;;;; src/cold-bootstrap-retained.lisp — BODY-UNREACHABLE kept on purpose.
;;;;
;;;; Copyright (c) 2026 Anthony Green <green@moxielogic.com>
;;;; SPDX-License-Identifier: GPL-2.0-only WITH Classpath-exception-2.0
;;;;
;;;; ADR 0019 step 2.5 — names that cold's main never reaches
;;;; statically, but that the release intentionally keeps because
;;;; user code, the REPL, hosted macros, or save/load image paths
;;;; can reach them at runtime.
;;;;
;;;; The two-way gate test asserts:
;;;;   BODY-UNREACHABLE ⇔ (cold-bootstrap-only.lisp ∪ this file)
;;;;
;;;; Per ADR 0019, cold-bootstrap-only.lisp lists names safe to
;;;; elide from the shipped binary (step 3 input).  This file lists
;;;; names that look orphaned to the strict-link analyzer but are
;;;; reachable through paths the analyzer doesn't see:
;;;;
;;;;   1. Inline-emitted primitives.  CAR, CDR, CONS, +, -, *, <,
;;;;      etc. are registered in *ag-fn-table* so a user's
;;;;      `(funcall #'+ x y)' resolves to a real fn-pointer, but
;;;;      call sites for these names compile to inline asm-* and
;;;;      never go through emit-ir-fn-call → no edge in
;;;;      *ag-call-graph-edges*.
;;;;
;;;;   2. CL standard library users will call.  FORMAT, FIND,
;;;;      HASH-TABLE-*, MAPHASH, EVAL, etc.  Cold's main doesn't
;;;;      touch them but every user program might.
;;;;
;;;;   3. Internal helpers reached only at runtime through the
;;;;      REPL eval-form path, hosted macro expansion, or save/
;;;;      load image — not from cold's `main' dispatch.
;;;;
;;;;   4. Gensyms (__G0__, __G1__) and the unresolved-call trap —
;;;;      compile-time scratch the analyzer happens to find in
;;;;      *ag-fn-table*.
;;;;
;;;; A finer-grained split (one file per category, with attribution
;;;; per name) would make the rationale easier to audit but isn't
;;;; load-bearing.  Today's flat list keeps the test simple.
;;;;
;;;; Regenerate via:
;;;;   make build/funcl-cold
;;;;   build/funcl-cold --tree-shake-report \
;;;;     <colon-list-of-COLD_SRCS> /tmp/out
;;;;   then copy the BODY-UNREACHABLE names sorted unique.
;;;;
;;;; Format: one symbol per line, ;-comments allowed.

