SB-KERNEL

WORD-LOGICAL-ORC1 names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

REDEFINITION-WITH-DEFMACRO names the condition-class #<SB-PCL::CONDITION-CLASSSB-KERNEL:REDEFINITION-WITH-DEFMACRO>:
  Class precedence-list: SB-KERNEL:REDEFINITION-WITH-DEFMACRO,
                         SB-KERNEL::FUNCTION-REDEFINITION-WARNING,
                         SB-KERNEL:REDEFINITION-WARNING, STYLE-WARNING,WARNING,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL::FUNCTION-REDEFINITION-WARNING
  No subclasses.
  No direct slots.

PACKAGE-INTERNAL-SYMBOLS names a compiled function:
  An accessor for PACKAGE
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (PACKAGE) (VALUES SB-IMPL::SYMBOL-TABLE &OPTIONAL))
  Source file: SYS:SRC;CODE;PACKAGE.LISP

(SETF PACKAGE-INTERNAL-SYMBOLS) names a compiled function:
  An accessor for PACKAGE
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (SB-IMPL::SYMBOL-TABLE PACKAGE)
                 (VALUES SB-IMPL::SYMBOL-TABLE &OPTIONAL))
  Source file: SYS:SRC;CODE;PACKAGE.LISP

BUILT-IN-CLASSOID names the structure-class #<STRUCTURE-CLASS SB-KERNEL:BUILT-IN-CLASSOID>:
  Class precedence-list: SB-KERNEL:BUILT-IN-CLASSOID, CLASSOID, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CLASSOID
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::NAME
      Type: SYMBOL
      Initform: NIL
    SB-KERNEL:LAYOUT
      Type: (OR NULL SB-KERNEL:LAYOUT)
      Initform: NIL
    SB-KERNEL::STATE
      Type: (MEMBER NIL :READ-ONLY :SEALED)
      Initform: NIL
    SB-KERNEL::DIRECT-SUPERCLASSES
      Type: LIST
      Initform: NIL
    SB-KERNEL::SOURCE-LOCATION
      Type: T
      Initform: NIL
    SB-KERNEL::SUBCLASSES
      Type: (OR LIST HASH-TABLE)
      Initform: NIL
    SB-KERNEL::%LOCK
      Type: T
      Initform: NIL
    SB-KERNEL::PCL-CLASS
      Type: T
      Initform: NIL
    SB-KERNEL::TRANSLATION
      Type: (OR NULL SB-KERNEL:CTYPE (MEMBER :INITIALIZING))
      Initform: NIL
    SB-KERNEL::PREDICATE
      Type: (SB-INT:SFUNCTION (T) BOOLEAN)
      Initform: (SB-INT:MISSING-ARG)

