From 0eb621f75edc04cf6ee531bd491c52c1c9f3ff95 Mon Sep 17 00:00:00 2001
From: Justine Tunney <jtunney@gmail.com>
Date: Sun, 12 Feb 2023 22:13:45 -0800
Subject: [PATCH] Remove non-JIT'd blink builds for now

---
 ape/ape.S   | 289 ----------------------------------------------------
 ape/ape.lds | 154 ----------------------------
 2 files changed, 443 deletions(-)

diff --git a/ape/ape.S b/ape/ape.S
index 351cfb23e..117451787 100644
--- a/ape/ape.S
+++ b/ape/ape.S
@@ -771,239 +771,6 @@ emush:	.ascii	"\n@\n#'\"\n"
 	.ascii	"fi\n"
 	.ascii	"fi\n"
 
-//	Blink for Linux Generic ARM
-	.ascii	"if [ \"$s\" = Linux ] && [ \"${m#arm}\" != \"$m\" ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-arm to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_arm_b9
-	.byte	blink_arm_b8
-	.byte	blink_arm_b7
-	.byte	blink_arm_b6
-	.byte	blink_arm_b5
-	.byte	blink_arm_b4
-	.byte	blink_arm_b3
-	.byte	blink_arm_b2
-	.byte	blink_arm_b1
-	.byte	blink_arm_b0
-	.ascii	")) count=$(("
-	.byte	blink_arm_size_b9
-	.byte	blink_arm_size_b8
-	.byte	blink_arm_size_b7
-	.byte	blink_arm_size_b6
-	.byte	blink_arm_size_b5
-	.byte	blink_arm_size_b4
-	.byte	blink_arm_size_b3
-	.byte	blink_arm_size_b2
-	.byte	blink_arm_size_b1
-	.byte	blink_arm_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
-//	Blink for Linux on Legacy x86
-	.ascii	"if [ \"$s\" = Linux ]; then\n"
-	.ascii	"if [ \"$m\" = i686 ] || [ \"$m\" = i386 ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-i486 to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_i486_b9
-	.byte	blink_i486_b8
-	.byte	blink_i486_b7
-	.byte	blink_i486_b6
-	.byte	blink_i486_b5
-	.byte	blink_i486_b4
-	.byte	blink_i486_b3
-	.byte	blink_i486_b2
-	.byte	blink_i486_b1
-	.byte	blink_i486_b0
-	.ascii	")) count=$(("
-	.byte	blink_i486_size_b9
-	.byte	blink_i486_size_b8
-	.byte	blink_i486_size_b7
-	.byte	blink_i486_size_b6
-	.byte	blink_i486_size_b5
-	.byte	blink_i486_size_b4
-	.byte	blink_i486_size_b3
-	.byte	blink_i486_size_b2
-	.byte	blink_i486_size_b1
-	.byte	blink_i486_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-	.ascii	"fi\n"
-
-//	Blink for Linux on RISC-V
-	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = riscv64 ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-riscv64 to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_riscv64_b9
-	.byte	blink_riscv64_b8
-	.byte	blink_riscv64_b7
-	.byte	blink_riscv64_b6
-	.byte	blink_riscv64_b5
-	.byte	blink_riscv64_b4
-	.byte	blink_riscv64_b3
-	.byte	blink_riscv64_b2
-	.byte	blink_riscv64_b1
-	.byte	blink_riscv64_b0
-	.ascii	")) count=$(("
-	.byte	blink_riscv64_size_b9
-	.byte	blink_riscv64_size_b8
-	.byte	blink_riscv64_size_b7
-	.byte	blink_riscv64_size_b6
-	.byte	blink_riscv64_size_b5
-	.byte	blink_riscv64_size_b4
-	.byte	blink_riscv64_size_b3
-	.byte	blink_riscv64_size_b2
-	.byte	blink_riscv64_size_b1
-	.byte	blink_riscv64_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
-//	Blink for Linux on MIPS Little Endian, e.g. Ubiquiti EdgerouterX
-	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = mips ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-mipsel to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_mipsel_b9
-	.byte	blink_mipsel_b8
-	.byte	blink_mipsel_b7
-	.byte	blink_mipsel_b6
-	.byte	blink_mipsel_b5
-	.byte	blink_mipsel_b4
-	.byte	blink_mipsel_b3
-	.byte	blink_mipsel_b2
-	.byte	blink_mipsel_b1
-	.byte	blink_mipsel_b0
-	.ascii	")) count=$(("
-	.byte	blink_mipsel_size_b9
-	.byte	blink_mipsel_size_b8
-	.byte	blink_mipsel_size_b7
-	.byte	blink_mipsel_size_b6
-	.byte	blink_mipsel_size_b5
-	.byte	blink_mipsel_size_b4
-	.byte	blink_mipsel_size_b3
-	.byte	blink_mipsel_size_b2
-	.byte	blink_mipsel_size_b1
-	.byte	blink_mipsel_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
-//	Blink for Linux on PowerPC 64 Little Endian, e.g. Raptor
-	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = ppc64le ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-powerpc64le to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_powerpc64le_b9
-	.byte	blink_powerpc64le_b8
-	.byte	blink_powerpc64le_b7
-	.byte	blink_powerpc64le_b6
-	.byte	blink_powerpc64le_b5
-	.byte	blink_powerpc64le_b4
-	.byte	blink_powerpc64le_b3
-	.byte	blink_powerpc64le_b2
-	.byte	blink_powerpc64le_b1
-	.byte	blink_powerpc64le_b0
-	.ascii	")) count=$(("
-	.byte	blink_powerpc64le_size_b9
-	.byte	blink_powerpc64le_size_b8
-	.byte	blink_powerpc64le_size_b7
-	.byte	blink_powerpc64le_size_b6
-	.byte	blink_powerpc64le_size_b5
-	.byte	blink_powerpc64le_size_b4
-	.byte	blink_powerpc64le_size_b3
-	.byte	blink_powerpc64le_size_b2
-	.byte	blink_powerpc64le_size_b1
-	.byte	blink_powerpc64le_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
-//	Blink for Linux on PowerPC, e.g. Old Macintosh
-	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = ppc ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-powerpc to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_powerpc_b9
-	.byte	blink_powerpc_b8
-	.byte	blink_powerpc_b7
-	.byte	blink_powerpc_b6
-	.byte	blink_powerpc_b5
-	.byte	blink_powerpc_b4
-	.byte	blink_powerpc_b3
-	.byte	blink_powerpc_b2
-	.byte	blink_powerpc_b1
-	.byte	blink_powerpc_b0
-	.ascii	")) count=$(("
-	.byte	blink_powerpc_size_b9
-	.byte	blink_powerpc_size_b8
-	.byte	blink_powerpc_size_b7
-	.byte	blink_powerpc_size_b6
-	.byte	blink_powerpc_size_b5
-	.byte	blink_powerpc_size_b4
-	.byte	blink_powerpc_size_b3
-	.byte	blink_powerpc_size_b2
-	.byte	blink_powerpc_size_b1
-	.byte	blink_powerpc_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
-//	Blink for Linux on IBM Mainframes
-	.ascii	"if [ \"$s\" = Linux ] && [ \"$m\" = s390x ]; then\n"
-	.ascii	"if ! [ -x \"$e\" ]; then\n"
-	.ascii	"echo \"extracting blink-s390x to ${e}\" >&2\n"
-	.ascii	"dd if=\"$o\" bs=1 skip=$(("
-	.byte	blink_s390x_b9
-	.byte	blink_s390x_b8
-	.byte	blink_s390x_b7
-	.byte	blink_s390x_b6
-	.byte	blink_s390x_b5
-	.byte	blink_s390x_b4
-	.byte	blink_s390x_b3
-	.byte	blink_s390x_b2
-	.byte	blink_s390x_b1
-	.byte	blink_s390x_b0
-	.ascii	")) count=$(("
-	.byte	blink_s390x_size_b9
-	.byte	blink_s390x_size_b8
-	.byte	blink_s390x_size_b7
-	.byte	blink_s390x_size_b6
-	.byte	blink_s390x_size_b5
-	.byte	blink_s390x_size_b4
-	.byte	blink_s390x_size_b3
-	.byte	blink_s390x_size_b2
-	.byte	blink_s390x_size_b1
-	.byte	blink_s390x_size_b0
-	.ascii	")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n"
-	.ascii	"mv -f \"$e.$$\" \"$e\"\n"
-	.ascii	"chmod +x \"$e\"\n"
-	.ascii	"fi\n"
-	.ascii	"exec \"$e\" \"$o\" \"$@\"\n"
-	.ascii	"fi\n"
-
 	.ascii	"echo unsupported architecture >&2\n"
 	.rept	16
 	.ascii	"exit 127\n"