%ASH
;; runtime helpers destructuring-bind's &key expansion emits (cave#53);
;; user code reaches them, cold's main never destructures &key.
%DBIND-GETF
%DBIND-GETF-WALK
%DBIND-GETF-P
%DBIND-GETF-P-WALK
;; positional optional accessor emitted by the &optional+&key defun
;; rewrite (cave#20); no cold caller destructures that combo.
%OPT-ARG
;; runtime helper the loop desugar emits for `across'
%LOOP-ACROSS-ELT
;; ANSI macro introspection — prelude wrappers over the compiler's
;; macroexpander; user/runtime code reaches them, cold's main never does
MACRO-FUNCTION
MACROEXPAND
MACROEXPAND-1
*
+
-
/
1+
1-
<
<=
=
>
>=
ACONS
ADJOIN
AG-BV-BYTE-AT-OR-ZERO
AG-COLD-COUNT-CAPPED
AG-COLD-IMAGE-BYTES-EQUAL-32-WALK
AG-COLD-IMAGE-EMIT-SECTION-ENTRY
;; ADR 0026 Phase C step 1 allocator: kept BODY-UNREACHABLE (the step-3 intern
;; caller was reverted — it broke function cells for reexported symbols). Still
;; REPL/runtime-reachable via the GC-visibility witness.
AG-DYNAMIC-SYMBOL-RECORD-ALLOCATE
AG-DEFSTRUCT-BUILD-CONSTRUCTOR
AG-DEFSTRUCT-BUILD-PREDICATE
AG-EMIT-DEFVAR-INITS
AG-GET-RUNTIME-CODE
AG-IMAGE-SHA256
AG-KEY-SPECS-TO-BINDINGS
AG-LIFT-LAMBDAS-BINDINGS
AG-LIFT-LAMBDAS-LET-FORM
AG-REPL-EMIT-USER-DEFPARAMETER
AG-RUNTIME-INTERN-STRING
AG-RUNTIME-INTERN-STATIC-SCAN
AG-RUNTIME-INTERN-TABLE-SCAN
AG-LOAD-MAGIC-OK
AG-LOAD-MAGIC-WALK
AG-QUOTED-EMIT-BYTES
AG-SYM-CONCAT-2
AG-SYM-CONCAT-3
AG-TREE-SHAKE-MEMBER
;; cave#266 perf: per-package own-symbol first-byte index, reached only
;; at runtime by find-symbol-in-pkg (gated on symbol-unification=1); the
;; cold self-compile keeps the linear walk, so these have no cold caller.
AG-OWN-IDX-KEY
AG-PKG-OWN-CELL
AG-PKG-OWN-CELL-FIND
AG-PKG-OWN-IDX-ABSORB
AG-PKG-OWN-IDX-FENCE-REACHABLE-P
AG-PKG-OWN-IDX-INSERT
AG-PKG-OWN-IDX-SYNC
AG-PKG-OWN-IDX-WALK
ALIST-LOOKUP
ALPHA-CHAR-P
ALPHANUMERICP
;; cave#54 character class predicates (user-facing stdlib, BODY-UNREACHABLE)
BOTH-CASE-P
GRAPHIC-CHAR-P
STANDARD-CHAR-P
APPEND
ARRAY-DIMENSION
ARRAY-DIMENSIONS
ARRAY-RANK
ARRAY-TOTAL-SIZE
ARRAYP
;; cave#95 array predicates/accessors + vector ctor (BODY-UNREACHABLE)
ADJUSTABLE-ARRAY-P
ARRAY-HAS-FILL-POINTER-P
ARRAY-ELEMENT-TYPE
UPGRADED-ARRAY-ELEMENT-TYPE
SIMPLE-VECTOR-P
BIT-VECTOR-P
SIMPLE-BIT-VECTOR-P
ARRAY-ROW-MAJOR-INDEX
ROW-MAJOR-AREF
ROW-MAJOR-ASET
ARRAY-IN-BOUNDS-P
ARRAY-IN-BOUNDS-WALK
VECTOR
VECTOR-FILL-ARGS
ASM-ADD-RCX-R12
ASM-AND-RCX-IMM8
ASM-CMOVE-RDX-RAX
ASM-CMOVG-RDX-RAX
ASM-CMOVGE-RDX-RAX
ASM-CMOVL-RDX-RAX
ASM-CMOVLE-RDX-RAX
ASM-INC-QWORD-AT-RBX
ASM-JNZ-REL8-BACK
ASM-LOAD-RAX-FROM-RAX-8
ASM-MOV-BYTE-BRACKET-RAX-DISP8-IMM8
ASM-MOV-RCX-FROM-RAX-DISP8
ASM-MOV-RDI-RBX
ASM-STORE-RBX-AT-RCX
ASM-SUB-RCX-R15
ASM-SUB-RCX-RBX
ASM-TEST-RAX-RAX
ASSOC
ASSOC-IF
ATOM
BOUNDP
BUTLAST
CAAAR
CAADR
CAAR
CADAR
CADDR
CADR
CAR
CDAAR
CDADR
CDAR
CDDAR
CDDDR
CDDR
CDR
CEILING
CHAR-DOWNCASE
CHAR-UPCASE
;; ANSI 13.2 character comparisons (cave#94/#54): user-facing stdlib,
;; no cold caller — all BODY-UNREACHABLE.  Case-sensitive (char=/</>/
;; <=/>=//=), case-folding (char-equal/-lessp/-greaterp/-not-*), and
;; their recursive *-walk / member-p helpers.
CHAR=
CHAR=-WALK
CHAR<
CHAR<-WALK
CHAR>
CHAR>-WALK
CHAR<=
CHAR<=-WALK
CHAR>=
CHAR>=-WALK
CHAR/=
CHAR/=-WALK
CHAR-CODE-MEMBER-P
CHAR-UP-CODE
CHAR-UP-CODE-MEMBER-P
CHAR-EQUAL
CHAR-EQUAL-WALK
CHAR-LESSP
CHAR-LESSP-WALK
CHAR-GREATERP
CHAR-GREATERP-WALK
CHAR-NOT-GREATERP
CHAR-NOT-GREATERP-WALK
CHAR-NOT-LESSP
CHAR-NOT-LESSP-WALK
CHAR-NOT-EQUAL
CHAR-NOT-EQUAL-WALK
CLRHASH
COMPLEMENT
CONSTANTLY
COMPOSE
CONDITION-REPORT
CANONICAL-STRING-INDEX-BUILD
CANONICAL-STRING-INDEX-BUILD-WALK
CSI-BUCKET-FIND
CSI-INTERN
CSI-INTERN-CANONICAL
CONS
CONSP
COPY-ALIST
COPY-ALIST-WALK
COPY-SYMBOL
COPY-TREE
COUNT
COUNT-IF
COUNT-IF-WALK
COUNT-WALK
DIGIT-CHAR-P
EMIT-ELF-EHDR-TINY
EMIT-ELF-PHDR-TINY
EMIT-IR-ONLY-DEFUNS
EMIT-PE-COFF-HEADER
EMIT-PE-OPTIONAL-HEADER
EMIT-PE-OPTIONAL-HEADER-WITH-HEAP
ENDP
;; Inline-only primitive/predicate wrappers (real defuns so #'X /
;; (symbol-function 'X) / (funcall 'X …) work); no cold caller — the inner
;; op is inlined at call sites.  All BODY-UNREACHABLE.
SYMBOLP
STRINGP
CHARACTERP
CHAR-CODE
CODE-CHAR
SVREF
SYMBOL-PACKAGE
FUNCTIONP
VECTORP
FIXNUMP
BIGNUMP
RATIOP
FLOATP
BYTE-VECTOR-P
NOT
FUNCALL
APPLY
%APPLY-ARGS
;; cave#142: funcallable cells for the variadic bitwise ops (folds use the
;; inline 2-arg op).  No cold caller — BODY-UNREACHABLE.
LOGAND
LOGIOR
LOGXOR
%LOGAND-FOLD
%LOGIOR-FOLD
%LOGXOR-FOLD
EQ
EQUAL
EQUAL-WALK
EVAL
;; cave#15: #. read-time-eval thunk + its safe-form guard + the bv-aware
;; backquote-IR evaluator, reached only via the reader's *ag-read-eval-fn*
;; funcall hook (no static caller) — all BODY-UNREACHABLE.
AG-READ-EVAL-FORM
%BQ-OP-P
%READ-EVAL-SAFE-P
%READ-EVAL-SAFE-LIST-P
%READ-EVAL-BQ
%READ-EVAL-BQ-LIST
%READ-EVAL-BQ-LIST*
EVAL-ASSOC-WALK
EVAL-LET-BIND
EVAL-LIST
EVAL-PROGN
EVENP
EVERY
FBOUNDP
FDEFINITION
FILE-EXISTS-P
FIND
FIND-IF
FIND-IF-NOT
FIND-IF-WALK
FIND-SYMBOL
FIND-SYMBOL-IN-PKG
FIND-SYMBOL-VIA-INDEX
FIND-SYMBOL-VIA-USES-WALK
FIND-SYMBOL-VIA-USES-WALK-D
FIND-SYMBOL-WALK
FIND-WALK
FIRST
FLOAT
FLOAT-RADIX
FLOOR
FFLOOR
FCEILING
FTRUNCATE
FROUND
FMAKUNBOUND
IMAGPART
REALPART
;; char-int / char-name (BODY-UNREACHABLE).  (`string' and the string=
;; designator/comparison chain are now LIVE — reached by the condition
;; hierarchy's string= type-name compares — so they are NOT declared dead.)
CHAR-INT
CHAR-NAME
NAME-CHAR
;; cave#94 print/write family (build on format): user-facing stdlib,
;; BODY-UNREACHABLE in the cold compiler.
PRIN1
PRINC
PRINT
PROCLAIM
TYPE-ERROR-DATUM
TYPE-ERROR-EXPECTED-TYPE
CELL-ERROR-NAME
SIMPLE-CONDITION-FORMAT-CONTROL
SIMPLE-CONDITION-FORMAT-ARGUMENTS
PPRINT
WRITE
TERPRI
FRESH-LINE
WRITE-CHAR
WRITE-LINE
;; no-op flushes (funcl output is unbuffered); user/CL code calls them,
;; cold's main never flushes explicitly (cave#233)
FINISH-OUTPUT
FORCE-OUTPUT
CLEAR-OUTPUT
WRITE-TO-STRING
FOURTH
FIFTH
SIXTH
SEVENTH
EIGHTH
NINTH
TENTH
GET-PROPERTIES
FUNCL-RAISE-ARITY-ERROR
;; cave#92: svref/vector-set bounds-error signaller — reached only from
;; emitted guard code (emit-bounds-error-call), like the others here.
FUNCL-RAISE-BOUNDS-ERROR
;; cave#92: car/cdr type-error signaller — reached only from emitted
;; guard code (emit-not-list-error-call), like funcl-raise-arity-error.
FUNCL-RAISE-NOT-LIST
;; cave#244: empty-fn-cell funcall fallback — reached only from the
;; emitted designator-call path (emit-ir-funcall's symbol arm), which
;; resolves it by name via ag-patch-add like the signallers above.
FUNCL-FUNCALL-FALLBACK
;; cave#92: svref/aref/vector-length/vector-set type-error signaller —
;; reached only from emitted guard code (emit-not-vector-error-call).
FUNCL-RAISE-NOT-VECTOR
;; cave#92: symbol-name/symbol-value type-error signaller — reached only
;; from emitted guard code (emit-not-symbol-error-call).
FUNCL-RAISE-NOT-SYMBOL
;; cave#92: char-code type-error signaller — reached only from emitted
;; guard code (emit-not-character-error-call).
FUNCL-RAISE-NOT-CHARACTER
;; cave#143: bitwise-op integer guard signaller — reached only from emitted
;; guard code (emit-not-integer-error-call).
FUNCL-RAISE-NOT-INTEGER
GC
GC-CLOSE-CURRENT-WINDOW
GC-ANOMALY-MAP-BYTE
GC-ANOMALY-WORD
GC-AUDIT-STACK
GC-AUDIT-WALK
GC-CARD-BYTE-ADDR
GC-CARD-REGION-DIRTY-P
GC-CARD-REGION-DIRTY-WALK
GC-CARD-DIRTY-P
GC-CARDS-CLEAR
GC-CARDS-CLEAR-REGION
GC-CARDS-CLEAR-WALK
GC-CHECK-ADDR-MARKED
GC-CHENEY-SCAN
GC-COLLECT-FULL
GC-COLLECT-MINOR
GC-DEGEN-COUNT
GC-CHECK-SLOT-MARKED
GC-CHECK-SLOT-RUN
GC-CLOSE-RUN
GC-COLLECT
GC-COLLECT-COUNT
GC-CONS-MOVABLE-P
GC-DIRTY-CARD-COUNT
GC-DIRTY-CARD-COUNT-WALK
GC-EVAC-ALLOC
GC-EVAC-COPY-WORDS
GC-EVAC-COUNT
GC-EVAC-DEBUG-FROM
GC-EVAC-DEBUG-SIZE
GC-EVAC-DEBUG-TO
GC-EVAC-GRAB-CONTIG-CHECK
GC-EVAC-GRAB-CONTIG-WALK
GC-EVAC-GRAB-WALK
GC-EVAC-SEAL-TAIL
GC-EVAC-TAG-CONTIG
GC-EVACUATE
GC-HEAL-LOG-APPEND
GC-HEAL-LOG-COUNT
GC-HEAL-LOG-MAYBE
GC-HEAL-LOG-NEW
GC-HEAL-LOG-OLD
GC-HEAL-LOG-RESET
GC-HEAL-LOG-SLOT
GC-HEAL-PINNED-REGIONS
GC-MINOR-LARGE-FIT-P
GC-MINOR-PIN-FIXPOINT
GC-REGION-YOUNG-ISH-P
GC-STACK-STALE-COUNT
GC-VIRGIN-MAX-CONTIG-WALK
GC-WINDOW-BASE-PAST-OLD
GC-WINDOW-LIMIT-FROM
GC-YOUNG-MAX-EXTENT-WALK
GC-FALLBACK-COUNT
GC-FRAME-LOOKUP-RETPC
GC-FROM-EXTENT
GC-HEADER-FORWARDED-P
GC-HEADER-LENGTH
GC-HEAL-OBJECT
GC-HEAL-REGION-OBJECTS
GC-HEAL-SLOT
GC-HEAL-SLOT-RUN
GC-FRAME-LOOKUP-RUNTIME
GC-FRAME-LOOKUP-STATIC
GC-FRAME-RECORD-DEPTH-AT
GC-FRAME-RECORD-INDEX-FOR-PC
GC-FRAME-RECORD-MASK-AT
GC-FRAME-RECORD-NSLOTS-AT
GC-FRAME-RECORD-PC-AT
GC-FRAME-RECORD-WORD0
GC-FRAME-TABLE-COUNT
GC-FRAME-TABLE-VADDR
GC-INSTALL-WINDOW
GC-KEYWORD-POOL-RANGE-COUNT
GC-KEYWORD-POOL-RANGE-START
GC-LAST-FREED
GC-MARK-ADDR
GC-MARK-CONSERVATIVE
GC-MARK-DRAIN
GC-MARK-MASKED-REG
GC-MARK-MASKED-REGS
GC-MARK-MAYBE
GC-MARK-MAYBE-NOTING
GC-MARK-OBJECT
GC-MARK-POOL-RANGE
GC-MARK-PUSH
GC-MARK-REGISTRY
GC-MARK-REPL-DEFVAR-SLOTS
GC-MARK-ROOTS
GC-MARK-SLOT-RANGE
GC-MARK-SLOT-RUN-WALK
GC-MARK-STACK
GC-MARK-STACK-FALLBACK
GC-MARK-STACK-WORDS
GC-MARK-STATIC-ROOTS
GC-LIST-CONS-BASE
GC-LIST-FIELD
GC-MAP-CLEAR-SPAN
GC-MARK-VALUE
GC-MARK-VALUE-WALK
GC-MINOR-COUNT
GC-MINOR-ENABLE
GC-NEXT-START
GC-OBJECT-MOVABLE-P
GC-OBJECT-POINTER-SLOT-COUNT
GC-OBJECT-SIZE-FROM-HEADER
GC-RESOLVE-CONS-BASE
GC-SCAN-DIRTY-OLD-REGIONS
GC-SLOT-REF
GC-SLOT-SET
GC-PACKED-DEPTH
GC-PACKED-MASK
GC-PACKED-NSLOTS
GC-PRECISE-FRAMES
GC-PRECISE-MARK-COUNT
GC-PRECISE-STACK-CHECK
GC-RECLAIM-NOTE-RUN
GC-RECLAIM-YOUNG-REGIONS
GC-REGION-COUNT-KIND
GC-REGION-COUNT-KIND-WALK
GC-REGION-END-OF
GC-REGION-INDEX
GC-REGION-KIND-AT
GC-REGION-SET-KIND
GC-REGION-SYNC-ENTITIES
GC-REGION-TAG-SPAN-WALK
GC-REGION-TAG-SPAN-YOUNG
GC-REGION-SYNC
GC-STALE-CHECK-OBJECT
GC-STALE-CHECK-POOL
GC-STALE-CHECK-RANGE
GC-STALE-CHECK-REGISTRY
GC-STALE-CHECK-REPL-DEFVARS
GC-STALE-CHECK-RUN
GC-STALE-CHECK-SLOT
GC-STALE-CHECK-STATICS
GC-STALE-COUNT
GC-STALE-SCAN-OLD-REGIONS
GC-STALE-SCAN-REGION
GC-STALE-SLOT
GC-STALE-WORD
GC-START-KIND-AT
GC-START-MAP-BYTE-ADDR
GC-STATIC-ROOT-VADDR-AT
GC-STRESS
GC-SWEEP-EXTENT-END
GC-SWEEP-FINISH
GC-SWEEP-WALK
GC-VERIFY-CARD-SLOT
GC-VIRGIN-AT-LEAST-P
GC-VERIFY-CARD-SLOT-RUN
GC-VERIFY-CARDS
GC-VERIFY-CARDS-OBJECT
GC-VERIFY-CARDS-WALK
GC-VERIFY-HEAP
GC-VISIT-SLOT
GC-VISIT-SLOT-RUN
GC-VISIT-SLOT-WALK
GC-WALK-STACK-PRECISE
GC-VERIFY-OBJECT
GC-VERIFY-TO-SPACE
GC-WALK-ANOMALY-COUNT
GC-WALK-MARK
GC-WALK-HEAP
GENSYM
GENTEMP
GET
GETF
GETHASH
HASH-BV-LOOP
HASH-OF
SXHASH
REALP
LIST-ALL-PACKAGES
;; cave#19: hash-table accessor helpers (marker-discriminated rep)
HT-NBUCKETS
HASH-TABLE-KEYS
HASH-TABLE-VALUES
HT-BUCKET-KEYS
HT-BUCKET-VALUES
IDENTITY
;; environment-inquiry fns (cave#253 residual): asdf/user code calls
;; them (implementation-identifier -> FASL cache dir); cold never does.
LISP-IMPLEMENTATION-TYPE
LISP-IMPLEMENTATION-VERSION
INTEGER-DECODE-FLOAT
INTEGERP
INTERN
INTERN-STRING
INTERSECTION
INVOKE-RESTART
KEYWORDP
LAST
LCM
;; cave#76 numeric (logbitp/logcount/isqrt + helpers): BODY-UNREACHABLE
LOGBITP
LOGCOUNT
LOGANDC1
LOGANDC2
LOGORC1
LOGORC2
LOGNAND
LOGNOR
LOGEQV
LOGTEST
LDB-TEST
LOGCOUNT-BITS
ISQRT
ISQRT-ITER
;; cave#89 random / random-state: user-facing stdlib, no cold caller —
;; BODY-UNREACHABLE.  xorshift32 PRNG over a (CONS :random-state SEED).
RANDOM
MAKE-RANDOM-STATE
RANDOM-STATE-P
%XORSHIFT32
%RANDOM-NEXT
LIST*
LIST*-WALK
;; LOAD is now a function (was a macro) so (apply 'load …) works for asdf;
;; the REPL intercepts top-level (load …), so no cold caller — BODY-UNREACHABLE.
LOAD
LOAD-FILE-AT-RUNTIME
LOWER-CASE-P
MAKE-BUCKET-LIST
MAKE-DIVISION-BY-ZERO
MAKE-HASH-TABLE
MAKE-PROGRAM-ERROR
MAKE-SIMPLE-ERROR
MAKE-UNDEFINED-FUNCTION-ERROR
MAKUNBOUND
MAPAPPEND
MAPC
MAPCAN
MAPCAR
MAPHASH
MAPHASH-BUCKET
MAPHASH-WALK
MAX
MEMBER
MEMBER-IF
;; cave#90/alexandria list utilities (additive): BODY-UNREACHABLE.
MEMBER-IF-NOT
ASSOC-IF-NOT
RASSOC
RASSOC-IF
RASSOC-IF-NOT
MAPLIST
MAPL
ASH
MAPCON
PROPER-LIST-P
MIN
MINUSP
MOD
MV-EXTRAS-WALK
NAMESTRING
NCONC
NRECONC
NTH
NTH-CONS
NULL
ODDP
PAIRLIS
PLIST-HAS
PLIST-PUT
PROGV-RESTORE
PROGV-SAVE
PROGV-SET
PUT
PARSE-INTEGER
PATHNAME
PATHNAMEP
PE-IDATA-FILE-OFFSET-OR-DEFAULT
PLUSP
POOL-RECORD-ACCESSIBLE-P
POSITION
POSITION-WALK
READ-FILE-TO-BV
READER-BV-EQ
READER-BV-EQ-WALK
READER-READ-DIGITS
READER-READ-INTEGER
READER-UNQUOTE-BV
READER-UNQUOTE-SPLICING-BV
REDUCE
REDUCE-WALK
REDUCE-WALK-FE
REM
REMHASH
REMHASH-FROM-BUCKET
REMHASH-WALK-CHAIN
REMOVE
REMOVE-IF
REMOVE-IF-NOT
REMOVE-IF-WALK
REMOVE-WALK
REPLACE
REPLACE-LIST-INPLACE
REPLACE-STR-INPLACE
REPLACE-VEC-INPLACE
REST
REVAPPEND
ROUND
SECOND
SET-DIFFERENCE
SETHASH
SIGNUM
;; ANSI 17 sequence functions (cave#90): user-facing stdlib, no cold
;; caller — BODY-UNREACHABLE.  notany/notevery, count-if-not, the
;; position-if(-not) walkers, substitute family, delete family (fresh-
;; cons), and remove/delete-duplicates.
NOTANY
NOTEVERY
COUNT-IF-NOT
POSITION-IF
POSITION-IF-WALK
POSITION-IF-NOT
POSITION-IF-NOT-WALK
SUBSTITUTE
SUBSTITUTE-IF
SUBSTITUTE-IF-WALK
SUBSTITUTE-WALK
SUBSTITUTE-IF-NOT
DELETE
DELETE-IF
DELETE-IF-NOT
REMOVE-DUPLICATES
REM-DUP-MEMBER
REM-DUP-WALK
DELETE-DUPLICATES
SOME
STRING-EQUAL
STRING-EQUAL-WALK
EQUALP
;; ANSI 16.3 string ordering comparisons (cave#94): user-facing stdlib,
;; no cold caller — BODY-UNREACHABLE.  string-cmp / string-cmp-ci are
;; the shared lexicographic walkers; string-byte-up upcases one byte.
STRING<
STRING>
STRING<=
STRING>=
STRING/=
STRING-CMP
STRING-CMP-CI
STRING-CMP2-CI
%SCMP-CI
STRING-LESSP
STRING-GREATERP
STRING-NOT-GREATERP
STRING-NOT-LESSP
STRING-NOT-EQUAL
;; cave#94 string case conversion + trimming (fresh strings via
;; %alloc-string-bv): user-facing stdlib, BODY-UNREACHABLE.
STRING-UPCASE
STRING-UPCASE-WALK
STRING-DOWNCASE
STRING-DOWNCASE-WALK
STRING-CAPITALIZE
STRING-CAPITALIZE-WALK
NSTRING-UPCASE
NSTRING-DOWNCASE
NSTRING-CAPITALIZE
STRING-BYTE-ALNUM-P
STRING-TRIM
STRING-LEFT-TRIM
STRING-RIGHT-TRIM
STRING-TRIM-L
STRING-TRIM-R
STRING-BAG-HAS-P
STRING-BAG-HAS-WALK
STRING-COPY-RANGE
STRING-COPY-RANGE-WALK
STRING-LENGTH
;; cave#94 string constructors + simple/base predicates: user-facing
;; stdlib, no cold caller — BODY-UNREACHABLE.  make-string fills via
;; make-string-fill; schar/simple-*-p reduce to char/stringp.
SCHAR
MAKE-STRING
MAKE-STRING-FILL
SIMPLE-STRING-P
BASE-STRING-P
SIMPLE-BASE-STRING-P
;; eql + list/tree functions (cave#90/#76): user-facing stdlib, no cold
;; caller — BODY-UNREACHABLE.  Includes the merge-sort and *-walk helpers.
EQL
MAKE-LIST
MAKE-LIST-WALK
LIST-LENGTH
NBUTLAST
LDIFF
TAILP
SUBST
SUBST-IF
SUBST-IF-NOT
NSUBST
SUBLIS
NSUBLIS
NUNION
NINTERSECTION
NSET-DIFFERENCE
SET-EXCLUSIVE-OR
NSET-EXCLUSIVE-OR
MISMATCH
MISMATCH-WALK
TREE-EQUAL
SORT
STABLE-SORT
SORT-MERGE
SORT-TAKE
SORT-DROP
SUBSEQ-FROM-WALK
SUBTYPEP
SUBTYPEP-ANCESTOR-P
SUBTYPEP-CANON
SUBTYPEP-SUPER
SUBTYPEP-BOUND-OK-P
SUBTYPEP-NUM-BOUNDS
SUBTYPEP-NUM-EXPAND
SUBTYPEP-NORM-INT-BOUND
SUBTYPEP-NUM-NORM
SUBTYPEP-KIND-SUB-P
SUBTYPEP-BOUND-VAL
SUBTYPEP-BOUND-EXCL
SUBTYPEP-LOW-COVERS
SUBTYPEP-HIGH-COVERS
SUBTYPEP-RANGE-SUB-P
SUBTYPEP-INTERVAL-EMPTY-P
SUBTYPEP-NUMERIC
;; cave#94/#90 generic sequence access (elt) + string<->list coercion
;; (coerce / concatenate) + string subseq/reverse helpers: user-facing
;; stdlib, no cold caller — BODY-UNREACHABLE.
ELT
COERCE
CONCATENATE
%STRING->LIST
%STRING->LIST-WALK
%SEQ->LIST
%SEQ-LIKE
%ANY-NULL
%CARS
%CDRS
%MAPCAR-1
%MAPCAR-N
%MAPC-1
%MAPC-N
%SOS-WRITE-CHAR
MAKE-STRING-OUTPUT-STREAM
GET-OUTPUT-STREAM-STRING
WRITE-STRING
%SIS-P
%SIS-STR
%SIS-POS
%SIS-SET-POS
%SIS-EOF-P
%STREAM-EOF-VALUE
%READ-LINE-WALK
MAKE-STRING-INPUT-STREAM
READ-CHAR
PEEK-CHAR
READ-LINE
%MEMBER-TEST-P
%SUBSETP-WALK
%CHT-ALIST
%CHT-BUCKETS
SUBSETP
BYTE
BYTE-SIZE
BYTE-POSITION
LDB
DEPOSIT-FIELD
DPB
MASK-FIELD
COPY-HASH-TABLE
%TYPE-STRING-P
%TYPE-LIST-P
;; cave#90 make-sequence / fill / map: user-facing stdlib, BODY-UNREACHABLE.
MAKE-SEQUENCE
FILL
%FILL-STRING
%FILL-VECTOR
MAP
%MAP-LISTS
%TYPE-VECTOR-P
;; cave#90 copy-seq / search / nsubstitute / merge: BODY-UNREACHABLE.
COPY-SEQ
%COPY-VECTOR-WALK
SEARCH
%PREFIX-AT
%SEARCH-WALK
NSUBSTITUTE
NSUBSTITUTE-IF
NSUBSTITUTE-IF-NOT
%NSUBST-WALK
MERGE
%MERGE-WALK
;; cave#90 vector support for subseq/reverse + %seq->list: BODY-UNREACHABLE.
%VECTOR->LIST
%VECTOR->LIST-WALK
SYM-PLIST-ENTRY
SYMBOL-PLIST
THIRD
TRUNCATE
TYPE-OF
TYPEP
TYPEP-AND
TYPEP-BOUND-HIGH
TYPEP-BOUND-LOW
TYPEP-COMPOUND
TYPEP-INT-RANGE
TYPEP-REAL-RANGE
TYPEP-MEMBER
TYPEP-OR
UNION
RPLACA
UPPER-CASE-P
WHITESPACE-CHAR-P
WRAP-CODE-AS-ELF-TINY
WRAP-CODE-AS-PE
ZEROP
;; Phase 4 bignum printing.  Stage C wired the %GENERIC-* dispatchers
;; into the +/-/*/compare emit (via emit-generic-binop-call, which logs
;; an ag-edge-add DIRECT-CALL edge), so the whole arithmetic cluster is
;; now STATICALLY reachable and no longer listed here.  These four
;; print helpers are reached only from fmt-print-thing, which the cold
;; build's main never calls, so they remain BODY-UNREACHABLE.
;; Phase 4 floats (F3/F4). The FMT-* single-float helpers are reached
;; only via fmt-print-thing (cold main never prints). All BODY-
;; UNREACHABLE.  (NUMBERP dropped off this list in cave#92: %need-number
;; — reached from the statically-live %generic-+/-/* — now calls it, so
;; it is reachable.  %GENERIC-DIV stays dead: it is reached only via `/',
;; and no COLD source calls `/'.  The prelude's `expt' uses `/', but the
;; prelude is NOT in COLD_SRCS (it is loaded/compiled at runtime), so it
;; contributes no cold static edge — a fresh tree-shake confirms
;; %GENERIC-DIV is BODY-UNREACHABLE.)
%GENERIC-DIV
;; Shortest round-trip float printing (Burger-Dybvig). single->string
;; and its helpers are reached only via fmt-print-single / the warm
;; ag-print-float, neither on the cold main path. All BODY-UNREACHABLE.
;; Phase 4 ratios. R4 made ratio-add/-sub/-mul reachable (via the
;; %generic-+/-/* edges), so MAKE-RATIONAL / NUMERATOR / DENOMINATOR
;; (and GCD/ABS) became statically reachable and dropped off this list.
;; RATIO-DIV is reached only from %GENERIC-DIV (no reachable cold `/'),
;; so it stays. RATIONALP has no cold caller; the FMT-* ratio helpers
;; are reached only via fmt-print-thing. All BODY-UNREACHABLE.
RATIO-DIV
RATIONAL
RATIONALIZE
RATIONALP
FLOAT-DIGITS
FLOAT-PRECISION
FLOAT-SIGN
SCALE-FLOAT
SQRT
SQRT-NEWTON
CONJUGATE
INTEGER-LENGTH
INTEGER-LENGTH-LOOP
DECODE-FLOAT
;; Phase 5 C1 catch/throw. These throw-token helpers are reached only
;; from CATCH/THROW macro expansions; no cold source uses catch/throw,
;; so they're BODY-UNREACHABLE here.
%MAKE-THROW-TOKEN
THROW-TOKEN-P
THROW-TOKEN-TAG
THROW-TOKEN-VALUE
;; Phase 5 conditions: the remaining statically-dead helpers.  Most of
;; the C2 hierarchy (condition-typep, cond-*-subtypep, cond-direct/user-
;; parents, cond-type-name) and signal + its cluster walkers became
;; reachable in C5, once `error' = signal + %raise pulled the whole
;; signal → condition-typep dispatch into cold's static graph.  Only
;; these two stay cold-dead: COND-NAMES (a print helper) and
;; %register-condition (reached only from define-condition expansions).
COND-NAMES
%REGISTER-CONDITION
;; Phase 5 C4: restart system — restart-case / invoke-restart and the
;; standard restart functions, reached only at runtime from user code.
%COMPUTE-RESTARTS
%FIND-RESTART
%FIND-RESTART-IN
%MAKE-RESTART
%MAKE-RESTART-RESULT
%RESTART-INDEX
%RESTART-NAME-EQ
%RESTART-RESULT-ARGS
%RESTART-RESULT-INDEX
%RESTART-RESULT-P
%RESTART-TAG
ABORT
COMPUTE-RESTARTS
CONTINUE
FIND-RESTART
MUFFLE-WARNING
RESTART-NAME
STORE-VALUE
USE-VALUE
;; Phase 5 C5: error (= signal then %raise), warn, cerror, invoke-debugger
;; and the restart printer — all reached only at runtime from user code.
WARN
CERROR
INVOKE-DEBUGGER
%PRINT-RESTARTS
;; Lifted-lambda gensyms with no static caller — reached only at runtime
;; via the restart dispatch's apply (warn/cerror's restart-case +
;; muffle-warning/continue clause lambdas, the first prelude uses of
;; restart-case).  C5 made the earlier __G0__/__G1__ reachable (the
;; condition machinery they belonged to is now live via `error'), leaving
;; these four.  The numbers shift when prelude macro-expansion gensym
;; counts change — regenerate from the tree-shake report on the next edit.
__UNRESOLVED-CALL-TRAP__
;; ADR 0022 steps 1 + 2: GDB JIT v1 protocol.  The hook
;; (lowercase, pipe-escaped name) is never called by funcl — gdb sets
;; an internal breakpoint here.  The descriptor accessor + the
;; registration helpers in src/cold/jit-dwarf.lisp are reached only
;; from runtime emit pipelines (step 2 follow-up will wire them); the
;; tree-shake analyzer can't see those edges, so list each
;; deliberately-kept name here.  When step 2's REPL/file-compile
;; wiring lands, the BUILDER-ENTRY (AG-JIT-REGISTER-BATCH) will pick
;; up a real caller and the rest will become statically reachable
;; through it — these entries can move to the cold-bootstrap-only
;; manifest at that point.
;; cave#50 multiple-value producers: values-list spreads a runtime list
;; into *mv-buf* (vl-store-extras is its walker).  User-facing stdlib with
;; no cold caller — BODY-UNREACHABLE.  multiple-value-call / -prog1 / -setq
;; are macros and never appear here.
VALUES
VALUES-LIST
VL-STORE-EXTRAS

;; cave#104: member / assoc gained CL's :test / :key (member-walk /
;; assoc-walk are their inner walkers).  User-facing stdlib with no cold
;; caller — BODY-UNREACHABLE.
MEMBER-WALK
ASSOC-WALK
;; ADR-0026-adjacent ANSI fix: remf's plist-rebuild helper (the REMF macro
;; expands away; only this defun is BODY-UNREACHABLE). User-facing stdlib.
%REMF-PAIR
;; ANSI remprop (remove a property from a symbol's plist). User-facing stdlib.
REMPROP


;; ---- 2026-07-02 re-arm (cave#151): the July campaign batch ----
;; Condition readers (#199), file streams (#189/#193), *features*
;; (#202), /= + vector coerce/typep + median deps (#203), keyword
;; one-door runtime helpers (#155), escaping-block machinery
;; runtime-reached halves (#148), fence-index internals (#188),
;; image-saver hashes (#138), deftype registry, eval/defun (#174).
;; All user-facing stdlib or runtime/REPL-path helpers with no
;; static cold caller.
%C-PATH
%CALL-TO-FUNCALL
%CALL-TO-FUNCALL-LIST
%COND-ASSOC-NAME
%COND-FIND-SLOT
%COND-FIND-SLOT-IN
%COND-FIND-SLOT-PARENTS
%COND-INITARG-OR
%COND-INSTALL-ONE-READER
%COND-INSTALL-READER-PLIST
%COND-INSTALL-READERS
%COND-INSTALL-SLOT-READERS
%COND-PLIST-GET
%COND-PLIST-PROBE
%COND-REPORT-OPTION
%COND-SLOT-NAME
%COND-SLOT-OPT
%CONDITION-SLOT-VALUE
%COPY-FILE
%COPY-FILE-LOOP
%DEFINE-CONDITION-RUNTIME
%DEFTYPE-BUILTIN
%DEFTYPE-ENTRY
%DEFTYPE-EXPAND
%DEFTYPE-REGISTER
%EVAL-DEFUN
%EVERY1
%EVERYN
%FOS-PATH-ENTRY
%GETF-CELL
%LAST-2PTR
%LIST->VECTOR
%LIST->VECTOR-FILL
%NE-AGAINST-ALL
%NE-PAIRS
%PUT-GETF
%READ-SEQ-WALK
%REGISTER-CONDITION-REPORT
%REGISTER-CONDITION-SLOTS
%RESPEC
%SEQS-ANY-NULL
%SEQS-CARS
%SEQS-CDRS
%SOME1
%SOMEN
%SYNC-FEATURES
%USES-CL-BY-NAME-P
%WRITE-SEQ-BV-WALK
%WRITE-SEQ-VEC-WALK
/=
AG-FIND-KEYWORD
AG-SET-HOSTED-BAIL-LOUD
AG-SET-RF-TRACE
AG-SOURCE-POSITIONS-RESET
BUCKET-TREE-CELL
CLOSE
COPY-FILE
CSI-BUCKET-CELL
DOCUMENTATION
FILE-LENGTH
MAKE-BUCKET-TREE
OPEN
POOL-RECORD-ACCESSIBLE-FROM-P
READ-BYTE
READ-FROM-STRING
READ-SEQUENCE
SETF-DOCUMENTATION
STREAM-ELEMENT-TYPE
WRITE-SEQUENCE

;; conditions design step 6 (find-class shim) — user-facing, no cold caller
FIND-CLASS
%CONDITION-CLASS-NAME-P

;; cave#204 :report wiring — warm-only report path helpers
%COND-REPORT-NORMALIZE
%CONDITION-REPORT-FOR
%CONDITION-REPORT-PARENTS
%CONDITION-REPORT-RENDER

;; cave#205 package API surface + do-symbols (all user-facing, no cold callers)
PACKAGE-NAME
PACKAGE-NICKNAMES
PACKAGE-SHADOWING-SYMBOLS
PACKAGE-USE-LIST
PACKAGE-USED-BY-LIST
MAKE-PACKAGE
RENAME-PACKAGE
USE-PACKAGE
UNUSE-PACKAGE
UNINTERN
EXPORT
UNEXPORT
IMPORT
SHADOWING-IMPORT
SHADOW
DELETE-PACKAGE
%PKG-ARG
%PKG-LISTIFY
%PKG-USED-BY-WALK
%USE-PACKAGE-WALK
%PKG-REMOVE-USE
%UNUSE-PACKAGE-WALK
%PKG-ALIST-REMOVE
%EXPORT-WALK
%PKG-NAME-REMOVE
%UNEXPORT-WALK
%IMPORT-WALK
%SHADOWING-IMPORT-WALK
%SHADOW-WALK
%PKG-LIST-REMOVE
%PKG-OWN-SYMBOLS-WALK
%PKG-EXTERNAL-WALK
%PKG-EXTERNAL-SYMBOLS
%PKG-INHERITED-SYMBOLS
%PKG-ACCESSIBLE-SYMBOLS

;; cave#234-followup: compile-file-pathname (asdf output-files calls it to
;; name a cl-source-file's fasl). User-facing stdlib, no cold caller.
COMPILE-FILE-PATHNAME
;; cave#236-followup: real file timestamps for asdf compute-action-stamp
;; (stat(2)/time(2) via %sys-stat/%sys-time inline primitives).
FILE-WRITE-DATE
GET-UNIVERSAL-TIME
%BV-U32-AT

;; cave#235: pathnames are a DISTINCT type.  The rewritten pathname layer
;; (record constructor/accessors + namestring parsers/builder + coercion +
;; the public CL API) is user/runtime-facing with no cold caller.  The old
;; string-based layer was spuriously cold-reachable through a now-removed
;; edge, which also kept its transitive deps (%getenv, %typep-base, provide/
;; require, %check-type-fail, …) live; with the rewrite they are correctly
;; BODY-UNREACHABLE.  (Build is byte-identical self-host, so no regression.)
%PATH-COERCE
%MP-HAS
%MAKE-PN
%PN-NS
%PN-HOST
%PN-DEVICE
%PN-DIRECTORY
%PN-NAME
%PN-TYPE
%PN-VERSION
%PN-NS-BUILD
%NS-DIR-STRING
%NS-FILE-STRING
%NS-NAME
%NS-TYPE
%NS-DIRECTORY
%PATH-LAST-SLASH
%PATH-BASE-DOT
%PATH-SPLIT-DIR
%PATH-DIR-LIST->STRING
%PATH-DIR-JOIN
%PATH-COMP->STRING
MAKE-PATHNAME
MERGE-PATHNAMES
DIRECTORY-NAMESTRING
FILE-NAMESTRING
HOST-NAMESTRING
PATHNAME-NAME
PATHNAME-TYPE
PATHNAME-DIRECTORY
PATHNAME-HOST
PATHNAME-DEVICE
PATHNAME-VERSION
PARSE-NAMESTRING
ENOUGH-NAMESTRING
TRANSLATE-PATHNAME
TRANSLATE-LOGICAL-PATHNAME
PATHNAME-MATCH-P
WILD-PATHNAME-P
PROBE-FILE
TRUENAME
USER-HOMEDIR-PATHNAME
%GETENV
%GETENV-ENVIRON-SCAN
%ENVIRON-KEY-MATCH
%ENVIRON-NEXT-NUL
%ENVIRON-VALUE-STR
%ENVIRON-COLLECT
%TYPEP-BASE
%TYPEP-MEMBER-ONE
%CHECK-TYPE-FAIL
%ASSERT-FAIL
COMPILE-FILE
COMPILE-FILE-PATHNAME
%FASL-OUTPUT-NAMESTRING
%FASL-OUT-SCAN
%COND-APPLIES-P
%MC-ACCESSOR-FALLBACK
%APPEND-LIST
%MODULE-NAME-STR
%MODULE-PRESENT-WALK
%PKG-NICKS-FOR
%PKG-REGISTER-NICKNAME
%PKG-REGISTER-NICKNAMES
ENSURE-PACKAGE
PROVIDE
REQUIRE
ASM-CMP-RAX-IMM32
AG-MACRO-KNOWN-P
%SPECIAL-OPERATOR-NAME-P
SPECIAL-OPERATOR-P
CONSTANTP
%CONDITION-IMAGE-TABLES
%CONDITION-IMAGE-RESTORE-TABLES
DIRECTORY
%DIRENT-RECLEN
%DIRENT-NAME-COPY
%DIRENT-NAME
%DIR-COMP-MATCH
%DIR-NAME-MATCHES
%DIR-COLLECT
%DIR-PARSE-BUF
%DIR-GETDENTS-LOOP
%EDX-COPY
%EDX-MKDIR-PREFIX
%EDX-WALK
ENSURE-DIRECTORIES-EXIST
%BV-DATA-ADDR
%ENVIRON-SKIP-TO-NEXT
%ENVIRON-PTR-WALK
%RP-CSTR
%FUNCL-RUN-PROGRAM

;; ---- 2026-07-13 manifest refresh (cave#299/#300 lineage) ----
;; Mechanically synced to the BODY-UNREACHABLE set after the July
;; fasl campaign (ADR-0030 KIND relocs, pack-mode loader, splice).
;; G-numbered entries are dead lifted-lambda gensyms from cold macro
;; expansions — deterministic for unchanged sources; expect 1-line
;; churn here when cold sources shift them.
%BUTLAST-TAKE
%DIV-WALK
%EQUALP-VEC
%FILL-LIST-RANGE
%INTERSECTION-WALK
%LAST-ADVANCE
%LCM-WALK
%LCM2
%MAP-INTO-LIST-WALK
%MAP-INTO-VEC-WALK
%MAPCAN-1
%MAPCAN-N
%MAPCON-1
%MAPCON-N
%MAPLIST-1
%MAPLIST-N
%MAX-WALK
%MIN-WALK
%MINUS-WALK
%NCONC-WALK
%NCONC2
%PAIRLIS-WALK
%PERF-COLLECT
%PERF-COLLECT-FN-TABLE
%PERF-EMIT-LINES
%PERF-LT
%PERF-NAME-STR
%PERF-PID
%PERF-PID-WALK
%PI-DIGIT-WEIGHT
%PI-DIGITS
%PI-GETKEY
%PI-SIGNBYTE
%PI-SKIP-WS
%PI-WS-P
%PLUS-WALK
%SEQS->LISTS
%SET-DIFF-WALK
%SET-IN
%SORT-LIST
%STDOUT-STREAM-P
%TIMES-WALK
%TYPE-FLOAT-P
%UNION-WALK
AG-FN-KEY
AG-FN-NAME-EQ
AG-SYM-PKG-SCOPED-P
ASM-ADD-RAX-R12
ASM-MOV-RDX-RBX
BOOLE
GC-BYTES-CONSED
GC-CARDS-DIRTY-SPAN
GC-CARDS-DIRTY-SPAN-WALK
GC-CENSUS-ACCOUNT
GC-CENSUS-ROW
GC-CENSUS-WALK
GC-CENSUS-ZERO
GC-DEMOTE-CANDIDATES
GC-DEMOTE-EMPTY-OLD-REGIONS
GC-DEMOTE-FINISH
GC-DEMOTE-TOUCH-SPAN
GC-DEMOTE-WALK
GC-ENV-ENTRY-MATCHES-WALK
GC-ENV-NAME-BYTE
GC-EVAC-GRAB-FLOOR
GC-FRAME-RECORD-INDEX-FOR-PC-BSEARCH
GC-GATE-FIT-COUNT
GC-GATE-VIRGIN-COUNT
GC-HEAP-CENSUS
GC-MAP-CLEAR-SPAN-U8
GC-MAP-CLEAR-SPAN-U8-WALK
GC-MAP-CLEAR-U64-WALK
GC-MARK-PENDING-POOL
GC-MARK-PENDING-RECORDS
GC-MAX-HEAP-CAP
GC-MAX-HEAP-ENV-WALK
GC-MAX-HEAP-HIT-P
GC-MAX-HEAP-PARSE-WALK
GC-MINOR-ENABLED
GC-PIN-MAYBE
GC-PIN-SPAN
GC-PIN-STACK-CONSERVATIVE
GC-PIN-STACK-WORD
GC-STATS
GC-TRUNCATE-COVERING-BLOCK
GC-TRUNCATE-COVERING-BLOCK-WALK
GC-VALIDATE-POOLS
GC-VP-WALK
GC-WINDOW-FIT-FROM
INTERN-PKG-SCOPED-P
MAP-INTO
READ
READER-INTERN-IN-CURRENT-PACKAGE
SAVE-PERF-MAP
SETF-CAAAAR
SETF-CAAADR
SETF-CAAAR
SETF-CAADAR
SETF-CAADDR
SETF-CAADR
SETF-CAAR
SETF-CADAAR
SETF-CADADR
SETF-CADAR
SETF-CADDAR
SETF-CADDDR
SETF-CADDR
SETF-CADR
SETF-CDAAAR
SETF-CDAADR
SETF-CDAAR
SETF-CDADAR
SETF-CDADDR
SETF-CDADR
SETF-CDAR
SETF-CDDAAR
SETF-CDDADR
SETF-CDDAR
SETF-CDDDAR
SETF-CDDDDR
SETF-CDDDR
SETF-CDDR
SETF-CHAR
SETF-EIGHTH
SETF-ELT
SETF-FIFTH
SETF-FIRST
SETF-FOURTH
SETF-NINTH
SETF-REST
SETF-SCHAR
SETF-SECOND
SETF-SEVENTH
SETF-SIXTH
SETF-SUBSEQ
SETF-TENTH
SETF-THIRD
__G24__
__G25__
__G26__
__G27__
__G28__
__G29__
__G33__
__G37__
__G38__
__G39__