CONDITION-SLOT-DOCUMENTATION names a compiled function:
  An accessor for SB-KERNEL::CONDITION-SLOT
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL::CONDITION-SLOT)
                 (VALUES (OR STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

(SETF CONDITION-SLOT-DOCUMENTATION) names a compiled function:
  An accessor for SB-KERNEL::CONDITION-SLOT
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION ((OR STRING NULL) SB-KERNEL::CONDITION-SLOT)
                 (VALUES (OR STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

CLASSOID-TYPEP names a compiled function:
  Lambda-list: (OBJ-LAYOUT CLASSOID OBJECT)
  Derived type: (FUNCTION (SB-KERNEL:LAYOUT T T) *)
  Source file: SYS:SRC;CODE;TYPEP.LISP

%COMPARE-AND-SWAP-CAR names a compiled function:
  Lambda-list: (CONS OLD NEW)
  Declared type: (FUNCTION (CONS T T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;CAS.LISP

• Called by
  • SB-SPROF::CALL-WITH-EACH-PROFILE-BUFFER

DSD-INDEX names a compiled function:
  Lambda-list: (DSD)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;CODE;DEFSTRUCT.LISP

STRUCT-SLOT-SAP names a macro:
  Lambda-list: (INSTANCE TYPE-NAME SLOT-NAME)
  Source file: SYS:SRC;CODE;DEFSTRUCT.LISP

%NEW-INSTANCE names a macro:
  Lambda-list: (LAYOUT SIZE)
  Source file: SYS:SRC;CODE;DEFSTRUCT.LISP

NUMERIC-UNION-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:NUMERIC-UNION-TYPE>:
  Class precedence-list: SB-KERNEL:NUMERIC-UNION-TYPE, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:CTYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::ASPECTS
      Type: SB-KERNEL::NUMTYPE-ASPECTS
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::RANGES
      Type: SIMPLE-VECTOR
      Initform: #()

%ASSOC-IF-NOT names a compiled function:
  Lambda-list: (X LIST)
  Dynamic-extent arguments: positional=(0)
  Declared type: (FUNCTION (FUNCTION LIST) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (FUNCTION T) (VALUES LIST &OPTIONAL))
  Known attributes: call, foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

LIST-REVERSE-INTO-VECTOR names a compiled function:
  Lambda-list: (LIST)
  Declared type: (FUNCTION (LIST) (VALUES SIMPLE-VECTOR &OPTIONAL))
  Derived type: (FUNCTION (T) (VALUES SIMPLE-VECTOR &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;SEQ.LISP

• Called by
  • SB-COVER::SOURCE-PATH-SOURCE-POSITION
  • DAT/HTML::FLUSH-CHARACTERS
  • (%END-TAG-OTHER ((EQL IN-BODY) T))
  • (%START-TAG-LIST-ITEM ((EQL IN-BODY) T))
  • (%PROCESS-EOF ((EQL IN-BODY) T))
  • (%ADD-FORMATTING-ELEMENT ((EQL IN-BODY) T))
  • (%START-TAG-FROM-HEAD ((EQL AFTER-HEAD) T))
  • DAT/HTML::RESET-INSERTION-MODE
  • DAT/HTML::ELEMENT-IN-ACTIVE-FORMATTING-ELEMENTS
  • DAT/CSV:READ-CSV-FILE-AND-SORT
  • SWANK::SLOT-HOME-CLASS-USING-CLASS
  • (CREATE-MATCHER-AUX (SEQ T))
  • (COMPUTE-MIN-REST (SEQ T))
  • (END-STRING-AUX (SEQ))

TYPE-SPECIFIER names a compiled function:
  Lambda-list: (TYPE &OPTIONAL SIMPLIFY-FUN-TYPES)
  Derived type: (FUNCTION (SB-KERNEL:CTYPE &OPTIONAL T) *)
  Source file: SYS:SRC;CODE;TYPE.LISP

TYPE-SPECIFIER names a type-specifier:
  Lambda-list: ()
  Expansion: (OR LIST SYMBOL CLASSOID CLASS)

• Called by
  • SB-INTROSPECT::COLLECT-XREF
  • SB-INTROSPECT:FUNCTION-TYPE
  • SB-INTROSPECT:FIND-DEFINITION-SOURCES-BY-NAME
  • DECLARATION-INFORMATION
  • VARIABLE-INFORMATION
  • FUNCTION-INFORMATION

UB64-BASH-FILL-WITH-FIXNUM names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  (FIXNUM
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION (FIXNUM T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

THE* names a special operator:
  Lambda-list: ((TYPE &KEY CONTEXT SILENT-CONFLICT DERIVE-TYPE-ONLY TRULY
                 SOURCE-FORM USE-ANNOTATIONS RESTART)
                FORM)
  Source file: SYS:SRC;COMPILER;IR1-TRANSLATORS.LISP

(SETF THE*) has a complex setf-expansion:
  Lambda-list: (TYPE PLACE)
  (undocumented)
  Source file: SYS:SRC;CODE;DEFSETFS.LISP

LAYOUT names the structure-class #<STRUCTURE-CLASS SB-KERNEL:LAYOUT>:
  Class precedence-list: SB-KERNEL:LAYOUT, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::FLAGS
      Type: (SIGNED-BYTE 64) (unboxed)
      Initform: 0
    SB-KERNEL::CLOS-HASH
      Type: (AND FIXNUM UNSIGNED-BYTE)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::VTABLE
      Type: T
      Initform: NIL
    CLASSOID
      Type: SB-KERNEL:CLASSOID
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::INVALID
      Type: (OR CONS (MEMBER NIL T :UNINITIALIZED))
      Initform: :UNINITIALIZED
    SB-KERNEL::INHERITS
      Type: SIMPLE-VECTOR
      Initform: #()
    SB-KERNEL::%INFO
      Type: (OR LIST SB-KERNEL:DEFSTRUCT-DESCRIPTION)
      Initform: NIL
    SB-KERNEL::EQUALP-IMPL
      Type: (SB-INT:SFUNCTION (T T) BOOLEAN)
      Initform: #'SB-KERNEL::EQUALP-ERR
    SB-KERNEL::SLOT-MAPPER
      Type: (OR (SB-INT:SFUNCTION (SYMBOL) (OR SB-INT:INDEX NULL))
                SIMPLE-VECTOR NULL)
      Initform: NIL
    SB-KERNEL::SLOT-TABLE
      Type: SIMPLE-VECTOR
      Initform: #(1 NIL)
    SB-KERNEL::ID-WORD0
      Type: SB-EXT:WORD (unboxed)
      Initform: 0
    SB-KERNEL::ID-WORD1
      Type: SB-EXT:WORD (unboxed)
      Initform: 0
    SB-KERNEL::ID-WORD2
      Type: SB-EXT:WORD (unboxed)
      Initform: 0

FLOAT-SIGN-BIT-SET-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (FLOAT) (VALUES BOOLEAN &OPTIONAL))
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;TARGET-FLOAT.LISP

%FIND-POSITION-IF names a compiled function:
  Lambda-list: (PREDICATE SEQUENCE-ARG FROM-END START END KEY)
  Dynamic-extent arguments: positional=(0 5)
  Declared type: (FUNCTION
                  (FUNCTION SEQUENCE T (UNSIGNED-BYTE 44)
                   (OR NULL (UNSIGNED-BYTE 44)) FUNCTION)
                  (VALUES T (OR NULL (UNSIGNED-BYTE 44)) &OPTIONAL))
  Derived type: (FUNCTION
                 (FUNCTION T T (UNSIGNED-BYTE 44) (OR NULL (UNSIGNED-BYTE 44))
                  FUNCTION)
                 (VALUES T (OR (MOD 17592186044415) NULL) &OPTIONAL))
  Known attributes: call, foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;SEQ.LISP

%ADJOIN-TEST-NOT names a compiled function:
  Lambda-list: (X LIST TEST-NOT)
  Dynamic-extent arguments: positional=(2)
  Declared type: (FUNCTION (T LIST FUNCTION) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T FUNCTION) (VALUES T &OPTIONAL))
  Known attributes: call, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

SIMPLE-ARRAY-UNSIGNED-FIXNUM-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

%LEA names a compiled function:
  Lambda-list: (BASE INDEX SCALE DISP)
  Declared type: (FUNCTION
                  (INTEGER INTEGER
                   (OR (INTEGER 1 2) (INTEGER 4 4) (INTEGER 8 8)
                       (INTEGER 16 16))
                   (SIGNED-BYTE 64))
                  (VALUES INTEGER &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;COMPILER;X86-64;ARITH.LISP

UPDATE-OBJECT-LAYOUT names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES SB-KERNEL:LAYOUT &OPTIONAL))
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;TYPEP.LISP

%SET-SAP-REF-16 names an undefined function
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 16) SB-SYS:SYSTEM-AREA-POINTER FIXNUM)
                  (VALUES &OPTIONAL))

• Called by
  • (UB16REF/LE)
  • STD/ALIEN::%SAP-SET

VALUES-SPECIFIER-TYPE-CACHE-CLEAR names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

%COMPARE-AND-SWAP-SYMBOL-VALUE names a compiled function:
  Lambda-list: (SYMBOL OLD NEW)
  Declared type: (FUNCTION (SYMBOL T T) (VALUES T &OPTIONAL))
  Known attributes: unwind
  Source file: SYS:SRC;CODE;CAS.LISP

PROFILE-DEINIT names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL
                 (VALUES (MEMBER SB-PROFILE::*OVERHEAD*) &OPTIONAL))
  Source file: SYS:SRC;CODE;PROFILE.LISP

VALUES-TYPE-REQUIRED names a compiled function:
  An accessor for SB-KERNEL:VALUES-TYPE
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:VALUES-TYPE) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

ASTERISKS-AROUND-LEXICAL-VARIABLE-NAME names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:ASTERISKS-AROUND-LEXICAL-VARIABLE-NAME>:
  Class precedence-list: SB-KERNEL:ASTERISKS-AROUND-LEXICAL-VARIABLE-NAME,
                         SB-KERNEL:DUBIOUS-ASTERISKS-AROUND-VARIABLE-NAME,
                         STYLE-WARNING, WARNING, SIMPLE-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:DUBIOUS-ASTERISKS-AROUND-VARIABLE-NAME
  No subclasses.
  No direct slots.

%EQL names a compiled function:
  Lambda-list: (OBJ1 OBJ2)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;PRED.LISP

ARRAY-TYPE-SPECIALIZED-ELEMENT-TYPE names a compiled function:
  An accessor for SB-KERNEL:ARRAY-TYPE
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:ARRAY-TYPE)
                 (VALUES SB-KERNEL:CTYPE &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

FIND-CALLER-FRAME names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL
                 (VALUES (OR (MEMBER NIL :UNPARSED) SB-DI:FRAME) &OPTIONAL))
  Source file: SYS:SRC;CODE;DEBUG-INT.LISP

%ARRAY-RANK names a type-specifier:
  Lambda-list: ()
  Expansion: (INTEGER 0 (129))

DEFSTRUCT-DESCRIPTION names the structure-class #<STRUCTURE-CLASS SB-KERNEL:DEFSTRUCT-DESCRIPTION>:
  Class precedence-list: SB-KERNEL:DEFSTRUCT-DESCRIPTION, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::NAME
      Type: SYMBOL
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::FLAGS
      Type: FIXNUM
      Initform: 0
    SB-KERNEL::DOC
      Type: (OR STRING NULL)
      Initform: NIL
    SB-KERNEL::CONC-NAME
      Type: (OR STRING NULL)
      Initform: NIL
    SB-KERNEL::CONSTRUCTORS
      Type: LIST
      Initform: NIL
    SB-KERNEL::COPIER-NAME
      Type: SYMBOL
      Initform: NIL
    SB-KERNEL::PREDICATE-NAME
      Type: SYMBOL
      Initform: NIL
    SB-KERNEL::INCLUDE
      Type: LIST
      Initform: NIL
    SB-KERNEL::ALTERNATE-METACLASS
      Type: LIST
      Initform: NIL
    SB-KERNEL::SLOTS
      Type: LIST
      Initform: NIL
    SB-KERNEL::BITMAP
      Type: INTEGER
      Initform: SB-KERNEL:+LAYOUT-ALL-TAGGED+
    SB-KERNEL::INHERITED-ACCESSOR-ALIST
      Type: LIST
      Initform: NIL
    LENGTH
      Type: SB-INT:INDEX
      Initform: 0
    TYPE
      Type: (MEMBER STRUCTURE VECTOR LIST SB-KERNEL:FUNCALLABLE-STRUCTURE)
      Initform: 'STRUCTURE
    SB-KERNEL::%ELEMENT-TYPE
      Type: T
      Initform: T
    SB-KERNEL::OFFSET
      Type: (OR SB-INT:INDEX NULL)
      Initform: NIL
    SB-KERNEL::PRINTER-FNAME
      Type: (OR CONS SYMBOL)
      Initform: NIL

INTERPRETED-FUNCTION names the structure-class #<STRUCTURE-CLASS SB-KERNEL:INTERPRETED-FUNCTION>:
  Class precedence-list: SB-KERNEL:INTERPRETED-FUNCTION, FUNCTION, T
  Direct superclasses: FUNCTION
  No subclasses.
  Sealed.
  Slots:
    SB-EVAL::NAME
      Type: T
      Initform: NIL
    SB-EVAL::DEBUG-NAME
      Type: T
      Initform: NIL
    SB-EVAL::LAMBDA-LIST
      Type: T
      Initform: NIL
    SB-EVAL::DEBUG-LAMBDA-LIST
      Type: T
      Initform: NIL
    SB-EVAL::ENV
      Type: T
      Initform: NIL
    SB-EVAL::DECLARATIONS
      Type: T
      Initform: NIL
    DOCUMENTATION
      Type: T
      Initform: NIL
    SB-EVAL::BODY
      Type: T
      Initform: NIL
    SB-EVAL::SOURCE-LOCATION
      Type: T
      Initform: NIL

UNINTERESTING-GENERIC-FUNCTION-REDEFINITION-P names a compiled function:
  Lambda-list: (WARNING)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

%ASINF names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (SINGLE-FLOAT)
                  (VALUES (SINGLE-FLOAT -1.5707964 1.5707964) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

CHECK-BOUND names a compiled function:
  Lambda-list: (ARRAY BOUND INDEX)
  Declared type: (FUNCTION (ARRAY (UNSIGNED-BYTE 44) T)
                  (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Derived type: (FUNCTION (ARRAY (UNSIGNED-BYTE 44) FIXNUM)
                 (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Known attributes: dx-safe
  Source file: SYS:SRC;CODE;ARRAY.LISP

• Called by
  • SB-SIMD-AVX2::S64.4-NTSTORE
  • SB-SIMD-AVX2::S32.8-NTSTORE
  • SB-SIMD-AVX2::S16.16-NTSTORE
  • SB-SIMD-AVX2::S8.32-NTSTORE
  • SB-SIMD-AVX2::U64.4-NTSTORE
  • SB-SIMD-AVX2::U32.8-NTSTORE
  • SB-SIMD-AVX2::U16.16-NTSTORE
  • SB-SIMD-AVX2::U8.32-NTSTORE
  • SB-SIMD-AVX2::S64.2-NTSTORE
  • SB-SIMD-AVX2::S32.4-NTSTORE
  • SB-SIMD-AVX2::S16.8-NTSTORE
  • SB-SIMD-AVX2::S8.16-NTSTORE
  • SB-SIMD-AVX2::U64.2-NTSTORE
  • SB-SIMD-AVX2::U32.4-NTSTORE
  • SB-SIMD-AVX2::U16.8-NTSTORE
  • SB-SIMD-AVX2::U8.16-NTSTORE
  • SB-SIMD-AVX2::F64.4-NTSTORE
  • SB-SIMD-AVX2::F32.8-NTSTORE
  • SB-SIMD-AVX2::F64.2-NTSTORE
  • SB-SIMD-AVX2::F32.4-NTSTORE
  • SB-SIMD-AVX::S64.4-NTSTORE
  • SB-SIMD-AVX::S32.8-NTSTORE
  • SB-SIMD-AVX::S16.16-NTSTORE
  • SB-SIMD-AVX::S8.32-NTSTORE
  • SB-SIMD-AVX::U64.4-NTSTORE
  • SB-SIMD-AVX::U32.8-NTSTORE
  • SB-SIMD-AVX::U16.16-NTSTORE
  • SB-SIMD-AVX::U8.32-NTSTORE
  • SB-SIMD-AVX::S64.2-NTSTORE
  • SB-SIMD-AVX::S32.4-NTSTORE
  • SB-SIMD-AVX::S16.8-NTSTORE
  • SB-SIMD-AVX::S8.16-NTSTORE
  • SB-SIMD-AVX::U64.2-NTSTORE
  • SB-SIMD-AVX::U32.4-NTSTORE
  • SB-SIMD-AVX::U16.8-NTSTORE
  • SB-SIMD-AVX::U8.16-NTSTORE
  • SB-SIMD-AVX::F64.4-NTSTORE
  • SB-SIMD-AVX::F32.8-NTSTORE
  • SB-SIMD-AVX::F64.2-NTSTORE
  • SB-SIMD-AVX::F32.4-NTSTORE
  • SB-SIMD-AVX::S64.4-STORE
  • SB-SIMD-AVX::S32.8-STORE
  • SB-SIMD-AVX::S16.16-STORE
  • SB-SIMD-AVX::S8.32-STORE
  • SB-SIMD-AVX::U64.4-STORE
  • SB-SIMD-AVX::U32.8-STORE
  • SB-SIMD-AVX::U16.16-STORE
  • SB-SIMD-AVX::U8.32-STORE
  • SB-SIMD-AVX::S64.2-STORE
  • SB-SIMD-AVX::S32.4-STORE
  • SB-SIMD-AVX::S16.8-STORE
  • SB-SIMD-AVX::S8.16-STORE
  • SB-SIMD-AVX::U64.2-STORE
  • SB-SIMD-AVX::U32.4-STORE
  • SB-SIMD-AVX::U16.8-STORE
  • SB-SIMD-AVX::U8.16-STORE
  • SB-SIMD-AVX::F64.4-STORE
  • SB-SIMD-AVX::F32.8-STORE
  • SB-SIMD-AVX::F64.2-STORE
  • SB-SIMD-AVX::F32.4-STORE
  • SB-SIMD-AVX::F64-STORE
  • SB-SIMD-AVX::F32-STORE
  • SB-SIMD-AVX::U32.8-STORE-INTO-STRING
  • SB-SIMD-AVX::U32.4-STORE-INTO-STRING
  • SB-SIMD-SSE4.1::S64.2-NTSTORE
  • SB-SIMD-SSE4.1::S32.4-NTSTORE
  • SB-SIMD-SSE4.1::S16.8-NTSTORE
  • SB-SIMD-SSE4.1::S8.16-NTSTORE
  • SB-SIMD-SSE4.1::U64.2-NTSTORE
  • SB-SIMD-SSE4.1::U32.4-NTSTORE
  • SB-SIMD-SSE4.1::U16.8-NTSTORE
  • SB-SIMD-SSE4.1::U8.16-NTSTORE
  • SB-SIMD-SSE4.1::F64.2-NTSTORE
  • SB-SIMD-SSE4.1::F32.4-NTSTORE
  • SB-SIMD-SSE2::S64.2-NTSTORE
  • SB-SIMD-SSE2::S32.4-NTSTORE
  • SB-SIMD-SSE2::S16.8-NTSTORE
  • SB-SIMD-SSE2::S8.16-NTSTORE
  • SB-SIMD-SSE2::U64.2-NTSTORE
  • SB-SIMD-SSE2::U32.4-NTSTORE
  • SB-SIMD-SSE2::U16.8-NTSTORE
  • SB-SIMD-SSE2::U8.16-NTSTORE
  • SB-SIMD-SSE2::F64.2-NTSTORE
  • SB-SIMD-SSE2::S64.2-STORE
  • SB-SIMD-SSE2::S32.4-STORE
  • SB-SIMD-SSE2::S16.8-STORE
  • SB-SIMD-SSE2::S8.16-STORE
  • SB-SIMD-SSE2::U64.2-STORE
  • SB-SIMD-SSE2::U32.4-STORE
  • SB-SIMD-SSE2::U16.8-STORE
  • SB-SIMD-SSE2::U8.16-STORE
  • SB-SIMD-SSE2::F64.2-STORE
  • SB-SIMD-SSE2::F64-STORE
  • SB-SIMD-SSE2::U32.4-STORE-INTO-STRING
  • SB-SIMD-SSE::F32.4-NTSTORE
  • SB-SIMD-SSE::F32.4-STORE
  • SB-SIMD-SSE::F32-STORE
  • SB-SIMD-AVX2::S64.4-NTLOAD
  • SB-SIMD-AVX2::S32.8-NTLOAD
  • SB-SIMD-AVX2::S16.16-NTLOAD
  • SB-SIMD-AVX2::S8.32-NTLOAD
  • SB-SIMD-AVX2::U64.4-NTLOAD
  • SB-SIMD-AVX2::U32.8-NTLOAD
  • SB-SIMD-AVX2::U16.16-NTLOAD
  • SB-SIMD-AVX2::U8.32-NTLOAD
  • SB-SIMD-AVX2::S64.2-NTLOAD
  • SB-SIMD-AVX2::S32.4-NTLOAD
  • SB-SIMD-AVX2::S16.8-NTLOAD
  • SB-SIMD-AVX2::S8.16-NTLOAD
  • SB-SIMD-AVX2::U64.2-NTLOAD
  • SB-SIMD-AVX2::U32.4-NTLOAD
  • SB-SIMD-AVX2::U16.8-NTLOAD
  • SB-SIMD-AVX2::U8.16-NTLOAD
  • SB-SIMD-AVX2::F64.4-NTLOAD
  • SB-SIMD-AVX2::F32.8-NTLOAD
  • SB-SIMD-AVX2::F64.2-NTLOAD
  • SB-SIMD-AVX2::F32.4-NTLOAD
  • SB-SIMD-AVX::S64.4-LOAD
  • SB-SIMD-AVX::S32.8-LOAD
  • SB-SIMD-AVX::S16.16-LOAD
  • SB-SIMD-AVX::S8.32-LOAD
  • SB-SIMD-AVX::S64.2-LOAD
  • SB-SIMD-AVX::S32.4-LOAD
  • SB-SIMD-AVX::S16.8-LOAD
  • SB-SIMD-AVX::S8.16-LOAD
  • SB-SIMD-AVX::U64.4-LOAD
  • SB-SIMD-AVX::U32.8-LOAD
  • SB-SIMD-AVX::U16.16-LOAD
  • SB-SIMD-AVX::U8.32-LOAD
  • SB-SIMD-AVX::U64.2-LOAD
  • SB-SIMD-AVX::U32.4-LOAD
  • SB-SIMD-AVX::U16.8-LOAD
  • SB-SIMD-AVX::U8.16-LOAD
  • SB-SIMD-AVX::F64.4-LOAD
  • SB-SIMD-AVX::F32.8-LOAD
  • SB-SIMD-AVX::F64.2-LOAD
  • SB-SIMD-AVX::F32.4-LOAD
  • SB-SIMD-AVX::F64-LOAD
  • SB-SIMD-AVX::F32-LOAD
  • SB-SIMD-AVX::U32.8-LOAD-FROM-STRING
  • SB-SIMD-AVX::U32.4-LOAD-FROM-STRING
  • SB-SIMD-SSE4.1::S64.2-NTLOAD
  • SB-SIMD-SSE4.1::S32.4-NTLOAD
  • SB-SIMD-SSE4.1::S16.8-NTLOAD
  • SB-SIMD-SSE4.1::S8.16-NTLOAD
  • SB-SIMD-SSE4.1::U64.2-NTLOAD
  • SB-SIMD-SSE4.1::U32.4-NTLOAD
  • SB-SIMD-SSE4.1::U16.8-NTLOAD
  • SB-SIMD-SSE4.1::U8.16-NTLOAD
  • SB-SIMD-SSE4.1::F64.2-NTLOAD
  • SB-SIMD-SSE4.1::F32.4-NTLOAD
  • SB-SIMD-SSE2::S64.2-LOAD
  • SB-SIMD-SSE2::S32.4-LOAD
  • SB-SIMD-SSE2::S16.8-LOAD
  • SB-SIMD-SSE2::S8.16-LOAD
  • SB-SIMD-SSE2::U64.2-LOAD
  • SB-SIMD-SSE2::U32.4-LOAD
  • SB-SIMD-SSE2::U16.8-LOAD
  • SB-SIMD-SSE2::U8.16-LOAD
  • SB-SIMD-SSE2::F64.2-LOAD
  • SB-SIMD-SSE2::F64-LOAD
  • SB-SIMD-SSE2::U32.4-LOAD-FROM-STRING
  • SB-SIMD-SSE::F32.4-LOAD
  • SB-SIMD-SSE::F32-LOAD

%SET-SYMBOL-PACKAGE names a compiled function:
  Lambda-list: (SYMBOL PACKAGE)
  Declared type: (FUNCTION ((AND SYMBOL (NOT NULL)) (OR PACKAGE NULL))
                  (VALUES T &OPTIONAL))
  Derived type: (FUNCTION ((AND SYMBOL (NOT NULL)) (OR PACKAGE NULL))
                 (VALUES (OR PACKAGE NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;SYMBOL.LISP

%MAKE-INSTANCE names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 44))
                  (VALUES SB-KERNEL:INSTANCE &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

WORD-LOGICAL-ANDC2 names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

%SIMD-PACK-LOW names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK)
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

ANSI-STREAM-IN names a compiled function:
  An accessor for SB-KERNEL:ANSI-STREAM
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:ANSI-STREAM) (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

(SETF ANSI-STREAM-IN) names a compiled function:
  An accessor for SB-KERNEL:ANSI-STREAM
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (FUNCTION SB-KERNEL:ANSI-STREAM)
                 (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

IMMOBILE-SPACE-ADDR-P names a compiled function:
  Lambda-list: (ADDR)
  Derived type: (FUNCTION ((UNSIGNED-BYTE 64)) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;ALLOC.LISP

LAYOUT-CLOS-HASH names a compiled function:
  An accessor for SB-KERNEL:LAYOUT
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:LAYOUT)
                 (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-CLASSOID.LISP

(SETF LAYOUT-CLOS-HASH) names a compiled function:
  An accessor for SB-KERNEL:LAYOUT
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION ((UNSIGNED-BYTE 62) SB-KERNEL:LAYOUT)
                 (VALUES (UNSIGNED-BYTE 62) &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-CLASSOID.LISP

• Called by
  • (PRODUCE-DIGEST (SHA3))
  • (COPY-DIGEST (SHA3))

FUN-TYPE-CHANGE-RETURN names a compiled function:
  Lambda-list: (TYPE RETURN)
  Derived type: (FUNCTION (T T) (VALUES SB-KERNEL:FUN-TYPE &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

VECTOR-UNSIGNED-BYTE-7-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

%MAP-TO-LIST-ARITY-1 names a compiled function:
  Lambda-list: (FUN SEQUENCE)
  Dynamic-extent arguments: positional=(0)
  Declared type: (FUNCTION ((OR FUNCTION SYMBOL) SEQUENCE)
                  (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES LIST &OPTIONAL))
  Known attributes: call, flushable, unsafely-flushable, no-verify-arg-count,foldable-read-only
  Source file: SYS:SRC;CODE;SEQ.LISP

FLOATING-POINT-EXCEPTION names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:FLOATING-POINT-EXCEPTION>:
  Class precedence-list: SB-KERNEL:FLOATING-POINT-EXCEPTION, ARITHMETIC-ERROR,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: ARITHMETIC-ERROR
  No subclasses.
  Direct slots:
    SB-KERNEL::FLAGS
      Initargs: :TRAPS
      Initform: 'NIL
      Readers: SB-KERNEL::FLOATING-POINT-EXCEPTION-TRAPS

%SIN names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES (DOUBLE-FLOAT -1.0d0 1.0d0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

PROCLAMATION-MISMATCH-OLD names a compiled function:
  Lambda-list: (CONDITION)
  Declared type: (FUNCTION (T) *)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

REGISTER-LAYOUT names a compiled function:
  Lambda-list: (LAYOUT &KEY (INVALIDATE T) DESTRUCT-LAYOUT)
  Derived type: (FUNCTION
                 (SB-KERNEL:LAYOUT &KEY (:INVALIDATE T)
                  (:DESTRUCT-LAYOUT (OR NULL SB-KERNEL:LAYOUT)))
                 (VALUES &OPTIONAL))
  Source file: SYS:SRC;CODE;CLASS.LISP

READER-IMPOSSIBLE-NUMBER-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:READER-IMPOSSIBLE-NUMBER-ERROR>:
  Class precedence-list: SB-KERNEL:READER-IMPOSSIBLE-NUMBER-ERROR,
                         SB-INT:SIMPLE-READER-ERROR, READER-ERROR, PARSE-ERROR,
                         STREAM-ERROR, ERROR, SERIOUS-CONDITION,
                         SIMPLE-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-INT:SIMPLE-READER-ERROR
  No subclasses.
  Direct slots:
    ERROR
      Initargs: :ERROR
      Readers: SB-KERNEL::READER-IMPOSSIBLE-NUMBER-ERROR-ERROR

%ASH/RIGHT names a compiled function:
  Lambda-list: (INTEGER AMOUNT)
  Declared type: (FUNCTION
                  ((INTEGER -9223372036854775808 18446744073709551615)
                   (UNSIGNED-BYTE 6))
                  (VALUES (INTEGER -9223372036854775808 18446744073709551615)
                          &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, always-translatable
  Source file: SYS:SRC;COMPILER;SRCTRAN.LISP

FUN-DESIGNATOR-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:FUN-DESIGNATOR-TYPE>:
  Class precedence-list: SB-KERNEL:FUN-DESIGNATOR-TYPE, SB-KERNEL:FUN-TYPE,
                         SB-KERNEL:ARGS-TYPE, SB-KERNEL:CTYPE, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:FUN-TYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::REQUIRED
      Type: LIST
      Initform: NIL
    SB-KERNEL::OPTIONAL
      Type: LIST
      Initform: NIL
    REST
      Type: (OR SB-KERNEL:CTYPE NULL)
      Initform: NIL
    SB-KERNEL::KEYP
      Type: BOOLEAN
      Initform: NIL
    SB-KERNEL::KEYWORDS
      Type: LIST
      Initform: NIL
    SB-KERNEL::ALLOWP
      Type: BOOLEAN
      Initform: NIL
    SB-KERNEL::WILD-ARGS
      Type: BOOLEAN
      Initform: NIL
    SB-KERNEL::RETURNS
      Type: SB-KERNEL:CTYPE
      Initform: (SB-INT:MISSING-ARG)

GENERALIZED-BOOLEAN names a type-specifier:
  Lambda-list: ()
  Expansion: T

%FUN-POINTER-WIDETAG names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (FUNCTION)
                  (VALUES (OR (INTEGER 61 61) (INTEGER 65 65) (INTEGER 69 69))
                          &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

*VECTOR-WITHOUT-COMPLEX-TYPECODE-INFOS* names a global variable:
  Declared always-bound.
  Value: ((SB-KERNEL:VECTOR-NIL-P NIL)
          (SB-KERNEL:VECTOR-SINGLE-FLOAT-P SINGLE-FLOAT)
          (SB-KERNEL:VECTOR-DOUBLE-FLOAT-P DOUBLE-FLOAT)
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-2-P (UNSIGNED-BYTE 2))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-4-P (UNSIGNED-BYTE 4))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-7-P (UNSIGNED-BYTE 7))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-8-P (UNSIGNED-BYTE 8))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-15-P (UNSIGNED-BYTE 15))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-16-P (UNSIGNED-BYTE 16))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-31-P (UNSIGNED-BYTE 31))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-32-P (UNSIGNED-BYTE 32))
          (SB-VM::VECTOR-UNSIGNED-BYTE-62-P (UNSIGNED-BYTE 62))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-63-P (UNSIGNED-BYTE 63))
          (SB-KERNEL:VECTOR-UNSIGNED-BYTE-64-P (UNSIGNED-BYTE 64))
          (SB-KERNEL:VECTOR-SIGNED-BYTE-8-P (SIGNED-BYTE 8))
          (SB-KERNEL:VECTOR-SIGNED-BYTE-16-P (SIGNED-BYTE 16))
          (SB-KERNEL:VECTOR-SIGNED-BYTE-32-P (SIGNED-BYTE 32))
          (SB-KERNEL:VECTOR-FIXNUM-P FIXNUM)
          (SB-KERNEL:VECTOR-SIGNED-BYTE-64-P (SIGNED-BYTE 64))
          (SB-KERNEL:VECTOR-COMPLEX-SINGLE-FLOAT-P (COMPLEX SINGLE-FLOAT))
          (SB-KERNEL:VECTOR-COMPLEX-DOUBLE-FLOAT-P (COMPLEX DOUBLE-FLOAT))
          (SB-KERNEL:VECTOR-T-P T))

COND-DISPATCH names a macro:
  Lambda-list: (COND &BODY BODY)
  Source file: SYS:SRC;CODE;NUMBER-DISPATCH.LISP

%INSTANCE-REF-EQ names an undefined function
  Declared type: (FUNCTION (SB-KERNEL:INSTANCE (UNSIGNED-BYTE 44) T)
                  (VALUES BOOLEAN &OPTIONAL))

*EMPTY-TYPE* names a constant variable:
  Value: #<SB-KERNEL:NAMED-TYPE NIL>

*IN-WITHOUT-GCING* names a special variable:
  Declared always-bound.
  Value: NIL

VECTOR-UNSIGNED-BYTE-32-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

READ-ONLY-SPACE-OBJ-P names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;MISC-ALIENS.LISP

EXTERNAL-FORMAT-DESIGNATOR names a type-specifier:
  Lambda-list: ()
  Expansion: (OR KEYWORD (CONS KEYWORD))

NON-NULL-SYMBOL-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-SIMD-INTERNALS:PARSE-FUNCTION-NAME
  • OBJ/META/FAST::BLOCK-NAME

EXPT-SINGLE-FLOAT names a compiled function:
  Lambda-list: (BASE POWER)
  Declared type: (FUNCTION (SINGLE-FLOAT SINGLE-FLOAT)
                  (VALUES (OR SINGLE-FLOAT (COMPLEX SINGLE-FLOAT)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;IRRAT.LISP

%FUN-FUN names a compiled function:
  Lambda-list: (FUNCTION)
  Declared type: (FUNCTION (FUNCTION)
                  (VALUES (SATISFIES SB-KERNEL:SIMPLE-FUN-P) &OPTIONAL))
  Derived type: (FUNCTION (FUNCTION)
                 (VALUES (AND (SATISFIES SB-KERNEL:SIMPLE-FUN-P) FUNCTION)
                         &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, recursive
  Source file: SYS:SRC;CODE;SIMPLE-FUN.LISP

• Called by
  • SB-INTROSPECT:FIND-FUNCTION-CALLEES
  • SB-INTROSPECT::FUNCTION-DEBUG-INFO

%CONCATENATE-TO-SIMPLE-VECTOR-SUBSEQ names a compiled function:
  Lambda-list: (&REST SEQUENCES)
  Declared type: (FUNCTION * (VALUES SIMPLE-VECTOR &OPTIONAL))
  Derived type: (FUNCTION (&REST T) (VALUES SIMPLE-VECTOR &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, foldable-read-only
  Source file: SYS:SRC;CODE;SEQ.LISP

%RASSOC-KEY-EQ names a compiled function:
  Lambda-list: (X LIST KEY)
  Dynamic-extent arguments: positional=(2)
  Declared type: (FUNCTION (T LIST FUNCTION) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T FUNCTION) (VALUES LIST &OPTIONAL))
  Known attributes: call, foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

SIMPLE-ARRAY-NIL-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

%SET-SAP-REF-SINGLE names an undefined function
  Declared type: (FUNCTION (SINGLE-FLOAT SB-SYS:SYSTEM-AREA-POINTER FIXNUM)
                  (VALUES &OPTIONAL))

• Called by
  • STD/ALIEN::%SAP-SET

ARGS-TYPE-KEYWORDS names a compiled function:
  Lambda-list: (TYPE)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

RESTART-DESIGNATOR names a type-specifier:
  Lambda-list: ()
  Expansion: (OR (AND SYMBOL (NOT NULL)) RESTART)

%CAS-SYMBOL-GLOBAL-VALUE names an undefined function
  Declared type: (FUNCTION (SYMBOL T T) (VALUES T &OPTIONAL))

SUB-GC names a compiled function:
  Lambda-list: (GEN)
  Derived type: (FUNCTION (T) (VALUES (OR (INTEGER 0 0) BOOLEAN) &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

VALUES-TYPE-MIN-VALUE-COUNT names a compiled function:
  Lambda-list: (TYPE)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 37) &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

VECTOR-FILL/T names an undefined function
  Declared type: (FUNCTION (T T T T) (VALUES VECTOR &OPTIONAL))

%MEMBER names a compiled function:
  Lambda-list: (X LIST)
  Declared type: (FUNCTION (T LIST) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES LIST &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

DOUBLE-FLOAT-EXPONENT names a type-specifier:
  Lambda-list: ()
  Expansion: (INTEGER -1074 1024)

DSD-NAME names a compiled function:
  An accessor for SB-KERNEL:DEFSTRUCT-SLOT-DESCRIPTION
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:DEFSTRUCT-SLOT-DESCRIPTION)
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;DEFSTRUCT.LISP

• Called by
  • SB-ACLREPL::INSPECTED-STRUCTURE-PARTS

%SIMPLE-FUN-XREFS names a compiled function:
  Lambda-list: (FUN)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;SIMPLE-FUN.LISP

• Called by
  • SB-INTROSPECT::COLLECT-XREF

%EXP names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES (DOUBLE-FLOAT 0.0d0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

%RANDOM-DOUBLE-FLOAT names a compiled function:
  Lambda-list: (ARG STATE)
  Declared type: (FUNCTION ((DOUBLE-FLOAT (0.0d0)) RANDOM-STATE)
                  (VALUES (DOUBLE-FLOAT 0.0d0) &REST T))
  Derived type: (FUNCTION ((DOUBLE-FLOAT (0.0d0)) RANDOM-STATE)
                 (VALUES (DOUBLE-FLOAT 0.0d0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;TARGET-RANDOM.LISP

%ATANHF names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (SINGLE-FLOAT) (VALUES SINGLE-FLOAT &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

UNSIGNED-BYTE-32-P names an undefined function
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))

CHARACTER-SET-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:CHARACTER-SET-TYPE>:
  Class precedence-list: SB-KERNEL:CHARACTER-SET-TYPE, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:CTYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::PAIRS
      Type: LIST
      Initform: (SB-INT:MISSING-ARG)

FP>= names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

%SIMD-PACK-512-1 names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

TWO-ARG-XOR names a compiled function:
  Lambda-list: (INTEGER1 INTEGER2)
  Declared type: (FUNCTION (INTEGER INTEGER) (VALUES INTEGER &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES (OR NULL INTEGER) &OPTIONAL))
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;NUMBERS.LISP

• Called by
  • IRONCLAD:PSS-VERIFY
  • IRONCLAD:OAEP-DECODE
  • IRONCLAD:OAEP-ENCODE

SIMPLE-FUN names a type-specifier:
  Lambda-list: ()
  Expansion: (SATISFIES SB-KERNEL:SIMPLE-FUN-P)

DEFSTRUCT-SLOT-DESCRIPTION names the structure-class #<STRUCTURE-CLASS SB-KERNEL:DEFSTRUCT-SLOT-DESCRIPTION>:
  Class precedence-list: SB-KERNEL:DEFSTRUCT-SLOT-DESCRIPTION, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STRUCTURE-OBJECT
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::NAME
      Type: T
      Initform: NIL
    TYPE
      Type: T
      Initform: T
    SB-KERNEL::ACCESSOR-NAME
      Type: SYMBOL
      Initform: NIL
    SB-KERNEL::BITS
      Type: FIXNUM
      Initform: 0
    SB-KERNEL::DEFAULT
      Type: T
      Initform: NIL

UB16-BASH-COPY names a compiled function:
  Lambda-list: (SRC SRC-START DST DST-START NELEMENTS)
  Declared type: (FUNCTION
                  ((OR SIMPLE-BASE-STRING (SIMPLE-ARRAY CHARACTER (*))
                       (SIMPLE-ARRAY SINGLE-FLOAT (*))
                       (SIMPLE-ARRAY DOUBLE-FLOAT (*)) SIMPLE-BIT-VECTOR
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY FIXNUM (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT) (*))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)))
                   (UNSIGNED-BYTE 44)
                   (OR SIMPLE-BASE-STRING (SIMPLE-ARRAY CHARACTER (*))
                       (SIMPLE-ARRAY SINGLE-FLOAT (*))
                       (SIMPLE-ARRAY DOUBLE-FLOAT (*)) SIMPLE-BIT-VECTOR
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY FIXNUM (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT) (*))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

SIMPLE-ARRAY-UNSIGNED-BYTE-31-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

LOG-DOUBLE-FLOAT2 names a compiled function:
  Lambda-list: (NUMBER BASE)
  Declared type: (FUNCTION (DOUBLE-FLOAT DOUBLE-FLOAT)
                  (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args
  Source file: SYS:SRC;CODE;IRRAT.LISP

%CONCATENATE-TO-SIMPLE-VECTOR names a compiled function:
  Lambda-list: (&REST SEQUENCES)
  Declared type: (FUNCTION (&REST SEQUENCE) (VALUES SIMPLE-VECTOR &OPTIONAL))
  Derived type: (FUNCTION (&REST T) (VALUES SIMPLE-VECTOR &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, foldable-read-only
  Source file: SYS:SRC;CODE;SEQ.LISP

%SINF names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (SINGLE-FLOAT)
                  (VALUES (SINGLE-FLOAT -1.0 1.0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

ARGS-TYPE-REQUIRED names a compiled function:
  An accessor for SB-KERNEL:ARGS-TYPE
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:ARGS-TYPE) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

SEQUENCEP names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P
  • SB-COVER::SUPPRESS-SHARP-A
  • NET/CODEC/DBUS::VALID-DICT-ENTRY-P
  • NET/CODEC/DBUS::VALID-STRUCT-P
  • NET/CODEC/DBUS::VALID-ARRAY-P
  • DAT/DOT:GRAPH-TO-DOT
  • OBJ/META/SEALED::%STARTS-WITH
  • SWANK::LENGTH=
  • STARTS-WITH
  • SEQUENCEP

%ASSOC-IF-KEY names a compiled function:
  Lambda-list: (X LIST KEY)
  Dynamic-extent arguments: positional=(0 2)
  Declared type: (FUNCTION (FUNCTION LIST FUNCTION) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (FUNCTION T FUNCTION) (VALUES LIST &OPTIONAL))
  Known attributes: call, foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

%SIMPLE-FUN-LEXPR names a compiled function:
  Lambda-list: (SIMPLE-FUN)
  Derived type: (FUNCTION ((SATISFIES SB-KERNEL:SIMPLE-FUN-P))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;SIMPLE-FUN.LISP

FUN-TYPE-P names a compiled function:
  A predicate for SB-KERNEL:FUN-TYPE
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

• Called by
  • SB-INTROSPECT::COLLECT-XREF

WORD-LOGICAL-NAND names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 64) (UNSIGNED-BYTE 64))
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

CTYPE-ARRAY-SPECIALIZED-ELEMENT-TYPES names a compiled function:
  Lambda-list: (TYPE)
  Derived type: (FUNCTION (T) (VALUES (OR LIST SB-KERNEL:NAMED-TYPE)&OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

TYPE-PROCLAMATION-MISMATCH-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:TYPE-PROCLAMATION-MISMATCH-WARNING>:
  Class precedence-list: SB-KERNEL:TYPE-PROCLAMATION-MISMATCH-WARNING,
                         STYLE-WARNING, WARNING,
                         SB-KERNEL:TYPE-PROCLAMATION-MISMATCH,
                         SB-KERNEL:PROCLAMATION-MISMATCH, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STYLE-WARNING, SB-KERNEL:TYPE-PROCLAMATION-MISMATCH
  No subclasses.
  No direct slots.

DO-REST-ARG names a macro:
  Lambda-list: (((VAR &OPTIONAL INDEX-VAR) REST-VAR &OPTIONAL (START 0) RESULT)
                &BODY BODY)
  Source file: SYS:SRC;CODE;SYSMACS.LISP

ARRAY-UNDERLYING-WIDETAG names a compiled function:
  Lambda-list: (ARRAY)
  Declared type: (FUNCTION (ARRAY) (VALUES (INTEGER 128 255) &OPTIONAL))
  Derived type: (FUNCTION (ARRAY) (VALUES (INTEGER 128 229) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;ARRAY.LISP

%CLOSURE-INDEX-REF names a compiled function:
  Lambda-list: (CLOSURE INDEX)
  Declared type: (FUNCTION (FUNCTION (UNSIGNED-BYTE 44)) (VALUES T &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • SB-INTROSPECT:FIND-FUNCTION-CALLEES
  • (EMACS-INSPECT (FUNCTION))
  • DEEP-SIZE

%FUNCALLABLE-INSTANCE-INFO names a compiled function:
  Lambda-list: (FIN I)
  Declared type: (FUNCTION (FUNCTION (UNSIGNED-BYTE 44)) (VALUES T &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

(SETF %FUNCALLABLE-INSTANCE-INFO) names a compiled function:
  Lambda-list: (NEWVAL FIN INDEX)
  Declared type: (FUNCTION (T FUNCTION (UNSIGNED-BYTE 44)) (VALUES T&OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;DEFSETFS.LISP

• Called by
  • SB-INTROSPECT::OBJECT-SIZE
  • SB-INTROSPECT:MAP-ROOT
  • SB-INTROSPECT:FIND-DEFINITION-SOURCE
  • SWANK:DISASSEMBLE-FORM
  • DEEP-SIZE
  • (KERNEL-INFO (FUNCALLABLE-STANDARD-OBJECT T))

%RASSOC-TEST names a compiled function:
  Lambda-list: (X LIST TEST)
  Dynamic-extent arguments: positional=(2)
  Declared type: (FUNCTION (T LIST FUNCTION) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T FUNCTION) (VALUES LIST &OPTIONAL))
  Known attributes: call, foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

%FUN-LAYOUT names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (FUNCTION) (VALUES SB-KERNEL:LAYOUT &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

(SETF %FUN-LAYOUT) names a compiled function:
  Lambda-list: (NEWVAL X)
  Derived type: (FUNCTION (T T) (VALUES SB-KERNEL:LAYOUT &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • DEEP-SIZE

INTERNAL-SECONDS-LIMIT names a constant variable:
  Value: 2305843009213

DECODE-SINGLE-FLOAT names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (SINGLE-FLOAT)
                  (VALUES SINGLE-FLOAT (INTEGER -149 128)
                          (OR (SINGLE-FLOAT -1.0 -1.0) (SINGLE-FLOAT 1.0 1.0))
                          &OPTIONAL))
  Derived type: (FUNCTION (SINGLE-FLOAT)
                 (VALUES SINGLE-FLOAT (INTEGER -148 128)
                         (OR (SINGLE-FLOAT -1.0 -1.0) (SINGLE-FLOAT 1.0 1.0))
                         &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;FLOAT.LISP

GET-CLOSURE-LENGTH names a compiled function:
  Lambda-list: (F)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 15) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;SIMPLE-FUN.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • (EMACS-INSPECT (FUNCTION))
  • DEEP-SIZE

%TYPEP names a compiled function:
  Lambda-list: (OBJECT SPECIFIER)
  Declared type: (FUNCTION (T (OR CONS SYMBOL CLASS SB-KERNEL:CTYPE))
                  (VALUES BOOLEAN &OPTIONAL))
  Derived type: (FUNCTION (T T) *)
  Known attributes: flushable, unsafely-flushable, movable, no-verify-arg-count
  Source file: SYS:SRC;CODE;TYPEP.LISP

ARRAY-DIMENSIONS-EQUAL names a compiled function:
  Lambda-list: (ARRAY1 ARRAY2)
  Declared type: (FUNCTION (ARRAY ARRAY) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;ARRAY.LISP

SCHWARTZIAN-STABLE-SORT-VECTOR names a compiled function:
  Lambda-list: (VECTOR COMPARATOR &KEY KEY)
  Derived type: (FUNCTION (T T &KEY (:KEY T))
                 (VALUES
                  (OR LIST (SIMPLE-ARRAY * (*)) SB-KERNEL:EXTENDED-SEQUENCE)
                  &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;EARLY-EXTENSIONS.LISP

+LAYOUT-ALL-TAGGED+ names a constant variable:
  Value: -1

NUMERIC-TYPE names a type-specifier:
  Lambda-list: ()
  Expansion: (SATISFIES SB-KERNEL:NUMERIC-TYPE-P)

TYPE-*-TO-T names a compiled function:
  Lambda-list: (TYPE)
  Derived type: (FUNCTION (T) (VALUES SB-KERNEL:CTYPE &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

%MAKE-FUNCALLABLE-STRUCTURE-INSTANCE-ALLOCATOR names a compiled function:
  Lambda-list: (DD SLOT-SPECS)
  Derived type: (FUNCTION (T T) (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;CODE;DEFSTRUCT.LISP

SIMPLE-ARRAY-UNSIGNED-BYTE-16-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-SIMD:U16VEC

OUTPUT-UGLY-OBJECT names a compiled function:
  Lambda-list: (STREAM OBJECT)
  Derived type: (FUNCTION (T T) *)
  Source file: SYS:SRC;CODE;PRINT.LISP

SIMPLE-ARRAY-UNSIGNED-BYTE-4-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

%SIMD-PACK-512-5 names a compiled function:
  Lambda-list: (PACK)
  Declared type: (FUNCTION (SB-EXT:SIMD-PACK-512)
                  (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

%TANHF names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (SINGLE-FLOAT)
                  (VALUES (SINGLE-FLOAT -1.0 1.0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

SET-ARRAY-HEADER names a compiled function:
  Lambda-list: (ARRAY DATA LENGTH FILL-POINTER DISPLACEMENT DIMENSIONS
                DISPLACEDP NEWP)
  Derived type: (FUNCTION (T T T T T T T T) (VALUES ARRAY &OPTIONAL))
  Source file: SYS:SRC;CODE;ARRAY.LISP

HAIRY-DATA-VECTOR-SET names a compiled function:
  Lambda-list: (ARRAY INDEX NEW-VALUE)
  Declared type: (FUNCTION (ARRAY (UNSIGNED-BYTE 44) T) (VALUES T &OPTIONAL))
  Derived type: (FUNCTION (T T T) *)
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;ARRAY.LISP

CONS-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:CONS-TYPE>:
  Class precedence-list: SB-KERNEL:CONS-TYPE, SB-KERNEL:CTYPE, STRUCTURE-OBJECT,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:CTYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::CAR-TYPE
      Type: SB-KERNEL:CTYPE
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::CDR-TYPE
      Type: SB-KERNEL:CTYPE
      Initform: (SB-INT:MISSING-ARG)

SIMPLE-PACKAGE-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:SIMPLE-PACKAGE-ERROR>:
  Class precedence-list: SB-KERNEL:SIMPLE-PACKAGE-ERROR, SIMPLE-CONDITION,
                         PACKAGE-ERROR, ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SIMPLE-CONDITION, PACKAGE-ERROR
  Direct subclasses: PACKAGE-DOES-NOT-EXIST
  No direct slots.

PACKAGE-DOC-STRING names a compiled function:
  An accessor for PACKAGE
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (PACKAGE) (VALUES (OR SIMPLE-STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;PACKAGE.LISP

(SETF PACKAGE-DOC-STRING) names a compiled function:
  An accessor for PACKAGE
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION ((OR SIMPLE-STRING NULL) PACKAGE)
                 (VALUES (OR SIMPLE-STRING NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;PACKAGE.LISP

*GC-PIN-CODE-PAGES* names a special variable:
  Declared always-bound.
  Value: 0

• Bound by
  • SB-SPROF::MAKE-CALL-GRAPH
• Referenced by
  • SB-SPROF::MAKE-CALL-GRAPH

SYMBOL-%INFO names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (SYMBOL)
                  (VALUES (OR LIST SB-KERNEL:INSTANCE) &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

• Called by
  • DEEP-SIZE

STATIC-CLASSOID names the structure-class #<STRUCTURE-CLASS SB-KERNEL:STATIC-CLASSOID>:
  Class precedence-list: SB-KERNEL:STATIC-CLASSOID, CLASSOID, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CLASSOID
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::NAME
      Type: SYMBOL
      Initform: NIL
    SB-KERNEL:LAYOUT
      Type: (OR NULL SB-KERNEL:LAYOUT)
      Initform: NIL
    SB-KERNEL::STATE
      Type: (MEMBER NIL :READ-ONLY :SEALED)
      Initform: NIL
    SB-KERNEL::DIRECT-SUPERCLASSES
      Type: LIST
      Initform: NIL
    SB-KERNEL::SOURCE-LOCATION
      Type: T
      Initform: NIL
    SB-KERNEL::SUBCLASSES
      Type: (OR LIST HASH-TABLE)
      Initform: NIL
    SB-KERNEL::%LOCK
      Type: T
      Initform: NIL
    SB-KERNEL::PCL-CLASS
      Type: T
      Initform: NIL

%COERCE-CALLABLE-FOR-CALL names a compiled function:
  Lambda-list: (CALLABLE)
  Declared type: (FUNCTION ((OR FUNCTION SYMBOL)) (VALUES FUNCTION &OPTIONAL))
  Derived type: (FUNCTION (T) (VALUES FUNCTION &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;FDEFINITION.LISP

• Called by
  • SB-ACLREPL::INSPECTED-STRUCTURE-PARTS
  • SB-ACLREPL::REPL-READ-FORM-FUN
  • SB-ACLREPL::PROCESS-CMD
  • SB-ACLREPL::REPL-PROMPT-FUN
  • SB-ACLREPL::REMOVE-ALIAS
  • SB-ACLREPL::GET-CMD-DOC-LIST
  • SB-ACLREPL::REP-ONE
  • SB-SIMD-INTERNALS:FILTER-AVAILABLE-FUNCTION-RECORDS
  • SB-SIMD-INTERNALS:FILTER-FUNCTION-RECORDS
  • (SHARED-INITIALIZE AROUND (FUNCTION-RECORD T))
  • (CALL-NEXT-METHOD-N IN home/ellis/src/infra.stash/src/sbcl/contrib/sb-simd/code/record.lisp)
  • SB-SIMD-INTERNALS:FILTER-VALUE-RECORDS
  • SB-SIMD-INTERNALS:INSTRUCTION-SET-AVAILABLE-P
  • SB-INTROSPECT:MAP-ROOT
  • SB-INTROSPECT::COLLECT-SPECIALIZING-METHODS
  • SB-INTROSPECT:FIND-FUNCTION-CALLERS
  • SB-INTROSPECT:FIND-DEFINITION-SOURCES-BY-NAME
  • SB-INTROSPECT::MAP-CALLER-CODE-COMPONENTS
  • SB-INTROSPECT::MAP-ALLOCATED-CODE-COMPONENTS
  • SB-INTROSPECT::MAP-CODE-CONSTANTS
  • SB-CONCURRENCY::PROMISE-COMPILE
  • SB-CONCURRENCY::RUN-BACKGROUND-COMPILE
  • SB-CONCURRENCY::TRY-WALK-QUEUE
  • GET-HOST-BY-ADDRESS
  • GET-HOST-BY-NAME
  • MAKE-INET-SOCKET
  • (SOCKET-ACCEPT (SOCKET))
  • SB-BSD-SOCKETS::CALL-WITH-SOCKET-ADDR
  • SB-POSIX:CFSETOSPEED
  • SB-POSIX:CFSETISPEED
  • TCGETATTR
  • SB-POSIX::ALIEN-TO-TERMIOS
  • SB-POSIX:FSTAT
  • SB-POSIX:LSTAT
  • STAT
  • SB-POSIX::ALIEN-TO-STAT
  • SB-POSIX::ALIEN-TO-TIMEVAL
  • SB-POSIX::GETGRENT
  • SB-POSIX:GETGRGID
  • SB-POSIX:GETGRNAM
  • SB-POSIX::GETPWENT
  • SB-POSIX:GETPWUID
  • SB-POSIX:GETPWNAM
  • SB-POSIX::ALIEN-TO-GROUP
  • SB-POSIX::ALIEN-TO-PASSWD
  • SB-POSIX:FCNTL
  • SB-POSIX::ALIEN-TO-FLOCK
  • (DEFINE-C-STRUCT)
  • (ACCESSORS-FOR (T VALUE-SLOT T))
  • MK-VAL
  • SB-GROVEL::MK-UNION
  • SB-GROVEL::MK-STRUCT
  • SB-GROVEL::MK-PADDING
  • SB-GROVEL::RETRIEVE-TYPE-FOR
  • SB-GROVEL::C-FOR-STRUCTURE
  • ASDF/SOURCE-REGISTRY:COMPUTE-SOURCE-REGISTRY
  • (PROCESS-SOURCE-REGISTRY (SYMBOL))
  • ASDF/SOURCE-REGISTRY::PROCESS-SOURCE-REGISTRY-DIRECTIVE
  • ASDF/SOURCE-REGISTRY::PROCESS-SOURCE-REGISTRY-CACHE
  • (PROCESS-OUTPUT-TRANSLATIONS (SYMBOL))
  • ASDF/OUTPUT-TRANSLATIONS::PROCESS-OUTPUT-TRANSLATIONS-DIRECTIVE
  • (COMPONENT-DEPENDS-ON (LOAD-BUNDLE-OP PRECOMPILED-SYSTEM))
  • (COMPONENT-DEPENDS-ON (LOAD-BUNDLE-OP SYSTEM))
  • ASDF/BUNDLE:DIRECT-DEPENDENCY-FILES
  • (COMPONENT-DEPENDS-ON (GATHER-OPERATION SYSTEM))
  • ASDF/PARSE-DEFSYSTEM:REGISTER-SYSTEM-DEFINITION
  • ASDF/FIND-SYSTEM::DEFINITION-DEPENDENCIES-UP-TO-DATE-P
  • ASDF/FIND-SYSTEM:LOAD-ASD
  • (COMPONENT-DEPENDS-ON (OPERATION SYSTEM))
  • (RESOLVE-DEPENDENCY-COMBINATION (T (EQL REQUIRE) T))
  • (COMPONENT-DEPENDS-ON (BUILD-OP COMPONENT))
  • (OPERATE AROUND (T T))
  • (PERFORM-PLAN AROUND (T))
  • (PLAN-ACTIONS (FILTERED-SEQUENTIAL-PLAN))
  • ASDF/PLAN:REDUCE-DIRECT-DEPENDENCIES
  • ASDF/PLAN:MAP-DIRECT-DEPENDENCIES
  • ASDF/PLAN::MAKE-ACTION-STATUS
  • ASDF/FORCING:MAKE-FORCING
  • ASDF/FORCING::ACTION-OVERRIDE-P
  • (PRINT-OBJECT (MISSING-DEPENDENCY T))
  • (PERFORM-WITH-RESTARTS (LOAD-OP CL-SOURCE-FILE))
  • (PERFORM-WITH-RESTARTS AROUND (T T))
  • (PERFORM AROUND (OPERATION COMPONENT))
  • (INPUT-FILES (SELFWARD-OPERATION COMPONENT))
  • (INPUT-FILES AROUND (T T))
  • (OUTPUT-FILES AROUND (T T))
  • (COMPONENT-DEPENDS-ON (SELFWARD-OPERATION COMPONENT))
  • (COMPONENT-DEPENDS-ON (SIDEWAY-OPERATION COMPONENT))
  • (COMPONENT-DEPENDS-ON (UPWARD-OPERATION CHILD-COMPONENT))
  • (COMPONENT-DEPENDS-ON (DOWNWARD-OPERATION PARENT-COMPONENT))
  • (COMPONENT-DEPENDS-ON AROUND (OPERATION COMPONENT))
  • ASDF/ACTION:CALL-WHILE-VISITING-ACTION
  • ASDF/SYSTEM-REGISTRY:SEARCH-FOR-SYSTEM-DEFINITION
  • ASDF/SYSTEM-REGISTRY:MAP-SYSTEMS
  • (COMPONENT-PATHNAME (SYSTEM))
  • ASDF/SESSION:CALL-WITH-ASDF-SESSION
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FILE
  • UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FORM
  • UIOP/CONFIGURATION:REPORT-INVALID-FORM
  • RUN-PROGRAM
  • UIOP/RUN-PROGRAM::%USE-LAUNCH-PROGRAM
  • UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO
  • (VOMIT-OUTPUT-STREAM (CONS T))
  • (VOMIT-OUTPUT-STREAM #'T)
  • (SLURP-INPUT-STREAM (CONS T))
  • (SLURP-INPUT-STREAM #'T)
  • UIOP/RUN-PROGRAM::CALL-STREAM-PROCESSOR
  • UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM
  • UIOP/LAUNCH-PROGRAM:ESCAPE-COMMAND
  • UIOP/LAUNCH-PROGRAM:ESCAPE-TOKEN
  • UIOP/LISP-BUILD:COMPILE-FILE*
  • UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME*
  • CALL-WITH-SAVED-DEFERRED-WARNINGS
  • UIOP/IMAGE:CALL-WITH-FATAL-CONDITION-HANDLER
  • UIOP/STREAM:CALL-WITH-STAGING-PATHNAME
  • UIOP/STREAM:CALL-WITH-TEMPORARY-FILE
  • UIOP/STREAM:EVAL-THUNK
  • UIOP/STREAM::CALL-WITH-INPUT
  • UIOP/STREAM:CALL-WITH-INPUT-FILE
  • UIOP/STREAM::CALL-WITH-OUTPUT
  • UIOP/STREAM:CALL-WITH-OUTPUT-FILE
  • CALL-WITH-SAFE-IO-SYNTAX
  • UIOP/STREAM:ENCODING-EXTERNAL-FORMAT
  • UIOP/STREAM:DETECT-ENCODING
  • UIOP/FILESYSTEM:LISP-IMPLEMENTATION-DIRECTORY
  • UIOP/FILESYSTEM:CALL-WITH-CURRENT-DIRECTORY
  • UIOP/PATHNAME:TRANSLATE-PATHNAME*
  • UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME
  • UIOP/PATHNAME:MERGE-PATHNAMES*
  • UIOP/OS:DETECT-OS
  • UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS
  • UIOP/UTILITY:MATCH-CONDITION-P
  • UIOP/UTILITY:LEXICOGRAPHIC<
  • UIOP/UTILITY:CALL-FUNCTION
  • UIOP/UTILITY:ACCESS-AT
  • ENSURE-FUNCTION
  • UIOP/COMMON-LISP::FROB-SUBSTRINGS
  • SYMBOL-CALL
  • SB-COVER:REPORT
  • SB-COVER:LCOV-REPORT
  • SB-COVER::MAKE-SOURCE-RECORDER
  • SB-COVER::COVERAGE-AUGMENTATION
  • SB-COVER::NOTE-SUPPRESSIONS
  • SB-COVER::GET-RECORDS
  • SB-COVER:RESET-COVERAGE
  • SB-SPROF:START-PROFILING
  • SB-SPROF::MAKE-NODE-COMPARATOR
  • SB-SPROF::REDUCE-GRAPH
  • SB-SPROF::MAP-VERTICES
  • SB-SPROF::CALL-COUNTER
  • SB-SPROF::DISABLE-CALL-COUNTING
  • SB-SPROF::ENABLE-CALL-COUNTING
  • SB-SPROF::CALL-WITH-EACH-PROFILE-BUFFER
  • SB-SPROF::CALL-WITH-SAMPLING
  • SB-SPROF::MAP-TRACE-PC-LOCS
  • SB-SPROF:MAP-TRACES
  • (PRINT-OBJECT (SAMPLES T))
  • SKEL/MPK::INIT-METRO
  • SKEL/MPK:LOAD-MPKRC
  • SKEL/MPK:INIT-MPKRC
  • (LOAD-AST (MPK-CONFIG))
  • SKEL/MPK/DB:UPDATE-MUSIC-METADATA
  • SKEL/MPK/DB:MPK-DB-SHUTDOWN
  • SKEL/MPK/DB:MPK-DB-INIT
  • (MAKE-ID ((EQL MPK)))
  • SKEL/MPK::MUSIC-METADATA-TAGS
  • SKEL/MPK:GET-MUSIC-METADATA*
  • SKEL/MPK:MPK-ENSURE-DIRECTORIES
  • SKEL/MPK/MPD::LOAD-MPD-CONFIG
  • SKEL/MPK/MPD::MAKE-MPD-AUDIO-OUTPUT
  • SKEL/MPK/MPD::PROCESS-VALUE
  • SKEL/MPK/MPD:MPC-CONNECT
  • (INITIALIZE-INSTANCE AROUND (TRACK))
  • SKEL/HOMER/CORE:LOAD-HOMERC
  • SKEL/HOMER/CORE::INIT-HOMERC
  • (LOAD-AST (HOME-CONFIG))
  • (EXEC (HOMER-JOB))
  • SKEL/KRYPT:LOAD-KRYPTRC
  • SKEL/PACKY/CLI::START-PACKY
  • (MAKE-CONFIG ((EQL PACKY)))
  • SKEL/PACKY::INSERT-PACK
  • SKEL/PACKY:INIT-PACKY-DB
  • (DESERIALIZE (PATHNAME (EQL PKGFILE)))
  • (MAKE-RANDOM-ID ((EQL PACKAGE)))
  • (MAKE-ID ((EQL PACKAGE)))
  • (LOAD-PROJECT-COMPONENT ((EQL EL) PATHNAME))
  • (LOAD-PROJECT-COMPONENT ((EQL DIR-LOCALS) PATHNAME))
  • (LOAD-PROJECT-COMPONENT ((EQL PYTHON-SYSTEM) PATHNAME))
  • (LOAD-PROJECT-COMPONENT ((EQL RUST-SYSTEM) PATHNAME))
  • (PROJECT-COMPILE (MAKEFILE))
  • (LOAD-PROJECT-COMPONENT ((EQL LISP) PATHNAME))
  • (PROJECT-CONVERT (FILE-COMPONENT))
  • SETF-SKEL-VARS
  • INIT-SKEL
  • INIT-SKELFILE
  • LOAD-SKELFILE
  • LOAD-SYSTEM-SKELRC
  • LOAD-USER-SKELRC
  • INIT-SYSTEM-SKELRC
  • INIT-USER-SKELRC
  • SKEL/CORE::SK-LOG-DESTROY
  • SK-LOG-REPAIR
  • SKEL/CORE::SK-LOG
  • (CALL (SKEL-PROJECT (EQL CLEAN)))
  • (WRITE-AST AROUND (SKEL-PROJECT T))
  • (LOAD-AST (SKEL-PROJECT))
  • SKEL/CORE::DEFAULT-SKEL-USER-CONFIG
  • SKEL/CORE::DEFAULT-SKEL-SYSTEM-CONFIG
  • MATH/GRAPH:MAX-DAG
  • MATH/GRAPH:DIRECTED-SUBGRAPH
  • MATH/GRAPH:DIJKSTRA-PRIMS
  • MATH/GRAPH:DIJKSTRA
  • MATH/GRAPH:CHOLESKY-COVER
  • MATH/GRAPH:ELIMINATION-TREE
  • MATH/GRAPH:MAX-CARDINALITY-SEARCH
  • MATH/GRAPH::GRAPH-QUEUE
  • MATH/GRAPH::CLIQUEP
  • MATH/GRAPH::HYPER->BIPARTITE
  • MATH/GRAPH::ADLIST-TO-GRAPH
  • MATH/SYN::OP-OVERLOAD
  • (T.LAPACK-TRSYL!)
  • (T.LAPACK-GESVD!)
  • (T.LAPACK-GEES!)
  • (T.LAPACK-ORMQR!)
  • (T.LAPACK-ORGQR!)
  • (T.LAPACK-GEHR!)
  • (T.LAPACK-GEQP!)
  • (T.LAPACK-GELSY!)
  • (GEEV! BEFORE (TENSOR))
  • (T.GEEV-OUTPUT-FIX)
  • (T.LAPACK-HEEV!)
  • (T.LAPACK-GEEV!)
  • MATH/LAPACK:LDL
  • (T.LAPACK-LDL!)
  • (T.LAPACK-POTRI!)
  • (T.LAPACK-POTRS!)
  • (T.LAPACK-POTRF!)
  • (T.LAPACK-GETRI!)
  • (T.LAPACK-GETRS!)
  • (T.LAPACK-GETRF!)
  • (T.BLAS-TRSV!)
  • (T.BLAS-TRSM!)
  • (T.GER!)
  • (T.BLAS-GER!)
  • (T.GEMM!)
  • (T.GEMV!)
  • (T.BLAS-GEMM!)
  • (T.BLAS-GEMV!)
  • (T.SUM)
  • (AXPY! BEFORE (NUMBER BASE-TENSOR BASE-TENSOR))
  • (T.AXPY!)
  • (T.BLAS-AXPY!)
  • (SEND-REQUEST (LIBPOD-CLIENT T))
  • LIBPOD-REQUEST
  • (WITH-LIBPOD-CLIENT)
  • (DESERIALIZE (PATHNAME (EQL CONTAINERFILE)))
  • PROJECT-DOCUMENTATION
  • SYSTEM-DOCUMENTATION
  • PACKAGE-DOCUMENTATION
  • MAKE-FILE-HEADER
  • FILE-DOCUMENTATION
  • (CHANGE-CLASS (MOD-COMPONENT (EQL MOD-DOCUMENTATION)))
  • READ-FILE-HEADER
  • DOC::READ-FILE-HEADLINE
  • DOC::READ-FILE-HEADING
  • SYMBOL-DOCUMENTATION
  • FUZZY-MATCH
  • DOC/NLP::UNION-LENGTH
  • DOC/NLP::INTERSECTION-LENGTH
  • EXTRACT-SECTIONS
  • SUMMARIZE-TEXT
  • (TEXTRANK (DOCUMENT-COLLECTION))
  • (VECTORIZE-DOCUMENTS (DOCUMENT-COLLECTION T))
  • EXTRACT-KEYWORDS
  • MAKE-HG-REPO
  • (VC-INIT ((EQL HG)))
  • (CHANGE-CLASS (INI-DOCUMENT (EQL HG-CONFIG)))
  • (MAKE-CONFIG ((EQL HG)))
  • (VC-INIT ((EQL GIT)))
  • MAKE-GIT-REPO
  • (CHANGE-CLASS (INI-DOCUMENT (EQL GIT-CONFIG)))
  • (VC-PATH-IGNORED-P (VC-IGNORE T))
  • VC/PROTO::MAP-LINES
  • ORGAN/GRAPH::%ORG-HEADING-HASH-TABLE
  • ORGAN/GRAPH::EXPAND-FILES
  • ORGAN/GRAPH:ORG-GRAPH-EXTRACT-FILES
  • ORGAN/GRAPH::WRAP-EDGE
  • ORGAN/GRAPH::WRAP-NODE
  • ORGAN/GRAPH::EXTRACT-EXTERNAL-NODE
  • (READ-AST ((EQL ORG-GRAPH) T))
  • (ORG-PARSE ((EQL HEADING) STREAM))
  • INIT-RDBRC
  • (STORED-SLOT-MAKUNBOUND (RDB-STORE T T))
  • (STORED-SLOT-BOUNDP (RDB-STORE T T))
  • (STORED-SLOT-WRITER (RDB-STORE T T T))
  • (STORED-SLOT-READER (RDB-STORE T T))
  • (CURSOR-NEXT-NODUP (RDB-DUP-CURSOR))
  • (MAKE-CURSOR (RDB-DUP-BTREE))
  • (DELETE-KEY (T RDB-DUP-BTREE))
  • ((SETF GET-VALUE) (T T RDB-DUP-BTREE))
  • (EXISTSP (T RDB-DUP-BTREE))
  • (GET-VALUE (T RDB-DUP-BTREE))
  • (BUILD-DUP-BTREE (RDB-STORE))
  • (CURSOR-PPREV-NODUP (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PPREV-NODUP)
  • (CURSOR-PNEXT-NODUP (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PNEXT-NODUP)
  • (CURSOR-PNEXT-DUP (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PNEXT-DUP)
  • (CURSOR-PREV-NODUP (RDB-SECONDARY-CURSOR))
  • (CURSOR-NEXT-NODUP (RDB-SECONDARY-CURSOR))
  • (CURSOR-NEXT-DUP (RDB-SECONDARY-CURSOR))
  • (CURSOR-DELETE (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-DELETE)
  • (CURSOR-PGET-BOTH-RANGE (RDB-SECONDARY-CURSOR T T))
  • (BODY IN CURSOR-PGET-BOTH-RANGE)
  • (CURSOR-PGET-BOTH (RDB-SECONDARY-CURSOR T T))
  • (BODY IN CURSOR-PGET-BOTH)
  • (CURSOR-PSET-RANGE (RDB-SECONDARY-CURSOR T))
  • (BODY IN CURSOR-PSET-RANGE)
  • (CURSOR-PSET (RDB-SECONDARY-CURSOR T))
  • (BODY IN CURSOR-PSET)
  • (CURSOR-PPREV (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PPREV)
  • (CURSOR-PNEXT (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PNEXT)
  • (CURSOR-PLAST (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PLAST)
  • (CURSOR-PFIRST (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PFIRST)
  • (CURSOR-PCURRENT (RDB-SECONDARY-CURSOR))
  • (BODY IN CURSOR-PCURRENT)
  • (MAKE-CURSOR (RDB-BTREE-INDEX))
  • (CURSOR-PUT (RDB-CURSOR T))
  • (CURSOR-DELETE (RDB-CURSOR))
  • (CURSOR-GET-BOTH-RANGE (RDB-CURSOR T T))
  • (CURSOR-GET-BOTH (RDB-CURSOR T T))
  • (CURSOR-SET-RANGE (RDB-CURSOR T))
  • (CURSOR-SET (RDB-CURSOR T))
  • (CURSOR-PREV (RDB-CURSOR))
  • (CURSOR-NEXT (RDB-CURSOR))
  • (CURSOR-LAST (RDB-CURSOR))
  • (CURSOR-FIRST (RDB-CURSOR))
  • (CURSOR-CURRENT (RDB-CURSOR))
  • (CURSOR-DUPLICATE (RDB-CURSOR))
  • (MAKE-CURSOR (RDB-BTREE))
  • (GET-PRIMARY-KEY (T BTREE-INDEX))
  • (GET-VALUE (T RDB-BTREE-INDEX))
  • (DELETE-KEY (T RDB-INDEXED-BTREE))
  • (BODY IN DELETE-KEY)
  • ((SETF GET-VALUE) (T T RDB-INDEXED-BTREE))
  • (MAP-INDEX (T RDB-INDEXED-BTREE))
  • (POPULATE (RDB-INDEXED-BTREE T))
  • (BODY IN POPULATE)
  • (ADD-INDEX (RDB-INDEXED-BTREE))
  • (BUILD-BTREE-INDEX (RDB-STORE))
  • (BUILD-INDEXED-BTREE (RDB-STORE))
  • (DELETE-KEY (T RDB-BTREE))
  • ((SETF GET-VALUE) (T T RDB-BTREE))
  • (EXISTSP (T RDB-BTREE))
  • (BODY IN EXISTSP)
  • (GET-VALUE (T RDB-BTREE))
  • (BODY IN GET-VALUE)
  • (BUILD-BTREE (RDB-STORE))
  • (EXECUTE-TRANSACTION (RDB-DATABASE FUNCTION))
  • (LOAD-SCHEMA (RDB-DATABASE SCHEMA))
  • (MAKE-DB ((EQL RDB)))
  • (OPEN-WITH-COLUMNS (RDB-DATABASE))
  • (ADD-COLUMN (RDB-CF RDB-DATABASE))
  • (LOAD-OPTS (RDB-DATABASE))
  • (CHANGE-CLASS (COLUMN (EQL RDB-COLUMN-FAMILY)))
  • (CHANGE-CLASS (RDB-CF (EQL RDB-COLUMN-FAMILY)))
  • (CHANGE-CLASS (FIELD (EQL RDB-COLUMN-FAMILY)))
  • (PULL-SAP* (RDB-BACKUPOPTS))
  • (PUSH-SAP* (RDB-BACKUPOPTS))
  • (AST (RDB-BACKUPOPTS))
  • (PULL-SAP* (RDB-COMPACTOPTS))
  • (PUSH-SAP* (RDB-COMPACTOPTS))
  • (AST (RDB-COMPACTOPTS))
  • (PULL-SAP* (RDB-WRITEOPTS))
  • (PUSH-SAP* (RDB-WRITEOPTS))
  • (AST (RDB-WRITEOPTS))
  • (PULL-SAP* (RDB-READOPTS))
  • (PUSH-SAP* (RDB-READOPTS))
  • (AST (RDB-READOPTS))
  • (PULL-SAP* (RDB-OPTS))
  • (PUSH-SAP* (RDB-OPTS))
  • (AST (RDB-OPTS))
  • RDB::%GET-RDB-INGESTOPT
  • RDB::%SET-RDB-INGESTOPT
  • RDB::%GET-RDB-COMPACTOPT
  • RDB::%SET-RDB-COMPACTOPT
  • RDB::%GET-RDB-BACKUPOPT
  • RDB::%SET-RDB-BACKUPOPT
  • RDB::%GET-RDB-WRITEOPT
  • RDB::%SET-RDB-WRITEOPT
  • RDB::%GET-RDB-READOPT
  • RDB::%SET-RDB-READOPT
  • RDB::%GET-RDB-OPT
  • RDB::%SET-RDB-OPT
  • RDB::MAKE-ROCKSDB-OPTIONS
  • Q/SQL:MAKE-SQL-DF
  • Q/SQL::PLAN-AGGREGATE-QUERY
  • Q/SQL::PLAN-NON-AGGREGATE-QUERY
  • Q/SQL::MAKE-SQL-LOGICAL-EXPRESSION
  • (PARSE-SELECT (SQL-PARSER))
  • (PARSE-CAST (SQL-PARSER))
  • (PARSE-ORDER (SQL-PARSER))
  • (PARSE-INFIX (SQL-PARSER SQL-EXPRESSION T))
  • (PARSE-PREFIX (SQL-PARSER))
  • (EXEC (LOGICAL-QUERY-PLAN))
  • Q/PROTO::%PUSHDOWN
  • (MAKE-PHYSICAL-PLAN (LOGICAL-QUERY-PLAN))
  • (MAKE-PHYSICAL-EXPRESSION (COLUMN-EXPRESSION LOGICAL-QUERY-PLAN))
  • (MAKE-PHYSICAL-EXPRESSION (BINARY-EXPRESSION LOGICAL-QUERY-PLAN))
  • (MAKE-ACCUMULATOR (MAX-PHYSICAL-EXPRESSION))
  • (EVALUATE (STRING RECORD-BATCH))
  • (EVALUATE (NUMBER RECORD-BATCH))
  • (DF-AGGREGATE (DATA-FRAME VECTOR VECTOR))
  • (DF-FILTER (DATA-FRAME LOGICAL-EXPR))
  • (DF-PROJ (DATA-FRAME VECTOR))
  • (SCHEMA (JOIN))
  • (DF-COL (STRING))
  • (PROJ (SCHEMA LIST))
  • (PROJ (SCHEMA VECTOR))
  • (SELECT (SCHEMA LIST))
  • (SELECT (SCHEMA VECTOR))
  • (DESERIALIZE (JSON-OBJECT (EQL OPENAPI)))
  • NET/SRV/OAUTH::SERVLET
  • NET/SRV/OAUTH::OAUTH2-REFRESH-TOKEN
  • NET/SRV/OAUTH::OAUTH2-AUTH-CODE
  • NET/SRV/OAUTH::GET-AUTH-REQUEST-URL
  • (INITIALIZE-CONNECTION-HOOK (SSL-SERVICE T))
  • NET/SRV/http::WAKE-TCP-SERVICE-FOR-SHUTDOWN
  • (PROCESS-CONNECTION (HTTP-SERVICE T))
  • NET/SRV/http::HANDLE-STATIC-FILE
  • NET/SRV/http::MAYBE-HANDLE-RANGE-HEADER
  • (PROCESS-CONNECTION (UDP-SERVICE T))
  • NET/SRV::DISPATCH-ROUTES
  • CALL-WITH-REQUEST-COUNT-INCF
  • (PROCESS-CONNECTION AROUND (NET-SERVICE T))
  • (START-LISTENING (NET-SERVICE))
  • (START-LISTENING AROUND (NET-SERVICE))
  • SEND-SERVICE-UNAVAILABLE-RESPONSE
  • START-SESSION
  • (SEND-REQUEST AROUND (SIMPLE-HTTP-CLIENT T))
  • (SEND-REQUEST (HTTP-CLIENT T))
  • (MAKE-CLIENT-REQUEST BEFORE (SIMPLE-HTTP-CLIENT T))
  • NET/REQ::RETRY-REQUEST-NTIMES
  • NET/REQ::REQ
  • NET/REQ::READ-RESPONSE
  • NET/REQ:CLEAR-CONNECTION-POOL
  • NET/REQ::PUSH-CONNECTION
  • NET/REQ::DECOMPRESS-BODY
  • (CLOSE (KEEP-ALIVE-STREAM))
  • NET/REQ::MAYBE-CLOSE
  • NET/REQ::MAKE-KEEP-ALIVE-STREAM
  • NET/PROTO/DM::ENSURE-DM-NODE
  • NET/PROTO/DBUS::CALL-WITH-OPEN-BUS
  • (APPLY-HANDLER (DBUS-METHOD-HANDLER DBUS-METHOD-CALL-MESSAGE CONNECTION))
  • (APPLY-HANDLER (DBUS-SIGNAL-HANDLER DBUS-SIGNAL-MESSAGE CONNECTION))
  • NET/PROTO/DBUS::MAKE-DBUS-SIGNAL
  • NET/PROTO/DBUS::MAKE-DBUS-PROPERTY
  • NET/PROTO/DBUS::MAKE-DBUS-METHOD
  • NET/PROTO/DBUS::MAKE-DBUS-INTERFACE
  • NET/PROTO/DBUS::LIST-INTERFACE-SIGNALS
  • NET/PROTO/DBUS::LIST-INTERFACE-PROPERTIES
  • NET/PROTO/DBUS::LIST-INTERFACE-METHODS
  • NET/PROTO/DBUS::MAKE-OBJECT
  • NET/PROTO/DBUS::LIST-OBJECT-INTERFACES
  • (CONNECT (T UNIX-SERVER-ADDRESS))
  • (AUTHENTICATE AROUND (T STANDARD-DBUS-CONNECTION))
  • (SUPPORTED-AUTHENTICATORS (STANDARD-DBUS-CONNECTION))
  • NET/PROTO/DBUS::PARSE-SERVER-ADDRESSES-FROM-STREAM
  • (CONNECT AROUND (T STANDARD-SERVER-ADDRESS))
  • NET/PROTO/http::PARSE-HEADER-VALUE-PARAMETERS
  • PARSE-RESPONSE
  • PARSE-REQUEST
  • NET/PROTO/http::PARSE-CHUNKED-BODY
  • NET/PROTO/http::PARSE-HTTP-BODY
  • NET/PROTO/http::READ-BODY-DATA
  • NET/PROTO/http::PARSE-HEADER-VALUE
  • NET/PROTO/http::PARSE-HEADER-FIELD-AND-VALUE
  • NET/PROTO/http::PARSE-STATUS-CODE
  • MAKE-MULTIPART-PARSER
  • HTTP-MULTIPART-PARSE
  • MAKE-HTTP-PARSER
  • NET/PROTO/http::NUMBER-STRING-P
  • NET/PROTO/http::POSITION-NOT-WHITESPACE
  • EVAL-REPEATEDLY-ASYNC-STATE
  • NET/PROTO/CREW::ASYNC-RESULTS-LOOP
  • EVAL-FORM-REPEATEDLY
  • PARALLEL-REDUCE
  • (WITH-MUTEX-THUNK IN PARALLEL-REDUCE)
  • NET/PROTO/CREW::DISPATCH-WORK
  • (WITH-MUTEX-THUNK IN DISPATCH-WORK)
  • NET/PROTO/CREW::EVAL-ON-MASTER
  • NET/PROTO/CREW::HANDLE-CONNECTION-CLOSED
  • (WITH-MUTEX-THUNK IN HANDLE-CONNECTION-CLOSED)
  • NET/PROTO/CREW::ALLOCATE-WORKER-AND-EVALUATE
  • NET/PROTO/CREW::CONNECT-WORKERS
  • MAKE-CREW
  • NET/PROTO/SWANK::SLIME-DISPATCH-EVENTS
  • SLIME-EVAL-ASYNC
  • NET/PROTO/SWANK::SLIME-DISPATCH-EVENT
  • NET/PROTO/SWANK::SLIME-NET-CONNECT
  • NET/PROTO/DNS::TRY-SERVER
  • REGISTER-DBUS-SIGNAL-HANDLER
  • NET/CODEC/DBUS::REGISTER-DBUS-METHOD
  • REGISTER-DBUS-OBJECT
  • DECODE-DBUS-MESSAGE
  • ENCODE-DBUS-MESSAGE
  • NET/CODEC/DBUS::UNPACK-VARIANT
  • NET/CODEC/DBUS::UNPACK-ARRAY
  • NET/CODEC/DBUS::PACK-ARRAY
  • NET/CODEC/DBUS::UNPACK-STRING
  • NET/CODEC/DBUS::PACK-STRING
  • NET/CODEC/DBUS::UNPACK-1
  • NET/CODEC/DBUS::PACK-1
  • NET/CODEC/DBUS::VALID-VALUE-P
  • NET/CODEC/DBUS::FORMAT-SIGEXP-TO-STREAM
  • NET/CODEC/DBUS::PARSE-SIGNATURE-FROM-STREAM
  • MAKE-KEYWORD
  • (OSC-DISPATCH (T OSC-MESSAGE T T T))
  • MAKE-OSC-BUNDLE
  • MAKE-OSC-MESSAGE
  • MAKE-TLV
  • DECODE-RESPONSE
  • UDP-RECEIVE-PING
  • UDP-ECHO
  • TCP-RECEIVE-PING
  • TCP-ECHO
  • NET/CORE::PORT-OPEN-P
  • MAKE-SOCKET
  • (EXECUTE-TEMPLATE (PATHNAME))
  • (EXECUTE-TEMPLATE (TEMPO-FUNCTION))
  • (EXECUTE-TEMPLATE (T))
  • SYN/TEMPO:TEMPO-FUNCTION
  • SYN/GEN/CU::GEN-CU
  • SYN/GEN/CU::READ-CU-STRING
  • SYN/GEN/CU::READ-CU-FILE
  • SYN/GEN/CPP::GEN-CPP
  • SYN/GEN/CPP::READ-CPP-STRING
  • SYN/GEN/CPP::READ-CPP-FILE
  • SYN/GEN/C:GEN-C
  • SYN/GEN/C:READ-C-STRING
  • SYN/GEN/C:READ-C-FILE
  • SYN/GEN:CODE-PRINT
  • SYN/GEN:PRINT-CODE
  • SYN/GEN::%MAKE-NODE
  • SYN/FMT::READ-FMT
  • (MAKE-CONFIG ((EQL TRANSMISSION)))
  • (MAKE-CONFIG ((EQL FIREFOX)))
  • (MAKE-CONFIG ((EQL CHROMIUM)))
  • LOAD-MAKEPKG-CONFIG
  • (MAKE-CONFIG ((EQL TMUX)))
  • MAKE-TOPLEVEL-INIT
  • INSTALL-REPL
  • CLI/LINEDIT::TOGGLE-INSERT
  • CLI/LINEDIT::INSPECT-WORD
  • CLI/LINEDIT::DESCRIBE-WORD
  • CLI/LINEDIT::APROPOS-WORD
  • CLI/LINEDIT::COMPLETE
  • CLI/LINEDIT::HELP
  • CLI/LINEDIT::STOP-LISP
  • CLI/LINEDIT::INTERRUPT-LISP
  • CLI/LINEDIT::KILL-SEXP
  • CLI/LINEDIT::SET-MARK
  • CLI/LINEDIT::CUT-REGION
  • CLI/LINEDIT::COPY-REGION
  • CLI/LINEDIT::KILL-TO-BOL
  • CLI/LINEDIT::KILL-TO-EOL
  • CLI/LINEDIT::YANK-CYCLE
  • CLI/LINEDIT::YANK
  • CLI/LINEDIT::SEARCH-HISTORY-FORWARD
  • CLI/LINEDIT::SEARCH-HISTORY-BACKWARD
  • CLI/LINEDIT::HISTORY-NEXT
  • CLI/LINEDIT::HISTORY-PREVIOUS
  • CLI/LINEDIT::UNDO
  • CLI/LINEDIT::FINISH-INPUT
  • CLI/LINEDIT::LISP-COMPLETE
  • CLI/LINEDIT::DIRECTORY-COMPLETE
  • CLI/LINEDIT::EDITOR-COMPLETE
  • CLI/LINEDIT::NEXT-CHORD
  • (BACKEND-INIT (SMART-TERMINAL))
  • CLI/LINEDIT::EOF-HANDLER
  • (REWIND-STATE (EDITOR))
  • SAVE-STATE
  • ENSURE-BUFFER
  • COPY-BUFFER
  • ((SETF GET-POINT) AROUND (T T))
  • ((SETF GET-STRING) AROUND (T T))
  • (MAKE-CONFIG ((EQL EMACS)))
  • (MAKE-CONFIG ((EQL EDITOR)))
  • CAPABILITIES
  • CLI/TERM::%CAPABILITY
  • CLI/PROGRESS::MAKE-PROGRESS-BAR
  • CONCAT-ENV-TABLE
  • SET-TTY-MODE
  • CLI/ANSI::SET-TERMIOS-FLAG
  • MAKE-CLI
  • (MAKE-CONFIG ((EQL SSH)))
  • (MAKE-CONFIG ((EQL GPG-AGENT)))
  • (MAKE-CONFIG ((EQL GPG)))
  • (MAKE-KEYRING (NUMBER))
  • (MAKE-KEYRING ((EQL USER)))
  • (MAKE-KEYRING ((EQL THREAD)))
  • (MAKE-KEYRING ((EQL USER-SESSION)))
  • (MAKE-KEYRING ((EQL SESSION)))
  • (MAKE-KEYRING ((EQL GROUP)))
  • (MAKE-KEYRING ((EQL PROCESS)))
  • (MAKE-KEYRING ((EQL REQKEY-AUTH)))
  • (DESERIALIZE (STRING (EQL AUTHINFO)))
  • (DESERIALIZE (PATHNAME (EQL AUTHINFO)))
  • CRY/TLS::CALL-WITH-GLOBAL-CONTEXT
  • CRY/TLS:MAKE-SSL-SERVER-STREAM
  • CRY/TLS:MAKE-SSL-CLIENT-STREAM
  • CRY/TLS::INSTALL-NONBLOCK-FLAG
  • (STREAM-FORCE-OUTPUT (SSL-STREAM))
  • (STREAM-READ-SEQUENCE (SSL-STREAM T))
  • (STREAM-READ-BYTE (SSL-STREAM))
  • (STREAM-LISTEN (SSL-STREAM))
  • (CLOSE (SSL-STREAM))
  • (INIT ((EQL SSL)))
  • CRY/TLS::NONBLOCKING-SSL-FUNCALL
  • CRY/TLS::ENSURE-SSL-FUNCALL
  • CRY/TLS::COLLECTING-VERIFY-ERROR-IMPL
  • PARSE/YACC:PARSE-WITH-LEXER
  • PARSE/YACC::LR1-ADD-COLLECTION
  • PARSE/YACC::MAP-LR1-COLLECTION
  • PARSE/LEX:MATCHER-PREV
  • PARSE/LEX:MATCHER-NEXT
  • PARSE/LEX:MATCHER-NOT
  • PARSE/LEX:MATCHER-AND
  • PARSE/LEX:MATCHER-OR
  • PARSE/LEX:CONSUME-UNTIL
  • (VECTOR-CASE)
  • JACK:JACK-HANDLE-EVENT-SEQS
  • JACK:JACK-SEQ-HUSH-ALL-SEQS
  • JACK:JACK-ALL-NOTES-OFF
  • JACK:SEQHASH-CLEAR-NOTE-OFFS
  • JACK:SEQHASH-MIDI-PITCH-WHEEL-MSG
  • JACK:SEQHASH-MIDI-PROGRAM-CHANGE
  • (FUZZ* (LIST FUNCTION))
  • (FUZZ* (VECTOR FUNCTION))
  • (FUZZ* (HASH-TABLE FUNCTION))
  • (FUZZ* (RANDOM-STATE FUNCTION))
  • (FUZZ (FUZZER))
  • RT/FUZZ:FUZZER
  • RT/LIPSUM:LIPSUM
  • MAKE-GRAPH
  • RT/FLAMEGRAPH::SEARCH-OR-ADD-CHILD
  • RT/TRACING::EXTRACT-THREADS
  • (POST-PROCESS-ARG (SEQUENCE))
  • RT/TRACING::%TRACE-START-BREAKPOINT-FUN
  • RT/TRACING::GET-CURRENT-TIME
  • RT/TRACING::CONVERT-ARGS
  • (DO-TEST (TEST))
  • (FUNCALL-TEST (TEST))
  • (INITIALIZE-INSTANCE (TEST))
  • DAT/QRCODE:QR-SYMBOL-TO-PNG
  • DAT/QRCODE::INPUT->SYMBOL
  • DAT/QRCODE::BYTES->INPUT
  • DAT/QRCODE::MASK-MATRIX
  • DAT/QRCODE::COPY-AND-MASK
  • DAT/QRCODE::SEGMENT->BSTREAM
  • (EC-CODING (QR-INPUT))
  • (ANALYSE-NUMERIC-MODE (QR-INPUT))
  • (ANALYSE-ALNUM-MODE (QR-INPUT))
  • (ANALYSE-BYTE-MODE (QR-INPUT))
  • (DATA-ANALYSIS (QR-INPUT))
  • DAT/QRCODE::POLY-MOD
  • DAT/QRCODE::POLY-SUBSTRACT
  • DAT/QRCODE::POLY-MULTIPLY
  • DAT/TTF:GET-FONT-SUBFAMILIES
  • DAT/TTF:GET-FONT-FAMILIES
  • DAT/TTF::OPEN-FONT-LOADER-FROM-STREAM
  • (INDEX-GLYPH (T T))
  • DAT/TTF::TRANSFORM-CONTOURS
  • DAT/TTF::MAKE-CONTROL-POINT
  • DAT/TTF::LOAD-UNICODE-CMAP
  • DAT/TTF::LOAD-UNICODE-CMAP-FORMAT12
  • DAT/TTF::LOAD-NAME-INFO
  • (ALL-KERNING-PAIRS (FONT-LOADER))
  • DAT/TTF::LOAD-KERNING-FORMAT-2
  • DAT/GIF::PROCESS-OBJECTS
  • DAT/GIF::READ-GRAPHIC-CONTROL-EXTENSION
  • DAT/GIF::WRITE-GIF-STREAM
  • DAT/GIF:MAKE-GIF-STREAM
  • DAT/GIF:MAKE-GIF-IMAGE
  • (FINISH-PNG (PIXEL-STREAMED-PNG))
  • (RESET (PIXEL-STREAMED-PNG))
  • (START-PNG (PIXEL-STREAMED-PNG T))
  • (START-PNG (STREAMED-PNG T))
  • (COPY-PNG (T))
  • (WRITE-IDAT (T T))
  • DAT/PNG::MAKE-CHUNK
  • (PRINT-MIDI-MESSAGE (TIME-SIGNATURE-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (SMPTE-OFFSET-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (TEMPO-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (TEXT-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (TIMING-CODE-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (PROGRAM-CHANGE-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (NOTE-ON-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (NOTE-OFF-MESSAGE T))
  • (PRINT-MIDI-MESSAGE (CHANNEL-MESSAGE T))
  • DAT/MIDI:READ-MIDI-FILE
  • DAT/MIDI::WRITE-TRACK
  • DAT/MIDI::READ-MESSAGE
  • DAT/TAR:CALL-WITH-OPEN-TAR-FILE
  • (WRITE-GNU-LONG-NAME-ENTRY (T T))
  • (WRITE-GNU-LONG-LINK-NAME-ENTRY (T T))
  • (WRITE-PAX-GLOBAL-ATTRIBUTES-ENTRY (T T))
  • (WRITE-PAX-EXTENDED-ATTRIBUTES-ENTRY (T T))
  • (ATTRIBUTE-NAMES (PAX-ATTRIBUTES-ENTRY))
  • (WRITE-FIFO-ENTRY (T T))
  • (WRITE-DIRECTORY-ENTRY (T T))
  • (WRITE-BLOCK-DEVICE-ENTRY (T T))
  • (WRITE-CHARACTER-DEVICE-ENTRY (T T))
  • (WRITE-SYMBOLIC-LINK-ENTRY (T T))
  • (WRITE-HARD-LINK-ENTRY (T T))
  • (WRITE-FILE-ENTRY (T T))
  • (READ-HEADER-FROM-BUFFER ((EQL GNU-HEADER) T T))
  • (READ-HEADER-FROM-BUFFER ((EQL USTAR-HEADER) T T))
  • (READ-HEADER-FROM-BUFFER ((EQL V7-HEADER) T T))
  • (READ-ENTRY AROUND (TAR-FILE))
  • (READ-ENTRY (TAR-FILE))
  • DAT/TAR:OPEN-TAR-FILE
  • DAT/TAR::DETECT-TYPE
  • DAT/TAR::TAR-CHECKSUM-GUTS
  • DAT/BIB::READ-BIBTEX-STREAM
  • DAT/BIB::READ-BIBTEX-ENTRY
  • DAT/ARFF:PARSE-ARFF-STREAM
  • DAT/TOML::TOML-READ-DOCUMENT
  • DAT/TOML::TOML-READ-TABLE
  • (SERIALIZE (LIST (EQL INI)))
  • DAT/INI::INI-READ-DOCUMENT
  • DAT/INI::INI-READ-SECTION
  • DAT/HTML::ESCAPE-CHAR-ALL
  • DAT/HTML::ESCAPE-CHAR-ISO-8859-1
  • DAT/HTML::ESCAPE-CHAR-MINIMAL-PLUS-QUOTES
  • DAT/HTML::ESCAPE-CHAR-MINIMAL
  • DAT/HTML::ESCAPE-CHAR
  • DAT/HTML::CALL-PHASE-METHOD
  • DAT/HTML::PARSE-HTML5-FROM-SOURCE
  • DAT/HTML:ELEMENT-MAP-ATTRIBUTES
  • DAT/HTML:ELEMENT-MAP-ATTRIBUTES*
  • DAT/HTML:MAKE-TEXT-NODE
  • DAT/HTML:MAKE-ELEMENT
  • DAT/HTML:MAKE-COMMENT
  • DAT/HTML:MAKE-DOCTYPE
  • DAT/HTML:MAKE-FRAGMENT
  • DAT/HTML:MAKE-DOCUMENT
  • (RUN-STATE* (T (EQL MARKUP-DECLARATION-OPEN-STATE)))
  • DAT/HTML::MAP-TOKENS
  • DAT/HTML::MAKE-HTML-TOKENIZER
  • DAT/HTML::OPEN-CHAR-STREAM
  • DAT/HTML::MAKE-HTML-INPUT-STREAM
  • DAT/XML::XMLDECL
  • DAT/PARQUET::PARQUET-READ-FILE-META-DATA
  • DAT/CSS::FORMAT-DECLARATION
  • DAT/CSS::FORMAT-DECLARATION-VALUE
  • (LOAD-AST (JSON-SCHEMA))
  • DAT/JSON::RESOLVE-JSON-REFERENCE
  • DAT/JSON:JSON-ENABLE-READER-MACRO
  • DAT/JSON::JSON-READ-OBJECT
  • DAT/DOT::GRAPH-FROM-DOT
  • DAT/DOT:GRAPH-TO-DOT
  • DAT/DOT::NODE-TO-DOT
  • DAT/DOT::EDGE-TO-DOT
  • DAT/IMG:READ-CANVAS
  • (SCALE (CANVAS T))
  • DAT/IMG::MAKE-CANVAS
  • (CLONE (CANVAS))
  • (DESERIALIZE (T (EQL JPEG)))
  • LOG::BUILD-LOGGER-CONFIG
  • (MAKE-CONFIG ((EQL LOGGER)))
  • DEFAULT-LOGGER
  • (LOG-OBJECT (T T SYMBOL))
  • (LOG-OBJECT (T T FUNCTION))
  • LOG-MESSAGE*
  • LOG-TIMESTAMP-SOURCE
  • IO/MUX::DISPATCH-FD-TIMEOUTS
  • IO/MUX::%DISPATCH-EVENT
  • IO/MUX::%HANDLE-ONE-FD
  • (EVENT-DISPATCH AROUND (EVENT-BASE))
  • (INITIALIZE-INSTANCE AFTER (EVENT-BASE))
  • (CLOSE-MULTIPLEXER AROUND (MULTIPLEXER))
  • IO/KBD:SEARCH-KEYMAP
  • IO/KBD:DEFINE-KEY
  • IO/KBD:KEYSYMS-FROM-CHARACTER
  • IO/KBD::LIST-ALL-KEYCODES
  • IO/DISK:LIST-DISKS
  • IO/DEFLATE::GZIP-STREAM
  • (FINISH-DATA-FORMAT (DEFLATE-COMPRESSOR))
  • IO/DEFLATE:DEFLATE
  • IO/DEFLATE::MERGE-INPUT
  • (FLUSH (BITSTREAM))
  • IO/DEFLATE::MERGE-OCTET
  • IO/DEFLATE::MERGE-BITS
  • (STREAM-READ-SEQUENCE (DECOMPRESSING-DEFLATE-STREAM T))
  • IO/DEFLATE::REFILL-STREAM-OUTPUT-BUFFER
  • IO/DEFLATE::MAKE-DECOMPRESSING-DEFLATE-STREAM
  • IO/DEFLATE::%DECOMPRESS/STREAM-STREAM
  • IO/DEFLATE::%DECOMPRESS/STREAM-VECTOR
  • IO/DEFLATE::%DECOMPRESS/VECTOR-VECTOR
  • IO/DEFLATE::%DECOMPRESS/NULL-STREAM
  • IO/DEFLATE::%DECOMPRESS/NULL-VECTOR
  • IO/DEFLATE::%BZIP2-STATE-MACHINE
  • (BZIP2-OUTPUT IN %BZIP2-STATE-MACHINE)
  • (BZIP2-RUNC IN %BZIP2-STATE-MACHINE)
  • (BZIP2-FINISH-RLE-SEQUENCE IN %BZIP2-STATE-MACHINE)
  • (BZIP2-DECODE-RLE-SEQUENCE IN %BZIP2-STATE-MACHINE)
  • (BZIP2-GET-MTF-VALUE-DONE IN %BZIP2-STATE-MACHINE)
  • (BZIP2-GET-MTF-VALUE3 IN %BZIP2-STATE-MACHINE)
  • (BZIP2-GET-MTF-VALUE IN %BZIP2-STATE-MACHINE)
  • (BZIP2-CREATE-HUFFMAN-DECODE-TABLES IN %BZIP2-STATE-MACHINE)
  • (BZIP2-CODING-TABLES-ALPHA-LOOP2 IN %BZIP2-STATE-MACHINE)
  • (BZIP2-SELECTOR-UNDO-MTF-VALUES IN %BZIP2-STATE-MACHINE)
  • (BZIP2-SELECTOR3A IN %BZIP2-STATE-MACHINE)
  • (BZIP2-SELECTOR1 IN %BZIP2-STATE-MACHINE)
  • (BZIP2-MAPPING-TABLE1 IN %BZIP2-STATE-MACHINE)
  • (BZIP2-BLOCK-RANDOMBIT IN %BZIP2-STATE-MACHINE)
  • (BZIP2-BLOCK-HEADER6 IN %BZIP2-STATE-MACHINE)
  • (BZIP2-BLOCK-HEADER4 IN %BZIP2-STATE-MACHINE)
  • (BZIP2-BLOCK-HEADER2 IN %BZIP2-STATE-MACHINE)
  • IO/DEFLATE::%INFLATE-STATE-MACHINE
  • (GZIP-FNAME IN %INFLATE-STATE-MACHINE)
  • (GZIP-OS IN %INFLATE-STATE-MACHINE)
  • (GZIP-MTIME IN %INFLATE-STATE-MACHINE)
  • (GZIP-CM IN %INFLATE-STATE-MACHINE)
  • IO/DEFLATE::%INFLATE
  • IO/DEFLATE::DISTANCE-CODES
  • IO/DEFLATE::LENGTH-CODES
  • IO/DEFLATE::FIXED-HUFFMAN-CODES
  • (MAKE-DECOMPRESSING-STREAM ((EQL ZSTD) T))
  • (MAKE-COMPRESSING-STREAM ((EQL ZSTD) T))
  • (MAKE-COMPRESSING-STREAM (T T))
  • (CLOSE (BLOCK-STREAM))
  • (FLUSH-BUFFER (BLOCK-OUTPUT-STREAM))
  • MAKE-CHUNKED-STREAM
  • (CLOSE (CHUNKED-OUTPUT-STREAM))
  • FINALIZE-BUFFER
  • (INITIALIZE-INSTANCE (FAST-INPUT-STREAM))
  • (INITIALIZE-INSTANCE (FAST-OUTPUT-STREAM))
  • MAKE-BOUND-STREAM
  • (STREAM-READ-CHAR (DECODING-STREAM))
  • MAKE-DECODING-STREAM
  • MAKE-IN-MEMORY-OUTPUT-STREAM
  • (MAKE-IN-MEMORY-INPUT-STREAM (LIST))
  • (MAKE-IN-MEMORY-INPUT-STREAM (VECTOR))
  • (STREAM-READ-SEQUENCE (VECTOR-INPUT-STREAM T))
  • (STREAM-READ-SEQUENCE (LIST-INPUT-STREAM T))
  • (TRANSFORM-OCTET (IN-MEMORY-STREAM T))
  • IO/SYS:DISPATCH-TIMER
  • OBJ/SRV::BUILD-SERVICE
  • LIST-ALL-SERVICES
  • (CACHE-SANITY-CHECK (CACHE))
  • (CACHE-FLUSH (CACHE))
  • (CACHE-REMOVE (CACHE T))
  • (CACHE-RELEASE (CACHE T))
  • (CACHE-FETCH (CACHE T))
  • (SET-CACHE-MAX-SIZE (CACHE T))
  • MAKE-CACHE
  • (INITIALIZE-INSTANCE (CACHE))
  • (EVICT-ENTRY (LFUDA-CACHE-POLICY T))
  • (ENTRY-ADDED (LFUDA-CACHE-POLICY CACHE-ENTRY))
  • (SHARED-INITIALIZE (LINKED-CACHE-ENTRY T))
  • OBJ/CACHE::MAP-CACHE
  • (COMPUTE-SLOTS AROUND (STANDARD-CLASS))
  • OBJ/STORE::MAP-INVERTED-INDEX
  • MAP-CLASS
  • OBJ/STORE::KNOWN-CLASSES
  • OBJ/STORE::UPDATE-DERIVED-SLOT
  • (DROP-INSTANCE (STORED-OBJECT))
  • (BUILD-SLOT-SET (STORE))
  • (DROP-SSET (DEFAULT-SSET))
  • (MAP-SSET (T DEFAULT-SSET))
  • (FIND-ITEM (T DEFAULT-SSET))
  • (BUILD-SSET (STORE))
  • (UPDATE-INSTANCE-FOR-REDEFINED-CLASS AROUND (STORED-OBJECT T T T))
  • (RECREATE-INSTANCE-USING-CLASS (T))
  • OBJ/STORE::COPY-SCHEMA
  • OBJ/STORE::LOGICAL-COPY-SCHEMA
  • OBJ/STORE::REMOVE-ASSOCIATION
  • OBJ/STORE::ADD-ASSOCIATION
  • (DROP-INSTANCE (SSET))
  • (REVEAL (SECRET))
  • CLASS-GRAPH
  • (SHORTEST-PATH (GRAPH T T))
  • (OUTDEGREE (DIRECTED-GRAPH T))
  • (INDEGREE (DIRECTED-GRAPH T))
  • (MERGE-NODES (GRAPH T T))
  • (SUBGRAPH (GRAPH T))
  • (COPY-OBJECT (GRAPH))
  • (EQUIV (SIMPLE-GRAPH SIMPLE-GRAPH))
  • (DATABASE-VERSION AROUND (T))
  • OBJ/DB::%LOAD-DATABASE-BACKEND
  • EVAL-COMMAND
  • (CALL (COMMAND STRING))
  • (CALL (COMMAND LIST))
  • (CALL (COMMAND NULL))
  • MAP-COMMANDS
  • MAP-COMMAND-TYPES
  • OBJ/CMD::CALL-DS-COMMAND-TYPE
  • OBJ/PROJECT::CALL-WITH-RULE
  • OBJ/PROJECT::CALL-WITH-PROJECT
  • (LOAD-PROJECT-COMPONENT ((EQL MODULE) T))
  • MAKE-RULE
  • PROJECT-DIRECTORIES
  • LIST-ALL-PROJECTS
  • OBJ/SCHEMA::CLASS-DEFAULT-FIELDS
  • APPLY-SCHEMA-CHANGE-FN
  • OBJ/SCHEMA::COMPUTE-WRITER
  • OBJ/SCHEMA::COMPUTE-READER
  • (DUMP-SCHEMA (SIMPLE-SCHEMA))
  • COMPUTE-TRANSIENT-SCHEMA
  • CLASS-INSTANCE-SCHEMA
  • MAKE-SIMPLE-SCHEMA
  • MAKE-SCHEMA
  • CALL-WITH-AST
  • (TRAVERSE (T NODE T))
  • (TRAVERSE AFTER (COPY-TRAVERSER NODE T))
  • OCTET-VECTOR-TO-UUID
  • MAKE-V4-UUID
  • MAKE-V1-UUID
  • MAKE-NULL-UUID
  • MAKE-UUID-FROM-STRING
  • OBJ/UUID::UUID-FROM-STRING
  • OBJ/TIME::CONTEST
  • OCTETS-TO-TIMESTAMP
  • UNIX-TO-TIMESTAMP
  • UNIVERSAL-TO-TIMESTAMP
  • ENCODE-TIMESTAMP
  • TIMESTAMP+
  • OBJ/TIME::%OFFSET-TIMESTAMP-PART
  • OBJ/TIME::%EXPAND-ADJUST-TIMESTAMP-CHANGES
  • CLONE-TIMESTAMP
  • CALL-WITH-PALETTE
  • BASE-COLOR-PALETTE-P
  • (EQUIV (VECTOR VECTOR))
  • DUMP-INDEX
  • DUMP-BTREE
  • OBJ/BTREE::MAP-INDEX-FROM-END
  • OBJ/BTREE::MAP-INDEX-FROM-START
  • MAP-INDEX-VALUES
  • OBJ/BTREE::MAP-BTREE-FROM-END
  • OBJ/BTREE::MAP-BTREE-FROM-START
  • OBJ/BTREE::MAP-BTREE-VALUES
  • (DROP-BTREE (INDEXED-BTREE))
  • OBJ/BTREE::FUNCTION<-KEYFORM
  • (DROP-INSTANCE (BTREE))
  • (BUILD-BTREE (T))
  • DIAG~
  • OBJ/TENSOR::BLAS-COPYABLEP
  • OBJ/TENSOR::CONSECUTIVE-STOREP
  • MAPSLICEC~
  • MAPSLICE~
  • MAPSLICE
  • MAPSOR
  • (MAPSOR! BEFORE (FUNCTION TENSOR TENSOR))
  • (DIV! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (SCAL! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (T.SCDI!)
  • (T.DOT)
  • TENSOR-IMAGPART~
  • TENSOR-REALPART~
  • (GO= (TENSOR TENSOR))
  • (GA= (TENSOR TENSOR))
  • (GE= (TENSOR TENSOR))
  • (SUPTENSOR~ (DENSE-TENSOR T))
  • ((SETF SUBTENSOR~) (T DENSE-TENSOR LIST))
  • (SUBTENSOR~ (DENSE-TENSOR LIST))
  • SORT-PERMUTE
  • PERMUTATION*
  • PERMUTATION/
  • (COPY! (PERMUTATION-PIVOT-FLIP (EQL PERMUTATION-PIVOT-FLIP)))
  • (COPY! (PERMUTATION-PIVOT-FLIP (EQL PERMUTATION-ACTION)))
  • (COPY! (PERMUTATION-CYCLE (EQL PERMUTATION-CYCLE)))
  • (COPY! (PERMUTATION-CYCLE (EQL PERMUTATION-ACTION)))
  • (COPY! (PERMUTATION-ACTION (EQL PERMUTATION-ACTION)))
  • (COPY! (PERMUTATION-ACTION (EQL PERMUTATION-PIVOT-FLIP)))
  • (COPY! (PERMUTATION-ACTION (EQL PERMUTATION-CYCLE)))
  • SHUFFLE!
  • (SWAP! BEFORE (DENSE-TENSOR DENSE-TENSOR))
  • (T.SWAP!)
  • (T.BLAS-SWAP!)
  • (COPY! BEFORE (TENSOR TENSOR))
  • (T.COPY!)
  • (T.BLAS-COPY!)
  • (COPY! (T CONS))
  • (MAPCAR! IN COPY!)
  • OBJ/TENSOR::MAKE-FOREIGN-DENSE-TENSOR
  • OBJ/TENSOR::COORDINATE-INDEXING
  • OBJ/TENSOR::GRAPH-INDEXING!
  • Δ-I
  • OBJ/TENSOR::STRIDE-PIVOT
  • (T.ZEROS)
  • (T.BLAS-THRESHOLD)
  • (WITH-FIELD-ELEMENT)
  • (T.STORE-SET)
  • (T.STORE-REF)
  • (T.TOTAL-SIZE)
  • (T.STORE-ALLOCATOR)
  • (T.STORE-SIZE)
  • (T.COMPUTE-STORE-SIZE)
  • (T.REALIFIED-TENSOR)
  • (T.COMPLEXIFIED-TENSOR)
  • (T.FIELD-TYPE)
  • (T.STORE)
  • (T.STORE-TYPE)
  • (T.STRICT-COERCE)
  • OBJ/TENSOR::DICT-COMPARE
  • OBJ/TENSOR::STRICT-COMPARE
  • (T.COERCE)
  • (T.FIMAGPART)
  • (T.FREALPART)
  • (T.FC)
  • (T.FID*)
  • (T.FID+)
  • (T.F=)
  • (T.F/)
  • (T.F*)
  • (T.F-)
  • (T.F+)
  • (REALIFIED-TENSOR AROUND (TENSOR-CLASS))
  • (COMPLEXIFIED-TENSOR AROUND (TENSOR-CLASS))
  • OBJ/TENSOR::SUBTYPE-SPECIALIZER
  • OBJ/TENSOR::GROUP-SPECIALIZER
  • OBJ/TENSOR::CLASSP-SPECIALIZER
  • OBJ/TENSOR::LAZY-COERCE
  • REWRITE-URLS
  • OBJ/URL::READ-WHILE
  • URL-DECODE
  • URL-DECODE-PARAMS
  • STRING-TO-IRI
  • STRING-TO-URI
  • PARSE-URI
  • OBJ/URI::SCAN-FORWARD
  • COPY-URI
  • PARSE-DOMAIN
  • (MAKE-ID ((EQL NIL)))
  • (MAKE-ID ((EQL T)))
  • OBJ/META/MIX::DEFINE-MIXIN
  • (EFFECTIVE-SLOT-DEFINITION-CLASS (DYNAMIC-CLASS))
  • (COMPUTE-EFFECTIVE-SLOT-DEFINITION (DYNAMIC-CLASS T T))
  • (DIRECT-SLOT-DEFINITION-CLASS (DYNAMIC-CLASS))
  • (ALLOCATE-INSTANCE (DYNAMIC-CLASS))
  • (COMPUTE-EFFECTIVE-SLOT-DEFINITION-INITARGS (STORED-CLASS T))
  • OBJ/META/STORED::GEN-DERIVED-FN-WRAPPER
  • OBJ/META/STORED::GEN-DERIVED-SYM-WRAPPER
  • (COMPUTE-EFFECTIVE-SLOT-DEFINITION (STORED-CLASS T T))
  • (SHARED-INITIALIZE AROUND (STORED-CLASS T))
  • (CALL-NEXT-METHOD-N IN /home/ellis/src/core/lib/obj/meta/stored.lisp)
  • OBJ/META/FAST::MERGE-KEYWORD-INFOS
  • OBJ/META/FAST::MERGE-OPTIONAL-INFOS
  • (OPTIMIZE-FUNCTION-CALL AROUND (FAST-GENERIC-FUNCTION STATIC-CALL-SIGNATURE))
  • (MAKE-METHOD-LAMBDA AROUND (SEALABLE-STANDARD-GENERIC-FUNCTION FAST-METHOD T T))
  • OBJ/META/FAST::COERCE-TO-FAST-METHOD
  • OBJ/META/FAST::ANONYMIZE-AUXILIARY-INFO
  • OBJ/META/FAST::ANONYMIZE-KEYWORD-INFO
  • OBJ/META/FAST::ANONYMIZE-OPTIONAL-INFO
  • OBJ/META/FAST::ANONYMIZE-REQUIRED-INFO
  • OBJ/META/FAST::PARSE-AUXILIARY-ITEM
  • OBJ/META/FAST::PARSE-KEYWORD-ITEM
  • OBJ/META/FAST::PARSE-OPTIONAL-ITEM
  • OBJ/META/FAST::PARSE-REQIRED-ITEM
  • (REMOVE-METHOD (FILTERED-FUNCTION T))
  • (ADD-METHOD (FILTERED-FUNCTION T))
  • (COMPUTE-DISCRIMINATING-FUNCTION (FILTERED-FUNCTION))
  • (COMPUTE-APPLICABLE-METHODS-USING-CLASSES (FILTERED-FUNCTION T))
  • (ENSURE-CLASS-USING-CLASS AROUND (T (EQL VICTIM-CLASS)))
  • (CALL-NEXT-METHOD-N IN ADD-MIXIN)
  • OBJ/META/SEALED::MAP-TYPES-AND-PROTOTYPES
  • (COMPUTE-STATIC-CALL-SIGNATURES (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • OBJ/META/SEALED::SPECIALIZER-SNODE
  • OBJ/META/SEALED::MAP-CLASS-PROTOTYPES
  • (ADD-METHOD AROUND (SEALABLE-GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD))
  • (SEAL-DOMAIN AROUND (SEALABLE-GENERIC-FUNCTION DOMAIN))
  • (MAKE-METHOD-LAMBDA AROUND (GENERIC-FUNCTION POTENTIALLY-SEALABLE-METHOD T T))
  • (SHARED-INITIALIZE (SEALABLE-METAOBJECT-MIXIN (EQL T)))
  • (CALL-NEXT-METHOD-N IN /home/ellis/src/core/lib/obj/meta/sealed.lisp)
  • (REINITIALIZE-INSTANCE AROUND (SEALABLE-METAOBJECT-MIXIN))
  • (CHANGE-CLASS AROUND (SEALABLE-METAOBJECT-MIXIN T))
  • OBJ/META/SEALED::MAKE-DOMAIN
  • (SEAL-METHOD AROUND (METHOD))
  • (SEAL-GENERIC-FUNCTION AROUND (GENERIC-FUNCTION))
  • (SEAL-CLASS AROUND (CLASS))
  • (SEAL-METAOBJECT AROUND (T))
  • (ENSURE-SPECIALIZER (SYMBOL))
  • (ENSURE-SPECIALIZER (CONS))
  • TREE-SITTER:CONVERT-TS-TREE
  • TREE-SITTER:LANGUAGE-MODULE
  • SYS::IO-OCTET-VECTOR
  • SWANK-MACROSTEP::MAKE-TRACKING-PPRINT-DISPATCH
  • SWANK-TRACE-DIALOG:TRACE-FORMAT
  • SWANK-TRACE-DIALOG:DIALOG-TRACE
  • SWANK-MREPL::SPAWN-LISTENER-THREAD
  • SWANK-MREPL:CREATE-MREPL
  • (COMPUTE-ENRICHED-DECODED-ARGLIST ((EQL INST) T))
  • SWANK:HYPERDOC
  • SWANK::MONKEY-PATCH-STREAM-PRINTING
  • (PRINT-OBJECT AROUND (PATHNAME T))
  • SWANK::PRESENTING-OBJECT-1
  • SWANK::WRITE-ANNOTATION
  • (MENU-CHOICES-FOR-PRESENTATION (PATHNAME))
  • SWANK::EXECUTE-MENU-CHOICE-FOR-PRESENTATION-ID
  • SWANK::COMMON-SEPERATED-SPEC
  • (EMACS-INSPECT (STREAM-ERROR))
  • (EMACS-INSPECT (FILE-STREAM))
  • (EMACS-INSPECT (STANDARD-GENERIC-FUNCTION))
  • SWANK::FUZZY-FIND-MATCHING-PACKAGES
  • SWANK::FUZZY-FIND-MATCHING-SYMBOLS
  • SWANK::%MAKE-DUPLICATE-SYMBOLS-FILTER
  • SWANK::FUZZY-FORMAT-MATCHING
  • (ARGLIST-DISPATCH ((EQL DEFINE-COMPILER-MACRO) T))
  • (ARGLIST-DISPATCH ((EQL DEFMETHOD) T))
  • (COMPUTE-ENRICHED-DECODED-ARGLIST ((EQL APPLY) T))
  • (COMPUTE-ENRICHED-DECODED-ARGLIST ((EQL WITH-OPEN-FILE) T))
  • (EXTRA-KEYWORDS ((EQL CHANGE-CLASS) T))
  • (EXTRA-KEYWORDS ((EQL CERROR) T))
  • (EXTRA-KEYWORDS ((EQL WARN) T))
  • (EXTRA-KEYWORDS ((EQL SIGNAL) T))
  • (EXTRA-KEYWORDS ((EQL ERROR) T))
  • (EXTRA-KEYWORDS ((EQL MAKE-CONDITION) T))
  • (EXTRA-KEYWORDS ((EQL MAKE-INSTANCE) T))
  • (EXTRA-KEYWORDS AROUND (T T))
  • SWANK::EXTENDED-AUTODOC
  • SWANK::EXTENDED-AUTODOC-OPERATOR-P
  • SWANK::MAKE-COMPOUND-PREFIX-MATCHER
  • SWANK::COMPLETION-OUTPUT-SYMBOL-CONVERTER
  • SWANK::FIND-MATCHING-PACKAGES
  • SWANK::FIND-MATCHING-SYMBOLS-IN-LIST
  • SWANK::FIND-MATCHING-SYMBOLS
  • SWANK::PACKAGE-COMPLETION-SET
  • SWANK::SYMBOL-COMPLETION-SET
  • SWANK-REPL::TRACK-PACKAGE
  • SWANK-REPL::REPL-EVAL
  • SWANK-REPL:LISTENER-EVAL
  • SWANK-REPL:LISTENER-SAVE-VALUE
  • SWANK-REPL:RUN-FUNCTION-AND-SWITCH-TO-NEW-THREAD
  • SWANK-REPL::REPL-LOOP
  • SWANK-REPL::MAKE-OUTPUT-FUNCTION
  • SWANK-REPL::OPEN-STREAMS
  • SWANK:FLOW-CONTROL-TEST
  • SWANK:MAKE-OUTPUT-FUNCTION-FOR-TARGET
  • SWANK::INDENTATION-CACHE-LOOP
  • SWANK::MOP-HELPER
  • SWANK:DEBUG-NTH-THREAD
  • SWANK::HASH-TABLE-TO-ALIST
  • SWANK:INSPECTOR-CALL-NTH-ACTION
  • SWANK::FIND-DEFINITION
  • SWANK::LCONS-CDR
  • SWANK:SWANK-TOGGLE-TRACE
  • SWANK::CALL-WITH-DESCRIBE-SETTINGS
  • SWANK::APROPOS-SYMBOLS
  • SWANK::LISTIFY
  • SWANK::MAP-IF
  • SWANK::MATCHING-SYMBOLS
  • SWANK:SWANK-MACROLET-EXPAND
  • SWANK::APPLY-MACRO-EXPANDER
  • SWANK::MODULE-FILENAME
  • SWANK::FASL-PATHNAME
  • SWANK:COMPILE-FILE-FOR-EMACS
  • SWANK::COLLECT-NOTES
  • SWANK::MEASURE-TIME-INTERVAL
  • SWANK::EVAL-IN-FRAME-AUX
  • SWANK::SAFE-CONDITION-MESSAGE
  • SWANK:INVOKE-SLIME-DEBUGGER
  • SWANK:INSPECT-IN-EMACS
  • SWANK:ED-IN-EMACS
  • SWANK::CALL/TRUNCATED-OUTPUT-TO-STRING
  • SWANK::SIMPLE-SERVE-REQUESTS
  • SWANK::DISPATCH-INTERRUPT-EVENT
  • SWANK::SPAWN-WORKER-THREAD
  • SWANK::PROCESS-REQUESTS
  • SWANK::HANDLE-REQUESTS
  • SWANK::ACCEPT-CONNECTIONS
  • SWANK::SETUP-SERVER
  • SWANK::CALL-WITH-RETRY-RESTART
  • SWANK::INVOKE-OR-QUEUE-INTERRUPT
  • SWANK::MAKE-CONNECTION
  • SWANK::RUN-HOOK-UNTIL-SUCCESS
  • SWANK::RUN-HOOK
  • SWANK::CALL-WITH-BINDINGS
  • (MAKE-INPUT-STREAM IN /home/ellis/src/core/lib/swank/gray.lisp)
  • (MAKE-OUTPUT-STREAM IN /home/ellis/src/core/lib/swank/gray.lisp)
  • (STREAM-READ-CHAR (SLIME-INPUT-STREAM))
  • SWANK/GRAY::%STREAM-FINISH-OUTPUT
  • (STREAM-WRITE-STRING (SLIME-OUTPUT-STREAM T))
  • (CALL-WITH-INTERRUPT-HANDLER IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::SBCL-WRAP
  • (BACKGROUND-SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (EXEC-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (SAVE-IMAGE IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (CALL-WITH-LOCK-HELD IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (EMACS-INSPECT AROUND (GENERIC-FUNCTION))
  • (EMACS-INSPECT (FUNCTION))
  • (RESTART-FRAME IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (EVAL-IN-FRAME IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::DEBUG-VAR-INFO
  • (CALL-WITH-DEBUGGING-ENVIRONMENT IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::CALL-WITH-BREAK-HOOK
  • SWANK/SBCL::SWANK-INVOKE-DEBUGGER-HOOK
  • (CALL-WITH-COMPILATION-HOOKS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (TYPE-SPECIFIER-ARGLIST AROUND (T))
  • (DECLARATION-ARGLIST ((EQL OPTIMIZE)))
  • (CALL-WITH-SYNTAX-HOOKS IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::CALL-WITH-DEBOOTSTRAPPING
  • (ADD-FD-HANDLER IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::ENABLE-SIGIO-ON-FD
  • SWANK/SBCL::SIGIO-HANDLER
  • (INSTALL-SIGINT-HANDLER IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • (CREATE-SOCKET IN /home/ellis/src/core/lib/swank/sbcl.lisp)
  • SWANK/SBCL::SBCL-WITH-SETF-INVERSE-META-INFO
  • SWANK/SOURCE-PATH-PARSER::READTABLE-FOR-PACKAGE
  • SWANK/SOURCE-PATH-PARSER::MAKE-SOURCE-RECORDER
  • SWANK/SOURCE-PATH-PARSER::MAKE-SHARPDOT-READER
  • SWANK/BACKEND:CALL-WITH-INTERRUPT-HANDLER
  • SWANK/BACKEND:STRUCTURE-ACCESSOR-P
  • SWANK/BACKEND:AUGMENT-FEATURES
  • SWANK/BACKEND:WRAPPED-P
  • UNWRAP
  • WRAP
  • SWANK/BACKEND:BACKGROUND-SAVE-IMAGE
  • SWANK/BACKEND:SAVE-IMAGE
  • SWANK/BACKEND:CHARACTER-COMPLETION-SET
  • FLOAT-INFINITY-P
  • FLOAT-NAN-P
  • HASH-TABLE-WEAKNESS
  • SWANK/BACKEND:MAKE-WEAK-VALUE-HASH-TABLE
  • SWANK/BACKEND:MAKE-WEAK-KEY-HASH-TABLE
  • SWANK/BACKEND:CALL-WITH-LOCK-HELD
  • SWANK/BACKEND:MAKE-LOCK
  • SWANK/BACKEND:WAIT-FOR-INPUT
  • SWANK/BACKEND:CHECK-SLIME-INTERRUPTS
  • SWANK/BACKEND:SET-DEFAULT-INITIAL-BINDING
  • SWANK/BACKEND:FIND-REGISTERED
  • SWANK/BACKEND:REGISTER-THREAD
  • SWANK/BACKEND:WAKE-THREAD
  • SWANK/BACKEND:RECEIVE-IF
  • RECEIVE
  • SEND
  • KILL-THREAD
  • INTERRUPT-THREAD
  • THREAD-ALIVE-P
  • SWANK/BACKEND:ALL-THREADS
  • SWANK/BACKEND:CURRENT-THREAD
  • SWANK/BACKEND:THREAD-ATTRIBUTES
  • SWANK/BACKEND:THREAD-STATUS
  • THREAD-NAME
  • FIND-THREAD
  • SWANK/BACKEND:THREAD-ID
  • SWANK/BACKEND:SPAWN
  • SWANK/BACKEND:INITIALIZE-MULTIPROCESSING
  • SWANK/BACKEND:DESCRIBE-PRIMITIVE-TYPE
  • SWANK/BACKEND:EVAL-CONTEXT
  • SWANK/BACKEND:TOGGLE-TRACE
  • SWANK/BACKEND:PROFILE-PACKAGE
  • SWANK/BACKEND:PROFILE-RESET
  • SWANK/BACKEND:PROFILE-REPORT
  • SWANK/BACKEND:UNPROFILE-ALL
  • SWANK/BACKEND:UNPROFILE
  • SWANK/BACKEND:PROFILED-FUNCTIONS
  • SWANK/BACKEND:PROFILE
  • SWANK/BACKEND:LIST-CALLEES
  • SWANK/BACKEND:LIST-CALLERS
  • SWANK/BACKEND:WHO-SPECIALIZES
  • SWANK/BACKEND:WHO-MACROEXPANDS
  • SWANK/BACKEND:WHO-SETS
  • SWANK/BACKEND:WHO-BINDS
  • SWANK/BACKEND:WHO-REFERENCES
  • SWANK/BACKEND:CALLS-WHO
  • SWANK/BACKEND:WHO-CALLS
  • SWANK/BACKEND:BUFFER-FIRST-CHANGE
  • SWANK/BACKEND:FIND-SOURCE-LOCATION
  • FIND-DEFINITIONS
  • SWANK/BACKEND:SLDB-STEP-OUT
  • SWANK/BACKEND:SLDB-STEP-NEXT
  • SWANK/BACKEND:SLDB-STEP-INTO
  • SWANK/BACKEND:SLDB-STEPPER-CONDITION-P
  • SWANK/BACKEND:SLDB-BREAK-AT-START
  • SWANK/BACKEND:SLDB-BREAK-ON-RETURN
  • SWANK/BACKEND:ACTIVATE-STEPPING
  • SWANK/BACKEND:GDB-INITIAL-COMMANDS
  • SWANK/BACKEND:CONDITION-EXTRAS
  • SWANK/BACKEND:PRINT-CONDITION
  • SWANK/BACKEND:RESTART-FRAME
  • SWANK/BACKEND:RETURN-FROM-FRAME
  • SWANK/BACKEND:FRAME-CALL
  • SWANK/BACKEND:FRAME-PACKAGE
  • SWANK/BACKEND:EVAL-IN-FRAME
  • SWANK/BACKEND:FRAME-FUNCTION
  • SWANK/BACKEND:DISASSEMBLE-FRAME
  • SWANK/BACKEND:FRAME-VAR-VALUE
  • SWANK/BACKEND:FRAME-LOCALS
  • SWANK/BACKEND:FRAME-CATCH-TAGS
  • SWANK/BACKEND:FRAME-SOURCE-LOCATION
  • SWANK/BACKEND:FRAME-RESTARTABLE-P
  • SWANK/BACKEND:PRINT-FRAME
  • SWANK/BACKEND:COMPUTE-BACKTRACE
  • SWANK/BACKEND:CALL-WITH-DEBUGGER-HOOK
  • SWANK/BACKEND:CALL-WITH-DEBUGGING-ENVIRONMENT
  • SWANK/BACKEND:INSTALL-DEBUGGER-GLOBALLY
  • SWANK/BACKEND:DESCRIBE-DEFINITION
  • SWANK/BACKEND:DESCRIBE-SYMBOL-FOR-EMACS
  • SWANK/BACKEND:FORMAT-STRING-EXPAND
  • SWANK/BACKEND:COLLECT-MACRO-FORMS
  • SWANK/BACKEND::CALL-WITH-COLLECTED-MACRO-FORMS
  • SWANK/BACKEND:COMPILER-MACROEXPAND
  • SWANK/BACKEND:COMPILER-MACROEXPAND-1
  • SWANK/BACKEND:VALID-FUNCTION-NAME-P
  • SWANK/BACKEND:FUNCTION-NAME
  • SWANK/BACKEND:TYPE-SPECIFIER-P
  • SWANK/BACKEND:REALLY-FINISH-OUTPUT
  • SWANK/BACKEND:MAKE-AUTO-FLUSH-THREAD
  • SWANK/BACKEND:AUTO-FLUSH-LOOP
  • SWANK/BACKEND:MAKE-INPUT-STREAM
  • SWANK/BACKEND:MAKE-OUTPUT-STREAM
  • SWANK/BACKEND:GUESS-EXTERNAL-FORMAT
  • SWANK/BACKEND:FIND-EXTERNAL-FORMAT
  • SWANK/BACKEND:SWANK-COMPILE-FILE
  • SWANK/BACKEND:SWANK-COMPILE-STRING
  • SWANK/BACKEND:CALL-WITH-COMPILATION-HOOKS
  • SWANK/BACKEND:FIND-LOCALLY-NICKNAMED-PACKAGE
  • PACKAGE-LOCAL-NICKNAMES
  • SWANK/BACKEND:CALL-WITH-SYNTAX-HOOKS
  • SWANK/BACKEND:SET-DEFAULT-DIRECTORY
  • SWANK/BACKEND:DEFAULT-DIRECTORY
  • SWANK/BACKEND:PATHNAME-TO-FILENAME
  • SWANK/BACKEND:FILENAME-TO-PATHNAME
  • SWANK/BACKEND:COMMAND-LINE-ARGS
  • SWANK/BACKEND:EXEC-IMAGE
  • SWANK/BACKEND:DUP
  • SWANK/BACKEND:MAKE-FD-STREAM
  • SWANK/BACKEND:SOCKET-FD
  • SWANK/BACKEND:LISP-IMPLEMENTATION-PROGRAM
  • SWANK/BACKEND:LISP-IMPLEMENTATION-TYPE-NAME
  • SWANK/BACKEND:QUIT-LISP
  • SWANK/BACKEND:CALL-WITH-USER-BREAK-HANDLER
  • SWANK/BACKEND:INSTALL-SIGINT-HANDLER
  • SWANK/BACKEND:GETPID
  • SWANK/BACKEND:EMACS-CONNECTED
  • SWANK/BACKEND:SET-STREAM-TIMEOUT
  • SWANK/BACKEND:PREFERRED-COMMUNICATION-STYLE
  • SWANK/BACKEND:REMOVE-FD-HANDLERS
  • SWANK/BACKEND:ADD-FD-HANDLER
  • SWANK/BACKEND:REMOVE-SIGIO-HANDLERS
  • SWANK/BACKEND:ADD-SIGIO-HANDLER
  • SWANK/BACKEND:ACCEPT-CONNECTION
  • SWANK/BACKEND:CLOSE-SOCKET
  • SWANK/BACKEND:LOCAL-PORT
  • SWANK/BACKEND:CREATE-SOCKET
  • SWANK/BACKEND:GRAY-PACKAGE-NAME
  • SWANK::SETUP
  • SWANK::LOAD-SWANK
  • (MAKE-PRIVATE-KEY ((EQL ED25519)))
  • (MAKE-PUBLIC-KEY ((EQL ED25519)))
  • (EC-MAKE-POINT ((EQL ED25519)))
  • (EC-DOUBLE (ED25519-POINT))
  • (EC-ADD (ED25519-POINT ED25519-POINT))
  • (MAKE-PRIVATE-KEY ((EQL CURVE25519)))
  • (MAKE-PUBLIC-KEY ((EQL CURVE25519)))
  • (EC-MAKE-POINT ((EQL CURVE25519)))
  • (EC-SCALAR-MULT (CURVE25519-POINT T))
  • (SHARED-INITIALIZE AFTER (PBKDF1 T))
  • IRONCLAD:MAKE-KDF
  • (STREAM-WRITE-SEQUENCE (AUTHENTICATING-STREAM T))
  • IRONCLAD:MAKE-AUTHENTICATING-STREAM
  • (STREAM-WRITE-SEQUENCE (DECRYPTING-OUTPUT-STREAM T))
  • (STREAM-WRITE-SEQUENCE (ENCRYPTING-OUTPUT-STREAM T))
  • (STREAM-READ-SEQUENCE (DECRYPTING-INPUT-STREAM T))
  • (STREAM-READ-SEQUENCE (ENCRYPTING-INPUT-STREAM T))
  • IRONCLAD:MAKE-DECRYPTING-STREAM
  • IRONCLAD:MAKE-ENCRYPTING-STREAM
  • IRONCLAD:EXECUTE-WITH-DIGESTING-STREAM
  • (STREAM-WRITE-SEQUENCE (DIGESTING-STREAM T))
  • IRONCLAD:MAKE-DIGESTING-STREAM
  • (MAKE-PRNG ((EQL OS)))
  • (MAKE-PRNG AROUND (T))
  • (REINITIALIZE-INSTANCE (HMAC))
  • IRONCLAD:MAKE-HMAC
  • IRONCLAD:MAKE-MAC
  • IRONCLAD:MAKE-DIGEST
  • IRONCLAD::MDX-UPDATER
  • IRONCLAD::SALSA20-CRYPT
  • IRONCLAD::CHACHA-CRYPT
  • (MODE-CRYPT-FUNCTIONS (T STREAM-MODE))
  • (MODE-CRYPT-FUNCTIONS (8-BYTE-BLOCK-MIXIN CTR-MODE))
  • (MODE-CRYPT-FUNCTIONS (16-BYTE-BLOCK-MIXIN CTR-MODE))
  • (MODE-CRYPT-FUNCTIONS (32-BYTE-BLOCK-MIXIN CTR-MODE))
  • (MODE-CRYPT-FUNCTIONS (64-BYTE-BLOCK-MIXIN CTR-MODE))
  • (MODE-CRYPT-FUNCTIONS (128-BYTE-BLOCK-MIXIN CTR-MODE))
  • (MODE-CRYPT-FUNCTIONS (8-BYTE-BLOCK-MIXIN OFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (16-BYTE-BLOCK-MIXIN OFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (32-BYTE-BLOCK-MIXIN OFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (64-BYTE-BLOCK-MIXIN OFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (128-BYTE-BLOCK-MIXIN OFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (8-BYTE-BLOCK-MIXIN CFB8-MODE))
  • (MODE-CRYPT-FUNCTIONS (16-BYTE-BLOCK-MIXIN CFB8-MODE))
  • (MODE-CRYPT-FUNCTIONS (32-BYTE-BLOCK-MIXIN CFB8-MODE))
  • (MODE-CRYPT-FUNCTIONS (64-BYTE-BLOCK-MIXIN CFB8-MODE))
  • (MODE-CRYPT-FUNCTIONS (128-BYTE-BLOCK-MIXIN CFB8-MODE))
  • (MODE-CRYPT-FUNCTIONS (8-BYTE-BLOCK-MIXIN CFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (16-BYTE-BLOCK-MIXIN CFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (32-BYTE-BLOCK-MIXIN CFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (64-BYTE-BLOCK-MIXIN CFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (128-BYTE-BLOCK-MIXIN CFB-MODE))
  • (MODE-CRYPT-FUNCTIONS (8-BYTE-BLOCK-MIXIN CBC-MODE))
  • (MODE-CRYPT-FUNCTIONS (16-BYTE-BLOCK-MIXIN CBC-MODE))
  • (MODE-CRYPT-FUNCTIONS (32-BYTE-BLOCK-MIXIN CBC-MODE))
  • (MODE-CRYPT-FUNCTIONS (64-BYTE-BLOCK-MIXIN CBC-MODE))
  • (MODE-CRYPT-FUNCTIONS (128-BYTE-BLOCK-MIXIN CBC-MODE))
  • (MODE-CRYPT-FUNCTIONS (8-BYTE-BLOCK-MIXIN ECB-MODE))
  • (MODE-CRYPT-FUNCTIONS (16-BYTE-BLOCK-MIXIN ECB-MODE))
  • (MODE-CRYPT-FUNCTIONS (32-BYTE-BLOCK-MIXIN ECB-MODE))
  • (MODE-CRYPT-FUNCTIONS (64-BYTE-BLOCK-MIXIN ECB-MODE))
  • (MODE-CRYPT-FUNCTIONS (128-BYTE-BLOCK-MIXIN ECB-MODE))
  • (INITIALIZE-INSTANCE AFTER (ENCRYPTION-MODE))
  • IRONCLAD:MAKE-CIPHER
  • IRONCLAD::MAKE-MODE-FOR-CIPHER
  • (DECRYPT (CIPHER T T))
  • (ENCRYPT (CIPHER T T))
  • (UPDATE-SHA1-BLOCK)
  • (MAKE-SYSTEM (SYSTEM))
  • (LOAD-SYSTEM (SYSTEM))
  • (FIND-SYSTEM (T))
  • STD/DEFSYS::%PARSE-COMPONENT-FORM
  • STD/DEFSYS::MAKE-SYSTEM-TASK
  • (CHANGE-CLASS (SYSTEM (EQL BENCH-SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL TEST-SYSTEM)))
  • LIST-ALL-TEST-SYSTEMS
  • (CHANGE-CLASS (SYSTEM (EQL SYSTEM)))
  • (CHANGE-CLASS (SYSTEM (EQL SYSTEM)))
  • (CHANGE-CLASS (MOD-COMPONENT (EQL MODULE)))
  • (CHANGE-CLASS (MODULE (EQL MOD-COMPONENT)))
  • (CHANGE-CLASS (GROVEL-CONSTANTS-FILE (EQL GROVEL-COMPONENT)))
  • (CHANGE-CLASS (GROVEL-COMPONENT (EQL GROVEL-CONSTANTS-FILE)))
  • (CHANGE-CLASS (FILE-COMPONENT (EQL FILE-COMPONENT)))
  • (CHANGE-CLASS (FILE-COMPONENT (EQL FILE-COMPONENT)))
  • (CHANGE-CLASS (COMPONENT (EQL COMPONENT)))
  • (CHANGE-CLASS (COMPONENT (EQL COMPONENT)))
  • STD/DEFSYS::%LOAD-MODULE
  • STD/DEFSYS::INIT-MODULE
  • STD/DEFSYS::FIND-SUBMODULES
  • CALL-PROVIDER
  • LIST-ALL-SYSTEMS
  • STD/OS::CALL-WITH-DIRECTORY-ITERATOR
  • INIT-XDG-DIRS
  • LIST-ALL-GROUPS
  • LIST-ALL-USERS
  • USER-INFO
  • WALK-DIRECTORY
  • CALL-WITH-DIRECTORY
  • EXPAND-ANNOTATION
  • STD/PRINT::MAXIMIZE-LENGTH
  • PLOT-FUNCTION
  • STD/PRINT::COPY-BITMAP-ONTO-BITMAP
  • STD/PRINT::FORMAT-TREE-SEGMENTS
  • MAKE-JOB
  • MAKE-TASK
  • STD/ASYNC::CALL-INSIDE-WORKER
  • STD/ASYNC::PFIND-IF/LIST
  • STD/ASYNC::PFIND-IF/VECTOR
  • STD/ASYNC::%PDOTIMES
  • PCOUNT-IF
  • STD/ASYNC::PQUANTIFIER
  • STD/ASYNC::PMAP-INTO/UNPARSED
  • STD/ASYNC::PMAP-INTO/POWDER/LIST
  • STD/ASYNC::PMAP-INTO/POWDER/ARRAY
  • STD/ASYNC::MAP-ITERATE
  • STD/ASYNC::MAPLIST-INTO
  • STD/ASYNC::PMAP-INTO/PARTS
  • STD/ASYNC::PREDUCE/COMMON
  • STD/ASYNC::PREDUCE-PARTIAL/LIST
  • STD/ASYNC::PREDUCE-PARTIAL/VECTOR
  • STD/ASYNC::MAKE-PARTS
  • STD/ASYNC::FULFILL-FUTURE
  • STD/ASYNC::FULFILL-PROMISE
  • CALL-WITH-TEMP-POOL
  • STD/THREAD::INDEXING-WRAPPER
  • EXIT-THREAD-POOLS
  • BROADCAST-WORK
  • STD/THREAD::RECEIVE-RESULTS
  • STD/THREAD::STEAL-UNTIL-RECEIVE-RESULT
  • STD/THREAD::MAKE-CHANNELED-WORK
  • MAKE-THREAD-POOL
  • STD/THREAD::%MAKE-WORKER
  • STD/THREAD::CALL-WITH-WORKER-CONTEXT
  • STD/THREAD::REPLACE-WORKER
  • STD/THREAD::EXEC-WITHOUT-WORKER
  • STD/THREAD::EXEC-WITH-WORKER
  • (CALL (THREAD-POOL T))
  • MAKE-SCHEDULER
  • RUN-WITH-TIMER
  • STD/THREAD::CALL-WITH-WORK-HANDLER
  • STD/THREAD::%CALL-WITH-WORK-HANDLER
  • STD/THREAD::MAKE-DEBUGGER-HOOK
  • STD/THREAD::CALL-WITH-TRACKED-ERROR
  • STD/SEQ::CALL-WITH-VECTOR-QUEUE-LOCK
  • STD/SEQ::CALL-WITH-CONS-QUEUE-LOCK
  • STD/SEQ::TRY-EACH-ELEM
  • PQUEUE-INSERT
  • STD/SEQ::HEAP-INSERT
  • STD/SEQ::HEAPIFY
  • STD/SEQ::FIB-ORDER
  • MAKE-PRIORITY-QUEUE
  • ENDS-WITH-SUBSEQ
  • STARTS-WITH
  • ITEM-PREDICATE
  • CALL-WITH-SAVED-DEFERRED-WARNINGS
  • STD/COMP::RUNTIME*
  • STD/COMP::MAP-OPTIMIZE-DECLARATIONS
  • STD/COMP::MAP-OPTIMIZATION-QUALITY-COMBINATIONS
  • STD/COMP::%CHECKED-COMPILE-AND-ASSERT-ONE-CASE
  • STD/COMP::CALL-CAPTURING-VALUES-AND-CONDITIONS
  • STD/COMP::COMPILE-CAPTURING-OUTPUT-AND-CONDITIONS
  • GET-SIMPLE-FUN-INSTRUCTION-MODEL
  • DEEP-SIZE
  • SAP-REF
  • LOAD-ALIEN
  • PACKAGE-SYMBOLS
  • STD/CORE::SYS-CONFIG-PATH
  • STD/CORE::USER-CONFIG-PATH
  • DEFPIPE*
  • (FORMAT-MESSAGE (NULL FUNCTION))
  • (FORMAT-MESSAGE AROUND (STREAM-SINK T))
  • (MSG (PIPE STRING))
  • (MSG (PREDICATE-FILTER T))
  • (REPLACE-ELEMENT (PIPE SYMBOL T))
  • (INSERT-ELEMENT (PIPE T SYMBOL))
  • (FIND-PARENT-ELEMENT (PIPE SYMBOL))
  • (FIND-ELEMENT (SYMBOL PIPE))
  • VECTOR-EQ
  • VECTOR-MAP-FOLDR
  • VECTOR-MAP-FOLDL
  • VECTOR-FOLDR
  • VECTOR-FOLDL
  • (STREAM-WRITE-CHAR (PREFIXED-CHARACTER-OUTPUT-STREAM T))
  • (WRITE-PREFIX #'T)
  • (STREAM-UNREAD-CHAR (COUNTING-CHARACTER-INPUT-STREAM T))
  • (STREAM-READ-CHAR (COUNTING-CHARACTER-INPUT-STREAM))
  • MAKE-OCTET-OUTPUT-STREAM
  • (STREAM-WRITE-SEQUENCE (OCTET-OUTPUT-STREAM T))
  • MAKE-OCTET-INPUT-STREAM
  • (STREAM-READ-SEQUENCE (OCTET-INPUT-STREAM T))
  • (DEFINE-TEMPLATE-METHOD)
  • (PREPROCESS-TEMPLATE-DISPATCH (SYMBOL T))
  • (COMPUTE-TEMPLATE-DISPATCH (SYMBOL T))
  • SHALLOW-COPY-OBJECT
  • (WITH-MEMOIZATION)
  • COMPILE-AND-EVAL*
  • COMPILE-AND-EVAL
  • STD/MACS::%RECALL-CONSTANT
  • STD/MACS::%WITH-COLLECTORS-GENSYMS-ALIST
  • PANDORIC-HOTPATCH
  • GET-PANDORIC
  • #`-reader
  • STD/PPCRE::REPLACE-AUX
  • STD/PPCRE::BUILD-REPLACEMENT
  • SPLIT
  • ALL-MATCHES-AS-STRINGS
  • SCAN-TO-STRINGS
  • (SCAN (T T))
  • (SCAN #'T)
  • (SCAN (STRING T))
  • (CREATE-CONSTANT-REPETITION-MATCHER (REPETITION T))
  • (CREATE-CONSTANT-REPETITION-CONSTANT-LENGTH-MATCHER (REPETITION T))
  • (CREATE-NON-GREEDY-MATCHER (REPETITION T))
  • (CREATE-NON-GREEDY-NO-ZERO-MATCHER (REPETITION T))
  • (CREATE-NON-GREEDY-CONSTANT-LENGTH-MATCHER (REPETITION T))
  • (CREATE-GREEDY-MATCHER (REPETITION T))
  • (CREATE-GREEDY-NO-ZERO-MATCHER (REPETITION T))
  • STD/PPCRE::CREATE-GREEDY-EVERYTHING-MATCHER
  • (CREATE-MATCHER-AUX (FILTER T))
  • (CREATE-MATCHER-AUX (STANDALONE T))
  • (CREATE-MATCHER-AUX (BRANCH T))
  • (CREATE-MATCHER-AUX (BACK-REFERENCE T))
  • (CREATE-MATCHER-AUX (ANCHOR T))
  • (CREATE-MATCHER-AUX (EVERYTHING T))
  • (CREATE-MATCHER-AUX (WORD-BOUNDARY T))
  • (CREATE-MATCHER-AUX (STR T))
  • (CREATE-MATCHER-AUX (LOOKBEHIND T))
  • (CREATE-MATCHER-AUX (LOOKAHEAD T))
  • (CREATE-MATCHER-AUX (REGISTER T))
  • (CREATE-MATCHER-AUX (ALTERNATION T))
  • (END-STRING-AUX (REGEX))
  • (END-STRING-AUX (SEQ))
  • (GATHER-STRINGS (SEQ))
  • (FLATTEN (SEQ))
  • (CONVERT-SIMPLE-PARSE-TREE (STRING))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL VOID)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL WORD-BOUNDARY)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL NON-WORD-BOUNDARY)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL EVERYTHING)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL DIGIT-CLASS)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL WORD-CHAR-CLASS)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL WHITESPACE-CHAR-CLASS)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL NON-DIGIT-CLASS)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL NON-WORD-CHAR-CLASS)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL NON-WHITESPACE-CHAR-CLASS)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL START-ANCHOR)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL END-ANCHOR)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL MODELESS-START-ANCHOR)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL MODELESS-END-ANCHOR)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL MODELESS-END-ANCHOR-NO-NEWLINE)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL CASE-INSENSITIVE-P)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL CASE-SENSITIVE-P)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL MULTI-LINE-MODE-P)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL NOT-MULTI-LINE-MODE-P)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL SINGLE-LINE-MODE-P)))
  • (CONVERT-SIMPLE-PARSE-TREE ((EQL NOT-SINGLE-LINE-MODE-P)))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL FLAGS) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL INVERTED-PROPERTY) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL PROPERTY) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL CHAR-CLASS) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL BACK-REFERENCE) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL STANDALONE) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL FILTER) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL REGISTER) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL GREEDY-REPETITION) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL POSITIVE-LOOKBEHIND) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL POSITIVE-LOOKAHEAD) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL BRANCH) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL ALTERNATION) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL GROUP) T))
  • (CONVERT-COMPOUND-PARSE-TREE ((EQL SEQUENCE) T))
  • STD/PPCRE::MAYBE-ACCUMULATE
  • STD/PPCRE::MAYBE-SPLIT-REPETITION
  • STD/PPCRE::CONVERT-CHAR-CLASS-TO-TEST-FUNCTION
  • (RESOLVE-PROPERTY (STRING))
  • (REMOVE-REGISTERS (SEQ))
  • (REMOVE-REGISTERS (BRANCH))
  • (REMOVE-REGISTERS (LOOKBEHIND))
  • (REMOVE-REGISTERS (LOOKAHEAD))
  • (REMOVE-REGISTERS (STANDALONE))
  • (REMOVE-REGISTERS (REPETITION))
  • (COPY-REGEX (FILTER))
  • (COPY-REGEX (STR))
  • (COPY-REGEX (CHAR-CLASS))
  • (COPY-REGEX (BACK-REFERENCE))
  • (COPY-REGEX (STANDALONE))
  • (COPY-REGEX (REGISTER))
  • (COPY-REGEX (REPETITION))
  • (COPY-REGEX (LOOKBEHIND))
  • (COPY-REGEX (BRANCH))
  • (COPY-REGEX (ALTERNATION))
  • (COPY-REGEX (SEQ))
  • (COPY-REGEX (LOOKAHEAD))
  • (COPY-REGEX (VOID))
  • (COPY-REGEX (WORD-BOUNDARY))
  • (COPY-REGEX (EVERYTHING))
  • (COPY-REGEX (ANCHOR))
  • STD/PPCRE::CREATE-HASH-TABLE-FROM-TEST-FUNCTION
  • STD/PPCRE::CREATE-CHARMAP-FROM-TEST-FUNCTION
  • STD/PPCRE::MAKE-CHARMAP
  • STD/PPCRE::CREATE-CHARSET-FROM-TEST-FUNCTION
  • STD/PPCRE::MAP-CHARSET
  • STD/PPCRE::COMPLEMENT*
  • HASH-OBJECT-ADDRESS
  • HASH-TABLE-PLIST
  • HASH-TABLE-LIST
  • HASH-TABLE-ALIST
  • HASH-TABLE-VALUES
  • HASH-TABLE-KEYS
  • MAPHASH-VALUES
  • MAPHASH-KEYS
  • COPY-HASH
  • AUTOFUNCALL
  • RCURRY
  • CURRY
  • MULTIPLE-VALUE-COMPOSE
  • COMPOSE
  • CONJOIN
  • DISJOIN
  • STD/STRING::ALL-EQUAL
  • STD/STRING::HASH-TABLE->LIST
  • STD/STRING::SPLIT-TREE
  • (SIMPLE-TYPE-ID)
  • MAP-IOTA
  • MERGE-READTABLES-INTO
  • (PRINT-OBJECT AROUND (READTABLE T))
  • STD/NAMED-READTABLES::%CLEAR-READTABLE
  • STD/NAMED-READTABLES::%MAKE-READTABLE-ITERATOR
  • STD/NAMED-READTABLES::FUNCALL-OR
  • (COMPILE-KEY-HOOK)
  • MAKE-KERNEL
  • CALL-WITH-SAFE-IO-SYNTAX
  • TOPOSORT
  • SORT!
  • MERGE!
  • MAPTREE-EKI
  • MAPTREE-IF
  • MAPCART
  • STD/CONDITION::CALL-WITH-RETRY-RESTART
  • STD/CONDITION::CALL-WITH-IF-FAILED-HANDLER
  • (PRINT-OBJECT (UNKNOWN-TOKEN T))
  • (PRINT-OBJECT (OUT-OF-BOUNDS-ERROR T))
  • CONDITION-HANDLER
  • SYMBOL-CALL
  • STD/THREAD::%WORK
  • (CREATE-GREEDY-CONSTANT-LENGTH-MATCHER (REPETITION T))
  • (CREATE-MATCHER-AUX (CHAR-CLASS T))
  • (INITIALIZE-INSTANCE (KEY-HOOK))
  • RT/TRACING::%%TIME
  • (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT SYMBOL))
  • (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT ASSOCIATION-SLOT-DEFINITION))
  • (SLOT-BOUNDP-USING-CLASS (STORED-CLASS STORED-OBJECT ASSOCIATION-SLOT-DEFINITION))
  • (SLOT-VALUE-USING-CLASS (STORED-CLASS STORED-OBJECT ASSOCIATION-SLOT-DEFINITION))
  • (SLOT-MAKUNBOUND-USING-CLASS (STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))
  • (SLOT-VALUE-USING-CLASS (STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))
  • (COMPUTE-APPLICABLE-METHODS (FILTERED-FUNCTION T))
  • (COMPUTE-APPLICABLE-METHODS (SIMPLE-FILTERED-FUNCTION T))
  • ((SETF SLOT-VALUE-USING-CLASS) (T STORED-CLASS STORED-OBJECT SET-VALUED-SLOT-DEFINITION))
  • STD/PPCRE::CREATE-SCANNER-AUX

%ADJOIN-KEY-EQ names a compiled function:
  Lambda-list: (X LIST KEY)
  Dynamic-extent arguments: positional=(2)
  Declared type: (FUNCTION (T LIST FUNCTION) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T FUNCTION) (VALUES T &OPTIONAL))
  Known attributes: call, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

MEMBER-TYPE-P names a compiled function:
  A predicate for SB-KERNEL:MEMBER-TYPE
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

MEMBER-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:MEMBER-TYPE>:
  Class precedence-list: SB-KERNEL:MEMBER-TYPE, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:CTYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-INT:XSET
      Type: SB-INT:XSET
      Initform: NIL

CLASSOID-ALL-SUBCLASSOIDS names a compiled function:
  Lambda-list: (CLASSOID)
  Derived type: (FUNCTION (T) (VALUES LIST &OPTIONAL))
  Source file: SYS:SRC;CODE;CLASS.LISP

%COSF names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (SINGLE-FLOAT)
                  (VALUES (SINGLE-FLOAT -1.0 1.0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

%ATOMIC-DEC-SYMBOL-GLOBAL-VALUE names a compiled function:
  Lambda-list: (PLACE DELTA)
  Declared type: (FUNCTION (SYMBOL FIXNUM) (VALUES FIXNUM &OPTIONAL))
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;CAS.LISP

UB64-BASH-COPY names a compiled function:
  Lambda-list: (SRC SRC-START DST DST-START NELEMENTS)
  Declared type: (FUNCTION
                  ((OR SIMPLE-BASE-STRING (SIMPLE-ARRAY CHARACTER (*))
                       (SIMPLE-ARRAY SINGLE-FLOAT (*))
                       (SIMPLE-ARRAY DOUBLE-FLOAT (*)) SIMPLE-BIT-VECTOR
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY FIXNUM (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT) (*))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)))
                   (UNSIGNED-BYTE 44)
                   (OR SIMPLE-BASE-STRING (SIMPLE-ARRAY CHARACTER (*))
                       (SIMPLE-ARRAY SINGLE-FLOAT (*))
                       (SIMPLE-ARRAY DOUBLE-FLOAT (*)) SIMPLE-BIT-VECTOR
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16) (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32) (*))
                       (SIMPLE-ARRAY FIXNUM (*))
                       (SIMPLE-ARRAY (SIGNED-BYTE 64) (*))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT) (*))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

PATHNAME-COMPONENT-CASE names a type-specifier:
  Lambda-list: ()
  Expansion: (MEMBER :LOCAL :COMMON)

%MAKE-FUNCALLABLE-INSTANCE names an undefined function
  Declared type: (FUNCTION ((UNSIGNED-BYTE 44)) (VALUES FUNCTION &OPTIONAL))

• Called by
  • SB-CONCURRENCY::PROMISE-COMPILE

UB1-BASH-FILL-WITH-SB1 names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  ((INTEGER -1 0)
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION
                 ((INTEGER -1 0) T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

EFFECTIVE-FIND-POSITION-TEST names a compiled function:
  Lambda-list: (TEST TEST-NOT)
  Declared type: (FUNCTION ((OR FUNCTION SYMBOL) (OR FUNCTION SYMBOL))
                  (VALUES FUNCTION &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;SEQ.LISP

VECTOR-HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS names a compiled function:
  Lambda-list: (ARRAY INDEX NEW-VALUE)
  Declared type: (FUNCTION (VECTOR (UNSIGNED-BYTE 44) T) (VALUES T &OPTIONAL))
  Derived type: (FUNCTION (T T T) *)
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;ARRAY.LISP

EXTENDED-SEQUENCE-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Inline proclamation: MAYBE-INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

OVERFLOW- names an undefined function
  Declared type: (FUNCTION (INTEGER INTEGER T) (VALUES INTEGER &OPTIONAL))

STRING-DESIGNATOR names a type-specifier:
  Lambda-list: ()
  Expansion: (OR STRING SYMBOL CHARACTER)

SINGLE-FLOAT-INT-EXPONENT names a type-specifier:
  Lambda-list: ()
  Expansion: (INTEGER -173 104)

%OTHER-POINTER-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable,predicate, always-translatable
  Source file: SYS:SRC;CODE;PRED.LISP

%SP-STRING-COMPARE names a compiled function:
  Lambda-list: (STRING1 STRING2 START1 END1 START2 END2)
  Declared type: (FUNCTION
                  (SIMPLE-STRING SIMPLE-STRING (UNSIGNED-BYTE 44)
                   (OR NULL (UNSIGNED-BYTE 44)) (UNSIGNED-BYTE 44)
                   (OR NULL (UNSIGNED-BYTE 44)))
                  (VALUES (UNSIGNED-BYTE 44) FIXNUM &OPTIONAL))
  Derived type: (FUNCTION
                 (SIMPLE-STRING SIMPLE-STRING (UNSIGNED-BYTE 44)
                  (OR NULL (UNSIGNED-BYTE 44)) (UNSIGNED-BYTE 44)
                  (OR NULL (UNSIGNED-BYTE 44)))
                 (VALUES (UNSIGNED-BYTE 44) (INTEGER -1114111 1114111)
                         &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;MIPSSTROPS.LISP

%RASSOC-IF names a compiled function:
  Lambda-list: (X LIST)
  Dynamic-extent arguments: positional=(0)
  Declared type: (FUNCTION (FUNCTION LIST) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (FUNCTION T) (VALUES LIST &OPTIONAL))
  Known attributes: call, foldable, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

TYPE-INTERSECTION2 names a compiled function:
  Lambda-list: (TYPE1 TYPE2)
  Derived type: (FUNCTION (SB-KERNEL:CTYPE SB-KERNEL:CTYPE)
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

%SINH names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (DOUBLE-FLOAT) (VALUES DOUBLE-FLOAT &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

QUIET< names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION (REAL REAL) (VALUES BOOLEAN &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;FLOAT.LISP

%COPY-INSTANCE names a compiled function:
  Lambda-list: (TO FROM)
  Declared type: (FUNCTION (SB-KERNEL:INSTANCE SB-KERNEL:INSTANCE)
                  (VALUES SB-KERNEL:INSTANCE &OPTIONAL))
  Derived type: (FUNCTION (STRUCTURE-OBJECT STRUCTURE-OBJECT)
                 (VALUES STRUCTURE-OBJECT &OPTIONAL))
  Source file: SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP

NAMESTRING-PARSE-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:NAMESTRING-PARSE-ERROR>:
  Class precedence-list: SB-KERNEL:NAMESTRING-PARSE-ERROR, PARSE-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: PARSE-ERROR
  No subclasses.
  Direct slots:
    SB-KERNEL::COMPLAINT
      Initargs: :COMPLAINT
      Readers: SB-KERNEL::NAMESTRING-PARSE-ERROR-COMPLAINT
    SB-KERNEL::ARGS
      Initargs: :ARGS
      Initform: 'NIL
      Readers: SB-KERNEL::NAMESTRING-PARSE-ERROR-ARGS
    NAMESTRING
      Initargs: :NAMESTRING
      Readers: SB-KERNEL::NAMESTRING-PARSE-ERROR-NAMESTRING
    SB-KERNEL::OFFSET
      Initargs: :OFFSET
      Readers: SB-KERNEL:NAMESTRING-PARSE-ERROR-OFFSET

ANSI-STREAM-IN-INDEX names a compiled function:
  An accessor for SB-KERNEL:ANSI-STREAM
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:ANSI-STREAM) (VALUES (MOD 513) &OPTIONAL))
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

(SETF ANSI-STREAM-IN-INDEX) names a compiled function:
  An accessor for SB-KERNEL:ANSI-STREAM
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION ((MOD 513) SB-KERNEL:ANSI-STREAM)
                 (VALUES (MOD 513) &OPTIONAL))
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

%SQRT names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES (DOUBLE-FLOAT 0.0d0) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

%EXPF names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (SINGLE-FLOAT) (VALUES (SINGLE-FLOAT 0.0)&OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

CLASSOID-OF names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES SB-KERNEL:CLASSOID &OPTIONAL))
  Documentation:
    Return the class of the supplied object, which may be any Lisp object, not
    just a CLOS STANDARD-OBJECT.
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;CLASS.LISP

UB16-BASH-FILL-WITH-SB16 names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  ((SIGNED-BYTE 16)
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION
                 ((SIGNED-BYTE 16) T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

ARRAY-TYPE-DIMENSIONS names a compiled function:
  An accessor for SB-KERNEL:ARRAY-TYPE
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:ARRAY-TYPE)
                 (VALUES (OR CONS (MEMBER NIL *)) &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

%NUMERATOR names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (RATIO)
                  (VALUES (OR (INTEGER * -1) (INTEGER 1)) &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;STUBS.LISP

• Called by
  • COERCE
  • SB-MPFR:COMPARE
  • DIV
  • SB-MPFR:MUL
  • SB-MPFR:SUB
  • SB-MPFR:ADD
  • SB-GMP::GMP-INTEXP
  • (INSPECTED-PARTS (RATIO))
  • SB-INTROSPECT:MAP-ROOT
  • (EMACS-INSPECT (RATIO))
  • DEEP-SIZE

COERCE-TO-VECTOR names a compiled function:
  Lambda-list: (OBJECT OUTPUT-TYPE-SPEC)
  Derived type: (FUNCTION (T T) (VALUES VECTOR &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;COERCE.LISP

TWO-ARG->= names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION (NUMBER NUMBER) (VALUES BOOLEAN &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;NUMBERS.LISP

FTYPE-PROCLAMATION-MISMATCH-WARNING names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:FTYPE-PROCLAMATION-MISMATCH-WARNING>:
  Class precedence-list: SB-KERNEL:FTYPE-PROCLAMATION-MISMATCH-WARNING,
                         STYLE-WARNING, WARNING,
                         SB-KERNEL:FTYPE-PROCLAMATION-MISMATCH,
                         SB-KERNEL:PROCLAMATION-MISMATCH, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: STYLE-WARNING, SB-KERNEL:FTYPE-PROCLAMATION-MISMATCH
  Direct subclasses: SB-KERNEL::FTYPE-PROCLAMATION-DERIVED-MISMATCH-WARNING
  No direct slots.

MAKE-MEMBER-TYPE names a compiled function:
  Lambda-list: (XSET)
  Derived type: (FUNCTION (T) (VALUES (NOT NULL) &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

UB32-BASH-FILL-WITH-UB32 names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 32)
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION
                 ((UNSIGNED-BYTE 32) T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

LEXENV-DESIGNATOR names a type-specifier:
  Lambda-list: ()
  Expansion: (OR SB-C::ABSTRACT-LEXENV NULL)

+PCL-OBJECT-LAYOUT-FLAG+ names a constant variable:
  Value: 4

MAKE-NUMERIC-TYPE names a compiled function:
  Lambda-list: (TYPE &OPTIONAL LOW HIGH (NORMALIZE-ZEROS T))
  Declared type: (FUNCTION
                  ((MEMBER RATIONAL INTEGER EQL FLOAT COMPLEX REAL NIL
                           DOUBLE-FLOAT SINGLE-FLOAT MOD SIGNED-BYTE
                           UNSIGNED-BYTE)
                   &OPTIONAL T T T)
                  (VALUES SB-KERNEL:CTYPE &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

%MAKE-SYMBOL names a compiled function:
  Lambda-list: (KIND NAME)
  Declared type: (FUNCTION (FIXNUM SIMPLE-STRING) (VALUES SYMBOL &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;SYMBOL.LISP

INTERNAL-TIME names a type-specifier:
  Lambda-list: ()
  Expansion: (UNSIGNED-BYTE 61)

%ADJOIN-KEY-TEST names a compiled function:
  Lambda-list: (X LIST KEY TEST)
  Dynamic-extent arguments: positional=(2 3)
  Declared type: (FUNCTION (T LIST FUNCTION FUNCTION) (VALUES LIST &OPTIONAL))
  Derived type: (FUNCTION (T T FUNCTION FUNCTION) (VALUES T &OPTIONAL))
  Known attributes: call, flushable, unsafely-flushable, no-verify-arg-count
  Source file: SYS:SRC;CODE;LIST.LISP

%COERCE-NAME-TO-FUN names a compiled function:
  Lambda-list: (NAME)
  Derived type: (FUNCTION (T) (VALUES FUNCTION &OPTIONAL))
  Source file: SYS:SRC;CODE;FDEFINITION.LISP

TWO-ARG-< names a compiled function:
  Lambda-list: (X Y)
  Declared type: (FUNCTION (NUMBER NUMBER) (VALUES BOOLEAN &OPTIONAL))
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;NUMBERS.LISP

• Called by
  • (DEFINE-C-STRUCT)
  • MATH/GRAPH::HYPER->BIPARTITE
  • MATH/GRAPH::ADLIST-TO-GRAPH
  • DAT/MIDI::FORMAT1-TRACKS-TO-FORMAT0-TRACKS
  • OBJ/STORE::GET-DB-SCHEMAS
  • OBJ/TIME::%TIMESTAMP-DECODE-DATE
  • (INITIALIZE-INSTANCE AFTER (PERMUTATION-CYCLE))
  • (INITIALIZE-INSTANCE AFTER (PERMUTATION-ACTION))
  • PICK-RANDOM
  • (EMACS-INSPECT (HASH-TABLE))
  • STD/STRING::%EMIT-STRING-CASE

CLASSOID-PCL-CLASS names a compiled function:
  An accessor for SB-KERNEL:CLASSOID
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:CLASSOID) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-CLASSOID.LISP

(SETF CLASSOID-PCL-CLASS) names a compiled function:
  An accessor for SB-KERNEL:CLASSOID
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (T SB-KERNEL:CLASSOID) (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;EARLY-CLASSOID.LISP

%CONCATENATE-TO-BASE-STRING-SUBSEQ names a compiled function:
  Lambda-list: (&REST SEQUENCES)
  Declared type: (FUNCTION * (VALUES SIMPLE-BASE-STRING &OPTIONAL))
  Derived type: (FUNCTION (&REST T) (VALUES SIMPLE-BASE-STRING &OPTIONAL))
  Known attributes: flushable, unsafely-flushable, foldable-read-only
  Source file: SYS:SRC;CODE;SEQ.LISP

+STRUCTURE-LAYOUT-FLAG+ names a constant variable:
  Value: 1

FUN-DESIGNATOR-TYPE-P names a compiled function:
  A predicate for SB-KERNEL:FUN-DESIGNATOR-TYPE
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

MEMBER-TYPE-SIZE names a compiled function:
  Lambda-list: (TYPE)
  Derived type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

%ARRAY-DISPLACEMENT names a compiled function:
  Lambda-list: (ARRAY)
  Declared type: (FUNCTION (T) (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;ARRAY.LISP

(SETF %ARRAY-DISPLACEMENT) names a compiled function:
  Lambda-list: (VALUE ARRAY)
  Declared type: (FUNCTION ((UNSIGNED-BYTE 44) T)
                  (VALUES (UNSIGNED-BYTE 44) &OPTIONAL))
  Source file: SYS:SRC;CODE;ARRAY.LISP

OBJECT-CARD-MARKS names a compiled function:
  Lambda-list: (OBJ)
  Derived type: (FUNCTION (T) (VALUES SIMPLE-BIT-VECTOR &OPTIONAL))
  Source file: SYS:SRC;CODE;GC.LISP

CONSTANT names the structure-class #<STRUCTURE-CLASS SB-KERNEL:CONSTANT>:
  Class precedence-list: SB-KERNEL:CONSTANT, SB-C::LEAF, SB-INT:SSET-ELEMENT,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-C::LEAF
  No subclasses.
  Sealed.
  Slots:
    NUMBER
      Type: (OR SB-INT:INDEX NULL)
      Initform: (WHEN (BOUNDP 'SB-C:*COMPILATION*)
                  (INCF (SB-C::SSET-COUNTER SB-C:*COMPILATION*)))
    SB-C::%SOURCE-NAME
      Type: (OR SYMBOL (AND CONS (SATISFIES SB-INT:LEGAL-FUN-NAME-P)))
      Initform: (SB-INT:MISSING-ARG)
    TYPE
      Type: SB-KERNEL:CTYPE
      Initform: SB-KERNEL:*UNIVERSAL-TYPE*
    SB-C::DEFINED-TYPE
      Type: SB-KERNEL:CTYPE
      Initform: SB-KERNEL:*UNIVERSAL-TYPE*
    SB-C::WHERE-FROM
      Type: (MEMBER :DECLARED :DECLARED-VERIFY :ASSUMED :DEFINED-HERE :DEFINED
                    :DEFINED-METHOD)
      Initform: :ASSUMED
    SB-C::REFS
      Type: LIST
      Initform: NIL
    SB-C::EVER-USED
      Type: (MEMBER NIL SET T SB-C::INITIAL-UNUSED)
      Initform: NIL
    DYNAMIC-EXTENT
      Type: BOOLEAN
      Initform: NIL
    INFO
      Type: T
      Initform: NIL
    SB-C::VALUE
      Type: T
      Initform: (SB-INT:MISSING-ARG)

BIG-RANDOM-CHUNK names a compiled function:
  Lambda-list: (STATE)
  Derived type: (FUNCTION (RANDOM-STATE) (VALUES (UNSIGNED-BYTE 64) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;TARGET-RANDOM.LISP

VECTOR-SIGNED-BYTE-64-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

SYMBOL-PACKAGE-ID names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (SYMBOL) (VALUES (UNSIGNED-BYTE 16) &OPTIONAL))
  Known attributes: unwind, any
  Source file: SYS:SRC;CODE;STUBS.LISP

%MAP names a compiled function:
  Lambda-list: (RESULT-TYPE FUNCTION &REST SEQUENCES)
  Dynamic-extent arguments: positional=(1)
  Declared type: (FUNCTION
                  ((OR CONS SYMBOL SB-KERNEL:CLASSOID CLASS)
                   (OR FUNCTION SYMBOL) &REST SEQUENCE)
                  (VALUES
                   (OR LIST (SIMPLE-ARRAY * (*)) SB-KERNEL:EXTENDED-SEQUENCE)
                   &OPTIONAL))
  Derived type: (FUNCTION (T T &REST T)
                 (VALUES
                  (OR LIST (SIMPLE-ARRAY * (*)) SB-KERNEL:EXTENDED-SEQUENCE)
                  &OPTIONAL))
  Known attributes: call, no-verify-arg-count, foldable-read-only
  Source file: SYS:SRC;CODE;SEQ.LISP

• Called by
  • SB-MPFR::%LOAD-MPFR
  • SB-GMP::%LOAD-GMP
  • SB-ACLREPL::REMOVE-ALIAS
  • SB-SIMD-INTERNALS:SIMD-FUNCTION-RECORD-P
  • SB-SIMD-INTERNALS:SCALAR-FUNCTION-RECORD-P
  • SB-SIMD-INTERNALS::UPDATE-IDISPATCH-INDEX
  • ASDF/SOURCE-REGISTRY:VALIDATE-SOURCE-REGISTRY-DIRECTIVE
  • (TRIVIAL-SYSTEM-P (SYSTEM))
  • UIOP/CONFIGURATION:LOCATION-DESIGNATOR-P
  • UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P
  • FEATUREP
  • SB-SPROF::PRINT-CYCLES
  • SKEL/CORE::SK-MULTI-RECIPE-P
  • MATH/UTIL::ARCH-EXISTS-P
  • PACKAGE-DOCUMENTATION
  • FUZZY-MATCH
  • (COSINE-SIMILARITY (SEARCH-DOCUMENT SEARCH-DOCUMENT))
  • NET/SRV/http::WAKE-TCP-SERVICE-FOR-SHUTDOWN
  • NET/SRV/http::GET-HTTP-REQUEST-DATA
  • NET/SRV/http::PARSE-PATH
  • (CONNECT (T LIST))
  • NET/CODEC/DBUS::VALID-BODY-P
  • NET/CODEC/DBUS::VALID-DICT-ENTRY-P
  • NET/CODEC/DBUS::VALID-STRUCT-P
  • NET/CODEC/DBUS::VALID-ARRAY-P
  • CLI/SPARK::AT-LEAST-TWO-CHARS-P
  • PARSE/YACC::SEQUENCE-DERIVES-EPSILON
  • PARSE/YACC::DERIVES-EPSILON*
  • PARSE/BYTES::CHECK-MATCH-CASES
  • PARSE/BYTES::CHECK-SKIP-ELEMS
  • (POST-PROCESS-ARG (SEQUENCE))
  • DAT/TAR::DETECT-TYPE
  • DAT/INI::DESKTOP-ENTRY-IN-CATEGORIES-P
  • DAT/HTML::SAME-CASE-P
  • DAT/HTML::ESCAPE-CHAR-P
  • DAT/HTML:XML-ESCAPE-NAME
  • (%PROCESS-CHARACTERS ((EQL IN-BODY) T))
  • DAT/ASN1::ASN1-TELETEX-STRING-P
  • DAT/ASN1::ASN1-PRINTABLE-STRING-P
  • DAT/ASN1::ASN1-IASTRING-P
  • BASE-COLOR-PALETTE-P
  • OBJ/META/STORED::CACHED-SLOT-SPECIFICATION-P
  • OBJ/META/STORED::SUPERCLASS-MEMBER-P
  • OBJ/META/STORED::ENSURE-CLASS-INHERITS-FROM
  • (OPTIMIZE-FUNCTION-CALL (FAST-GENERIC-FUNCTION STATIC-CALL-SIGNATURE))
  • (EXTERNALIZABLE-OBJECT-P (STATIC-CALL-SIGNATURE))
  • (SPECIALIZER-PROTOTYPE (CLASS))
  • (METAOBJECT-SEALABLE-P (POTENTIALLY-SEALABLE-METHOD))
  • (SHARED-INITIALIZE (SEALABLE-METAOBJECT-MIXIN (EQL T)))
  • (DOMAIN-SUBSETP (DOMAIN DOMAIN))
  • (DOMAIN-INTERSECTIONP (DOMAIN DOMAIN))
  • (DOMAIN-EQUAL (DOMAIN DOMAIN))
  • SWANK::MACRO-INDENTATION
  • SWANK::EXTENDED-AUTODOC-OPERATOR-P
  • SWANK::TRANSPOSE-LISTS
  • SWANK::MAKE-COMPOUND-PREFIX-MATCHER
  • SWANK::DETERMINE-CASE
  • SWANK::COMPLETION-OUTPUT-SYMBOL-CONVERTER
  • SWANK::COMPLETION-OUTPUT-CASE-CONVERTER
  • (EMACS-INSPECT (HASH-TABLE))
  • SWANK::FIND-SWANK-MODULE
  • SWANK::EVENT-MATCH-P
  • SWANK::ASCII-STRING-P
  • SWANK/SOURCE-PATH-PARSER::CHECK-SOURCE-PATH
  • (DEFIMPLEMENTATION)
  • (DEFINTERFACE)
  • IRONCLAD::%DEFCIPHER
  • STD/DEFSYS::COMPONENT-RECOMPILE-P
  • STD/DEFSYS::COMPONENT-RELOAD-P
  • STD/PRINT::ROTATE-ROWS-TO-COLUMNS
  • STD/THREAD::FILL-WORKERS
  • STARTS-WITH-ONE-OF-P
  • STD/COMP::%CHECKED-COMPILE-AND-ASSERT-ONE-CASE
  • STD/ALIEN::C-NAME-FROM-LISP
  • (MOVE-ELEMENT (PIPE T T))
  • (INSERT-ELEMENT (PIPE ELEMENT T))
  • (INSERT-ELEMENT (PIPE ARRAY T))
  • (REMOVE-ELEMENT (PIPE T))
  • STD/PPCRE::PARSE-REGISTER-NAME-AUX
  • DISJOIN
  • ASCII-ISTRING=
  • STD/STRING::ALL-EQUAL
  • ZIP-TREE

COERCE-TO-LEXENV names a compiled function:
  Lambda-list: (X)
  Derived type: (FUNCTION (T) (VALUES SB-KERNEL:LEXENV &OPTIONAL))
  Source file: SYS:SRC;COMPILER;NODE.LISP

• Called by
  • VARIABLE-INFORMATION
  • AUGMENT-ENVIRONMENT

FDEFN-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • DEEP-SIZE

INTEGER-DECODE-DOUBLE-FLOAT names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES (UNSIGNED-BYTE 53) (INTEGER -1127 971)
                          (OR (INTEGER -1 -1) (INTEGER 1 1)) &OPTIONAL))
  Derived type: (FUNCTION (DOUBLE-FLOAT)
                 (VALUES (UNSIGNED-BYTE 53) (INTEGER -1074 971)
                         (OR (INTEGER -1 -1) (INTEGER 1 1)) &OPTIONAL))
  Inline proclamation: MAYBE-INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;FLOAT.LISP

SIMPLE-ARRAY-SIGNED-BYTE-8-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-SIMD:S8VEC

ANSI-STREAM-BOUT names a compiled function:
  An accessor for SB-KERNEL:ANSI-STREAM
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:ANSI-STREAM)
                 (VALUES (FUNCTION * (VALUES T &OPTIONAL)) &OPTIONAL))
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

(SETF ANSI-STREAM-BOUT) names a compiled function:
  An accessor for SB-KERNEL:ANSI-STREAM
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION
                 ((FUNCTION * (VALUES T &OPTIONAL)) SB-KERNEL:ANSI-STREAM)
                 (VALUES (FUNCTION * (VALUES T &OPTIONAL)) &OPTIONAL))
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

%RAW-INSTANCE-SET/DOUBLE names a compiled function:
  Lambda-list: (INSTANCE INDEX NEWVAL)
  Declared type: (FUNCTION (SB-KERNEL:INSTANCE (UNSIGNED-BYTE 44) DOUBLE-FLOAT)
                  (VALUES &OPTIONAL))
  Known attributes: always-translatable
  Source file: SYS:SRC;CODE;TARGET-DEFSTRUCT.LISP

• Called by
  • IO/MUX::%HANDLE-ONE-FD
  • (FD-ENTRY-WRITE-TS)

LIST-TO-WEAK-VECTOR names a compiled function:
  Lambda-list: (LIST)
  Derived type: (FUNCTION (T) (VALUES SIMPLE-VECTOR &OPTIONAL))
  Source file: SYS:SRC;CODE;WEAK.LISP

UB1-BASH-FILL-WITH-UB1 names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  (BIT
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION (BIT T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

UB8-BASH-FILL-WITH-SB8 names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  ((SIGNED-BYTE 8)
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION
                 ((SIGNED-BYTE 8) T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

VECTOR-DOUBLE-FLOAT-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

INLINE-VOP names a macro:
  Lambda-list: (VARS RESULTS &BODY BODY)
  Source file: SYS:SRC;COMPILER;META-VMDEF.LISP

CODE-HEADER-REF names a compiled function:
  Lambda-list: (CODE-OBJ INDEX)
  Declared type: (FUNCTION (SB-KERNEL:CODE-COMPONENT (UNSIGNED-BYTE 44))
                  (VALUES T &OPTIONAL))
  Known attributes: flushable, unsafely-flushable
  Source file: SYS:SRC;CODE;STUBS.LISP

(SETF CODE-HEADER-REF) names a compiled function:
  Lambda-list: (VALUE CODE INDEX)
  Derived type: (FUNCTION (T T T) (VALUES T &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Source file: SYS:SRC;CODE;DEFSETFS.LISP

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • SB-INTROSPECT::MAP-CODE-CONSTANTS
  • (EMACS-INSPECT (CODE-COMPONENT))
  • DEEP-SIZE

VECTOR-NIL-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

STREAM-DESIGNATOR names a type-specifier:
  Lambda-list: ()
  Expansion: (OR STREAM (MEMBER NIL T))

UB8-BASH-FILL-WITH-UB8 names a compiled function:
  Lambda-list: (VALUE DST DST-OFFSET LENGTH)
  Declared type: (FUNCTION
                  ((UNSIGNED-BYTE 8)
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                  (VALUES
                   (OR (SIMPLE-ARRAY BASE-CHAR) (SIMPLE-ARRAY CHARACTER)
                       (SIMPLE-ARRAY SINGLE-FLOAT) (SIMPLE-ARRAY DOUBLE-FLOAT)
                       (SIMPLE-ARRAY BIT) (SIMPLE-ARRAY (UNSIGNED-BYTE 2))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 4))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 7))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 8))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 15))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 16))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 31))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 32))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 62))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 63))
                       (SIMPLE-ARRAY (UNSIGNED-BYTE 64))
                       (SIMPLE-ARRAY (SIGNED-BYTE 8))
                       (SIMPLE-ARRAY (SIGNED-BYTE 16))
                       (SIMPLE-ARRAY (SIGNED-BYTE 32)) (SIMPLE-ARRAY FIXNUM)
                       (SIMPLE-ARRAY (SIGNED-BYTE 64))
                       (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT))
                       (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT)))
                   &OPTIONAL))
  Derived type: (FUNCTION
                 ((UNSIGNED-BYTE 8) T (UNSIGNED-BYTE 44) (UNSIGNED-BYTE 44))
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;BIT-BASH.LISP

IMMOBILE-SPACE-OBJ-P names a compiled function:
  Lambda-list: (OBJ)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;ALLOC.LISP

SIGNED-BYTE-8-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-SIMD-NEON:S8.16!
  • SB-SIMD-AVX2:S8.16!
  • SB-SIMD-AVX:S8.32!
  • SB-SIMD-AVX:S8.16!
  • SB-SIMD-SSE2:S8.16!
  • S8

N-RANDOM-CHUNK-BITS names a constant variable:
  Value: 32

CONSTANT-TYPE names a compiled function:
  An accessor for SB-KERNEL:CONSTANT
  Lambda-list: (INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:CONSTANT)
                 (VALUES SB-KERNEL:CTYPE &OPTIONAL))
  Source file: SYS:SRC;COMPILER;NODE.LISP

(SETF CONSTANT-TYPE) names a compiled function:
  An accessor for SB-KERNEL:CONSTANT
  Lambda-list: (VALUE INSTANCE)
  Derived type: (FUNCTION (SB-KERNEL:CTYPE SB-KERNEL:CONSTANT)
                 (VALUES SB-KERNEL:CTYPE &OPTIONAL))
  Source file: SYS:SRC;COMPILER;NODE.LISP

CONSTANT-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:CONSTANT-TYPE>:
  Class precedence-list: SB-KERNEL:CONSTANT-TYPE, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:CTYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    TYPE
      Type: SB-KERNEL:CTYPE
      Initform: (SB-INT:MISSING-ARG)

SIMPLE-ARRAY-COMPLEX-DOUBLE-FLOAT-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

VALUES-TYPE-INTERSECTION names a compiled function:
  Lambda-list: (TYPE1 TYPE2)
  Derived type: (FUNCTION (SB-KERNEL:CTYPE SB-KERNEL:CTYPE)
                 (VALUES T &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

STANDARD-CLASSOID names the structure-class #<STRUCTURE-CLASS SB-KERNEL:STANDARD-CLASSOID>:
  Class precedence-list: SB-KERNEL:STANDARD-CLASSOID, CLASSOID, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: CLASSOID
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-KERNEL::NAME
      Type: SYMBOL
      Initform: NIL
    SB-KERNEL:LAYOUT
      Type: (OR NULL SB-KERNEL:LAYOUT)
      Initform: NIL
    SB-KERNEL::STATE
      Type: (MEMBER NIL :READ-ONLY :SEALED)
      Initform: NIL
    SB-KERNEL::DIRECT-SUPERCLASSES
      Type: LIST
      Initform: NIL
    SB-KERNEL::SOURCE-LOCATION
      Type: T
      Initform: NIL
    SB-KERNEL::SUBCLASSES
      Type: (OR LIST HASH-TABLE)
      Initform: NIL
    SB-KERNEL::%LOCK
      Type: T
      Initform: NIL
    SB-KERNEL::PCL-CLASS
      Type: T
      Initform: NIL
    SB-KERNEL::OLD-LAYOUTS
      Type: T
      Initform: NIL

%WITH-OUTPUT-TO-STRING names a macro:
  Lambda-list: ((VAR) &BODY BODY)
  Source file: SYS:SRC;CODE;ANSI-STREAM.LISP

• Macroexpanded by
  • NIL

HANDLE-CIRCULARITY names a compiled function:
  Lambda-list: (MARKER STREAM)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;PRINT.LISP

SCALE-DOUBLE-FLOAT names a compiled function:
  Lambda-list: (FLOAT N)
  Declared type: (FUNCTION (DOUBLE-FLOAT INTEGER)
                  (VALUES DOUBLE-FLOAT &OPTIONAL))
  Inline proclamation: MAYBE-INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable, no-verify-arg-count, fixed-args, unboxed-return
  Source file: SYS:SRC;CODE;FLOAT.LISP

VALUES-TYPE-NTH names a compiled function:
  Lambda-list: (N TYPE &OPTIONAL (NULL T))
  Derived type: (FUNCTION (T SB-KERNEL:CTYPE &OPTIONAL T) *)
  Source file: SYS:SRC;CODE;TYPE.LISP

%IMAGPART names an undefined function
  Declared type: (FUNCTION (COMPLEX) (VALUES REAL &OPTIONAL))

• Called by
  • SB-INTROSPECT:MAP-ROOT
  • DEEP-SIZE

FLOAT-FORMAT-NAME names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (FLOAT) (VALUES &OPTIONAL SYMBOL &REST T))
  Derived type: (FUNCTION (FLOAT)
                 (VALUES (MEMBER DOUBLE-FLOAT SINGLE-FLOAT) &OPTIONAL))
  Source file: SYS:SRC;COMPILER;GENERIC;VM-TYPE.LISP

FP< names a compiled function:
  Lambda-list: (A B)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE.LISP

SIMPLE-BASE-STRING-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • SB-POSIX:STRTOD
  • DAT/BASE64:BASE64-STRING-TO-STREAM
  • DAT/BASE64:BASE64-STRING-TO-INTEGER
  • DAT/BASE64:BASE64-STRING-TO-STRING
  • DAT/BASE64:BASE64-STRING-TO-OCTET-VECTOR

NO-NAMESTRING-ERROR names a compiled function:
  Lambda-list: (PATHNAME &OPTIONAL FORMAT-CONTROL &REST FORMAT-ARGUMENTS)
  Derived type: (FUNCTION (T &REST T) NIL)
  Source file: SYS:SRC;CODE;TARGET-ERROR.LISP

NO-NAMESTRING-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS SB-KERNEL:NO-NAMESTRING-ERROR>:
  Class precedence-list: SB-KERNEL:NO-NAMESTRING-ERROR,
                         SB-KERNEL::PATHNAME-UNPARSE-ERROR, FILE-ERROR, ERROR,
                         SERIOUS-CONDITION, SIMPLE-CONDITION,
                         SB-INT:REFERENCE-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL::PATHNAME-UNPARSE-ERROR,
                       SB-INT:REFERENCE-CONDITION
  No subclasses.
  No direct slots.

UNSIGNED-BYTE-64-P names a compiled function:
  Lambda-list: (OBJECT)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable, predicate
  Source file: SYS:SRC;CODE;PRED.LISP

• Called by
  • COERCE
  • SB-MPFR:COMPARE-2EXP
  • SB-MPFR:COMPARE
  • SB-MPFR:YN
  • SB-MPFR:JN
  • SB-MPFR:ZETA
  • SB-MPFR:DIV-2-RAISED
  • SB-MPFR:MUL-2-RAISED
  • SB-MPFR:POWER
  • SB-MPFR:K-ROOT
  • SQRT
  • DIV
  • SB-MPFR:MUL
  • SB-MPFR:SUB
  • SB-MPFR:ADD
  • SB-MPFR:SET-PRECISION
  • SB-SIMD-NEON:U64.2!
  • SB-SIMD-AVX2:U64.2!
  • SB-SIMD-AVX:U64.4!
  • SB-SIMD-AVX:U64.2!
  • SB-SIMD-SSE2:U64.2!
  • [BROKEN LINK: STD/TYPE::U64]
  • OBJ/TIME::TIMETAGP

ALIEN-TYPE-TYPE names the structure-class #<STRUCTURE-CLASS SB-KERNEL:ALIEN-TYPE-TYPE>:
  Class precedence-list: SB-KERNEL:ALIEN-TYPE-TYPE, SB-KERNEL:CTYPE,
                         STRUCTURE-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SB-KERNEL:CTYPE
  No subclasses.
  Sealed.
  Slots:
    SB-KERNEL::%BITS
      Type: (SIGNED-BYTE 30)
      Initform: (SB-INT:MISSING-ARG)
    SB-ALIEN-INTERNALS:ALIEN-TYPE
      Type: SB-ALIEN-INTERNALS:ALIEN-TYPE
      Initform: NIL

VECTOR-UNSIGNED-BYTE-63-P names a compiled function:
  Lambda-list: (X)
  Declared type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;PRED.LISP

BECOME-DEFINED-FUN-NAME names a compiled function:
  Lambda-list: (NAME)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;COMPILER;PROCLAIM.LISP

FILL-POINTER-ERROR names a compiled function:
  Lambda-list: (VECTOR)
  Declared type: (FUNCTION (T) NIL)
  Known attributes: no-verify-arg-count
  Source file: SYS:SRC;CODE;ARRAY.LISP

• Called by
  • UIOP/STREAM::CALL-WITH-OUTPUT
  • DOC/NLP::STEP5
  • DOC/NLP::STEP4
  • DOC/NLP::STEP3
  • DOC/NLP::STEP2
  • DOC/NLP::STEP1C
  • DOC/NLP::STEP1AB
  • DOC/NLP::R
  • DOC/NLP::ENDS
  • DOC/NLP::VOWELINSTEM
  • CLI/ED::%REWIND-COUNT
  • CLI/TERM::XFORM
  • DAT/HTML::READ-CHUNK
  • DAT/HTML::HTML5-STREAM-UNGET
  • DAT/XML::PI-CONTENTS
  • DAT/XML::COMMENT-OR-CDATA
  • DAT/IMG:LAST-IMAGE
  • (STREAM-FILE-POSITION (VECTOR-OUTPUT-STREAM))
  • OBJ/URL::READ-UNTIL
  • (INITIALIZE-INSTANCE AFTER (TRACE-ENTRY))
  • SWANK::EMACS-INSPECT-VECTOR-WITH-FILL-POINTER-AUX
  • (EMACS-INSPECT (ARRAY))
  • SWANK::ASSIGN-INDEX
  • STD/ASYNC::PMAP-INTO/UNPARSED
  • STD/SEQ::HEAP-EXTRACT
  • VECTOR-PUSH-EXTEND-POSITION
  • ARRAY-SHIFT
  • COPY-ARRAY

VALUE-CELL-SET names an undefined function
  Declared type: (FUNCTION (T T) (VALUES T &OPTIONAL))

%COS names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES (DOUBLE-FLOAT -1.0d0 1.0d0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

CONS-TYPE-P names a compiled function:
  A predicate for SB-KERNEL:CONS-TYPE
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) (VALUES BOOLEAN &OPTIONAL))
  Source file: SYS:SRC;CODE;TYPE-CLASS.LISP

%COSH names a compiled function:
  Lambda-list: (ARG0)
  Declared type: (FUNCTION (DOUBLE-FLOAT)
                  (VALUES (DOUBLE-FLOAT 1.0d0) &OPTIONAL))
  Inline proclamation: INLINE (inline expansion available)
  Known attributes: foldable, flushable, unsafely-flushable, movable
  Source file: SYS:SRC;CODE;IRRAT.LISP

SCRUB-POWER-CACHE names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES NULL &OPTIONAL))
  Source file: SYS:SRC;CODE;PRINT.LISP