@@ -2172,61 +1939,5 @@ blink_darwin_arm64:
 blink_darwin_arm64_size = . - blink_darwin_arm64
 	.previous
 
-	.section .blink,"a",@progbits
-	.globl	blink_arm_size
-blink_arm:
-	.incbin	"ape/blink-arm.gz"
-	.endobj	blink_arm,globl
-blink_arm_size = . - blink_arm
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_i486_size
-blink_i486:
-	.incbin	"ape/blink-i486.gz"
-	.endobj	blink_i486,globl
-blink_i486_size = . - blink_i486
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_riscv64_size
-blink_riscv64:
-	.incbin	"ape/blink-riscv64.gz"
-	.endobj	blink_riscv64,globl
-blink_riscv64_size = . - blink_riscv64
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_mipsel_size
-blink_mipsel:
-	.incbin	"ape/blink-mipsel.gz"
-	.endobj	blink_mipsel,globl
-blink_mipsel_size = . - blink_mipsel
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_powerpc64le_size
-blink_powerpc64le:
-	.incbin	"ape/blink-powerpc64le.gz"
-	.endobj	blink_powerpc64le,globl
-blink_powerpc64le_size = . - blink_powerpc64le
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_powerpc_size
-blink_powerpc:
-	.incbin	"ape/blink-powerpc.gz"
-	.endobj	blink_powerpc,globl
-blink_powerpc_size = . - blink_powerpc
-	.previous
-
-	.section .blink,"a",@progbits
-	.globl	blink_s390x_size
-blink_s390x:
-	.incbin	"ape/blink-s390x.gz"
-	.endobj	blink_s390x,globl
-blink_s390x_size = . - blink_s390x
-	.previous
-
 .end
 
