Tell _frozen_importlib to consider bytecode first (#248 )

Support optimize flag
Get Python compiler working
2026-11-08 01:58:20 -10:00 · 2021-08-17 22:07:27 -07:00 · 2021-08-17 14:07:59 -07:00 · 2021-08-17 12:14:47 -07:00 · 2021-08-17 12:11:29 -07:00 · 2021-08-17 10:20:55 -07:00
15757 changed files with 300432 additions and 1495007 deletions
@@ -8,7 +8,6 @@ AlwaysBreakBeforeMultilineStrings: false
 AllowShortFunctionsOnASingleLine: false
 KeepEmptyLinesAtTheStartOfBlocks: true
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
-IncludeBlocks: Merge
 ---
 Language: Cpp
 AllowShortFunctionsOnASingleLine: false
@@ -1,31 +0,0 @@
-name: build
-
-on:
-  push:
-    branches:
-      - "master"
-      - "flake"
-  pull_request:
-    branches:
-      - "master"
-
-  # run workflow manually from the Actions tab
-  workflow_dispatch:
-
-jobs:
-  matrix_on_mode:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        mode: ["", tiny, opt, rel]
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: support ape bins 1
-        run: sudo cp 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 }}
@@ -1,7 +1,6 @@
 # -*- conf -*-

 /o
-/.prompt.jtlp

 # TODO: Find some way to have Python write to o/
 __pycache__
@@ -12,5 +11,4 @@ __pycache__
 /TAGS
 /bx_enh_dbg.ini
 /tool/emacs/*.elc
-/perf.data
-/perf.data.old
+/usr/share/dict/words
@@ -0,0 +1,6 @@
+virt: lxd
+os: linux
+language: c
+script: make -j4 V=0
+notifications:
+  email: false
@@ -15,7 +15,7 @@
 				"alignas(x)",
 				"alignof(x)",
 				"artificial=",
-				"dontdiscard=",
+				"nodiscard=",
 				"mayalias=",
 				"forceinline=",
 				"forcealign(x)=",
@@ -43,12 +43,12 @@
 				"forcealignargpointer=",
 				"noasan=",
 				"noubsan=",
+				"testonly=",
 				"donothing=",
 				"nosideeffect=",
-				"unreachable=",,
-				"notpossible=",
+				"unreachable=",
 				"thatispacked=",
-				"dontthrow=",
+				"nothrow=",
 				"nocallback=",
 				"relegated=",
 				"hidden=",
@@ -37,7 +37,7 @@
 #
 #   # basic debugging
 #   make -j8 -O MODE=dbg o/dbg/examples/crashreport.com
-#   o/examples/crashreport.com
+#   o/dbg/examples/crashreport.com
 #   less examples/crashreport.c
 #
 #   # extremely tiny binaries
@@ -59,26 +59,18 @@
 #
 #   build/config.mk

-SHELL      = build/bootstrap/cocmd.com
-HOSTS     ?= freebsd openbsd netbsd rhel7 rhel5 xnu win10
-MAKEFLAGS += --no-builtin-rules
+SHELL         = /bin/sh
+HOSTS        ?= freebsd openbsd netbsd rhel7 rhel5 xnu win7 win10
+SANITY       := $(shell build/sanitycheck $$PPID)
+GNUMAKEFLAGS += --output-sync

 .SUFFIXES:
 .DELETE_ON_ERROR:
 .FEATURES: output-sync
 .PHONY: all o bins check test depend tags

-ifneq ($(m),)
-ifeq ($(MODE),)
-MODE := $(m)
-endif
-endif
-
 all:	o
-o:	o/$(MODE)
-
-o/$(MODE):			\
-	o/$(MODE)/ape		\
+o:	o/$(MODE)/ape		\
 	o/$(MODE)/dsp		\
 	o/$(MODE)/net		\
 	o/$(MODE)/libc		\
@@ -87,22 +79,6 @@ o/$(MODE):			\
 	o/$(MODE)/examples	\
 	o/$(MODE)/third_party

-.STRICT = 1
-.PLEDGE = stdio rpath wpath cpath fattr proc
-.UNVEIL =			\
-	libc/integral		\
-	libc/disclaimer.inc	\
-	rwc:/dev/shm		\
-	rx:build/bootstrap	\
-	rx:o/third_party/gcc	\
-	/proc/stat		\
-	rw:/dev/null		\
-	w:o/stack.log		\
-	/etc/hosts		\
-	~/.runit.psk		\
-	/proc/self/status	\
-	/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
-
 PKGS =

 -include ~/.cosmo.mk
@@ -119,43 +95,36 @@ include libc/intrin/intrin.mk			# │  You can use the stack
 include libc/linux/linux.mk			# │  You can manipulate arrays
 include libc/tinymath/tinymath.mk		# │  You can issue raw system calls
 include third_party/compiler_rt/compiler_rt.mk	# │
+include libc/bits/bits.mk			# │
 include libc/str/str.mk				# │
 include third_party/xed/xed.mk			# │
-include third_party/puff/puff.mk		# │
 include third_party/zlib/zlib.mk		# │
-include third_party/double-conversion/dc.mk	# │
 include libc/elf/elf.mk				# │
 include ape/ape.mk				# │
-include libc/fmt/fmt.mk				# │
-include libc/vga/vga.mk				#─┘
+include libc/fmt/fmt.mk				#─┘
 include libc/calls/calls.mk			#─┐
-include third_party/getopt/getopt.mk		# │
 include libc/runtime/runtime.mk			# ├──SYSTEMS RUNTIME
 include libc/crt/crt.mk				# │  You can issue system calls
-include third_party/nsync/nsync.mk		# │
+include libc/rand/rand.mk			# │
+include libc/unicode/unicode.mk			# │
 include third_party/dlmalloc/dlmalloc.mk	#─┘
 include libc/mem/mem.mk				#─┐
-include third_party/gdtoa/gdtoa.mk		# ├──DYNAMIC RUNTIME
-include third_party/nsync/mem/mem.mk		# │  You can now use stdio
-include libc/thread/thread.mk			# │  You can finally call malloc()
-include libc/zipos/zipos.mk			# │
+include libc/ohmyplus/ohmyplus.mk		# ├──DYNAMIC RUNTIME
+include libc/zipos/zipos.mk			# │  You can now use stdio
+include third_party/gdtoa/gdtoa.mk		# │  You can finally call malloc()
 include libc/time/time.mk			# │
+include libc/alg/alg.mk				# │
 include libc/stdio/stdio.mk			# │
-include third_party/libcxx/libcxx.mk		# │
 include net/net.mk				# │
-include third_party/vqsort/vqsort.mk		# │
 include libc/log/log.mk				# │
-include third_party/ggml/ggml.mk		# │
-include third_party/bzip2/bzip2.mk		# │
 include dsp/core/core.mk			# │
 include libc/x/x.mk				# │
 include third_party/stb/stb.mk			# │
 include dsp/scale/scale.mk			# │
 include dsp/mpeg/mpeg.mk			# │
 include dsp/dsp.mk				# │
-include third_party/zlib/gz/gz.mk		# │
 include third_party/musl/musl.mk		# │
-include third_party/intel/intel.mk		# │
+include third_party/getopt/getopt.mk		# │
 include libc/libc.mk				#─┘
 include libc/sock/sock.mk			#─┐
 include dsp/tty/tty.mk				# ├──ONLINE RUNTIME
@@ -164,79 +133,52 @@ include net/http/http.mk			# │
 include third_party/mbedtls/mbedtls.mk		# │
 include net/https/https.mk			# │
 include third_party/regex/regex.mk		#─┘
-include third_party/tidy/tidy.mk
 include third_party/third_party.mk
-include third_party/nsync/testing/testing.mk
 include libc/testlib/testlib.mk
 include tool/viz/lib/vizlib.mk
-include tool/args/args.mk
-include test/tool/args/test.mk
 include third_party/linenoise/linenoise.mk
-include third_party/maxmind/maxmind.mk
-include net/finger/finger.mk
-include third_party/double-conversion/test/test.mk
 include third_party/lua/lua.mk
-include third_party/tr/tr.mk
-include third_party/sed/sed.mk
-include third_party/awk/awk.mk
-include third_party/hiredis/hiredis.mk
-include third_party/make/make.mk
-include third_party/ctags/ctags.mk
-include third_party/finger/finger.mk
-include third_party/argon2/argon2.mk
-include third_party/smallz4/smallz4.mk
 include third_party/sqlite3/sqlite3.mk
 include third_party/mbedtls/test/test.mk
 include third_party/quickjs/quickjs.mk
 include third_party/lz4cli/lz4cli.mk
-include third_party/zip/zip.mk
-include third_party/unzip/unzip.mk
+include third_party/infozip/infozip.mk
+include third_party/python/python.mk
 include tool/build/lib/buildlib.mk
 include third_party/chibicc/chibicc.mk
 include third_party/chibicc/test/test.mk
-include third_party/python/python.mk
 include tool/build/emucrt/emucrt.mk
 include tool/build/emubin/emubin.mk
 include tool/build/build.mk
-include tool/curl/curl.mk
 include examples/examples.mk
-include examples/pyapp/pyapp.mk
-include examples/pylife/pylife.mk
 include tool/decode/lib/decodelib.mk
 include tool/decode/decode.mk
-include tool/lambda/lib/lib.mk
-include tool/lambda/lambda.mk
-include tool/plinko/lib/lib.mk
-include tool/plinko/plinko.mk
-include test/tool/plinko/test.mk
 include tool/hash/hash.mk
 include tool/net/net.mk
 include tool/viz/viz.mk
 include tool/tool.mk
-include net/turfwar/turfwar.mk
+include test/libc/alg/test.mk
 include test/libc/tinymath/test.mk
 include test/libc/intrin/test.mk
 include test/libc/mem/test.mk
 include test/libc/nexgen32e/test.mk
 include test/libc/runtime/test.mk
-include test/libc/thread/test.mk
 include test/libc/sock/test.mk
+include test/libc/bits/test.mk
 include test/libc/str/test.mk
-include test/libc/log/test.mk
-include test/libc/str/test.mk
+include test/libc/unicode/test.mk
 include test/libc/calls/test.mk
 include test/libc/x/test.mk
 include test/libc/xed/test.mk
 include test/libc/fmt/test.mk
 include test/libc/dns/test.mk
+include test/libc/rand/test.mk
 include test/libc/time/test.mk
 include test/libc/stdio/test.mk
-include test/libc/zipos/test.mk
 include test/libc/release/test.mk
 include test/libc/test.mk
 include test/net/http/test.mk
 include test/net/https/test.mk
-include test/net/finger/test.mk
 include test/net/test.mk
 include test/tool/build/lib/test.mk
 include test/tool/build/test.mk
@@ -263,144 +205,136 @@ CHECKS	 = $(foreach x,$(PKGS),$($(x)_CHECKS))

 bins:	$(BINS)
 check:	$(CHECKS)
-test:	$(TESTS)
+test:	$(TESTS) all
 depend:	o/$(MODE)/depend
 tags:	TAGS HTAGS

 o/$(MODE)/.x:
-	@$(COMPILE) -AMKDIR -tT$@ $(MKDIR) $(@D)
+	@mkdir -p $(@D) && touch $@

+ifneq ($(findstring 4.,,$(MAKE_VERSION)),$(MAKE_VERSION))
 o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
-	$(file >$@,$(SRCS))
-o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
-	$(file >$@,$(HDRS) $(INCS))
-o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
-	$(file >$@,$(INCS))
-o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
-	@$(COMPILE) -AMKDEPS -L320 $(MKDEPS) -o $@ -r o/$(MODE)/ @o/$(MODE)/srcs.txt @o/$(MODE)/hdrs.txt @o/$(MODE)/incs.txt
-
-o/$(MODE)/srcs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(SRCS),$(file >>$@,$(x)))
-o/$(MODE)/hdrs-old.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
 	$(file >$@) $(foreach x,$(HDRS) $(INCS),$(file >>$@,$(x)))
+o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
+	$(file >$@) $(foreach x,$(INCS) $(INCS),$(file >>$@,$(x)))
+else
+o/$(MODE)/srcs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(SRCS),$(dir $(x))))
+	$(MAKE) MODE=rel -j8 -pn bopit 2>/dev/null | sed -ne '/^SRCS/ {s/.*:= //;s/  */\n/g;p;q}' >$@
+o/$(MODE)/hdrs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x))))
+	$(MAKE) MODE=rel -j8 -pn bopit 2>/dev/null | sed -ne '/^HDRS/ {s/.*:= //;s/  */\n/g;p;q}' >$@
+o/$(MODE)/incs.txt: o/$(MODE)/.x $(MAKEFILES) $(call uniq,$(foreach x,$(INCS) $(INCS),$(dir $(x))))
+	$(MAKE) MODE=rel -j8 -pn bopit 2>/dev/null | sed -ne '/^INCS/ {s/.*:= //;s/  */\n/g;p;q}' >$@
+endif

-TAGS: private .UNSANDBOXED = 1
-TAGS:	o/$(MODE)/srcs-old.txt $(SRCS) o/$(MODE)/third_party/ctags/ctags.com
-	@$(RM) $@
-	@o/$(MODE)/third_party/ctags/ctags.com $(TAGSFLAGS) -L $< -o $@
+o/$(MODE)/depend: o/$(MODE)/.x o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt $(SRCS) $(HDRS) $(INCS)
+	@$(COMPILE) -AMKDEPS $(MKDEPS) -o $@ -r o/$(MODE)/ o/$(MODE)/srcs.txt o/$(MODE)/hdrs.txt o/$(MODE)/incs.txt

-HTAGS: private .UNSANDBOXED = 1
-HTAGS:	o/$(MODE)/hdrs-old.txt $(HDRS) o/$(MODE)/third_party/ctags/ctags.com
-	@$(RM) $@
-	@build/htags o/$(MODE)/third_party/ctags/ctags.com -L $< -o $@
+TAGS:	o/$(MODE)/srcs.txt $(SRCS)
+	@rm -f $@
+	@$(COMPILE) -ATAGS -T$@ $(TAGS) $(TAGSFLAGS) -L $< -o $@
+
+HTAGS:	o/$(MODE)/hdrs.txt $(HDRS)
+	@rm -f $@
+	@$(COMPILE) -ATAGS -T$@ build/htags -L $< -o $@

-loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy.com
 	find -name \*.h -or -name \*.c -or -name \*.S | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<

-# PLEASE: MAINTAIN TOPOLOGICAL ORDER
-# FROM HIGHEST LEVEL TO LOWEST LEVEL
-COSMOPOLITAN_OBJECTS =			\
-	NET_HTTP			\
-	LIBC_DNS			\
-	LIBC_SOCK			\
-	LIBC_NT_WS2_32			\
-	LIBC_NT_IPHLPAPI		\
-	LIBC_NT_MSWSOCK			\
-	LIBC_X				\
-	THIRD_PARTY_GETOPT		\
-	LIBC_LOG			\
-	LIBC_TIME			\
-	LIBC_ZIPOS			\
-	THIRD_PARTY_MUSL		\
-	LIBC_STDIO			\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_REGEX		\
-	LIBC_THREAD			\
-	THIRD_PARTY_NSYNC_MEM		\
-	LIBC_MEM			\
-	THIRD_PARTY_DLMALLOC		\
-	LIBC_RUNTIME			\
-	THIRD_PARTY_NSYNC		\
-	LIBC_ELF			\
-	LIBC_CALLS			\
-	LIBC_SYSV_CALLS			\
-	LIBC_VGA			\
-	LIBC_NT_PSAPI			\
-	LIBC_NT_POWRPROF		\
-	LIBC_NT_PDH			\
-	LIBC_NT_GDI32			\
-	LIBC_NT_COMDLG32		\
-	LIBC_NT_URL			\
-	LIBC_NT_USER32			\
-	LIBC_NT_NTDLL			\
-	LIBC_NT_ADVAPI32		\
-	LIBC_NT_SYNCHRONIZATION		\
-	LIBC_FMT			\
-	THIRD_PARTY_PUFF		\
-	THIRD_PARTY_COMPILER_RT		\
-	LIBC_TINYMATH			\
-	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_INTRIN			\
-	LIBC_NT_KERNEL32		\
+COSMOPOLITAN_OBJECTS =		\
+	LIBC_DNS		\
+	LIBC_SOCK		\
+	LIBC_NT_WS2_32		\
+	LIBC_NT_IPHLPAPI	\
+	LIBC_NT_MSWSOCK		\
+	LIBC_OHMYPLUS		\
+	LIBC_X			\
+	THIRD_PARTY_GETOPT	\
+	LIBC_LOG		\
+	LIBC_UNICODE		\
+	LIBC_TIME		\
+	LIBC_ZIPOS		\
+	THIRD_PARTY_ZLIB	\
+	THIRD_PARTY_MUSL	\
+	LIBC_STDIO		\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_REGEX	\
+	LIBC_ALG		\
+	LIBC_MEM		\
+	THIRD_PARTY_DLMALLOC	\
+	LIBC_BITS		\
+	LIBC_RUNTIME		\
+	LIBC_ELF		\
+	LIBC_CALLS		\
+	LIBC_RAND		\
+	LIBC_SYSV_CALLS		\
+	LIBC_NT_KERNELBASE	\
+	LIBC_NT_SHELL32		\
+	LIBC_NT_GDI32		\
+	LIBC_NT_COMDLG32	\
+	LIBC_NT_NETAPI32	\
+	LIBC_NT_URL		\
+	LIBC_NT_USER32		\
+	LIBC_NT_NTDLL		\
+	LIBC_NT_ADVAPI32	\
+	LIBC_FMT		\
+	THIRD_PARTY_COMPILER_RT	\
+	LIBC_TINYMATH		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_INTRIN		\
+	LIBC_NT_KERNEL32	\
 	LIBC_NEXGEN32E

-COSMOPOLITAN_HEADERS =			\
-	APE				\
-	LIBC				\
-	LIBC_CALLS			\
-	LIBC_DNS			\
-	LIBC_ELF			\
-	LIBC_FMT			\
-	LIBC_INTRIN			\
-	LIBC_LOG			\
-	LIBC_MEM			\
-	LIBC_NEXGEN32E			\
-	LIBC_NT				\
-	LIBC_RUNTIME			\
-	LIBC_SOCK			\
-	LIBC_STDIO			\
-	THIRD_PARTY_NSYNC		\
-	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_THREAD			\
-	LIBC_TIME			\
-	LIBC_TINYMATH			\
-	LIBC_X				\
-	LIBC_ZIPOS			\
-	LIBC_VGA			\
-	NET_HTTP			\
-	THIRD_PARTY_DLMALLOC		\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_GETOPT		\
-	THIRD_PARTY_MUSL		\
+COSMOPOLITAN_HEADERS =		\
+	LIBC			\
+	LIBC_ALG		\
+	LIBC_BITS		\
+	LIBC_CALLS		\
+	LIBC_DNS		\
+	LIBC_ELF		\
+	LIBC_FMT		\
+	LIBC_INTRIN		\
+	LIBC_LOG		\
+	LIBC_MEM		\
+	LIBC_NEXGEN32E		\
+	LIBC_NT			\
+	LIBC_OHMYPLUS		\
+	LIBC_RAND		\
+	LIBC_RUNTIME		\
+	LIBC_SOCK		\
+	LIBC_STDIO		\
+	LIBC_STR		\
+	LIBC_SYSV		\
+	LIBC_TIME		\
+	LIBC_TINYMATH		\
+	LIBC_UNICODE		\
+	LIBC_X			\
+	LIBC_ZIPOS		\
+	THIRD_PARTY_DLMALLOC	\
+	THIRD_PARTY_GDTOA	\
+	THIRD_PARTY_GETOPT	\
+	THIRD_PARTY_MUSL	\
+	THIRD_PARTY_ZLIB	\
 	THIRD_PARTY_REGEX

-o/$(MODE)/cosmopolitan.a:		\
-		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
+o/$(MODE)/cosmopolitan.a.txt:
+	printf "%s\n" $(call reverse,$(call uniq,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)))))
+o/$(MODE)/cosmopolitan.a: $(filter-out o/libc/stubs/exit11.o,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS)))
+o/cosmopolitan.h:				\
+		o/$(MODE)/tool/build/rollup.com	\
+		libc/integral/normalize.inc	\
+		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))
+	@$(COMPILE) -AROLLUP -T$@ $^ >$@

-o/cosmopolitan.h:							\
-		o/$(MODE)/tool/build/rollup.com				\
-		libc/integral/normalize.inc				\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS))	\
-		$(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_INCS))
-	$(file >$(TMPDIR)/$(subst /,_,$@),libc/integral/normalize.inc $(foreach x,$(COSMOPOLITAN_HEADERS),$($(x)_HDRS)))
-	@$(COMPILE) -AROLLUP -T$@ o/$(MODE)/tool/build/rollup.com @$(TMPDIR)/$(subst /,_,$@) >$@
-
-o/cosmopolitan.html: private .UNSANDBOXED = 1
 o/cosmopolitan.html:							\
 		o/$(MODE)/third_party/chibicc/chibicc.com.dbg		\
-		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))	\
-		$(SRCS)							\
-		$(HDRS)
-	$(file >$(TMPDIR)/$(subst /,_,$@),$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS))))
+		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))
 	o/$(MODE)/third_party/chibicc/chibicc.com.dbg -J		\
 		-fno-common -include libc/integral/normalize.inc -o $@	\
-		@$(TMPDIR)/$(subst /,_,$@)
+		$(filter-out %.s,$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_SRCS)))

 $(SRCS):					\
 	libc/integral/normalize.inc		\
@@ -410,16 +344,6 @@ $(SRCS):					\
 	libc/integral/lp64arg.inc		\
 	libc/integral/lp64.inc

-.PHONY: toolchain
-toolchain:	o/cosmopolitan.h				\
-		o/$(MODE)/ape/public/ape.lds			\
-		o/$(MODE)/libc/crt/crt.o			\
-		o/$(MODE)/ape/ape.o				\
-		o/$(MODE)/ape/ape-copy-self.o			\
-		o/$(MODE)/ape/ape-no-modify-self.o		\
-		o/$(MODE)/cosmopolitan.a			\
-		o/$(MODE)/third_party/libcxx/libcxx.a
-
 # UNSPECIFIED PREREQUISITES TUTORIAL
 #
 # A build rule must exist for all files that make needs to consider in
@@ -444,9 +368,9 @@ $(SRCS):
 $(HDRS):
 $(INCS):
 .DEFAULT:
-	@$(ECHO)
-	@$(ECHO) NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@
-	@$(ECHO)
-	$(RM) o/$(MODE)/depend
+	@echo >&2
+	@echo NOTE: deleting o/$(MODE)/depend because of an unspecified prerequisite: $@ >&2
+	@echo >&2
+	rm -f o/$(MODE)/depend

 -include o/$(MODE)/depend
@@ -1,6 +1,5 @@
 ![Cosmopolitan Honeybadger](usr/share/img/honeybadger.png)

