;; -*- Mode: Lisp; -*-

;; Generated from "build/tex.p".

(CL:IN-PACKAGE :CL-USER)

(DEFPACKAGE :PASCAL.TEX (:USE :PASCAL) (:EXPORT "TEX"))
(IN-PACKAGE :PASCAL.TEX)

(LABEL $L.1)

(LABEL $L.9998)

(LABEL $L.9999)

(CONST MEM-MAX 60000)

(CONST MEM-MIN 0)

(CONST BUF-SIZE 500)

(CONST ERROR-LINE 72)

(CONST HALF-ERROR-LINE 42)

(CONST MAX-PRINT-LINE 79)

(CONST STACK-SIZE 200)

(CONST MAX-IN-OPEN 6)

(CONST FONT-MAX 75)

(CONST FONT-MEM-SIZE 60000)

(CONST PARAM-SIZE 60)

(CONST NEST-SIZE 40)

(CONST MAX-STRINGS 9000)

(CONST STRING-VACANCIES 8000)

(CONST POOL-SIZE 64000)

(CONST SAVE-SIZE 600)

(CONST TRIE-SIZE 8000)

(CONST TRIE-OP-SIZE 500)

(CONST DVI-BUF-SIZE 800)

(CONST FILE-NAME-SIZE 40)

(CONST POOL-NAME "TeXformats:TEX.POOL                     ")

(TYPE ASCII-CODE (RANGE 0 255))

(TYPE EIGHT-BITS (RANGE 0 255))

(TYPE ALPHA-FILE TEXT)

(TYPE BYTE-FILE (PACKED (FILE EIGHT-BITS)))

(TYPE POOL-POINTER (RANGE 0 POOL-SIZE))

(TYPE STR-NUMBER (RANGE 0 MAX-STRINGS))

(TYPE PACKED-ASCII-CODE (RANGE 0 255))

(TYPE SCALED INTEGER)

(TYPE NONNEGATIVE-INTEGER (RANGE 0 2147483647))

(TYPE SMALL-NUMBER (RANGE 0 63))

(TYPE GLUE-RATIO REAL)

(TYPE QUARTERWORD (RANGE 0 255))

(TYPE HALFWORD (RANGE 0 65535))

(TYPE TWO-CHOICES (RANGE 1 2))

(TYPE FOUR-CHOICES (RANGE 1 4))

(TYPE TWO-HALVES
      (PACKED
       (RECORD TWO-HALVES (RH HALFWORD)
        (CASE TWO-CHOICES
          ((1) (LH HALFWORD))
          ((2) (B0 QUARTERWORD) (B1 QUARTERWORD))))))

(TYPE FOUR-QUARTERS
      (PACKED
       (RECORD FOUR-QUARTERS (B0 QUARTERWORD) (B1 QUARTERWORD) (B2 QUARTERWORD)
        (B3 QUARTERWORD))))

(TYPE MEMORY-WORD
      (RECORD MEMORY-WORD
       (CASE FOUR-CHOICES
         ((1) (INT INTEGER))
         ((2) (GR GLUE-RATIO))
         ((3) (HH TWO-HALVES))
         ((4) (QQQQ FOUR-QUARTERS)))))

(TYPE WORD-FILE (FILE MEMORY-WORD))

(TYPE GLUE-ORD (RANGE 0 3))

(TYPE LIST-STATE-RECORD
      (RECORD LIST-STATE-RECORD (MODE-FIELD (RANGE (- 203) 203)) (HEAD-FIELD HALFWORD)
       (TAIL-FIELD HALFWORD) (PG-FIELD INTEGER) (ML-FIELD INTEGER) (AUX-FIELD MEMORY-WORD)))

(TYPE GROUP-CODE (RANGE 0 16))

(TYPE IN-STATE-RECORD
      (RECORD IN-STATE-RECORD (STATE-FIELD QUARTERWORD) (INDEX-FIELD QUARTERWORD)
       (START-FIELD HALFWORD) (LOC-FIELD HALFWORD) (LIMIT-FIELD HALFWORD)
       (NAME-FIELD HALFWORD)))

(TYPE INTERNAL-FONT-NUMBER (RANGE 0 FONT-MAX))

(TYPE FONT-INDEX (RANGE 0 FONT-MEM-SIZE))

(TYPE DVI-INDEX (RANGE 0 DVI-BUF-SIZE))

(TYPE TRIE-POINTER (RANGE 0 TRIE-SIZE))

(TYPE HYPH-POINTER (RANGE 0 307))

(VAR BAD INTEGER)

(VAR XORD (ARRAY ASCII-CODE CHAR))

(VAR XCHR (ARRAY CHAR ASCII-CODE))

(VAR NAME-OF-FILE (PACKED (ARRAY CHAR (RANGE 1 FILE-NAME-SIZE))))

(VAR NAME-LENGTH (RANGE 0 FILE-NAME-SIZE))

(VAR BUFFER (ARRAY ASCII-CODE (RANGE 0 BUF-SIZE)))

(VAR FIRST (RANGE 0 BUF-SIZE))

(VAR LAST (RANGE 0 BUF-SIZE))

(VAR MAX-BUF-STACK (RANGE 0 BUF-SIZE))

(VAR TERM-IN ALPHA-FILE)

(VAR TERM-OUT ALPHA-FILE)

(VAR STR-POOL (PACKED (ARRAY PACKED-ASCII-CODE POOL-POINTER)))

(VAR STR-START (ARRAY POOL-POINTER STR-NUMBER))

(VAR POOL-PTR POOL-POINTER)

(VAR STR-PTR STR-NUMBER)

(VAR INIT-POOL-PTR POOL-POINTER)

(VAR INIT-STR-PTR STR-NUMBER)

(VAR POOL-FILE ALPHA-FILE)

(VAR LOG-FILE ALPHA-FILE)

(VAR SELECTOR (RANGE 0 21))

(VAR DIG (ARRAY (RANGE 0 15) (RANGE 0 22)))

(VAR TALLY INTEGER)

(VAR TERM-OFFSET (RANGE 0 MAX-PRINT-LINE))

(VAR FILE-OFFSET (RANGE 0 MAX-PRINT-LINE))

(VAR TRICK-BUF (ARRAY ASCII-CODE (RANGE 0 ERROR-LINE)))

(VAR TRICK-COUNT INTEGER)

(VAR FIRST-COUNT INTEGER)

(VAR INTERACTION (RANGE 0 3))

(VAR DELETIONS-ALLOWED BOOLEAN)

(VAR SET-BOX-ALLOWED BOOLEAN)

(VAR HISTORY (RANGE 0 3))

(VAR ERROR-COUNT (RANGE (- 1) 100))

(VAR HELP-LINE (ARRAY STR-NUMBER (RANGE 0 5)))

(VAR HELP-PTR (RANGE 0 6))

(VAR USE-ERR-HELP BOOLEAN)

(VAR INTERRUPT INTEGER)

(VAR OK-TO-INTERRUPT BOOLEAN)

(VAR ARITH-ERROR BOOLEAN)

(VAR REMAINDER SCALED)

(VAR TEMP-PTR HALFWORD)

(VAR MEM (ARRAY MEMORY-WORD (RANGE MEM-MIN MEM-MAX)))

(VAR LO-MEM-MAX HALFWORD)

(VAR HI-MEM-MIN HALFWORD)

(VAR VAR-USED INTEGER)

(VAR DYN-USED INTEGER)

(VAR AVAIL HALFWORD)

(VAR MEM-END HALFWORD)

(VAR ROVER HALFWORD)

(VAR FONT-IN-SHORT-DISPLAY INTEGER)

(VAR DEPTH-THRESHOLD INTEGER)

(VAR BREADTH-MAX INTEGER)

(VAR NEST (ARRAY LIST-STATE-RECORD (RANGE 0 NEST-SIZE)))

(VAR NEST-PTR (RANGE 0 NEST-SIZE))

(VAR MAX-NEST-STACK (RANGE 0 NEST-SIZE))

(VAR CUR-LIST LIST-STATE-RECORD)

(VAR SHOWN-MODE (RANGE (- 203) 203))

(VAR OLD-SETTING (RANGE 0 21))

(VAR SYS-TIME INTEGER)

(VAR SYS-DAY INTEGER)

(VAR SYS-MONTH INTEGER)

(VAR SYS-YEAR INTEGER)

(VAR EQTB (ARRAY MEMORY-WORD (RANGE 1 10006)))

(VAR XEQ-LEVEL (ARRAY QUARTERWORD (RANGE 9163 10006)))

(VAR HASH (ARRAY TWO-HALVES (RANGE 514 6780)))

(VAR HASH-USED HALFWORD)

(VAR NO-NEW-CONTROL-SEQUENCE BOOLEAN)

(VAR CS-COUNT INTEGER)

(VAR SAVE-STACK (ARRAY MEMORY-WORD (RANGE 0 SAVE-SIZE)))

(VAR SAVE-PTR (RANGE 0 SAVE-SIZE))

(VAR MAX-SAVE-STACK (RANGE 0 SAVE-SIZE))

(VAR CUR-LEVEL QUARTERWORD)

(VAR CUR-GROUP GROUP-CODE)

(VAR CUR-BOUNDARY (RANGE 0 SAVE-SIZE))

(VAR MAG-SET INTEGER)

(VAR CUR-CMD EIGHT-BITS)

(VAR CUR-CHR HALFWORD)

(VAR CUR-CS HALFWORD)

(VAR CUR-TOK HALFWORD)

(VAR INPUT-STACK (ARRAY IN-STATE-RECORD (RANGE 0 STACK-SIZE)))

(VAR INPUT-PTR (RANGE 0 STACK-SIZE))

(VAR MAX-IN-STACK (RANGE 0 STACK-SIZE))

(VAR CUR-INPUT IN-STATE-RECORD)

(VAR IN-OPEN (RANGE 0 MAX-IN-OPEN))

(VAR OPEN-PARENS (RANGE 0 MAX-IN-OPEN))

(VAR INPUT-FILE (ARRAY ALPHA-FILE (RANGE 1 MAX-IN-OPEN)))

(VAR LINE INTEGER)

(VAR LINE-STACK (ARRAY INTEGER (RANGE 1 MAX-IN-OPEN)))

(VAR SCANNER-STATUS (RANGE 0 5))

(VAR WARNING-INDEX HALFWORD)

(VAR DEF-REF HALFWORD)

(VAR PARAM-STACK (ARRAY HALFWORD (RANGE 0 PARAM-SIZE)))

(VAR PARAM-PTR (RANGE 0 PARAM-SIZE))

(VAR MAX-PARAM-STACK INTEGER)

(VAR ALIGN-STATE INTEGER)

(VAR BASE-PTR (RANGE 0 STACK-SIZE))

(VAR PAR-LOC HALFWORD)

(VAR PAR-TOKEN HALFWORD)

(VAR FORCE-EOF BOOLEAN)

(VAR CUR-MARK (ARRAY HALFWORD (RANGE 0 4)))

(VAR LONG-STATE (RANGE 111 114))

(VAR PSTACK (ARRAY HALFWORD (RANGE 0 8)))

(VAR CUR-VAL INTEGER)

(VAR CUR-VAL-LEVEL (RANGE 0 5))

(VAR RADIX SMALL-NUMBER)

(VAR CUR-ORDER GLUE-ORD)

(VAR READ-FILE (ARRAY ALPHA-FILE (RANGE 0 15)))

(VAR READ-OPEN (ARRAY (RANGE 0 2) (RANGE 0 16)))

(VAR COND-PTR HALFWORD)

(VAR IF-LIMIT (RANGE 0 4))

(VAR CUR-IF SMALL-NUMBER)

(VAR IF-LINE INTEGER)

(VAR SKIP-LINE INTEGER)

(VAR CUR-NAME STR-NUMBER)

(VAR CUR-AREA STR-NUMBER)

(VAR CUR-EXT STR-NUMBER)

(VAR AREA-DELIMITER POOL-POINTER)

(VAR EXT-DELIMITER POOL-POINTER)

(VAR TEX-FORMAT-DEFAULT (PACKED (ARRAY CHAR (RANGE 1 20))))

(VAR NAME-IN-PROGRESS BOOLEAN)

(VAR JOB-NAME STR-NUMBER)

(VAR LOG-OPENED BOOLEAN)

(VAR DVI-FILE BYTE-FILE)

(VAR OUTPUT-FILE-NAME STR-NUMBER)

(VAR LOG-NAME STR-NUMBER)

(VAR TFM-FILE BYTE-FILE)

(VAR FONT-INFO (ARRAY MEMORY-WORD FONT-INDEX))

(VAR FMEM-PTR FONT-INDEX)

(VAR FONT-PTR INTERNAL-FONT-NUMBER)

(VAR FONT-CHECK (ARRAY FOUR-QUARTERS INTERNAL-FONT-NUMBER))

(VAR FONT-SIZE (ARRAY SCALED INTERNAL-FONT-NUMBER))

(VAR FONT-DSIZE (ARRAY SCALED INTERNAL-FONT-NUMBER))

(VAR FONT-PARAMS (ARRAY FONT-INDEX INTERNAL-FONT-NUMBER))

(VAR FONT-NAME (ARRAY STR-NUMBER INTERNAL-FONT-NUMBER))

(VAR FONT-AREA (ARRAY STR-NUMBER INTERNAL-FONT-NUMBER))

(VAR FONT-BC (ARRAY EIGHT-BITS INTERNAL-FONT-NUMBER))

(VAR FONT-EC (ARRAY EIGHT-BITS INTERNAL-FONT-NUMBER))

(VAR FONT-GLUE (ARRAY HALFWORD INTERNAL-FONT-NUMBER))

(VAR FONT-USED (ARRAY BOOLEAN INTERNAL-FONT-NUMBER))

(VAR HYPHEN-CHAR (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR SKEW-CHAR (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR BCHAR-LABEL (ARRAY FONT-INDEX INTERNAL-FONT-NUMBER))

(VAR FONT-BCHAR (ARRAY (RANGE 0 256) INTERNAL-FONT-NUMBER))

(VAR FONT-FALSE-BCHAR (ARRAY (RANGE 0 256) INTERNAL-FONT-NUMBER))

(VAR CHAR-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR WIDTH-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR HEIGHT-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR DEPTH-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR ITALIC-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR LIG-KERN-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR KERN-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR EXTEN-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR PARAM-BASE (ARRAY INTEGER INTERNAL-FONT-NUMBER))

(VAR NULL-CHARACTER FOUR-QUARTERS)

(VAR TOTAL-PAGES INTEGER)

(VAR MAX-V SCALED)

(VAR MAX-H SCALED)

(VAR MAX-PUSH INTEGER)

(VAR LAST-BOP INTEGER)

(VAR DEAD-CYCLES INTEGER)

(VAR DOING-LEADERS BOOLEAN)

(VAR C QUARTERWORD)

(VAR F QUARTERWORD)

(VAR RULE-HT SCALED)

(VAR RULE-DP SCALED)

(VAR RULE-WD SCALED)

(VAR G HALFWORD)

(VAR LQ INTEGER)

(VAR LR INTEGER)

(VAR DVI-BUF (ARRAY EIGHT-BITS DVI-INDEX))

(VAR HALF-BUF DVI-INDEX)

(VAR DVI-LIMIT DVI-INDEX)

(VAR DVI-PTR DVI-INDEX)

(VAR DVI-OFFSET INTEGER)

(VAR DVI-GONE INTEGER)

(VAR DOWN-PTR HALFWORD)

(VAR RIGHT-PTR HALFWORD)

(VAR DVI-H SCALED)

(VAR DVI-V SCALED)

(VAR CUR-H SCALED)

(VAR CUR-V SCALED)

(VAR DVI-F INTERNAL-FONT-NUMBER)

(VAR CUR-S INTEGER)

(VAR TOTAL-STRETCH (ARRAY SCALED GLUE-ORD))

(VAR TOTAL-SHRINK (ARRAY SCALED GLUE-ORD))

(VAR LAST-BADNESS INTEGER)

(VAR ADJUST-TAIL HALFWORD)

(VAR PACK-BEGIN-LINE INTEGER)

(VAR EMPTY-FIELD TWO-HALVES)

(VAR NULL-DELIMITER FOUR-QUARTERS)

(VAR CUR-MLIST HALFWORD)

(VAR CUR-STYLE SMALL-NUMBER)

(VAR CUR-SIZE SMALL-NUMBER)

(VAR CUR-MU SCALED)

(VAR MLIST-PENALTIES BOOLEAN)

(VAR CUR-F INTERNAL-FONT-NUMBER)

(VAR CUR-C QUARTERWORD)

(VAR CUR-I FOUR-QUARTERS)

(VAR MAGIC-OFFSET INTEGER)

(VAR CUR-ALIGN HALFWORD)

(VAR CUR-SPAN HALFWORD)

(VAR CUR-LOOP HALFWORD)

(VAR ALIGN-PTR HALFWORD)

(VAR CUR-HEAD HALFWORD)

(VAR CUR-TAIL HALFWORD)

(VAR JUST-BOX HALFWORD)

(VAR PASSIVE HALFWORD)

(VAR PRINTED-NODE HALFWORD)

(VAR PASS-NUMBER HALFWORD)

(VAR ACTIVE-WIDTH (ARRAY SCALED (RANGE 1 6)))

(VAR CUR-ACTIVE-WIDTH (ARRAY SCALED (RANGE 1 6)))

(VAR BACKGROUND (ARRAY SCALED (RANGE 1 6)))

(VAR BREAK-WIDTH (ARRAY SCALED (RANGE 1 6)))

(VAR NO-SHRINK-ERROR-YET BOOLEAN)

(VAR CUR-P HALFWORD)

(VAR SECOND-PASS BOOLEAN)

(VAR FINAL-PASS BOOLEAN)

(VAR THRESHOLD INTEGER)

(VAR MINIMAL-DEMERITS (ARRAY INTEGER (RANGE 0 3)))

(VAR MINIMUM-DEMERITS INTEGER)

(VAR BEST-PLACE (ARRAY HALFWORD (RANGE 0 3)))

(VAR BEST-PL-LINE (ARRAY HALFWORD (RANGE 0 3)))

(VAR DISC-WIDTH SCALED)

(VAR EASY-LINE HALFWORD)

(VAR LAST-SPECIAL-LINE HALFWORD)

(VAR FIRST-WIDTH SCALED)

(VAR SECOND-WIDTH SCALED)

(VAR FIRST-INDENT SCALED)

(VAR SECOND-INDENT SCALED)

(VAR BEST-BET HALFWORD)

(VAR FEWEST-DEMERITS INTEGER)

(VAR BEST-LINE HALFWORD)

(VAR ACTUAL-LOOSENESS INTEGER)

(VAR LINE-DIFF INTEGER)

(VAR HC (ARRAY (RANGE 0 256) (RANGE 0 65)))

(VAR HN (RANGE 0 64))

(VAR HA HALFWORD)

(VAR HB HALFWORD)

(VAR HF INTERNAL-FONT-NUMBER)

(VAR HU (ARRAY (RANGE 0 256) (RANGE 0 63)))

(VAR HYF-CHAR INTEGER)

(VAR CUR-LANG ASCII-CODE)

(VAR INIT-CUR-LANG ASCII-CODE)

(VAR L-HYF INTEGER)

(VAR R-HYF INTEGER)

(VAR INIT-L-HYF INTEGER)

(VAR INIT-R-HYF INTEGER)

(VAR HYF-BCHAR HALFWORD)

(VAR HYF (ARRAY (RANGE 0 9) (RANGE 0 64)))

(VAR INIT-LIST HALFWORD)

(VAR INIT-LIG BOOLEAN)

(VAR INIT-LFT BOOLEAN)

(VAR HYPHEN-PASSED SMALL-NUMBER)

(VAR CUR-L HALFWORD)

(VAR CUR-R HALFWORD)

(VAR CUR-Q HALFWORD)

(VAR LIG-STACK HALFWORD)

(VAR LIGATURE-PRESENT BOOLEAN)

(VAR LFT-HIT BOOLEAN)

(VAR RT-HIT BOOLEAN)

(VAR TRIE (ARRAY TWO-HALVES TRIE-POINTER))

(VAR HYF-DISTANCE (ARRAY SMALL-NUMBER (RANGE 1 TRIE-OP-SIZE)))

(VAR HYF-NUM (ARRAY SMALL-NUMBER (RANGE 1 TRIE-OP-SIZE)))

(VAR HYF-NEXT (ARRAY QUARTERWORD (RANGE 1 TRIE-OP-SIZE)))

(VAR OP-START (ARRAY (RANGE 0 TRIE-OP-SIZE) ASCII-CODE))

(VAR HYPH-WORD (ARRAY STR-NUMBER HYPH-POINTER))

(VAR HYPH-LIST (ARRAY HALFWORD HYPH-POINTER))

(VAR HYPH-COUNT HYPH-POINTER)

(VAR TRIE-OP-HASH (ARRAY (RANGE 0 TRIE-OP-SIZE) (RANGE (- TRIE-OP-SIZE) TRIE-OP-SIZE)))

(VAR TRIE-USED (ARRAY QUARTERWORD ASCII-CODE))

(VAR TRIE-OP-LANG (ARRAY ASCII-CODE (RANGE 1 TRIE-OP-SIZE)))

(VAR TRIE-OP-VAL (ARRAY QUARTERWORD (RANGE 1 TRIE-OP-SIZE)))

(VAR TRIE-OP-PTR (RANGE 0 TRIE-OP-SIZE))

(VAR TRIE-C (PACKED (ARRAY PACKED-ASCII-CODE TRIE-POINTER)))

(VAR TRIE-O (PACKED (ARRAY QUARTERWORD TRIE-POINTER)))

(VAR TRIE-L (PACKED (ARRAY TRIE-POINTER TRIE-POINTER)))

(VAR TRIE-R (PACKED (ARRAY TRIE-POINTER TRIE-POINTER)))

(VAR TRIE-PTR TRIE-POINTER)

(VAR TRIE-HASH (PACKED (ARRAY TRIE-POINTER TRIE-POINTER)))

(VAR TRIE-TAKEN (PACKED (ARRAY BOOLEAN (RANGE 1 TRIE-SIZE))))

(VAR TRIE-MIN (ARRAY TRIE-POINTER ASCII-CODE))

(VAR TRIE-MAX TRIE-POINTER)

(VAR TRIE-NOT-READY BOOLEAN)

(VAR BEST-HEIGHT-PLUS-DEPTH SCALED)

(VAR PAGE-TAIL HALFWORD)

(VAR PAGE-CONTENTS (RANGE 0 2))

(VAR PAGE-MAX-DEPTH SCALED)

(VAR BEST-PAGE-BREAK HALFWORD)

(VAR LEAST-PAGE-COST INTEGER)

(VAR BEST-SIZE SCALED)

(VAR PAGE-SO-FAR (ARRAY SCALED (RANGE 0 7)))

(VAR LAST-GLUE HALFWORD)

(VAR LAST-PENALTY INTEGER)

(VAR LAST-KERN SCALED)

(VAR INSERT-PENALTIES INTEGER)

(VAR OUTPUT-ACTIVE BOOLEAN)

(VAR MAIN-F INTERNAL-FONT-NUMBER)

(VAR MAIN-I FOUR-QUARTERS)

(VAR MAIN-J FOUR-QUARTERS)

(VAR MAIN-K FONT-INDEX)

(VAR MAIN-P HALFWORD)

(VAR MAIN-S INTEGER)

(VAR BCHAR HALFWORD)

(VAR FALSE-BCHAR HALFWORD)

(VAR CANCEL-BOUNDARY BOOLEAN)

(VAR INS-DISC BOOLEAN)

(VAR CUR-BOX HALFWORD)

(VAR AFTER-TOKEN HALFWORD)

(VAR LONG-HELP-SEEN BOOLEAN)

(VAR FORMAT-IDENT STR-NUMBER)

(VAR FMT-FILE WORD-FILE)

(VAR READY-ALREADY INTEGER)

(VAR WRITE-FILE (ARRAY ALPHA-FILE (RANGE 0 15)))

(VAR WRITE-OPEN (ARRAY BOOLEAN (RANGE 0 17)))

(VAR WRITE-LOC HALFWORD)

(PROCEDURE INITIALIZE ()
  (VAR I INTEGER)
  (VAR K INTEGER)
  (VAR Z HYPH-POINTER)
  (SETF (AREF XCHR 32) " ")
  (SETF (AREF XCHR 33) "!")
  (SETF (AREF XCHR 34) "\"")
  (SETF (AREF XCHR 35) "#")
  (SETF (AREF XCHR 36) "$")
  (SETF (AREF XCHR 37) "%")
  (SETF (AREF XCHR 38) "&")
  (SETF (AREF XCHR 39) "'")
  (SETF (AREF XCHR 40) "(")
  (SETF (AREF XCHR 41) ")")
  (SETF (AREF XCHR 42) "*")
  (SETF (AREF XCHR 43) "+")
  (SETF (AREF XCHR 44) ",")
  (SETF (AREF XCHR 45) "-")
  (SETF (AREF XCHR 46) ".")
  (SETF (AREF XCHR 47) "/")
  (SETF (AREF XCHR 48) "0")
  (SETF (AREF XCHR 49) "1")
  (SETF (AREF XCHR 50) "2")
  (SETF (AREF XCHR 51) "3")
  (SETF (AREF XCHR 52) "4")
  (SETF (AREF XCHR 53) "5")
  (SETF (AREF XCHR 54) "6")
  (SETF (AREF XCHR 55) "7")
  (SETF (AREF XCHR 56) "8")
  (SETF (AREF XCHR 57) "9")
  (SETF (AREF XCHR 58) ":")
  (SETF (AREF XCHR 59) ";")
  (SETF (AREF XCHR 60) "<")
  (SETF (AREF XCHR 61) "=")
  (SETF (AREF XCHR 62) ">")
  (SETF (AREF XCHR 63) "?")
  (SETF (AREF XCHR 64) "@")
  (SETF (AREF XCHR 65) "A")
  (SETF (AREF XCHR 66) "B")
  (SETF (AREF XCHR 67) "C")
  (SETF (AREF XCHR 68) "D")
  (SETF (AREF XCHR 69) "E")
  (SETF (AREF XCHR 70) "F")
  (SETF (AREF XCHR 71) "G")
  (SETF (AREF XCHR 72) "H")
  (SETF (AREF XCHR 73) "I")
  (SETF (AREF XCHR 74) "J")
  (SETF (AREF XCHR 75) "K")
  (SETF (AREF XCHR 76) "L")
  (SETF (AREF XCHR 77) "M")
  (SETF (AREF XCHR 78) "N")
  (SETF (AREF XCHR 79) "O")
  (SETF (AREF XCHR 80) "P")
  (SETF (AREF XCHR 81) "Q")
  (SETF (AREF XCHR 82) "R")
  (SETF (AREF XCHR 83) "S")
  (SETF (AREF XCHR 84) "T")
  (SETF (AREF XCHR 85) "U")
  (SETF (AREF XCHR 86) "V")
  (SETF (AREF XCHR 87) "W")
  (SETF (AREF XCHR 88) "X")
  (SETF (AREF XCHR 89) "Y")
  (SETF (AREF XCHR 90) "Z")
  (SETF (AREF XCHR 91) "[")
  (SETF (AREF XCHR 92) "\\")
  (SETF (AREF XCHR 93) "]")
  (SETF (AREF XCHR 94) "^")
  (SETF (AREF XCHR 95) "_")
  (SETF (AREF XCHR 96) "`")
  (SETF (AREF XCHR 97) "a")
  (SETF (AREF XCHR 98) "b")
  (SETF (AREF XCHR 99) "c")
  (SETF (AREF XCHR 100) "d")
  (SETF (AREF XCHR 101) "e")
  (SETF (AREF XCHR 102) "f")
  (SETF (AREF XCHR 103) "g")
  (SETF (AREF XCHR 104) "h")
  (SETF (AREF XCHR 105) "i")
  (SETF (AREF XCHR 106) "j")
  (SETF (AREF XCHR 107) "k")
  (SETF (AREF XCHR 108) "l")
  (SETF (AREF XCHR 109) "m")
  (SETF (AREF XCHR 110) "n")
  (SETF (AREF XCHR 111) "o")
  (SETF (AREF XCHR 112) "p")
  (SETF (AREF XCHR 113) "q")
  (SETF (AREF XCHR 114) "r")
  (SETF (AREF XCHR 115) "s")
  (SETF (AREF XCHR 116) "t")
  (SETF (AREF XCHR 117) "u")
  (SETF (AREF XCHR 118) "v")
  (SETF (AREF XCHR 119) "w")
  (SETF (AREF XCHR 120) "x")
  (SETF (AREF XCHR 121) "y")
  (SETF (AREF XCHR 122) "z")
  (SETF (AREF XCHR 123) "{")
  (SETF (AREF XCHR 124) "|")
  (SETF (AREF XCHR 125) "}")
  (SETF (AREF XCHR 126) "~")
  (FOR (I 0 TO 31) (SETF (AREF XCHR I) " "))
  (FOR (I 127 TO 255) (SETF (AREF XCHR I) " "))
  (FOR (I 0 TO 255) (SETF (AREF XORD (CHR I)) 127))
  (FOR (I 128 TO 255) (SETF (AREF XORD (AREF XCHR I)) I))
  (FOR (I 0 TO 126) (SETF (AREF XORD (AREF XCHR I)) I))
  (SETF (AREF XORD (CHR 9)) 32)
  (SETF (AREF XORD (CHR 12)) 32)
  (SETF (AREF XCHR 9) (CHR 32))
  (SETF (AREF XCHR 12) (CHR 32))
  (SETF INTERACTION 3)
  (SETF DELETIONS-ALLOWED TRUE)
  (SETF SET-BOX-ALLOWED TRUE)
  (SETF ERROR-COUNT 0)
  (SETF HELP-PTR 0)
  (SETF USE-ERR-HELP FALSE)
  (SETF INTERRUPT 0)
  (SETF OK-TO-INTERRUPT TRUE)
  (SETF NEST-PTR 0)
  (SETF MAX-NEST-STACK 0)
  (SETF (SLOT CUR-LIST MODE-FIELD) 1)
  (SETF (SLOT CUR-LIST HEAD-FIELD) 59999)
  (SETF (SLOT CUR-LIST TAIL-FIELD) 59999)
  (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000))
  (SETF (SLOT CUR-LIST ML-FIELD) 0)
  (SETF (SLOT CUR-LIST PG-FIELD) 0)
  (SETF SHOWN-MODE 0)
  (SETF PAGE-CONTENTS 0)
  (SETF PAGE-TAIL 59998)
  (SETF (SLOT (SLOT (AREF MEM 59998) HH) RH) 0)
  (SETF LAST-GLUE 65535)
  (SETF LAST-PENALTY 0)
  (SETF LAST-KERN 0)
  (SETF (AREF PAGE-SO-FAR 7) 0)
  (SETF PAGE-MAX-DEPTH 0)
  (FOR (K 9163 TO 10006) (SETF (AREF XEQ-LEVEL K) 1))
  (SETF NO-NEW-CONTROL-SEQUENCE TRUE)
  (SETF (SLOT (AREF HASH 514) LH) 0)
  (SETF (SLOT (AREF HASH 514) RH) 0)
  (FOR (K 515 TO 6780) (SETF (AREF HASH K) (AREF HASH 514)))
  (SETF SAVE-PTR 0)
  (SETF CUR-LEVEL 1)
  (SETF CUR-GROUP 0)
  (SETF CUR-BOUNDARY 0)
  (SETF MAX-SAVE-STACK 0)
  (SETF MAG-SET 0)
  (SETF (AREF CUR-MARK 0) 0)
  (SETF (AREF CUR-MARK 1) 0)
  (SETF (AREF CUR-MARK 2) 0)
  (SETF (AREF CUR-MARK 3) 0)
  (SETF (AREF CUR-MARK 4) 0)
  (SETF CUR-VAL 0)
  (SETF CUR-VAL-LEVEL 0)
  (SETF RADIX 0)
  (SETF CUR-ORDER 0)
  (FOR (K 0 TO 16) (SETF (AREF READ-OPEN K) 2))
  (SETF COND-PTR 0)
  (SETF IF-LIMIT 0)
  (SETF CUR-IF 0)
  (SETF IF-LINE 0)
  (SETF TEX-FORMAT-DEFAULT "TeXformats:plain.fmt")
  (FOR (K 0 TO FONT-MAX) (SETF (AREF FONT-USED K) FALSE))
  (SETF (SLOT NULL-CHARACTER B0) 0)
  (SETF (SLOT NULL-CHARACTER B1) 0)
  (SETF (SLOT NULL-CHARACTER B2) 0)
  (SETF (SLOT NULL-CHARACTER B3) 0)
  (SETF TOTAL-PAGES 0)
  (SETF MAX-V 0)
  (SETF MAX-H 0)
  (SETF MAX-PUSH 0)
  (SETF LAST-BOP (- 1))
  (SETF DOING-LEADERS FALSE)
  (SETF DEAD-CYCLES 0)
  (SETF CUR-S (- 1))
  (SETF HALF-BUF (DIV DVI-BUF-SIZE 2))
  (SETF DVI-LIMIT DVI-BUF-SIZE)
  (SETF DVI-PTR 0)
  (SETF DVI-OFFSET 0)
  (SETF DVI-GONE 0)
  (SETF DOWN-PTR 0)
  (SETF RIGHT-PTR 0)
  (SETF ADJUST-TAIL 0)
  (SETF LAST-BADNESS 0)
  (SETF PACK-BEGIN-LINE 0)
  (SETF (SLOT EMPTY-FIELD RH) 0)
  (SETF (SLOT EMPTY-FIELD LH) 0)
  (SETF (SLOT NULL-DELIMITER B0) 0)
  (SETF (SLOT NULL-DELIMITER B1) 0)
  (SETF (SLOT NULL-DELIMITER B2) 0)
  (SETF (SLOT NULL-DELIMITER B3) 0)
  (SETF ALIGN-PTR 0)
  (SETF CUR-ALIGN 0)
  (SETF CUR-SPAN 0)
  (SETF CUR-LOOP 0)
  (SETF CUR-HEAD 0)
  (SETF CUR-TAIL 0)
  (FOR (Z 0 TO 307) (SETF (AREF HYPH-WORD Z) 0) (SETF (AREF HYPH-LIST Z) 0))
  (SETF HYPH-COUNT 0)
  (SETF OUTPUT-ACTIVE FALSE)
  (SETF INSERT-PENALTIES 0)
  (SETF LIGATURE-PRESENT FALSE)
  (SETF CANCEL-BOUNDARY FALSE)
  (SETF LFT-HIT FALSE)
  (SETF RT-HIT FALSE)
  (SETF INS-DISC FALSE)
  (SETF AFTER-TOKEN 0)
  (SETF LONG-HELP-SEEN FALSE)
  (SETF FORMAT-IDENT 0)
  (FOR (K 0 TO 17) (SETF (AREF WRITE-OPEN K) FALSE))
  (FOR (K 1 TO 19) (SETF (SLOT (AREF MEM K) INT) 0))
  (SETF K 0)
  (WHILE (<= K 19)
    (SETF (SLOT (SLOT (AREF MEM K) HH) RH) 1)
    (SETF (SLOT (SLOT (AREF MEM K) HH) B0) 0)
    (SETF (SLOT (SLOT (AREF MEM K) HH) B1) 0)
    (INCF K 4))
  (SETF (SLOT (AREF MEM 6) INT) 65536)
  (SETF (SLOT (SLOT (AREF MEM 4) HH) B0) 1)
  (SETF (SLOT (AREF MEM 10) INT) 65536)
  (SETF (SLOT (SLOT (AREF MEM 8) HH) B0) 2)
  (SETF (SLOT (AREF MEM 14) INT) 65536)
  (SETF (SLOT (SLOT (AREF MEM 12) HH) B0) 1)
  (SETF (SLOT (AREF MEM 15) INT) 65536)
  (SETF (SLOT (SLOT (AREF MEM 12) HH) B1) 1)
  (SETF (SLOT (AREF MEM 18) INT) (- 65536))
  (SETF (SLOT (SLOT (AREF MEM 16) HH) B0) 1)
  (SETF ROVER 20)
  (SETF (SLOT (SLOT (AREF MEM ROVER) HH) RH) 65535)
  (SETF (SLOT (SLOT (AREF MEM ROVER) HH) LH) 1000)
  (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH) ROVER)
  (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) RH) ROVER)
  (SETF LO-MEM-MAX (+ ROVER 1000))
  (SETF (SLOT (SLOT (AREF MEM LO-MEM-MAX) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF MEM LO-MEM-MAX) HH) LH) 0)
  (FOR (K 59987 TO 60000) (SETF (AREF MEM K) (AREF MEM LO-MEM-MAX)))
  (SETF (SLOT (SLOT (AREF MEM 59990) HH) LH) 10614)
  (SETF (SLOT (SLOT (AREF MEM 59991) HH) RH) 256)
  (SETF (SLOT (SLOT (AREF MEM 59991) HH) LH) 0)
  (SETF (SLOT (SLOT (AREF MEM 59993) HH) B0) 1)
  (SETF (SLOT (SLOT (AREF MEM 59994) HH) LH) 65535)
  (SETF (SLOT (SLOT (AREF MEM 59993) HH) B1) 0)
  (SETF (SLOT (SLOT (AREF MEM 60000) HH) B1) 255)
  (SETF (SLOT (SLOT (AREF MEM 60000) HH) B0) 1)
  (SETF (SLOT (SLOT (AREF MEM 60000) HH) RH) 60000)
  (SETF (SLOT (SLOT (AREF MEM 59998) HH) B0) 10)
  (SETF (SLOT (SLOT (AREF MEM 59998) HH) B1) 0)
  (SETF AVAIL 0)
  (SETF MEM-END 60000)
  (SETF HI-MEM-MIN 59987)
  (SETF VAR-USED 20)
  (SETF DYN-USED 14)
  (SETF (SLOT (SLOT (AREF EQTB 6781) HH) B0) 101)
  (SETF (SLOT (SLOT (AREF EQTB 6781) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 6781) HH) B1) 0)
  (FOR (K 1 TO 6780) (SETF (AREF EQTB K) (AREF EQTB 6781)))
  (SETF (SLOT (SLOT (AREF EQTB 6782) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 6782) HH) B1) 1)
  (SETF (SLOT (SLOT (AREF EQTB 6782) HH) B0) 117)
  (FOR (K 6783 TO 7311) (SETF (AREF EQTB K) (AREF EQTB 6782)))
  (SETF (SLOT (SLOT (AREF MEM 0) HH) RH) (+ (SLOT (SLOT (AREF MEM 0) HH) RH) 530))
  (SETF (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 7312) HH) B0) 118)
  (SETF (SLOT (SLOT (AREF EQTB 7312) HH) B1) 1)
  (FOR (K 7313 TO 7577) (SETF (AREF EQTB K) (AREF EQTB 6781)))
  (SETF (SLOT (SLOT (AREF EQTB 7578) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 7578) HH) B0) 119)
  (SETF (SLOT (SLOT (AREF EQTB 7578) HH) B1) 1)
  (FOR (K 7579 TO 7833) (SETF (AREF EQTB K) (AREF EQTB 7578)))
  (SETF (SLOT (SLOT (AREF EQTB 7834) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 7834) HH) B0) 120)
  (SETF (SLOT (SLOT (AREF EQTB 7834) HH) B1) 1)
  (FOR (K 7835 TO 7882) (SETF (AREF EQTB K) (AREF EQTB 7834)))
  (SETF (SLOT (SLOT (AREF EQTB 7883) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 7883) HH) B0) 120)
  (SETF (SLOT (SLOT (AREF EQTB 7883) HH) B1) 1)
  (FOR (K 7884 TO 9162) (SETF (AREF EQTB K) (AREF EQTB 7883)))
  (FOR (K 0 TO 255)
    (SETF (SLOT (SLOT (AREF EQTB (+ 7883 K)) HH) RH) 12)
    (SETF (SLOT (SLOT (AREF EQTB (+ 8907 K)) HH) RH) (+ K 0))
    (SETF (SLOT (SLOT (AREF EQTB (+ 8651 K)) HH) RH) 1000))
  (SETF (SLOT (SLOT (AREF EQTB 7896) HH) RH) 5)
  (SETF (SLOT (SLOT (AREF EQTB 7915) HH) RH) 10)
  (SETF (SLOT (SLOT (AREF EQTB 7975) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF EQTB 7920) HH) RH) 14)
  (SETF (SLOT (SLOT (AREF EQTB 8010) HH) RH) 15)
  (SETF (SLOT (SLOT (AREF EQTB 7883) HH) RH) 9)
  (FOR (K 48 TO 57) (SETF (SLOT (SLOT (AREF EQTB (+ 8907 K)) HH) RH) (+ K 28672)))
  (FOR (K 65 TO 90)
    (SETF (SLOT (SLOT (AREF EQTB (+ 7883 K)) HH) RH) 11)
    (SETF (SLOT (SLOT (AREF EQTB (+ (+ 7883 K) 32)) HH) RH) 11)
    (SETF (SLOT (SLOT (AREF EQTB (+ 8907 K)) HH) RH) (+ K 28928))
    (SETF (SLOT (SLOT (AREF EQTB (+ (+ 8907 K) 32)) HH) RH) (+ K 28960))
    (SETF (SLOT (SLOT (AREF EQTB (+ 8139 K)) HH) RH) (+ K 32))
    (SETF (SLOT (SLOT (AREF EQTB (+ (+ 8139 K) 32)) HH) RH) (+ K 32))
    (SETF (SLOT (SLOT (AREF EQTB (+ 8395 K)) HH) RH) K)
    (SETF (SLOT (SLOT (AREF EQTB (+ (+ 8395 K) 32)) HH) RH) K)
    (SETF (SLOT (SLOT (AREF EQTB (+ 8651 K)) HH) RH) 999))
  (FOR (K 9163 TO 9473) (SETF (SLOT (AREF EQTB K) INT) 0))
  (SETF (SLOT (AREF EQTB 9180) INT) 1000)
  (SETF (SLOT (AREF EQTB 9164) INT) 10000)
  (SETF (SLOT (AREF EQTB 9204) INT) 1)
  (SETF (SLOT (AREF EQTB 9203) INT) 25)
  (SETF (SLOT (AREF EQTB 9208) INT) 92)
  (SETF (SLOT (AREF EQTB 9211) INT) 13)
  (FOR (K 0 TO 255) (SETF (SLOT (AREF EQTB (+ 9474 K)) INT) (- 1)))
  (SETF (SLOT (AREF EQTB 9520) INT) 0)
  (FOR (K 9730 TO 10006) (SETF (SLOT (AREF EQTB K) INT) 0))
  (SETF HASH-USED 6514)
  (SETF CS-COUNT 0)
  (SETF (SLOT (SLOT (AREF EQTB 6523) HH) B0) 116)
  (SETF (SLOT (AREF HASH 6523) RH) 502)
  (SETF FONT-PTR 0)
  (SETF FMEM-PTR 7)
  (SETF (AREF FONT-NAME 0) 801)
  (SETF (AREF FONT-AREA 0) 338)
  (SETF (AREF HYPHEN-CHAR 0) 45)
  (SETF (AREF SKEW-CHAR 0) (- 1))
  (SETF (AREF BCHAR-LABEL 0) 0)
  (SETF (AREF FONT-BCHAR 0) 256)
  (SETF (AREF FONT-FALSE-BCHAR 0) 256)
  (SETF (AREF FONT-BC 0) 1)
  (SETF (AREF FONT-EC 0) 0)
  (SETF (AREF FONT-SIZE 0) 0)
  (SETF (AREF FONT-DSIZE 0) 0)
  (SETF (AREF CHAR-BASE 0) 0)
  (SETF (AREF WIDTH-BASE 0) 0)
  (SETF (AREF HEIGHT-BASE 0) 0)
  (SETF (AREF DEPTH-BASE 0) 0)
  (SETF (AREF ITALIC-BASE 0) 0)
  (SETF (AREF LIG-KERN-BASE 0) 0)
  (SETF (AREF KERN-BASE 0) 0)
  (SETF (AREF EXTEN-BASE 0) 0)
  (SETF (AREF FONT-GLUE 0) 0)
  (SETF (AREF FONT-PARAMS 0) 7)
  (SETF (AREF PARAM-BASE 0) (- 1))
  (FOR (K 0 TO 6) (SETF (SLOT (AREF FONT-INFO K) INT) 0))
  (FOR (K (- TRIE-OP-SIZE) TO TRIE-OP-SIZE) (SETF (AREF TRIE-OP-HASH K) 0))
  (FOR (K 0 TO 255) (SETF (AREF TRIE-USED K) 0))
  (SETF TRIE-OP-PTR 0)
  (SETF TRIE-NOT-READY TRUE)
  (SETF (AREF TRIE-L 0) 0)
  (SETF (AREF TRIE-C 0) 0)
  (SETF TRIE-PTR 0)
  (SETF (SLOT (AREF HASH 6514) RH) 1190)
  (SETF FORMAT-IDENT 1257)
  (SETF (SLOT (AREF HASH 6522) RH) 1296)
  (SETF (SLOT (SLOT (AREF EQTB 6522) HH) B1) 1)
  (SETF (SLOT (SLOT (AREF EQTB 6522) HH) B0) 113)
  (SETF (SLOT (SLOT (AREF EQTB 6522) HH) RH) 0))

(PROCEDURE PRINT-LN ()
  (CASE SELECTOR
    ((19) (WRITELN TERM-OUT) (WRITELN LOG-FILE) (SETF TERM-OFFSET 0) (SETF FILE-OFFSET 0))
    ((18) (WRITELN LOG-FILE) (SETF FILE-OFFSET 0))
    ((17) (WRITELN TERM-OUT) (SETF TERM-OFFSET 0))
    ((16 20 21))
    (ELSE (WRITELN (AREF WRITE-FILE SELECTOR)))))

(PROCEDURE PRINT-CHAR ((S ASCII-CODE))
  (LABEL $L.10)
  (WHEN (= S (SLOT (AREF EQTB 9212) INT)) (WHEN (< SELECTOR 20) (PRINT-LN) (GOTO $L.10)))
  (CASE SELECTOR
    ((19) (WRITE TERM-OUT (AREF XCHR S)) (WRITE LOG-FILE (AREF XCHR S)) (INCF TERM-OFFSET 1)
     (INCF FILE-OFFSET 1)
     (WHEN (= TERM-OFFSET MAX-PRINT-LINE) (WRITELN TERM-OUT) (SETF TERM-OFFSET 0))
     (WHEN (= FILE-OFFSET MAX-PRINT-LINE) (WRITELN LOG-FILE) (SETF FILE-OFFSET 0)))
    ((18) (WRITE LOG-FILE (AREF XCHR S)) (INCF FILE-OFFSET 1)
     (WHEN (= FILE-OFFSET MAX-PRINT-LINE) (PRINT-LN)))
    ((17) (WRITE TERM-OUT (AREF XCHR S)) (INCF TERM-OFFSET 1)
     (WHEN (= TERM-OFFSET MAX-PRINT-LINE) (PRINT-LN)))
    ((16))
    ((20) (WHEN (< TALLY TRICK-COUNT) (SETF (AREF TRICK-BUF (MOD TALLY ERROR-LINE)) S)))
    ((21) (WHEN (< POOL-PTR POOL-SIZE) (SETF (AREF STR-POOL POOL-PTR) S) (INCF POOL-PTR 1)))
    (ELSE (WRITE (AREF WRITE-FILE SELECTOR) (AREF XCHR S))))
  (INCF TALLY 1)
  $L.10)

(PROCEDURE PRINT ((S INTEGER))
  (LABEL $L.10)
  (VAR J POOL-POINTER)
  (VAR NL INTEGER)
  (COND ((>= S STR-PTR) (SETF S 259))
        ((< S 256)
         (COND ((< S 0) (SETF S 259))
               (TRUE
                (WHEN (> SELECTOR 20) (PRINT-CHAR S) (GOTO $L.10))
                (WHEN (= S (SLOT (AREF EQTB 9212) INT))
                  (WHEN (< SELECTOR 20) (PRINT-LN) (GOTO $L.10)))
                (SETF NL (SLOT (AREF EQTB 9212) INT))
                (SETF (SLOT (AREF EQTB 9212) INT) (- 1))
                (SETF J (AREF STR-START S))
                (WHILE (< J (AREF STR-START (+ S 1)))
                  (PRINT-CHAR (AREF STR-POOL J))
                  (INCF J 1))
                (SETF (SLOT (AREF EQTB 9212) INT) NL)
                (GOTO $L.10)))))
  (SETF J (AREF STR-START S))
  (WHILE (< J (AREF STR-START (+ S 1))) (PRINT-CHAR (AREF STR-POOL J)) (INCF J 1))
  $L.10)

(PROCEDURE SLOW-PRINT ((S INTEGER))
  (VAR J POOL-POINTER)
  (COND ((OR (>= S STR-PTR) (< S 256)) (PRINT S))
        (TRUE
         (SETF J (AREF STR-START S))
         (WHILE (< J (AREF STR-START (+ S 1))) (PRINT (AREF STR-POOL J)) (INCF J 1)))))

(PROCEDURE PRINT-NL ((S STR-NUMBER))
  (WHEN (OR (AND (> TERM-OFFSET 0) (ODD SELECTOR)) (AND (> FILE-OFFSET 0) (>= SELECTOR 18)))
    (PRINT-LN))
  (PRINT S))

(PROCEDURE PRINT-ESC ((S STR-NUMBER))
  (VAR C INTEGER)
  (SETF C (SLOT (AREF EQTB 9208) INT))
  (WHEN (>= C 0) (WHEN (< C 256) (PRINT C)))
  (SLOW-PRINT S))

(PROCEDURE PRINT-THE-DIGS ((K EIGHT-BITS))
  (WHILE (> K 0)
    (DECF K 1)
    (COND ((< (AREF DIG K) 10) (PRINT-CHAR (+ 48 (AREF DIG K))))
          (TRUE (PRINT-CHAR (+ 55 (AREF DIG K)))))))

(PROCEDURE PRINT-INT ((N INTEGER))
  (VAR K (RANGE 0 23))
  (VAR M INTEGER)
  (SETF K 0)
  (WHEN (< N 0)
    (PRINT-CHAR 45)
    (COND ((> N (- 100000000)) (SETF N (- N)))
          (TRUE
           (SETF M (- (- 1) N))
           (SETF N (DIV M 10))
           (SETF M (+ (MOD M 10) 1))
           (SETF K 1)
           (COND ((< M 10) (SETF (AREF DIG 0) M)) (TRUE (SETF (AREF DIG 0) 0) (INCF N 1))))))
  (REPEAT (SETF (AREF DIG K) (MOD N 10)) (SETF N (DIV N 10)) (INCF K 1) (UNTIL (= N 0)))
  (PRINT-THE-DIGS K))

(PROCEDURE PRINT-CS ((P INTEGER))
  (COND ((< P 514)
         (COND ((>= P 257)
                (COND ((= P 513) (PRINT-ESC 504) (PRINT-ESC 505) (PRINT-CHAR 32))
                      (TRUE
                       (PRINT-ESC (- P 257))
                       (WHEN (= (SLOT (SLOT (AREF EQTB (- (+ 7883 P) 257)) HH) RH) 11)
                         (PRINT-CHAR 32)))))
               ((< P 1) (PRINT-ESC 506))
               (TRUE (PRINT (- P 1)))))
        ((>= P 6781) (PRINT-ESC 506))
        ((OR (< (SLOT (AREF HASH P) RH) 0) (>= (SLOT (AREF HASH P) RH) STR-PTR))
         (PRINT-ESC 507))
        (TRUE (PRINT-ESC (SLOT (AREF HASH P) RH)) (PRINT-CHAR 32))))

(PROCEDURE SPRINT-CS ((P HALFWORD))
  (COND ((< P 514)
         (COND ((< P 257) (PRINT (- P 1)))
               ((< P 513) (PRINT-ESC (- P 257)))
               (TRUE (PRINT-ESC 504) (PRINT-ESC 505))))
        (TRUE (PRINT-ESC (SLOT (AREF HASH P) RH)))))

(PROCEDURE PRINT-FILE-NAME ((N INTEGER) (A INTEGER) (E INTEGER))
  (SLOW-PRINT A)
  (SLOW-PRINT N)
  (SLOW-PRINT E))

(PROCEDURE PRINT-SIZE ((S INTEGER))
  (COND ((= S 0) (PRINT-ESC 412)) ((= S 16) (PRINT-ESC 413)) (TRUE (PRINT-ESC 414))))

(PROCEDURE PRINT-WRITE-WHATSIT ((S STR-NUMBER) (P HALFWORD))
  (PRINT-ESC S)
  (COND ((< (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 16)
         (PRINT-INT (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)))
        ((= (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 16) (PRINT-CHAR 42))
        (TRUE (PRINT-CHAR 45))))

(PROCEDURE NORMALIZE-SELECTOR () :FORWARD)

(PROCEDURE GET-TOKEN () :FORWARD)

(PROCEDURE TERM-INPUT () :FORWARD)

(PROCEDURE SHOW-CONTEXT () :FORWARD)

(PROCEDURE BEGIN-FILE-READING () :FORWARD)

(PROCEDURE OPEN-LOG-FILE () :FORWARD)

(PROCEDURE CLOSE-FILES-AND-TERMINATE () :FORWARD)

(PROCEDURE CLEAR-FOR-ERROR-PROMPT () :FORWARD)

(PROCEDURE GIVE-ERR-HELP () :FORWARD)

(PROCEDURE JUMP-OUT () (GOTO $L.9998))

(PROCEDURE ERROR ()
  (LABEL $L.22)
  (LABEL $L.10)
  (VAR C ASCII-CODE)
  (VAR S1 INTEGER)
  (VAR S2 INTEGER)
  (VAR S3 INTEGER)
  (VAR S4 INTEGER)
  (WHEN (< HISTORY 2) (SETF HISTORY 2))
  (PRINT-CHAR 46)
  (SHOW-CONTEXT)
  (WHEN (= INTERACTION 3)
    (WHILE TRUE
      $L.22
      (WHEN (/= INTERACTION 3) (GOTO $L.10))
      (CLEAR-FOR-ERROR-PROMPT)
      (PRINT 264)
      (TERM-INPUT)
      (WHEN (= LAST FIRST) (GOTO $L.10))
      (SETF C (AREF BUFFER FIRST))
      (WHEN (>= C 97) (DECF C 32))
      (CASE C
        ((48 49 50 51 52 53 54 55 56 57)
         (WHEN DELETIONS-ALLOWED
           (SETF S1 CUR-TOK)
           (SETF S2 CUR-CMD)
           (SETF S3 CUR-CHR)
           (SETF S4 ALIGN-STATE)
           (SETF ALIGN-STATE 1000000)
           (SETF OK-TO-INTERRUPT FALSE)
           (COND ((AND (AND (> LAST (+ FIRST 1)) (>= (AREF BUFFER (+ FIRST 1)) 48))
                       (<= (AREF BUFFER (+ FIRST 1)) 57))
                  (SETF C (- (+ (* C 10) (AREF BUFFER (+ FIRST 1))) (* 48 11))))
                 (TRUE (DECF C 48)))
           (WHILE (> C 0) (GET-TOKEN) (DECF C 1))
           (SETF CUR-TOK S1)
           (SETF CUR-CMD S2)
           (SETF CUR-CHR S3)
           (SETF ALIGN-STATE S4)
           (SETF OK-TO-INTERRUPT TRUE)
           (SETF HELP-PTR 2)
           (SETF (AREF HELP-LINE 1) 279)
           (SETF (AREF HELP-LINE 0) 280)
           (SHOW-CONTEXT)
           (GOTO $L.22)))
        ((69)
         (WHEN (> BASE-PTR 0)
           (WHEN (>= (SLOT (AREF INPUT-STACK BASE-PTR) NAME-FIELD) 256)
             (PRINT-NL 265)
             (SLOW-PRINT (SLOT (AREF INPUT-STACK BASE-PTR) NAME-FIELD))
             (PRINT 266)
             (PRINT-INT LINE)
             (SETF INTERACTION 2)
             (JUMP-OUT))))
        ((72)
         (COND (USE-ERR-HELP (GIVE-ERR-HELP) (SETF USE-ERR-HELP FALSE))
               (TRUE
                (WHEN (= HELP-PTR 0)
                  (SETF HELP-PTR 2)
                  (SETF (AREF HELP-LINE 1) 281)
                  (SETF (AREF HELP-LINE 0) 282))
                (REPEAT (DECF HELP-PTR 1)
                        (PRINT (AREF HELP-LINE HELP-PTR))
                        (PRINT-LN)
                        (UNTIL (= HELP-PTR 0)))))
         (SETF HELP-PTR 4) (SETF (AREF HELP-LINE 3) 283) (SETF (AREF HELP-LINE 2) 282)
         (SETF (AREF HELP-LINE 1) 284) (SETF (AREF HELP-LINE 0) 285) (GOTO $L.22))
        ((73) (BEGIN-FILE-READING)
         (COND ((> LAST (+ FIRST 1))
                (SETF (SLOT CUR-INPUT LOC-FIELD) (+ FIRST 1))
                (SETF (AREF BUFFER FIRST) 32))
               (TRUE (PRINT 278) (TERM-INPUT) (SETF (SLOT CUR-INPUT LOC-FIELD) FIRST)))
         (SETF FIRST LAST) (SETF (SLOT CUR-INPUT LIMIT-FIELD) (- LAST 1)) (GOTO $L.10))
        ((81 82 83) (SETF ERROR-COUNT 0) (SETF INTERACTION (- (+ 0 C) 81)) (PRINT 273)
         (CASE C
           ((81) (PRINT-ESC 274) (DECF SELECTOR 1))
           ((82) (PRINT-ESC 275))
           ((83) (PRINT-ESC 276)))
         (PRINT 277) (PRINT-LN) (BREAK TERM-OUT) (GOTO $L.10))
        ((88) (SETF INTERACTION 2) (JUMP-OUT))
        (ELSE))
      (PRINT 267)
      (PRINT-NL 268)
      (PRINT-NL 269)
      (WHEN (> BASE-PTR 0)
        (WHEN (>= (SLOT (AREF INPUT-STACK BASE-PTR) NAME-FIELD) 256) (PRINT 270)))
      (WHEN DELETIONS-ALLOWED (PRINT-NL 271))
      (PRINT-NL 272)))
  (INCF ERROR-COUNT 1)
  (WHEN (= ERROR-COUNT 100) (PRINT-NL 263) (SETF HISTORY 3) (JUMP-OUT))
  (WHEN (> INTERACTION 0) (DECF SELECTOR 1))
  (COND (USE-ERR-HELP (PRINT-LN) (GIVE-ERR-HELP))
        (TRUE (WHILE (> HELP-PTR 0) (DECF HELP-PTR 1) (PRINT-NL (AREF HELP-LINE HELP-PTR)))))
  (PRINT-LN)
  (WHEN (> INTERACTION 0) (INCF SELECTOR 1))
  (PRINT-LN)
  $L.10)

(PROCEDURE FATAL-ERROR ((S STR-NUMBER))
  (NORMALIZE-SELECTOR)
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 287)
  (SETF HELP-PTR 1)
  (SETF (AREF HELP-LINE 0) S)
  (WHEN (= INTERACTION 3) (SETF INTERACTION 2))
  (WHEN LOG-OPENED (ERROR))
  (SETF HISTORY 3)
  (JUMP-OUT))

(PROCEDURE OVERFLOW ((S STR-NUMBER) (N INTEGER))
  (NORMALIZE-SELECTOR)
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 288)
  (PRINT S)
  (PRINT-CHAR 61)
  (PRINT-INT N)
  (PRINT-CHAR 93)
  (SETF HELP-PTR 2)
  (SETF (AREF HELP-LINE 1) 289)
  (SETF (AREF HELP-LINE 0) 290)
  (WHEN (= INTERACTION 3) (SETF INTERACTION 2))
  (WHEN LOG-OPENED (ERROR))
  (SETF HISTORY 3)
  (JUMP-OUT))

(PROCEDURE CONFUSION ((S STR-NUMBER))
  (NORMALIZE-SELECTOR)
  (COND ((< HISTORY 2)
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 291)
         (PRINT S)
         (PRINT-CHAR 41)
         (SETF HELP-PTR 1)
         (SETF (AREF HELP-LINE 0) 292))
        (TRUE
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 293)
         (SETF HELP-PTR 2)
         (SETF (AREF HELP-LINE 1) 294)
         (SETF (AREF HELP-LINE 0) 295)))
  (WHEN (= INTERACTION 3) (SETF INTERACTION 2))
  (WHEN LOG-OPENED (ERROR))
  (SETF HISTORY 3)
  (JUMP-OUT))

(FUNCTION (A-OPEN-IN BOOLEAN) ((F (VAR ALPHA-FILE)))
  (RESET F NAME-OF-FILE "/O")
  (SETF A-OPEN-IN (= (ERSTAT F) 0)))

(FUNCTION (A-OPEN-OUT BOOLEAN) ((F (VAR ALPHA-FILE)))
  (REWRITE F NAME-OF-FILE "/O")
  (SETF A-OPEN-OUT (= (ERSTAT F) 0)))

(FUNCTION (B-OPEN-IN BOOLEAN) ((F (VAR BYTE-FILE)))
  (RESET F NAME-OF-FILE "/O")
  (SETF B-OPEN-IN (= (ERSTAT F) 0)))

(FUNCTION (B-OPEN-OUT BOOLEAN) ((F (VAR BYTE-FILE)))
  (REWRITE F NAME-OF-FILE "/O")
  (SETF B-OPEN-OUT (= (ERSTAT F) 0)))

(FUNCTION (W-OPEN-IN BOOLEAN) ((F (VAR WORD-FILE)))
  (RESET F NAME-OF-FILE "/O")
  (SETF W-OPEN-IN (= (ERSTAT F) 0)))

(FUNCTION (W-OPEN-OUT BOOLEAN) ((F (VAR WORD-FILE)))
  (REWRITE F NAME-OF-FILE "/O")
  (SETF W-OPEN-OUT (= (ERSTAT F) 0)))

(PROCEDURE A-CLOSE ((F (VAR ALPHA-FILE))) (CLOSE F))

(PROCEDURE B-CLOSE ((F (VAR BYTE-FILE))) (CLOSE F))

(PROCEDURE W-CLOSE ((F (VAR WORD-FILE))) (CLOSE F))

(FUNCTION (INPUT-LN BOOLEAN) ((F (VAR ALPHA-FILE)) (BYPASS-EOLN BOOLEAN))
  (VAR LAST-NONBLANK (RANGE 0 BUF-SIZE))
  (WHEN BYPASS-EOLN (UNLESS (EOF F) (GET F)))
  (SETF LAST FIRST)
  (COND ((EOF F) (SETF INPUT-LN FALSE))
        (TRUE
         (SETF LAST-NONBLANK FIRST)
         (WHILE (NOT (EOLN F))
           (WHEN (>= LAST MAX-BUF-STACK)
             (SETF MAX-BUF-STACK (+ LAST 1))
             (WHEN (= MAX-BUF-STACK BUF-SIZE)
               (COND ((= FORMAT-IDENT 0)
                      (WRITELN TERM-OUT "Buffer size exceeded!")
                      (GOTO $L.9999))
                     (TRUE
                      (SETF (SLOT CUR-INPUT LOC-FIELD) FIRST)
                      (SETF (SLOT CUR-INPUT LIMIT-FIELD) (- LAST 1))
                      (OVERFLOW 256 BUF-SIZE)))))
           (SETF (AREF BUFFER LAST) (AREF XORD (AREF F)))
           (GET F)
           (INCF LAST 1)
           (WHEN (/= (AREF BUFFER (- LAST 1)) 32) (SETF LAST-NONBLANK LAST)))
         (SETF LAST LAST-NONBLANK)
         (SETF INPUT-LN TRUE))))

(FUNCTION (INIT-TERMINAL BOOLEAN) ()
  (LABEL $L.10)
  (RESET TERM-IN "TTY:" "/O/I")
  (WHILE TRUE
    (WRITE TERM-OUT "**")
    (BREAK TERM-OUT)
    (UNLESS (INPUT-LN TERM-IN TRUE)
      (WRITELN TERM-OUT)
      (WRITE TERM-OUT "! End of file on the terminal... why?")
      (SETF INIT-TERMINAL FALSE)
      (GOTO $L.10))
    (SETF (SLOT CUR-INPUT LOC-FIELD) FIRST)
    (WHILE (AND (< (SLOT CUR-INPUT LOC-FIELD) LAST)
                (= (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)) 32))
      (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LOC-FIELD) 1)))
    (WHEN (< (SLOT CUR-INPUT LOC-FIELD) LAST) (SETF INIT-TERMINAL TRUE) (GOTO $L.10))
    (WRITELN TERM-OUT "Please type the name of your input file."))
  $L.10)

(FUNCTION (MAKE-STRING STR-NUMBER) ()
  (WHEN (= STR-PTR MAX-STRINGS) (OVERFLOW 258 (- MAX-STRINGS INIT-STR-PTR)))
  (INCF STR-PTR 1)
  (SETF (AREF STR-START STR-PTR) POOL-PTR)
  (SETF MAKE-STRING (- STR-PTR 1)))

(FUNCTION (STR-EQ-BUF BOOLEAN) ((S STR-NUMBER) (K INTEGER))
  (LABEL $L.45)
  (VAR J POOL-POINTER)
  (VAR RESULT BOOLEAN)
  (SETF J (AREF STR-START S))
  (WHILE (< J (AREF STR-START (+ S 1)))
    (WHEN (/= (AREF STR-POOL J) (AREF BUFFER K)) (SETF RESULT FALSE) (GOTO $L.45))
    (INCF J 1)
    (INCF K 1))
  (SETF RESULT TRUE)
  $L.45
  (SETF STR-EQ-BUF RESULT))

(FUNCTION (STR-EQ-STR BOOLEAN) ((S STR-NUMBER) (T STR-NUMBER))
  (LABEL $L.45)
  (VAR J POOL-POINTER)
  (VAR K POOL-POINTER)
  (VAR RESULT BOOLEAN)
  (SETF RESULT FALSE)
  (WHEN (/= (- (AREF STR-START (+ S 1)) (AREF STR-START S))
            (- (AREF STR-START (+ T 1)) (AREF STR-START T)))
    (GOTO $L.45))
  (SETF J (AREF STR-START S))
  (SETF K (AREF STR-START T))
  (WHILE (< J (AREF STR-START (+ S 1)))
    (WHEN (/= (AREF STR-POOL J) (AREF STR-POOL K)) (GOTO $L.45))
    (INCF J 1)
    (INCF K 1))
  (SETF RESULT TRUE)
  $L.45
  (SETF STR-EQ-STR RESULT))

(FUNCTION (GET-STRINGS-STARTED BOOLEAN) ()
  (LABEL $L.30)
  (LABEL $L.10)
  (VAR K (RANGE 0 255))
  (VAR L (RANGE 0 255))
  (VAR M CHAR)
  (VAR N CHAR)
  (VAR G STR-NUMBER)
  (VAR A INTEGER)
  (VAR C BOOLEAN)
  (SETF POOL-PTR 0)
  (SETF STR-PTR 0)
  (SETF (AREF STR-START 0) 0)
  (FOR (K 0 TO 255)
    (COND ((OR (< K 32) (> K 126))
           (SETF (AREF STR-POOL POOL-PTR) 94)
           (INCF POOL-PTR 1)
           (SETF (AREF STR-POOL POOL-PTR) 94)
           (INCF POOL-PTR 1)
           (COND ((< K 64) (SETF (AREF STR-POOL POOL-PTR) (+ K 64)) (INCF POOL-PTR 1))
                 ((< K 128) (SETF (AREF STR-POOL POOL-PTR) (- K 64)) (INCF POOL-PTR 1))
                 (TRUE
                  (SETF L (DIV K 16))
                  (COND ((< L 10) (SETF (AREF STR-POOL POOL-PTR) (+ L 48)) (INCF POOL-PTR 1))
                        (TRUE (SETF (AREF STR-POOL POOL-PTR) (+ L 87)) (INCF POOL-PTR 1)))
                  (SETF L (MOD K 16))
                  (COND ((< L 10) (SETF (AREF STR-POOL POOL-PTR) (+ L 48)) (INCF POOL-PTR 1))
                        (TRUE (SETF (AREF STR-POOL POOL-PTR) (+ L 87)) (INCF POOL-PTR 1))))))
          (TRUE (SETF (AREF STR-POOL POOL-PTR) K) (INCF POOL-PTR 1)))
    (SETF G MAKE-STRING))
  (SETF NAME-OF-FILE POOL-NAME)
  (COND ((A-OPEN-IN POOL-FILE)
         (SETF C FALSE)
         (REPEAT (WHEN (EOF POOL-FILE)
                   (WRITELN TERM-OUT "! TEX.POOL has no check sum.")
                   (A-CLOSE POOL-FILE)
                   (SETF GET-STRINGS-STARTED FALSE)
                   (GOTO $L.10))
                 (READ POOL-FILE M N)
                 (COND ((= M "*")
                        (SETF A 0)
                        (SETF K 1)
                        (WHILE TRUE
                          (WHEN (OR (< (AREF XORD N) 48) (> (AREF XORD N) 57))
                            (WRITELN TERM-OUT "! TEX.POOL check sum doesn't have nine digits.")
                            (A-CLOSE POOL-FILE)
                            (SETF GET-STRINGS-STARTED FALSE)
                            (GOTO $L.10))
                          (SETF A (- (+ (* 10 A) (AREF XORD N)) 48))
                          (WHEN (= K 9) (GOTO $L.30))
                          (INCF K 1)
                          (READ POOL-FILE N))
                        $L.30
                        (WHEN (/= A 504454778)
                          (WRITELN TERM-OUT "! TEX.POOL doesn't match; TANGLE me again.")
                          (A-CLOSE POOL-FILE)
                          (SETF GET-STRINGS-STARTED FALSE)
                          (GOTO $L.10))
                        (SETF C TRUE))
                       (TRUE
                        (WHEN (OR (OR (OR (< (AREF XORD M) 48) (> (AREF XORD M) 57))
                                      (< (AREF XORD N) 48))
                                  (> (AREF XORD N) 57))
                          (WRITELN TERM-OUT "! TEX.POOL line doesn't begin with two digits.")
                          (A-CLOSE POOL-FILE)
                          (SETF GET-STRINGS-STARTED FALSE)
                          (GOTO $L.10))
                        (SETF L (- (+ (* (AREF XORD M) 10) (AREF XORD N)) (* 48 11)))
                        (WHEN (> (+ (+ POOL-PTR L) STRING-VACANCIES) POOL-SIZE)
                          (WRITELN TERM-OUT "! You have to increase POOLSIZE.")
                          (A-CLOSE POOL-FILE)
                          (SETF GET-STRINGS-STARTED FALSE)
                          (GOTO $L.10))
                        (FOR (K 1 TO L)
                          (COND ((EOLN POOL-FILE) (SETF M " ")) (TRUE (READ POOL-FILE M)))
                          (SETF (AREF STR-POOL POOL-PTR) (AREF XORD M))
                          (INCF POOL-PTR 1))
                        (READLN POOL-FILE)
                        (SETF G MAKE-STRING)))
                 (UNTIL C))
         (A-CLOSE POOL-FILE)
         (SETF GET-STRINGS-STARTED TRUE))
        (TRUE
         (WRITELN TERM-OUT "! I can't read TEX.POOL.")
         (A-CLOSE POOL-FILE)
         (SETF GET-STRINGS-STARTED FALSE)
         (GOTO $L.10)))
  $L.10)

(PROCEDURE PRINT-TWO ((N INTEGER))
  (SETF N (MOD (ABS N) 100))
  (PRINT-CHAR (+ 48 (DIV N 10)))
  (PRINT-CHAR (+ 48 (MOD N 10))))

(PROCEDURE PRINT-HEX ((N INTEGER))
  (VAR K (RANGE 0 22))
  (SETF K 0)
  (PRINT-CHAR 34)
  (REPEAT (SETF (AREF DIG K) (MOD N 16)) (SETF N (DIV N 16)) (INCF K 1) (UNTIL (= N 0)))
  (PRINT-THE-DIGS K))

(PROCEDURE PRINT-ROMAN-INT ((N INTEGER))
  (LABEL $L.10)
  (VAR J POOL-POINTER)
  (VAR K POOL-POINTER)
  (VAR U NONNEGATIVE-INTEGER)
  (VAR V NONNEGATIVE-INTEGER)
  (SETF J (AREF STR-START 260))
  (SETF V 1000)
  (WHILE TRUE
    (WHILE (>= N V) (PRINT-CHAR (AREF STR-POOL J)) (DECF N V))
    (WHEN (<= N 0) (GOTO $L.10))
    (SETF K (+ J 2))
    (SETF U (DIV V (- (AREF STR-POOL (- K 1)) 48)))
    (WHEN (= (AREF STR-POOL (- K 1)) 50)
      (INCF K 2)
      (SETF U (DIV U (- (AREF STR-POOL (- K 1)) 48))))
    (COND ((>= (+ N U) V) (PRINT-CHAR (AREF STR-POOL K)) (INCF N U))
          (TRUE (INCF J 2) (SETF V (DIV V (- (AREF STR-POOL (- J 1)) 48))))))
  $L.10)

(PROCEDURE PRINT-CURRENT-STRING ()
  (VAR J POOL-POINTER)
  (SETF J (AREF STR-START STR-PTR))
  (WHILE (< J POOL-PTR) (PRINT-CHAR (AREF STR-POOL J)) (INCF J 1)))

(PROCEDURE TERM-INPUT ()
  (VAR K (RANGE 0 BUF-SIZE))
  (BREAK TERM-OUT)
  (UNLESS (INPUT-LN TERM-IN TRUE) (FATAL-ERROR 261))
  (SETF TERM-OFFSET 0)
  (DECF SELECTOR 1)
  (WHEN (/= LAST FIRST) (FOR (K FIRST TO (- LAST 1)) (PRINT (AREF BUFFER K))))
  (PRINT-LN)
  (INCF SELECTOR 1))

(PROCEDURE INT-ERROR ((N INTEGER)) (PRINT 286) (PRINT-INT N) (PRINT-CHAR 41) (ERROR))

(PROCEDURE NORMALIZE-SELECTOR ()
  (COND (LOG-OPENED (SETF SELECTOR 19)) (TRUE (SETF SELECTOR 17)))
  (WHEN (= JOB-NAME 0) (OPEN-LOG-FILE))
  (WHEN (= INTERACTION 0) (DECF SELECTOR 1)))

(PROCEDURE PAUSE-FOR-INSTRUCTIONS ()
  (WHEN OK-TO-INTERRUPT
    (SETF INTERACTION 3)
    (WHEN (OR (= SELECTOR 18) (= SELECTOR 16)) (INCF SELECTOR 1))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 296)
    (SETF HELP-PTR 3)
    (SETF (AREF HELP-LINE 2) 297)
    (SETF (AREF HELP-LINE 1) 298)
    (SETF (AREF HELP-LINE 0) 299)
    (SETF DELETIONS-ALLOWED FALSE)
    (ERROR)
    (SETF DELETIONS-ALLOWED TRUE)
    (SETF INTERRUPT 0)))

(FUNCTION (HALF INTEGER) ((X INTEGER))
  (COND ((ODD X) (SETF HALF (DIV (+ X 1) 2))) (TRUE (SETF HALF (DIV X 2)))))

(FUNCTION (ROUND-DECIMALS SCALED) ((K SMALL-NUMBER))
  (VAR A INTEGER)
  (SETF A 0)
  (WHILE (> K 0) (DECF K 1) (SETF A (DIV (+ A (* (AREF DIG K) 131072)) 10)))
  (SETF ROUND-DECIMALS (DIV (+ A 1) 2)))

(PROCEDURE PRINT-SCALED ((S SCALED))
  (VAR DELTA SCALED)
  (WHEN (< S 0) (PRINT-CHAR 45) (SETF S (- S)))
  (PRINT-INT (DIV S 65536))
  (PRINT-CHAR 46)
  (SETF S (+ (* 10 (MOD S 65536)) 5))
  (SETF DELTA 10)
  (REPEAT (WHEN (> DELTA 65536) (DECF S 17232))
          (PRINT-CHAR (+ 48 (DIV S 65536)))
          (SETF S (* 10 (MOD S 65536)))
          (SETF DELTA (* DELTA 10))
          (UNTIL (<= S DELTA))))

(FUNCTION (MULT-AND-ADD SCALED) ((N INTEGER) (X SCALED) (Y SCALED) (MAX-ANSWER SCALED))
  (WHEN (< N 0) (SETF X (- X)) (SETF N (- N)))
  (COND ((= N 0) (SETF MULT-AND-ADD Y))
        ((AND (<= X (DIV (- MAX-ANSWER Y) N)) (<= (- X) (DIV (+ MAX-ANSWER Y) N)))
         (SETF MULT-AND-ADD (+ (* N X) Y)))
        (TRUE (SETF ARITH-ERROR TRUE) (SETF MULT-AND-ADD 0))))

(FUNCTION (X-OVER-N SCALED) ((X SCALED) (N INTEGER))
  (VAR NEGATIVE BOOLEAN)
  (SETF NEGATIVE FALSE)
  (COND ((= N 0) (SETF ARITH-ERROR TRUE) (SETF X-OVER-N 0) (SETF REMAINDER X))
        (TRUE
         (WHEN (< N 0) (SETF X (- X)) (SETF N (- N)) (SETF NEGATIVE TRUE))
         (COND ((>= X 0) (SETF X-OVER-N (DIV X N)) (SETF REMAINDER (MOD X N)))
               (TRUE (SETF X-OVER-N (- (DIV (- X) N))) (SETF REMAINDER (- (MOD (- X) N)))))))
  (WHEN NEGATIVE (SETF REMAINDER (- REMAINDER))))

(FUNCTION (XN-OVER-D SCALED) ((X SCALED) (N INTEGER) (D INTEGER))
  (VAR POSITIVE BOOLEAN)
  (VAR T NONNEGATIVE-INTEGER)
  (VAR U NONNEGATIVE-INTEGER)
  (VAR V NONNEGATIVE-INTEGER)
  (COND ((>= X 0) (SETF POSITIVE TRUE)) (TRUE (SETF X (- X)) (SETF POSITIVE FALSE)))
  (SETF T (* (MOD X 32768) N))
  (SETF U (+ (* (DIV X 32768) N) (DIV T 32768)))
  (SETF V (+ (* (MOD U D) 32768) (MOD T 32768)))
  (COND ((>= (DIV U D) 32768) (SETF ARITH-ERROR TRUE))
        (TRUE (SETF U (+ (* 32768 (DIV U D)) (DIV V D)))))
  (COND (POSITIVE (SETF XN-OVER-D U) (SETF REMAINDER (MOD V D)))
        (TRUE (SETF XN-OVER-D (- U)) (SETF REMAINDER (- (MOD V D))))))

(FUNCTION (BADNESS HALFWORD) ((T SCALED) (S SCALED))
  (VAR R INTEGER)
  (COND ((= T 0) (SETF BADNESS 0))
        ((<= S 0) (SETF BADNESS 10000))
        (TRUE
         (COND ((<= T 7230584) (SETF R (DIV (* T 297) S)))
               ((>= S 1663497) (SETF R (DIV T (DIV S 297))))
               (TRUE (SETF R T)))
         (COND ((> R 1290) (SETF BADNESS 10000))
               (TRUE (SETF BADNESS (DIV (+ (* (* R R) R) 131072) 262144)))))))

(PROCEDURE SHOW-TOKEN-LIST ((P INTEGER) (Q INTEGER) (L INTEGER))
  (LABEL $L.10)
  (VAR M INTEGER)
  (VAR C INTEGER)
  (VAR MATCH-CHR ASCII-CODE)
  (VAR N ASCII-CODE)
  (SETF MATCH-CHR 35)
  (SETF N 48)
  (SETF TALLY 0)
  (WHILE (AND (/= P 0) (< TALLY L))
    (WHEN (= P Q)
      (SETF FIRST-COUNT TALLY)
      (SETF TRICK-COUNT (- (+ (+ TALLY 1) ERROR-LINE) HALF-ERROR-LINE))
      (WHEN (< TRICK-COUNT ERROR-LINE) (SETF TRICK-COUNT ERROR-LINE)))
    (WHEN (OR (< P HI-MEM-MIN) (> P MEM-END)) (PRINT-ESC 309) (GOTO $L.10))
    (COND ((>= (SLOT (SLOT (AREF MEM P) HH) LH) 4095)
           (PRINT-CS (- (SLOT (SLOT (AREF MEM P) HH) LH) 4095)))
          (TRUE
           (SETF M (DIV (SLOT (SLOT (AREF MEM P) HH) LH) 256))
           (SETF C (MOD (SLOT (SLOT (AREF MEM P) HH) LH) 256))
           (COND ((< (SLOT (SLOT (AREF MEM P) HH) LH) 0) (PRINT-ESC 555))
                 (TRUE
                  (CASE M
                    ((1 2 3 4 7 8 10 11 12) (PRINT C))
                    ((6) (PRINT C) (PRINT C))
                    ((5) (PRINT MATCH-CHR)
                     (COND ((<= C 9) (PRINT-CHAR (+ C 48)))
                           (TRUE (PRINT-CHAR 33) (GOTO $L.10))))
                    ((13) (SETF MATCH-CHR C) (PRINT C) (INCF N 1) (PRINT-CHAR N)
                     (WHEN (> N 57) (GOTO $L.10)))
                    ((14) (PRINT 556))
                    (ELSE (PRINT-ESC 555)))))))
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  (WHEN (/= P 0) (PRINT-ESC 554))
  $L.10)

(PROCEDURE RUNAWAY ()
  (VAR P HALFWORD)
  (WHEN (> SCANNER-STATUS 1)
    (PRINT-NL 569)
    (CASE SCANNER-STATUS
      ((2) (PRINT 570) (SETF P DEF-REF))
      ((3) (PRINT 571) (SETF P 59997))
      ((4) (PRINT 572) (SETF P 59996))
      ((5) (PRINT 573) (SETF P DEF-REF)))
    (PRINT-CHAR 63)
    (PRINT-LN)
    (SHOW-TOKEN-LIST (SLOT (SLOT (AREF MEM P) HH) RH) 0 (- ERROR-LINE 10))))

(FUNCTION (GET-AVAIL HALFWORD) ()
  (VAR P HALFWORD)
  (SETF P AVAIL)
  (COND ((/= P 0) (SETF AVAIL (SLOT (SLOT (AREF MEM AVAIL) HH) RH)))
        ((< MEM-END MEM-MAX) (INCF MEM-END 1) (SETF P MEM-END))
        (TRUE
         (DECF HI-MEM-MIN 1)
         (SETF P HI-MEM-MIN)
         (WHEN (<= HI-MEM-MIN LO-MEM-MAX) (RUNAWAY) (OVERFLOW 300 (- (+ MEM-MAX 1) MEM-MIN)))))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
  (SETF GET-AVAIL P))

(PROCEDURE FLUSH-LIST ((P HALFWORD))
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (WHEN (/= P 0)
    (SETF R P)
    (REPEAT (SETF Q R) (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)) (UNTIL (= R 0)))
    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) AVAIL)
    (SETF AVAIL P)))

(FUNCTION (GET-NODE HALFWORD) ((S INTEGER))
  (LABEL $L.40)
  (LABEL $L.10)
  (LABEL $L.20)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R INTEGER)
  (VAR T INTEGER)
  $L.20
  (SETF P ROVER)
  (REPEAT (SETF Q (+ P (SLOT (SLOT (AREF MEM P) HH) LH)))
          (WHILE (= (SLOT (SLOT (AREF MEM Q) HH) RH) 65535)
            (SETF T (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
            (WHEN (= Q ROVER) (SETF ROVER T))
            (SETF (SLOT (SLOT (AREF MEM (+ T 1)) HH) LH)
                  (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
            (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) 1)) HH) RH)
                  T)
            (INCF Q (SLOT (SLOT (AREF MEM Q) HH) LH)))
          (SETF R (- Q S))
          (WHEN (> R (+ P 1))
            (SETF (SLOT (SLOT (AREF MEM P) HH) LH) (- R P))
            (SETF ROVER P)
            (GOTO $L.40))
          (WHEN (= R P)
            (WHEN (/= (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) P)
              (SETF ROVER (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
              (SETF T (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH) T)
              (SETF (SLOT (SLOT (AREF MEM (+ T 1)) HH) RH) ROVER)
              (GOTO $L.40)))
          (SETF (SLOT (SLOT (AREF MEM P) HH) LH) (- Q P))
          (SETF P (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
          (UNTIL (= P ROVER)))
  (WHEN (= S 1073741824) (SETF GET-NODE 65535) (GOTO $L.10))
  (WHEN (< (+ LO-MEM-MAX 2) HI-MEM-MIN)
    (WHEN (<= (+ LO-MEM-MAX 2) 65535)
      (COND ((>= (- HI-MEM-MIN LO-MEM-MAX) 1998) (SETF T (+ LO-MEM-MAX 1000)))
            (TRUE (SETF T (+ (+ LO-MEM-MAX 1) (DIV (- HI-MEM-MIN LO-MEM-MAX) 2)))))
      (SETF P (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH))
      (SETF Q LO-MEM-MAX)
      (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) Q)
      (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH) Q)
      (WHEN (> T 65535) (SETF T 65535))
      (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) ROVER)
      (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) P)
      (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 65535)
      (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (- T LO-MEM-MAX))
      (SETF LO-MEM-MAX T)
      (SETF (SLOT (SLOT (AREF MEM LO-MEM-MAX) HH) RH) 0)
      (SETF (SLOT (SLOT (AREF MEM LO-MEM-MAX) HH) LH) 0)
      (SETF ROVER Q)
      (GOTO $L.20)))
  (OVERFLOW 300 (- (+ MEM-MAX 1) MEM-MIN))
  $L.40
  (SETF (SLOT (SLOT (AREF MEM R) HH) RH) 0)
  (SETF GET-NODE R)
  $L.10)

(PROCEDURE FREE-NODE ((P HALFWORD) (S HALFWORD))
  (VAR Q HALFWORD)
  (SETF (SLOT (SLOT (AREF MEM P) HH) LH) S)
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 65535)
  (SETF Q (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH))
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) Q)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) ROVER)
  (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH) P)
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) P))

(PROCEDURE SORT-AVAIL ()
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR OLD-ROVER HALFWORD)
  (SETF P (GET-NODE 1073741824))
  (SETF P (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) RH) 65535)
  (SETF OLD-ROVER ROVER)
  (WHILE (/= P OLD-ROVER)
    (COND ((< P ROVER)
           (SETF Q P)
           (SETF P (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) ROVER)
           (SETF ROVER Q))
          (TRUE
           (SETF Q ROVER)
           (WHILE (< (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) P)
             (SETF Q (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH)))
           (SETF R (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) P)
           (SETF P R))))
  (SETF P ROVER)
  (WHILE (/= (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 65535)
    (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 1)) HH) LH) P)
    (SETF P (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)))
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) ROVER)
  (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH) P))

(FUNCTION (NEW-NULL-BOX HALFWORD) ()
  (VAR P HALFWORD)
  (SETF P (GET-NODE 7))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 0)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) 0)
  (SETF (SLOT (AREF MEM (+ P 2)) INT) 0)
  (SETF (SLOT (AREF MEM (+ P 3)) INT) 0)
  (SETF (SLOT (AREF MEM (+ P 4)) INT) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 6)) GR) 0.0)
  (SETF NEW-NULL-BOX P))

(FUNCTION (NEW-RULE HALFWORD) ()
  (VAR P HALFWORD)
  (SETF P (GET-NODE 4))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 2)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) (- 1073741824))
  (SETF (SLOT (AREF MEM (+ P 2)) INT) (- 1073741824))
  (SETF (SLOT (AREF MEM (+ P 3)) INT) (- 1073741824))
  (SETF NEW-RULE P))

(FUNCTION (NEW-LIGATURE HALFWORD) ((F QUARTERWORD) (C QUARTERWORD) (Q HALFWORD))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 6)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) B0) F)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) B1) C)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) Q)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF NEW-LIGATURE P))

(FUNCTION (NEW-LIG-ITEM HALFWORD) ((C QUARTERWORD))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) C)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 0)
  (SETF NEW-LIG-ITEM P))

(FUNCTION (NEW-DISC HALFWORD) ()
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 7)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 0)
  (SETF NEW-DISC P))

(FUNCTION (NEW-MATH HALFWORD) ((W SCALED) (S SMALL-NUMBER))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 9)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) S)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) W)
  (SETF NEW-MATH P))

(FUNCTION (NEW-SPEC HALFWORD) ((P HALFWORD))
  (VAR Q HALFWORD)
  (SETF Q (GET-NODE 4))
  (SETF (AREF MEM Q) (AREF MEM P))
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
  (SETF (SLOT (AREF MEM (+ Q 1)) INT) (SLOT (AREF MEM (+ P 1)) INT))
  (SETF (SLOT (AREF MEM (+ Q 2)) INT) (SLOT (AREF MEM (+ P 2)) INT))
  (SETF (SLOT (AREF MEM (+ Q 3)) INT) (SLOT (AREF MEM (+ P 3)) INT))
  (SETF NEW-SPEC Q))

(FUNCTION (NEW-PARAM-GLUE HALFWORD) ((N SMALL-NUMBER))
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 10)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) (+ N 1))
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 0)
  (SETF Q (SLOT (SLOT (AREF EQTB (+ 6782 N)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) Q)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (+ (SLOT (SLOT (AREF MEM Q) HH) RH) 1))
  (SETF NEW-PARAM-GLUE P))

(FUNCTION (NEW-GLUE HALFWORD) ((Q HALFWORD))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 10)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) Q)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (+ (SLOT (SLOT (AREF MEM Q) HH) RH) 1))
  (SETF NEW-GLUE P))

(FUNCTION (NEW-SKIP-PARAM HALFWORD) ((N SMALL-NUMBER))
  (VAR P HALFWORD)
  (SETF TEMP-PTR (NEW-SPEC (SLOT (SLOT (AREF EQTB (+ 6782 N)) HH) RH)))
  (SETF P (NEW-GLUE TEMP-PTR))
  (SETF (SLOT (SLOT (AREF MEM TEMP-PTR) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) (+ N 1))
  (SETF NEW-SKIP-PARAM P))

(FUNCTION (NEW-KERN HALFWORD) ((W SCALED))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 11)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) W)
  (SETF NEW-KERN P))

(FUNCTION (NEW-PENALTY HALFWORD) ((M INTEGER))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 12)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) M)
  (SETF NEW-PENALTY P))

(PROCEDURE SHORT-DISPLAY ((P INTEGER))
  (VAR N INTEGER)
  (WHILE (> P MEM-MIN)
    (COND ((>= P HI-MEM-MIN)
           (WHEN (<= P MEM-END)
             (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B0) FONT-IN-SHORT-DISPLAY)
               (COND ((OR (< (SLOT (SLOT (AREF MEM P) HH) B0) 0)
                          (> (SLOT (SLOT (AREF MEM P) HH) B0) FONT-MAX))
                      (PRINT-CHAR 42))
                     (TRUE
                      (PRINT-ESC (SLOT (AREF HASH (+ 6524 (SLOT (SLOT (AREF MEM P) HH) B0)))
                                       RH))))
               (PRINT-CHAR 32)
               (SETF FONT-IN-SHORT-DISPLAY (SLOT (SLOT (AREF MEM P) HH) B0)))
             (PRINT (- (SLOT (SLOT (AREF MEM P) HH) B1) 0))))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1 3 8 4 5 13) (PRINT 308))
             ((2) (PRINT-CHAR 124))
             ((10) (WHEN (/= (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 0) (PRINT-CHAR 32)))
             ((9) (PRINT-CHAR 36))
             ((6) (SHORT-DISPLAY (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)))
             ((7) (SHORT-DISPLAY (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (SHORT-DISPLAY (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
              (SETF N (SLOT (SLOT (AREF MEM P) HH) B1))
              (WHILE (> N 0)
                (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) RH) 0)
                  (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
                (DECF N 1)))
             (ELSE))))
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))))

(PROCEDURE PRINT-FONT-AND-CHAR ((P INTEGER))
  (COND ((> P MEM-END) (PRINT-ESC 309))
        (TRUE
         (COND ((OR (< (SLOT (SLOT (AREF MEM P) HH) B0) 0)
                    (> (SLOT (SLOT (AREF MEM P) HH) B0) FONT-MAX))
                (PRINT-CHAR 42))
               (TRUE
                (PRINT-ESC (SLOT (AREF HASH (+ 6524 (SLOT (SLOT (AREF MEM P) HH) B0))) RH))))
         (PRINT-CHAR 32)
         (PRINT (- (SLOT (SLOT (AREF MEM P) HH) B1) 0)))))

(PROCEDURE PRINT-MARK ((P INTEGER))
  (PRINT-CHAR 123)
  (COND ((OR (< P HI-MEM-MIN) (> P MEM-END)) (PRINT-ESC 309))
        (TRUE (SHOW-TOKEN-LIST (SLOT (SLOT (AREF MEM P) HH) RH) 0 (- MAX-PRINT-LINE 10))))
  (PRINT-CHAR 125))

(PROCEDURE PRINT-RULE-DIMEN ((D SCALED))
  (COND ((= D (- 1073741824)) (PRINT-CHAR 42)) (TRUE (PRINT-SCALED D))))

(PROCEDURE PRINT-GLUE ((D SCALED) (ORDER INTEGER) (S STR-NUMBER))
  (PRINT-SCALED D)
  (COND ((OR (< ORDER 0) (> ORDER 3)) (PRINT 310))
        ((> ORDER 0) (PRINT 311) (WHILE (> ORDER 1) (PRINT-CHAR 108) (DECF ORDER 1)))
        ((/= S 0) (PRINT S))))

(PROCEDURE PRINT-SPEC ((P INTEGER) (S STR-NUMBER))
  (COND ((OR (< P MEM-MIN) (>= P LO-MEM-MAX)) (PRINT-CHAR 42))
        (TRUE
         (PRINT-SCALED (SLOT (AREF MEM (+ P 1)) INT))
         (WHEN (/= S 0) (PRINT S))
         (WHEN (/= (SLOT (AREF MEM (+ P 2)) INT) 0)
           (PRINT 312)
           (PRINT-GLUE (SLOT (AREF MEM (+ P 2)) INT) (SLOT (SLOT (AREF MEM P) HH) B0) S))
         (WHEN (/= (SLOT (AREF MEM (+ P 3)) INT) 0)
           (PRINT 313)
           (PRINT-GLUE (SLOT (AREF MEM (+ P 3)) INT) (SLOT (SLOT (AREF MEM P) HH) B1) S)))))

(PROCEDURE PRINT-FAM-AND-CHAR ((P HALFWORD))
  (PRINT-ESC 464)
  (PRINT-INT (SLOT (SLOT (AREF MEM P) HH) B0))
  (PRINT-CHAR 32)
  (PRINT (- (SLOT (SLOT (AREF MEM P) HH) B1) 0)))

(PROCEDURE PRINT-DELIMITER ((P HALFWORD))
  (VAR A INTEGER)
  (SETF A
        (- (+ (* (SLOT (SLOT (AREF MEM P) QQQQ) B0) 256) (SLOT (SLOT (AREF MEM P) QQQQ) B1))
           0))
  (SETF A
        (- (+ (+ (* A 4096) (* (SLOT (SLOT (AREF MEM P) QQQQ) B2) 256))
              (SLOT (SLOT (AREF MEM P) QQQQ) B3))
           0))
  (COND ((< A 0) (PRINT-INT A)) (TRUE (PRINT-HEX A))))

(PROCEDURE SHOW-INFO () :FORWARD)

(PROCEDURE PRINT-SUBSIDIARY-DATA ((P HALFWORD) (C ASCII-CODE))
  (COND ((>= (- POOL-PTR (AREF STR-START STR-PTR)) DEPTH-THRESHOLD)
         (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) RH) 0) (PRINT 314)))
        (TRUE
         (SETF (AREF STR-POOL POOL-PTR) C)
         (INCF POOL-PTR 1)
         (SETF TEMP-PTR P)
         (CASE (SLOT (SLOT (AREF MEM P) HH) RH)
           ((1) (PRINT-LN) (PRINT-CURRENT-STRING) (PRINT-FAM-AND-CHAR P))
           ((2) (SHOW-INFO))
           ((3)
            (COND ((= (SLOT (SLOT (AREF MEM P) HH) LH) 0)
                   (PRINT-LN)
                   (PRINT-CURRENT-STRING)
                   (PRINT 860))
                  (TRUE (SHOW-INFO))))
           (ELSE))
         (DECF POOL-PTR 1))))

(PROCEDURE PRINT-STYLE ((C INTEGER))
  (CASE (DIV C 2)
    ((0) (PRINT-ESC 861))
    ((1) (PRINT-ESC 862))
    ((2) (PRINT-ESC 863))
    ((3) (PRINT-ESC 864))
    (ELSE (PRINT 865))))

(PROCEDURE PRINT-SKIP-PARAM ((N INTEGER))
  (CASE N
    ((0) (PRINT-ESC 376))
    ((1) (PRINT-ESC 377))
    ((2) (PRINT-ESC 378))
    ((3) (PRINT-ESC 379))
    ((4) (PRINT-ESC 380))
    ((5) (PRINT-ESC 381))
    ((6) (PRINT-ESC 382))
    ((7) (PRINT-ESC 383))
    ((8) (PRINT-ESC 384))
    ((9) (PRINT-ESC 385))
    ((10) (PRINT-ESC 386))
    ((11) (PRINT-ESC 387))
    ((12) (PRINT-ESC 388))
    ((13) (PRINT-ESC 389))
    ((14) (PRINT-ESC 390))
    ((15) (PRINT-ESC 391))
    ((16) (PRINT-ESC 392))
    ((17) (PRINT-ESC 393))
    (ELSE (PRINT 394))))

(PROCEDURE SHOW-NODE-LIST ((P INTEGER))
  (LABEL $L.10)
  (VAR N INTEGER)
  (VAR G REAL)
  (WHEN (> (- POOL-PTR (AREF STR-START STR-PTR)) DEPTH-THRESHOLD)
    (WHEN (> P 0) (PRINT 314))
    (GOTO $L.10))
  (SETF N 0)
  (WHILE (> P MEM-MIN)
    (PRINT-LN)
    (PRINT-CURRENT-STRING)
    (WHEN (> P MEM-END) (PRINT 315) (GOTO $L.10))
    (INCF N 1)
    (WHEN (> N BREADTH-MAX) (PRINT 316) (GOTO $L.10))
    (COND ((>= P HI-MEM-MIN) (PRINT-FONT-AND-CHAR P))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1 13)
              (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 0) (PRINT-ESC 104))
                    ((= (SLOT (SLOT (AREF MEM P) HH) B0) 1) (PRINT-ESC 118))
                    (TRUE (PRINT-ESC 318)))
              (PRINT 319) (PRINT-SCALED (SLOT (AREF MEM (+ P 3)) INT)) (PRINT-CHAR 43)
              (PRINT-SCALED (SLOT (AREF MEM (+ P 2)) INT)) (PRINT 320)
              (PRINT-SCALED (SLOT (AREF MEM (+ P 1)) INT))
              (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 13)
                     (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B1) 0)
                       (PRINT 286)
                       (PRINT-INT (+ (SLOT (SLOT (AREF MEM P) HH) B1) 1))
                       (PRINT 322))
                     (WHEN (/= (SLOT (AREF MEM (+ P 6)) INT) 0)
                       (PRINT 323)
                       (PRINT-GLUE (SLOT (AREF MEM (+ P 6)) INT)
                                   (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1)
                                   0))
                     (WHEN (/= (SLOT (AREF MEM (+ P 4)) INT) 0)
                       (PRINT 324)
                       (PRINT-GLUE (SLOT (AREF MEM (+ P 4)) INT)
                                   (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0)
                                   0)))
                    (TRUE
                     (SETF G (SLOT (AREF MEM (+ P 6)) GR))
                     (WHEN (AND (/= G 0.0) (/= (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0) 0))
                       (PRINT 325)
                       (WHEN (= (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0) 2) (PRINT 326))
                       (COND (FALSE (PRINT 327))
                             ((> (ABS G) 20000.0)
                              (COND ((> G 0.0) (PRINT-CHAR 62)) (TRUE (PRINT 328)))
                              (PRINT-GLUE (* 20000 65536)
                                          (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1)
                                          0))
                             (TRUE
                              (PRINT-GLUE (ROUND (* 65536 G))
                                          (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1)
                                          0))))
                     (WHEN (/= (SLOT (AREF MEM (+ P 4)) INT) 0)
                       (PRINT 321)
                       (PRINT-SCALED (SLOT (AREF MEM (+ P 4)) INT)))))
              (SETF (AREF STR-POOL POOL-PTR) 46) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH)) (DECF POOL-PTR 1))
             ((2) (PRINT-ESC 329) (PRINT-RULE-DIMEN (SLOT (AREF MEM (+ P 3)) INT))
              (PRINT-CHAR 43) (PRINT-RULE-DIMEN (SLOT (AREF MEM (+ P 2)) INT)) (PRINT 320)
              (PRINT-RULE-DIMEN (SLOT (AREF MEM (+ P 1)) INT)))
             ((3) (PRINT-ESC 330) (PRINT-INT (- (SLOT (SLOT (AREF MEM P) HH) B1) 0))
              (PRINT 331) (PRINT-SCALED (SLOT (AREF MEM (+ P 3)) INT)) (PRINT 332)
              (PRINT-SPEC (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH) 0) (PRINT-CHAR 44)
              (PRINT-SCALED (SLOT (AREF MEM (+ P 2)) INT)) (PRINT 333)
              (PRINT-INT (SLOT (AREF MEM (+ P 1)) INT)) (SETF (AREF STR-POOL POOL-PTR) 46)
              (INCF POOL-PTR 1) (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH))
              (DECF POOL-PTR 1))
             ((8)
              (CASE (SLOT (SLOT (AREF MEM P) HH) B1)
                ((0) (PRINT-WRITE-WHATSIT 1285 P) (PRINT-CHAR 61)
                 (PRINT-FILE-NAME
                   (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)
                   (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH)
                   (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH)))
                ((1) (PRINT-WRITE-WHATSIT 594 P)
                 (PRINT-MARK (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)))
                ((2) (PRINT-WRITE-WHATSIT 1286 P))
                ((3) (PRINT-ESC 1287) (PRINT-MARK (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)))
                ((4) (PRINT-ESC 1289) (PRINT-INT (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                 (PRINT 1292) (PRINT-INT (SLOT (SLOT (AREF MEM (+ P 1)) HH) B0))
                 (PRINT-CHAR 44) (PRINT-INT (SLOT (SLOT (AREF MEM (+ P 1)) HH) B1))
                 (PRINT-CHAR 41))
                (ELSE (PRINT 1293))))
             ((10)
              (COND ((>= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
                     (PRINT-ESC 338)
                     (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 101) (PRINT-CHAR 99))
                           ((= (SLOT (SLOT (AREF MEM P) HH) B1) 102) (PRINT-CHAR 120)))
                     (PRINT 339)
                     (PRINT-SPEC (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 0)
                     (SETF (AREF STR-POOL POOL-PTR) 46)
                     (INCF POOL-PTR 1)
                     (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                     (DECF POOL-PTR 1))
                    (TRUE
                     (PRINT-ESC 334)
                     (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B1) 0)
                       (PRINT-CHAR 40)
                       (COND ((< (SLOT (SLOT (AREF MEM P) HH) B1) 98)
                              (PRINT-SKIP-PARAM (- (SLOT (SLOT (AREF MEM P) HH) B1) 1)))
                             ((= (SLOT (SLOT (AREF MEM P) HH) B1) 98) (PRINT-ESC 335))
                             (TRUE (PRINT-ESC 336)))
                       (PRINT-CHAR 41))
                     (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B1) 98)
                       (PRINT-CHAR 32)
                       (COND ((< (SLOT (SLOT (AREF MEM P) HH) B1) 98)
                              (PRINT-SPEC (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 0))
                             (TRUE
                              (PRINT-SPEC (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 337)))))))
             ((11)
              (COND ((/= (SLOT (SLOT (AREF MEM P) HH) B1) 99)
                     (PRINT-ESC 340)
                     (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B1) 0) (PRINT-CHAR 32))
                     (PRINT-SCALED (SLOT (AREF MEM (+ P 1)) INT))
                     (WHEN (= (SLOT (SLOT (AREF MEM P) HH) B1) 2) (PRINT 341)))
                    (TRUE
                     (PRINT-ESC 342)
                     (PRINT-SCALED (SLOT (AREF MEM (+ P 1)) INT))
                     (PRINT 337))))
             ((9) (PRINT-ESC 343)
              (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 0) (PRINT 344)) (TRUE (PRINT 345)))
              (WHEN (/= (SLOT (AREF MEM (+ P 1)) INT) 0)
                (PRINT 346)
                (PRINT-SCALED (SLOT (AREF MEM (+ P 1)) INT))))
             ((6) (PRINT-FONT-AND-CHAR (+ P 1)) (PRINT 347)
              (WHEN (> (SLOT (SLOT (AREF MEM P) HH) B1) 1) (PRINT-CHAR 124))
              (SETF FONT-IN-SHORT-DISPLAY (SLOT (SLOT (AREF MEM (+ P 1)) HH) B0))
              (SHORT-DISPLAY (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
              (WHEN (ODD (SLOT (SLOT (AREF MEM P) HH) B1)) (PRINT-CHAR 124)) (PRINT-CHAR 41))
             ((12) (PRINT-ESC 348) (PRINT-INT (SLOT (AREF MEM (+ P 1)) INT)))
             ((7) (PRINT-ESC 349)
              (WHEN (> (SLOT (SLOT (AREF MEM P) HH) B1) 0)
                (PRINT 350)
                (PRINT-INT (SLOT (SLOT (AREF MEM P) HH) B1)))
              (SETF (AREF STR-POOL POOL-PTR) 46) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) (DECF POOL-PTR 1)
              (SETF (AREF STR-POOL POOL-PTR) 124) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)) (DECF POOL-PTR 1))
             ((4) (PRINT-ESC 351) (PRINT-MARK (SLOT (AREF MEM (+ P 1)) INT)))
             ((5) (PRINT-ESC 352) (SETF (AREF STR-POOL POOL-PTR) 46) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (AREF MEM (+ P 1)) INT)) (DECF POOL-PTR 1))
             ((14) (PRINT-STYLE (SLOT (SLOT (AREF MEM P) HH) B1)))
             ((15) (PRINT-ESC 525) (SETF (AREF STR-POOL POOL-PTR) 68) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) (DECF POOL-PTR 1)
              (SETF (AREF STR-POOL POOL-PTR) 84) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)) (DECF POOL-PTR 1)
              (SETF (AREF STR-POOL POOL-PTR) 83) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH)) (DECF POOL-PTR 1)
              (SETF (AREF STR-POOL POOL-PTR) 115) (INCF POOL-PTR 1)
              (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH)) (DECF POOL-PTR 1))
             ((16 17 18 19 20 21 22 23 24 27 26 29 28 30 31)
              (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
                ((16) (PRINT-ESC 866))
                ((17) (PRINT-ESC 867))
                ((18) (PRINT-ESC 868))
                ((19) (PRINT-ESC 869))
                ((20) (PRINT-ESC 870))
                ((21) (PRINT-ESC 871))
                ((22) (PRINT-ESC 872))
                ((23) (PRINT-ESC 873))
                ((27) (PRINT-ESC 874))
                ((26) (PRINT-ESC 875))
                ((29) (PRINT-ESC 539))
                ((24) (PRINT-ESC 533) (PRINT-DELIMITER (+ P 4)))
                ((28) (PRINT-ESC 508) (PRINT-FAM-AND-CHAR (+ P 4)))
                ((30) (PRINT-ESC 876) (PRINT-DELIMITER (+ P 1)))
                ((31) (PRINT-ESC 877) (PRINT-DELIMITER (+ P 1))))
              (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B1) 0)
                (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 1) (PRINT-ESC 878))
                      (TRUE (PRINT-ESC 879))))
              (WHEN (< (SLOT (SLOT (AREF MEM P) HH) B0) 30) (PRINT-SUBSIDIARY-DATA (+ P 1) 46))
              (PRINT-SUBSIDIARY-DATA (+ P 2) 94) (PRINT-SUBSIDIARY-DATA (+ P 3) 95))
             ((25) (PRINT-ESC 880)
              (COND ((= (SLOT (AREF MEM (+ P 1)) INT) 1073741824) (PRINT 881))
                    (TRUE (PRINT-SCALED (SLOT (AREF MEM (+ P 1)) INT))))
              (WHEN (OR (OR (OR (/= (SLOT (SLOT (AREF MEM (+ P 4)) QQQQ) B0) 0)
                                (/= (SLOT (SLOT (AREF MEM (+ P 4)) QQQQ) B1) 0))
                            (/= (SLOT (SLOT (AREF MEM (+ P 4)) QQQQ) B2) 0))
                        (/= (SLOT (SLOT (AREF MEM (+ P 4)) QQQQ) B3) 0))
                (PRINT 882)
                (PRINT-DELIMITER (+ P 4)))
              (WHEN (OR (OR (OR (/= (SLOT (SLOT (AREF MEM (+ P 5)) QQQQ) B0) 0)
                                (/= (SLOT (SLOT (AREF MEM (+ P 5)) QQQQ) B1) 0))
                            (/= (SLOT (SLOT (AREF MEM (+ P 5)) QQQQ) B2) 0))
                        (/= (SLOT (SLOT (AREF MEM (+ P 5)) QQQQ) B3) 0))
                (PRINT 883)
                (PRINT-DELIMITER (+ P 5)))
              (PRINT-SUBSIDIARY-DATA (+ P 2) 92) (PRINT-SUBSIDIARY-DATA (+ P 3) 47))
             (ELSE (PRINT 317)))))
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  $L.10)

(PROCEDURE SHOW-BOX ((P HALFWORD))
  (SETF DEPTH-THRESHOLD (SLOT (AREF EQTB 9188) INT))
  (SETF BREADTH-MAX (SLOT (AREF EQTB 9187) INT))
  (WHEN (<= BREADTH-MAX 0) (SETF BREADTH-MAX 5))
  (WHEN (>= (+ POOL-PTR DEPTH-THRESHOLD) POOL-SIZE)
    (SETF DEPTH-THRESHOLD (- (- POOL-SIZE POOL-PTR) 1)))
  (SHOW-NODE-LIST P)
  (PRINT-LN))

(PROCEDURE DELETE-TOKEN-REF ((P HALFWORD))
  (COND ((= (SLOT (SLOT (AREF MEM P) HH) LH) 0) (FLUSH-LIST P))
        (TRUE (SETF (SLOT (SLOT (AREF MEM P) HH) LH) (- (SLOT (SLOT (AREF MEM P) HH) LH) 1)))))

(PROCEDURE DELETE-GLUE-REF ((P HALFWORD))
  (COND ((= (SLOT (SLOT (AREF MEM P) HH) RH) 0) (FREE-NODE P 4))
        (TRUE (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (- (SLOT (SLOT (AREF MEM P) HH) RH) 1)))))

(PROCEDURE FLUSH-NODE-LIST ((P HALFWORD))
  (LABEL $L.30)
  (VAR Q HALFWORD)
  (WHILE (/= P 0)
    (SETF Q (SLOT (SLOT (AREF MEM P) HH) RH))
    (COND ((>= P HI-MEM-MIN) (SETF (SLOT (SLOT (AREF MEM P) HH) RH) AVAIL) (SETF AVAIL P))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1 13) (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH)) (FREE-NODE P 7)
              (GOTO $L.30))
             ((2) (FREE-NODE P 4) (GOTO $L.30))
             ((3) (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH))
              (DELETE-GLUE-REF (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH)) (FREE-NODE P 5)
              (GOTO $L.30))
             ((8)
              (CASE (SLOT (SLOT (AREF MEM P) HH) B1)
                ((0) (FREE-NODE P 3))
                ((1 3) (DELETE-TOKEN-REF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                 (FREE-NODE P 2) (GOTO $L.30))
                ((2 4) (FREE-NODE P 2))
                (ELSE (CONFUSION 1295)))
              (GOTO $L.30))
             ((10)
              (COND ((= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) HH) RH)
                        0)
                     (FREE-NODE (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 4))
                    (TRUE
                     (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) HH)
                                 RH)
                           (- (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) HH)
                                    RH)
                              1))))
              (WHEN (/= (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 0)
                (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))))
             ((11 9 12))
             ((6) (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)))
             ((4) (DELETE-TOKEN-REF (SLOT (AREF MEM (+ P 1)) INT)))
             ((7) (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)))
             ((5) (FLUSH-NODE-LIST (SLOT (AREF MEM (+ P 1)) INT)))
             ((14) (FREE-NODE P 3) (GOTO $L.30))
             ((15) (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
              (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH))
              (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH)) (FREE-NODE P 3)
              (GOTO $L.30))
             ((16 17 18 19 20 21 22 23 24 27 26 29 28)
              (WHEN (>= (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 2)
                (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)))
              (WHEN (>= (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH) 2)
                (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH)))
              (WHEN (>= (SLOT (SLOT (AREF MEM (+ P 3)) HH) RH) 2)
                (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 3)) HH) LH)))
              (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 24) (FREE-NODE P 5))
                    ((= (SLOT (SLOT (AREF MEM P) HH) B0) 28) (FREE-NODE P 5))
                    (TRUE (FREE-NODE P 4)))
              (GOTO $L.30))
             ((30 31) (FREE-NODE P 4) (GOTO $L.30))
             ((25) (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH))
              (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 3)) HH) LH)) (FREE-NODE P 6)
              (GOTO $L.30))
             (ELSE (CONFUSION 353)))
           (FREE-NODE P 2)
           $L.30))
    (SETF P Q)))

(FUNCTION (COPY-NODE-LIST HALFWORD) ((P HALFWORD))
  (VAR H HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR WORDS (RANGE 0 5))
  (SETF H GET-AVAIL)
  (SETF Q H)
  (WHILE (/= P 0)
    (SETF WORDS 1)
    (COND ((>= P HI-MEM-MIN) (SETF R GET-AVAIL))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1 13) (SETF R (GET-NODE 7)) (SETF (AREF MEM (+ R 6)) (AREF MEM (+ P 6)))
              (SETF (AREF MEM (+ R 5)) (AREF MEM (+ P 5)))
              (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH)
                    (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH)))
              (SETF WORDS 5))
             ((2) (SETF R (GET-NODE 4)) (SETF WORDS 4))
             ((3) (SETF R (GET-NODE 5)) (SETF (AREF MEM (+ R 4)) (AREF MEM (+ P 4)))
              (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH)) HH) RH)
                    (+ (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH)) HH) RH)
                       1))
              (SETF (SLOT (SLOT (AREF MEM (+ R 4)) HH) LH)
                    (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH)))
              (SETF WORDS 4))
             ((8)
              (CASE (SLOT (SLOT (AREF MEM P) HH) B1)
                ((0) (SETF R (GET-NODE 3)) (SETF WORDS 3))
                ((1 3) (SETF R (GET-NODE 2))
                 (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)) HH) LH)
                       (+ (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)) HH) LH)
                          1))
                 (SETF WORDS 2))
                ((2 4) (SETF R (GET-NODE 2)) (SETF WORDS 2))
                (ELSE (CONFUSION 1294))))
             ((10) (SETF R (GET-NODE 2))
              (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) HH) RH)
                    (+ (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)) HH) RH)
                       1))
              (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH)
                    (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH)
                    (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))))
             ((11 9 12) (SETF R (GET-NODE 2)) (SETF WORDS 2))
             ((6) (SETF R (GET-NODE 2)) (SETF (AREF MEM (+ R 1)) (AREF MEM (+ P 1)))
              (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH)
                    (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))))
             ((7) (SETF R (GET-NODE 2))
              (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH)
                    (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH)))
              (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH)
                    (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))))
             ((4) (SETF R (GET-NODE 2))
              (SETF (SLOT (SLOT (AREF MEM (SLOT (AREF MEM (+ P 1)) INT)) HH) LH)
                    (+ (SLOT (SLOT (AREF MEM (SLOT (AREF MEM (+ P 1)) INT)) HH) LH) 1))
              (SETF WORDS 2))
             ((5) (SETF R (GET-NODE 2))
              (SETF (SLOT (AREF MEM (+ R 1)) INT)
                    (COPY-NODE-LIST (SLOT (AREF MEM (+ P 1)) INT))))
             (ELSE (CONFUSION 354)))))
    (WHILE (> WORDS 0) (DECF WORDS 1) (SETF (AREF MEM (+ R WORDS)) (AREF MEM (+ P WORDS))))
    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
    (SETF Q R)
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
  (SETF Q (SLOT (SLOT (AREF MEM H) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM H) HH) RH) AVAIL)
  (SETF AVAIL H)
  (SETF COPY-NODE-LIST Q))

(PROCEDURE PRINT-MODE ((M INTEGER))
  (COND ((> M 0) (CASE (DIV M 101) ((0) (PRINT 355)) ((1) (PRINT 356)) ((2) (PRINT 357))))
        ((= M 0) (PRINT 358))
        (TRUE (CASE (DIV (- M) 101) ((0) (PRINT 359)) ((1) (PRINT 360)) ((2) (PRINT 343)))))
  (PRINT 361))

(PROCEDURE PUSH-NEST ()
  (WHEN (> NEST-PTR MAX-NEST-STACK)
    (SETF MAX-NEST-STACK NEST-PTR)
    (WHEN (= NEST-PTR NEST-SIZE) (OVERFLOW 362 NEST-SIZE)))
  (SETF (AREF NEST NEST-PTR) CUR-LIST)
  (INCF NEST-PTR 1)
  (SETF (SLOT CUR-LIST HEAD-FIELD) GET-AVAIL)
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
  (SETF (SLOT CUR-LIST PG-FIELD) 0)
  (SETF (SLOT CUR-LIST ML-FIELD) LINE))

(PROCEDURE POP-NEST ()
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) AVAIL)
  (SETF AVAIL (SLOT CUR-LIST HEAD-FIELD))
  (DECF NEST-PTR 1)
  (SETF CUR-LIST (AREF NEST NEST-PTR)))

(PROCEDURE PRINT-TOTALS () :FORWARD)

(PROCEDURE SHOW-ACTIVITIES ()
  (VAR P (RANGE 0 NEST-SIZE))
  (VAR M (RANGE (- 203) 203))
  (VAR A MEMORY-WORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR T INTEGER)
  (SETF (AREF NEST NEST-PTR) CUR-LIST)
  (PRINT-NL 338)
  (PRINT-LN)
  (FOR (P NEST-PTR DOWNTO 0)
    (SETF M (SLOT (AREF NEST P) MODE-FIELD))
    (SETF A (SLOT (AREF NEST P) AUX-FIELD))
    (PRINT-NL 363)
    (PRINT-MODE M)
    (PRINT 364)
    (PRINT-INT (ABS (SLOT (AREF NEST P) ML-FIELD)))
    (WHEN (= M 102)
      (WHEN (/= (SLOT (AREF NEST P) PG-FIELD) 8585216)
        (PRINT 365)
        (PRINT-INT (MOD (SLOT (AREF NEST P) PG-FIELD) 65536))
        (PRINT 366)
        (PRINT-INT (DIV (SLOT (AREF NEST P) PG-FIELD) 4194304))
        (PRINT-CHAR 44)
        (PRINT-INT (MOD (DIV (SLOT (AREF NEST P) PG-FIELD) 65536) 64))
        (PRINT-CHAR 41)))
    (WHEN (< (SLOT (AREF NEST P) ML-FIELD) 0) (PRINT 367))
    (WHEN (= P 0)
      (WHEN (/= 59998 PAGE-TAIL)
        (PRINT-NL 980)
        (WHEN OUTPUT-ACTIVE (PRINT 981))
        (SHOW-BOX (SLOT (SLOT (AREF MEM 59998) HH) RH))
        (WHEN (> PAGE-CONTENTS 0)
          (PRINT-NL 982)
          (PRINT-TOTALS)
          (PRINT-NL 983)
          (PRINT-SCALED (AREF PAGE-SO-FAR 0))
          (SETF R (SLOT (SLOT (AREF MEM 60000) HH) RH))
          (WHILE (/= R 60000)
            (PRINT-LN)
            (PRINT-ESC 330)
            (SETF T (- (SLOT (SLOT (AREF MEM R) HH) B1) 0))
            (PRINT-INT T)
            (PRINT 984)
            (COND ((= (SLOT (AREF EQTB (+ 9218 T)) INT) 1000)
                   (SETF T (SLOT (AREF MEM (+ R 3)) INT)))
                  (TRUE
                   (SETF T
                         (* (X-OVER-N (SLOT (AREF MEM (+ R 3)) INT) 1000)
                            (SLOT (AREF EQTB (+ 9218 T)) INT)))))
            (PRINT-SCALED T)
            (WHEN (= (SLOT (SLOT (AREF MEM R) HH) B0) 1)
              (SETF Q 59998)
              (SETF T 0)
              (REPEAT (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
                      (WHEN (AND (= (SLOT (SLOT (AREF MEM Q) HH) B0) 3)
                                 (= (SLOT (SLOT (AREF MEM Q) HH) B1)
                                    (SLOT (SLOT (AREF MEM R) HH) B1)))
                        (INCF T 1))
                      (UNTIL (= Q (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH))))
              (PRINT 985)
              (PRINT-INT T)
              (PRINT 986))
            (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)))))
      (WHEN (/= (SLOT (SLOT (AREF MEM 59999) HH) RH) 0) (PRINT-NL 368)))
    (SHOW-BOX (SLOT (SLOT (AREF MEM (SLOT (AREF NEST P) HEAD-FIELD)) HH) RH))
    (CASE (DIV (ABS M) 101)
      ((0) (PRINT-NL 369)
       (COND ((<= (SLOT A INT) (- 65536000)) (PRINT 370)) (TRUE (PRINT-SCALED (SLOT A INT))))
       (WHEN (/= (SLOT (AREF NEST P) PG-FIELD) 0)
         (PRINT 371)
         (PRINT-INT (SLOT (AREF NEST P) PG-FIELD))
         (PRINT 372)
         (WHEN (/= (SLOT (AREF NEST P) PG-FIELD) 1) (PRINT-CHAR 115))))
      ((1) (PRINT-NL 373) (PRINT-INT (SLOT (SLOT A HH) LH))
       (WHEN (> M 0)
         (WHEN (> (SLOT (SLOT A HH) RH) 0) (PRINT 374) (PRINT-INT (SLOT (SLOT A HH) RH)))))
      ((2) (WHEN (/= (SLOT A INT) 0) (PRINT 375) (SHOW-BOX (SLOT A INT)))))))

(PROCEDURE PRINT-PARAM ((N INTEGER))
  (CASE N
    ((0) (PRINT-ESC 420))
    ((1) (PRINT-ESC 421))
    ((2) (PRINT-ESC 422))
    ((3) (PRINT-ESC 423))
    ((4) (PRINT-ESC 424))
    ((5) (PRINT-ESC 425))
    ((6) (PRINT-ESC 426))
    ((7) (PRINT-ESC 427))
    ((8) (PRINT-ESC 428))
    ((9) (PRINT-ESC 429))
    ((10) (PRINT-ESC 430))
    ((11) (PRINT-ESC 431))
    ((12) (PRINT-ESC 432))
    ((13) (PRINT-ESC 433))
    ((14) (PRINT-ESC 434))
    ((15) (PRINT-ESC 435))
    ((16) (PRINT-ESC 436))
    ((17) (PRINT-ESC 437))
    ((18) (PRINT-ESC 438))
    ((19) (PRINT-ESC 439))
    ((20) (PRINT-ESC 440))
    ((21) (PRINT-ESC 441))
    ((22) (PRINT-ESC 442))
    ((23) (PRINT-ESC 443))
    ((24) (PRINT-ESC 444))
    ((25) (PRINT-ESC 445))
    ((26) (PRINT-ESC 446))
    ((27) (PRINT-ESC 447))
    ((28) (PRINT-ESC 448))
    ((29) (PRINT-ESC 449))
    ((30) (PRINT-ESC 450))
    ((31) (PRINT-ESC 451))
    ((32) (PRINT-ESC 452))
    ((33) (PRINT-ESC 453))
    ((34) (PRINT-ESC 454))
    ((35) (PRINT-ESC 455))
    ((36) (PRINT-ESC 456))
    ((37) (PRINT-ESC 457))
    ((38) (PRINT-ESC 458))
    ((39) (PRINT-ESC 459))
    ((40) (PRINT-ESC 460))
    ((41) (PRINT-ESC 461))
    ((42) (PRINT-ESC 462))
    ((43) (PRINT-ESC 463))
    ((44) (PRINT-ESC 464))
    ((45) (PRINT-ESC 465))
    ((46) (PRINT-ESC 466))
    ((47) (PRINT-ESC 467))
    ((48) (PRINT-ESC 468))
    ((49) (PRINT-ESC 469))
    ((50) (PRINT-ESC 470))
    ((51) (PRINT-ESC 471))
    ((52) (PRINT-ESC 472))
    ((53) (PRINT-ESC 473))
    ((54) (PRINT-ESC 474))
    (ELSE (PRINT 475))))

(PROCEDURE FIX-DATE-AND-TIME ()
  (SETF SYS-TIME (* 12 60))
  (SETF SYS-DAY 4)
  (SETF SYS-MONTH 7)
  (SETF SYS-YEAR 1776)
  (SETF (SLOT (AREF EQTB 9183) INT) SYS-TIME)
  (SETF (SLOT (AREF EQTB 9184) INT) SYS-DAY)
  (SETF (SLOT (AREF EQTB 9185) INT) SYS-MONTH)
  (SETF (SLOT (AREF EQTB 9186) INT) SYS-YEAR))

(PROCEDURE BEGIN-DIAGNOSTIC ()
  (SETF OLD-SETTING SELECTOR)
  (WHEN (AND (<= (SLOT (AREF EQTB 9192) INT) 0) (= SELECTOR 19))
    (DECF SELECTOR 1)
    (WHEN (= HISTORY 0) (SETF HISTORY 1))))

(PROCEDURE END-DIAGNOSTIC ((BLANK-LINE BOOLEAN))
  (PRINT-NL 338)
  (WHEN BLANK-LINE (PRINT-LN))
  (SETF SELECTOR OLD-SETTING))

(PROCEDURE PRINT-LENGTH-PARAM ((N INTEGER))
  (CASE N
    ((0) (PRINT-ESC 478))
    ((1) (PRINT-ESC 479))
    ((2) (PRINT-ESC 480))
    ((3) (PRINT-ESC 481))
    ((4) (PRINT-ESC 482))
    ((5) (PRINT-ESC 483))
    ((6) (PRINT-ESC 484))
    ((7) (PRINT-ESC 485))
    ((8) (PRINT-ESC 486))
    ((9) (PRINT-ESC 487))
    ((10) (PRINT-ESC 488))
    ((11) (PRINT-ESC 489))
    ((12) (PRINT-ESC 490))
    ((13) (PRINT-ESC 491))
    ((14) (PRINT-ESC 492))
    ((15) (PRINT-ESC 493))
    ((16) (PRINT-ESC 494))
    ((17) (PRINT-ESC 495))
    ((18) (PRINT-ESC 496))
    ((19) (PRINT-ESC 497))
    ((20) (PRINT-ESC 498))
    (ELSE (PRINT 499))))

(PROCEDURE PRINT-CMD-CHR ((CMD QUARTERWORD) (CHR-CODE HALFWORD))
  (CASE CMD
    ((1) (PRINT 557) (PRINT CHR-CODE))
    ((2) (PRINT 558) (PRINT CHR-CODE))
    ((3) (PRINT 559) (PRINT CHR-CODE))
    ((6) (PRINT 560) (PRINT CHR-CODE))
    ((7) (PRINT 561) (PRINT CHR-CODE))
    ((8) (PRINT 562) (PRINT CHR-CODE))
    ((9) (PRINT 563))
    ((10) (PRINT 564) (PRINT CHR-CODE))
    ((11) (PRINT 565) (PRINT CHR-CODE))
    ((12) (PRINT 566) (PRINT CHR-CODE))
    ((75 76)
     (COND ((< CHR-CODE 6800) (PRINT-SKIP-PARAM (- CHR-CODE 6782)))
           ((< CHR-CODE 7056) (PRINT-ESC 395) (PRINT-INT (- CHR-CODE 6800)))
           (TRUE (PRINT-ESC 396) (PRINT-INT (- CHR-CODE 7056)))))
    ((72)
     (COND ((>= CHR-CODE 7322) (PRINT-ESC 407) (PRINT-INT (- CHR-CODE 7322)))
           (TRUE
            (CASE CHR-CODE
              ((7313) (PRINT-ESC 398))
              ((7314) (PRINT-ESC 399))
              ((7315) (PRINT-ESC 400))
              ((7316) (PRINT-ESC 401))
              ((7317) (PRINT-ESC 402))
              ((7318) (PRINT-ESC 403))
              ((7319) (PRINT-ESC 404))
              ((7320) (PRINT-ESC 405))
              (ELSE (PRINT-ESC 406))))))
    ((73)
     (COND ((< CHR-CODE 9218) (PRINT-PARAM (- CHR-CODE 9163)))
           (TRUE (PRINT-ESC 476) (PRINT-INT (- CHR-CODE 9218)))))
    ((74)
     (COND ((< CHR-CODE 9751) (PRINT-LENGTH-PARAM (- CHR-CODE 9730)))
           (TRUE (PRINT-ESC 500) (PRINT-INT (- CHR-CODE 9751)))))
    ((45) (PRINT-ESC 508))
    ((90) (PRINT-ESC 509))
    ((40) (PRINT-ESC 510))
    ((41) (PRINT-ESC 511))
    ((77) (PRINT-ESC 519))
    ((61) (PRINT-ESC 512))
    ((42) (PRINT-ESC 531))
    ((16) (PRINT-ESC 513))
    ((107) (PRINT-ESC 504))
    ((88) (PRINT-ESC 518))
    ((15) (PRINT-ESC 514))
    ((92) (PRINT-ESC 515))
    ((67) (PRINT-ESC 505))
    ((62) (PRINT-ESC 516))
    ((64) (PRINT-ESC 32))
    ((102) (PRINT-ESC 517))
    ((32) (PRINT-ESC 520))
    ((36) (PRINT-ESC 521))
    ((39) (PRINT-ESC 522))
    ((37) (PRINT-ESC 330))
    ((44) (PRINT-ESC 47))
    ((18) (PRINT-ESC 351))
    ((46) (PRINT-ESC 523))
    ((17) (PRINT-ESC 524))
    ((54) (PRINT-ESC 525))
    ((91) (PRINT-ESC 526))
    ((34) (PRINT-ESC 527))
    ((65) (PRINT-ESC 528))
    ((103) (PRINT-ESC 529))
    ((55) (PRINT-ESC 335))
    ((63) (PRINT-ESC 530))
    ((66) (PRINT-ESC 533))
    ((96) (PRINT-ESC 534))
    ((0) (PRINT-ESC 535))
    ((98) (PRINT-ESC 536))
    ((80) (PRINT-ESC 532))
    ((84) (PRINT-ESC 408))
    ((109) (PRINT-ESC 537))
    ((71) (PRINT-ESC 407))
    ((38) (PRINT-ESC 352))
    ((33) (PRINT-ESC 538))
    ((56) (PRINT-ESC 539))
    ((35) (PRINT-ESC 540))
    ((13) (PRINT-ESC 597))
    ((104) (COND ((= CHR-CODE 0) (PRINT-ESC 629)) (TRUE (PRINT-ESC 630))))
    ((110)
     (CASE CHR-CODE
       ((1) (PRINT-ESC 632))
       ((2) (PRINT-ESC 633))
       ((3) (PRINT-ESC 634))
       ((4) (PRINT-ESC 635))
       (ELSE (PRINT-ESC 631))))
    ((89)
     (COND ((= CHR-CODE 0) (PRINT-ESC 476))
           ((= CHR-CODE 1) (PRINT-ESC 500))
           ((= CHR-CODE 2) (PRINT-ESC 395))
           (TRUE (PRINT-ESC 396))))
    ((79) (COND ((= CHR-CODE 1) (PRINT-ESC 669)) (TRUE (PRINT-ESC 668))))
    ((82) (COND ((= CHR-CODE 0) (PRINT-ESC 670)) (TRUE (PRINT-ESC 671))))
    ((83)
     (COND ((= CHR-CODE 1) (PRINT-ESC 672))
           ((= CHR-CODE 3) (PRINT-ESC 673))
           (TRUE (PRINT-ESC 674))))
    ((70)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 675))
       ((1) (PRINT-ESC 676))
       ((2) (PRINT-ESC 677))
       ((3) (PRINT-ESC 678))
       (ELSE (PRINT-ESC 679))))
    ((108)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 735))
       ((1) (PRINT-ESC 736))
       ((2) (PRINT-ESC 737))
       ((3) (PRINT-ESC 738))
       ((4) (PRINT-ESC 739))
       (ELSE (PRINT-ESC 740))))
    ((105)
     (CASE CHR-CODE
       ((1) (PRINT-ESC 758))
       ((2) (PRINT-ESC 759))
       ((3) (PRINT-ESC 760))
       ((4) (PRINT-ESC 761))
       ((5) (PRINT-ESC 762))
       ((6) (PRINT-ESC 763))
       ((7) (PRINT-ESC 764))
       ((8) (PRINT-ESC 765))
       ((9) (PRINT-ESC 766))
       ((10) (PRINT-ESC 767))
       ((11) (PRINT-ESC 768))
       ((12) (PRINT-ESC 769))
       ((13) (PRINT-ESC 770))
       ((14) (PRINT-ESC 771))
       ((15) (PRINT-ESC 772))
       ((16) (PRINT-ESC 773))
       (ELSE (PRINT-ESC 757))))
    ((106)
     (COND ((= CHR-CODE 2) (PRINT-ESC 774))
           ((= CHR-CODE 4) (PRINT-ESC 775))
           (TRUE (PRINT-ESC 776))))
    ((4) (COND ((= CHR-CODE 256) (PRINT-ESC 898)) (TRUE (PRINT 902) (PRINT CHR-CODE))))
    ((5) (COND ((= CHR-CODE 257) (PRINT-ESC 899)) (TRUE (PRINT-ESC 900))))
    ((81)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 970))
       ((1) (PRINT-ESC 971))
       ((2) (PRINT-ESC 972))
       ((3) (PRINT-ESC 973))
       ((4) (PRINT-ESC 974))
       ((5) (PRINT-ESC 975))
       ((6) (PRINT-ESC 976))
       (ELSE (PRINT-ESC 977))))
    ((14) (COND ((= CHR-CODE 1) (PRINT-ESC 1026)) (TRUE (PRINT-ESC 1025))))
    ((26)
     (CASE CHR-CODE
       ((4) (PRINT-ESC 1027))
       ((0) (PRINT-ESC 1028))
       ((1) (PRINT-ESC 1029))
       ((2) (PRINT-ESC 1030))
       (ELSE (PRINT-ESC 1031))))
    ((27)
     (CASE CHR-CODE
       ((4) (PRINT-ESC 1032))
       ((0) (PRINT-ESC 1033))
       ((1) (PRINT-ESC 1034))
       ((2) (PRINT-ESC 1035))
       (ELSE (PRINT-ESC 1036))))
    ((28) (PRINT-ESC 336))
    ((29) (PRINT-ESC 340))
    ((30) (PRINT-ESC 342))
    ((21) (COND ((= CHR-CODE 1) (PRINT-ESC 1054)) (TRUE (PRINT-ESC 1055))))
    ((22) (COND ((= CHR-CODE 1) (PRINT-ESC 1056)) (TRUE (PRINT-ESC 1057))))
    ((20)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 409))
       ((1) (PRINT-ESC 1058))
       ((2) (PRINT-ESC 1059))
       ((3) (PRINT-ESC 965))
       ((4) (PRINT-ESC 1060))
       ((5) (PRINT-ESC 967))
       (ELSE (PRINT-ESC 1061))))
    ((31)
     (COND ((= CHR-CODE 100) (PRINT-ESC 1063))
           ((= CHR-CODE 101) (PRINT-ESC 1064))
           ((= CHR-CODE 102) (PRINT-ESC 1065))
           (TRUE (PRINT-ESC 1062))))
    ((43) (COND ((= CHR-CODE 0) (PRINT-ESC 1081)) (TRUE (PRINT-ESC 1080))))
    ((25)
     (COND ((= CHR-CODE 10) (PRINT-ESC 1092))
           ((= CHR-CODE 11) (PRINT-ESC 1091))
           (TRUE (PRINT-ESC 1090))))
    ((23) (COND ((= CHR-CODE 1) (PRINT-ESC 1094)) (TRUE (PRINT-ESC 1093))))
    ((24) (COND ((= CHR-CODE 1) (PRINT-ESC 1096)) (TRUE (PRINT-ESC 1095))))
    ((47) (COND ((= CHR-CODE 1) (PRINT-ESC 45)) (TRUE (PRINT-ESC 349))))
    ((48) (COND ((= CHR-CODE 1) (PRINT-ESC 1128)) (TRUE (PRINT-ESC 1127))))
    ((50)
     (CASE CHR-CODE
       ((16) (PRINT-ESC 866))
       ((17) (PRINT-ESC 867))
       ((18) (PRINT-ESC 868))
       ((19) (PRINT-ESC 869))
       ((20) (PRINT-ESC 870))
       ((21) (PRINT-ESC 871))
       ((22) (PRINT-ESC 872))
       ((23) (PRINT-ESC 873))
       ((26) (PRINT-ESC 875))
       (ELSE (PRINT-ESC 874))))
    ((51)
     (COND ((= CHR-CODE 1) (PRINT-ESC 878))
           ((= CHR-CODE 2) (PRINT-ESC 879))
           (TRUE (PRINT-ESC 1129))))
    ((53) (PRINT-STYLE CHR-CODE))
    ((52)
     (CASE CHR-CODE
       ((1) (PRINT-ESC 1148))
       ((2) (PRINT-ESC 1149))
       ((3) (PRINT-ESC 1150))
       ((4) (PRINT-ESC 1151))
       ((5) (PRINT-ESC 1152))
       (ELSE (PRINT-ESC 1147))))
    ((49) (COND ((= CHR-CODE 30) (PRINT-ESC 876)) (TRUE (PRINT-ESC 877))))
    ((93)
     (COND ((= CHR-CODE 1) (PRINT-ESC 1171))
           ((= CHR-CODE 2) (PRINT-ESC 1172))
           (TRUE (PRINT-ESC 1173))))
    ((97)
     (COND ((= CHR-CODE 0) (PRINT-ESC 1174))
           ((= CHR-CODE 1) (PRINT-ESC 1175))
           ((= CHR-CODE 2) (PRINT-ESC 1176))
           (TRUE (PRINT-ESC 1177))))
    ((94) (COND ((/= CHR-CODE 0) (PRINT-ESC 1192)) (TRUE (PRINT-ESC 1191))))
    ((95)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 1193))
       ((1) (PRINT-ESC 1194))
       ((2) (PRINT-ESC 1195))
       ((3) (PRINT-ESC 1196))
       ((4) (PRINT-ESC 1197))
       ((5) (PRINT-ESC 1198))
       (ELSE (PRINT-ESC 1199))))
    ((68) (PRINT-ESC 513) (PRINT-HEX CHR-CODE))
    ((69) (PRINT-ESC 524) (PRINT-HEX CHR-CODE))
    ((85)
     (COND ((= CHR-CODE 7883) (PRINT-ESC 415))
           ((= CHR-CODE 8907) (PRINT-ESC 419))
           ((= CHR-CODE 8139) (PRINT-ESC 416))
           ((= CHR-CODE 8395) (PRINT-ESC 417))
           ((= CHR-CODE 8651) (PRINT-ESC 418))
           (TRUE (PRINT-ESC 477))))
    ((86) (PRINT-SIZE (- CHR-CODE 7835)))
    ((99) (COND ((= CHR-CODE 1) (PRINT-ESC 953)) (TRUE (PRINT-ESC 941))))
    ((78) (COND ((= CHR-CODE 0) (PRINT-ESC 1217)) (TRUE (PRINT-ESC 1218))))
    ((87) (PRINT 1226) (SLOW-PRINT (AREF FONT-NAME CHR-CODE))
     (WHEN (/= (AREF FONT-SIZE CHR-CODE) (AREF FONT-DSIZE CHR-CODE))
       (PRINT 741)
       (PRINT-SCALED (AREF FONT-SIZE CHR-CODE))
       (PRINT 397)))
    ((100)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 274))
       ((1) (PRINT-ESC 275))
       ((2) (PRINT-ESC 276))
       (ELSE (PRINT-ESC 1227))))
    ((60) (COND ((= CHR-CODE 0) (PRINT-ESC 1229)) (TRUE (PRINT-ESC 1228))))
    ((58) (COND ((= CHR-CODE 0) (PRINT-ESC 1230)) (TRUE (PRINT-ESC 1231))))
    ((57) (COND ((= CHR-CODE 8139) (PRINT-ESC 1237)) (TRUE (PRINT-ESC 1238))))
    ((19)
     (CASE CHR-CODE
       ((1) (PRINT-ESC 1240))
       ((2) (PRINT-ESC 1241))
       ((3) (PRINT-ESC 1242))
       (ELSE (PRINT-ESC 1239))))
    ((101) (PRINT 1249))
    ((111) (PRINT 1250))
    ((112) (PRINT-ESC 1251))
    ((113) (PRINT-ESC 1252))
    ((114) (PRINT-ESC 1171) (PRINT-ESC 1252))
    ((115) (PRINT-ESC 1253))
    ((59)
     (CASE CHR-CODE
       ((0) (PRINT-ESC 1285))
       ((1) (PRINT-ESC 594))
       ((2) (PRINT-ESC 1286))
       ((3) (PRINT-ESC 1287))
       ((4) (PRINT-ESC 1288))
       ((5) (PRINT-ESC 1289))
       (ELSE (PRINT 1290))))
    (ELSE (PRINT 567))))

(FUNCTION (ID-LOOKUP HALFWORD) ((J INTEGER) (L INTEGER))
  (LABEL $L.40)
  (VAR H INTEGER)
  (VAR D INTEGER)
  (VAR P HALFWORD)
  (VAR K HALFWORD)
  (SETF H (AREF BUFFER J))
  (FOR (K (+ J 1) TO (- (+ J L) 1))
    (SETF H (+ (+ H H) (AREF BUFFER K)))
    (WHILE (>= H 1777) (DECF H 1777)))
  (SETF P (+ H 514))
  (WHILE TRUE
    (WHEN (> (SLOT (AREF HASH P) RH) 0)
      (WHEN (= (- (AREF STR-START (+ (SLOT (AREF HASH P) RH) 1))
                  (AREF STR-START (SLOT (AREF HASH P) RH)))
               L)
        (WHEN (STR-EQ-BUF (SLOT (AREF HASH P) RH) J) (GOTO $L.40))))
    (WHEN (= (SLOT (AREF HASH P) LH) 0)
      (COND (NO-NEW-CONTROL-SEQUENCE (SETF P 6781))
            (TRUE
             (WHEN (> (SLOT (AREF HASH P) RH) 0)
               (REPEAT (WHEN (= HASH-USED 514) (OVERFLOW 503 6000))
                       (DECF HASH-USED 1)
                       (UNTIL (= (SLOT (AREF HASH HASH-USED) RH) 0)))
               (SETF (SLOT (AREF HASH P) LH) HASH-USED)
               (SETF P HASH-USED))
             (WHEN (> (+ POOL-PTR L) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
             (SETF D (- POOL-PTR (AREF STR-START STR-PTR)))
             (WHILE (> POOL-PTR (AREF STR-START STR-PTR))
               (DECF POOL-PTR 1)
               (SETF (AREF STR-POOL (+ POOL-PTR L)) (AREF STR-POOL POOL-PTR)))
             (FOR (K J TO (- (+ J L) 1))
               (SETF (AREF STR-POOL POOL-PTR) (AREF BUFFER K))
               (INCF POOL-PTR 1))
             (SETF (SLOT (AREF HASH P) RH) MAKE-STRING)
             (INCF POOL-PTR D)))
      (GOTO $L.40))
    (SETF P (SLOT (AREF HASH P) LH)))
  $L.40
  (SETF ID-LOOKUP P))

(PROCEDURE PRIMITIVE ((S STR-NUMBER) (C QUARTERWORD) (O HALFWORD))
  (VAR K POOL-POINTER)
  (VAR J SMALL-NUMBER)
  (VAR L SMALL-NUMBER)
  (COND ((< S 256) (SETF CUR-VAL (+ S 257)))
        (TRUE
         (SETF K (AREF STR-START S))
         (SETF L (- (AREF STR-START (+ S 1)) K))
         (FOR (J 0 TO (- L 1)) (SETF (AREF BUFFER J) (AREF STR-POOL (+ K J))))
         (SETF CUR-VAL (ID-LOOKUP 0 L))
         (DECF STR-PTR 1)
         (SETF POOL-PTR (AREF STR-START STR-PTR))
         (SETF (SLOT (AREF HASH CUR-VAL) RH) S)))
  (SETF (SLOT (SLOT (AREF EQTB CUR-VAL) HH) B1) 1)
  (SETF (SLOT (SLOT (AREF EQTB CUR-VAL) HH) B0) C)
  (SETF (SLOT (SLOT (AREF EQTB CUR-VAL) HH) RH) O))

(PROCEDURE NEW-SAVE-LEVEL ((C GROUP-CODE))
  (WHEN (> SAVE-PTR MAX-SAVE-STACK)
    (SETF MAX-SAVE-STACK SAVE-PTR)
    (WHEN (> MAX-SAVE-STACK (- SAVE-SIZE 6)) (OVERFLOW 541 SAVE-SIZE)))
  (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 3)
  (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B1) CUR-GROUP)
  (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) RH) CUR-BOUNDARY)
  (WHEN (= CUR-LEVEL 255) (OVERFLOW 542 255))
  (SETF CUR-BOUNDARY SAVE-PTR)
  (INCF CUR-LEVEL 1)
  (INCF SAVE-PTR 1)
  (SETF CUR-GROUP C))

(PROCEDURE EQ-DESTROY ((W MEMORY-WORD))
  (VAR Q HALFWORD)
  (CASE (SLOT (SLOT W HH) B0)
    ((111 112 113 114) (DELETE-TOKEN-REF (SLOT (SLOT W HH) RH)))
    ((117) (DELETE-GLUE-REF (SLOT (SLOT W HH) RH)))
    ((118) (SETF Q (SLOT (SLOT W HH) RH))
     (WHEN (/= Q 0)
       (FREE-NODE Q
                  (+ (+ (SLOT (SLOT (AREF MEM Q) HH) LH) (SLOT (SLOT (AREF MEM Q) HH) LH))
                     1))))
    ((119) (FLUSH-NODE-LIST (SLOT (SLOT W HH) RH)))
    (ELSE)))

(PROCEDURE EQ-SAVE ((P HALFWORD) (L QUARTERWORD))
  (WHEN (> SAVE-PTR MAX-SAVE-STACK)
    (SETF MAX-SAVE-STACK SAVE-PTR)
    (WHEN (> MAX-SAVE-STACK (- SAVE-SIZE 6)) (OVERFLOW 541 SAVE-SIZE)))
  (COND ((= L 0) (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 1))
        (TRUE
         (SETF (AREF SAVE-STACK SAVE-PTR) (AREF EQTB P))
         (INCF SAVE-PTR 1)
         (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 0)))
  (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B1) L)
  (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) RH) P)
  (INCF SAVE-PTR 1))

(PROCEDURE EQ-DEFINE ((P HALFWORD) (T QUARTERWORD) (E HALFWORD))
  (COND ((= (SLOT (SLOT (AREF EQTB P) HH) B1) CUR-LEVEL) (EQ-DESTROY (AREF EQTB P)))
        ((> CUR-LEVEL 1) (EQ-SAVE P (SLOT (SLOT (AREF EQTB P) HH) B1))))
  (SETF (SLOT (SLOT (AREF EQTB P) HH) B1) CUR-LEVEL)
  (SETF (SLOT (SLOT (AREF EQTB P) HH) B0) T)
  (SETF (SLOT (SLOT (AREF EQTB P) HH) RH) E))

(PROCEDURE EQ-WORD-DEFINE ((P HALFWORD) (W INTEGER))
  (WHEN (/= (AREF XEQ-LEVEL P) CUR-LEVEL)
    (EQ-SAVE P (AREF XEQ-LEVEL P))
    (SETF (AREF XEQ-LEVEL P) CUR-LEVEL))
  (SETF (SLOT (AREF EQTB P) INT) W))

(PROCEDURE GEQ-DEFINE ((P HALFWORD) (T QUARTERWORD) (E HALFWORD))
  (EQ-DESTROY (AREF EQTB P))
  (SETF (SLOT (SLOT (AREF EQTB P) HH) B1) 1)
  (SETF (SLOT (SLOT (AREF EQTB P) HH) B0) T)
  (SETF (SLOT (SLOT (AREF EQTB P) HH) RH) E))

(PROCEDURE GEQ-WORD-DEFINE ((P HALFWORD) (W INTEGER))
  (SETF (SLOT (AREF EQTB P) INT) W)
  (SETF (AREF XEQ-LEVEL P) 1))

(PROCEDURE SAVE-FOR-AFTER ((T HALFWORD))
  (WHEN (> CUR-LEVEL 1)
    (WHEN (> SAVE-PTR MAX-SAVE-STACK)
      (SETF MAX-SAVE-STACK SAVE-PTR)
      (WHEN (> MAX-SAVE-STACK (- SAVE-SIZE 6)) (OVERFLOW 541 SAVE-SIZE)))
    (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 2)
    (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B1) 0)
    (SETF (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) RH) T)
    (INCF SAVE-PTR 1)))

(PROCEDURE BACK-INPUT () :FORWARD)

(PROCEDURE UNSAVE ()
  (LABEL $L.30)
  (VAR P HALFWORD)
  (VAR L QUARTERWORD)
  (VAR T HALFWORD)
  (COND ((> CUR-LEVEL 1)
         (DECF CUR-LEVEL 1)
         (WHILE TRUE
           (DECF SAVE-PTR 1)
           (WHEN (= (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 3) (GOTO $L.30))
           (SETF P (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) RH))
           (COND ((= (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 2)
                  (SETF T CUR-TOK)
                  (SETF CUR-TOK P)
                  (BACK-INPUT)
                  (SETF CUR-TOK T))
                 (TRUE
                  (COND ((= (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B0) 0)
                         (SETF L (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B1))
                         (DECF SAVE-PTR 1))
                        (TRUE (SETF (AREF SAVE-STACK SAVE-PTR) (AREF EQTB 6781))))
                  (COND ((< P 9163)
                         (COND ((= (SLOT (SLOT (AREF EQTB P) HH) B1) 1)
                                (EQ-DESTROY (AREF SAVE-STACK SAVE-PTR)))
                               (TRUE
                                (EQ-DESTROY (AREF EQTB P))
                                (SETF (AREF EQTB P) (AREF SAVE-STACK SAVE-PTR)))))
                        ((/= (AREF XEQ-LEVEL P) 1)
                         (SETF (AREF EQTB P) (AREF SAVE-STACK SAVE-PTR))
                         (SETF (AREF XEQ-LEVEL P) L))
                        (TRUE)))))
         $L.30
         (SETF CUR-GROUP (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) B1))
         (SETF CUR-BOUNDARY (SLOT (SLOT (AREF SAVE-STACK SAVE-PTR) HH) RH)))
        (TRUE (CONFUSION 543))))

(PROCEDURE PREPARE-MAG ()
  (WHEN (AND (> MAG-SET 0) (/= (SLOT (AREF EQTB 9180) INT) MAG-SET))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 547)
    (PRINT-INT (SLOT (AREF EQTB 9180) INT))
    (PRINT 548)
    (PRINT-NL 549)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 550)
    (SETF (AREF HELP-LINE 0) 551)
    (INT-ERROR MAG-SET)
    (GEQ-WORD-DEFINE 9180 MAG-SET))
  (WHEN (OR (<= (SLOT (AREF EQTB 9180) INT) 0) (> (SLOT (AREF EQTB 9180) INT) 32768))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 552)
    (SETF HELP-PTR 1)
    (SETF (AREF HELP-LINE 0) 553)
    (INT-ERROR (SLOT (AREF EQTB 9180) INT))
    (GEQ-WORD-DEFINE 9180 1000))
  (SETF MAG-SET (SLOT (AREF EQTB 9180) INT)))

(PROCEDURE TOKEN-SHOW ((P HALFWORD))
  (WHEN (/= P 0) (SHOW-TOKEN-LIST (SLOT (SLOT (AREF MEM P) HH) RH) 0 10000000)))

(PROCEDURE PRINT-MEANING ()
  (PRINT-CMD-CHR CUR-CMD CUR-CHR)
  (COND ((>= CUR-CMD 111) (PRINT-CHAR 58) (PRINT-LN) (TOKEN-SHOW CUR-CHR))
        ((= CUR-CMD 110) (PRINT-CHAR 58) (PRINT-LN) (TOKEN-SHOW (AREF CUR-MARK CUR-CHR)))))

(PROCEDURE SHOW-CUR-CMD-CHR ()
  (BEGIN-DIAGNOSTIC)
  (PRINT-NL 123)
  (WHEN (/= (SLOT CUR-LIST MODE-FIELD) SHOWN-MODE)
    (PRINT-MODE (SLOT CUR-LIST MODE-FIELD))
    (PRINT 568)
    (SETF SHOWN-MODE (SLOT CUR-LIST MODE-FIELD)))
  (PRINT-CMD-CHR CUR-CMD CUR-CHR)
  (PRINT-CHAR 125)
  (END-DIAGNOSTIC FALSE))

(PROCEDURE SHOW-CONTEXT ()
  (LABEL $L.30)
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR NN INTEGER)
  (VAR BOTTOM-LINE BOOLEAN)
  (VAR I (RANGE 0 BUF-SIZE))
  (VAR J (RANGE 0 BUF-SIZE))
  (VAR L (RANGE 0 HALF-ERROR-LINE))
  (VAR M INTEGER)
  (VAR N (RANGE 0 ERROR-LINE))
  (VAR P INTEGER)
  (VAR Q INTEGER)
  (SETF BASE-PTR INPUT-PTR)
  (SETF (AREF INPUT-STACK BASE-PTR) CUR-INPUT)
  (SETF NN (- 1))
  (SETF BOTTOM-LINE FALSE)
  (WHILE TRUE
    (SETF CUR-INPUT (AREF INPUT-STACK BASE-PTR))
    (WHEN (/= (SLOT CUR-INPUT STATE-FIELD) 0)
      (WHEN (OR (> (SLOT CUR-INPUT NAME-FIELD) 17) (= BASE-PTR 0)) (SETF BOTTOM-LINE TRUE)))
    (COND ((OR (OR (= BASE-PTR INPUT-PTR) BOTTOM-LINE) (< NN (SLOT (AREF EQTB 9217) INT)))
           (WHEN (OR (OR (OR (= BASE-PTR INPUT-PTR) (/= (SLOT CUR-INPUT STATE-FIELD) 0))
                         (/= (SLOT CUR-INPUT INDEX-FIELD) 3))
                     (/= (SLOT CUR-INPUT LOC-FIELD) 0))
             (SETF TALLY 0)
             (SETF OLD-SETTING SELECTOR)
             (COND ((/= (SLOT CUR-INPUT STATE-FIELD) 0)
                    (COND ((<= (SLOT CUR-INPUT NAME-FIELD) 17)
                           (COND ((= (SLOT CUR-INPUT NAME-FIELD) 0)
                                  (COND ((= BASE-PTR 0) (PRINT-NL 574)) (TRUE (PRINT-NL 575))))
                                 (TRUE
                                  (PRINT-NL 576)
                                  (COND ((= (SLOT CUR-INPUT NAME-FIELD) 17) (PRINT-CHAR 42))
                                        (TRUE (PRINT-INT (- (SLOT CUR-INPUT NAME-FIELD) 1))))
                                  (PRINT-CHAR 62))))
                          (TRUE (PRINT-NL 577) (PRINT-INT LINE)))
                    (PRINT-CHAR 32)
                    (SETF L TALLY)
                    (SETF TALLY 0)
                    (SETF SELECTOR 20)
                    (SETF TRICK-COUNT 1000000)
                    (COND ((= (AREF BUFFER (SLOT CUR-INPUT LIMIT-FIELD))
                              (SLOT (AREF EQTB 9211) INT))
                           (SETF J (SLOT CUR-INPUT LIMIT-FIELD)))
                          (TRUE (SETF J (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))))
                    (WHEN (> J 0)
                      (FOR (I (SLOT CUR-INPUT START-FIELD) TO (- J 1))
                        (WHEN (= I (SLOT CUR-INPUT LOC-FIELD))
                          (SETF FIRST-COUNT TALLY)
                          (SETF TRICK-COUNT (- (+ (+ TALLY 1) ERROR-LINE) HALF-ERROR-LINE))
                          (WHEN (< TRICK-COUNT ERROR-LINE) (SETF TRICK-COUNT ERROR-LINE)))
                        (PRINT (AREF BUFFER I)))))
                   (TRUE
                    (CASE (SLOT CUR-INPUT INDEX-FIELD)
                      ((0) (PRINT-NL 578))
                      ((1 2) (PRINT-NL 579))
                      ((3)
                       (COND ((= (SLOT CUR-INPUT LOC-FIELD) 0) (PRINT-NL 580))
                             (TRUE (PRINT-NL 581))))
                      ((4) (PRINT-NL 582))
                      ((5) (PRINT-LN) (PRINT-CS (SLOT CUR-INPUT NAME-FIELD)))
                      ((6) (PRINT-NL 583))
                      ((7) (PRINT-NL 584))
                      ((8) (PRINT-NL 585))
                      ((9) (PRINT-NL 586))
                      ((10) (PRINT-NL 587))
                      ((11) (PRINT-NL 588))
                      ((12) (PRINT-NL 589))
                      ((13) (PRINT-NL 590))
                      ((14) (PRINT-NL 591))
                      ((15) (PRINT-NL 592))
                      (ELSE (PRINT-NL 63)))
                    (SETF L TALLY)
                    (SETF TALLY 0)
                    (SETF SELECTOR 20)
                    (SETF TRICK-COUNT 1000000)
                    (COND ((< (SLOT CUR-INPUT INDEX-FIELD) 5)
                           (SHOW-TOKEN-LIST
                             (SLOT CUR-INPUT START-FIELD)
                             (SLOT CUR-INPUT LOC-FIELD)
                             100000))
                          (TRUE
                           (SHOW-TOKEN-LIST
                             (SLOT (SLOT (AREF MEM (SLOT CUR-INPUT START-FIELD)) HH) RH)
                             (SLOT CUR-INPUT LOC-FIELD)
                             100000)))))
             (SETF SELECTOR OLD-SETTING)
             (WHEN (= TRICK-COUNT 1000000)
               (SETF FIRST-COUNT TALLY)
               (SETF TRICK-COUNT (- (+ (+ TALLY 1) ERROR-LINE) HALF-ERROR-LINE))
               (WHEN (< TRICK-COUNT ERROR-LINE) (SETF TRICK-COUNT ERROR-LINE)))
             (COND ((< TALLY TRICK-COUNT) (SETF M (- TALLY FIRST-COUNT)))
                   (TRUE (SETF M (- TRICK-COUNT FIRST-COUNT))))
             (COND ((<= (+ L FIRST-COUNT) HALF-ERROR-LINE)
                    (SETF P 0)
                    (SETF N (+ L FIRST-COUNT)))
                   (TRUE
                    (PRINT 277)
                    (SETF P (+ (- (+ L FIRST-COUNT) HALF-ERROR-LINE) 3))
                    (SETF N HALF-ERROR-LINE)))
             (FOR (Q P TO (- FIRST-COUNT 1)) (PRINT-CHAR (AREF TRICK-BUF (MOD Q ERROR-LINE))))
             (PRINT-LN)
             (FOR (Q 1 TO N) (PRINT-CHAR 32))
             (COND ((<= (+ M N) ERROR-LINE) (SETF P (+ FIRST-COUNT M)))
                   (TRUE (SETF P (+ FIRST-COUNT (- (- ERROR-LINE N) 3)))))
             (FOR (Q FIRST-COUNT TO (- P 1)) (PRINT-CHAR (AREF TRICK-BUF (MOD Q ERROR-LINE))))
             (WHEN (> (+ M N) ERROR-LINE) (PRINT 277))
             (INCF NN 1)))
          ((= NN (SLOT (AREF EQTB 9217) INT)) (PRINT-NL 277) (INCF NN 1)))
    (WHEN BOTTOM-LINE (GOTO $L.30))
    (DECF BASE-PTR 1))
  $L.30
  (SETF CUR-INPUT (AREF INPUT-STACK INPUT-PTR)))

(PROCEDURE BEGIN-TOKEN-LIST ((P HALFWORD) (T QUARTERWORD))
  (WHEN (> INPUT-PTR MAX-IN-STACK)
    (SETF MAX-IN-STACK INPUT-PTR)
    (WHEN (= INPUT-PTR STACK-SIZE) (OVERFLOW 593 STACK-SIZE)))
  (SETF (AREF INPUT-STACK INPUT-PTR) CUR-INPUT)
  (INCF INPUT-PTR 1)
  (SETF (SLOT CUR-INPUT STATE-FIELD) 0)
  (SETF (SLOT CUR-INPUT START-FIELD) P)
  (SETF (SLOT CUR-INPUT INDEX-FIELD) T)
  (COND ((>= T 5)
         (SETF (SLOT (SLOT (AREF MEM P) HH) LH) (+ (SLOT (SLOT (AREF MEM P) HH) LH) 1))
         (COND ((= T 5) (SETF (SLOT CUR-INPUT LIMIT-FIELD) PARAM-PTR))
               (TRUE
                (SETF (SLOT CUR-INPUT LOC-FIELD) (SLOT (SLOT (AREF MEM P) HH) RH))
                (WHEN (> (SLOT (AREF EQTB 9193) INT) 1)
                  (BEGIN-DIAGNOSTIC)
                  (PRINT-NL 338)
                  (CASE T
                    ((14) (PRINT-ESC 351))
                    ((15) (PRINT-ESC 594))
                    (ELSE (PRINT-CMD-CHR 72 (+ T 7307))))
                  (PRINT 556)
                  (TOKEN-SHOW P)
                  (END-DIAGNOSTIC FALSE)))))
        (TRUE (SETF (SLOT CUR-INPUT LOC-FIELD) P))))

(PROCEDURE END-TOKEN-LIST ()
  (COND ((>= (SLOT CUR-INPUT INDEX-FIELD) 3)
         (COND ((<= (SLOT CUR-INPUT INDEX-FIELD) 4) (FLUSH-LIST (SLOT CUR-INPUT START-FIELD)))
               (TRUE
                (DELETE-TOKEN-REF (SLOT CUR-INPUT START-FIELD))
                (WHEN (= (SLOT CUR-INPUT INDEX-FIELD) 5)
                  (WHILE (> PARAM-PTR (SLOT CUR-INPUT LIMIT-FIELD))
                    (DECF PARAM-PTR 1)
                    (FLUSH-LIST (AREF PARAM-STACK PARAM-PTR)))))))
        ((= (SLOT CUR-INPUT INDEX-FIELD) 1)
         (COND ((> ALIGN-STATE 500000) (SETF ALIGN-STATE 0)) (TRUE (FATAL-ERROR 595)))))
  (DECF INPUT-PTR 1)
  (SETF CUR-INPUT (AREF INPUT-STACK INPUT-PTR))
  (WHEN (/= INTERRUPT 0) (PAUSE-FOR-INSTRUCTIONS)))

(PROCEDURE BACK-INPUT ()
  (VAR P HALFWORD)
  (WHILE (AND (AND (= (SLOT CUR-INPUT STATE-FIELD) 0) (= (SLOT CUR-INPUT LOC-FIELD) 0))
              (/= (SLOT CUR-INPUT INDEX-FIELD) 2))
    (END-TOKEN-LIST))
  (SETF P GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM P) HH) LH) CUR-TOK)
  (WHEN (< CUR-TOK 768)
    (COND ((< CUR-TOK 512) (DECF ALIGN-STATE 1)) (TRUE (INCF ALIGN-STATE 1))))
  (WHEN (> INPUT-PTR MAX-IN-STACK)
    (SETF MAX-IN-STACK INPUT-PTR)
    (WHEN (= INPUT-PTR STACK-SIZE) (OVERFLOW 593 STACK-SIZE)))
  (SETF (AREF INPUT-STACK INPUT-PTR) CUR-INPUT)
  (INCF INPUT-PTR 1)
  (SETF (SLOT CUR-INPUT STATE-FIELD) 0)
  (SETF (SLOT CUR-INPUT START-FIELD) P)
  (SETF (SLOT CUR-INPUT INDEX-FIELD) 3)
  (SETF (SLOT CUR-INPUT LOC-FIELD) P))

(PROCEDURE BACK-ERROR ()
  (SETF OK-TO-INTERRUPT FALSE)
  (BACK-INPUT)
  (SETF OK-TO-INTERRUPT TRUE)
  (ERROR))

(PROCEDURE INS-ERROR ()
  (SETF OK-TO-INTERRUPT FALSE)
  (BACK-INPUT)
  (SETF (SLOT CUR-INPUT INDEX-FIELD) 4)
  (SETF OK-TO-INTERRUPT TRUE)
  (ERROR))

(PROCEDURE BEGIN-FILE-READING ()
  (WHEN (= IN-OPEN MAX-IN-OPEN) (OVERFLOW 596 MAX-IN-OPEN))
  (WHEN (= FIRST BUF-SIZE) (OVERFLOW 256 BUF-SIZE))
  (INCF IN-OPEN 1)
  (WHEN (> INPUT-PTR MAX-IN-STACK)
    (SETF MAX-IN-STACK INPUT-PTR)
    (WHEN (= INPUT-PTR STACK-SIZE) (OVERFLOW 593 STACK-SIZE)))
  (SETF (AREF INPUT-STACK INPUT-PTR) CUR-INPUT)
  (INCF INPUT-PTR 1)
  (SETF (SLOT CUR-INPUT INDEX-FIELD) IN-OPEN)
  (SETF (AREF LINE-STACK (SLOT CUR-INPUT INDEX-FIELD)) LINE)
  (SETF (SLOT CUR-INPUT START-FIELD) FIRST)
  (SETF (SLOT CUR-INPUT STATE-FIELD) 1)
  (SETF (SLOT CUR-INPUT NAME-FIELD) 0))

(PROCEDURE END-FILE-READING ()
  (SETF FIRST (SLOT CUR-INPUT START-FIELD))
  (SETF LINE (AREF LINE-STACK (SLOT CUR-INPUT INDEX-FIELD)))
  (WHEN (> (SLOT CUR-INPUT NAME-FIELD) 17)
    (A-CLOSE (AREF INPUT-FILE (SLOT CUR-INPUT INDEX-FIELD))))
  (DECF INPUT-PTR 1)
  (SETF CUR-INPUT (AREF INPUT-STACK INPUT-PTR))
  (DECF IN-OPEN 1))

(PROCEDURE CLEAR-FOR-ERROR-PROMPT ()
  (WHILE (AND (AND (AND (/= (SLOT CUR-INPUT STATE-FIELD) 0) (= (SLOT CUR-INPUT NAME-FIELD) 0))
                   (> INPUT-PTR 0))
              (> (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD)))
    (END-FILE-READING))
  (PRINT-LN)
  (BREAK-IN TERM-IN TRUE))

(PROCEDURE CHECK-OUTER-VALIDITY ()
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (WHEN (/= SCANNER-STATUS 0)
    (SETF DELETIONS-ALLOWED FALSE)
    (WHEN (/= CUR-CS 0)
      (WHEN (OR (OR (= (SLOT CUR-INPUT STATE-FIELD) 0) (< (SLOT CUR-INPUT NAME-FIELD) 1))
                (> (SLOT CUR-INPUT NAME-FIELD) 17))
        (SETF P GET-AVAIL)
        (SETF (SLOT (SLOT (AREF MEM P) HH) LH) (+ 4095 CUR-CS))
        (BEGIN-TOKEN-LIST P 3))
      (SETF CUR-CMD 10)
      (SETF CUR-CHR 32))
    (COND ((> SCANNER-STATUS 1)
           (RUNAWAY)
           (COND ((= CUR-CS 0) (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 604))
                 (TRUE (SETF CUR-CS 0) (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 605)))
           (PRINT 606)
           (SETF P GET-AVAIL)
           (CASE SCANNER-STATUS
             ((2) (PRINT 570) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 637))
             ((3) (PRINT 612) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) PAR-TOKEN)
              (SETF LONG-STATE 113))
             ((4) (PRINT 572) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 637) (SETF Q P)
              (SETF P GET-AVAIL) (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
              (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 10610) (SETF ALIGN-STATE (- 1000000)))
             ((5) (PRINT 573) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 637)))
           (BEGIN-TOKEN-LIST P 4)
           (PRINT 607)
           (SPRINT-CS WARNING-INDEX)
           (SETF HELP-PTR 4)
           (SETF (AREF HELP-LINE 3) 608)
           (SETF (AREF HELP-LINE 2) 609)
           (SETF (AREF HELP-LINE 1) 610)
           (SETF (AREF HELP-LINE 0) 611)
           (ERROR))
          (TRUE
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 598)
           (PRINT-CMD-CHR 105 CUR-IF)
           (PRINT 599)
           (PRINT-INT SKIP-LINE)
           (SETF HELP-PTR 3)
           (SETF (AREF HELP-LINE 2) 600)
           (SETF (AREF HELP-LINE 1) 601)
           (SETF (AREF HELP-LINE 0) 602)
           (COND ((/= CUR-CS 0) (SETF CUR-CS 0)) (TRUE (SETF (AREF HELP-LINE 2) 603)))
           (SETF CUR-TOK 10613)
           (INS-ERROR)))
    (SETF DELETIONS-ALLOWED TRUE)))

(PROCEDURE FIRM-UP-THE-LINE () :FORWARD)

(PROCEDURE GET-NEXT ()
  (LABEL $L.20)
  (LABEL $L.25)
  (LABEL $L.21)
  (LABEL $L.26)
  (LABEL $L.40)
  (LABEL $L.10)
  (VAR K (RANGE 0 BUF-SIZE))
  (VAR T HALFWORD)
  (VAR CAT (RANGE 0 15))
  (VAR C ASCII-CODE)
  (VAR CC ASCII-CODE)
  (VAR D (RANGE 2 3))
  $L.20
  (SETF CUR-CS 0)
  (COND ((/= (SLOT CUR-INPUT STATE-FIELD) 0)
         $L.25
         (COND ((<= (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
                (SETF CUR-CHR (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)))
                (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LOC-FIELD) 1))
                $L.21
                (SETF CUR-CMD (SLOT (SLOT (AREF EQTB (+ 7883 CUR-CHR)) HH) RH))
                (CASE (+ (SLOT CUR-INPUT STATE-FIELD) CUR-CMD)
                  ((10 26 42 27 43) (GOTO $L.25))
                  ((1 17 33)
                   (COND ((> (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
                          (SETF CUR-CS 513))
                         (TRUE
                          $L.26
                          (SETF K (SLOT CUR-INPUT LOC-FIELD))
                          (SETF CUR-CHR (AREF BUFFER K))
                          (SETF CAT (SLOT (SLOT (AREF EQTB (+ 7883 CUR-CHR)) HH) RH))
                          (INCF K 1)
                          (COND ((= CAT 11) (SETF (SLOT CUR-INPUT STATE-FIELD) 17))
                                ((= CAT 10) (SETF (SLOT CUR-INPUT STATE-FIELD) 17))
                                (TRUE (SETF (SLOT CUR-INPUT STATE-FIELD) 1)))
                          (COND ((AND (= CAT 11) (<= K (SLOT CUR-INPUT LIMIT-FIELD)))
                                 (REPEAT (SETF CUR-CHR (AREF BUFFER K))
                                         (SETF CAT
                                               (SLOT (SLOT (AREF EQTB (+ 7883 CUR-CHR)) HH)
                                                     RH))
                                         (INCF K 1)
                                         (UNTIL
                                          (OR (/= CAT 11) (> K (SLOT CUR-INPUT LIMIT-FIELD)))))
                                 (WHEN (= (AREF BUFFER K) CUR-CHR)
                                   (WHEN (= CAT 7)
                                     (WHEN (< K (SLOT CUR-INPUT LIMIT-FIELD))
                                       (SETF C (AREF BUFFER (+ K 1)))
                                       (WHEN (< C 128)
                                         (SETF D 2)
                                         (WHEN (OR (AND (>= C 48) (<= C 57))
                                                   (AND (>= C 97) (<= C 102)))
                                           (WHEN (<= (+ K 2) (SLOT CUR-INPUT LIMIT-FIELD))
                                             (SETF CC (AREF BUFFER (+ K 2)))
                                             (WHEN (OR (AND (>= CC 48) (<= CC 57))
                                                       (AND (>= CC 97) (<= CC 102)))
                                               (INCF D 1))))
                                         (COND ((> D 2)
                                                (COND ((<= C 57) (SETF CUR-CHR (- C 48)))
                                                      (TRUE (SETF CUR-CHR (- C 87))))
                                                (COND ((<= CC 57)
                                                       (SETF
                                                        CUR-CHR
                                                        (- (+ (* 16 CUR-CHR) CC) 48)))
                                                      (TRUE
                                                       (SETF
                                                        CUR-CHR
                                                        (- (+ (* 16 CUR-CHR) CC) 87))))
                                                (SETF (AREF BUFFER (- K 1)) CUR-CHR))
                                               ((< C 64) (SETF (AREF BUFFER (- K 1)) (+ C 64)))
                                               (TRUE (SETF (AREF BUFFER (- K 1)) (- C 64))))
                                         (SETF (SLOT CUR-INPUT LIMIT-FIELD)
                                               (- (SLOT CUR-INPUT LIMIT-FIELD) D))
                                         (DECF FIRST D)
                                         (WHILE (<= K (SLOT CUR-INPUT LIMIT-FIELD))
                                           (SETF (AREF BUFFER K) (AREF BUFFER (+ K D)))
                                           (INCF K 1))
                                         (GOTO $L.26)))))
                                 (WHEN (/= CAT 11) (DECF K 1))
                                 (WHEN (> K (+ (SLOT CUR-INPUT LOC-FIELD) 1))
                                   (SETF CUR-CS
                                         (ID-LOOKUP (SLOT CUR-INPUT LOC-FIELD)
                                                    (- K (SLOT CUR-INPUT LOC-FIELD))))
                                   (SETF (SLOT CUR-INPUT LOC-FIELD) K)
                                   (GOTO $L.40)))
                                ((= (AREF BUFFER K) CUR-CHR)
                                 (WHEN (= CAT 7)
                                   (WHEN (< K (SLOT CUR-INPUT LIMIT-FIELD))
                                     (SETF C (AREF BUFFER (+ K 1)))
                                     (WHEN (< C 128)
                                       (SETF D 2)
                                       (WHEN (OR (AND (>= C 48) (<= C 57))
                                                 (AND (>= C 97) (<= C 102)))
                                         (WHEN (<= (+ K 2) (SLOT CUR-INPUT LIMIT-FIELD))
                                           (SETF CC (AREF BUFFER (+ K 2)))
                                           (WHEN (OR (AND (>= CC 48) (<= CC 57))
                                                     (AND (>= CC 97) (<= CC 102)))
                                             (INCF D 1))))
                                       (COND ((> D 2)
                                              (COND ((<= C 57) (SETF CUR-CHR (- C 48)))
                                                    (TRUE (SETF CUR-CHR (- C 87))))
                                              (COND ((<= CC 57)
                                                     (SETF CUR-CHR
                                                           (- (+ (* 16 CUR-CHR) CC) 48)))
                                                    (TRUE
                                                     (SETF CUR-CHR
                                                           (- (+ (* 16 CUR-CHR) CC) 87))))
                                              (SETF (AREF BUFFER (- K 1)) CUR-CHR))
                                             ((< C 64) (SETF (AREF BUFFER (- K 1)) (+ C 64)))
                                             (TRUE (SETF (AREF BUFFER (- K 1)) (- C 64))))
                                       (SETF (SLOT CUR-INPUT LIMIT-FIELD)
                                             (- (SLOT CUR-INPUT LIMIT-FIELD) D))
                                       (DECF FIRST D)
                                       (WHILE (<= K (SLOT CUR-INPUT LIMIT-FIELD))
                                         (SETF (AREF BUFFER K) (AREF BUFFER (+ K D)))
                                         (INCF K 1))
                                       (GOTO $L.26))))))
                          (SETF CUR-CS (+ 257 (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD))))
                          (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LOC-FIELD) 1))))
                   $L.40 (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
                   (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
                   (WHEN (>= CUR-CMD 113) (CHECK-OUTER-VALIDITY)))
                  ((14 30 46) (SETF CUR-CS (+ CUR-CHR 1))
                   (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
                   (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
                   (SETF (SLOT CUR-INPUT STATE-FIELD) 1)
                   (WHEN (>= CUR-CMD 113) (CHECK-OUTER-VALIDITY)))
                  ((8 24 40)
                   (WHEN (= CUR-CHR (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)))
                     (WHEN (< (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
                       (SETF C (AREF BUFFER (+ (SLOT CUR-INPUT LOC-FIELD) 1)))
                       (WHEN (< C 128)
                         (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LOC-FIELD) 2))
                         (WHEN (OR (AND (>= C 48) (<= C 57)) (AND (>= C 97) (<= C 102)))
                           (WHEN (<= (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
                             (SETF CC (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)))
                             (WHEN (OR (AND (>= CC 48) (<= CC 57))
                                       (AND (>= CC 97) (<= CC 102)))
                               (SETF (SLOT CUR-INPUT LOC-FIELD)
                                     (+ (SLOT CUR-INPUT LOC-FIELD) 1))
                               (COND ((<= C 57) (SETF CUR-CHR (- C 48)))
                                     (TRUE (SETF CUR-CHR (- C 87))))
                               (COND ((<= CC 57) (SETF CUR-CHR (- (+ (* 16 CUR-CHR) CC) 48)))
                                     (TRUE (SETF CUR-CHR (- (+ (* 16 CUR-CHR) CC) 87))))
                               (GOTO $L.21))))
                         (COND ((< C 64) (SETF CUR-CHR (+ C 64)))
                               (TRUE (SETF CUR-CHR (- C 64))))
                         (GOTO $L.21))))
                   (SETF (SLOT CUR-INPUT STATE-FIELD) 1))
                  ((16 32 48) (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 613)
                   (SETF HELP-PTR 2) (SETF (AREF HELP-LINE 1) 614)
                   (SETF (AREF HELP-LINE 0) 615) (SETF DELETIONS-ALLOWED FALSE) (ERROR)
                   (SETF DELETIONS-ALLOWED TRUE) (GOTO $L.20))
                  ((11) (SETF (SLOT CUR-INPUT STATE-FIELD) 17) (SETF CUR-CHR 32))
                  ((6) (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
                   (SETF CUR-CMD 10) (SETF CUR-CHR 32))
                  ((22 15 31 47)
                   (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
                   (GOTO $L.25))
                  ((38) (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
                   (SETF CUR-CS PAR-LOC) (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
                   (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
                   (WHEN (>= CUR-CMD 113) (CHECK-OUTER-VALIDITY)))
                  ((2) (INCF ALIGN-STATE 1))
                  ((18 34) (SETF (SLOT CUR-INPUT STATE-FIELD) 1) (INCF ALIGN-STATE 1))
                  ((3) (DECF ALIGN-STATE 1))
                  ((19 35) (SETF (SLOT CUR-INPUT STATE-FIELD) 1) (DECF ALIGN-STATE 1))
                  ((20 21 23 25 28 29 36 37 39 41 44 45) (SETF (SLOT CUR-INPUT STATE-FIELD) 1))
                  (ELSE)))
               (TRUE
                (SETF (SLOT CUR-INPUT STATE-FIELD) 33)
                (COND ((> (SLOT CUR-INPUT NAME-FIELD) 17)
                       (INCF LINE 1)
                       (SETF FIRST (SLOT CUR-INPUT START-FIELD))
                       (UNLESS FORCE-EOF
                         (COND ((INPUT-LN (AREF INPUT-FILE (SLOT CUR-INPUT INDEX-FIELD)) TRUE)
                                (FIRM-UP-THE-LINE))
                               (TRUE (SETF FORCE-EOF TRUE))))
                       (WHEN FORCE-EOF
                         (PRINT-CHAR 41)
                         (DECF OPEN-PARENS 1)
                         (BREAK TERM-OUT)
                         (SETF FORCE-EOF FALSE)
                         (END-FILE-READING)
                         (CHECK-OUTER-VALIDITY)
                         (GOTO $L.20))
                       (COND ((OR (< (SLOT (AREF EQTB 9211) INT) 0)
                                  (> (SLOT (AREF EQTB 9211) INT) 255))
                              (SETF (SLOT CUR-INPUT LIMIT-FIELD)
                                    (- (SLOT CUR-INPUT LIMIT-FIELD) 1)))
                             (TRUE
                              (SETF (AREF BUFFER (SLOT CUR-INPUT LIMIT-FIELD))
                                    (SLOT (AREF EQTB 9211) INT))))
                       (SETF FIRST (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
                       (SETF (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT START-FIELD)))
                      (TRUE
                       (UNLESS (= (SLOT CUR-INPUT NAME-FIELD) 0)
                         (SETF CUR-CMD 0)
                         (SETF CUR-CHR 0)
                         (GOTO $L.10))
                       (WHEN (> INPUT-PTR 0) (END-FILE-READING) (GOTO $L.20))
                       (WHEN (< SELECTOR 18) (OPEN-LOG-FILE))
                       (COND ((> INTERACTION 1)
                              (WHEN (OR (< (SLOT (AREF EQTB 9211) INT) 0)
                                        (> (SLOT (AREF EQTB 9211) INT) 255))
                                (SETF (SLOT CUR-INPUT LIMIT-FIELD)
                                      (+ (SLOT CUR-INPUT LIMIT-FIELD) 1)))
                              (WHEN (= (SLOT CUR-INPUT LIMIT-FIELD)
                                       (SLOT CUR-INPUT START-FIELD))
                                (PRINT-NL 616))
                              (PRINT-LN)
                              (SETF FIRST (SLOT CUR-INPUT START-FIELD))
                              (PRINT 42)
                              (TERM-INPUT)
                              (SETF (SLOT CUR-INPUT LIMIT-FIELD) LAST)
                              (COND ((OR (< (SLOT (AREF EQTB 9211) INT) 0)
                                         (> (SLOT (AREF EQTB 9211) INT) 255))
                                     (SETF (SLOT CUR-INPUT LIMIT-FIELD)
                                           (- (SLOT CUR-INPUT LIMIT-FIELD) 1)))
                                    (TRUE
                                     (SETF (AREF BUFFER (SLOT CUR-INPUT LIMIT-FIELD))
                                           (SLOT (AREF EQTB 9211) INT))))
                              (SETF FIRST (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
                              (SETF (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT START-FIELD)))
                             (TRUE (FATAL-ERROR 617)))))
                (WHEN (/= INTERRUPT 0) (PAUSE-FOR-INSTRUCTIONS))
                (GOTO $L.25))))
        ((/= (SLOT CUR-INPUT LOC-FIELD) 0)
         (SETF T (SLOT (SLOT (AREF MEM (SLOT CUR-INPUT LOC-FIELD)) HH) LH))
         (SETF (SLOT CUR-INPUT LOC-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-INPUT LOC-FIELD)) HH) RH))
         (COND ((>= T 4095)
                (SETF CUR-CS (- T 4095))
                (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
                (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
                (WHEN (>= CUR-CMD 113)
                  (COND ((= CUR-CMD 116)
                         (SETF CUR-CS
                               (- (SLOT (SLOT (AREF MEM (SLOT CUR-INPUT LOC-FIELD)) HH) LH)
                                  4095))
                         (SETF (SLOT CUR-INPUT LOC-FIELD) 0)
                         (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
                         (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
                         (WHEN (> CUR-CMD 100) (SETF CUR-CMD 0) (SETF CUR-CHR 257)))
                        (TRUE (CHECK-OUTER-VALIDITY)))))
               (TRUE
                (SETF CUR-CMD (DIV T 256))
                (SETF CUR-CHR (MOD T 256))
                (CASE CUR-CMD
                  ((1) (INCF ALIGN-STATE 1))
                  ((2) (DECF ALIGN-STATE 1))
                  ((5)
                   (BEGIN-TOKEN-LIST
                     (AREF PARAM-STACK (- (+ (SLOT CUR-INPUT LIMIT-FIELD) CUR-CHR) 1))
                     0)
                   (GOTO $L.20))
                  (ELSE)))))
        (TRUE (END-TOKEN-LIST) (GOTO $L.20)))
  (WHEN (<= CUR-CMD 5)
    (WHEN (>= CUR-CMD 4)
      (WHEN (= ALIGN-STATE 0)
        (WHEN (OR (= SCANNER-STATUS 4) (= CUR-ALIGN 0)) (FATAL-ERROR 595))
        (SETF CUR-CMD (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH))
        (SETF (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH) CUR-CHR)
        (COND ((= CUR-CMD 63) (BEGIN-TOKEN-LIST 59990 2))
              (TRUE (BEGIN-TOKEN-LIST (SLOT (AREF MEM (+ CUR-ALIGN 2)) INT) 2)))
        (SETF ALIGN-STATE 1000000)
        (GOTO $L.20))))
  $L.10)

(PROCEDURE FIRM-UP-THE-LINE ()
  (VAR K (RANGE 0 BUF-SIZE))
  (SETF (SLOT CUR-INPUT LIMIT-FIELD) LAST)
  (WHEN (> (SLOT (AREF EQTB 9191) INT) 0)
    (WHEN (> INTERACTION 1)
      (PRINT-LN)
      (WHEN (< (SLOT CUR-INPUT START-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
        (FOR (K (SLOT CUR-INPUT START-FIELD) TO (- (SLOT CUR-INPUT LIMIT-FIELD) 1))
          (PRINT (AREF BUFFER K))))
      (SETF FIRST (SLOT CUR-INPUT LIMIT-FIELD))
      (PRINT 618)
      (TERM-INPUT)
      (WHEN (> LAST FIRST)
        (FOR (K FIRST TO (- LAST 1))
          (SETF (AREF BUFFER (- (+ K (SLOT CUR-INPUT START-FIELD)) FIRST)) (AREF BUFFER K)))
        (SETF (SLOT CUR-INPUT LIMIT-FIELD) (- (+ (SLOT CUR-INPUT START-FIELD) LAST) FIRST))))))

(PROCEDURE GET-TOKEN ()
  (SETF NO-NEW-CONTROL-SEQUENCE FALSE)
  (GET-NEXT)
  (SETF NO-NEW-CONTROL-SEQUENCE TRUE)
  (COND ((= CUR-CS 0) (SETF CUR-TOK (+ (* CUR-CMD 256) CUR-CHR)))
        (TRUE (SETF CUR-TOK (+ 4095 CUR-CS)))))

(PROCEDURE MACRO-CALL ()
  (LABEL $L.10)
  (LABEL $L.22)
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.40)
  (VAR R HALFWORD)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR S HALFWORD)
  (VAR T HALFWORD)
  (VAR U HALFWORD)
  (VAR V HALFWORD)
  (VAR RBRACE-PTR HALFWORD)
  (VAR N SMALL-NUMBER)
  (VAR UNBALANCE HALFWORD)
  (VAR M HALFWORD)
  (VAR REF-COUNT HALFWORD)
  (VAR SAVE-SCANNER-STATUS SMALL-NUMBER)
  (VAR SAVE-WARNING-INDEX HALFWORD)
  (VAR MATCH-CHR ASCII-CODE)
  (SETF SAVE-SCANNER-STATUS SCANNER-STATUS)
  (SETF SAVE-WARNING-INDEX WARNING-INDEX)
  (SETF WARNING-INDEX CUR-CS)
  (SETF REF-COUNT CUR-CHR)
  (SETF R (SLOT (SLOT (AREF MEM REF-COUNT) HH) RH))
  (SETF N 0)
  (WHEN (> (SLOT (AREF EQTB 9193) INT) 0)
    (BEGIN-DIAGNOSTIC)
    (PRINT-LN)
    (PRINT-CS WARNING-INDEX)
    (TOKEN-SHOW REF-COUNT)
    (END-DIAGNOSTIC FALSE))
  (WHEN (/= (SLOT (SLOT (AREF MEM R) HH) LH) 3584)
    (SETF SCANNER-STATUS 3)
    (SETF UNBALANCE 0)
    (SETF LONG-STATE (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
    (WHEN (>= LONG-STATE 113) (DECF LONG-STATE 2))
    (REPEAT (SETF (SLOT (SLOT (AREF MEM 59997) HH) RH) 0)
            (COND ((OR (> (SLOT (SLOT (AREF MEM R) HH) LH) 3583)
                       (< (SLOT (SLOT (AREF MEM R) HH) LH) 3328))
                   (SETF S 0))
                  (TRUE
                   (SETF MATCH-CHR (- (SLOT (SLOT (AREF MEM R) HH) LH) 3328))
                   (SETF S (SLOT (SLOT (AREF MEM R) HH) RH))
                   (SETF R S)
                   (SETF P 59997)
                   (SETF M 0)))
            $L.22
            (GET-TOKEN)
            (WHEN (= CUR-TOK (SLOT (SLOT (AREF MEM R) HH) LH))
              (SETF R (SLOT (SLOT (AREF MEM R) HH) RH))
              (COND ((AND (>= (SLOT (SLOT (AREF MEM R) HH) LH) 3328)
                          (<= (SLOT (SLOT (AREF MEM R) HH) LH) 3584))
                     (WHEN (< CUR-TOK 512) (DECF ALIGN-STATE 1))
                     (GOTO $L.40))
                    (TRUE (GOTO $L.22))))
            (WHEN (/= S R)
              (COND ((= S 0)
                     (WHEN (= INTERACTION 3))
                     (PRINT-NL 262)
                     (PRINT 650)
                     (SPRINT-CS WARNING-INDEX)
                     (PRINT 651)
                     (SETF HELP-PTR 4)
                     (SETF (AREF HELP-LINE 3) 652)
                     (SETF (AREF HELP-LINE 2) 653)
                     (SETF (AREF HELP-LINE 1) 654)
                     (SETF (AREF HELP-LINE 0) 655)
                     (ERROR)
                     (GOTO $L.10))
                    (TRUE
                     (SETF T S)
                     (REPEAT (SETF Q GET-AVAIL)
                             (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                             (SETF (SLOT (SLOT (AREF MEM Q) HH) LH)
                                   (SLOT (SLOT (AREF MEM T) HH) LH))
                             (SETF P Q)
                             (INCF M 1)
                             (SETF U (SLOT (SLOT (AREF MEM T) HH) RH))
                             (SETF V S)
                             (WHILE TRUE
                               (WHEN (= U R)
                                 (COND ((/= CUR-TOK (SLOT (SLOT (AREF MEM V) HH) LH))
                                        (GOTO $L.30))
                                       (TRUE
                                        (SETF R (SLOT (SLOT (AREF MEM V) HH) RH))
                                        (GOTO $L.22))))
                               (WHEN (/= (SLOT (SLOT (AREF MEM U) HH) LH)
                                         (SLOT (SLOT (AREF MEM V) HH) LH))
                                 (GOTO $L.30))
                               (SETF U (SLOT (SLOT (AREF MEM U) HH) RH))
                               (SETF V (SLOT (SLOT (AREF MEM V) HH) RH)))
                             $L.30
                             (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
                             (UNTIL (= T R)))
                     (SETF R S))))
            (WHEN (= CUR-TOK PAR-TOKEN)
              (WHEN (/= LONG-STATE 112)
                (WHEN (= LONG-STATE 111)
                  (RUNAWAY)
                  (WHEN (= INTERACTION 3))
                  (PRINT-NL 262)
                  (PRINT 645)
                  (SPRINT-CS WARNING-INDEX)
                  (PRINT 646)
                  (SETF HELP-PTR 3)
                  (SETF (AREF HELP-LINE 2) 647)
                  (SETF (AREF HELP-LINE 1) 648)
                  (SETF (AREF HELP-LINE 0) 649)
                  (BACK-ERROR))
                (SETF (AREF PSTACK N) (SLOT (SLOT (AREF MEM 59997) HH) RH))
                (DECF ALIGN-STATE UNBALANCE)
                (FOR (M 0 TO N) (FLUSH-LIST (AREF PSTACK M)))
                (GOTO $L.10)))
            (COND ((< CUR-TOK 768)
                   (COND ((< CUR-TOK 512)
                          (SETF UNBALANCE 1)
                          (WHILE TRUE
                            (SETF Q AVAIL)
                            (COND ((= Q 0) (SETF Q GET-AVAIL))
                                  (TRUE
                                   (SETF AVAIL (SLOT (SLOT (AREF MEM Q) HH) RH))
                                   (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)))
                            (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                            (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
                            (SETF P Q)
                            (GET-TOKEN)
                            (WHEN (= CUR-TOK PAR-TOKEN)
                              (WHEN (/= LONG-STATE 112)
                                (WHEN (= LONG-STATE 111)
                                  (RUNAWAY)
                                  (WHEN (= INTERACTION 3))
                                  (PRINT-NL 262)
                                  (PRINT 645)
                                  (SPRINT-CS WARNING-INDEX)
                                  (PRINT 646)
                                  (SETF HELP-PTR 3)
                                  (SETF (AREF HELP-LINE 2) 647)
                                  (SETF (AREF HELP-LINE 1) 648)
                                  (SETF (AREF HELP-LINE 0) 649)
                                  (BACK-ERROR))
                                (SETF (AREF PSTACK N) (SLOT (SLOT (AREF MEM 59997) HH) RH))
                                (DECF ALIGN-STATE UNBALANCE)
                                (FOR (M 0 TO N) (FLUSH-LIST (AREF PSTACK M)))
                                (GOTO $L.10)))
                            (WHEN (< CUR-TOK 768)
                              (COND ((< CUR-TOK 512) (INCF UNBALANCE 1))
                                    (TRUE
                                     (DECF UNBALANCE 1)
                                     (WHEN (= UNBALANCE 0) (GOTO $L.31))))))
                          $L.31
                          (SETF RBRACE-PTR P)
                          (SETF Q GET-AVAIL)
                          (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                          (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
                          (SETF P Q))
                         (TRUE
                          (BACK-INPUT)
                          (WHEN (= INTERACTION 3))
                          (PRINT-NL 262)
                          (PRINT 637)
                          (SPRINT-CS WARNING-INDEX)
                          (PRINT 638)
                          (SETF HELP-PTR 6)
                          (SETF (AREF HELP-LINE 5) 639)
                          (SETF (AREF HELP-LINE 4) 640)
                          (SETF (AREF HELP-LINE 3) 641)
                          (SETF (AREF HELP-LINE 2) 642)
                          (SETF (AREF HELP-LINE 1) 643)
                          (SETF (AREF HELP-LINE 0) 644)
                          (INCF ALIGN-STATE 1)
                          (SETF LONG-STATE 111)
                          (SETF CUR-TOK PAR-TOKEN)
                          (INS-ERROR)
                          (GOTO $L.22))))
                  (TRUE
                   (WHEN (= CUR-TOK 2592)
                     (WHEN (<= (SLOT (SLOT (AREF MEM R) HH) LH) 3584)
                       (WHEN (>= (SLOT (SLOT (AREF MEM R) HH) LH) 3328) (GOTO $L.22))))
                   (SETF Q GET-AVAIL)
                   (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                   (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
                   (SETF P Q)))
            (INCF M 1)
            (WHEN (> (SLOT (SLOT (AREF MEM R) HH) LH) 3584) (GOTO $L.22))
            (WHEN (< (SLOT (SLOT (AREF MEM R) HH) LH) 3328) (GOTO $L.22))
            $L.40
            (WHEN (/= S 0)
              (COND ((AND (= M 1) (< (SLOT (SLOT (AREF MEM P) HH) LH) 768))
                     (SETF (SLOT (SLOT (AREF MEM RBRACE-PTR) HH) RH) 0)
                     (SETF (SLOT (SLOT (AREF MEM P) HH) RH) AVAIL)
                     (SETF AVAIL P)
                     (SETF P (SLOT (SLOT (AREF MEM 59997) HH) RH))
                     (SETF (AREF PSTACK N) (SLOT (SLOT (AREF MEM P) HH) RH))
                     (SETF (SLOT (SLOT (AREF MEM P) HH) RH) AVAIL)
                     (SETF AVAIL P))
                    (TRUE (SETF (AREF PSTACK N) (SLOT (SLOT (AREF MEM 59997) HH) RH))))
              (INCF N 1)
              (WHEN (> (SLOT (AREF EQTB 9193) INT) 0)
                (BEGIN-DIAGNOSTIC)
                (PRINT-NL MATCH-CHR)
                (PRINT-INT N)
                (PRINT 656)
                (SHOW-TOKEN-LIST (AREF PSTACK (- N 1)) 0 1000)
                (END-DIAGNOSTIC FALSE)))
            (UNTIL (= (SLOT (SLOT (AREF MEM R) HH) LH) 3584))))
  (WHILE (AND (AND (= (SLOT CUR-INPUT STATE-FIELD) 0) (= (SLOT CUR-INPUT LOC-FIELD) 0))
              (/= (SLOT CUR-INPUT INDEX-FIELD) 2))
    (END-TOKEN-LIST))
  (BEGIN-TOKEN-LIST REF-COUNT 5)
  (SETF (SLOT CUR-INPUT NAME-FIELD) WARNING-INDEX)
  (SETF (SLOT CUR-INPUT LOC-FIELD) (SLOT (SLOT (AREF MEM R) HH) RH))
  (WHEN (> N 0)
    (WHEN (> (+ PARAM-PTR N) MAX-PARAM-STACK)
      (SETF MAX-PARAM-STACK (+ PARAM-PTR N))
      (WHEN (> MAX-PARAM-STACK PARAM-SIZE) (OVERFLOW 636 PARAM-SIZE)))
    (FOR (M 0 TO (- N 1)) (SETF (AREF PARAM-STACK (+ PARAM-PTR M)) (AREF PSTACK M)))
    (INCF PARAM-PTR N))
  $L.10
  (SETF SCANNER-STATUS SAVE-SCANNER-STATUS)
  (SETF WARNING-INDEX SAVE-WARNING-INDEX))

(PROCEDURE INSERT-RELAX ()
  (SETF CUR-TOK (+ 4095 CUR-CS))
  (BACK-INPUT)
  (SETF CUR-TOK 10616)
  (BACK-INPUT)
  (SETF (SLOT CUR-INPUT INDEX-FIELD) 4))

(PROCEDURE PASS-TEXT () :FORWARD)

(PROCEDURE START-INPUT () :FORWARD)

(PROCEDURE CONDITIONAL () :FORWARD)

(PROCEDURE GET-X-TOKEN () :FORWARD)

(PROCEDURE CONV-TOKS () :FORWARD)

(PROCEDURE INS-THE-TOKS () :FORWARD)

(PROCEDURE EXPAND ()
  (VAR T HALFWORD)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR J (RANGE 0 BUF-SIZE))
  (VAR CV-BACKUP INTEGER)
  (VAR CVL-BACKUP SMALL-NUMBER)
  (VAR RADIX-BACKUP SMALL-NUMBER)
  (VAR CO-BACKUP SMALL-NUMBER)
  (VAR BACKUP-BACKUP HALFWORD)
  (VAR SAVE-SCANNER-STATUS SMALL-NUMBER)
  (SETF CV-BACKUP CUR-VAL)
  (SETF CVL-BACKUP CUR-VAL-LEVEL)
  (SETF RADIX-BACKUP RADIX)
  (SETF CO-BACKUP CUR-ORDER)
  (SETF BACKUP-BACKUP (SLOT (SLOT (AREF MEM 59987) HH) RH))
  (COND ((< CUR-CMD 111)
         (WHEN (> (SLOT (AREF EQTB 9199) INT) 1) (SHOW-CUR-CMD-CHR))
         (CASE CUR-CMD
           ((110)
            (WHEN (/= (AREF CUR-MARK CUR-CHR) 0)
              (BEGIN-TOKEN-LIST (AREF CUR-MARK CUR-CHR) 14)))
           ((102) (GET-TOKEN) (SETF T CUR-TOK) (GET-TOKEN)
            (COND ((> CUR-CMD 100) (EXPAND)) (TRUE (BACK-INPUT))) (SETF CUR-TOK T)
            (BACK-INPUT))
           ((103) (SETF SAVE-SCANNER-STATUS SCANNER-STATUS) (SETF SCANNER-STATUS 0) (GET-TOKEN)
            (SETF SCANNER-STATUS SAVE-SCANNER-STATUS) (SETF T CUR-TOK) (BACK-INPUT)
            (WHEN (>= T 4095)
              (SETF P GET-AVAIL)
              (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 10618)
              (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (SLOT CUR-INPUT LOC-FIELD))
              (SETF (SLOT CUR-INPUT START-FIELD) P)
              (SETF (SLOT CUR-INPUT LOC-FIELD) P)))
           ((107) (SETF R GET-AVAIL) (SETF P R)
            (REPEAT (GET-X-TOKEN)
                    (WHEN (= CUR-CS 0)
                      (SETF Q GET-AVAIL)
                      (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                      (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
                      (SETF P Q))
                    (UNTIL (/= CUR-CS 0)))
            (WHEN (/= CUR-CMD 67)
              (WHEN (= INTERACTION 3))
              (PRINT-NL 262)
              (PRINT 625)
              (PRINT-ESC 505)
              (PRINT 626)
              (SETF HELP-PTR 2)
              (SETF (AREF HELP-LINE 1) 627)
              (SETF (AREF HELP-LINE 0) 628)
              (BACK-ERROR))
            (SETF J FIRST) (SETF P (SLOT (SLOT (AREF MEM R) HH) RH))
            (WHILE (/= P 0)
              (WHEN (>= J MAX-BUF-STACK)
                (SETF MAX-BUF-STACK (+ J 1))
                (WHEN (= MAX-BUF-STACK BUF-SIZE) (OVERFLOW 256 BUF-SIZE)))
              (SETF (AREF BUFFER J) (MOD (SLOT (SLOT (AREF MEM P) HH) LH) 256))
              (INCF J 1)
              (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
            (COND ((> J (+ FIRST 1))
                   (SETF NO-NEW-CONTROL-SEQUENCE FALSE)
                   (SETF CUR-CS (ID-LOOKUP FIRST (- J FIRST)))
                   (SETF NO-NEW-CONTROL-SEQUENCE TRUE))
                  ((= J FIRST) (SETF CUR-CS 513))
                  (TRUE (SETF CUR-CS (+ 257 (AREF BUFFER FIRST)))))
            (FLUSH-LIST R)
            (WHEN (= (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0) 101) (EQ-DEFINE CUR-CS 0 256))
            (SETF CUR-TOK (+ CUR-CS 4095)) (BACK-INPUT))
           ((108) (CONV-TOKS))
           ((109) (INS-THE-TOKS))
           ((105) (CONDITIONAL))
           ((106)
            (COND ((> CUR-CHR IF-LIMIT)
                   (COND ((= IF-LIMIT 1) (INSERT-RELAX))
                         (TRUE
                          (WHEN (= INTERACTION 3))
                          (PRINT-NL 262)
                          (PRINT 777)
                          (PRINT-CMD-CHR 106 CUR-CHR)
                          (SETF HELP-PTR 1)
                          (SETF (AREF HELP-LINE 0) 778)
                          (ERROR))))
                  (TRUE
                   (WHILE (/= CUR-CHR 2) (PASS-TEXT))
                   (SETF P COND-PTR)
                   (SETF IF-LINE (SLOT (AREF MEM (+ P 1)) INT))
                   (SETF CUR-IF (SLOT (SLOT (AREF MEM P) HH) B1))
                   (SETF IF-LIMIT (SLOT (SLOT (AREF MEM P) HH) B0))
                   (SETF COND-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
                   (FREE-NODE P 2))))
           ((104)
            (COND ((> CUR-CHR 0) (SETF FORCE-EOF TRUE))
                  (NAME-IN-PROGRESS (INSERT-RELAX))
                  (TRUE (START-INPUT))))
           (ELSE (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 619) (SETF HELP-PTR 5)
            (SETF (AREF HELP-LINE 4) 620) (SETF (AREF HELP-LINE 3) 621)
            (SETF (AREF HELP-LINE 2) 622) (SETF (AREF HELP-LINE 1) 623)
            (SETF (AREF HELP-LINE 0) 624) (ERROR))))
        ((< CUR-CMD 115) (MACRO-CALL))
        (TRUE (SETF CUR-TOK 10615) (BACK-INPUT)))
  (SETF CUR-VAL CV-BACKUP)
  (SETF CUR-VAL-LEVEL CVL-BACKUP)
  (SETF RADIX RADIX-BACKUP)
  (SETF CUR-ORDER CO-BACKUP)
  (SETF (SLOT (SLOT (AREF MEM 59987) HH) RH) BACKUP-BACKUP))

(PROCEDURE GET-X-TOKEN ()
  (LABEL $L.20)
  (LABEL $L.30)
  $L.20
  (GET-NEXT)
  (WHEN (<= CUR-CMD 100) (GOTO $L.30))
  (COND ((>= CUR-CMD 111)
         (COND ((< CUR-CMD 115) (MACRO-CALL))
               (TRUE (SETF CUR-CS 6520) (SETF CUR-CMD 9) (GOTO $L.30))))
        (TRUE (EXPAND)))
  (GOTO $L.20)
  $L.30
  (COND ((= CUR-CS 0) (SETF CUR-TOK (+ (* CUR-CMD 256) CUR-CHR)))
        (TRUE (SETF CUR-TOK (+ 4095 CUR-CS)))))

(PROCEDURE X-TOKEN ()
  (WHILE (> CUR-CMD 100) (EXPAND) (GET-NEXT))
  (COND ((= CUR-CS 0) (SETF CUR-TOK (+ (* CUR-CMD 256) CUR-CHR)))
        (TRUE (SETF CUR-TOK (+ 4095 CUR-CS)))))

(PROCEDURE SCAN-LEFT-BRACE ()
  (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
  (WHEN (/= CUR-CMD 1)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 657)
    (SETF HELP-PTR 4)
    (SETF (AREF HELP-LINE 3) 658)
    (SETF (AREF HELP-LINE 2) 659)
    (SETF (AREF HELP-LINE 1) 660)
    (SETF (AREF HELP-LINE 0) 661)
    (BACK-ERROR)
    (SETF CUR-TOK 379)
    (SETF CUR-CMD 1)
    (SETF CUR-CHR 123)
    (INCF ALIGN-STATE 1)))

(PROCEDURE SCAN-OPTIONAL-EQUALS ()
  (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
  (WHEN (/= CUR-TOK 3133) (BACK-INPUT)))

(FUNCTION (SCAN-KEYWORD BOOLEAN) ((S STR-NUMBER))
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR K POOL-POINTER)
  (SETF P 59987)
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
  (SETF K (AREF STR-START S))
  (WHILE (< K (AREF STR-START (+ S 1)))
    (GET-X-TOKEN)
    (COND ((AND (= CUR-CS 0)
                (OR (= CUR-CHR (AREF STR-POOL K)) (= CUR-CHR (- (AREF STR-POOL K) 32))))
           (SETF Q GET-AVAIL)
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
           (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
           (SETF P Q)
           (INCF K 1))
          ((OR (/= CUR-CMD 10) (/= P 59987))
           (BACK-INPUT)
           (WHEN (/= P 59987) (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF MEM 59987) HH) RH) 3))
           (SETF SCAN-KEYWORD FALSE)
           (GOTO $L.10))))
  (FLUSH-LIST (SLOT (SLOT (AREF MEM 59987) HH) RH))
  (SETF SCAN-KEYWORD TRUE)
  $L.10)

(PROCEDURE MU-ERROR ()
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 662)
  (SETF HELP-PTR 1)
  (SETF (AREF HELP-LINE 0) 663)
  (ERROR))

(PROCEDURE SCAN-INT () :FORWARD)

(PROCEDURE SCAN-EIGHT-BIT-INT ()
  (SCAN-INT)
  (WHEN (OR (< CUR-VAL 0) (> CUR-VAL 255))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 687)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 688)
    (SETF (AREF HELP-LINE 0) 689)
    (INT-ERROR CUR-VAL)
    (SETF CUR-VAL 0)))

(PROCEDURE SCAN-CHAR-NUM ()
  (SCAN-INT)
  (WHEN (OR (< CUR-VAL 0) (> CUR-VAL 255))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 690)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 691)
    (SETF (AREF HELP-LINE 0) 689)
    (INT-ERROR CUR-VAL)
    (SETF CUR-VAL 0)))

(PROCEDURE SCAN-FOUR-BIT-INT ()
  (SCAN-INT)
  (WHEN (OR (< CUR-VAL 0) (> CUR-VAL 15))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 692)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 693)
    (SETF (AREF HELP-LINE 0) 689)
    (INT-ERROR CUR-VAL)
    (SETF CUR-VAL 0)))

(PROCEDURE SCAN-FIFTEEN-BIT-INT ()
  (SCAN-INT)
  (WHEN (OR (< CUR-VAL 0) (> CUR-VAL 32767))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 694)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 695)
    (SETF (AREF HELP-LINE 0) 689)
    (INT-ERROR CUR-VAL)
    (SETF CUR-VAL 0)))

(PROCEDURE SCAN-TWENTY-SEVEN-BIT-INT ()
  (SCAN-INT)
  (WHEN (OR (< CUR-VAL 0) (> CUR-VAL 134217727))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 696)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 697)
    (SETF (AREF HELP-LINE 0) 689)
    (INT-ERROR CUR-VAL)
    (SETF CUR-VAL 0)))

(PROCEDURE SCAN-FONT-IDENT ()
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR M HALFWORD)
  (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
  (COND ((= CUR-CMD 88) (SETF F (SLOT (SLOT (AREF EQTB 7834) HH) RH)))
        ((= CUR-CMD 87) (SETF F CUR-CHR))
        ((= CUR-CMD 86)
         (SETF M CUR-CHR)
         (SCAN-FOUR-BIT-INT)
         (SETF F (SLOT (SLOT (AREF EQTB (+ M CUR-VAL)) HH) RH)))
        (TRUE
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 817)
         (SETF HELP-PTR 2)
         (SETF (AREF HELP-LINE 1) 818)
         (SETF (AREF HELP-LINE 0) 819)
         (BACK-ERROR)
         (SETF F 0)))
  (SETF CUR-VAL F))

(PROCEDURE FIND-FONT-DIMEN ((WRITING BOOLEAN))
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR N INTEGER)
  (SCAN-INT)
  (SETF N CUR-VAL)
  (SCAN-FONT-IDENT)
  (SETF F CUR-VAL)
  (COND ((<= N 0) (SETF CUR-VAL FMEM-PTR))
        (TRUE
         (WHEN (AND (AND (AND WRITING (<= N 4)) (>= N 2)) (/= (AREF FONT-GLUE F) 0))
           (DELETE-GLUE-REF (AREF FONT-GLUE F))
           (SETF (AREF FONT-GLUE F) 0))
         (COND ((> N (AREF FONT-PARAMS F))
                (COND ((< F FONT-PTR) (SETF CUR-VAL FMEM-PTR))
                      (TRUE
                       (REPEAT (WHEN (= FMEM-PTR FONT-MEM-SIZE) (OVERFLOW 824 FONT-MEM-SIZE))
                               (SETF (SLOT (AREF FONT-INFO FMEM-PTR) INT) 0)
                               (INCF FMEM-PTR 1)
                               (SETF (AREF FONT-PARAMS F) (+ (AREF FONT-PARAMS F) 1))
                               (UNTIL (= N (AREF FONT-PARAMS F))))
                       (SETF CUR-VAL (- FMEM-PTR 1)))))
               (TRUE (SETF CUR-VAL (+ N (AREF PARAM-BASE F)))))))
  (WHEN (= CUR-VAL FMEM-PTR)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 802)
    (PRINT-ESC (SLOT (AREF HASH (+ 6524 F)) RH))
    (PRINT 820)
    (PRINT-INT (AREF FONT-PARAMS F))
    (PRINT 821)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 822)
    (SETF (AREF HELP-LINE 0) 823)
    (ERROR)))

(PROCEDURE SCAN-SOMETHING-INTERNAL ((LEVEL SMALL-NUMBER) (NEGATIVE BOOLEAN))
  (VAR M HALFWORD)
  (VAR P (RANGE 0 NEST-SIZE))
  (SETF M CUR-CHR)
  (CASE CUR-CMD
    ((85) (SCAN-CHAR-NUM)
     (COND ((= M 8907)
            (SETF CUR-VAL (- (SLOT (SLOT (AREF EQTB (+ 8907 CUR-VAL)) HH) RH) 0))
            (SETF CUR-VAL-LEVEL 0))
           ((< M 8907)
            (SETF CUR-VAL (SLOT (SLOT (AREF EQTB (+ M CUR-VAL)) HH) RH))
            (SETF CUR-VAL-LEVEL 0))
           (TRUE (SETF CUR-VAL (SLOT (AREF EQTB (+ M CUR-VAL)) INT)) (SETF CUR-VAL-LEVEL 0))))
    ((71 72 86 87 88)
     (COND ((/= LEVEL 5)
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 664)
            (SETF HELP-PTR 3)
            (SETF (AREF HELP-LINE 2) 665)
            (SETF (AREF HELP-LINE 1) 666)
            (SETF (AREF HELP-LINE 0) 667)
            (BACK-ERROR)
            (SETF CUR-VAL 0)
            (SETF CUR-VAL-LEVEL 1))
           ((<= CUR-CMD 72)
            (WHEN (< CUR-CMD 72) (SCAN-EIGHT-BIT-INT) (SETF M (+ 7322 CUR-VAL)))
            (SETF CUR-VAL (SLOT (SLOT (AREF EQTB M) HH) RH))
            (SETF CUR-VAL-LEVEL 5))
           (TRUE
            (BACK-INPUT)
            (SCAN-FONT-IDENT)
            (SETF CUR-VAL (+ 6524 CUR-VAL))
            (SETF CUR-VAL-LEVEL 4))))
    ((73) (SETF CUR-VAL (SLOT (AREF EQTB M) INT)) (SETF CUR-VAL-LEVEL 0))
    ((74) (SETF CUR-VAL (SLOT (AREF EQTB M) INT)) (SETF CUR-VAL-LEVEL 1))
    ((75) (SETF CUR-VAL (SLOT (SLOT (AREF EQTB M) HH) RH)) (SETF CUR-VAL-LEVEL 2))
    ((76) (SETF CUR-VAL (SLOT (SLOT (AREF EQTB M) HH) RH)) (SETF CUR-VAL-LEVEL 3))
    ((79)
     (COND ((/= (ABS (SLOT CUR-LIST MODE-FIELD)) M)
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 680)
            (PRINT-CMD-CHR 79 M)
            (SETF HELP-PTR 4)
            (SETF (AREF HELP-LINE 3) 681)
            (SETF (AREF HELP-LINE 2) 682)
            (SETF (AREF HELP-LINE 1) 683)
            (SETF (AREF HELP-LINE 0) 684)
            (ERROR)
            (COND ((/= LEVEL 5) (SETF CUR-VAL 0) (SETF CUR-VAL-LEVEL 1))
                  (TRUE (SETF CUR-VAL 0) (SETF CUR-VAL-LEVEL 0))))
           ((= M 1) (SETF CUR-VAL (SLOT (SLOT CUR-LIST AUX-FIELD) INT)) (SETF CUR-VAL-LEVEL 1))
           (TRUE
            (SETF CUR-VAL (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH))
            (SETF CUR-VAL-LEVEL 0))))
    ((80)
     (COND ((= (SLOT CUR-LIST MODE-FIELD) 0) (SETF CUR-VAL 0) (SETF CUR-VAL-LEVEL 0))
           (TRUE
            (SETF (AREF NEST NEST-PTR) CUR-LIST)
            (SETF P NEST-PTR)
            (WHILE (/= (ABS (SLOT (AREF NEST P) MODE-FIELD)) 1) (DECF P 1))
            (SETF CUR-VAL (SLOT (AREF NEST P) PG-FIELD))
            (SETF CUR-VAL-LEVEL 0))))
    ((82) (COND ((= M 0) (SETF CUR-VAL DEAD-CYCLES)) (TRUE (SETF CUR-VAL INSERT-PENALTIES)))
     (SETF CUR-VAL-LEVEL 0))
    ((81)
     (COND ((AND (= PAGE-CONTENTS 0) (NOT OUTPUT-ACTIVE))
            (COND ((= M 0) (SETF CUR-VAL 1073741823)) (TRUE (SETF CUR-VAL 0))))
           (TRUE (SETF CUR-VAL (AREF PAGE-SO-FAR M))))
     (SETF CUR-VAL-LEVEL 1))
    ((84)
     (COND ((= (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0) (SETF CUR-VAL 0))
           (TRUE
            (SETF CUR-VAL
                  (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 7312) HH) RH)) HH) LH))))
     (SETF CUR-VAL-LEVEL 0))
    ((83) (SCAN-EIGHT-BIT-INT)
     (COND ((= (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH) 0) (SETF CUR-VAL 0))
           (TRUE
            (SETF CUR-VAL
                  (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH) M))
                        INT))))
     (SETF CUR-VAL-LEVEL 1))
    ((68 69) (SETF CUR-VAL CUR-CHR) (SETF CUR-VAL-LEVEL 0))
    ((77) (FIND-FONT-DIMEN FALSE) (SETF (SLOT (AREF FONT-INFO FMEM-PTR) INT) 0)
     (SETF CUR-VAL (SLOT (AREF FONT-INFO CUR-VAL) INT)) (SETF CUR-VAL-LEVEL 1))
    ((78) (SCAN-FONT-IDENT)
     (COND ((= M 0) (SETF CUR-VAL (AREF HYPHEN-CHAR CUR-VAL)) (SETF CUR-VAL-LEVEL 0))
           (TRUE (SETF CUR-VAL (AREF SKEW-CHAR CUR-VAL)) (SETF CUR-VAL-LEVEL 0))))
    ((89) (SCAN-EIGHT-BIT-INT)
     (CASE M
       ((0) (SETF CUR-VAL (SLOT (AREF EQTB (+ 9218 CUR-VAL)) INT)))
       ((1) (SETF CUR-VAL (SLOT (AREF EQTB (+ 9751 CUR-VAL)) INT)))
       ((2) (SETF CUR-VAL (SLOT (SLOT (AREF EQTB (+ 6800 CUR-VAL)) HH) RH)))
       ((3) (SETF CUR-VAL (SLOT (SLOT (AREF EQTB (+ 7056 CUR-VAL)) HH) RH))))
     (SETF CUR-VAL-LEVEL M))
    ((70)
     (COND ((> CUR-CHR 2)
            (COND ((= CUR-CHR 3) (SETF CUR-VAL LINE)) (TRUE (SETF CUR-VAL LAST-BADNESS)))
            (SETF CUR-VAL-LEVEL 0))
           (TRUE
            (COND ((= CUR-CHR 2) (SETF CUR-VAL 0)) (TRUE (SETF CUR-VAL 0)))
            (SETF CUR-VAL-LEVEL CUR-CHR)
            (COND ((AND (NOT (>= (SLOT CUR-LIST TAIL-FIELD) HI-MEM-MIN))
                        (/= (SLOT CUR-LIST MODE-FIELD) 0))
                   (CASE CUR-CHR
                     ((0)
                      (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 12)
                        (SETF CUR-VAL (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT))))
                     ((1)
                      (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 11)
                        (SETF CUR-VAL (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT))))
                     ((2)
                      (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 10)
                        (SETF CUR-VAL
                              (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH))
                        (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 99)
                          (SETF CUR-VAL-LEVEL 3))))))
                  ((AND (= (SLOT CUR-LIST MODE-FIELD) 1)
                        (= (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD)))
                   (CASE CUR-CHR
                     ((0) (SETF CUR-VAL LAST-PENALTY))
                     ((1) (SETF CUR-VAL LAST-KERN))
                     ((2) (WHEN (/= LAST-GLUE 65535) (SETF CUR-VAL LAST-GLUE)))))))))
    (ELSE (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 685) (PRINT-CMD-CHR CUR-CMD CUR-CHR)
     (PRINT 686) (PRINT-ESC 537) (SETF HELP-PTR 1) (SETF (AREF HELP-LINE 0) 684) (ERROR)
     (COND ((/= LEVEL 5) (SETF CUR-VAL 0) (SETF CUR-VAL-LEVEL 1))
           (TRUE (SETF CUR-VAL 0) (SETF CUR-VAL-LEVEL 0)))))
  (WHILE (> CUR-VAL-LEVEL LEVEL)
    (COND ((= CUR-VAL-LEVEL 2) (SETF CUR-VAL (SLOT (AREF MEM (+ CUR-VAL 1)) INT)))
          ((= CUR-VAL-LEVEL 3) (MU-ERROR)))
    (DECF CUR-VAL-LEVEL 1))
  (COND (NEGATIVE
         (COND ((>= CUR-VAL-LEVEL 2)
                (SETF CUR-VAL (NEW-SPEC CUR-VAL))
                (SETF (SLOT (AREF MEM (+ CUR-VAL 1)) INT)
                      (- (SLOT (AREF MEM (+ CUR-VAL 1)) INT)))
                (SETF (SLOT (AREF MEM (+ CUR-VAL 2)) INT)
                      (- (SLOT (AREF MEM (+ CUR-VAL 2)) INT)))
                (SETF (SLOT (AREF MEM (+ CUR-VAL 3)) INT)
                      (- (SLOT (AREF MEM (+ CUR-VAL 3)) INT))))
               (TRUE (SETF CUR-VAL (- CUR-VAL)))))
        ((AND (>= CUR-VAL-LEVEL 2) (<= CUR-VAL-LEVEL 3))
         (SETF (SLOT (SLOT (AREF MEM CUR-VAL) HH) RH)
               (+ (SLOT (SLOT (AREF MEM CUR-VAL) HH) RH) 1)))))

(PROCEDURE SCAN-INT ()
  (LABEL $L.30)
  (VAR NEGATIVE BOOLEAN)
  (VAR M INTEGER)
  (VAR D SMALL-NUMBER)
  (VAR VACUOUS BOOLEAN)
  (VAR OK-SO-FAR BOOLEAN)
  (SETF RADIX 0)
  (SETF OK-SO-FAR TRUE)
  (SETF NEGATIVE FALSE)
  (REPEAT (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
          (WHEN (= CUR-TOK 3117) (SETF NEGATIVE (NOT NEGATIVE)) (SETF CUR-TOK 3115))
          (UNTIL (/= CUR-TOK 3115)))
  (COND ((= CUR-TOK 3168)
         (GET-TOKEN)
         (COND ((< CUR-TOK 4095)
                (SETF CUR-VAL CUR-CHR)
                (WHEN (<= CUR-CMD 2)
                  (COND ((= CUR-CMD 2) (INCF ALIGN-STATE 1)) (TRUE (DECF ALIGN-STATE 1)))))
               ((< CUR-TOK 4352) (SETF CUR-VAL (- CUR-TOK 4096)))
               (TRUE (SETF CUR-VAL (- CUR-TOK 4352))))
         (COND ((> CUR-VAL 255)
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 698)
                (SETF HELP-PTR 2)
                (SETF (AREF HELP-LINE 1) 699)
                (SETF (AREF HELP-LINE 0) 700)
                (SETF CUR-VAL 48)
                (BACK-ERROR))
               (TRUE (GET-X-TOKEN) (WHEN (/= CUR-CMD 10) (BACK-INPUT)))))
        ((AND (>= CUR-CMD 68) (<= CUR-CMD 89)) (SCAN-SOMETHING-INTERNAL 0 FALSE))
        (TRUE
         (SETF RADIX 10)
         (SETF M 214748364)
         (COND ((= CUR-TOK 3111) (SETF RADIX 8) (SETF M 268435456) (GET-X-TOKEN))
               ((= CUR-TOK 3106) (SETF RADIX 16) (SETF M 134217728) (GET-X-TOKEN)))
         (SETF VACUOUS TRUE)
         (SETF CUR-VAL 0)
         (WHILE TRUE
           (COND ((AND (AND (< CUR-TOK (+ 3120 RADIX)) (>= CUR-TOK 3120)) (<= CUR-TOK 3129))
                  (SETF D (- CUR-TOK 3120)))
                 ((= RADIX 16)
                  (COND ((AND (<= CUR-TOK 2886) (>= CUR-TOK 2881)) (SETF D (- CUR-TOK 2871)))
                        ((AND (<= CUR-TOK 3142) (>= CUR-TOK 3137)) (SETF D (- CUR-TOK 3127)))
                        (TRUE (GOTO $L.30))))
                 (TRUE (GOTO $L.30)))
           (SETF VACUOUS FALSE)
           (COND ((AND (>= CUR-VAL M) (OR (OR (> CUR-VAL M) (> D 7)) (/= RADIX 10)))
                  (WHEN OK-SO-FAR
                    (WHEN (= INTERACTION 3))
                    (PRINT-NL 262)
                    (PRINT 701)
                    (SETF HELP-PTR 2)
                    (SETF (AREF HELP-LINE 1) 702)
                    (SETF (AREF HELP-LINE 0) 703)
                    (ERROR)
                    (SETF CUR-VAL 2147483647)
                    (SETF OK-SO-FAR FALSE)))
                 (TRUE (SETF CUR-VAL (+ (* CUR-VAL RADIX) D))))
           (GET-X-TOKEN))
         $L.30
         (COND (VACUOUS
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 664)
                (SETF HELP-PTR 3)
                (SETF (AREF HELP-LINE 2) 665)
                (SETF (AREF HELP-LINE 1) 666)
                (SETF (AREF HELP-LINE 0) 667)
                (BACK-ERROR))
               ((/= CUR-CMD 10) (BACK-INPUT)))))
  (WHEN NEGATIVE (SETF CUR-VAL (- CUR-VAL))))

(PROCEDURE SCAN-DIMEN ((MU BOOLEAN) (INF BOOLEAN) (SHORTCUT BOOLEAN))
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.32)
  (LABEL $L.40)
  (LABEL $L.45)
  (LABEL $L.88)
  (LABEL $L.89)
  (VAR NEGATIVE BOOLEAN)
  (VAR F INTEGER)
  (VAR NUM (RANGE 1 65536))
  (VAR DENOM (RANGE 1 65536))
  (VAR K SMALL-NUMBER)
  (VAR KK SMALL-NUMBER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR V SCALED)
  (VAR SAVE-CUR-VAL INTEGER)
  (SETF F 0)
  (SETF ARITH-ERROR FALSE)
  (SETF CUR-ORDER 0)
  (SETF NEGATIVE FALSE)
  (UNLESS SHORTCUT
    (SETF NEGATIVE FALSE)
    (REPEAT (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
            (WHEN (= CUR-TOK 3117) (SETF NEGATIVE (NOT NEGATIVE)) (SETF CUR-TOK 3115))
            (UNTIL (/= CUR-TOK 3115)))
    (COND ((AND (>= CUR-CMD 68) (<= CUR-CMD 89))
           (COND (MU
                  (SCAN-SOMETHING-INTERNAL 3 FALSE)
                  (WHEN (>= CUR-VAL-LEVEL 2)
                    (SETF V (SLOT (AREF MEM (+ CUR-VAL 1)) INT))
                    (DELETE-GLUE-REF CUR-VAL)
                    (SETF CUR-VAL V))
                  (WHEN (= CUR-VAL-LEVEL 3) (GOTO $L.89))
                  (WHEN (/= CUR-VAL-LEVEL 0) (MU-ERROR)))
                 (TRUE
                  (SCAN-SOMETHING-INTERNAL 1 FALSE)
                  (WHEN (= CUR-VAL-LEVEL 1) (GOTO $L.89)))))
          (TRUE
           (BACK-INPUT)
           (WHEN (= CUR-TOK 3116) (SETF CUR-TOK 3118))
           (COND ((/= CUR-TOK 3118) (SCAN-INT)) (TRUE (SETF RADIX 10) (SETF CUR-VAL 0)))
           (WHEN (= CUR-TOK 3116) (SETF CUR-TOK 3118))
           (WHEN (AND (= RADIX 10) (= CUR-TOK 3118))
             (SETF K 0)
             (SETF P 0)
             (GET-TOKEN)
             (WHILE TRUE
               (GET-X-TOKEN)
               (WHEN (OR (> CUR-TOK 3129) (< CUR-TOK 3120)) (GOTO $L.31))
               (WHEN (< K 17)
                 (SETF Q GET-AVAIL)
                 (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
                 (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (- CUR-TOK 3120))
                 (SETF P Q)
                 (INCF K 1)))
             $L.31
             (FOR (KK K DOWNTO 1)
               (SETF (AREF DIG (- KK 1)) (SLOT (SLOT (AREF MEM P) HH) LH))
               (SETF Q P)
               (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
               (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) AVAIL)
               (SETF AVAIL Q))
             (SETF F (ROUND-DECIMALS K))
             (WHEN (/= CUR-CMD 10) (BACK-INPUT))))))
  (WHEN (< CUR-VAL 0) (SETF NEGATIVE (NOT NEGATIVE)) (SETF CUR-VAL (- CUR-VAL)))
  (WHEN INF
    (WHEN (SCAN-KEYWORD 311)
      (SETF CUR-ORDER 1)
      (WHILE (SCAN-KEYWORD 108)
        (COND ((= CUR-ORDER 3)
               (WHEN (= INTERACTION 3))
               (PRINT-NL 262)
               (PRINT 705)
               (PRINT 706)
               (SETF HELP-PTR 1)
               (SETF (AREF HELP-LINE 0) 707)
               (ERROR))
              (TRUE (INCF CUR-ORDER 1))))
      (GOTO $L.88)))
  (SETF SAVE-CUR-VAL CUR-VAL)
  (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
  (COND ((OR (< CUR-CMD 68) (> CUR-CMD 89)) (BACK-INPUT))
        (TRUE
         (COND (MU
                (SCAN-SOMETHING-INTERNAL 3 FALSE)
                (WHEN (>= CUR-VAL-LEVEL 2)
                  (SETF V (SLOT (AREF MEM (+ CUR-VAL 1)) INT))
                  (DELETE-GLUE-REF CUR-VAL)
                  (SETF CUR-VAL V))
                (WHEN (/= CUR-VAL-LEVEL 3) (MU-ERROR)))
               (TRUE (SCAN-SOMETHING-INTERNAL 1 FALSE)))
         (SETF V CUR-VAL)
         (GOTO $L.40)))
  (WHEN MU (GOTO $L.45))
  (COND ((SCAN-KEYWORD 708)
         (SETF V
               (SLOT (AREF FONT-INFO
                           (+ 6 (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB 7834) HH) RH))))
                     INT)))
        ((SCAN-KEYWORD 709)
         (SETF V
               (SLOT (AREF FONT-INFO
                           (+ 5 (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB 7834) HH) RH))))
                     INT)))
        (TRUE (GOTO $L.45)))
  (GET-X-TOKEN)
  (WHEN (/= CUR-CMD 10) (BACK-INPUT))
  $L.40
  (SETF CUR-VAL (MULT-AND-ADD SAVE-CUR-VAL V (XN-OVER-D V F 65536) 1073741823))
  (GOTO $L.89)
  $L.45
  (WHEN MU
    (COND ((SCAN-KEYWORD 337) (GOTO $L.88))
          (TRUE
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 705)
           (PRINT 710)
           (SETF HELP-PTR 4)
           (SETF (AREF HELP-LINE 3) 711)
           (SETF (AREF HELP-LINE 2) 712)
           (SETF (AREF HELP-LINE 1) 713)
           (SETF (AREF HELP-LINE 0) 714)
           (ERROR)
           (GOTO $L.88))))
  (WHEN (SCAN-KEYWORD 704)
    (PREPARE-MAG)
    (WHEN (/= (SLOT (AREF EQTB 9180) INT) 1000)
      (SETF CUR-VAL (XN-OVER-D CUR-VAL 1000 (SLOT (AREF EQTB 9180) INT)))
      (SETF F (DIV (+ (* 1000 F) (* 65536 REMAINDER)) (SLOT (AREF EQTB 9180) INT)))
      (INCF CUR-VAL (DIV F 65536))
      (SETF F (MOD F 65536))))
  (WHEN (SCAN-KEYWORD 397) (GOTO $L.88))
  (COND ((SCAN-KEYWORD 715) (SETF NUM 7227) (SETF DENOM 100))
        ((SCAN-KEYWORD 716) (SETF NUM 12) (SETF DENOM 1))
        ((SCAN-KEYWORD 717) (SETF NUM 7227) (SETF DENOM 254))
        ((SCAN-KEYWORD 718) (SETF NUM 7227) (SETF DENOM 2540))
        ((SCAN-KEYWORD 719) (SETF NUM 7227) (SETF DENOM 7200))
        ((SCAN-KEYWORD 720) (SETF NUM 1238) (SETF DENOM 1157))
        ((SCAN-KEYWORD 721) (SETF NUM 14856) (SETF DENOM 1157))
        ((SCAN-KEYWORD 722) (GOTO $L.30))
        (TRUE
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 705)
         (PRINT 723)
         (SETF HELP-PTR 6)
         (SETF (AREF HELP-LINE 5) 724)
         (SETF (AREF HELP-LINE 4) 725)
         (SETF (AREF HELP-LINE 3) 726)
         (SETF (AREF HELP-LINE 2) 712)
         (SETF (AREF HELP-LINE 1) 713)
         (SETF (AREF HELP-LINE 0) 714)
         (ERROR)
         (GOTO $L.32)))
  (SETF CUR-VAL (XN-OVER-D CUR-VAL NUM DENOM))
  (SETF F (DIV (+ (* NUM F) (* 65536 REMAINDER)) DENOM))
  (INCF CUR-VAL (DIV F 65536))
  (SETF F (MOD F 65536))
  $L.32
  $L.88
  (COND ((>= CUR-VAL 16384) (SETF ARITH-ERROR TRUE))
        (TRUE (SETF CUR-VAL (+ (* CUR-VAL 65536) F))))
  $L.30
  (GET-X-TOKEN)
  (WHEN (/= CUR-CMD 10) (BACK-INPUT))
  $L.89
  (WHEN (OR ARITH-ERROR (>= (ABS CUR-VAL) 1073741824))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 727)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 728)
    (SETF (AREF HELP-LINE 0) 729)
    (ERROR)
    (SETF CUR-VAL 1073741823)
    (SETF ARITH-ERROR FALSE))
  (WHEN NEGATIVE (SETF CUR-VAL (- CUR-VAL))))

(PROCEDURE SCAN-GLUE ((LEVEL SMALL-NUMBER))
  (LABEL $L.10)
  (VAR NEGATIVE BOOLEAN)
  (VAR Q HALFWORD)
  (VAR MU BOOLEAN)
  (SETF MU (= LEVEL 3))
  (SETF NEGATIVE FALSE)
  (REPEAT (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
          (WHEN (= CUR-TOK 3117) (SETF NEGATIVE (NOT NEGATIVE)) (SETF CUR-TOK 3115))
          (UNTIL (/= CUR-TOK 3115)))
  (COND ((AND (>= CUR-CMD 68) (<= CUR-CMD 89))
         (SCAN-SOMETHING-INTERNAL LEVEL NEGATIVE)
         (WHEN (>= CUR-VAL-LEVEL 2) (WHEN (/= CUR-VAL-LEVEL LEVEL) (MU-ERROR)) (GOTO $L.10))
         (COND ((= CUR-VAL-LEVEL 0) (SCAN-DIMEN MU FALSE TRUE)) ((= LEVEL 3) (MU-ERROR))))
        (TRUE
         (BACK-INPUT)
         (SCAN-DIMEN MU FALSE FALSE)
         (WHEN NEGATIVE (SETF CUR-VAL (- CUR-VAL)))))
  (SETF Q (NEW-SPEC 0))
  (SETF (SLOT (AREF MEM (+ Q 1)) INT) CUR-VAL)
  (WHEN (SCAN-KEYWORD 730)
    (SCAN-DIMEN MU TRUE FALSE)
    (SETF (SLOT (AREF MEM (+ Q 2)) INT) CUR-VAL)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) CUR-ORDER))
  (WHEN (SCAN-KEYWORD 731)
    (SCAN-DIMEN MU TRUE FALSE)
    (SETF (SLOT (AREF MEM (+ Q 3)) INT) CUR-VAL)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) CUR-ORDER))
  (SETF CUR-VAL Q)
  $L.10)

(FUNCTION (SCAN-RULE-SPEC HALFWORD) ()
  (LABEL $L.21)
  (VAR Q HALFWORD)
  (SETF Q NEW-RULE)
  (COND ((= CUR-CMD 35) (SETF (SLOT (AREF MEM (+ Q 1)) INT) 26214))
        (TRUE
         (SETF (SLOT (AREF MEM (+ Q 3)) INT) 26214)
         (SETF (SLOT (AREF MEM (+ Q 2)) INT) 0)))
  $L.21
  (WHEN (SCAN-KEYWORD 732)
    (SCAN-DIMEN FALSE FALSE FALSE)
    (SETF (SLOT (AREF MEM (+ Q 1)) INT) CUR-VAL)
    (GOTO $L.21))
  (WHEN (SCAN-KEYWORD 733)
    (SCAN-DIMEN FALSE FALSE FALSE)
    (SETF (SLOT (AREF MEM (+ Q 3)) INT) CUR-VAL)
    (GOTO $L.21))
  (WHEN (SCAN-KEYWORD 734)
    (SCAN-DIMEN FALSE FALSE FALSE)
    (SETF (SLOT (AREF MEM (+ Q 2)) INT) CUR-VAL)
    (GOTO $L.21))
  (SETF SCAN-RULE-SPEC Q))

(FUNCTION (STR-TOKS HALFWORD) ((B POOL-POINTER))
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR T HALFWORD)
  (VAR K POOL-POINTER)
  (WHEN (> (+ POOL-PTR 1) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
  (SETF P 59997)
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
  (SETF K B)
  (WHILE (< K POOL-PTR)
    (SETF T (AREF STR-POOL K))
    (COND ((= T 32) (SETF T 2592)) (TRUE (SETF T (+ 3072 T))))
    (SETF Q AVAIL)
    (COND ((= Q 0) (SETF Q GET-AVAIL))
          (TRUE
           (SETF AVAIL (SLOT (SLOT (AREF MEM Q) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)))
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) T)
    (SETF P Q)
    (INCF K 1))
  (SETF POOL-PTR B)
  (SETF STR-TOKS P))

(FUNCTION (THE-TOKS HALFWORD) ()
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR B POOL-POINTER)
  (GET-X-TOKEN)
  (SCAN-SOMETHING-INTERNAL 5 FALSE)
  (COND ((>= CUR-VAL-LEVEL 4)
         (SETF P 59997)
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
         (COND ((= CUR-VAL-LEVEL 4)
                (SETF Q GET-AVAIL)
                (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (+ 4095 CUR-VAL))
                (SETF P Q))
               ((/= CUR-VAL 0)
                (SETF R (SLOT (SLOT (AREF MEM CUR-VAL) HH) RH))
                (WHILE (/= R 0)
                  (SETF Q AVAIL)
                  (COND ((= Q 0) (SETF Q GET-AVAIL))
                        (TRUE
                         (SETF AVAIL (SLOT (SLOT (AREF MEM Q) HH) RH))
                         (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)))
                  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
                  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (SLOT (SLOT (AREF MEM R) HH) LH))
                  (SETF P Q)
                  (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)))))
         (SETF THE-TOKS P))
        (TRUE
         (SETF OLD-SETTING SELECTOR)
         (SETF SELECTOR 21)
         (SETF B POOL-PTR)
         (CASE CUR-VAL-LEVEL
           ((0) (PRINT-INT CUR-VAL))
           ((1) (PRINT-SCALED CUR-VAL) (PRINT 397))
           ((2) (PRINT-SPEC CUR-VAL 397) (DELETE-GLUE-REF CUR-VAL))
           ((3) (PRINT-SPEC CUR-VAL 337) (DELETE-GLUE-REF CUR-VAL)))
         (SETF SELECTOR OLD-SETTING)
         (SETF THE-TOKS (STR-TOKS B)))))

(PROCEDURE INS-THE-TOKS ()
  (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH) THE-TOKS)
  (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF MEM 59997) HH) RH) 4))

(PROCEDURE CONV-TOKS ()
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR C (RANGE 0 5))
  (VAR SAVE-SCANNER-STATUS SMALL-NUMBER)
  (VAR B POOL-POINTER)
  (SETF C CUR-CHR)
  (CASE C
    ((0 1) (SCAN-INT))
    ((2 3) (SETF SAVE-SCANNER-STATUS SCANNER-STATUS) (SETF SCANNER-STATUS 0) (GET-TOKEN)
     (SETF SCANNER-STATUS SAVE-SCANNER-STATUS))
    ((4) (SCAN-FONT-IDENT))
    ((5) (WHEN (= JOB-NAME 0) (OPEN-LOG-FILE))))
  (SETF OLD-SETTING SELECTOR)
  (SETF SELECTOR 21)
  (SETF B POOL-PTR)
  (CASE C
    ((0) (PRINT-INT CUR-VAL))
    ((1) (PRINT-ROMAN-INT CUR-VAL))
    ((2) (COND ((/= CUR-CS 0) (SPRINT-CS CUR-CS)) (TRUE (PRINT-CHAR CUR-CHR))))
    ((3) (PRINT-MEANING))
    ((4) (PRINT (AREF FONT-NAME CUR-VAL))
     (WHEN (/= (AREF FONT-SIZE CUR-VAL) (AREF FONT-DSIZE CUR-VAL))
       (PRINT 741)
       (PRINT-SCALED (AREF FONT-SIZE CUR-VAL))
       (PRINT 397)))
    ((5) (PRINT JOB-NAME)))
  (SETF SELECTOR OLD-SETTING)
  (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH) (STR-TOKS B))
  (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF MEM 59997) HH) RH) 4))

(FUNCTION (SCAN-TOKS HALFWORD) ((MACRO-DEF BOOLEAN) (XPAND BOOLEAN))
  (LABEL $L.40)
  (LABEL $L.22)
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.32)
  (VAR T HALFWORD)
  (VAR S HALFWORD)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR UNBALANCE HALFWORD)
  (VAR HASH-BRACE HALFWORD)
  (COND (MACRO-DEF (SETF SCANNER-STATUS 2)) (TRUE (SETF SCANNER-STATUS 5)))
  (SETF WARNING-INDEX CUR-CS)
  (SETF DEF-REF GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM DEF-REF) HH) LH) 0)
  (SETF P DEF-REF)
  (SETF HASH-BRACE 0)
  (SETF T 3120)
  (COND (MACRO-DEF
         (WHILE TRUE
           $L.22
           (GET-TOKEN)
           (WHEN (< CUR-TOK 768) (GOTO $L.31))
           (WHEN (= CUR-CMD 6)
             (SETF S (+ 3328 CUR-CHR))
             (GET-TOKEN)
             (WHEN (< CUR-TOK 512)
               (SETF HASH-BRACE CUR-TOK)
               (SETF Q GET-AVAIL)
               (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
               (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
               (SETF P Q)
               (SETF Q GET-AVAIL)
               (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
               (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 3584)
               (SETF P Q)
               (GOTO $L.30))
             (COND ((= T 3129)
                    (WHEN (= INTERACTION 3))
                    (PRINT-NL 262)
                    (PRINT 744)
                    (SETF HELP-PTR 2)
                    (SETF (AREF HELP-LINE 1) 745)
                    (SETF (AREF HELP-LINE 0) 746)
                    (ERROR)
                    (GOTO $L.22))
                   (TRUE
                    (INCF T 1)
                    (WHEN (/= CUR-TOK T)
                      (WHEN (= INTERACTION 3))
                      (PRINT-NL 262)
                      (PRINT 747)
                      (SETF HELP-PTR 2)
                      (SETF (AREF HELP-LINE 1) 748)
                      (SETF (AREF HELP-LINE 0) 749)
                      (BACK-ERROR))
                    (SETF CUR-TOK S))))
           (SETF Q GET-AVAIL)
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
           (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
           (SETF P Q))
         $L.31
         (SETF Q GET-AVAIL)
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
         (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 3584)
         (SETF P Q)
         (WHEN (= CUR-CMD 2)
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 657)
           (INCF ALIGN-STATE 1)
           (SETF HELP-PTR 2)
           (SETF (AREF HELP-LINE 1) 742)
           (SETF (AREF HELP-LINE 0) 743)
           (ERROR)
           (GOTO $L.40))
         $L.30)
        (TRUE (SCAN-LEFT-BRACE)))
  (SETF UNBALANCE 1)
  (WHILE TRUE
    (COND (XPAND
           (WHILE TRUE
             (GET-NEXT)
             (WHEN (<= CUR-CMD 100) (GOTO $L.32))
             (COND ((/= CUR-CMD 109) (EXPAND))
                   (TRUE
                    (SETF Q THE-TOKS)
                    (WHEN (/= (SLOT (SLOT (AREF MEM 59997) HH) RH) 0)
                      (SETF (SLOT (SLOT (AREF MEM P) HH) RH)
                            (SLOT (SLOT (AREF MEM 59997) HH) RH))
                      (SETF P Q)))))
           $L.32
           (X-TOKEN))
          (TRUE (GET-TOKEN)))
    (COND ((< CUR-TOK 768)
           (COND ((< CUR-CMD 2) (INCF UNBALANCE 1))
                 (TRUE (DECF UNBALANCE 1) (WHEN (= UNBALANCE 0) (GOTO $L.40)))))
          ((= CUR-CMD 6)
           (WHEN MACRO-DEF
             (SETF S CUR-TOK)
             (COND (XPAND (GET-X-TOKEN)) (TRUE (GET-TOKEN)))
             (WHEN (/= CUR-CMD 6)
               (COND ((OR (<= CUR-TOK 3120) (> CUR-TOK T))
                      (WHEN (= INTERACTION 3))
                      (PRINT-NL 262)
                      (PRINT 750)
                      (SPRINT-CS WARNING-INDEX)
                      (SETF HELP-PTR 3)
                      (SETF (AREF HELP-LINE 2) 751)
                      (SETF (AREF HELP-LINE 1) 752)
                      (SETF (AREF HELP-LINE 0) 753)
                      (BACK-ERROR)
                      (SETF CUR-TOK S))
                     (TRUE (SETF CUR-TOK (+ 1232 CUR-CHR))))))))
    (SETF Q GET-AVAIL)
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
    (SETF P Q))
  $L.40
  (SETF SCANNER-STATUS 0)
  (WHEN (/= HASH-BRACE 0)
    (SETF Q GET-AVAIL)
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) HASH-BRACE)
    (SETF P Q))
  (SETF SCAN-TOKS P))

(PROCEDURE READ-TOKS ((N INTEGER) (R HALFWORD))
  (LABEL $L.30)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR S INTEGER)
  (VAR M SMALL-NUMBER)
  (SETF SCANNER-STATUS 2)
  (SETF WARNING-INDEX R)
  (SETF DEF-REF GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM DEF-REF) HH) LH) 0)
  (SETF P DEF-REF)
  (SETF Q GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 3584)
  (SETF P Q)
  (COND ((OR (< N 0) (> N 15)) (SETF M 16)) (TRUE (SETF M N)))
  (SETF S ALIGN-STATE)
  (SETF ALIGN-STATE 1000000)
  (REPEAT (BEGIN-FILE-READING)
          (SETF (SLOT CUR-INPUT NAME-FIELD) (+ M 1))
          (COND ((= (AREF READ-OPEN M) 2)
                 (COND ((> INTERACTION 1)
                        (COND ((< N 0) (PRINT 338) (TERM-INPUT))
                              (TRUE
                               (PRINT-LN)
                               (SPRINT-CS R)
                               (PRINT 61)
                               (TERM-INPUT)
                               (SETF N (- 1)))))
                       (TRUE (FATAL-ERROR 754))))
                ((= (AREF READ-OPEN M) 1)
                 (COND ((INPUT-LN (AREF READ-FILE M) FALSE) (SETF (AREF READ-OPEN M) 0))
                       (TRUE (A-CLOSE (AREF READ-FILE M)) (SETF (AREF READ-OPEN M) 2))))
                ((NOT (UNLESS (INPUT-LN (AREF READ-FILE M) TRUE)
                        (A-CLOSE (AREF READ-FILE M))
                        (SETF (AREF READ-OPEN M) 2)
                        (WHEN (/= ALIGN-STATE 1000000)
                          (RUNAWAY)
                          (WHEN (= INTERACTION 3))
                          (PRINT-NL 262)
                          (PRINT 755)
                          (PRINT-ESC 534)
                          (SETF HELP-PTR 1)
                          (SETF (AREF HELP-LINE 0) 756)
                          (SETF ALIGN-STATE 1000000)
                          (SETF (SLOT CUR-INPUT LIMIT-FIELD) 0)
                          (ERROR))))
                 (A-CLOSE (AREF READ-FILE M))
                 (SETF (AREF READ-OPEN M) 2)
                 (WHEN (/= ALIGN-STATE 1000000)
                   (RUNAWAY)
                   (WHEN (= INTERACTION 3))
                   (PRINT-NL 262)
                   (PRINT 755)
                   (PRINT-ESC 534)
                   (SETF HELP-PTR 1)
                   (SETF (AREF HELP-LINE 0) 756)
                   (SETF ALIGN-STATE 1000000)
                   (SETF (SLOT CUR-INPUT LIMIT-FIELD) 0)
                   (ERROR))))
          (SETF (SLOT CUR-INPUT LIMIT-FIELD) LAST)
          (COND ((OR (< (SLOT (AREF EQTB 9211) INT) 0) (> (SLOT (AREF EQTB 9211) INT) 255))
                 (SETF (SLOT CUR-INPUT LIMIT-FIELD) (- (SLOT CUR-INPUT LIMIT-FIELD) 1)))
                (TRUE
                 (SETF (AREF BUFFER (SLOT CUR-INPUT LIMIT-FIELD))
                       (SLOT (AREF EQTB 9211) INT))))
          (SETF FIRST (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
          (SETF (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT START-FIELD))
          (SETF (SLOT CUR-INPUT STATE-FIELD) 33)
          (WHILE TRUE
            (GET-TOKEN)
            (WHEN (= CUR-TOK 0) (GOTO $L.30))
            (WHEN (< ALIGN-STATE 1000000)
              (REPEAT (GET-TOKEN) (UNTIL (= CUR-TOK 0)))
              (SETF ALIGN-STATE 1000000)
              (GOTO $L.30))
            (SETF Q GET-AVAIL)
            (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
            (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) CUR-TOK)
            (SETF P Q))
          $L.30
          (END-FILE-READING)
          (UNTIL (= ALIGN-STATE 1000000)))
  (SETF CUR-VAL DEF-REF)
  (SETF SCANNER-STATUS 0)
  (SETF ALIGN-STATE S))

(PROCEDURE PASS-TEXT ()
  (LABEL $L.30)
  (VAR L INTEGER)
  (VAR SAVE-SCANNER-STATUS SMALL-NUMBER)
  (SETF SAVE-SCANNER-STATUS SCANNER-STATUS)
  (SETF SCANNER-STATUS 1)
  (SETF L 0)
  (SETF SKIP-LINE LINE)
  (WHILE TRUE
    (GET-NEXT)
    (COND ((= CUR-CMD 106) (WHEN (= L 0) (GOTO $L.30)) (WHEN (= CUR-CHR 2) (DECF L 1)))
          ((= CUR-CMD 105) (INCF L 1))))
  $L.30
  (SETF SCANNER-STATUS SAVE-SCANNER-STATUS))

(PROCEDURE CHANGE-IF-LIMIT ((L SMALL-NUMBER) (P HALFWORD))
  (LABEL $L.10)
  (VAR Q HALFWORD)
  (COND ((= P COND-PTR) (SETF IF-LIMIT L))
        (TRUE
         (SETF Q COND-PTR)
         (WHILE TRUE
           (WHEN (= Q 0) (CONFUSION 757))
           (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) RH) P)
             (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) L)
             (GOTO $L.10))
           (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))))
  $L.10)

(PROCEDURE CONDITIONAL ()
  (LABEL $L.10)
  (LABEL $L.50)
  (VAR B BOOLEAN)
  (VAR R (RANGE 60 62))
  (VAR M INTEGER)
  (VAR N INTEGER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR SAVE-SCANNER-STATUS SMALL-NUMBER)
  (VAR SAVE-COND-PTR HALFWORD)
  (VAR THIS-IF SMALL-NUMBER)
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) COND-PTR)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) IF-LIMIT)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) CUR-IF)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) IF-LINE)
  (SETF COND-PTR P)
  (SETF CUR-IF CUR-CHR)
  (SETF IF-LIMIT 1)
  (SETF IF-LINE LINE)
  (SETF SAVE-COND-PTR COND-PTR)
  (SETF THIS-IF CUR-CHR)
  (CASE THIS-IF
    ((0 1) (GET-X-TOKEN)
     (WHEN (= CUR-CMD 0)
       (WHEN (= CUR-CHR 257) (SETF CUR-CMD 13) (SETF CUR-CHR (- CUR-TOK 4096))))
     (COND ((OR (> CUR-CMD 13) (> CUR-CHR 255)) (SETF M 0) (SETF N 256))
           (TRUE (SETF M CUR-CMD) (SETF N CUR-CHR)))
     (GET-X-TOKEN)
     (WHEN (= CUR-CMD 0)
       (WHEN (= CUR-CHR 257) (SETF CUR-CMD 13) (SETF CUR-CHR (- CUR-TOK 4096))))
     (WHEN (OR (> CUR-CMD 13) (> CUR-CHR 255)) (SETF CUR-CMD 0) (SETF CUR-CHR 256))
     (COND ((= THIS-IF 0) (SETF B (= N CUR-CHR))) (TRUE (SETF B (= M CUR-CMD)))))
    ((2 3) (COND ((= THIS-IF 2) (SCAN-INT)) (TRUE (SCAN-DIMEN FALSE FALSE FALSE)))
     (SETF N CUR-VAL) (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
     (COND ((AND (>= CUR-TOK 3132) (<= CUR-TOK 3134)) (SETF R (- CUR-TOK 3072)))
           (TRUE
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 781)
            (PRINT-CMD-CHR 105 THIS-IF)
            (SETF HELP-PTR 1)
            (SETF (AREF HELP-LINE 0) 782)
            (BACK-ERROR)
            (SETF R 61)))
     (COND ((= THIS-IF 2) (SCAN-INT)) (TRUE (SCAN-DIMEN FALSE FALSE FALSE)))
     (CASE R
       ((60) (SETF B (< N CUR-VAL)))
       ((61) (SETF B (= N CUR-VAL)))
       ((62) (SETF B (> N CUR-VAL)))))
    ((4) (SCAN-INT) (SETF B (ODD CUR-VAL)))
    ((5) (SETF B (= (ABS (SLOT CUR-LIST MODE-FIELD)) 1)))
    ((6) (SETF B (= (ABS (SLOT CUR-LIST MODE-FIELD)) 102)))
    ((7) (SETF B (= (ABS (SLOT CUR-LIST MODE-FIELD)) 203)))
    ((8) (SETF B (< (SLOT CUR-LIST MODE-FIELD) 0)))
    ((9 10 11) (SCAN-EIGHT-BIT-INT) (SETF P (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH))
     (COND ((= THIS-IF 9) (SETF B (= P 0)))
           ((= P 0) (SETF B FALSE))
           ((= THIS-IF 10) (SETF B (= (SLOT (SLOT (AREF MEM P) HH) B0) 0)))
           (TRUE (SETF B (= (SLOT (SLOT (AREF MEM P) HH) B0) 1)))))
    ((12) (SETF SAVE-SCANNER-STATUS SCANNER-STATUS) (SETF SCANNER-STATUS 0) (GET-NEXT)
     (SETF N CUR-CS) (SETF P CUR-CMD) (SETF Q CUR-CHR) (GET-NEXT)
     (COND ((/= CUR-CMD P) (SETF B FALSE))
           ((< CUR-CMD 111) (SETF B (= CUR-CHR Q)))
           (TRUE
            (SETF P (SLOT (SLOT (AREF MEM CUR-CHR) HH) RH))
            (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB N) HH) RH)) HH) RH))
            (COND ((= P Q) (SETF B TRUE))
                  (TRUE
                   (WHILE (AND (/= P 0) (/= Q 0))
                     (COND ((/= (SLOT (SLOT (AREF MEM P) HH) LH)
                                (SLOT (SLOT (AREF MEM Q) HH) LH))
                            (SETF P 0))
                           (TRUE
                            (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
                            (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))))
                   (SETF B (AND (= P 0) (= Q 0)))))))
     (SETF SCANNER-STATUS SAVE-SCANNER-STATUS))
    ((13) (SCAN-FOUR-BIT-INT) (SETF B (= (AREF READ-OPEN CUR-VAL) 2)))
    ((14) (SETF B TRUE))
    ((15) (SETF B FALSE))
    ((16) (SCAN-INT) (SETF N CUR-VAL)
     (WHEN (> (SLOT (AREF EQTB 9199) INT) 1)
       (BEGIN-DIAGNOSTIC)
       (PRINT 783)
       (PRINT-INT N)
       (PRINT-CHAR 125)
       (END-DIAGNOSTIC FALSE))
     (WHILE (/= N 0)
       (PASS-TEXT)
       (COND ((= COND-PTR SAVE-COND-PTR) (COND ((= CUR-CHR 4) (DECF N 1)) (TRUE (GOTO $L.50))))
             ((= CUR-CHR 2)
              (SETF P COND-PTR)
              (SETF IF-LINE (SLOT (AREF MEM (+ P 1)) INT))
              (SETF CUR-IF (SLOT (SLOT (AREF MEM P) HH) B1))
              (SETF IF-LIMIT (SLOT (SLOT (AREF MEM P) HH) B0))
              (SETF COND-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
              (FREE-NODE P 2))))
     (CHANGE-IF-LIMIT 4 SAVE-COND-PTR) (GOTO $L.10)))
  (WHEN (> (SLOT (AREF EQTB 9199) INT) 1)
    (BEGIN-DIAGNOSTIC)
    (COND (B (PRINT 779)) (TRUE (PRINT 780)))
    (END-DIAGNOSTIC FALSE))
  (WHEN B (CHANGE-IF-LIMIT 3 SAVE-COND-PTR) (GOTO $L.10))
  (WHILE TRUE
    (PASS-TEXT)
    (COND ((= COND-PTR SAVE-COND-PTR)
           (WHEN (/= CUR-CHR 4) (GOTO $L.50))
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 777)
           (PRINT-ESC 775)
           (SETF HELP-PTR 1)
           (SETF (AREF HELP-LINE 0) 778)
           (ERROR))
          ((= CUR-CHR 2)
           (SETF P COND-PTR)
           (SETF IF-LINE (SLOT (AREF MEM (+ P 1)) INT))
           (SETF CUR-IF (SLOT (SLOT (AREF MEM P) HH) B1))
           (SETF IF-LIMIT (SLOT (SLOT (AREF MEM P) HH) B0))
           (SETF COND-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
           (FREE-NODE P 2))))
  $L.50
  (COND ((= CUR-CHR 2)
         (SETF P COND-PTR)
         (SETF IF-LINE (SLOT (AREF MEM (+ P 1)) INT))
         (SETF CUR-IF (SLOT (SLOT (AREF MEM P) HH) B1))
         (SETF IF-LIMIT (SLOT (SLOT (AREF MEM P) HH) B0))
         (SETF COND-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
         (FREE-NODE P 2))
        (TRUE (SETF IF-LIMIT 2)))
  $L.10)

(PROCEDURE BEGIN-NAME () (SETF AREA-DELIMITER 0) (SETF EXT-DELIMITER 0))

(FUNCTION (MORE-NAME BOOLEAN) ((C ASCII-CODE))
  (COND ((= C 32) (SETF MORE-NAME FALSE))
        (TRUE
         (WHEN (> (+ POOL-PTR 1) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
         (SETF (AREF STR-POOL POOL-PTR) C)
         (INCF POOL-PTR 1)
         (COND ((OR (= C 62) (= C 58))
                (SETF AREA-DELIMITER (- POOL-PTR (AREF STR-START STR-PTR)))
                (SETF EXT-DELIMITER 0))
               ((AND (= C 46) (= EXT-DELIMITER 0))
                (SETF EXT-DELIMITER (- POOL-PTR (AREF STR-START STR-PTR)))))
         (SETF MORE-NAME TRUE))))

(PROCEDURE END-NAME ()
  (WHEN (> (+ STR-PTR 3) MAX-STRINGS) (OVERFLOW 258 (- MAX-STRINGS INIT-STR-PTR)))
  (COND ((= AREA-DELIMITER 0) (SETF CUR-AREA 338))
        (TRUE
         (SETF CUR-AREA STR-PTR)
         (SETF (AREF STR-START (+ STR-PTR 1)) (+ (AREF STR-START STR-PTR) AREA-DELIMITER))
         (INCF STR-PTR 1)))
  (COND ((= EXT-DELIMITER 0) (SETF CUR-EXT 338) (SETF CUR-NAME MAKE-STRING))
        (TRUE
         (SETF CUR-NAME STR-PTR)
         (SETF (AREF STR-START (+ STR-PTR 1))
               (- (- (+ (AREF STR-START STR-PTR) EXT-DELIMITER) AREA-DELIMITER) 1))
         (INCF STR-PTR 1)
         (SETF CUR-EXT MAKE-STRING))))

(PROCEDURE PACK-FILE-NAME ((N STR-NUMBER) (A STR-NUMBER) (E STR-NUMBER))
  (VAR K INTEGER)
  (VAR C ASCII-CODE)
  (VAR J POOL-POINTER)
  (SETF K 0)
  (FOR (J (AREF STR-START A) TO (- (AREF STR-START (+ A 1)) 1))
    (SETF C (AREF STR-POOL J))
    (INCF K 1)
    (WHEN (<= K FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) (AREF XCHR C))))
  (FOR (J (AREF STR-START N) TO (- (AREF STR-START (+ N 1)) 1))
    (SETF C (AREF STR-POOL J))
    (INCF K 1)
    (WHEN (<= K FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) (AREF XCHR C))))
  (FOR (J (AREF STR-START E) TO (- (AREF STR-START (+ E 1)) 1))
    (SETF C (AREF STR-POOL J))
    (INCF K 1)
    (WHEN (<= K FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) (AREF XCHR C))))
  (COND ((<= K FILE-NAME-SIZE) (SETF NAME-LENGTH K)) (TRUE (SETF NAME-LENGTH FILE-NAME-SIZE)))
  (FOR (K (+ NAME-LENGTH 1) TO FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) " ")))

(PROCEDURE PACK-BUFFERED-NAME ((N SMALL-NUMBER) (A INTEGER) (B INTEGER))
  (VAR K INTEGER)
  (VAR C ASCII-CODE)
  (VAR J INTEGER)
  (WHEN (> (+ (- (+ N B) A) 5) FILE-NAME-SIZE) (SETF B (- (- (+ A FILE-NAME-SIZE) N) 5)))
  (SETF K 0)
  (FOR (J 1 TO N)
    (SETF C (AREF XORD (AREF TEX-FORMAT-DEFAULT J)))
    (INCF K 1)
    (WHEN (<= K FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) (AREF XCHR C))))
  (FOR (J A TO B)
    (SETF C (AREF BUFFER J))
    (INCF K 1)
    (WHEN (<= K FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) (AREF XCHR C))))
  (FOR (J 17 TO 20)
    (SETF C (AREF XORD (AREF TEX-FORMAT-DEFAULT J)))
    (INCF K 1)
    (WHEN (<= K FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) (AREF XCHR C))))
  (COND ((<= K FILE-NAME-SIZE) (SETF NAME-LENGTH K)) (TRUE (SETF NAME-LENGTH FILE-NAME-SIZE)))
  (FOR (K (+ NAME-LENGTH 1) TO FILE-NAME-SIZE) (SETF (AREF NAME-OF-FILE K) " ")))

(FUNCTION (MAKE-NAME-STRING STR-NUMBER) ()
  (VAR K (RANGE 1 FILE-NAME-SIZE))
  (COND ((OR (OR (> (+ POOL-PTR NAME-LENGTH) POOL-SIZE) (= STR-PTR MAX-STRINGS))
             (> (- POOL-PTR (AREF STR-START STR-PTR)) 0))
         (SETF MAKE-NAME-STRING 63))
        (TRUE
         (FOR (K 1 TO NAME-LENGTH)
           (SETF (AREF STR-POOL POOL-PTR) (AREF XORD (AREF NAME-OF-FILE K)))
           (INCF POOL-PTR 1))
         (SETF MAKE-NAME-STRING MAKE-STRING))))

(FUNCTION (A-MAKE-NAME-STRING STR-NUMBER) ((F (VAR ALPHA-FILE)))
  (SETF A-MAKE-NAME-STRING MAKE-NAME-STRING))

(FUNCTION (B-MAKE-NAME-STRING STR-NUMBER) ((F (VAR BYTE-FILE)))
  (SETF B-MAKE-NAME-STRING MAKE-NAME-STRING))

(FUNCTION (W-MAKE-NAME-STRING STR-NUMBER) ((F (VAR WORD-FILE)))
  (SETF W-MAKE-NAME-STRING MAKE-NAME-STRING))

(PROCEDURE SCAN-FILE-NAME ()
  (LABEL $L.30)
  (SETF NAME-IN-PROGRESS TRUE)
  (BEGIN-NAME)
  (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
  (WHILE TRUE
    (WHEN (OR (> CUR-CMD 12) (> CUR-CHR 255)) (BACK-INPUT) (GOTO $L.30))
    (UNLESS (MORE-NAME CUR-CHR) (GOTO $L.30))
    (GET-X-TOKEN))
  $L.30
  (END-NAME)
  (SETF NAME-IN-PROGRESS FALSE))

(PROCEDURE PACK-JOB-NAME ((S STR-NUMBER))
  (SETF CUR-AREA 338)
  (SETF CUR-EXT S)
  (SETF CUR-NAME JOB-NAME)
  (PACK-FILE-NAME CUR-NAME CUR-AREA CUR-EXT))

(PROCEDURE PROMPT-FILE-NAME ((S STR-NUMBER) (E STR-NUMBER))
  (LABEL $L.30)
  (VAR K (RANGE 0 BUF-SIZE))
  (WHEN (= INTERACTION 2))
  (COND ((= S 787) (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 788))
        (TRUE (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 789)))
  (PRINT-FILE-NAME CUR-NAME CUR-AREA CUR-EXT)
  (PRINT 790)
  (WHEN (= E 791) (SHOW-CONTEXT))
  (PRINT-NL 792)
  (PRINT S)
  (WHEN (< INTERACTION 2) (FATAL-ERROR 793))
  (BREAK-IN TERM-IN TRUE)
  (PRINT 568)
  (TERM-INPUT)
  (BEGIN-NAME)
  (SETF K FIRST)
  (WHILE (AND (= (AREF BUFFER K) 32) (< K LAST)) (INCF K 1))
  (WHILE TRUE
    (WHEN (= K LAST) (GOTO $L.30))
    (UNLESS (MORE-NAME (AREF BUFFER K)) (GOTO $L.30))
    (INCF K 1))
  $L.30
  (END-NAME)
  (WHEN (= CUR-EXT 338) (SETF CUR-EXT E))
  (PACK-FILE-NAME CUR-NAME CUR-AREA CUR-EXT))

(PROCEDURE OPEN-LOG-FILE ()
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR K (RANGE 0 BUF-SIZE))
  (VAR L (RANGE 0 BUF-SIZE))
  (VAR MONTHS (PACKED (ARRAY CHAR (RANGE 1 36))))
  (SETF OLD-SETTING SELECTOR)
  (WHEN (= JOB-NAME 0) (SETF JOB-NAME 796))
  (PACK-JOB-NAME 797)
  (WHILE (NOT (A-OPEN-OUT LOG-FILE)) (SETF SELECTOR 17) (PROMPT-FILE-NAME 799 797))
  (SETF LOG-NAME (A-MAKE-NAME-STRING LOG-FILE))
  (SETF SELECTOR 18)
  (SETF LOG-OPENED TRUE)
  (WRITE LOG-FILE "This is TeX, Version 3.141592653")
  (SLOW-PRINT FORMAT-IDENT)
  (PRINT 800)
  (PRINT-INT SYS-DAY)
  (PRINT-CHAR 32)
  (SETF MONTHS "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC")
  (FOR (K (- (* 3 SYS-MONTH) 2) TO (* 3 SYS-MONTH)) (WRITE LOG-FILE (AREF MONTHS K)))
  (PRINT-CHAR 32)
  (PRINT-INT SYS-YEAR)
  (PRINT-CHAR 32)
  (PRINT-TWO (DIV SYS-TIME 60))
  (PRINT-CHAR 58)
  (PRINT-TWO (MOD SYS-TIME 60))
  (SETF (AREF INPUT-STACK INPUT-PTR) CUR-INPUT)
  (PRINT-NL 798)
  (SETF L (SLOT (AREF INPUT-STACK 0) LIMIT-FIELD))
  (WHEN (= (AREF BUFFER L) (SLOT (AREF EQTB 9211) INT)) (DECF L 1))
  (FOR (K 1 TO L) (PRINT (AREF BUFFER K)))
  (PRINT-LN)
  (SETF SELECTOR (+ OLD-SETTING 2)))

(PROCEDURE START-INPUT ()
  (LABEL $L.30)
  (SCAN-FILE-NAME)
  (WHEN (= CUR-EXT 338) (SETF CUR-EXT 791))
  (PACK-FILE-NAME CUR-NAME CUR-AREA CUR-EXT)
  (WHILE TRUE
    (BEGIN-FILE-READING)
    (WHEN (A-OPEN-IN (AREF INPUT-FILE (SLOT CUR-INPUT INDEX-FIELD))) (GOTO $L.30))
    (WHEN (= CUR-AREA 338)
      (PACK-FILE-NAME CUR-NAME 784 CUR-EXT)
      (WHEN (A-OPEN-IN (AREF INPUT-FILE (SLOT CUR-INPUT INDEX-FIELD))) (GOTO $L.30)))
    (END-FILE-READING)
    (PROMPT-FILE-NAME 787 791))
  $L.30
  (SETF (SLOT CUR-INPUT NAME-FIELD)
        (A-MAKE-NAME-STRING (AREF INPUT-FILE (SLOT CUR-INPUT INDEX-FIELD))))
  (WHEN (= JOB-NAME 0) (SETF JOB-NAME CUR-NAME) (OPEN-LOG-FILE))
  (COND ((> (+ TERM-OFFSET
               (- (AREF STR-START (+ (SLOT CUR-INPUT NAME-FIELD) 1))
                  (AREF STR-START (SLOT CUR-INPUT NAME-FIELD))))
            (- MAX-PRINT-LINE 2))
         (PRINT-LN))
        ((OR (> TERM-OFFSET 0) (> FILE-OFFSET 0)) (PRINT-CHAR 32)))
  (PRINT-CHAR 40)
  (INCF OPEN-PARENS 1)
  (SLOW-PRINT (SLOT CUR-INPUT NAME-FIELD))
  (BREAK TERM-OUT)
  (SETF (SLOT CUR-INPUT STATE-FIELD) 33)
  (WHEN (= (SLOT CUR-INPUT NAME-FIELD) (- STR-PTR 1))
    (DECF STR-PTR 1)
    (SETF POOL-PTR (AREF STR-START STR-PTR))
    (SETF (SLOT CUR-INPUT NAME-FIELD) CUR-NAME))
  (SETF LINE 1)
  (WHEN (INPUT-LN (AREF INPUT-FILE (SLOT CUR-INPUT INDEX-FIELD)) FALSE))
  (FIRM-UP-THE-LINE)
  (COND ((OR (< (SLOT (AREF EQTB 9211) INT) 0) (> (SLOT (AREF EQTB 9211) INT) 255))
         (SETF (SLOT CUR-INPUT LIMIT-FIELD) (- (SLOT CUR-INPUT LIMIT-FIELD) 1)))
        (TRUE (SETF (AREF BUFFER (SLOT CUR-INPUT LIMIT-FIELD)) (SLOT (AREF EQTB 9211) INT))))
  (SETF FIRST (+ (SLOT CUR-INPUT LIMIT-FIELD) 1))
  (SETF (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT START-FIELD)))

(FUNCTION (READ-FONT-INFO INTERNAL-FONT-NUMBER) ((U HALFWORD) (NOM STR-NUMBER)
                                                 (AIRE STR-NUMBER) (S SCALED))
  (LABEL $L.30)
  (LABEL $L.11)
  (LABEL $L.45)
  (VAR K FONT-INDEX)
  (VAR FILE-OPENED BOOLEAN)
  (VAR LF HALFWORD)
  (VAR LH HALFWORD)
  (VAR BC HALFWORD)
  (VAR EC HALFWORD)
  (VAR NW HALFWORD)
  (VAR NH HALFWORD)
  (VAR ND HALFWORD)
  (VAR NI HALFWORD)
  (VAR NL HALFWORD)
  (VAR NK HALFWORD)
  (VAR NE HALFWORD)
  (VAR NP HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR G INTERNAL-FONT-NUMBER)
  (VAR A EIGHT-BITS)
  (VAR B EIGHT-BITS)
  (VAR C EIGHT-BITS)
  (VAR D EIGHT-BITS)
  (VAR QW FOUR-QUARTERS)
  (VAR SW SCALED)
  (VAR BCH-LABEL INTEGER)
  (VAR BCHAR (RANGE 0 256))
  (VAR Z SCALED)
  (VAR ALPHA INTEGER)
  (VAR BETA (RANGE 1 16))
  (SETF G 0)
  (SETF FILE-OPENED FALSE)
  (COND ((= AIRE 338) (PACK-FILE-NAME NOM 785 811)) (TRUE (PACK-FILE-NAME NOM AIRE 811)))
  (UNLESS (B-OPEN-IN TFM-FILE) (GOTO $L.11))
  (SETF FILE-OPENED TRUE)
  (SETF LF (AREF TFM-FILE))
  (WHEN (> LF 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF LF (+ (* LF 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF LH (AREF TFM-FILE))
  (WHEN (> LH 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF LH (+ (* LH 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF BC (AREF TFM-FILE))
  (WHEN (> BC 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF BC (+ (* BC 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF EC (AREF TFM-FILE))
  (WHEN (> EC 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF EC (+ (* EC 256) (AREF TFM-FILE)))
  (WHEN (OR (> BC (+ EC 1)) (> EC 255)) (GOTO $L.11))
  (WHEN (> BC 255) (SETF BC 1) (SETF EC 0))
  (GET TFM-FILE)
  (SETF NW (AREF TFM-FILE))
  (WHEN (> NW 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NW (+ (* NW 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF NH (AREF TFM-FILE))
  (WHEN (> NH 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NH (+ (* NH 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF ND (AREF TFM-FILE))
  (WHEN (> ND 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF ND (+ (* ND 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF NI (AREF TFM-FILE))
  (WHEN (> NI 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NI (+ (* NI 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF NL (AREF TFM-FILE))
  (WHEN (> NL 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NL (+ (* NL 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF NK (AREF TFM-FILE))
  (WHEN (> NK 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NK (+ (* NK 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF NE (AREF TFM-FILE))
  (WHEN (> NE 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NE (+ (* NE 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF NP (AREF TFM-FILE))
  (WHEN (> NP 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF NP (+ (* NP 256) (AREF TFM-FILE)))
  (WHEN (/= LF
            (+ (+ (+ (+ (+ (+ (+ (+ (+ (+ 6 LH) (+ (- EC BC) 1)) NW) NH) ND) NI) NL) NK) NE)
               NP))
    (GOTO $L.11))
  (WHEN (OR (OR (OR (= NW 0) (= NH 0)) (= ND 0)) (= NI 0)) (GOTO $L.11))
  (SETF LF (- (- LF 6) LH))
  (WHEN (< NP 7) (SETF LF (- (+ LF 7) NP)))
  (WHEN (OR (= FONT-PTR FONT-MAX) (> (+ FMEM-PTR LF) FONT-MEM-SIZE))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 802)
    (SPRINT-CS U)
    (PRINT-CHAR 61)
    (PRINT-FILE-NAME NOM AIRE 338)
    (COND ((>= S 0) (PRINT 741) (PRINT-SCALED S) (PRINT 397))
          ((/= S (- 1000)) (PRINT 803) (PRINT-INT (- S))))
    (PRINT 812)
    (SETF HELP-PTR 4)
    (SETF (AREF HELP-LINE 3) 813)
    (SETF (AREF HELP-LINE 2) 814)
    (SETF (AREF HELP-LINE 1) 815)
    (SETF (AREF HELP-LINE 0) 816)
    (ERROR)
    (GOTO $L.30))
  (SETF F (+ FONT-PTR 1))
  (SETF (AREF CHAR-BASE F) (- FMEM-PTR BC))
  (SETF (AREF WIDTH-BASE F) (+ (+ (AREF CHAR-BASE F) EC) 1))
  (SETF (AREF HEIGHT-BASE F) (+ (AREF WIDTH-BASE F) NW))
  (SETF (AREF DEPTH-BASE F) (+ (AREF HEIGHT-BASE F) NH))
  (SETF (AREF ITALIC-BASE F) (+ (AREF DEPTH-BASE F) ND))
  (SETF (AREF LIG-KERN-BASE F) (+ (AREF ITALIC-BASE F) NI))
  (SETF (AREF KERN-BASE F) (- (+ (AREF LIG-KERN-BASE F) NL) (* 256 128)))
  (SETF (AREF EXTEN-BASE F) (+ (+ (AREF KERN-BASE F) (* 256 128)) NK))
  (SETF (AREF PARAM-BASE F) (+ (AREF EXTEN-BASE F) NE))
  (WHEN (< LH 2) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF A (AREF TFM-FILE))
  (SETF (SLOT QW B0) (+ A 0))
  (GET TFM-FILE)
  (SETF B (AREF TFM-FILE))
  (SETF (SLOT QW B1) (+ B 0))
  (GET TFM-FILE)
  (SETF C (AREF TFM-FILE))
  (SETF (SLOT QW B2) (+ C 0))
  (GET TFM-FILE)
  (SETF D (AREF TFM-FILE))
  (SETF (SLOT QW B3) (+ D 0))
  (SETF (AREF FONT-CHECK F) QW)
  (GET TFM-FILE)
  (SETF Z (AREF TFM-FILE))
  (WHEN (> Z 127) (GOTO $L.11))
  (GET TFM-FILE)
  (SETF Z (+ (* Z 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF Z (+ (* Z 256) (AREF TFM-FILE)))
  (GET TFM-FILE)
  (SETF Z (+ (* Z 16) (DIV (AREF TFM-FILE) 16)))
  (WHEN (< Z 65536) (GOTO $L.11))
  (WHILE (> LH 2) (GET TFM-FILE) (GET TFM-FILE) (GET TFM-FILE) (GET TFM-FILE) (DECF LH 1))
  (SETF (AREF FONT-DSIZE F) Z)
  (WHEN (/= S (- 1000)) (COND ((>= S 0) (SETF Z S)) (TRUE (SETF Z (XN-OVER-D Z (- S) 1000)))))
  (SETF (AREF FONT-SIZE F) Z)
  (FOR (K FMEM-PTR TO (- (AREF WIDTH-BASE F) 1))
    (GET TFM-FILE)
    (SETF A (AREF TFM-FILE))
    (SETF (SLOT QW B0) (+ A 0))
    (GET TFM-FILE)
    (SETF B (AREF TFM-FILE))
    (SETF (SLOT QW B1) (+ B 0))
    (GET TFM-FILE)
    (SETF C (AREF TFM-FILE))
    (SETF (SLOT QW B2) (+ C 0))
    (GET TFM-FILE)
    (SETF D (AREF TFM-FILE))
    (SETF (SLOT QW B3) (+ D 0))
    (SETF (SLOT (AREF FONT-INFO K) QQQQ) QW)
    (WHEN (OR (OR (OR (>= A NW) (>= (DIV B 16) NH)) (>= (MOD B 16) ND)) (>= (DIV C 4) NI))
      (GOTO $L.11))
    (CASE (MOD C 4)
      ((1) (WHEN (>= D NL) (GOTO $L.11)))
      ((3) (WHEN (>= D NE) (GOTO $L.11)))
      ((2) (WHEN (OR (< D BC) (> D EC)) (GOTO $L.11))
       (WHILE (< D (- (+ K BC) FMEM-PTR))
         (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) D)) QQQQ))
         (WHEN (/= (MOD (- (SLOT QW B2) 0) 4) 2) (GOTO $L.45))
         (SETF D (- (SLOT QW B3) 0)))
       (WHEN (= D (- (+ K BC) FMEM-PTR)) (GOTO $L.11)) $L.45)
      (ELSE)))
  (SETF ALPHA 16)
  (WHILE (>= Z 8388608) (SETF Z (DIV Z 2)) (INCF ALPHA ALPHA))
  (SETF BETA (DIV 256 ALPHA))
  (SETF ALPHA (* ALPHA Z))
  (FOR (K (AREF WIDTH-BASE F) TO (- (AREF LIG-KERN-BASE F) 1))
    (GET TFM-FILE)
    (SETF A (AREF TFM-FILE))
    (GET TFM-FILE)
    (SETF B (AREF TFM-FILE))
    (GET TFM-FILE)
    (SETF C (AREF TFM-FILE))
    (GET TFM-FILE)
    (SETF D (AREF TFM-FILE))
    (SETF SW (DIV (+ (DIV (+ (DIV (* D Z) 256) (* C Z)) 256) (* B Z)) BETA))
    (COND ((= A 0) (SETF (SLOT (AREF FONT-INFO K) INT) SW))
          ((= A 255) (SETF (SLOT (AREF FONT-INFO K) INT) (- SW ALPHA)))
          (TRUE (GOTO $L.11))))
  (WHEN (/= (SLOT (AREF FONT-INFO (AREF WIDTH-BASE F)) INT) 0) (GOTO $L.11))
  (WHEN (/= (SLOT (AREF FONT-INFO (AREF HEIGHT-BASE F)) INT) 0) (GOTO $L.11))
  (WHEN (/= (SLOT (AREF FONT-INFO (AREF DEPTH-BASE F)) INT) 0) (GOTO $L.11))
  (WHEN (/= (SLOT (AREF FONT-INFO (AREF ITALIC-BASE F)) INT) 0) (GOTO $L.11))
  (SETF BCH-LABEL 32767)
  (SETF BCHAR 256)
  (WHEN (> NL 0)
    (FOR (K (AREF LIG-KERN-BASE F) TO (- (+ (AREF KERN-BASE F) (* 256 128)) 1))
      (GET TFM-FILE)
      (SETF A (AREF TFM-FILE))
      (SETF (SLOT QW B0) (+ A 0))
      (GET TFM-FILE)
      (SETF B (AREF TFM-FILE))
      (SETF (SLOT QW B1) (+ B 0))
      (GET TFM-FILE)
      (SETF C (AREF TFM-FILE))
      (SETF (SLOT QW B2) (+ C 0))
      (GET TFM-FILE)
      (SETF D (AREF TFM-FILE))
      (SETF (SLOT QW B3) (+ D 0))
      (SETF (SLOT (AREF FONT-INFO K) QQQQ) QW)
      (COND ((> A 128)
             (WHEN (>= (+ (* 256 C) D) NL) (GOTO $L.11))
             (WHEN (= A 255) (WHEN (= K (AREF LIG-KERN-BASE F)) (SETF BCHAR B))))
            (TRUE
             (WHEN (/= B BCHAR)
               (WHEN (OR (< B BC) (> B EC)) (GOTO $L.11))
               (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) B)) QQQQ))
               (UNLESS (> (SLOT QW B0) 0) (GOTO $L.11)))
             (COND ((< C 128)
                    (WHEN (OR (< D BC) (> D EC)) (GOTO $L.11))
                    (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) D)) QQQQ))
                    (UNLESS (> (SLOT QW B0) 0) (GOTO $L.11)))
                   ((>= (+ (* 256 (- C 128)) D) NK) (GOTO $L.11)))
             (WHEN (< A 128)
               (WHEN (>= (+ (+ (- K (AREF LIG-KERN-BASE F)) A) 1) NL) (GOTO $L.11))))))
    (WHEN (= A 255) (SETF BCH-LABEL (+ (* 256 C) D))))
  (FOR (K (+ (AREF KERN-BASE F) (* 256 128)) TO (- (AREF EXTEN-BASE F) 1))
    (GET TFM-FILE)
    (SETF A (AREF TFM-FILE))
    (GET TFM-FILE)
    (SETF B (AREF TFM-FILE))
    (GET TFM-FILE)
    (SETF C (AREF TFM-FILE))
    (GET TFM-FILE)
    (SETF D (AREF TFM-FILE))
    (SETF SW (DIV (+ (DIV (+ (DIV (* D Z) 256) (* C Z)) 256) (* B Z)) BETA))
    (COND ((= A 0) (SETF (SLOT (AREF FONT-INFO K) INT) SW))
          ((= A 255) (SETF (SLOT (AREF FONT-INFO K) INT) (- SW ALPHA)))
          (TRUE (GOTO $L.11))))
  (FOR (K (AREF EXTEN-BASE F) TO (- (AREF PARAM-BASE F) 1))
    (GET TFM-FILE)
    (SETF A (AREF TFM-FILE))
    (SETF (SLOT QW B0) (+ A 0))
    (GET TFM-FILE)
    (SETF B (AREF TFM-FILE))
    (SETF (SLOT QW B1) (+ B 0))
    (GET TFM-FILE)
    (SETF C (AREF TFM-FILE))
    (SETF (SLOT QW B2) (+ C 0))
    (GET TFM-FILE)
    (SETF D (AREF TFM-FILE))
    (SETF (SLOT QW B3) (+ D 0))
    (SETF (SLOT (AREF FONT-INFO K) QQQQ) QW)
    (WHEN (/= A 0)
      (WHEN (OR (< A BC) (> A EC)) (GOTO $L.11))
      (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) A)) QQQQ))
      (UNLESS (> (SLOT QW B0) 0) (GOTO $L.11)))
    (WHEN (/= B 0)
      (WHEN (OR (< B BC) (> B EC)) (GOTO $L.11))
      (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) B)) QQQQ))
      (UNLESS (> (SLOT QW B0) 0) (GOTO $L.11)))
    (WHEN (/= C 0)
      (WHEN (OR (< C BC) (> C EC)) (GOTO $L.11))
      (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) C)) QQQQ))
      (UNLESS (> (SLOT QW B0) 0) (GOTO $L.11)))
    (WHEN (OR (< D BC) (> D EC)) (GOTO $L.11))
    (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) D)) QQQQ))
    (UNLESS (> (SLOT QW B0) 0) (GOTO $L.11)))
  (FOR (K 1 TO NP)
    (COND ((= K 1)
           (GET TFM-FILE)
           (SETF SW (AREF TFM-FILE))
           (WHEN (> SW 127) (DECF SW 256))
           (GET TFM-FILE)
           (SETF SW (+ (* SW 256) (AREF TFM-FILE)))
           (GET TFM-FILE)
           (SETF SW (+ (* SW 256) (AREF TFM-FILE)))
           (GET TFM-FILE)
           (SETF (SLOT (AREF FONT-INFO (AREF PARAM-BASE F)) INT)
                 (+ (* SW 16) (DIV (AREF TFM-FILE) 16))))
          (TRUE
           (GET TFM-FILE)
           (SETF A (AREF TFM-FILE))
           (GET TFM-FILE)
           (SETF B (AREF TFM-FILE))
           (GET TFM-FILE)
           (SETF C (AREF TFM-FILE))
           (GET TFM-FILE)
           (SETF D (AREF TFM-FILE))
           (SETF SW (DIV (+ (DIV (+ (DIV (* D Z) 256) (* C Z)) 256) (* B Z)) BETA))
           (COND ((= A 0)
                  (SETF (SLOT (AREF FONT-INFO (- (+ (AREF PARAM-BASE F) K) 1)) INT) SW))
                 ((= A 255)
                  (SETF (SLOT (AREF FONT-INFO (- (+ (AREF PARAM-BASE F) K) 1)) INT)
                        (- SW ALPHA)))
                 (TRUE (GOTO $L.11))))))
  (WHEN (EOF TFM-FILE) (GOTO $L.11))
  (FOR (K (+ NP 1) TO 7) (SETF (SLOT (AREF FONT-INFO (- (+ (AREF PARAM-BASE F) K) 1)) INT) 0))
  (COND ((>= NP 7) (SETF (AREF FONT-PARAMS F) NP)) (TRUE (SETF (AREF FONT-PARAMS F) 7)))
  (SETF (AREF HYPHEN-CHAR F) (SLOT (AREF EQTB 9209) INT))
  (SETF (AREF SKEW-CHAR F) (SLOT (AREF EQTB 9210) INT))
  (COND ((< BCH-LABEL NL) (SETF (AREF BCHAR-LABEL F) (+ BCH-LABEL (AREF LIG-KERN-BASE F))))
        (TRUE (SETF (AREF BCHAR-LABEL F) 0)))
  (SETF (AREF FONT-BCHAR F) (+ BCHAR 0))
  (SETF (AREF FONT-FALSE-BCHAR F) (+ BCHAR 0))
  (WHEN (<= BCHAR EC)
    (WHEN (>= BCHAR BC)
      (SETF QW (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) BCHAR)) QQQQ))
      (WHEN (> (SLOT QW B0) 0) (SETF (AREF FONT-FALSE-BCHAR F) 256))))
  (SETF (AREF FONT-NAME F) NOM)
  (SETF (AREF FONT-AREA F) AIRE)
  (SETF (AREF FONT-BC F) BC)
  (SETF (AREF FONT-EC F) EC)
  (SETF (AREF FONT-GLUE F) 0)
  (SETF (AREF CHAR-BASE F) (- (AREF CHAR-BASE F) 0))
  (SETF (AREF WIDTH-BASE F) (- (AREF WIDTH-BASE F) 0))
  (SETF (AREF LIG-KERN-BASE F) (- (AREF LIG-KERN-BASE F) 0))
  (SETF (AREF KERN-BASE F) (- (AREF KERN-BASE F) 0))
  (SETF (AREF EXTEN-BASE F) (- (AREF EXTEN-BASE F) 0))
  (SETF (AREF PARAM-BASE F) (- (AREF PARAM-BASE F) 1))
  (INCF FMEM-PTR LF)
  (SETF FONT-PTR F)
  (SETF G F)
  (GOTO $L.30)
  $L.11
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 802)
  (SPRINT-CS U)
  (PRINT-CHAR 61)
  (PRINT-FILE-NAME NOM AIRE 338)
  (COND ((>= S 0) (PRINT 741) (PRINT-SCALED S) (PRINT 397))
        ((/= S (- 1000)) (PRINT 803) (PRINT-INT (- S))))
  (COND (FILE-OPENED (PRINT 804)) (TRUE (PRINT 805)))
  (SETF HELP-PTR 5)
  (SETF (AREF HELP-LINE 4) 806)
  (SETF (AREF HELP-LINE 3) 807)
  (SETF (AREF HELP-LINE 2) 808)
  (SETF (AREF HELP-LINE 1) 809)
  (SETF (AREF HELP-LINE 0) 810)
  (ERROR)
  $L.30
  (WHEN FILE-OPENED (B-CLOSE TFM-FILE))
  (SETF READ-FONT-INFO G))

(PROCEDURE CHAR-WARNING ((F INTERNAL-FONT-NUMBER) (C EIGHT-BITS))
  (WHEN (> (SLOT (AREF EQTB 9198) INT) 0)
    (BEGIN-DIAGNOSTIC)
    (PRINT-NL 825)
    (PRINT C)
    (PRINT 826)
    (SLOW-PRINT (AREF FONT-NAME F))
    (PRINT-CHAR 33)
    (END-DIAGNOSTIC FALSE)))

(FUNCTION (NEW-CHARACTER HALFWORD) ((F INTERNAL-FONT-NUMBER) (C EIGHT-BITS))
  (LABEL $L.10)
  (VAR P HALFWORD)
  (WHEN (<= (AREF FONT-BC F) C)
    (WHEN (>= (AREF FONT-EC F) C)
      (WHEN (> (SLOT (SLOT (AREF FONT-INFO (+ (+ (AREF CHAR-BASE F) C) 0)) QQQQ) B0) 0)
        (SETF P GET-AVAIL)
        (SETF (SLOT (SLOT (AREF MEM P) HH) B0) F)
        (SETF (SLOT (SLOT (AREF MEM P) HH) B1) (+ C 0))
        (SETF NEW-CHARACTER P)
        (GOTO $L.10))))
  (CHAR-WARNING F C)
  (SETF NEW-CHARACTER 0)
  $L.10)

(PROCEDURE WRITE-DVI ((A DVI-INDEX) (B DVI-INDEX))
  (VAR K DVI-INDEX)
  (FOR (K A TO B) (WRITE DVI-FILE (AREF DVI-BUF K))))

(PROCEDURE DVI-SWAP ()
  (COND ((= DVI-LIMIT DVI-BUF-SIZE)
         (WRITE-DVI 0 (- HALF-BUF 1))
         (SETF DVI-LIMIT HALF-BUF)
         (INCF DVI-OFFSET DVI-BUF-SIZE)
         (SETF DVI-PTR 0))
        (TRUE (WRITE-DVI HALF-BUF (- DVI-BUF-SIZE 1)) (SETF DVI-LIMIT DVI-BUF-SIZE)))
  (INCF DVI-GONE HALF-BUF))

(PROCEDURE DVI-FOUR ((X INTEGER))
  (COND ((>= X 0)
         (SETF (AREF DVI-BUF DVI-PTR) (DIV X 16777216))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
        (TRUE
         (INCF X 1073741824)
         (INCF X 1073741824)
         (SETF (AREF DVI-BUF DVI-PTR) (+ (DIV X 16777216) 128))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))))
  (SETF X (MOD X 16777216))
  (SETF (AREF DVI-BUF DVI-PTR) (DIV X 65536))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF X (MOD X 65536))
  (SETF (AREF DVI-BUF DVI-PTR) (DIV X 256))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR) (MOD X 256))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))

(PROCEDURE DVI-POP ((L INTEGER))
  (COND ((AND (= L (+ DVI-OFFSET DVI-PTR)) (> DVI-PTR 0)) (DECF DVI-PTR 1))
        (TRUE
         (SETF (AREF DVI-BUF DVI-PTR) 142)
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))))

(PROCEDURE DVI-FONT-DEF ((F INTERNAL-FONT-NUMBER))
  (VAR K POOL-POINTER)
  (SETF (AREF DVI-BUF DVI-PTR) 243)
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR) (- F 1))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR) (- (SLOT (AREF FONT-CHECK F) B0) 0))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR) (- (SLOT (AREF FONT-CHECK F) B1) 0))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR) (- (SLOT (AREF FONT-CHECK F) B2) 0))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR) (- (SLOT (AREF FONT-CHECK F) B3) 0))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (DVI-FOUR (AREF FONT-SIZE F))
  (DVI-FOUR (AREF FONT-DSIZE F))
  (SETF (AREF DVI-BUF DVI-PTR)
        (- (AREF STR-START (+ (AREF FONT-AREA F) 1)) (AREF STR-START (AREF FONT-AREA F))))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (SETF (AREF DVI-BUF DVI-PTR)
        (- (AREF STR-START (+ (AREF FONT-NAME F) 1)) (AREF STR-START (AREF FONT-NAME F))))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (FOR (K (AREF STR-START (AREF FONT-AREA F)) TO
        (- (AREF STR-START (+ (AREF FONT-AREA F) 1)) 1))
    (SETF (AREF DVI-BUF DVI-PTR) (AREF STR-POOL K))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
  (FOR (K (AREF STR-START (AREF FONT-NAME F)) TO
        (- (AREF STR-START (+ (AREF FONT-NAME F) 1)) 1))
    (SETF (AREF DVI-BUF DVI-PTR) (AREF STR-POOL K))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))))

(PROCEDURE MOVEMENT ((W SCALED) (O EIGHT-BITS))
  (LABEL $L.10)
  (LABEL $L.40)
  (LABEL $L.45)
  (LABEL $L.2)
  (LABEL $L.1)
  (VAR MSTATE SMALL-NUMBER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR K INTEGER)
  (SETF Q (GET-NODE 3))
  (SETF (SLOT (AREF MEM (+ Q 1)) INT) W)
  (SETF (SLOT (AREF MEM (+ Q 2)) INT) (+ DVI-OFFSET DVI-PTR))
  (COND ((= O 157) (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) DOWN-PTR) (SETF DOWN-PTR Q))
        (TRUE (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) RIGHT-PTR) (SETF RIGHT-PTR Q)))
  (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
  (SETF MSTATE 0)
  (WHILE (/= P 0)
    (COND ((= (SLOT (AREF MEM (+ P 1)) INT) W)
           (CASE (+ MSTATE (SLOT (SLOT (AREF MEM P) HH) LH))
             ((3 4 15 16)
              (COND ((< (SLOT (AREF MEM (+ P 2)) INT) DVI-GONE) (GOTO $L.45))
                    (TRUE
                     (SETF K (- (SLOT (AREF MEM (+ P 2)) INT) DVI-OFFSET))
                     (WHEN (< K 0) (INCF K DVI-BUF-SIZE))
                     (SETF (AREF DVI-BUF K) (+ (AREF DVI-BUF K) 5))
                     (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 1)
                     (GOTO $L.40))))
             ((5 9 11)
              (COND ((< (SLOT (AREF MEM (+ P 2)) INT) DVI-GONE) (GOTO $L.45))
                    (TRUE
                     (SETF K (- (SLOT (AREF MEM (+ P 2)) INT) DVI-OFFSET))
                     (WHEN (< K 0) (INCF K DVI-BUF-SIZE))
                     (SETF (AREF DVI-BUF K) (+ (AREF DVI-BUF K) 10))
                     (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 2)
                     (GOTO $L.40))))
             ((1 2 8 13) (GOTO $L.40))
             (ELSE)))
          (TRUE
           (CASE (+ MSTATE (SLOT (SLOT (AREF MEM P) HH) LH))
             ((1) (SETF MSTATE 6))
             ((2) (SETF MSTATE 12))
             ((8 13) (GOTO $L.45))
             (ELSE))))
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  $L.45
  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 3)
  (WHEN (>= (ABS W) 8388608)
    (SETF (AREF DVI-BUF DVI-PTR) (+ O 3))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (DVI-FOUR W)
    (GOTO $L.10))
  (WHEN (>= (ABS W) 32768)
    (SETF (AREF DVI-BUF DVI-PTR) (+ O 2))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (WHEN (< W 0) (INCF W 16777216))
    (SETF (AREF DVI-BUF DVI-PTR) (DIV W 65536))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (SETF W (MOD W 65536))
    (GOTO $L.2))
  (WHEN (>= (ABS W) 128)
    (SETF (AREF DVI-BUF DVI-PTR) (+ O 1))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (WHEN (< W 0) (INCF W 65536))
    (GOTO $L.2))
  (SETF (AREF DVI-BUF DVI-PTR) O)
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (WHEN (< W 0) (INCF W 256))
  (GOTO $L.1)
  $L.2
  (SETF (AREF DVI-BUF DVI-PTR) (DIV W 256))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  $L.1
  (SETF (AREF DVI-BUF DVI-PTR) (MOD W 256))
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (GOTO $L.10)
  $L.40
  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (SLOT (SLOT (AREF MEM P) HH) LH))
  (COND ((= (SLOT (SLOT (AREF MEM Q) HH) LH) 1)
         (SETF (AREF DVI-BUF DVI-PTR) (+ O 4))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (WHILE (/= (SLOT (SLOT (AREF MEM Q) HH) RH) P)
           (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
           (CASE (SLOT (SLOT (AREF MEM Q) HH) LH)
             ((3) (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 5))
             ((4) (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 6))
             (ELSE))))
        (TRUE
         (SETF (AREF DVI-BUF DVI-PTR) (+ O 9))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (WHILE (/= (SLOT (SLOT (AREF MEM Q) HH) RH) P)
           (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
           (CASE (SLOT (SLOT (AREF MEM Q) HH) LH)
             ((3) (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 4))
             ((5) (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 6))
             (ELSE)))))
  $L.10)

(PROCEDURE PRUNE-MOVEMENTS ((L INTEGER))
  (LABEL $L.30)
  (LABEL $L.10)
  (VAR P HALFWORD)
  (WHILE (/= DOWN-PTR 0)
    (WHEN (< (SLOT (AREF MEM (+ DOWN-PTR 2)) INT) L) (GOTO $L.30))
    (SETF P DOWN-PTR)
    (SETF DOWN-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
    (FREE-NODE P 3))
  $L.30
  (WHILE (/= RIGHT-PTR 0)
    (WHEN (< (SLOT (AREF MEM (+ RIGHT-PTR 2)) INT) L) (GOTO $L.10))
    (SETF P RIGHT-PTR)
    (SETF RIGHT-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
    (FREE-NODE P 3))
  $L.10)

(PROCEDURE VLIST-OUT () :FORWARD)

(PROCEDURE SPECIAL-OUT ((P HALFWORD))
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR K POOL-POINTER)
  (WHEN (/= CUR-H DVI-H) (MOVEMENT (- CUR-H DVI-H) 143) (SETF DVI-H CUR-H))
  (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
  (SETF OLD-SETTING SELECTOR)
  (SETF SELECTOR 21)
  (SHOW-TOKEN-LIST
    (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH)) HH) RH)
    0
    (- POOL-SIZE POOL-PTR))
  (SETF SELECTOR OLD-SETTING)
  (WHEN (> (+ POOL-PTR 1) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
  (COND ((< (- POOL-PTR (AREF STR-START STR-PTR)) 256)
         (SETF (AREF DVI-BUF DVI-PTR) 239)
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (SETF (AREF DVI-BUF DVI-PTR) (- POOL-PTR (AREF STR-START STR-PTR)))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
        (TRUE
         (SETF (AREF DVI-BUF DVI-PTR) 242)
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (DVI-FOUR (- POOL-PTR (AREF STR-START STR-PTR)))))
  (FOR (K (AREF STR-START STR-PTR) TO (- POOL-PTR 1))
    (SETF (AREF DVI-BUF DVI-PTR) (AREF STR-POOL K))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
  (SETF POOL-PTR (AREF STR-START STR-PTR)))

(PROCEDURE WRITE-OUT ((P HALFWORD))
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR OLD-MODE INTEGER)
  (VAR J SMALL-NUMBER)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (SETF Q GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 637)
  (SETF R GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
  (SETF (SLOT (SLOT (AREF MEM R) HH) LH) 10617)
  (BEGIN-TOKEN-LIST Q 4)
  (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 15)
  (SETF Q GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 379)
  (BEGIN-TOKEN-LIST Q 4)
  (SETF OLD-MODE (SLOT CUR-LIST MODE-FIELD))
  (SETF (SLOT CUR-LIST MODE-FIELD) 0)
  (SETF CUR-CS WRITE-LOC)
  (SETF Q (SCAN-TOKS FALSE TRUE))
  (GET-TOKEN)
  (WHEN (/= CUR-TOK 10617)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1297)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 1298)
    (SETF (AREF HELP-LINE 0) 1012)
    (ERROR)
    (REPEAT (GET-TOKEN) (UNTIL (= CUR-TOK 10617))))
  (SETF (SLOT CUR-LIST MODE-FIELD) OLD-MODE)
  (END-TOKEN-LIST)
  (SETF OLD-SETTING SELECTOR)
  (SETF J (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
  (COND ((AREF WRITE-OPEN J) (SETF SELECTOR J))
        (TRUE (WHEN (AND (= J 17) (= SELECTOR 19)) (SETF SELECTOR 18)) (PRINT-NL 338)))
  (TOKEN-SHOW DEF-REF)
  (PRINT-LN)
  (FLUSH-LIST DEF-REF)
  (SETF SELECTOR OLD-SETTING))

(PROCEDURE OUT-WHAT ((P HALFWORD))
  (VAR J SMALL-NUMBER)
  (CASE (SLOT (SLOT (AREF MEM P) HH) B1)
    ((0 1 2)
     (UNLESS DOING-LEADERS
       (SETF J (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
       (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 1) (WRITE-OUT P))
             (TRUE
              (WHEN (AREF WRITE-OPEN J) (A-CLOSE (AREF WRITE-FILE J)))
              (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 2) (SETF (AREF WRITE-OPEN J) FALSE))
                    ((< J 16)
                     (SETF CUR-NAME (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                     (SETF CUR-AREA (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH))
                     (SETF CUR-EXT (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH))
                     (WHEN (= CUR-EXT 338) (SETF CUR-EXT 791))
                     (PACK-FILE-NAME CUR-NAME CUR-AREA CUR-EXT)
                     (WHILE (NOT (A-OPEN-OUT (AREF WRITE-FILE J))) (PROMPT-FILE-NAME 1300 791))
                     (SETF (AREF WRITE-OPEN J) TRUE)))))))
    ((3) (SPECIAL-OUT P))
    ((4))
    (ELSE (CONFUSION 1299))))

(PROCEDURE HLIST-OUT ()
  (LABEL $L.21)
  (LABEL $L.13)
  (LABEL $L.14)
  (LABEL $L.15)
  (VAR BASE-LINE SCALED)
  (VAR LEFT-EDGE SCALED)
  (VAR SAVE-H SCALED)
  (VAR SAVE-V SCALED)
  (VAR THIS-BOX HALFWORD)
  (VAR G-ORDER GLUE-ORD)
  (VAR G-SIGN (RANGE 0 2))
  (VAR P HALFWORD)
  (VAR SAVE-LOC INTEGER)
  (VAR LEADER-BOX HALFWORD)
  (VAR LEADER-WD SCALED)
  (VAR LX SCALED)
  (VAR OUTER-DOING-LEADERS BOOLEAN)
  (VAR EDGE SCALED)
  (VAR GLUE-TEMP REAL)
  (VAR CUR-GLUE REAL)
  (VAR CUR-G SCALED)
  (SETF CUR-G 0)
  (SETF CUR-GLUE 0.0)
  (SETF THIS-BOX TEMP-PTR)
  (SETF G-ORDER (SLOT (SLOT (AREF MEM (+ THIS-BOX 5)) HH) B1))
  (SETF G-SIGN (SLOT (SLOT (AREF MEM (+ THIS-BOX 5)) HH) B0))
  (SETF P (SLOT (SLOT (AREF MEM (+ THIS-BOX 5)) HH) RH))
  (INCF CUR-S 1)
  (WHEN (> CUR-S 0)
    (SETF (AREF DVI-BUF DVI-PTR) 141)
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
  (WHEN (> CUR-S MAX-PUSH) (SETF MAX-PUSH CUR-S))
  (SETF SAVE-LOC (+ DVI-OFFSET DVI-PTR))
  (SETF BASE-LINE CUR-V)
  (SETF LEFT-EDGE CUR-H)
  (WHILE (/= P 0)
    $L.21
    (COND ((>= P HI-MEM-MIN)
           (WHEN (/= CUR-H DVI-H) (MOVEMENT (- CUR-H DVI-H) 143) (SETF DVI-H CUR-H))
           (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
           (REPEAT (SETF F (SLOT (SLOT (AREF MEM P) HH) B0))
                   (SETF C (SLOT (SLOT (AREF MEM P) HH) B1))
                   (WHEN (/= F DVI-F)
                     (UNLESS (AREF FONT-USED F)
                       (DVI-FONT-DEF F)
                       (SETF (AREF FONT-USED F) TRUE))
                     (COND ((<= F 64)
                            (SETF (AREF DVI-BUF DVI-PTR) (+ F 170))
                            (INCF DVI-PTR 1)
                            (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
                           (TRUE
                            (SETF (AREF DVI-BUF DVI-PTR) 235)
                            (INCF DVI-PTR 1)
                            (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
                            (SETF (AREF DVI-BUF DVI-PTR) (- F 1))
                            (INCF DVI-PTR 1)
                            (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))))
                     (SETF DVI-F F))
                   (WHEN (>= C 128)
                     (SETF (AREF DVI-BUF DVI-PTR) 128)
                     (INCF DVI-PTR 1)
                     (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
                   (SETF (AREF DVI-BUF DVI-PTR) (- C 0))
                   (INCF DVI-PTR 1)
                   (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
                   (INCF CUR-H
                    (SLOT (AREF FONT-INFO
                                (+ (AREF WIDTH-BASE F)
                                   (SLOT (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) C)) QQQQ)
                                         B0)))
                          INT))
                   (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
                   (UNTIL (NOT (>= P HI-MEM-MIN))))
           (SETF DVI-H CUR-H))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1)
              (COND ((= (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH) 0)
                     (INCF CUR-H (SLOT (AREF MEM (+ P 1)) INT)))
                    (TRUE
                     (SETF SAVE-H DVI-H)
                     (SETF SAVE-V DVI-V)
                     (SETF CUR-V (+ BASE-LINE (SLOT (AREF MEM (+ P 4)) INT)))
                     (SETF TEMP-PTR P)
                     (SETF EDGE CUR-H)
                     (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 1) (VLIST-OUT))
                           (TRUE (HLIST-OUT)))
                     (SETF DVI-H SAVE-H)
                     (SETF DVI-V SAVE-V)
                     (SETF CUR-H (+ EDGE (SLOT (AREF MEM (+ P 1)) INT)))
                     (SETF CUR-V BASE-LINE))))
             ((2) (SETF RULE-HT (SLOT (AREF MEM (+ P 3)) INT))
              (SETF RULE-DP (SLOT (AREF MEM (+ P 2)) INT))
              (SETF RULE-WD (SLOT (AREF MEM (+ P 1)) INT)) (GOTO $L.14))
             ((8) (OUT-WHAT P))
             ((10) (SETF G (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (SETF RULE-WD (- (SLOT (AREF MEM (+ G 1)) INT) CUR-G))
              (WHEN (/= G-SIGN 0)
                (COND ((= G-SIGN 1)
                       (WHEN (= (SLOT (SLOT (AREF MEM G) HH) B0) G-ORDER)
                         (INCF CUR-GLUE (SLOT (AREF MEM (+ G 2)) INT))
                         (SETF GLUE-TEMP (* (SLOT (AREF MEM (+ THIS-BOX 6)) GR) CUR-GLUE))
                         (COND ((> GLUE-TEMP 1.0E+9) (SETF GLUE-TEMP 1.0E+9))
                               ((< GLUE-TEMP (- 1.0E+9)) (SETF GLUE-TEMP (- 1.0E+9))))
                         (SETF CUR-G (ROUND GLUE-TEMP))))
                      ((= (SLOT (SLOT (AREF MEM G) HH) B1) G-ORDER)
                       (DECF CUR-GLUE (SLOT (AREF MEM (+ G 3)) INT))
                       (SETF GLUE-TEMP (* (SLOT (AREF MEM (+ THIS-BOX 6)) GR) CUR-GLUE))
                       (COND ((> GLUE-TEMP 1.0E+9) (SETF GLUE-TEMP 1.0E+9))
                             ((< GLUE-TEMP (- 1.0E+9)) (SETF GLUE-TEMP (- 1.0E+9))))
                       (SETF CUR-G (ROUND GLUE-TEMP)))))
              (INCF RULE-WD CUR-G)
              (WHEN (>= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
                (SETF LEADER-BOX (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                (WHEN (= (SLOT (SLOT (AREF MEM LEADER-BOX) HH) B0) 2)
                  (SETF RULE-HT (SLOT (AREF MEM (+ LEADER-BOX 3)) INT))
                  (SETF RULE-DP (SLOT (AREF MEM (+ LEADER-BOX 2)) INT))
                  (GOTO $L.14))
                (SETF LEADER-WD (SLOT (AREF MEM (+ LEADER-BOX 1)) INT))
                (WHEN (AND (> LEADER-WD 0) (> RULE-WD 0))
                  (INCF RULE-WD 10)
                  (SETF EDGE (+ CUR-H RULE-WD))
                  (SETF LX 0)
                  (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
                         (SETF SAVE-H CUR-H)
                         (SETF CUR-H
                               (+ LEFT-EDGE (* LEADER-WD (DIV (- CUR-H LEFT-EDGE) LEADER-WD))))
                         (WHEN (< CUR-H SAVE-H) (INCF CUR-H LEADER-WD)))
                        (TRUE
                         (SETF LQ (DIV RULE-WD LEADER-WD))
                         (SETF LR (MOD RULE-WD LEADER-WD))
                         (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 101)
                                (INCF CUR-H (DIV LR 2)))
                               (TRUE
                                (SETF LX (DIV LR (+ LQ 1)))
                                (INCF CUR-H (DIV (- LR (* (- LQ 1) LX)) 2))))))
                  (WHILE (<= (+ CUR-H LEADER-WD) EDGE)
                    (SETF CUR-V (+ BASE-LINE (SLOT (AREF MEM (+ LEADER-BOX 4)) INT)))
                    (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
                    (SETF SAVE-V DVI-V)
                    (WHEN (/= CUR-H DVI-H) (MOVEMENT (- CUR-H DVI-H) 143) (SETF DVI-H CUR-H))
                    (SETF SAVE-H DVI-H)
                    (SETF TEMP-PTR LEADER-BOX)
                    (SETF OUTER-DOING-LEADERS DOING-LEADERS)
                    (SETF DOING-LEADERS TRUE)
                    (COND ((= (SLOT (SLOT (AREF MEM LEADER-BOX) HH) B0) 1) (VLIST-OUT))
                          (TRUE (HLIST-OUT)))
                    (SETF DOING-LEADERS OUTER-DOING-LEADERS)
                    (SETF DVI-V SAVE-V)
                    (SETF DVI-H SAVE-H)
                    (SETF CUR-V BASE-LINE)
                    (SETF CUR-H (+ (+ SAVE-H LEADER-WD) LX)))
                  (SETF CUR-H (- EDGE 10))
                  (GOTO $L.15)))
              (GOTO $L.13))
             ((11 9) (INCF CUR-H (SLOT (AREF MEM (+ P 1)) INT)))
             ((6) (SETF (AREF MEM 59988) (AREF MEM (+ P 1)))
              (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH) (SLOT (SLOT (AREF MEM P) HH) RH))
              (SETF P 59988) (GOTO $L.21))
             (ELSE))
           (GOTO $L.15)
           $L.14
           (WHEN (= RULE-HT (- 1073741824))
             (SETF RULE-HT (SLOT (AREF MEM (+ THIS-BOX 3)) INT)))
           (WHEN (= RULE-DP (- 1073741824))
             (SETF RULE-DP (SLOT (AREF MEM (+ THIS-BOX 2)) INT)))
           (INCF RULE-HT RULE-DP)
           (WHEN (AND (> RULE-HT 0) (> RULE-WD 0))
             (WHEN (/= CUR-H DVI-H) (MOVEMENT (- CUR-H DVI-H) 143) (SETF DVI-H CUR-H))
             (SETF CUR-V (+ BASE-LINE RULE-DP))
             (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
             (SETF (AREF DVI-BUF DVI-PTR) 132)
             (INCF DVI-PTR 1)
             (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
             (DVI-FOUR RULE-HT)
             (DVI-FOUR RULE-WD)
             (SETF CUR-V BASE-LINE)
             (INCF DVI-H RULE-WD))
           $L.13
           (INCF CUR-H RULE-WD)
           $L.15
           (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))))
  (PRUNE-MOVEMENTS SAVE-LOC)
  (WHEN (> CUR-S 0) (DVI-POP SAVE-LOC))
  (DECF CUR-S 1))

(PROCEDURE VLIST-OUT ()
  (LABEL $L.13)
  (LABEL $L.14)
  (LABEL $L.15)
  (VAR LEFT-EDGE SCALED)
  (VAR TOP-EDGE SCALED)
  (VAR SAVE-H SCALED)
  (VAR SAVE-V SCALED)
  (VAR THIS-BOX HALFWORD)
  (VAR G-ORDER GLUE-ORD)
  (VAR G-SIGN (RANGE 0 2))
  (VAR P HALFWORD)
  (VAR SAVE-LOC INTEGER)
  (VAR LEADER-BOX HALFWORD)
  (VAR LEADER-HT SCALED)
  (VAR LX SCALED)
  (VAR OUTER-DOING-LEADERS BOOLEAN)
  (VAR EDGE SCALED)
  (VAR GLUE-TEMP REAL)
  (VAR CUR-GLUE REAL)
  (VAR CUR-G SCALED)
  (SETF CUR-G 0)
  (SETF CUR-GLUE 0.0)
  (SETF THIS-BOX TEMP-PTR)
  (SETF G-ORDER (SLOT (SLOT (AREF MEM (+ THIS-BOX 5)) HH) B1))
  (SETF G-SIGN (SLOT (SLOT (AREF MEM (+ THIS-BOX 5)) HH) B0))
  (SETF P (SLOT (SLOT (AREF MEM (+ THIS-BOX 5)) HH) RH))
  (INCF CUR-S 1)
  (WHEN (> CUR-S 0)
    (SETF (AREF DVI-BUF DVI-PTR) 141)
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
  (WHEN (> CUR-S MAX-PUSH) (SETF MAX-PUSH CUR-S))
  (SETF SAVE-LOC (+ DVI-OFFSET DVI-PTR))
  (SETF LEFT-EDGE CUR-H)
  (DECF CUR-V (SLOT (AREF MEM (+ THIS-BOX 3)) INT))
  (SETF TOP-EDGE CUR-V)
  (WHILE (/= P 0)
    (COND ((>= P HI-MEM-MIN) (CONFUSION 828))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1)
              (COND ((= (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH) 0)
                     (SETF CUR-V
                           (+ (+ CUR-V (SLOT (AREF MEM (+ P 3)) INT))
                              (SLOT (AREF MEM (+ P 2)) INT))))
                    (TRUE
                     (INCF CUR-V (SLOT (AREF MEM (+ P 3)) INT))
                     (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
                     (SETF SAVE-H DVI-H)
                     (SETF SAVE-V DVI-V)
                     (SETF CUR-H (+ LEFT-EDGE (SLOT (AREF MEM (+ P 4)) INT)))
                     (SETF TEMP-PTR P)
                     (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 1) (VLIST-OUT))
                           (TRUE (HLIST-OUT)))
                     (SETF DVI-H SAVE-H)
                     (SETF DVI-V SAVE-V)
                     (SETF CUR-V (+ SAVE-V (SLOT (AREF MEM (+ P 2)) INT)))
                     (SETF CUR-H LEFT-EDGE))))
             ((2) (SETF RULE-HT (SLOT (AREF MEM (+ P 3)) INT))
              (SETF RULE-DP (SLOT (AREF MEM (+ P 2)) INT))
              (SETF RULE-WD (SLOT (AREF MEM (+ P 1)) INT)) (GOTO $L.14))
             ((8) (OUT-WHAT P))
             ((10) (SETF G (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (SETF RULE-HT (- (SLOT (AREF MEM (+ G 1)) INT) CUR-G))
              (WHEN (/= G-SIGN 0)
                (COND ((= G-SIGN 1)
                       (WHEN (= (SLOT (SLOT (AREF MEM G) HH) B0) G-ORDER)
                         (INCF CUR-GLUE (SLOT (AREF MEM (+ G 2)) INT))
                         (SETF GLUE-TEMP (* (SLOT (AREF MEM (+ THIS-BOX 6)) GR) CUR-GLUE))
                         (COND ((> GLUE-TEMP 1.0E+9) (SETF GLUE-TEMP 1.0E+9))
                               ((< GLUE-TEMP (- 1.0E+9)) (SETF GLUE-TEMP (- 1.0E+9))))
                         (SETF CUR-G (ROUND GLUE-TEMP))))
                      ((= (SLOT (SLOT (AREF MEM G) HH) B1) G-ORDER)
                       (DECF CUR-GLUE (SLOT (AREF MEM (+ G 3)) INT))
                       (SETF GLUE-TEMP (* (SLOT (AREF MEM (+ THIS-BOX 6)) GR) CUR-GLUE))
                       (COND ((> GLUE-TEMP 1.0E+9) (SETF GLUE-TEMP 1.0E+9))
                             ((< GLUE-TEMP (- 1.0E+9)) (SETF GLUE-TEMP (- 1.0E+9))))
                       (SETF CUR-G (ROUND GLUE-TEMP)))))
              (INCF RULE-HT CUR-G)
              (WHEN (>= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
                (SETF LEADER-BOX (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                (WHEN (= (SLOT (SLOT (AREF MEM LEADER-BOX) HH) B0) 2)
                  (SETF RULE-WD (SLOT (AREF MEM (+ LEADER-BOX 1)) INT))
                  (SETF RULE-DP 0)
                  (GOTO $L.14))
                (SETF LEADER-HT
                      (+ (SLOT (AREF MEM (+ LEADER-BOX 3)) INT)
                         (SLOT (AREF MEM (+ LEADER-BOX 2)) INT)))
                (WHEN (AND (> LEADER-HT 0) (> RULE-HT 0))
                  (INCF RULE-HT 10)
                  (SETF EDGE (+ CUR-V RULE-HT))
                  (SETF LX 0)
                  (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
                         (SETF SAVE-V CUR-V)
                         (SETF CUR-V
                               (+ TOP-EDGE (* LEADER-HT (DIV (- CUR-V TOP-EDGE) LEADER-HT))))
                         (WHEN (< CUR-V SAVE-V) (INCF CUR-V LEADER-HT)))
                        (TRUE
                         (SETF LQ (DIV RULE-HT LEADER-HT))
                         (SETF LR (MOD RULE-HT LEADER-HT))
                         (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 101)
                                (INCF CUR-V (DIV LR 2)))
                               (TRUE
                                (SETF LX (DIV LR (+ LQ 1)))
                                (INCF CUR-V (DIV (- LR (* (- LQ 1) LX)) 2))))))
                  (WHILE (<= (+ CUR-V LEADER-HT) EDGE)
                    (SETF CUR-H (+ LEFT-EDGE (SLOT (AREF MEM (+ LEADER-BOX 4)) INT)))
                    (WHEN (/= CUR-H DVI-H) (MOVEMENT (- CUR-H DVI-H) 143) (SETF DVI-H CUR-H))
                    (SETF SAVE-H DVI-H)
                    (INCF CUR-V (SLOT (AREF MEM (+ LEADER-BOX 3)) INT))
                    (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
                    (SETF SAVE-V DVI-V)
                    (SETF TEMP-PTR LEADER-BOX)
                    (SETF OUTER-DOING-LEADERS DOING-LEADERS)
                    (SETF DOING-LEADERS TRUE)
                    (COND ((= (SLOT (SLOT (AREF MEM LEADER-BOX) HH) B0) 1) (VLIST-OUT))
                          (TRUE (HLIST-OUT)))
                    (SETF DOING-LEADERS OUTER-DOING-LEADERS)
                    (SETF DVI-V SAVE-V)
                    (SETF DVI-H SAVE-H)
                    (SETF CUR-H LEFT-EDGE)
                    (SETF CUR-V
                          (+ (+ (- SAVE-V (SLOT (AREF MEM (+ LEADER-BOX 3)) INT)) LEADER-HT)
                             LX)))
                  (SETF CUR-V (- EDGE 10))
                  (GOTO $L.15)))
              (GOTO $L.13))
             ((11) (INCF CUR-V (SLOT (AREF MEM (+ P 1)) INT)))
             (ELSE))
           (GOTO $L.15)
           $L.14
           (WHEN (= RULE-WD (- 1073741824))
             (SETF RULE-WD (SLOT (AREF MEM (+ THIS-BOX 1)) INT)))
           (INCF RULE-HT RULE-DP)
           (INCF CUR-V RULE-HT)
           (WHEN (AND (> RULE-HT 0) (> RULE-WD 0))
             (WHEN (/= CUR-H DVI-H) (MOVEMENT (- CUR-H DVI-H) 143) (SETF DVI-H CUR-H))
             (WHEN (/= CUR-V DVI-V) (MOVEMENT (- CUR-V DVI-V) 157) (SETF DVI-V CUR-V))
             (SETF (AREF DVI-BUF DVI-PTR) 137)
             (INCF DVI-PTR 1)
             (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
             (DVI-FOUR RULE-HT)
             (DVI-FOUR RULE-WD))
           (GOTO $L.15)
           $L.13
           (INCF CUR-V RULE-HT)))
    $L.15
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  (PRUNE-MOVEMENTS SAVE-LOC)
  (WHEN (> CUR-S 0) (DVI-POP SAVE-LOC))
  (DECF CUR-S 1))

(PROCEDURE SHIP-OUT ((P HALFWORD))
  (LABEL $L.30)
  (VAR PAGE-LOC INTEGER)
  (VAR J (RANGE 0 9))
  (VAR K (RANGE 0 9))
  (VAR S POOL-POINTER)
  (VAR OLD-SETTING (RANGE 0 21))
  (WHEN (> (SLOT (AREF EQTB 9197) INT) 0) (PRINT-NL 338) (PRINT-LN) (PRINT 829))
  (COND ((> TERM-OFFSET (- MAX-PRINT-LINE 9)) (PRINT-LN))
        ((OR (> TERM-OFFSET 0) (> FILE-OFFSET 0)) (PRINT-CHAR 32)))
  (PRINT-CHAR 91)
  (SETF J 9)
  (WHILE (AND (= (SLOT (AREF EQTB (+ 9218 J)) INT) 0) (> J 0)) (DECF J 1))
  (FOR (K 0 TO J) (PRINT-INT (SLOT (AREF EQTB (+ 9218 K)) INT)) (WHEN (< K J) (PRINT-CHAR 46)))
  (BREAK TERM-OUT)
  (WHEN (> (SLOT (AREF EQTB 9197) INT) 0)
    (PRINT-CHAR 93)
    (BEGIN-DIAGNOSTIC)
    (SHOW-BOX P)
    (END-DIAGNOSTIC TRUE))
  (WHEN (OR (OR (OR (> (SLOT (AREF MEM (+ P 3)) INT) 1073741823)
                    (> (SLOT (AREF MEM (+ P 2)) INT) 1073741823))
                (> (+ (+ (SLOT (AREF MEM (+ P 3)) INT) (SLOT (AREF MEM (+ P 2)) INT))
                      (SLOT (AREF EQTB 9749) INT))
                   1073741823))
            (> (+ (SLOT (AREF MEM (+ P 1)) INT) (SLOT (AREF EQTB 9748) INT)) 1073741823))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 833)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 834)
    (SETF (AREF HELP-LINE 0) 835)
    (ERROR)
    (WHEN (<= (SLOT (AREF EQTB 9197) INT) 0)
      (BEGIN-DIAGNOSTIC)
      (PRINT-NL 836)
      (SHOW-BOX P)
      (END-DIAGNOSTIC TRUE))
    (GOTO $L.30))
  (WHEN (> (+ (+ (SLOT (AREF MEM (+ P 3)) INT) (SLOT (AREF MEM (+ P 2)) INT))
              (SLOT (AREF EQTB 9749) INT))
           MAX-V)
    (SETF MAX-V
          (+ (+ (SLOT (AREF MEM (+ P 3)) INT) (SLOT (AREF MEM (+ P 2)) INT))
             (SLOT (AREF EQTB 9749) INT))))
  (WHEN (> (+ (SLOT (AREF MEM (+ P 1)) INT) (SLOT (AREF EQTB 9748) INT)) MAX-H)
    (SETF MAX-H (+ (SLOT (AREF MEM (+ P 1)) INT) (SLOT (AREF EQTB 9748) INT))))
  (SETF DVI-H 0)
  (SETF DVI-V 0)
  (SETF CUR-H (SLOT (AREF EQTB 9748) INT))
  (SETF DVI-F 0)
  (WHEN (= OUTPUT-FILE-NAME 0)
    (WHEN (= JOB-NAME 0) (OPEN-LOG-FILE))
    (PACK-JOB-NAME 794)
    (WHILE (NOT (B-OPEN-OUT DVI-FILE)) (PROMPT-FILE-NAME 795 794))
    (SETF OUTPUT-FILE-NAME (B-MAKE-NAME-STRING DVI-FILE)))
  (WHEN (= TOTAL-PAGES 0)
    (SETF (AREF DVI-BUF DVI-PTR) 247)
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (SETF (AREF DVI-BUF DVI-PTR) 2)
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (DVI-FOUR 25400000)
    (DVI-FOUR 473628672)
    (PREPARE-MAG)
    (DVI-FOUR (SLOT (AREF EQTB 9180) INT))
    (SETF OLD-SETTING SELECTOR)
    (SETF SELECTOR 21)
    (PRINT 827)
    (PRINT-INT (SLOT (AREF EQTB 9186) INT))
    (PRINT-CHAR 46)
    (PRINT-TWO (SLOT (AREF EQTB 9185) INT))
    (PRINT-CHAR 46)
    (PRINT-TWO (SLOT (AREF EQTB 9184) INT))
    (PRINT-CHAR 58)
    (PRINT-TWO (DIV (SLOT (AREF EQTB 9183) INT) 60))
    (PRINT-TWO (MOD (SLOT (AREF EQTB 9183) INT) 60))
    (SETF SELECTOR OLD-SETTING)
    (SETF (AREF DVI-BUF DVI-PTR) (- POOL-PTR (AREF STR-START STR-PTR)))
    (INCF DVI-PTR 1)
    (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
    (FOR (S (AREF STR-START STR-PTR) TO (- POOL-PTR 1))
      (SETF (AREF DVI-BUF DVI-PTR) (AREF STR-POOL S))
      (INCF DVI-PTR 1)
      (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
    (SETF POOL-PTR (AREF STR-START STR-PTR)))
  (SETF PAGE-LOC (+ DVI-OFFSET DVI-PTR))
  (SETF (AREF DVI-BUF DVI-PTR) 139)
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (FOR (K 0 TO 9) (DVI-FOUR (SLOT (AREF EQTB (+ 9218 K)) INT)))
  (DVI-FOUR LAST-BOP)
  (SETF LAST-BOP PAGE-LOC)
  (SETF CUR-V (+ (SLOT (AREF MEM (+ P 3)) INT) (SLOT (AREF EQTB 9749) INT)))
  (SETF TEMP-PTR P)
  (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 1) (VLIST-OUT)) (TRUE (HLIST-OUT)))
  (SETF (AREF DVI-BUF DVI-PTR) 140)
  (INCF DVI-PTR 1)
  (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
  (INCF TOTAL-PAGES 1)
  (SETF CUR-S (- 1))
  $L.30
  (WHEN (<= (SLOT (AREF EQTB 9197) INT) 0) (PRINT-CHAR 93))
  (SETF DEAD-CYCLES 0)
  (BREAK TERM-OUT)
  (FLUSH-NODE-LIST P))

(PROCEDURE SCAN-SPEC ((C GROUP-CODE) (THREE-CODES BOOLEAN))
  (LABEL $L.40)
  (VAR S INTEGER)
  (VAR SPEC-CODE (RANGE 0 1))
  (WHEN THREE-CODES (SETF S (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)))
  (COND ((SCAN-KEYWORD 842) (SETF SPEC-CODE 0))
        ((SCAN-KEYWORD 843) (SETF SPEC-CODE 1))
        (TRUE (SETF SPEC-CODE 1) (SETF CUR-VAL 0) (GOTO $L.40)))
  (SCAN-DIMEN FALSE FALSE FALSE)
  $L.40
  (WHEN THREE-CODES (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) S) (INCF SAVE-PTR 1))
  (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) SPEC-CODE)
  (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 1)) INT) CUR-VAL)
  (INCF SAVE-PTR 2)
  (NEW-SAVE-LEVEL C)
  (SCAN-LEFT-BRACE))

(FUNCTION (HPACK HALFWORD) ((P HALFWORD) (W SCALED) (M SMALL-NUMBER))
  (LABEL $L.21)
  (LABEL $L.50)
  (LABEL $L.10)
  (VAR R HALFWORD)
  (VAR Q HALFWORD)
  (VAR H SCALED)
  (VAR D SCALED)
  (VAR X SCALED)
  (VAR S SCALED)
  (VAR G HALFWORD)
  (VAR O GLUE-ORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR I FOUR-QUARTERS)
  (VAR HD EIGHT-BITS)
  (SETF LAST-BADNESS 0)
  (SETF R (GET-NODE 7))
  (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 0)
  (SETF (SLOT (SLOT (AREF MEM R) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ R 4)) INT) 0)
  (SETF Q (+ R 5))
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
  (SETF H 0)
  (SETF D 0)
  (SETF X 0)
  (SETF (AREF TOTAL-STRETCH 0) 0)
  (SETF (AREF TOTAL-SHRINK 0) 0)
  (SETF (AREF TOTAL-STRETCH 1) 0)
  (SETF (AREF TOTAL-SHRINK 1) 0)
  (SETF (AREF TOTAL-STRETCH 2) 0)
  (SETF (AREF TOTAL-SHRINK 2) 0)
  (SETF (AREF TOTAL-STRETCH 3) 0)
  (SETF (AREF TOTAL-SHRINK 3) 0)
  (WHILE (/= P 0)
    $L.21
    (WHILE (>= P HI-MEM-MIN)
      (SETF F (SLOT (SLOT (AREF MEM P) HH) B0))
      (SETF I
            (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) (SLOT (SLOT (AREF MEM P) HH) B1)))
                  QQQQ))
      (SETF HD (- (SLOT I B1) 0))
      (INCF X (SLOT (AREF FONT-INFO (+ (AREF WIDTH-BASE F) (SLOT I B0))) INT))
      (SETF S (SLOT (AREF FONT-INFO (+ (AREF HEIGHT-BASE F) (DIV HD 16))) INT))
      (WHEN (> S H) (SETF H S))
      (SETF S (SLOT (AREF FONT-INFO (+ (AREF DEPTH-BASE F) (MOD HD 16))) INT))
      (WHEN (> S D) (SETF D S))
      (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
    (WHEN (/= P 0)
      (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
        ((0 1 2 13) (INCF X (SLOT (AREF MEM (+ P 1)) INT))
         (COND ((>= (SLOT (SLOT (AREF MEM P) HH) B0) 2) (SETF S 0))
               (TRUE (SETF S (SLOT (AREF MEM (+ P 4)) INT))))
         (WHEN (> (- (SLOT (AREF MEM (+ P 3)) INT) S) H)
           (SETF H (- (SLOT (AREF MEM (+ P 3)) INT) S)))
         (WHEN (> (+ (SLOT (AREF MEM (+ P 2)) INT) S) D)
           (SETF D (+ (SLOT (AREF MEM (+ P 2)) INT) S))))
        ((3 4 5)
         (WHEN (/= ADJUST-TAIL 0)
           (WHILE (/= (SLOT (SLOT (AREF MEM Q) HH) RH) P)
             (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))
           (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 5)
                  (SETF (SLOT (SLOT (AREF MEM ADJUST-TAIL) HH) RH)
                        (SLOT (AREF MEM (+ P 1)) INT))
                  (WHILE (/= (SLOT (SLOT (AREF MEM ADJUST-TAIL) HH) RH) 0)
                    (SETF ADJUST-TAIL (SLOT (SLOT (AREF MEM ADJUST-TAIL) HH) RH)))
                  (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
                  (FREE-NODE (SLOT (SLOT (AREF MEM Q) HH) RH) 2))
                 (TRUE
                  (SETF (SLOT (SLOT (AREF MEM ADJUST-TAIL) HH) RH) P)
                  (SETF ADJUST-TAIL P)
                  (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))))
           (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
           (SETF P Q)))
        ((8))
        ((10) (SETF G (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
         (INCF X (SLOT (AREF MEM (+ G 1)) INT)) (SETF O (SLOT (SLOT (AREF MEM G) HH) B0))
         (SETF (AREF TOTAL-STRETCH O) (+ (AREF TOTAL-STRETCH O) (SLOT (AREF MEM (+ G 2)) INT)))
         (SETF O (SLOT (SLOT (AREF MEM G) HH) B1))
         (SETF (AREF TOTAL-SHRINK O) (+ (AREF TOTAL-SHRINK O) (SLOT (AREF MEM (+ G 3)) INT)))
         (WHEN (>= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
           (SETF G (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
           (WHEN (> (SLOT (AREF MEM (+ G 3)) INT) H) (SETF H (SLOT (AREF MEM (+ G 3)) INT)))
           (WHEN (> (SLOT (AREF MEM (+ G 2)) INT) D) (SETF D (SLOT (AREF MEM (+ G 2)) INT)))))
        ((11 9) (INCF X (SLOT (AREF MEM (+ P 1)) INT)))
        ((6) (SETF (AREF MEM 59988) (AREF MEM (+ P 1)))
         (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH) (SLOT (SLOT (AREF MEM P) HH) RH))
         (SETF P 59988) (GOTO $L.21))
        (ELSE))
      (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))))
  (WHEN (/= ADJUST-TAIL 0) (SETF (SLOT (SLOT (AREF MEM ADJUST-TAIL) HH) RH) 0))
  (SETF (SLOT (AREF MEM (+ R 3)) INT) H)
  (SETF (SLOT (AREF MEM (+ R 2)) INT) D)
  (WHEN (= M 1) (SETF W (+ X W)))
  (SETF (SLOT (AREF MEM (+ R 1)) INT) W)
  (SETF X (- W X))
  (COND ((= X 0)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) 0)
         (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0)
         (GOTO $L.10))
        ((> X 0)
         (COND ((/= (AREF TOTAL-STRETCH 3) 0) (SETF O 3))
               ((/= (AREF TOTAL-STRETCH 2) 0) (SETF O 2))
               ((/= (AREF TOTAL-STRETCH 1) 0) (SETF O 1))
               (TRUE (SETF O 0)))
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) O)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 1)
         (COND ((/= (AREF TOTAL-STRETCH O) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) (/ X (AREF TOTAL-STRETCH O))))
               (TRUE
                (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0)))
         (WHEN (= O 0)
           (WHEN (/= (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) 0)
             (SETF LAST-BADNESS (BADNESS X (AREF TOTAL-STRETCH 0)))
             (WHEN (> LAST-BADNESS (SLOT (AREF EQTB 9189) INT))
               (PRINT-LN)
               (COND ((> LAST-BADNESS 100) (PRINT-NL 844)) (TRUE (PRINT-NL 845)))
               (PRINT 846)
               (PRINT-INT LAST-BADNESS)
               (GOTO $L.50))))
         (GOTO $L.10))
        (TRUE
         (COND ((/= (AREF TOTAL-SHRINK 3) 0) (SETF O 3))
               ((/= (AREF TOTAL-SHRINK 2) 0) (SETF O 2))
               ((/= (AREF TOTAL-SHRINK 1) 0) (SETF O 1))
               (TRUE (SETF O 0)))
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) O)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 2)
         (COND ((/= (AREF TOTAL-SHRINK O) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) (/ (- X) (AREF TOTAL-SHRINK O))))
               (TRUE
                (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0)))
         (COND ((AND (AND (< (AREF TOTAL-SHRINK O) (- X)) (= O 0))
                     (/= (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) 0))
                (SETF LAST-BADNESS 1000000)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) 1.0)
                (WHEN (OR (> (- (- X) (AREF TOTAL-SHRINK 0)) (SLOT (AREF EQTB 9738) INT))
                          (< (SLOT (AREF EQTB 9189) INT) 100))
                  (WHEN (AND (> (SLOT (AREF EQTB 9746) INT) 0)
                             (> (- (- X) (AREF TOTAL-SHRINK 0)) (SLOT (AREF EQTB 9738) INT)))
                    (WHILE (/= (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
                      (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) NEW-RULE)
                    (SETF (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM Q) HH) RH) 1)) INT)
                          (SLOT (AREF EQTB 9746) INT)))
                  (PRINT-LN)
                  (PRINT-NL 852)
                  (PRINT-SCALED (- (- X) (AREF TOTAL-SHRINK 0)))
                  (PRINT 853)
                  (GOTO $L.50)))
               ((= O 0)
                (WHEN (/= (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) 0)
                  (SETF LAST-BADNESS (BADNESS (- X) (AREF TOTAL-SHRINK 0)))
                  (WHEN (> LAST-BADNESS (SLOT (AREF EQTB 9189) INT))
                    (PRINT-LN)
                    (PRINT-NL 854)
                    (PRINT-INT LAST-BADNESS)
                    (GOTO $L.50)))))
         (GOTO $L.10)))
  $L.50
  (COND (OUTPUT-ACTIVE (PRINT 847))
        (TRUE
         (COND ((/= PACK-BEGIN-LINE 0)
                (COND ((> PACK-BEGIN-LINE 0) (PRINT 848)) (TRUE (PRINT 849)))
                (PRINT-INT (ABS PACK-BEGIN-LINE))
                (PRINT 850))
               (TRUE (PRINT 851)))
         (PRINT-INT LINE)))
  (PRINT-LN)
  (SETF FONT-IN-SHORT-DISPLAY 0)
  (SHORT-DISPLAY (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH))
  (PRINT-LN)
  (BEGIN-DIAGNOSTIC)
  (SHOW-BOX R)
  (END-DIAGNOSTIC TRUE)
  $L.10
  (SETF HPACK R))

(FUNCTION (VPACKAGE HALFWORD) ((P HALFWORD) (H SCALED) (M SMALL-NUMBER) (L SCALED))
  (LABEL $L.50)
  (LABEL $L.10)
  (VAR R HALFWORD)
  (VAR W SCALED)
  (VAR D SCALED)
  (VAR X SCALED)
  (VAR S SCALED)
  (VAR G HALFWORD)
  (VAR O GLUE-ORD)
  (SETF LAST-BADNESS 0)
  (SETF R (GET-NODE 7))
  (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 1)
  (SETF (SLOT (SLOT (AREF MEM R) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ R 4)) INT) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) P)
  (SETF W 0)
  (SETF D 0)
  (SETF X 0)
  (SETF (AREF TOTAL-STRETCH 0) 0)
  (SETF (AREF TOTAL-SHRINK 0) 0)
  (SETF (AREF TOTAL-STRETCH 1) 0)
  (SETF (AREF TOTAL-SHRINK 1) 0)
  (SETF (AREF TOTAL-STRETCH 2) 0)
  (SETF (AREF TOTAL-SHRINK 2) 0)
  (SETF (AREF TOTAL-STRETCH 3) 0)
  (SETF (AREF TOTAL-SHRINK 3) 0)
  (WHILE (/= P 0)
    (COND ((>= P HI-MEM-MIN) (CONFUSION 855))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1 2 13) (SETF X (+ (+ X D) (SLOT (AREF MEM (+ P 3)) INT)))
              (SETF D (SLOT (AREF MEM (+ P 2)) INT))
              (COND ((>= (SLOT (SLOT (AREF MEM P) HH) B0) 2) (SETF S 0))
                    (TRUE (SETF S (SLOT (AREF MEM (+ P 4)) INT))))
              (WHEN (> (+ (SLOT (AREF MEM (+ P 1)) INT) S) W)
                (SETF W (+ (SLOT (AREF MEM (+ P 1)) INT) S))))
             ((8))
             ((10) (INCF X D) (SETF D 0) (SETF G (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
              (INCF X (SLOT (AREF MEM (+ G 1)) INT)) (SETF O (SLOT (SLOT (AREF MEM G) HH) B0))
              (SETF (AREF TOTAL-STRETCH O)
                    (+ (AREF TOTAL-STRETCH O) (SLOT (AREF MEM (+ G 2)) INT)))
              (SETF O (SLOT (SLOT (AREF MEM G) HH) B1))
              (SETF (AREF TOTAL-SHRINK O)
                    (+ (AREF TOTAL-SHRINK O) (SLOT (AREF MEM (+ G 3)) INT)))
              (WHEN (>= (SLOT (SLOT (AREF MEM P) HH) B1) 100)
                (SETF G (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
                (WHEN (> (SLOT (AREF MEM (+ G 1)) INT) W)
                  (SETF W (SLOT (AREF MEM (+ G 1)) INT)))))
             ((11) (SETF X (+ (+ X D) (SLOT (AREF MEM (+ P 1)) INT))) (SETF D 0))
             (ELSE))))
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  (SETF (SLOT (AREF MEM (+ R 1)) INT) W)
  (COND ((> D L) (SETF X (- (+ X D) L)) (SETF (SLOT (AREF MEM (+ R 2)) INT) L))
        (TRUE (SETF (SLOT (AREF MEM (+ R 2)) INT) D)))
  (WHEN (= M 1) (SETF H (+ X H)))
  (SETF (SLOT (AREF MEM (+ R 3)) INT) H)
  (SETF X (- H X))
  (COND ((= X 0)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) 0)
         (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0)
         (GOTO $L.10))
        ((> X 0)
         (COND ((/= (AREF TOTAL-STRETCH 3) 0) (SETF O 3))
               ((/= (AREF TOTAL-STRETCH 2) 0) (SETF O 2))
               ((/= (AREF TOTAL-STRETCH 1) 0) (SETF O 1))
               (TRUE (SETF O 0)))
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) O)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 1)
         (COND ((/= (AREF TOTAL-STRETCH O) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) (/ X (AREF TOTAL-STRETCH O))))
               (TRUE
                (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0)))
         (WHEN (= O 0)
           (WHEN (/= (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) 0)
             (SETF LAST-BADNESS (BADNESS X (AREF TOTAL-STRETCH 0)))
             (WHEN (> LAST-BADNESS (SLOT (AREF EQTB 9190) INT))
               (PRINT-LN)
               (COND ((> LAST-BADNESS 100) (PRINT-NL 844)) (TRUE (PRINT-NL 845)))
               (PRINT 856)
               (PRINT-INT LAST-BADNESS)
               (GOTO $L.50))))
         (GOTO $L.10))
        (TRUE
         (COND ((/= (AREF TOTAL-SHRINK 3) 0) (SETF O 3))
               ((/= (AREF TOTAL-SHRINK 2) 0) (SETF O 2))
               ((/= (AREF TOTAL-SHRINK 1) 0) (SETF O 1))
               (TRUE (SETF O 0)))
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) O)
         (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 2)
         (COND ((/= (AREF TOTAL-SHRINK O) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) (/ (- X) (AREF TOTAL-SHRINK O))))
               (TRUE
                (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0)))
         (COND ((AND (AND (< (AREF TOTAL-SHRINK O) (- X)) (= O 0))
                     (/= (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) 0))
                (SETF LAST-BADNESS 1000000)
                (SETF (SLOT (AREF MEM (+ R 6)) GR) 1.0)
                (WHEN (OR (> (- (- X) (AREF TOTAL-SHRINK 0)) (SLOT (AREF EQTB 9739) INT))
                          (< (SLOT (AREF EQTB 9190) INT) 100))
                  (PRINT-LN)
                  (PRINT-NL 857)
                  (PRINT-SCALED (- (- X) (AREF TOTAL-SHRINK 0)))
                  (PRINT 858)
                  (GOTO $L.50)))
               ((= O 0)
                (WHEN (/= (SLOT (SLOT (AREF MEM (+ R 5)) HH) RH) 0)
                  (SETF LAST-BADNESS (BADNESS (- X) (AREF TOTAL-SHRINK 0)))
                  (WHEN (> LAST-BADNESS (SLOT (AREF EQTB 9190) INT))
                    (PRINT-LN)
                    (PRINT-NL 859)
                    (PRINT-INT LAST-BADNESS)
                    (GOTO $L.50)))))
         (GOTO $L.10)))
  $L.50
  (COND (OUTPUT-ACTIVE (PRINT 847))
        (TRUE
         (COND ((/= PACK-BEGIN-LINE 0)
                (PRINT 849)
                (PRINT-INT (ABS PACK-BEGIN-LINE))
                (PRINT 850))
               (TRUE (PRINT 851)))
         (PRINT-INT LINE)
         (PRINT-LN)))
  (BEGIN-DIAGNOSTIC)
  (SHOW-BOX R)
  (END-DIAGNOSTIC TRUE)
  $L.10
  (SETF VPACKAGE R))

(PROCEDURE APPEND-TO-VLIST ((B HALFWORD))
  (VAR D SCALED)
  (VAR P HALFWORD)
  (WHEN (> (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000))
    (SETF D
          (- (- (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB 6783) HH) RH) 1)) INT)
                (SLOT (SLOT CUR-LIST AUX-FIELD) INT))
             (SLOT (AREF MEM (+ B 3)) INT)))
    (COND ((< D (SLOT (AREF EQTB 9732) INT)) (SETF P (NEW-PARAM-GLUE 0)))
          (TRUE (SETF P (NEW-SKIP-PARAM 1)) (SETF (SLOT (AREF MEM (+ TEMP-PTR 1)) INT) D)))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
    (SETF (SLOT CUR-LIST TAIL-FIELD) P))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) B)
  (SETF (SLOT CUR-LIST TAIL-FIELD) B)
  (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (SLOT (AREF MEM (+ B 2)) INT)))

(FUNCTION (NEW-NOAD HALFWORD) ()
  (VAR P HALFWORD)
  (SETF P (GET-NODE 4))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 16)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 1)) HH) EMPTY-FIELD)
  (SETF (SLOT (AREF MEM (+ P 3)) HH) EMPTY-FIELD)
  (SETF (SLOT (AREF MEM (+ P 2)) HH) EMPTY-FIELD)
  (SETF NEW-NOAD P))

(FUNCTION (NEW-STYLE HALFWORD) ((S SMALL-NUMBER))
  (VAR P HALFWORD)
  (SETF P (GET-NODE 3))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 14)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) S)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) 0)
  (SETF (SLOT (AREF MEM (+ P 2)) INT) 0)
  (SETF NEW-STYLE P))

(FUNCTION (NEW-CHOICE HALFWORD) ()
  (VAR P HALFWORD)
  (SETF P (GET-NODE 3))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 15)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 2)) HH) LH) 0)
  (SETF (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH) 0)
  (SETF NEW-CHOICE P))

(PROCEDURE SHOW-INFO () (SHOW-NODE-LIST (SLOT (SLOT (AREF MEM TEMP-PTR) HH) LH)))

(FUNCTION (FRACTION-RULE HALFWORD) ((T SCALED))
  (VAR P HALFWORD)
  (SETF P NEW-RULE)
  (SETF (SLOT (AREF MEM (+ P 3)) INT) T)
  (SETF (SLOT (AREF MEM (+ P 2)) INT) 0)
  (SETF FRACTION-RULE P))

(FUNCTION (OVERBAR HALFWORD) ((B HALFWORD) (K SCALED) (T SCALED))
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (SETF P (NEW-KERN K))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) B)
  (SETF Q (FRACTION-RULE T))
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
  (SETF P (NEW-KERN T))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q)
  (SETF OVERBAR (VPACKAGE P 0 1 1073741823)))

(FUNCTION (CHAR-BOX HALFWORD) ((F INTERNAL-FONT-NUMBER) (C QUARTERWORD))
  (VAR Q FOUR-QUARTERS)
  (VAR HD EIGHT-BITS)
  (VAR B HALFWORD)
  (VAR P HALFWORD)
  (SETF Q (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) C)) QQQQ))
  (SETF HD (- (SLOT Q B1) 0))
  (SETF B NEW-NULL-BOX)
  (SETF (SLOT (AREF MEM (+ B 1)) INT)
        (+ (SLOT (AREF FONT-INFO (+ (AREF WIDTH-BASE F) (SLOT Q B0))) INT)
           (SLOT (AREF FONT-INFO (+ (AREF ITALIC-BASE F) (DIV (- (SLOT Q B2) 0) 4))) INT)))
  (SETF (SLOT (AREF MEM (+ B 3)) INT)
        (SLOT (AREF FONT-INFO (+ (AREF HEIGHT-BASE F) (DIV HD 16))) INT))
  (SETF (SLOT (AREF MEM (+ B 2)) INT)
        (SLOT (AREF FONT-INFO (+ (AREF DEPTH-BASE F) (MOD HD 16))) INT))
  (SETF P GET-AVAIL)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) C)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) F)
  (SETF (SLOT (SLOT (AREF MEM (+ B 5)) HH) RH) P)
  (SETF CHAR-BOX B))

(PROCEDURE STACK-INTO-BOX ((B HALFWORD) (F INTERNAL-FONT-NUMBER) (C QUARTERWORD))
  (VAR P HALFWORD)
  (SETF P (CHAR-BOX F C))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (SLOT (SLOT (AREF MEM (+ B 5)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (+ B 5)) HH) RH) P)
  (SETF (SLOT (AREF MEM (+ B 3)) INT) (SLOT (AREF MEM (+ P 3)) INT)))

(FUNCTION (HEIGHT-PLUS-DEPTH SCALED) ((F INTERNAL-FONT-NUMBER) (C QUARTERWORD))
  (VAR Q FOUR-QUARTERS)
  (VAR HD EIGHT-BITS)
  (SETF Q (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) C)) QQQQ))
  (SETF HD (- (SLOT Q B1) 0))
  (SETF HEIGHT-PLUS-DEPTH
        (+ (SLOT (AREF FONT-INFO (+ (AREF HEIGHT-BASE F) (DIV HD 16))) INT)
           (SLOT (AREF FONT-INFO (+ (AREF DEPTH-BASE F) (MOD HD 16))) INT))))

(FUNCTION (VAR-DELIMITER HALFWORD) ((D HALFWORD) (S SMALL-NUMBER) (V SCALED))
  (LABEL $L.40)
  (LABEL $L.22)
  (VAR B HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR G INTERNAL-FONT-NUMBER)
  (VAR C QUARTERWORD)
  (VAR X QUARTERWORD)
  (VAR Y QUARTERWORD)
  (VAR M INTEGER)
  (VAR N INTEGER)
  (VAR U SCALED)
  (VAR W SCALED)
  (VAR Q FOUR-QUARTERS)
  (VAR HD EIGHT-BITS)
  (VAR R FOUR-QUARTERS)
  (VAR Z SMALL-NUMBER)
  (VAR LARGE-ATTEMPT BOOLEAN)
  (SETF F 0)
  (SETF W 0)
  (SETF LARGE-ATTEMPT FALSE)
  (SETF Z (SLOT (SLOT (AREF MEM D) QQQQ) B0))
  (SETF X (SLOT (SLOT (AREF MEM D) QQQQ) B1))
  (WHILE TRUE
    (WHEN (OR (/= Z 0) (/= X 0))
      (SETF Z (+ (+ Z S) 16))
      (REPEAT (DECF Z 16)
              (SETF G (SLOT (SLOT (AREF EQTB (+ 7835 Z)) HH) RH))
              (WHEN (/= G 0)
                (SETF Y X)
                (WHEN (AND (>= (- Y 0) (AREF FONT-BC G)) (<= (- Y 0) (AREF FONT-EC G)))
                  $L.22
                  (SETF Q (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE G) Y)) QQQQ))
                  (WHEN (> (SLOT Q B0) 0)
                    (WHEN (= (MOD (- (SLOT Q B2) 0) 4) 3) (SETF F G) (SETF C Y) (GOTO $L.40))
                    (SETF HD (- (SLOT Q B1) 0))
                    (SETF U
                          (+ (SLOT (AREF FONT-INFO (+ (AREF HEIGHT-BASE G) (DIV HD 16))) INT)
                             (SLOT (AREF FONT-INFO (+ (AREF DEPTH-BASE G) (MOD HD 16))) INT)))
                    (WHEN (> U W)
                      (SETF F G)
                      (SETF C Y)
                      (SETF W U)
                      (WHEN (>= U V) (GOTO $L.40)))
                    (WHEN (= (MOD (- (SLOT Q B2) 0) 4) 2) (SETF Y (SLOT Q B3)) (GOTO $L.22)))))
              (UNTIL (< Z 16))))
    (WHEN LARGE-ATTEMPT (GOTO $L.40))
    (SETF LARGE-ATTEMPT TRUE)
    (SETF Z (SLOT (SLOT (AREF MEM D) QQQQ) B2))
    (SETF X (SLOT (SLOT (AREF MEM D) QQQQ) B3)))
  $L.40
  (COND ((/= F 0)
         (COND ((= (MOD (- (SLOT Q B2) 0) 4) 3)
                (SETF B NEW-NULL-BOX)
                (SETF (SLOT (SLOT (AREF MEM B) HH) B0) 1)
                (SETF R (SLOT (AREF FONT-INFO (+ (AREF EXTEN-BASE F) (SLOT Q B3))) QQQQ))
                (SETF C (SLOT R B3))
                (SETF U (HEIGHT-PLUS-DEPTH F C))
                (SETF W 0)
                (SETF Q (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) C)) QQQQ))
                (SETF (SLOT (AREF MEM (+ B 1)) INT)
                      (+ (SLOT (AREF FONT-INFO (+ (AREF WIDTH-BASE F) (SLOT Q B0))) INT)
                         (SLOT (AREF FONT-INFO
                                     (+ (AREF ITALIC-BASE F) (DIV (- (SLOT Q B2) 0) 4)))
                               INT)))
                (SETF C (SLOT R B2))
                (WHEN (/= C 0) (INCF W (HEIGHT-PLUS-DEPTH F C)))
                (SETF C (SLOT R B1))
                (WHEN (/= C 0) (INCF W (HEIGHT-PLUS-DEPTH F C)))
                (SETF C (SLOT R B0))
                (WHEN (/= C 0) (INCF W (HEIGHT-PLUS-DEPTH F C)))
                (SETF N 0)
                (WHEN (> U 0)
                  (WHILE (< W V) (INCF W U) (INCF N 1) (WHEN (/= (SLOT R B1) 0) (INCF W U))))
                (SETF C (SLOT R B2))
                (WHEN (/= C 0) (STACK-INTO-BOX B F C))
                (SETF C (SLOT R B3))
                (FOR (M 1 TO N) (STACK-INTO-BOX B F C))
                (SETF C (SLOT R B1))
                (WHEN (/= C 0)
                  (STACK-INTO-BOX B F C)
                  (SETF C (SLOT R B3))
                  (FOR (M 1 TO N) (STACK-INTO-BOX B F C)))
                (SETF C (SLOT R B0))
                (WHEN (/= C 0) (STACK-INTO-BOX B F C))
                (SETF (SLOT (AREF MEM (+ B 2)) INT) (- W (SLOT (AREF MEM (+ B 3)) INT))))
               (TRUE (SETF B (CHAR-BOX F C)))))
        (TRUE
         (SETF B NEW-NULL-BOX)
         (SETF (SLOT (AREF MEM (+ B 1)) INT) (SLOT (AREF EQTB 9741) INT))))
  (SETF (SLOT (AREF MEM (+ B 4)) INT)
        (- (HALF (- (SLOT (AREF MEM (+ B 3)) INT) (SLOT (AREF MEM (+ B 2)) INT)))
           (SLOT (AREF FONT-INFO
                       (+ 22 (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7837 S)) HH) RH))))
                 INT)))
  (SETF VAR-DELIMITER B))

(FUNCTION (REBOX HALFWORD) ((B HALFWORD) (W SCALED))
  (VAR P HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR V SCALED)
  (COND ((AND (/= (SLOT (AREF MEM (+ B 1)) INT) W)
              (/= (SLOT (SLOT (AREF MEM (+ B 5)) HH) RH) 0))
         (WHEN (= (SLOT (SLOT (AREF MEM B) HH) B0) 1) (SETF B (HPACK B 0 1)))
         (SETF P (SLOT (SLOT (AREF MEM (+ B 5)) HH) RH))
         (WHEN (AND (>= P HI-MEM-MIN) (= (SLOT (SLOT (AREF MEM P) HH) RH) 0))
           (SETF F (SLOT (SLOT (AREF MEM P) HH) B0))
           (SETF V
                 (SLOT (AREF FONT-INFO
                             (+ (AREF WIDTH-BASE F)
                                (SLOT (SLOT (AREF FONT-INFO
                                                  (+ (AREF CHAR-BASE F)
                                                     (SLOT (SLOT (AREF MEM P) HH) B1)))
                                            QQQQ)
                                      B0)))
                       INT))
           (WHEN (/= V (SLOT (AREF MEM (+ B 1)) INT))
             (SETF (SLOT (SLOT (AREF MEM P) HH) RH)
                   (NEW-KERN (- (SLOT (AREF MEM (+ B 1)) INT) V)))))
         (FREE-NODE B 7)
         (SETF B (NEW-GLUE 12))
         (SETF (SLOT (SLOT (AREF MEM B) HH) RH) P)
         (WHILE (/= (SLOT (SLOT (AREF MEM P) HH) RH) 0)
           (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (NEW-GLUE 12))
         (SETF REBOX (HPACK B W 0)))
        (TRUE (SETF (SLOT (AREF MEM (+ B 1)) INT) W) (SETF REBOX B))))

(FUNCTION (MATH-GLUE HALFWORD) ((G HALFWORD) (M SCALED))
  (VAR P HALFWORD)
  (VAR N INTEGER)
  (VAR F SCALED)
  (SETF N (X-OVER-N M 65536))
  (SETF F REMAINDER)
  (WHEN (< F 0) (DECF N 1) (INCF F 65536))
  (SETF P (GET-NODE 4))
  (SETF (SLOT (AREF MEM (+ P 1)) INT)
        (MULT-AND-ADD N
                      (SLOT (AREF MEM (+ G 1)) INT)
                      (XN-OVER-D (SLOT (AREF MEM (+ G 1)) INT) F 65536)
                      1073741823))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) (SLOT (SLOT (AREF MEM G) HH) B0))
  (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 0)
         (SETF (SLOT (AREF MEM (+ P 2)) INT)
               (MULT-AND-ADD N
                             (SLOT (AREF MEM (+ G 2)) INT)
                             (XN-OVER-D (SLOT (AREF MEM (+ G 2)) INT) F 65536)
                             1073741823)))
        (TRUE (SETF (SLOT (AREF MEM (+ P 2)) INT) (SLOT (AREF MEM (+ G 2)) INT))))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) (SLOT (SLOT (AREF MEM G) HH) B1))
  (COND ((= (SLOT (SLOT (AREF MEM P) HH) B1) 0)
         (SETF (SLOT (AREF MEM (+ P 3)) INT)
               (MULT-AND-ADD N
                             (SLOT (AREF MEM (+ G 3)) INT)
                             (XN-OVER-D (SLOT (AREF MEM (+ G 3)) INT) F 65536)
                             1073741823)))
        (TRUE (SETF (SLOT (AREF MEM (+ P 3)) INT) (SLOT (AREF MEM (+ G 3)) INT))))
  (SETF MATH-GLUE P))

(PROCEDURE MATH-KERN ((P HALFWORD) (M SCALED))
  (VAR N INTEGER)
  (VAR F SCALED)
  (WHEN (= (SLOT (SLOT (AREF MEM P) HH) B1) 99)
    (SETF N (X-OVER-N M 65536))
    (SETF F REMAINDER)
    (WHEN (< F 0) (DECF N 1) (INCF F 65536))
    (SETF (SLOT (AREF MEM (+ P 1)) INT)
          (MULT-AND-ADD N
                        (SLOT (AREF MEM (+ P 1)) INT)
                        (XN-OVER-D (SLOT (AREF MEM (+ P 1)) INT) F 65536)
                        1073741823))
    (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 1)))

(PROCEDURE FLUSH-MATH ()
  (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
  (FLUSH-NODE-LIST (SLOT (SLOT CUR-LIST AUX-FIELD) INT))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) 0)
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
  (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 0))

(PROCEDURE MLIST-TO-HLIST () :FORWARD)

(FUNCTION (CLEAN-BOX HALFWORD) ((P HALFWORD) (S SMALL-NUMBER))
  (LABEL $L.40)
  (VAR Q HALFWORD)
  (VAR SAVE-STYLE SMALL-NUMBER)
  (VAR X HALFWORD)
  (VAR R HALFWORD)
  (CASE (SLOT (SLOT (AREF MEM P) HH) RH)
    ((1) (SETF CUR-MLIST NEW-NOAD) (SETF (AREF MEM (+ CUR-MLIST 1)) (AREF MEM P)))
    ((2) (SETF Q (SLOT (SLOT (AREF MEM P) HH) LH)) (GOTO $L.40))
    ((3) (SETF CUR-MLIST (SLOT (SLOT (AREF MEM P) HH) LH)))
    (ELSE (SETF Q NEW-NULL-BOX) (GOTO $L.40)))
  (SETF SAVE-STYLE CUR-STYLE)
  (SETF CUR-STYLE S)
  (SETF MLIST-PENALTIES FALSE)
  (MLIST-TO-HLIST)
  (SETF Q (SLOT (SLOT (AREF MEM 59997) HH) RH))
  (SETF CUR-STYLE SAVE-STYLE)
  (COND ((< CUR-STYLE 4) (SETF CUR-SIZE 0))
        (TRUE (SETF CUR-SIZE (* 16 (DIV (- CUR-STYLE 2) 2)))))
  (SETF CUR-MU
        (X-OVER-N (SLOT (AREF FONT-INFO
                              (+ 6
                                 (AREF PARAM-BASE
                                       (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                        INT)
                  18))
  $L.40
  (COND ((OR (>= Q HI-MEM-MIN) (= Q 0)) (SETF X (HPACK Q 0 1)))
        ((AND (AND (= (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
                   (<= (SLOT (SLOT (AREF MEM Q) HH) B0) 1))
              (= (SLOT (AREF MEM (+ Q 4)) INT) 0))
         (SETF X Q))
        (TRUE (SETF X (HPACK Q 0 1))))
  (SETF Q (SLOT (SLOT (AREF MEM (+ X 5)) HH) RH))
  (WHEN (>= Q HI-MEM-MIN)
    (SETF R (SLOT (SLOT (AREF MEM Q) HH) RH))
    (WHEN (/= R 0)
      (WHEN (= (SLOT (SLOT (AREF MEM R) HH) RH) 0)
        (UNLESS (>= R HI-MEM-MIN)
          (WHEN (= (SLOT (SLOT (AREF MEM R) HH) B0) 11)
            (FREE-NODE R 2)
            (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0))))))
  (SETF CLEAN-BOX X))

(PROCEDURE FETCH ((A HALFWORD))
  (SETF CUR-C (SLOT (SLOT (AREF MEM A) HH) B1))
  (SETF CUR-F
        (SLOT (SLOT (AREF EQTB (+ (+ 7835 (SLOT (SLOT (AREF MEM A) HH) B0)) CUR-SIZE)) HH) RH))
  (COND ((= CUR-F 0)
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 338)
         (PRINT-SIZE CUR-SIZE)
         (PRINT-CHAR 32)
         (PRINT-INT (SLOT (SLOT (AREF MEM A) HH) B0))
         (PRINT 884)
         (PRINT (- CUR-C 0))
         (PRINT-CHAR 41)
         (SETF HELP-PTR 4)
         (SETF (AREF HELP-LINE 3) 885)
         (SETF (AREF HELP-LINE 2) 886)
         (SETF (AREF HELP-LINE 1) 887)
         (SETF (AREF HELP-LINE 0) 888)
         (ERROR)
         (SETF CUR-I NULL-CHARACTER)
         (SETF (SLOT (SLOT (AREF MEM A) HH) RH) 0))
        (TRUE
         (COND ((AND (>= (- CUR-C 0) (AREF FONT-BC CUR-F))
                     (<= (- CUR-C 0) (AREF FONT-EC CUR-F)))
                (SETF CUR-I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE CUR-F) CUR-C)) QQQQ)))
               (TRUE (SETF CUR-I NULL-CHARACTER)))
         (UNLESS (> (SLOT CUR-I B0) 0)
           (CHAR-WARNING CUR-F (- CUR-C 0))
           (SETF (SLOT (SLOT (AREF MEM A) HH) RH) 0)
           (SETF CUR-I NULL-CHARACTER)))))

(PROCEDURE MAKE-OVER ((Q HALFWORD))
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH)
        (OVERBAR (CLEAN-BOX (+ Q 1) (+ (* 2 (DIV CUR-STYLE 2)) 1))
                 (* 3
                    (SLOT (AREF FONT-INFO
                                (+ 8
                                   (AREF PARAM-BASE
                                         (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                          INT))
                 (SLOT (AREF FONT-INFO
                             (+ 8
                                (AREF PARAM-BASE
                                      (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                       INT)))
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 2))

(PROCEDURE MAKE-UNDER ((Q HALFWORD))
  (VAR P HALFWORD)
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR DELTA SCALED)
  (SETF X (CLEAN-BOX (+ Q 1) CUR-STYLE))
  (SETF P
        (NEW-KERN (* 3
                     (SLOT (AREF FONT-INFO
                                 (+ 8
                                    (AREF PARAM-BASE
                                          (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                           INT))))
  (SETF (SLOT (SLOT (AREF MEM X) HH) RH) P)
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH)
        (FRACTION-RULE
          (SLOT (AREF FONT-INFO
                      (+ 8
                         (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                INT)))
  (SETF Y (VPACKAGE X 0 1 1073741823))
  (SETF DELTA
        (+ (+ (SLOT (AREF MEM (+ Y 3)) INT) (SLOT (AREF MEM (+ Y 2)) INT))
           (SLOT (AREF FONT-INFO
                       (+ 8
                          (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                 INT)))
  (SETF (SLOT (AREF MEM (+ Y 3)) INT) (SLOT (AREF MEM (+ X 3)) INT))
  (SETF (SLOT (AREF MEM (+ Y 2)) INT) (- DELTA (SLOT (AREF MEM (+ Y 3)) INT)))
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) Y)
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 2))

(PROCEDURE MAKE-VCENTER ((Q HALFWORD))
  (VAR V HALFWORD)
  (VAR DELTA SCALED)
  (SETF V (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
  (WHEN (/= (SLOT (SLOT (AREF MEM V) HH) B0) 1) (CONFUSION 539))
  (SETF DELTA (+ (SLOT (AREF MEM (+ V 3)) INT) (SLOT (AREF MEM (+ V 2)) INT)))
  (SETF (SLOT (AREF MEM (+ V 3)) INT)
        (+ (SLOT (AREF FONT-INFO
                       (+ 22
                          (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                 INT)
           (HALF DELTA)))
  (SETF (SLOT (AREF MEM (+ V 2)) INT) (- DELTA (SLOT (AREF MEM (+ V 3)) INT))))

(PROCEDURE MAKE-RADICAL ((Q HALFWORD))
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR DELTA SCALED)
  (VAR CLR SCALED)
  (SETF X (CLEAN-BOX (+ Q 1) (+ (* 2 (DIV CUR-STYLE 2)) 1)))
  (COND ((< CUR-STYLE 2)
         (SETF CLR
               (+ (SLOT (AREF FONT-INFO
                              (+ 8
                                 (AREF PARAM-BASE
                                       (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                        INT)
                  (DIV (ABS (SLOT (AREF FONT-INFO
                                        (+ 5
                                           (AREF PARAM-BASE
                                                 (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                       RH))))
                                  INT))
                       4))))
        (TRUE
         (SETF CLR
               (SLOT (AREF FONT-INFO
                           (+ 8
                              (AREF PARAM-BASE
                                    (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                     INT))
         (INCF CLR (DIV (ABS CLR) 4))))
  (SETF Y
        (VAR-DELIMITER
          (+ Q 4)
          CUR-SIZE
          (+ (+ (+ (SLOT (AREF MEM (+ X 3)) INT) (SLOT (AREF MEM (+ X 2)) INT)) CLR)
             (SLOT (AREF FONT-INFO
                         (+ 8
                            (AREF PARAM-BASE
                                  (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                   INT))))
  (SETF DELTA
        (- (SLOT (AREF MEM (+ Y 2)) INT)
           (+ (+ (SLOT (AREF MEM (+ X 3)) INT) (SLOT (AREF MEM (+ X 2)) INT)) CLR)))
  (WHEN (> DELTA 0) (INCF CLR (HALF DELTA)))
  (SETF (SLOT (AREF MEM (+ Y 4)) INT) (- (+ (SLOT (AREF MEM (+ X 3)) INT) CLR)))
  (SETF (SLOT (SLOT (AREF MEM Y) HH) RH) (OVERBAR X CLR (SLOT (AREF MEM (+ Y 3)) INT)))
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) (HPACK Y 0 1))
  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 2))

(PROCEDURE MAKE-MATH-ACCENT ((Q HALFWORD))
  (LABEL $L.30)
  (LABEL $L.31)
  (VAR P HALFWORD)
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR A INTEGER)
  (VAR C QUARTERWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR I FOUR-QUARTERS)
  (VAR S SCALED)
  (VAR H SCALED)
  (VAR DELTA SCALED)
  (VAR W SCALED)
  (FETCH (+ Q 4))
  (WHEN (> (SLOT CUR-I B0) 0)
    (SETF I CUR-I)
    (SETF C CUR-C)
    (SETF F CUR-F)
    (SETF S 0)
    (WHEN (= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 1)
      (FETCH (+ Q 1))
      (WHEN (= (MOD (- (SLOT CUR-I B2) 0) 4) 1)
        (SETF A (+ (AREF LIG-KERN-BASE CUR-F) (SLOT CUR-I B3)))
        (SETF CUR-I (SLOT (AREF FONT-INFO A) QQQQ))
        (WHEN (> (SLOT CUR-I B0) 128)
          (SETF A
                (- (+ (+ (+ (AREF LIG-KERN-BASE CUR-F) (* 256 (SLOT CUR-I B2)))
                         (SLOT CUR-I B3))
                      32768)
                   (* 256 128)))
          (SETF CUR-I (SLOT (AREF FONT-INFO A) QQQQ)))
        (WHILE TRUE
          (WHEN (= (- (SLOT CUR-I B1) 0) (AREF SKEW-CHAR CUR-F))
            (WHEN (>= (SLOT CUR-I B2) 128)
              (WHEN (<= (SLOT CUR-I B0) 128)
                (SETF S
                      (SLOT (AREF FONT-INFO
                                  (+ (+ (AREF KERN-BASE CUR-F) (* 256 (SLOT CUR-I B2)))
                                     (SLOT CUR-I B3)))
                            INT))))
            (GOTO $L.31))
          (WHEN (>= (SLOT CUR-I B0) 128) (GOTO $L.31))
          (SETF A (+ (+ A (SLOT CUR-I B0)) 1))
          (SETF CUR-I (SLOT (AREF FONT-INFO A) QQQQ)))))
    $L.31
    (SETF X (CLEAN-BOX (+ Q 1) (+ (* 2 (DIV CUR-STYLE 2)) 1)))
    (SETF W (SLOT (AREF MEM (+ X 1)) INT))
    (SETF H (SLOT (AREF MEM (+ X 3)) INT))
    (WHILE TRUE
      (WHEN (/= (MOD (- (SLOT I B2) 0) 4) 2) (GOTO $L.30))
      (SETF Y (SLOT I B3))
      (SETF I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) Y)) QQQQ))
      (UNLESS (> (SLOT I B0) 0) (GOTO $L.30))
      (WHEN (> (SLOT (AREF FONT-INFO (+ (AREF WIDTH-BASE F) (SLOT I B0))) INT) W) (GOTO $L.30))
      (SETF C Y))
    $L.30
    (COND ((< H (SLOT (AREF FONT-INFO (+ 5 (AREF PARAM-BASE F))) INT)) (SETF DELTA H))
          (TRUE (SETF DELTA (SLOT (AREF FONT-INFO (+ 5 (AREF PARAM-BASE F))) INT))))
    (WHEN (OR (/= (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH) 0)
              (/= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0))
      (WHEN (= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 1)
        (FLUSH-NODE-LIST X)
        (SETF X NEW-NOAD)
        (SETF (AREF MEM (+ X 1)) (AREF MEM (+ Q 1)))
        (SETF (AREF MEM (+ X 2)) (AREF MEM (+ Q 2)))
        (SETF (AREF MEM (+ X 3)) (AREF MEM (+ Q 3)))
        (SETF (SLOT (AREF MEM (+ Q 2)) HH) EMPTY-FIELD)
        (SETF (SLOT (AREF MEM (+ Q 3)) HH) EMPTY-FIELD)
        (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 3)
        (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) X)
        (SETF X (CLEAN-BOX (+ Q 1) CUR-STYLE))
        (SETF DELTA (- (+ DELTA (SLOT (AREF MEM (+ X 3)) INT)) H))
        (SETF H (SLOT (AREF MEM (+ X 3)) INT))))
    (SETF Y (CHAR-BOX F C))
    (SETF (SLOT (AREF MEM (+ Y 4)) INT) (+ S (HALF (- W (SLOT (AREF MEM (+ Y 1)) INT)))))
    (SETF (SLOT (AREF MEM (+ Y 1)) INT) 0)
    (SETF P (NEW-KERN (- DELTA)))
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) X)
    (SETF (SLOT (SLOT (AREF MEM Y) HH) RH) P)
    (SETF Y (VPACKAGE Y 0 1 1073741823))
    (SETF (SLOT (AREF MEM (+ Y 1)) INT) (SLOT (AREF MEM (+ X 1)) INT))
    (WHEN (< (SLOT (AREF MEM (+ Y 3)) INT) H)
      (SETF P (NEW-KERN (- H (SLOT (AREF MEM (+ Y 3)) INT))))
      (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (SLOT (SLOT (AREF MEM (+ Y 5)) HH) RH))
      (SETF (SLOT (SLOT (AREF MEM (+ Y 5)) HH) RH) P)
      (SETF (SLOT (AREF MEM (+ Y 3)) INT) H))
    (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) Y)
    (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 2)))

(PROCEDURE MAKE-FRACTION ((Q HALFWORD))
  (VAR P HALFWORD)
  (VAR V HALFWORD)
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR Z HALFWORD)
  (VAR DELTA SCALED)
  (VAR DELTA1 SCALED)
  (VAR DELTA2 SCALED)
  (VAR SHIFT-UP SCALED)
  (VAR SHIFT-DOWN SCALED)
  (VAR CLR SCALED)
  (WHEN (= (SLOT (AREF MEM (+ Q 1)) INT) 1073741824)
    (SETF (SLOT (AREF MEM (+ Q 1)) INT)
          (SLOT (AREF FONT-INFO
                      (+ 8
                         (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                INT)))
  (SETF X (CLEAN-BOX (+ Q 2) (- (+ CUR-STYLE 2) (* 2 (DIV CUR-STYLE 6)))))
  (SETF Z (CLEAN-BOX (+ Q 3) (- (+ (* 2 (DIV CUR-STYLE 2)) 3) (* 2 (DIV CUR-STYLE 6)))))
  (COND ((< (SLOT (AREF MEM (+ X 1)) INT) (SLOT (AREF MEM (+ Z 1)) INT))
         (SETF X (REBOX X (SLOT (AREF MEM (+ Z 1)) INT))))
        (TRUE (SETF Z (REBOX Z (SLOT (AREF MEM (+ X 1)) INT)))))
  (COND ((< CUR-STYLE 2)
         (SETF SHIFT-UP
               (SLOT (AREF FONT-INFO
                           (+ 8
                              (AREF PARAM-BASE
                                    (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                     INT))
         (SETF SHIFT-DOWN
               (SLOT (AREF FONT-INFO
                           (+ 11
                              (AREF PARAM-BASE
                                    (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                     INT)))
        (TRUE
         (SETF SHIFT-DOWN
               (SLOT (AREF FONT-INFO
                           (+ 12
                              (AREF PARAM-BASE
                                    (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                     INT))
         (COND ((/= (SLOT (AREF MEM (+ Q 1)) INT) 0)
                (SETF SHIFT-UP
                      (SLOT (AREF FONT-INFO
                                  (+ 9
                                     (AREF PARAM-BASE
                                           (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                            INT)))
               (TRUE
                (SETF SHIFT-UP
                      (SLOT (AREF FONT-INFO
                                  (+ 10
                                     (AREF PARAM-BASE
                                           (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                            INT))))))
  (COND ((= (SLOT (AREF MEM (+ Q 1)) INT) 0)
         (COND ((< CUR-STYLE 2)
                (SETF CLR
                      (* 7
                         (SLOT (AREF FONT-INFO
                                     (+ 8
                                        (AREF PARAM-BASE
                                              (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                    RH))))
                               INT))))
               (TRUE
                (SETF CLR
                      (* 3
                         (SLOT (AREF FONT-INFO
                                     (+ 8
                                        (AREF PARAM-BASE
                                              (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                    RH))))
                               INT)))))
         (SETF DELTA
               (HALF (- CLR
                        (- (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))
                           (- (SLOT (AREF MEM (+ Z 3)) INT) SHIFT-DOWN)))))
         (WHEN (> DELTA 0) (INCF SHIFT-UP DELTA) (INCF SHIFT-DOWN DELTA)))
        (TRUE
         (COND ((< CUR-STYLE 2) (SETF CLR (* 3 (SLOT (AREF MEM (+ Q 1)) INT))))
               (TRUE (SETF CLR (SLOT (AREF MEM (+ Q 1)) INT))))
         (SETF DELTA (HALF (SLOT (AREF MEM (+ Q 1)) INT)))
         (SETF DELTA1
               (- CLR
                  (- (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))
                     (+ (SLOT (AREF FONT-INFO
                                    (+ 22
                                       (AREF PARAM-BASE
                                             (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                   RH))))
                              INT)
                        DELTA))))
         (SETF DELTA2
               (- CLR
                  (- (- (SLOT (AREF FONT-INFO
                                    (+ 22
                                       (AREF PARAM-BASE
                                             (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                   RH))))
                              INT)
                        DELTA)
                     (- (SLOT (AREF MEM (+ Z 3)) INT) SHIFT-DOWN))))
         (WHEN (> DELTA1 0) (INCF SHIFT-UP DELTA1))
         (WHEN (> DELTA2 0) (INCF SHIFT-DOWN DELTA2))))
  (SETF V NEW-NULL-BOX)
  (SETF (SLOT (SLOT (AREF MEM V) HH) B0) 1)
  (SETF (SLOT (AREF MEM (+ V 3)) INT) (+ SHIFT-UP (SLOT (AREF MEM (+ X 3)) INT)))
  (SETF (SLOT (AREF MEM (+ V 2)) INT) (+ (SLOT (AREF MEM (+ Z 2)) INT) SHIFT-DOWN))
  (SETF (SLOT (AREF MEM (+ V 1)) INT) (SLOT (AREF MEM (+ X 1)) INT))
  (COND ((= (SLOT (AREF MEM (+ Q 1)) INT) 0)
         (SETF P
               (NEW-KERN (- (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))
                            (- (SLOT (AREF MEM (+ Z 3)) INT) SHIFT-DOWN))))
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Z))
        (TRUE
         (SETF Y (FRACTION-RULE (SLOT (AREF MEM (+ Q 1)) INT)))
         (SETF P
               (NEW-KERN (- (- (SLOT (AREF FONT-INFO
                                           (+ 22
                                              (AREF PARAM-BASE
                                                    (SLOT (SLOT
                                                           (AREF EQTB (+ 7837 CUR-SIZE))
                                                           HH)
                                                          RH))))
                                     INT)
                               DELTA)
                            (- (SLOT (AREF MEM (+ Z 3)) INT) SHIFT-DOWN))))
         (SETF (SLOT (SLOT (AREF MEM Y) HH) RH) P)
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Z)
         (SETF P
               (NEW-KERN (- (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))
                            (+ (SLOT (AREF FONT-INFO
                                           (+ 22
                                              (AREF PARAM-BASE
                                                    (SLOT (SLOT
                                                           (AREF EQTB (+ 7837 CUR-SIZE))
                                                           HH)
                                                          RH))))
                                     INT)
                               DELTA))))
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Y)))
  (SETF (SLOT (SLOT (AREF MEM X) HH) RH) P)
  (SETF (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH) X)
  (COND ((< CUR-STYLE 2)
         (SETF DELTA
               (SLOT (AREF FONT-INFO
                           (+ 20
                              (AREF PARAM-BASE
                                    (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                     INT)))
        (TRUE
         (SETF DELTA
               (SLOT (AREF FONT-INFO
                           (+ 21
                              (AREF PARAM-BASE
                                    (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                     INT))))
  (SETF X (VAR-DELIMITER (+ Q 4) CUR-SIZE DELTA))
  (SETF (SLOT (SLOT (AREF MEM X) HH) RH) V)
  (SETF Z (VAR-DELIMITER (+ Q 5) CUR-SIZE DELTA))
  (SETF (SLOT (SLOT (AREF MEM V) HH) RH) Z)
  (SETF (SLOT (AREF MEM (+ Q 1)) INT) (HPACK X 0 1)))

(FUNCTION (MAKE-OP SCALED) ((Q HALFWORD))
  (VAR DELTA SCALED)
  (VAR P HALFWORD)
  (VAR V HALFWORD)
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR Z HALFWORD)
  (VAR C QUARTERWORD)
  (VAR I FOUR-QUARTERS)
  (VAR SHIFT-UP SCALED)
  (VAR SHIFT-DOWN SCALED)
  (WHEN (AND (= (SLOT (SLOT (AREF MEM Q) HH) B1) 0) (< CUR-STYLE 2))
    (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 1))
  (COND ((= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 1)
         (FETCH (+ Q 1))
         (WHEN (AND (< CUR-STYLE 2) (= (MOD (- (SLOT CUR-I B2) 0) 4) 2))
           (SETF C (SLOT CUR-I B3))
           (SETF I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE CUR-F) C)) QQQQ))
           (WHEN (> (SLOT I B0) 0)
             (SETF CUR-C C)
             (SETF CUR-I I)
             (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) B1) C)))
         (SETF DELTA
               (SLOT (AREF FONT-INFO
                           (+ (AREF ITALIC-BASE CUR-F) (DIV (- (SLOT CUR-I B2) 0) 4)))
                     INT))
         (SETF X (CLEAN-BOX (+ Q 1) CUR-STYLE))
         (WHEN (AND (/= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0)
                    (/= (SLOT (SLOT (AREF MEM Q) HH) B1) 1))
           (SETF (SLOT (AREF MEM (+ X 1)) INT) (- (SLOT (AREF MEM (+ X 1)) INT) DELTA)))
         (SETF (SLOT (AREF MEM (+ X 4)) INT)
               (- (HALF (- (SLOT (AREF MEM (+ X 3)) INT) (SLOT (AREF MEM (+ X 2)) INT)))
                  (SLOT (AREF FONT-INFO
                              (+ 22
                                 (AREF PARAM-BASE
                                       (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                        INT)))
         (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 2)
         (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) X))
        (TRUE (SETF DELTA 0)))
  (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B1) 1)
    (SETF X (CLEAN-BOX (+ Q 2) (+ (+ (* 2 (DIV CUR-STYLE 4)) 4) (MOD CUR-STYLE 2))))
    (SETF Y (CLEAN-BOX (+ Q 1) CUR-STYLE))
    (SETF Z (CLEAN-BOX (+ Q 3) (+ (* 2 (DIV CUR-STYLE 4)) 5)))
    (SETF V NEW-NULL-BOX)
    (SETF (SLOT (SLOT (AREF MEM V) HH) B0) 1)
    (SETF (SLOT (AREF MEM (+ V 1)) INT) (SLOT (AREF MEM (+ Y 1)) INT))
    (WHEN (> (SLOT (AREF MEM (+ X 1)) INT) (SLOT (AREF MEM (+ V 1)) INT))
      (SETF (SLOT (AREF MEM (+ V 1)) INT) (SLOT (AREF MEM (+ X 1)) INT)))
    (WHEN (> (SLOT (AREF MEM (+ Z 1)) INT) (SLOT (AREF MEM (+ V 1)) INT))
      (SETF (SLOT (AREF MEM (+ V 1)) INT) (SLOT (AREF MEM (+ Z 1)) INT)))
    (SETF X (REBOX X (SLOT (AREF MEM (+ V 1)) INT)))
    (SETF Y (REBOX Y (SLOT (AREF MEM (+ V 1)) INT)))
    (SETF Z (REBOX Z (SLOT (AREF MEM (+ V 1)) INT)))
    (SETF (SLOT (AREF MEM (+ X 4)) INT) (HALF DELTA))
    (SETF (SLOT (AREF MEM (+ Z 4)) INT) (- (SLOT (AREF MEM (+ X 4)) INT)))
    (SETF (SLOT (AREF MEM (+ V 3)) INT) (SLOT (AREF MEM (+ Y 3)) INT))
    (SETF (SLOT (AREF MEM (+ V 2)) INT) (SLOT (AREF MEM (+ Y 2)) INT))
    (COND ((= (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH) 0)
           (FREE-NODE X 7)
           (SETF (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH) Y))
          (TRUE
           (SETF SHIFT-UP
                 (- (SLOT (AREF FONT-INFO
                                (+ 11
                                   (AREF PARAM-BASE
                                         (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                          INT)
                    (SLOT (AREF MEM (+ X 2)) INT)))
           (WHEN (< SHIFT-UP
                    (SLOT (AREF FONT-INFO
                                (+ 9
                                   (AREF PARAM-BASE
                                         (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                          INT))
             (SETF SHIFT-UP
                   (SLOT (AREF FONT-INFO
                               (+ 9
                                  (AREF PARAM-BASE
                                        (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                         INT)))
           (SETF P (NEW-KERN SHIFT-UP))
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Y)
           (SETF (SLOT (SLOT (AREF MEM X) HH) RH) P)
           (SETF P
                 (NEW-KERN (SLOT (AREF FONT-INFO
                                       (+ 13
                                          (AREF PARAM-BASE
                                                (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                      RH))))
                                 INT)))
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH) X)
           (SETF (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH) P)
           (SETF (SLOT (AREF MEM (+ V 3)) INT)
                 (+ (+ (+ (+ (SLOT (AREF MEM (+ V 3)) INT)
                             (SLOT (AREF FONT-INFO
                                         (+ 13
                                            (AREF PARAM-BASE
                                                  (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                        RH))))
                                   INT))
                          (SLOT (AREF MEM (+ X 3)) INT))
                       (SLOT (AREF MEM (+ X 2)) INT))
                    SHIFT-UP))))
    (COND ((= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0) (FREE-NODE Z 7))
          (TRUE
           (SETF SHIFT-DOWN
                 (- (SLOT (AREF FONT-INFO
                                (+ 12
                                   (AREF PARAM-BASE
                                         (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                          INT)
                    (SLOT (AREF MEM (+ Z 3)) INT)))
           (WHEN (< SHIFT-DOWN
                    (SLOT (AREF FONT-INFO
                                (+ 10
                                   (AREF PARAM-BASE
                                         (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                          INT))
             (SETF SHIFT-DOWN
                   (SLOT (AREF FONT-INFO
                               (+ 10
                                  (AREF PARAM-BASE
                                        (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH) RH))))
                         INT)))
           (SETF P (NEW-KERN SHIFT-DOWN))
           (SETF (SLOT (SLOT (AREF MEM Y) HH) RH) P)
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Z)
           (SETF P
                 (NEW-KERN (SLOT (AREF FONT-INFO
                                       (+ 13
                                          (AREF PARAM-BASE
                                                (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                      RH))))
                                 INT)))
           (SETF (SLOT (SLOT (AREF MEM Z) HH) RH) P)
           (SETF (SLOT (AREF MEM (+ V 2)) INT)
                 (+ (+ (+ (+ (SLOT (AREF MEM (+ V 2)) INT)
                             (SLOT (AREF FONT-INFO
                                         (+ 13
                                            (AREF PARAM-BASE
                                                  (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                        RH))))
                                   INT))
                          (SLOT (AREF MEM (+ Z 3)) INT))
                       (SLOT (AREF MEM (+ Z 2)) INT))
                    SHIFT-DOWN))))
    (SETF (SLOT (AREF MEM (+ Q 1)) INT) V))
  (SETF MAKE-OP DELTA))

(PROCEDURE MAKE-ORD ((Q HALFWORD))
  (LABEL $L.20)
  (LABEL $L.10)
  (VAR A INTEGER)
  (VAR P HALFWORD)
  (VAR R HALFWORD)
  $L.20
  (WHEN (= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0)
    (WHEN (= (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH) 0)
      (WHEN (= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 1)
        (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
        (WHEN (/= P 0)
          (WHEN (AND (>= (SLOT (SLOT (AREF MEM P) HH) B0) 16)
                     (<= (SLOT (SLOT (AREF MEM P) HH) B0) 22))
            (WHEN (= (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 1)
              (WHEN (= (SLOT (SLOT (AREF MEM (+ P 1)) HH) B0)
                       (SLOT (SLOT (AREF MEM (+ Q 1)) HH) B0))
                (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 4)
                (FETCH (+ Q 1))
                (WHEN (= (MOD (- (SLOT CUR-I B2) 0) 4) 1)
                  (SETF A (+ (AREF LIG-KERN-BASE CUR-F) (SLOT CUR-I B3)))
                  (SETF CUR-C (SLOT (SLOT (AREF MEM (+ P 1)) HH) B1))
                  (SETF CUR-I (SLOT (AREF FONT-INFO A) QQQQ))
                  (WHEN (> (SLOT CUR-I B0) 128)
                    (SETF A
                          (- (+ (+ (+ (AREF LIG-KERN-BASE CUR-F) (* 256 (SLOT CUR-I B2)))
                                   (SLOT CUR-I B3))
                                32768)
                             (* 256 128)))
                    (SETF CUR-I (SLOT (AREF FONT-INFO A) QQQQ)))
                  (WHILE TRUE
                    (WHEN (= (SLOT CUR-I B1) CUR-C)
                      (WHEN (<= (SLOT CUR-I B0) 128)
                        (COND ((>= (SLOT CUR-I B2) 128)
                               (SETF P
                                     (NEW-KERN (SLOT (AREF FONT-INFO
                                                           (+
                                                            (+
                                                             (AREF KERN-BASE CUR-F)
                                                             (* 256 (SLOT CUR-I B2)))
                                                            (SLOT CUR-I B3)))
                                                     INT)))
                               (SETF (SLOT (SLOT (AREF MEM P) HH) RH)
                                     (SLOT (SLOT (AREF MEM Q) HH) RH))
                               (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
                               (GOTO $L.10))
                              (TRUE
                               (WHEN (/= INTERRUPT 0) (PAUSE-FOR-INSTRUCTIONS))
                               (CASE (SLOT CUR-I B2)
                                 ((1 5)
                                  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) B1)
                                        (SLOT CUR-I B3)))
                                 ((2 6)
                                  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) B1)
                                        (SLOT CUR-I B3)))
                                 ((3 7 11) (SETF R NEW-NOAD)
                                  (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) B1) (SLOT CUR-I B3))
                                  (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) B0)
                                        (SLOT (SLOT (AREF MEM (+ Q 1)) HH) B0))
                                  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
                                  (SETF (SLOT (SLOT (AREF MEM R) HH) RH) P)
                                  (COND ((< (SLOT CUR-I B2) 11)
                                         (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH) 1))
                                        (TRUE
                                         (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH) 4))))
                                 (ELSE
                                  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH)
                                        (SLOT (SLOT (AREF MEM P) HH) RH))
                                  (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) B1) (SLOT CUR-I B3))
                                  (SETF (AREF MEM (+ Q 3)) (AREF MEM (+ P 3)))
                                  (SETF (AREF MEM (+ Q 2)) (AREF MEM (+ P 2)))
                                  (FREE-NODE P 4)))
                               (WHEN (> (SLOT CUR-I B2) 3) (GOTO $L.10))
                               (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 1)
                               (GOTO $L.20)))))
                    (WHEN (>= (SLOT CUR-I B0) 128) (GOTO $L.10))
                    (SETF A (+ (+ A (SLOT CUR-I B0)) 1))
                    (SETF CUR-I (SLOT (AREF FONT-INFO A) QQQQ)))))))))))
  $L.10)

(PROCEDURE MAKE-SCRIPTS ((Q HALFWORD) (DELTA SCALED))
  (VAR P HALFWORD)
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR Z HALFWORD)
  (VAR SHIFT-UP SCALED)
  (VAR SHIFT-DOWN SCALED)
  (VAR CLR SCALED)
  (VAR T SMALL-NUMBER)
  (SETF P (SLOT (AREF MEM (+ Q 1)) INT))
  (COND ((>= P HI-MEM-MIN) (SETF SHIFT-UP 0) (SETF SHIFT-DOWN 0))
        (TRUE
         (SETF Z (HPACK P 0 1))
         (COND ((< CUR-STYLE 4) (SETF T 16)) (TRUE (SETF T 32)))
         (SETF SHIFT-UP
               (- (SLOT (AREF MEM (+ Z 3)) INT)
                  (SLOT (AREF FONT-INFO
                              (+ 18
                                 (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7837 T)) HH) RH))))
                        INT)))
         (SETF SHIFT-DOWN
               (+ (SLOT (AREF MEM (+ Z 2)) INT)
                  (SLOT (AREF FONT-INFO
                              (+ 19
                                 (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7837 T)) HH) RH))))
                        INT)))
         (FREE-NODE Z 7)))
  (COND ((= (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH) 0)
         (SETF X (CLEAN-BOX (+ Q 3) (+ (* 2 (DIV CUR-STYLE 4)) 5)))
         (SETF (SLOT (AREF MEM (+ X 1)) INT)
               (+ (SLOT (AREF MEM (+ X 1)) INT) (SLOT (AREF EQTB 9742) INT)))
         (WHEN (< SHIFT-DOWN
                  (SLOT (AREF FONT-INFO
                              (+ 16
                                 (AREF PARAM-BASE
                                       (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                        INT))
           (SETF SHIFT-DOWN
                 (SLOT (AREF FONT-INFO
                             (+ 16
                                (AREF PARAM-BASE
                                      (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                       INT)))
         (SETF CLR
               (- (SLOT (AREF MEM (+ X 3)) INT)
                  (DIV (ABS (* (SLOT (AREF FONT-INFO
                                           (+ 5
                                              (AREF PARAM-BASE
                                                    (SLOT (SLOT
                                                           (AREF EQTB (+ 7837 CUR-SIZE))
                                                           HH)
                                                          RH))))
                                     INT)
                               4))
                       5)))
         (WHEN (< SHIFT-DOWN CLR) (SETF SHIFT-DOWN CLR))
         (SETF (SLOT (AREF MEM (+ X 4)) INT) SHIFT-DOWN))
        (TRUE
         (SETF X (CLEAN-BOX (+ Q 2) (+ (+ (* 2 (DIV CUR-STYLE 4)) 4) (MOD CUR-STYLE 2))))
         (SETF (SLOT (AREF MEM (+ X 1)) INT)
               (+ (SLOT (AREF MEM (+ X 1)) INT) (SLOT (AREF EQTB 9742) INT)))
         (COND ((ODD CUR-STYLE)
                (SETF CLR
                      (SLOT (AREF FONT-INFO
                                  (+ 15
                                     (AREF PARAM-BASE
                                           (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                            INT)))
               ((< CUR-STYLE 2)
                (SETF CLR
                      (SLOT (AREF FONT-INFO
                                  (+ 13
                                     (AREF PARAM-BASE
                                           (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                            INT)))
               (TRUE
                (SETF CLR
                      (SLOT (AREF FONT-INFO
                                  (+ 14
                                     (AREF PARAM-BASE
                                           (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                            INT))))
         (WHEN (< SHIFT-UP CLR) (SETF SHIFT-UP CLR))
         (SETF CLR
               (+ (SLOT (AREF MEM (+ X 2)) INT)
                  (DIV (ABS (SLOT (AREF FONT-INFO
                                        (+ 5
                                           (AREF PARAM-BASE
                                                 (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                       RH))))
                                  INT))
                       4)))
         (WHEN (< SHIFT-UP CLR) (SETF SHIFT-UP CLR))
         (COND ((= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0)
                (SETF (SLOT (AREF MEM (+ X 4)) INT) (- SHIFT-UP)))
               (TRUE
                (SETF Y (CLEAN-BOX (+ Q 3) (+ (* 2 (DIV CUR-STYLE 4)) 5)))
                (SETF (SLOT (AREF MEM (+ Y 1)) INT)
                      (+ (SLOT (AREF MEM (+ Y 1)) INT) (SLOT (AREF EQTB 9742) INT)))
                (WHEN (< SHIFT-DOWN
                         (SLOT (AREF FONT-INFO
                                     (+ 17
                                        (AREF PARAM-BASE
                                              (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                    RH))))
                               INT))
                  (SETF SHIFT-DOWN
                        (SLOT (AREF FONT-INFO
                                    (+ 17
                                       (AREF PARAM-BASE
                                             (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                   RH))))
                              INT)))
                (SETF CLR
                      (- (* 4
                            (SLOT (AREF FONT-INFO
                                        (+ 8
                                           (AREF PARAM-BASE
                                                 (SLOT (SLOT (AREF EQTB (+ 7838 CUR-SIZE)) HH)
                                                       RH))))
                                  INT))
                         (- (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))
                            (- (SLOT (AREF MEM (+ Y 3)) INT) SHIFT-DOWN))))
                (WHEN (> CLR 0)
                  (INCF SHIFT-DOWN CLR)
                  (SETF CLR
                        (- (DIV (ABS (* (SLOT (AREF FONT-INFO
                                                    (+ 5
                                                       (AREF
                                                        PARAM-BASE
                                                        (SLOT
                                                         (SLOT
                                                          (AREF EQTB (+ 7837 CUR-SIZE))
                                                          HH)
                                                         RH))))
                                              INT)
                                        4))
                                5)
                           (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))))
                  (WHEN (> CLR 0) (INCF SHIFT-UP CLR) (DECF SHIFT-DOWN CLR)))
                (SETF (SLOT (AREF MEM (+ X 4)) INT) DELTA)
                (SETF P
                      (NEW-KERN (- (- SHIFT-UP (SLOT (AREF MEM (+ X 2)) INT))
                                   (- (SLOT (AREF MEM (+ Y 3)) INT) SHIFT-DOWN))))
                (SETF (SLOT (SLOT (AREF MEM X) HH) RH) P)
                (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Y)
                (SETF X (VPACKAGE X 0 1 1073741823))
                (SETF (SLOT (AREF MEM (+ X 4)) INT) SHIFT-DOWN)))))
  (COND ((= (SLOT (AREF MEM (+ Q 1)) INT) 0) (SETF (SLOT (AREF MEM (+ Q 1)) INT) X))
        (TRUE
         (SETF P (SLOT (AREF MEM (+ Q 1)) INT))
         (WHILE (/= (SLOT (SLOT (AREF MEM P) HH) RH) 0)
           (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) X))))

(FUNCTION (MAKE-LEFT-RIGHT SMALL-NUMBER) ((Q HALFWORD) (STYLE SMALL-NUMBER) (MAX-D SCALED)
                                          (MAX-H SCALED))
  (VAR DELTA SCALED)
  (VAR DELTA1 SCALED)
  (VAR DELTA2 SCALED)
  (COND ((< STYLE 4) (SETF CUR-SIZE 0)) (TRUE (SETF CUR-SIZE (* 16 (DIV (- STYLE 2) 2)))))
  (SETF DELTA2
        (+ MAX-D
           (SLOT (AREF FONT-INFO
                       (+ 22
                          (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                 INT)))
  (SETF DELTA1 (- (+ MAX-H MAX-D) DELTA2))
  (WHEN (> DELTA2 DELTA1) (SETF DELTA1 DELTA2))
  (SETF DELTA (* (DIV DELTA1 500) (SLOT (AREF EQTB 9181) INT)))
  (SETF DELTA2 (- (+ DELTA1 DELTA1) (SLOT (AREF EQTB 9740) INT)))
  (WHEN (< DELTA DELTA2) (SETF DELTA DELTA2))
  (SETF (SLOT (AREF MEM (+ Q 1)) INT) (VAR-DELIMITER (+ Q 1) CUR-SIZE DELTA))
  (SETF MAKE-LEFT-RIGHT (- (SLOT (SLOT (AREF MEM Q) HH) B0) 10)))

(PROCEDURE MLIST-TO-HLIST ()
  (LABEL $L.21)
  (LABEL $L.82)
  (LABEL $L.80)
  (LABEL $L.81)
  (LABEL $L.83)
  (LABEL $L.30)
  (VAR MLIST HALFWORD)
  (VAR PENALTIES BOOLEAN)
  (VAR STYLE SMALL-NUMBER)
  (VAR SAVE-STYLE SMALL-NUMBER)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR R-TYPE SMALL-NUMBER)
  (VAR T SMALL-NUMBER)
  (VAR P HALFWORD)
  (VAR X HALFWORD)
  (VAR Y HALFWORD)
  (VAR Z HALFWORD)
  (VAR PEN INTEGER)
  (VAR S SMALL-NUMBER)
  (VAR MAX-H SCALED)
  (VAR MAX-D SCALED)
  (VAR DELTA SCALED)
  (SETF MLIST CUR-MLIST)
  (SETF PENALTIES MLIST-PENALTIES)
  (SETF STYLE CUR-STYLE)
  (SETF Q MLIST)
  (SETF R 0)
  (SETF R-TYPE 17)
  (SETF MAX-H 0)
  (SETF MAX-D 0)
  (COND ((< CUR-STYLE 4) (SETF CUR-SIZE 0))
        (TRUE (SETF CUR-SIZE (* 16 (DIV (- CUR-STYLE 2) 2)))))
  (SETF CUR-MU
        (X-OVER-N (SLOT (AREF FONT-INFO
                              (+ 6
                                 (AREF PARAM-BASE
                                       (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                        INT)
                  18))
  (WHILE (/= Q 0)
    $L.21
    (SETF DELTA 0)
    (CASE (SLOT (SLOT (AREF MEM Q) HH) B0)
      ((18)
       (CASE R-TYPE
         ((18 17 19 20 22 30) (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 16) (GOTO $L.21))
         (ELSE)))
      ((19 21 22 31) (WHEN (= R-TYPE 18) (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 16))
       (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B0) 31) (GOTO $L.80)))
      ((30) (GOTO $L.80))
      ((25) (MAKE-FRACTION Q) (GOTO $L.82))
      ((17) (SETF DELTA (MAKE-OP Q))
       (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B1) 1) (GOTO $L.82)))
      ((16) (MAKE-ORD Q))
      ((20 23))
      ((24) (MAKE-RADICAL Q))
      ((27) (MAKE-OVER Q))
      ((26) (MAKE-UNDER Q))
      ((28) (MAKE-MATH-ACCENT Q))
      ((29) (MAKE-VCENTER Q))
      ((14) (SETF CUR-STYLE (SLOT (SLOT (AREF MEM Q) HH) B1))
       (COND ((< CUR-STYLE 4) (SETF CUR-SIZE 0))
             (TRUE (SETF CUR-SIZE (* 16 (DIV (- CUR-STYLE 2) 2)))))
       (SETF CUR-MU
             (X-OVER-N (SLOT (AREF FONT-INFO
                                   (+ 6
                                      (AREF PARAM-BASE
                                            (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                  RH))))
                             INT)
                       18))
       (GOTO $L.81))
      ((15)
       (CASE (DIV CUR-STYLE 2)
         ((0) (SETF P (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
          (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) 0))
         ((1) (SETF P (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 0))
         ((2) (SETF P (SLOT (SLOT (AREF MEM (+ Q 2)) HH) LH))
          (SETF (SLOT (SLOT (AREF MEM (+ Q 2)) HH) LH) 0))
         ((3) (SETF P (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH) 0)))
       (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
       (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
       (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ Q 2)) HH) LH))
       (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH))
       (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 14)
       (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) CUR-STYLE) (SETF (SLOT (AREF MEM (+ Q 1)) INT) 0)
       (SETF (SLOT (AREF MEM (+ Q 2)) INT) 0)
       (WHEN (/= P 0)
         (SETF Z (SLOT (SLOT (AREF MEM Q) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
         (WHILE (/= (SLOT (SLOT (AREF MEM P) HH) RH) 0)
           (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
         (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Z))
       (GOTO $L.81))
      ((3 4 5 8 12 7) (GOTO $L.81))
      ((2)
       (WHEN (> (SLOT (AREF MEM (+ Q 3)) INT) MAX-H)
         (SETF MAX-H (SLOT (AREF MEM (+ Q 3)) INT)))
       (WHEN (> (SLOT (AREF MEM (+ Q 2)) INT) MAX-D)
         (SETF MAX-D (SLOT (AREF MEM (+ Q 2)) INT)))
       (GOTO $L.81))
      ((10)
       (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B1) 99)
              (SETF X (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
              (SETF Y (MATH-GLUE X CUR-MU))
              (DELETE-GLUE-REF X)
              (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) Y)
              (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0))
             ((AND (/= CUR-SIZE 0) (= (SLOT (SLOT (AREF MEM Q) HH) B1) 98))
              (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
              (WHEN (/= P 0)
                (WHEN (OR (= (SLOT (SLOT (AREF MEM P) HH) B0) 10)
                          (= (SLOT (SLOT (AREF MEM P) HH) B0) 11))
                  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (SLOT (SLOT (AREF MEM P) HH) RH))
                  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
                  (FLUSH-NODE-LIST P)))))
       (GOTO $L.81))
      ((11) (MATH-KERN Q CUR-MU) (GOTO $L.81))
      (ELSE (CONFUSION 889)))
    (CASE (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH)
      ((1 4) (FETCH (+ Q 1))
       (COND ((> (SLOT CUR-I B0) 0)
              (SETF DELTA
                    (SLOT (AREF FONT-INFO
                                (+ (AREF ITALIC-BASE CUR-F) (DIV (- (SLOT CUR-I B2) 0) 4)))
                          INT))
              (SETF P (NEW-CHARACTER CUR-F (- CUR-C 0)))
              (WHEN (AND (= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 4)
                         (/= (SLOT (AREF FONT-INFO (+ 2 (AREF PARAM-BASE CUR-F))) INT) 0))
                (SETF DELTA 0))
              (WHEN (AND (= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0) (/= DELTA 0))
                (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (NEW-KERN DELTA))
                (SETF DELTA 0)))
             (TRUE (SETF P 0))))
      ((0) (SETF P 0))
      ((2) (SETF P (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH)))
      ((3) (SETF CUR-MLIST (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH)) (SETF SAVE-STYLE CUR-STYLE)
       (SETF MLIST-PENALTIES FALSE) (MLIST-TO-HLIST) (SETF CUR-STYLE SAVE-STYLE)
       (COND ((< CUR-STYLE 4) (SETF CUR-SIZE 0))
             (TRUE (SETF CUR-SIZE (* 16 (DIV (- CUR-STYLE 2) 2)))))
       (SETF CUR-MU
             (X-OVER-N (SLOT (AREF FONT-INFO
                                   (+ 6
                                      (AREF PARAM-BASE
                                            (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                  RH))))
                             INT)
                       18))
       (SETF P (HPACK (SLOT (SLOT (AREF MEM 59997) HH) RH) 0 1)))
      (ELSE (CONFUSION 890)))
    (SETF (SLOT (AREF MEM (+ Q 1)) INT) P)
    (WHEN (AND (= (SLOT (SLOT (AREF MEM (+ Q 3)) HH) RH) 0)
               (= (SLOT (SLOT (AREF MEM (+ Q 2)) HH) RH) 0))
      (GOTO $L.82))
    (MAKE-SCRIPTS Q DELTA)
    $L.82
    (SETF Z (HPACK (SLOT (AREF MEM (+ Q 1)) INT) 0 1))
    (WHEN (> (SLOT (AREF MEM (+ Z 3)) INT) MAX-H) (SETF MAX-H (SLOT (AREF MEM (+ Z 3)) INT)))
    (WHEN (> (SLOT (AREF MEM (+ Z 2)) INT) MAX-D) (SETF MAX-D (SLOT (AREF MEM (+ Z 2)) INT)))
    (FREE-NODE Z 7)
    $L.80
    (SETF R Q)
    (SETF R-TYPE (SLOT (SLOT (AREF MEM R) HH) B0))
    $L.81
    (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))
  (WHEN (= R-TYPE 18) (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 16))
  (SETF P 59997)
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
  (SETF Q MLIST)
  (SETF R-TYPE 0)
  (SETF CUR-STYLE STYLE)
  (COND ((< CUR-STYLE 4) (SETF CUR-SIZE 0))
        (TRUE (SETF CUR-SIZE (* 16 (DIV (- CUR-STYLE 2) 2)))))
  (SETF CUR-MU
        (X-OVER-N (SLOT (AREF FONT-INFO
                              (+ 6
                                 (AREF PARAM-BASE
                                       (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH) RH))))
                        INT)
                  18))
  (WHILE (/= Q 0)
    (SETF T 16)
    (SETF S 4)
    (SETF PEN 10000)
    (CASE (SLOT (SLOT (AREF MEM Q) HH) B0)
      ((17 20 21 22 23) (SETF T (SLOT (SLOT (AREF MEM Q) HH) B0)))
      ((18) (SETF T 18) (SETF PEN (SLOT (AREF EQTB 9172) INT)))
      ((19) (SETF T 19) (SETF PEN (SLOT (AREF EQTB 9173) INT)))
      ((16 29 27 26))
      ((24) (SETF S 5))
      ((28) (SETF S 5))
      ((25) (SETF S 6))
      ((30 31) (SETF T (MAKE-LEFT-RIGHT Q STYLE MAX-D MAX-H)))
      ((14) (SETF CUR-STYLE (SLOT (SLOT (AREF MEM Q) HH) B1)) (SETF S 3)
       (COND ((< CUR-STYLE 4) (SETF CUR-SIZE 0))
             (TRUE (SETF CUR-SIZE (* 16 (DIV (- CUR-STYLE 2) 2)))))
       (SETF CUR-MU
             (X-OVER-N (SLOT (AREF FONT-INFO
                                   (+ 6
                                      (AREF PARAM-BASE
                                            (SLOT (SLOT (AREF EQTB (+ 7837 CUR-SIZE)) HH)
                                                  RH))))
                             INT)
                       18))
       (GOTO $L.83))
      ((8 12 2 7 5 3 4 10 11) (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Q) (SETF P Q)
       (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)) (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
       (GOTO $L.30))
      (ELSE (CONFUSION 891)))
    (WHEN (> R-TYPE 0)
      (CASE (AREF STR-POOL (+ (+ (* R-TYPE 8) T) MAGIC-OFFSET))
        ((48) (SETF X 0))
        ((49) (COND ((< CUR-STYLE 4) (SETF X 15)) (TRUE (SETF X 0))))
        ((50) (SETF X 15))
        ((51) (COND ((< CUR-STYLE 4) (SETF X 16)) (TRUE (SETF X 0))))
        ((52) (COND ((< CUR-STYLE 4) (SETF X 17)) (TRUE (SETF X 0))))
        (ELSE (CONFUSION 893)))
      (WHEN (/= X 0)
        (SETF Y (MATH-GLUE (SLOT (SLOT (AREF EQTB (+ 6782 X)) HH) RH) CUR-MU))
        (SETF Z (NEW-GLUE Y))
        (SETF (SLOT (SLOT (AREF MEM Y) HH) RH) 0)
        (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Z)
        (SETF P Z)
        (SETF (SLOT (SLOT (AREF MEM Z) HH) B1) (+ X 1))))
    (WHEN (/= (SLOT (AREF MEM (+ Q 1)) INT) 0)
      (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (SLOT (AREF MEM (+ Q 1)) INT))
      (REPEAT (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
              (UNTIL (= (SLOT (SLOT (AREF MEM P) HH) RH) 0))))
    (WHEN PENALTIES
      (WHEN (/= (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
        (WHEN (< PEN 10000)
          (SETF R-TYPE (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) RH)) HH) B0))
          (WHEN (/= R-TYPE 12)
            (WHEN (/= R-TYPE 19)
              (SETF Z (NEW-PENALTY PEN))
              (SETF (SLOT (SLOT (AREF MEM P) HH) RH) Z)
              (SETF P Z))))))
    (SETF R-TYPE T)
    $L.83
    (SETF R Q)
    (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
    (FREE-NODE R S)
    $L.30))

(PROCEDURE PUSH-ALIGNMENT ()
  (VAR P HALFWORD)
  (SETF P (GET-NODE 5))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) ALIGN-PTR)
  (SETF (SLOT (SLOT (AREF MEM P) HH) LH) CUR-ALIGN)
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) (SLOT (SLOT (AREF MEM 59992) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) CUR-SPAN)
  (SETF (SLOT (AREF MEM (+ P 2)) INT) CUR-LOOP)
  (SETF (SLOT (AREF MEM (+ P 3)) INT) ALIGN-STATE)
  (SETF (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH) CUR-HEAD)
  (SETF (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH) CUR-TAIL)
  (SETF ALIGN-PTR P)
  (SETF CUR-HEAD GET-AVAIL))

(PROCEDURE POP-ALIGNMENT ()
  (VAR P HALFWORD)
  (SETF (SLOT (SLOT (AREF MEM CUR-HEAD) HH) RH) AVAIL)
  (SETF AVAIL CUR-HEAD)
  (SETF P ALIGN-PTR)
  (SETF CUR-TAIL (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH))
  (SETF CUR-HEAD (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH))
  (SETF ALIGN-STATE (SLOT (AREF MEM (+ P 3)) INT))
  (SETF CUR-LOOP (SLOT (AREF MEM (+ P 2)) INT))
  (SETF CUR-SPAN (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM 59992) HH) RH) (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
  (SETF CUR-ALIGN (SLOT (SLOT (AREF MEM P) HH) LH))
  (SETF ALIGN-PTR (SLOT (SLOT (AREF MEM P) HH) RH))
  (FREE-NODE P 5))

(PROCEDURE GET-PREAMBLE-TOKEN ()
  (LABEL $L.20)
  $L.20
  (GET-TOKEN)
  (WHILE (AND (= CUR-CHR 256) (= CUR-CMD 4))
    (GET-TOKEN)
    (WHEN (> CUR-CMD 100) (EXPAND) (GET-TOKEN)))
  (WHEN (= CUR-CMD 9) (FATAL-ERROR 595))
  (WHEN (AND (= CUR-CMD 75) (= CUR-CHR 6793))
    (SCAN-OPTIONAL-EQUALS)
    (SCAN-GLUE 2)
    (COND ((> (SLOT (AREF EQTB 9206) INT) 0) (GEQ-DEFINE 6793 117 CUR-VAL))
          (TRUE (EQ-DEFINE 6793 117 CUR-VAL)))
    (GOTO $L.20)))

(PROCEDURE ALIGN-PEEK () :FORWARD)

(PROCEDURE NORMAL-PARAGRAPH () :FORWARD)

(PROCEDURE INIT-ALIGN ()
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.32)
  (LABEL $L.22)
  (VAR SAVE-CS-PTR HALFWORD)
  (VAR P HALFWORD)
  (SETF SAVE-CS-PTR CUR-CS)
  (PUSH-ALIGNMENT)
  (SETF ALIGN-STATE (- 1000000))
  (WHEN (AND (= (SLOT CUR-LIST MODE-FIELD) 203)
             (OR (/= (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
                 (/= (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 0)))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 680)
    (PRINT-ESC 520)
    (PRINT 894)
    (SETF HELP-PTR 3)
    (SETF (AREF HELP-LINE 2) 895)
    (SETF (AREF HELP-LINE 1) 896)
    (SETF (AREF HELP-LINE 0) 897)
    (ERROR)
    (FLUSH-MATH))
  (PUSH-NEST)
  (COND ((= (SLOT CUR-LIST MODE-FIELD) 203)
         (SETF (SLOT CUR-LIST MODE-FIELD) (- 1))
         (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT)
               (SLOT (SLOT (AREF NEST (- NEST-PTR 2)) AUX-FIELD) INT)))
        ((> (SLOT CUR-LIST MODE-FIELD) 0)
         (SETF (SLOT CUR-LIST MODE-FIELD) (- (SLOT CUR-LIST MODE-FIELD)))))
  (SCAN-SPEC 6 FALSE)
  (SETF (SLOT (SLOT (AREF MEM 59992) HH) RH) 0)
  (SETF CUR-ALIGN 59992)
  (SETF CUR-LOOP 0)
  (SETF SCANNER-STATUS 4)
  (SETF WARNING-INDEX SAVE-CS-PTR)
  (SETF ALIGN-STATE (- 1000000))
  (WHILE TRUE
    (SETF (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) RH) (NEW-PARAM-GLUE 11))
    (SETF CUR-ALIGN (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) RH))
    (WHEN (= CUR-CMD 5) (GOTO $L.30))
    (SETF P 59996)
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
    (WHILE TRUE
      (GET-PREAMBLE-TOKEN)
      (WHEN (= CUR-CMD 6) (GOTO $L.31))
      (COND ((AND (AND (<= CUR-CMD 5) (>= CUR-CMD 4)) (= ALIGN-STATE (- 1000000)))
             (COND ((AND (AND (= P 59996) (= CUR-LOOP 0)) (= CUR-CMD 4))
                    (SETF CUR-LOOP CUR-ALIGN))
                   (TRUE
                    (WHEN (= INTERACTION 3))
                    (PRINT-NL 262)
                    (PRINT 903)
                    (SETF HELP-PTR 3)
                    (SETF (AREF HELP-LINE 2) 904)
                    (SETF (AREF HELP-LINE 1) 905)
                    (SETF (AREF HELP-LINE 0) 906)
                    (BACK-ERROR)
                    (GOTO $L.31))))
            ((OR (/= CUR-CMD 10) (/= P 59996))
             (SETF (SLOT (SLOT (AREF MEM P) HH) RH) GET-AVAIL)
             (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
             (SETF (SLOT (SLOT (AREF MEM P) HH) LH) CUR-TOK))))
    $L.31
    (SETF (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) RH) NEW-NULL-BOX)
    (SETF CUR-ALIGN (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) LH) 59991)
    (SETF (SLOT (AREF MEM (+ CUR-ALIGN 1)) INT) (- 1073741824))
    (SETF (SLOT (AREF MEM (+ CUR-ALIGN 3)) INT) (SLOT (SLOT (AREF MEM 59996) HH) RH))
    (SETF P 59996)
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
    (WHILE TRUE
      $L.22
      (GET-PREAMBLE-TOKEN)
      (WHEN (AND (AND (<= CUR-CMD 5) (>= CUR-CMD 4)) (= ALIGN-STATE (- 1000000))) (GOTO $L.32))
      (WHEN (= CUR-CMD 6)
        (WHEN (= INTERACTION 3))
        (PRINT-NL 262)
        (PRINT 907)
        (SETF HELP-PTR 3)
        (SETF (AREF HELP-LINE 2) 904)
        (SETF (AREF HELP-LINE 1) 905)
        (SETF (AREF HELP-LINE 0) 908)
        (ERROR)
        (GOTO $L.22))
      (SETF (SLOT (SLOT (AREF MEM P) HH) RH) GET-AVAIL)
      (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
      (SETF (SLOT (SLOT (AREF MEM P) HH) LH) CUR-TOK))
    $L.32
    (SETF (SLOT (SLOT (AREF MEM P) HH) RH) GET-AVAIL)
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 10614)
    (SETF (SLOT (AREF MEM (+ CUR-ALIGN 2)) INT) (SLOT (SLOT (AREF MEM 59996) HH) RH)))
  $L.30
  (SETF SCANNER-STATUS 0)
  (NEW-SAVE-LEVEL 6)
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7320) HH) RH) 0)
    (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7320) HH) RH) 13))
  (ALIGN-PEEK))

(PROCEDURE INIT-SPAN ((P HALFWORD))
  (PUSH-NEST)
  (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 102))
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
        (TRUE (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000)) (NORMAL-PARAGRAPH)))
  (SETF CUR-SPAN P))

(PROCEDURE INIT-ROW ()
  (PUSH-NEST)
  (SETF (SLOT CUR-LIST MODE-FIELD) (- (- 103) (SLOT CUR-LIST MODE-FIELD)))
  (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 102))
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 0))
        (TRUE (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 0)))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
        (NEW-GLUE (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM 59992) HH) RH) 1)) HH) LH)))
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 12)
  (SETF CUR-ALIGN (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM 59992) HH) RH)) HH) RH))
  (SETF CUR-TAIL CUR-HEAD)
  (INIT-SPAN CUR-ALIGN))

(PROCEDURE INIT-COL ()
  (SETF (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH) CUR-CMD)
  (COND ((= CUR-CMD 63) (SETF ALIGN-STATE 0))
        (TRUE (BACK-INPUT) (BEGIN-TOKEN-LIST (SLOT (AREF MEM (+ CUR-ALIGN 3)) INT) 1))))

(FUNCTION (FIN-COL BOOLEAN) ()
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR U HALFWORD)
  (VAR W SCALED)
  (VAR O GLUE-ORD)
  (VAR N HALFWORD)
  (WHEN (= CUR-ALIGN 0) (CONFUSION 909))
  (SETF Q (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) RH))
  (WHEN (= Q 0) (CONFUSION 909))
  (WHEN (< ALIGN-STATE 500000) (FATAL-ERROR 595))
  (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
  (WHEN (AND (= P 0) (< (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH) 257))
    (COND ((/= CUR-LOOP 0)
           (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) NEW-NULL-BOX)
           (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 59991)
           (SETF (SLOT (AREF MEM (+ P 1)) INT) (- 1073741824))
           (SETF CUR-LOOP (SLOT (SLOT (AREF MEM CUR-LOOP) HH) RH))
           (SETF Q 59996)
           (SETF R (SLOT (AREF MEM (+ CUR-LOOP 3)) INT))
           (WHILE (/= R 0)
             (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) GET-AVAIL)
             (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
             (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (SLOT (SLOT (AREF MEM R) HH) LH))
             (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)))
           (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
           (SETF (SLOT (AREF MEM (+ P 3)) INT) (SLOT (SLOT (AREF MEM 59996) HH) RH))
           (SETF Q 59996)
           (SETF R (SLOT (AREF MEM (+ CUR-LOOP 2)) INT))
           (WHILE (/= R 0)
             (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) GET-AVAIL)
             (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
             (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (SLOT (SLOT (AREF MEM R) HH) LH))
             (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)))
           (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
           (SETF (SLOT (AREF MEM (+ P 2)) INT) (SLOT (SLOT (AREF MEM 59996) HH) RH))
           (SETF CUR-LOOP (SLOT (SLOT (AREF MEM CUR-LOOP) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH)
                 (NEW-GLUE (SLOT (SLOT (AREF MEM (+ CUR-LOOP 1)) HH) LH)))
           (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM P) HH) RH)) HH) B1) 12))
          (TRUE
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 910)
           (PRINT-ESC 899)
           (SETF HELP-PTR 3)
           (SETF (AREF HELP-LINE 2) 911)
           (SETF (AREF HELP-LINE 1) 912)
           (SETF (AREF HELP-LINE 0) 913)
           (SETF (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH) 257)
           (ERROR))))
  (WHEN (/= (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH) 256)
    (UNSAVE)
    (NEW-SAVE-LEVEL 6)
    (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 102))
           (SETF ADJUST-TAIL CUR-TAIL)
           (SETF U (HPACK (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) 0 1))
           (SETF W (SLOT (AREF MEM (+ U 1)) INT))
           (SETF CUR-TAIL ADJUST-TAIL)
           (SETF ADJUST-TAIL 0))
          (TRUE
           (SETF U (VPACKAGE (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) 0 1 0))
           (SETF W (SLOT (AREF MEM (+ U 3)) INT))))
    (SETF N 0)
    (COND ((/= CUR-SPAN CUR-ALIGN)
           (SETF Q CUR-SPAN)
           (REPEAT (INCF N 1)
                   (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) RH)) HH) RH))
                   (UNTIL (= Q CUR-ALIGN)))
           (WHEN (> N 255) (CONFUSION 914))
           (SETF Q CUR-SPAN)
           (WHILE (< (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) LH)) HH) RH) N)
             (SETF Q (SLOT (SLOT (AREF MEM Q) HH) LH)))
           (COND ((> (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) LH)) HH) RH) N)
                  (SETF S (GET-NODE 2))
                  (SETF (SLOT (SLOT (AREF MEM S) HH) LH) (SLOT (SLOT (AREF MEM Q) HH) LH))
                  (SETF (SLOT (SLOT (AREF MEM S) HH) RH) N)
                  (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) S)
                  (SETF (SLOT (AREF MEM (+ S 1)) INT) W))
                 ((< (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM Q) HH) LH) 1)) INT) W)
                  (SETF (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM Q) HH) LH) 1)) INT) W))))
          ((> W (SLOT (AREF MEM (+ CUR-ALIGN 1)) INT))
           (SETF (SLOT (AREF MEM (+ CUR-ALIGN 1)) INT) W)))
    (SETF (SLOT (SLOT (AREF MEM U) HH) B0) 13)
    (SETF (SLOT (SLOT (AREF MEM U) HH) B1) N)
    (COND ((/= (AREF TOTAL-STRETCH 3) 0) (SETF O 3))
          ((/= (AREF TOTAL-STRETCH 2) 0) (SETF O 2))
          ((/= (AREF TOTAL-STRETCH 1) 0) (SETF O 1))
          (TRUE (SETF O 0)))
    (SETF (SLOT (SLOT (AREF MEM (+ U 5)) HH) B1) O)
    (SETF (SLOT (AREF MEM (+ U 6)) INT) (AREF TOTAL-STRETCH O))
    (COND ((/= (AREF TOTAL-SHRINK 3) 0) (SETF O 3))
          ((/= (AREF TOTAL-SHRINK 2) 0) (SETF O 2))
          ((/= (AREF TOTAL-SHRINK 1) 0) (SETF O 1))
          (TRUE (SETF O 0)))
    (SETF (SLOT (SLOT (AREF MEM (+ U 5)) HH) B0) O)
    (SETF (SLOT (AREF MEM (+ U 4)) INT) (AREF TOTAL-SHRINK O))
    (POP-NEST)
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) U)
    (SETF (SLOT CUR-LIST TAIL-FIELD) U)
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
          (NEW-GLUE (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM CUR-ALIGN) HH) RH) 1)) HH)
                          LH)))
    (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 12)
    (WHEN (>= (SLOT (SLOT (AREF MEM (+ CUR-ALIGN 5)) HH) LH) 257)
      (SETF FIN-COL TRUE)
      (GOTO $L.10))
    (INIT-SPAN P))
  (SETF ALIGN-STATE 1000000)
  (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
  (SETF CUR-ALIGN P)
  (INIT-COL)
  (SETF FIN-COL FALSE)
  $L.10)

(PROCEDURE FIN-ROW ()
  (VAR P HALFWORD)
  (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 102))
         (SETF P (HPACK (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) 0 1))
         (POP-NEST)
         (APPEND-TO-VLIST P)
         (WHEN (/= CUR-HEAD CUR-TAIL)
           (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
                 (SLOT (SLOT (AREF MEM CUR-HEAD) HH) RH))
           (SETF (SLOT CUR-LIST TAIL-FIELD) CUR-TAIL)))
        (TRUE
         (SETF P
               (VPACKAGE (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH)
                         0
                         1
                         1073741823))
         (POP-NEST)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
         (SETF (SLOT CUR-LIST TAIL-FIELD) P)
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 13)
  (SETF (SLOT (AREF MEM (+ P 6)) INT) 0)
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7320) HH) RH) 0)
    (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7320) HH) RH) 13))
  (ALIGN-PEEK))

(PROCEDURE DO-ASSIGNMENTS () :FORWARD)

(PROCEDURE RESUME-AFTER-DISPLAY () :FORWARD)

(PROCEDURE BUILD-PAGE () :FORWARD)

(PROCEDURE FIN-ALIGN ()
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR U HALFWORD)
  (VAR V HALFWORD)
  (VAR T SCALED)
  (VAR W SCALED)
  (VAR O SCALED)
  (VAR N HALFWORD)
  (VAR RULE-SAVE SCALED)
  (VAR AUX-SAVE MEMORY-WORD)
  (WHEN (/= CUR-GROUP 6) (CONFUSION 915))
  (UNSAVE)
  (WHEN (/= CUR-GROUP 6) (CONFUSION 916))
  (UNSAVE)
  (COND ((= (SLOT (AREF NEST (- NEST-PTR 1)) MODE-FIELD) 203)
         (SETF O (SLOT (AREF EQTB 9745) INT)))
        (TRUE (SETF O 0)))
  (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM 59992) HH) RH)) HH) RH))
  (REPEAT (FLUSH-LIST (SLOT (AREF MEM (+ Q 3)) INT))
          (FLUSH-LIST (SLOT (AREF MEM (+ Q 2)) INT))
          (SETF P (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) RH)) HH) RH))
          (WHEN (= (SLOT (AREF MEM (+ Q 1)) INT) (- 1073741824))
            (SETF (SLOT (AREF MEM (+ Q 1)) INT) 0)
            (SETF R (SLOT (SLOT (AREF MEM Q) HH) RH))
            (SETF S (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH))
            (WHEN (/= S 0)
              (SETF (SLOT (SLOT (AREF MEM 0) HH) RH) (+ (SLOT (SLOT (AREF MEM 0) HH) RH) 1))
              (DELETE-GLUE-REF S)
              (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH) 0)))
          (WHEN (/= (SLOT (SLOT (AREF MEM Q) HH) LH) 59991)
            (SETF T
                  (+ (SLOT (AREF MEM (+ Q 1)) INT)
                     (SLOT (AREF MEM
                                 (+ (SLOT (SLOT (AREF MEM
                                                      (+ (SLOT (SLOT (AREF MEM Q) HH) RH) 1))
                                                HH)
                                          LH)
                                    1))
                           INT)))
            (SETF R (SLOT (SLOT (AREF MEM Q) HH) LH))
            (SETF S 59991)
            (SETF (SLOT (SLOT (AREF MEM S) HH) LH) P)
            (SETF N 1)
            (REPEAT (SETF (SLOT (AREF MEM (+ R 1)) INT) (- (SLOT (AREF MEM (+ R 1)) INT) T))
                    (SETF U (SLOT (SLOT (AREF MEM R) HH) LH))
                    (WHILE (> (SLOT (SLOT (AREF MEM R) HH) RH) N)
                      (SETF S (SLOT (SLOT (AREF MEM S) HH) LH))
                      (SETF N
                            (+ (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM S) HH) LH)) HH) RH)
                               1)))
                    (COND ((< (SLOT (SLOT (AREF MEM R) HH) RH) N)
                           (SETF (SLOT (SLOT (AREF MEM R) HH) LH)
                                 (SLOT (SLOT (AREF MEM S) HH) LH))
                           (SETF (SLOT (SLOT (AREF MEM S) HH) LH) R)
                           (SETF (SLOT (SLOT (AREF MEM R) HH) RH)
                                 (- (SLOT (SLOT (AREF MEM R) HH) RH) 1))
                           (SETF S R))
                          (TRUE
                           (WHEN (> (SLOT (AREF MEM (+ R 1)) INT)
                                    (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM S) HH) LH) 1))
                                          INT))
                             (SETF (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM S) HH) LH) 1)) INT)
                                   (SLOT (AREF MEM (+ R 1)) INT)))
                           (FREE-NODE R 2)))
                    (SETF R U)
                    (UNTIL (= R 59991))))
          (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 13)
          (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
          (SETF (SLOT (AREF MEM (+ Q 3)) INT) 0)
          (SETF (SLOT (AREF MEM (+ Q 2)) INT) 0)
          (SETF (SLOT (SLOT (AREF MEM (+ Q 5)) HH) B1) 0)
          (SETF (SLOT (SLOT (AREF MEM (+ Q 5)) HH) B0) 0)
          (SETF (SLOT (AREF MEM (+ Q 6)) INT) 0)
          (SETF (SLOT (AREF MEM (+ Q 4)) INT) 0)
          (SETF Q P)
          (UNTIL (= Q 0)))
  (DECF SAVE-PTR 2)
  (SETF PACK-BEGIN-LINE (- (SLOT CUR-LIST ML-FIELD)))
  (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 1))
         (SETF RULE-SAVE (SLOT (AREF EQTB 9746) INT))
         (SETF (SLOT (AREF EQTB 9746) INT) 0)
         (SETF P
               (HPACK (SLOT (SLOT (AREF MEM 59992) HH) RH)
                      (SLOT (AREF SAVE-STACK (+ SAVE-PTR 1)) INT)
                      (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)))
         (SETF (SLOT (AREF EQTB 9746) INT) RULE-SAVE))
        (TRUE
         (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM 59992) HH) RH)) HH) RH))
         (REPEAT (SETF (SLOT (AREF MEM (+ Q 3)) INT) (SLOT (AREF MEM (+ Q 1)) INT))
                 (SETF (SLOT (AREF MEM (+ Q 1)) INT) 0)
                 (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) RH)) HH) RH))
                 (UNTIL (= Q 0)))
         (SETF P
               (VPACKAGE (SLOT (SLOT (AREF MEM 59992) HH) RH)
                         (SLOT (AREF SAVE-STACK (+ SAVE-PTR 1)) INT)
                         (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)
                         1073741823))
         (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM 59992) HH) RH)) HH) RH))
         (REPEAT (SETF (SLOT (AREF MEM (+ Q 1)) INT) (SLOT (AREF MEM (+ Q 3)) INT))
                 (SETF (SLOT (AREF MEM (+ Q 3)) INT) 0)
                 (SETF Q (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM Q) HH) RH)) HH) RH))
                 (UNTIL (= Q 0)))))
  (SETF PACK-BEGIN-LINE 0)
  (SETF Q (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
  (SETF S (SLOT CUR-LIST HEAD-FIELD))
  (WHILE (/= Q 0)
    (UNLESS (>= Q HI-MEM-MIN)
      (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 13)
             (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 1))
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 0)
                    (SETF (SLOT (AREF MEM (+ Q 1)) INT) (SLOT (AREF MEM (+ P 1)) INT)))
                   (TRUE
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 1)
                    (SETF (SLOT (AREF MEM (+ Q 3)) INT) (SLOT (AREF MEM (+ P 3)) INT))))
             (SETF (SLOT (SLOT (AREF MEM (+ Q 5)) HH) B1)
                   (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1))
             (SETF (SLOT (SLOT (AREF MEM (+ Q 5)) HH) B0)
                   (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0))
             (SETF (SLOT (AREF MEM (+ Q 6)) GR) (SLOT (AREF MEM (+ P 6)) GR))
             (SETF (SLOT (AREF MEM (+ Q 4)) INT) O)
             (SETF R (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ Q 5)) HH) RH)) HH) RH))
             (SETF S (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH)) HH) RH))
             (REPEAT (SETF N (SLOT (SLOT (AREF MEM R) HH) B1))
                     (SETF T (SLOT (AREF MEM (+ S 1)) INT))
                     (SETF W T)
                     (SETF U 59996)
                     (WHILE (> N 0)
                       (DECF N 1)
                       (SETF S (SLOT (SLOT (AREF MEM S) HH) RH))
                       (SETF V (SLOT (SLOT (AREF MEM (+ S 1)) HH) LH))
                       (SETF (SLOT (SLOT (AREF MEM U) HH) RH) (NEW-GLUE V))
                       (SETF U (SLOT (SLOT (AREF MEM U) HH) RH))
                       (SETF (SLOT (SLOT (AREF MEM U) HH) B1) 12)
                       (INCF T (SLOT (AREF MEM (+ V 1)) INT))
                       (COND ((= (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0) 1)
                              (WHEN (= (SLOT (SLOT (AREF MEM V) HH) B0)
                                       (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1))
                                (INCF T
                                 (ROUND (* (SLOT (AREF MEM (+ P 6)) GR)
                                           (SLOT (AREF MEM (+ V 2)) INT))))))
                             ((= (SLOT (SLOT (AREF MEM (+ P 5)) HH) B0) 2)
                              (WHEN (= (SLOT (SLOT (AREF MEM V) HH) B1)
                                       (SLOT (SLOT (AREF MEM (+ P 5)) HH) B1))
                                (DECF T
                                 (ROUND (* (SLOT (AREF MEM (+ P 6)) GR)
                                           (SLOT (AREF MEM (+ V 3)) INT)))))))
                       (SETF S (SLOT (SLOT (AREF MEM S) HH) RH))
                       (SETF (SLOT (SLOT (AREF MEM U) HH) RH) NEW-NULL-BOX)
                       (SETF U (SLOT (SLOT (AREF MEM U) HH) RH))
                       (INCF T (SLOT (AREF MEM (+ S 1)) INT))
                       (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 1))
                              (SETF (SLOT (AREF MEM (+ U 1)) INT)
                                    (SLOT (AREF MEM (+ S 1)) INT)))
                             (TRUE
                              (SETF (SLOT (SLOT (AREF MEM U) HH) B0) 1)
                              (SETF (SLOT (AREF MEM (+ U 3)) INT)
                                    (SLOT (AREF MEM (+ S 1)) INT)))))
                     (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 1))
                            (SETF (SLOT (AREF MEM (+ R 3)) INT) (SLOT (AREF MEM (+ Q 3)) INT))
                            (SETF (SLOT (AREF MEM (+ R 2)) INT) (SLOT (AREF MEM (+ Q 2)) INT))
                            (COND ((= T (SLOT (AREF MEM (+ R 1)) INT))
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) 0)
                                   (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0))
                                  ((> T (SLOT (AREF MEM (+ R 1)) INT))
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 1)
                                   (COND ((= (SLOT (AREF MEM (+ R 6)) INT) 0)
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0))
                                         (TRUE
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR)
                                                (/ (- T (SLOT (AREF MEM (+ R 1)) INT))
                                                   (SLOT (AREF MEM (+ R 6)) INT))))))
                                  (TRUE
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1)
                                         (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0))
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 2)
                                   (COND ((= (SLOT (AREF MEM (+ R 4)) INT) 0)
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0))
                                         ((AND (= (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) 0)
                                               (> (- (SLOT (AREF MEM (+ R 1)) INT) T)
                                                  (SLOT (AREF MEM (+ R 4)) INT)))
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR) 1.0))
                                         (TRUE
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR)
                                                (/ (- (SLOT (AREF MEM (+ R 1)) INT) T)
                                                   (SLOT (AREF MEM (+ R 4)) INT)))))))
                            (SETF (SLOT (AREF MEM (+ R 1)) INT) W)
                            (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 0))
                           (TRUE
                            (SETF (SLOT (AREF MEM (+ R 1)) INT) (SLOT (AREF MEM (+ Q 1)) INT))
                            (COND ((= T (SLOT (AREF MEM (+ R 3)) INT))
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 0)
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) 0)
                                   (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0))
                                  ((> T (SLOT (AREF MEM (+ R 3)) INT))
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 1)
                                   (COND ((= (SLOT (AREF MEM (+ R 6)) INT) 0)
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0))
                                         (TRUE
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR)
                                                (/ (- T (SLOT (AREF MEM (+ R 3)) INT))
                                                   (SLOT (AREF MEM (+ R 6)) INT))))))
                                  (TRUE
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1)
                                         (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0))
                                   (SETF (SLOT (SLOT (AREF MEM (+ R 5)) HH) B0) 2)
                                   (COND ((= (SLOT (AREF MEM (+ R 4)) INT) 0)
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR) 0.0))
                                         ((AND (= (SLOT (SLOT (AREF MEM (+ R 5)) HH) B1) 0)
                                               (> (- (SLOT (AREF MEM (+ R 3)) INT) T)
                                                  (SLOT (AREF MEM (+ R 4)) INT)))
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR) 1.0))
                                         (TRUE
                                          (SETF (SLOT (AREF MEM (+ R 6)) GR)
                                                (/ (- (SLOT (AREF MEM (+ R 3)) INT) T)
                                                   (SLOT (AREF MEM (+ R 4)) INT)))))))
                            (SETF (SLOT (AREF MEM (+ R 3)) INT) W)
                            (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 1)))
                     (SETF (SLOT (AREF MEM (+ R 4)) INT) 0)
                     (WHEN (/= U 59996)
                       (SETF (SLOT (SLOT (AREF MEM U) HH) RH) (SLOT (SLOT (AREF MEM R) HH) RH))
                       (SETF (SLOT (SLOT (AREF MEM R) HH) RH)
                             (SLOT (SLOT (AREF MEM 59996) HH) RH))
                       (SETF R U))
                     (SETF R (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM R) HH) RH)) HH) RH))
                     (SETF S (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM S) HH) RH)) HH) RH))
                     (UNTIL (= R 0))))
            ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 2)
             (WHEN (= (SLOT (AREF MEM (+ Q 1)) INT) (- 1073741824))
               (SETF (SLOT (AREF MEM (+ Q 1)) INT) (SLOT (AREF MEM (+ P 1)) INT)))
             (WHEN (= (SLOT (AREF MEM (+ Q 3)) INT) (- 1073741824))
               (SETF (SLOT (AREF MEM (+ Q 3)) INT) (SLOT (AREF MEM (+ P 3)) INT)))
             (WHEN (= (SLOT (AREF MEM (+ Q 2)) INT) (- 1073741824))
               (SETF (SLOT (AREF MEM (+ Q 2)) INT) (SLOT (AREF MEM (+ P 2)) INT)))
             (WHEN (/= O 0)
               (SETF R (SLOT (SLOT (AREF MEM Q) HH) RH))
               (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
               (SETF Q (HPACK Q 0 1))
               (SETF (SLOT (AREF MEM (+ Q 4)) INT) O)
               (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
               (SETF (SLOT (SLOT (AREF MEM S) HH) RH) Q)))))
    (SETF S Q)
    (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))
  (FLUSH-NODE-LIST P)
  (POP-ALIGNMENT)
  (SETF AUX-SAVE (SLOT CUR-LIST AUX-FIELD))
  (SETF P (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
  (SETF Q (SLOT CUR-LIST TAIL-FIELD))
  (POP-NEST)
  (COND ((= (SLOT CUR-LIST MODE-FIELD) 203)
         (DO-ASSIGNMENTS)
         (COND ((/= CUR-CMD 3)
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 1170)
                (SETF HELP-PTR 2)
                (SETF (AREF HELP-LINE 1) 895)
                (SETF (AREF HELP-LINE 0) 896)
                (BACK-ERROR))
               (TRUE
                (GET-X-TOKEN)
                (WHEN (/= CUR-CMD 3)
                  (WHEN (= INTERACTION 3))
                  (PRINT-NL 262)
                  (PRINT 1166)
                  (SETF HELP-PTR 2)
                  (SETF (AREF HELP-LINE 1) 1167)
                  (SETF (AREF HELP-LINE 0) 1168)
                  (BACK-ERROR))))
         (POP-NEST)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (NEW-PENALTY (SLOT (AREF EQTB 9174) INT)))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PARAM-GLUE 3))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
         (WHEN (/= P 0) (SETF (SLOT CUR-LIST TAIL-FIELD) Q))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (NEW-PENALTY (SLOT (AREF EQTB 9175) INT)))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PARAM-GLUE 4))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (SLOT AUX-SAVE INT))
         (RESUME-AFTER-DISPLAY))
        (TRUE
         (SETF (SLOT CUR-LIST AUX-FIELD) AUX-SAVE)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
         (WHEN (/= P 0) (SETF (SLOT CUR-LIST TAIL-FIELD) Q))
         (WHEN (= (SLOT CUR-LIST MODE-FIELD) 1) (BUILD-PAGE)))))

(PROCEDURE ALIGN-PEEK ()
  (LABEL $L.20)
  $L.20
  (SETF ALIGN-STATE 1000000)
  (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10)))
  (COND ((= CUR-CMD 34)
         (SCAN-LEFT-BRACE)
         (NEW-SAVE-LEVEL 7)
         (WHEN (= (SLOT CUR-LIST MODE-FIELD) (- 1)) (NORMAL-PARAGRAPH)))
        ((= CUR-CMD 2) (FIN-ALIGN))
        ((AND (= CUR-CMD 5) (= CUR-CHR 258)) (GOTO $L.20))
        (TRUE (INIT-ROW) (INIT-COL))))

(FUNCTION (FINITE-SHRINK HALFWORD) ((P HALFWORD))
  (VAR Q HALFWORD)
  (WHEN NO-SHRINK-ERROR-YET
    (SETF NO-SHRINK-ERROR-YET FALSE)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 917)
    (SETF HELP-PTR 5)
    (SETF (AREF HELP-LINE 4) 918)
    (SETF (AREF HELP-LINE 3) 919)
    (SETF (AREF HELP-LINE 2) 920)
    (SETF (AREF HELP-LINE 1) 921)
    (SETF (AREF HELP-LINE 0) 922)
    (ERROR))
  (SETF Q (NEW-SPEC P))
  (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
  (DELETE-GLUE-REF P)
  (SETF FINITE-SHRINK Q))

(PROCEDURE TRY-BREAK ((PI INTEGER) (BREAK-TYPE SMALL-NUMBER))
  (LABEL $L.10)
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.22)
  (LABEL $L.60)
  (VAR R HALFWORD)
  (VAR PREV-R HALFWORD)
  (VAR OLD-L HALFWORD)
  (VAR NO-BREAK-YET BOOLEAN)
  (VAR PREV-PREV-R HALFWORD)
  (VAR S HALFWORD)
  (VAR Q HALFWORD)
  (VAR V HALFWORD)
  (VAR T INTEGER)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR L HALFWORD)
  (VAR NODE-R-STAYS-ACTIVE BOOLEAN)
  (VAR LINE-WIDTH SCALED)
  (VAR FIT-CLASS (RANGE 0 3))
  (VAR B HALFWORD)
  (VAR D INTEGER)
  (VAR ARTIFICIAL-DEMERITS BOOLEAN)
  (VAR SAVE-LINK HALFWORD)
  (VAR SHORTFALL SCALED)
  (WHEN (>= (ABS PI) 10000) (COND ((> PI 0) (GOTO $L.10)) (TRUE (SETF PI (- 10000)))))
  (SETF NO-BREAK-YET TRUE)
  (SETF PREV-R 59993)
  (SETF OLD-L 0)
  (SETF (AREF CUR-ACTIVE-WIDTH 1) (AREF ACTIVE-WIDTH 1))
  (SETF (AREF CUR-ACTIVE-WIDTH 2) (AREF ACTIVE-WIDTH 2))
  (SETF (AREF CUR-ACTIVE-WIDTH 3) (AREF ACTIVE-WIDTH 3))
  (SETF (AREF CUR-ACTIVE-WIDTH 4) (AREF ACTIVE-WIDTH 4))
  (SETF (AREF CUR-ACTIVE-WIDTH 5) (AREF ACTIVE-WIDTH 5))
  (SETF (AREF CUR-ACTIVE-WIDTH 6) (AREF ACTIVE-WIDTH 6))
  (WHILE TRUE
    $L.22
    (SETF R (SLOT (SLOT (AREF MEM PREV-R) HH) RH))
    (WHEN (= (SLOT (SLOT (AREF MEM R) HH) B0) 2)
      (SETF (AREF CUR-ACTIVE-WIDTH 1)
            (+ (AREF CUR-ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ R 1)) INT)))
      (SETF (AREF CUR-ACTIVE-WIDTH 2)
            (+ (AREF CUR-ACTIVE-WIDTH 2) (SLOT (AREF MEM (+ R 2)) INT)))
      (SETF (AREF CUR-ACTIVE-WIDTH 3)
            (+ (AREF CUR-ACTIVE-WIDTH 3) (SLOT (AREF MEM (+ R 3)) INT)))
      (SETF (AREF CUR-ACTIVE-WIDTH 4)
            (+ (AREF CUR-ACTIVE-WIDTH 4) (SLOT (AREF MEM (+ R 4)) INT)))
      (SETF (AREF CUR-ACTIVE-WIDTH 5)
            (+ (AREF CUR-ACTIVE-WIDTH 5) (SLOT (AREF MEM (+ R 5)) INT)))
      (SETF (AREF CUR-ACTIVE-WIDTH 6)
            (+ (AREF CUR-ACTIVE-WIDTH 6) (SLOT (AREF MEM (+ R 6)) INT)))
      (SETF PREV-PREV-R PREV-R)
      (SETF PREV-R R)
      (GOTO $L.22))
    (SETF L (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH))
    (WHEN (> L OLD-L)
      (WHEN (AND (< MINIMUM-DEMERITS 1073741823) (OR (/= OLD-L EASY-LINE) (= R 59993)))
        (WHEN NO-BREAK-YET
          (SETF NO-BREAK-YET FALSE)
          (SETF (AREF BREAK-WIDTH 1) (AREF BACKGROUND 1))
          (SETF (AREF BREAK-WIDTH 2) (AREF BACKGROUND 2))
          (SETF (AREF BREAK-WIDTH 3) (AREF BACKGROUND 3))
          (SETF (AREF BREAK-WIDTH 4) (AREF BACKGROUND 4))
          (SETF (AREF BREAK-WIDTH 5) (AREF BACKGROUND 5))
          (SETF (AREF BREAK-WIDTH 6) (AREF BACKGROUND 6))
          (SETF S CUR-P)
          (WHEN (> BREAK-TYPE 0)
            (WHEN (/= CUR-P 0)
              (SETF T (SLOT (SLOT (AREF MEM CUR-P) HH) B1))
              (SETF V CUR-P)
              (SETF S (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) RH))
              (WHILE (> T 0)
                (DECF T 1)
                (SETF V (SLOT (SLOT (AREF MEM V) HH) RH))
                (COND ((>= V HI-MEM-MIN)
                       (SETF F (SLOT (SLOT (AREF MEM V) HH) B0))
                       (SETF (AREF BREAK-WIDTH 1)
                             (- (AREF BREAK-WIDTH 1)
                                (SLOT (AREF FONT-INFO
                                            (+ (AREF WIDTH-BASE F)
                                               (SLOT (SLOT (AREF
                                                            FONT-INFO
                                                            (+
                                                             (AREF CHAR-BASE F)
                                                             (SLOT (SLOT (AREF MEM V) HH) B1)))
                                                           QQQQ)
                                                     B0)))
                                      INT))))
                      (TRUE
                       (CASE (SLOT (SLOT (AREF MEM V) HH) B0)
                         ((6) (SETF F (SLOT (SLOT (AREF MEM (+ V 1)) HH) B0))
                          (SETF (AREF BREAK-WIDTH 1)
                                (- (AREF BREAK-WIDTH 1)
                                   (SLOT (AREF FONT-INFO
                                               (+ (AREF WIDTH-BASE F)
                                                  (SLOT (SLOT
                                                         (AREF
                                                          FONT-INFO
                                                          (+
                                                           (AREF CHAR-BASE F)
                                                           (SLOT
                                                            (SLOT (AREF MEM (+ V 1)) HH)
                                                            B1)))
                                                         QQQQ)
                                                        B0)))
                                         INT))))
                         ((0 1 2 11)
                          (SETF (AREF BREAK-WIDTH 1)
                                (- (AREF BREAK-WIDTH 1) (SLOT (AREF MEM (+ V 1)) INT))))
                         (ELSE (CONFUSION 923))))))
              (WHILE (/= S 0)
                (COND ((>= S HI-MEM-MIN)
                       (SETF F (SLOT (SLOT (AREF MEM S) HH) B0))
                       (SETF (AREF BREAK-WIDTH 1)
                             (+ (AREF BREAK-WIDTH 1)
                                (SLOT (AREF FONT-INFO
                                            (+ (AREF WIDTH-BASE F)
                                               (SLOT (SLOT (AREF
                                                            FONT-INFO
                                                            (+
                                                             (AREF CHAR-BASE F)
                                                             (SLOT (SLOT (AREF MEM S) HH) B1)))
                                                           QQQQ)
                                                     B0)))
                                      INT))))
                      (TRUE
                       (CASE (SLOT (SLOT (AREF MEM S) HH) B0)
                         ((6) (SETF F (SLOT (SLOT (AREF MEM (+ S 1)) HH) B0))
                          (SETF (AREF BREAK-WIDTH 1)
                                (+ (AREF BREAK-WIDTH 1)
                                   (SLOT (AREF FONT-INFO
                                               (+ (AREF WIDTH-BASE F)
                                                  (SLOT (SLOT
                                                         (AREF
                                                          FONT-INFO
                                                          (+
                                                           (AREF CHAR-BASE F)
                                                           (SLOT
                                                            (SLOT (AREF MEM (+ S 1)) HH)
                                                            B1)))
                                                         QQQQ)
                                                        B0)))
                                         INT))))
                         ((0 1 2 11)
                          (SETF (AREF BREAK-WIDTH 1)
                                (+ (AREF BREAK-WIDTH 1) (SLOT (AREF MEM (+ S 1)) INT))))
                         (ELSE (CONFUSION 924)))))
                (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
              (SETF (AREF BREAK-WIDTH 1) (+ (AREF BREAK-WIDTH 1) DISC-WIDTH))
              (WHEN (= (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) RH) 0)
                (SETF S (SLOT (SLOT (AREF MEM V) HH) RH)))))
          (WHILE (/= S 0)
            (WHEN (>= S HI-MEM-MIN) (GOTO $L.30))
            (CASE (SLOT (SLOT (AREF MEM S) HH) B0)
              ((10) (SETF V (SLOT (SLOT (AREF MEM (+ S 1)) HH) LH))
               (SETF (AREF BREAK-WIDTH 1)
                     (- (AREF BREAK-WIDTH 1) (SLOT (AREF MEM (+ V 1)) INT)))
               (SETF (AREF BREAK-WIDTH (+ 2 (SLOT (SLOT (AREF MEM V) HH) B0)))
                     (- (AREF BREAK-WIDTH (+ 2 (SLOT (SLOT (AREF MEM V) HH) B0)))
                        (SLOT (AREF MEM (+ V 2)) INT)))
               (SETF (AREF BREAK-WIDTH 6)
                     (- (AREF BREAK-WIDTH 6) (SLOT (AREF MEM (+ V 3)) INT))))
              ((12))
              ((9)
               (SETF (AREF BREAK-WIDTH 1)
                     (- (AREF BREAK-WIDTH 1) (SLOT (AREF MEM (+ S 1)) INT))))
              ((11)
               (COND ((/= (SLOT (SLOT (AREF MEM S) HH) B1) 1) (GOTO $L.30))
                     (TRUE
                      (SETF (AREF BREAK-WIDTH 1)
                            (- (AREF BREAK-WIDTH 1) (SLOT (AREF MEM (+ S 1)) INT))))))
              (ELSE (GOTO $L.30)))
            (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
          $L.30)
        (COND ((= (SLOT (SLOT (AREF MEM PREV-R) HH) B0) 2)
               (SETF (SLOT (AREF MEM (+ PREV-R 1)) INT)
                     (+ (- (SLOT (AREF MEM (+ PREV-R 1)) INT) (AREF CUR-ACTIVE-WIDTH 1))
                        (AREF BREAK-WIDTH 1)))
               (SETF (SLOT (AREF MEM (+ PREV-R 2)) INT)
                     (+ (- (SLOT (AREF MEM (+ PREV-R 2)) INT) (AREF CUR-ACTIVE-WIDTH 2))
                        (AREF BREAK-WIDTH 2)))
               (SETF (SLOT (AREF MEM (+ PREV-R 3)) INT)
                     (+ (- (SLOT (AREF MEM (+ PREV-R 3)) INT) (AREF CUR-ACTIVE-WIDTH 3))
                        (AREF BREAK-WIDTH 3)))
               (SETF (SLOT (AREF MEM (+ PREV-R 4)) INT)
                     (+ (- (SLOT (AREF MEM (+ PREV-R 4)) INT) (AREF CUR-ACTIVE-WIDTH 4))
                        (AREF BREAK-WIDTH 4)))
               (SETF (SLOT (AREF MEM (+ PREV-R 5)) INT)
                     (+ (- (SLOT (AREF MEM (+ PREV-R 5)) INT) (AREF CUR-ACTIVE-WIDTH 5))
                        (AREF BREAK-WIDTH 5)))
               (SETF (SLOT (AREF MEM (+ PREV-R 6)) INT)
                     (+ (- (SLOT (AREF MEM (+ PREV-R 6)) INT) (AREF CUR-ACTIVE-WIDTH 6))
                        (AREF BREAK-WIDTH 6))))
              ((= PREV-R 59993)
               (SETF (AREF ACTIVE-WIDTH 1) (AREF BREAK-WIDTH 1))
               (SETF (AREF ACTIVE-WIDTH 2) (AREF BREAK-WIDTH 2))
               (SETF (AREF ACTIVE-WIDTH 3) (AREF BREAK-WIDTH 3))
               (SETF (AREF ACTIVE-WIDTH 4) (AREF BREAK-WIDTH 4))
               (SETF (AREF ACTIVE-WIDTH 5) (AREF BREAK-WIDTH 5))
               (SETF (AREF ACTIVE-WIDTH 6) (AREF BREAK-WIDTH 6)))
              (TRUE
               (SETF Q (GET-NODE 7))
               (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
               (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 2)
               (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
               (SETF (SLOT (AREF MEM (+ Q 1)) INT)
                     (- (AREF BREAK-WIDTH 1) (AREF CUR-ACTIVE-WIDTH 1)))
               (SETF (SLOT (AREF MEM (+ Q 2)) INT)
                     (- (AREF BREAK-WIDTH 2) (AREF CUR-ACTIVE-WIDTH 2)))
               (SETF (SLOT (AREF MEM (+ Q 3)) INT)
                     (- (AREF BREAK-WIDTH 3) (AREF CUR-ACTIVE-WIDTH 3)))
               (SETF (SLOT (AREF MEM (+ Q 4)) INT)
                     (- (AREF BREAK-WIDTH 4) (AREF CUR-ACTIVE-WIDTH 4)))
               (SETF (SLOT (AREF MEM (+ Q 5)) INT)
                     (- (AREF BREAK-WIDTH 5) (AREF CUR-ACTIVE-WIDTH 5)))
               (SETF (SLOT (AREF MEM (+ Q 6)) INT)
                     (- (AREF BREAK-WIDTH 6) (AREF CUR-ACTIVE-WIDTH 6)))
               (SETF (SLOT (SLOT (AREF MEM PREV-R) HH) RH) Q)
               (SETF PREV-PREV-R PREV-R)
               (SETF PREV-R Q)))
        (COND ((>= (ABS (SLOT (AREF EQTB 9179) INT)) (- 1073741823 MINIMUM-DEMERITS))
               (SETF MINIMUM-DEMERITS 1073741822))
              (TRUE (INCF MINIMUM-DEMERITS (ABS (SLOT (AREF EQTB 9179) INT)))))
        (FOR (FIT-CLASS 0 TO 3)
          (WHEN (<= (AREF MINIMAL-DEMERITS FIT-CLASS) MINIMUM-DEMERITS)
            (SETF Q (GET-NODE 2))
            (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) PASSIVE)
            (SETF PASSIVE Q)
            (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) CUR-P)
            (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) (AREF BEST-PLACE FIT-CLASS))
            (SETF Q (GET-NODE 3))
            (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) PASSIVE)
            (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) (+ (AREF BEST-PL-LINE FIT-CLASS) 1))
            (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) FIT-CLASS)
            (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) BREAK-TYPE)
            (SETF (SLOT (AREF MEM (+ Q 2)) INT) (AREF MINIMAL-DEMERITS FIT-CLASS))
            (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
            (SETF (SLOT (SLOT (AREF MEM PREV-R) HH) RH) Q)
            (SETF PREV-R Q))
          (SETF (AREF MINIMAL-DEMERITS FIT-CLASS) 1073741823))
        (SETF MINIMUM-DEMERITS 1073741823)
        (WHEN (/= R 59993)
          (SETF Q (GET-NODE 7))
          (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
          (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 2)
          (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
          (SETF (SLOT (AREF MEM (+ Q 1)) INT)
                (- (AREF CUR-ACTIVE-WIDTH 1) (AREF BREAK-WIDTH 1)))
          (SETF (SLOT (AREF MEM (+ Q 2)) INT)
                (- (AREF CUR-ACTIVE-WIDTH 2) (AREF BREAK-WIDTH 2)))
          (SETF (SLOT (AREF MEM (+ Q 3)) INT)
                (- (AREF CUR-ACTIVE-WIDTH 3) (AREF BREAK-WIDTH 3)))
          (SETF (SLOT (AREF MEM (+ Q 4)) INT)
                (- (AREF CUR-ACTIVE-WIDTH 4) (AREF BREAK-WIDTH 4)))
          (SETF (SLOT (AREF MEM (+ Q 5)) INT)
                (- (AREF CUR-ACTIVE-WIDTH 5) (AREF BREAK-WIDTH 5)))
          (SETF (SLOT (AREF MEM (+ Q 6)) INT)
                (- (AREF CUR-ACTIVE-WIDTH 6) (AREF BREAK-WIDTH 6)))
          (SETF (SLOT (SLOT (AREF MEM PREV-R) HH) RH) Q)
          (SETF PREV-PREV-R PREV-R)
          (SETF PREV-R Q)))
      (WHEN (= R 59993) (GOTO $L.10))
      (COND ((> L EASY-LINE) (SETF LINE-WIDTH SECOND-WIDTH) (SETF OLD-L 65534))
            (TRUE
             (SETF OLD-L L)
             (COND ((> L LAST-SPECIAL-LINE) (SETF LINE-WIDTH SECOND-WIDTH))
                   ((= (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0) (SETF LINE-WIDTH FIRST-WIDTH))
                   (TRUE
                    (SETF LINE-WIDTH
                          (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH) (* 2 L)))
                                INT)))))))
    (SETF ARTIFICIAL-DEMERITS FALSE)
    (SETF SHORTFALL (- LINE-WIDTH (AREF CUR-ACTIVE-WIDTH 1)))
    (COND ((> SHORTFALL 0)
           (COND ((OR (OR (/= (AREF CUR-ACTIVE-WIDTH 3) 0) (/= (AREF CUR-ACTIVE-WIDTH 4) 0))
                      (/= (AREF CUR-ACTIVE-WIDTH 5) 0))
                  (SETF B 0)
                  (SETF FIT-CLASS 2))
                 (TRUE
                  (WHEN (> SHORTFALL 7230584)
                    (WHEN (< (AREF CUR-ACTIVE-WIDTH 2) 1663497)
                      (SETF B 10000)
                      (SETF FIT-CLASS 0)
                      (GOTO $L.31)))
                  (SETF B (BADNESS SHORTFALL (AREF CUR-ACTIVE-WIDTH 2)))
                  (COND ((> B 12)
                         (COND ((> B 99) (SETF FIT-CLASS 0)) (TRUE (SETF FIT-CLASS 1))))
                        (TRUE (SETF FIT-CLASS 2)))
                  $L.31)))
          (TRUE
           (COND ((> (- SHORTFALL) (AREF CUR-ACTIVE-WIDTH 6)) (SETF B 10001))
                 (TRUE (SETF B (BADNESS (- SHORTFALL) (AREF CUR-ACTIVE-WIDTH 6)))))
           (COND ((> B 12) (SETF FIT-CLASS 3)) (TRUE (SETF FIT-CLASS 2)))))
    (COND ((OR (> B 10000) (= PI (- 10000)))
           (COND ((AND (AND (AND FINAL-PASS (= MINIMUM-DEMERITS 1073741823))
                            (= (SLOT (SLOT (AREF MEM R) HH) RH) 59993))
                       (= PREV-R 59993))
                  (SETF ARTIFICIAL-DEMERITS TRUE))
                 ((> B THRESHOLD) (GOTO $L.60)))
           (SETF NODE-R-STAYS-ACTIVE FALSE))
          (TRUE
           (SETF PREV-R R)
           (WHEN (> B THRESHOLD) (GOTO $L.22))
           (SETF NODE-R-STAYS-ACTIVE TRUE)))
    (COND (ARTIFICIAL-DEMERITS (SETF D 0))
          (TRUE
           (SETF D (+ (SLOT (AREF EQTB 9165) INT) B))
           (COND ((>= (ABS D) 10000) (SETF D 100000000)) (TRUE (SETF D (* D D))))
           (WHEN (/= PI 0)
             (COND ((> PI 0) (INCF D (* PI PI))) ((> PI (- 10000)) (DECF D (* PI PI)))))
           (WHEN (AND (= BREAK-TYPE 1) (= (SLOT (SLOT (AREF MEM R) HH) B0) 1))
             (COND ((/= CUR-P 0) (INCF D (SLOT (AREF EQTB 9177) INT)))
                   (TRUE (INCF D (SLOT (AREF EQTB 9178) INT)))))
           (WHEN (> (ABS (- FIT-CLASS (SLOT (SLOT (AREF MEM R) HH) B1))) 1)
             (INCF D (SLOT (AREF EQTB 9179) INT)))))
    (INCF D (SLOT (AREF MEM (+ R 2)) INT))
    (WHEN (<= D (AREF MINIMAL-DEMERITS FIT-CLASS))
      (SETF (AREF MINIMAL-DEMERITS FIT-CLASS) D)
      (SETF (AREF BEST-PLACE FIT-CLASS) (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH))
      (SETF (AREF BEST-PL-LINE FIT-CLASS) L)
      (WHEN (< D MINIMUM-DEMERITS) (SETF MINIMUM-DEMERITS D)))
    (WHEN NODE-R-STAYS-ACTIVE (GOTO $L.22))
    $L.60
    (SETF (SLOT (SLOT (AREF MEM PREV-R) HH) RH) (SLOT (SLOT (AREF MEM R) HH) RH))
    (FREE-NODE R 3)
    (COND ((= PREV-R 59993)
           (SETF R (SLOT (SLOT (AREF MEM 59993) HH) RH))
           (WHEN (= (SLOT (SLOT (AREF MEM R) HH) B0) 2)
             (SETF (AREF ACTIVE-WIDTH 1)
                   (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ R 1)) INT)))
             (SETF (AREF ACTIVE-WIDTH 2)
                   (+ (AREF ACTIVE-WIDTH 2) (SLOT (AREF MEM (+ R 2)) INT)))
             (SETF (AREF ACTIVE-WIDTH 3)
                   (+ (AREF ACTIVE-WIDTH 3) (SLOT (AREF MEM (+ R 3)) INT)))
             (SETF (AREF ACTIVE-WIDTH 4)
                   (+ (AREF ACTIVE-WIDTH 4) (SLOT (AREF MEM (+ R 4)) INT)))
             (SETF (AREF ACTIVE-WIDTH 5)
                   (+ (AREF ACTIVE-WIDTH 5) (SLOT (AREF MEM (+ R 5)) INT)))
             (SETF (AREF ACTIVE-WIDTH 6)
                   (+ (AREF ACTIVE-WIDTH 6) (SLOT (AREF MEM (+ R 6)) INT)))
             (SETF (AREF CUR-ACTIVE-WIDTH 1) (AREF ACTIVE-WIDTH 1))
             (SETF (AREF CUR-ACTIVE-WIDTH 2) (AREF ACTIVE-WIDTH 2))
             (SETF (AREF CUR-ACTIVE-WIDTH 3) (AREF ACTIVE-WIDTH 3))
             (SETF (AREF CUR-ACTIVE-WIDTH 4) (AREF ACTIVE-WIDTH 4))
             (SETF (AREF CUR-ACTIVE-WIDTH 5) (AREF ACTIVE-WIDTH 5))
             (SETF (AREF CUR-ACTIVE-WIDTH 6) (AREF ACTIVE-WIDTH 6))
             (SETF (SLOT (SLOT (AREF MEM 59993) HH) RH) (SLOT (SLOT (AREF MEM R) HH) RH))
             (FREE-NODE R 7)))
          ((= (SLOT (SLOT (AREF MEM PREV-R) HH) B0) 2)
           (SETF R (SLOT (SLOT (AREF MEM PREV-R) HH) RH))
           (COND ((= R 59993)
                  (SETF (AREF CUR-ACTIVE-WIDTH 1)
                        (- (AREF CUR-ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ PREV-R 1)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 2)
                        (- (AREF CUR-ACTIVE-WIDTH 2) (SLOT (AREF MEM (+ PREV-R 2)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 3)
                        (- (AREF CUR-ACTIVE-WIDTH 3) (SLOT (AREF MEM (+ PREV-R 3)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 4)
                        (- (AREF CUR-ACTIVE-WIDTH 4) (SLOT (AREF MEM (+ PREV-R 4)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 5)
                        (- (AREF CUR-ACTIVE-WIDTH 5) (SLOT (AREF MEM (+ PREV-R 5)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 6)
                        (- (AREF CUR-ACTIVE-WIDTH 6) (SLOT (AREF MEM (+ PREV-R 6)) INT)))
                  (SETF (SLOT (SLOT (AREF MEM PREV-PREV-R) HH) RH) 59993)
                  (FREE-NODE PREV-R 7)
                  (SETF PREV-R PREV-PREV-R))
                 ((= (SLOT (SLOT (AREF MEM R) HH) B0) 2)
                  (SETF (AREF CUR-ACTIVE-WIDTH 1)
                        (+ (AREF CUR-ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ R 1)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 2)
                        (+ (AREF CUR-ACTIVE-WIDTH 2) (SLOT (AREF MEM (+ R 2)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 3)
                        (+ (AREF CUR-ACTIVE-WIDTH 3) (SLOT (AREF MEM (+ R 3)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 4)
                        (+ (AREF CUR-ACTIVE-WIDTH 4) (SLOT (AREF MEM (+ R 4)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 5)
                        (+ (AREF CUR-ACTIVE-WIDTH 5) (SLOT (AREF MEM (+ R 5)) INT)))
                  (SETF (AREF CUR-ACTIVE-WIDTH 6)
                        (+ (AREF CUR-ACTIVE-WIDTH 6) (SLOT (AREF MEM (+ R 6)) INT)))
                  (SETF (SLOT (AREF MEM (+ PREV-R 1)) INT)
                        (+ (SLOT (AREF MEM (+ PREV-R 1)) INT) (SLOT (AREF MEM (+ R 1)) INT)))
                  (SETF (SLOT (AREF MEM (+ PREV-R 2)) INT)
                        (+ (SLOT (AREF MEM (+ PREV-R 2)) INT) (SLOT (AREF MEM (+ R 2)) INT)))
                  (SETF (SLOT (AREF MEM (+ PREV-R 3)) INT)
                        (+ (SLOT (AREF MEM (+ PREV-R 3)) INT) (SLOT (AREF MEM (+ R 3)) INT)))
                  (SETF (SLOT (AREF MEM (+ PREV-R 4)) INT)
                        (+ (SLOT (AREF MEM (+ PREV-R 4)) INT) (SLOT (AREF MEM (+ R 4)) INT)))
                  (SETF (SLOT (AREF MEM (+ PREV-R 5)) INT)
                        (+ (SLOT (AREF MEM (+ PREV-R 5)) INT) (SLOT (AREF MEM (+ R 5)) INT)))
                  (SETF (SLOT (AREF MEM (+ PREV-R 6)) INT)
                        (+ (SLOT (AREF MEM (+ PREV-R 6)) INT) (SLOT (AREF MEM (+ R 6)) INT)))
                  (SETF (SLOT (SLOT (AREF MEM PREV-R) HH) RH) (SLOT (SLOT (AREF MEM R) HH) RH))
                  (FREE-NODE R 7))))))
  $L.10)

(PROCEDURE POST-LINE-BREAK ((FINAL-WIDOW-PENALTY INTEGER))
  (LABEL $L.30)
  (LABEL $L.31)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR DISC-BREAK BOOLEAN)
  (VAR POST-DISC-BREAK BOOLEAN)
  (VAR CUR-WIDTH SCALED)
  (VAR CUR-INDENT SCALED)
  (VAR T QUARTERWORD)
  (VAR PEN INTEGER)
  (VAR CUR-LINE HALFWORD)
  (SETF Q (SLOT (SLOT (AREF MEM (+ BEST-BET 1)) HH) RH))
  (SETF CUR-P 0)
  (REPEAT (SETF R Q)
          (SETF Q (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
          (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH) CUR-P)
          (SETF CUR-P R)
          (UNTIL (= Q 0)))
  (SETF CUR-LINE (+ (SLOT CUR-LIST PG-FIELD) 1))
  (REPEAT (SETF Q (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) RH))
          (SETF DISC-BREAK FALSE)
          (SETF POST-DISC-BREAK FALSE)
          (COND ((/= Q 0)
                 (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 10)
                        (DELETE-GLUE-REF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
                        (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH)
                              (SLOT (SLOT (AREF EQTB 6790) HH) RH))
                        (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 9)
                        (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 6790) HH) RH)) HH)
                                    RH)
                              (+ (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 6790) HH) RH))
                                             HH)
                                       RH)
                                 1))
                        (GOTO $L.30))
                       ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 7)
                        (SETF T (SLOT (SLOT (AREF MEM Q) HH) B1))
                        (COND ((= T 0) (SETF R (SLOT (SLOT (AREF MEM Q) HH) RH)))
                              (TRUE
                               (SETF R Q)
                               (WHILE (> T 1)
                                 (SETF R (SLOT (SLOT (AREF MEM R) HH) RH))
                                 (DECF T 1))
                               (SETF S (SLOT (SLOT (AREF MEM R) HH) RH))
                               (SETF R (SLOT (SLOT (AREF MEM S) HH) RH))
                               (SETF (SLOT (SLOT (AREF MEM S) HH) RH) 0)
                               (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM Q) HH) RH))
                               (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0)))
                        (WHEN (/= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 0)
                          (SETF S (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
                          (WHILE (/= (SLOT (SLOT (AREF MEM S) HH) RH) 0)
                            (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
                          (SETF (SLOT (SLOT (AREF MEM S) HH) RH) R)
                          (SETF R (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
                          (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 0)
                          (SETF POST-DISC-BREAK TRUE))
                        (WHEN (/= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) 0)
                          (SETF S (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH))
                          (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) S)
                          (WHILE (/= (SLOT (SLOT (AREF MEM S) HH) RH) 0)
                            (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
                          (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) 0)
                          (SETF Q S))
                        (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
                        (SETF DISC-BREAK TRUE))
                       ((OR (= (SLOT (SLOT (AREF MEM Q) HH) B0) 9)
                            (= (SLOT (SLOT (AREF MEM Q) HH) B0) 11))
                        (SETF (SLOT (AREF MEM (+ Q 1)) INT) 0))))
                (TRUE
                 (SETF Q 59997)
                 (WHILE (/= (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
                   (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))))
          (SETF R (NEW-PARAM-GLUE 8))
          (SETF (SLOT (SLOT (AREF MEM R) HH) RH) (SLOT (SLOT (AREF MEM Q) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) R)
          (SETF Q R)
          $L.30
          (SETF R (SLOT (SLOT (AREF MEM Q) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
          (SETF Q (SLOT (SLOT (AREF MEM 59997) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM 59997) HH) RH) R)
          (WHEN (/= (SLOT (SLOT (AREF EQTB 6789) HH) RH) 0)
            (SETF R (NEW-PARAM-GLUE 7))
            (SETF (SLOT (SLOT (AREF MEM R) HH) RH) Q)
            (SETF Q R))
          (COND ((> CUR-LINE LAST-SPECIAL-LINE)
                 (SETF CUR-WIDTH SECOND-WIDTH)
                 (SETF CUR-INDENT SECOND-INDENT))
                ((= (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0)
                 (SETF CUR-WIDTH FIRST-WIDTH)
                 (SETF CUR-INDENT FIRST-INDENT))
                (TRUE
                 (SETF CUR-WIDTH
                       (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH) (* 2 CUR-LINE)))
                             INT))
                 (SETF CUR-INDENT
                       (SLOT (AREF MEM
                                   (- (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH) (* 2 CUR-LINE))
                                      1))
                             INT))))
          (SETF ADJUST-TAIL 59995)
          (SETF JUST-BOX (HPACK Q CUR-WIDTH 0))
          (SETF (SLOT (AREF MEM (+ JUST-BOX 4)) INT) CUR-INDENT)
          (APPEND-TO-VLIST JUST-BOX)
          (WHEN (/= 59995 ADJUST-TAIL)
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
                  (SLOT (SLOT (AREF MEM 59995) HH) RH))
            (SETF (SLOT CUR-LIST TAIL-FIELD) ADJUST-TAIL))
          (SETF ADJUST-TAIL 0)
          (WHEN (/= (+ CUR-LINE 1) BEST-LINE)
            (SETF PEN (SLOT (AREF EQTB 9176) INT))
            (WHEN (= CUR-LINE (+ (SLOT CUR-LIST PG-FIELD) 1))
              (INCF PEN (SLOT (AREF EQTB 9168) INT)))
            (WHEN (= (+ CUR-LINE 2) BEST-LINE) (INCF PEN FINAL-WIDOW-PENALTY))
            (WHEN DISC-BREAK (INCF PEN (SLOT (AREF EQTB 9171) INT)))
            (WHEN (/= PEN 0)
              (SETF R (NEW-PENALTY PEN))
              (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) R)
              (SETF (SLOT CUR-LIST TAIL-FIELD) R)))
          (INCF CUR-LINE 1)
          (SETF CUR-P (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH))
          (WHEN (/= CUR-P 0)
            (UNLESS POST-DISC-BREAK
              (SETF R 59997)
              (WHILE TRUE
                (SETF Q (SLOT (SLOT (AREF MEM R) HH) RH))
                (WHEN (= Q (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) RH)) (GOTO $L.31))
                (WHEN (>= Q HI-MEM-MIN) (GOTO $L.31))
                (WHEN (< (SLOT (SLOT (AREF MEM Q) HH) B0) 9) (GOTO $L.31))
                (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B0) 11)
                  (WHEN (/= (SLOT (SLOT (AREF MEM Q) HH) B1) 1) (GOTO $L.31)))
                (SETF R Q))
              $L.31
              (WHEN (/= R 59997)
                (SETF (SLOT (SLOT (AREF MEM R) HH) RH) 0)
                (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM 59997) HH) RH))
                (SETF (SLOT (SLOT (AREF MEM 59997) HH) RH) Q))))
          (UNTIL (= CUR-P 0)))
  (WHEN (OR (/= CUR-LINE BEST-LINE) (/= (SLOT (SLOT (AREF MEM 59997) HH) RH) 0))
    (CONFUSION 939))
  (SETF (SLOT CUR-LIST PG-FIELD) (- BEST-LINE 1)))

(FUNCTION (RECONSTITUTE SMALL-NUMBER) ((J SMALL-NUMBER) (N SMALL-NUMBER) (BCHAR HALFWORD)
                                       (HCHAR HALFWORD))
  (LABEL $L.22)
  (LABEL $L.30)
  (VAR P HALFWORD)
  (VAR T HALFWORD)
  (VAR Q FOUR-QUARTERS)
  (VAR CUR-RH HALFWORD)
  (VAR TEST-CHAR HALFWORD)
  (VAR W SCALED)
  (VAR K FONT-INDEX)
  (SETF HYPHEN-PASSED 0)
  (SETF T 59996)
  (SETF W 0)
  (SETF (SLOT (SLOT (AREF MEM 59996) HH) RH) 0)
  (SETF CUR-L (+ (AREF HU J) 0))
  (SETF CUR-Q T)
  (COND ((= J 0)
         (SETF LIGATURE-PRESENT INIT-LIG)
         (SETF P INIT-LIST)
         (WHEN LIGATURE-PRESENT (SETF LFT-HIT INIT-LFT))
         (WHILE (> P 0)
           (SETF (SLOT (SLOT (AREF MEM T) HH) RH) GET-AVAIL)
           (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
           (SETF (SLOT (SLOT (AREF MEM T) HH) B0) HF)
           (SETF (SLOT (SLOT (AREF MEM T) HH) B1) (SLOT (SLOT (AREF MEM P) HH) B1))
           (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))))
        ((< CUR-L 256)
         (SETF (SLOT (SLOT (AREF MEM T) HH) RH) GET-AVAIL)
         (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM T) HH) B0) HF)
         (SETF (SLOT (SLOT (AREF MEM T) HH) B1) CUR-L)))
  (SETF LIG-STACK 0)
  (COND ((< J N) (SETF CUR-R (+ (AREF HU (+ J 1)) 0))) (TRUE (SETF CUR-R BCHAR)))
  (COND ((ODD (AREF HYF J)) (SETF CUR-RH HCHAR)) (TRUE (SETF CUR-RH 256)))
  $L.22
  (COND ((= CUR-L 256)
         (SETF K (AREF BCHAR-LABEL HF))
         (COND ((= K 0) (GOTO $L.30)) (TRUE (SETF Q (SLOT (AREF FONT-INFO K) QQQQ)))))
        (TRUE
         (SETF Q (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE HF) CUR-L)) QQQQ))
         (WHEN (/= (MOD (- (SLOT Q B2) 0) 4) 1) (GOTO $L.30))
         (SETF K (+ (AREF LIG-KERN-BASE HF) (SLOT Q B3)))
         (SETF Q (SLOT (AREF FONT-INFO K) QQQQ))
         (WHEN (> (SLOT Q B0) 128)
           (SETF K
                 (- (+ (+ (+ (AREF LIG-KERN-BASE HF) (* 256 (SLOT Q B2))) (SLOT Q B3)) 32768)
                    (* 256 128)))
           (SETF Q (SLOT (AREF FONT-INFO K) QQQQ)))))
  (COND ((< CUR-RH 256) (SETF TEST-CHAR CUR-RH)) (TRUE (SETF TEST-CHAR CUR-R)))
  (WHILE TRUE
    (WHEN (= (SLOT Q B1) TEST-CHAR)
      (WHEN (<= (SLOT Q B0) 128)
        (COND ((< CUR-RH 256)
               (SETF HYPHEN-PASSED J)
               (SETF HCHAR 256)
               (SETF CUR-RH 256)
               (GOTO $L.22))
              (TRUE
               (WHEN (< HCHAR 256)
                 (WHEN (ODD (AREF HYF J)) (SETF HYPHEN-PASSED J) (SETF HCHAR 256)))
               (WHEN (< (SLOT Q B2) 128)
                 (WHEN (= CUR-L 256) (SETF LFT-HIT TRUE))
                 (WHEN (= J N) (WHEN (= LIG-STACK 0) (SETF RT-HIT TRUE)))
                 (WHEN (/= INTERRUPT 0) (PAUSE-FOR-INSTRUCTIONS))
                 (CASE (SLOT Q B2)
                   ((1 5) (SETF CUR-L (SLOT Q B3)) (SETF LIGATURE-PRESENT TRUE))
                   ((2 6) (SETF CUR-R (SLOT Q B3))
                    (COND ((> LIG-STACK 0)
                           (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1) CUR-R))
                          (TRUE
                           (SETF LIG-STACK (NEW-LIG-ITEM CUR-R))
                           (COND ((= J N) (SETF BCHAR 256))
                                 (TRUE
                                  (SETF P GET-AVAIL)
                                  (SETF (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH) P)
                                  (SETF (SLOT (SLOT (AREF MEM P) HH) B1)
                                        (+ (AREF HU (+ J 1)) 0))
                                  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) HF))))))
                   ((3) (SETF CUR-R (SLOT Q B3)) (SETF P LIG-STACK)
                    (SETF LIG-STACK (NEW-LIG-ITEM CUR-R))
                    (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH) P))
                   ((7 11)
                    (WHEN LIGATURE-PRESENT
                      (SETF P (NEW-LIGATURE HF CUR-L (SLOT (SLOT (AREF MEM CUR-Q) HH) RH)))
                      (WHEN LFT-HIT
                        (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 2)
                        (SETF LFT-HIT FALSE))
                      (WHEN FALSE
                        (WHEN (= LIG-STACK 0)
                          (SETF (SLOT (SLOT (AREF MEM P) HH) B1)
                                (+ (SLOT (SLOT (AREF MEM P) HH) B1) 1))
                          (SETF RT-HIT FALSE)))
                      (SETF (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) P)
                      (SETF T P)
                      (SETF LIGATURE-PRESENT FALSE))
                    (SETF CUR-Q T) (SETF CUR-L (SLOT Q B3)) (SETF LIGATURE-PRESENT TRUE))
                   (ELSE (SETF CUR-L (SLOT Q B3)) (SETF LIGATURE-PRESENT TRUE)
                    (COND ((> LIG-STACK 0)
                           (WHEN (> (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH) 0)
                             (SETF (SLOT (SLOT (AREF MEM T) HH) RH)
                                   (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH))
                             (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
                             (INCF J 1))
                           (SETF P LIG-STACK)
                           (SETF LIG-STACK (SLOT (SLOT (AREF MEM P) HH) RH))
                           (FREE-NODE P 2)
                           (COND ((= LIG-STACK 0)
                                  (COND ((< J N) (SETF CUR-R (+ (AREF HU (+ J 1)) 0)))
                                        (TRUE (SETF CUR-R BCHAR)))
                                  (COND ((ODD (AREF HYF J)) (SETF CUR-RH HCHAR))
                                        (TRUE (SETF CUR-RH 256))))
                                 (TRUE (SETF CUR-R (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1)))))
                          ((= J N) (GOTO $L.30))
                          (TRUE
                           (SETF (SLOT (SLOT (AREF MEM T) HH) RH) GET-AVAIL)
                           (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
                           (SETF (SLOT (SLOT (AREF MEM T) HH) B0) HF)
                           (SETF (SLOT (SLOT (AREF MEM T) HH) B1) CUR-R)
                           (INCF J 1)
                           (COND ((< J N) (SETF CUR-R (+ (AREF HU (+ J 1)) 0)))
                                 (TRUE (SETF CUR-R BCHAR)))
                           (COND ((ODD (AREF HYF J)) (SETF CUR-RH HCHAR))
                                 (TRUE (SETF CUR-RH 256)))))))
                 (WHEN (> (SLOT Q B2) 4) (WHEN (/= (SLOT Q B2) 7) (GOTO $L.30)))
                 (GOTO $L.22))
               (SETF W
                     (SLOT (AREF FONT-INFO
                                 (+ (+ (AREF KERN-BASE HF) (* 256 (SLOT Q B2))) (SLOT Q B3)))
                           INT))
               (GOTO $L.30)))))
    (WHEN (>= (SLOT Q B0) 128)
      (COND ((= CUR-RH 256) (GOTO $L.30)) (TRUE (SETF CUR-RH 256) (GOTO $L.22))))
    (SETF K (+ (+ K (SLOT Q B0)) 1))
    (SETF Q (SLOT (AREF FONT-INFO K) QQQQ)))
  $L.30
  (WHEN LIGATURE-PRESENT
    (SETF P (NEW-LIGATURE HF CUR-L (SLOT (SLOT (AREF MEM CUR-Q) HH) RH)))
    (WHEN LFT-HIT (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 2) (SETF LFT-HIT FALSE))
    (WHEN RT-HIT
      (WHEN (= LIG-STACK 0)
        (SETF (SLOT (SLOT (AREF MEM P) HH) B1) (+ (SLOT (SLOT (AREF MEM P) HH) B1) 1))
        (SETF RT-HIT FALSE)))
    (SETF (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) P)
    (SETF T P)
    (SETF LIGATURE-PRESENT FALSE))
  (WHEN (/= W 0)
    (SETF (SLOT (SLOT (AREF MEM T) HH) RH) (NEW-KERN W))
    (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
    (SETF W 0))
  (WHEN (> LIG-STACK 0)
    (SETF CUR-Q T)
    (SETF CUR-L (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1))
    (SETF LIGATURE-PRESENT TRUE)
    (WHEN (> (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH) 0)
      (SETF (SLOT (SLOT (AREF MEM T) HH) RH) (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH))
      (SETF T (SLOT (SLOT (AREF MEM T) HH) RH))
      (INCF J 1))
    (SETF P LIG-STACK)
    (SETF LIG-STACK (SLOT (SLOT (AREF MEM P) HH) RH))
    (FREE-NODE P 2)
    (COND ((= LIG-STACK 0)
           (COND ((< J N) (SETF CUR-R (+ (AREF HU (+ J 1)) 0))) (TRUE (SETF CUR-R BCHAR)))
           (COND ((ODD (AREF HYF J)) (SETF CUR-RH HCHAR)) (TRUE (SETF CUR-RH 256))))
          (TRUE (SETF CUR-R (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1))))
    (GOTO $L.22))
  (SETF RECONSTITUTE J))

(PROCEDURE HYPHENATE ()
  (LABEL $L.50)
  (LABEL $L.30)
  (LABEL $L.40)
  (LABEL $L.41)
  (LABEL $L.42)
  (LABEL $L.45)
  (LABEL $L.10)
  (VAR I (RANGE 0 65))
  (VAR J (RANGE 0 65))
  (VAR L (RANGE 0 65))
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR BCHAR HALFWORD)
  (VAR MAJOR-TAIL HALFWORD)
  (VAR MINOR-TAIL HALFWORD)
  (VAR C ASCII-CODE)
  (VAR C-LOC (RANGE 0 63))
  (VAR R-COUNT INTEGER)
  (VAR HYF-NODE HALFWORD)
  (VAR Z TRIE-POINTER)
  (VAR V INTEGER)
  (VAR H HYPH-POINTER)
  (VAR K STR-NUMBER)
  (VAR U POOL-POINTER)
  (FOR (J 0 TO HN) (SETF (AREF HYF J) 0))
  (SETF H (AREF HC 1))
  (INCF HN 1)
  (SETF (AREF HC HN) CUR-LANG)
  (FOR (J 2 TO HN) (SETF H (MOD (+ (+ H H) (AREF HC J)) 307)))
  (WHILE TRUE
    (SETF K (AREF HYPH-WORD H))
    (WHEN (= K 0) (GOTO $L.45))
    (WHEN (< (- (AREF STR-START (+ K 1)) (AREF STR-START K)) HN) (GOTO $L.45))
    (WHEN (= (- (AREF STR-START (+ K 1)) (AREF STR-START K)) HN)
      (SETF J 1)
      (SETF U (AREF STR-START K))
      (REPEAT (WHEN (< (AREF STR-POOL U) (AREF HC J)) (GOTO $L.45))
              (WHEN (> (AREF STR-POOL U) (AREF HC J)) (GOTO $L.30))
              (INCF J 1)
              (INCF U 1)
              (UNTIL (> J HN)))
      (SETF S (AREF HYPH-LIST H))
      (WHILE (/= S 0)
        (SETF (AREF HYF (SLOT (SLOT (AREF MEM S) HH) LH)) 1)
        (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
      (DECF HN 1)
      (GOTO $L.40))
    $L.30
    (COND ((> H 0) (DECF H 1)) (TRUE (SETF H 307))))
  $L.45
  (DECF HN 1)
  (WHEN (/= (SLOT (AREF TRIE (+ CUR-LANG 1)) B1) (+ CUR-LANG 0)) (GOTO $L.10))
  (SETF (AREF HC 0) 0)
  (SETF (AREF HC (+ HN 1)) 0)
  (SETF (AREF HC (+ HN 2)) 256)
  (FOR (J 0 TO (+ (- HN R-HYF) 1))
    (SETF Z (+ (SLOT (AREF TRIE (+ CUR-LANG 1)) RH) (AREF HC J)))
    (SETF L J)
    (WHILE (= (AREF HC L) (- (SLOT (AREF TRIE Z) B1) 0))
      (WHEN (/= (SLOT (AREF TRIE Z) B0) 0)
        (SETF V (SLOT (AREF TRIE Z) B0))
        (REPEAT (INCF V (AREF OP-START CUR-LANG))
                (SETF I (- L (AREF HYF-DISTANCE V)))
                (WHEN (> (AREF HYF-NUM V) (AREF HYF I)) (SETF (AREF HYF I) (AREF HYF-NUM V)))
                (SETF V (AREF HYF-NEXT V))
                (UNTIL (= V 0))))
      (INCF L 1)
      (SETF Z (+ (SLOT (AREF TRIE Z) RH) (AREF HC L)))))
  $L.40
  (FOR (J 0 TO (- L-HYF 1)) (SETF (AREF HYF J) 0))
  (FOR (J 0 TO (- R-HYF 1)) (SETF (AREF HYF (- HN J)) 0))
  (FOR (J L-HYF TO (- HN R-HYF)) (WHEN (ODD (AREF HYF J)) (GOTO $L.41)))
  (GOTO $L.10)
  $L.41
  (SETF Q (SLOT (SLOT (AREF MEM HB) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM HB) HH) RH) 0)
  (SETF R (SLOT (SLOT (AREF MEM HA) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM HA) HH) RH) 0)
  (SETF BCHAR HYF-BCHAR)
  (COND ((>= HA HI-MEM-MIN)
         (COND ((/= (SLOT (SLOT (AREF MEM HA) HH) B0) HF) (GOTO $L.42))
               (TRUE
                (SETF INIT-LIST HA)
                (SETF INIT-LIG FALSE)
                (SETF (AREF HU 0) (- (SLOT (SLOT (AREF MEM HA) HH) B1) 0)))))
        ((= (SLOT (SLOT (AREF MEM HA) HH) B0) 6)
         (COND ((/= (SLOT (SLOT (AREF MEM (+ HA 1)) HH) B0) HF) (GOTO $L.42))
               (TRUE
                (SETF INIT-LIST (SLOT (SLOT (AREF MEM (+ HA 1)) HH) RH))
                (SETF INIT-LIG TRUE)
                (SETF INIT-LFT (> (SLOT (SLOT (AREF MEM HA) HH) B1) 1))
                (SETF (AREF HU 0) (- (SLOT (SLOT (AREF MEM (+ HA 1)) HH) B1) 0))
                (WHEN (= INIT-LIST 0)
                  (WHEN INIT-LFT (SETF (AREF HU 0) 256) (SETF INIT-LIG FALSE)))
                (FREE-NODE HA 2))))
        (TRUE
         (UNLESS (>= R HI-MEM-MIN)
           (WHEN (= (SLOT (SLOT (AREF MEM R) HH) B0) 6)
             (WHEN (> (SLOT (SLOT (AREF MEM R) HH) B1) 1) (GOTO $L.42))))
         (SETF J 1)
         (SETF S HA)
         (SETF INIT-LIST 0)
         (GOTO $L.50)))
  (SETF S CUR-P)
  (WHILE (/= (SLOT (SLOT (AREF MEM S) HH) RH) HA) (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
  (SETF J 0)
  (GOTO $L.50)
  $L.42
  (SETF S HA)
  (SETF J 0)
  (SETF (AREF HU 0) 256)
  (SETF INIT-LIG FALSE)
  (SETF INIT-LIST 0)
  $L.50
  (FLUSH-NODE-LIST R)
  (REPEAT (SETF L J)
          (SETF J (+ (RECONSTITUTE J HN BCHAR (+ HYF-CHAR 0)) 1))
          (WHEN (= HYPHEN-PASSED 0)
            (SETF (SLOT (SLOT (AREF MEM S) HH) RH) (SLOT (SLOT (AREF MEM 59996) HH) RH))
            (WHILE (> (SLOT (SLOT (AREF MEM S) HH) RH) 0)
              (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
            (WHEN (ODD (AREF HYF (- J 1)))
              (SETF L J)
              (SETF HYPHEN-PASSED (- J 1))
              (SETF (SLOT (SLOT (AREF MEM 59996) HH) RH) 0)))
          (WHEN (> HYPHEN-PASSED 0)
            (REPEAT (SETF R (GET-NODE 2))
                    (SETF (SLOT (SLOT (AREF MEM R) HH) RH)
                          (SLOT (SLOT (AREF MEM 59996) HH) RH))
                    (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 7)
                    (SETF MAJOR-TAIL R)
                    (SETF R-COUNT 0)
                    (WHILE (> (SLOT (SLOT (AREF MEM MAJOR-TAIL) HH) RH) 0)
                      (SETF MAJOR-TAIL (SLOT (SLOT (AREF MEM MAJOR-TAIL) HH) RH))
                      (INCF R-COUNT 1))
                    (SETF I HYPHEN-PASSED)
                    (SETF (AREF HYF I) 0)
                    (SETF MINOR-TAIL 0)
                    (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH) 0)
                    (SETF HYF-NODE (NEW-CHARACTER HF HYF-CHAR))
                    (WHEN (/= HYF-NODE 0)
                      (INCF I 1)
                      (SETF C (AREF HU I))
                      (SETF (AREF HU I) HYF-CHAR)
                      (SETF (SLOT (SLOT (AREF MEM HYF-NODE) HH) RH) AVAIL)
                      (SETF AVAIL HYF-NODE))
                    (WHILE (<= L I)
                      (SETF L (+ (RECONSTITUTE L I (AREF FONT-BCHAR HF) 256) 1))
                      (WHEN (> (SLOT (SLOT (AREF MEM 59996) HH) RH) 0)
                        (COND ((= MINOR-TAIL 0)
                               (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH)
                                     (SLOT (SLOT (AREF MEM 59996) HH) RH)))
                              (TRUE
                               (SETF (SLOT (SLOT (AREF MEM MINOR-TAIL) HH) RH)
                                     (SLOT (SLOT (AREF MEM 59996) HH) RH))))
                        (SETF MINOR-TAIL (SLOT (SLOT (AREF MEM 59996) HH) RH))
                        (WHILE (> (SLOT (SLOT (AREF MEM MINOR-TAIL) HH) RH) 0)
                          (SETF MINOR-TAIL (SLOT (SLOT (AREF MEM MINOR-TAIL) HH) RH)))))
                    (WHEN (/= HYF-NODE 0) (SETF (AREF HU I) C) (SETF L I) (DECF I 1))
                    (SETF MINOR-TAIL 0)
                    (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH) 0)
                    (SETF C-LOC 0)
                    (WHEN (/= (AREF BCHAR-LABEL HF) 0)
                      (DECF L 1)
                      (SETF C (AREF HU L))
                      (SETF C-LOC L)
                      (SETF (AREF HU L) 256))
                    (WHILE (< L J)
                      (REPEAT (SETF L (+ (RECONSTITUTE L HN BCHAR 256) 1))
                              (WHEN (> C-LOC 0) (SETF (AREF HU C-LOC) C) (SETF C-LOC 0))
                              (WHEN (> (SLOT (SLOT (AREF MEM 59996) HH) RH) 0)
                                (COND ((= MINOR-TAIL 0)
                                       (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH)
                                             (SLOT (SLOT (AREF MEM 59996) HH) RH)))
                                      (TRUE
                                       (SETF (SLOT (SLOT (AREF MEM MINOR-TAIL) HH) RH)
                                             (SLOT (SLOT (AREF MEM 59996) HH) RH))))
                                (SETF MINOR-TAIL (SLOT (SLOT (AREF MEM 59996) HH) RH))
                                (WHILE (> (SLOT (SLOT (AREF MEM MINOR-TAIL) HH) RH) 0)
                                  (SETF MINOR-TAIL (SLOT (SLOT (AREF MEM MINOR-TAIL) HH) RH))))
                              (UNTIL (>= L J)))
                      (WHILE (> L J)
                        (SETF J (+ (RECONSTITUTE J HN BCHAR 256) 1))
                        (SETF (SLOT (SLOT (AREF MEM MAJOR-TAIL) HH) RH)
                              (SLOT (SLOT (AREF MEM 59996) HH) RH))
                        (WHILE (> (SLOT (SLOT (AREF MEM MAJOR-TAIL) HH) RH) 0)
                          (SETF MAJOR-TAIL (SLOT (SLOT (AREF MEM MAJOR-TAIL) HH) RH))
                          (INCF R-COUNT 1))))
                    (COND ((> R-COUNT 127)
                           (SETF (SLOT (SLOT (AREF MEM S) HH) RH)
                                 (SLOT (SLOT (AREF MEM R) HH) RH))
                           (SETF (SLOT (SLOT (AREF MEM R) HH) RH) 0)
                           (FLUSH-NODE-LIST R))
                          (TRUE
                           (SETF (SLOT (SLOT (AREF MEM S) HH) RH) R)
                           (SETF (SLOT (SLOT (AREF MEM R) HH) B1) R-COUNT)))
                    (SETF S MAJOR-TAIL)
                    (SETF HYPHEN-PASSED (- J 1))
                    (SETF (SLOT (SLOT (AREF MEM 59996) HH) RH) 0)
                    (UNTIL (NOT (ODD (AREF HYF (- J 1)))))))
          (UNTIL (> J HN)))
  (SETF (SLOT (SLOT (AREF MEM S) HH) RH) Q)
  (FLUSH-LIST INIT-LIST)
  $L.10)

(FUNCTION (NEW-TRIE-OP QUARTERWORD) ((D SMALL-NUMBER) (N SMALL-NUMBER) (V QUARTERWORD))
  (LABEL $L.10)
  (VAR H (RANGE (- TRIE-OP-SIZE) TRIE-OP-SIZE))
  (VAR U QUARTERWORD)
  (VAR L (RANGE 0 TRIE-OP-SIZE))
  (SETF H
        (- (MOD (ABS (+ (+ (+ N (* 313 D)) (* 361 V)) (* 1009 CUR-LANG)))
                (+ TRIE-OP-SIZE TRIE-OP-SIZE))
           TRIE-OP-SIZE))
  (WHILE TRUE
    (SETF L (AREF TRIE-OP-HASH H))
    (WHEN (= L 0)
      (WHEN (= TRIE-OP-PTR TRIE-OP-SIZE) (OVERFLOW 949 TRIE-OP-SIZE))
      (SETF U (AREF TRIE-USED CUR-LANG))
      (WHEN (= U 255) (OVERFLOW 950 255))
      (INCF TRIE-OP-PTR 1)
      (INCF U 1)
      (SETF (AREF TRIE-USED CUR-LANG) U)
      (SETF (AREF HYF-DISTANCE TRIE-OP-PTR) D)
      (SETF (AREF HYF-NUM TRIE-OP-PTR) N)
      (SETF (AREF HYF-NEXT TRIE-OP-PTR) V)
      (SETF (AREF TRIE-OP-LANG TRIE-OP-PTR) CUR-LANG)
      (SETF (AREF TRIE-OP-HASH H) TRIE-OP-PTR)
      (SETF (AREF TRIE-OP-VAL TRIE-OP-PTR) U)
      (SETF NEW-TRIE-OP U)
      (GOTO $L.10))
    (WHEN (AND (AND (AND (= (AREF HYF-DISTANCE L) D) (= (AREF HYF-NUM L) N))
                    (= (AREF HYF-NEXT L) V))
               (= (AREF TRIE-OP-LANG L) CUR-LANG))
      (SETF NEW-TRIE-OP (AREF TRIE-OP-VAL L))
      (GOTO $L.10))
    (COND ((> H (- TRIE-OP-SIZE)) (DECF H 1)) (TRUE (SETF H TRIE-OP-SIZE))))
  $L.10)

(FUNCTION (TRIE-NODE TRIE-POINTER) ((P TRIE-POINTER))
  (LABEL $L.10)
  (VAR H TRIE-POINTER)
  (VAR Q TRIE-POINTER)
  (SETF H
        (MOD (ABS (+ (+ (+ (AREF TRIE-C P) (* 1009 (AREF TRIE-O P))) (* 2718 (AREF TRIE-L P)))
                     (* 3142 (AREF TRIE-R P))))
             TRIE-SIZE))
  (WHILE TRUE
    (SETF Q (AREF TRIE-HASH H))
    (WHEN (= Q 0) (SETF (AREF TRIE-HASH H) P) (SETF TRIE-NODE P) (GOTO $L.10))
    (WHEN (AND (AND (AND (= (AREF TRIE-C Q) (AREF TRIE-C P))
                         (= (AREF TRIE-O Q) (AREF TRIE-O P)))
                    (= (AREF TRIE-L Q) (AREF TRIE-L P)))
               (= (AREF TRIE-R Q) (AREF TRIE-R P)))
      (SETF TRIE-NODE Q)
      (GOTO $L.10))
    (COND ((> H 0) (DECF H 1)) (TRUE (SETF H TRIE-SIZE))))
  $L.10)

(FUNCTION (COMPRESS-TRIE TRIE-POINTER) ((P TRIE-POINTER))
  (COND ((= P 0) (SETF COMPRESS-TRIE 0))
        (TRUE
         (SETF (AREF TRIE-L P) (COMPRESS-TRIE (AREF TRIE-L P)))
         (SETF (AREF TRIE-R P) (COMPRESS-TRIE (AREF TRIE-R P)))
         (SETF COMPRESS-TRIE (TRIE-NODE P)))))

(PROCEDURE FIRST-FIT ((P TRIE-POINTER))
  (LABEL $L.45)
  (LABEL $L.40)
  (VAR H TRIE-POINTER)
  (VAR Z TRIE-POINTER)
  (VAR Q TRIE-POINTER)
  (VAR C ASCII-CODE)
  (VAR L TRIE-POINTER)
  (VAR R TRIE-POINTER)
  (VAR LL (RANGE 1 256))
  (SETF C (AREF TRIE-C P))
  (SETF Z (AREF TRIE-MIN C))
  (WHILE TRUE
    (SETF H (- Z C))
    (WHEN (< TRIE-MAX (+ H 256))
      (WHEN (<= TRIE-SIZE (+ H 256)) (OVERFLOW 951 TRIE-SIZE))
      (REPEAT (INCF TRIE-MAX 1)
              (SETF (AREF TRIE-TAKEN TRIE-MAX) FALSE)
              (SETF (SLOT (AREF TRIE TRIE-MAX) RH) (+ TRIE-MAX 1))
              (SETF (SLOT (AREF TRIE TRIE-MAX) LH) (- TRIE-MAX 1))
              (UNTIL (= TRIE-MAX (+ H 256)))))
    (WHEN (AREF TRIE-TAKEN H) (GOTO $L.45))
    (SETF Q (AREF TRIE-R P))
    (WHILE (> Q 0)
      (WHEN (= (SLOT (AREF TRIE (+ H (AREF TRIE-C Q))) RH) 0) (GOTO $L.45))
      (SETF Q (AREF TRIE-R Q)))
    (GOTO $L.40)
    $L.45
    (SETF Z (SLOT (AREF TRIE Z) RH)))
  $L.40
  (SETF (AREF TRIE-TAKEN H) TRUE)
  (SETF (AREF TRIE-HASH P) H)
  (SETF Q P)
  (REPEAT (SETF Z (+ H (AREF TRIE-C Q)))
          (SETF L (SLOT (AREF TRIE Z) LH))
          (SETF R (SLOT (AREF TRIE Z) RH))
          (SETF (SLOT (AREF TRIE R) LH) L)
          (SETF (SLOT (AREF TRIE L) RH) R)
          (SETF (SLOT (AREF TRIE Z) RH) 0)
          (WHEN (< L 256)
            (COND ((< Z 256) (SETF LL Z)) (TRUE (SETF LL 256)))
            (REPEAT (SETF (AREF TRIE-MIN L) R) (INCF L 1) (UNTIL (= L LL))))
          (SETF Q (AREF TRIE-R Q))
          (UNTIL (= Q 0))))

(PROCEDURE TRIE-PACK ((P TRIE-POINTER))
  (VAR Q TRIE-POINTER)
  (REPEAT (SETF Q (AREF TRIE-L P))
          (WHEN (AND (> Q 0) (= (AREF TRIE-HASH Q) 0)) (FIRST-FIT Q) (TRIE-PACK Q))
          (SETF P (AREF TRIE-R P))
          (UNTIL (= P 0))))

(PROCEDURE TRIE-FIX ((P TRIE-POINTER))
  (VAR Q TRIE-POINTER)
  (VAR C ASCII-CODE)
  (VAR Z TRIE-POINTER)
  (SETF Z (AREF TRIE-HASH P))
  (REPEAT (SETF Q (AREF TRIE-L P))
          (SETF C (AREF TRIE-C P))
          (SETF (SLOT (AREF TRIE (+ Z C)) RH) (AREF TRIE-HASH Q))
          (SETF (SLOT (AREF TRIE (+ Z C)) B1) (+ C 0))
          (SETF (SLOT (AREF TRIE (+ Z C)) B0) (AREF TRIE-O P))
          (WHEN (> Q 0) (TRIE-FIX Q))
          (SETF P (AREF TRIE-R P))
          (UNTIL (= P 0))))

(PROCEDURE NEW-PATTERNS ()
  (LABEL $L.30)
  (LABEL $L.31)
  (VAR K (RANGE 0 64))
  (VAR L (RANGE 0 64))
  (VAR DIGIT-SENSED BOOLEAN)
  (VAR V QUARTERWORD)
  (VAR P TRIE-POINTER)
  (VAR Q TRIE-POINTER)
  (VAR FIRST-CHILD BOOLEAN)
  (VAR C ASCII-CODE)
  (COND (TRIE-NOT-READY
         (COND ((<= (SLOT (AREF EQTB 9213) INT) 0) (SETF CUR-LANG 0))
               ((> (SLOT (AREF EQTB 9213) INT) 255) (SETF CUR-LANG 0))
               (TRUE (SETF CUR-LANG (SLOT (AREF EQTB 9213) INT))))
         (SCAN-LEFT-BRACE)
         (SETF K 0)
         (SETF (AREF HYF 0) 0)
         (SETF DIGIT-SENSED FALSE)
         (WHILE TRUE
           (GET-X-TOKEN)
           (CASE CUR-CMD
             ((11 12)
              (COND ((OR (OR DIGIT-SENSED (< CUR-CHR 48)) (> CUR-CHR 57))
                     (COND ((= CUR-CHR 46) (SETF CUR-CHR 0))
                           (TRUE
                            (SETF CUR-CHR (SLOT (SLOT (AREF EQTB (+ 8139 CUR-CHR)) HH) RH))
                            (WHEN (= CUR-CHR 0)
                              (WHEN (= INTERACTION 3))
                              (PRINT-NL 262)
                              (PRINT 957)
                              (SETF HELP-PTR 1)
                              (SETF (AREF HELP-LINE 0) 956)
                              (ERROR))))
                     (WHEN (< K 63)
                       (INCF K 1)
                       (SETF (AREF HC K) CUR-CHR)
                       (SETF (AREF HYF K) 0)
                       (SETF DIGIT-SENSED FALSE)))
                    ((< K 63) (SETF (AREF HYF K) (- CUR-CHR 48)) (SETF DIGIT-SENSED TRUE))))
             ((10 2)
              (WHEN (> K 0)
                (WHEN (= (AREF HC 1) 0) (SETF (AREF HYF 0) 0))
                (WHEN (= (AREF HC K) 0) (SETF (AREF HYF K) 0))
                (SETF L K)
                (SETF V 0)
                (WHILE TRUE
                  (WHEN (/= (AREF HYF L) 0) (SETF V (NEW-TRIE-OP (- K L) (AREF HYF L) V)))
                  (COND ((> L 0) (DECF L 1)) (TRUE (GOTO $L.31))))
                $L.31
                (SETF Q 0)
                (SETF (AREF HC 0) CUR-LANG)
                (WHILE (<= L K)
                  (SETF C (AREF HC L))
                  (INCF L 1)
                  (SETF P (AREF TRIE-L Q))
                  (SETF FIRST-CHILD TRUE)
                  (WHILE (AND (> P 0) (> C (AREF TRIE-C P)))
                    (SETF Q P)
                    (SETF P (AREF TRIE-R Q))
                    (SETF FIRST-CHILD FALSE))
                  (WHEN (OR (= P 0) (< C (AREF TRIE-C P)))
                    (WHEN (= TRIE-PTR TRIE-SIZE) (OVERFLOW 951 TRIE-SIZE))
                    (INCF TRIE-PTR 1)
                    (SETF (AREF TRIE-R TRIE-PTR) P)
                    (SETF P TRIE-PTR)
                    (SETF (AREF TRIE-L P) 0)
                    (COND (FIRST-CHILD (SETF (AREF TRIE-L Q) P))
                          (TRUE (SETF (AREF TRIE-R Q) P)))
                    (SETF (AREF TRIE-C P) C)
                    (SETF (AREF TRIE-O P) 0))
                  (SETF Q P))
                (WHEN (/= (AREF TRIE-O Q) 0)
                  (WHEN (= INTERACTION 3))
                  (PRINT-NL 262)
                  (PRINT 958)
                  (SETF HELP-PTR 1)
                  (SETF (AREF HELP-LINE 0) 956)
                  (ERROR))
                (SETF (AREF TRIE-O Q) V))
              (WHEN (= CUR-CMD 2) (GOTO $L.30)) (SETF K 0) (SETF (AREF HYF 0) 0)
              (SETF DIGIT-SENSED FALSE))
             (ELSE (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 955) (PRINT-ESC 953)
              (SETF HELP-PTR 1) (SETF (AREF HELP-LINE 0) 956) (ERROR))))
         $L.30)
        (TRUE
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 952)
         (PRINT-ESC 953)
         (SETF HELP-PTR 1)
         (SETF (AREF HELP-LINE 0) 954)
         (ERROR)
         (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH) (SCAN-TOKS FALSE FALSE))
         (FLUSH-LIST DEF-REF))))

(PROCEDURE INIT-TRIE ()
  (VAR P TRIE-POINTER)
  (VAR J INTEGER)
  (VAR K INTEGER)
  (VAR T INTEGER)
  (VAR R TRIE-POINTER)
  (VAR S TRIE-POINTER)
  (VAR H TWO-HALVES)
  (SETF (AREF OP-START 0) (- 0))
  (FOR (J 1 TO 255)
    (SETF (AREF OP-START J) (- (+ (AREF OP-START (- J 1)) (AREF TRIE-USED (- J 1))) 0)))
  (FOR (J 1 TO TRIE-OP-PTR)
    (SETF (AREF TRIE-OP-HASH J)
          (+ (AREF OP-START (AREF TRIE-OP-LANG J)) (AREF TRIE-OP-VAL J))))
  (FOR (J 1 TO TRIE-OP-PTR)
    (WHILE (> (AREF TRIE-OP-HASH J) J)
      (SETF K (AREF TRIE-OP-HASH J))
      (SETF T (AREF HYF-DISTANCE K))
      (SETF (AREF HYF-DISTANCE K) (AREF HYF-DISTANCE J))
      (SETF (AREF HYF-DISTANCE J) T)
      (SETF T (AREF HYF-NUM K))
      (SETF (AREF HYF-NUM K) (AREF HYF-NUM J))
      (SETF (AREF HYF-NUM J) T)
      (SETF T (AREF HYF-NEXT K))
      (SETF (AREF HYF-NEXT K) (AREF HYF-NEXT J))
      (SETF (AREF HYF-NEXT J) T)
      (SETF (AREF TRIE-OP-HASH J) (AREF TRIE-OP-HASH K))
      (SETF (AREF TRIE-OP-HASH K) K)))
  (FOR (P 0 TO TRIE-SIZE) (SETF (AREF TRIE-HASH P) 0))
  (SETF (AREF TRIE-L 0) (COMPRESS-TRIE (AREF TRIE-L 0)))
  (FOR (P 0 TO TRIE-PTR) (SETF (AREF TRIE-HASH P) 0))
  (FOR (P 0 TO 255) (SETF (AREF TRIE-MIN P) (+ P 1)))
  (SETF (SLOT (AREF TRIE 0) RH) 1)
  (SETF TRIE-MAX 0)
  (WHEN (/= (AREF TRIE-L 0) 0) (FIRST-FIT (AREF TRIE-L 0)) (TRIE-PACK (AREF TRIE-L 0)))
  (SETF (SLOT H RH) 0)
  (SETF (SLOT H B0) 0)
  (SETF (SLOT H B1) 0)
  (COND ((= (AREF TRIE-L 0) 0) (FOR (R 0 TO 256) (SETF (AREF TRIE R) H)) (SETF TRIE-MAX 256))
        (TRUE
         (TRIE-FIX (AREF TRIE-L 0))
         (SETF R 0)
         (REPEAT (SETF S (SLOT (AREF TRIE R) RH))
                 (SETF (AREF TRIE R) H)
                 (SETF R S)
                 (UNTIL (> R TRIE-MAX)))))
  (SETF (SLOT (AREF TRIE 0) B1) 63)
  (SETF TRIE-NOT-READY FALSE))

(PROCEDURE LINE-BREAK ((FINAL-WIDOW-PENALTY INTEGER))
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.32)
  (LABEL $L.33)
  (LABEL $L.34)
  (LABEL $L.35)
  (LABEL $L.22)
  (VAR AUTO-BREAKING BOOLEAN)
  (VAR PREV-P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR PREV-S HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR J SMALL-NUMBER)
  (VAR C (RANGE 0 255))
  (SETF PACK-BEGIN-LINE (SLOT CUR-LIST ML-FIELD))
  (SETF (SLOT (SLOT (AREF MEM 59997) HH) RH)
        (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
  (COND ((>= (SLOT CUR-LIST TAIL-FIELD) HI-MEM-MIN)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PENALTY 10000))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
        ((/= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 10)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PENALTY 10000))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
        (TRUE
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 12)
         (DELETE-GLUE-REF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH))
         (FLUSH-NODE-LIST (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH))
         (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT) 10000)))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PARAM-GLUE 14))
  (SETF INIT-CUR-LANG (MOD (SLOT CUR-LIST PG-FIELD) 65536))
  (SETF INIT-L-HYF (DIV (SLOT CUR-LIST PG-FIELD) 4194304))
  (SETF INIT-R-HYF (MOD (DIV (SLOT CUR-LIST PG-FIELD) 65536) 64))
  (POP-NEST)
  (SETF NO-SHRINK-ERROR-YET TRUE)
  (WHEN (AND (/= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 6789) HH) RH)) HH) B1) 0)
             (/= (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB 6789) HH) RH) 3)) INT) 0))
    (SETF (SLOT (SLOT (AREF EQTB 6789) HH) RH)
          (FINITE-SHRINK (SLOT (SLOT (AREF EQTB 6789) HH) RH))))
  (WHEN (AND (/= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 6790) HH) RH)) HH) B1) 0)
             (/= (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB 6790) HH) RH) 3)) INT) 0))
    (SETF (SLOT (SLOT (AREF EQTB 6790) HH) RH)
          (FINITE-SHRINK (SLOT (SLOT (AREF EQTB 6790) HH) RH))))
  (SETF Q (SLOT (SLOT (AREF EQTB 6789) HH) RH))
  (SETF R (SLOT (SLOT (AREF EQTB 6790) HH) RH))
  (SETF (AREF BACKGROUND 1) (+ (SLOT (AREF MEM (+ Q 1)) INT) (SLOT (AREF MEM (+ R 1)) INT)))
  (SETF (AREF BACKGROUND 2) 0)
  (SETF (AREF BACKGROUND 3) 0)
  (SETF (AREF BACKGROUND 4) 0)
  (SETF (AREF BACKGROUND 5) 0)
  (SETF (AREF BACKGROUND (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0))) (SLOT (AREF MEM (+ Q 2)) INT))
  (SETF (AREF BACKGROUND (+ 2 (SLOT (SLOT (AREF MEM R) HH) B0)))
        (+ (AREF BACKGROUND (+ 2 (SLOT (SLOT (AREF MEM R) HH) B0)))
           (SLOT (AREF MEM (+ R 2)) INT)))
  (SETF (AREF BACKGROUND 6) (+ (SLOT (AREF MEM (+ Q 3)) INT) (SLOT (AREF MEM (+ R 3)) INT)))
  (SETF MINIMUM-DEMERITS 1073741823)
  (SETF (AREF MINIMAL-DEMERITS 3) 1073741823)
  (SETF (AREF MINIMAL-DEMERITS 2) 1073741823)
  (SETF (AREF MINIMAL-DEMERITS 1) 1073741823)
  (SETF (AREF MINIMAL-DEMERITS 0) 1073741823)
  (COND ((= (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0)
         (COND ((= (SLOT (AREF EQTB 9747) INT) 0)
                (SETF LAST-SPECIAL-LINE 0)
                (SETF SECOND-WIDTH (SLOT (AREF EQTB 9733) INT))
                (SETF SECOND-INDENT 0))
               (TRUE
                (SETF LAST-SPECIAL-LINE (ABS (SLOT (AREF EQTB 9204) INT)))
                (COND ((< (SLOT (AREF EQTB 9204) INT) 0)
                       (SETF FIRST-WIDTH
                             (- (SLOT (AREF EQTB 9733) INT) (ABS (SLOT (AREF EQTB 9747) INT))))
                       (COND ((>= (SLOT (AREF EQTB 9747) INT) 0)
                              (SETF FIRST-INDENT (SLOT (AREF EQTB 9747) INT)))
                             (TRUE (SETF FIRST-INDENT 0)))
                       (SETF SECOND-WIDTH (SLOT (AREF EQTB 9733) INT))
                       (SETF SECOND-INDENT 0))
                      (TRUE
                       (SETF FIRST-WIDTH (SLOT (AREF EQTB 9733) INT))
                       (SETF FIRST-INDENT 0)
                       (SETF SECOND-WIDTH
                             (- (SLOT (AREF EQTB 9733) INT) (ABS (SLOT (AREF EQTB 9747) INT))))
                       (COND ((>= (SLOT (AREF EQTB 9747) INT) 0)
                              (SETF SECOND-INDENT (SLOT (AREF EQTB 9747) INT)))
                             (TRUE (SETF SECOND-INDENT 0))))))))
        (TRUE
         (SETF LAST-SPECIAL-LINE
               (- (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 7312) HH) RH)) HH) LH) 1))
         (SETF SECOND-WIDTH
               (SLOT (AREF MEM
                           (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH)
                              (* 2 (+ LAST-SPECIAL-LINE 1))))
                     INT))
         (SETF SECOND-INDENT
               (SLOT (AREF MEM
                           (+ (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH) (* 2 LAST-SPECIAL-LINE))
                              1))
                     INT))))
  (COND ((= (SLOT (AREF EQTB 9182) INT) 0) (SETF EASY-LINE LAST-SPECIAL-LINE))
        (TRUE (SETF EASY-LINE 65535)))
  (SETF THRESHOLD (SLOT (AREF EQTB 9163) INT))
  (COND ((>= THRESHOLD 0) (SETF SECOND-PASS FALSE) (SETF FINAL-PASS FALSE))
        (TRUE
         (SETF THRESHOLD (SLOT (AREF EQTB 9164) INT))
         (SETF SECOND-PASS TRUE)
         (SETF FINAL-PASS (<= (SLOT (AREF EQTB 9750) INT) 0))))
  (WHILE TRUE
    (WHEN (> THRESHOLD 10000) (SETF THRESHOLD 10000))
    (WHEN SECOND-PASS
      (WHEN TRIE-NOT-READY (INIT-TRIE))
      (SETF CUR-LANG INIT-CUR-LANG)
      (SETF L-HYF INIT-L-HYF)
      (SETF R-HYF INIT-R-HYF))
    (SETF Q (GET-NODE 3))
    (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 0)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 2)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 59993)
    (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 0)
    (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) (+ (SLOT CUR-LIST PG-FIELD) 1))
    (SETF (SLOT (AREF MEM (+ Q 2)) INT) 0)
    (SETF (SLOT (SLOT (AREF MEM 59993) HH) RH) Q)
    (SETF (AREF ACTIVE-WIDTH 1) (AREF BACKGROUND 1))
    (SETF (AREF ACTIVE-WIDTH 2) (AREF BACKGROUND 2))
    (SETF (AREF ACTIVE-WIDTH 3) (AREF BACKGROUND 3))
    (SETF (AREF ACTIVE-WIDTH 4) (AREF BACKGROUND 4))
    (SETF (AREF ACTIVE-WIDTH 5) (AREF BACKGROUND 5))
    (SETF (AREF ACTIVE-WIDTH 6) (AREF BACKGROUND 6))
    (SETF PASSIVE 0)
    (SETF PRINTED-NODE 59997)
    (SETF PASS-NUMBER 0)
    (SETF FONT-IN-SHORT-DISPLAY 0)
    (SETF CUR-P (SLOT (SLOT (AREF MEM 59997) HH) RH))
    (SETF AUTO-BREAKING TRUE)
    (SETF PREV-P CUR-P)
    (WHILE (AND (/= CUR-P 0) (/= (SLOT (SLOT (AREF MEM 59993) HH) RH) 59993))
      (WHEN (>= CUR-P HI-MEM-MIN)
        (SETF PREV-P CUR-P)
        (REPEAT (SETF F (SLOT (SLOT (AREF MEM CUR-P) HH) B0))
                (SETF (AREF ACTIVE-WIDTH 1)
                      (+ (AREF ACTIVE-WIDTH 1)
                         (SLOT (AREF FONT-INFO
                                     (+ (AREF WIDTH-BASE F)
                                        (SLOT (SLOT (AREF FONT-INFO
                                                          (+
                                                           (AREF CHAR-BASE F)
                                                           (SLOT
                                                            (SLOT (AREF MEM CUR-P) HH)
                                                            B1)))
                                                    QQQQ)
                                              B0)))
                               INT)))
                (SETF CUR-P (SLOT (SLOT (AREF MEM CUR-P) HH) RH))
                (UNTIL (NOT (>= CUR-P HI-MEM-MIN)))))
      (CASE (SLOT (SLOT (AREF MEM CUR-P) HH) B0)
        ((0 1 2)
         (SETF (AREF ACTIVE-WIDTH 1)
               (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ CUR-P 1)) INT))))
        ((8)
         (WHEN (= (SLOT (SLOT (AREF MEM CUR-P) HH) B1) 4)
           (SETF CUR-LANG (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) RH))
           (SETF L-HYF (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) B0))
           (SETF R-HYF (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) B1))))
        ((10)
         (WHEN AUTO-BREAKING
           (COND ((>= PREV-P HI-MEM-MIN) (TRY-BREAK 0 0))
                 ((< (SLOT (SLOT (AREF MEM PREV-P) HH) B0) 9) (TRY-BREAK 0 0))
                 ((AND (= (SLOT (SLOT (AREF MEM PREV-P) HH) B0) 11)
                       (/= (SLOT (SLOT (AREF MEM PREV-P) HH) B1) 1))
                  (TRY-BREAK 0 0))))
         (WHEN (AND (/= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH)) HH)
                              B1)
                        0)
                    (/= (SLOT (AREF MEM (+ (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH) 3)) INT)
                        0))
           (SETF (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH)
                 (FINITE-SHRINK (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH))))
         (SETF Q (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH))
         (SETF (AREF ACTIVE-WIDTH 1) (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ Q 1)) INT)))
         (SETF (AREF ACTIVE-WIDTH (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
               (+ (AREF ACTIVE-WIDTH (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                  (SLOT (AREF MEM (+ Q 2)) INT)))
         (SETF (AREF ACTIVE-WIDTH 6) (+ (AREF ACTIVE-WIDTH 6) (SLOT (AREF MEM (+ Q 3)) INT)))
         (WHEN (AND SECOND-PASS AUTO-BREAKING)
           (SETF PREV-S CUR-P)
           (SETF S (SLOT (SLOT (AREF MEM PREV-S) HH) RH))
           (WHEN (/= S 0)
             (WHILE TRUE
               (COND ((>= S HI-MEM-MIN)
                      (SETF C (- (SLOT (SLOT (AREF MEM S) HH) B1) 0))
                      (SETF HF (SLOT (SLOT (AREF MEM S) HH) B0)))
                     ((= (SLOT (SLOT (AREF MEM S) HH) B0) 6)
                      (COND ((= (SLOT (SLOT (AREF MEM (+ S 1)) HH) RH) 0) (GOTO $L.22))
                            (TRUE
                             (SETF Q (SLOT (SLOT (AREF MEM (+ S 1)) HH) RH))
                             (SETF C (- (SLOT (SLOT (AREF MEM Q) HH) B1) 0))
                             (SETF HF (SLOT (SLOT (AREF MEM Q) HH) B0)))))
                     ((AND (= (SLOT (SLOT (AREF MEM S) HH) B0) 11)
                           (= (SLOT (SLOT (AREF MEM S) HH) B1) 0))
                      (GOTO $L.22))
                     ((= (SLOT (SLOT (AREF MEM S) HH) B0) 8)
                      (WHEN (= (SLOT (SLOT (AREF MEM S) HH) B1) 4)
                        (SETF CUR-LANG (SLOT (SLOT (AREF MEM (+ S 1)) HH) RH))
                        (SETF L-HYF (SLOT (SLOT (AREF MEM (+ S 1)) HH) B0))
                        (SETF R-HYF (SLOT (SLOT (AREF MEM (+ S 1)) HH) B1)))
                      (GOTO $L.22))
                     (TRUE (GOTO $L.31)))
               (WHEN (/= (SLOT (SLOT (AREF EQTB (+ 8139 C)) HH) RH) 0)
                 (COND ((OR (= (SLOT (SLOT (AREF EQTB (+ 8139 C)) HH) RH) C)
                            (> (SLOT (AREF EQTB 9201) INT) 0))
                        (GOTO $L.32))
                       (TRUE (GOTO $L.31))))
               $L.22
               (SETF PREV-S S)
               (SETF S (SLOT (SLOT (AREF MEM PREV-S) HH) RH)))
             $L.32
             (SETF HYF-CHAR (AREF HYPHEN-CHAR HF))
             (WHEN (< HYF-CHAR 0) (GOTO $L.31))
             (WHEN (> HYF-CHAR 255) (GOTO $L.31))
             (SETF HA PREV-S)
             (WHEN (> (+ L-HYF R-HYF) 63) (GOTO $L.31))
             (SETF HN 0)
             (WHILE TRUE
               (COND ((>= S HI-MEM-MIN)
                      (WHEN (/= (SLOT (SLOT (AREF MEM S) HH) B0) HF) (GOTO $L.33))
                      (SETF HYF-BCHAR (SLOT (SLOT (AREF MEM S) HH) B1))
                      (SETF C (- HYF-BCHAR 0))
                      (WHEN (= (SLOT (SLOT (AREF EQTB (+ 8139 C)) HH) RH) 0) (GOTO $L.33))
                      (WHEN (= HN 63) (GOTO $L.33))
                      (SETF HB S)
                      (INCF HN 1)
                      (SETF (AREF HU HN) C)
                      (SETF (AREF HC HN) (SLOT (SLOT (AREF EQTB (+ 8139 C)) HH) RH))
                      (SETF HYF-BCHAR 256))
                     ((= (SLOT (SLOT (AREF MEM S) HH) B0) 6)
                      (WHEN (/= (SLOT (SLOT (AREF MEM (+ S 1)) HH) B0) HF) (GOTO $L.33))
                      (SETF J HN)
                      (SETF Q (SLOT (SLOT (AREF MEM (+ S 1)) HH) RH))
                      (WHEN (> Q 0) (SETF HYF-BCHAR (SLOT (SLOT (AREF MEM Q) HH) B1)))
                      (WHILE (> Q 0)
                        (SETF C (- (SLOT (SLOT (AREF MEM Q) HH) B1) 0))
                        (WHEN (= (SLOT (SLOT (AREF EQTB (+ 8139 C)) HH) RH) 0) (GOTO $L.33))
                        (WHEN (= J 63) (GOTO $L.33))
                        (INCF J 1)
                        (SETF (AREF HU J) C)
                        (SETF (AREF HC J) (SLOT (SLOT (AREF EQTB (+ 8139 C)) HH) RH))
                        (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))
                      (SETF HB S)
                      (SETF HN J)
                      (COND ((ODD (SLOT (SLOT (AREF MEM S) HH) B1))
                             (SETF HYF-BCHAR (AREF FONT-BCHAR HF)))
                            (TRUE (SETF HYF-BCHAR 256))))
                     ((AND (= (SLOT (SLOT (AREF MEM S) HH) B0) 11)
                           (= (SLOT (SLOT (AREF MEM S) HH) B1) 0))
                      (SETF HB S)
                      (SETF HYF-BCHAR (AREF FONT-BCHAR HF)))
                     (TRUE (GOTO $L.33)))
               (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
             $L.33
             (WHEN (< HN (+ L-HYF R-HYF)) (GOTO $L.31))
             (WHILE TRUE
               (UNLESS (>= S HI-MEM-MIN)
                 (CASE (SLOT (SLOT (AREF MEM S) HH) B0)
                   ((6))
                   ((11) (WHEN (/= (SLOT (SLOT (AREF MEM S) HH) B1) 0) (GOTO $L.34)))
                   ((8 10 12 3 5 4) (GOTO $L.34))
                   (ELSE (GOTO $L.31))))
               (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
             $L.34
             (HYPHENATE))
           $L.31))
        ((11)
         (COND ((= (SLOT (SLOT (AREF MEM CUR-P) HH) B1) 1)
                (WHEN (AND (NOT (>= (SLOT (SLOT (AREF MEM CUR-P) HH) RH) HI-MEM-MIN))
                           AUTO-BREAKING)
                  (WHEN (= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM CUR-P) HH) RH)) HH) B0)
                           10)
                    (TRY-BREAK 0 0)))
                (SETF (AREF ACTIVE-WIDTH 1)
                      (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ CUR-P 1)) INT))))
               (TRUE
                (SETF (AREF ACTIVE-WIDTH 1)
                      (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ CUR-P 1)) INT))))))
        ((6) (SETF F (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) B0))
         (SETF (AREF ACTIVE-WIDTH 1)
               (+ (AREF ACTIVE-WIDTH 1)
                  (SLOT (AREF FONT-INFO
                              (+ (AREF WIDTH-BASE F)
                                 (SLOT (SLOT (AREF FONT-INFO
                                                   (+ (AREF CHAR-BASE F)
                                                      (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH)
                                                            B1)))
                                             QQQQ)
                                       B0)))
                        INT))))
        ((7) (SETF S (SLOT (SLOT (AREF MEM (+ CUR-P 1)) HH) LH)) (SETF DISC-WIDTH 0)
         (COND ((= S 0) (TRY-BREAK (SLOT (AREF EQTB 9167) INT) 1))
               (TRUE
                (REPEAT (COND ((>= S HI-MEM-MIN)
                               (SETF F (SLOT (SLOT (AREF MEM S) HH) B0))
                               (INCF DISC-WIDTH
                                (SLOT (AREF FONT-INFO
                                            (+ (AREF WIDTH-BASE F)
                                               (SLOT (SLOT (AREF
                                                            FONT-INFO
                                                            (+
                                                             (AREF CHAR-BASE F)
                                                             (SLOT (SLOT (AREF MEM S) HH) B1)))
                                                           QQQQ)
                                                     B0)))
                                      INT)))
                              (TRUE
                               (CASE (SLOT (SLOT (AREF MEM S) HH) B0)
                                 ((6) (SETF F (SLOT (SLOT (AREF MEM (+ S 1)) HH) B0))
                                  (INCF DISC-WIDTH
                                   (SLOT (AREF FONT-INFO
                                               (+ (AREF WIDTH-BASE F)
                                                  (SLOT (SLOT
                                                         (AREF
                                                          FONT-INFO
                                                          (+
                                                           (AREF CHAR-BASE F)
                                                           (SLOT
                                                            (SLOT (AREF MEM (+ S 1)) HH)
                                                            B1)))
                                                         QQQQ)
                                                        B0)))
                                         INT)))
                                 ((0 1 2 11) (INCF DISC-WIDTH (SLOT (AREF MEM (+ S 1)) INT)))
                                 (ELSE (CONFUSION 937)))))
                        (SETF S (SLOT (SLOT (AREF MEM S) HH) RH))
                        (UNTIL (= S 0)))
                (SETF (AREF ACTIVE-WIDTH 1) (+ (AREF ACTIVE-WIDTH 1) DISC-WIDTH))
                (TRY-BREAK (SLOT (AREF EQTB 9166) INT) 1)
                (SETF (AREF ACTIVE-WIDTH 1) (- (AREF ACTIVE-WIDTH 1) DISC-WIDTH))))
         (SETF R (SLOT (SLOT (AREF MEM CUR-P) HH) B1))
         (SETF S (SLOT (SLOT (AREF MEM CUR-P) HH) RH))
         (WHILE (> R 0)
           (COND ((>= S HI-MEM-MIN)
                  (SETF F (SLOT (SLOT (AREF MEM S) HH) B0))
                  (SETF (AREF ACTIVE-WIDTH 1)
                        (+ (AREF ACTIVE-WIDTH 1)
                           (SLOT (AREF FONT-INFO
                                       (+ (AREF WIDTH-BASE F)
                                          (SLOT (SLOT (AREF FONT-INFO
                                                            (+
                                                             (AREF CHAR-BASE F)
                                                             (SLOT (SLOT (AREF MEM S) HH) B1)))
                                                      QQQQ)
                                                B0)))
                                 INT))))
                 (TRUE
                  (CASE (SLOT (SLOT (AREF MEM S) HH) B0)
                    ((6) (SETF F (SLOT (SLOT (AREF MEM (+ S 1)) HH) B0))
                     (SETF (AREF ACTIVE-WIDTH 1)
                           (+ (AREF ACTIVE-WIDTH 1)
                              (SLOT (AREF FONT-INFO
                                          (+ (AREF WIDTH-BASE F)
                                             (SLOT (SLOT (AREF
                                                          FONT-INFO
                                                          (+
                                                           (AREF CHAR-BASE F)
                                                           (SLOT
                                                            (SLOT (AREF MEM (+ S 1)) HH)
                                                            B1)))
                                                         QQQQ)
                                                   B0)))
                                    INT))))
                    ((0 1 2 11)
                     (SETF (AREF ACTIVE-WIDTH 1)
                           (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ S 1)) INT))))
                    (ELSE (CONFUSION 938)))))
           (DECF R 1)
           (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
         (SETF PREV-P CUR-P) (SETF CUR-P S) (GOTO $L.35))
        ((9) (SETF AUTO-BREAKING (= (SLOT (SLOT (AREF MEM CUR-P) HH) B1) 1))
         (WHEN (AND (NOT (>= (SLOT (SLOT (AREF MEM CUR-P) HH) RH) HI-MEM-MIN)) AUTO-BREAKING)
           (WHEN (= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM CUR-P) HH) RH)) HH) B0) 10)
             (TRY-BREAK 0 0)))
         (SETF (AREF ACTIVE-WIDTH 1)
               (+ (AREF ACTIVE-WIDTH 1) (SLOT (AREF MEM (+ CUR-P 1)) INT))))
        ((12) (TRY-BREAK (SLOT (AREF MEM (+ CUR-P 1)) INT) 0))
        ((4 3 5))
        (ELSE (CONFUSION 936)))
      (SETF PREV-P CUR-P)
      (SETF CUR-P (SLOT (SLOT (AREF MEM CUR-P) HH) RH))
      $L.35)
    (WHEN (= CUR-P 0)
      (TRY-BREAK (- 10000) 1)
      (WHEN (/= (SLOT (SLOT (AREF MEM 59993) HH) RH) 59993)
        (SETF R (SLOT (SLOT (AREF MEM 59993) HH) RH))
        (SETF FEWEST-DEMERITS 1073741823)
        (REPEAT (WHEN (/= (SLOT (SLOT (AREF MEM R) HH) B0) 2)
                  (WHEN (< (SLOT (AREF MEM (+ R 2)) INT) FEWEST-DEMERITS)
                    (SETF FEWEST-DEMERITS (SLOT (AREF MEM (+ R 2)) INT))
                    (SETF BEST-BET R)))
                (SETF R (SLOT (SLOT (AREF MEM R) HH) RH))
                (UNTIL (= R 59993)))
        (SETF BEST-LINE (SLOT (SLOT (AREF MEM (+ BEST-BET 1)) HH) LH))
        (WHEN (= (SLOT (AREF EQTB 9182) INT) 0) (GOTO $L.30))
        (SETF R (SLOT (SLOT (AREF MEM 59993) HH) RH))
        (SETF ACTUAL-LOOSENESS 0)
        (REPEAT (WHEN (/= (SLOT (SLOT (AREF MEM R) HH) B0) 2)
                  (SETF LINE-DIFF (- (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH) BEST-LINE))
                  (COND ((OR (AND (< LINE-DIFF ACTUAL-LOOSENESS)
                                  (<= (SLOT (AREF EQTB 9182) INT) LINE-DIFF))
                             (AND (> LINE-DIFF ACTUAL-LOOSENESS)
                                  (>= (SLOT (AREF EQTB 9182) INT) LINE-DIFF)))
                         (SETF BEST-BET R)
                         (SETF ACTUAL-LOOSENESS LINE-DIFF)
                         (SETF FEWEST-DEMERITS (SLOT (AREF MEM (+ R 2)) INT)))
                        ((AND (= LINE-DIFF ACTUAL-LOOSENESS)
                              (< (SLOT (AREF MEM (+ R 2)) INT) FEWEST-DEMERITS))
                         (SETF BEST-BET R)
                         (SETF FEWEST-DEMERITS (SLOT (AREF MEM (+ R 2)) INT)))))
                (SETF R (SLOT (SLOT (AREF MEM R) HH) RH))
                (UNTIL (= R 59993)))
        (SETF BEST-LINE (SLOT (SLOT (AREF MEM (+ BEST-BET 1)) HH) LH))
        (WHEN (OR (= ACTUAL-LOOSENESS (SLOT (AREF EQTB 9182) INT)) FINAL-PASS) (GOTO $L.30))))
    (SETF Q (SLOT (SLOT (AREF MEM 59993) HH) RH))
    (WHILE (/= Q 59993)
      (SETF CUR-P (SLOT (SLOT (AREF MEM Q) HH) RH))
      (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 2) (FREE-NODE Q 7)) (TRUE (FREE-NODE Q 3)))
      (SETF Q CUR-P))
    (SETF Q PASSIVE)
    (WHILE (/= Q 0)
      (SETF CUR-P (SLOT (SLOT (AREF MEM Q) HH) RH))
      (FREE-NODE Q 2)
      (SETF Q CUR-P))
    (COND ((NOT SECOND-PASS)
           (SETF THRESHOLD (SLOT (AREF EQTB 9164) INT))
           (SETF SECOND-PASS TRUE)
           (SETF FINAL-PASS (<= (SLOT (AREF EQTB 9750) INT) 0)))
          (TRUE
           (SETF (AREF BACKGROUND 2) (+ (AREF BACKGROUND 2) (SLOT (AREF EQTB 9750) INT)))
           (SETF FINAL-PASS TRUE))))
  $L.30
  (POST-LINE-BREAK FINAL-WIDOW-PENALTY)
  (SETF Q (SLOT (SLOT (AREF MEM 59993) HH) RH))
  (WHILE (/= Q 59993)
    (SETF CUR-P (SLOT (SLOT (AREF MEM Q) HH) RH))
    (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 2) (FREE-NODE Q 7)) (TRUE (FREE-NODE Q 3)))
    (SETF Q CUR-P))
  (SETF Q PASSIVE)
  (WHILE (/= Q 0) (SETF CUR-P (SLOT (SLOT (AREF MEM Q) HH) RH)) (FREE-NODE Q 2) (SETF Q CUR-P))
  (SETF PACK-BEGIN-LINE 0))

(PROCEDURE NEW-HYPH-EXCEPTIONS ()
  (LABEL $L.21)
  (LABEL $L.10)
  (LABEL $L.40)
  (LABEL $L.45)
  (VAR N (RANGE 0 64))
  (VAR J (RANGE 0 64))
  (VAR H HYPH-POINTER)
  (VAR K STR-NUMBER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR S STR-NUMBER)
  (VAR T STR-NUMBER)
  (VAR U POOL-POINTER)
  (VAR V POOL-POINTER)
  (SCAN-LEFT-BRACE)
  (COND ((<= (SLOT (AREF EQTB 9213) INT) 0) (SETF CUR-LANG 0))
        ((> (SLOT (AREF EQTB 9213) INT) 255) (SETF CUR-LANG 0))
        (TRUE (SETF CUR-LANG (SLOT (AREF EQTB 9213) INT))))
  (SETF N 0)
  (SETF P 0)
  (WHILE TRUE
    (GET-X-TOKEN)
    $L.21
    (CASE CUR-CMD
      ((11 12 68)
       (COND ((= CUR-CHR 45)
              (WHEN (< N 63)
                (SETF Q GET-AVAIL)
                (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
                (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) N)
                (SETF P Q)))
             ((= (SLOT (SLOT (AREF EQTB (+ 8139 CUR-CHR)) HH) RH) 0)
              (WHEN (= INTERACTION 3))
              (PRINT-NL 262)
              (PRINT 945)
              (SETF HELP-PTR 2)
              (SETF (AREF HELP-LINE 1) 946)
              (SETF (AREF HELP-LINE 0) 947)
              (ERROR))
             ((< N 63)
              (INCF N 1)
              (SETF (AREF HC N) (SLOT (SLOT (AREF EQTB (+ 8139 CUR-CHR)) HH) RH)))))
      ((16) (SCAN-CHAR-NUM) (SETF CUR-CHR CUR-VAL) (SETF CUR-CMD 68) (GOTO $L.21))
      ((10 2)
       (WHEN (> N 1)
         (INCF N 1)
         (SETF (AREF HC N) CUR-LANG)
         (WHEN (> (+ POOL-PTR N) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
         (SETF H 0)
         (FOR (J 1 TO N)
           (SETF H (MOD (+ (+ H H) (AREF HC J)) 307))
           (SETF (AREF STR-POOL POOL-PTR) (AREF HC J))
           (INCF POOL-PTR 1))
         (SETF S MAKE-STRING)
         (WHEN (= HYPH-COUNT 307) (OVERFLOW 948 307))
         (INCF HYPH-COUNT 1)
         (WHILE (/= (AREF HYPH-WORD H) 0)
           (SETF K (AREF HYPH-WORD H))
           (WHEN (< (- (AREF STR-START (+ K 1)) (AREF STR-START K))
                    (- (AREF STR-START (+ S 1)) (AREF STR-START S)))
             (GOTO $L.40))
           (WHEN (> (- (AREF STR-START (+ K 1)) (AREF STR-START K))
                    (- (AREF STR-START (+ S 1)) (AREF STR-START S)))
             (GOTO $L.45))
           (SETF U (AREF STR-START K))
           (SETF V (AREF STR-START S))
           (REPEAT (WHEN (< (AREF STR-POOL U) (AREF STR-POOL V)) (GOTO $L.40))
                   (WHEN (> (AREF STR-POOL U) (AREF STR-POOL V)) (GOTO $L.45))
                   (INCF U 1)
                   (INCF V 1)
                   (UNTIL (= U (AREF STR-START (+ K 1)))))
           $L.40
           (SETF Q (AREF HYPH-LIST H))
           (SETF (AREF HYPH-LIST H) P)
           (SETF P Q)
           (SETF T (AREF HYPH-WORD H))
           (SETF (AREF HYPH-WORD H) S)
           (SETF S T)
           $L.45
           (COND ((> H 0) (DECF H 1)) (TRUE (SETF H 307))))
         (SETF (AREF HYPH-WORD H) S)
         (SETF (AREF HYPH-LIST H) P))
       (WHEN (= CUR-CMD 2) (GOTO $L.10)) (SETF N 0) (SETF P 0))
      (ELSE (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 680) (PRINT-ESC 941) (PRINT 942)
       (SETF HELP-PTR 2) (SETF (AREF HELP-LINE 1) 943) (SETF (AREF HELP-LINE 0) 944) (ERROR))))
  $L.10)

(FUNCTION (PRUNE-PAGE-TOP HALFWORD) ((P HALFWORD))
  (VAR PREV-P HALFWORD)
  (VAR Q HALFWORD)
  (SETF PREV-P 59997)
  (SETF (SLOT (SLOT (AREF MEM 59997) HH) RH) P)
  (WHILE (/= P 0)
    (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
      ((0 1 2) (SETF Q (NEW-SKIP-PARAM 10)) (SETF (SLOT (SLOT (AREF MEM PREV-P) HH) RH) Q)
       (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
       (COND ((> (SLOT (AREF MEM (+ TEMP-PTR 1)) INT) (SLOT (AREF MEM (+ P 3)) INT))
              (SETF (SLOT (AREF MEM (+ TEMP-PTR 1)) INT)
                    (- (SLOT (AREF MEM (+ TEMP-PTR 1)) INT) (SLOT (AREF MEM (+ P 3)) INT))))
             (TRUE (SETF (SLOT (AREF MEM (+ TEMP-PTR 1)) INT) 0)))
       (SETF P 0))
      ((8 4 3) (SETF PREV-P P) (SETF P (SLOT (SLOT (AREF MEM PREV-P) HH) RH)))
      ((10 11 12) (SETF Q P) (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
       (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0) (SETF (SLOT (SLOT (AREF MEM PREV-P) HH) RH) P)
       (FLUSH-NODE-LIST Q))
      (ELSE (CONFUSION 959))))
  (SETF PRUNE-PAGE-TOP (SLOT (SLOT (AREF MEM 59997) HH) RH)))

(FUNCTION (VERT-BREAK HALFWORD) ((P HALFWORD) (H SCALED) (D SCALED))
  (LABEL $L.30)
  (LABEL $L.45)
  (LABEL $L.90)
  (VAR PREV-P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR PI INTEGER)
  (VAR B INTEGER)
  (VAR LEAST-COST INTEGER)
  (VAR BEST-PLACE HALFWORD)
  (VAR PREV-DP SCALED)
  (VAR T SMALL-NUMBER)
  (SETF PREV-P P)
  (SETF LEAST-COST 1073741823)
  (SETF (AREF ACTIVE-WIDTH 1) 0)
  (SETF (AREF ACTIVE-WIDTH 2) 0)
  (SETF (AREF ACTIVE-WIDTH 3) 0)
  (SETF (AREF ACTIVE-WIDTH 4) 0)
  (SETF (AREF ACTIVE-WIDTH 5) 0)
  (SETF (AREF ACTIVE-WIDTH 6) 0)
  (SETF PREV-DP 0)
  (WHILE TRUE
    (COND ((= P 0) (SETF PI (- 10000)))
          (TRUE
           (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
             ((0 1 2)
              (SETF (AREF ACTIVE-WIDTH 1)
                    (+ (+ (AREF ACTIVE-WIDTH 1) PREV-DP) (SLOT (AREF MEM (+ P 3)) INT)))
              (SETF PREV-DP (SLOT (AREF MEM (+ P 2)) INT)) (GOTO $L.45))
             ((8) (GOTO $L.45))
             ((10)
              (COND ((< (SLOT (SLOT (AREF MEM PREV-P) HH) B0) 9) (SETF PI 0))
                    (TRUE (GOTO $L.90))))
             ((11)
              (COND ((= (SLOT (SLOT (AREF MEM P) HH) RH) 0) (SETF T 12))
                    (TRUE
                     (SETF T (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM P) HH) RH)) HH) B0))))
              (COND ((= T 10) (SETF PI 0)) (TRUE (GOTO $L.90))))
             ((12) (SETF PI (SLOT (AREF MEM (+ P 1)) INT)))
             ((4 3) (GOTO $L.45))
             (ELSE (CONFUSION 960)))))
    (WHEN (< PI 10000)
      (COND ((< (AREF ACTIVE-WIDTH 1) H)
             (COND ((OR (OR (/= (AREF ACTIVE-WIDTH 3) 0) (/= (AREF ACTIVE-WIDTH 4) 0))
                        (/= (AREF ACTIVE-WIDTH 5) 0))
                    (SETF B 0))
                   (TRUE
                    (SETF B (BADNESS (- H (AREF ACTIVE-WIDTH 1)) (AREF ACTIVE-WIDTH 2))))))
            ((> (- (AREF ACTIVE-WIDTH 1) H) (AREF ACTIVE-WIDTH 6)) (SETF B 1073741823))
            (TRUE (SETF B (BADNESS (- (AREF ACTIVE-WIDTH 1) H) (AREF ACTIVE-WIDTH 6)))))
      (WHEN (< B 1073741823)
        (COND ((<= PI (- 10000)) (SETF B PI))
              ((< B 10000) (INCF B PI))
              (TRUE (SETF B 100000))))
      (WHEN (<= B LEAST-COST)
        (SETF BEST-PLACE P)
        (SETF LEAST-COST B)
        (SETF BEST-HEIGHT-PLUS-DEPTH (+ (AREF ACTIVE-WIDTH 1) PREV-DP)))
      (WHEN (OR (= B 1073741823) (<= PI (- 10000))) (GOTO $L.30)))
    (WHEN (OR (< (SLOT (SLOT (AREF MEM P) HH) B0) 10) (> (SLOT (SLOT (AREF MEM P) HH) B0) 11))
      (GOTO $L.45))
    $L.90
    (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 11) (SETF Q P))
          (TRUE
           (SETF Q (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
           (SETF (AREF ACTIVE-WIDTH (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                 (+ (AREF ACTIVE-WIDTH (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                    (SLOT (AREF MEM (+ Q 2)) INT)))
           (SETF (AREF ACTIVE-WIDTH 6) (+ (AREF ACTIVE-WIDTH 6) (SLOT (AREF MEM (+ Q 3)) INT)))
           (WHEN (AND (/= (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
                      (/= (SLOT (AREF MEM (+ Q 3)) INT) 0))
             (WHEN (= INTERACTION 3))
             (PRINT-NL 262)
             (PRINT 961)
             (SETF HELP-PTR 4)
             (SETF (AREF HELP-LINE 3) 962)
             (SETF (AREF HELP-LINE 2) 963)
             (SETF (AREF HELP-LINE 1) 964)
             (SETF (AREF HELP-LINE 0) 922)
             (ERROR)
             (SETF R (NEW-SPEC Q))
             (SETF (SLOT (SLOT (AREF MEM R) HH) B1) 0)
             (DELETE-GLUE-REF Q)
             (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) R)
             (SETF Q R))))
    (SETF (AREF ACTIVE-WIDTH 1)
          (+ (+ (AREF ACTIVE-WIDTH 1) PREV-DP) (SLOT (AREF MEM (+ Q 1)) INT)))
    (SETF PREV-DP 0)
    $L.45
    (WHEN (> PREV-DP D)
      (SETF (AREF ACTIVE-WIDTH 1) (- (+ (AREF ACTIVE-WIDTH 1) PREV-DP) D))
      (SETF PREV-DP D))
    (SETF PREV-P P)
    (SETF P (SLOT (SLOT (AREF MEM PREV-P) HH) RH)))
  $L.30
  (SETF VERT-BREAK BEST-PLACE))

(FUNCTION (VSPLIT HALFWORD) ((N EIGHT-BITS) (H SCALED))
  (LABEL $L.10)
  (LABEL $L.30)
  (VAR V HALFWORD)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (SETF V (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH))
  (WHEN (/= (AREF CUR-MARK 3) 0)
    (DELETE-TOKEN-REF (AREF CUR-MARK 3))
    (SETF (AREF CUR-MARK 3) 0)
    (DELETE-TOKEN-REF (AREF CUR-MARK 4))
    (SETF (AREF CUR-MARK 4) 0))
  (WHEN (= V 0) (SETF VSPLIT 0) (GOTO $L.10))
  (WHEN (/= (SLOT (SLOT (AREF MEM V) HH) B0) 1)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 338)
    (PRINT-ESC 965)
    (PRINT 966)
    (PRINT-ESC 967)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 968)
    (SETF (AREF HELP-LINE 0) 969)
    (ERROR)
    (SETF VSPLIT 0)
    (GOTO $L.10))
  (SETF Q (VERT-BREAK (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH) H (SLOT (AREF EQTB 9736) INT)))
  (SETF P (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH))
  (COND ((= P Q) (SETF (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH) 0))
        (TRUE
         (WHILE TRUE
           (WHEN (= (SLOT (SLOT (AREF MEM P) HH) B0) 4)
             (COND ((= (AREF CUR-MARK 3) 0)
                    (SETF (AREF CUR-MARK 3) (SLOT (AREF MEM (+ P 1)) INT))
                    (SETF (AREF CUR-MARK 4) (AREF CUR-MARK 3))
                    (SETF (SLOT (SLOT (AREF MEM (AREF CUR-MARK 3)) HH) LH)
                          (+ (SLOT (SLOT (AREF MEM (AREF CUR-MARK 3)) HH) LH) 2)))
                   (TRUE
                    (DELETE-TOKEN-REF (AREF CUR-MARK 4))
                    (SETF (AREF CUR-MARK 4) (SLOT (AREF MEM (+ P 1)) INT))
                    (SETF (SLOT (SLOT (AREF MEM (AREF CUR-MARK 4)) HH) LH)
                          (+ (SLOT (SLOT (AREF MEM (AREF CUR-MARK 4)) HH) LH) 1)))))
           (WHEN (= (SLOT (SLOT (AREF MEM P) HH) RH) Q)
             (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
             (GOTO $L.30))
           (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))))
  $L.30
  (SETF Q (PRUNE-PAGE-TOP Q))
  (SETF P (SLOT (SLOT (AREF MEM (+ V 5)) HH) RH))
  (FREE-NODE V 7)
  (COND ((= Q 0) (SETF (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 0))
        (TRUE (SETF (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) (VPACKAGE Q 0 1 1073741823))))
  (SETF VSPLIT (VPACKAGE P H 0 (SLOT (AREF EQTB 9736) INT)))
  $L.10)

(PROCEDURE PRINT-TOTALS ()
  (PRINT-SCALED (AREF PAGE-SO-FAR 1))
  (WHEN (/= (AREF PAGE-SO-FAR 2) 0)
    (PRINT 312)
    (PRINT-SCALED (AREF PAGE-SO-FAR 2))
    (PRINT 338))
  (WHEN (/= (AREF PAGE-SO-FAR 3) 0)
    (PRINT 312)
    (PRINT-SCALED (AREF PAGE-SO-FAR 3))
    (PRINT 311))
  (WHEN (/= (AREF PAGE-SO-FAR 4) 0)
    (PRINT 312)
    (PRINT-SCALED (AREF PAGE-SO-FAR 4))
    (PRINT 978))
  (WHEN (/= (AREF PAGE-SO-FAR 5) 0)
    (PRINT 312)
    (PRINT-SCALED (AREF PAGE-SO-FAR 5))
    (PRINT 979))
  (WHEN (/= (AREF PAGE-SO-FAR 6) 0) (PRINT 313) (PRINT-SCALED (AREF PAGE-SO-FAR 6))))

(PROCEDURE FREEZE-PAGE-SPECS ((S SMALL-NUMBER))
  (SETF PAGE-CONTENTS S)
  (SETF (AREF PAGE-SO-FAR 0) (SLOT (AREF EQTB 9734) INT))
  (SETF PAGE-MAX-DEPTH (SLOT (AREF EQTB 9735) INT))
  (SETF (AREF PAGE-SO-FAR 7) 0)
  (SETF (AREF PAGE-SO-FAR 1) 0)
  (SETF (AREF PAGE-SO-FAR 2) 0)
  (SETF (AREF PAGE-SO-FAR 3) 0)
  (SETF (AREF PAGE-SO-FAR 4) 0)
  (SETF (AREF PAGE-SO-FAR 5) 0)
  (SETF (AREF PAGE-SO-FAR 6) 0)
  (SETF LEAST-PAGE-COST 1073741823))

(PROCEDURE BOX-ERROR ((N EIGHT-BITS))
  (ERROR)
  (BEGIN-DIAGNOSTIC)
  (PRINT-NL 836)
  (SHOW-BOX (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH))
  (END-DIAGNOSTIC TRUE)
  (FLUSH-NODE-LIST (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH))
  (SETF (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 0))

(PROCEDURE ENSURE-VBOX ((N EIGHT-BITS))
  (VAR P HALFWORD)
  (SETF P (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH))
  (WHEN (/= P 0)
    (WHEN (= (SLOT (SLOT (AREF MEM P) HH) B0) 0)
      (WHEN (= INTERACTION 3))
      (PRINT-NL 262)
      (PRINT 989)
      (SETF HELP-PTR 3)
      (SETF (AREF HELP-LINE 2) 990)
      (SETF (AREF HELP-LINE 1) 991)
      (SETF (AREF HELP-LINE 0) 992)
      (BOX-ERROR N))))

(PROCEDURE FIRE-UP ((C HALFWORD))
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR PREV-P HALFWORD)
  (VAR N (RANGE 0 255))
  (VAR WAIT BOOLEAN)
  (VAR SAVE-VBADNESS INTEGER)
  (VAR SAVE-VFUZZ SCALED)
  (VAR SAVE-SPLIT-TOP-SKIP HALFWORD)
  (COND ((= (SLOT (SLOT (AREF MEM BEST-PAGE-BREAK) HH) B0) 12)
         (GEQ-WORD-DEFINE 9202 (SLOT (AREF MEM (+ BEST-PAGE-BREAK 1)) INT))
         (SETF (SLOT (AREF MEM (+ BEST-PAGE-BREAK 1)) INT) 10000))
        (TRUE (GEQ-WORD-DEFINE 9202 10000)))
  (WHEN (/= (AREF CUR-MARK 2) 0)
    (WHEN (/= (AREF CUR-MARK 0) 0) (DELETE-TOKEN-REF (AREF CUR-MARK 0)))
    (SETF (AREF CUR-MARK 0) (AREF CUR-MARK 2))
    (SETF (SLOT (SLOT (AREF MEM (AREF CUR-MARK 0)) HH) LH)
          (+ (SLOT (SLOT (AREF MEM (AREF CUR-MARK 0)) HH) LH) 1))
    (DELETE-TOKEN-REF (AREF CUR-MARK 1))
    (SETF (AREF CUR-MARK 1) 0))
  (WHEN (= C BEST-PAGE-BREAK) (SETF BEST-PAGE-BREAK 0))
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7833) HH) RH) 0)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 338)
    (PRINT-ESC 409)
    (PRINT 1003)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 1004)
    (SETF (AREF HELP-LINE 0) 992)
    (BOX-ERROR 255))
  (SETF INSERT-PENALTIES 0)
  (SETF SAVE-SPLIT-TOP-SKIP (SLOT (SLOT (AREF EQTB 6792) HH) RH))
  (WHEN (<= (SLOT (AREF EQTB 9216) INT) 0)
    (SETF R (SLOT (SLOT (AREF MEM 60000) HH) RH))
    (WHILE (/= R 60000)
      (WHEN (/= (SLOT (SLOT (AREF MEM (+ R 2)) HH) LH) 0)
        (SETF N (- (SLOT (SLOT (AREF MEM R) HH) B1) 0))
        (ENSURE-VBOX N)
        (WHEN (= (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 0)
          (SETF (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) NEW-NULL-BOX))
        (SETF P (+ (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 5))
        (WHILE (/= (SLOT (SLOT (AREF MEM P) HH) RH) 0)
          (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
        (SETF (SLOT (SLOT (AREF MEM (+ R 2)) HH) RH) P))
      (SETF R (SLOT (SLOT (AREF MEM R) HH) RH))))
  (SETF Q 59996)
  (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
  (SETF PREV-P 59998)
  (SETF P (SLOT (SLOT (AREF MEM PREV-P) HH) RH))
  (WHILE (/= P BEST-PAGE-BREAK)
    (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 3)
           (WHEN (<= (SLOT (AREF EQTB 9216) INT) 0)
             (SETF R (SLOT (SLOT (AREF MEM 60000) HH) RH))
             (WHILE (/= (SLOT (SLOT (AREF MEM R) HH) B1) (SLOT (SLOT (AREF MEM P) HH) B1))
               (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)))
             (COND ((= (SLOT (SLOT (AREF MEM (+ R 2)) HH) LH) 0) (SETF WAIT TRUE))
                   (TRUE
                    (SETF WAIT FALSE)
                    (SETF S (SLOT (SLOT (AREF MEM (+ R 2)) HH) RH))
                    (SETF (SLOT (SLOT (AREF MEM S) HH) RH)
                          (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH))
                    (COND ((= (SLOT (SLOT (AREF MEM (+ R 2)) HH) LH) P)
                           (WHEN (= (SLOT (SLOT (AREF MEM R) HH) B0) 1)
                             (WHEN (AND (= (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH) P)
                                        (/= (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH) 0))
                               (WHILE (/= (SLOT (SLOT (AREF MEM S) HH) RH)
                                          (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH))
                                 (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
                               (SETF (SLOT (SLOT (AREF MEM S) HH) RH) 0)
                               (SETF (SLOT (SLOT (AREF EQTB 6792) HH) RH)
                                     (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH))
                               (SETF (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH)
                                     (PRUNE-PAGE-TOP (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH)))
                               (WHEN (/= (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH) 0)
                                 (SETF TEMP-PTR
                                       (VPACKAGE (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH)
                                                 0
                                                 1
                                                 1073741823))
                                 (SETF (SLOT (AREF MEM (+ P 3)) INT)
                                       (+ (SLOT (AREF MEM (+ TEMP-PTR 3)) INT)
                                          (SLOT (AREF MEM (+ TEMP-PTR 2)) INT)))
                                 (FREE-NODE TEMP-PTR 7)
                                 (SETF WAIT TRUE))))
                           (SETF (SLOT (SLOT (AREF MEM (+ R 2)) HH) LH) 0)
                           (SETF N (- (SLOT (SLOT (AREF MEM R) HH) B1) 0))
                           (SETF TEMP-PTR
                                 (SLOT (SLOT (AREF MEM
                                                   (+ (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH)
                                                            RH)
                                                      5))
                                             HH)
                                       RH))
                           (FREE-NODE (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 7)
                           (SETF (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH)
                                 (VPACKAGE TEMP-PTR 0 1 1073741823)))
                          (TRUE
                           (WHILE (/= (SLOT (SLOT (AREF MEM S) HH) RH) 0)
                             (SETF S (SLOT (SLOT (AREF MEM S) HH) RH)))
                           (SETF (SLOT (SLOT (AREF MEM (+ R 2)) HH) RH) S)))))
             (SETF (SLOT (SLOT (AREF MEM PREV-P) HH) RH) (SLOT (SLOT (AREF MEM P) HH) RH))
             (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
             (COND (WAIT
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
                    (SETF Q P)
                    (INCF INSERT-PENALTIES 1))
                   (TRUE
                    (DELETE-GLUE-REF (SLOT (SLOT (AREF MEM (+ P 4)) HH) RH))
                    (FREE-NODE P 5)))
             (SETF P PREV-P)))
          ((= (SLOT (SLOT (AREF MEM P) HH) B0) 4)
           (WHEN (= (AREF CUR-MARK 1) 0)
             (SETF (AREF CUR-MARK 1) (SLOT (AREF MEM (+ P 1)) INT))
             (SETF (SLOT (SLOT (AREF MEM (AREF CUR-MARK 1)) HH) LH)
                   (+ (SLOT (SLOT (AREF MEM (AREF CUR-MARK 1)) HH) LH) 1)))
           (WHEN (/= (AREF CUR-MARK 2) 0) (DELETE-TOKEN-REF (AREF CUR-MARK 2)))
           (SETF (AREF CUR-MARK 2) (SLOT (AREF MEM (+ P 1)) INT))
           (SETF (SLOT (SLOT (AREF MEM (AREF CUR-MARK 2)) HH) LH)
                 (+ (SLOT (SLOT (AREF MEM (AREF CUR-MARK 2)) HH) LH) 1))))
    (SETF PREV-P P)
    (SETF P (SLOT (SLOT (AREF MEM PREV-P) HH) RH)))
  (SETF (SLOT (SLOT (AREF EQTB 6792) HH) RH) SAVE-SPLIT-TOP-SKIP)
  (WHEN (/= P 0)
    (WHEN (= (SLOT (SLOT (AREF MEM 59999) HH) RH) 0)
      (COND ((= NEST-PTR 0) (SETF (SLOT CUR-LIST TAIL-FIELD) PAGE-TAIL))
            (TRUE (SETF (SLOT (AREF NEST 0) TAIL-FIELD) PAGE-TAIL))))
    (SETF (SLOT (SLOT (AREF MEM PAGE-TAIL) HH) RH) (SLOT (SLOT (AREF MEM 59999) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM 59999) HH) RH) P)
    (SETF (SLOT (SLOT (AREF MEM PREV-P) HH) RH) 0))
  (SETF SAVE-VBADNESS (SLOT (AREF EQTB 9190) INT))
  (SETF (SLOT (AREF EQTB 9190) INT) 10000)
  (SETF SAVE-VFUZZ (SLOT (AREF EQTB 9739) INT))
  (SETF (SLOT (AREF EQTB 9739) INT) 1073741823)
  (SETF (SLOT (SLOT (AREF EQTB 7833) HH) RH)
        (VPACKAGE (SLOT (SLOT (AREF MEM 59998) HH) RH) BEST-SIZE 0 PAGE-MAX-DEPTH))
  (SETF (SLOT (AREF EQTB 9190) INT) SAVE-VBADNESS)
  (SETF (SLOT (AREF EQTB 9739) INT) SAVE-VFUZZ)
  (WHEN (/= LAST-GLUE 65535) (DELETE-GLUE-REF LAST-GLUE))
  (SETF PAGE-CONTENTS 0)
  (SETF PAGE-TAIL 59998)
  (SETF (SLOT (SLOT (AREF MEM 59998) HH) RH) 0)
  (SETF LAST-GLUE 65535)
  (SETF LAST-PENALTY 0)
  (SETF LAST-KERN 0)
  (SETF (AREF PAGE-SO-FAR 7) 0)
  (SETF PAGE-MAX-DEPTH 0)
  (WHEN (/= Q 59996)
    (SETF (SLOT (SLOT (AREF MEM 59998) HH) RH) (SLOT (SLOT (AREF MEM 59996) HH) RH))
    (SETF PAGE-TAIL Q))
  (SETF R (SLOT (SLOT (AREF MEM 60000) HH) RH))
  (WHILE (/= R 60000) (SETF Q (SLOT (SLOT (AREF MEM R) HH) RH)) (FREE-NODE R 4) (SETF R Q))
  (SETF (SLOT (SLOT (AREF MEM 60000) HH) RH) 60000)
  (WHEN (AND (/= (AREF CUR-MARK 0) 0) (= (AREF CUR-MARK 1) 0))
    (SETF (AREF CUR-MARK 1) (AREF CUR-MARK 0))
    (SETF (SLOT (SLOT (AREF MEM (AREF CUR-MARK 0)) HH) LH)
          (+ (SLOT (SLOT (AREF MEM (AREF CUR-MARK 0)) HH) LH) 1)))
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7313) HH) RH) 0)
    (COND ((>= DEAD-CYCLES (SLOT (AREF EQTB 9203) INT))
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 1005)
           (PRINT-INT DEAD-CYCLES)
           (PRINT 1006)
           (SETF HELP-PTR 3)
           (SETF (AREF HELP-LINE 2) 1007)
           (SETF (AREF HELP-LINE 1) 1008)
           (SETF (AREF HELP-LINE 0) 1009)
           (ERROR))
          (TRUE
           (SETF OUTPUT-ACTIVE TRUE)
           (INCF DEAD-CYCLES 1)
           (PUSH-NEST)
           (SETF (SLOT CUR-LIST MODE-FIELD) (- 1))
           (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000))
           (SETF (SLOT CUR-LIST ML-FIELD) (- LINE))
           (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7313) HH) RH) 6)
           (NEW-SAVE-LEVEL 8)
           (NORMAL-PARAGRAPH)
           (SCAN-LEFT-BRACE)
           (GOTO $L.10))))
  (WHEN (/= (SLOT (SLOT (AREF MEM 59998) HH) RH) 0)
    (COND ((= (SLOT (SLOT (AREF MEM 59999) HH) RH) 0)
           (COND ((= NEST-PTR 0) (SETF (SLOT CUR-LIST TAIL-FIELD) PAGE-TAIL))
                 (TRUE (SETF (SLOT (AREF NEST 0) TAIL-FIELD) PAGE-TAIL))))
          (TRUE
           (SETF (SLOT (SLOT (AREF MEM PAGE-TAIL) HH) RH)
                 (SLOT (SLOT (AREF MEM 59999) HH) RH))))
    (SETF (SLOT (SLOT (AREF MEM 59999) HH) RH) (SLOT (SLOT (AREF MEM 59998) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM 59998) HH) RH) 0)
    (SETF PAGE-TAIL 59998))
  (SHIP-OUT (SLOT (SLOT (AREF EQTB 7833) HH) RH))
  (SETF (SLOT (SLOT (AREF EQTB 7833) HH) RH) 0)
  $L.10)

(PROCEDURE BUILD-PAGE ()
  (LABEL $L.10)
  (LABEL $L.30)
  (LABEL $L.31)
  (LABEL $L.22)
  (LABEL $L.80)
  (LABEL $L.90)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR B INTEGER)
  (VAR C INTEGER)
  (VAR PI INTEGER)
  (VAR N (RANGE 0 255))
  (VAR DELTA SCALED)
  (VAR H SCALED)
  (VAR W SCALED)
  (WHEN (OR (= (SLOT (SLOT (AREF MEM 59999) HH) RH) 0) OUTPUT-ACTIVE) (GOTO $L.10))
  (REPEAT $L.22
          (SETF P (SLOT (SLOT (AREF MEM 59999) HH) RH))
          (WHEN (/= LAST-GLUE 65535) (DELETE-GLUE-REF LAST-GLUE))
          (SETF LAST-PENALTY 0)
          (SETF LAST-KERN 0)
          (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 10)
                 (SETF LAST-GLUE (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
                 (SETF (SLOT (SLOT (AREF MEM LAST-GLUE) HH) RH)
                       (+ (SLOT (SLOT (AREF MEM LAST-GLUE) HH) RH) 1)))
                (TRUE
                 (SETF LAST-GLUE 65535)
                 (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 12)
                        (SETF LAST-PENALTY (SLOT (AREF MEM (+ P 1)) INT)))
                       ((= (SLOT (SLOT (AREF MEM P) HH) B0) 11)
                        (SETF LAST-KERN (SLOT (AREF MEM (+ P 1)) INT))))))
          (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
            ((0 1 2)
             (COND ((< PAGE-CONTENTS 2)
                    (COND ((= PAGE-CONTENTS 0) (FREEZE-PAGE-SPECS 2))
                          (TRUE (SETF PAGE-CONTENTS 2)))
                    (SETF Q (NEW-SKIP-PARAM 9))
                    (COND ((> (SLOT (AREF MEM (+ TEMP-PTR 1)) INT)
                              (SLOT (AREF MEM (+ P 3)) INT))
                           (SETF (SLOT (AREF MEM (+ TEMP-PTR 1)) INT)
                                 (- (SLOT (AREF MEM (+ TEMP-PTR 1)) INT)
                                    (SLOT (AREF MEM (+ P 3)) INT))))
                          (TRUE (SETF (SLOT (AREF MEM (+ TEMP-PTR 1)) INT) 0)))
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
                    (SETF (SLOT (SLOT (AREF MEM 59999) HH) RH) Q)
                    (GOTO $L.22))
                   (TRUE
                    (SETF (AREF PAGE-SO-FAR 1)
                          (+ (+ (AREF PAGE-SO-FAR 1) (AREF PAGE-SO-FAR 7))
                             (SLOT (AREF MEM (+ P 3)) INT)))
                    (SETF (AREF PAGE-SO-FAR 7) (SLOT (AREF MEM (+ P 2)) INT))
                    (GOTO $L.80))))
            ((8) (GOTO $L.80))
            ((10)
             (COND ((< PAGE-CONTENTS 2) (GOTO $L.31))
                   ((< (SLOT (SLOT (AREF MEM PAGE-TAIL) HH) B0) 9) (SETF PI 0))
                   (TRUE (GOTO $L.90))))
            ((11)
             (COND ((< PAGE-CONTENTS 2) (GOTO $L.31))
                   ((= (SLOT (SLOT (AREF MEM P) HH) RH) 0) (GOTO $L.10))
                   ((= (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM P) HH) RH)) HH) B0) 10)
                    (SETF PI 0))
                   (TRUE (GOTO $L.90))))
            ((12)
             (COND ((< PAGE-CONTENTS 2) (GOTO $L.31))
                   (TRUE (SETF PI (SLOT (AREF MEM (+ P 1)) INT)))))
            ((4) (GOTO $L.80))
            ((3) (WHEN (= PAGE-CONTENTS 0) (FREEZE-PAGE-SPECS 1))
             (SETF N (SLOT (SLOT (AREF MEM P) HH) B1)) (SETF R 60000)
             (WHILE (>= N (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF MEM R) HH) RH)) HH) B1))
               (SETF R (SLOT (SLOT (AREF MEM R) HH) RH)))
             (DECF N 0)
             (WHEN (/= (SLOT (SLOT (AREF MEM R) HH) B1) (+ N 0))
               (SETF Q (GET-NODE 4))
               (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (SLOT (SLOT (AREF MEM R) HH) RH))
               (SETF (SLOT (SLOT (AREF MEM R) HH) RH) Q)
               (SETF R Q)
               (SETF (SLOT (SLOT (AREF MEM R) HH) B1) (+ N 0))
               (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 0)
               (ENSURE-VBOX N)
               (COND ((= (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 0)
                      (SETF (SLOT (AREF MEM (+ R 3)) INT) 0))
                     (TRUE
                      (SETF (SLOT (AREF MEM (+ R 3)) INT)
                            (+ (SLOT (AREF MEM
                                           (+ (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 3))
                                     INT)
                               (SLOT (AREF MEM
                                           (+ (SLOT (SLOT (AREF EQTB (+ 7578 N)) HH) RH) 2))
                                     INT)))))
               (SETF (SLOT (SLOT (AREF MEM (+ R 2)) HH) LH) 0)
               (SETF Q (SLOT (SLOT (AREF EQTB (+ 6800 N)) HH) RH))
               (COND ((= (SLOT (AREF EQTB (+ 9218 N)) INT) 1000)
                      (SETF H (SLOT (AREF MEM (+ R 3)) INT)))
                     (TRUE
                      (SETF H
                            (* (X-OVER-N (SLOT (AREF MEM (+ R 3)) INT) 1000)
                               (SLOT (AREF EQTB (+ 9218 N)) INT)))))
               (SETF (AREF PAGE-SO-FAR 0)
                     (- (- (AREF PAGE-SO-FAR 0) H) (SLOT (AREF MEM (+ Q 1)) INT)))
               (SETF (AREF PAGE-SO-FAR (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                     (+ (AREF PAGE-SO-FAR (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                        (SLOT (AREF MEM (+ Q 2)) INT)))
               (SETF (AREF PAGE-SO-FAR 6)
                     (+ (AREF PAGE-SO-FAR 6) (SLOT (AREF MEM (+ Q 3)) INT)))
               (WHEN (AND (/= (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
                          (/= (SLOT (AREF MEM (+ Q 3)) INT) 0))
                 (WHEN (= INTERACTION 3))
                 (PRINT-NL 262)
                 (PRINT 998)
                 (PRINT-ESC 395)
                 (PRINT-INT N)
                 (SETF HELP-PTR 3)
                 (SETF (AREF HELP-LINE 2) 999)
                 (SETF (AREF HELP-LINE 1) 1000)
                 (SETF (AREF HELP-LINE 0) 922)
                 (ERROR)))
             (COND ((= (SLOT (SLOT (AREF MEM R) HH) B0) 1)
                    (INCF INSERT-PENALTIES (SLOT (AREF MEM (+ P 1)) INT)))
                   (TRUE
                    (SETF (SLOT (SLOT (AREF MEM (+ R 2)) HH) RH) P)
                    (SETF DELTA
                          (+ (- (- (AREF PAGE-SO-FAR 0) (AREF PAGE-SO-FAR 1))
                                (AREF PAGE-SO-FAR 7))
                             (AREF PAGE-SO-FAR 6)))
                    (COND ((= (SLOT (AREF EQTB (+ 9218 N)) INT) 1000)
                           (SETF H (SLOT (AREF MEM (+ P 3)) INT)))
                          (TRUE
                           (SETF H
                                 (* (X-OVER-N (SLOT (AREF MEM (+ P 3)) INT) 1000)
                                    (SLOT (AREF EQTB (+ 9218 N)) INT)))))
                    (COND ((AND (OR (<= H 0) (<= H DELTA))
                                (<= (+ (SLOT (AREF MEM (+ P 3)) INT)
                                       (SLOT (AREF MEM (+ R 3)) INT))
                                    (SLOT (AREF EQTB (+ 9751 N)) INT)))
                           (SETF (AREF PAGE-SO-FAR 0) (- (AREF PAGE-SO-FAR 0) H))
                           (SETF (SLOT (AREF MEM (+ R 3)) INT)
                                 (+ (SLOT (AREF MEM (+ R 3)) INT)
                                    (SLOT (AREF MEM (+ P 3)) INT))))
                          (TRUE
                           (COND ((<= (SLOT (AREF EQTB (+ 9218 N)) INT) 0) (SETF W 1073741823))
                                 (TRUE
                                  (SETF W
                                        (- (- (AREF PAGE-SO-FAR 0) (AREF PAGE-SO-FAR 1))
                                           (AREF PAGE-SO-FAR 7)))
                                  (WHEN (/= (SLOT (AREF EQTB (+ 9218 N)) INT) 1000)
                                    (SETF W
                                          (* (X-OVER-N W (SLOT (AREF EQTB (+ 9218 N)) INT))
                                             1000)))))
                           (WHEN (> W
                                    (- (SLOT (AREF EQTB (+ 9751 N)) INT)
                                       (SLOT (AREF MEM (+ R 3)) INT)))
                             (SETF W
                                   (- (SLOT (AREF EQTB (+ 9751 N)) INT)
                                      (SLOT (AREF MEM (+ R 3)) INT))))
                           (SETF Q
                                 (VERT-BREAK (SLOT (SLOT (AREF MEM (+ P 4)) HH) LH)
                                             W
                                             (SLOT (AREF MEM (+ P 2)) INT)))
                           (SETF (SLOT (AREF MEM (+ R 3)) INT)
                                 (+ (SLOT (AREF MEM (+ R 3)) INT) BEST-HEIGHT-PLUS-DEPTH))
                           (WHEN (/= (SLOT (AREF EQTB (+ 9218 N)) INT) 1000)
                             (SETF BEST-HEIGHT-PLUS-DEPTH
                                   (* (X-OVER-N BEST-HEIGHT-PLUS-DEPTH 1000)
                                      (SLOT (AREF EQTB (+ 9218 N)) INT))))
                           (SETF (AREF PAGE-SO-FAR 0)
                                 (- (AREF PAGE-SO-FAR 0) BEST-HEIGHT-PLUS-DEPTH))
                           (SETF (SLOT (SLOT (AREF MEM R) HH) B0) 1)
                           (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) RH) Q)
                           (SETF (SLOT (SLOT (AREF MEM (+ R 1)) HH) LH) P)
                           (COND ((= Q 0) (DECF INSERT-PENALTIES 10000))
                                 ((= (SLOT (SLOT (AREF MEM Q) HH) B0) 12)
                                  (INCF INSERT-PENALTIES (SLOT (AREF MEM (+ Q 1)) INT))))))))
             (GOTO $L.80))
            (ELSE (CONFUSION 993)))
          (WHEN (< PI 10000)
            (COND ((< (AREF PAGE-SO-FAR 1) (AREF PAGE-SO-FAR 0))
                   (COND ((OR (OR (/= (AREF PAGE-SO-FAR 3) 0) (/= (AREF PAGE-SO-FAR 4) 0))
                              (/= (AREF PAGE-SO-FAR 5) 0))
                          (SETF B 0))
                         (TRUE
                          (SETF B
                                (BADNESS (- (AREF PAGE-SO-FAR 0) (AREF PAGE-SO-FAR 1))
                                         (AREF PAGE-SO-FAR 2))))))
                  ((> (- (AREF PAGE-SO-FAR 1) (AREF PAGE-SO-FAR 0)) (AREF PAGE-SO-FAR 6))
                   (SETF B 1073741823))
                  (TRUE
                   (SETF B
                         (BADNESS (- (AREF PAGE-SO-FAR 1) (AREF PAGE-SO-FAR 0))
                                  (AREF PAGE-SO-FAR 6)))))
            (COND ((< B 1073741823)
                   (COND ((<= PI (- 10000)) (SETF C PI))
                         ((< B 10000) (SETF C (+ (+ B PI) INSERT-PENALTIES)))
                         (TRUE (SETF C 100000))))
                  (TRUE (SETF C B)))
            (WHEN (>= INSERT-PENALTIES 10000) (SETF C 1073741823))
            (WHEN (<= C LEAST-PAGE-COST)
              (SETF BEST-PAGE-BREAK P)
              (SETF BEST-SIZE (AREF PAGE-SO-FAR 0))
              (SETF LEAST-PAGE-COST C)
              (SETF R (SLOT (SLOT (AREF MEM 60000) HH) RH))
              (WHILE (/= R 60000)
                (SETF (SLOT (SLOT (AREF MEM (+ R 2)) HH) LH)
                      (SLOT (SLOT (AREF MEM (+ R 2)) HH) RH))
                (SETF R (SLOT (SLOT (AREF MEM R) HH) RH))))
            (WHEN (OR (= C 1073741823) (<= PI (- 10000)))
              (FIRE-UP P)
              (WHEN OUTPUT-ACTIVE (GOTO $L.10))
              (GOTO $L.30)))
          (WHEN (OR (< (SLOT (SLOT (AREF MEM P) HH) B0) 10)
                    (> (SLOT (SLOT (AREF MEM P) HH) B0) 11))
            (GOTO $L.80))
          $L.90
          (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 11) (SETF Q P))
                (TRUE
                 (SETF Q (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
                 (SETF (AREF PAGE-SO-FAR (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                       (+ (AREF PAGE-SO-FAR (+ 2 (SLOT (SLOT (AREF MEM Q) HH) B0)))
                          (SLOT (AREF MEM (+ Q 2)) INT)))
                 (SETF (AREF PAGE-SO-FAR 6)
                       (+ (AREF PAGE-SO-FAR 6) (SLOT (AREF MEM (+ Q 3)) INT)))
                 (WHEN (AND (/= (SLOT (SLOT (AREF MEM Q) HH) B1) 0)
                            (/= (SLOT (AREF MEM (+ Q 3)) INT) 0))
                   (WHEN (= INTERACTION 3))
                   (PRINT-NL 262)
                   (PRINT 994)
                   (SETF HELP-PTR 4)
                   (SETF (AREF HELP-LINE 3) 995)
                   (SETF (AREF HELP-LINE 2) 963)
                   (SETF (AREF HELP-LINE 1) 964)
                   (SETF (AREF HELP-LINE 0) 922)
                   (ERROR)
                   (SETF R (NEW-SPEC Q))
                   (SETF (SLOT (SLOT (AREF MEM R) HH) B1) 0)
                   (DELETE-GLUE-REF Q)
                   (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) R)
                   (SETF Q R))))
          (SETF (AREF PAGE-SO-FAR 1)
                (+ (+ (AREF PAGE-SO-FAR 1) (AREF PAGE-SO-FAR 7))
                   (SLOT (AREF MEM (+ Q 1)) INT)))
          (SETF (AREF PAGE-SO-FAR 7) 0)
          $L.80
          (WHEN (> (AREF PAGE-SO-FAR 7) PAGE-MAX-DEPTH)
            (SETF (AREF PAGE-SO-FAR 1)
                  (- (+ (AREF PAGE-SO-FAR 1) (AREF PAGE-SO-FAR 7)) PAGE-MAX-DEPTH))
            (SETF (AREF PAGE-SO-FAR 7) PAGE-MAX-DEPTH))
          (SETF (SLOT (SLOT (AREF MEM PAGE-TAIL) HH) RH) P)
          (SETF PAGE-TAIL P)
          (SETF (SLOT (SLOT (AREF MEM 59999) HH) RH) (SLOT (SLOT (AREF MEM P) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
          (GOTO $L.30)
          $L.31
          (SETF (SLOT (SLOT (AREF MEM 59999) HH) RH) (SLOT (SLOT (AREF MEM P) HH) RH))
          (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
          (FLUSH-NODE-LIST P)
          $L.30
          (UNTIL (= (SLOT (SLOT (AREF MEM 59999) HH) RH) 0)))
  (COND ((= NEST-PTR 0) (SETF (SLOT CUR-LIST TAIL-FIELD) 59999))
        (TRUE (SETF (SLOT (AREF NEST 0) TAIL-FIELD) 59999)))
  $L.10)

(PROCEDURE APP-SPACE ()
  (VAR Q HALFWORD)
  (COND ((AND (>= (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 2000)
              (/= (SLOT (SLOT (AREF EQTB 6795) HH) RH) 0))
         (SETF Q (NEW-PARAM-GLUE 13)))
        (TRUE
         (COND ((/= (SLOT (SLOT (AREF EQTB 6794) HH) RH) 0)
                (SETF MAIN-P (SLOT (SLOT (AREF EQTB 6794) HH) RH)))
               (TRUE
                (SETF MAIN-P (AREF FONT-GLUE (SLOT (SLOT (AREF EQTB 7834) HH) RH)))
                (WHEN (= MAIN-P 0)
                  (SETF MAIN-P (NEW-SPEC 0))
                  (SETF MAIN-K (+ (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB 7834) HH) RH)) 2))
                  (SETF (SLOT (AREF MEM (+ MAIN-P 1)) INT) (SLOT (AREF FONT-INFO MAIN-K) INT))
                  (SETF (SLOT (AREF MEM (+ MAIN-P 2)) INT)
                        (SLOT (AREF FONT-INFO (+ MAIN-K 1)) INT))
                  (SETF (SLOT (AREF MEM (+ MAIN-P 3)) INT)
                        (SLOT (AREF FONT-INFO (+ MAIN-K 2)) INT))
                  (SETF (AREF FONT-GLUE (SLOT (SLOT (AREF EQTB 7834) HH) RH)) MAIN-P))))
         (SETF MAIN-P (NEW-SPEC MAIN-P))
         (WHEN (>= (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 2000)
           (SETF (SLOT (AREF MEM (+ MAIN-P 1)) INT)
                 (+ (SLOT (AREF MEM (+ MAIN-P 1)) INT)
                    (SLOT (AREF FONT-INFO
                                (+ 7 (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB 7834) HH) RH))))
                          INT))))
         (SETF (SLOT (AREF MEM (+ MAIN-P 2)) INT)
               (XN-OVER-D (SLOT (AREF MEM (+ MAIN-P 2)) INT)
                          (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH)
                          1000))
         (SETF (SLOT (AREF MEM (+ MAIN-P 3)) INT)
               (XN-OVER-D (SLOT (AREF MEM (+ MAIN-P 3)) INT)
                          1000
                          (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH)))
         (SETF Q (NEW-GLUE MAIN-P))
         (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) RH) 0)))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) Q)
  (SETF (SLOT CUR-LIST TAIL-FIELD) Q))

(PROCEDURE INSERT-DOLLAR-SIGN ()
  (BACK-INPUT)
  (SETF CUR-TOK 804)
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 1017)
  (SETF HELP-PTR 2)
  (SETF (AREF HELP-LINE 1) 1018)
  (SETF (AREF HELP-LINE 0) 1019)
  (INS-ERROR))

(PROCEDURE YOU-CANT ()
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 685)
  (PRINT-CMD-CHR CUR-CMD CUR-CHR)
  (PRINT 1020)
  (PRINT-MODE (SLOT CUR-LIST MODE-FIELD)))

(PROCEDURE REPORT-ILLEGAL-CASE ()
  (YOU-CANT)
  (SETF HELP-PTR 4)
  (SETF (AREF HELP-LINE 3) 1021)
  (SETF (AREF HELP-LINE 2) 1022)
  (SETF (AREF HELP-LINE 1) 1023)
  (SETF (AREF HELP-LINE 0) 1024)
  (ERROR))

(FUNCTION (PRIVILEGED BOOLEAN) ()
  (COND ((> (SLOT CUR-LIST MODE-FIELD) 0) (SETF PRIVILEGED TRUE))
        (TRUE (REPORT-ILLEGAL-CASE) (SETF PRIVILEGED FALSE))))

(FUNCTION (ITS-ALL-OVER BOOLEAN) ()
  (LABEL $L.10)
  (WHEN PRIVILEGED
    (WHEN (AND (AND (= 59998 PAGE-TAIL)
                    (= (SLOT CUR-LIST HEAD-FIELD) (SLOT CUR-LIST TAIL-FIELD)))
               (= DEAD-CYCLES 0))
      (SETF ITS-ALL-OVER TRUE)
      (GOTO $L.10))
    (BACK-INPUT)
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-NULL-BOX)
    (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
    (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT) (SLOT (AREF EQTB 9733) INT))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-GLUE 8))
    (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
          (NEW-PENALTY (- 1073741824)))
    (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
    (BUILD-PAGE))
  (SETF ITS-ALL-OVER FALSE)
  $L.10)

(PROCEDURE APPEND-GLUE ()
  (VAR S SMALL-NUMBER)
  (SETF S CUR-CHR)
  (CASE S
    ((0) (SETF CUR-VAL 4))
    ((1) (SETF CUR-VAL 8))
    ((2) (SETF CUR-VAL 12))
    ((3) (SETF CUR-VAL 16))
    ((4) (SCAN-GLUE 2))
    ((5) (SCAN-GLUE 3)))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-GLUE CUR-VAL))
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (WHEN (>= S 4)
    (SETF (SLOT (SLOT (AREF MEM CUR-VAL) HH) RH) (- (SLOT (SLOT (AREF MEM CUR-VAL) HH) RH) 1))
    (WHEN (> S 4) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 99))))

(PROCEDURE APPEND-KERN ()
  (VAR S QUARTERWORD)
  (SETF S CUR-CHR)
  (SCAN-DIMEN (= S 99) FALSE FALSE)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-KERN CUR-VAL))
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) S))

(PROCEDURE OFF-SAVE ()
  (VAR P HALFWORD)
  (COND ((= CUR-GROUP 0)
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 777)
         (PRINT-CMD-CHR CUR-CMD CUR-CHR)
         (SETF HELP-PTR 1)
         (SETF (AREF HELP-LINE 0) 1043)
         (ERROR))
        (TRUE
         (BACK-INPUT)
         (SETF P GET-AVAIL)
         (SETF (SLOT (SLOT (AREF MEM 59997) HH) RH) P)
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 625)
         (CASE CUR-GROUP
           ((14) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 10611) (PRINT-ESC 516))
           ((15) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 804) (PRINT-CHAR 36))
           ((16) (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 10612)
            (SETF (SLOT (SLOT (AREF MEM P) HH) RH) GET-AVAIL)
            (SETF P (SLOT (SLOT (AREF MEM P) HH) RH))
            (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 3118) (PRINT-ESC 1042))
           (ELSE (SETF (SLOT (SLOT (AREF MEM P) HH) LH) 637) (PRINT-CHAR 125)))
         (PRINT 626)
         (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF MEM 59997) HH) RH) 4)
         (SETF HELP-PTR 5)
         (SETF (AREF HELP-LINE 4) 1037)
         (SETF (AREF HELP-LINE 3) 1038)
         (SETF (AREF HELP-LINE 2) 1039)
         (SETF (AREF HELP-LINE 1) 1040)
         (SETF (AREF HELP-LINE 0) 1041)
         (ERROR))))

(PROCEDURE EXTRA-RIGHT-BRACE ()
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 1048)
  (CASE CUR-GROUP ((14) (PRINT-ESC 516)) ((15) (PRINT-CHAR 36)) ((16) (PRINT-ESC 877)))
  (SETF HELP-PTR 5)
  (SETF (AREF HELP-LINE 4) 1049)
  (SETF (AREF HELP-LINE 3) 1050)
  (SETF (AREF HELP-LINE 2) 1051)
  (SETF (AREF HELP-LINE 1) 1052)
  (SETF (AREF HELP-LINE 0) 1053)
  (ERROR)
  (INCF ALIGN-STATE 1))

(PROCEDURE NORMAL-PARAGRAPH ()
  (WHEN (/= (SLOT (AREF EQTB 9182) INT) 0) (EQ-WORD-DEFINE 9182 0))
  (WHEN (/= (SLOT (AREF EQTB 9747) INT) 0) (EQ-WORD-DEFINE 9747 0))
  (WHEN (/= (SLOT (AREF EQTB 9204) INT) 1) (EQ-WORD-DEFINE 9204 1))
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0) (EQ-DEFINE 7312 118 0)))

(PROCEDURE BOX-END ((BOX-CONTEXT INTEGER))
  (VAR P HALFWORD)
  (COND ((< BOX-CONTEXT 1073741824)
         (WHEN (/= CUR-BOX 0)
           (SETF (SLOT (AREF MEM (+ CUR-BOX 4)) INT) BOX-CONTEXT)
           (COND ((= (ABS (SLOT CUR-LIST MODE-FIELD)) 1)
                  (APPEND-TO-VLIST CUR-BOX)
                  (WHEN (/= ADJUST-TAIL 0)
                    (WHEN (/= 59995 ADJUST-TAIL)
                      (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
                            (SLOT (SLOT (AREF MEM 59995) HH) RH))
                      (SETF (SLOT CUR-LIST TAIL-FIELD) ADJUST-TAIL))
                    (SETF ADJUST-TAIL 0))
                  (WHEN (> (SLOT CUR-LIST MODE-FIELD) 0) (BUILD-PAGE)))
                 (TRUE
                  (COND ((= (ABS (SLOT CUR-LIST MODE-FIELD)) 102)
                         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
                        (TRUE
                         (SETF P NEW-NOAD)
                         (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 2)
                         (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH) CUR-BOX)
                         (SETF CUR-BOX P)))
                  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) CUR-BOX)
                  (SETF (SLOT CUR-LIST TAIL-FIELD) CUR-BOX)))))
        ((< BOX-CONTEXT 1073742336)
         (COND ((< BOX-CONTEXT 1073742080)
                (EQ-DEFINE (+ (- 1073734246) BOX-CONTEXT) 119 CUR-BOX))
               (TRUE (GEQ-DEFINE (+ (- 1073734502) BOX-CONTEXT) 119 CUR-BOX))))
        ((/= CUR-BOX 0)
         (COND ((> BOX-CONTEXT 1073742336)
                (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
                (COND ((OR (AND (= CUR-CMD 26) (/= (ABS (SLOT CUR-LIST MODE-FIELD)) 1))
                           (AND (= CUR-CMD 27) (= (ABS (SLOT CUR-LIST MODE-FIELD)) 1)))
                       (APPEND-GLUE)
                       (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1)
                             (- BOX-CONTEXT 1073742237))
                       (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH)
                             CUR-BOX))
                      (TRUE
                       (WHEN (= INTERACTION 3))
                       (PRINT-NL 262)
                       (PRINT 1066)
                       (SETF HELP-PTR 3)
                       (SETF (AREF HELP-LINE 2) 1067)
                       (SETF (AREF HELP-LINE 1) 1068)
                       (SETF (AREF HELP-LINE 0) 1069)
                       (BACK-ERROR)
                       (FLUSH-NODE-LIST CUR-BOX))))
               (TRUE (SHIP-OUT CUR-BOX))))))

(PROCEDURE BEGIN-BOX ((BOX-CONTEXT INTEGER))
  (LABEL $L.10)
  (LABEL $L.30)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR M QUARTERWORD)
  (VAR K HALFWORD)
  (VAR N EIGHT-BITS)
  (CASE CUR-CHR
    ((0) (SCAN-EIGHT-BIT-INT) (SETF CUR-BOX (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH))
     (SETF (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH) 0))
    ((1) (SCAN-EIGHT-BIT-INT)
     (SETF CUR-BOX (COPY-NODE-LIST (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH))))
    ((2) (SETF CUR-BOX 0)
     (COND ((= (ABS (SLOT CUR-LIST MODE-FIELD)) 203)
            (YOU-CANT)
            (SETF HELP-PTR 1)
            (SETF (AREF HELP-LINE 0) 1070)
            (ERROR))
           ((AND (= (SLOT CUR-LIST MODE-FIELD) 1)
                 (= (SLOT CUR-LIST HEAD-FIELD) (SLOT CUR-LIST TAIL-FIELD)))
            (YOU-CANT)
            (SETF HELP-PTR 2)
            (SETF (AREF HELP-LINE 1) 1071)
            (SETF (AREF HELP-LINE 0) 1072)
            (ERROR))
           ((NOT (UNLESS (>= (SLOT CUR-LIST TAIL-FIELD) HI-MEM-MIN)
                   (WHEN (OR (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 0)
                             (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 1))
                     (SETF Q (SLOT CUR-LIST HEAD-FIELD))
                     (REPEAT (SETF P Q)
                             (UNLESS (>= Q HI-MEM-MIN)
                               (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B0) 7)
                                 (FOR (M 1 TO (SLOT (SLOT (AREF MEM Q) HH) B1))
                                   (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
                                 (WHEN (= P (SLOT CUR-LIST TAIL-FIELD)) (GOTO $L.30))))
                             (SETF Q (SLOT (SLOT (AREF MEM P) HH) RH))
                             (UNTIL (= Q (SLOT CUR-LIST TAIL-FIELD))))
                     (SETF CUR-BOX (SLOT CUR-LIST TAIL-FIELD))
                     (SETF (SLOT (AREF MEM (+ CUR-BOX 4)) INT) 0)
                     (SETF (SLOT CUR-LIST TAIL-FIELD) P)
                     (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
                     $L.30)))
            (WHEN (OR (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 0)
                      (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 1))
              (SETF Q (SLOT CUR-LIST HEAD-FIELD))
              (REPEAT (SETF P Q)
                      (UNLESS (>= Q HI-MEM-MIN)
                        (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B0) 7)
                          (FOR (M 1 TO (SLOT (SLOT (AREF MEM Q) HH) B1))
                            (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
                          (WHEN (= P (SLOT CUR-LIST TAIL-FIELD)) (GOTO $L.30))))
                      (SETF Q (SLOT (SLOT (AREF MEM P) HH) RH))
                      (UNTIL (= Q (SLOT CUR-LIST TAIL-FIELD))))
              (SETF CUR-BOX (SLOT CUR-LIST TAIL-FIELD))
              (SETF (SLOT (AREF MEM (+ CUR-BOX 4)) INT) 0)
              (SETF (SLOT CUR-LIST TAIL-FIELD) P)
              (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
              $L.30))))
    ((3) (SCAN-EIGHT-BIT-INT) (SETF N CUR-VAL)
     (UNLESS (SCAN-KEYWORD 842)
       (WHEN (= INTERACTION 3))
       (PRINT-NL 262)
       (PRINT 1073)
       (SETF HELP-PTR 2)
       (SETF (AREF HELP-LINE 1) 1074)
       (SETF (AREF HELP-LINE 0) 1075)
       (ERROR))
     (SCAN-DIMEN FALSE FALSE FALSE) (SETF CUR-BOX (VSPLIT N CUR-VAL)))
    (ELSE (SETF K (- CUR-CHR 4)) (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) BOX-CONTEXT)
     (COND ((= K 102)
            (COND ((AND (< BOX-CONTEXT 1073741824) (= (ABS (SLOT CUR-LIST MODE-FIELD)) 1))
                   (SCAN-SPEC 3 TRUE))
                  (TRUE (SCAN-SPEC 2 TRUE))))
           (TRUE
            (COND ((= K 1) (SCAN-SPEC 4 TRUE)) (TRUE (SCAN-SPEC 5 TRUE) (SETF K 1)))
            (NORMAL-PARAGRAPH)))
     (PUSH-NEST) (SETF (SLOT CUR-LIST MODE-FIELD) (- K))
     (COND ((= K 1)
            (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000))
            (WHEN (/= (SLOT (SLOT (AREF EQTB 7318) HH) RH) 0)
              (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7318) HH) RH) 11)))
           (TRUE
            (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
            (WHEN (/= (SLOT (SLOT (AREF EQTB 7317) HH) RH) 0)
              (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7317) HH) RH) 10))))
     (GOTO $L.10)))
  (BOX-END BOX-CONTEXT)
  $L.10)

(PROCEDURE SCAN-BOX ((BOX-CONTEXT INTEGER))
  (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
  (COND ((= CUR-CMD 20) (BEGIN-BOX BOX-CONTEXT))
        ((AND (>= BOX-CONTEXT 1073742337) (OR (= CUR-CMD 36) (= CUR-CMD 35)))
         (SETF CUR-BOX SCAN-RULE-SPEC)
         (BOX-END BOX-CONTEXT))
        (TRUE
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 1076)
         (SETF HELP-PTR 3)
         (SETF (AREF HELP-LINE 2) 1077)
         (SETF (AREF HELP-LINE 1) 1078)
         (SETF (AREF HELP-LINE 0) 1079)
         (BACK-ERROR))))

(PROCEDURE PACKAGE ((C SMALL-NUMBER))
  (VAR H SCALED)
  (VAR P HALFWORD)
  (VAR D SCALED)
  (SETF D (SLOT (AREF EQTB 9737) INT))
  (UNSAVE)
  (DECF SAVE-PTR 3)
  (COND ((= (SLOT CUR-LIST MODE-FIELD) (- 102))
         (SETF CUR-BOX
               (HPACK (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH)
                      (SLOT (AREF SAVE-STACK (+ SAVE-PTR 2)) INT)
                      (SLOT (AREF SAVE-STACK (+ SAVE-PTR 1)) INT))))
        (TRUE
         (SETF CUR-BOX
               (VPACKAGE (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH)
                         (SLOT (AREF SAVE-STACK (+ SAVE-PTR 2)) INT)
                         (SLOT (AREF SAVE-STACK (+ SAVE-PTR 1)) INT)
                         D))
         (WHEN (= C 4)
           (SETF H 0)
           (SETF P (SLOT (SLOT (AREF MEM (+ CUR-BOX 5)) HH) RH))
           (WHEN (/= P 0)
             (WHEN (<= (SLOT (SLOT (AREF MEM P) HH) B0) 2)
               (SETF H (SLOT (AREF MEM (+ P 3)) INT))))
           (SETF (SLOT (AREF MEM (+ CUR-BOX 2)) INT)
                 (+ (- (SLOT (AREF MEM (+ CUR-BOX 2)) INT) H)
                    (SLOT (AREF MEM (+ CUR-BOX 3)) INT)))
           (SETF (SLOT (AREF MEM (+ CUR-BOX 3)) INT) H))))
  (POP-NEST)
  (BOX-END (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)))

(FUNCTION (NORM-MIN SMALL-NUMBER) ((H INTEGER))
  (COND ((<= H 0) (SETF NORM-MIN 1)) ((>= H 63) (SETF NORM-MIN 63)) (TRUE (SETF NORM-MIN H))))

(PROCEDURE NEW-GRAF ((INDENTED BOOLEAN))
  (SETF (SLOT CUR-LIST PG-FIELD) 0)
  (WHEN (OR (= (SLOT CUR-LIST MODE-FIELD) 1)
            (/= (SLOT CUR-LIST HEAD-FIELD) (SLOT CUR-LIST TAIL-FIELD)))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PARAM-GLUE 2))
    (SETF (SLOT CUR-LIST TAIL-FIELD)
          (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
  (PUSH-NEST)
  (SETF (SLOT CUR-LIST MODE-FIELD) 102)
  (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
  (COND ((<= (SLOT (AREF EQTB 9213) INT) 0) (SETF CUR-LANG 0))
        ((> (SLOT (AREF EQTB 9213) INT) 255) (SETF CUR-LANG 0))
        (TRUE (SETF CUR-LANG (SLOT (AREF EQTB 9213) INT))))
  (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH) CUR-LANG)
  (SETF (SLOT CUR-LIST PG-FIELD)
        (+ (* (+ (* (NORM-MIN (SLOT (AREF EQTB 9214) INT)) 64)
                 (NORM-MIN (SLOT (AREF EQTB 9215) INT)))
              65536)
           CUR-LANG))
  (WHEN INDENTED
    (SETF (SLOT CUR-LIST TAIL-FIELD) NEW-NULL-BOX)
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) (SLOT CUR-LIST TAIL-FIELD))
    (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT) (SLOT (AREF EQTB 9730) INT)))
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7314) HH) RH) 0)
    (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7314) HH) RH) 7))
  (WHEN (= NEST-PTR 1) (BUILD-PAGE)))

(PROCEDURE INDENT-IN-HMODE ()
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (WHEN (> CUR-CHR 0)
    (SETF P NEW-NULL-BOX)
    (SETF (SLOT (AREF MEM (+ P 1)) INT) (SLOT (AREF EQTB 9730) INT))
    (COND ((= (ABS (SLOT CUR-LIST MODE-FIELD)) 102)
           (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
          (TRUE
           (SETF Q NEW-NOAD)
           (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) 2)
           (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) P)
           (SETF P Q)))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
    (SETF (SLOT CUR-LIST TAIL-FIELD)
          (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))))

(PROCEDURE HEAD-FOR-VMODE ()
  (COND ((< (SLOT CUR-LIST MODE-FIELD) 0)
         (COND ((/= CUR-CMD 36) (OFF-SAVE))
               (TRUE
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 685)
                (PRINT-ESC 521)
                (PRINT 1082)
                (SETF HELP-PTR 2)
                (SETF (AREF HELP-LINE 1) 1083)
                (SETF (AREF HELP-LINE 0) 1084)
                (ERROR))))
        (TRUE
         (BACK-INPUT)
         (SETF CUR-TOK PAR-TOKEN)
         (BACK-INPUT)
         (SETF (SLOT CUR-INPUT INDEX-FIELD) 4))))

(PROCEDURE END-GRAF ()
  (WHEN (= (SLOT CUR-LIST MODE-FIELD) 102)
    (COND ((= (SLOT CUR-LIST HEAD-FIELD) (SLOT CUR-LIST TAIL-FIELD)) (POP-NEST))
          (TRUE (LINE-BREAK (SLOT (AREF EQTB 9169) INT))))
    (NORMAL-PARAGRAPH)
    (SETF ERROR-COUNT 0)))

(PROCEDURE BEGIN-INSERT-OR-ADJUST ()
  (COND ((= CUR-CMD 38) (SETF CUR-VAL 255))
        (TRUE
         (SCAN-EIGHT-BIT-INT)
         (WHEN (= CUR-VAL 255)
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 1085)
           (PRINT-ESC 330)
           (PRINT-INT 255)
           (SETF HELP-PTR 1)
           (SETF (AREF HELP-LINE 0) 1086)
           (ERROR)
           (SETF CUR-VAL 0))))
  (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) CUR-VAL)
  (INCF SAVE-PTR 1)
  (NEW-SAVE-LEVEL 11)
  (SCAN-LEFT-BRACE)
  (NORMAL-PARAGRAPH)
  (PUSH-NEST)
  (SETF (SLOT CUR-LIST MODE-FIELD) (- 1))
  (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000)))

(PROCEDURE MAKE-MARK ()
  (VAR P HALFWORD)
  (SETF P (SCAN-TOKS FALSE TRUE))
  (SETF P (GET-NODE 2))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 4)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ P 1)) INT) DEF-REF)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
  (SETF (SLOT CUR-LIST TAIL-FIELD) P))

(PROCEDURE APPEND-PENALTY ()
  (SCAN-INT)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PENALTY CUR-VAL))
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (WHEN (= (SLOT CUR-LIST MODE-FIELD) 1) (BUILD-PAGE)))

(PROCEDURE DELETE-LAST ()
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR M QUARTERWORD)
  (COND ((AND (= (SLOT CUR-LIST MODE-FIELD) 1)
              (= (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD)))
         (WHEN (OR (/= CUR-CHR 10) (/= LAST-GLUE 65535))
           (YOU-CANT)
           (SETF HELP-PTR 2)
           (SETF (AREF HELP-LINE 1) 1071)
           (SETF (AREF HELP-LINE 0) 1087)
           (COND ((= CUR-CHR 11) (SETF (AREF HELP-LINE 0) 1088))
                 ((/= CUR-CHR 10) (SETF (AREF HELP-LINE 0) 1089)))
           (ERROR)))
        ((NOT (UNLESS (>= (SLOT CUR-LIST TAIL-FIELD) HI-MEM-MIN)
                (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) CUR-CHR)
                  (SETF Q (SLOT CUR-LIST HEAD-FIELD))
                  (REPEAT (SETF P Q)
                          (UNLESS (>= Q HI-MEM-MIN)
                            (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B0) 7)
                              (FOR (M 1 TO (SLOT (SLOT (AREF MEM Q) HH) B1))
                                (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
                              (WHEN (= P (SLOT CUR-LIST TAIL-FIELD)) (GOTO $L.10))))
                          (SETF Q (SLOT (SLOT (AREF MEM P) HH) RH))
                          (UNTIL (= Q (SLOT CUR-LIST TAIL-FIELD))))
                  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
                  (FLUSH-NODE-LIST (SLOT CUR-LIST TAIL-FIELD))
                  (SETF (SLOT CUR-LIST TAIL-FIELD) P))))
         (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) CUR-CHR)
           (SETF Q (SLOT CUR-LIST HEAD-FIELD))
           (REPEAT (SETF P Q)
                   (UNLESS (>= Q HI-MEM-MIN)
                     (WHEN (= (SLOT (SLOT (AREF MEM Q) HH) B0) 7)
                       (FOR (M 1 TO (SLOT (SLOT (AREF MEM Q) HH) B1))
                         (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
                       (WHEN (= P (SLOT CUR-LIST TAIL-FIELD)) (GOTO $L.10))))
                   (SETF Q (SLOT (SLOT (AREF MEM P) HH) RH))
                   (UNTIL (= Q (SLOT CUR-LIST TAIL-FIELD))))
           (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0)
           (FLUSH-NODE-LIST (SLOT CUR-LIST TAIL-FIELD))
           (SETF (SLOT CUR-LIST TAIL-FIELD) P))))
  $L.10)

(PROCEDURE UNPACKAGE ()
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR C (RANGE 0 1))
  (SETF C CUR-CHR)
  (SCAN-EIGHT-BIT-INT)
  (SETF P (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH))
  (WHEN (= P 0) (GOTO $L.10))
  (WHEN (OR (OR (= (ABS (SLOT CUR-LIST MODE-FIELD)) 203)
                (AND (= (ABS (SLOT CUR-LIST MODE-FIELD)) 1)
                     (/= (SLOT (SLOT (AREF MEM P) HH) B0) 1)))
            (AND (= (ABS (SLOT CUR-LIST MODE-FIELD)) 102)
                 (/= (SLOT (SLOT (AREF MEM P) HH) B0) 0)))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1097)
    (SETF HELP-PTR 3)
    (SETF (AREF HELP-LINE 2) 1098)
    (SETF (AREF HELP-LINE 1) 1099)
    (SETF (AREF HELP-LINE 0) 1100)
    (ERROR)
    (GOTO $L.10))
  (COND ((= C 1)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (COPY-NODE-LIST (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH))))
        (TRUE
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH))
         (SETF (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH) 0)
         (FREE-NODE P 7)))
  (WHILE (/= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) 0)
    (SETF (SLOT CUR-LIST TAIL-FIELD)
          (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
  $L.10)

(PROCEDURE APPEND-ITALIC-CORRECTION ()
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (WHEN (/= (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
    (COND ((>= (SLOT CUR-LIST TAIL-FIELD) HI-MEM-MIN) (SETF P (SLOT CUR-LIST TAIL-FIELD)))
          ((= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 6)
           (SETF P (+ (SLOT CUR-LIST TAIL-FIELD) 1)))
          (TRUE (GOTO $L.10)))
    (SETF F (SLOT (SLOT (AREF MEM P) HH) B0))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
          (NEW-KERN (SLOT (AREF FONT-INFO
                                (+ (AREF ITALIC-BASE F)
                                   (DIV (- (SLOT (SLOT (AREF
                                                        FONT-INFO
                                                        (+
                                                         (AREF CHAR-BASE F)
                                                         (SLOT (SLOT (AREF MEM P) HH) B1)))
                                                       QQQQ)
                                                 B2)
                                           0)
                                        4)))
                          INT)))
    (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 1))
  $L.10)

(PROCEDURE APPEND-DISCRETIONARY ()
  (VAR C INTEGER)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-DISC)
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (COND ((= CUR-CHR 1)
         (SETF C (AREF HYPHEN-CHAR (SLOT (SLOT (AREF EQTB 7834) HH) RH)))
         (WHEN (>= C 0)
           (WHEN (< C 256)
             (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH)
                   (NEW-CHARACTER (SLOT (SLOT (AREF EQTB 7834) HH) RH) C)))))
        (TRUE
         (INCF SAVE-PTR 1)
         (SETF (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT) 0)
         (NEW-SAVE-LEVEL 10)
         (SCAN-LEFT-BRACE)
         (PUSH-NEST)
         (SETF (SLOT CUR-LIST MODE-FIELD) (- 102))
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))))

(PROCEDURE BUILD-DISCRETIONARY ()
  (LABEL $L.30)
  (LABEL $L.10)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR N INTEGER)
  (UNSAVE)
  (SETF Q (SLOT CUR-LIST HEAD-FIELD))
  (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
  (SETF N 0)
  (WHILE (/= P 0)
    (UNLESS (>= P HI-MEM-MIN)
      (WHEN (> (SLOT (SLOT (AREF MEM P) HH) B0) 2)
        (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B0) 11)
          (WHEN (/= (SLOT (SLOT (AREF MEM P) HH) B0) 6)
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 1107)
            (SETF HELP-PTR 1)
            (SETF (AREF HELP-LINE 0) 1108)
            (ERROR)
            (BEGIN-DIAGNOSTIC)
            (PRINT-NL 1109)
            (SHOW-BOX P)
            (END-DIAGNOSTIC TRUE)
            (FLUSH-NODE-LIST P)
            (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 0)
            (GOTO $L.30)))))
    (SETF Q P)
    (SETF P (SLOT (SLOT (AREF MEM Q) HH) RH))
    (INCF N 1))
  $L.30
  (SETF P (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
  (POP-NEST)
  (CASE (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT)
    ((0) (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH) P))
    ((1) (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) P))
    ((2)
     (COND ((AND (> N 0) (= (ABS (SLOT CUR-LIST MODE-FIELD)) 203))
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 1101)
            (PRINT-ESC 349)
            (SETF HELP-PTR 2)
            (SETF (AREF HELP-LINE 1) 1102)
            (SETF (AREF HELP-LINE 0) 1103)
            (FLUSH-NODE-LIST P)
            (SETF N 0)
            (ERROR))
           (TRUE (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)))
     (COND ((<= N 255) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) N))
           (TRUE
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 1104)
            (SETF HELP-PTR 2)
            (SETF (AREF HELP-LINE 1) 1105)
            (SETF (AREF HELP-LINE 0) 1106)
            (ERROR)))
     (WHEN (> N 0) (SETF (SLOT CUR-LIST TAIL-FIELD) Q)) (DECF SAVE-PTR 1) (GOTO $L.10)))
  (SETF (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT)
        (+ (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT) 1))
  (NEW-SAVE-LEVEL 10)
  (SCAN-LEFT-BRACE)
  (PUSH-NEST)
  (SETF (SLOT CUR-LIST MODE-FIELD) (- 102))
  (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
  $L.10)

(PROCEDURE MAKE-ACCENT ()
  (VAR S REAL)
  (VAR T REAL)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR A SCALED)
  (VAR H SCALED)
  (VAR X SCALED)
  (VAR W SCALED)
  (VAR DELTA SCALED)
  (VAR I FOUR-QUARTERS)
  (SCAN-CHAR-NUM)
  (SETF F (SLOT (SLOT (AREF EQTB 7834) HH) RH))
  (SETF P (NEW-CHARACTER F CUR-VAL))
  (WHEN (/= P 0)
    (SETF X (SLOT (AREF FONT-INFO (+ 5 (AREF PARAM-BASE F))) INT))
    (SETF S (/ (SLOT (AREF FONT-INFO (+ 1 (AREF PARAM-BASE F))) INT) 65536.0))
    (SETF A
          (SLOT (AREF FONT-INFO
                      (+ (AREF WIDTH-BASE F)
                         (SLOT (SLOT (AREF FONT-INFO
                                           (+ (AREF CHAR-BASE F)
                                              (SLOT (SLOT (AREF MEM P) HH) B1)))
                                     QQQQ)
                               B0)))
                INT))
    (DO-ASSIGNMENTS)
    (SETF Q 0)
    (SETF F (SLOT (SLOT (AREF EQTB 7834) HH) RH))
    (COND ((OR (OR (= CUR-CMD 11) (= CUR-CMD 12)) (= CUR-CMD 68))
           (SETF Q (NEW-CHARACTER F CUR-CHR)))
          ((= CUR-CMD 16) (SCAN-CHAR-NUM) (SETF Q (NEW-CHARACTER F CUR-VAL)))
          (TRUE (BACK-INPUT)))
    (WHEN (/= Q 0)
      (SETF T (/ (SLOT (AREF FONT-INFO (+ 1 (AREF PARAM-BASE F))) INT) 65536.0))
      (SETF I
            (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE F) (SLOT (SLOT (AREF MEM Q) HH) B1)))
                  QQQQ))
      (SETF W (SLOT (AREF FONT-INFO (+ (AREF WIDTH-BASE F) (SLOT I B0))) INT))
      (SETF H (SLOT (AREF FONT-INFO (+ (AREF HEIGHT-BASE F) (DIV (- (SLOT I B1) 0) 16))) INT))
      (WHEN (/= H X) (SETF P (HPACK P 0 1)) (SETF (SLOT (AREF MEM (+ P 4)) INT) (- X H)))
      (SETF DELTA (ROUND (- (+ (/ (- W A) 2.0) (* H T)) (* X S))))
      (SETF R (NEW-KERN DELTA))
      (SETF (SLOT (SLOT (AREF MEM R) HH) B1) 2)
      (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) R)
      (SETF (SLOT (SLOT (AREF MEM R) HH) RH) P)
      (SETF (SLOT CUR-LIST TAIL-FIELD) (NEW-KERN (- (- A) DELTA)))
      (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 2)
      (SETF (SLOT (SLOT (AREF MEM P) HH) RH) (SLOT CUR-LIST TAIL-FIELD))
      (SETF P Q))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
    (SETF (SLOT CUR-LIST TAIL-FIELD) P)
    (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)))

(PROCEDURE ALIGN-ERROR ()
  (COND ((> (ABS ALIGN-STATE) 2)
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 1114)
         (PRINT-CMD-CHR CUR-CMD CUR-CHR)
         (COND ((= CUR-TOK 1062)
                (SETF HELP-PTR 6)
                (SETF (AREF HELP-LINE 5) 1115)
                (SETF (AREF HELP-LINE 4) 1116)
                (SETF (AREF HELP-LINE 3) 1117)
                (SETF (AREF HELP-LINE 2) 1118)
                (SETF (AREF HELP-LINE 1) 1119)
                (SETF (AREF HELP-LINE 0) 1120))
               (TRUE
                (SETF HELP-PTR 5)
                (SETF (AREF HELP-LINE 4) 1115)
                (SETF (AREF HELP-LINE 3) 1121)
                (SETF (AREF HELP-LINE 2) 1118)
                (SETF (AREF HELP-LINE 1) 1119)
                (SETF (AREF HELP-LINE 0) 1120)))
         (ERROR))
        (TRUE
         (BACK-INPUT)
         (COND ((< ALIGN-STATE 0)
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 657)
                (INCF ALIGN-STATE 1)
                (SETF CUR-TOK 379))
               (TRUE
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 1110)
                (DECF ALIGN-STATE 1)
                (SETF CUR-TOK 637)))
         (SETF HELP-PTR 3)
         (SETF (AREF HELP-LINE 2) 1111)
         (SETF (AREF HELP-LINE 1) 1112)
         (SETF (AREF HELP-LINE 0) 1113)
         (INS-ERROR))))

(PROCEDURE NO-ALIGN-ERROR ()
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 1114)
  (PRINT-ESC 527)
  (SETF HELP-PTR 2)
  (SETF (AREF HELP-LINE 1) 1122)
  (SETF (AREF HELP-LINE 0) 1123)
  (ERROR))

(PROCEDURE OMIT-ERROR ()
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 1114)
  (PRINT-ESC 530)
  (SETF HELP-PTR 2)
  (SETF (AREF HELP-LINE 1) 1124)
  (SETF (AREF HELP-LINE 0) 1123)
  (ERROR))

(PROCEDURE DO-ENDV ()
  (SETF BASE-PTR INPUT-PTR)
  (SETF (AREF INPUT-STACK BASE-PTR) CUR-INPUT)
  (WHILE (AND (AND (/= (SLOT (AREF INPUT-STACK BASE-PTR) INDEX-FIELD) 2)
                   (= (SLOT (AREF INPUT-STACK BASE-PTR) LOC-FIELD) 0))
              (= (SLOT (AREF INPUT-STACK BASE-PTR) STATE-FIELD) 0))
    (DECF BASE-PTR 1))
  (WHEN (OR (OR (/= (SLOT (AREF INPUT-STACK BASE-PTR) INDEX-FIELD) 2)
                (/= (SLOT (AREF INPUT-STACK BASE-PTR) LOC-FIELD) 0))
            (/= (SLOT (AREF INPUT-STACK BASE-PTR) STATE-FIELD) 0))
    (FATAL-ERROR 595))
  (COND ((= CUR-GROUP 6) (END-GRAF) (WHEN FIN-COL (FIN-ROW))) (TRUE (OFF-SAVE))))

(PROCEDURE CS-ERROR ()
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 777)
  (PRINT-ESC 505)
  (SETF HELP-PTR 1)
  (SETF (AREF HELP-LINE 0) 1126)
  (ERROR))

(PROCEDURE PUSH-MATH ((C GROUP-CODE))
  (PUSH-NEST)
  (SETF (SLOT CUR-LIST MODE-FIELD) (- 203))
  (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 0)
  (NEW-SAVE-LEVEL C))

(PROCEDURE INIT-MATH ()
  (LABEL $L.21)
  (LABEL $L.40)
  (LABEL $L.45)
  (LABEL $L.30)
  (VAR W SCALED)
  (VAR L SCALED)
  (VAR S SCALED)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR N INTEGER)
  (VAR V SCALED)
  (VAR D SCALED)
  (GET-TOKEN)
  (COND ((AND (= CUR-CMD 3) (> (SLOT CUR-LIST MODE-FIELD) 0))
         (COND ((= (SLOT CUR-LIST HEAD-FIELD) (SLOT CUR-LIST TAIL-FIELD))
                (POP-NEST)
                (SETF W (- 1073741823)))
               (TRUE
                (LINE-BREAK (SLOT (AREF EQTB 9170) INT))
                (SETF V
                      (+ (SLOT (AREF MEM (+ JUST-BOX 4)) INT)
                         (* 2
                            (SLOT (AREF FONT-INFO
                                        (+ 6
                                           (AREF PARAM-BASE
                                                 (SLOT (SLOT (AREF EQTB 7834) HH) RH))))
                                  INT))))
                (SETF W (- 1073741823))
                (SETF P (SLOT (SLOT (AREF MEM (+ JUST-BOX 5)) HH) RH))
                (WHILE (/= P 0)
                  $L.21
                  (WHEN (>= P HI-MEM-MIN)
                    (SETF F (SLOT (SLOT (AREF MEM P) HH) B0))
                    (SETF D
                          (SLOT (AREF FONT-INFO
                                      (+ (AREF WIDTH-BASE F)
                                         (SLOT (SLOT (AREF FONT-INFO
                                                           (+
                                                            (AREF CHAR-BASE F)
                                                            (SLOT (SLOT (AREF MEM P) HH) B1)))
                                                     QQQQ)
                                               B0)))
                                INT))
                    (GOTO $L.40))
                  (CASE (SLOT (SLOT (AREF MEM P) HH) B0)
                    ((0 1 2) (SETF D (SLOT (AREF MEM (+ P 1)) INT)) (GOTO $L.40))
                    ((6) (SETF (AREF MEM 59988) (AREF MEM (+ P 1)))
                     (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH)
                           (SLOT (SLOT (AREF MEM P) HH) RH))
                     (SETF P 59988) (GOTO $L.21))
                    ((11 9) (SETF D (SLOT (AREF MEM (+ P 1)) INT)))
                    ((10) (SETF Q (SLOT (SLOT (AREF MEM (+ P 1)) HH) LH))
                     (SETF D (SLOT (AREF MEM (+ Q 1)) INT))
                     (COND ((= (SLOT (SLOT (AREF MEM (+ JUST-BOX 5)) HH) B0) 1)
                            (WHEN (AND (= (SLOT (SLOT (AREF MEM (+ JUST-BOX 5)) HH) B1)
                                          (SLOT (SLOT (AREF MEM Q) HH) B0))
                                       (/= (SLOT (AREF MEM (+ Q 2)) INT) 0))
                              (SETF V 1073741823)))
                           ((= (SLOT (SLOT (AREF MEM (+ JUST-BOX 5)) HH) B0) 2)
                            (WHEN (AND (= (SLOT (SLOT (AREF MEM (+ JUST-BOX 5)) HH) B1)
                                          (SLOT (SLOT (AREF MEM Q) HH) B1))
                                       (/= (SLOT (AREF MEM (+ Q 3)) INT) 0))
                              (SETF V 1073741823))))
                     (WHEN (>= (SLOT (SLOT (AREF MEM P) HH) B1) 100) (GOTO $L.40)))
                    ((8) (SETF D 0))
                    (ELSE (SETF D 0)))
                  (WHEN (< V 1073741823) (INCF V D))
                  (GOTO $L.45)
                  $L.40
                  (COND ((< V 1073741823) (INCF V D) (SETF W V))
                        (TRUE (SETF W 1073741823) (GOTO $L.30)))
                  $L.45
                  (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
                $L.30))
         (COND ((= (SLOT (SLOT (AREF EQTB 7312) HH) RH) 0)
                (COND ((AND (/= (SLOT (AREF EQTB 9747) INT) 0)
                            (OR (AND (>= (SLOT (AREF EQTB 9204) INT) 0)
                                     (> (+ (SLOT CUR-LIST PG-FIELD) 2)
                                        (SLOT (AREF EQTB 9204) INT)))
                                (< (+ (SLOT CUR-LIST PG-FIELD) 1)
                                   (- (SLOT (AREF EQTB 9204) INT)))))
                       (SETF L
                             (- (SLOT (AREF EQTB 9733) INT) (ABS (SLOT (AREF EQTB 9747) INT))))
                       (COND ((> (SLOT (AREF EQTB 9747) INT) 0)
                              (SETF S (SLOT (AREF EQTB 9747) INT)))
                             (TRUE (SETF S 0))))
                      (TRUE (SETF L (SLOT (AREF EQTB 9733) INT)) (SETF S 0))))
               (TRUE
                (SETF N (SLOT (SLOT (AREF MEM (SLOT (SLOT (AREF EQTB 7312) HH) RH)) HH) LH))
                (COND ((>= (+ (SLOT CUR-LIST PG-FIELD) 2) N)
                       (SETF P (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH) (* 2 N))))
                      (TRUE
                       (SETF P
                             (+ (SLOT (SLOT (AREF EQTB 7312) HH) RH)
                                (* 2 (+ (SLOT CUR-LIST PG-FIELD) 2))))))
                (SETF S (SLOT (AREF MEM (- P 1)) INT))
                (SETF L (SLOT (AREF MEM P) INT))))
         (PUSH-MATH 15)
         (SETF (SLOT CUR-LIST MODE-FIELD) 203)
         (EQ-WORD-DEFINE 9207 (- 1))
         (EQ-WORD-DEFINE 9743 W)
         (EQ-WORD-DEFINE 9744 L)
         (EQ-WORD-DEFINE 9745 S)
         (WHEN (/= (SLOT (SLOT (AREF EQTB 7316) HH) RH) 0)
           (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7316) HH) RH) 9))
         (WHEN (= NEST-PTR 1) (BUILD-PAGE)))
        (TRUE
         (BACK-INPUT)
         (PUSH-MATH 15)
         (EQ-WORD-DEFINE 9207 (- 1))
         (WHEN (/= (SLOT (SLOT (AREF EQTB 7315) HH) RH) 0)
           (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7315) HH) RH) 8)))))

(PROCEDURE START-EQ-NO ()
  (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) CUR-CHR)
  (INCF SAVE-PTR 1)
  (PUSH-MATH 15)
  (EQ-WORD-DEFINE 9207 (- 1))
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7315) HH) RH) 0)
    (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7315) HH) RH) 8)))

(PROCEDURE SCAN-MATH ((P HALFWORD))
  (LABEL $L.20)
  (LABEL $L.21)
  (LABEL $L.10)
  (VAR C INTEGER)
  $L.20
  (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
  $L.21
  (CASE CUR-CMD
    ((11 12 68) (SETF C (- (SLOT (SLOT (AREF EQTB (+ 8907 CUR-CHR)) HH) RH) 0))
     (WHEN (= C 32768)
       (SETF CUR-CS (+ CUR-CHR 1))
       (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
       (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
       (X-TOKEN)
       (BACK-INPUT)
       (GOTO $L.20)))
    ((16) (SCAN-CHAR-NUM) (SETF CUR-CHR CUR-VAL) (SETF CUR-CMD 68) (GOTO $L.21))
    ((17) (SCAN-FIFTEEN-BIT-INT) (SETF C CUR-VAL))
    ((69) (SETF C CUR-CHR))
    ((15) (SCAN-TWENTY-SEVEN-BIT-INT) (SETF C (DIV CUR-VAL 4096)))
    (ELSE (BACK-INPUT) (SCAN-LEFT-BRACE) (SETF (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) P)
     (INCF SAVE-PTR 1) (PUSH-MATH 9) (GOTO $L.10)))
  (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 1)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) (+ (MOD C 256) 0))
  (COND ((AND (>= C 28672)
              (AND (>= (SLOT (AREF EQTB 9207) INT) 0) (< (SLOT (AREF EQTB 9207) INT) 16)))
         (SETF (SLOT (SLOT (AREF MEM P) HH) B0) (SLOT (AREF EQTB 9207) INT)))
        (TRUE (SETF (SLOT (SLOT (AREF MEM P) HH) B0) (MOD (DIV C 256) 16))))
  $L.10)

(PROCEDURE SET-MATH-CHAR ((C INTEGER))
  (VAR P HALFWORD)
  (COND ((>= C 32768)
         (SETF CUR-CS (+ CUR-CHR 1))
         (SETF CUR-CMD (SLOT (SLOT (AREF EQTB CUR-CS) HH) B0))
         (SETF CUR-CHR (SLOT (SLOT (AREF EQTB CUR-CS) HH) RH))
         (X-TOKEN)
         (BACK-INPUT))
        (TRUE
         (SETF P NEW-NOAD)
         (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) 1)
         (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) B1) (+ (MOD C 256) 0))
         (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) B0) (MOD (DIV C 256) 16))
         (COND ((>= C 28672)
                (WHEN (AND (>= (SLOT (AREF EQTB 9207) INT) 0)
                           (< (SLOT (AREF EQTB 9207) INT) 16))
                  (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) B0) (SLOT (AREF EQTB 9207) INT)))
                (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 16))
               (TRUE (SETF (SLOT (SLOT (AREF MEM P) HH) B0) (+ 16 (DIV C 4096)))))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
         (SETF (SLOT CUR-LIST TAIL-FIELD) P))))

(PROCEDURE MATH-LIMIT-SWITCH ()
  (LABEL $L.10)
  (WHEN (/= (SLOT CUR-LIST HEAD-FIELD) (SLOT CUR-LIST TAIL-FIELD))
    (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 17)
      (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) CUR-CHR)
      (GOTO $L.10)))
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 1130)
  (SETF HELP-PTR 1)
  (SETF (AREF HELP-LINE 0) 1131)
  (ERROR)
  $L.10)

(PROCEDURE SCAN-DELIMITER ((P HALFWORD) (R BOOLEAN))
  (COND (R (SCAN-TWENTY-SEVEN-BIT-INT))
        (TRUE
         (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
         (CASE CUR-CMD
           ((11 12) (SETF CUR-VAL (SLOT (AREF EQTB (+ 9474 CUR-CHR)) INT)))
           ((15) (SCAN-TWENTY-SEVEN-BIT-INT))
           (ELSE (SETF CUR-VAL (- 1))))))
  (WHEN (< CUR-VAL 0)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1132)
    (SETF HELP-PTR 6)
    (SETF (AREF HELP-LINE 5) 1133)
    (SETF (AREF HELP-LINE 4) 1134)
    (SETF (AREF HELP-LINE 3) 1135)
    (SETF (AREF HELP-LINE 2) 1136)
    (SETF (AREF HELP-LINE 1) 1137)
    (SETF (AREF HELP-LINE 0) 1138)
    (BACK-ERROR)
    (SETF CUR-VAL 0))
  (SETF (SLOT (SLOT (AREF MEM P) QQQQ) B0) (MOD (DIV CUR-VAL 1048576) 16))
  (SETF (SLOT (SLOT (AREF MEM P) QQQQ) B1) (+ (MOD (DIV CUR-VAL 4096) 256) 0))
  (SETF (SLOT (SLOT (AREF MEM P) QQQQ) B2) (MOD (DIV CUR-VAL 256) 16))
  (SETF (SLOT (SLOT (AREF MEM P) QQQQ) B3) (+ (MOD CUR-VAL 256) 0)))

(PROCEDURE MATH-RADICAL ()
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (GET-NODE 5))
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 24)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) EMPTY-FIELD)
  (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 3)) HH) EMPTY-FIELD)
  (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) HH) EMPTY-FIELD)
  (SCAN-DELIMITER (+ (SLOT CUR-LIST TAIL-FIELD) 4) TRUE)
  (SCAN-MATH (+ (SLOT CUR-LIST TAIL-FIELD) 1)))

(PROCEDURE MATH-AC ()
  (WHEN (= CUR-CMD 45)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1139)
    (PRINT-ESC 523)
    (PRINT 1140)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 1141)
    (SETF (AREF HELP-LINE 0) 1142)
    (ERROR))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (GET-NODE 5))
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 28)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 0)
  (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) EMPTY-FIELD)
  (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 3)) HH) EMPTY-FIELD)
  (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) HH) EMPTY-FIELD)
  (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 4)) HH) RH) 1)
  (SCAN-FIFTEEN-BIT-INT)
  (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 4)) HH) B1)
        (+ (MOD CUR-VAL 256) 0))
  (COND ((AND (>= CUR-VAL 28672)
              (AND (>= (SLOT (AREF EQTB 9207) INT) 0) (< (SLOT (AREF EQTB 9207) INT) 16)))
         (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 4)) HH) B0)
               (SLOT (AREF EQTB 9207) INT)))
        (TRUE
         (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 4)) HH) B0)
               (MOD (DIV CUR-VAL 256) 16))))
  (SCAN-MATH (+ (SLOT CUR-LIST TAIL-FIELD) 1)))

(PROCEDURE APPEND-CHOICES ()
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-CHOICE)
  (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
  (INCF SAVE-PTR 1)
  (SETF (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT) 0)
  (PUSH-MATH 13)
  (SCAN-LEFT-BRACE))

(FUNCTION (FIN-MLIST HALFWORD) ((P HALFWORD))
  (VAR Q HALFWORD)
  (COND ((/= (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 0)
         (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 3)) HH) RH) 3)
         (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 3)) HH) LH)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
         (COND ((= P 0) (SETF Q (SLOT (SLOT CUR-LIST AUX-FIELD) INT)))
               (TRUE
                (SETF Q
                      (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 2)) HH)
                            LH))
                (WHEN (/= (SLOT (SLOT (AREF MEM Q) HH) B0) 30) (CONFUSION 877))
                (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 2)) HH) LH)
                      (SLOT (SLOT (AREF MEM Q) HH) RH))
                (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (SLOT (SLOT CUR-LIST AUX-FIELD) INT))
                (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT CUR-LIST AUX-FIELD) INT)) HH) RH) P))))
        (TRUE
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
         (SETF Q (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))))
  (POP-NEST)
  (SETF FIN-MLIST Q))

(PROCEDURE BUILD-CHOICES ()
  (LABEL $L.10)
  (VAR P HALFWORD)
  (UNSAVE)
  (SETF P (FIN-MLIST 0))
  (CASE (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT)
    ((0) (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH) P))
    ((1) (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) P))
    ((2) (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) HH) LH) P))
    ((3) (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) HH) RH) P)
     (DECF SAVE-PTR 1) (GOTO $L.10)))
  (SETF (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT)
        (+ (SLOT (AREF SAVE-STACK (- SAVE-PTR 1)) INT) 1))
  (PUSH-MATH 13)
  (SCAN-LEFT-BRACE)
  $L.10)

(PROCEDURE SUB-SUP ()
  (VAR T SMALL-NUMBER)
  (VAR P HALFWORD)
  (SETF T 0)
  (SETF P 0)
  (WHEN (/= (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
    (WHEN (AND (>= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 16)
               (< (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 30))
      (SETF P (- (+ (+ (SLOT CUR-LIST TAIL-FIELD) 2) CUR-CMD) 7))
      (SETF T (SLOT (SLOT (AREF MEM P) HH) RH))))
  (WHEN (OR (= P 0) (/= T 0))
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-NOAD)
    (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
    (SETF P (- (+ (+ (SLOT CUR-LIST TAIL-FIELD) 2) CUR-CMD) 7))
    (WHEN (/= T 0)
      (COND ((= CUR-CMD 7)
             (WHEN (= INTERACTION 3))
             (PRINT-NL 262)
             (PRINT 1143)
             (SETF HELP-PTR 1)
             (SETF (AREF HELP-LINE 0) 1144))
            (TRUE
             (WHEN (= INTERACTION 3))
             (PRINT-NL 262)
             (PRINT 1145)
             (SETF HELP-PTR 1)
             (SETF (AREF HELP-LINE 0) 1146)))
      (ERROR)))
  (SCAN-MATH P))

(PROCEDURE MATH-FRACTION ()
  (VAR C SMALL-NUMBER)
  (SETF C CUR-CHR)
  (COND ((/= (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 0)
         (WHEN (>= C 3) (SCAN-DELIMITER 59988 FALSE) (SCAN-DELIMITER 59988 FALSE))
         (WHEN (= (MOD C 3) 0) (SCAN-DIMEN FALSE FALSE FALSE))
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 1153)
         (SETF HELP-PTR 3)
         (SETF (AREF HELP-LINE 2) 1154)
         (SETF (AREF HELP-LINE 1) 1155)
         (SETF (AREF HELP-LINE 0) 1156)
         (ERROR))
        (TRUE
         (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (GET-NODE 6))
         (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT CUR-LIST AUX-FIELD) INT)) HH) B0) 25)
         (SETF (SLOT (SLOT (AREF MEM (SLOT (SLOT CUR-LIST AUX-FIELD) INT)) HH) B1) 0)
         (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 2)) HH) RH) 3)
         (SETF (SLOT (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 2)) HH) LH)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
         (SETF (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 3)) HH) EMPTY-FIELD)
         (SETF (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 4)) QQQQ)
               NULL-DELIMITER)
         (SETF (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 5)) QQQQ)
               NULL-DELIMITER)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) 0)
         (SETF (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
         (WHEN (>= C 3)
           (SCAN-DELIMITER (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 4) FALSE)
           (SCAN-DELIMITER (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 5) FALSE))
         (CASE (MOD C 3)
           ((0) (SCAN-DIMEN FALSE FALSE FALSE)
            (SETF (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 1)) INT) CUR-VAL))
           ((1)
            (SETF (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 1)) INT) 1073741824))
           ((2) (SETF (SLOT (AREF MEM (+ (SLOT (SLOT CUR-LIST AUX-FIELD) INT) 1)) INT) 0))))))

(PROCEDURE MATH-LEFT-RIGHT ()
  (VAR T SMALL-NUMBER)
  (VAR P HALFWORD)
  (SETF T CUR-CHR)
  (COND ((AND (= T 31) (/= CUR-GROUP 16))
         (COND ((= CUR-GROUP 15)
                (SCAN-DELIMITER 59988 FALSE)
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 777)
                (PRINT-ESC 877)
                (SETF HELP-PTR 1)
                (SETF (AREF HELP-LINE 0) 1157)
                (ERROR))
               (TRUE (OFF-SAVE))))
        (TRUE
         (SETF P NEW-NOAD)
         (SETF (SLOT (SLOT (AREF MEM P) HH) B0) T)
         (SCAN-DELIMITER (+ P 1) FALSE)
         (COND ((= T 30)
                (PUSH-MATH 16)
                (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) P)
                (SETF (SLOT CUR-LIST TAIL-FIELD) P))
               (TRUE
                (SETF P (FIN-MLIST P))
                (UNSAVE)
                (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-NOAD)
                (SETF (SLOT CUR-LIST TAIL-FIELD)
                      (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
                (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 23)
                (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) 3)
                (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH) P))))))

(PROCEDURE AFTER-MATH ()
  (VAR L BOOLEAN)
  (VAR DANGER BOOLEAN)
  (VAR M INTEGER)
  (VAR P HALFWORD)
  (VAR A HALFWORD)
  (VAR B HALFWORD)
  (VAR W SCALED)
  (VAR Z SCALED)
  (VAR E SCALED)
  (VAR Q SCALED)
  (VAR D SCALED)
  (VAR S SCALED)
  (VAR G1 SMALL-NUMBER)
  (VAR G2 SMALL-NUMBER)
  (VAR R HALFWORD)
  (VAR T HALFWORD)
  (SETF DANGER FALSE)
  (COND ((OR (OR (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7837) HH) RH)) 22)
                 (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7853) HH) RH)) 22))
             (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7869) HH) RH)) 22))
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 1158)
         (SETF HELP-PTR 3)
         (SETF (AREF HELP-LINE 2) 1159)
         (SETF (AREF HELP-LINE 1) 1160)
         (SETF (AREF HELP-LINE 0) 1161)
         (ERROR)
         (FLUSH-MATH)
         (SETF DANGER TRUE))
        ((OR (OR (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7838) HH) RH)) 13)
                 (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7854) HH) RH)) 13))
             (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7870) HH) RH)) 13))
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 1162)
         (SETF HELP-PTR 3)
         (SETF (AREF HELP-LINE 2) 1163)
         (SETF (AREF HELP-LINE 1) 1164)
         (SETF (AREF HELP-LINE 0) 1165)
         (ERROR)
         (FLUSH-MATH)
         (SETF DANGER TRUE)))
  (SETF M (SLOT CUR-LIST MODE-FIELD))
  (SETF L FALSE)
  (SETF P (FIN-MLIST 0))
  (COND ((= (SLOT CUR-LIST MODE-FIELD) (- M))
         (GET-X-TOKEN)
         (WHEN (/= CUR-CMD 3)
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 1166)
           (SETF HELP-PTR 2)
           (SETF (AREF HELP-LINE 1) 1167)
           (SETF (AREF HELP-LINE 0) 1168)
           (BACK-ERROR))
         (SETF CUR-MLIST P)
         (SETF CUR-STYLE 2)
         (SETF MLIST-PENALTIES FALSE)
         (MLIST-TO-HLIST)
         (SETF A (HPACK (SLOT (SLOT (AREF MEM 59997) HH) RH) 0 1))
         (UNSAVE)
         (DECF SAVE-PTR 1)
         (WHEN (= (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) 1) (SETF L TRUE))
         (SETF DANGER FALSE)
         (COND ((OR (OR (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7837) HH) RH)) 22)
                        (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7853) HH) RH)) 22))
                    (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7869) HH) RH)) 22))
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 1158)
                (SETF HELP-PTR 3)
                (SETF (AREF HELP-LINE 2) 1159)
                (SETF (AREF HELP-LINE 1) 1160)
                (SETF (AREF HELP-LINE 0) 1161)
                (ERROR)
                (FLUSH-MATH)
                (SETF DANGER TRUE))
               ((OR (OR (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7838) HH) RH)) 13)
                        (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7854) HH) RH)) 13))
                    (< (AREF FONT-PARAMS (SLOT (SLOT (AREF EQTB 7870) HH) RH)) 13))
                (WHEN (= INTERACTION 3))
                (PRINT-NL 262)
                (PRINT 1162)
                (SETF HELP-PTR 3)
                (SETF (AREF HELP-LINE 2) 1163)
                (SETF (AREF HELP-LINE 1) 1164)
                (SETF (AREF HELP-LINE 0) 1165)
                (ERROR)
                (FLUSH-MATH)
                (SETF DANGER TRUE)))
         (SETF M (SLOT CUR-LIST MODE-FIELD))
         (SETF P (FIN-MLIST 0)))
        (TRUE (SETF A 0)))
  (COND ((< M 0)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (NEW-MATH (SLOT (AREF EQTB 9731) INT) 0))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (SETF CUR-MLIST P)
         (SETF CUR-STYLE 2)
         (SETF MLIST-PENALTIES (> (SLOT CUR-LIST MODE-FIELD) 0))
         (MLIST-TO-HLIST)
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (SLOT (SLOT (AREF MEM 59997) HH) RH))
         (WHILE (/= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) 0)
           (SETF (SLOT CUR-LIST TAIL-FIELD)
                 (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (NEW-MATH (SLOT (AREF EQTB 9731) INT) 1))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
         (UNSAVE))
        (TRUE
         (WHEN (= A 0)
           (GET-X-TOKEN)
           (WHEN (/= CUR-CMD 3)
             (WHEN (= INTERACTION 3))
             (PRINT-NL 262)
             (PRINT 1166)
             (SETF HELP-PTR 2)
             (SETF (AREF HELP-LINE 1) 1167)
             (SETF (AREF HELP-LINE 0) 1168)
             (BACK-ERROR)))
         (SETF CUR-MLIST P)
         (SETF CUR-STYLE 0)
         (SETF MLIST-PENALTIES FALSE)
         (MLIST-TO-HLIST)
         (SETF P (SLOT (SLOT (AREF MEM 59997) HH) RH))
         (SETF ADJUST-TAIL 59995)
         (SETF B (HPACK P 0 1))
         (SETF P (SLOT (SLOT (AREF MEM (+ B 5)) HH) RH))
         (SETF T ADJUST-TAIL)
         (SETF ADJUST-TAIL 0)
         (SETF W (SLOT (AREF MEM (+ B 1)) INT))
         (SETF Z (SLOT (AREF EQTB 9744) INT))
         (SETF S (SLOT (AREF EQTB 9745) INT))
         (COND ((OR (= A 0) DANGER) (SETF E 0) (SETF Q 0))
               (TRUE
                (SETF E (SLOT (AREF MEM (+ A 1)) INT))
                (SETF Q
                      (+ E
                         (SLOT (AREF FONT-INFO
                                     (+ 6
                                        (AREF PARAM-BASE
                                              (SLOT (SLOT (AREF EQTB 7837) HH) RH))))
                               INT)))))
         (WHEN (> (+ W Q) Z)
           (COND ((AND (/= E 0)
                       (OR (OR (OR (<= (+ (- W (AREF TOTAL-SHRINK 0)) Q) Z)
                                   (/= (AREF TOTAL-SHRINK 1) 0))
                               (/= (AREF TOTAL-SHRINK 2) 0))
                           (/= (AREF TOTAL-SHRINK 3) 0)))
                  (FREE-NODE B 7)
                  (SETF B (HPACK P (- Z Q) 0)))
                 (TRUE (SETF E 0) (WHEN (> W Z) (FREE-NODE B 7) (SETF B (HPACK P Z 0)))))
           (SETF W (SLOT (AREF MEM (+ B 1)) INT)))
         (SETF D (HALF (- Z W)))
         (WHEN (AND (> E 0) (< D (* 2 E)))
           (SETF D (HALF (- (- Z W) E)))
           (WHEN (/= P 0)
             (UNLESS (>= P HI-MEM-MIN)
               (WHEN (= (SLOT (SLOT (AREF MEM P) HH) B0) 10) (SETF D 0)))))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (NEW-PENALTY (SLOT (AREF EQTB 9174) INT)))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (COND ((OR (<= (+ D S) (SLOT (AREF EQTB 9743) INT)) L) (SETF G1 3) (SETF G2 4))
               (TRUE (SETF G1 5) (SETF G2 6)))
         (COND ((AND L (= E 0))
                (SETF (SLOT (AREF MEM (+ A 4)) INT) S)
                (APPEND-TO-VLIST A)
                (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
                      (NEW-PENALTY 10000))
                (SETF (SLOT CUR-LIST TAIL-FIELD)
                      (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
               (TRUE
                (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
                      (NEW-PARAM-GLUE G1))
                (SETF (SLOT CUR-LIST TAIL-FIELD)
                      (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))))
         (WHEN (/= E 0)
           (SETF R (NEW-KERN (- (- (- Z W) E) D)))
           (COND (L
                  (SETF (SLOT (SLOT (AREF MEM A) HH) RH) R)
                  (SETF (SLOT (SLOT (AREF MEM R) HH) RH) B)
                  (SETF B A)
                  (SETF D 0))
                 (TRUE
                  (SETF (SLOT (SLOT (AREF MEM B) HH) RH) R)
                  (SETF (SLOT (SLOT (AREF MEM R) HH) RH) A)))
           (SETF B (HPACK B 0 1)))
         (SETF (SLOT (AREF MEM (+ B 4)) INT) (+ S D))
         (APPEND-TO-VLIST B)
         (WHEN (AND (AND (/= A 0) (= E 0)) (NOT L))
           (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PENALTY 10000))
           (SETF (SLOT CUR-LIST TAIL-FIELD)
                 (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
           (SETF (SLOT (AREF MEM (+ A 4)) INT) (- (+ S Z) (SLOT (AREF MEM (+ A 1)) INT)))
           (APPEND-TO-VLIST A)
           (SETF G2 0))
         (WHEN (/= T 59995)
           (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
                 (SLOT (SLOT (AREF MEM 59995) HH) RH))
           (SETF (SLOT CUR-LIST TAIL-FIELD) T))
         (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
               (NEW-PENALTY (SLOT (AREF EQTB 9175) INT)))
         (SETF (SLOT CUR-LIST TAIL-FIELD)
               (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
         (WHEN (> G2 0)
           (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-PARAM-GLUE G2))
           (SETF (SLOT CUR-LIST TAIL-FIELD)
                 (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
         (RESUME-AFTER-DISPLAY))))

(PROCEDURE RESUME-AFTER-DISPLAY ()
  (WHEN (/= CUR-GROUP 15) (CONFUSION 1169))
  (UNSAVE)
  (SETF (SLOT CUR-LIST PG-FIELD) (+ (SLOT CUR-LIST PG-FIELD) 3))
  (PUSH-NEST)
  (SETF (SLOT CUR-LIST MODE-FIELD) 102)
  (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
  (COND ((<= (SLOT (AREF EQTB 9213) INT) 0) (SETF CUR-LANG 0))
        ((> (SLOT (AREF EQTB 9213) INT) 255) (SETF CUR-LANG 0))
        (TRUE (SETF CUR-LANG (SLOT (AREF EQTB 9213) INT))))
  (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH) CUR-LANG)
  (SETF (SLOT CUR-LIST PG-FIELD)
        (+ (* (+ (* (NORM-MIN (SLOT (AREF EQTB 9214) INT)) 64)
                 (NORM-MIN (SLOT (AREF EQTB 9215) INT)))
              65536)
           CUR-LANG))
  (GET-X-TOKEN)
  (WHEN (/= CUR-CMD 10) (BACK-INPUT))
  (WHEN (= NEST-PTR 1) (BUILD-PAGE)))

(PROCEDURE GET-R-TOKEN ()
  (LABEL $L.20)
  $L.20
  (REPEAT (GET-TOKEN) (UNTIL (/= CUR-TOK 2592)))
  (WHEN (OR (= CUR-CS 0) (> CUR-CS 6514))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1184)
    (SETF HELP-PTR 5)
    (SETF (AREF HELP-LINE 4) 1185)
    (SETF (AREF HELP-LINE 3) 1186)
    (SETF (AREF HELP-LINE 2) 1187)
    (SETF (AREF HELP-LINE 1) 1188)
    (SETF (AREF HELP-LINE 0) 1189)
    (WHEN (= CUR-CS 0) (BACK-INPUT))
    (SETF CUR-TOK 10609)
    (INS-ERROR)
    (GOTO $L.20)))

(PROCEDURE TRAP-ZERO-GLUE ()
  (WHEN (AND (AND (= (SLOT (AREF MEM (+ CUR-VAL 1)) INT) 0)
                  (= (SLOT (AREF MEM (+ CUR-VAL 2)) INT) 0))
             (= (SLOT (AREF MEM (+ CUR-VAL 3)) INT) 0))
    (SETF (SLOT (SLOT (AREF MEM 0) HH) RH) (+ (SLOT (SLOT (AREF MEM 0) HH) RH) 1))
    (DELETE-GLUE-REF CUR-VAL)
    (SETF CUR-VAL 0)))

(PROCEDURE DO-REGISTER-COMMAND ((A SMALL-NUMBER))
  (LABEL $L.40)
  (LABEL $L.10)
  (VAR L HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (VAR S HALFWORD)
  (VAR P (RANGE 0 3))
  (SETF Q CUR-CMD)
  (WHEN (/= Q 89)
    (GET-X-TOKEN)
    (WHEN (AND (>= CUR-CMD 73) (<= CUR-CMD 76))
      (SETF L CUR-CHR)
      (SETF P (- CUR-CMD 73))
      (GOTO $L.40))
    (WHEN (/= CUR-CMD 89)
      (WHEN (= INTERACTION 3))
      (PRINT-NL 262)
      (PRINT 685)
      (PRINT-CMD-CHR CUR-CMD CUR-CHR)
      (PRINT 686)
      (PRINT-CMD-CHR Q 0)
      (SETF HELP-PTR 1)
      (SETF (AREF HELP-LINE 0) 1210)
      (ERROR)
      (GOTO $L.10)))
  (SETF P CUR-CHR)
  (SCAN-EIGHT-BIT-INT)
  (CASE P
    ((0) (SETF L (+ CUR-VAL 9218)))
    ((1) (SETF L (+ CUR-VAL 9751)))
    ((2) (SETF L (+ CUR-VAL 6800)))
    ((3) (SETF L (+ CUR-VAL 7056))))
  $L.40
  (COND ((= Q 89) (SCAN-OPTIONAL-EQUALS)) ((SCAN-KEYWORD 1206)))
  (SETF ARITH-ERROR FALSE)
  (COND ((< Q 91)
         (COND ((< P 2)
                (COND ((= P 0) (SCAN-INT)) (TRUE (SCAN-DIMEN FALSE FALSE FALSE)))
                (WHEN (= Q 90) (INCF CUR-VAL (SLOT (AREF EQTB L) INT))))
               (TRUE
                (SCAN-GLUE P)
                (WHEN (= Q 90)
                  (SETF Q (NEW-SPEC CUR-VAL))
                  (SETF R (SLOT (SLOT (AREF EQTB L) HH) RH))
                  (DELETE-GLUE-REF CUR-VAL)
                  (SETF (SLOT (AREF MEM (+ Q 1)) INT)
                        (+ (SLOT (AREF MEM (+ Q 1)) INT) (SLOT (AREF MEM (+ R 1)) INT)))
                  (WHEN (= (SLOT (AREF MEM (+ Q 2)) INT) 0)
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) B0) 0))
                  (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B0) (SLOT (SLOT (AREF MEM R) HH) B0))
                         (SETF (SLOT (AREF MEM (+ Q 2)) INT)
                               (+ (SLOT (AREF MEM (+ Q 2)) INT)
                                  (SLOT (AREF MEM (+ R 2)) INT))))
                        ((AND (< (SLOT (SLOT (AREF MEM Q) HH) B0)
                                 (SLOT (SLOT (AREF MEM R) HH) B0))
                              (/= (SLOT (AREF MEM (+ R 2)) INT) 0))
                         (SETF (SLOT (AREF MEM (+ Q 2)) INT) (SLOT (AREF MEM (+ R 2)) INT))
                         (SETF (SLOT (SLOT (AREF MEM Q) HH) B0)
                               (SLOT (SLOT (AREF MEM R) HH) B0))))
                  (WHEN (= (SLOT (AREF MEM (+ Q 3)) INT) 0)
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) B1) 0))
                  (COND ((= (SLOT (SLOT (AREF MEM Q) HH) B1) (SLOT (SLOT (AREF MEM R) HH) B1))
                         (SETF (SLOT (AREF MEM (+ Q 3)) INT)
                               (+ (SLOT (AREF MEM (+ Q 3)) INT)
                                  (SLOT (AREF MEM (+ R 3)) INT))))
                        ((AND (< (SLOT (SLOT (AREF MEM Q) HH) B1)
                                 (SLOT (SLOT (AREF MEM R) HH) B1))
                              (/= (SLOT (AREF MEM (+ R 3)) INT) 0))
                         (SETF (SLOT (AREF MEM (+ Q 3)) INT) (SLOT (AREF MEM (+ R 3)) INT))
                         (SETF (SLOT (SLOT (AREF MEM Q) HH) B1)
                               (SLOT (SLOT (AREF MEM R) HH) B1))))
                  (SETF CUR-VAL Q)))))
        (TRUE
         (SCAN-INT)
         (COND ((< P 2)
                (COND ((= Q 91)
                       (COND ((= P 0)
                              (SETF CUR-VAL
                                    (MULT-AND-ADD (SLOT (AREF EQTB L) INT)
                                                  CUR-VAL
                                                  0
                                                  2147483647)))
                             (TRUE
                              (SETF CUR-VAL
                                    (MULT-AND-ADD (SLOT (AREF EQTB L) INT)
                                                  CUR-VAL
                                                  0
                                                  1073741823)))))
                      (TRUE (SETF CUR-VAL (X-OVER-N (SLOT (AREF EQTB L) INT) CUR-VAL)))))
               (TRUE
                (SETF S (SLOT (SLOT (AREF EQTB L) HH) RH))
                (SETF R (NEW-SPEC S))
                (COND ((= Q 91)
                       (SETF (SLOT (AREF MEM (+ R 1)) INT)
                             (MULT-AND-ADD (SLOT (AREF MEM (+ S 1)) INT) CUR-VAL 0 1073741823))
                       (SETF (SLOT (AREF MEM (+ R 2)) INT)
                             (MULT-AND-ADD (SLOT (AREF MEM (+ S 2)) INT) CUR-VAL 0 1073741823))
                       (SETF (SLOT (AREF MEM (+ R 3)) INT)
                             (MULT-AND-ADD (SLOT (AREF MEM (+ S 3)) INT)
                                           CUR-VAL
                                           0
                                           1073741823)))
                      (TRUE
                       (SETF (SLOT (AREF MEM (+ R 1)) INT)
                             (X-OVER-N (SLOT (AREF MEM (+ S 1)) INT) CUR-VAL))
                       (SETF (SLOT (AREF MEM (+ R 2)) INT)
                             (X-OVER-N (SLOT (AREF MEM (+ S 2)) INT) CUR-VAL))
                       (SETF (SLOT (AREF MEM (+ R 3)) INT)
                             (X-OVER-N (SLOT (AREF MEM (+ S 3)) INT) CUR-VAL))))
                (SETF CUR-VAL R)))))
  (WHEN ARITH-ERROR
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1207)
    (SETF HELP-PTR 2)
    (SETF (AREF HELP-LINE 1) 1208)
    (SETF (AREF HELP-LINE 0) 1209)
    (WHEN (>= P 2) (DELETE-GLUE-REF CUR-VAL))
    (ERROR)
    (GOTO $L.10))
  (COND ((< P 2)
         (COND ((>= A 4) (GEQ-WORD-DEFINE L CUR-VAL)) (TRUE (EQ-WORD-DEFINE L CUR-VAL))))
        (TRUE
         (TRAP-ZERO-GLUE)
         (COND ((>= A 4) (GEQ-DEFINE L 117 CUR-VAL)) (TRUE (EQ-DEFINE L 117 CUR-VAL)))))
  $L.10)

(PROCEDURE ALTER-AUX ()
  (VAR C HALFWORD)
  (COND ((/= CUR-CHR (ABS (SLOT CUR-LIST MODE-FIELD))) (REPORT-ILLEGAL-CASE))
        (TRUE
         (SETF C CUR-CHR)
         (SCAN-OPTIONAL-EQUALS)
         (COND ((= C 1)
                (SCAN-DIMEN FALSE FALSE FALSE)
                (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) CUR-VAL))
               (TRUE
                (SCAN-INT)
                (COND ((OR (<= CUR-VAL 0) (> CUR-VAL 32767))
                       (WHEN (= INTERACTION 3))
                       (PRINT-NL 262)
                       (PRINT 1213)
                       (SETF HELP-PTR 1)
                       (SETF (AREF HELP-LINE 0) 1214)
                       (INT-ERROR CUR-VAL))
                      (TRUE (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) CUR-VAL))))))))

(PROCEDURE ALTER-PREV-GRAF ()
  (VAR P (RANGE 0 NEST-SIZE))
  (SETF (AREF NEST NEST-PTR) CUR-LIST)
  (SETF P NEST-PTR)
  (WHILE (/= (ABS (SLOT (AREF NEST P) MODE-FIELD)) 1) (DECF P 1))
  (SCAN-OPTIONAL-EQUALS)
  (SCAN-INT)
  (COND ((< CUR-VAL 0)
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 955)
         (PRINT-ESC 532)
         (SETF HELP-PTR 1)
         (SETF (AREF HELP-LINE 0) 1215)
         (INT-ERROR CUR-VAL))
        (TRUE
         (SETF (SLOT (AREF NEST P) PG-FIELD) CUR-VAL)
         (SETF CUR-LIST (AREF NEST NEST-PTR)))))

(PROCEDURE ALTER-PAGE-SO-FAR ()
  (VAR C (RANGE 0 7))
  (SETF C CUR-CHR)
  (SCAN-OPTIONAL-EQUALS)
  (SCAN-DIMEN FALSE FALSE FALSE)
  (SETF (AREF PAGE-SO-FAR C) CUR-VAL))

(PROCEDURE ALTER-INTEGER ()
  (VAR C (RANGE 0 1))
  (SETF C CUR-CHR)
  (SCAN-OPTIONAL-EQUALS)
  (SCAN-INT)
  (COND ((= C 0) (SETF DEAD-CYCLES CUR-VAL)) (TRUE (SETF INSERT-PENALTIES CUR-VAL))))

(PROCEDURE ALTER-BOX-DIMEN ()
  (VAR C SMALL-NUMBER)
  (VAR B EIGHT-BITS)
  (SETF C CUR-CHR)
  (SCAN-EIGHT-BIT-INT)
  (SETF B CUR-VAL)
  (SCAN-OPTIONAL-EQUALS)
  (SCAN-DIMEN FALSE FALSE FALSE)
  (WHEN (/= (SLOT (SLOT (AREF EQTB (+ 7578 B)) HH) RH) 0)
    (SETF (SLOT (AREF MEM (+ (SLOT (SLOT (AREF EQTB (+ 7578 B)) HH) RH) C)) INT) CUR-VAL)))

(PROCEDURE NEW-FONT ((A SMALL-NUMBER))
  (LABEL $L.50)
  (VAR U HALFWORD)
  (VAR S SCALED)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR T STR-NUMBER)
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR FLUSHABLE-STRING STR-NUMBER)
  (WHEN (= JOB-NAME 0) (OPEN-LOG-FILE))
  (GET-R-TOKEN)
  (SETF U CUR-CS)
  (COND ((>= U 514) (SETF T (SLOT (AREF HASH U) RH)))
        ((>= U 257) (COND ((= U 513) (SETF T 1219)) (TRUE (SETF T (- U 257)))))
        (TRUE
         (SETF OLD-SETTING SELECTOR)
         (SETF SELECTOR 21)
         (PRINT 1219)
         (PRINT (- U 1))
         (SETF SELECTOR OLD-SETTING)
         (WHEN (> (+ POOL-PTR 1) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
         (SETF T MAKE-STRING)))
  (COND ((>= A 4) (GEQ-DEFINE U 87 0)) (TRUE (EQ-DEFINE U 87 0)))
  (SCAN-OPTIONAL-EQUALS)
  (SCAN-FILE-NAME)
  (SETF NAME-IN-PROGRESS TRUE)
  (COND ((SCAN-KEYWORD 1220)
         (SCAN-DIMEN FALSE FALSE FALSE)
         (SETF S CUR-VAL)
         (WHEN (OR (<= S 0) (>= S 134217728))
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 1222)
           (PRINT-SCALED S)
           (PRINT 1223)
           (SETF HELP-PTR 2)
           (SETF (AREF HELP-LINE 1) 1224)
           (SETF (AREF HELP-LINE 0) 1225)
           (ERROR)
           (SETF S (* 10 65536))))
        ((SCAN-KEYWORD 1221)
         (SCAN-INT)
         (SETF S (- CUR-VAL))
         (WHEN (OR (<= CUR-VAL 0) (> CUR-VAL 32768))
           (WHEN (= INTERACTION 3))
           (PRINT-NL 262)
           (PRINT 552)
           (SETF HELP-PTR 1)
           (SETF (AREF HELP-LINE 0) 553)
           (INT-ERROR CUR-VAL)
           (SETF S (- 1000))))
        (TRUE (SETF S (- 1000))))
  (SETF NAME-IN-PROGRESS FALSE)
  (SETF FLUSHABLE-STRING (- STR-PTR 1))
  (FOR (F 1 TO FONT-PTR)
    (WHEN (AND (STR-EQ-STR (AREF FONT-NAME F) CUR-NAME)
               (STR-EQ-STR (AREF FONT-AREA F) CUR-AREA))
      (WHEN (= CUR-NAME FLUSHABLE-STRING)
        (DECF STR-PTR 1)
        (SETF POOL-PTR (AREF STR-START STR-PTR))
        (SETF CUR-NAME (AREF FONT-NAME F)))
      (COND ((> S 0) (WHEN (= S (AREF FONT-SIZE F)) (GOTO $L.50)))
            ((= (AREF FONT-SIZE F) (XN-OVER-D (AREF FONT-DSIZE F) (- S) 1000)) (GOTO $L.50)))))
  (SETF F (READ-FONT-INFO U CUR-NAME CUR-AREA S))
  $L.50
  (SETF (SLOT (SLOT (AREF EQTB U) HH) RH) F)
  (SETF (AREF EQTB (+ 6524 F)) (AREF EQTB U))
  (SETF (SLOT (AREF HASH (+ 6524 F)) RH) T))

(PROCEDURE NEW-INTERACTION ()
  (PRINT-LN)
  (SETF INTERACTION CUR-CHR)
  (COND ((= INTERACTION 0) (SETF SELECTOR 16)) (TRUE (SETF SELECTOR 17)))
  (WHEN LOG-OPENED (INCF SELECTOR 2)))

(PROCEDURE PREFIXED-COMMAND ()
  (LABEL $L.30)
  (LABEL $L.10)
  (VAR A SMALL-NUMBER)
  (VAR F INTERNAL-FONT-NUMBER)
  (VAR J HALFWORD)
  (VAR K FONT-INDEX)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR N INTEGER)
  (VAR E BOOLEAN)
  (SETF A 0)
  (WHILE (= CUR-CMD 93)
    (UNLESS (ODD (DIV A CUR-CHR)) (INCF A CUR-CHR))
    (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
    (WHEN (<= CUR-CMD 70)
      (WHEN (= INTERACTION 3))
      (PRINT-NL 262)
      (PRINT 1179)
      (PRINT-CMD-CHR CUR-CMD CUR-CHR)
      (PRINT-CHAR 39)
      (SETF HELP-PTR 1)
      (SETF (AREF HELP-LINE 0) 1180)
      (BACK-ERROR)
      (GOTO $L.10)))
  (WHEN (AND (/= CUR-CMD 97) (/= (MOD A 4) 0))
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 685)
    (PRINT-ESC 1171)
    (PRINT 1181)
    (PRINT-ESC 1172)
    (PRINT 1182)
    (PRINT-CMD-CHR CUR-CMD CUR-CHR)
    (PRINT-CHAR 39)
    (SETF HELP-PTR 1)
    (SETF (AREF HELP-LINE 0) 1183)
    (ERROR))
  (WHEN (/= (SLOT (AREF EQTB 9206) INT) 0)
    (COND ((< (SLOT (AREF EQTB 9206) INT) 0) (WHEN (>= A 4) (DECF A 4)))
          ((NOT (UNLESS (>= A 4) (INCF A 4))) (INCF A 4))))
  (CASE CUR-CMD
    ((87) (COND ((>= A 4) (GEQ-DEFINE 7834 120 CUR-CHR)) (TRUE (EQ-DEFINE 7834 120 CUR-CHR))))
    ((97)
     (WHEN (AND (AND (ODD CUR-CHR) (NOT (>= A 4))) (>= (SLOT (AREF EQTB 9206) INT) 0))
       (INCF A 4))
     (SETF E (>= CUR-CHR 2)) (GET-R-TOKEN) (SETF P CUR-CS) (SETF Q (SCAN-TOKS TRUE E))
     (COND ((>= A 4) (GEQ-DEFINE P (+ 111 (MOD A 4)) DEF-REF))
           (TRUE (EQ-DEFINE P (+ 111 (MOD A 4)) DEF-REF))))
    ((94) (SETF N CUR-CHR) (GET-R-TOKEN) (SETF P CUR-CS)
     (COND ((= N 0)
            (REPEAT (GET-TOKEN) (UNTIL (/= CUR-CMD 10)))
            (WHEN (= CUR-TOK 3133) (GET-TOKEN) (WHEN (= CUR-CMD 10) (GET-TOKEN))))
           (TRUE
            (GET-TOKEN)
            (SETF Q CUR-TOK)
            (GET-TOKEN)
            (BACK-INPUT)
            (SETF CUR-TOK Q)
            (BACK-INPUT)))
     (WHEN (>= CUR-CMD 111)
       (SETF (SLOT (SLOT (AREF MEM CUR-CHR) HH) LH)
             (+ (SLOT (SLOT (AREF MEM CUR-CHR) HH) LH) 1)))
     (COND ((>= A 4) (GEQ-DEFINE P CUR-CMD CUR-CHR)) (TRUE (EQ-DEFINE P CUR-CMD CUR-CHR))))
    ((95) (SETF N CUR-CHR) (GET-R-TOKEN) (SETF P CUR-CS)
     (COND ((>= A 4) (GEQ-DEFINE P 0 256)) (TRUE (EQ-DEFINE P 0 256))) (SCAN-OPTIONAL-EQUALS)
     (CASE N
       ((0) (SCAN-CHAR-NUM)
        (COND ((>= A 4) (GEQ-DEFINE P 68 CUR-VAL)) (TRUE (EQ-DEFINE P 68 CUR-VAL))))
       ((1) (SCAN-FIFTEEN-BIT-INT)
        (COND ((>= A 4) (GEQ-DEFINE P 69 CUR-VAL)) (TRUE (EQ-DEFINE P 69 CUR-VAL))))
       (ELSE (SCAN-EIGHT-BIT-INT)
        (CASE N
          ((2)
           (COND ((>= A 4) (GEQ-DEFINE P 73 (+ 9218 CUR-VAL)))
                 (TRUE (EQ-DEFINE P 73 (+ 9218 CUR-VAL)))))
          ((3)
           (COND ((>= A 4) (GEQ-DEFINE P 74 (+ 9751 CUR-VAL)))
                 (TRUE (EQ-DEFINE P 74 (+ 9751 CUR-VAL)))))
          ((4)
           (COND ((>= A 4) (GEQ-DEFINE P 75 (+ 6800 CUR-VAL)))
                 (TRUE (EQ-DEFINE P 75 (+ 6800 CUR-VAL)))))
          ((5)
           (COND ((>= A 4) (GEQ-DEFINE P 76 (+ 7056 CUR-VAL)))
                 (TRUE (EQ-DEFINE P 76 (+ 7056 CUR-VAL)))))
          ((6)
           (COND ((>= A 4) (GEQ-DEFINE P 72 (+ 7322 CUR-VAL)))
                 (TRUE (EQ-DEFINE P 72 (+ 7322 CUR-VAL)))))))))
    ((96) (SCAN-INT) (SETF N CUR-VAL)
     (UNLESS (SCAN-KEYWORD 842)
       (WHEN (= INTERACTION 3))
       (PRINT-NL 262)
       (PRINT 1073)
       (SETF HELP-PTR 2)
       (SETF (AREF HELP-LINE 1) 1200)
       (SETF (AREF HELP-LINE 0) 1201)
       (ERROR))
     (GET-R-TOKEN) (SETF P CUR-CS) (READ-TOKS N P)
     (COND ((>= A 4) (GEQ-DEFINE P 111 CUR-VAL)) (TRUE (EQ-DEFINE P 111 CUR-VAL))))
    ((71 72) (SETF Q CUR-CS)
     (COND ((= CUR-CMD 71) (SCAN-EIGHT-BIT-INT) (SETF P (+ 7322 CUR-VAL)))
           (TRUE (SETF P CUR-CHR)))
     (SCAN-OPTIONAL-EQUALS) (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
     (WHEN (/= CUR-CMD 1)
       (WHEN (= CUR-CMD 71)
         (SCAN-EIGHT-BIT-INT)
         (SETF CUR-CMD 72)
         (SETF CUR-CHR (+ 7322 CUR-VAL)))
       (WHEN (= CUR-CMD 72)
         (SETF Q (SLOT (SLOT (AREF EQTB CUR-CHR) HH) RH))
         (COND ((= Q 0) (COND ((>= A 4) (GEQ-DEFINE P 101 0)) (TRUE (EQ-DEFINE P 101 0))))
               (TRUE
                (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (+ (SLOT (SLOT (AREF MEM Q) HH) LH) 1))
                (COND ((>= A 4) (GEQ-DEFINE P 111 Q)) (TRUE (EQ-DEFINE P 111 Q)))))
         (GOTO $L.30)))
     (BACK-INPUT) (SETF CUR-CS Q) (SETF Q (SCAN-TOKS FALSE FALSE))
     (COND ((= (SLOT (SLOT (AREF MEM DEF-REF) HH) RH) 0)
            (COND ((>= A 4) (GEQ-DEFINE P 101 0)) (TRUE (EQ-DEFINE P 101 0)))
            (SETF (SLOT (SLOT (AREF MEM DEF-REF) HH) RH) AVAIL)
            (SETF AVAIL DEF-REF))
           (TRUE
            (WHEN (= P 7313)
              (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) GET-AVAIL)
              (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH))
              (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 637)
              (SETF Q GET-AVAIL)
              (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) 379)
              (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (SLOT (SLOT (AREF MEM DEF-REF) HH) RH))
              (SETF (SLOT (SLOT (AREF MEM DEF-REF) HH) RH) Q))
            (COND ((>= A 4) (GEQ-DEFINE P 111 DEF-REF)) (TRUE (EQ-DEFINE P 111 DEF-REF))))))
    ((73) (SETF P CUR-CHR) (SCAN-OPTIONAL-EQUALS) (SCAN-INT)
     (COND ((>= A 4) (GEQ-WORD-DEFINE P CUR-VAL)) (TRUE (EQ-WORD-DEFINE P CUR-VAL))))
    ((74) (SETF P CUR-CHR) (SCAN-OPTIONAL-EQUALS) (SCAN-DIMEN FALSE FALSE FALSE)
     (COND ((>= A 4) (GEQ-WORD-DEFINE P CUR-VAL)) (TRUE (EQ-WORD-DEFINE P CUR-VAL))))
    ((75 76) (SETF P CUR-CHR) (SETF N CUR-CMD) (SCAN-OPTIONAL-EQUALS)
     (COND ((= N 76) (SCAN-GLUE 3)) (TRUE (SCAN-GLUE 2))) (TRAP-ZERO-GLUE)
     (COND ((>= A 4) (GEQ-DEFINE P 117 CUR-VAL)) (TRUE (EQ-DEFINE P 117 CUR-VAL))))
    ((85)
     (COND ((= CUR-CHR 7883) (SETF N 15))
           ((= CUR-CHR 8907) (SETF N 32768))
           ((= CUR-CHR 8651) (SETF N 32767))
           ((= CUR-CHR 9474) (SETF N 16777215))
           (TRUE (SETF N 255)))
     (SETF P CUR-CHR) (SCAN-CHAR-NUM) (INCF P CUR-VAL) (SCAN-OPTIONAL-EQUALS) (SCAN-INT)
     (WHEN (OR (AND (< CUR-VAL 0) (< P 9474)) (> CUR-VAL N))
       (WHEN (= INTERACTION 3))
       (PRINT-NL 262)
       (PRINT 1202)
       (PRINT-INT CUR-VAL)
       (COND ((< P 9474) (PRINT 1203)) (TRUE (PRINT 1204)))
       (PRINT-INT N)
       (SETF HELP-PTR 1)
       (SETF (AREF HELP-LINE 0) 1205)
       (ERROR)
       (SETF CUR-VAL 0))
     (COND ((< P 8907)
            (COND ((>= A 4) (GEQ-DEFINE P 120 CUR-VAL)) (TRUE (EQ-DEFINE P 120 CUR-VAL))))
           ((< P 9474)
            (COND ((>= A 4) (GEQ-DEFINE P 120 (+ CUR-VAL 0)))
                  (TRUE (EQ-DEFINE P 120 (+ CUR-VAL 0)))))
           ((>= A 4) (GEQ-WORD-DEFINE P CUR-VAL))
           (TRUE (EQ-WORD-DEFINE P CUR-VAL))))
    ((86) (SETF P CUR-CHR) (SCAN-FOUR-BIT-INT) (INCF P CUR-VAL) (SCAN-OPTIONAL-EQUALS)
     (SCAN-FONT-IDENT)
     (COND ((>= A 4) (GEQ-DEFINE P 120 CUR-VAL)) (TRUE (EQ-DEFINE P 120 CUR-VAL))))
    ((89 90 91 92) (DO-REGISTER-COMMAND A))
    ((98) (SCAN-EIGHT-BIT-INT)
     (COND ((>= A 4) (SETF N (+ 256 CUR-VAL))) (TRUE (SETF N CUR-VAL))) (SCAN-OPTIONAL-EQUALS)
     (COND (SET-BOX-ALLOWED (SCAN-BOX (+ 1073741824 N)))
           (TRUE
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 680)
            (PRINT-ESC 536)
            (SETF HELP-PTR 2)
            (SETF (AREF HELP-LINE 1) 1211)
            (SETF (AREF HELP-LINE 0) 1212)
            (ERROR))))
    ((79) (ALTER-AUX))
    ((80) (ALTER-PREV-GRAF))
    ((81) (ALTER-PAGE-SO-FAR))
    ((82) (ALTER-INTEGER))
    ((83) (ALTER-BOX-DIMEN))
    ((84) (SCAN-OPTIONAL-EQUALS) (SCAN-INT) (SETF N CUR-VAL)
     (COND ((<= N 0) (SETF P 0))
           (TRUE
            (SETF P (GET-NODE (+ (* 2 N) 1)))
            (SETF (SLOT (SLOT (AREF MEM P) HH) LH) N)
            (FOR (J 1 TO N)
              (SCAN-DIMEN FALSE FALSE FALSE)
              (SETF (SLOT (AREF MEM (- (+ P (* 2 J)) 1)) INT) CUR-VAL)
              (SCAN-DIMEN FALSE FALSE FALSE)
              (SETF (SLOT (AREF MEM (+ P (* 2 J))) INT) CUR-VAL))))
     (COND ((>= A 4) (GEQ-DEFINE 7312 118 P)) (TRUE (EQ-DEFINE 7312 118 P))))
    ((99)
     (COND ((= CUR-CHR 1)
            (NEW-PATTERNS)
            (GOTO $L.30)
            (WHEN (= INTERACTION 3))
            (PRINT-NL 262)
            (PRINT 1216)
            (SETF HELP-PTR 0)
            (ERROR)
            (REPEAT (GET-TOKEN) (UNTIL (= CUR-CMD 2)))
            (GOTO $L.10))
           (TRUE (NEW-HYPH-EXCEPTIONS) (GOTO $L.30))))
    ((77) (FIND-FONT-DIMEN TRUE) (SETF K CUR-VAL) (SCAN-OPTIONAL-EQUALS)
     (SCAN-DIMEN FALSE FALSE FALSE) (SETF (SLOT (AREF FONT-INFO K) INT) CUR-VAL))
    ((78) (SETF N CUR-CHR) (SCAN-FONT-IDENT) (SETF F CUR-VAL) (SCAN-OPTIONAL-EQUALS) (SCAN-INT)
     (COND ((= N 0) (SETF (AREF HYPHEN-CHAR F) CUR-VAL))
           (TRUE (SETF (AREF SKEW-CHAR F) CUR-VAL))))
    ((88) (NEW-FONT A))
    ((100) (NEW-INTERACTION))
    (ELSE (CONFUSION 1178)))
  $L.30
  (WHEN (/= AFTER-TOKEN 0) (SETF CUR-TOK AFTER-TOKEN) (BACK-INPUT) (SETF AFTER-TOKEN 0))
  $L.10)

(PROCEDURE DO-ASSIGNMENTS ()
  (LABEL $L.10)
  (WHILE TRUE
    (REPEAT (GET-X-TOKEN) (UNTIL (AND (/= CUR-CMD 10) (/= CUR-CMD 0))))
    (WHEN (<= CUR-CMD 70) (GOTO $L.10))
    (SETF SET-BOX-ALLOWED FALSE)
    (PREFIXED-COMMAND)
    (SETF SET-BOX-ALLOWED TRUE))
  $L.10)

(PROCEDURE OPEN-OR-CLOSE-IN ()
  (VAR C (RANGE 0 1))
  (VAR N (RANGE 0 15))
  (SETF C CUR-CHR)
  (SCAN-FOUR-BIT-INT)
  (SETF N CUR-VAL)
  (WHEN (/= (AREF READ-OPEN N) 2) (A-CLOSE (AREF READ-FILE N)) (SETF (AREF READ-OPEN N) 2))
  (WHEN (/= C 0)
    (SCAN-OPTIONAL-EQUALS)
    (SCAN-FILE-NAME)
    (WHEN (= CUR-EXT 338) (SETF CUR-EXT 791))
    (PACK-FILE-NAME CUR-NAME CUR-AREA CUR-EXT)
    (WHEN (A-OPEN-IN (AREF READ-FILE N)) (SETF (AREF READ-OPEN N) 1))))

(PROCEDURE ISSUE-MESSAGE ()
  (VAR OLD-SETTING (RANGE 0 21))
  (VAR C (RANGE 0 1))
  (VAR S STR-NUMBER)
  (SETF C CUR-CHR)
  (SETF (SLOT (SLOT (AREF MEM 59988) HH) RH) (SCAN-TOKS FALSE TRUE))
  (SETF OLD-SETTING SELECTOR)
  (SETF SELECTOR 21)
  (TOKEN-SHOW DEF-REF)
  (SETF SELECTOR OLD-SETTING)
  (FLUSH-LIST DEF-REF)
  (WHEN (> (+ POOL-PTR 1) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
  (SETF S MAKE-STRING)
  (COND ((= C 0)
         (COND ((> (+ TERM-OFFSET (- (AREF STR-START (+ S 1)) (AREF STR-START S)))
                   (- MAX-PRINT-LINE 2))
                (PRINT-LN))
               ((OR (> TERM-OFFSET 0) (> FILE-OFFSET 0)) (PRINT-CHAR 32)))
         (SLOW-PRINT S)
         (BREAK TERM-OUT))
        (TRUE
         (WHEN (= INTERACTION 3))
         (PRINT-NL 262)
         (PRINT 338)
         (SLOW-PRINT S)
         (COND ((/= (SLOT (SLOT (AREF EQTB 7321) HH) RH) 0) (SETF USE-ERR-HELP TRUE))
               (LONG-HELP-SEEN (SETF HELP-PTR 1) (SETF (AREF HELP-LINE 0) 1232))
               (TRUE
                (WHEN (< INTERACTION 3) (SETF LONG-HELP-SEEN TRUE))
                (SETF HELP-PTR 4)
                (SETF (AREF HELP-LINE 3) 1233)
                (SETF (AREF HELP-LINE 2) 1234)
                (SETF (AREF HELP-LINE 1) 1235)
                (SETF (AREF HELP-LINE 0) 1236)))
         (ERROR)
         (SETF USE-ERR-HELP FALSE)))
  (DECF STR-PTR 1)
  (SETF POOL-PTR (AREF STR-START STR-PTR)))

(PROCEDURE SHIFT-CASE ()
  (VAR B HALFWORD)
  (VAR P HALFWORD)
  (VAR T HALFWORD)
  (VAR C EIGHT-BITS)
  (SETF B CUR-CHR)
  (SETF P (SCAN-TOKS FALSE FALSE))
  (SETF P (SLOT (SLOT (AREF MEM DEF-REF) HH) RH))
  (WHILE (/= P 0)
    (SETF T (SLOT (SLOT (AREF MEM P) HH) LH))
    (WHEN (< T 4352)
      (SETF C (MOD T 256))
      (WHEN (/= (SLOT (SLOT (AREF EQTB (+ B C)) HH) RH) 0)
        (SETF (SLOT (SLOT (AREF MEM P) HH) LH)
              (+ (- T C) (SLOT (SLOT (AREF EQTB (+ B C)) HH) RH)))))
    (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF MEM DEF-REF) HH) RH) 3)
  (SETF (SLOT (SLOT (AREF MEM DEF-REF) HH) RH) AVAIL)
  (SETF AVAIL DEF-REF))

(PROCEDURE SHOW-WHATEVER ()
  (LABEL $L.50)
  (VAR P HALFWORD)
  (CASE CUR-CHR
    ((3) (BEGIN-DIAGNOSTIC) (SHOW-ACTIVITIES))
    ((1) (SCAN-EIGHT-BIT-INT) (BEGIN-DIAGNOSTIC) (PRINT-NL 1254) (PRINT-INT CUR-VAL)
     (PRINT-CHAR 61)
     (COND ((= (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH) 0) (PRINT 410))
           (TRUE (SHOW-BOX (SLOT (SLOT (AREF EQTB (+ 7578 CUR-VAL)) HH) RH)))))
    ((0) (GET-TOKEN) (WHEN (= INTERACTION 3)) (PRINT-NL 1248)
     (WHEN (/= CUR-CS 0) (SPRINT-CS CUR-CS) (PRINT-CHAR 61)) (PRINT-MEANING) (GOTO $L.50))
    (ELSE (SETF P THE-TOKS) (WHEN (= INTERACTION 3)) (PRINT-NL 1248) (TOKEN-SHOW 59997)
     (FLUSH-LIST (SLOT (SLOT (AREF MEM 59997) HH) RH)) (GOTO $L.50)))
  (END-DIAGNOSTIC TRUE)
  (WHEN (= INTERACTION 3))
  (PRINT-NL 262)
  (PRINT 1255)
  (WHEN (= SELECTOR 19)
    (WHEN (<= (SLOT (AREF EQTB 9192) INT) 0)
      (SETF SELECTOR 17)
      (PRINT 1256)
      (SETF SELECTOR 19)))
  $L.50
  (COND ((< INTERACTION 3) (SETF HELP-PTR 0) (DECF ERROR-COUNT 1))
        ((> (SLOT (AREF EQTB 9192) INT) 0)
         (SETF HELP-PTR 3)
         (SETF (AREF HELP-LINE 2) 1243)
         (SETF (AREF HELP-LINE 1) 1244)
         (SETF (AREF HELP-LINE 0) 1245))
        (TRUE
         (SETF HELP-PTR 5)
         (SETF (AREF HELP-LINE 4) 1243)
         (SETF (AREF HELP-LINE 3) 1244)
         (SETF (AREF HELP-LINE 2) 1245)
         (SETF (AREF HELP-LINE 1) 1246)
         (SETF (AREF HELP-LINE 0) 1247)))
  (ERROR))

(PROCEDURE STORE-FMT-FILE ()
  (LABEL $L.41)
  (LABEL $L.42)
  (LABEL $L.31)
  (LABEL $L.32)
  (VAR J INTEGER)
  (VAR K INTEGER)
  (VAR L INTEGER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR X INTEGER)
  (VAR W FOUR-QUARTERS)
  (WHEN (/= SAVE-PTR 0)
    (WHEN (= INTERACTION 3))
    (PRINT-NL 262)
    (PRINT 1258)
    (SETF HELP-PTR 1)
    (SETF (AREF HELP-LINE 0) 1259)
    (WHEN (= INTERACTION 3) (SETF INTERACTION 2))
    (WHEN LOG-OPENED (ERROR))
    (SETF HISTORY 3)
    (JUMP-OUT))
  (SETF SELECTOR 21)
  (PRINT 1272)
  (PRINT JOB-NAME)
  (PRINT-CHAR 32)
  (PRINT-INT (SLOT (AREF EQTB 9186) INT))
  (PRINT-CHAR 46)
  (PRINT-INT (SLOT (AREF EQTB 9185) INT))
  (PRINT-CHAR 46)
  (PRINT-INT (SLOT (AREF EQTB 9184) INT))
  (PRINT-CHAR 41)
  (COND ((= INTERACTION 0) (SETF SELECTOR 18)) (TRUE (SETF SELECTOR 19)))
  (WHEN (> (+ POOL-PTR 1) POOL-SIZE) (OVERFLOW 257 (- POOL-SIZE INIT-POOL-PTR)))
  (SETF FORMAT-IDENT MAKE-STRING)
  (PACK-JOB-NAME 786)
  (WHILE (NOT (W-OPEN-OUT FMT-FILE)) (PROMPT-FILE-NAME 1273 786))
  (PRINT-NL 1274)
  (SLOW-PRINT (W-MAKE-NAME-STRING FMT-FILE))
  (DECF STR-PTR 1)
  (SETF POOL-PTR (AREF STR-START STR-PTR))
  (PRINT-NL 338)
  (SLOW-PRINT FORMAT-IDENT)
  (SETF (SLOT (AREF FMT-FILE) INT) 504454778)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) 0)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) 60000)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) 10006)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) 1777)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) 307)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) POOL-PTR)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) STR-PTR)
  (PUT FMT-FILE)
  (FOR (K 0 TO STR-PTR) (SETF (SLOT (AREF FMT-FILE) INT) (AREF STR-START K)) (PUT FMT-FILE))
  (SETF K 0)
  (WHILE (< (+ K 4) POOL-PTR)
    (SETF (SLOT W B0) (+ (AREF STR-POOL K) 0))
    (SETF (SLOT W B1) (+ (AREF STR-POOL (+ K 1)) 0))
    (SETF (SLOT W B2) (+ (AREF STR-POOL (+ K 2)) 0))
    (SETF (SLOT W B3) (+ (AREF STR-POOL (+ K 3)) 0))
    (SETF (SLOT (AREF FMT-FILE) QQQQ) W)
    (PUT FMT-FILE)
    (INCF K 4))
  (SETF K (- POOL-PTR 4))
  (SETF (SLOT W B0) (+ (AREF STR-POOL K) 0))
  (SETF (SLOT W B1) (+ (AREF STR-POOL (+ K 1)) 0))
  (SETF (SLOT W B2) (+ (AREF STR-POOL (+ K 2)) 0))
  (SETF (SLOT W B3) (+ (AREF STR-POOL (+ K 3)) 0))
  (SETF (SLOT (AREF FMT-FILE) QQQQ) W)
  (PUT FMT-FILE)
  (PRINT-LN)
  (PRINT-INT STR-PTR)
  (PRINT 1260)
  (PRINT-INT POOL-PTR)
  (SORT-AVAIL)
  (SETF VAR-USED 0)
  (SETF (SLOT (AREF FMT-FILE) INT) LO-MEM-MAX)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) ROVER)
  (PUT FMT-FILE)
  (SETF P 0)
  (SETF Q ROVER)
  (SETF X 0)
  (REPEAT (FOR (K P TO (+ Q 1)) (SETF (AREF FMT-FILE) (AREF MEM K)) (PUT FMT-FILE))
          (SETF X (- (+ (+ X Q) 2) P))
          (SETF VAR-USED (- (+ VAR-USED Q) P))
          (SETF P (+ Q (SLOT (SLOT (AREF MEM Q) HH) LH)))
          (SETF Q (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
          (UNTIL (= Q ROVER)))
  (SETF VAR-USED (- (+ VAR-USED LO-MEM-MAX) P))
  (SETF DYN-USED (- (+ MEM-END 1) HI-MEM-MIN))
  (FOR (K P TO LO-MEM-MAX) (SETF (AREF FMT-FILE) (AREF MEM K)) (PUT FMT-FILE))
  (SETF X (- (+ (+ X LO-MEM-MAX) 1) P))
  (SETF (SLOT (AREF FMT-FILE) INT) HI-MEM-MIN)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) AVAIL)
  (PUT FMT-FILE)
  (FOR (K HI-MEM-MIN TO MEM-END) (SETF (AREF FMT-FILE) (AREF MEM K)) (PUT FMT-FILE))
  (SETF X (- (+ (+ X MEM-END) 1) HI-MEM-MIN))
  (SETF P AVAIL)
  (WHILE (/= P 0) (DECF DYN-USED 1) (SETF P (SLOT (SLOT (AREF MEM P) HH) RH)))
  (SETF (SLOT (AREF FMT-FILE) INT) VAR-USED)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) DYN-USED)
  (PUT FMT-FILE)
  (PRINT-LN)
  (PRINT-INT X)
  (PRINT 1261)
  (PRINT-INT VAR-USED)
  (PRINT-CHAR 38)
  (PRINT-INT DYN-USED)
  (SETF K 1)
  (REPEAT (SETF J K)
          (WHILE (< J 9162)
            (WHEN (AND (AND (= (SLOT (SLOT (AREF EQTB J) HH) RH)
                               (SLOT (SLOT (AREF EQTB (+ J 1)) HH) RH))
                            (= (SLOT (SLOT (AREF EQTB J) HH) B0)
                               (SLOT (SLOT (AREF EQTB (+ J 1)) HH) B0)))
                       (= (SLOT (SLOT (AREF EQTB J) HH) B1)
                          (SLOT (SLOT (AREF EQTB (+ J 1)) HH) B1)))
              (GOTO $L.41))
            (INCF J 1))
          (SETF L 9163)
          (GOTO $L.31)
          $L.41
          (INCF J 1)
          (SETF L J)
          (WHILE (< J 9162)
            (WHEN (OR (OR (/= (SLOT (SLOT (AREF EQTB J) HH) RH)
                              (SLOT (SLOT (AREF EQTB (+ J 1)) HH) RH))
                          (/= (SLOT (SLOT (AREF EQTB J) HH) B0)
                              (SLOT (SLOT (AREF EQTB (+ J 1)) HH) B0)))
                      (/= (SLOT (SLOT (AREF EQTB J) HH) B1)
                          (SLOT (SLOT (AREF EQTB (+ J 1)) HH) B1)))
              (GOTO $L.31))
            (INCF J 1))
          $L.31
          (SETF (SLOT (AREF FMT-FILE) INT) (- L K))
          (PUT FMT-FILE)
          (WHILE (< K L) (SETF (AREF FMT-FILE) (AREF EQTB K)) (PUT FMT-FILE) (INCF K 1))
          (SETF K (+ J 1))
          (SETF (SLOT (AREF FMT-FILE) INT) (- K L))
          (PUT FMT-FILE)
          (UNTIL (= K 9163)))
  (REPEAT (SETF J K)
          (WHILE (< J 10006)
            (WHEN (= (SLOT (AREF EQTB J) INT) (SLOT (AREF EQTB (+ J 1)) INT)) (GOTO $L.42))
            (INCF J 1))
          (SETF L 10007)
          (GOTO $L.32)
          $L.42
          (INCF J 1)
          (SETF L J)
          (WHILE (< J 10006)
            (WHEN (/= (SLOT (AREF EQTB J) INT) (SLOT (AREF EQTB (+ J 1)) INT)) (GOTO $L.32))
            (INCF J 1))
          $L.32
          (SETF (SLOT (AREF FMT-FILE) INT) (- L K))
          (PUT FMT-FILE)
          (WHILE (< K L) (SETF (AREF FMT-FILE) (AREF EQTB K)) (PUT FMT-FILE) (INCF K 1))
          (SETF K (+ J 1))
          (SETF (SLOT (AREF FMT-FILE) INT) (- K L))
          (PUT FMT-FILE)
          (UNTIL (> K 10006)))
  (SETF (SLOT (AREF FMT-FILE) INT) PAR-LOC)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) WRITE-LOC)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) HASH-USED)
  (PUT FMT-FILE)
  (SETF CS-COUNT (- 6513 HASH-USED))
  (FOR (P 514 TO HASH-USED)
    (WHEN (/= (SLOT (AREF HASH P) RH) 0)
      (SETF (SLOT (AREF FMT-FILE) INT) P)
      (PUT FMT-FILE)
      (SETF (SLOT (AREF FMT-FILE) HH) (AREF HASH P))
      (PUT FMT-FILE)
      (INCF CS-COUNT 1)))
  (FOR (P (+ HASH-USED 1) TO 6780)
    (SETF (SLOT (AREF FMT-FILE) HH) (AREF HASH P))
    (PUT FMT-FILE))
  (SETF (SLOT (AREF FMT-FILE) INT) CS-COUNT)
  (PUT FMT-FILE)
  (PRINT-LN)
  (PRINT-INT CS-COUNT)
  (PRINT 1262)
  (SETF (SLOT (AREF FMT-FILE) INT) FMEM-PTR)
  (PUT FMT-FILE)
  (FOR (K 0 TO (- FMEM-PTR 1)) (SETF (AREF FMT-FILE) (AREF FONT-INFO K)) (PUT FMT-FILE))
  (SETF (SLOT (AREF FMT-FILE) INT) FONT-PTR)
  (PUT FMT-FILE)
  (FOR (K 0 TO FONT-PTR)
    (SETF (SLOT (AREF FMT-FILE) QQQQ) (AREF FONT-CHECK K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-SIZE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-DSIZE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-PARAMS K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF HYPHEN-CHAR K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF SKEW-CHAR K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-NAME K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-AREA K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-BC K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-EC K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF CHAR-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF WIDTH-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF HEIGHT-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF DEPTH-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF ITALIC-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF LIG-KERN-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF KERN-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF EXTEN-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF PARAM-BASE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-GLUE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF BCHAR-LABEL K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-BCHAR K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF FONT-FALSE-BCHAR K))
    (PUT FMT-FILE)
    (PRINT-NL 1265)
    (PRINT-ESC (SLOT (AREF HASH (+ 6524 K)) RH))
    (PRINT-CHAR 61)
    (PRINT-FILE-NAME (AREF FONT-NAME K) (AREF FONT-AREA K) 338)
    (WHEN (/= (AREF FONT-SIZE K) (AREF FONT-DSIZE K))
      (PRINT 741)
      (PRINT-SCALED (AREF FONT-SIZE K))
      (PRINT 397)))
  (PRINT-LN)
  (PRINT-INT (- FMEM-PTR 7))
  (PRINT 1263)
  (PRINT-INT (- FONT-PTR 0))
  (PRINT 1264)
  (WHEN (/= FONT-PTR 1) (PRINT-CHAR 115))
  (SETF (SLOT (AREF FMT-FILE) INT) HYPH-COUNT)
  (PUT FMT-FILE)
  (FOR (K 0 TO 307)
    (WHEN (/= (AREF HYPH-WORD K) 0)
      (SETF (SLOT (AREF FMT-FILE) INT) K)
      (PUT FMT-FILE)
      (SETF (SLOT (AREF FMT-FILE) INT) (AREF HYPH-WORD K))
      (PUT FMT-FILE)
      (SETF (SLOT (AREF FMT-FILE) INT) (AREF HYPH-LIST K))
      (PUT FMT-FILE)))
  (PRINT-LN)
  (PRINT-INT HYPH-COUNT)
  (PRINT 1266)
  (WHEN (/= HYPH-COUNT 1) (PRINT-CHAR 115))
  (WHEN TRIE-NOT-READY (INIT-TRIE))
  (SETF (SLOT (AREF FMT-FILE) INT) TRIE-MAX)
  (PUT FMT-FILE)
  (FOR (K 0 TO TRIE-MAX) (SETF (SLOT (AREF FMT-FILE) HH) (AREF TRIE K)) (PUT FMT-FILE))
  (SETF (SLOT (AREF FMT-FILE) INT) TRIE-OP-PTR)
  (PUT FMT-FILE)
  (FOR (K 1 TO TRIE-OP-PTR)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF HYF-DISTANCE K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF HYF-NUM K))
    (PUT FMT-FILE)
    (SETF (SLOT (AREF FMT-FILE) INT) (AREF HYF-NEXT K))
    (PUT FMT-FILE))
  (PRINT-NL 1267)
  (PRINT-INT TRIE-MAX)
  (PRINT 1268)
  (PRINT-INT TRIE-OP-PTR)
  (PRINT 1269)
  (WHEN (/= TRIE-OP-PTR 1) (PRINT-CHAR 115))
  (PRINT 1270)
  (PRINT-INT TRIE-OP-SIZE)
  (FOR (K 255 DOWNTO 0)
    (WHEN (> (AREF TRIE-USED K) 0)
      (PRINT-NL 800)
      (PRINT-INT (- (AREF TRIE-USED K) 0))
      (PRINT 1271)
      (PRINT-INT K)
      (SETF (SLOT (AREF FMT-FILE) INT) K)
      (PUT FMT-FILE)
      (SETF (SLOT (AREF FMT-FILE) INT) (- (AREF TRIE-USED K) 0))
      (PUT FMT-FILE)))
  (SETF (SLOT (AREF FMT-FILE) INT) INTERACTION)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) FORMAT-IDENT)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF FMT-FILE) INT) 69069)
  (PUT FMT-FILE)
  (SETF (SLOT (AREF EQTB 9194) INT) 0)
  (W-CLOSE FMT-FILE))

(PROCEDURE NEW-WHATSIT ((S SMALL-NUMBER) (W SMALL-NUMBER))
  (VAR P HALFWORD)
  (SETF P (GET-NODE W))
  (SETF (SLOT (SLOT (AREF MEM P) HH) B0) 8)
  (SETF (SLOT (SLOT (AREF MEM P) HH) B1) S)
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) P)
  (SETF (SLOT CUR-LIST TAIL-FIELD) P))

(PROCEDURE NEW-WRITE-WHATSIT ((W SMALL-NUMBER))
  (NEW-WHATSIT CUR-CHR W)
  (COND ((/= W 2) (SCAN-FOUR-BIT-INT))
        (TRUE
         (SCAN-INT)
         (COND ((< CUR-VAL 0) (SETF CUR-VAL 17)) ((> CUR-VAL 15) (SETF CUR-VAL 16)))))
  (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH) CUR-VAL))

(PROCEDURE DO-EXTENSION ()
  (VAR I INTEGER)
  (VAR J INTEGER)
  (VAR K INTEGER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR R HALFWORD)
  (CASE CUR-CHR
    ((0) (NEW-WRITE-WHATSIT 3) (SCAN-OPTIONAL-EQUALS) (SCAN-FILE-NAME)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) CUR-NAME)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) HH) LH) CUR-AREA)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) HH) RH) CUR-EXT))
    ((1) (SETF K CUR-CS) (NEW-WRITE-WHATSIT 2) (SETF CUR-CS K) (SETF P (SCAN-TOKS FALSE FALSE))
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) DEF-REF))
    ((2) (NEW-WRITE-WHATSIT 2)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) 0))
    ((3) (NEW-WHATSIT 3 2)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH) 0)
     (SETF P (SCAN-TOKS FALSE TRUE))
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) DEF-REF))
    ((4) (GET-X-TOKEN)
     (COND ((AND (= CUR-CMD 59) (<= CUR-CHR 2))
            (SETF P (SLOT CUR-LIST TAIL-FIELD))
            (DO-EXTENSION)
            (OUT-WHAT (SLOT CUR-LIST TAIL-FIELD))
            (FLUSH-NODE-LIST (SLOT CUR-LIST TAIL-FIELD))
            (SETF (SLOT CUR-LIST TAIL-FIELD) P)
            (SETF (SLOT (SLOT (AREF MEM P) HH) RH) 0))
           (TRUE (BACK-INPUT))))
    ((5)
     (COND ((/= (ABS (SLOT CUR-LIST MODE-FIELD)) 102) (REPORT-ILLEGAL-CASE))
           (TRUE
            (NEW-WHATSIT 4 2)
            (SCAN-INT)
            (COND ((<= CUR-VAL 0) (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH) 0))
                  ((> CUR-VAL 255) (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH) 0))
                  (TRUE (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH) CUR-VAL)))
            (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH)
                  (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH))
            (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) B0)
                  (NORM-MIN (SLOT (AREF EQTB 9214) INT)))
            (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) B1)
                  (NORM-MIN (SLOT (AREF EQTB 9215) INT))))))
    (ELSE (CONFUSION 1291))))

(PROCEDURE FIX-LANGUAGE ()
  (VAR L ASCII-CODE)
  (COND ((<= (SLOT (AREF EQTB 9213) INT) 0) (SETF L 0))
        ((> (SLOT (AREF EQTB 9213) INT) 255) (SETF L 0))
        (TRUE (SETF L (SLOT (AREF EQTB 9213) INT))))
  (WHEN (/= L (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH))
    (NEW-WHATSIT 4 2)
    (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) L)
    (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH) L)
    (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) B0)
          (NORM-MIN (SLOT (AREF EQTB 9214) INT)))
    (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) B1)
          (NORM-MIN (SLOT (AREF EQTB 9215) INT)))))

(PROCEDURE HANDLE-RIGHT-BRACE ()
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR D SCALED)
  (VAR F INTEGER)
  (CASE CUR-GROUP
    ((1) (UNSAVE))
    ((0) (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 1044) (SETF HELP-PTR 2)
     (SETF (AREF HELP-LINE 1) 1045) (SETF (AREF HELP-LINE 0) 1046) (ERROR))
    ((14 15 16) (EXTRA-RIGHT-BRACE))
    ((2) (PACKAGE 0))
    ((3) (SETF ADJUST-TAIL 59995) (PACKAGE 0))
    ((4) (END-GRAF) (PACKAGE 0))
    ((5) (END-GRAF) (PACKAGE 4))
    ((11) (END-GRAF) (SETF Q (SLOT (SLOT (AREF EQTB 6792) HH) RH))
     (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) (+ (SLOT (SLOT (AREF MEM Q) HH) RH) 1))
     (SETF D (SLOT (AREF EQTB 9736) INT)) (SETF F (SLOT (AREF EQTB 9205) INT)) (UNSAVE)
     (DECF SAVE-PTR 1)
     (SETF P
           (VPACKAGE (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH) 0 1 1073741823))
     (POP-NEST)
     (COND ((< (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) 255)
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (GET-NODE 5))
            (SETF (SLOT CUR-LIST TAIL-FIELD)
                  (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 3)
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1)
                  (+ (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT) 0))
            (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 3)) INT)
                  (+ (SLOT (AREF MEM (+ P 3)) INT) (SLOT (AREF MEM (+ P 2)) INT)))
            (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 4)) HH) LH)
                  (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH))
            (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 4)) HH) RH) Q)
            (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 2)) INT) D)
            (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT) F))
           (TRUE
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (GET-NODE 2))
            (SETF (SLOT CUR-LIST TAIL-FIELD)
                  (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 5)
            (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 0)
            (SETF (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) INT)
                  (SLOT (SLOT (AREF MEM (+ P 5)) HH) RH))
            (DELETE-GLUE-REF Q)))
     (FREE-NODE P 7) (WHEN (= NEST-PTR 0) (BUILD-PAGE)))
    ((8)
     (WHEN (OR (/= (SLOT CUR-INPUT LOC-FIELD) 0)
               (AND (/= (SLOT CUR-INPUT INDEX-FIELD) 6) (/= (SLOT CUR-INPUT INDEX-FIELD) 3)))
       (WHEN (= INTERACTION 3))
       (PRINT-NL 262)
       (PRINT 1010)
       (SETF HELP-PTR 2)
       (SETF (AREF HELP-LINE 1) 1011)
       (SETF (AREF HELP-LINE 0) 1012)
       (ERROR)
       (REPEAT (GET-TOKEN) (UNTIL (= (SLOT CUR-INPUT LOC-FIELD) 0))))
     (END-TOKEN-LIST) (END-GRAF) (UNSAVE) (SETF OUTPUT-ACTIVE FALSE) (SETF INSERT-PENALTIES 0)
     (WHEN (/= (SLOT (SLOT (AREF EQTB 7833) HH) RH) 0)
       (WHEN (= INTERACTION 3))
       (PRINT-NL 262)
       (PRINT 1013)
       (PRINT-ESC 409)
       (PRINT-INT 255)
       (SETF HELP-PTR 3)
       (SETF (AREF HELP-LINE 2) 1014)
       (SETF (AREF HELP-LINE 1) 1015)
       (SETF (AREF HELP-LINE 0) 1016)
       (BOX-ERROR 255))
     (WHEN (/= (SLOT CUR-LIST TAIL-FIELD) (SLOT CUR-LIST HEAD-FIELD))
       (SETF (SLOT (SLOT (AREF MEM PAGE-TAIL) HH) RH)
             (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH))
       (SETF PAGE-TAIL (SLOT CUR-LIST TAIL-FIELD)))
     (WHEN (/= (SLOT (SLOT (AREF MEM 59998) HH) RH) 0)
       (WHEN (= (SLOT (SLOT (AREF MEM 59999) HH) RH) 0)
         (SETF (SLOT (AREF NEST 0) TAIL-FIELD) PAGE-TAIL))
       (SETF (SLOT (SLOT (AREF MEM PAGE-TAIL) HH) RH) (SLOT (SLOT (AREF MEM 59999) HH) RH))
       (SETF (SLOT (SLOT (AREF MEM 59999) HH) RH) (SLOT (SLOT (AREF MEM 59998) HH) RH))
       (SETF (SLOT (SLOT (AREF MEM 59998) HH) RH) 0)
       (SETF PAGE-TAIL 59998))
     (POP-NEST) (BUILD-PAGE))
    ((10) (BUILD-DISCRETIONARY))
    ((6) (BACK-INPUT) (SETF CUR-TOK 10610) (WHEN (= INTERACTION 3)) (PRINT-NL 262) (PRINT 625)
     (PRINT-ESC 899) (PRINT 626) (SETF HELP-PTR 1) (SETF (AREF HELP-LINE 0) 1125) (INS-ERROR))
    ((7) (END-GRAF) (UNSAVE) (ALIGN-PEEK))
    ((12) (END-GRAF) (UNSAVE) (DECF SAVE-PTR 2)
     (SETF P
           (VPACKAGE (SLOT (SLOT (AREF MEM (SLOT CUR-LIST HEAD-FIELD)) HH) RH)
                     (SLOT (AREF SAVE-STACK (+ SAVE-PTR 1)) INT)
                     (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)
                     1073741823))
     (POP-NEST) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-NOAD)
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
     (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 29)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) RH) 2)
     (SETF (SLOT (SLOT (AREF MEM (+ (SLOT CUR-LIST TAIL-FIELD) 1)) HH) LH) P))
    ((13) (BUILD-CHOICES))
    ((9) (UNSAVE) (DECF SAVE-PTR 1)
     (SETF (SLOT (SLOT (AREF MEM (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)) HH) RH) 3)
     (SETF P (FIN-MLIST 0))
     (SETF (SLOT (SLOT (AREF MEM (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)) HH) LH) P)
     (WHEN (/= P 0)
       (WHEN (= (SLOT (SLOT (AREF MEM P) HH) RH) 0)
         (COND ((= (SLOT (SLOT (AREF MEM P) HH) B0) 16)
                (WHEN (= (SLOT (SLOT (AREF MEM (+ P 3)) HH) RH) 0)
                  (WHEN (= (SLOT (SLOT (AREF MEM (+ P 2)) HH) RH) 0)
                    (SETF (SLOT (AREF MEM (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)) HH)
                          (SLOT (AREF MEM (+ P 1)) HH))
                    (FREE-NODE P 4))))
               ((= (SLOT (SLOT (AREF MEM P) HH) B0) 28)
                (WHEN (= (SLOT (AREF SAVE-STACK (+ SAVE-PTR 0)) INT)
                         (+ (SLOT CUR-LIST TAIL-FIELD) 1))
                  (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) 16)
                    (SETF Q (SLOT CUR-LIST HEAD-FIELD))
                    (WHILE (/= (SLOT (SLOT (AREF MEM Q) HH) RH) (SLOT CUR-LIST TAIL-FIELD))
                      (SETF Q (SLOT (SLOT (AREF MEM Q) HH) RH)))
                    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) P)
                    (FREE-NODE (SLOT CUR-LIST TAIL-FIELD) 4)
                    (SETF (SLOT CUR-LIST TAIL-FIELD) P))))))))
    (ELSE (CONFUSION 1047))))

(PROCEDURE MAIN-CONTROL ()
  (LABEL $L.60)
  (LABEL $L.21)
  (LABEL $L.70)
  (LABEL $L.80)
  (LABEL $L.90)
  (LABEL $L.91)
  (LABEL $L.92)
  (LABEL $L.95)
  (LABEL $L.100)
  (LABEL $L.101)
  (LABEL $L.110)
  (LABEL $L.111)
  (LABEL $L.112)
  (LABEL $L.120)
  (LABEL $L.10)
  (VAR T INTEGER)
  (WHEN (/= (SLOT (SLOT (AREF EQTB 7319) HH) RH) 0)
    (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7319) HH) RH) 12))
  $L.60
  (GET-X-TOKEN)
  $L.21
  (WHEN (/= INTERRUPT 0)
    (WHEN OK-TO-INTERRUPT
      (BACK-INPUT)
      (WHEN (/= INTERRUPT 0) (PAUSE-FOR-INSTRUCTIONS))
      (GOTO $L.60)))
  (WHEN (> (SLOT (AREF EQTB 9199) INT) 0) (SHOW-CUR-CMD-CHR))
  (CASE (+ (ABS (SLOT CUR-LIST MODE-FIELD)) CUR-CMD)
    ((113 114 170) (GOTO $L.70))
    ((118) (SCAN-CHAR-NUM) (SETF CUR-CHR CUR-VAL) (GOTO $L.70))
    ((167) (GET-X-TOKEN)
     (WHEN (OR (OR (OR (= CUR-CMD 11) (= CUR-CMD 12)) (= CUR-CMD 68)) (= CUR-CMD 16))
       (SETF CANCEL-BOUNDARY TRUE))
     (GOTO $L.21))
    ((112)
     (COND ((= (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000) (GOTO $L.120))
           (TRUE (APP-SPACE))))
    ((166 267) (GOTO $L.120))
    ((1 102 203 11 213 268))
    ((40 141 242) (REPEAT (GET-X-TOKEN) (UNTIL (/= CUR-CMD 10))) (GOTO $L.21))
    ((15) (WHEN ITS-ALL-OVER (GOTO $L.10)))
    ((23 123 224 71 172 273 39 45 49 150 7 108 209) (REPORT-ILLEGAL-CASE))
    ((8 109 9 110 18 119 70 171 51 152 16 117 50 151 53 154 67 168 54 155 55 156 57 158 56 157
      31 132 52 153 29 130 47 148 212 216 217 230 227 236 239)
     (INSERT-DOLLAR-SIGN))
    ((37 137 238)
     (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) SCAN-RULE-SPEC)
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
     (COND ((= (ABS (SLOT CUR-LIST MODE-FIELD)) 1)
            (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000)))
           ((= (ABS (SLOT CUR-LIST MODE-FIELD)) 102)
            (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))))
    ((28 128 229 231) (APPEND-GLUE))
    ((30 131 232 233) (APPEND-KERN))
    ((2 103) (NEW-SAVE-LEVEL 1))
    ((62 163 264) (NEW-SAVE-LEVEL 14))
    ((63 164 265) (COND ((= CUR-GROUP 14) (UNSAVE)) (TRUE (OFF-SAVE))))
    ((3 104 205) (HANDLE-RIGHT-BRACE))
    ((22 124 225) (SETF T CUR-CHR) (SCAN-DIMEN FALSE FALSE FALSE)
     (COND ((= T 0) (SCAN-BOX CUR-VAL)) (TRUE (SCAN-BOX (- CUR-VAL)))))
    ((32 133 234) (SCAN-BOX (+ 1073742237 CUR-CHR)))
    ((21 122 223) (BEGIN-BOX 0))
    ((44) (NEW-GRAF (> CUR-CHR 0)))
    ((12 13 17 69 4 24 36 46 48 27 34 65 66) (BACK-INPUT) (NEW-GRAF TRUE))
    ((145 246) (INDENT-IN-HMODE))
    ((14) (NORMAL-PARAGRAPH) (WHEN (> (SLOT CUR-LIST MODE-FIELD) 0) (BUILD-PAGE)))
    ((115) (WHEN (< ALIGN-STATE 0) (OFF-SAVE)) (END-GRAF)
     (WHEN (= (SLOT CUR-LIST MODE-FIELD) 1) (BUILD-PAGE)))
    ((116 129 138 126 134) (HEAD-FOR-VMODE))
    ((38 139 240 140 241) (BEGIN-INSERT-OR-ADJUST))
    ((19 120 221) (MAKE-MARK))
    ((43 144 245) (APPEND-PENALTY))
    ((26 127 228) (DELETE-LAST))
    ((25 125 226) (UNPACKAGE))
    ((146) (APPEND-ITALIC-CORRECTION))
    ((247) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-KERN 0))
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
    ((149 250) (APPEND-DISCRETIONARY))
    ((147) (MAKE-ACCENT))
    ((6 107 208 5 106 207) (ALIGN-ERROR))
    ((35 136 237) (NO-ALIGN-ERROR))
    ((64 165 266) (OMIT-ERROR))
    ((33 135) (INIT-ALIGN))
    ((235) (WHEN PRIVILEGED (COND ((= CUR-GROUP 15) (INIT-ALIGN)) (TRUE (OFF-SAVE)))))
    ((10 111) (DO-ENDV))
    ((68 169 270) (CS-ERROR))
    ((105) (INIT-MATH))
    ((251) (WHEN PRIVILEGED (COND ((= CUR-GROUP 15) (START-EQ-NO)) (TRUE (OFF-SAVE)))))
    ((204) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-NOAD)
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
     (BACK-INPUT) (SCAN-MATH (+ (SLOT CUR-LIST TAIL-FIELD) 1)))
    ((214 215 271) (SET-MATH-CHAR (- (SLOT (SLOT (AREF EQTB (+ 8907 CUR-CHR)) HH) RH) 0)))
    ((219) (SCAN-CHAR-NUM) (SETF CUR-CHR CUR-VAL)
     (SET-MATH-CHAR (- (SLOT (SLOT (AREF EQTB (+ 8907 CUR-CHR)) HH) RH) 0)))
    ((220) (SCAN-FIFTEEN-BIT-INT) (SET-MATH-CHAR CUR-VAL))
    ((272) (SET-MATH-CHAR CUR-CHR))
    ((218) (SCAN-TWENTY-SEVEN-BIT-INT) (SET-MATH-CHAR (DIV CUR-VAL 4096)))
    ((253) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-NOAD)
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
     (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B0) CUR-CHR)
     (SCAN-MATH (+ (SLOT CUR-LIST TAIL-FIELD) 1)))
    ((254) (MATH-LIMIT-SWITCH))
    ((269) (MATH-RADICAL))
    ((248 249) (MATH-AC))
    ((259) (SCAN-SPEC 12 FALSE) (NORMAL-PARAGRAPH) (PUSH-NEST)
     (SETF (SLOT CUR-LIST MODE-FIELD) (- 1))
     (SETF (SLOT (SLOT CUR-LIST AUX-FIELD) INT) (- 65536000))
     (WHEN (/= (SLOT (SLOT (AREF EQTB 7318) HH) RH) 0)
       (BEGIN-TOKEN-LIST (SLOT (SLOT (AREF EQTB 7318) HH) RH) 11)))
    ((256) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-STYLE CUR-CHR))
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
    ((258) (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) (NEW-GLUE 0))
     (SETF (SLOT CUR-LIST TAIL-FIELD)
           (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
     (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1) 98))
    ((257) (APPEND-CHOICES))
    ((211 210) (SUB-SUP))
    ((255) (MATH-FRACTION))
    ((252) (MATH-LEFT-RIGHT))
    ((206) (COND ((= CUR-GROUP 15) (AFTER-MATH)) (TRUE (OFF-SAVE))))
    ((72 173 274 73 174 275 74 175 276 75 176 277 76 177 278 77 178 279 78 179 280 79 180 281
      80 181 282 81 182 283 82 183 284 83 184 285 84 185 286 85 186 287 86 187 288 87 188 289
      88 189 290 89 190 291 90 191 292 91 192 293 92 193 294 93 194 295 94 195 296 95 196 297
      96 197 298 97 198 299 98 199 300 99 200 301 100 201 302 101 202 303)
     (PREFIXED-COMMAND))
    ((41 142 243) (GET-TOKEN) (SETF AFTER-TOKEN CUR-TOK))
    ((42 143 244) (GET-TOKEN) (SAVE-FOR-AFTER CUR-TOK))
    ((61 162 263) (OPEN-OR-CLOSE-IN))
    ((59 160 261) (ISSUE-MESSAGE))
    ((58 159 260) (SHIFT-CASE))
    ((20 121 222) (SHOW-WHATEVER))
    ((60 161 262) (DO-EXTENSION)))
  (GOTO $L.60)
  $L.70
  (SETF MAIN-S (SLOT (SLOT (AREF EQTB (+ 8651 CUR-CHR)) HH) RH))
  (COND ((= MAIN-S 1000) (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
        ((< MAIN-S 1000)
         (WHEN (> MAIN-S 0) (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) MAIN-S)))
        ((< (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
        (TRUE (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) MAIN-S)))
  (SETF MAIN-F (SLOT (SLOT (AREF EQTB 7834) HH) RH))
  (SETF BCHAR (AREF FONT-BCHAR MAIN-F))
  (SETF FALSE-BCHAR (AREF FONT-FALSE-BCHAR MAIN-F))
  (WHEN (> (SLOT CUR-LIST MODE-FIELD) 0)
    (WHEN (/= (SLOT (AREF EQTB 9213) INT) (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) RH))
      (FIX-LANGUAGE)))
  (SETF LIG-STACK AVAIL)
  (COND ((= LIG-STACK 0) (SETF LIG-STACK GET-AVAIL))
        (TRUE
         (SETF AVAIL (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH) 0)))
  (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) B0) MAIN-F)
  (SETF CUR-L (+ CUR-CHR 0))
  (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1) CUR-L)
  (SETF CUR-Q (SLOT CUR-LIST TAIL-FIELD))
  (COND (CANCEL-BOUNDARY (SETF CANCEL-BOUNDARY FALSE) (SETF MAIN-K 0))
        (TRUE (SETF MAIN-K (AREF BCHAR-LABEL MAIN-F))))
  (WHEN (= MAIN-K 0) (GOTO $L.92))
  (SETF CUR-R CUR-L)
  (SETF CUR-L 256)
  (GOTO $L.111)
  $L.80
  (WHEN (< CUR-L 256)
    (WHEN (> (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) 0)
      (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1)
               (+ (AREF HYPHEN-CHAR MAIN-F) 0))
        (SETF INS-DISC TRUE)))
    (WHEN LIGATURE-PRESENT
      (SETF MAIN-P (NEW-LIGATURE MAIN-F CUR-L (SLOT (SLOT (AREF MEM CUR-Q) HH) RH)))
      (WHEN LFT-HIT (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) B1) 2) (SETF LFT-HIT FALSE))
      (WHEN RT-HIT
        (WHEN (= LIG-STACK 0)
          (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) B1)
                (+ (SLOT (SLOT (AREF MEM MAIN-P) HH) B1) 1))
          (SETF RT-HIT FALSE)))
      (SETF (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) MAIN-P)
      (SETF (SLOT CUR-LIST TAIL-FIELD) MAIN-P)
      (SETF LIGATURE-PRESENT FALSE))
    (WHEN INS-DISC
      (SETF INS-DISC FALSE)
      (WHEN (> (SLOT CUR-LIST MODE-FIELD) 0)
        (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-DISC)
        (SETF (SLOT CUR-LIST TAIL-FIELD)
              (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))))
  $L.90
  (WHEN (= LIG-STACK 0) (GOTO $L.21))
  (SETF CUR-Q (SLOT CUR-LIST TAIL-FIELD))
  (SETF CUR-L (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1))
  $L.91
  (UNLESS (>= LIG-STACK HI-MEM-MIN) (GOTO $L.95))
  $L.92
  (WHEN (OR (< CUR-CHR (AREF FONT-BC MAIN-F)) (> CUR-CHR (AREF FONT-EC MAIN-F)))
    (CHAR-WARNING MAIN-F CUR-CHR)
    (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH) AVAIL)
    (SETF AVAIL LIG-STACK)
    (GOTO $L.60))
  (SETF MAIN-I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE MAIN-F) CUR-L)) QQQQ))
  (UNLESS (> (SLOT MAIN-I B0) 0)
    (CHAR-WARNING MAIN-F CUR-CHR)
    (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH) AVAIL)
    (SETF AVAIL LIG-STACK)
    (GOTO $L.60))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) LIG-STACK)
  (SETF (SLOT CUR-LIST TAIL-FIELD) LIG-STACK)
  $L.100
  (GET-NEXT)
  (WHEN (= CUR-CMD 11) (GOTO $L.101))
  (WHEN (= CUR-CMD 12) (GOTO $L.101))
  (WHEN (= CUR-CMD 68) (GOTO $L.101))
  (X-TOKEN)
  (WHEN (= CUR-CMD 11) (GOTO $L.101))
  (WHEN (= CUR-CMD 12) (GOTO $L.101))
  (WHEN (= CUR-CMD 68) (GOTO $L.101))
  (WHEN (= CUR-CMD 16) (SCAN-CHAR-NUM) (SETF CUR-CHR CUR-VAL) (GOTO $L.101))
  (WHEN (= CUR-CMD 65) (SETF BCHAR 256))
  (SETF CUR-R BCHAR)
  (SETF LIG-STACK 0)
  (GOTO $L.110)
  $L.101
  (SETF MAIN-S (SLOT (SLOT (AREF EQTB (+ 8651 CUR-CHR)) HH) RH))
  (COND ((= MAIN-S 1000) (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
        ((< MAIN-S 1000)
         (WHEN (> MAIN-S 0) (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) MAIN-S)))
        ((< (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000)
         (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) 1000))
        (TRUE (SETF (SLOT (SLOT (SLOT CUR-LIST AUX-FIELD) HH) LH) MAIN-S)))
  (SETF LIG-STACK AVAIL)
  (COND ((= LIG-STACK 0) (SETF LIG-STACK GET-AVAIL))
        (TRUE
         (SETF AVAIL (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH))
         (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH) 0)))
  (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) B0) MAIN-F)
  (SETF CUR-R (+ CUR-CHR 0))
  (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1) CUR-R)
  (WHEN (= CUR-R FALSE-BCHAR) (SETF CUR-R 256))
  $L.110
  (WHEN (/= (MOD (- (SLOT MAIN-I B2) 0) 4) 1) (GOTO $L.80))
  (WHEN (= CUR-R 256) (GOTO $L.80))
  (SETF MAIN-K (+ (AREF LIG-KERN-BASE MAIN-F) (SLOT MAIN-I B3)))
  (SETF MAIN-J (SLOT (AREF FONT-INFO MAIN-K) QQQQ))
  (WHEN (<= (SLOT MAIN-J B0) 128) (GOTO $L.112))
  (SETF MAIN-K
        (- (+ (+ (+ (AREF LIG-KERN-BASE MAIN-F) (* 256 (SLOT MAIN-J B2))) (SLOT MAIN-J B3))
              32768)
           (* 256 128)))
  $L.111
  (SETF MAIN-J (SLOT (AREF FONT-INFO MAIN-K) QQQQ))
  $L.112
  (WHEN (= (SLOT MAIN-J B1) CUR-R)
    (WHEN (<= (SLOT MAIN-J B0) 128)
      (WHEN (>= (SLOT MAIN-J B2) 128)
        (WHEN (< CUR-L 256)
          (WHEN (> (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) 0)
            (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1)
                     (+ (AREF HYPHEN-CHAR MAIN-F) 0))
              (SETF INS-DISC TRUE)))
          (WHEN LIGATURE-PRESENT
            (SETF MAIN-P (NEW-LIGATURE MAIN-F CUR-L (SLOT (SLOT (AREF MEM CUR-Q) HH) RH)))
            (WHEN LFT-HIT (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) B1) 2) (SETF LFT-HIT FALSE))
            (WHEN RT-HIT
              (WHEN (= LIG-STACK 0)
                (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) B1)
                      (+ (SLOT (SLOT (AREF MEM MAIN-P) HH) B1) 1))
                (SETF RT-HIT FALSE)))
            (SETF (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) MAIN-P)
            (SETF (SLOT CUR-LIST TAIL-FIELD) MAIN-P)
            (SETF LIGATURE-PRESENT FALSE))
          (WHEN INS-DISC
            (SETF INS-DISC FALSE)
            (WHEN (> (SLOT CUR-LIST MODE-FIELD) 0)
              (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-DISC)
              (SETF (SLOT CUR-LIST TAIL-FIELD)
                    (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))))
        (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)
              (NEW-KERN (SLOT (AREF FONT-INFO
                                    (+ (+ (AREF KERN-BASE MAIN-F) (* 256 (SLOT MAIN-J B2)))
                                       (SLOT MAIN-J B3)))
                              INT)))
        (SETF (SLOT CUR-LIST TAIL-FIELD)
              (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH))
        (GOTO $L.90))
      (COND ((= CUR-L 256) (SETF LFT-HIT TRUE)) ((= LIG-STACK 0) (SETF RT-HIT TRUE)))
      (WHEN (/= INTERRUPT 0) (PAUSE-FOR-INSTRUCTIONS))
      (CASE (SLOT MAIN-J B2)
        ((1 5) (SETF CUR-L (SLOT MAIN-J B3))
         (SETF MAIN-I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE MAIN-F) CUR-L)) QQQQ))
         (SETF LIGATURE-PRESENT TRUE))
        ((2 6) (SETF CUR-R (SLOT MAIN-J B3))
         (COND ((= LIG-STACK 0) (SETF LIG-STACK (NEW-LIG-ITEM CUR-R)) (SETF BCHAR 256))
               ((>= LIG-STACK HI-MEM-MIN)
                (SETF MAIN-P LIG-STACK)
                (SETF LIG-STACK (NEW-LIG-ITEM CUR-R))
                (SETF (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH) MAIN-P))
               (TRUE (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1) CUR-R))))
        ((3) (SETF CUR-R (SLOT MAIN-J B3)) (SETF MAIN-P LIG-STACK)
         (SETF LIG-STACK (NEW-LIG-ITEM CUR-R))
         (SETF (SLOT (SLOT (AREF MEM LIG-STACK) HH) RH) MAIN-P))
        ((7 11)
         (WHEN (< CUR-L 256)
           (WHEN (> (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) 0)
             (WHEN (= (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) B1)
                      (+ (AREF HYPHEN-CHAR MAIN-F) 0))
               (SETF INS-DISC TRUE)))
           (WHEN LIGATURE-PRESENT
             (SETF MAIN-P (NEW-LIGATURE MAIN-F CUR-L (SLOT (SLOT (AREF MEM CUR-Q) HH) RH)))
             (WHEN LFT-HIT (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) B1) 2) (SETF LFT-HIT FALSE))
             (WHEN FALSE
               (WHEN (= LIG-STACK 0)
                 (SETF (SLOT (SLOT (AREF MEM MAIN-P) HH) B1)
                       (+ (SLOT (SLOT (AREF MEM MAIN-P) HH) B1) 1))
                 (SETF RT-HIT FALSE)))
             (SETF (SLOT (SLOT (AREF MEM CUR-Q) HH) RH) MAIN-P)
             (SETF (SLOT CUR-LIST TAIL-FIELD) MAIN-P)
             (SETF LIGATURE-PRESENT FALSE))
           (WHEN INS-DISC
             (SETF INS-DISC FALSE)
             (WHEN (> (SLOT CUR-LIST MODE-FIELD) 0)
               (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) NEW-DISC)
               (SETF (SLOT CUR-LIST TAIL-FIELD)
                     (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))))
         (SETF CUR-Q (SLOT CUR-LIST TAIL-FIELD)) (SETF CUR-L (SLOT MAIN-J B3))
         (SETF MAIN-I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE MAIN-F) CUR-L)) QQQQ))
         (SETF LIGATURE-PRESENT TRUE))
        (ELSE (SETF CUR-L (SLOT MAIN-J B3)) (SETF LIGATURE-PRESENT TRUE)
         (COND ((= LIG-STACK 0) (GOTO $L.80)) (TRUE (GOTO $L.91)))))
      (WHEN (> (SLOT MAIN-J B2) 4) (WHEN (/= (SLOT MAIN-J B2) 7) (GOTO $L.80)))
      (WHEN (< CUR-L 256) (GOTO $L.110))
      (SETF MAIN-K (AREF BCHAR-LABEL MAIN-F))
      (GOTO $L.111)))
  (COND ((= (SLOT MAIN-J B0) 0) (INCF MAIN-K 1))
        (TRUE
         (WHEN (>= (SLOT MAIN-J B0) 128) (GOTO $L.80))
         (SETF MAIN-K (+ (+ MAIN-K (SLOT MAIN-J B0)) 1))))
  (GOTO $L.111)
  $L.95
  (SETF MAIN-P (SLOT (SLOT (AREF MEM (+ LIG-STACK 1)) HH) RH))
  (WHEN (> MAIN-P 0)
    (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) MAIN-P)
    (SETF (SLOT CUR-LIST TAIL-FIELD)
          (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH)))
  (SETF TEMP-PTR LIG-STACK)
  (SETF LIG-STACK (SLOT (SLOT (AREF MEM TEMP-PTR) HH) RH))
  (FREE-NODE TEMP-PTR 2)
  (SETF MAIN-I (SLOT (AREF FONT-INFO (+ (AREF CHAR-BASE MAIN-F) CUR-L)) QQQQ))
  (SETF LIGATURE-PRESENT TRUE)
  (COND ((= LIG-STACK 0) (COND ((> MAIN-P 0) (GOTO $L.100)) (TRUE (SETF CUR-R BCHAR))))
        (TRUE (SETF CUR-R (SLOT (SLOT (AREF MEM LIG-STACK) HH) B1))))
  (GOTO $L.110)
  $L.120
  (COND ((= (SLOT (SLOT (AREF EQTB 6794) HH) RH) 0)
         (SETF MAIN-P (AREF FONT-GLUE (SLOT (SLOT (AREF EQTB 7834) HH) RH)))
         (WHEN (= MAIN-P 0)
           (SETF MAIN-P (NEW-SPEC 0))
           (SETF MAIN-K (+ (AREF PARAM-BASE (SLOT (SLOT (AREF EQTB 7834) HH) RH)) 2))
           (SETF (SLOT (AREF MEM (+ MAIN-P 1)) INT) (SLOT (AREF FONT-INFO MAIN-K) INT))
           (SETF (SLOT (AREF MEM (+ MAIN-P 2)) INT) (SLOT (AREF FONT-INFO (+ MAIN-K 1)) INT))
           (SETF (SLOT (AREF MEM (+ MAIN-P 3)) INT) (SLOT (AREF FONT-INFO (+ MAIN-K 2)) INT))
           (SETF (AREF FONT-GLUE (SLOT (SLOT (AREF EQTB 7834) HH) RH)) MAIN-P))
         (SETF TEMP-PTR (NEW-GLUE MAIN-P)))
        (TRUE (SETF TEMP-PTR (NEW-PARAM-GLUE 12))))
  (SETF (SLOT (SLOT (AREF MEM (SLOT CUR-LIST TAIL-FIELD)) HH) RH) TEMP-PTR)
  (SETF (SLOT CUR-LIST TAIL-FIELD) TEMP-PTR)
  (GOTO $L.60)
  $L.10)

(PROCEDURE GIVE-ERR-HELP () (TOKEN-SHOW (SLOT (SLOT (AREF EQTB 7321) HH) RH)))

(FUNCTION (OPEN-FMT-FILE BOOLEAN) ()
  (LABEL $L.40)
  (LABEL $L.10)
  (VAR J (RANGE 0 BUF-SIZE))
  (SETF J (SLOT CUR-INPUT LOC-FIELD))
  (WHEN (= (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)) 38)
    (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LOC-FIELD) 1))
    (SETF J (SLOT CUR-INPUT LOC-FIELD))
    (SETF (AREF BUFFER LAST) 32)
    (WHILE (/= (AREF BUFFER J) 32) (INCF J 1))
    (PACK-BUFFERED-NAME 0 (SLOT CUR-INPUT LOC-FIELD) (- J 1))
    (WHEN (W-OPEN-IN FMT-FILE) (GOTO $L.40))
    (PACK-BUFFERED-NAME 11 (SLOT CUR-INPUT LOC-FIELD) (- J 1))
    (WHEN (W-OPEN-IN FMT-FILE) (GOTO $L.40))
    (WRITELN TERM-OUT "Sorry, I can't find that format;" " will try PLAIN.")
    (BREAK TERM-OUT))
  (PACK-BUFFERED-NAME 16 1 0)
  (UNLESS (W-OPEN-IN FMT-FILE)
    (WRITELN TERM-OUT "I can't find the PLAIN format file!")
    (SETF OPEN-FMT-FILE FALSE)
    (GOTO $L.10))
  $L.40
  (SETF (SLOT CUR-INPUT LOC-FIELD) J)
  (SETF OPEN-FMT-FILE TRUE)
  $L.10)

(FUNCTION (LOAD-FMT-FILE BOOLEAN) ()
  (LABEL $L.6666)
  (LABEL $L.10)
  (VAR J INTEGER)
  (VAR K INTEGER)
  (VAR P HALFWORD)
  (VAR Q HALFWORD)
  (VAR X INTEGER)
  (VAR W FOUR-QUARTERS)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (/= X 504454778) (GOTO $L.6666))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (/= X 0) (GOTO $L.6666))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (/= X 60000) (GOTO $L.6666))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (/= X 10006) (GOTO $L.6666))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (/= X 1777) (GOTO $L.6666))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (/= X 307) (GOTO $L.6666))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (< X 0) (GOTO $L.6666))
  (COND ((> X POOL-SIZE)
         (WRITELN TERM-OUT "---! Must increase the " "string pool size")
         (GOTO $L.6666))
        (TRUE (SETF POOL-PTR X)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (< X 0) (GOTO $L.6666))
  (COND ((> X MAX-STRINGS)
         (WRITELN TERM-OUT "---! Must increase the " "max strings")
         (GOTO $L.6666))
        (TRUE (SETF STR-PTR X)))
  (FOR (K 0 TO STR-PTR)
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X POOL-PTR)) (GOTO $L.6666)) (TRUE (SETF (AREF STR-START K) X))))
  (SETF K 0)
  (WHILE (< (+ K 4) POOL-PTR)
    (GET FMT-FILE)
    (SETF W (SLOT (AREF FMT-FILE) QQQQ))
    (SETF (AREF STR-POOL K) (- (SLOT W B0) 0))
    (SETF (AREF STR-POOL (+ K 1)) (- (SLOT W B1) 0))
    (SETF (AREF STR-POOL (+ K 2)) (- (SLOT W B2) 0))
    (SETF (AREF STR-POOL (+ K 3)) (- (SLOT W B3) 0))
    (INCF K 4))
  (SETF K (- POOL-PTR 4))
  (GET FMT-FILE)
  (SETF W (SLOT (AREF FMT-FILE) QQQQ))
  (SETF (AREF STR-POOL K) (- (SLOT W B0) 0))
  (SETF (AREF STR-POOL (+ K 1)) (- (SLOT W B1) 0))
  (SETF (AREF STR-POOL (+ K 2)) (- (SLOT W B2) 0))
  (SETF (AREF STR-POOL (+ K 3)) (- (SLOT W B3) 0))
  (SETF INIT-STR-PTR STR-PTR)
  (SETF INIT-POOL-PTR POOL-PTR)
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 1019) (> X 59986)) (GOTO $L.6666)) (TRUE (SETF LO-MEM-MAX X)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 20) (> X LO-MEM-MAX)) (GOTO $L.6666)) (TRUE (SETF ROVER X)))
  (SETF P 0)
  (SETF Q ROVER)
  (REPEAT (FOR (K P TO (+ Q 1)) (GET FMT-FILE) (SETF (AREF MEM K) (AREF FMT-FILE)))
          (SETF P (+ Q (SLOT (SLOT (AREF MEM Q) HH) LH)))
          (WHEN (OR (> P LO-MEM-MAX)
                    (AND (>= Q (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
                         (/= (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) ROVER)))
            (GOTO $L.6666))
          (SETF Q (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH))
          (UNTIL (= Q ROVER)))
  (FOR (K P TO LO-MEM-MAX) (GET FMT-FILE) (SETF (AREF MEM K) (AREF FMT-FILE)))
  (WHEN (< MEM-MIN (- 2))
    (SETF P (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH))
    (SETF Q (+ MEM-MIN 1))
    (SETF (SLOT (SLOT (AREF MEM MEM-MIN) HH) RH) 0)
    (SETF (SLOT (SLOT (AREF MEM MEM-MIN) HH) LH) 0)
    (SETF (SLOT (SLOT (AREF MEM (+ P 1)) HH) RH) Q)
    (SETF (SLOT (SLOT (AREF MEM (+ ROVER 1)) HH) LH) Q)
    (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) RH) ROVER)
    (SETF (SLOT (SLOT (AREF MEM (+ Q 1)) HH) LH) P)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) RH) 65535)
    (SETF (SLOT (SLOT (AREF MEM Q) HH) LH) (- (- 0) Q)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X (+ LO-MEM-MAX 1)) (> X 59987)) (GOTO $L.6666)) (TRUE (SETF HI-MEM-MIN X)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 0) (> X 60000)) (GOTO $L.6666)) (TRUE (SETF AVAIL X)))
  (SETF MEM-END 60000)
  (FOR (K HI-MEM-MIN TO MEM-END) (GET FMT-FILE) (SETF (AREF MEM K) (AREF FMT-FILE)))
  (GET FMT-FILE)
  (SETF VAR-USED (SLOT (AREF FMT-FILE) INT))
  (GET FMT-FILE)
  (SETF DYN-USED (SLOT (AREF FMT-FILE) INT))
  (SETF K 1)
  (REPEAT (GET FMT-FILE)
          (SETF X (SLOT (AREF FMT-FILE) INT))
          (WHEN (OR (< X 1) (> (+ K X) 10007)) (GOTO $L.6666))
          (FOR (J K TO (- (+ K X) 1)) (GET FMT-FILE) (SETF (AREF EQTB J) (AREF FMT-FILE)))
          (INCF K X)
          (GET FMT-FILE)
          (SETF X (SLOT (AREF FMT-FILE) INT))
          (WHEN (OR (< X 0) (> (+ K X) 10007)) (GOTO $L.6666))
          (FOR (J K TO (- (+ K X) 1)) (SETF (AREF EQTB J) (AREF EQTB (- K 1))))
          (INCF K X)
          (UNTIL (> K 10006)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 514) (> X 6514)) (GOTO $L.6666)) (TRUE (SETF PAR-LOC X)))
  (SETF PAR-TOKEN (+ 4095 PAR-LOC))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 514) (> X 6514)) (GOTO $L.6666)) (TRUE (SETF WRITE-LOC X)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 514) (> X 6514)) (GOTO $L.6666)) (TRUE (SETF HASH-USED X)))
  (SETF P 513)
  (REPEAT (GET FMT-FILE)
          (SETF X (SLOT (AREF FMT-FILE) INT))
          (COND ((OR (< X (+ P 1)) (> X HASH-USED)) (GOTO $L.6666)) (TRUE (SETF P X)))
          (GET FMT-FILE)
          (SETF (AREF HASH P) (SLOT (AREF FMT-FILE) HH))
          (UNTIL (= P HASH-USED)))
  (FOR (P (+ HASH-USED 1) TO 6780)
    (GET FMT-FILE)
    (SETF (AREF HASH P) (SLOT (AREF FMT-FILE) HH)))
  (GET FMT-FILE)
  (SETF CS-COUNT (SLOT (AREF FMT-FILE) INT))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (< X 7) (GOTO $L.6666))
  (COND ((> X FONT-MEM-SIZE)
         (WRITELN TERM-OUT "---! Must increase the " "font mem size")
         (GOTO $L.6666))
        (TRUE (SETF FMEM-PTR X)))
  (FOR (K 0 TO (- FMEM-PTR 1)) (GET FMT-FILE) (SETF (AREF FONT-INFO K) (AREF FMT-FILE)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (< X 0) (GOTO $L.6666))
  (COND ((> X FONT-MAX) (WRITELN TERM-OUT "---! Must increase the " "font max") (GOTO $L.6666))
        (TRUE (SETF FONT-PTR X)))
  (FOR (K 0 TO FONT-PTR)
    (GET FMT-FILE)
    (SETF (AREF FONT-CHECK K) (SLOT (AREF FMT-FILE) QQQQ))
    (GET FMT-FILE)
    (SETF (AREF FONT-SIZE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF FONT-DSIZE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 65535)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-PARAMS K) X)))
    (GET FMT-FILE)
    (SETF (AREF HYPHEN-CHAR K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF SKEW-CHAR K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X STR-PTR)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-NAME K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X STR-PTR)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-AREA K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 255)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-BC K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 255)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-EC K) X)))
    (GET FMT-FILE)
    (SETF (AREF CHAR-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF WIDTH-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF HEIGHT-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF DEPTH-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF ITALIC-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF LIG-KERN-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF KERN-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF EXTEN-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF (AREF PARAM-BASE K) (SLOT (AREF FMT-FILE) INT))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X LO-MEM-MAX)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-GLUE K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X (- FMEM-PTR 1))) (GOTO $L.6666))
          (TRUE (SETF (AREF BCHAR-LABEL K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 256)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-BCHAR K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 256)) (GOTO $L.6666)) (TRUE (SETF (AREF FONT-FALSE-BCHAR K) X))))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 0) (> X 307)) (GOTO $L.6666)) (TRUE (SETF HYPH-COUNT X)))
  (FOR (K 1 TO HYPH-COUNT)
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 307)) (GOTO $L.6666)) (TRUE (SETF J X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X STR-PTR)) (GOTO $L.6666)) (TRUE (SETF (AREF HYPH-WORD J) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 65535)) (GOTO $L.6666)) (TRUE (SETF (AREF HYPH-LIST J) X))))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (< X 0) (GOTO $L.6666))
  (COND ((> X TRIE-SIZE)
         (WRITELN TERM-OUT "---! Must increase the " "trie size")
         (GOTO $L.6666))
        (TRUE (SETF J X)))
  (SETF TRIE-MAX J)
  (FOR (K 0 TO J) (GET FMT-FILE) (SETF (AREF TRIE K) (SLOT (AREF FMT-FILE) HH)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (< X 0) (GOTO $L.6666))
  (COND ((> X TRIE-OP-SIZE)
         (WRITELN TERM-OUT "---! Must increase the " "trie op size")
         (GOTO $L.6666))
        (TRUE (SETF J X)))
  (SETF TRIE-OP-PTR J)
  (FOR (K 1 TO J)
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 63)) (GOTO $L.6666)) (TRUE (SETF (AREF HYF-DISTANCE K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 63)) (GOTO $L.6666)) (TRUE (SETF (AREF HYF-NUM K) X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X 255)) (GOTO $L.6666)) (TRUE (SETF (AREF HYF-NEXT K) X))))
  (FOR (K 0 TO 255) (SETF (AREF TRIE-USED K) 0))
  (SETF K 256)
  (WHILE (> J 0)
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 0) (> X (- K 1))) (GOTO $L.6666)) (TRUE (SETF K X)))
    (GET FMT-FILE)
    (SETF X (SLOT (AREF FMT-FILE) INT))
    (COND ((OR (< X 1) (> X J)) (GOTO $L.6666)) (TRUE (SETF X X)))
    (SETF (AREF TRIE-USED K) (+ X 0))
    (DECF J X)
    (SETF (AREF OP-START K) (- J 0)))
  (SETF TRIE-NOT-READY FALSE)
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 0) (> X 3)) (GOTO $L.6666)) (TRUE (SETF INTERACTION X)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (COND ((OR (< X 0) (> X STR-PTR)) (GOTO $L.6666)) (TRUE (SETF FORMAT-IDENT X)))
  (GET FMT-FILE)
  (SETF X (SLOT (AREF FMT-FILE) INT))
  (WHEN (OR (/= X 69069) (EOF FMT-FILE)) (GOTO $L.6666))
  (SETF LOAD-FMT-FILE TRUE)
  (GOTO $L.10)
  $L.6666
  (WRITELN TERM-OUT "(Fatal format file error; I'm stymied)")
  (SETF LOAD-FMT-FILE FALSE)
  $L.10)

(PROCEDURE CLOSE-FILES-AND-TERMINATE ()
  (VAR K INTEGER)
  (FOR (K 0 TO 15) (WHEN (AREF WRITE-OPEN K) (A-CLOSE (AREF WRITE-FILE K))))
  (SETF (SLOT (AREF EQTB 9212) INT) (- 1))
  (WHILE (> CUR-S (- 1))
    (COND ((> CUR-S 0)
           (SETF (AREF DVI-BUF DVI-PTR) 142)
           (INCF DVI-PTR 1)
           (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP)))
          (TRUE
           (SETF (AREF DVI-BUF DVI-PTR) 140)
           (INCF DVI-PTR 1)
           (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
           (INCF TOTAL-PAGES 1)))
    (DECF CUR-S 1))
  (COND ((= TOTAL-PAGES 0) (PRINT-NL 837))
        (TRUE
         (SETF (AREF DVI-BUF DVI-PTR) 248)
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (DVI-FOUR LAST-BOP)
         (SETF LAST-BOP (- (+ DVI-OFFSET DVI-PTR) 5))
         (DVI-FOUR 25400000)
         (DVI-FOUR 473628672)
         (PREPARE-MAG)
         (DVI-FOUR (SLOT (AREF EQTB 9180) INT))
         (DVI-FOUR MAX-V)
         (DVI-FOUR MAX-H)
         (SETF (AREF DVI-BUF DVI-PTR) (DIV MAX-PUSH 256))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (SETF (AREF DVI-BUF DVI-PTR) (MOD MAX-PUSH 256))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (SETF (AREF DVI-BUF DVI-PTR) (MOD (DIV TOTAL-PAGES 256) 256))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (SETF (AREF DVI-BUF DVI-PTR) (MOD TOTAL-PAGES 256))
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (WHILE (> FONT-PTR 0)
           (WHEN (AREF FONT-USED FONT-PTR) (DVI-FONT-DEF FONT-PTR))
           (DECF FONT-PTR 1))
         (SETF (AREF DVI-BUF DVI-PTR) 249)
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (DVI-FOUR LAST-BOP)
         (SETF (AREF DVI-BUF DVI-PTR) 2)
         (INCF DVI-PTR 1)
         (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
         (SETF K (+ 4 (MOD (- DVI-BUF-SIZE DVI-PTR) 4)))
         (WHILE (> K 0)
           (SETF (AREF DVI-BUF DVI-PTR) 223)
           (INCF DVI-PTR 1)
           (WHEN (= DVI-PTR DVI-LIMIT) (DVI-SWAP))
           (DECF K 1))
         (WHEN (= DVI-LIMIT HALF-BUF) (WRITE-DVI HALF-BUF (- DVI-BUF-SIZE 1)))
         (WHEN (> DVI-PTR 0) (WRITE-DVI 0 (- DVI-PTR 1)))
         (PRINT-NL 838)
         (SLOW-PRINT OUTPUT-FILE-NAME)
         (PRINT 286)
         (PRINT-INT TOTAL-PAGES)
         (PRINT 839)
         (WHEN (/= TOTAL-PAGES 1) (PRINT-CHAR 115))
         (PRINT 840)
         (PRINT-INT (+ DVI-OFFSET DVI-PTR))
         (PRINT 841)
         (B-CLOSE DVI-FILE)))
  (WHEN LOG-OPENED
    (WRITELN LOG-FILE)
    (A-CLOSE LOG-FILE)
    (DECF SELECTOR 2)
    (WHEN (= SELECTOR 17) (PRINT-NL 1275) (SLOW-PRINT LOG-NAME) (PRINT-CHAR 46))))

(PROCEDURE FINAL-CLEANUP ()
  (LABEL $L.10)
  (VAR C SMALL-NUMBER)
  (SETF C CUR-CHR)
  (WHEN (/= C 1) (SETF (SLOT (AREF EQTB 9212) INT) (- 1)))
  (WHEN (= JOB-NAME 0) (OPEN-LOG-FILE))
  (WHILE (> INPUT-PTR 0)
    (COND ((= (SLOT CUR-INPUT STATE-FIELD) 0) (END-TOKEN-LIST)) (TRUE (END-FILE-READING))))
  (WHILE (> OPEN-PARENS 0) (PRINT 1276) (DECF OPEN-PARENS 1))
  (WHEN (> CUR-LEVEL 1)
    (PRINT-NL 40)
    (PRINT-ESC 1277)
    (PRINT 1278)
    (PRINT-INT (- CUR-LEVEL 1))
    (PRINT-CHAR 41))
  (WHILE (/= COND-PTR 0)
    (PRINT-NL 40)
    (PRINT-ESC 1277)
    (PRINT 1279)
    (PRINT-CMD-CHR 105 CUR-IF)
    (WHEN (/= IF-LINE 0) (PRINT 1280) (PRINT-INT IF-LINE))
    (PRINT 1281)
    (SETF IF-LINE (SLOT (AREF MEM (+ COND-PTR 1)) INT))
    (SETF CUR-IF (SLOT (SLOT (AREF MEM COND-PTR) HH) B1))
    (SETF TEMP-PTR COND-PTR)
    (SETF COND-PTR (SLOT (SLOT (AREF MEM COND-PTR) HH) RH))
    (FREE-NODE TEMP-PTR 2))
  (WHEN (/= HISTORY 0)
    (WHEN (OR (= HISTORY 1) (< INTERACTION 3))
      (WHEN (= SELECTOR 19) (SETF SELECTOR 17) (PRINT-NL 1282) (SETF SELECTOR 19))))
  (WHEN (= C 1)
    (FOR (C 0 TO 4) (WHEN (/= (AREF CUR-MARK C) 0) (DELETE-TOKEN-REF (AREF CUR-MARK C))))
    (WHEN (/= LAST-GLUE 65535) (DELETE-GLUE-REF LAST-GLUE))
    (STORE-FMT-FILE)
    (GOTO $L.10)
    (PRINT-NL 1283)
    (GOTO $L.10))
  $L.10)

(PROCEDURE INIT-PRIM ()
  (SETF NO-NEW-CONTROL-SEQUENCE FALSE)
  (PRIMITIVE 376 75 6782)
  (PRIMITIVE 377 75 6783)
  (PRIMITIVE 378 75 6784)
  (PRIMITIVE 379 75 6785)
  (PRIMITIVE 380 75 6786)
  (PRIMITIVE 381 75 6787)
  (PRIMITIVE 382 75 6788)
  (PRIMITIVE 383 75 6789)
  (PRIMITIVE 384 75 6790)
  (PRIMITIVE 385 75 6791)
  (PRIMITIVE 386 75 6792)
  (PRIMITIVE 387 75 6793)
  (PRIMITIVE 388 75 6794)
  (PRIMITIVE 389 75 6795)
  (PRIMITIVE 390 75 6796)
  (PRIMITIVE 391 76 6797)
  (PRIMITIVE 392 76 6798)
  (PRIMITIVE 393 76 6799)
  (PRIMITIVE 398 72 7313)
  (PRIMITIVE 399 72 7314)
  (PRIMITIVE 400 72 7315)
  (PRIMITIVE 401 72 7316)
  (PRIMITIVE 402 72 7317)
  (PRIMITIVE 403 72 7318)
  (PRIMITIVE 404 72 7319)
  (PRIMITIVE 405 72 7320)
  (PRIMITIVE 406 72 7321)
  (PRIMITIVE 420 73 9163)
  (PRIMITIVE 421 73 9164)
  (PRIMITIVE 422 73 9165)
  (PRIMITIVE 423 73 9166)
  (PRIMITIVE 424 73 9167)
  (PRIMITIVE 425 73 9168)
  (PRIMITIVE 426 73 9169)
  (PRIMITIVE 427 73 9170)
  (PRIMITIVE 428 73 9171)
  (PRIMITIVE 429 73 9172)
  (PRIMITIVE 430 73 9173)
  (PRIMITIVE 431 73 9174)
  (PRIMITIVE 432 73 9175)
  (PRIMITIVE 433 73 9176)
  (PRIMITIVE 434 73 9177)
  (PRIMITIVE 435 73 9178)
  (PRIMITIVE 436 73 9179)
  (PRIMITIVE 437 73 9180)
  (PRIMITIVE 438 73 9181)
  (PRIMITIVE 439 73 9182)
  (PRIMITIVE 440 73 9183)
  (PRIMITIVE 441 73 9184)
  (PRIMITIVE 442 73 9185)
  (PRIMITIVE 443 73 9186)
  (PRIMITIVE 444 73 9187)
  (PRIMITIVE 445 73 9188)
  (PRIMITIVE 446 73 9189)
  (PRIMITIVE 447 73 9190)
  (PRIMITIVE 448 73 9191)
  (PRIMITIVE 449 73 9192)
  (PRIMITIVE 450 73 9193)
  (PRIMITIVE 451 73 9194)
  (PRIMITIVE 452 73 9195)
  (PRIMITIVE 453 73 9196)
  (PRIMITIVE 454 73 9197)
  (PRIMITIVE 455 73 9198)
  (PRIMITIVE 456 73 9199)
  (PRIMITIVE 457 73 9200)
  (PRIMITIVE 458 73 9201)
  (PRIMITIVE 459 73 9202)
  (PRIMITIVE 460 73 9203)
  (PRIMITIVE 461 73 9204)
  (PRIMITIVE 462 73 9205)
  (PRIMITIVE 463 73 9206)
  (PRIMITIVE 464 73 9207)
  (PRIMITIVE 465 73 9208)
  (PRIMITIVE 466 73 9209)
  (PRIMITIVE 467 73 9210)
  (PRIMITIVE 468 73 9211)
  (PRIMITIVE 469 73 9212)
  (PRIMITIVE 470 73 9213)
  (PRIMITIVE 471 73 9214)
  (PRIMITIVE 472 73 9215)
  (PRIMITIVE 473 73 9216)
  (PRIMITIVE 474 73 9217)
  (PRIMITIVE 478 74 9730)
  (PRIMITIVE 479 74 9731)
  (PRIMITIVE 480 74 9732)
  (PRIMITIVE 481 74 9733)
  (PRIMITIVE 482 74 9734)
  (PRIMITIVE 483 74 9735)
  (PRIMITIVE 484 74 9736)
  (PRIMITIVE 485 74 9737)
  (PRIMITIVE 486 74 9738)
  (PRIMITIVE 487 74 9739)
  (PRIMITIVE 488 74 9740)
  (PRIMITIVE 489 74 9741)
  (PRIMITIVE 490 74 9742)
  (PRIMITIVE 491 74 9743)
  (PRIMITIVE 492 74 9744)
  (PRIMITIVE 493 74 9745)
  (PRIMITIVE 494 74 9746)
  (PRIMITIVE 495 74 9747)
  (PRIMITIVE 496 74 9748)
  (PRIMITIVE 497 74 9749)
  (PRIMITIVE 498 74 9750)
  (PRIMITIVE 32 64 0)
  (PRIMITIVE 47 44 0)
  (PRIMITIVE 508 45 0)
  (PRIMITIVE 509 90 0)
  (PRIMITIVE 510 40 0)
  (PRIMITIVE 511 41 0)
  (PRIMITIVE 512 61 0)
  (PRIMITIVE 513 16 0)
  (PRIMITIVE 504 107 0)
  (PRIMITIVE 514 15 0)
  (PRIMITIVE 515 92 0)
  (PRIMITIVE 505 67 0)
  (PRIMITIVE 516 62 0)
  (SETF (SLOT (AREF HASH 6516) RH) 516)
  (SETF (AREF EQTB 6516) (AREF EQTB CUR-VAL))
  (PRIMITIVE 517 102 0)
  (PRIMITIVE 518 88 0)
  (PRIMITIVE 519 77 0)
  (PRIMITIVE 520 32 0)
  (PRIMITIVE 521 36 0)
  (PRIMITIVE 522 39 0)
  (PRIMITIVE 330 37 0)
  (PRIMITIVE 351 18 0)
  (PRIMITIVE 523 46 0)
  (PRIMITIVE 524 17 0)
  (PRIMITIVE 525 54 0)
  (PRIMITIVE 526 91 0)
  (PRIMITIVE 527 34 0)
  (PRIMITIVE 528 65 0)
  (PRIMITIVE 529 103 0)
  (PRIMITIVE 335 55 0)
  (PRIMITIVE 530 63 0)
  (PRIMITIVE 408 84 0)
  (PRIMITIVE 531 42 0)
  (PRIMITIVE 532 80 0)
  (PRIMITIVE 533 66 0)
  (PRIMITIVE 534 96 0)
  (PRIMITIVE 535 0 256)
  (SETF (SLOT (AREF HASH 6521) RH) 535)
  (SETF (AREF EQTB 6521) (AREF EQTB CUR-VAL))
  (PRIMITIVE 536 98 0)
  (PRIMITIVE 537 109 0)
  (PRIMITIVE 407 71 0)
  (PRIMITIVE 352 38 0)
  (PRIMITIVE 538 33 0)
  (PRIMITIVE 539 56 0)
  (PRIMITIVE 540 35 0)
  (PRIMITIVE 597 13 256)
  (SETF PAR-LOC CUR-VAL)
  (SETF PAR-TOKEN (+ 4095 PAR-LOC))
  (PRIMITIVE 629 104 0)
  (PRIMITIVE 630 104 1)
  (PRIMITIVE 631 110 0)
  (PRIMITIVE 632 110 1)
  (PRIMITIVE 633 110 2)
  (PRIMITIVE 634 110 3)
  (PRIMITIVE 635 110 4)
  (PRIMITIVE 476 89 0)
  (PRIMITIVE 500 89 1)
  (PRIMITIVE 395 89 2)
  (PRIMITIVE 396 89 3)
  (PRIMITIVE 668 79 102)
  (PRIMITIVE 669 79 1)
  (PRIMITIVE 670 82 0)
  (PRIMITIVE 671 82 1)
  (PRIMITIVE 672 83 1)
  (PRIMITIVE 673 83 3)
  (PRIMITIVE 674 83 2)
  (PRIMITIVE 675 70 0)
  (PRIMITIVE 676 70 1)
  (PRIMITIVE 677 70 2)
  (PRIMITIVE 678 70 3)
  (PRIMITIVE 679 70 4)
  (PRIMITIVE 735 108 0)
  (PRIMITIVE 736 108 1)
  (PRIMITIVE 737 108 2)
  (PRIMITIVE 738 108 3)
  (PRIMITIVE 739 108 4)
  (PRIMITIVE 740 108 5)
  (PRIMITIVE 757 105 0)
  (PRIMITIVE 758 105 1)
  (PRIMITIVE 759 105 2)
  (PRIMITIVE 760 105 3)
  (PRIMITIVE 761 105 4)
  (PRIMITIVE 762 105 5)
  (PRIMITIVE 763 105 6)
  (PRIMITIVE 764 105 7)
  (PRIMITIVE 765 105 8)
  (PRIMITIVE 766 105 9)
  (PRIMITIVE 767 105 10)
  (PRIMITIVE 768 105 11)
  (PRIMITIVE 769 105 12)
  (PRIMITIVE 770 105 13)
  (PRIMITIVE 771 105 14)
  (PRIMITIVE 772 105 15)
  (PRIMITIVE 773 105 16)
  (PRIMITIVE 774 106 2)
  (SETF (SLOT (AREF HASH 6518) RH) 774)
  (SETF (AREF EQTB 6518) (AREF EQTB CUR-VAL))
  (PRIMITIVE 775 106 4)
  (PRIMITIVE 776 106 3)
  (PRIMITIVE 801 87 0)
  (SETF (SLOT (AREF HASH 6524) RH) 801)
  (SETF (AREF EQTB 6524) (AREF EQTB CUR-VAL))
  (PRIMITIVE 898 4 256)
  (PRIMITIVE 899 5 257)
  (SETF (SLOT (AREF HASH 6515) RH) 899)
  (SETF (AREF EQTB 6515) (AREF EQTB CUR-VAL))
  (PRIMITIVE 900 5 258)
  (SETF (SLOT (AREF HASH 6519) RH) 901)
  (SETF (SLOT (AREF HASH 6520) RH) 901)
  (SETF (SLOT (SLOT (AREF EQTB 6520) HH) B0) 9)
  (SETF (SLOT (SLOT (AREF EQTB 6520) HH) RH) 59989)
  (SETF (SLOT (SLOT (AREF EQTB 6520) HH) B1) 1)
  (SETF (AREF EQTB 6519) (AREF EQTB 6520))
  (SETF (SLOT (SLOT (AREF EQTB 6519) HH) B0) 115)
  (PRIMITIVE 970 81 0)
  (PRIMITIVE 971 81 1)
  (PRIMITIVE 972 81 2)
  (PRIMITIVE 973 81 3)
  (PRIMITIVE 974 81 4)
  (PRIMITIVE 975 81 5)
  (PRIMITIVE 976 81 6)
  (PRIMITIVE 977 81 7)
  (PRIMITIVE 1025 14 0)
  (PRIMITIVE 1026 14 1)
  (PRIMITIVE 1027 26 4)
  (PRIMITIVE 1028 26 0)
  (PRIMITIVE 1029 26 1)
  (PRIMITIVE 1030 26 2)
  (PRIMITIVE 1031 26 3)
  (PRIMITIVE 1032 27 4)
  (PRIMITIVE 1033 27 0)
  (PRIMITIVE 1034 27 1)
  (PRIMITIVE 1035 27 2)
  (PRIMITIVE 1036 27 3)
  (PRIMITIVE 336 28 5)
  (PRIMITIVE 340 29 1)
  (PRIMITIVE 342 30 99)
  (PRIMITIVE 1054 21 1)
  (PRIMITIVE 1055 21 0)
  (PRIMITIVE 1056 22 1)
  (PRIMITIVE 1057 22 0)
  (PRIMITIVE 409 20 0)
  (PRIMITIVE 1058 20 1)
  (PRIMITIVE 1059 20 2)
  (PRIMITIVE 965 20 3)
  (PRIMITIVE 1060 20 4)
  (PRIMITIVE 967 20 5)
  (PRIMITIVE 1061 20 106)
  (PRIMITIVE 1062 31 99)
  (PRIMITIVE 1063 31 100)
  (PRIMITIVE 1064 31 101)
  (PRIMITIVE 1065 31 102)
  (PRIMITIVE 1080 43 1)
  (PRIMITIVE 1081 43 0)
  (PRIMITIVE 1090 25 12)
  (PRIMITIVE 1091 25 11)
  (PRIMITIVE 1092 25 10)
  (PRIMITIVE 1093 23 0)
  (PRIMITIVE 1094 23 1)
  (PRIMITIVE 1095 24 0)
  (PRIMITIVE 1096 24 1)
  (PRIMITIVE 45 47 1)
  (PRIMITIVE 349 47 0)
  (PRIMITIVE 1127 48 0)
  (PRIMITIVE 1128 48 1)
  (PRIMITIVE 866 50 16)
  (PRIMITIVE 867 50 17)
  (PRIMITIVE 868 50 18)
  (PRIMITIVE 869 50 19)
  (PRIMITIVE 870 50 20)
  (PRIMITIVE 871 50 21)
  (PRIMITIVE 872 50 22)
  (PRIMITIVE 873 50 23)
  (PRIMITIVE 875 50 26)
  (PRIMITIVE 874 50 27)
  (PRIMITIVE 1129 51 0)
  (PRIMITIVE 878 51 1)
  (PRIMITIVE 879 51 2)
  (PRIMITIVE 861 53 0)
  (PRIMITIVE 862 53 2)
  (PRIMITIVE 863 53 4)
  (PRIMITIVE 864 53 6)
  (PRIMITIVE 1147 52 0)
  (PRIMITIVE 1148 52 1)
  (PRIMITIVE 1149 52 2)
  (PRIMITIVE 1150 52 3)
  (PRIMITIVE 1151 52 4)
  (PRIMITIVE 1152 52 5)
  (PRIMITIVE 876 49 30)
  (PRIMITIVE 877 49 31)
  (SETF (SLOT (AREF HASH 6517) RH) 877)
  (SETF (AREF EQTB 6517) (AREF EQTB CUR-VAL))
  (PRIMITIVE 1171 93 1)
  (PRIMITIVE 1172 93 2)
  (PRIMITIVE 1173 93 4)
  (PRIMITIVE 1174 97 0)
  (PRIMITIVE 1175 97 1)
  (PRIMITIVE 1176 97 2)
  (PRIMITIVE 1177 97 3)
  (PRIMITIVE 1191 94 0)
  (PRIMITIVE 1192 94 1)
  (PRIMITIVE 1193 95 0)
  (PRIMITIVE 1194 95 1)
  (PRIMITIVE 1195 95 2)
  (PRIMITIVE 1196 95 3)
  (PRIMITIVE 1197 95 4)
  (PRIMITIVE 1198 95 5)
  (PRIMITIVE 1199 95 6)
  (PRIMITIVE 415 85 7883)
  (PRIMITIVE 419 85 8907)
  (PRIMITIVE 416 85 8139)
  (PRIMITIVE 417 85 8395)
  (PRIMITIVE 418 85 8651)
  (PRIMITIVE 477 85 9474)
  (PRIMITIVE 412 86 7835)
  (PRIMITIVE 413 86 7851)
  (PRIMITIVE 414 86 7867)
  (PRIMITIVE 941 99 0)
  (PRIMITIVE 953 99 1)
  (PRIMITIVE 1217 78 0)
  (PRIMITIVE 1218 78 1)
  (PRIMITIVE 274 100 0)
  (PRIMITIVE 275 100 1)
  (PRIMITIVE 276 100 2)
  (PRIMITIVE 1227 100 3)
  (PRIMITIVE 1228 60 1)
  (PRIMITIVE 1229 60 0)
  (PRIMITIVE 1230 58 0)
  (PRIMITIVE 1231 58 1)
  (PRIMITIVE 1237 57 8139)
  (PRIMITIVE 1238 57 8395)
  (PRIMITIVE 1239 19 0)
  (PRIMITIVE 1240 19 1)
  (PRIMITIVE 1241 19 2)
  (PRIMITIVE 1242 19 3)
  (PRIMITIVE 1285 59 0)
  (PRIMITIVE 594 59 1)
  (SETF WRITE-LOC CUR-VAL)
  (PRIMITIVE 1286 59 2)
  (PRIMITIVE 1287 59 3)
  (PRIMITIVE 1288 59 4)
  (PRIMITIVE 1289 59 5)
  (SETF NO-NEW-CONTROL-SEQUENCE TRUE))


(PROGRAM TEX ()
  (SETF HISTORY 3)
  (REWRITE TERM-OUT "TTY:" "/O")
  (WHEN (= READY-ALREADY 314159) (GOTO $L.1))
  (SETF BAD 0)
  (WHEN (OR (< HALF-ERROR-LINE 30) (> HALF-ERROR-LINE (- ERROR-LINE 15))) (SETF BAD 1))
  (WHEN (< MAX-PRINT-LINE 60) (SETF BAD 2))
  (WHEN (/= (MOD DVI-BUF-SIZE 8) 0) (SETF BAD 3))
  (WHEN (> 1100 60000) (SETF BAD 4))
  (WHEN (> 1777 6000) (SETF BAD 5))
  (WHEN (>= MAX-IN-OPEN 128) (SETF BAD 6))
  (WHEN (< 60000 267) (SETF BAD 7))
  (WHEN (OR (/= MEM-MIN 0) (/= MEM-MAX 60000)) (SETF BAD 10))
  (WHEN (OR (> MEM-MIN 0) (< MEM-MAX 60000)) (SETF BAD 10))
  (WHEN (OR (> 0 0) (< 255 127)) (SETF BAD 11))
  (WHEN (OR (> 0 0) (< 65535 32767)) (SETF BAD 12))
  (WHEN (OR (< 0 0) (> 255 65535)) (SETF BAD 13))
  (WHEN (OR (OR (< MEM-MIN 0) (>= MEM-MAX 65535)) (> (- (- 0) MEM-MIN) 65536))
    (SETF BAD 14))
  (WHEN (OR (< 0 0) (> FONT-MAX 255)) (SETF BAD 15))
  (WHEN (> FONT-MAX 256) (SETF BAD 16))
  (WHEN (OR (> SAVE-SIZE 65535) (> MAX-STRINGS 65535)) (SETF BAD 17))
  (WHEN (> BUF-SIZE 65535) (SETF BAD 18))
  (WHEN (< 255 255) (SETF BAD 19))
  (WHEN (> 10876 65535) (SETF BAD 21))
  (WHEN (> 20 FILE-NAME-SIZE) (SETF BAD 31))
  (WHEN (< (* 2 65535) (- 60000 MEM-MIN)) (SETF BAD 41))
  (WHEN (> BAD 0)
    (WRITELN TERM-OUT
             "Ouch---my internal constants have been clobbered!"
             "---case "
             (:COLON BAD 1))
    (GOTO $L.9999))
  (INITIALIZE)
  (UNLESS GET-STRINGS-STARTED (GOTO $L.9999))
  (INIT-PRIM)
  (SETF INIT-STR-PTR STR-PTR)
  (SETF INIT-POOL-PTR POOL-PTR)
  (FIX-DATE-AND-TIME)
  (SETF READY-ALREADY 314159)
  $L.1
  (SETF SELECTOR 17)
  (SETF TALLY 0)
  (SETF TERM-OFFSET 0)
  (SETF FILE-OFFSET 0)
  (WRITE TERM-OUT "This is TeX, Version 3.141592653")
  (COND ((= FORMAT-IDENT 0) (WRITELN TERM-OUT " (no format preloaded)"))
        (TRUE (SLOW-PRINT FORMAT-IDENT) (PRINT-LN)))
  (BREAK TERM-OUT)
  (SETF JOB-NAME 0)
  (SETF NAME-IN-PROGRESS FALSE)
  (SETF LOG-OPENED FALSE)
  (SETF OUTPUT-FILE-NAME 0)
  (SETF INPUT-PTR 0)
  (SETF MAX-IN-STACK 0)
  (SETF IN-OPEN 0)
  (SETF OPEN-PARENS 0)
  (SETF MAX-BUF-STACK 0)
  (SETF PARAM-PTR 0)
  (SETF MAX-PARAM-STACK 0)
  (SETF FIRST BUF-SIZE)
  (REPEAT (SETF (AREF BUFFER FIRST) 0) (DECF FIRST 1) (UNTIL (= FIRST 0)))
  (SETF SCANNER-STATUS 0)
  (SETF WARNING-INDEX 0)
  (SETF FIRST 1)
  (SETF (SLOT CUR-INPUT STATE-FIELD) 33)
  (SETF (SLOT CUR-INPUT START-FIELD) 1)
  (SETF (SLOT CUR-INPUT INDEX-FIELD) 0)
  (SETF LINE 0)
  (SETF (SLOT CUR-INPUT NAME-FIELD) 0)
  (SETF FORCE-EOF FALSE)
  (SETF ALIGN-STATE 1000000)
  (UNLESS INIT-TERMINAL (GOTO $L.9999))
  (SETF (SLOT CUR-INPUT LIMIT-FIELD) LAST)
  (SETF FIRST (+ LAST 1))
  (WHEN (OR (= FORMAT-IDENT 0) (= (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)) 38))
    (WHEN (/= FORMAT-IDENT 0) (INITIALIZE))
    (UNLESS OPEN-FMT-FILE (GOTO $L.9999))
    (UNLESS LOAD-FMT-FILE (W-CLOSE FMT-FILE) (GOTO $L.9999))
    (W-CLOSE FMT-FILE)
    (WHILE (AND (< (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
                (= (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD)) 32))
      (SETF (SLOT CUR-INPUT LOC-FIELD) (+ (SLOT CUR-INPUT LOC-FIELD) 1))))
  (COND ((OR (< (SLOT (AREF EQTB 9211) INT) 0) (> (SLOT (AREF EQTB 9211) INT) 255))
         (SETF (SLOT CUR-INPUT LIMIT-FIELD) (- (SLOT CUR-INPUT LIMIT-FIELD) 1)))
        (TRUE
         (SETF (AREF BUFFER (SLOT CUR-INPUT LIMIT-FIELD)) (SLOT (AREF EQTB 9211) INT))))
  (FIX-DATE-AND-TIME)
  (SETF MAGIC-OFFSET (- (AREF STR-START 892) (* 9 16)))
  (COND ((= INTERACTION 0) (SETF SELECTOR 16)) (TRUE (SETF SELECTOR 17)))
  (WHEN (AND (< (SLOT CUR-INPUT LOC-FIELD) (SLOT CUR-INPUT LIMIT-FIELD))
             (/= (SLOT (SLOT (AREF EQTB
                                   (+ 7883 (AREF BUFFER (SLOT CUR-INPUT LOC-FIELD))))
                             HH)
                       RH)
                 0))
    (START-INPUT))
  (SETF HISTORY 0)
  (MAIN-CONTROL)
  (FINAL-CLEANUP)
  $L.9998
  (CLOSE-FILES-AND-TERMINATE)
  $L.9999
  (SETF READY-ALREADY 0))