\ No newline at end of file
diff --git a/ape/ape.lds b/ape/ape.lds
index 880369408..e2bab3cb9 100644
--- a/ape/ape.lds
+++ b/ape/ape.lds
@@ -611,160 +611,6 @@ HIDDEN(blink_darwin_arm64_size_b7 = blink_darwin_arm64_size < 10000000 ? 32 : bl
 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);
 
-HIDDEN(blink_arm_b0 = RVA(blink_arm) % 10 + 48);
-HIDDEN(blink_arm_b1 = RVA(blink_arm) < 10 ? 32 : RVA(blink_arm) / 10 % 10 + 48);
-HIDDEN(blink_arm_b2 = RVA(blink_arm) < 100 ? 32 : RVA(blink_arm) / 100 % 10 + 48);
-HIDDEN(blink_arm_b3 = RVA(blink_arm) < 1000 ? 32 : RVA(blink_arm) / 1000 % 10 + 48);
-HIDDEN(blink_arm_b4 = RVA(blink_arm) < 10000 ? 32 : RVA(blink_arm) / 10000 % 10 + 48);
-HIDDEN(blink_arm_b5 = RVA(blink_arm) < 100000 ? 32 : RVA(blink_arm) / 100000 % 10 + 48);
-HIDDEN(blink_arm_b6 = RVA(blink_arm) < 1000000 ? 32 : RVA(blink_arm) / 1000000 % 10 + 48);
-HIDDEN(blink_arm_b7 = RVA(blink_arm) < 10000000 ? 32 : RVA(blink_arm) / 10000000 % 10 + 48);
-HIDDEN(blink_arm_b8 = RVA(blink_arm) < 100000000 ? 32 : RVA(blink_arm) / 100000000 % 10 + 48);
-HIDDEN(blink_arm_b9 = RVA(blink_arm) < 1000000000 ? 32 : RVA(blink_arm) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_arm_size_b0 = blink_arm_size % 10 + 48);
-HIDDEN(blink_arm_size_b1 = blink_arm_size < 10 ? 32 : blink_arm_size / 10 % 10 + 48);
-HIDDEN(blink_arm_size_b2 = blink_arm_size < 100 ? 32 : blink_arm_size / 100 % 10 + 48);
-HIDDEN(blink_arm_size_b3 = blink_arm_size < 1000 ? 32 : blink_arm_size / 1000 % 10 + 48);
-HIDDEN(blink_arm_size_b4 = blink_arm_size < 10000 ? 32 : blink_arm_size / 10000 % 10 + 48);
-HIDDEN(blink_arm_size_b5 = blink_arm_size < 100000 ? 32 : blink_arm_size / 100000 % 10 + 48);
-HIDDEN(blink_arm_size_b6 = blink_arm_size < 1000000 ? 32 : blink_arm_size / 1000000 % 10 + 48);
-HIDDEN(blink_arm_size_b7 = blink_arm_size < 10000000 ? 32 : blink_arm_size / 10000000 % 10 + 48);
-HIDDEN(blink_arm_size_b8 = blink_arm_size < 100000000 ? 32 : blink_arm_size / 100000000 % 10 + 48);
-HIDDEN(blink_arm_size_b9 = blink_arm_size < 1000000000 ? 32 : blink_arm_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_i486_b0 = RVA(blink_i486) % 10 + 48);
-HIDDEN(blink_i486_b1 = RVA(blink_i486) < 10 ? 32 : RVA(blink_i486) / 10 % 10 + 48);
-HIDDEN(blink_i486_b2 = RVA(blink_i486) < 100 ? 32 : RVA(blink_i486) / 100 % 10 + 48);
-HIDDEN(blink_i486_b3 = RVA(blink_i486) < 1000 ? 32 : RVA(blink_i486) / 1000 % 10 + 48);
-HIDDEN(blink_i486_b4 = RVA(blink_i486) < 10000 ? 32 : RVA(blink_i486) / 10000 % 10 + 48);
-HIDDEN(blink_i486_b5 = RVA(blink_i486) < 100000 ? 32 : RVA(blink_i486) / 100000 % 10 + 48);
-HIDDEN(blink_i486_b6 = RVA(blink_i486) < 1000000 ? 32 : RVA(blink_i486) / 1000000 % 10 + 48);
-HIDDEN(blink_i486_b7 = RVA(blink_i486) < 10000000 ? 32 : RVA(blink_i486) / 10000000 % 10 + 48);
-HIDDEN(blink_i486_b8 = RVA(blink_i486) < 100000000 ? 32 : RVA(blink_i486) / 100000000 % 10 + 48);
-HIDDEN(blink_i486_b9 = RVA(blink_i486) < 1000000000 ? 32 : RVA(blink_i486) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_i486_size_b0 = blink_i486_size % 10 + 48);
-HIDDEN(blink_i486_size_b1 = blink_i486_size < 10 ? 32 : blink_i486_size / 10 % 10 + 48);
-HIDDEN(blink_i486_size_b2 = blink_i486_size < 100 ? 32 : blink_i486_size / 100 % 10 + 48);
-HIDDEN(blink_i486_size_b3 = blink_i486_size < 1000 ? 32 : blink_i486_size / 1000 % 10 + 48);
-HIDDEN(blink_i486_size_b4 = blink_i486_size < 10000 ? 32 : blink_i486_size / 10000 % 10 + 48);
-HIDDEN(blink_i486_size_b5 = blink_i486_size < 100000 ? 32 : blink_i486_size / 100000 % 10 + 48);
-HIDDEN(blink_i486_size_b6 = blink_i486_size < 1000000 ? 32 : blink_i486_size / 1000000 % 10 + 48);
-HIDDEN(blink_i486_size_b7 = blink_i486_size < 10000000 ? 32 : blink_i486_size / 10000000 % 10 + 48);
-HIDDEN(blink_i486_size_b8 = blink_i486_size < 100000000 ? 32 : blink_i486_size / 100000000 % 10 + 48);
-HIDDEN(blink_i486_size_b9 = blink_i486_size < 1000000000 ? 32 : blink_i486_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_riscv64_b0 = RVA(blink_riscv64) % 10 + 48);
-HIDDEN(blink_riscv64_b1 = RVA(blink_riscv64) < 10 ? 32 : RVA(blink_riscv64) / 10 % 10 + 48);
-HIDDEN(blink_riscv64_b2 = RVA(blink_riscv64) < 100 ? 32 : RVA(blink_riscv64) / 100 % 10 + 48);
-HIDDEN(blink_riscv64_b3 = RVA(blink_riscv64) < 1000 ? 32 : RVA(blink_riscv64) / 1000 % 10 + 48);
-HIDDEN(blink_riscv64_b4 = RVA(blink_riscv64) < 10000 ? 32 : RVA(blink_riscv64) / 10000 % 10 + 48);
-HIDDEN(blink_riscv64_b5 = RVA(blink_riscv64) < 100000 ? 32 : RVA(blink_riscv64) / 100000 % 10 + 48);
-HIDDEN(blink_riscv64_b6 = RVA(blink_riscv64) < 1000000 ? 32 : RVA(blink_riscv64) / 1000000 % 10 + 48);
-HIDDEN(blink_riscv64_b7 = RVA(blink_riscv64) < 10000000 ? 32 : RVA(blink_riscv64) / 10000000 % 10 + 48);
-HIDDEN(blink_riscv64_b8 = RVA(blink_riscv64) < 100000000 ? 32 : RVA(blink_riscv64) / 100000000 % 10 + 48);
-HIDDEN(blink_riscv64_b9 = RVA(blink_riscv64) < 1000000000 ? 32 : RVA(blink_riscv64) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_riscv64_size_b0 = blink_riscv64_size % 10 + 48);
-HIDDEN(blink_riscv64_size_b1 = blink_riscv64_size < 10 ? 32 : blink_riscv64_size / 10 % 10 + 48);
-HIDDEN(blink_riscv64_size_b2 = blink_riscv64_size < 100 ? 32 : blink_riscv64_size / 100 % 10 + 48);
-HIDDEN(blink_riscv64_size_b3 = blink_riscv64_size < 1000 ? 32 : blink_riscv64_size / 1000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b4 = blink_riscv64_size < 10000 ? 32 : blink_riscv64_size / 10000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b5 = blink_riscv64_size < 100000 ? 32 : blink_riscv64_size / 100000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b6 = blink_riscv64_size < 1000000 ? 32 : blink_riscv64_size / 1000000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b7 = blink_riscv64_size < 10000000 ? 32 : blink_riscv64_size / 10000000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b8 = blink_riscv64_size < 100000000 ? 32 : blink_riscv64_size / 100000000 % 10 + 48);
-HIDDEN(blink_riscv64_size_b9 = blink_riscv64_size < 1000000000 ? 32 : blink_riscv64_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_mipsel_b0 = RVA(blink_mipsel) % 10 + 48);
-HIDDEN(blink_mipsel_b1 = RVA(blink_mipsel) < 10 ? 32 : RVA(blink_mipsel) / 10 % 10 + 48);
-HIDDEN(blink_mipsel_b2 = RVA(blink_mipsel) < 100 ? 32 : RVA(blink_mipsel) / 100 % 10 + 48);
-HIDDEN(blink_mipsel_b3 = RVA(blink_mipsel) < 1000 ? 32 : RVA(blink_mipsel) / 1000 % 10 + 48);
-HIDDEN(blink_mipsel_b4 = RVA(blink_mipsel) < 10000 ? 32 : RVA(blink_mipsel) / 10000 % 10 + 48);
-HIDDEN(blink_mipsel_b5 = RVA(blink_mipsel) < 100000 ? 32 : RVA(blink_mipsel) / 100000 % 10 + 48);
-HIDDEN(blink_mipsel_b6 = RVA(blink_mipsel) < 1000000 ? 32 : RVA(blink_mipsel) / 1000000 % 10 + 48);
-HIDDEN(blink_mipsel_b7 = RVA(blink_mipsel) < 10000000 ? 32 : RVA(blink_mipsel) / 10000000 % 10 + 48);
-HIDDEN(blink_mipsel_b8 = RVA(blink_mipsel) < 100000000 ? 32 : RVA(blink_mipsel) / 100000000 % 10 + 48);
-HIDDEN(blink_mipsel_b9 = RVA(blink_mipsel) < 1000000000 ? 32 : RVA(blink_mipsel) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_mipsel_size_b0 = blink_mipsel_size % 10 + 48);
-HIDDEN(blink_mipsel_size_b1 = blink_mipsel_size < 10 ? 32 : blink_mipsel_size / 10 % 10 + 48);
-HIDDEN(blink_mipsel_size_b2 = blink_mipsel_size < 100 ? 32 : blink_mipsel_size / 100 % 10 + 48);
-HIDDEN(blink_mipsel_size_b3 = blink_mipsel_size < 1000 ? 32 : blink_mipsel_size / 1000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b4 = blink_mipsel_size < 10000 ? 32 : blink_mipsel_size / 10000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b5 = blink_mipsel_size < 100000 ? 32 : blink_mipsel_size / 100000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b6 = blink_mipsel_size < 1000000 ? 32 : blink_mipsel_size / 1000000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b7 = blink_mipsel_size < 10000000 ? 32 : blink_mipsel_size / 10000000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b8 = blink_mipsel_size < 100000000 ? 32 : blink_mipsel_size / 100000000 % 10 + 48);
-HIDDEN(blink_mipsel_size_b9 = blink_mipsel_size < 1000000000 ? 32 : blink_mipsel_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc64le_b0 = RVA(blink_powerpc64le) % 10 + 48);
-HIDDEN(blink_powerpc64le_b1 = RVA(blink_powerpc64le) < 10 ? 32 : RVA(blink_powerpc64le) / 10 % 10 + 48);
-HIDDEN(blink_powerpc64le_b2 = RVA(blink_powerpc64le) < 100 ? 32 : RVA(blink_powerpc64le) / 100 % 10 + 48);
-HIDDEN(blink_powerpc64le_b3 = RVA(blink_powerpc64le) < 1000 ? 32 : RVA(blink_powerpc64le) / 1000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b4 = RVA(blink_powerpc64le) < 10000 ? 32 : RVA(blink_powerpc64le) / 10000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b5 = RVA(blink_powerpc64le) < 100000 ? 32 : RVA(blink_powerpc64le) / 100000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b6 = RVA(blink_powerpc64le) < 1000000 ? 32 : RVA(blink_powerpc64le) / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b7 = RVA(blink_powerpc64le) < 10000000 ? 32 : RVA(blink_powerpc64le) / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b8 = RVA(blink_powerpc64le) < 100000000 ? 32 : RVA(blink_powerpc64le) / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_b9 = RVA(blink_powerpc64le) < 1000000000 ? 32 : RVA(blink_powerpc64le) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc64le_size_b0 = blink_powerpc64le_size % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b1 = blink_powerpc64le_size < 10 ? 32 : blink_powerpc64le_size / 10 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b2 = blink_powerpc64le_size < 100 ? 32 : blink_powerpc64le_size / 100 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b3 = blink_powerpc64le_size < 1000 ? 32 : blink_powerpc64le_size / 1000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b4 = blink_powerpc64le_size < 10000 ? 32 : blink_powerpc64le_size / 10000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b5 = blink_powerpc64le_size < 100000 ? 32 : blink_powerpc64le_size / 100000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b6 = blink_powerpc64le_size < 1000000 ? 32 : blink_powerpc64le_size / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b7 = blink_powerpc64le_size < 10000000 ? 32 : blink_powerpc64le_size / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b8 = blink_powerpc64le_size < 100000000 ? 32 : blink_powerpc64le_size / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc64le_size_b9 = blink_powerpc64le_size < 1000000000 ? 32 : blink_powerpc64le_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc_b0 = RVA(blink_powerpc) % 10 + 48);
-HIDDEN(blink_powerpc_b1 = RVA(blink_powerpc) < 10 ? 32 : RVA(blink_powerpc) / 10 % 10 + 48);
-HIDDEN(blink_powerpc_b2 = RVA(blink_powerpc) < 100 ? 32 : RVA(blink_powerpc) / 100 % 10 + 48);
-HIDDEN(blink_powerpc_b3 = RVA(blink_powerpc) < 1000 ? 32 : RVA(blink_powerpc) / 1000 % 10 + 48);
-HIDDEN(blink_powerpc_b4 = RVA(blink_powerpc) < 10000 ? 32 : RVA(blink_powerpc) / 10000 % 10 + 48);
-HIDDEN(blink_powerpc_b5 = RVA(blink_powerpc) < 100000 ? 32 : RVA(blink_powerpc) / 100000 % 10 + 48);
-HIDDEN(blink_powerpc_b6 = RVA(blink_powerpc) < 1000000 ? 32 : RVA(blink_powerpc) / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc_b7 = RVA(blink_powerpc) < 10000000 ? 32 : RVA(blink_powerpc) / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc_b8 = RVA(blink_powerpc) < 100000000 ? 32 : RVA(blink_powerpc) / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc_b9 = RVA(blink_powerpc) < 1000000000 ? 32 : RVA(blink_powerpc) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_powerpc_size_b0 = blink_powerpc_size % 10 + 48);
-HIDDEN(blink_powerpc_size_b1 = blink_powerpc_size < 10 ? 32 : blink_powerpc_size / 10 % 10 + 48);
-HIDDEN(blink_powerpc_size_b2 = blink_powerpc_size < 100 ? 32 : blink_powerpc_size / 100 % 10 + 48);
-HIDDEN(blink_powerpc_size_b3 = blink_powerpc_size < 1000 ? 32 : blink_powerpc_size / 1000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b4 = blink_powerpc_size < 10000 ? 32 : blink_powerpc_size / 10000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b5 = blink_powerpc_size < 100000 ? 32 : blink_powerpc_size / 100000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b6 = blink_powerpc_size < 1000000 ? 32 : blink_powerpc_size / 1000000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b7 = blink_powerpc_size < 10000000 ? 32 : blink_powerpc_size / 10000000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b8 = blink_powerpc_size < 100000000 ? 32 : blink_powerpc_size / 100000000 % 10 + 48);
-HIDDEN(blink_powerpc_size_b9 = blink_powerpc_size < 1000000000 ? 32 : blink_powerpc_size / 1000000000 % 10 + 48);
-
-HIDDEN(blink_s390x_b0 = RVA(blink_s390x) % 10 + 48);
-HIDDEN(blink_s390x_b1 = RVA(blink_s390x) < 10 ? 32 : RVA(blink_s390x) / 10 % 10 + 48);
-HIDDEN(blink_s390x_b2 = RVA(blink_s390x) < 100 ? 32 : RVA(blink_s390x) / 100 % 10 + 48);
-HIDDEN(blink_s390x_b3 = RVA(blink_s390x) < 1000 ? 32 : RVA(blink_s390x) / 1000 % 10 + 48);
-HIDDEN(blink_s390x_b4 = RVA(blink_s390x) < 10000 ? 32 : RVA(blink_s390x) / 10000 % 10 + 48);
-HIDDEN(blink_s390x_b5 = RVA(blink_s390x) < 100000 ? 32 : RVA(blink_s390x) / 100000 % 10 + 48);
-HIDDEN(blink_s390x_b6 = RVA(blink_s390x) < 1000000 ? 32 : RVA(blink_s390x) / 1000000 % 10 + 48);
-HIDDEN(blink_s390x_b7 = RVA(blink_s390x) < 10000000 ? 32 : RVA(blink_s390x) / 10000000 % 10 + 48);
-HIDDEN(blink_s390x_b8 = RVA(blink_s390x) < 100000000 ? 32 : RVA(blink_s390x) / 100000000 % 10 + 48);
-HIDDEN(blink_s390x_b9 = RVA(blink_s390x) < 1000000000 ? 32 : RVA(blink_s390x) / 1000000000 % 10 + 48);
-
-HIDDEN(blink_s390x_size_b0 = blink_s390x_size % 10 + 48);
-HIDDEN(blink_s390x_size_b1 = blink_s390x_size < 10 ? 32 : blink_s390x_size / 10 % 10 + 48);
-HIDDEN(blink_s390x_size_b2 = blink_s390x_size < 100 ? 32 : blink_s390x_size / 100 % 10 + 48);
-HIDDEN(blink_s390x_size_b3 = blink_s390x_size < 1000 ? 32 : blink_s390x_size / 1000 % 10 + 48);
-HIDDEN(blink_s390x_size_b4 = blink_s390x_size < 10000 ? 32 : blink_s390x_size / 10000 % 10 + 48);
-HIDDEN(blink_s390x_size_b5 = blink_s390x_size < 100000 ? 32 : blink_s390x_size / 100000 % 10 + 48);
-HIDDEN(blink_s390x_size_b6 = blink_s390x_size < 1000000 ? 32 : blink_s390x_size / 1000000 % 10 + 48);
-HIDDEN(blink_s390x_size_b7 = blink_s390x_size < 10000000 ? 32 : blink_s390x_size / 10000000 % 10 + 48);
-HIDDEN(blink_s390x_size_b8 = blink_s390x_size < 100000000 ? 32 : blink_s390x_size / 100000000 % 10 + 48);
-HIDDEN(blink_s390x_size_b9 = blink_s390x_size < 1000000000 ? 32 : blink_s390x_size / 1000000000 % 10 + 48);
-
 #if SupportsMetal()
 HIDDEN(v_ape_realsectors =
            MIN(0x70000 - IMAGE_BASE_REAL, ROUNDUP(RVA(_ezip), 512)) / 512);