-[![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
@@ -23,94 +22,27 @@ If you're doing your development work on Linux or BSD then you need just
 five files to get started. Here's what you do on Linux:

 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-2.2.zip
-unzip cosmopolitan-amalgamation-2.2.zip
+wget https://justine.lol/cosmopolitan/cosmopolitan-amalgamation-1.0.zip
+unzip cosmopolitan-amalgamation-1.0.zip
 printf 'main() { printf("hello world\\n"); }\n' >hello.c
 gcc -g -Os -static -nostdlib -nostdinc -fno-pie -no-pie -mno-red-zone \
-  -fno-omit-frame-pointer -pg -mnop-mcount -mno-tls-direct-seg-refs -gdwarf-4 \
-  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds -Wl,--gc-sections \
-  -include cosmopolitan.h crt.o ape-no-modify-self.o cosmopolitan.a
+  -fno-omit-frame-pointer -pg -mnop-mcount \
+  -o hello.com.dbg hello.c -fuse-ld=bfd -Wl,-T,ape.lds \
+  -include cosmopolitan.h crt.o ape.o cosmopolitan.a
 objcopy -S -O binary hello.com.dbg hello.com
 ```

-You now have a portable program.
+You now have a portable program. Please note that your APE binary will
+assimilate itself as a conventional resident of your platform after the
+first run, so it can be fast and efficient for subsequent executions.

 ```sh
 ./hello.com
-bash -c './hello.com'  # zsh/fish workaround (we patched them in 2021)
+bash -c './hello.com'  # zsh/fish workaround (we upstreamed patches)
 ```

-If `./hello.com` executed on Linux throws an error about not finding an
-interpreter, it should be fixed by running the following command (although
-note that it may not survive a system restart):
-
-```sh
-sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"
-```
-
-If the same command produces puzzling errors on WSL or WINE when using
-Redbean 2.x, they may be fixed by disabling binfmt_misc:
-
-```sh
-sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status'
-```
-
-Since we used the `ape-no-modify-self.o` bootloader (rather than
-`ape.o`) your executable will not modify itself when it's run. What
-it'll instead do, is extract a 4kb program (the [APE loader](https://justine.lol/apeloader/))
-to `${TMPDIR:-${HOME:-.}}` that maps your program into memory without
-needing to copy it. The APE loader must be in an executable location
-(e.g. not stored on a `noexec` mount) for it to run. See below for
-alternatives:
-
-It's possible to install the APE loader systemwide as follows.
-
-```sh
-# System-Wide APE Install
-# for Linux, Darwin, and BSDs
-# 1. Copies APE Loader to /usr/bin/ape
-# 2. Registers w/ binfmt_misc too if Linux
-ape/apeinstall.sh
-
-# System-Wide APE Uninstall
-# for Linux, Darwin, and BSDs
-ape/apeuninstall.sh
-```
-
-It's also possible to convert APE binaries into the system-local format
-by using the `--assimilate` flag. Please note that if binfmt_misc is in
-play, you'll need to unregister it temporarily before doing this, since
-the assimilate feature is part of the shell script header.
-
-```sh
-$ file hello.com
-hello.com: DOS/MBR boot sector
-./hello.com --assimilate
-$ file hello.com
-hello.com: ELF 64-bit LSB executable
-```
-
-Now that you're up and running with Cosmopolitan Libc and APE, here's
-some of the most important troubleshooting tools APE offers that you
-should know, in case you encounter any issues:
-
-```sh
-./hello.com --strace   # log system calls to stderr
-./hello.com --ftrace   # log function calls to stderr
-```
-
-Do you love tiny binaries? If so, you may not be happy with Cosmo adding
-heavyweight features like tracing to your binaries by default. In that
-case, you may want to consider using our build system:
-
-```sh
-make m=tiny
-```
-
-Which will cause programs such as `hello.com` and `life.com` to shrink
-from 60kb in size to about 16kb. There's also a prebuilt amalgamation
-online <https://justine.lol/cosmopolitan/cosmopolitan-tiny.zip> hosted
-on our download page <https://justine.lol/cosmopolitan/download.html>.
+So if you intend to copy the binary to Windows or Mac then please do
+that before you run it, not after.

 ### MacOS

@@ -132,149 +64,32 @@ Windows](https://justine.lol/cosmopolitan/windows-compiling.html)
 tutorial. It's needed because the ELF object format is what makes
 universal binaries possible.

-Cosmopolitan officially only builds on Linux. However, one highly
-experimental (and currently broken) thing you could try, is building the
-entire cosmo repository from source using the cross9 toolchain.
-
-```
-mkdir -p o/third_party
-rm -rf o/third_party/gcc
-wget https://justine.lol/linux-compiler-on-windows/cross9.zip
-unzip cross9.zip
-mv cross9 o/third_party/gcc
-build/bootstrap/make.com
-```
-
 ## Source Builds

-Cosmopolitan can be compiled from source on any Linux distro. First, you
-need to download or clone the repository.
+Cosmopolitan can be compiled from source on any Linux distro. GNU make
+needs to be installed beforehand. This is a freestanding hermetic
+repository that bootstraps using a vendored static gcc9 executable.
+No further dependencies are required.

 ```sh
-wget https://justine.lol/cosmopolitan/cosmopolitan.tar.gz
-tar xf cosmopolitan.tar.gz  # see releases page
+wget https://justine.lol/cosmopolitan/cosmopolitan-1.0.tar.gz
+tar xf cosmopolitan-1.0.tar.gz  # see releases page
 cd cosmopolitan
-```
-
-This will build the entire repository and run all the tests:
-
-```sh
-build/bootstrap/make.com
+make -j16
 o//examples/hello.com
 find o -name \*.com | xargs ls -rShal | less
 ```

-If you get an error running make.com then it's probably because you have
-WINE installed to `binfmt_misc`. You can fix that by installing the the
-APE loader as an interpreter. It'll improve build performance too!
-
-```sh
-ape/apeinstall.sh
-```
-
-Since the Cosmopolitan repository is very large, you might only want to
-build a particular thing. Cosmopolitan's build config does a good job at
-having minimal deterministic builds. For example, if you wanted to build
-only hello.com then you could do that as follows:
-
-```sh
-build/bootstrap/make.com o//examples/hello.com
-```
-
-Sometimes it's desirable to build a subset of targets, without having to
-list out each individual one. You can do that by asking make to build a
-directory name. For example, if you wanted to build only the targets and
-subtargets of the chibicc package including its tests, you would say:
-
-```sh
-build/bootstrap/make.com o//third_party/chibicc
-o//third_party/chibicc/chibicc.com --help
-```
-
-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.com m=tiny
-```
-
-Here's some other build modes you can try:
-
-```sh
-build/bootstrap/make.com m=dbg       # asan + ubsan + debug
-build/bootstrap/make.com m=asan      # production memory safety
-build/bootstrap/make.com m=opt       # -march=native optimizations
-build/bootstrap/make.com m=rel       # traditional release binaries
-build/bootstrap/make.com m=optlinux  # optimal linux-only performance
-build/bootstrap/make.com m=fastbuild # build 28% faster w/o debugging
-build/bootstrap/make.com m=tinylinux # tiniest linux-only 4kb binaries
-```
-
-For further details, see [//build/config.mk](build/config.mk).
-
-## GDB
-
-Here's the recommended `~/.gdbinit` config:
-
-```gdb
-set host-charset UTF-8
-set target-charset UTF-8
-set target-wide-charset UTF-8
-set osabi none
-set complaints 0
-set confirm off
-set history save on
-set history filename ~/.gdb_history
-define asm
-  layout asm
-  layout reg
-end
-define src
-  layout src
-  layout reg
-end
-src
-```
-
-You normally run the `.com.dbg` file under gdb. If you need to debug the
-`.com` file itself, then you can load the debug symbols independently as
-
-```
-gdb foo.com -ex 'add-symbol-file foo.com.dbg 0x401000'
-```
-
-## Discord Chatroom
-
-The Cosmopolitan development team collaborates on the Redbean Discord
-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  |
-| Mac OS X        | 15.6        | 2018  |
+| New Technology  | Vista       | 2006  |
+| GNU/Systemd     | 2.6.18      | 2007  |
+| XNU's Not UNIX! | 15.6        | 2018  |
+| FreeBSD         | 12          | 2018  |
 | OpenBSD         | 6.4         | 2018  |
-| 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
-    Vista and Windows 7.
-
-## Special Thanks
-
-Funding for this project is crowdsourced using
-[GitHub Sponsors](https://github.com/sponsors/jart) and
-[Patreon](https://www.patreon.com/jart). Your support is what makes this
-project possible. Thank you! We'd also like to give special thanks to
-the following groups and individuals:
-
- [Joe Drumgoole](https://github.com/jdrumgoole)
- [Rob Figueiredo](https://github.com/robfig)
- [Wasmer](https://wasmer.io/)
-
-For publicly sponsoring our work at the highest tier.
+| NetBSD          | 9.1         | 2020  |
+| GNU Make        | 3.80        | 2010  |
@@ -177,21 +177,16 @@
 #include "ape/macros.internal.h"
 #include "ape/relocations.h"
 #include "libc/dce.h"
-#include "libc/elf/def.h"
-#include "libc/elf/pf2prot.internal.h"
 #include "libc/nt/pedef.internal.h"
-#include "libc/thread/tls.h"
 #include "libc/zip.h"

 ENTRY(_start)

 PHDRS {
-  Head PT_LOAD FLAGS(PF_X|PF_R);
-  Rom PT_LOAD FLAGS(PF_X|PF_R);
-  Ram PT_LOAD FLAGS(PF_W|PF_R);
-  Tls PT_TLS FLAGS(PF_W|PF_R);
-  Bss PT_LOAD FLAGS(PF_W|PF_R);
-  stack PT_GNU_STACK FLAGS(PF_W|PF_R);
+  Head PT_LOAD FLAGS(5);
+  Rom PT_LOAD FLAGS(5);
+  Ram PT_LOAD FLAGS(6);
+  stack PT_GNU_STACK FLAGS(6);
 }

 SECTIONS {
@@ -216,8 +211,6 @@ SECTIONS {
    KEEP(*(.elf.phdrs))
    HIDDEN(ape_phdrs_end = .);

-    KEEP(*(.emush))
-
    /* OpenBSD */
    . = ALIGN(__SIZEOF_POINTER__);
    HIDDEN(ape_note = .);
@@ -244,17 +237,14 @@ SECTIONS {
 /*BEGIN: nt addressability guarantee */

  .text . : {
-    BYTE(0x90) /* TODO: fix blinkenlights symbol __map_phdrs */
    /* Code that needs to be addressable in Real Mode */
    *(.text.real)
    KEEP(*(SORT_BY_NAME(.sort.text.real.*)))
-    /* Code we want earlier in the binary w/o modifications */
-    KEEP(*(.ape.loader))
    HIDDEN(_ereal = .);
-/*END: realmode addressability guarantee */
-/*BEGIN: morphable code */
    . += 1;

+/*END: realmode addressability guarantee */
+
    /* Normal Code */
    *(.start)
    KEEP(*(.initprologue))
@@ -275,7 +265,6 @@ SECTIONS {
    KEEP(*(.textwindowsprologue))
    *(.text.windows)
    KEEP(*(.textwindowsepilogue))
-    KEEP(*(.blink))
    *(SORT_BY_ALIGNMENT(.text.modernity))
    *(SORT_BY_ALIGNMENT(.text.modernity.*))
    *(SORT_BY_ALIGNMENT(.text.hot))
@@ -283,7 +272,6 @@ SECTIONS {
    KEEP(*(.keep.text))
    *(.text .stub .text.*)
    KEEP(*(SORT_BY_NAME(.sort.text.*)))
-    *(.subrs)

    KEEP(*(.ape.pad.test));
    *(.test.unlikely)
@@ -292,7 +280,6 @@ SECTIONS {
    /* Privileged code invulnerable to magic */
    KEEP(*(.ape.pad.privileged));
    . += . > 0 ? 1 : 0;
-/*END: morphable code */
    HIDDEN(__privileged_start = .);
    . += . > 0 ? 1 : 0;
    *(.privileged)
@@ -302,9 +289,6 @@ SECTIONS {
 /*BEGIN: Read Only Data */

    KEEP(*(.ape.pad.rodata));
-    KEEP(*(.rodata.pytab.0));
-    KEEP(*(.rodata.pytab.1));
-    KEEP(*(.rodata.pytab.2));

    *(.rodata .rodata.*)
    *(.ubsan.types)
@@ -352,34 +336,11 @@ SECTIONS {
    HIDDEN(_etext = .);
    PROVIDE_HIDDEN(etext = .);
 /*END: Read Only Data (only needed for initialization) */
+/*END: Read Only Data */
  } :Rom

-/* initialization image for thread-local storage, this is copied */
-/* out to actual TLS areas at runtime, so just make it read-only */
-  .tdata . : {
-    _tdata_start = .;
-    *(SORT_BY_ALIGNMENT(.tdata))
-    *(SORT_BY_ALIGNMENT(.tdata.*))
-    _tdata_end = .;
-    . = ALIGN(PAGESIZE);
-  } :Tls :Rom
-/*END: Read Only Data */
-
-/* this only tells the linker about the layout of uninitialized */
-/* TLS data, and does not advance the linker's location counter */
-  .tbss . : {
-    _tbss_start = .;
-    *(SORT_BY_ALIGNMENT(.tbss))
-    *(SORT_BY_ALIGNMENT(.tbss.*))
-    . = ALIGN(TLS_ALIGNMENT);
-    /* the %fs register is based on this location */
-    _tbss_end = .;
-  } :Tls
-
-  .data ALIGN(PAGESIZE) : {
+  .data . : {
 /*BEGIN: Read/Write Data */
-    KEEP(*(SORT_BY_NAME(.piro.data.sort.iat.*)))
-/*BEGIN: NT FORK COPYING */
    KEEP(*(.dataprologue))
    *(.data .data.*)
    KEEP(*(SORT_BY_NAME(.sort.data.*)))
@@ -400,22 +361,23 @@ SECTIONS {
    . = ALIGN(__SIZEOF_POINTER__);
    KEEP(*(SORT_BY_NAME(.piro.data.sort.*)))
    KEEP(*(.piro.pad.data))
-    KEEP(*(.dataepilogue))
-/*END: NT FORK COPYING */
+    . = ALIGN(PAGESIZE);
    HIDDEN(_edata = .);
    PROVIDE_HIDDEN(edata = .);
-    KEEP(*(SORT_BY_NAME(.zip.*)))
-    HIDDEN(_ezip = .);
-    . = ALIGN(PAGESIZE);
  } :Ram

 /*END:   file content that's loaded by o/s */
+/*BEGIN: bss memory void */
+
+  .zip . : {
+    KEEP(*(SORT_BY_NAME(.zip.*)))
+    HIDDEN(_ezip = .);
+  }
+
 /*END:   file content */
 /*BEGIN: bss memory that's addressable */

  .bss ALIGN(64) : {
-/*BEGIN: NT FORK COPYING */
-    KEEP(*(.bssprologue))
    KEEP(*(SORT_BY_NAME(.piro.bss.init.*)))
    *(.piro.bss)
    KEEP(*(SORT_BY_NAME(.piro.bss.sort.*)))
@@ -430,12 +392,10 @@ SECTIONS {

    KEEP(*(SORT_BY_NAME(.sort.bss.*)))

-    KEEP(*(.bssepilogue))
-/*END: NT FORK COPYING */
-    . = ALIGN(PAGESIZE);
+    . = ALIGN(FRAMESIZE); /* for brk()/sbrk() allocation */
    HIDDEN(_end = .);
    PROVIDE_HIDDEN(end = .);
-  } :Bss
+  }

 /*END: nt addressability guarantee */
 /*END: bsd addressability guarantee */
@@ -463,7 +423,6 @@ SECTIONS {
  .debug_line        0 : { *(.debug_line .debug_line.* .debug_line_end ) }
  .debug_frame       0 : { *(.debug_frame) }
  .debug_str         0 : { *(.debug_str) }
-  .debug_line_str    0 : { *(.debug_line_str) }
  .debug_loc         0 : { *(.debug_loc) }
  .debug_macinfo     0 : { *(.debug_macinfo) }
  .debug_weaknames   0 : { *(.debug_weaknames) }
@@ -472,7 +431,6 @@ SECTIONS {
  .debug_varnames    0 : { *(.debug_varnames) }
  .debug_pubtypes    0 : { *(.debug_pubtypes) }
  .debug_ranges      0 : { *(.debug_ranges) }
-  .debug_rnglists    0 : { *(.debug_rnglists) }
  .debug_macro       0 : { *(.debug_macro) }
  .debug_addr        0 : { *(.debug_addr) }
  .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
@@ -493,15 +451,9 @@ PFSTUB4(ape_elf_phnum, (ape_phdrs_end - ape_phdrs) / 56);
 PFSTUB4(ape_elf_shnum, 0);
 PFSTUB4(ape_elf_shstrndx, 0);

-HIDDEN(_tls_size = _tbss_end - _tdata_start);
-HIDDEN(_tdata_size = _tdata_end - _tdata_start);
-HIDDEN(_tbss_size = _tbss_end - _tbss_start);
-HIDDEN(_tbss_offset = _tbss_start - _tdata_start);
-HIDDEN(_tls_content = (_tdata_end - _tdata_start) + (_tbss_end - _tbss_start));
-
-HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE));
+HIDDEN(__privileged_addr = ROUNDDOWN(__privileged_start, PAGESIZE)); 
 HIDDEN(__privileged_size = (ROUNDUP(__privileged_end, PAGESIZE) -
-                            ROUNDDOWN(__privileged_start, PAGESIZE)));
+                            ROUNDDOWN(__privileged_start, PAGESIZE))); 

 HIDDEN(ape_rom_offset = 0);
 HIDDEN(ape_rom_vaddr = ADDR(.head));
@@ -519,13 +471,11 @@ HIDDEN(ape_ram_memsz = ADDR(.bss) + SIZEOF(.bss) - ape_ram_vaddr);
 HIDDEN(ape_ram_align = PAGESIZE);
 HIDDEN(ape_ram_rva = RVA(ape_ram_vaddr));

-HIDDEN(ape_stack_pf = DEFINED(ape_stack_pf) ? ape_stack_pf : PF_R | PF_W);
-HIDDEN(ape_stack_prot = _PF2PROT(ape_stack_pf));
 HIDDEN(ape_stack_offset = ape_ram_offset + ape_ram_filesz);
-HIDDEN(ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000);
+HIDDEN(ape_stack_vaddr = 0x700000000000 - STACKSIZE);
 HIDDEN(ape_stack_paddr = ape_ram_paddr + ape_ram_filesz);
 HIDDEN(ape_stack_filesz = 0);
-HIDDEN(ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : STACKSIZE);
+HIDDEN(ape_stack_memsz = STACKSIZE);
 HIDDEN(ape_stack_align = 16);

 HIDDEN(ape_note_offset = ape_rom_offset + (ape_note - ape_rom_vaddr));
@@ -538,8 +488,8 @@ HIDDEN(ape_note_align = __SIZEOF_POINTER__);
 HIDDEN(ape_text_offset = ape_rom_offset + LOADADDR(.text) - ape_rom_paddr);
 HIDDEN(ape_text_paddr = LOADADDR(.text));
 HIDDEN(ape_text_vaddr = ADDR(.text));
-HIDDEN(ape_text_filesz = SIZEOF(.text) + SIZEOF(.tdata));
-HIDDEN(ape_text_memsz = SIZEOF(.text) + SIZEOF(.tdata));
+HIDDEN(ape_text_filesz = SIZEOF(.text));
+HIDDEN(ape_text_memsz = SIZEOF(.text));
 HIDDEN(ape_text_align = PAGESIZE);
 HIDDEN(ape_text_rva = RVA(ape_text_vaddr));

@@ -558,68 +508,39 @@ HIDDEN(ape_bss_filesz = 0);
 HIDDEN(ape_bss_memsz = SIZEOF(.bss));
 HIDDEN(ape_bss_align = PAGESIZE);

-/* 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 */
-SHSTUB2(ape_loader_dd_skip, DEFINED(ape_loader) ? RVA(ape_loader) / 64 : 0);
-SHSTUB2(ape_loader_dd_count,
-        DEFINED(ape_loader_end)
-            ? ROUNDUP(ape_loader_end - ape_loader, PAGESIZE) / 64
-            : 0);
+#if SupportsXnu()
+SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
+SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
+#endif

-HIDDEN(blink_aarch64_b0 = RVA(blink_aarch64) % 10 + 48);
-HIDDEN(blink_aarch64_b1 = RVA(blink_aarch64) < 10 ? 32 : RVA(blink_aarch64) / 10 % 10 + 48);
-HIDDEN(blink_aarch64_b2 = RVA(blink_aarch64) < 100 ? 32 : RVA(blink_aarch64) / 100 % 10 + 48);
-HIDDEN(blink_aarch64_b3 = RVA(blink_aarch64) < 1000 ? 32 : RVA(blink_aarch64) / 1000 % 10 + 48);
-HIDDEN(blink_aarch64_b4 = RVA(blink_aarch64) < 10000 ? 32 : RVA(blink_aarch64) / 10000 % 10 + 48);
-HIDDEN(blink_aarch64_b5 = RVA(blink_aarch64) < 100000 ? 32 : RVA(blink_aarch64) / 100000 % 10 + 48);
-HIDDEN(blink_aarch64_b6 = RVA(blink_aarch64) < 1000000 ? 32 : RVA(blink_aarch64) / 1000000 % 10 + 48);
-HIDDEN(blink_aarch64_b7 = RVA(blink_aarch64) < 10000000 ? 32 : RVA(blink_aarch64) / 10000000 % 10 + 48);
-HIDDEN(blink_aarch64_b8 = RVA(blink_aarch64) < 100000000 ? 32 : RVA(blink_aarch64) / 100000000 % 10 + 48);
-HIDDEN(blink_aarch64_b9 = RVA(blink_aarch64) < 1000000000 ? 32 : RVA(blink_aarch64) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_aarch64_size_b0 = blink_aarch64_size % 10 + 48);
-HIDDEN(blink_aarch64_size_b1 = blink_aarch64_size < 10 ? 32 : blink_aarch64_size / 10 % 10 + 48);
-HIDDEN(blink_aarch64_size_b2 = blink_aarch64_size < 100 ? 32 : blink_aarch64_size / 100 % 10 + 48);
-HIDDEN(blink_aarch64_size_b3 = blink_aarch64_size < 1000 ? 32 : blink_aarch64_size / 1000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b4 = blink_aarch64_size < 10000 ? 32 : blink_aarch64_size / 10000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b5 = blink_aarch64_size < 100000 ? 32 : blink_aarch64_size / 100000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b6 = blink_aarch64_size < 1000000 ? 32 : blink_aarch64_size / 1000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b7 = blink_aarch64_size < 10000000 ? 32 : blink_aarch64_size / 10000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b8 = blink_aarch64_size < 100000000 ? 32 : blink_aarch64_size / 100000000 % 10 + 48);
-HIDDEN(blink_aarch64_size_b9 = blink_aarch64_size < 1000000000 ? 32 : blink_aarch64_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_darwin_arm64_b0 = RVA(blink_darwin_arm64) % 10 + 48);
-HIDDEN(blink_darwin_arm64_b1 = RVA(blink_darwin_arm64) < 10 ? 32 : RVA(blink_darwin_arm64) / 10 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b2 = RVA(blink_darwin_arm64) < 100 ? 32 : RVA(blink_darwin_arm64) / 100 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b3 = RVA(blink_darwin_arm64) < 1000 ? 32 : RVA(blink_darwin_arm64) / 1000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b4 = RVA(blink_darwin_arm64) < 10000 ? 32 : RVA(blink_darwin_arm64) / 10000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b5 = RVA(blink_darwin_arm64) < 100000 ? 32 : RVA(blink_darwin_arm64) / 100000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b6 = RVA(blink_darwin_arm64) < 1000000 ? 32 : RVA(blink_darwin_arm64) / 1000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b7 = RVA(blink_darwin_arm64) < 10000000 ? 32 : RVA(blink_darwin_arm64) / 10000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b8 = RVA(blink_darwin_arm64) < 100000000 ? 32 : RVA(blink_darwin_arm64) / 100000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_b9 = RVA(blink_darwin_arm64) < 1000000000 ? 32 : RVA(blink_darwin_arm64) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_darwin_arm64_size_b0 = blink_darwin_arm64_size % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b1 = blink_darwin_arm64_size < 10 ? 32 : blink_darwin_arm64_size / 10 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b2 = blink_darwin_arm64_size < 100 ? 32 : blink_darwin_arm64_size / 100 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b3 = blink_darwin_arm64_size < 1000 ? 32 : blink_darwin_arm64_size / 1000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b4 = blink_darwin_arm64_size < 10000 ? 32 : blink_darwin_arm64_size / 10000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b5 = blink_darwin_arm64_size < 100000 ? 32 : blink_darwin_arm64_size / 100000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b6 = blink_darwin_arm64_size < 1000000 ? 32 : blink_darwin_arm64_size / 1000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b7 = blink_darwin_arm64_size < 10000000 ? 32 : blink_darwin_arm64_size / 10000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b8 = blink_darwin_arm64_size < 100000000 ? 32 : blink_darwin_arm64_size / 100000000 % 10 + 48);
-HIDDEN(blink_darwin_arm64_size_b9 = blink_darwin_arm64_size < 1000000000 ? 32 : blink_darwin_arm64_size / 1000000000 % 10 + 48);
+#if SupportsWindows() || SupportsMetal()
+#define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
+PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
+HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
+HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
+HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
+HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
+HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
+HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
+HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
+HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
+HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
+HIDDEN(v_ntsubsystem = (LINK_WINDOWS
+                        ? (DEFINED(GetMessage)
+                           ? kNtImageSubsystemWindowsGui
+                           : kNtImageSubsystemWindowsCui)
+                        : kNtImageSubsystemEfiApplication));
+HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
+#endif

 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
-           MIN(0x70000 - IMAGE_BASE_REAL, ROUNDUP(RVA(_ezip), 512)) / 512);
-HIDDEN(v_ape_realbytes = v_ape_realsectors * 512);
-HIDDEN(v_ape_realdwords = v_ape_realsectors * (512 / 4));
-HIDDEN(v_ape_allsectors = ROUNDUP(RVA(_ezip), 512) / 512);
-HIDDEN(v_ape_allbytes = v_ape_allsectors * 512);
-HIDDEN(v_ape_highsectors = MIN(0xffff, v_ape_allsectors - v_ape_realsectors));
-TSSDESCSTUB2(_tss, _tss, _tss_end ? _tss_end - _tss - 1 : 0);
+           MIN(0x70000 - IMAGE_BASE_REAL,
+               ROUNDUP(RVA(_edata), 4096)) / 512);
+HIDDEN(v_ape_realpages = v_ape_realsectors / (4096 / 512));
+HIDDEN(v_ape_highsectors =
+           (ROUNDUP(RVA(_edata), 512) / 512) - v_ape_realsectors);
 #endif

 /* ZIP End of Central Directory header */
@@ -701,7 +622,7 @@ CHURN(ADDR(.bss));
 CHURN(_start);
 CHURN(ape_phdrs);
 #if SupportsMetal()
-CHURN(v_ape_allsectors);
+CHURN(v_ape_realsectors);
 #endif
 #if SupportsXnu()
 CHURN(ape_macho);
@@ -719,32 +640,6 @@ CHURN(WinMain);
 #endif /* SupportsWindows() */
 #endif /* SupportsXnu() */

-#if SupportsWindows() || SupportsMetal()
-#define LINK_WINDOWS (SupportsWindows() && !DEFINED(EfiMain))
-PFSTUB4(ape_pe_offset, ape_pe - ape_mz);
-HIDDEN(ape_pe_optsz = ape_pe_sections - (ape_pe + 24));
-HIDDEN(ape_pe_shnum = (ape_pe_sections_end - ape_pe_sections) / 40);
-HIDDEN(ape_pe_base = IMAGE_BASE_VIRTUAL);
-HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_iat) : 0);
-HIDDEN(ape_idata_iatsize = LINK_WINDOWS ? ape_idata_iatend - ape_idata_iat : 0);
-HIDDEN(ape_idata = LINK_WINDOWS ? RVA(ape_idata_idt) : 0);
-HIDDEN(ape_idata_idtsize = LINK_WINDOWS ? ape_idata_idtend - ape_idata_idt : 0);
-HIDDEN(v_ntversion = LINK_WINDOWS ? 6 : 1);
-HIDDEN(v_ntdllchar = LINK_WINDOWS ? 288 : 0);
-HIDDEN(v_ntsubversion = LINK_WINDOWS ? 6 : 5);
-HIDDEN(v_ntsubsystem = (LINK_WINDOWS
-                        ? (DEFINED(GetMessage)
-                           ? kNtImageSubsystemWindowsGui
-                           : kNtImageSubsystemWindowsCui)
-                        : kNtImageSubsystemEfiApplication));
-HIDDEN(ape_pe_entry = LINK_WINDOWS ? WinMain : EfiMain);
-#endif
-
-#if SupportsXnu()
-SHSTUB2(ape_macho_dd_skip, RVA(ape_macho) / 8);
-SHSTUB2(ape_macho_dd_count, (ape_macho_end - ape_macho) / 8);
-#endif
-
 ASSERT(DEFINED(ape_mz) ? ape_mz == IMAGE_BASE_VIRTUAL : 1, "linker panic");
 ASSERT((DEFINED(__init_bss_end) ? __init_bss_end : 0) % __SIZEOF_POINTER__ == 0,
       "__init_bss misalign");
@@ -761,15 +656,6 @@ ASSERT(DEFINED(_start) || DEFINED(_start16),
 ASSERT(!DEFINED(_start16) || REAL(_end) < 65536,
       "ape won't support non-tiny real mode programs");

-ASSERT(IS2POW(ape_stack_memsz),
-       "ape_stack_memsz must be a two power");
-
-ASSERT(ape_stack_vaddr % ape_stack_memsz == 0,
-       "ape_stack_vaddr must have ape_stack_memsz alignment; try using STATIC_STACK_ADDR(0x700000040000 & -ape_stack_memsz);");
-
-ASSERT(ALIGNOF(.tdata) <= TLS_ALIGNMENT && ALIGNOF(.tbss) <= TLS_ALIGNMENT,
-       "_Thread_local _Alignof can't exceed TLS_ALIGNMENT");
-
 /* Let's not be like Knight Capital. */
 /* NOCROSSREFS_TO(.test .text) */

@@ -15,182 +15,49 @@

 PKGS += APE

-APE =	o/$(MODE)/ape/ape.o			\
+APE =	$(APE_DEPS)			\
+	$(APE_OBJS)			\
 	o/$(MODE)/ape/ape.lds

-APE_NO_MODIFY_SELF =				\
-	o/$(MODE)/ape/ape.lds			\
-	o/$(MODE)/ape/ape-no-modify-self.o
+APE_BUILDSAFE =				\
+	$(APE_DEPS)			\
+	o/$(MODE)/ape/ape-buildsafe.o	\
+	o/$(MODE)/ape/ape.lds

-APE_COPY_SELF =					\
-	o/$(MODE)/ape/ape.lds			\
-	o/$(MODE)/ape/ape-copy-self.o
-
-APELINK =					\
-	$(COMPILE)				\
-	-ALINK.ape				\
-	$(LINK)					\
-	$(LINKARGS)				\
+APELINK =				\
+	$(COMPILE)			\
+	-ALINK.ape			\
+	$(LINK)				\
+	$(LINKARGS)			\
 	$(OUTPUT_OPTION)

-APE_LOADER_FLAGS =				\
-	-DNDEBUG				\
-	-iquote.				\
-	-Wall					\
-	-Wextra					\
-	-fpie					\
-	-Os					\
-	-ffreestanding				\
-	-mgeneral-regs-only			\
-	-mno-red-zone				\
-	-fno-ident				\
-	-fno-gnu-unique				\
-	-c					\
-	 $(OUTPUT_OPTION)			\
-	$<
-
 APE_FILES := $(wildcard ape/*.*)
 APE_HDRS = $(filter %.h,$(APE_FILES))
 APE_INCS = $(filter %.inc,$(APE_FILES))
-APE_SRCS_C = ape/loader.c
-APE_SRCS_S = $(filter %.S,$(APE_FILES))
-APE_SRCS = $(APE_SRCS_C) $(APE_SRCS_S)
-APE_OBJS = $(APE_SRCS_S:%.S=o/$(MODE)/%.o)
+APE_SRCS = $(filter %.S,$(APE_FILES))
+APE_OBJS = $(APE_SRCS:%.S=o/$(MODE)/%.o)
 APE_CHECKS = $(APE_HDRS:%=o/%.ok)

-o/$(MODE)/ape/ape.lds:				\
-		ape/ape.lds			\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		libc/intrin/bits.h		\
-		libc/thread/tls.h		\
-		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
+o/$(MODE)/ape/ape.lds:			\
+		ape/ape.lds		\
+		ape/macros.internal.h	\
+		libc/dce.h		\
 		libc/zip.h

-o/$(MODE)/ape/public/ape.lds: OVERRIDE_CPPFLAGS += -UCOSMO
-o/$(MODE)/ape/public/ape.lds:			\
-		ape/public/ape.lds		\
-		ape/ape.lds			\
-		ape/macros.internal.h		\
-		ape/relocations.h		\
-		libc/intrin/bits.h		\
-		libc/thread/tls.h		\
-		libc/calls/struct/timespec.h	\
-		libc/thread/thread.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
-		libc/nt/pedef.internal.h	\
-		libc/str/str.h			\
-		libc/zip.h
-
-o/ape/idata.inc:				\
-		ape/idata.internal.h		\
+o/ape/idata.inc:			\
+		ape/idata.internal.h	\
 		ape/relocations.h

-o/$(MODE)/ape/ape.o:				\
-		ape/blink-aarch64.gz		\
-		ape/blink-darwin-arm64.gz
+$(APE_OBJS):	$(BUILD_FILES)		\
+		ape/ape.mk

-o/$(MODE)/ape/ape-no-modify-self.o:		\
-		ape/ape.S			\
-		ape/macros.internal.h		\
-		ape/notice.inc			\
-		ape/relocations.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/intrin/asancodes.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
-		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.internal.h	\
-		libc/nexgen32e/vidya.internal.h	\
-		libc/nt/pedef.internal.h	\
-		libc/runtime/e820.internal.h	\
-		libc/runtime/mman.internal.h	\
-		libc/runtime/pc.internal.h	\
-		libc/runtime/symbolic.h		\
-		libc/sysv/consts/prot.h		\
-		ape/blink-aarch64.gz		\
-		ape/blink-darwin-arm64.gz	\
-		o/$(MODE)/ape/ape.elf
-	@$(COMPILE)				\
-		-AOBJECTIFY.S			\
-		$(OBJECTIFY.S)			\
-		$(OUTPUT_OPTION)		\
-		-DAPE_NO_MODIFY_SELF		\
-		-DAPE_LOADER='"o/$(MODE)/ape/ape.elf"' $<
+o/$(MODE)/ape/ape-no-modify-self.o: ape/ape.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -DAPE_NO_MODIFY_SELF $<

-o/$(MODE)/ape/ape-copy-self.o:			\
-		ape/ape.S			\
-		ape/macros.internal.h		\
-		ape/notice.inc			\
-		ape/relocations.h		\
-		libc/dce.h			\
-		libc/elf/def.h			\
-		libc/intrin/asancodes.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
-		libc/nexgen32e/uart.internal.h	\
-		libc/calls/metalfile.internal.h	\
-		libc/nexgen32e/vidya.internal.h	\
-		libc/nt/pedef.internal.h	\
-		libc/runtime/e820.internal.h	\
-		libc/runtime/mman.internal.h	\
-		libc/runtime/pc.internal.h	\
-		libc/runtime/symbolic.h		\
-		libc/sysv/consts/prot.h		\
-		ape/blink-aarch64.gz		\
-		ape/blink-darwin-arm64.gz
-	@$(COMPILE)				\
-		-AOBJECTIFY.S			\
-		$(OBJECTIFY.S)			\
-		$(OUTPUT_OPTION)		\
-		-DAPE_NO_MODIFY_SELF $<
-
-o/$(MODE)/ape/loader.o: ape/loader.c ape/loader.h
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=0b01111001 -S -g0 $(APE_LOADER_FLAGS)
-
-o/$(MODE)/ape/loader-xnu.o: ape/loader.c ape/loader.h
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -g $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-xnu-gcc.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CC) -DSUPPORT_VECTOR=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
-o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
-	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=0b00001000 -S -g0 $(APE_LOADER_FLAGS)
-
-o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.macho.dbg
-
-o/$(MODE)/ape/ape.elf.dbg:			\
-		o/$(MODE)/ape/loader.o		\
-		o/$(MODE)/ape/loader-elf.o	\
-		ape/loader.lds
-	@$(ELFLINK) -z max-page-size=0x10
-
-o/$(MODE)/ape/ape.macho.dbg:			\
-		o/$(MODE)/ape/loader-xnu.o	\
-		o/$(MODE)/ape/loader-macho.o	\
-		ape/loader-macho.lds
-	@$(ELFLINK) -z max-page-size=0x10
+o/$(MODE)/ape/ape-buildsafe.o: ape/ape.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -DAPE_BUILDSAFE $<

 .PHONY: o/$(MODE)/ape
-o/$(MODE)/ape:	$(APE_CHECKS)			\
-		o/$(MODE)/ape/ape.o		\
-		o/$(MODE)/ape/ape.lds		\
-		o/$(MODE)/ape/public/ape.lds	\
-		o/$(MODE)/ape/ape.elf		\
-		o/$(MODE)/ape/ape.macho		\
-		o/$(MODE)/ape/ape-copy-self.o	\
+o/$(MODE)/ape:	$(APE)			\
+		$(APE_CHECKS)		\
 		o/$(MODE)/ape/ape-no-modify-self.o
@@ -1,128 +0,0 @@
-#!/bin/sh
-
-if [ "$(id -u)" -eq 0 ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-echo "Actually Portable Executable (APE) Installer" >&2
-echo "Author:  Justine Tunney <[email protected]>"  >&2
-
-################################################################################
-# INSTALL APE LOADER SYSTEMWIDE
-
-if [ -f o/depend ]; then
-  # mkdeps.com build was successfully run so assume we can build
-  echo >&2
-  echo "recompiling ape loader" >&2
-  echo "running: make -j8 o//ape" >&2
-  make -j8 o//ape || exit
-  echo "done" >&2
-elif [ -d build/bootstrap ]; then
-  # if make isn't being used then it's unlikely the user changed the sources
-  # in that case the prebuilt binaries should be completely up-to-date
-  echo "using prebuilt ape loader from cosmo repo" >&2
-  mkdir -p o//ape || exit
-  cp -af build/bootstrap/ape.elf o//ape/ape.elf || exit
-  cp -af build/bootstrap/ape.macho o//ape/ape.macho || exit
-else
-  echo "no cosmopolitan libc repository here" >&2
-  echo "fetching ape loader from justine.lol"  >&2
-  mkdir -p o//ape || exit
-  if command -v wget >/dev/null 2>&1; then
-    wget -qO o//ape/ape.elf https://justine.lol/ape.elf || exit
-    wget -qO o//ape/ape.macho https://justine.lol/ape.macho || exit
-  else
-    curl -Rso o//ape/ape.elf https://justine.lol/ape.elf || exit
-    curl -Rso o//ape/ape.macho https://justine.lol/ape.macho || exit
-  fi
-  chmod +x o//ape/ape.elf || exit
-  chmod +x o//ape/ape.macho || exit
-fi
-
-if [ "$(uname -s)" = "Darwin" ]; then
-  if ! [ /usr/bin/ape -nt o//ape/ape.macho ]; then
-    echo >&2
-    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
-    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
-    $SUDO cp -f o//ape/ape.macho /usr/bin/ape || exit
-    echo "done" >&2
-  fi
-else
-  if ! [ /usr/bin/ape -nt o//ape/ape.elf ]; then
-    echo >&2
-    echo "installing o//ape/ape.elf to /usr/bin/ape" >&2
-    echo "$SUDO mv -f o//ape/ape.elf /usr/bin/ape" >&2
-    $SUDO cp -f o//ape/ape.elf /usr/bin/ape || exit
-    echo "done" >&2
-  fi
-fi
-
-################################################################################
-# REGISTER APE LOADER WITH BINFMT_MISC TOO (LINUX-ONLY)
-
-if [ x"$(uname -s)" = xLinux ]; then
-
-  if [ -e /proc/sys/fs/binfmt_misc/APE ]; then
-    echo >&2
-    echo it looks like APE is already registered with binfmt_misc >&2
-    echo To reinstall please run ape/apeuninstall.sh first >&2
-    echo please check that it is mapped to ape not /bin/sh >&2
-    echo cat /proc/sys/fs/binfmt_misc/APE >&2
-    cat /proc/sys/fs/binfmt_misc/APE >&2
-    exit
-  fi
-
-  if ! [ -e /proc/sys/fs/binfmt_misc ]; then
-    echo >&2
-    echo loading binfmt_misc into your kernel >&2
-    echo you may need to edit configs to persist across reboot >&2
-    echo $SUDO modprobe binfmt_misc >&2
-    $SUDO modprobe binfmt_misc || exit
-    echo done >&2
-  fi
-
-  if ! [ -e /proc/sys/fs/binfmt_misc/register ]; then
-    echo >&2
-    echo mounting binfmt_misc into your kernel >&2
-    echo you may need to edit configs to persist across reboot >&2
-    echo $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc >&2
-    $SUDO mount -t binfmt_misc none /proc/sys/fs/binfmt_misc || exit
-    echo done >&2
-  fi
-
-  echo >&2
-  echo registering APE with binfmt_misc >&2
-  echo you may need to edit configs to persist across reboot >&2
-  echo '$SUDO sh -c "echo '"'"':APE:M::MZqFpD::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-  echo '$SUDO sh -c "echo '"'"':APE-jart:M::jartsr::/usr/bin/ape:'"'"' >/proc/sys/fs/binfmt_misc/register"' >&2
-  $SUDO sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register" || exit
-  echo done >&2
-
-  if [ x"$(cat /proc/sys/fs/binfmt_misc/status)" = xdisabled ]; then
-    echo >&2
-    echo enabling binfmt_misc >&2
-    echo you may need to edit configs to persist across reboot >&2
-    echo $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' >&2
-    $SUDO sh -c 'echo 1 >/proc/sys/fs/binfmt_misc/status' || exit
-    echo done >&2
-  fi
-
-fi
-
-################################################################################
-
-{
-  echo
-  echo "------------------------------------------------------------------"
-  echo
-  echo "APE INSTALL COMPLETE"
-  echo
-  echo "If you decide to uninstall APE later on"
-  echo "you may do so using ape/apeuninstall.sh"
-  echo
-  echo "Enjoy your APE loader (>'.')>"
-  echo
-} >&2
@@ -1,26 +0,0 @@
-#!/bin/sh
-
-if [ "$UID" = "0" ]; then
-  SUDO=
-else
-  SUDO=sudo
-fi
-
-{
-  echo
-  echo "APE Uninstaller intends to run (in pseudo-shell)"
-  echo
-  echo "    sudo echo -1 into /proc/sys/fs/binfmt_misc/APE*"
-  echo "    sudo rm -f /usr/bin/ape ~/.ape o/tmp/.ape /tmp/.ape"
-  echo
-  echo "You may then use ape/apeinstall.sh to reinstall it"
-  echo
-} >&2
-
-set -ex
-for f in /proc/sys/fs/binfmt_misc/APE*; do
-  if [ -f $f ]; then
-    $SUDO sh -c "echo -1 >$f" || exit
-  fi
-done
-$SUDO rm -f /usr/bin/ape ~/.ape o/tmp/.ape o/tmp/ape /tmp/.ape /tmp/ape || exit
@@ -1,10 +0,0 @@
-#ifndef COSMOPOLITAN_APE_CONFIG_H_
-#define COSMOPOLITAN_APE_CONFIG_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-
-#define STATIC_SYMBOL(NAME, VALUE)   \
-  asm(".equ\t" NAME "," VALUE "\n\t" \
-      ".globl\t" NAME)
-
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_APE_CONFIG_H_ */
@@ -32,23 +32,23 @@
 //	@see	ape/ape.lds
 //	@see	winimp
 .macro	.imp	dll:req fn:req actual:req hint
-	.dll	"\dll"
-	.section ".piro.data.sort.iat.2.\dll\().2.\actual","aw",@progbits
+	.dll	\dll
+	.section .piro.data.sort.iat.2.\dll\().2.\actual,"aw",@progbits
 	.type	\fn,@object
 	.align	__SIZEOF_POINTER__
-\fn:	.quad	RVA(("\dll\().\actual"))
+\fn:	.quad	RVA((\dll\().\actual))
 	.size	\fn,.-\fn
 	.globl	\fn
 	.hidden	\fn
 	.previous
-	.section ".idata.ro.ilt.\dll\().2.\actual","a",@progbits
-".Lidata.ilt.\dll\().\actual":
-	.quad	RVA("\dll\().\actual")
-	.type	".Lidata.ilt.\dll\().\actual",@object
-	.size	".Lidata.ilt.\dll\().\actual",.-".Lidata.ilt.\dll\().\actual"
+	.section .idata.ro.ilt.\dll\().2.\actual,"a",@progbits
+.Lidata.ilt.\dll\().\actual:
+	.quad	RVA((\dll\().\actual))
+	.type	.Lidata.ilt.\dll\().\actual,@object
+	.size	.Lidata.ilt.\dll\().\actual,.-.Lidata.ilt.\dll\().\actual
 	.previous
-	.section ".idata.ro.hnt.\dll\().2.\actual","a",@progbits
-"\dll\().\actual":
+	.section .idata.ro.hnt.\dll\().2.\actual,"a",@progbits
+\dll\().\actual:
 	.ifnb	\hint			# hint i.e. guess function ordinal
 	.short	\hint
 	.else
@@ -56,55 +56,55 @@
 	.endif
 	.asciz	"\actual"
 	.align	2			# documented requirement
-	.globl	"\dll\().\actual"
-	.hidden	"\dll\().\actual"
-	.type	"\dll\().\actual",@object
-	.size	"\dll\().\actual",.-"\dll\().\actual"
+	.globl	\dll\().\actual
+	.hidden	\dll\().\actual
+	.type	\dll\().\actual,@object
+	.size	\dll\().\actual,.-\dll\().\actual
 	.previous
 .endm

 //	Defines DLL import.
 //	@note	this is an implementation detail of .imp
 .macro	.dll	name:req
-  .section ".idata.ro.idt.2.\name","aG",@progbits,"\name",comdat
-	.equ	".Lidata.idt.\name",.
-	.long	RVA("idata.ilt.\name")		# ImportLookupTable
+  .section .idata.ro.idt.2.\name,"aG",@progbits,\name,comdat
+	.equ	.Lidata.idt.\name,.
+	.long	RVA(idata.ilt.\name)		# ImportLookupTable
 	.long	0				# TimeDateStamp
 	.long	0				# ForwarderChain
-	.long	RVA(".Lidata.str.\name")	# DllNameRva
-	.long	RVA("idata.iat.\name")		# ImportAddressTable
-	.type	".Lidata.idt.\name",@object
-	.size	".Lidata.idt.\name",.-".Lidata.idt.\name"
+	.long	RVA(.Lidata.str.\name)		# DllNameRva
+	.long	RVA(idata.iat.\name)		# ImportAddressTable
+	.type	.Lidata.idt.\name,@object
+	.size	.Lidata.idt.\name,.-.Lidata.idt.\name
  .previous
-  .section ".idata.ro.ilt.\name\().1","aG",@progbits,"\name",comdat
+  .section .idata.ro.ilt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.ilt.\name",@object
-"idata.ilt.\name":
+	.type	idata.ilt.\name,@object
+idata.ilt.\name:
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section ".idata.ro.ilt.\name\().3","aG",@progbits,"\name",comdat
+	*/.section .idata.ro.ilt.\name\().3,"aG",@progbits,\name,comdat
 	.quad	0
  .previous
-  .section ".idata.ro.hnt.\name\().1","aG",@progbits,"\name",comdat
+  .section .idata.ro.hnt.\name\().1,"aG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.hnt.\name",@object
-	.equ	"idata.hnt.\name",.
+	.type	idata.hnt.\name,@object
+	.equ	idata.hnt.\name,.
  .previous
-  .section ".piro.data.sort.iat.2.\name\().1","awG",@progbits,"\name",comdat
+  .section .piro.data.sort.iat.2.\name\().1,"awG",@progbits,\name,comdat
 	.align	__SIZEOF_POINTER__
-	.type	"idata.iat.\name",@object
-"idata.iat.\name":
+	.type	idata.iat.\name,@object
+idata.iat.\name:
 	.previous/*
 	...
 	decentralized content
 	...
-	*/.section ".piro.data.sort.iat.2.\name\().3","awG",@progbits,"\name",comdat
+	*/.section .piro.data.sort.iat.2.\name\().3,"awG",@progbits,\name,comdat
 	.quad	0
  .previous
  .section .rodata.str1.1,"aSM",@progbits,1
-".Lidata.str.\name":
+.Lidata.str.\name:
 	.asciz	"\name\().dll"
  .previous
 .endm
@@ -1,249 +0,0 @@
-/*-*- 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 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/elf/def.h"
-#include "libc/sysv/consts/prot.h"
-#include "libc/macho.internal.h"
-#include "libc/dce.h"
-#include "libc/macros.internal.h"
-
-//	APE Loader Executable Structure
-//	Linux, FreeBSD, NetBSD, OpenBSD
-
-	.align	8
-ehdr:	.ascii	"\177ELF"
-	.byte	ELFCLASS64
-	.byte	ELFDATA2LSB
-	.byte	1
-	.byte	ELFOSABI_FREEBSD
-	.quad	0
-	.word	ET_EXEC			# e_type
-	.word	EM_NEXGEN32E		# e_machine
-	.long	1			# e_version
-	.quad	_start			# e_entry
-	.quad	phdrs - ehdr		# e_phoff
-	.quad	0			# e_shoff
-	.long	0			# e_flags
-	.word	64			# e_ehsize
-	.word	56			# e_phentsize
-	.word	4			# e_phnum
-	.word	0			# e_shentsize
-	.word	0			# e_shnum
-	.word	0			# e_shstrndx
-	.endobj	ehdr,globl
-
-	.align	8
-phdrs:	.long	PT_LOAD			# p_type
-	.long	PF_R|PF_X		# p_flags
-	.quad	0			# p_offset
-	.quad	ehdr			# p_vaddr
-	.quad	ehdr			# p_paddr
-	.quad	filesz			# p_filesz
-	.quad	filesz			# p_memsz
-	.quad	PAGESIZE		# p_align
-
-	.long	PT_LOAD			# p_type
-	.long	PF_R|PF_W		# p_flags
-	.quad	0			# p_offset
-	.quad	bss			# p_vaddr
-	.quad	bss			# p_paddr
-	.quad	0			# p_filesz
-	.quad	bsssize			# p_memsz
-	.quad	PAGESIZE		# p_align
-
-	.long	PT_GNU_STACK		# p_type
-	.long	PF_R|PF_W		# p_flags
-	.quad	0			# p_offset
-	.quad	0			# p_vaddr
-	.quad	0			# p_paddr
-	.quad	0			# p_filesz
-	.quad	0			# p_memsz
-	.quad	16			# p_align
-
-	.long	PT_NOTE			# p_type
-	.long	PF_R			# p_flags
-	.quad	note - ehdr		# p_offset
-	.quad	note			# p_vaddr
-	.quad	note			# p_paddr
-	.quad	notesize		# p_filesz
-	.quad	notesize		# p_memsz
-	.quad	8			# p_align
-	.endobj	phdrs
-
-note:	.long	2f-1f
-	.long	4f-3f
-	.long	1
-1:	.asciz	"OpenBSD"
-2:	.align	4
-3:	.long	0
-4:	.long	2f-1f
-	.long	4f-3f
-	.long	1
-1:	.asciz	"NetBSD"
-2:	.align	4
-3:	.long	901000000
-4:	.endobj	note
-	notesize = . - note
-
-	.align	64,0				# for ape.S dd
-	.org	0x180				# for ape.S dd
-
-//	APE Loader XNU Header
-//
-//	This header is dd'd backwards by the APE shell script when
-//	running on Mac OS X.
-//
-//	@see	ape/ape.S
-macho:	.long	0xFEEDFACE+1
-	.long	MAC_CPU_NEXGEN32E
-	.long	MAC_CPU_NEXGEN32E_ALL
-	.long	MAC_EXECUTE
-	.long	5				# number of load commands
-	.long	60f-10f				# size of all load commands
-	.long	MAC_NOUNDEFS			# flags
-	.long	0				# reserved
-10:	.long	MAC_LC_SEGMENT_64
-	.long	20f-10b				# unmaps first page dir
-	.ascin	"__PAGEZERO",16			# consistent with linux
-	.quad	0,0x200000,0,0			# which forbids mem <2m
-	.long	0,0,0,0
-20:	.long	MAC_LC_SEGMENT_64
-	.long	30f-20b
-	.ascin	"__TEXT",16
-	.quad	ehdr				# vaddr
-	.quad	4096				# memsz
-	.quad	0				# file offset
-	.quad	filesz				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_EXEC|PROT_READ		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-210:	.ascin	"__text",16			# section name (.text)
-	.ascin	"__TEXT",16
-	.quad	_start				# vaddr
-	.quad	textsz				# memsz
-	.long	textoff				# offset
-	.long	6				# align 2**6 = 64
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ATTR_SOME_INSTRUCTIONS	# section type & attributes
-	.long	0,0,0				# reserved
-30:	.long	MAC_LC_SEGMENT_64
-	.long	40f-30b
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.quad	0				# offset
-	.quad	0				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_READ|PROT_WRITE		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-310:	.ascin	"__bss",16			# section name (.bss)
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.long	0				# offset
-	.long	12				# align 2**12 = 4096
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ZEROFILL			# section type & attributes
-	.long	0,0,0				# reserved
-40:	.long	MAC_LC_UUID
-	.long	50f-40b
-	.quad	0x3fb29ee4ac6c87aa		# uuid1
-	.quad	0xdd2c9bb866d9eef8		# uuid2
-50:	.long	MAC_LC_UNIXTHREAD
-	.long	60f-50b				# cmdsize
-	.long	MAC_THREAD_NEXGEN32E		# flavaflav
-	.long	(520f-510f)/4			# count
-510:	.quad	0				# rax
-	.quad	0				# rbx
-	.quad	0				# rcx
-	.quad	_HOSTXNU			# rdx
-	.quad	0				# rdi
-	.quad	0				# rsi
-	.quad	0				# rbp
-	.quad	0				# rsp
-	.quad	0				# r8
-	.quad	0				# r9
-	.quad	0				# r10
-	.quad	0				# r11
-	.quad	0				# r12
-	.quad	0				# r13
-	.quad	0				# r14
-	.quad	0				# r15
-	.quad	_start				# rip
-	.quad	0				# rflags
-	.quad	0				# cs
-	.quad	0				# fs
-	.quad	0				# gs
-520:
-60:
-	.endobj	macho
-
-	.align	64,0				# for ape.S dd
-	.org	0x400				# for ape.S dd
-
-//	Ape Loader Entrpoint
-//
-//	This is normally called by the operating system. However it may
-//	be called by the Actually Portable Executables themselves, when
-//	re-executing a program. Just do this:
-//
-//	    memcpy(0x200000, loader)
-//	    lea handoff(%rip),%rcx
-//	    lea argblock(%rip),%rsp
-//	    jmp 0x200400
-//
-//	@see	APE_LOADER_ENTRY
-//	@see	ape/loader.h
-_start:
-
-//	Hack for detecting M1 Rosetta environment.
-//	https://github.com/jart/cosmopolitan/issues/429#issuecomment-1166704377
-	cmp	$-1,%ebx
-	jne	0f
-	cmp	$+1,%edx
-	jne	0f
-	mov	$_HOSTXNU,%dl
-	xor	%ecx,%ecx
-
-0:	mov	%rsp,%rsi
-	jmp	ApeLoader
-	.endfn	_start,globl
-
-//	System Call Entrpoint
-//
-//	This function is used by the APE loader to make system calls.
-//	We also pass a reference to this function to the APE binary's
-//	_start() function. It's needed because on OpenBSD, msyscall()
-//	restricts which pages can issue system calls, and it can only
-//	be called once. Therefore if we want to be load and re-load a
-//	binary multiple times without calling the system execve(), we
-//	need to be able to handover the SYSCALL function. We hardcode
-//	this to a fixed address, but that shouldn't be used, since we
-//	would ideally want to move it to a random page in the future.
-__syscall_loader:
-	clc
-	syscall
-	jc	1f
-	ret
-1:	neg	%rax
-	ret
-	.endfn	__syscall_loader,globl
@@ -1,138 +0,0 @@
-/*-*- 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 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/macho.internal.h"
-#include "libc/sysv/consts/prot.h"
-#include "libc/dce.h"
-#include "libc/macros.internal.h"
-
-//	APE Loader Executable Structure for XNU
-
-	.align	4096
-macho:	.long	0xFEEDFACE+1
-	.long	MAC_CPU_NEXGEN32E
-	.long	MAC_CPU_NEXGEN32E_ALL
-	.long	MAC_EXECUTE
-	.long	5				# number of load commands
-	.long	60f-10f				# size of all load commands
-	.long	MAC_NOUNDEFS			# flags
-	.long	0				# reserved
-10:	.long	MAC_LC_SEGMENT_64
-	.long	20f-10b				# unmaps first page dir
-	.ascin	"__PAGEZERO",16			# consistent with linux
-	.quad	0,0x200000,0,0			# which forbids mem <2m
-	.long	0,0,0,0
-20:	.long	MAC_LC_SEGMENT_64
-	.long	30f-20b
-	.ascin	"__TEXT",16
-	.quad	macho				# vaddr
-	.quad	4096				# memsz
-	.quad	0				# file offset
-	.quad	filesz				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_EXEC|PROT_READ		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-210:	.ascin	"__text",16			# section name (.text)
-	.ascin	"__TEXT",16
-	.quad	_start				# vaddr
-	.quad	textsz				# memsz
-	.long	textoff				# offset
-	.long	6				# align 2**3 = 64
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ATTR_SOME_INSTRUCTIONS	# section type & attributes
-	.long	0,0,0				# reserved
-30:	.long	MAC_LC_SEGMENT_64
-	.long	40f-30b
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.quad	0				# offset
-	.quad	0				# file size
-	.long	PROT_EXEC|PROT_READ|PROT_WRITE	# maxprot
-	.long	PROT_READ|PROT_WRITE		# initprot
-	.long	1				# segment section count
-	.long	0				# flags
-310:	.ascin	"__bss",16			# section name (.bss)
-	.ascin	"__DATA",16
-	.quad	bss				# vaddr
-	.quad	bsssize				# memsz
-	.long	0				# offset
-	.long	12				# align 2**12 = 4096
-	.long	0				# reloc table offset
-	.long	0				# relocation count
-	.long	MAC_S_ZEROFILL			# section type & attributes
-	.long	0,0,0				# reserved
-40:	.long	MAC_LC_UUID
-	.long	50f-40b
-	.quad	0x3fb29ee4ac6c87aa		# uuid1
-	.quad	0xdd2c9bb866d9eef8		# uuid2
-50:	.long	MAC_LC_UNIXTHREAD
-	.long	60f-50b				# cmdsize
-	.long	MAC_THREAD_NEXGEN32E		# flavaflav
-	.long	(520f-510f)/4			# count
-510:	.quad	0				# rax
-	.quad	0				# rbx
-	.quad	0				# rcx
-	.quad	_HOSTXNU			# rdx
-	.quad	0				# rdi
-	.quad	0				# rsi
-	.quad	0				# rbp
-	.quad	0				# rsp
-	.quad	0				# r8
-	.quad	0				# r9
-	.quad	0				# r10
-	.quad	0				# r11
-	.quad	0				# r12
-	.quad	0				# r13
-	.quad	0				# r14
-	.quad	0				# r15
-	.quad	_start				# rip
-	.quad	0				# rflags
-	.quad	0				# cs
-	.quad	0				# fs
-	.quad	0				# gs
-520:
-60:
-	.endobj	macho,globl
-
-	.align	64
-_start:
-
-//	Hack for detecting M1 Rosetta environment.
-//	https://github.com/jart/cosmopolitan/issues/429#issuecomment-1166704377
-	cmp	$-1,%ebx
-	jne	0f
-	cmp	$+1,%edx
-	jne	0f
-	mov	$_HOSTXNU,%dl
-	xor	%ecx,%ecx
-
-0:	mov	%rsp,%rsi
-	jmp	ApeLoader
-	.endfn	_start,globl
-
-__syscall_loader:
-	clc
-	syscall
-	jc	1f
-	ret
-1:	neg	%rax
-	ret
-	.endfn	__syscall_loader,globl
@@ -1,42 +0,0 @@
-/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=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.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-ENTRY(_start)
-
-SECTIONS {
-  . = 0x200000;
-  .text : {
-    *(.text)
-    *(.rodata .rodata.*)
-    . = ALIGN(4096);
-  }
-  filesz = . - macho;
-  textsz = . - _start;
-  .bss ALIGN(4096) : {
-    bss = .;
-    *(.bss)
-    . = ALIGN(4096);
-  }
-  memsz = . - macho;
-  /DISCARD/ : {
-    *(.*)
-  }
-}
-
-bsssize = SIZEOF(.bss);
-textoff = _start - macho;
@@ -1,791 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net 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 "ape/loader.h"
-
-#define SET_EXE_FILE    0 /* needs root ;_; */
-#define TROUBLESHOOT    0
-#define TROUBLESHOOT_OS LINUX
-
-/**
- * @fileoverview APE Loader for GNU/Systemd/XNU/FreeBSD/NetBSD/OpenBSD
- *
- * We recommend using the normal APE design, where binaries assimilate
- * themselves once by self-modifying the first 64 bytes. If that can't
- * meet your requirements then we provide an excellent alternative.
- *
- *     m=tiny
- *     make -j8 MODE=$m o/$m/ape o/$m/examples/printargs.com
- *     o/$m/ape/ape.elf o/$m/examples/printargs.com
- *
- * This is an embeddable Actually Portable Executable interpreter. The
- * `ape/ape.S` bootloader embeds this binary inside each binary that's
- * linked using `$(APE_NO_MODIFY_SELF)` so it is an automated seamless
- * process. the shell script at the top of the .COM files will copy it
- * to `${TMPDIR:-${HOME:-.}}/.ape` and call execve(). It's a zero copy
- * operation in praxis since this payload uses mmap() to load the rest
- * of your executable the same way the kernel does, based on ELF phdrs
- * which are located in accordance with the first sh printf statement.
- *
- * APE executables will look for this program on the system path first
- * so your APE loader may be installed to your system as follows:
- *
- *     m=tiny
- *     make -j8 MODE=$m o/$m/ape/ape.elf
- *     sudo cp o/$m/ape/ape.elf /usr/bin/ape
- *
- * For Mac OS X systems you should install the `ape.macho` executable:
- *
- *     sudo cp o/$m/ape/ape.macho /usr/bin/ape
- *
- * Your APE loader may be used as a shebang interpreter by doing this:
- *
- *     #!/usr/bin/ape python.com
- *     # -*- python -*-
- *     print("hello world")
- *
- * However you won't need to do that, if your APE Loader is registered
- * as a binfmt_misc interpreter. You can do that as follows with root:
- *
- *     sudo cp -f o/$m/ape/ape.elf /usr/bin
- *     f=/proc/sys/fs/binfmt_misc/register
- *     sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >$f"
- *
- * If the register file doesn't exist on your Linux machine then you'd
- * load it using the following commands:
- *
- *     sudo modprobe binfmt_misc
- *     sudo mount -t binfmt_misc none /proc/sys/fs/binfmt_misc
- *
- * You should now experience a performance boost, and you can also now
- * use the regular shebang form:
- *
- *     #!/usr/bin/python.com
- *     # -*- python -*-
- *     print("hello world")
- *
- * @note this can probably be used as a binfmt_misc interpreter
- */
-
-#define LINUX   1
-#define XNU     8
-#define OPENBSD 16
-#define FREEBSD 32
-#define NETBSD  64
-
-#define SupportsLinux()   (SUPPORT_VECTOR & LINUX)
-#define SupportsXnu()     (SUPPORT_VECTOR & XNU)
-#define SupportsFreebsd() (SUPPORT_VECTOR & FREEBSD)
-#define SupportsOpenbsd() (SUPPORT_VECTOR & OPENBSD)
-#define SupportsNetbsd()  (SUPPORT_VECTOR & NETBSD)
-
-#define IsLinux()   (SupportsLinux() && os == LINUX)
-#define IsXnu()     (SupportsXnu() && os == XNU)
-#define IsFreebsd() (SupportsFreebsd() && os == FREEBSD)
-#define IsOpenbsd() (SupportsOpenbsd() && os == OPENBSD)
-#define IsNetbsd()  (SupportsNetbsd() && os == NETBSD)
-
-#define O_RDONLY           0
-#define PROT_READ          1
-#define PROT_WRITE         2
-#define PROT_EXEC          4
-#define MAP_SHARED         1
-#define MAP_PRIVATE        2
-#define MAP_FIXED          16
-#define MAP_ANONYMOUS      (IsLinux() ? 32 : 4096)
-#define AT_EXECFN_LINUX    31
-#define AT_EXECFN_NETBSD   2014
-#define ELFCLASS64         2
-#define ELFDATA2LSB        1
-#define EM_NEXGEN32E       62
-#define ET_EXEC            2
-#define PT_LOAD            1
-#define PT_DYNAMIC         2
-#define EI_CLASS           4
-#define EI_DATA            5
-#define PF_X               1
-#define PF_W               2
-#define PF_R               4
-#define X_OK               1
-#define XCR0_SSE           2
-#define XCR0_AVX           4
-#define PR_SET_MM          35
-#define PR_SET_MM_EXE_FILE 13
-
-#define Read32(S)                                                      \
-  ((unsigned)(255 & (S)[3]) << 030 | (unsigned)(255 & (S)[2]) << 020 | \
-   (unsigned)(255 & (S)[1]) << 010 | (unsigned)(255 & (S)[0]) << 000)
-
-#define Read64(S)                         \
-  ((unsigned long)(255 & (S)[7]) << 070 | \
-   (unsigned long)(255 & (S)[6]) << 060 | \
-   (unsigned long)(255 & (S)[5]) << 050 | \
-   (unsigned long)(255 & (S)[4]) << 040 | \
-   (unsigned long)(255 & (S)[3]) << 030 | \
-   (unsigned long)(255 & (S)[2]) << 020 | \
-   (unsigned long)(255 & (S)[1]) << 010 | \
-   (unsigned long)(255 & (S)[0]) << 000)
-
-struct PathSearcher {
-  char os;
-  unsigned long namelen;
-  const char *name;
-  const char *syspath;
-  char path[1024];
-};
-
-struct ElfEhdr {
-  unsigned char e_ident[16];
-  unsigned short e_type;
-  unsigned short e_machine;
-  unsigned e_version;
-  unsigned long e_entry;
-  unsigned long e_phoff;
-  unsigned long e_shoff;
-  unsigned e_flags;
-  unsigned short e_ehsize;
-  unsigned short e_phentsize;
-  unsigned short e_phnum;
-  unsigned short e_shentsize;
-  unsigned short e_shnum;
-  unsigned short e_shstrndx;
-};
-
-struct ElfPhdr {
-  unsigned p_type;
-  unsigned p_flags;
-  unsigned long p_offset;
-  unsigned long p_vaddr;
-  unsigned long p_paddr;
-  unsigned long p_filesz;
-  unsigned long p_memsz;
-  unsigned long p_align;
-};
-
-extern char ehdr[];
-extern char _end[];
-static void *syscall_;
-static char relocated;
-static struct PathSearcher ps;
-extern char __syscall_loader[];
-
-static int ToLower(int c) {
-  return 'A' <= c && c <= 'Z' ? c + ('a' - 'A') : c;
-}
-
-char *MemCpy(char *d, const char *s, unsigned long n) {
-  unsigned long i = 0;
-  for (; i < n; ++i) d[i] = s[i];
-  return d + n;
-}
-
-static unsigned long StrLen(const char *s) {
-  unsigned long n = 0;
-  while (*s++) ++n;
-  return n;
-}
-
-static const char *MemChr(const char *s, unsigned char c, unsigned long n) {
-  for (; n; --n, ++s) {
-    if ((*s & 255) == c) {
-      return s;
-    }
-  }
-  return 0;
-}
-
-static char *GetEnv(char **p, const char *s) {
-  unsigned long i, j;
-  if (p) {
-    for (i = 0; p[i]; ++i) {
-      for (j = 0;; ++j) {
-        if (!s[j]) {
-          if (p[i][j] == '=') {
-            return p[i] + j + 1;
-          }
-          break;
-        }
-        if (s[j] != p[i][j]) {
-          break;
-        }
-      }
-    }
-  }
-  return 0;
-}
-
-static char *Utoa(char p[21], unsigned long x) {
-  char t;
-  unsigned long i, a, b;
-  i = 0;
-  do {
-    p[i++] = x % 10 + '0';
-    x = x / 10;
-  } while (x > 0);
-  p[i] = '\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;
-}
-
-static char *Itoa(char p[21], long x) {
-  if (x < 0) *p++ = '-', x = -(unsigned long)x;
-  return Utoa(p, x);
-}
-
-#if TROUBLESHOOT
-const char *DescribeOs(int os) {
-  if (IsLinux()) {
-    return "GNU/SYSTEMD";
-  } else if (IsXnu()) {
-    return "XNU";
-  } else if (IsFreebsd()) {
-    return "FREEBSD";
-  } else if (IsOpenbsd()) {
-    return "OPENBSD";
-  } else if (IsNetbsd()) {
-    return "NETBSD";
-  } else {
-    return "WUT";
-  }
-}
-#endif
-
-__attribute__((__noreturn__)) static void Exit(int rc, int os) {
-  asm volatile("call\t*%2"
-               : /* no outputs */
-               : "a"((IsLinux() ? 60 : 1) | (IsXnu() ? 0x2000000 : 0)), "D"(rc),
-                 "rm"(syscall_)
-               : "memory");
-  __builtin_unreachable();
-}
-
-static void Close(int fd, int os) {
-  int ax, di;
-  asm volatile("call\t*%4"
-               : "=a"(ax), "=D"(di)
-               : "0"((IsLinux() ? 3 : 6) | (IsXnu() ? 0x2000000 : 0)), "1"(fd),
-                 "rm"(syscall_)
-               : "rcx", "rdx", "rsi", "r8", "r9", "r10", "r11", "memory", "cc");
-}
-
-static int Read(int fd, void *data, int size, int os) {
-  long si;
-  int ax, di, dx;
-  asm volatile("call\t*%8"
-               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
-               : "0"((IsLinux() ? 0 : 3) | (IsXnu() ? 0x2000000 : 0)), "1"(fd),
-                 "2"(data), "3"(size), "rm"(syscall_)
-               : "rcx", "r8", "r9", "r10", "r11", "memory");
-  return ax;
-}
-
-static void Write(int fd, const void *data, int size, int os) {
-  long si;
-  int ax, di, dx;
-  asm volatile("call\t*%8"
-               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
-               : "0"((IsLinux() ? 1 : 4) | (IsXnu() ? 0x2000000 : 0)), "1"(fd),
-                 "2"(data), "3"(size), "rm"(syscall_)
-               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
-}
-
-static void Execve(const char *prog, char **argv, char **envp, int os) {
-  long ax, di, si, dx;
-  asm volatile("call\t*%8"
-               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
-               : "0"(59 | (IsXnu() ? 0x2000000 : 0)), "1"(prog), "2"(argv),
-                 "3"(envp), "rm"(syscall_)
-               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
-}
-
-static int Access(const char *path, int mode, int os) {
-  int ax, si;
-  long dx, di;
-  asm volatile("call\t*%7"
-               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
-               : "0"((IsLinux() ? 21 : 33) | (IsXnu() ? 0x2000000 : 0)),
-                 "1"(path), "2"(mode), "rm"(syscall_)
-               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
-  return ax;
-}
-
-static int Msyscall(long p, long n, int os) {
-  int ax;
-  long di, si;
-  if (!IsOpenbsd()) {
-    return 0;
-  } else {
-    asm volatile("call\t*%6"
-                 : "=a"(ax), "=D"(di), "=S"(si)
-                 : "0"(37), "1"(p), "2"(n), "rm"(syscall_)
-                 : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
-    return ax;
-  }
-}
-
-static int Open(const char *path, int flags, int mode, int os) {
-  long di;
-  int ax, dx, si;
-  asm volatile("call\t*%8"
-               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx)
-               : "0"((IsLinux() ? 2 : 5) | (IsXnu() ? 0x2000000 : 0)),
-                 "1"(path), "2"(flags), "3"(mode), "rm"(syscall_)
-               : "rcx", "r8", "r9", "r10", "r11", "memory", "cc");
-  return ax;
-}
-
-__attribute__((__noinline__)) static long Mmap(long addr, long size, int prot,
-                                               int flags, int fd, long off,
-                                               int os) {
-  long ax, di, si, dx;
-  register int flags_ asm("r10") = flags;
-  register int fd_ asm("r8") = fd;
-  register long off_ asm("r9") = off;
-  asm volatile("push\t%%r9\n\t"
-               "push\t%%r9\n\t"
-               "call\t*%7\n\t"
-               "pop\t%%r9\n\t"
-               "pop\t%%r9"
-               : "=a"(ax), "=D"(di), "=S"(si), "=d"(dx), "+r"(flags_),
-                 "+r"(fd_), "+r"(off_)
-               : "rm"(syscall_),
-                 "0"((IsLinux()     ? 9
-                      : IsFreebsd() ? 477
-                                    : 197) |
-                     (IsXnu() ? 0x2000000 : 0)),
-                 "1"(addr), "2"(size), "3"(prot)
-               : "rcx", "r11", "memory", "cc");
-  return ax;
-}
-
-int MunmapLinux(const void *addr, unsigned long size) {
-  int ax;
-  asm volatile("syscall"
-               : "=a"(ax)
-               : "0"(11), "D"(addr), "S"(size)
-               : "rcx", "r11", "memory");
-  return ax;
-}
-
-int PrctlLinux(int op, long a, long b, long c, long d) {
-  int rc;
-  asm volatile("mov\t%5,%%r10\n\t"
-               "mov\t%6,%%r8\n\t"
-               "syscall"
-               : "=a"(rc)
-               : "0"(157), "D"(op), "S"(a), "d"(b), "g"(c), "g"(d)
-               : "rcx", "r8", "r10", "r11", "memory");
-  return rc;
-}
-
-static void Emit(int os, const char *s) {
-  Write(2, s, StrLen(s), os);
-}
-
-static void Perror(int os, const char *c, int rc, const char *s) {
-  char ibuf[21];
-  Emit(os, "ape error: ");
-  Emit(os, c);
-  Emit(os, ": ");
-  Emit(os, s);
-  if (rc) {
-    Emit(os, " failed errno=");
-    Itoa(ibuf, -rc);
-    Emit(os, ibuf);
-  }
-  Emit(os, "\n");
-}
-
-__attribute__((__noreturn__)) static void Pexit(int os, const char *c, int rc,
-                                                const char *s) {
-  Perror(os, c, rc, s);
-  Exit(127, os);
-}
-
-static int StrCmp(const char *l, const char *r) {
-  unsigned long i = 0;
-  while (l[i] == r[i] && r[i]) ++i;
-  return (l[i] & 255) - (r[i] & 255);
-}
-
-static char EndsWithIgnoreCase(const char *p, unsigned long n, const char *s) {
-  unsigned long i, m;
-  if (n >= (m = StrLen(s))) {
-    for (i = n - m; i < n; ++i) {
-      if (ToLower(p[i]) != *s++) {
-        return 0;
-      }
-    }
-    return 1;
-  } else {
-    return 0;
-  }
-}
-
-static char IsComPath(struct PathSearcher *ps) {
-  return EndsWithIgnoreCase(ps->name, ps->namelen, ".com") ||
-         EndsWithIgnoreCase(ps->name, ps->namelen, ".exe") ||
-         EndsWithIgnoreCase(ps->name, ps->namelen, ".com.dbg");
-}
-
-static char AccessCommand(struct PathSearcher *ps, const char *suffix,
-                          unsigned long pathlen) {
-  unsigned long suffixlen;
-  suffixlen = StrLen(suffix);
-  if (pathlen + 1 + ps->namelen + suffixlen + 1 > sizeof(ps->path)) return 0;
-  if (pathlen && ps->path[pathlen - 1] != '/') ps->path[pathlen++] = '/';
-  MemCpy(ps->path + pathlen, ps->name, ps->namelen);
-  MemCpy(ps->path + pathlen + ps->namelen, suffix, suffixlen + 1);
-  return !Access(ps->path, X_OK, ps->os);
-}
-
-static char SearchPath(struct PathSearcher *ps, const char *suffix) {
-  const char *p;
-  unsigned long i;
-  for (p = ps->syspath;;) {
-    for (i = 0; p[i] && p[i] != ':'; ++i) {
-      if (i < sizeof(ps->path)) {
-        ps->path[i] = p[i];
-      }
-    }
-    if (AccessCommand(ps, suffix, i)) {
-      return 1;
-    } else if (p[i] == ':') {
-      p += i + 1;
-    } else {
-      return 0;
-    }
-  }
-}
-
-static char FindCommand(struct PathSearcher *ps, const char *suffix) {
-  if (MemChr(ps->name, '/', ps->namelen) ||
-      MemChr(ps->name, '\\', ps->namelen)) {
-    ps->path[0] = 0;
-    return AccessCommand(ps, suffix, 0);
-  } else {
-    if (AccessCommand(ps, suffix, 0)) return 1;
-  }
-  return SearchPath(ps, suffix);
-}
-
-static char *Commandv(struct PathSearcher *ps, int os, const char *name,
-                      const char *syspath) {
-  ps->os = os;
-  ps->syspath = syspath ? syspath : "/bin:/usr/local/bin:/usr/bin";
-  if (!(ps->namelen = StrLen((ps->name = name)))) return 0;
-  if (ps->namelen + 1 > sizeof(ps->path)) return 0;
-  if (FindCommand(ps, "") || (!IsComPath(ps) && FindCommand(ps, ".com"))) {
-    return ps->path;
-  } else {
-    return 0;
-  }
-}
-
-__attribute__((__noreturn__)) static void Spawn(int os, const char *exe, int fd,
-                                                long *sp, char *page,
-                                                struct ElfEhdr *e) {
-  long rc;
-  unsigned long i;
-  int prot, flags;
-  struct ElfPhdr *p;
-  long code, codesize;
-  if (e->e_type != ET_EXEC) {
-    Pexit(os, exe, 0, "ELF e_type != ET_EXEC");
-  }
-  if (e->e_machine != EM_NEXGEN32E) {
-    Pexit(os, exe, 0, "ELF e_machine != EM_NEXGEN32E");
-  }
-  if (e->e_ident[EI_CLASS] != ELFCLASS64) {
-    Pexit(os, exe, 0, "ELF e_ident[EI_CLASS] != ELFCLASS64");
-  }
-  if (e->e_ident[EI_DATA] != ELFDATA2LSB) {
-    Pexit(os, exe, 0, "ELF e_ident[EI_DATA] != ELFDATA2LSB");
-  }
-  if (e->e_phoff + e->e_phnum * sizeof(*p) > 0x1000) {
-    Pexit(os, exe, 0, "ELF phdrs need to be in first page");
-  }
-  code = 0;
-  codesize = 0;
-  for (p = (struct ElfPhdr *)(page + e->e_phoff), i = e->e_phnum; i--;) {
-    if (p[i].p_type == PT_DYNAMIC) {
-      Pexit(os, exe, 0, "not a real executable");
-    }
-    if (p[i].p_type != PT_LOAD) continue;
-    if ((p[i].p_vaddr | p[i].p_filesz | p[i].p_memsz | p[i].p_offset) & 0xfff) {
-      Pexit(os, exe, 0, "APE phdrs must be 4096-aligned and 4096-padded");
-    }
-    prot = 0;
-    flags = MAP_FIXED | MAP_PRIVATE;
-    if (p[i].p_flags & PF_R) {
-      prot |= PROT_READ;
-    }
-    if (p[i].p_flags & PF_W) {
-      prot |= PROT_WRITE;
-    }
-    if (p[i].p_flags & PF_X) {
-      prot |= PROT_EXEC;
-      code = p[i].p_vaddr;
-      codesize = p[i].p_filesz;
-    }
-    if (p[i].p_memsz > p[i].p_filesz) {
-      if ((rc = Mmap(p[i].p_vaddr + p[i].p_filesz, p[i].p_memsz - p[i].p_filesz,
-                     prot, flags | MAP_ANONYMOUS, -1, 0, os)) < 0) {
-        Pexit(os, exe, rc, "bss mmap()");
-      }
-    }
-    if (p[i].p_filesz) {
-      if ((rc = Mmap(p[i].p_vaddr, p[i].p_filesz, prot, flags, fd,
-                     p[i].p_offset, os)) < 0) {
-        Pexit(os, exe, rc, "image mmap()");
-      }
-    }
-  }
-  if (!code) {
-    Pexit(os, exe, 0, "ELF needs PT_LOAD phdr w/ PF_X");
-  }
-
-#if SET_EXE_FILE
-  // change /proc/pid/exe to new executable path
-  if (IsLinux() && relocated) {
-    MunmapLinux((char *)0x200000, (long)(_end - ehdr));
-    PrctlLinux(PR_SET_MM, PR_SET_MM_EXE_FILE, fd, 0, 0);
-  }
-#endif
-
-  if (relocated) {
-    int ax;
-    asm volatile("syscall"
-                 : "=a"(ax)
-                 : "0"(1), "D"(1), "S"("hello\n"), "d"(6)
-                 : "rcx", "r11", "memory");
-  }
-
-  Close(fd, os);
-
-  // authorize only the loaded program to issue system calls. if this
-  // fails, then we pass a link to our syscall function to the program
-  // since it probably means a userspace program executed this loader
-  // and passed us a custom syscall function earlier.
-  if (Msyscall(code, codesize, os) != -1) {
-    syscall_ = 0;
-  }
-
-#if TROUBLESHOOT
-  Emit(TROUBLESHOOT_OS, "preparing to jump\n");
-#endif
-
-  // we clear all the general registers we can to have some wiggle room
-  // to extend the behavior of this loader in the future. we don't need
-  // to clear the xmm registers since the ape loader should be compiled
-  // with the -mgeneral-regs-only flag.
-  register void *r8 asm("r8") = syscall_;
-  asm volatile("xor\t%%eax,%%eax\n\t"
-               "xor\t%%r9d,%%r9d\n\t"
-               "xor\t%%r10d,%%r10d\n\t"
-               "xor\t%%r11d,%%r11d\n\t"
-               "xor\t%%ebx,%%ebx\n\t"    // netbsd doesnt't clear this
-               "xor\t%%r12d,%%r12d\n\t"  // netbsd doesnt't clear this
-               "xor\t%%r13d,%%r13d\n\t"  // netbsd doesnt't clear this
-               "xor\t%%r14d,%%r14d\n\t"  // netbsd doesnt't clear this
-               "xor\t%%r15d,%%r15d\n\t"  // netbsd doesnt't clear this
-               "mov\t%%rdx,%%rsp\n\t"
-               "xor\t%%edx,%%edx\n\t"
-               "push\t%%rsi\n\t"
-               "xor\t%%esi,%%esi\n\t"
-               "xor\t%%ebp,%%ebp\n\t"
-               "ret"
-               : /* no outputs */
-               : "D"(IsFreebsd() ? sp : 0), "S"(e->e_entry), "d"(sp), "c"(os),
-                 "r"(r8)
-               : "memory");
-  __builtin_unreachable();
-}
-
-__attribute__((__noreturn__)) void ApeLoader(long di, long *sp, char dl,
-                                             struct ApeLoader *handoff) {
-  int rc;
-  long *auxv;
-  struct ElfEhdr *eh;
-  int c, i, fd, os, argc;
-  char *p, *exe, *prog, **argv, **envp, *page;
-  static union {
-    struct ElfEhdr ehdr;
-    char p[0x1000];
-  } u;
-
-  // detect freebsd
-  if (handoff) {
-    os = handoff->os;
-  } else if (SupportsXnu() && dl == XNU) {
-    os = XNU;
-  } else if (SupportsFreebsd() && di) {
-    os = FREEBSD;
-    sp = (long *)di;
-  } else {
-    os = 0;
-  }
-
-  // extract arguments
-  argc = *sp;
-  argv = (char **)(sp + 1);
-  envp = (char **)(sp + 1 + argc + 1);
-  auxv = (long *)(sp + 1 + argc + 1);
-  for (;;) {
-    if (!*auxv++) {
-      break;
-    }
-  }
-
-  // get syscall function pointer
-  if (handoff && handoff->systemcall) {
-    syscall_ = handoff->systemcall;
-  } else {
-    syscall_ = __syscall_loader;
-  }
-
-  if (handoff) {
-    // we were called by ape_execve()
-    // no argument parsing is needed
-    // no path searching is needed
-    exe = handoff->prog;
-    fd = handoff->fd;
-    exe = handoff->prog;
-    page = handoff->page;
-    eh = (struct ElfEhdr *)handoff->page;
-  } else {
-
-    // detect openbsd
-    if (SupportsOpenbsd() && !os && !auxv[0]) {
-      os = OPENBSD;
-    }
-
-    // detect netbsd
-    if (SupportsNetbsd() && !os) {
-      for (; auxv[0]; auxv += 2) {
-        if (auxv[0] == AT_EXECFN_NETBSD) {
-          os = NETBSD;
-          break;
-        }
-      }
-    }
-
-    // default operating system
-    if (!os) {
-      os = LINUX;
-    }
-
-#if SET_EXE_FILE
-    if (IsLinux() && !relocated) {
-      char *b1 = (char *)0x200000;
-      char *b2 = (char *)0x300000;
-      void (*pApeLoader)(long, long *, char, struct ApeLoader *);
-      Mmap((long)b2, (long)(_end - ehdr), PROT_READ | PROT_WRITE | PROT_EXEC,
-           MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0, os);
-      relocated = 1;
-      MemCpy(b2, b1, (long)(_end - ehdr));
-      pApeLoader = (void *)((char *)&ApeLoader - b1 + b2);
-      pApeLoader(di, sp, dl, handoff);
-    }
-#endif
-
-    // we can load via shell, shebang, or binfmt_misc
-    if (argc >= 3 && !StrCmp(argv[1], "-")) {
-      // if the first argument is a hyphen then we give the user the
-      // power to change argv[0] or omit it entirely. most operating
-      // systems don't permit the omission of argv[0] but we do, b/c
-      // it's specified by ANSI X3.159-1988.
-      prog = (char *)sp[3];
-      argc = sp[3] = sp[0] - 3;
-      argv = (char **)((sp += 3) + 1);
-    } else if (argc < 2) {
-      Emit(os, "usage: ape   PROG [ARGV1,ARGV2,...]\n"
-               "       ape - PROG [ARGV0,ARGV1,...]\n"
-               "αcτµαlly pδrταblε εxεcµταblε loader v1.o\n"
-               "copyright 2022 justine alexandra roberts tunney\n"
-               "https://justine.lol/ape.html\n");
-      Exit(1, os);
-    } else {
-      prog = (char *)sp[2];
-      argc = sp[1] = sp[0] - 1;
-      argv = (char **)((sp += 1) + 1);
-    }
-
-    if (!(exe = Commandv(&ps, os, prog, GetEnv(envp, "PATH")))) {
-      Pexit(os, prog, 0, "not found (maybe chmod +x)");
-    } else if ((fd = Open(exe, O_RDONLY, 0, os)) < 0) {
-      Pexit(os, exe, fd, "open");
-    } else if ((rc = Read(fd, u.p, sizeof(u.p), os)) < 0) {
-      Pexit(os, exe, rc, "read");
-    } else if (rc != sizeof(u.p) && Read32(u.p) != Read32("\177ELF")) {
-      Pexit(os, exe, 0, "too small");
-    }
-
-    page = u.p;
-    eh = &u.ehdr;
-  }
-
-#if TROUBLESHOOT
-  Emit(TROUBLESHOOT_OS, "os = ");
-  Emit(TROUBLESHOOT_OS, DescribeOs(os));
-  Emit(TROUBLESHOOT_OS, "\n");
-  for (i = 0; i < argc; ++i) {
-    Emit(TROUBLESHOOT_OS, "argv = ");
-    Emit(TROUBLESHOOT_OS, argv[i]);
-    Emit(TROUBLESHOOT_OS, "\n");
-  }
-#endif
-
-  if ((IsXnu() && Read32(page) == 0xFEEDFACE + 1) ||
-      (!IsXnu() && Read32(page) == Read32("\177ELF"))) {
-    Close(fd, os);
-    Execve(exe, argv, envp, os);
-  }
-
-  // TODO(jart): Parse Mach-O for old APE binary support on XNU.
-  for (p = page; p < page + sizeof(u.p); ++p) {
-    if (Read64(p) != Read64("printf '")) continue;
-    for (i = 0, p += 8; p + 3 < page + sizeof(u.p) && (c = *p++) != '\'';) {
-      if (c == '\\') {
-        if ('0' <= *p && *p <= '7') {
-          c = *p++ - '0';
-          if ('0' <= *p && *p <= '7') {
-            c *= 8;
-            c += *p++ - '0';
-            if ('0' <= *p && *p <= '7') {
-              c *= 8;
-              c += *p++ - '0';
-            }
-          }
-        }
-      }
-      page[i++] = c;
-    }
-    if (i >= 64 && Read32(page) == Read32("\177ELF")) {
-      Spawn(os, exe, fd, sp, page, eh);
-    }
-  }
-
-  Pexit(os, exe, 0, "could not find printf elf in first page");
-}
@@ -1,20 +0,0 @@
-#ifndef COSMOPOLITAN_APE_LOADER_H_
-#define COSMOPOLITAN_APE_LOADER_H_
-
-#define APE_LOADER_BASE  0x200000
-#define APE_LOADER_SIZE  0x200000
-#define APE_LOADER_ENTRY 0x200400
-#define APE_LOADER_BSS   (PAGESIZE * 2)
-#define APE_LOADER_STACK 0x7f0000000000
-#define APE_BLOCK_BASE   0x7e0000000000
-#define APE_BLOCK_SIZE   0x000200000000
-
-struct ApeLoader {
-  int fd;
-  int os;
-  char *prog;
-  char *page;
-  void *systemcall;
-};
-
-#endif /* COSMOPOLITAN_APE_LOADER_H_ */
@@ -1,43 +0,0 @@
-/*-*- mode: ld-script; indent-tabs-mode: nil; tab-width: 2; coding: utf-8   -*-│
-│vi: set et sts=2 tw=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.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-ENTRY(_start)
-
-SECTIONS {
-  . = 0x200000;
-  .text : {
-    *(.text)
-    *(.rodata .rodata.*)
-    . = ALIGN(64);
-  }
-  filesz = . - ehdr;
-  textsz = . - _start;
-  .bss ALIGN(4096) : {
-    bss = .;
-    *(.bss)
-    . = ALIGN(4096);
-  }
-  _end = .;
-  memsz = _end - ehdr;
-  /DISCARD/ : {
-    *(.*)
-  }
-}
-
-bsssize = SIZEOF(.bss);
-textoff = _start - ehdr;
@@ -54,7 +54,7 @@
 	jmp	297f
 	.byte	0xbf			# mov $0x????xxxx,%edi
 	.long	\address
-297:
+297:	
 .endm

 //	Loads 16-bit CONSTEXPR into Qw-register w/ optional zero-extend.
@@ -180,20 +180,6 @@
 .stub	\name\()_bcs\n,long
 .endm

-//	Task State Segment Descriptor Entries.
-.macro	.tssdescstub name:req
- .ifndef \name
-  .weak	\name
-  .set	\name,0
- .endif
- .ifndef \name\()_end
-  .weak	\name\()_end
-  .set	\name\()_end,0
- .endif
- .stub	\name\()_desc_ent0,quad
- .stub	\name\()_desc_ent1,quad
-.endm
-
 /* clang-format on */
 #elif defined(__LINKER__)

@@ -235,58 +221,44 @@
 /**
 * Binary coded decimal support.
 *
- * <p>This allows linker scripts to generate dd commands, e.g. ape.lds.
- * There are a few ways to pad each number to the necessary 8 bytes.
- * Spaces cannot be prepended because busybox refuses to parse them.
- * Zeros cannot be prepended because Mac will take numbers as octal.
- * That leaves appending spaces. The user's shell ought to treat any
- * unquoted run of spaces as if there was only one, so this is safe.
+ * <p>This allows linker scripts to generate dd commands. Leading spaces
+ * need to be inserted so Mac doesn't consider them octal; therefore,
+ * parameters must be quoted; and eight digits should be good enough.
 */
-#define SHSTUB2(SYM, X)             \
-  HIDDEN(SYM##_bcs0 = BCD_LEFT(X)); \
-  HIDDEN(SYM##_bcs1 = BCD_RIGHT(X))
-#define BCD_SMEAR(X) ((X) + (X) * 10000)
-#define BCD_LEFT(X)                                      \
-  (((X)) < 10000     ? BCD_RIGHT(BCD_SMEAR(X)) | 0x10    \
-   : (X) < 100000    ? BCD_RIGHT(BCD_SMEAR((X) / 10))    \
-   : (X) < 1000000   ? BCD_RIGHT(BCD_SMEAR((X) / 100))   \
-   : (X) < 10000000  ? BCD_RIGHT(BCD_SMEAR((X) / 1000))  \
-   : (X) < 100000000 ? BCD_RIGHT(BCD_SMEAR((X) / 10000)) \
-                     : 0xffffffffffffffff)
-#define BCD_RIGHT(X) \
-  (((X)) < 10000     ? 0x20202020                  \
-   : (X) < 100000    ? 0x20202030 +                \
-                       (X) % 10                    \
-   : (X) < 1000000   ? 0x20203030 +                \
-                       ((X) / 10) % 10 +           \
-                       (X) % 10 * 0x100            \
-   : (X) < 10000000  ? 0x20303030 +                \
-                       ((X) / 100) % 10 +          \
-                       ((X) / 10) % 10 * 0x100 +   \
-                       (X) % 10 * 0x10000          \
-   : (X) < 100000000 ? 0x30303030 +                \
-                       ((X) / 1000) % 10 +         \
-                       ((X) / 100) % 10 * 0x100 +  \
-                       ((X) / 10) % 10 * 0x10000 + \
-                       (X) % 10 * 0x1000000        \
-                     : 0xffffffffffffffff)
-
-/**
- * Laying out the GDT entries for a TSS for bare metal operation.
- */
-#define TSSDESCSTUB2(SYM, BASE, LIM)                 \
-  HIDDEN(SYM##_desc_ent0 = TSSDESC_ENT0(BASE, LIM)); \
-  HIDDEN(SYM##_desc_ent1 = TSSDESC_ENT1(BASE));      \
-  ASSERT((LIM) >= 0 && (LIM) <= 0xffff, "bare metal TSS is suspiciously fat")
-#define TSSDESC_ENT0(BASE, LIM)                \
-  (((LIM)        <<  0 & 0x000000000000ffff) | \
-   ((BASE)       << 16 & 0x000000ffffff0000) | \
-    0x89         << 40                       | \
-   ((LIM)  >> 16 << 48 & 0x000f000000000000) | \
-    0x2          << 52                       | \
-   ((BASE) >> 24 << 56 & 0xff00000000000000))
-#define TSSDESC_ENT1(BASE)                     \
-   ((BASE) >> 32 <<  0 & 0x00000000ffffffff)
+#define SHSTUB2(SYM, X)           \
+  HIDDEN(SYM##_bcs0 = BCD10K(X)); \
+  HIDDEN(SYM##_bcs1 = BCD(X))
+#define BCD(X)                                                                 \
+  ((X) == 0                                                                    \
+       ? 0x20202030                                                            \
+       : (X) < 10 ? 0x30202020 + (((X) % 10) << 24)                            \
+                  : (X) < 100 ? 0x30302020 + (((X) % 10) << 24) +              \
+                                    (((X) / 10 % 10) << 16)                    \
+                              : (X) < 1000 ? 0x30303020 + (((X) % 10) << 24) + \
+                                                 (((X) / 10 % 10) << 16) +     \
+                                                 (((X) / 100 % 10) << 8)       \
+                                           : 0x30303030 + (((X) % 10) << 24) + \
+                                                 (((X) / 10 % 10) << 16) +     \
+                                                 (((X) / 100 % 10) << 8) +     \
+                                                 (((X) / 1000 % 10) << 0))
+#define BCD10K(X)                                                          \
+  ((X) < 10000                                                             \
+       ? 0x20202020                                                        \
+       : (X) < 100000                                                      \
+             ? 0x30202020 + (((X) / 10000 % 10) << 24)                     \
+             : (X) < 1000000                                               \
+                   ? 0x30302020 + (((X) / 10000 % 10) << 24) +             \
+                         (((X) / 100000 % 10) << 16)                       \
+                   : (X) < 10000000                                        \
+                         ? 0x30303020 + (((X) / 10000 % 10) << 24) +       \
+                               (((X) / 100000 % 10) << 16) +               \
+                               (((X) / 1000000 % 10) << 8)                 \
+                         : (X) < 100000000                                 \
+                               ? 0x30303030 + (((X) / 10000 % 10) << 24) + \
+                                     (((X) / 100000 % 10) << 16) +         \
+                                     (((X) / 1000000 % 10) << 8) +         \
+                                     (((X) / 10000000 % 10) << 0)          \
+                               : 0xffffffffffffffff)

 #endif /* __ASSEMBLER__ */
 #endif /* APE_MACROS_H_ */
@@ -1 +0,0 @@
-#include "ape/ape.lds"
@@ -36,8 +36,8 @@
 */
 #define REAL(x) ((x) - (IMAGE_BASE_VIRTUAL - IMAGE_BASE_REAL))

-#if IMAGE_BASE_VIRTUAL % 0x1000 != 0
-#error "IMAGE_BASE_VIRTUAL must be 4kb aligned"
+#if IMAGE_BASE_VIRTUAL % 0x200000 != 0
+#error "IMAGE_BASE_VIRTUAL must be 2mb aligned"
 #endif
 #if IMAGE_BASE_PHYSICAL % 0x1000 != 0
 #error "IMAGE_BASE_PHYSICAL must be 4kb aligned"
@@ -1,34 +0,0 @@
-#ifndef COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
-#define COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-extern unsigned char _base[];
-extern unsigned char _ehead[];
-extern unsigned char _etext[];
-extern unsigned char _edata[];
-extern unsigned char _ezip[];
-extern unsigned char _end[];
-extern unsigned char _ereal[];
-extern unsigned char _tdata_start[];
-extern unsigned char _tdata_end[];
-extern unsigned char _tbss_start[];
-extern unsigned char _tbss_end[];
-extern unsigned char __privileged_start[];
-extern unsigned char __privileged_addr[];
-extern unsigned char __privileged_size[];
-extern unsigned char __privileged_end[];
-extern unsigned char __test_start[];
-extern unsigned char __ro[];
-extern unsigned char *__relo_start[];
-extern unsigned char *__relo_end[];
-extern uint8_t __zip_start[];
-extern uint8_t __zip_end[];
-extern uint8_t __data_start[];
-extern uint8_t __data_end[];
-extern uint8_t __bss_start[];
-extern uint8_t __bss_end[];
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_APE_SECTIONS_INTERNAL_H_ */
@@ -4,35 +4,22 @@
 # Default Mode
 #
 #   - `make`
-#   - Optimized
 #   - Backtraces
-#   - Debuggable
-#   - Syscall tracing
 #   - Function tracing
 #   - Reasonably small
-#
+#   - Reasonably optimized
+#   - Reasonably debuggable
+
 ifeq ($(MODE),)
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
-CONFIG_CPPFLAGS += -DSYSDEBUG
-TARGET_ARCH ?= -msse3
-endif
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	$(FTRACE)		\
+	-Og
+
+TARGET_ARCH ?=			\
+	-msse3

-# Fast Build Mode
-#
-#   - `make MODE=fastbuild`
-#   - No debugging
-#   - Syscall tracing
-#   - Function tracing
-#   - Some optimizations
-#   - Limited Backtraces
-#   - Compiles 28% faster
-#
-ifeq ($(MODE),fastbuild)
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O
-CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
-CONFIG_OFLAGS += -g0
-CONFIG_LDFLAGS += -S
-TARGET_ARCH ?= -msse3
 endif

 # Optimized Mode
@@ -40,33 +27,25 @@ endif
 #   - `make MODE=opt`
 #   - Backtraces
 #   - More optimized
-#   - Syscall tracing
-#   - Function tracing
 #   - Reasonably small
 #   - No memory corruption detection
 #   - assert() / CHECK_xx() may leak code into binary for debuggability
 #   - GCC 8+ hoists check fails into .text.cold, thus minimizing impact
-#
-ifeq ($(MODE), opt)
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -msse2avx -Wa,-msse2avx
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O3 -fmerge-all-constants
-TARGET_ARCH ?= -march=native
-endif

-# Optimized Linux Mode
-#
-#   - `make MODE=optlinux`
-#   - Turns on red zone
-#   - Turns off backtraces
-#   - Turns off function tracing
-#   - Turns off support for older cpu models
-#   - Turns off support for other operating systems
-#
-ifeq ($(MODE), optlinux)
-CONFIG_CPPFLAGS += -DNDEBUG -msse2avx -Wa,-msse2avx -DSUPPORT_VECTOR=1
-CONFIG_CCFLAGS += -O3 -fmerge-all-constants
-DEFAULT_COPTS += -mred-zone
-TARGET_ARCH ?= -march=native
+ifeq ($(MODE), opt)
+
+CONFIG_CPPFLAGS +=		\
+	-DNDEBUG		\
+	-msse2avx		\
+	-Wa,-msse2avx
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	-O3
+
+TARGET_ARCH ?=			\
+	-march=native
+
 endif

 # Release Mode
@@ -82,12 +61,19 @@ endif
 #   - DCHECK_xx() statements removed
 #   - No memory corruption detection
 #   - CHECK_xx() won't leak strings into binary
-#
+
 ifeq ($(MODE), rel)
-CONFIG_CPPFLAGS += -DNDEBUG
-CONFIG_CCFLAGS += $(BACKTRACES) -O2
-TARGET_ARCH ?= -msse3
-PYFLAGS += -O1
+
+CONFIG_CPPFLAGS +=		\
+	-DNDEBUG
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	-O2
+
+TARGET_ARCH ?=			\
+	-msse3
+
 endif

 # Asan Mode
@@ -100,11 +86,19 @@ endif
 #   - Backtraces
 #   - Debuggability
 #   - Larger binaries
-#
+
 ifeq ($(MODE), asan)
-CONFIG_CCFLAGS += $(BACKTRACES) -O2 -DSYSDEBUG
-CONFIG_COPTS += -fsanitize=address
-TARGET_ARCH ?= -msse3
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	-O2
+
+CONFIG_COPTS +=			\
+	-fsanitize=address
+
+TARGET_ARCH ?=			\
+	-msse3
+
 endif

 # Debug Mode
@@ -116,29 +110,26 @@ endif
 #   - Stack canaries
 #   - No optimization (TODO)
 #   - Enormous binaries
-#
-ifeq ($(MODE), dbg)
-CONFIG_CPPFLAGS += -DMODE_DBG
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O -fno-inline
-CONFIG_COPTS += -fsanitize=address -fsanitize=undefined
-TARGET_ARCH ?= -msse3
-OVERRIDE_CCFLAGS += -fno-pie
-endif

-# System Five Mode
-#
-#   - `make MODE=sysv`
-#   - Optimized
-#   - Backtraces
-#   - Debuggable
-#   - Syscall tracing
-#   - Function tracing
-#   - No Windows bloat!
-#
-ifeq ($(MODE), sysv)
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
-CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
-TARGET_ARCH ?= -msse3
+ifeq ($(MODE), dbg)
+
+CONFIG_CPPFLAGS +=		\
+	-DMODE_DBG
+
+CONFIG_CCFLAGS +=		\
+	$(BACKTRACES)		\
+	$(FTRACE)		\
+	-O2
+
+CONFIG_COPTS +=			\
+	-fsanitize=address
+
+TARGET_ARCH ?=			\
+	-msse3
+
+OVERRIDE_CCFLAGS +=		\
+	-fno-pie
+
 endif

 # Tiny Mode
@@ -152,32 +143,20 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tiny)
-CONFIG_CPPFLAGS +=			\
-	-DTINY				\
-	-DNDEBUG			\
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
 	-DTRUSTWORTHY
-CONFIG_CCFLAGS +=			\
-	-Os				\
-	-fno-align-functions		\
-	-fno-align-jumps		\
-	-fno-align-labels		\
-	-fno-align-loops		\
-	-fschedule-insns2		\
-	-fomit-frame-pointer		\
-	-momit-leaf-frame-pointer	\
-	-foptimize-sibling-calls	\
-	-DDWARFLESS
-CONFIG_OFLAGS +=			\
-	-g0
-CONFIG_LDFLAGS +=			\
-	-S
-TARGET_ARCH ?=				\
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
+	-fno-align-loops
+TARGET_ARCH ?=			\
 	-msse3
-PYFLAGS +=				\
-	-O2				\
-	-B
 endif

 # Linux-Only Tiny Mode
@@ -192,27 +171,20 @@ endif
 #   - No portability
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinylinux)
-CONFIG_CPPFLAGS +=			\
-	-DTINY				\
-	-DNDEBUG			\
-	-DTRUSTWORTHY			\
-	-DSUPPORT_VECTOR=1		\
-	-DDWARFLESS
-DEFAULT_COPTS +=			\
-	-mred-zone
-CONFIG_OFLAGS +=			\
-	-g0
-CONFIG_LDFLAGS +=			\
-	-S
-CONFIG_CCFLAGS +=			\
-	-Os				\
-	-fno-align-functions		\
-	-fno-align-jumps		\
-	-fno-align-labels		\
+CONFIG_CPPFLAGS +=		\
+	-DTINY			\
+	-DNDEBUG		\
+	-DTRUSTWORTHY		\
+	-DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS +=		\
+	-Os			\
+	-fno-align-functions	\
+	-fno-align-jumps	\
+	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=				\
+TARGET_ARCH ?=			\
 	-msse3
 endif

@@ -229,20 +201,13 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinylinuxbsd)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=113	\
-	-DDWARFLESS
-DEFAULT_COPTS +=		\
-	-mred-zone
-CONFIG_OFLAGS +=		\
-	-g0
-CONFIG_LDFLAGS +=		\
-	-S
+	-DSUPPORT_VECTOR=113
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
@@ -265,26 +230,19 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinysysv)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=121	\
-	-DDWARFLESS
-DEFAULT_COPTS +=		\
-	-mred-zone
+	-DSUPPORT_VECTOR=121
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-CONFIG_OFLAGS +=		\
-	-g0
-CONFIG_LDFLAGS +=		\
-	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif
@@ -301,54 +259,27 @@ endif
 #   - No backtraces
 #   - No algorithmics
 #   - YOLO
-#
+
 ifeq ($(MODE), tinynowin)
 CONFIG_CPPFLAGS +=		\
 	-DTINY			\
 	-DNDEBUG		\
 	-DTRUSTWORTHY		\
-	-DSUPPORT_VECTOR=251	\
-	-DDWARFLESS
+	-DSUPPORT_VECTOR=251
 CONFIG_CCFLAGS +=		\
 	-Os			\
 	-fno-align-functions	\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-CONFIG_OFLAGS +=		\
-	-g0
-CONFIG_LDFLAGS +=		\
-	-S
 TARGET_ARCH ?=			\
 	-msse3
 endif

-# GCC11 Mode
-# https://justine.lol/compilers/x86_64-linux-musl__x86_64-linux-musl__g++-11.2.0.tar.xz
-ifeq ($(MODE), gcc11)
-.UNVEIL += rx:/opt/gcc11
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
-AS = /opt/gcc11/bin/x86_64-linux-musl-as
-CC = /opt/gcc11/bin/x86_64-linux-musl-gcc
-CXX = /opt/gcc11/bin/x86_64-linux-musl-g++
-CXXFILT = /opt/gcc11/bin/x86_64-linux-musl-c++filt
-LD = /opt/gcc11/bin/x86_64-linux-musl-ld.bfd
-NM = /opt/gcc11/bin/x86_64-linux-musl-nm
-GCC = /opt/gcc11/bin/x86_64-linux-musl-gcc
-STRIP = /opt/gcc11/bin/x86_64-linux-musl-strip
-OBJCOPY = /opt/gcc11/bin/x86_64-linux-musl-objcopy
-OBJDUMP = /opt/gcc11/bin/x86_64-linux-musl-objdump
-ADDR2LINE = /opt/gcc11/bin/x86_64-linux-musl-addr2line
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2 -Wno-stringop-overread
-CONFIG_CFLAGS += -Wno-old-style-definition
-CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
-TARGET_ARCH ?= -msse3
-endif
-
 # LLVM Mode
 ifeq ($(MODE), llvm)
 TARGET_ARCH ?= -msse3
-CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -DSYSDEBUG -O2
+CONFIG_CCFLAGS += $(BACKTRACES) $(FTRACE) -O2
 AS = clang
 CC = clang
 CXX = clang++
@@ -42,85 +42,62 @@
 #     ASFLAGS      assembler flags (don't use -Wa, frontend prefix)
 #     TARGET_ARCH  microarchitecture flags (e.g. -march=native)

+V ?= 1
 LC_ALL = C
 SOURCE_DATE_EPOCH = 0

+TAGS ?= /usr/bin/ctags  # emacs source builds or something breaks it
 ARFLAGS = rcsD
 ZFLAGS ?=
 XARGS ?= xargs -P4 -rs8000
 DOT ?= dot
+GZ ?= gzip
 CLANG = clang
 FC = gfortran  #/opt/cross9f/bin/x86_64-linux-musl-gfortran
-TMPDIR = o/tmp

+# see build/compile, etc. which run third_party/gcc/unbundle.sh
 AR = build/bootstrap/ar.com
-CP = build/bootstrap/cp.com
-RM = build/bootstrap/rm.com -f
-ECHO = build/bootstrap/echo.com
-TOUCH = build/bootstrap/touch.com
 PKG = build/bootstrap/package.com
 MKDEPS = build/bootstrap/mkdeps.com
 ZIPOBJ = build/bootstrap/zipobj.com
-FIXUPOBJ = build/bootstrap/fixupobj.com
-MKDIR = build/bootstrap/mkdir.com -p
-COMPILE = build/bootstrap/compile.com -V9 -P4096 $(QUOTA)
+AS = o/third_party/gcc/bin/x86_64-linux-musl-as
+CC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
+CXX = o/third_party/gcc/bin/x86_64-linux-musl-g++
+CXXFILT = o/third_party/gcc/bin/x86_64-linux-musl-c++filt
+LD = o/third_party/gcc/bin/x86_64-linux-musl-ld.bfd
+NM = o/third_party/gcc/bin/x86_64-linux-musl-nm
+GCC = o/third_party/gcc/bin/x86_64-linux-musl-gcc
+STRIP = o/third_party/gcc/bin/x86_64-linux-musl-strip
+OBJCOPY = o/third_party/gcc/bin/x86_64-linux-musl-objcopy
+OBJDUMP = o/third_party/gcc/bin/x86_64-linux-musl-objdump
+ADDR2LINE = o/third_party/gcc/bin/x86_64-linux-musl-addr2line

 COMMA := ,
-PWD := $(shell build/bootstrap/pwd.com)
+PWD := $(shell pwd)
 IMAGE_BASE_VIRTUAL ?= 0x400000
-
-IGNORE := $(shell $(ECHO) -2 ♥cosmo)
-IGNORE := $(shell $(MKDIR) o/tmp)
-
-ifneq ("$(wildcard o/third_party/gcc/bin/x86_64-pc-linux-gnu-*)","")
-PREFIX = o/third_party/gcc/bin/x86_64-pc-linux-gnu-
-else
-IGNORE := $(shell build/bootstrap/unbundle.com)
-PREFIX = o/third_party/gcc/bin/x86_64-linux-musl-
-endif
-
-AS = $(PREFIX)as
-CC = $(PREFIX)gcc
-CXX = $(PREFIX)g++
-CXXFILT = $(PREFIX)c++filt
-LD = $(PREFIX)ld.bfd
-NM = $(PREFIX)nm
-GCC = $(PREFIX)gcc
-STRIP = $(PREFIX)strip
-OBJCOPY = $(PREFIX)objcopy
-OBJDUMP = $(PREFIX)objdump
-ADDR2LINE = $(PWD)/$(PREFIX)addr2line
+HELLO := $(shell build/hello)
+TMPDIR := $(shell build/findtmp)
+SPAWNER := $(shell build/getcompile) -V$(shell build/getccversion $(CC))
+COMPILE = $(SPAWNER) $(QUOTA)

 export ADDR2LINE
 export LC_ALL
-export MKDIR
 export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
-
-ifeq ($(LANDLOCKMAKE_VERSION),)
-TMPSAFE = $(TMPDIR)/$(subst /,_,$@).tmp
-else
-TMPSAFE = $(TMPDIR)/
-endif
+export V

 FTRACE =								\
 	-pg

-BACKTRACES =								\
-	-fno-schedule-insns2						\
-	-fno-omit-frame-pointer						\
-	-fno-optimize-sibling-calls					\
-	-mno-omit-leaf-frame-pointer
-
 SANITIZER =								\
 	-fsanitize=address

 NO_MAGIC =								\
 	-mno-fentry							\
 	-fno-stack-protector						\
-	-fwrapv								\
-	-fno-sanitize=all
+	-fno-sanitize=all						\
+	-fwrapv

 OLD_CODE =								\
 	-fno-strict-aliasing						\
@@ -134,12 +111,11 @@ TRADITIONAL =								\
 DEFAULT_CCFLAGS =							\
 	-Wall								\
 	-Werror								\
-	-fdebug-prefix-map='$(PWD)'=					\
+	-fdebug-prefix-map="$(PWD)"=					\
 	-frecord-gcc-switches

 DEFAULT_OFLAGS =							\
 	-g								\
-	-gdwarf-4							\
 	-gdescribe-dies

 DEFAULT_COPTS =								\
@@ -152,8 +128,9 @@ DEFAULT_COPTS =								\
 	-fno-gnu-unique							\
 	-fstrict-aliasing						\
 	-fstrict-overflow						\
+	-fno-omit-frame-pointer						\
 	-fno-semantic-interposition					\
-	-mno-tls-direct-seg-refs
+	-mno-omit-leaf-frame-pointer

 MATHEMATICAL =								\
 	-O3								\
@@ -164,19 +141,19 @@ DEFAULT_CPPFLAGS =							\
 	-DMODE='"$(MODE)"'						\
 	-DIMAGE_BASE_VIRTUAL=$(IMAGE_BASE_VIRTUAL)			\
 	-nostdinc							\
-	-iquote .
+	-iquote.

 DEFAULT_CFLAGS =							\
 	-std=gnu2x

 DEFAULT_CXXFLAGS =							\
+	-std=gnu++11							\
 	-fno-rtti							\
 	-fno-exceptions							\
 	-fuse-cxa-atexit						\
 	-fno-threadsafe-statics						\
 	-Wno-int-in-bool-context					\
-	-Wno-narrowing							\
-	-Wno-literal-suffix
+	-Wno-narrowing

 DEFAULT_ASFLAGS =							\
 	-W								\
@@ -187,22 +164,19 @@ DEFAULT_ASFLAGS =							\
 DEFAULT_LDFLAGS =							\
 	-static								\
 	-nostdlib							\
-	-melf_x86_64							\
+	-m elf_x86_64							\
 	--gc-sections							\
 	--build-id=none							\
 	--no-dynamic-linker						\
-	-zmax-page-size=0x1000 #--cref [email protected]
+	-z max-page-size=0x1000

 ZIPOBJ_FLAGS =								\
 	 -b$(IMAGE_BASE_VIRTUAL)

-PYFLAGS =								\
-	 -b$(IMAGE_BASE_VIRTUAL)
-
 ASONLYFLAGS =								\
 	-c								\
 	-g								\
-	--debug-prefix-map='$(PWD)'=
+	--debug-prefix-map="$(PWD)"=

 DEFAULT_LDLIBS =

@@ -323,9 +297,6 @@ OBJECTIFY.greg.c =							\
 	-fno-instrument-functions					\
 	-fno-optimize-sibling-calls					\
 	-fno-sanitize=all						\
-	-ffreestanding							\
-	-mno-fentry							\
-	-fwrapv								\
 	-c

 OBJECTIFY.ansi.c = $(CC) $(OBJECTIFY.c.flags) -ansi -Wextra -Werror -pedantic-errors -c
@@ -0,0 +1,17 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# OVERVIEW
+#
+#   Temporary Directory Discovery
+#
+# DESCRIPTION
+#
+#   We call this script once per build to ideally find a folder that's
+#   backed by an in-memory file system. We then export it to the TMPDIR
+#   environment variable. Many programs use it under the hood, e.g. gcc,
+#   so it grants many small performance improvements.
+
+mkdir -p o/tmp
+echo o/tmp
@@ -12,9 +12,5 @@

 tail = $(wordlist 2,$(words $1),$1)
 reverse = $(if $1,$(call reverse,$(call tail,$1)) $(firstword $1))
-uniqr = $(if $1,$(call uniqr,$(filter-out $(firstword $1),$1)) $(firstword $1))
-
-# polyfill uniq native (landlock make 1.4)
-ifneq ($(call uniq,c b c a),c b a)
 uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))
-endif
+uniqr = $(if $1,$(call uniqr,$(filter-out $(firstword $1),$1)) $(firstword $1))
@@ -0,0 +1,39 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# OVERVIEW
+#
+#   Compiler Version Discovery
+#
+# DESCRIPTION
+#
+#   Cosmopolitan itself may be built using either GCC and Clang, and our
+#   build irons out many of the differences between the two. This script
+#   is used by build/definitions.mk alongside build/getccname to support
+#   the different versions folks use.
+#
+#   Our aim is to support GCC 4.2.1+ since that's the last GPLv2 version
+#   with any sort of industry consensus. Please note, Cosmopolitan never
+#   links GCC runtimes when using later versions, so some concerns might
+#   not apply.
+
+if [ ! -d o/third_party/gcc ]; then
+  third_party/gcc/unbundle.sh
+fi
+
+set -e
+
+MAJOR_VERSION=$(
+  $1 --version |
+    head -n1 |
+    sed -n '
+        s!^[^(]*([^)]*) \([[:digit:]][[:digit:]]*\).*!\1!p
+        s!^.*clang.*version \([[:digit:]][[:digit:]]*\).*!\1!p
+      ')
+
+if [ -z "$MAJOR_VERSION" ]; then
+  echo 6
+else
+  printf '%s\n' "$MAJOR_VERSION"
+fi
@@ -0,0 +1,12 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+
+if ! [ o/build/bootstrap/compile.com -nt build/bootstrap/compile.com ]; then
+  mkdir -p o/build/bootstrap/
+  cp -f build/bootstrap/compile.com o/build/bootstrap/compile.$$.com
+  o/build/bootstrap/compile.$$.com -n
+  mv -f o/build/bootstrap/compile.$$.com o/build/bootstrap/compile.com
+fi
+
+echo o/build/bootstrap/compile.com
@@ -0,0 +1,20 @@
+#!/bin/sh
+#-*-mode:sh;indent-tabs-mode:nil;tab-width:2;coding:utf-8-*-┐
+#───vi: set net ft=sh ts=2 sts=2 fenc=utf-8 :vi─────────────┘
+#
+# SYNOPSIS
+#
+#   HELLO BUILD
+#
+# OVERVIEW
+#
+#   We generate a line at the start of each Makefile run, because if we
+#   use `make V=0` mode then the terminal logging trick we use in
+#   tool/build/compile.c will delete the previous line, and we'd rather
+#   have that line not be the bash prompt that ran make.
+#
+#   This script is also useful for giving us an indicator each time the
+#   build restarts itself from scratch, which can happen in cases like
+#   when dependencies need to be regenerated by tool/build/mkdeps.c
+
+echo ♥cosmo >&2
@@ -43,19 +43,12 @@
 #     '(progn
 #        (add-hook 'c-mode-common-hook 'jart-c-mode-common-hook)))

-TAGS="$1"
-shift
-
-# ctags doesn't understand atomics, e.g.
-#   extern char **environ;
-set -- --regex-c='/_Atomic(\([^)]*\))/\1/b' "$@"
-
 # ctags doesn't understand variable prototypes, e.g.
 #   extern char **environ;
 set -- --regex-c='/^\(\(hidden\|extern\|const\) \)*[_[:alpha:]][_[:alnum:]]*[ *][ *]*\([_[:alpha:]][_[:alnum:]]*[ *][ *]*\)*\([_[:alpha:]][_$[:alnum:]]*\)/\4/b' "$@"

 # ctags doesn't understand function prototypes, e.g.
-#   bool isheap(void *p) dontthrow nocallback;
+#   bool isheap(void *p) nothrow nocallback;
 set -- --regex-c='/^[_[:alpha:]][_[:alnum:]]*[ *][ *]*\([_[:alpha:]][_[:alnum:]]*[ *][ *]*\)*\([_[:alpha:]][_$[:alnum:]]*\)(.*/\2/b' "$@"

 # ctags doesn't understand function pointers, e.g.
@@ -66,7 +59,7 @@ set -- --regex-c='/^extern [^(]*(\*const \([^)]*\))(/\1/b' "$@"
 #   struct WorstSoftwareEver;
 set -- --regex-c='/^struct.*;$/uehocruehcroue/b' "$@"

-exec $TAGS                                                        \
+exec ${TAGS:-ctags}                                               \
     -e                                                           \
     --langmap=c:.c.h                                             \
     --exclude=libc/nt/struct/imagefileheader.internal.h          \
@@ -23,9 +23,8 @@
 #   - tool/build/runitd.c

 .PRECIOUS: o/$(MODE)/%.com.ok
-o/$(MODE)/%.com.ok: .PLEDGE = stdio rpath wpath cpath proc fattr inet
 o/$(MODE)/%.com.ok:				\
 		o/$(MODE)/tool/build/runit.com	\
 		o/$(MODE)/tool/build/runitd.com	\
 		o/$(MODE)/%.com
-	@$(COMPILE) -wATEST -tT$@ $^ $(HOSTS)
+	@$(COMPILE) -ATEST -tT$@ $^ $(HOSTS)
@@ -16,210 +16,70 @@

 MAKEFLAGS += --no-builtin-rules

+o/%.a:                             ; @$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ $^
 o/%.o: %.s                         ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
 o/%.o: o/%.s                       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
 o/%.s: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/%.s: o/%.S                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/%.i: %.S                         ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/%.o: %.S                         ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
 o/%.o: o/%.S                       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/%.s: %.i                         ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.s: o/%.i                       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/%.o: %.cc                        ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/%.o: o/%.cc                      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
 o/%.lds: %.lds                     ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
 o/%.inc: %.h                       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) -D__ASSEMBLER__ -P $<
+o/%.pkg:                           ; @$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
+o/%.h.ok: %.h                      ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -x c -g0 -o $@ $<
+o/%.h.okk: %.h                     ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -x c++ -g0 -o $@ $<
 o/%.greg.o: %.greg.c               ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/%.zip.o: o/%                     ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<

+o/$(MODE)/%.a:                     ; @$(COMPILE) -AARCHIVE -T$@ $(AR) $(ARFLAGS) $@ $^
 o/$(MODE)/%: o/$(MODE)/%.dbg       ; @$(COMPILE) -AOBJCOPY -T$@ $(OBJCOPY) -S -O binary $< $@
 o/$(MODE)/%.o: %.s                 ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: o/$(MODE)/%.s       ; @$(COMPILE) -AOBJECTIFY.s $(OBJECTIFY.s) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.S       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: %.c                 ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.f                 ; @$(COMPILE) -AOBJECTIFY.f $(OBJECTIFY.f) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.F                 ; @$(COMPILE) -AOBJECTIFY.F $(OBJECTIFY.F) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.c       ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: %.c                ; @$(COMPILE) -ACOMPILE.c $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ss: o/$(MODE)/%.c      ; @$(COMPILE) -AOBJECTIFY.s $(COMPILE.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.S                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.c                 ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: %.cc                ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.i: o/$(MODE)/%.c       ; @$(COMPILE) -APREPROCESS $(PREPROCESS) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.h: %.c                 ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
 o/$(MODE)/%.h: o/$(MODE)/%.c       ; @$(COMPILE) -AAMALGAMATE $(PREPROCESS) $(OUTPUT_OPTION) -fdirectives-only -P $<
 o/$(MODE)/%.o: %.S                 ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: o/$(MODE)/%.S       ; @$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: %.i                 ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.s: o/$(MODE)/%.i       ; @$(COMPILE) -ACOMPILE.i $(COMPILE.i) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.o: %.cc                ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.o: o/$(MODE)/%.cc      ; @$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.lds: %.lds             ; @$(COMPILE) -APREPROCESS $(PREPROCESS.lds) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.h.ok: %.h              ; @$(COMPILE) -ACHECK.h $(COMPILE.c) -x c -g0 -o $@ $<
+o/$(MODE)/%.h.okk: %.h             ; @$(COMPILE) -ACHECK.h $(COMPILE.cxx) -x c++ -g0 -o $@ $<
 o/$(MODE)/%.o: %.greg.c            ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.greg.o: %.greg.c       ; @$(COMPILE) -AOBJECTIFY.greg $(OBJECTIFY.greg.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.ansi.c       ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.ansi.o: %.c            ; @$(COMPILE) -AOBJECTIFY.ansi $(OBJECTIFY.ansi.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c99.o: %.c99.c         ; @$(COMPILE) -AOBJECTIFY.c99 $(OBJECTIFY.c99.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c11.o: %.c11.c         ; @$(COMPILE) -AOBJECTIFY.c11 $(OBJECTIFY.c11.c) $(OUTPUT_OPTION) $<
+o/$(MODE)/%.c2x.o: %.c2x.c         ; @$(COMPILE) -AOBJECTIFY.c2x $(OBJECTIFY.c2x.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.initabi.o: %.initabi.c ; @$(COMPILE) -AOBJECTIFY.init $(OBJECTIFY.initabi.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.ncabi.o: %.ncabi.c     ; @$(COMPILE) -AOBJECTIFY.nc $(OBJECTIFY.ncabi.c) $(OUTPUT_OPTION) $<
 o/$(MODE)/%.real.o: %.c            ; @$(COMPILE) -AOBJECTIFY.real $(OBJECTIFY.real.c) $(OUTPUT_OPTION) $<
-
-o/%.o: %.cc
-	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/%.o: o/%.cc
-	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.o: %.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.o: o/$(MODE)/%.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/$(MODE)/%.o: o/$(MODE)/%.cc
-	@$(COMPILE) -AOBJECTIFY.cxx $(OBJECTIFY.cxx) $(OUTPUT_OPTION) $<
-	@$(COMPILE) -AFIXUPOBJ -wT$@ $(FIXUPOBJ) $@
-
-o/%.a:
-	$(file >$(TMPDIR)/$(subst /,_,$@),$^)
-	@$(COMPILE) -AARCHIVE -wT$@ $(AR) $(ARFLAGS) $@ @$(TMPDIR)/$(subst /,_,$@)
-
-o/%.pkg:
-	$(file >$(TMPSAFE).args,$(filter %.o,$^))
-	@$(COMPILE) -APACKAGE -wT$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$(TMPSAFE).args
-
-o/$(MODE)/%.pkg:
-	$(file >$(TMPSAFE).args,$(filter %.o,$^))
-	@$(COMPILE) -APACKAGE -wT$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) @$(TMPSAFE).args
-
-o/$(MODE)/%.o: %.py o/$(MODE)/third_party/python/pyobj.com
-	@$(COMPILE) -wAPYOBJ o/$(MODE)/third_party/python/pyobj.com $(PYFLAGS) -o $@ $<
-
-o/$(MODE)/%.pyc: %.py o/$(MODE)/third_party/python/pycomp.com
-	@$(COMPILE) -wAPYCOMP o/$(MODE)/third_party/python/pycomp.com $(PYCFLAGS) -o $@ $<
+o/$(MODE)/%.runs: o/$(MODE)/%      ; @$(COMPILE) -ACHECK -tT$@ $< $(TESTARGS)
+o/$(MODE)/%.pkg:                   ; @$(COMPILE) -APACKAGE -T$@ $(PKG) $(OUTPUT_OPTION) $(addprefix -d,$(filter %.pkg,$^)) $(filter %.o,$^)
+o/$(MODE)/%.zip.o: %               ; @$(COMPILE) -AZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
+o/$(MODE)/%-gcc.asm: %.c           ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+o/$(MODE)/%-clang.asm: %.c         ; @$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $< || echo / need $(CLANG) >$@

 o/$(MODE)/%.lua: %.lua o/$(MODE)/third_party/lua/luac.com
-	@$(COMPILE) -wALUAC o/$(MODE)/third_party/lua/luac.com -s -o $@ $<
-
-o/$(MODE)/%.lua.runs: %.lua o/$(MODE)/tool/net/redbean.com
-	@$(COMPILE) -wALUA -tT$@ o/$(MODE)/tool/net/redbean.com $(LUAFLAGS) -i $<
-
-o/$(MODE)/%: o/$(MODE)/%.com o/$(MODE)/tool/build/cp.com o/$(MODE)/tool/build/assimilate.com
-	@$(COMPILE) -wACP -T$@ o/$(MODE)/tool/build/cp.com $< $@
-	@$(COMPILE) -wAASSIMILATE -T$@ o/$(MODE)/tool/build/assimilate.com $@
-
-################################################################################
-# LOCAL UNIT TESTS
-#
-# We always run unit tests as part of the normal `make` invocation. you
-# may override the $(TESTARGS) variable to do things such as enable the
-# benchmarking feature. For example:
-#
-#     TESTARGS = -b
-#
-# May be specified in your ~/.cosmo.mk file. You can also use this to
-# enable things like function tracing. For example:
-#
-#     TESTARGS = ----ftrace
-#     .PLEDGE += prot_exec
-#
-# You could then run a command like:
-#
-#     make -j8 o//test/libc/calls/openbsd_test.com.runs
-#
-# You need PROT_EXEC permission since ftrace morphs the binary. It's
-# also worth mentioning that the pledge.com command can simulate what
-# Landlock Make does:
-#
-#     o//tool/build/pledge.com \
-#       -v. -p 'stdio rpath wpath cpath tty prot_exec' \
-#       o//test/libc/calls/openbsd_test.com \
-#       ----ftrace
-#
-# This is useful in the event a test binary should run by itself, but
-# fails to run beneath Landlock Make. It's also useful sometimes to
-# override the verbosity when running tests:
-#
-#     make V=5 TESTARGS=-b o//test/libc/calls/openbsd_test.com.runs
-#
-# This way, if for some reason a test should fail but calls exit(0),
-# then the stdout/stderr output, which would normally be suppressed,
-# will actually be displayed.
-
-o/$(MODE)/%.runs: o/$(MODE)/%
-	@$(COMPILE) -ACHECK -wtT$@ $< $(TESTARGS)
-
-################################################################################
-# ELF ZIP FILES
-#
-# zipobj.com lets us do fast incremental linking of compressed data.
-# it's nice because if we link a hundred binaries that use the time zone
-# database, then that database only needs to be DEFLATE'd once.
-
-o/%.zip.o: o/%
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-# an issue with sandboxing arises when creating directory entries in the
-# zip file. we need the trailing slash (e.g. o//foo/.zip.o) but Landlock
-# Make avoids sandboxing directory names that have a trailing slash (so
-# they can be used to watch for deleted files, without creating overly
-# broad unveiling). such rules need to be written more explicitly.
-o/$(MODE)%/.zip.o: %
-	@$(COMPILE) -wAZIPOBJ $(ZIPOBJ) $(ZIPOBJ_FLAGS) $(OUTPUT_OPTION) $<
-
-################################################################################
-# STRICT HEADER CHECKING
-#
-# these rules are unsandboxed since they're already a sandboxing test,
-# and it would be too costly in terms of make latency to have every
-# header file depend on $(HDRS) and $(INCS).
-
-o/%.h.ok: private .UNSANDBOXED = 1
-o/%.h.ok: %.h
-	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
-
-o/$(MODE)/%.h.ok: private .UNSANDBOXED = 1
-o/$(MODE)/%.h.ok: %.h
-	@$(COMPILE) -ACHECK.h $(COMPILE.c) -xc -g0 -o $@ $<
-
-o/$(MODE)/%.hh.ok: private .UNSANDBOXED = 1
-o/$(MODE)/%.hh.ok: %.hh
-	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-
-o/%.okk: .UNSANDBOXED = 1
-o/%.okk: %
-	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-
-o/$(MODE)/%.okk: private .UNSANDBOXED = 1
-o/$(MODE)/%.okk: %
-	@$(COMPILE) -ACHECK.h $(COMPILE.cxx) -xc++ -g0 -o $@ $<
-
-################################################################################
-# EXECUTABLE HELPERS
-
-MAKE_OBJCOPY =					\
-	$(COMPILE) -AOBJCOPY -T$@		\
-	$(OBJCOPY) -S -O binary $< $@
-
-MAKE_SYMTAB_CREATE =				\
-	$(COMPILE) -wASYMTAB			\
-	o/$(MODE)/tool/build/symtab.com		\
-	-o $(TMPSAFE)/.symtab			\
-	$<
-
-MAKE_SYMTAB_ZIP =				\
-	$(COMPILE) -AZIP -T$@			\
-	o/$(MODE)/third_party/zip/zip.com	\
-	-b$(TMPDIR)				\
-	-9qj					\
-	$@					\
-	$(TMPSAFE)/.symtab
-
-################################################################################
-# EMACS ASSEMBLY GENERATION
-
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-gcc.asm: %.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%-gcc.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-gcc.asm: %.cc
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
-
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-clang.asm: %.c
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.c) -S -g0 $(OUTPUT_OPTION) $<
+	@$(COMPILE) -ALUAC -T$@ o/$(MODE)/third_party/lua/luac.com -s -o $@ $<

 o/$(MODE)/%-clang.asm: CC = $(CLANG)
-o/$(MODE)/%-clang.asm: private .UNSANDBOXED = 1
-o/$(MODE)/%-clang.asm: %.cc
-	@$(COMPILE) -AOBJECTIFY.c $(OBJECTIFY.cxx) -S -g0 $(OUTPUT_OPTION) $<
@@ -27,37 +27,29 @@ EOF
  exit 1
 fi

-if [ ! -f /proc/sys/fs/binfmt_misc/status ]; then
-  exit 0
-fi
-
-if ! build/bootstrap/echo.com -n; then
+build/sanitycheck2
+if [ $? -ne 123 ]; then
  cat <<'EOF' >&2

 ERROR

-  APE Execution error.
+  Thompson Shell Backwards Compatibility Issue Detected

 DETAILS

-  Your system has probably been configured to use binfmt_misc. You need
-  to run the command below to install /usr/bin/ape and register it with
-  binfmt_misc. See ape/loader.c for source code, and technical details.
+  Actually Portable Executable assumes stock Linux configuration.
+  Normal behavior is non-ELF files with x bit are run by /bin/sh.
+  Linux lets people globally define arbitrary magic interpreters.
+  Your computer couldve been tuned to run MZ scripts inside WINE.
+  So if you use binfmt_misc you need to explicitly register this.

 WORKAROUND

-  ape/apeinstall.sh
-
-NOTES
-
-  If it still doesn't work, possibly due to an overly aggressive WINE
-  or WSL registration, or possibly due to the ordering of definitions,
-  then one troubleshooting step is to just unregister everything using
-  sudo sh -c 'echo -1 >/proc/sys/fs/binfmt_misc/status' and try again.
+  sudo sh -c "echo ':APE:M::MZqFpD::/bin/sh:' >/proc/sys/fs/binfmt_misc/register"

 SEE ALSO

-  https://justine.lol/ape.html
+  https://justine.storage.googleapis.com/ape.html

 EOF
  kill $1
@@ -0,0 +1,9 @@
+MZqFpD=123
+exit $MZqFpD
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+                                                                                
+ 
@@ -40,11 +40,11 @@ $(DSP_BMP_A).pkg:				\
 		$(foreach x,$(DSP_BMP_A_DIRECTDEPS),$($(x)_A).pkg)

 o/$(MODE)/dsp/bmp/float2short.o			\
-o/$(MODE)/dsp/bmp/scalevolume.o: private	\
+o/$(MODE)/dsp/bmp/scalevolume.o:		\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

-o/tiny/dsp/bmp/scalevolume.o: private		\
+o/tiny/dsp/bmp/scalevolume.o:			\
 		OVERRIDE_CFLAGS +=		\
 			-Os

@@ -1,46 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net 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"
-
-/**
- * Compresses 16-bit signed linear audio sample with a-Law.
- *
- * @param x is clamped to 16-bits of which the top 14 are considered
- * @return coded number in range [0..255]
- * @see ITU G.711
- */
-int alaw(int x) {
-  int a, b, e, i;
-  if ((a = x) < 0) a = ~a;
-  a >>= 4;
-  if (a > 15) {
-    if ((i = a >> 5)) {
-      b = (__builtin_clz(i) ^ 31) + 1;
-      a >>= b;
-      a -= 16;
-      a += (b + 1) << 4;
-    } else {
-      e = 1;
-      a -= 16;
-      a += 16;
-    }
-  }
-  if (x >= 0) a |= 128;
-  return a ^ 85;
-}
@@ -22,7 +22,7 @@
 void *byte2double(long n, const void *p, double weight, double bias) {
  long i;
  double f, *dst;
-  const unsigned char *src;
+  unsigned char *src;
  if ((dst = valloc(n * sizeof(double)))) {
    for (src = p, i = 0; i < n; ++i) {
      f = src[i];
@@ -3,19 +3,23 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

-int alaw(int);
-int unalaw(int);
+/**
+ * @fileoverview Cosmopolitan Digital Signal Processing.
+ */
+
 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[8][8], float, float, float, float, float);
 void *dctjpeg(float[8][8]);
+
 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]);
+
 double rgb2stdtv(double) pureconst;
 double rgb2lintv(double) pureconst;
 double rgb2stdpc(double, double) pureconst;
@@ -47,15 +47,15 @@ o/$(MODE)/dsp/core/c1331.o			\
 o/$(MODE)/dsp/core/magikarp.o			\
 o/$(MODE)/dsp/core/c93654369.o			\
 o/$(MODE)/dsp/core/float2short.o		\
-o/$(MODE)/dsp/core/scalevolume.o: private	\
+o/$(MODE)/dsp/core/scalevolume.o:		\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

-o/tiny/dsp/core/scalevolume.o: private		\
+o/tiny/dsp/core/scalevolume.o:			\
 		OVERRIDE_CFLAGS +=		\
 			-Os

-o/$(MODE)/dsp/core/det3.o: private		\
+o/$(MODE)/dsp/core/det3.o:			\
 		OVERRIDE_CFLAGS +=		\
 			-ffast-math

@@ -21,7 +21,7 @@
 #define DCT(A, B, C, D, E, F, G, H, T, C0, C1, C2, C3, C4)    \
  do {                                                        \
    T z1, z2, z3, z4, z5, z11, z13;                           \
-    T t0, t1, t2, t3, t4, t5, t6, t7, t10, t11, t12, t13;     \
+    T t0, t1, t2, t3, t4, t5, t6, t7, t8, t10, t11, t12, t13; \
    t0 = A + H;                                               \
    t7 = A - H;                                               \
    t1 = B + G;                                               \
@@ -30,6 +30,7 @@
 */
 void float2short(size_t n, short pcm16[n][8], const float binary32[n][8]) {
  size_t i, j;
+  float f[8], w[8];
  for (i = 0; i < n; ++i) {
    for (j = 0; j < 8; ++j) {
      pcm16[i][j] =
@@ -0,0 +1,63 @@
+/*-*- 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 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"
+
+#define BIAS 0x84
+
+//	Encodes audio sample with µ-Law.
+//
+//	This is both the highest quality and most widely supported
+//	telephony codec, whose use was phased out in the 2000's in
+//	favor of cost-saving GSM audio compression that was so bad
+//	consumers were willing to pay more cash, for the privilege
+//	of saving telcos even more money w/ text messaging. Mu Law
+//	reduces PCM data to half its original size, by diminishing
+//	audio bands not vocalized by human voice.
+//
+//	@param	%edi is pcm sample
+//	@return	%eax is uint8_t encoded sample
+mulaw:	.leafprologue
+	.profilable
+	mov	$BIAS,%eax
+	xor	%edx,%edx
+	test	%edi,%edi
+	js	1f
+	lea	(%edi,%eax),%eax
+	mov	$0xFF,%dl
+	jmp	2f
+1:	sub	%edi,%eax
+	mov	$0x7F,%dl
+2:	mov	%eax,%esi
+	or	$0xFF,%sil
+	bsr	%esi,%esi
+	sub	$7,%esi
+	cmp	$8,%esi
+	jge	4f
+	lea	3(%rdx),%ecx
+	sar	%cl,%eax
+	and	$0xF,%eax
+	shl	$4,%esi
+	or	%esi,%eax
+	xor	%edx,%eax
+3:	.leafepilogue
+4:	xor	$0x7F,%dl
+	mov	%edx,%eax
+	jmp	3b
+	.endfn	mulaw,globl
+	.source	__FILE__
@@ -1,40 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net 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"
-
-/**
- * Compresses 16-bit signed linear audio sample with μ-Law.
- *
- * @param x is clamped to 16-bits of which the top 14 are considered
- * @return coded number in range [0..255]
- * @see ITU G.711
- */
-int mulaw(int x) {
-  int b, i, a, s, l, h;
-  a = x < 0 ? (~x >> 2) + 33 : (x >> 2) + 33;
-  if (a > 8191) a = 8191;
-  i = a >> 6;
-  s = i ? (__builtin_clz(i) ^ 31) + 2 : 1;
-  h = 8 - s;
-  l = (a >> s) & 15;
-  l = 15 - l;
-  b = (h << 4) | l;
-  if (x >= 0) b |= 128;
-  return b;
-}
@@ -37,3 +37,4 @@ sad16x8n:
 	jnz	0b
 1:	.leafepilogue
 	.endfn	sad16x8n,globl,hidden
+	.source	__FILE__
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/intrin/bits.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/bits/bits.h"
+#include "libc/bits/safemacros.internal.h"
 #include "libc/limits.h"

 /**
@@ -1,38 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net 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"
-
-/**
- * Expands a-Law coded to audio sample.
- *
- * @param x is coded number masked to range [0..255]
- * @return 16-bit signed linear audio sample
- * @note generate lut to save 2 cycles
- * @see ITU G.711
- */
-int unalaw(int x) {
-  int e, i, m;
-  i = (x ^ 85) & 127;
-  e = i >> 4;
-  m = i & 15;
-  if (e > 0) m += 16;
-  m = (m << 4) + 8;
-  if (e > 1) m = m << (e - 1);
-  return x & 128 ? m : -m;
-}
@@ -1,37 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│vi: set net 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/intrin/likely.h"
-
-/**
- * Expands μ-Law coded to audio sample.
- *
- * @param x is coded number masked to range [0..255]
- * @return 16-bit signed linear audio sample
- * @note generate lut to save 2 cycles
- * @see ITU G.711
- */
-int unmulaw(int x) {
-  int e, m, k, s;
-  e = (~x >> 4) & 7;
-  m = ~x & 15;
-  k = 4 << (e + 1);
-  s = (128 << e) + k * m + k / 2 - 4 * 33;
-  return x & 128 ? s : -s;
-}
@@ -37,10 +37,10 @@ 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,
+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
+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().

@@ -51,11 +51,11 @@ 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
+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*
+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:
@@ -85,7 +85,7 @@ mat4 rec601 = mat4(
 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
+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.

@@ -67,7 +67,7 @@ plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done) {

 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));
+	b = memalign(alignof(plm_buffer_t), sizeof(plm_buffer_t));
 	memset(b, 0, sizeof(plm_buffer_t));
 	b->capacity = length;
 	b->length = length;
@@ -79,7 +79,7 @@ plm_buffer_t *plm_buffer_create_with_memory(unsigned char *bytes, size_t length,

 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));
+	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;
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/macros.internal.h"
+.source	__FILE__

 clamp4int256$core:
 	.leafprologue
@@ -115,8 +115,8 @@ plm_packet_t *plm_demux_decode(plm_demux_t *self) {
 	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_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);
@@ -273,11 +273,11 @@ 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_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));
+	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;
@@ -345,7 +345,7 @@ plm_samples_t *plm_audio_decode(plm_audio_t *self) {
 	self->samples.time = self->time;

 	self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->time = (double)self->samples_decoded /
+	self->time = (double)self->samples_decoded / 
 		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];

 	return &self->samples;
@@ -402,7 +402,7 @@ int plm_audio_decode_header(plm_audio_t *self) {
 		plm_buffer_skip(self->buffer, 16);
 	}

-	// Compute frame size, check if we have enough data to decode the whole
+	// 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];
@@ -561,7 +561,7 @@ void plm_audio_decode_frame(plm_audio_t *self) {
 						}
 					#else
 						for (int j = 0; j < 32; j++) {
-							self->samples.interleaved[((out_pos + j) << 1) + ch] =
+							self->samples.interleaved[((out_pos + j) << 1) + ch] = 
 								self->U[j] / 2147418112.0f;
 						}
 					#endif
@@ -37,7 +37,8 @@ DSP_MPEG_A_DIRECTDEPS =				\
 	LIBC_STUBS				\
 	LIBC_SYSV				\
 	LIBC_TIME				\
-	LIBC_TINYMATH
+	LIBC_TINYMATH				\
+	LIBC_UNICODE

 DSP_MPEG_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x))))
@@ -50,10 +51,13 @@ $(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/clamp4int256-k8.o:		\
 		OVERRIDE_CFLAGS +=		\
 			-Os

+#o/$(MODE)/dsp/mpeg/macroblock.o:		\
+		CC = $(CLANG)
+
 DSP_MPEG_LIBS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)))
 DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS))
 DSP_MPEG_HDRS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_HDRS))
@@ -32,7 +32,7 @@
 #include "dsp/mpeg/idct.h"
 #include "dsp/mpeg/mpeg.h"
 #include "dsp/mpeg/video.h"
-#include "libc/intrin/initializer.internal.h"
+#include "libc/bits/initializer.internal.h"
 #include "libc/fmt/conv.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
@@ -72,8 +72,7 @@ static const float PLM_VIDEO_PIXEL_ASPECT_RATIO[] = {
    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,
-};
+    1.0255, 1.0695, 1.0950, 1.1575, 1.2051};

 static const float PLM_VIDEO_PICTURE_RATE[] = {
    23.976, /* NTSC-Film */
@@ -592,24 +591,24 @@ void plm_video_decode_sequence_header(plm_video_t *self) {

  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);
+  LOGF("%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,
@@ -1083,7 +1082,7 @@ static plm_frame_t *plm_video_decode_impl(plm_video_t *self) {
 plm_frame_t *plm_video_decode(plm_video_t *self) {
  long double tsc;
  plm_frame_t *res;
-  INFOF("plm_video_decode");
+  LOGF("plm_video_decode");
  tsc = nowl();
  res = plm_video_decode_impl(self);
  plmpegdecode_latency_ = lroundl((nowl() - tsc) * 1e6l);
@@ -94,9 +94,9 @@ plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {

 	self->demux = plm_demux_create(buffer, destroy_when_done);

-	// In theory we should check plm_demux_get_num_video_streams() and
+	// 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
+	// do not specify these correcly. So we just assume we have a video and
 	// audio stream and create the decoders.

 	self->video_packet_type = PLM_DEMUX_PACKET_VIDEO_1;
@@ -159,7 +159,7 @@ double plm_get_framerate(plm_t *self) {

 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,
+	// 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;
@@ -40,7 +40,7 @@ asm(".include \"libc/disclaimer.inc\"");
 * @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
+  // Chroma values are the same for each block of 4 pixels, so we proccess
  // 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);
@@ -21,14 +21,14 @@
 #include "dsp/core/ituround.h"
 #include "dsp/core/q.h"
 #include "dsp/core/twixt8.h"
-#include "libc/intrin/bsr.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
 #include "libc/math.h"
-#include "libc/mem/gc.internal.h"
 #include "libc/mem/mem.h"
+#include "libc/nexgen32e/bsr.h"
+#include "libc/runtime/gc.internal.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
@@ -101,7 +101,7 @@ struct SamplingSolution *ComputeSamplingSolution(long dn, long sn, double dar,
  if (!off) off = (dar - 1) / 2;
  f = dar < 1 ? 1 / dar : dar;
  s = 3 * f + 4;
-  fweights = gc(xcalloc(s + /*xxx*/ 2, sizeof(double)));
+  fweights = gc(xcalloc(s, sizeof(double)));
  res = NewSamplingSolution(dn, s);
  weights = res->weights;
  indices = res->indices;
@@ -203,8 +203,8 @@ void *Gyarados(long dyw, long dxw, int dst[dyw][dxw], long syw, long sxw,
      CHECK_LE(sxn, sxw);
      CHECK_LE(dyn, dyw);
      CHECK_LE(dxn, dxw);
-      CHECK_LT(_bsrl(syn) + _bsrl(sxn), 32);
-      CHECK_LT(_bsrl(dyn) + _bsrl(dxn), 32);
+      CHECK_LT(bsrl(syn) + bsrl(sxn), 32);
+      CHECK_LT(bsrl(dyn) + bsrl(dxn), 32);
      CHECK_LE(dyw, 0x7fff);
      CHECK_LE(dxw, 0x7fff);
      CHECK_LE(syw, 0x7fff);
@@ -51,7 +51,7 @@ $(DSP_SCALE_A).pkg:				\
 o/$(MODE)/dsp/scale/cdecimate2xuint8x8.o	\
 o/$(MODE)/dsp/scale/gyarados.o			\
 o/$(MODE)/dsp/scale/magikarp.o			\
-o/$(MODE)/dsp/scale/scale.o: private		\
+o/$(MODE)/dsp/scale/scale.o:			\
 		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

@@ -30,7 +30,7 @@
 * @see ttyconfig(), ttyrestore()
 */
 int ttyconfig(int ttyfd, ttyconf_f fn, int64_t arg,
-              struct termios *opt_out_oldconf) {
+              const struct termios *opt_out_oldconf) {
  struct termios conf[2];
  if (tcgetattr(ttyfd, &conf[0]) != -1 &&
      fn(memcpy(&conf[1], &conf[0], sizeof(conf[0])), arg) != -1 &&
@@ -17,9 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/intrin/pushpop.h"
+#include "libc/bits/pushpop.h"
 #include "libc/dce.h"
-#include "libc/log/internal.h"
 #include "libc/log/log.h"
 #include "libc/nt/console.h"
 #include "libc/nt/runtime.h"
@@ -31,7 +30,7 @@
 static int ttysetcursor(int fd, bool visible) {
  struct NtConsoleCursorInfo ntcursor;
  char code[8] = "\e[?25l";
-  if (__nocolor) return 0;
+  if (IsTerminalInarticulate()) return 0;
  if (visible) code[5] = 'h';
  if (SupportsWindows()) {
    GetConsoleCursorInfo(GetStdHandle(kNtStdOutputHandle), &ntcursor);
@@ -17,17 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
+#include "libc/bits/safemacros.internal.h"
+#include "libc/bits/weaken.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/termios.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
 #include "libc/fmt/fmt.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
-#include "libc/sock/struct/pollfd.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/poll.h"
 #include "libc/sysv/errfuns.h"
@@ -83,11 +80,10 @@ int ttyident(struct TtyIdent *ti, int ttyinfd, int ttyoutfd) {
      if (ttyident_probe(ti, ttyinfd, ttyoutfd, "\e[>c") != -1) {
        rc = 0;
        memset(&outer, 0, sizeof(outer));
-        if (ti->id == 83 /* GNU Screen */ && (ti->next || _weaken(malloc)) &&
+        if (ti->id == 83 /* GNU Screen */ && (ti->next || weaken(malloc)) &&
            ttyident_probe(&outer, ttyinfd, ttyoutfd, "\eP\e[>c\e\\") != -1 &&
-            (ti->next =
-                 (ti->next ? ti->next
-                           : _weaken(malloc)(sizeof(struct TtyIdent))))) {
+            (ti->next = (ti->next ? ti->next
+                                  : weaken(malloc)(sizeof(struct TtyIdent))))) {
          memcpy(ti->next, &outer, sizeof(outer));
        } else {
          free_s(&ti->next);
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_TTY_INTERNAL_H_
 #define COSMOPOLITAN_DSP_TTY_INTERNAL_H_
 #include "dsp/tty/ttyrgb.h"
-#include "third_party/intel/xmmintrin.internal.h"
+#include "libc/bits/xmmintrin.internal.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
-#include "libc/intrin/bits.h"
-#include "libc/intrin/initializer.internal.h"
+#include "libc/bits/bits.h"
+#include "libc/bits/initializer.internal.h"
 #include "libc/str/str.h"

 struct Itoa8 kItoa8;
@@ -2,10 +2,10 @@
 #define DSP_TTY_QUANT_H_
 #include "dsp/tty/ttyrgb.h"
 #include "libc/assert.h"
-#include "libc/intrin/bits.h"
+#include "libc/bits/bits.h"
+#include "libc/bits/xmmintrin.internal.h"
 #include "libc/limits.h"
 #include "libc/str/str.h"
-#include "third_party/intel/xmmintrin.internal.h"
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_

@@ -19,7 +19,7 @@
 #include "dsp/core/core.h"
 #include "dsp/tty/quant.h"
 #include "libc/assert.h"
-#include "libc/intrin/initializer.internal.h"
+#include "libc/bits/initializer.internal.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
@@ -47,8 +47,7 @@ __m128 tty2rgbf_(struct TtyRgb rgbxt) {

 static int rgb2xterm256_(int r, int g, int b) {
  int cerr, gerr, ir, ig, ib, gray, grai, cr, cg, cb, gv;
-  gray = round(871024 / 4096299. * r + 8788810 / 12288897. * g +
-               887015 / 12288897. * b);
+  gray = round(r * .299 + g * .587 + b * .114);
  grai = gray > 238 ? 23 : (gray - 3) / 10;
  ir = r < 48 ? 0 : r < 115 ? 1 : (r - 35) / 40;
  ig = g < 48 ? 0 : g < 115 ? 1 : (g - 35) / 40;
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/quant.h"
-#include "third_party/intel/xmmintrin.internal.h"
+#include "libc/bits/xmmintrin.internal.h"

 struct TtyRgb rgb2ttyf2i_(__m128 rgb) {
  __v4si i4;
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/mem/arraylist2.internal.h"
-#include "libc/mem/gc.internal.h"
+#include "libc/alg/arraylist2.internal.h"
+#include "libc/runtime/gc.internal.h"
 #include "libc/x/x.h"

 /* TODO(jart): DELETE */
@@ -31,6 +31,13 @@ int ttysetraw(struct termios *conf, int64_t flags) {
  conf->c_cflag &= ~(CSIZE | PARENB);
  conf->c_cflag |= CS8;
  conf->c_iflag |= IUTF8;
+  /* if (flags & kTtyLfToCrLf) { */
+  /*   /\* conf->c_oflag &= ~(OLCUC | OCRNL | ONLRET | OFILL | OFDEL); *\/ */
+  /*   /\* conf->c_oflag |= ONLCR | ONOCR; *\/ */
+  /*   conf->c_oflag |= ONLCR; */
+  /* } else { */
+  /*   conf->c_oflag &= ~OPOST; */
+  /* } */
  if (!(flags & kTtySigs)) {
    conf->c_iflag &= ~(IGNBRK | BRKINT);
    conf->c_lflag &= ~(ISIG);
@@ -44,7 +44,7 @@ int ttysendtitle(int, const char *, const struct TtyIdent *);
 int ttyident(struct TtyIdent *, int, int);
 void ttyidentclear(struct TtyIdent *);
 char *ttydescribe(char *, size_t, const struct TtyIdent *);
-int ttyconfig(int, ttyconf_f, int64_t, struct termios *);
+int ttyconfig(int, ttyconf_f, int64_t, const struct termios *);
 int ttyrestore(int, const struct termios *);
 int ttysetrawdeadline(struct termios *, int64_t);
 int ttysetrawmode(struct termios *, int64_t);
@@ -25,6 +25,7 @@ DSP_TTY_A_CHECKS =				\

 DSP_TTY_A_DIRECTDEPS =				\
 	DSP_CORE				\
+	LIBC_ALG				\
 	LIBC_CALLS				\
 	LIBC_FMT				\
 	LIBC_INTRIN				\
@@ -40,7 +41,8 @@ DSP_TTY_A_DIRECTDEPS =				\
 	LIBC_SYSV				\
 	LIBC_TINYMATH				\
 	LIBC_TIME				\
-	LIBC_X
+	LIBC_X					\
+	LIBC_UNICODE

 DSP_TTY_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_TTY_A_DIRECTDEPS),$($(x))))
@@ -53,8 +55,8 @@ $(DSP_TTY_A).pkg:				\
 		$(DSP_TTY_A_OBJS)		\
 		$(foreach x,$(DSP_TTY_A_DIRECTDEPS),$($(x)_A).pkg)

-o/$(MODE)/dsp/tty/ttyraster.o: private		\
-		OVERRIDE_CFLAGS +=	\
+o/$(MODE)/dsp/tty/ttyraster.o:			\
+		OVERRIDE_CFLAGS +=		\
 			$(MATHEMATICAL)

 DSP_TTY_LIBS = $(foreach x,$(DSP_TTY_ARTIFACTS),$($(x)))
@@ -18,7 +18,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/tty.h"
-#include "libc/mem/alg.h"
+#include "libc/alg/alg.h"
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/str/str.h"

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
 #include "dsp/tty/tty.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/bits/safemacros.internal.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"

@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/internal.h"
 #include "dsp/tty/quant.h"
-#include "libc/intrin/initializer.internal.h"
+#include "libc/bits/initializer.internal.h"
 #include "libc/dce.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
@@ -22,8 +22,8 @@
 #include "dsp/tty/ttyrgb.h"
 #include "dsp/tty/windex.h"
 #include "libc/assert.h"
-#include "libc/intrin/bits.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/bits/bits.h"
+#include "libc/bits/safemacros.internal.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
@@ -731,19 +731,19 @@ static bool ChunkEq(struct TtyRgb c[hasatleast 4],
 }

 static struct TtyRgb *CopyChunk(struct TtyRgb chunk[hasatleast 4],
-                                const struct TtyRgb *c, size_t xn) {
-  chunk[TL] = c[00 + 0];
-  chunk[TR] = c[00 + 1];
-  chunk[BL] = c[xn + 0];
-  chunk[BR] = c[xn + 1];
+                                const struct TtyRgb *c, size_t n) {
+  chunk[TL] = c[0 + 0];
+  chunk[TR] = c[0 + 1];
+  chunk[BL] = c[n + 0];
+  chunk[BR] = c[n + 1];
  return chunk;
 }

-static dontinline char *CopyRun(char *v, size_t n,
-                                struct TtyRgb lastchunk[hasatleast 4],
-                                const struct TtyRgb **c, size_t *x,
-                                struct TtyRgb *bg, struct TtyRgb *fg,
-                                struct Glyph *glyph) {
+static noinline char *CopyRun(char *v, size_t n,
+                              struct TtyRgb lastchunk[hasatleast 4],
+                              const struct TtyRgb **c, size_t *x,
+                              struct TtyRgb *bg, struct TtyRgb *fg,
+                              struct Glyph *glyph) {
  struct TtyRgb chunk[4];
  if (memcmp(glyph, &kGlyphs[1][0], sizeof(*glyph)) == 0) {
    if (!ttyeq(*bg, *fg)) {
@@ -766,21 +766,17 @@ static dontinline char *CopyRun(char *v, size_t n,
 /**
 * Maps 2×2 pixel chunks onto ANSI UNICODE cells.
 * @note h/t Nick Black for his quadrant blitting work on notcurses
- * @note yn and xn need to be even
 */
-char *ttyraster(char *v, const struct TtyRgb *c, size_t yn, size_t xn,
+char *ttyraster(char *v, const struct TtyRgb *c, size_t yn, size_t n,
                struct TtyRgb bg, struct TtyRgb fg) {
  unsigned y, x;
  struct Pick p;
  struct Glyph glyph;
  struct TtyRgb chun[4], lastchunk[4];
-  for (y = 0; y < yn; y += 2, c += xn) {
-    if (y) {
-      v = stpcpy(v, "\e[0m\r\n");
-      v = setbgfg(v, bg, fg);
-    }
-    for (x = 0; x < xn; x += 2, c += 2) {
-      CopyChunk(chun, c, xn);
+  for (y = 0; y < yn; y += 2, c += n) {
+    if (y) *v++ = '\r', *v++ = '\n';
+    for (x = 0; x < n; x += 2, c += 2) {
+      CopyChunk(chun, c, n);
      if (ttyquant()->alg == kTtyQuantTrue) {
        if (ttyquant()->blocks == kTtyBlocksCp437) {
          p = PickBlockCp437True(chun[TL], chun[TR], chun[BL], chun[BR]);
@@ -798,6 +794,6 @@ char *ttyraster(char *v, const struct TtyRgb *c, size_t yn, size_t xn,
      memcpy(lastchunk, chun, sizeof(chun));
    }
  }
-  v = stpcpy(v, "\e[0m");
+  *v = '\0';
  return v;
 }
@@ -19,13 +19,15 @@
 #include "dsp/tty/tty.h"
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/sigbits.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/termios.h"
+#include "libc/calls/typedef/sigaction_f.h"
 #include "libc/calls/ucontext.h"
 #include "libc/log/log.h"
 #include "libc/macros.internal.h"
-#include "libc/mem/gc.internal.h"
+#include "libc/runtime/gc.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/fileno.h"
@@ -33,7 +35,6 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/x/x.h"
-#include "libc/x/xsigaction.h"

 /* TODO(jart): DELETE */

@@ -98,8 +99,8 @@ static relegated void ttyraw_onsig(int sig, struct siginfo *info,
  }
  for (i = 0; i < ARRAYLEN(g_ttyraw.sigs); ++i) {
    if (g_ttyraw.sigs[i] == sig) {
-      if (g_ttyraw.next[i] != (void *)SIG_IGN) {
-        if (g_ttyraw.next[i] != (void *)SIG_DFL) {
+      if (g_ttyraw.next[i] != SIG_IGN) {
+        if (g_ttyraw.next[i] != SIG_DFL) {
          if (g_ttyraw.next[i]) {
            g_ttyraw.next[i](sig, info, ctx);
          }
@@ -118,7 +119,7 @@ static textstartup void ttyraw_initsig(int sig, unsigned flags, unsigned mask) {
  struct sigaction old;
  g_ttyraw.next[i] = xsigaction(sig, ttyraw_onsig, flags, mask, &old) != -1
                         ? old.sa_sigaction
-                         : (void *)SIG_DFL;
+                         : SIG_DFL;
  g_ttyraw.sigs[i++] = sig;
 }

@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/macros.internal.h"
+.source	__FILE__

 //	Returns index of minimum uint16 in array.
 //
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/macros.internal.h"
+.source	__FILE__

 //	Returns index of minimum positive int16 in array.
 //
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/macros.internal.h"
+.source	__FILE__

 //	Dispatches to fastest windex() implementation.
 	.initbss 300,_init_windex
Author	SHA1	Message	Date
Gautham	ace523c79b	Tell _frozen_importlib to consider bytecode first (#248 )	2021-08-17 22:07:27 -07:00
Justine Tunney	c70422586a	Support optimize flag	2021-08-17 14:07:59 -07:00
Justine Tunney	cabb0a7ede	Get Python compiler working It turns out we needed a file length field.	2021-08-17 12:14:47 -07:00
Justine Tunney	38aece42ba	Add Python object dump tool	2021-08-17 12:11:29 -07:00
Justine Tunney	f66ef5d58e	Change stuff	2021-08-17 10:20:55 -07:00
Justine Tunney	0c6581f912	Attempt to build Python compiler program	2021-08-17 06:28:23 -07:00
Justine Tunney	d522a88def	Get freeze importlib program working	2021-08-17 01:27:03 -07:00
Justine Tunney	795d6fd6cd	Disable zipos trace	2021-08-17 01:26:48 -07:00
Justine Tunney	d3a735702b	Use real malloc so we can test Python with ASAN	2021-08-17 01:25:04 -07:00
Justine Tunney	214e3a68a9	Let's make imports simple	2021-08-17 00:10:24 -07:00