-
Notifications
You must be signed in to change notification settings - Fork 0
/
boot-common.lisp
469 lines (469 loc) · 109 KB
/
boot-common.lisp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
; Generated by 'makefiles/boot-common.lisp'.
(declaim #+sbcl(sb-ext:muffle-conditions compiler-note style-warning))
(proclaim '(optimize (speed 3) (space 0) (safety 1) (debug 0)))
(DEFPACKAGE "TRE-CORE" (:EXPORT "*LOAD*" "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "&REST" "&BODY" "&OPTIONAL" "&KEY" "BACKQUOTE" "QUASIQUOTE" "QUASIQUOTE-SPLICE" "BRACKETS" "BRACES" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "TAN" "ASIN" "ACOS" "ATAN" "EXP" "ROUND" "FLOOR" "CEILING" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT" "POW" "LOG" "CHARACTER>" "CHARACTER<" "CHARACTER==" "NUMBER>" "NUMBER<" "NUMBER/" "NUMBER*" "NUMBER-" "NUMBER+" "NUMBER==" "%/" "%*" ">=" "<=" ">" "<" "==" "/" "*" "-" "%CODE-CHAR" "INTEGER" "CHARACTER?" "NUMBER?" "ARRAY?" "STRING?" "FUNCTION?" "SYMBOL?" "CONS?" "MILLISECONDS-SINCE-1970" "UNIX-SH-RM" "UNIX-SH-MKDIR" "UNIX-SH-CP" "SH" "ARGUMENTS" "GETENV" "EXPORT" "FIND-SYMBOL" "=-SYMBOL-FUNCTION" "SYMBOL-PACKAGE" "SYMBOL-FUNCTION" "SYMBOL-VALUE" "SYMBOL-NAME" "MAKE-SYMBOL" "CHAR" "%ELT-STRING" "LIST-STRING" "STRING==" "STRING" "STRING-CONCAT" "EQL" "EQ" "NOT" "<<" ">>" "BIT-XOR" "BIT-OR" "BIT-AND" "CODE-CHAR" "QUIT" "MACROEXPAND" "MACROEXPAND-1" "%%MACRO?" "%%MACROCALL" "MACRO?" "LOAD" "APPEND" "MAPCAN" "FILTER" "%START-CORE" "SYS-IMAGE-CREATE" "HASHKEYS" "COPY-HASH-TABLE" "HREMOVE" "=-HREF" "HREF" "HASH-TABLE?" "MAKE-HASH-TABLE" "FUNCTION-BYTECODE" "=-FUNCTION-SOURCE" "FUNCTION-SOURCE" "DIRECTORY" "FILE-EXISTS?" "%READ-CHAR" "%FCLOSE" "%FOPEN" "%FORCE-OUTPUT" "%PRINC" "EVAL" "BREAK" "ENV-LOAD" "=-AREF" "MAKE-ARRAY" "BUILTIN?" "%FN-QUIET" "%FN" "%DEFVAR" "%DEFMACRO" "?" "*UNIVERSE*" "*VARIABLES*" "*FUNCTIONS*" "*ENVIRONMENT-PATH*" "*ENVIRONMENT-FILENAMES*" "*MACROEXPAND*" "*QUASIQUOTE-EXPAND*" "*DOT-EXPAND*" "*PACKAGE*" "*KEYWORD-PACKAGE*" "*POINTER-SIZE*" "*LAUNCHFILE*" "*ASSERT?*" "*TARGETS*" "*ENDIANESS*" "*CPU-TYPE*" "*LIBC-PATH*" "*RAND-MAX*" "*EVAL*" "CONS?" "SYMBOL?" "FUNCTION?" "STRING?" "ARRAY?" "NUMBER?" "CHARACTER?" "INTEGER" "%CODE-CHAR" "-" "*" "/" "==" "<" ">" "<=" ">=" "%*" "%/" "NUMBER==" "NUMBER+" "NUMBER-" "NUMBER*" "NUMBER/" "NUMBER<" "NUMBER>" "CHARACTER==" "CHARACTER<" "CHARACTER>" "LOG" "POW") (:IMPORT-FROM "CL" "NIL" "T" "SETQ" "COND" "PROGN" "BLOCK" "RETURN-FROM" "TAGBODY" "GO" "LABELS" "QUOTE" "FUNCTION" "LAMBDA" "&REST" "&BODY" "&OPTIONAL" "&KEY" "APPLY" "CONS" "CAR" "CDR" "RPLACA" "RPLACD" "LENGTH" "MAKE-STRING" "MOD" "SQRT" "SIN" "COS" "TAN" "ASIN" "ACOS" "ATAN" "EXP" "ROUND" "FLOOR" "CEILING" "AREF" "CHAR-CODE" "MAKE-PACKAGE" "PACKAGE-NAME" "FIND-PACKAGE" "PRINT") (:IMPORT-FROM "SB-EXT" "*POSIX-ARGV*"))
(DEFPACKAGE "TRE" (:USE "TRE-CORE"))
(CL:DEFPACKAGE "GLOBAL")
(CL:IN-PACKAGE :TRE-CORE)
"Section CL-CORE"
(CL:DEFVAR *UNIVERSE*)
(CL:DEFVAR *VARIABLES*)
(CL:DEFVAR *LAUNCHFILE*)
(CL:DEFVAR *POINTER-SIZE*)
(CL:DEFVAR *ASSERT?*)
(CL:DEFVAR *ENDIANESS*)
(CL:DEFVAR *CPU-TYPE*)
(CL:DEFVAR *LIBC-PATH*)
(CL:DEFVAR *RAND-MAX*)
(CL:DEFVAR *PRINT-DEFINITIONS?*)
(CL:DEFVAR *DEFAULT-STREAM-TABSIZE*)
(CL:DEFVAR *QUASIQUOTE-EXPAND*)
(CL:DEFVAR *DOT-EXPAND*)
(CL:DEFVAR *ARGV*)
(CL:DEFVAR *BUILTIN-ATOMS* (CL:MAKE-HASH-TABLE :TEST (CL:FUNCTION CL:EQ)))
(CL:PROGN (CL:DEFUN BUILTIN? (X) (CL:LABELS ((~G843 (~G798) (CL:COND (~G798 ~G798) (T (CL:MEMBER X +CL-FUNCTION-IMPORTS+))))) (~G843 (CL:GETHASH X *BUILTIN-ATOMS*)))) (CL:SETF (CL:GETHASH 'BUILTIN? *BUILTIN-ATOMS*) (CL:FUNCTION BUILTIN?)))
(CL:PROGN (CL:DEFUN MAKE-ARRAY (CL:&OPTIONAL (DIMENSIONS 1)) (CL:MAKE-ARRAY DIMENSIONS)) (CL:SETF (CL:GETHASH 'MAKE-ARRAY *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-ARRAY)))
(CL:PROGN (CL:DEFUN =-AREF (V X I) (CL:SETF (CL:AREF X I) V)) (CL:SETF (CL:GETHASH '=-AREF *BUILTIN-ATOMS*) (CL:FUNCTION =-AREF)))
(CL:DEFVAR *ENVIRONMENT-PATH*)
(CL:DEFVAR *ENVIRONMENT-FILENAMES*)
(CL:PROGN (CL:DEFUN ENV-LOAD (FILE-SPECIFIER CL:&REST TARGETS) (PRINT-DEFINITION `(ENV-LOAD ,FILE-SPECIFIER ,@TARGETS)) (CL:PROGN (CL:SETQ *ENVIRONMENT-FILENAMES* (ACONS FILE-SPECIFIER TARGETS *ENVIRONMENT-FILENAMES*))) (CL:COND ((CL:LABELS ((~G844 (~G799) (CL:COND (~G799 ~G799) (T (MEMBER :CL TARGETS))))) (~G844 (NOT TARGETS))) (CL:PROGN (LOAD (+ *ENVIRONMENT-PATH* "/environment/" FILE-SPECIFIER)))))) (CL:SETF (CL:GETHASH 'ENV-LOAD *BUILTIN-ATOMS*) (CL:FUNCTION ENV-LOAD)))
(CL:DEFUN MAKE-SCOPING-FUNCTION (X) (CL:LABELS ((~G845 (G) `(CL:LABELS ((,G ,@(MAKE-LAMBDAS (CADR (CL:CAR X))))) (,G ,@(MAKE-LAMBDAS (CL:CDR X)))))) (~G845 (GENSYM))))
(CL:DEFUN MAKE-ANONYMOUS-FUNCTION (X) (CL:LABELS ((~G846 (!) (CL:COND ((EQUAL ! '(NIL)) `(CL:LAMBDA NIL NIL)) (T `(CL:LAMBDA ,@!))))) (~G846 (MAKE-LAMBDAS (CL:CAR (CL:CDR X))))))
(CL:DEFUN LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? (X) (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:FUNCTION (CL:CAR X)) (CL:COND ((NOT (ATOM (CL:CAR (CL:CDR X)))) (NOT (EQ 'CL:LAMBDA (CL:CAR (CL:CAR (CL:CDR X))))))))))))
(CL:DEFUN MAKE-LAMBDAS (X) (CL:COND ((EQ 'CL:&BODY X) 'CL:&REST) ((ATOM X) X) ((EQ 'CL:QUOTE (CL:CAR X)) X) ((LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? (CL:CAR X)) (MAKE-SCOPING-FUNCTION X)) ((LAMBDA-EXPR-W/O-LAMBDA-KEYWORD? X) (MAKE-ANONYMOUS-FUNCTION X)) (T (DYNAMIC-MAP (CL:FUNCTION MAKE-LAMBDAS) X))))
(CL:PROGN (CL:DEFUN BREAK (CL:&OPTIONAL (MSG NIL)) (CL:BREAK MSG)) (CL:SETF (CL:GETHASH 'BREAK *BUILTIN-ATOMS*) (CL:FUNCTION BREAK)))
(CL:DEFUN TRE2CL (X) (MAKE-LAMBDAS (QUOTE-EXPAND (SPECIALEXPAND (QUOTE-EXPAND X)))))
(CL:DEFVAR *EVAL*)
(CL:PROGN (CL:DEFUN EVAL (X) (CL:EVAL (CL:PROGN (CL:SETQ *EVAL* (TRE2CL X))))) (CL:SETF (CL:GETHASH 'EVAL *BUILTIN-ATOMS*) (CL:FUNCTION EVAL)))
(CL:PROGN (CL:DEFUN %PRINC (X STREAM) (CL:LABELS ((~G847 (!) (CL:COND ((CHARACTER? X) (CL:WRITE-BYTE (CL:CHAR-CODE X) !)) ((STRING? X) (CL:LABELS ((~G848 (~G805) (CL:COND (~G805 (CL:PROGN (CL:LABELS ((~G849 (~G807) (CL:COND ((< ~G807 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G807))) (CL:BLOCK NIL (CL:LABELS ((~G850 (~G806) (CL:TAGBODY ~G808 (CL:COND ((== ~G806 ~G807) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G851 (I) (%PRINC I !))) (~G851 (ELT ~G805 ~G806))) (CL:SETQ ~G806 (NUMBER+ 1 ~G806)) (CL:GO ~G808)))) (~G850 0))))) (~G849 (INTEGER (CL:LENGTH ~G805))))))))) (~G848 X))) (T (CL:PRINC X !))))) (~G847 (CL:LABELS ((~G852 (~G804) (CL:COND (~G804 ~G804) (T CL:*STANDARD-OUTPUT*)))) (~G852 STREAM))))) (CL:SETF (CL:GETHASH '%PRINC *BUILTIN-ATOMS*) (CL:FUNCTION %PRINC)))
(CL:PROGN (CL:DEFUN %FORCE-OUTPUT (STREAM) (CL:FORCE-OUTPUT STREAM)) (CL:SETF (CL:GETHASH '%FORCE-OUTPUT *BUILTIN-ATOMS*) (CL:FUNCTION %FORCE-OUTPUT)))
(CL:PROGN (CL:DEFUN %FOPEN (FILE-SPECIFIER MODE) (CL:OPEN FILE-SPECIFIER :DIRECTION (CL:COND ((CL:FIND #\w MODE :TEST (CL:FUNCTION CL:EQUAL)) :OUTPUT) (T :INPUT)) :IF-EXISTS :SUPERSEDE :ELEMENT-TYPE '(CL:UNSIGNED-BYTE 8))) (CL:SETF (CL:GETHASH '%FOPEN *BUILTIN-ATOMS*) (CL:FUNCTION %FOPEN)))
(CL:PROGN (CL:DEFUN %FCLOSE (STREAM) (CL:CLOSE STREAM)) (CL:SETF (CL:GETHASH '%FCLOSE *BUILTIN-ATOMS*) (CL:FUNCTION %FCLOSE)))
(CL:PROGN (CL:DEFUN %READ-CHAR (STR) (CL:LABELS ((~G853 (!) (CL:COND ((NOT (EQ ! 'EOF)) (CL:PROGN (CL:CODE-CHAR !)))))) (~G853 (CL:READ-BYTE (CL:LABELS ((~G854 (~G809) (CL:COND (~G809 ~G809) (T CL:*STANDARD-INPUT*)))) (~G854 STR)) NIL 'EOF)))) (CL:SETF (CL:GETHASH '%READ-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %READ-CHAR)))
(CL:PROGN (CL:DEFUN FILE-EXISTS? (FILE-SPECIFIER) (CL:COND ((CL:PROBE-FILE FILE-SPECIFIER) T))) (CL:SETF (CL:GETHASH 'FILE-EXISTS? *BUILTIN-ATOMS*) (CL:FUNCTION FILE-EXISTS?)))
(CL:PROGN (CL:DEFUN DIRECTORY (FILE-SPECIFIER) (CL:DIRECTORY (+ FILE-SPECIFIER "*.*"))) (CL:SETF (CL:GETHASH 'DIRECTORY *BUILTIN-ATOMS*) (CL:FUNCTION DIRECTORY)))
(CL:DEFVAR *FUNCTIONS*)
(CL:PROGN (CL:DEFUN FUNCTION-SOURCE (X) (CL:CDR (CL:ASSOC X *FUNCTIONS* :TEST (CL:FUNCTION CL:EQ)))) (CL:SETF (CL:GETHASH 'FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-SOURCE)))
(CL:PROGN (CL:DEFUN =-FUNCTION-SOURCE (V X) (ERROR "Can't set function source in the Common Lisp core.")) (CL:SETF (CL:GETHASH '=-FUNCTION-SOURCE *BUILTIN-ATOMS*) (CL:FUNCTION =-FUNCTION-SOURCE)))
(CL:PROGN (CL:DEFUN FUNCTION-BYTECODE (X) X NIL) (CL:SETF (CL:GETHASH 'FUNCTION-BYTECODE *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION-BYTECODE)))
(CL:PROGN (CL:DEFUN MAKE-HASH-TABLE (CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:MAKE-HASH-TABLE :TEST (CL:COND ((CL:EQ TEST (CL:FUNCTION EQ)) (CL:FUNCTION CL:EQ)) ((CL:LABELS ((~G855 (~G810) (CL:COND (~G810 ~G810) (T (CL:EQ TEST (CL:FUNCTION ==)))))) (~G855 (CL:EQ TEST (CL:FUNCTION EQL)))) (CL:FUNCTION CL:EQL)) ((CL:EQ TEST (CL:FUNCTION STRING==)) (CL:FUNCTION CL:EQUAL)) (T TEST)))) (CL:SETF (CL:GETHASH 'MAKE-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-HASH-TABLE)))
(CL:PROGN (CL:DEFUN HASH-TABLE? (X) (CL:HASH-TABLE-P X)) (CL:SETF (CL:GETHASH 'HASH-TABLE? *BUILTIN-ATOMS*) (CL:FUNCTION HASH-TABLE?)))
(CL:PROGN (CL:DEFUN HREF (X I) (CL:GETHASH I X)) (CL:SETF (CL:GETHASH 'HREF *BUILTIN-ATOMS*) (CL:FUNCTION HREF)))
(CL:PROGN (CL:DEFUN =-HREF (V X I) (CL:SETF (CL:GETHASH I X) V)) (CL:SETF (CL:GETHASH '=-HREF *BUILTIN-ATOMS*) (CL:FUNCTION =-HREF)))
(CL:PROGN (CL:DEFUN HREMOVE (X K) (CL:REMHASH K X)) (CL:SETF (CL:GETHASH 'HREMOVE *BUILTIN-ATOMS*) (CL:FUNCTION HREMOVE)))
(CL:PROGN (CL:DEFUN COPY-HASH-TABLE (X) (CL:LABELS ((~G856 (!) (CL:MAPHASH (CL:LAMBDA (K V) (CL:SETF (CL:GETHASH K !) V)) X) !)) (~G856 (CL:MAKE-HASH-TABLE :TEST (CL:HASH-TABLE-TEST X) :SIZE (CL:HASH-TABLE-SIZE X))))) (CL:SETF (CL:GETHASH 'COPY-HASH-TABLE *BUILTIN-ATOMS*) (CL:FUNCTION COPY-HASH-TABLE)))
(CL:PROGN (CL:DEFUN HASHKEYS (X) (CL:LABELS ((~G857 (!) (CL:MAPHASH (CL:LAMBDA (K V) V (CL:PUSH K !)) X) !)) (~G857 NIL))) (CL:SETF (CL:GETHASH 'HASHKEYS *BUILTIN-ATOMS*) (CL:FUNCTION HASHKEYS)))
(CL:PROGN (CL:DEFUN SYS-IMAGE-CREATE (FILE-SPECIFIER FUN) (SB-EXT:SAVE-LISP-AND-DIE FILE-SPECIFIER :TOPLEVEL (CL:LAMBDA NIL (CL:FUNCALL FUN)))) (CL:SETF (CL:GETHASH 'SYS-IMAGE-CREATE *BUILTIN-ATOMS*) (CL:FUNCTION SYS-IMAGE-CREATE)))
(CL:PROGN (CL:DEFUN %START-CORE NIL (CL:USE-PACKAGE :TRE) (CL:SETQ *LAUNCHFILE* (CADR (CL:LABELS ((~G858 (~G811) (CL:COND (~G811 ~G811) (T NIL)))) (~G858 SB-EXT:*POSIX-ARGV*))))) (CL:SETF (CL:GETHASH '%START-CORE *BUILTIN-ATOMS*) (CL:FUNCTION %START-CORE)))
(CL:PROGN (CL:DEFUN FILTER (FUN X) (CL:MAPCAR FUN X)) (CL:SETF (CL:GETHASH 'FILTER *BUILTIN-ATOMS*) (CL:FUNCTION FILTER)))
(CL:PROGN (CL:DEFUN MAPCAN (FUN X) (CL:MAPCAN FUN X)) (CL:SETF (CL:GETHASH 'MAPCAN *BUILTIN-ATOMS*) (CL:FUNCTION MAPCAN)))
(CL:PROGN (CL:DEFUN APPEND (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:NCONC) (CL:MAPCAR (CL:FUNCTION CL:COPY-LIST) X))) (CL:SETF (CL:GETHASH 'APPEND *BUILTIN-ATOMS*) (CL:FUNCTION APPEND)))
(CL:DEFUN %LOAD-R (S) (CL:COND ((PEEK-CHAR S) (CL:PROGN (CL:CONS (READ S) (%LOAD-R S))))))
(CL:DEFUN %EXPAND (X) (CL:LABELS ((~G859 (!) (CL:COND ((EQUAL X !) X) (T (%EXPAND !))))) (~G859 (QUASIQUOTE-EXPAND (MACROEXPAND (DOT-EXPAND X))))))
(CL:DEFVAR *LOAD*)
(CL:PROGN (CL:DEFUN LOAD (FILE-SPECIFIER) (PRINT-DEFINITION `(LOAD ,FILE-SPECIFIER)) (CL:LABELS ((~G860 (~G812) (CL:PROGN (CL:SETQ *LOAD* FILE-SPECIFIER)) (CL:LABELS ((~G861 (~G813) (CL:PROGN (CL:SETQ *LOAD* ~G812)) ~G813)) (~G861 (CL:PROGN (CL:BLOCK NIL (CL:LABELS ((~G862 (~G817) (CL:LABELS ((~G863 (I) (CL:TAGBODY ~G815 (CL:COND ((NOT ~G817) (CL:GO ~G816))) (CL:SETQ I (CL:CAR ~G817)) (EVAL (%EXPAND I)) (CL:SETQ ~G817 (CL:CDR ~G817)) (CL:GO ~G815) ~G816 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G863 NIL)))) (~G862 (CL:LABELS ((~G864 (S) (CL:LABELS ((~G865 (~G814) (CLOSE S) ~G814)) (~G865 (CL:BLOCK NIL (%LOAD-R S)))))) (~G864 (OPEN FILE-SPECIFIER :DIRECTION 'INPUT))))))))))) (~G860 *LOAD*))) (CL:SETF (CL:GETHASH 'LOAD *BUILTIN-ATOMS*) (CL:FUNCTION LOAD)))
(CL:DEFUN ENV-MACROS NIL (SYMBOL-VALUE (TRE-SYMBOL '*MACROS*)))
(CL:PROGN (CL:DEFUN MACRO? (X) (CL:RASSOC X (ENV-MACROS) :TEST (CL:FUNCTION EQ))) (CL:SETF (CL:GETHASH 'MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION MACRO?)))
(CL:PROGN (CL:DEFUN %%MACROCALL (X) (CL:LABELS ((~G866 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR (CL:CAR !)) (CL:CDR X))))) (~G866 (CL:CDR (ASSOC (CL:CAR X) (ENV-MACROS) :TEST (CL:FUNCTION EQ)))))) (CL:SETF (CL:GETHASH '%%MACROCALL *BUILTIN-ATOMS*) (CL:FUNCTION %%MACROCALL)))
(CL:PROGN (CL:DEFUN %%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:LABELS ((~G867 (!) (CL:COND ((CONS? !) (ASSOC (CL:CAR X) ! :TEST (CL:FUNCTION EQ)))))) (~G867 (ENV-MACROS)))))))) (CL:SETF (CL:GETHASH '%%MACRO? *BUILTIN-ATOMS*) (CL:FUNCTION %%MACRO?)))
(CL:DEFVAR *MACROEXPAND*)
(CL:PROGN (CL:DEFUN MACROEXPAND-1 (X) (CL:LABELS ((~G868 (!) (CL:COND (! (CL:APPLY ! (LIST X))) (T X)))) (~G868 (SYMBOL-VALUE (TRE-SYMBOL '*MACROEXPAND*))))) (CL:SETF (CL:GETHASH 'MACROEXPAND-1 *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND-1)))
(CL:PROGN (CL:DEFUN MACROEXPAND (X) (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (MACROEXPAND X))))) (F X (MACROEXPAND-1 X)))) (CL:SETF (CL:GETHASH 'MACROEXPAND *BUILTIN-ATOMS*) (CL:FUNCTION MACROEXPAND)))
(CL:PROGN (CL:DEFUN QUIT (CL:&OPTIONAL EXIT-CODE) (SB-EXT:QUIT :UNIX-STATUS EXIT-CODE)) (CL:SETF (CL:GETHASH 'QUIT *BUILTIN-ATOMS*) (CL:FUNCTION QUIT)))
(CL:PROGN (CL:DEFUN CODE-CHAR (X) (CL:COND ((CL:CHARACTERP X) X) (T (CL:CODE-CHAR X)))) (CL:SETF (CL:GETHASH 'CODE-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION CODE-CHAR)))
(CL:DEFUN BITS-INTEGER (BITS) (CL:REDUCE (CL:LAMBDA (A B) (+ (* A 2) B)) BITS))
(CL:DEFUN NUMBER (X) (CL:COND ((CHARACTER? X) (CL:CHAR-CODE X)) (T X)))
(CL:DEFUN INTEGER-BITS (X) (CL:LABELS ((~G869 (!) (CL:LABELS ((~G870 (L) (CL:LABELS ((~G871 (~G818) (CL:COND ((< ~G818 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G818))) (CL:BLOCK NIL (CL:LABELS ((~G872 (I) (CL:TAGBODY ~G819 (CL:COND ((== I ~G818) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE ! 2) (CL:PROGN (CL:SETQ ! I)) (CL:PUSH R L)) (CL:SETQ I (NUMBER+ 1 I)) (CL:GO ~G819)))) (~G872 0))))) (~G871 (INTEGER 32))) (CL:COERCE L 'CL:BIT-VECTOR))) (~G870 NIL)))) (~G869 (NUMBER X))))
(CL:PROGN (CL:DEFUN BIT-AND (A B) (BITS-INTEGER (CL:BIT-AND (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-AND *BUILTIN-ATOMS*) (CL:FUNCTION BIT-AND)))
(CL:PROGN (CL:DEFUN BIT-OR (A B) (BITS-INTEGER (CL:BIT-IOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-OR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-OR)))
(CL:PROGN (CL:DEFUN BIT-XOR (A B) (BITS-INTEGER (CL:BIT-XOR (INTEGER-BITS A) (INTEGER-BITS B)))) (CL:SETF (CL:GETHASH 'BIT-XOR *BUILTIN-ATOMS*) (CL:FUNCTION BIT-XOR)))
(CL:PROGN (CL:DEFUN >> (X BITS) (CL:LABELS ((~G873 (~G820) (CL:COND ((< ~G820 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G820))) (CL:BLOCK NIL (CL:LABELS ((~G874 (N) (CL:TAGBODY ~G821 (CL:COND ((== N ~G820) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:MULTIPLE-VALUE-BIND (I R) (CL:TRUNCATE X 2) (CL:PROGN (CL:SETQ X I))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G821)))) (~G874 0))))) (~G873 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '>> *BUILTIN-ATOMS*) (CL:FUNCTION >>)))
(CL:PROGN (CL:DEFUN << (X BITS) (CL:LABELS ((~G875 (~G822) (CL:COND ((< ~G822 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G822))) (CL:BLOCK NIL (CL:LABELS ((~G876 (N) (CL:TAGBODY ~G823 (CL:COND ((== N ~G822) (CL:RETURN-FROM NIL (CL:PROGN X)))) (CL:PROGN (CL:SETQ X (* X 2))) (CL:SETQ N (NUMBER+ 1 N)) (CL:GO ~G823)))) (~G876 0))))) (~G875 (INTEGER BITS)))) (CL:SETF (CL:GETHASH '<< *BUILTIN-ATOMS*) (CL:FUNCTION <<)))
(CL:PROGN (CL:DEFUN NOT (CL:&REST X) (CL:EVERY (CL:FUNCTION CL:NOT) X)) (CL:SETF (CL:GETHASH 'NOT *BUILTIN-ATOMS*) (CL:FUNCTION NOT)))
(CL:PROGN (CL:DEFUN EQ (A B) (CL:EQ A B)) (CL:SETF (CL:GETHASH 'EQ *BUILTIN-ATOMS*) (CL:FUNCTION EQ)))
(CL:PROGN (CL:DEFUN EQL (A B) (CL:LABELS ((~G877 (~G824) (CL:COND (~G824 ~G824) (T (CL:COND ((CL:COND ((CL:CHARACTERP A) (CL:CHARACTERP B))) (CL:= (CL:CHAR-CODE A) (CL:CHAR-CODE B))) ((CL:COND ((NOT (CL:CHARACTERP A) (CL:CHARACTERP B)) (CL:COND ((NUMBER? A) (NUMBER? B))))) (CL:= A B)) ((CL:COND ((CL:CONSP A) (CL:CONSP B))) (CL:COND ((EQL (CL:CAR A) (CL:CAR B)) (EQL (CL:CDR A) (CL:CDR B))))) ((CL:COND ((CL:STRINGP A) (CL:STRINGP B))) (CL:STRING= A B))))))) (~G877 (CL:EQ A B)))) (CL:SETF (CL:GETHASH 'EQL *BUILTIN-ATOMS*) (CL:FUNCTION EQL)))
(CL:PROGN (CL:DEFUN STRING-CONCAT (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CONCATENATE) 'CL:STRING X)) (CL:SETF (CL:GETHASH 'STRING-CONCAT *BUILTIN-ATOMS*) (CL:FUNCTION STRING-CONCAT)))
(CL:PROGN (CL:DEFUN STRING (X) (CL:COND ((CL:NUMBERP X) (CL:FORMAT NIL "~A" X)) (T (CL:STRING X)))) (CL:SETF (CL:GETHASH 'STRING *BUILTIN-ATOMS*) (CL:FUNCTION STRING)))
(CL:PROGN (CL:DEFUN STRING== (A B) (CL:STRING= A B)) (CL:SETF (CL:GETHASH 'STRING== *BUILTIN-ATOMS*) (CL:FUNCTION STRING==)))
(CL:PROGN (CL:DEFUN LIST-STRING (X) (CL:LABELS ((~G878 (~G825) (CL:COND (~G825 ~G825) (T (ERROR "List expected instead of ~A." X))))) (~G878 (LIST? X))) (CL:CONCATENATE 'CL:STRING X)) (CL:SETF (CL:GETHASH 'LIST-STRING *BUILTIN-ATOMS*) (CL:FUNCTION LIST-STRING)))
(CL:PROGN (CL:DEFUN %ELT-STRING (OBJ IDX) (CL:ELT OBJ IDX)) (CL:SETF (CL:GETHASH '%ELT-STRING *BUILTIN-ATOMS*) (CL:FUNCTION %ELT-STRING)))
(CL:PROGN (CL:DEFUN CHAR (OBJ IDX) (CL:ELT OBJ IDX)) (CL:SETF (CL:GETHASH 'CHAR *BUILTIN-ATOMS*) (CL:FUNCTION CHAR)))
(CL:DEFVAR *SPECIAL-FORMS*)
(CL:DEFUN SPECIAL-%%MACROCALL (X) (CL:LABELS ((~G879 (!) (CL:APPLY (CL:CDR !) (ARGUMENT-EXPAND-VALUES (CL:CAR X) (CL:CAR !) (CL:CDR X))))) (~G879 (CL:CDR (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ))))))
(CL:DEFUN SPECIAL-%%MACRO? (X) (CL:COND ((CONS? X) (CL:COND ((SYMBOL? (CL:CAR X)) (ASSOC (CL:CAR X) *SPECIAL-FORMS* :TEST (CL:FUNCTION EQ)))))))
(CL:DEFUN SPECIALEXPAND (X) (CL:LABELS ((~G880 (~G826) (CL:PROGN (CL:SETQ *MACRO?* (CL:FUNCTION SPECIAL-%%MACRO?))) (CL:LABELS ((~G881 (~G827) (CL:PROGN (CL:SETQ *MACRO?* ~G826)) ~G827)) (~G881 (CL:PROGN (CL:LABELS ((~G882 (~G828) (CL:PROGN (CL:SETQ *MACROCALL* (CL:FUNCTION SPECIAL-%%MACROCALL))) (CL:LABELS ((~G883 (~G829) (CL:PROGN (CL:SETQ *MACROCALL* ~G828)) ~G829)) (~G883 (CL:PROGN (CL:LABELS ((F (OLD X) (CL:COND ((EQUAL OLD X) X) (T (F X (%MACROEXPAND X)))))) (F X (%MACROEXPAND X)))))))) (~G882 *MACROCALL*))))))) (~G880 *MACRO?*)))
(CL:DEFUN MAKE-%FN-QUIET (NAME ARGS BODY) (CL:COND (ARGS (CL:PROGN (CL:SETQ ARGS (ENSURE-LIST ARGS))))) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',(CL:CONS ARGS BODY)) *FUNCTIONS*) (CL:DEFUN ,NAME ,ARGS ,@BODY)))
(CL:DEFVAR *KEYWORD-PACKAGE*)
(CL:DEFVAR *PACKAGE*)
(CL:PROGN (CL:DEFUN MAKE-SYMBOL (X CL:&OPTIONAL (PACKAGE NIL)) (CL:INTERN X (CL:COND ((CL:NOT PACKAGE) *PACKAGE*) ((CL:PACKAGEP PACKAGE) (CL:PACKAGE-NAME PACKAGE)) ((CL:SYMBOLP PACKAGE) (CL:SYMBOL-NAME PACKAGE)) (T PACKAGE)))) (CL:SETF (CL:GETHASH 'MAKE-SYMBOL *BUILTIN-ATOMS*) (CL:FUNCTION MAKE-SYMBOL)))
(CL:PROGN (CL:DEFUN SYMBOL-NAME (X) (CL:COND ((CL:PACKAGEP X) (CL:PACKAGE-NAME X)) (T (CL:SYMBOL-NAME X)))) (CL:SETF (CL:GETHASH 'SYMBOL-NAME *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-NAME)))
(CL:PROGN (CL:DEFUN SYMBOL-VALUE (X) (CL:COND ((CL:BOUNDP X) (CL:SYMBOL-VALUE X)) (T X))) (CL:SETF (CL:GETHASH 'SYMBOL-VALUE *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-VALUE)))
(CL:PROGN (CL:DEFUN SYMBOL-FUNCTION (X) (CL:COND ((CL:FBOUNDP X) (CL:SYMBOL-FUNCTION X)))) (CL:SETF (CL:GETHASH 'SYMBOL-FUNCTION *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-FUNCTION)))
(CL:PROGN (CL:DEFUN SYMBOL-PACKAGE (X) (CL:SYMBOL-PACKAGE X)) (CL:SETF (CL:GETHASH 'SYMBOL-PACKAGE *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL-PACKAGE)))
(CL:PROGN (CL:DEFUN =-SYMBOL-FUNCTION (V X) (CL:SETF (CL:SYMBOL-FUNCTION X) V)) (CL:SETF (CL:GETHASH '=-SYMBOL-FUNCTION *BUILTIN-ATOMS*) (CL:FUNCTION =-SYMBOL-FUNCTION)))
(CL:PROGN (CL:DEFUN FIND-SYMBOL (X CL:&OPTIONAL (PKG *PACKAGE*)) (CL:FIND-SYMBOL X PKG)) (CL:SETF (CL:GETHASH 'FIND-SYMBOL *BUILTIN-ATOMS*) (CL:FUNCTION FIND-SYMBOL)))
(CL:DEFUN TRE-SYMBOL (X) (CL:INTERN (SYMBOL-NAME X) "TRE"))
(CL:PROGN (CL:DEFUN EXPORT (X CL:&OPTIONAL (PKG *PACKAGE*)) (CL:EXPORT X PKG)) (CL:SETF (CL:GETHASH 'EXPORT *BUILTIN-ATOMS*) (CL:FUNCTION EXPORT)))
(CL:PROGN (CL:DEFUN GETENV (NAME) (SB-EXT:POSIX-GETENV NAME)) (CL:SETF (CL:GETHASH 'GETENV *BUILTIN-ATOMS*) (CL:FUNCTION GETENV)))
(CL:PROGN (CL:DEFUN ARGUMENTS NIL *POSIX-ARGV*) (CL:SETF (CL:GETHASH 'ARGUMENTS *BUILTIN-ATOMS*) (CL:FUNCTION ARGUMENTS)))
(CL:PROGN (CL:DEFUN SH (PROGRAM CL:&REST ARGUMENTS) (SB-EXT:RUN-PROGRAM PROGRAM ARGUMENTS :PTY CL:*STANDARD-OUTPUT*)) (CL:SETF (CL:GETHASH 'SH *BUILTIN-ATOMS*) (CL:FUNCTION SH)))
(CL:PROGN (CL:DEFUN UNIX-SH-CP (FROM TO CL:&KEY (VERBOSE? NIL) (RECURSIVELY? NIL)) (CL:APPLY (CL:FUNCTION SH) "/bin/cp" `(,@(CL:COND (VERBOSE? '("-v"))) ,@(CL:COND (RECURSIVELY? '("-r"))) ,FROM ,TO))) (CL:SETF (CL:GETHASH 'UNIX-SH-CP *BUILTIN-ATOMS*) (CL:FUNCTION UNIX-SH-CP)))
(CL:PROGN (CL:DEFUN UNIX-SH-MKDIR (PATHNAME CL:&KEY (PARENTS NIL)) (CL:APPLY (CL:FUNCTION SH) "/bin/mkdir" `(,@(CL:COND (PARENTS '("-p"))) ,PATHNAME))) (CL:SETF (CL:GETHASH 'UNIX-SH-MKDIR *BUILTIN-ATOMS*) (CL:FUNCTION UNIX-SH-MKDIR)))
(CL:PROGN (CL:DEFUN UNIX-SH-RM (X CL:&KEY (VERBOSE? NIL) (RECURSIVELY? NIL) (FORCE? NIL)) (CL:APPLY (CL:FUNCTION SH) "/bin/rm" `(,@(CL:COND (VERBOSE? '("-v"))) ,@(CL:COND (RECURSIVELY? '("-r"))) ,@(CL:COND (FORCE? '("-f"))) ,X))) (CL:SETF (CL:GETHASH 'UNIX-SH-RM *BUILTIN-ATOMS*) (CL:FUNCTION UNIX-SH-RM)))
(CL:PROGN (CL:DEFUN MILLISECONDS-SINCE-1970 NIL (* 1000 (- (CL:GET-UNIVERSAL-TIME) +UNIX-EPOCH-DIFFERENCE+))) (CL:SETF (CL:GETHASH 'MILLISECONDS-SINCE-1970 *BUILTIN-ATOMS*) (CL:FUNCTION MILLISECONDS-SINCE-1970)))
(CL:PROGN (CL:DEFUN CONS? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CONSP) X)) (CL:SETF (CL:GETHASH 'CONS? *BUILTIN-ATOMS*) (CL:FUNCTION CONS?)))
(CL:PROGN (CL:DEFUN SYMBOL? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:SYMBOLP) X)) (CL:SETF (CL:GETHASH 'SYMBOL? *BUILTIN-ATOMS*) (CL:FUNCTION SYMBOL?)))
(CL:PROGN (CL:DEFUN FUNCTION? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:FUNCTIONP) X)) (CL:SETF (CL:GETHASH 'FUNCTION? *BUILTIN-ATOMS*) (CL:FUNCTION FUNCTION?)))
(CL:PROGN (CL:DEFUN STRING? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:STRINGP) X)) (CL:SETF (CL:GETHASH 'STRING? *BUILTIN-ATOMS*) (CL:FUNCTION STRING?)))
(CL:PROGN (CL:DEFUN ARRAY? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:ARRAYP) X)) (CL:SETF (CL:GETHASH 'ARRAY? *BUILTIN-ATOMS*) (CL:FUNCTION ARRAY?)))
(CL:PROGN (CL:DEFUN NUMBER? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:NUMBERP) X)) (CL:SETF (CL:GETHASH 'NUMBER? *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER?)))
(CL:PROGN (CL:DEFUN CHARACTER? (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CHARACTERP) X)) (CL:SETF (CL:GETHASH 'CHARACTER? *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER?)))
(CL:PROGN (CL:DEFUN INTEGER (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:FLOOR) X)) (CL:SETF (CL:GETHASH 'INTEGER *BUILTIN-ATOMS*) (CL:FUNCTION INTEGER)))
(CL:PROGN (CL:DEFUN %CODE-CHAR (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CODE-CHAR) X)) (CL:SETF (CL:GETHASH '%CODE-CHAR *BUILTIN-ATOMS*) (CL:FUNCTION %CODE-CHAR)))
(CL:PROGN (CL:DEFUN - (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:-) X)) (CL:SETF (CL:GETHASH '- *BUILTIN-ATOMS*) (CL:FUNCTION -)))
(CL:PROGN (CL:DEFUN * (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:*) X)) (CL:SETF (CL:GETHASH '* *BUILTIN-ATOMS*) (CL:FUNCTION *)))
(CL:PROGN (CL:DEFUN / (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:/) X)) (CL:SETF (CL:GETHASH '/ *BUILTIN-ATOMS*) (CL:FUNCTION /)))
(CL:PROGN (CL:DEFUN == (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:=) X)) (CL:SETF (CL:GETHASH '== *BUILTIN-ATOMS*) (CL:FUNCTION ==)))
(CL:PROGN (CL:DEFUN < (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:<) X)) (CL:SETF (CL:GETHASH '< *BUILTIN-ATOMS*) (CL:FUNCTION <)))
(CL:PROGN (CL:DEFUN > (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH '> *BUILTIN-ATOMS*) (CL:FUNCTION >)))
(CL:PROGN (CL:DEFUN <= (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:<=) X)) (CL:SETF (CL:GETHASH '<= *BUILTIN-ATOMS*) (CL:FUNCTION <=)))
(CL:PROGN (CL:DEFUN >= (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>=) X)) (CL:SETF (CL:GETHASH '>= *BUILTIN-ATOMS*) (CL:FUNCTION >=)))
(CL:PROGN (CL:DEFUN %* (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:*) X)) (CL:SETF (CL:GETHASH '%* *BUILTIN-ATOMS*) (CL:FUNCTION %*)))
(CL:PROGN (CL:DEFUN %/ (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:/) X)) (CL:SETF (CL:GETHASH '%/ *BUILTIN-ATOMS*) (CL:FUNCTION %/)))
(CL:PROGN (CL:DEFUN NUMBER== (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:=) X)) (CL:SETF (CL:GETHASH 'NUMBER== *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER==)))
(CL:PROGN (CL:DEFUN NUMBER+ (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:+) X)) (CL:SETF (CL:GETHASH 'NUMBER+ *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER+)))
(CL:PROGN (CL:DEFUN NUMBER- (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:-) X)) (CL:SETF (CL:GETHASH 'NUMBER- *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER-)))
(CL:PROGN (CL:DEFUN NUMBER* (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:*) X)) (CL:SETF (CL:GETHASH 'NUMBER* *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER*)))
(CL:PROGN (CL:DEFUN NUMBER/ (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:/) X)) (CL:SETF (CL:GETHASH 'NUMBER/ *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER/)))
(CL:PROGN (CL:DEFUN NUMBER< (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:<) X)) (CL:SETF (CL:GETHASH 'NUMBER< *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER<)))
(CL:PROGN (CL:DEFUN NUMBER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:>) X)) (CL:SETF (CL:GETHASH 'NUMBER> *BUILTIN-ATOMS*) (CL:FUNCTION NUMBER>)))
(CL:PROGN (CL:DEFUN CHARACTER== (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CHAR=) X)) (CL:SETF (CL:GETHASH 'CHARACTER== *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER==)))
(CL:PROGN (CL:DEFUN CHARACTER< (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CHAR<) X)) (CL:SETF (CL:GETHASH 'CHARACTER< *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER<)))
(CL:PROGN (CL:DEFUN CHARACTER> (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:CHAR>) X)) (CL:SETF (CL:GETHASH 'CHARACTER> *BUILTIN-ATOMS*) (CL:FUNCTION CHARACTER>)))
(CL:PROGN (CL:DEFUN LOG (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:LOG) X)) (CL:SETF (CL:GETHASH 'LOG *BUILTIN-ATOMS*) (CL:FUNCTION LOG)))
(CL:PROGN (CL:DEFUN POW (CL:&REST X) (CL:APPLY (CL:FUNCTION CL:EXPT) X)) (CL:SETF (CL:GETHASH 'POW *BUILTIN-ATOMS*) (CL:FUNCTION POW)))
"Section COMPILED-INITS"
"Section imports"
(CL:DEFVAR *DEFINITION-PRINTER*)
(CL:DEFVAR *PRINT-AUTOMATIC-NEWLINE?*)
(CL:DEFVAR *STANDARD-INPUT*)
(CL:DEFVAR *MACROEXPAND-BACKQUOTE*)
(CL:DEFVAR *MACROCALL*)
(CL:DEFVAR *MACRO?*)
(CL:DEFVAR +CL-FUNCTION-IMPORTS+)
(CL:DEFVAR *VALUES-MAGIC*)
(CL:DEFVAR *STANDARD-OUTPUT*)
(CL:DEFVAR *COMPILER-MACRO-EXPANDER*)
(CL:DEFVAR *GENSYM-COUNTER*)
(CL:DEFVAR *TAGBODY-REPLACEMENTS*)
(CL:DEFVAR *EXPANDER-DUMP?*)
(CL:DEFVAR *PRINTER-ABBREVIATIONS*)
(CL:DEFVAR *TYPES*)
(CL:DEFVAR *ALWAYS-PRINT-PACKAGE-NAMES?*)
(CL:DEFVAR *INVISIBLE-PACKAGE-NAMES*)
(CL:DEFVAR *PRINTER-ARGUMENT-DEFINITIONS*)
(CL:DEFUN %GET-PRINTER-ARGUMENT-DEFINITION (X) (CL:BLOCK %GET-PRINTER-ARGUMENT-DEFINITION (CL:BLOCK NIL (HREF *PRINTER-ARGUMENT-DEFINITIONS* X))))
(CL:DEFUN %PRINT-GAP (STR) (CL:BLOCK %PRINT-GAP (CL:BLOCK NIL (CL:LABELS ((~G884 (~G198) (CL:COND (~G198 ~G198) (T (PRINC " " STR))))) (~G884 (FRESH-LINE? STR))))))
(CL:DEFUN DIGIT-NUMBER (X) (CL:BLOCK DIGIT-NUMBER (CL:BLOCK NIL (- (CL:CHAR-CODE X) (CL:CHAR-CODE #\0)))))
(CL:DEFUN %NONDECIMAL-DIGIT? (X START BASE) (CL:BLOCK %NONDECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? X START (CODE-CHAR (+ (CL:CHAR-CODE START) (- BASE 10)))))))
(CL:DEFUN ABS (X) (CL:BLOCK ABS (CL:BLOCK NIL (CL:COND ((< X 0) (- X)) (T X)))))
(CL:DEFUN INVISIBLE-PACKAGE? (X) (CL:BLOCK INVISIBLE-PACKAGE? (CL:BLOCK NIL (CL:LABELS ((~G885 (!) (SOME (CL:LAMBDA (_) (CL:BLOCK NIL (STRING== ! _))) *INVISIBLE-PACKAGE-NAMES*))) (~G885 (CL:PACKAGE-NAME X))))))
(CL:DEFUN ABBREVIATED-PACKAGE-NAME (X) (CL:BLOCK ABBREVIATED-PACKAGE-NAME (CL:BLOCK NIL (CL:COND ((STRING== "COMMON-LISP" X) "CL") (T X)))))
(CL:DEFUN %PRINT-ESCAPED-SYMBOL (X STR) (CL:BLOCK %PRINT-ESCAPED-SYMBOL (CL:BLOCK NIL (PRINC #\| STR) (CL:BLOCK NIL (CL:LABELS ((~G886 (~G218) (CL:LABELS ((~G887 (I) (CL:TAGBODY ~G216 (CL:COND ((NOT ~G218) (CL:GO ~G217))) (CL:SETQ I (CL:CAR ~G218)) (CL:COND ((EQL I #\|) (PRINC "\\|" STR)) (T (PRINC I STR))) (CL:SETQ ~G218 (CL:CDR ~G218)) (CL:GO ~G216) ~G217 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G887 NIL)))) (~G886 (STRING-LIST X)))) (PRINC #\| STR))))
(CL:DEFUN SYMBOL-CHAR-NEEDS-ESCAPING? (X) (CL:BLOCK SYMBOL-CHAR-NEEDS-ESCAPING? (CL:BLOCK NIL (CL:LABELS ((~G888 (~G219) (CL:COND (~G219 ~G219) (T (LOWER-CASE? X))))) (~G888 (EQL #\| X))))))
(CL:DEFUN %PRINT-REST (X STR INFO) (CL:BLOCK %PRINT-REST (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:COND ((CONS? X) (CL:PROGN (%PRINT-GAP STR) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO))) (T (CL:PROGN (PRINC " . " STR) (%LATE-PRINT X STR INFO))))))))))
(CL:DEFUN %PRINT-CALL (X ARGDEF STR INFO) (CL:BLOCK %PRINT-CALL (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (CL:LABELS ((~G889 (EXPANDED) (CL:COND ((EQ EXPANDED 'ERROR) (%PRINT-REST (CL:CDR X) STR INFO)) (T (CL:BLOCK NIL (CL:LABELS ((~G890 (~G211) (CL:LABELS ((~G891 (I) (CL:TAGBODY ~G209 (CL:COND ((NOT ~G211) (CL:GO ~G210))) (CL:SETQ I (CL:CAR ~G211)) (%PRINT-GAP STR) (CL:COND ((CL:COND ((%BODY? (CL:CDR I)) (CL:CDR (CL:CDR I)))) (CL:PROGN (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (FRESH-LINE STR))) (%PRINT-BODY (CL:CDR (CL:CDR I)) STR INFO))) ((%REST? (CL:CDR I)) (%PRINT-REST (CL:CDR (CL:CDR I)) STR INFO)) ((%KEY? (CL:CDR I)) (CL:PROGN (%PRINT-SYMBOL (MAKE-KEYWORD (CL:CAR I)) STR INFO) (PRINC " " STR) (%LATE-PRINT (CL:CDR (CL:CDR I)) STR INFO))) (T (CL:LABELS ((~G892 (~G207) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G893 (~G208) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G207)) ~G208)) (~G893 (CL:PROGN (%LATE-PRINT (CL:CDR I) STR INFO)))))) (~G892 *PRINT-AUTOMATIC-NEWLINE?*)))) (CL:SETQ ~G211 (CL:CDR ~G211)) (CL:GO ~G209) ~G210 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G891 NIL)))) (~G890 EXPANDED))))))) (~G889 (ARGUMENT-EXPAND '%PRINT-CALL (CL:CDR X) ARGDEF))) (PRINC ")" STR) (CL:LABELS ((~G894 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G894 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))
(CL:DEFUN %PRINT-CALL? (X INFO) (CL:BLOCK %PRINT-CALL? (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((CONS? X) (CL:COND ((CL:CAR X) (CL:COND ((SYMBOL? (CL:CAR X)) (CL:COND ((LIST? (CL:CDR X)) (CL:LABELS ((~G895 (~G212) (CL:COND (~G212 ~G212) (T (CL:COND ((NOT (BUILTIN? (CL:CAR X))) (CL:PROGN (CL:COND ((FUNCTION? (SYMBOL-FUNCTION (CL:CAR X))) (FUNCTION-ARGUMENTS (CL:CAR X))))))))))) (~G895 (%GET-PRINTER-ARGUMENT-DEFINITION (CL:CAR X)))))))))))))))))
(CL:DEFUN RANGE? (X LOWER UPPER) (CL:BLOCK RANGE? (CL:BLOCK NIL (CL:COND ((>= X LOWER) (<= X UPPER))))))
(CL:DEFUN %PRINT-LIST (X STR INFO) (CL:BLOCK %PRINT-LIST (CL:BLOCK NIL (CL:LABELS ((~G896 (!) (CL:COND (! (CL:COND ((FUNCTION? !) (FUNCALL ! X STR INFO)) (T (%PRINT-CALL X ! STR INFO)))) (T (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS INFO)) INFO)) (PRINC "(" STR) (%LATE-PRINT (CL:CAR X) STR INFO) (%PRINT-REST (CL:CDR X) STR INFO) (PRINC ")" STR) (CL:LABELS ((~G897 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS INFO)) INFO)) RET)) (~G897 (CL:CAR (PRINT-INFO-COLUMNS INFO))))))))) (~G896 (%PRINT-CALL? X INFO))))))
(CL:DEFUN %PRINT-ABBREVIATION (ABBREVIATION X STR INFO) (CL:BLOCK %PRINT-ABBREVIATION (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (PRINC (CL:CAR (CL:CDR ABBREVIATION)) STR) (%LATE-PRINT (CL:CAR (CL:CDR X)) STR INFO)))))
(CL:DEFUN %PRINT-SYMBOL-COMPONENT (X STR) (CL:BLOCK %PRINT-SYMBOL-COMPONENT (CL:BLOCK NIL (CL:COND ((SOME (CL:FUNCTION SYMBOL-CHAR-NEEDS-ESCAPING?) (STRING-LIST X)) (%PRINT-ESCAPED-SYMBOL X STR)) (T (PRINC X STR))))))
(CL:DEFUN %PRINT-SYMBOL-PACKAGE (NAME STR) (CL:BLOCK %PRINT-SYMBOL-PACKAGE (CL:BLOCK NIL (%PRINT-SYMBOL-COMPONENT (ABBREVIATED-PACKAGE-NAME NAME) STR))))
(CL:DEFUN INVISIBLE-PACKAGE-NAME? (X) (CL:BLOCK INVISIBLE-PACKAGE-NAME? (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G898 (~G220) (CL:COND (~G220 ~G220) (T (CL:LABELS ((~G899 (~G221) (CL:COND (~G221 ~G221) (T *ALWAYS-PRINT-PACKAGE-NAMES?*)))) (~G899 (EQ T X))))))) (~G898 (NOT X)))) (CL:PROGN (INVISIBLE-PACKAGE? (SYMBOL-PACKAGE X))))))))
(CL:DEFUN FUNCTION-BODY (FUN) (CL:BLOCK FUNCTION-BODY (CL:BLOCK NIL (CL:COND ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 1)) (T (CL:CDR (FUNCTION-SOURCE FUN)))))))
(CL:DEFUN FUNCTION-ARGUMENTS (FUN) (CL:BLOCK FUNCTION-ARGUMENTS (CL:BLOCK NIL (CL:COND ((BUILTIN? FUN) (CL:CONS 'CL:&REST (CL:CONS 'ARGS-TO-BUILTIN NIL))) ((FUNCTION-BYTECODE FUN) (CL:AREF (FUNCTION-BYTECODE FUN) 0)) (T (CL:CAR (FUNCTION-SOURCE FUN)))))))
(CL:DEFUN NEXT-TABULATOR-COLUMN (COLUMN SIZE) (CL:BLOCK NEXT-TABULATOR-COLUMN (CL:BLOCK NIL (INTEGER (++ (* SIZE (++ (/ (-- COLUMN) SIZE))))))))
(CL:DEFUN =-STREAM-LOCATION-LINE (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
(CL:DEFUN =-STREAM-LOCATION-COLUMN (VAL ARR) (CL:BLOCK =-STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
(CL:DEFUN STREAM-LOCATION-TABSIZE (ARR) (CL:BLOCK STREAM-LOCATION-TABSIZE (CL:BLOCK NIL (CL:AREF ARR 6))))
(CL:DEFUN DECIMALS-CHARS (X) (CL:BLOCK DECIMALS-CHARS (CL:BLOCK NIL (CL:LABELS ((~G900 (!) (CL:COND ((< 0 !) (CL:CONS (NUMBER-DIGIT (INTEGER !)) (DECIMALS-CHARS !)))))) (~G900 (CL:MOD (* X 10) 10))))))
(CL:DEFUN INTEGER-CHARS (X) (CL:BLOCK INTEGER-CHARS (CL:BLOCK NIL (CL:LABELS ((F (_) (CL:BLOCK NIL (CL:LABELS ((~G901 (!) (CL:CONS (NUMBER-DIGIT !) (CL:COND ((<= 10 _) (F (/ (- _ !) 10))))))) (~G901 (INTEGER (CL:MOD _ 10))))))) (REVERSE (F (INTEGER (ABS X))))))))
(CL:DEFUN NUMBER-DIGIT (X) (CL:BLOCK NUMBER-DIGIT (CL:BLOCK NIL (CODE-CHAR (CL:COND ((< X 10) (+ (CL:CHAR-CODE #\0) X)) (T (+ (CL:CHAR-CODE #\a) -10 X)))))))
(CL:DEFUN NONDECIMAL-DIGIT? (X CL:&KEY (BASE 10)) (CL:BLOCK NONDECIMAL-DIGIT? (CL:BLOCK NIL (CL:COND ((< 10 BASE) (CL:LABELS ((~G902 (~G40) (CL:COND (~G40 ~G40) (T (%NONDECIMAL-DIGIT? X #\A BASE))))) (~G902 (%NONDECIMAL-DIGIT? X #\a BASE))))))))
(CL:DEFUN DECIMAL-DIGIT? (X) (CL:BLOCK DECIMAL-DIGIT? (CL:BLOCK NIL (CHARRANGE? X #\0 #\9))))
(CL:DEFUN VECTOR? (X) (CL:BLOCK VECTOR? (CL:BLOCK NIL (STRING? X) (ARRAY? X))))
(CL:DEFUN CHARACTER<= (CL:&REST X) (CL:BLOCK CHARACTER<= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION <=) (DYNAMIC-MAP (CL:FUNCTION CL:CHAR-CODE) X)))))
(CL:DEFUN CHARACTER>= (CL:&REST X) (CL:BLOCK CHARACTER>= (CL:BLOCK NIL (CL:APPLY (CL:FUNCTION >=) (DYNAMIC-MAP (CL:FUNCTION CL:CHAR-CODE) X)))))
(CL:DEFUN SPECIAL-CHAR? (X) (CL:BLOCK SPECIAL-CHAR? (CL:BLOCK NIL (CL:LABELS ((~G903 (~G252) (CL:COND (~G252 ~G252) (T (CL:LABELS ((~G904 (~G253) (CL:COND (~G253 ~G253) (T (CL:LABELS ((~G905 (~G254) (CL:COND (~G254 ~G254) (T (CL:LABELS ((~G906 (~G255) (CL:COND (~G255 ~G255) (T (CL:LABELS ((~G907 (~G256) (CL:COND (~G256 ~G256) (T (CL:LABELS ((~G908 (~G257) (CL:COND (~G257 ~G257) (T (CL:LABELS ((~G909 (~G258) (CL:COND (~G258 ~G258) (T (CL:LABELS ((~G910 (~G259) (CL:COND (~G259 ~G259) (T (CL:LABELS ((~G911 (~G260) (CL:COND (~G260 ~G260) (T (CL:LABELS ((~G912 (~G261) (CL:COND (~G261 ~G261) (T (CL:LABELS ((~G913 (~G262) (CL:COND (~G262 ~G262) (T (CL:LABELS ((~G914 (~G263) (CL:COND (~G263 ~G263) (T (EQL X #\#))))) (~G914 (EQL X #\;))))))) (~G913 (EQL X #\:))))))) (~G912 (EQL X #\,))))))) (~G911 (EQL X #\`))))))) (~G910 (EQL X #\'))))))) (~G909 (EQL X #\"))))))) (~G908 (EQL X #\}))))))) (~G907 (EQL X #\{))))))) (~G906 (EQL X #\]))))))) (~G905 (EQL X #\[))))))) (~G904 (EQL X #\)))))))) (~G903 (EQL X #\())))))
(CL:DEFUN READ-INTEGER-0 (STR V) (CL:BLOCK READ-INTEGER-0 (CL:BLOCK NIL (CL:COND ((AHEAD? (CL:FUNCTION DIGIT?) STR) (READ-INTEGER-0 STR (+ (* V 10) (DIGIT-NUMBER (READ-CHAR STR))))) (T V)))))
(CL:DEFUN READ-DECIMAL-PLACES-0 (STR V S) (CL:BLOCK READ-DECIMAL-PLACES-0 (CL:BLOCK NIL (CL:COND ((AHEAD? (CL:FUNCTION DIGIT?) STR) (READ-DECIMAL-PLACES-0 STR (+ V (* S (DIGIT-NUMBER (READ-CHAR STR)))) (/ S 10))) (T V)))))
(CL:DEFUN %FIND-IF-SEQUENCE (PRED SEQ START END FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-SEQUENCE (CL:BLOCK NIL (CL:COND (SEQ (CL:COND ((< 0 (CL:LENGTH SEQ)) (CL:LABELS ((~G915 (E) (CL:LABELS ((~G916 (S) (CL:COND ((CL:LABELS ((~G917 (~G69) (CL:COND (~G69 ~G69) (T (CL:COND ((< S E) FROM-END)))))) (~G917 (CL:COND ((> S E) (NOT FROM-END))))) (CL:LABELS ((~G918 (~G70) (CL:PROGN (CL:SETQ S E) (CL:SETQ E ~G70)))) (~G918 S)))) (CL:BLOCK NIL (CL:LABELS ((~G919 (I) (CL:TAGBODY ~G71 (CL:COND ((CL:COND (FROM-END (< I E)) (T (> I E))) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G920 (!) (CL:COND ((CL:APPLY PRED (CL:CONS ! (CL:COND (WITH-INDEX (LIST I))))) (CL:RETURN-FROM NIL !))))) (~G920 (ELT SEQ I))) (CL:SETQ I (CL:COND (FROM-END (-- I)) (T (++ I)))) (CL:GO ~G71)))) (~G919 S))))) (~G916 (CL:LABELS ((~G921 (~G68) (CL:COND (~G68 ~G68) (T 0)))) (~G921 START)))))) (~G915 (CL:LABELS ((~G922 (~G67) (CL:COND (~G67 ~G67) (T (-- (CL:LENGTH SEQ)))))) (~G922 END)))))))))))
(CL:DEFUN %FIND-IF-LIST (PRED SEQ FROM-END WITH-INDEX) (CL:BLOCK %FIND-IF-LIST (CL:BLOCK NIL (CL:LABELS ((~G923 (!) (CL:COND (WITH-INDEX (CL:LABELS ((~G924 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G925 (~G66) (CL:LABELS ((~G926 (I) (CL:TAGBODY ~G64 (CL:COND ((NOT ~G66) (CL:GO ~G65))) (CL:SETQ I (CL:CAR ~G66)) (CL:COND ((FUNCALL PRED I IDX) (CL:RETURN-FROM NIL I))) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G66 (CL:CDR ~G66)) (CL:GO ~G64) ~G65 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G926 NIL)))) (~G925 !))))) (~G924 0))) (T (CL:BLOCK NIL (CL:LABELS ((~G927 (~G63) (CL:LABELS ((~G928 (I) (CL:TAGBODY ~G61 (CL:COND ((NOT ~G63) (CL:GO ~G62))) (CL:SETQ I (CL:CAR ~G63)) (CL:COND ((FUNCALL PRED I) (CL:RETURN-FROM NIL I))) (CL:SETQ ~G63 (CL:CDR ~G63)) (CL:GO ~G61) ~G62 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G928 NIL)))) (~G927 !))))))) (~G923 (CL:COND (FROM-END (REVERSE SEQ)) (T SEQ)))))))
(CL:DEFUN ASSOC-VALUE (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC-VALUE (CL:BLOCK NIL (CL:CDR (ASSOC KEY LST :TEST TEST)))))
(CL:DEFUN EXPANDER-MACRO (EXPANDER MACRO-NAME) (CL:BLOCK EXPANDER-MACRO (CL:BLOCK NIL (HREF (EXPANDER-MACROS EXPANDER) MACRO-NAME))))
(CL:DEFUN REVERSE (LST) (CL:BLOCK REVERSE (CL:BLOCK NIL (CL:LABELS ((~G929 (!) (CL:BLOCK NIL (CL:LABELS ((~G930 (~G23) (CL:LABELS ((~G931 (I) (CL:TAGBODY ~G21 (CL:COND ((NOT ~G23) (CL:GO ~G22))) (CL:SETQ I (CL:CAR ~G23)) (CL:PROGN (CL:SETQ ! (CL:CONS I !))) (CL:SETQ ~G23 (CL:CDR ~G23)) (CL:GO ~G21) ~G22 (CL:RETURN-FROM NIL (CL:PROGN !))))) (~G931 NIL)))) (~G930 LST))))) (~G929 NIL)))))
(CL:DEFUN ARGDEF-GET-DEFAULT (X) (CL:BLOCK ARGDEF-GET-DEFAULT (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((ARGUMENT-TYPE-SPECIFIER? (CL:CAR (CL:CDR X))) (CL:CAR (CL:CDR (CL:CDR X)))) (T (CL:CAR (CL:CDR X))))) (T X)))))
(CL:DEFUN %TYPE-FUN (ARR) (CL:BLOCK %TYPE-FUN (CL:BLOCK NIL (CL:AREF ARR 3))))
(CL:DEFUN FIND-TYPE (NAME) (CL:BLOCK FIND-TYPE (CL:BLOCK NIL (ASSOC-VALUE NAME *TYPES*))))
(CL:DEFUN SOME (PRED CL:&REST SEQS) (CL:BLOCK SOME (CL:BLOCK NIL (FIND-IF PRED (CL:APPLY (CL:FUNCTION APPEND) SEQS)))))
(CL:DEFUN %NCONC-0 (LSTS) (CL:BLOCK %NCONC-0 (CL:BLOCK NIL (CL:COND (LSTS (CL:LABELS ((~G932 (!) (CL:COND (! (CL:PROGN (CL:RPLACD (LAST !) (%NCONC-0 (CL:CDR LSTS))) !)) (T (%NCONC-0 (CL:CDR LSTS)))))) (~G932 (CL:CAR LSTS))))))))
(CL:DEFUN ARGUMENT-TYPE-SPECIFIER? (X) (CL:BLOCK ARGUMENT-TYPE-SPECIFIER? (CL:BLOCK NIL (CL:LABELS ((~G933 (~G181) (CL:COND (~G181 ~G181) (T (ASSOC X *TYPES*))))) (~G933 (STRING? X))))))
(CL:DEFUN =-ELT (VAL SEQ IDX) (CL:BLOCK =-ELT (CL:BLOCK NIL (CL:COND ((ARRAY? SEQ) (CL:PROGN (=-AREF VAL SEQ IDX))) ((CONS? SEQ) (CL:RPLACA (NTHCDR IDX SEQ) VAL)) ((STRING? SEQ) (ERROR "Strings cannot be modified.")) (T (ERROR "Not a sequence: ~A" SEQ))))))
(CL:DEFUN FIND-IF (PRED SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (WITH-INDEX NIL)) (CL:BLOCK FIND-IF (CL:BLOCK NIL (CL:COND ((NOT (ATOM SEQ) START END) (%FIND-IF-LIST PRED SEQ FROM-END WITH-INDEX)) (T (%FIND-IF-SEQUENCE PRED SEQ START END FROM-END WITH-INDEX))))))
(CL:DEFUN QUEUE-POP (X) (CL:BLOCK QUEUE-POP (CL:BLOCK NIL (CL:LABELS ((~G934 (~G8) (CL:LABELS ((~G935 (~G9) (CL:COND (~G9 ~G9) (T (CL:RPLACA X NIL))))) (~G935 (CL:RPLACD X (CL:CDR (CL:CDR X))))) ~G8)) (~G934 (CL:CAR (CL:CDR X)))))))
(CL:DEFUN READ-DECIMAL-PLACES (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-DECIMAL-PLACES (CL:BLOCK NIL (CL:COND ((AHEAD? (CL:FUNCTION DIGIT?) STR) (READ-DECIMAL-PLACES-0 STR 0 0.1))))))
(CL:DEFUN READ-INTEGER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-INTEGER (CL:BLOCK NIL (CL:COND ((AHEAD? (CL:FUNCTION DIGIT?) STR) (INTEGER (READ-INTEGER-0 STR 0)))))))
(CL:DEFUN SYMBOL-CHAR? (X) (CL:BLOCK SYMBOL-CHAR? (CL:BLOCK NIL (CL:COND (X (CL:COND ((> (CL:CHAR-CODE X) 32) (NOT (SPECIAL-CHAR? X)))))))))
(CL:DEFUN HEX-DIGIT? (X) (CL:BLOCK HEX-DIGIT? (CL:BLOCK NIL (CL:LABELS ((~G936 (~G42) (CL:COND (~G42 ~G42) (T (CL:LABELS ((~G937 (~G43) (CL:COND (~G43 ~G43) (T (CL:COND ((CHARACTER>= X #\a) (CHARACTER<= X #\f))))))) (~G937 (CL:COND ((CHARACTER>= X #\A) (CHARACTER<= X #\F))))))))) (~G936 (DIGIT? X))))))
(CL:DEFUN LIST-ARRAY (X) (CL:BLOCK LIST-ARRAY (CL:BLOCK NIL (CL:LABELS ((~G938 (A) (CL:LABELS ((~G939 (IDX) (CL:BLOCK NIL (CL:LABELS ((~G940 (~G50) (CL:LABELS ((~G941 (I) (CL:TAGBODY ~G48 (CL:COND ((NOT ~G50) (CL:GO ~G49))) (CL:SETQ I (CL:CAR ~G50)) (CL:PROGN (=-AREF I A IDX)) (CL:PROGN (CL:SETQ IDX (NUMBER+ IDX 1))) (CL:SETQ ~G50 (CL:CDR ~G50)) (CL:GO ~G48) ~G49 (CL:RETURN-FROM NIL (CL:PROGN A))))) (~G941 NIL)))) (~G940 X))))) (~G939 0)))) (~G938 (MAKE-ARRAY (CL:LENGTH X)))))))
(CL:DEFUN SPLIT (OBJ SEQ CL:&KEY (TEST (CL:FUNCTION EQL)) (INCLUDE? NIL)) (CL:BLOCK SPLIT (CL:BLOCK NIL (CL:COND (SEQ (CL:LABELS ((~G942 (!) (CL:COND (! (CL:CONS (SUBSEQ SEQ 0 (CL:COND (INCLUDE? (++ !)) (T !))) (SPLIT OBJ (SUBSEQ SEQ (++ !)) :TEST TEST :INCLUDE? INCLUDE?))) (T (LIST SEQ))))) (~G942 (POSITION OBJ SEQ :TEST TEST))))))))
(CL:DEFUN STREAM-LOCATION-ID (ARR) (CL:BLOCK STREAM-LOCATION-ID (CL:BLOCK NIL (CL:AREF ARR 3))))
(CL:DEFUN STREAM-LOCATION-LINE (ARR) (CL:BLOCK STREAM-LOCATION-LINE (CL:BLOCK NIL (CL:AREF ARR 4))))
(CL:DEFUN STREAM-INPUT-LOCATION (ARR) (CL:BLOCK STREAM-INPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 8))))
(CL:DEFUN READ-MAKE-SYMBOL (SYM CL:&OPTIONAL (PKG *PACKAGE*)) (CL:BLOCK READ-MAKE-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G943 (~G279) (CL:COND (~G279 ~G279) (T (MAKE-SYMBOL SYM PKG))))) (~G943 (FIND-SYMBOL SYM PKG))))))
(CL:DEFUN READ-SYMBOL (STR) (CL:BLOCK READ-SYMBOL (CL:BLOCK NIL (CL:LABELS ((F NIL (CL:BLOCK NIL (CL:COND ((AHEAD? (CL:FUNCTION SYMBOL-CHAR?) STR) (CL:CONS (READ-CHAR STR) (F)))))) (F2 NIL (CL:BLOCK NIL (CL:COND ((NOT (CL:LABELS ((~G944 (~G264) (CL:COND (~G264 ~G264) (T (AHEAD? #\| STR))))) (~G944 (NOT (PEEK-CHAR STR))))) (CL:PROGN (CL:COND ((AHEAD? #\\ STR) (CL:PROGN (READ-CHAR STR) (CL:CONS (READ-CHAR STR) (F2)))) (T (CL:CONS (READ-CHAR STR) (F2)))))))))) (CL:COND ((AHEAD? #\| STR) (CL:PROGN (READ-CHAR STR) (CL:COND ((WHITESPACE? (PEEK-CHAR STR)) (CL:PROGN (CL:RETURN-FROM NIL (LIST #\|))))) (CL:LABELS ((~G945 (~G265) (CL:COND ((AHEAD? #\| STR) (READ-CHAR STR)) (T (ERROR "Expected end of symbol name '|' instead of '~A'." (PEEK-CHAR STR)))) ~G265)) (~G945 (F2))))) (T (CL:COND ((NOT (SPECIAL-CHAR? (SEEK-CHAR STR))) (CL:PROGN (FILTER (CL:FUNCTION CHAR-UPCASE) (F)))))))))))
(CL:DEFUN EVERY (PRED CL:&REST SEQS) (CL:BLOCK EVERY (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G946 (~G76) (CL:LABELS ((~G947 (SEQ) (CL:TAGBODY ~G74 (CL:COND ((NOT ~G76) (CL:GO ~G75))) (CL:SETQ SEQ (CL:CAR ~G76)) (CL:COND ((LIST? SEQ) (CL:BLOCK NIL (CL:LABELS ((~G948 (~G79) (CL:LABELS ((~G949 (I) (CL:TAGBODY ~G77 (CL:COND ((NOT ~G79) (CL:GO ~G78))) (CL:SETQ I (CL:CAR ~G79)) (CL:LABELS ((~G950 (~G72) (CL:COND (~G72 ~G72) (T (CL:RETURN-FROM EVERY NIL))))) (~G950 (FUNCALL PRED I))) (CL:SETQ ~G79 (CL:CDR ~G79)) (CL:GO ~G77) ~G78 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G949 NIL)))) (~G948 SEQ)))) ((VECTOR? SEQ) (CL:LABELS ((~G951 (~G80) (CL:COND ((< ~G80 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G80))) (CL:BLOCK NIL (CL:LABELS ((~G952 (!) (CL:TAGBODY ~G81 (CL:COND ((== ! ~G80) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G953 (~G73) (CL:COND (~G73 ~G73) (T (CL:RETURN-FROM EVERY NIL))))) (~G953 (FUNCALL PRED (ELT SEQ !)))) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G81)))) (~G952 0))))) (~G951 (INTEGER (CL:LENGTH SEQ))))) (T (ERROR "Not a sequence: ~A." SEQ))) (CL:SETQ ~G76 (CL:CDR ~G76)) (CL:GO ~G74) ~G75 (CL:RETURN-FROM NIL (CL:PROGN T))))) (~G947 NIL)))) (~G946 SEQS))))))
(CL:DEFUN DIGIT? (C CL:&KEY (BASE 10)) (CL:BLOCK DIGIT? (CL:BLOCK NIL (CL:COND ((CHARACTER? C) (CL:LABELS ((~G954 (~G41) (CL:COND (~G41 ~G41) (T (NONDECIMAL-DIGIT? C :BASE BASE))))) (~G954 (DECIMAL-DIGIT? C))))))))
(CL:DEFUN INTEGER-STRING (X N R) (CL:BLOCK INTEGER-STRING (CL:BLOCK NIL (CL:LABELS ((F (_) (CL:BLOCK NIL (CL:CONS (NUMBER-DIGIT (CL:MOD _ R)) (CL:COND ((NOT (== 0 (CL:PROGN (CL:SETQ N (- N 1))))) (CL:PROGN (F (INTEGER (/ _ R)))))))))) (LIST-STRING (REVERSE (F X)))))))
(CL:DEFUN NUMBER-DIGITS (X) (CL:BLOCK NUMBER-DIGITS (CL:BLOCK NIL (+ (CL:COND ((< X 0) (CL:CONS #\- NIL))) (INTEGER-CHARS X) (CL:LABELS ((~G955 (!) (CL:COND ((NOT (== 0 !)) (CL:PROGN (CL:CONS #\. (DECIMALS-CHARS !))))))) (~G955 (CL:MOD X 1)))))))
(CL:DEFUN STREAM-FUN-OUT (ARR) (CL:BLOCK STREAM-FUN-OUT (CL:BLOCK NIL (CL:AREF ARR 4))))
(CL:DEFUN %TRACK-LOCATION (SL X) (CL:BLOCK %TRACK-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G956 (~G154) (CL:LABELS ((~G957 (STREAM-LOCATION TRACK? ID LINE COLUMN TABSIZE) TRACK? ID LINE COLUMN TABSIZE (CL:COND (TRACK? (CL:PROGN (CL:COND ((STRING? X) (CL:LABELS ((~G958 (~G155) (CL:COND (~G155 (CL:PROGN (CL:LABELS ((~G959 (~G157) (CL:COND ((< ~G157 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G157))) (CL:BLOCK NIL (CL:LABELS ((~G960 (~G156) (CL:TAGBODY ~G158 (CL:COND ((== ~G156 ~G157) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (CL:LABELS ((~G961 (!) (%TRACK-LOCATION SL !))) (~G961 (ELT ~G155 ~G156))) (CL:SETQ ~G156 (NUMBER+ 1 ~G156)) (CL:GO ~G158)))) (~G960 0))))) (~G959 (INTEGER (CL:LENGTH ~G155))))))))) (~G958 X))) (T (CL:COND (X (CL:PROGN (CL:COND ((== 10 (CL:CHAR-CODE X)) (CL:PROGN (CL:PROGN (=-STREAM-LOCATION-COLUMN 1 SL)) (CL:PROGN (=-STREAM-LOCATION-LINE (NUMBER+ (STREAM-LOCATION-LINE SL) 1) SL)))) (T (CL:COND ((== 9 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NEXT-TABULATOR-COLUMN COLUMN TABSIZE) SL))) ((< 31 (CL:CHAR-CODE X)) (CL:PROGN (=-STREAM-LOCATION-COLUMN (NUMBER+ (STREAM-LOCATION-COLUMN SL) 1) SL)))))))))))))) X)) (~G957 ~G154 (STREAM-LOCATION-TRACK? ~G154) (STREAM-LOCATION-ID ~G154) (STREAM-LOCATION-LINE ~G154) (STREAM-LOCATION-COLUMN ~G154) (STREAM-LOCATION-TABSIZE ~G154))))) (~G956 SL)))))
(CL:DEFUN PRINT-INFO-PRETTY-PRINT? (ARR) (CL:BLOCK PRINT-INFO-PRETTY-PRINT? (CL:BLOCK NIL (CL:AREF ARR 2))))
(CL:DEFUN =-PRINT-INFO-INDENTATION (VAL ARR) (CL:BLOCK =-PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
(CL:DEFUN %BODY-INDENTATION (INFO) (CL:BLOCK %BODY-INDENTATION (CL:BLOCK NIL (CL:LABELS ((~G962 (~G201) (CL:COND (~G201 ~G201) (T 1)))) (~G962 (CL:CAR (PRINT-INFO-COLUMNS INFO)))))))
(CL:DEFUN PRINT-INFO-INDENTATION (ARR) (CL:BLOCK PRINT-INFO-INDENTATION (CL:BLOCK NIL (CL:AREF ARR 4))))
(CL:DEFUN %PRINT-FUNCTION (X STR INFO) (CL:BLOCK %PRINT-FUNCTION (CL:BLOCK NIL (PRINC "#'" STR) (%LATE-PRINT (CL:CONS (FUNCTION-ARGUMENTS X) (FUNCTION-BODY X)) STR INFO))))
(CL:DEFUN %PRINT-ARRAY (X STR INFO) (CL:BLOCK %PRINT-ARRAY (CL:BLOCK NIL (PRINC "#" STR) (%PRINT-CONS (ARRAY-LIST X) STR INFO))))
(CL:DEFUN %PRINT-STRING (X STR) (CL:BLOCK %PRINT-STRING (CL:BLOCK NIL (PRINC #\" STR) (CL:BLOCK NIL (CL:LABELS ((~G963 (~G215) (CL:LABELS ((~G964 (I) (CL:TAGBODY ~G213 (CL:COND ((NOT ~G215) (CL:GO ~G214))) (CL:SETQ I (CL:CAR ~G215)) (CL:COND ((EQL I #\") (PRINC "\\\"" STR)) ((EQL I #\\) (PRINC "\\\\" STR)) (T (PRINC I STR))) (CL:SETQ ~G215 (CL:CDR ~G215)) (CL:GO ~G213) ~G214 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G964 NIL)))) (~G963 (STRING-LIST X)))) (PRINC #\" STR))))
(CL:DEFUN %PRINT-CHARACTER (X STR) (CL:BLOCK %PRINT-CHARACTER (CL:BLOCK NIL (PRINC "#\\" STR) (PRINC X STR))))
(CL:DEFUN %PRINT-SYMBOL (X STR INFO) (CL:BLOCK %PRINT-SYMBOL (CL:BLOCK NIL (CL:LABELS ((~G965 (!) (CL:COND (! (CL:PROGN (CL:COND ((NOT (INVISIBLE-PACKAGE-NAME? X)) (CL:PROGN (CL:LABELS ((~G966 (~G222) (CL:COND (~G222 ~G222) (T (%PRINT-SYMBOL-PACKAGE (CL:PACKAGE-NAME !) STR))))) (~G966 (KEYWORD? X))) (PRINC #\: STR))))))))) (~G965 (CL:COND (X (CL:COND ((NOT (EQ T X)) (SYMBOL-PACKAGE X))))))) (%PRINT-SYMBOL-COMPONENT (SYMBOL-NAME X) STR))))
(CL:DEFUN %PRINT-CONS (X STR INFO) (CL:BLOCK %PRINT-CONS (CL:BLOCK NIL (CL:LABELS ((~G967 (!) (CL:COND (! (%PRINT-ABBREVIATION ! X STR INFO)) (T (%PRINT-LIST X STR INFO))))) (~G967 (CL:COND ((CONS? (CL:CDR X)) (CL:COND ((NOT (CL:CDR (CL:CDR X))) (ASSOC (CL:CAR X) *PRINTER-ABBREVIATIONS* :TEST (CL:FUNCTION EQ)))))))))))
(CL:DEFUN EXPANDER-CALL (ARR) (CL:BLOCK EXPANDER-CALL (CL:BLOCK NIL (CL:AREF ARR 5))))
(CL:DEFUN EXPANDER-PRED (ARR) (CL:BLOCK EXPANDER-PRED (CL:BLOCK NIL (CL:AREF ARR 4))))
(CL:DEFUN CHARRANGE? (X START END) (CL:BLOCK CHARRANGE? (CL:BLOCK NIL (RANGE? (CL:CHAR-CODE X) (CL:CHAR-CODE START) (CL:CHAR-CODE END)))))
(CL:DEFUN LOWER-CASE? (X) (CL:BLOCK LOWER-CASE? (CL:BLOCK NIL (CHARRANGE? X #\a #\z))))
(CL:DEFUN EXPANDER-POST (ARR) (CL:BLOCK EXPANDER-POST (CL:BLOCK NIL (CL:AREF ARR 7))))
(CL:DEFUN REFINE (FUN X) (CL:BLOCK REFINE (CL:BLOCK NIL (CL:LABELS ((~G968 (!) (CL:COND ((EQUAL X !) !) (T (REFINE FUN !))))) (~G968 (FUNCALL FUN X))))))
(CL:DEFUN EXPANDER-EXPAND-0 (EXPANDER EXPR) (CL:BLOCK EXPANDER-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G969 (~G350) (CL:PROGN (CL:SETQ *MACRO?* (EXPANDER-PRED EXPANDER))) (CL:LABELS ((~G970 (~G351) (CL:PROGN (CL:SETQ *MACRO?* ~G350)) ~G351)) (~G970 (CL:PROGN (CL:LABELS ((~G971 (~G352) (CL:PROGN (CL:SETQ *MACROCALL* (EXPANDER-CALL EXPANDER))) (CL:LABELS ((~G972 (~G353) (CL:PROGN (CL:SETQ *MACROCALL* ~G352)) ~G353)) (~G972 (CL:PROGN (CL:LABELS ((~G973 (!) (CL:COND ((EQ ! *EXPANDER-DUMP?*) (CL:PROGN (FORMAT T "~%; Expander ~A input:~%" !) (CL:PRINT EXPR) (FORMAT T "~%; Expander ~A output:~%" !) (CL:PRINT (%MACROEXPAND EXPR)))) (T (%MACROEXPAND EXPR))))) (~G973 (EXPANDER-NAME EXPANDER)))))))) (~G971 *MACROCALL*))))))) (~G969 *MACRO?*)))))
(CL:DEFUN EXPANDER-PRE (ARR) (CL:BLOCK EXPANDER-PRE (CL:BLOCK NIL (CL:AREF ARR 6))))
(CL:DEFUN EXPANDER? (X) (CL:BLOCK EXPANDER? (CL:BLOCK NIL (CL:COND ((ARRAY? X) (CL:COND ((EQ 'STRUCT (CL:AREF X 0)) (CL:COND ((EQ 'EXPANDER (CL:AREF X 1)) X)))))))))
(CL:DEFUN %LATE-PRINT (X STR INFO) (CL:BLOCK %LATE-PRINT (CL:BLOCK NIL (CL:PROGN (%PRINT-INDENTATION STR INFO) (CL:LABELS ((~G974 (~G223) (CL:COND ((CONS? ~G223) (%PRINT-CONS X STR INFO)) ((SYMBOL? ~G223) (%PRINT-SYMBOL X STR INFO)) ((CHARACTER? ~G223) (%PRINT-CHARACTER X STR)) ((NUMBER? ~G223) (PRINC X STR)) ((STRING? ~G223) (%PRINT-STRING X STR)) ((ARRAY? ~G223) (%PRINT-ARRAY X STR INFO)) ((FUNCTION? ~G223) (%PRINT-FUNCTION X STR INFO)) ((OBJECT? ~G223) (%PRINT-OBJECT X STR INFO)) (T (%ERROR "Don't know how to print object."))))) (~G974 X))))))
(CL:DEFUN %PRINT-BODY (X STR INFO) (CL:BLOCK %PRINT-BODY (CL:BLOCK NIL (CL:LABELS ((~G975 (~G202) (CL:PROGN (=-PRINT-INFO-INDENTATION (%BODY-INDENTATION INFO) INFO)) (CL:LABELS ((~G976 (~G203) (CL:PROGN (=-PRINT-INFO-INDENTATION ~G202 INFO)) ~G203)) (~G976 (CL:PROGN (CL:LABELS ((~G977 (FIRST?) (CL:BLOCK NIL (CL:LABELS ((~G978 (~G206) (CL:LABELS ((~G979 (I) (CL:TAGBODY ~G204 (CL:COND ((NOT ~G206) (CL:GO ~G205))) (CL:SETQ I (CL:CAR ~G206)) (CL:COND (FIRST? (CL:PROGN (CL:SETQ FIRST? NIL))) (T (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (FRESH-LINE STR))))) (%LATE-PRINT I STR INFO) (CL:SETQ ~G206 (CL:CDR ~G206)) (CL:GO ~G204) ~G205 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G979 NIL)))) (~G978 X))))) (~G977 T))))))) (~G975 (PRINT-INFO-INDENTATION INFO))))))
(CL:DEFUN =-PRINT-INFO-COLUMNS (VAL ARR) (CL:BLOCK =-PRINT-INFO-COLUMNS (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
(CL:DEFUN PRINT-INFO-COLUMNS (ARR) (CL:BLOCK PRINT-INFO-COLUMNS (CL:BLOCK NIL (CL:AREF ARR 5))))
(CL:DEFUN %PRINT-INDENTATION (STR INFO) (CL:BLOCK %PRINT-INDENTATION (CL:BLOCK NIL (CL:COND ((PRINT-INFO-PRETTY-PRINT? INFO) (CL:COND ((FRESH-LINE? STR) (CL:LABELS ((~G980 (~G199) (CL:COND ((< ~G199 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G199))) (CL:BLOCK NIL (CL:LABELS ((~G981 (!) (CL:TAGBODY ~G200 (CL:COND ((== ! ~G199) (CL:RETURN-FROM NIL (CL:PROGN NIL)))) (PRINC " " STR) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G200)))) (~G981 0))))) (~G980 (INTEGER (PRINT-INFO-INDENTATION INFO)))))))))))
(CL:DEFUN MAKE-PRINT-INFO (CL:&KEY (PRETTY-PRINT? 'PRETTY-PRINT?) (DOWNCASE? 'DOWNCASE?) (INDENTATION 'INDENTATION) (COLUMNS 'COLUMNS)) (CL:BLOCK MAKE-PRINT-INFO (CL:BLOCK NIL (CL:LABELS ((~G982 (~G197) (CL:PROGN (=-AREF 'STRUCT ~G197 0) (=-AREF 'PRINT-INFO ~G197 1)) (CL:PROGN (=-AREF (CL:COND ((EQ PRETTY-PRINT? 'PRETTY-PRINT?) NIL) (T PRETTY-PRINT?)) ~G197 2)) (CL:PROGN (=-AREF (CL:COND ((EQ DOWNCASE? 'DOWNCASE?) NIL) (T DOWNCASE?)) ~G197 3)) (CL:PROGN (=-AREF (CL:COND ((EQ INDENTATION 'INDENTATION) 0) (T INDENTATION)) ~G197 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMNS 'COLUMNS) NIL) (T COLUMNS)) ~G197 5)) ~G197)) (~G982 (MAKE-ARRAY 6))))))
(CL:DEFUN STREAM-PRINC (X STR) (CL:BLOCK STREAM-PRINC (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:BLOCK NIL (CL:LABELS ((~G983 (~G162) (CL:LABELS ((~G984 (I) (CL:TAGBODY ~G160 (CL:COND ((NOT ~G162) (CL:GO ~G161))) (CL:SETQ I (CL:CAR ~G162)) (STREAM-PRINC I STR) (CL:SETQ ~G162 (CL:CDR ~G162)) (CL:GO ~G160) ~G161 (CL:RETURN-FROM NIL (CL:PROGN X))))) (~G984 NIL)))) (~G983 X)))) ((CL:LABELS ((~G985 (~G159) (CL:COND (~G159 ~G159) (T (CHARACTER? X))))) (~G985 (STRING? X))) (CL:COND ((NOT (CL:COND ((STRING? X) (== 0 (CL:LENGTH X))))) (CL:PROGN (CL:PROGN (=-STREAM-LAST-CHAR (CL:COND ((STRING? X) (CHAR X (-- (CL:LENGTH X)))) (T X)) STR)) (%TRACK-LOCATION (STREAM-OUTPUT-LOCATION STR) X) (FUNCALL (STREAM-FUN-OUT STR) X STR))))) (T (FUNCALL (STREAM-FUN-OUT STR) X STR))))))
(CL:DEFUN PRINC-NUMBER (X STR) (CL:BLOCK PRINC-NUMBER (CL:BLOCK NIL (STREAM-PRINC (NUMBER-DIGITS X) STR))))
(CL:DEFUN PRINT-HEX (X N CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINT-HEX (CL:BLOCK NIL (PRINC (INTEGER-STRING (INTEGER X) N 16) (DEFAULT-STREAM STR)))))
(CL:DEFUN =-STREAM-USER-DETAIL (VAL ARR) (CL:BLOCK =-STREAM-USER-DETAIL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 10)))))
(CL:DEFUN QUEUE-STRING (X) (CL:BLOCK QUEUE-STRING (CL:BLOCK NIL (LIST-STRING (QUEUE-LIST X)))))
(CL:DEFUN STREAM-USER-DETAIL (ARR) (CL:BLOCK STREAM-USER-DETAIL (CL:BLOCK NIL (CL:AREF ARR 10))))
(CL:DEFUN STREAM-LOCATION-COLUMN (ARR) (CL:BLOCK STREAM-LOCATION-COLUMN (CL:BLOCK NIL (CL:AREF ARR 5))))
(CL:DEFUN STREAM-LOCATION-TRACK? (ARR) (CL:BLOCK STREAM-LOCATION-TRACK? (CL:BLOCK NIL (CL:AREF ARR 2))))
(CL:DEFUN STREAM-OUTPUT-LOCATION (ARR) (CL:BLOCK STREAM-OUTPUT-LOCATION (CL:BLOCK NIL (CL:AREF ARR 9))))
(CL:DEFUN VALUES (CL:&REST VALS) (CL:BLOCK VALUES (CL:BLOCK NIL (CL:CONS *VALUES-MAGIC* VALS))))
(CL:DEFUN READ-COMMENT-BLOCK (STR) (CL:BLOCK READ-COMMENT-BLOCK (CL:BLOCK NIL (CL:LABELS ((~G986 (~G267) (CL:COND (~G267 ~G267) (T (READ-COMMENT-BLOCK STR))))) (~G986 (CL:COND ((EQL #\| (READ-CHAR STR)) (AHEAD? #\# STR))))))))
(CL:DEFUN LIST-NUMBER? (X) (CL:BLOCK LIST-NUMBER? (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G987 (~G268) (CL:COND (~G268 ~G268) (T (DIGIT? (CL:CAR X)))))) (~G987 (CL:COND ((CL:CDR X) (CL:LABELS ((~G988 (~G269) (CL:COND (~G269 ~G269) (T (EQL #\. (CL:CAR X)))))) (~G988 (EQL #\- (CL:CAR X)))))))) (CL:COND ((CL:CDR X) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (CL:LABELS ((~G989 (~G270) (CL:COND (~G270 ~G270) (T (EQL #\. _))))) (~G989 (DIGIT? _))))) (CL:CDR X))) (T T)))))))
(CL:DEFUN READ-SYMBOL-AND-PACKAGE (STR) (CL:BLOCK READ-SYMBOL-AND-PACKAGE (CL:BLOCK NIL (CL:LABELS ((~G990 (!) (CL:COND ((AHEAD? #\: STR) (CL:PROGN (READ-CHAR STR) (VALUES (CL:LABELS ((~G991 (~G266) (CL:COND (~G266 ~G266) (T "KEYWORD")))) (~G991 (CL:COND (! (LIST-STRING !))))) (READ-SYMBOL STR)))) (T (VALUES NIL !))))) (~G990 (READ-SYMBOL STR))))))
(CL:DEFUN READ-SLOT-VALUE (X) (CL:BLOCK READ-SLOT-VALUE (CL:BLOCK NIL (CL:COND ((NOT X) NIL) ((CL:CDR X) (CL:CONS 'CL:SLOT-VALUE (CL:CONS (READ-SLOT-VALUE (BUTLAST X)) (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS (READ-MAKE-SYMBOL (CL:CAR (LAST X))) NIL)) NIL)))) ((STRING? (CL:CAR X)) (READ-MAKE-SYMBOL (CL:CAR X))) (T (CL:CAR X))))))
(CL:DEFUN READ-CONS (STR) (CL:BLOCK READ-CONS (CL:BLOCK NIL (CL:LABELS ((ERR (_) (CL:BLOCK NIL (CL:LABELS ((~G992 (!) (ERROR "~A at line ~A, column ~A in file ~A." _ (STREAM-LOCATION-LINE !) (STREAM-LOCATION-COLUMN !) (STREAM-LOCATION-ID !)))) (~G992 (STREAM-INPUT-LOCATION STR))))) (F (TOKEN PKG SYM) (CL:COND ((NOT (%READ-CLOSING-PARENS? TOKEN)) (CL:PROGN (CL:CONS (CL:LABELS ((~G993 (~G282) (CL:COND ((EQL ~G282 :PARENTHESIS-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G282 :BRACKET-OPEN) (CL:CONS 'BRACKETS (READ-CONS-SLOT STR))) ((EQL ~G282 :BRACE-OPEN) (CL:CONS 'BRACES (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G993 TOKEN)) (CL:LABELS ((~G994 (!) (CL:COND (! (CL:LABELS ((~G995 (~G284) (CL:LABELS ((~G996 (~G285) (CL:COND ((NOT (EQ (CL:CAR ~G284) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G284)))) (CL:LABELS ((~G997 (TOKEN) (CL:LABELS ((~G998 (~G286) (CL:LABELS ((~G999 (PKG) (CL:LABELS ((~G1000 (~G287) (CL:LABELS ((~G1001 (SYM) (CL:COND ((EQ :DOT TOKEN) (CL:LABELS ((~G1002 (X) (CL:LABELS ((~G1003 (~G291) (CL:LABELS ((~G1004 (~G292) (CL:COND ((NOT (EQ (CL:CAR ~G291) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G291)))) (CL:LABELS ((~G1005 (TOKEN) (CL:LABELS ((~G1006 (~G293) (CL:LABELS ((~G1007 (PKG) (CL:LABELS ((~G1008 (~G294) (CL:LABELS ((~G1009 (SYM) (CL:LABELS ((~G1010 (~G283) (CL:COND (~G283 ~G283) (T (ERR "Only one value allowed after dotted cons"))))) (~G1010 (%READ-CLOSING-PARENS? TOKEN))) X)) (~G1009 (CL:CAR ~G294))))) (~G1008 (CL:LABELS ((~G1011 (~G297) (CL:COND (~G297 ~G297) (T (%ERROR "Not enough VALUES."))))) (~G1011 (CL:CDR ~G293))))))) (~G1007 (CL:CAR ~G293))))) (~G1006 (CL:LABELS ((~G1012 (~G296) (CL:COND (~G296 ~G296) (T (%ERROR "Not enough VALUES."))))) (~G1012 (CL:CDR ~G292))))))) (~G1005 (CL:CAR ~G292))))) (~G1004 (CL:CDR ~G291))))) (~G1003 (READ-TOKEN STR))))) (~G1002 (READ-EXPR STR)))) (T (F TOKEN PKG SYM))))) (~G1001 (CL:CAR ~G287))))) (~G1000 (CL:LABELS ((~G1013 (~G290) (CL:COND (~G290 ~G290) (T (%ERROR "Not enough VALUES."))))) (~G1013 (CL:CDR ~G286))))))) (~G999 (CL:CAR ~G286))))) (~G998 (CL:LABELS ((~G1014 (~G289) (CL:COND (~G289 ~G289) (T (%ERROR "Not enough VALUES."))))) (~G1014 (CL:CDR ~G285))))))) (~G997 (CL:CAR ~G285))))) (~G996 (CL:CDR ~G284))))) (~G995 !))) (T (ERR "Closing bracket missing"))))) (~G994 (READ-TOKEN STR))))))))) (CL:LABELS ((~G1015 (~G298) (CL:LABELS ((~G1016 (~G299) (CL:COND ((NOT (EQ (CL:CAR ~G298) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G298)))) (CL:LABELS ((~G1017 (TOKEN) (CL:LABELS ((~G1018 (~G300) (CL:LABELS ((~G1019 (PKG) (CL:LABELS ((~G1020 (~G301) (CL:LABELS ((~G1021 (SYM) (CL:COND ((EQ TOKEN :DOT) (CL:CONS 'CL:CONS (READ-CONS STR))) (T (F TOKEN PKG SYM))))) (~G1021 (CL:CAR ~G301))))) (~G1020 (CL:LABELS ((~G1022 (~G304) (CL:COND (~G304 ~G304) (T (%ERROR "Not enough VALUES."))))) (~G1022 (CL:CDR ~G300))))))) (~G1019 (CL:CAR ~G300))))) (~G1018 (CL:LABELS ((~G1023 (~G303) (CL:COND (~G303 ~G303) (T (%ERROR "Not enough VALUES."))))) (~G1023 (CL:CDR ~G299))))))) (~G1017 (CL:CAR ~G299))))) (~G1016 (CL:CDR ~G298))))) (~G1015 (READ-TOKEN STR)))))))
(CL:DEFUN %READ-CLOSING-PARENS? (X) (CL:BLOCK %READ-CLOSING-PARENS? (CL:BLOCK NIL (CL:LABELS ((~G1024 (~G250) (CL:COND (~G250 ~G250) (T (CL:LABELS ((~G1025 (~G251) (CL:COND (~G251 ~G251) (T (EQL X :BRACE-CLOSE))))) (~G1025 (EQL X :BRACKET-CLOSE))))))) (~G1024 (EQL X :PARENTHESIS-CLOSE))))))
(CL:DEFUN READ-SYMBOL-OR-SLOT-VALUE (PKG SYM) (CL:BLOCK READ-SYMBOL-OR-SLOT-VALUE (CL:BLOCK NIL (CL:LABELS ((~G1026 (!) (CL:COND ((CL:COND ((CL:CDR !) (CL:COND ((CL:CAR !) (CL:CAR (LAST !)))))) (READ-SLOT-VALUE !)) (T (READ-MAKE-SYMBOL SYM PKG))))) (~G1026 (SPLIT #\. SYM))))))
(CL:DEFUN ARRAY (CL:&REST ELMS) (CL:BLOCK ARRAY (CL:BLOCK NIL (LIST-ARRAY ELMS))))
(CL:DEFUN READ-HEX (STR) (CL:BLOCK READ-HEX (CL:BLOCK NIL (CL:LABELS ((F (_) (CL:BLOCK NIL (CL:LABELS ((~G1027 (!) (CL:COND (! (CL:PROGN (READ-CHAR STR) (F (NUMBER+ (* _ 16) (- (CL:CHAR-CODE !) (CL:COND ((DIGIT? !) (CL:CHAR-CODE #\0)) (T (- (CL:CHAR-CODE #\A) 10)))))))) (T _)))) (~G1027 (CL:COND ((PEEK-CHAR STR) (CL:LABELS ((~G1028 (!) (CL:COND ((HEX-DIGIT? !) !)))) (~G1028 (CHAR-UPCASE (PEEK-CHAR STR))))))))))) (CL:LABELS ((~G1029 (~G230) (CL:COND (~G230 ~G230) (T (ERROR "Illegal character '~A' at begin of hexadecimal number." (PEEK-CHAR STR)))))) (~G1029 (HEX-DIGIT? (PEEK-CHAR STR)))) (CL:LABELS ((~G1030 (~G231) (CL:COND ((SYMBOL-CHAR? (PEEK-CHAR STR)) (ERROR "Illegal character '~A' in hexadecimal number." (PEEK-CHAR STR)))) ~G231)) (~G1030 (F 0)))))))
(CL:DEFUN READ-NUMBER (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-NUMBER (CL:BLOCK NIL (* (CL:COND ((AHEAD? #\- STR) (CL:LABELS ((~G1031 (~G245) (READ-CHAR STR) ~G245)) (~G1031 -1))) (T 1)) (+ (READ-INTEGER STR) (CL:LABELS ((~G1032 (~G246) (CL:COND (~G246 ~G246) (T 0)))) (~G1032 (CL:COND ((AHEAD? #\. STR) (CL:COND ((READ-CHAR STR) (READ-DECIMAL-PLACES STR))))))))))))
(CL:DEFUN MAKE-STRING-STREAM NIL (CL:BLOCK MAKE-STRING-STREAM (CL:BLOCK NIL (MAKE-STREAM :USER-DETAIL (MAKE-QUEUE) :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (QUEUE-POP (STREAM-USER-DETAIL _)))) :FUN-OUT (CL:LAMBDA (X STR) (CL:COND ((STRING? X) (CL:LABELS ((~G1033 (~G163) (CL:COND (~G163 (CL:PROGN (CL:LABELS ((~G1034 (~G165) (CL:COND ((< ~G165 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G165))) (CL:BLOCK NIL (CL:LABELS ((~G1035 (~G164) (CL:TAGBODY ~G166 (CL:COND ((== ~G164 ~G165) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:LABELS ((~G1036 (I) (ENQUEUE (STREAM-USER-DETAIL STR) I))) (~G1036 (ELT ~G163 ~G164))) (CL:SETQ ~G164 (NUMBER+ 1 ~G164)) (CL:GO ~G166)))) (~G1035 0))))) (~G1034 (INTEGER (CL:LENGTH ~G163))))))))) (~G1033 X))) (T (ENQUEUE (STREAM-USER-DETAIL STR) X)))) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (NOT (QUEUE-LIST (STREAM-USER-DETAIL _)))))))))
(CL:DEFUN READ-STRING (STR) (CL:BLOCK READ-STRING (CL:BLOCK NIL (CL:LABELS ((F NIL (CL:BLOCK NIL (CL:LABELS ((~G1037 (!) (CL:COND ((NOT (EQL ! #\")) (CL:PROGN (CL:CONS (CL:COND ((EQL ! #\\) (READ-CHAR STR)) (T !)) (F))))))) (~G1037 (READ-CHAR STR)))))) (LIST-STRING (F))))))
(CL:DEFUN READ-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ-CHAR (CL:BLOCK NIL (%TRACK-LOCATION (STREAM-INPUT-LOCATION STR) (READ-CHAR-0 STR)))))
(CL:DEFUN WHITESPACE? (X) (CL:BLOCK WHITESPACE? (CL:BLOCK NIL (CL:COND ((CHARACTER? X) (CL:COND ((< (CL:CHAR-CODE X) 33) (>= (CL:CHAR-CODE X) 0))))))))
(CL:DEFUN SKIP-COMMENT (STR) (CL:BLOCK SKIP-COMMENT (CL:BLOCK NIL (CL:LABELS ((~G1038 (!) (CL:COND (! (CL:PROGN (CL:COND ((== (CL:CHAR-CODE !) 10) (SKIP-SPACES STR)) (T (SKIP-COMMENT STR)))))))) (~G1038 (READ-CHAR STR))))))
(CL:DEFUN AHEAD? (WHAT STR) (CL:BLOCK AHEAD? (CL:BLOCK NIL (CL:LABELS ((~G1039 (!) (CL:COND ((CL:COND ((FUNCTION? WHAT) (FUNCALL WHAT !)) (T (EQL WHAT !))) !)))) (~G1039 (PEEK-CHAR STR))))))
(CL:DEFUN DOT-EXPAND-TAIL-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-TAIL-LENGTH (CL:BLOCK NIL (CL:COND ((EQL #\. (CL:CAR (LAST X))) (DOT-EXPAND-TAIL-LENGTH (BUTLAST X) (++ NUM))) (T (VALUES NUM X))))))
(CL:DEFUN DOT-EXPAND-HEAD-LENGTH (X CL:&OPTIONAL (NUM 0)) (CL:BLOCK DOT-EXPAND-HEAD-LENGTH (CL:BLOCK NIL (CL:COND ((EQL #\. (CL:CAR X)) (DOT-EXPAND-HEAD-LENGTH (CL:CDR X) (++ NUM))) (T (VALUES NUM X))))))
(CL:DEFUN POSITION (OBJ SEQ CL:&KEY (START NIL) (END NIL) (FROM-END NIL) (TEST (CL:FUNCTION EQL))) (CL:BLOCK POSITION (CL:BLOCK NIL (CL:LABELS ((~G1040 (!) (FIND-IF (CL:LAMBDA (X I) (CL:COND ((FUNCALL TEST X OBJ) (CL:PROGN (CL:SETQ ! I))))) SEQ :START START :END END :FROM-END FROM-END :WITH-INDEX T) !)) (~G1040 NIL)))))
(CL:DEFUN SUBSEQ-SEQUENCE (MAKER SEQ START END) (CL:BLOCK SUBSEQ-SEQUENCE (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1041 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:SETQ END !)))) (CL:LABELS ((~G1042 (L) (CL:LABELS ((~G1043 (S) (CL:LABELS ((~G1044 (~G91) (CL:COND ((< ~G91 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G91))) (CL:BLOCK NIL (CL:LABELS ((~G1045 (X) (CL:TAGBODY ~G92 (CL:COND ((== X ~G91) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (=-ELT (ELT SEQ (+ START X)) S X)) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G92)))) (~G1045 0))))) (~G1044 (INTEGER L))))) (~G1043 (FUNCALL MAKER L))))) (~G1042 (- END START)))))))) (~G1041 (CL:LENGTH SEQ)))))))))
(CL:DEFUN STRING-SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK STRING-SUBSEQ (CL:BLOCK NIL (CL:COND ((NOT (== START END)) (CL:PROGN (CL:LABELS ((~G1046 (!) (CL:COND ((< START !) (CL:PROGN (CL:COND ((>= END !) (CL:PROGN (CL:PROGN (CL:SETQ END !))))) (CL:LABELS ((~G1047 (L) (CL:LABELS ((~G1048 (S) (CL:LABELS ((~G1049 (~G59) (CL:COND ((< ~G59 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G59))) (CL:BLOCK NIL (CL:LABELS ((~G1050 (X) (CL:TAGBODY ~G60 (CL:COND ((== X ~G59) (CL:RETURN-FROM NIL (CL:PROGN S)))) (CL:PROGN (CL:SETQ S (STRING-CONCAT S (STRING (ELT SEQ (NUMBER+ START X)))))) (CL:SETQ X (NUMBER+ 1 X)) (CL:GO ~G60)))) (~G1050 0))))) (~G1049 (INTEGER L))))) (~G1048 (CL:MAKE-STRING 0))))) (~G1047 (- END START)))))))) (~G1046 (CL:LENGTH SEQ)))))))))
(CL:DEFUN %BODY? (X) (CL:BLOCK %BODY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%BODY (CL:CAR X)) X)))))))
(CL:DEFUN %REST? (X) (CL:BLOCK %REST? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%REST (CL:CAR X)) X)))))))
(CL:DEFUN KEYWORD? (X) (CL:BLOCK KEYWORD? (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (EQ *KEYWORD-PACKAGE* (SYMBOL-PACKAGE X)))))))
(CL:DEFUN TYPED-ARGUMENT? (X) (CL:BLOCK TYPED-ARGUMENT? (CL:BLOCK NIL (CL:COND ((CONS? X) (ARGUMENT-TYPE-SPECIFIER? (CL:CAR (CL:CDR X))))))))
(CL:DEFUN NCONC (CL:&REST LSTS) (CL:BLOCK NCONC (CL:BLOCK NIL (%NCONC-0 LSTS))))
(CL:DEFUN ARGUMENT-KEYWORD? (X) (CL:BLOCK ARGUMENT-KEYWORD? (CL:BLOCK NIL (CL:LABELS ((~G1051 (~G4) (CL:COND (~G4 ~G4) (T (CL:LABELS ((~G1052 (~G5) (CL:COND (~G5 ~G5) (T (CL:LABELS ((~G1053 (~G6) (CL:COND (~G6 ~G6) (T (EQ X 'CL:&KEY))))) (~G1053 (EQ X 'CL:&OPTIONAL))))))) (~G1052 (EQ X 'CL:&BODY))))))) (~G1051 (EQ X 'CL:&REST))))))
(CL:DEFUN ARGDEF-GET-VALUE (DEFS VALS) (CL:BLOCK ARGDEF-GET-VALUE (CL:BLOCK NIL (CL:COND ((CONS? VALS) (CL:CAR VALS)) ((CONS? (CL:CAR DEFS)) (CADR (CL:CAR DEFS))) (T (CL:CAR DEFS))))))
(CL:DEFUN $ (CL:&REST ARGS) (CL:BLOCK $ (CL:BLOCK NIL (MAKE-SYMBOL (CL:APPLY (CL:FUNCTION +) (DYNAMIC-MAP (CL:FUNCTION STRING) ARGS))))))
(CL:DEFUN TYPE? (O X) (CL:BLOCK TYPE? (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:COND ((CONS? X) (CL:LABELS ((~G1054 (~G335) (CL:COND ((EQL ~G335 'AND) (EVERY (CL:LAMBDA (_) (CL:BLOCK NIL (TYPE? O _))) (CL:CDR X))) ((EQL ~G335 'OR) (SOME (CL:LAMBDA (_) (CL:BLOCK NIL (TYPE? O _))) (CL:CDR X))) ((EQL ~G335 'SATISFIES) (FUNCALL (CL:LABELS ((~G1055 (~G336) (CL:COND (~G336 ~G336) (T (ERROR "~A is not a predicate for SATISFIES." (CL:CAR (CL:CDR X))))))) (~G1055 (SYMBOL-FUNCTION (CL:CAR (CL:CDR X))))) O)) (T (CL:LABELS ((~G1056 (!) (CL:COND (! (CL:APPLY (%TYPE-FUN !) (CL:CDR X))) (T (ERROR "Unknown type specifier symbol ~A." (CL:CAR X)))))) (~G1056 (FIND-TYPE (CL:CAR X)))))))) (~G1054 (CL:CAR X)))) (T (CL:COND ((STRING? X) (EQUAL O X)) (T (TYPE? O (FUNCALL (CL:LABELS ((~G1057 (~G337) (CL:COND (~G337 ~G337) (T (ERROR "No type specifier for ~A." X))))) (~G1057 (%TYPE-FUN (FIND-TYPE X))))))))))))))))
(CL:DEFUN ARGDEF-GET-TYPE (X) (CL:BLOCK ARGDEF-GET-TYPE (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((ARGUMENT-TYPE-SPECIFIER? (CL:CAR (CL:CDR X))) (CL:CAR (CL:CDR X)))))))))
(CL:DEFUN ARGDEF-GET-NAME (X) (CL:BLOCK ARGDEF-GET-NAME (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:CAR X)) (T X)))))
(CL:DEFUN MAKE-&KEY-ALIST (DEF) (CL:BLOCK MAKE-&KEY-ALIST (CL:BLOCK NIL (CL:LABELS ((~G1058 (KEYS) (CL:LABELS ((MAKE-&KEY-DESCR (_) (CL:BLOCK NIL (CL:COND (_ (CL:PROGN (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR _)) (COPY-DEF-UNTIL-&KEY _)) (T (CL:LABELS ((~G1059 (!) (CL:PROGN (CL:SETQ KEYS (CL:CONS (CL:COND ((CONS? !) (CL:CONS (CL:CAR !) (ARGDEF-GET-DEFAULT !))) (T (CL:CONS ! !))) KEYS))) (MAKE-&KEY-DESCR (CL:CDR _)))) (~G1059 (CL:CAR _)))))))))) (COPY-DEF-UNTIL-&KEY (_) (CL:BLOCK NIL (CL:COND (_ (CL:PROGN (CL:COND ((EQ 'CL:&KEY (CL:CAR _)) (MAKE-&KEY-DESCR (CL:CDR _))) (T (CL:CONS (CL:CAR _) (COPY-DEF-UNTIL-&KEY (CL:CDR _))))))))))) (VALUES (COPY-DEF-UNTIL-&KEY DEF) (REVERSE KEYS))))) (~G1058 NIL)))))
(CL:DEFUN =-EXPANDER-LOOKUP (VAL ARR) (CL:BLOCK =-EXPANDER-LOOKUP (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 8)))))
(CL:DEFUN EXPANDER-MACROS (ARR) (CL:BLOCK EXPANDER-MACROS (CL:BLOCK NIL (CL:AREF ARR 3))))
(CL:DEFUN =-EXPANDER-CALL (VAL ARR) (CL:BLOCK =-EXPANDER-CALL (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 5)))))
(CL:DEFUN EXPANDER-ARGDEF (EXPANDER MACRO-NAME) (CL:BLOCK EXPANDER-ARGDEF (CL:BLOCK NIL (CL:CAR (EXPANDER-MACRO EXPANDER MACRO-NAME)))))
(CL:DEFUN =-EXPANDER-PRED (VAL ARR) (CL:BLOCK =-EXPANDER-PRED (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 4)))))
(CL:DEFUN EXPANDER-FUNCTION (EXPANDER MACRO-NAME) (CL:BLOCK EXPANDER-FUNCTION (CL:BLOCK NIL (CL:CDR (EXPANDER-MACRO EXPANDER MACRO-NAME)))))
(CL:DEFUN MAKE-EXPANDER (CL:&KEY (NAME 'NAME) (MACROS 'MACROS) (PRED 'PRED) (CALL 'CALL) (PRE 'PRE) (POST 'POST) (LOOKUP 'LOOKUP) (USER 'USER)) (CL:BLOCK MAKE-EXPANDER (CL:BLOCK NIL (CL:LABELS ((~G1060 (~G345) (CL:PROGN (=-AREF 'STRUCT ~G345 0) (=-AREF 'EXPANDER ~G345 1)) (CL:PROGN (=-AREF (CL:COND ((EQ NAME 'NAME) NIL) (T NAME)) ~G345 2)) (CL:PROGN (=-AREF (CL:COND ((EQ MACROS 'MACROS) NIL) (T MACROS)) ~G345 3)) (CL:PROGN (=-AREF (CL:COND ((EQ PRED 'PRED) NIL) (T PRED)) ~G345 4)) (CL:PROGN (=-AREF (CL:COND ((EQ CALL 'CALL) NIL) (T CALL)) ~G345 5)) (CL:PROGN (=-AREF (CL:COND ((EQ PRE 'PRE) NIL) (T PRE)) ~G345 6)) (CL:PROGN (=-AREF (CL:COND ((EQ POST 'POST) NIL) (T POST)) ~G345 7)) (CL:PROGN (=-AREF (CL:COND ((EQ LOOKUP 'LOOKUP) NIL) (T LOOKUP)) ~G345 8)) (CL:PROGN (=-AREF (CL:COND ((EQ USER 'USER) NIL) (T USER)) ~G345 9)) ~G345)) (~G1060 (MAKE-ARRAY 10))))))
(CL:DEFUN EXPANDER-NAME (ARR) (CL:BLOCK EXPANDER-NAME (CL:BLOCK NIL (CL:AREF ARR 2))))
(CL:DEFUN INIT-COMPILER-MACROS NIL (CL:BLOCK INIT-COMPILER-MACROS (CL:BLOCK NIL (CL:PROGN (CL:SETQ *TAGBODY-REPLACEMENTS* NIL)))))
(CL:DEFUN DEFINE-EXPANDER (EXPANDER-NAME CL:&KEY (PRE NIL) (POST NIL) (PRED NIL) (CALL NIL)) (CL:BLOCK DEFINE-EXPANDER (CL:BLOCK NIL (CL:LABELS ((~G1061 (!) (CL:LABELS ((~G1062 (~G348) (CL:COND (~G348 ~G348) (T (CL:PROGN (=-EXPANDER-PRED (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((CONS? _) (CL:COND ((SYMBOL? (CL:CAR _)) (EXPANDER-FUNCTION ! (CL:CAR _)))))))) !)))))) (~G1062 PRED)) (CL:LABELS ((~G1063 (~G349) (CL:COND (~G349 ~G349) (T (CL:PROGN (=-EXPANDER-CALL (CL:LAMBDA (_) (CL:BLOCK NIL (CL:APPLY (EXPANDER-FUNCTION ! (CL:CAR _)) (ARGUMENT-EXPAND-VALUES (CL:CAR _) (EXPANDER-ARGDEF ! (CL:CAR _)) (CL:CDR _))))) !)))))) (~G1063 CALL)) (CL:PROGN (=-EXPANDER-LOOKUP (CL:LAMBDA (EXPANDER NAME) (HREF (EXPANDER-MACROS EXPANDER) NAME)) !)) !)) (~G1061 (MAKE-EXPANDER :NAME EXPANDER-NAME :MACROS (MAKE-HASH-TABLE :TEST (CL:FUNCTION EQ)) :PRED PRED :CALL CALL :PRE (CL:LABELS ((~G1064 (~G346) (CL:COND (~G346 ~G346) (T (CL:LAMBDA NIL NIL))))) (~G1064 PRE)) :POST (CL:LABELS ((~G1065 (~G347) (CL:COND (~G347 ~G347) (T (CL:LAMBDA NIL NIL))))) (~G1065 POST))))))))
(CL:DEFUN LIST-SUBSEQ (SEQ START CL:&OPTIONAL (END 999999)) (CL:BLOCK LIST-SUBSEQ (CL:BLOCK NIL (CL:COND ((CL:COND (SEQ (NOT (== START END)))) (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1066 (~G89) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G89)))) (~G1066 START)))) (CL:LABELS ((~G1067 (Q) (CL:LABELS ((~G1068 (LEN) (CL:LABELS ((~G1069 (LST) (CL:BLOCK NIL (CL:PROGN (CL:TAGBODY ~G90 (CL:COND ((NOT (CL:COND (LST (< 0 LEN)))) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST Q))))) (ENQUEUE Q (CL:CAR LST)) (CL:PROGN (CL:SETQ LEN (- LEN 1))) (CL:PROGN (CL:SETQ LST (CL:CDR LST))) (CL:GO ~G90)))))) (~G1069 (NTHCDR START SEQ))))) (~G1068 (- END START))))) (~G1067 (MAKE-QUEUE)))))))))
(CL:DEFUN CARLIST (~G36) (CL:BLOCK CARLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CAR) ~G36))))
(CL:DEFUN ARGUMENT-EXPAND-0 (FUN ADEF VALS APPLY-VALUES? BREAK-ON-ERRORS?) (CL:BLOCK ARGUMENT-EXPAND-0 (CL:BLOCK NIL (CL:LABELS ((~G1070 (~G185) (CL:LABELS ((~G1071 (~G186) (CL:COND ((NOT (EQ (CL:CAR ~G185) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G185)))) (CL:LABELS ((~G1072 (ARGDEFS) (CL:LABELS ((~G1073 (~G187) (CL:LABELS ((~G1074 (KEY-ARGS) (CL:LABELS ((~G1075 (NUM) (CL:LABELS ((~G1076 (NO-STATIC) (CL:LABELS ((~G1077 (REST-ARG) (CL:LABELS ((ERR (MSG ARGS) (CL:COND (BREAK-ON-ERRORS? (ERROR (+ "~LIn argument expansion for ~A:~A: ~A~%" "Argument definition: ~A~%" "Given arguments: ~A~%") (CL:PACKAGE-NAME (SYMBOL-PACKAGE FUN)) (SYMBOL-NAME FUN) (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS) ADEF VALS)) (T :ERROR))) (EXP-STATIC-ASSERT (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Static argument definition after ~A." (LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((NOT VALS) (CL:RETURN-FROM NIL (ERR "Argument ~A missing." (LIST NUM)))))))) (EXP-STATIC (DEF VALS) (EXP-STATIC-ASSERT DEF VALS) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-STATIC-TYPED (DEF VALS) (EXP-STATIC-ASSERT DEF VALS) (CL:LABELS ((~G1078 (!) (CL:COND ((NOT (CL:LABELS ((~G1079 (~G182) (CL:COND (~G182 ~G182) (T (TYPE? (CL:CAR VALS) !))))) (~G1079 (CL:COND ((STRING? !) (EQUAL (CL:CAR VALS) !)))))) (CL:PROGN (CL:RETURN-FROM NIL (ERR "\"~A\" expected for argument ~A." (LIST (ARGDEF-GET-TYPE (CL:CAR DEF)) (ARGDEF-GET-NAME (CL:CAR DEF)))))))))) (~G1078 (ARGDEF-GET-TYPE (CL:CAR DEF)))) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (CL:CAR VALS)) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-KEY (DEF VALS) (CL:LABELS ((~G1080 (K) (CL:COND (K (CL:LABELS ((~G1081 (!) (CL:COND ((NOT (CL:CDR !)) (CL:PROGN (CL:RETURN-FROM NIL (ERR "Value of ~A missing." (LIST (CL:CAR !))))))) (CL:RPLACD K (CL:CONS '%KEY (CL:CAR (CL:CDR !)))) (EXP-MAIN DEF (CL:CDR (CL:CDR !))))) (~G1081 VALS))) (T (EXP-MAIN-NON-KEY DEF VALS))))) (~G1080 (ASSOC ($ (CL:CAR VALS)) KEY-ARGS :TEST (CL:FUNCTION EQ))))) (EXP-REST (SYNONYM DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&REST)) (CL:PROGN (CL:SETQ REST-ARG (LIST (CL:CONS (ARGDEF-GET-NAME (CL:CAR (CL:CDR DEF))) (CL:CONS SYNONYM VALS))))) NIL) (EXP-OPTIONAL (DEF VALS) (CL:PROGN (CL:SETQ NO-STATIC 'CL:&OPTIONAL)) (CL:CONS (CL:CONS (ARGDEF-GET-NAME (CL:CAR DEF)) (ARGDEF-GET-VALUE DEF VALS)) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR (CL:CDR DEF))) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS))) ((CL:CDR DEF) (EXP-OPTIONAL (CL:CDR DEF) (CL:CDR VALS))) (T (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))))) (EXP-OPTIONAL-REST (DEF VALS) (CL:LABELS ((~G1082 (~G183) (CL:COND ((EQ ~G183 'CL:&REST) (EXP-REST '%REST DEF VALS)) ((EQ ~G183 'CL:&BODY) (EXP-REST '%BODY DEF VALS)) ((EQ ~G183 'CL:&OPTIONAL) (EXP-OPTIONAL (CL:CDR DEF) VALS))))) (~G1082 (CL:CAR DEF)))) (EXP-SUB (DEF VALS) (CL:COND (NO-STATIC (CL:RETURN-FROM NIL (ERR "Argument sublist definition after ~A." (LIST NO-STATIC))))) (CL:COND (APPLY-VALUES? (CL:COND ((ATOM (CL:CAR VALS)) (CL:RETURN-FROM NIL (ERR "Sublist expected for ~A." (LIST (CL:CAR DEF)))))))) (NCONC (ARGUMENT-EXPAND-0 FUN (CL:CAR DEF) (CL:CAR VALS) APPLY-VALUES? BREAK-ON-ERRORS?) (EXP-MAIN (CL:CDR DEF) (CL:CDR VALS)))) (EXP-CHECK-TOO-MANY (DEF VALS) (CL:COND ((NOT DEF) (CL:COND (VALS (CL:RETURN-FROM NIL (ERR "~%~A too many argument(s): ~AMaximum is ~A." (LIST (CL:LENGTH VALS) VALS (CL:LENGTH ARGDEFS))))))))) (EXP-MAIN-NON-KEY (DEF VALS) (EXP-CHECK-TOO-MANY DEF VALS) (CL:COND ((ARGUMENT-KEYWORD? (CL:CAR DEF)) (EXP-OPTIONAL-REST DEF VALS)) ((TYPED-ARGUMENT? (CL:CAR DEF)) (EXP-STATIC-TYPED DEF VALS)) ((CONS? (CL:CAR DEF)) (EXP-SUB DEF VALS)) (T (EXP-STATIC DEF VALS)))) (EXP-MAIN (DEF VALS) (CL:PROGN (CL:SETQ NUM (NUMBER+ NUM 1))) (CL:COND ((KEYWORD? (CL:CAR VALS)) (EXP-KEY DEF VALS)) (T (CL:LABELS ((~G1083 (~G184) (CL:COND (~G184 ~G184) (T (CL:COND (DEF (EXP-MAIN-NON-KEY DEF VALS))))))) (~G1083 (EXP-CHECK-TOO-MANY DEF VALS))))))) (CL:LABELS ((~G1084 (!) (CL:COND ((EQ ! :ERROR) !) (T (NCONC ! (NCONC KEY-ARGS REST-ARG)))))) (~G1084 (EXP-MAIN ARGDEFS VALS)))))) (~G1077 NIL)))) (~G1076 NIL)))) (~G1075 0)))) (~G1074 (CL:CAR ~G187))))) (~G1073 (CL:LABELS ((~G1085 (~G189) (CL:COND (~G189 ~G189) (T (%ERROR "Not enough VALUES."))))) (~G1085 (CL:CDR ~G186))))))) (~G1072 (CL:CAR ~G186))))) (~G1071 (CL:CDR ~G185))))) (~G1070 (MAKE-&KEY-ALIST ADEF))))))
(CL:DEFUN %KEY? (X) (CL:BLOCK %KEY? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ '%KEY (CL:CAR X)) X)))))))
(CL:DEFUN %REST-OR-%BODY? (X) (CL:BLOCK %REST-OR-%BODY? (CL:BLOCK NIL (CL:LABELS ((~G1086 (~G178) (CL:COND (~G178 ~G178) (T (%BODY? X))))) (~G1086 (%REST? X))))))
(CL:DEFUN ++ (X) (CL:BLOCK ++ (CL:BLOCK NIL (NUMBER+ X 1))))
(CL:DEFUN SUBSEQ (SEQ START CL:&OPTIONAL (END 99999)) (CL:BLOCK SUBSEQ (CL:BLOCK NIL (CL:COND (SEQ (CL:PROGN (CL:COND ((> START END) (CL:LABELS ((~G1087 (~G93) (CL:PROGN (CL:SETQ START END) (CL:SETQ END ~G93)))) (~G1087 START)))) (CL:LABELS ((~G1088 (~G94) (CL:COND ((LIST? ~G94) (LIST-SUBSEQ SEQ START END)) ((STRING? ~G94) (STRING-SUBSEQ SEQ START END)) ((ARRAY? ~G94) (SUBSEQ-SEQUENCE (CL:FUNCTION MAKE-ARRAY) SEQ START END)) (T (ERROR "Type of ~A not supported." SEQ))))) (~G1088 SEQ))))))))
(CL:DEFUN DOT-POSITION (X) (CL:BLOCK DOT-POSITION (CL:BLOCK NIL (POSITION #\. X))))
(CL:DEFUN DOT-EXPAND-LIST (X) (CL:BLOCK DOT-EXPAND-LIST (CL:BLOCK NIL (CL:LABELS ((~G1089 (~G95) (CL:LABELS ((~G1090 (~G96) (CL:COND ((NOT (EQ (CL:CAR ~G95) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G95)))) (CL:LABELS ((~G1091 (NUM-CDRS) (CL:LABELS ((~G1092 (~G97) (CL:LABELS ((~G1093 (WITHOUT-START) (CL:LABELS ((~G1094 (~G100) (CL:LABELS ((~G1095 (~G101) (CL:COND ((NOT (EQ (CL:CAR ~G100) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G100)))) (CL:LABELS ((~G1096 (NUM-CARS) (CL:LABELS ((~G1097 (~G102) (CL:LABELS ((~G1098 (WITHOUT-END) (CL:LABELS ((F (WHICH NUM X) (CL:COND ((< 0 NUM) (CL:CONS WHICH (CL:CONS (F WHICH (-- NUM) X) NIL))) (T X)))) (F 'CL:CAR NUM-CARS (F 'CL:CDR NUM-CDRS (DOT-EXPAND (MAKE-SYMBOL (LIST-STRING WITHOUT-END)))))))) (~G1098 (CL:CAR ~G102))))) (~G1097 (CL:LABELS ((~G1099 (~G104) (CL:COND (~G104 ~G104) (T (%ERROR "Not enough VALUES."))))) (~G1099 (CL:CDR ~G101))))))) (~G1096 (CL:CAR ~G101))))) (~G1095 (CL:CDR ~G100))))) (~G1094 (DOT-EXPAND-TAIL-LENGTH WITHOUT-START))))) (~G1093 (CL:CAR ~G97))))) (~G1092 (CL:LABELS ((~G1100 (~G99) (CL:COND (~G99 ~G99) (T (%ERROR "Not enough VALUES."))))) (~G1100 (CL:CDR ~G96))))))) (~G1091 (CL:CAR ~G96))))) (~G1090 (CL:CDR ~G95))))) (~G1089 (DOT-EXPAND-HEAD-LENGTH X))))))
(CL:DEFUN HAS-DOT-NOTATION? (X) (CL:BLOCK HAS-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1101 (!) (CL:LABELS ((~G1102 (~G106) (CL:COND (~G106 ~G106) (T (EQL #\. (ELT ! (-- (CL:LENGTH !)))))))) (~G1102 (EQL #\. (ELT ! 0)))))) (~G1101 (SYMBOL-NAME X))))))
(CL:DEFUN NO-DOT-NOTATION? (X) (CL:BLOCK NO-DOT-NOTATION? (CL:BLOCK NIL (CL:LABELS ((~G1103 (SL) (CL:LABELS ((~G1104 (L) (CL:LABELS ((~G1105 (~G105) (CL:COND (~G105 ~G105) (T (NOT (DOT-POSITION SL)))))) (~G1105 (== 1 L))))) (~G1104 (CL:LENGTH SL))))) (~G1103 (STRING-LIST (SYMBOL-NAME X)))))))
(CL:DEFUN SKIP-SPACES (STR) (CL:BLOCK SKIP-SPACES (CL:BLOCK NIL (CL:COND ((AHEAD? #\; STR) (CL:PROGN (SKIP-COMMENT STR)))) (CL:COND ((AHEAD? (CL:FUNCTION WHITESPACE?) STR) (CL:PROGN (READ-CHAR STR) (SKIP-SPACES STR)))))))
(CL:DEFUN READ-ATOM (STR TOKEN PKG SYM) (CL:BLOCK READ-ATOM (CL:BLOCK NIL (CL:LABELS ((~G1106 (~G280) (CL:COND ((EQ ~G280 :DBLQUOTE) (READ-STRING STR)) ((EQ ~G280 :CHAR) (READ-CHAR STR)) ((EQ ~G280 :NUMBER) (CL:LABELS ((~G1107 (S) (PRINC SYM S) (READ-NUMBER S))) (~G1107 (MAKE-STRING-STREAM)))) ((EQ ~G280 :HEXNUM) (READ-HEX STR)) ((EQ ~G280 :ARRAY) (CL:CONS 'ARRAY (READ-CONS-SLOT STR))) ((EQ ~G280 :FUNCTION) (CL:CONS 'CL:FUNCTION (CL:CONS (READ-EXPR STR) NIL))) ((EQ ~G280 :SYMBOL) (READ-SYMBOL-OR-SLOT-VALUE PKG SYM)) (T (CL:COND ((%READ-CLOSING-PARENS? TOKEN) (ERROR "Unexpected closing ~A." (CL:LABELS ((~G1108 (~G281) (CL:COND ((EQL ~G281 :PARENTHESIS-CLOSE) "parenthesis") ((EQL ~G281 :BRACE-CLOSE) "brace") ((EQL ~G281 :BRACKET-CLOSE) "bracket")))) (~G1108 TOKEN)))) (T (ERROR "Closing bracket missing."))))))) (~G1106 TOKEN)))))
(CL:DEFUN READ-QUOTE (STR TOKEN) (CL:BLOCK READ-QUOTE (CL:BLOCK NIL (LIST (MAKE-SYMBOL (SYMBOL-NAME TOKEN)) (READ-EXPR STR)))))
(CL:DEFUN TOKEN-IS-QUOTE? (X) (CL:BLOCK TOKEN-IS-QUOTE? (CL:BLOCK NIL (CL:LABELS ((~G1109 (~G247) (CL:COND (~G247 ~G247) (T (CL:LABELS ((~G1110 (~G248) (CL:COND (~G248 ~G248) (T (CL:LABELS ((~G1111 (~G249) (CL:COND (~G249 ~G249) (T (EQL X :QUASIQUOTE-SPLICE))))) (~G1111 (EQL X :QUASIQUOTE))))))) (~G1110 (EQL X :BACKQUOTE))))))) (~G1109 (EQL X :QUOTE))))))
(CL:DEFUN READ-CONS-SLOT (STR) (CL:BLOCK READ-CONS-SLOT (CL:BLOCK NIL (CL:LABELS ((~G1112 (!) (CL:COND ((AHEAD? #\. STR) (CL:PROGN (READ-CHAR STR) (CL:LABELS ((~G1113 (~G305) (CL:LABELS ((~G1114 (~G306) (CL:COND ((NOT (EQ (CL:CAR ~G305) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G305)))) (CL:LABELS ((~G1115 (TOKEN) (CL:LABELS ((~G1116 (~G307) (CL:LABELS ((~G1117 (PKG) (CL:LABELS ((~G1118 (~G308) (CL:LABELS ((~G1119 (SYM) (READ-SLOT-VALUE (LIST ! SYM)))) (~G1119 (CL:CAR ~G308))))) (~G1118 (CL:LABELS ((~G1120 (~G311) (CL:COND (~G311 ~G311) (T (%ERROR "Not enough VALUES."))))) (~G1120 (CL:CDR ~G307))))))) (~G1117 (CL:CAR ~G307))))) (~G1116 (CL:LABELS ((~G1121 (~G310) (CL:COND (~G310 ~G310) (T (%ERROR "Not enough VALUES."))))) (~G1121 (CL:CDR ~G306))))))) (~G1115 (CL:CAR ~G306))))) (~G1114 (CL:CDR ~G305))))) (~G1113 (READ-TOKEN STR))))) (T !)))) (~G1112 (READ-CONS STR))))))
(CL:DEFUN READ-TOKEN (STR) (CL:BLOCK READ-TOKEN (CL:BLOCK NIL (CL:LABELS ((~G1122 (!) (CL:COND (! (CL:PROGN (CL:LABELS ((~G1123 (~G274) (CL:LABELS ((~G1124 (~G275) (CL:COND ((NOT (EQ (CL:CAR ~G274) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G274)))) (CL:LABELS ((~G1125 (PKG) (CL:LABELS ((~G1126 (~G276) (CL:LABELS ((~G1127 (SYM) (VALUES (CL:COND ((CL:COND (SYM (CL:COND ((NOT (CL:CDR SYM)) (EQL #\. (CL:CAR SYM)))))) :DOT) (T (CL:COND (SYM (CL:COND ((LIST-NUMBER? SYM) :NUMBER) (T :SYMBOL))) (T (CL:LABELS ((~G1128 (~G271) (CL:COND ((EQL ~G271 #\() :PARENTHESIS-OPEN) ((EQL ~G271 #\)) :PARENTHESIS-CLOSE) ((EQL ~G271 #\[) :BRACKET-OPEN) ((EQL ~G271 #\]) :BRACKET-CLOSE) ((EQL ~G271 #\{) :BRACE-OPEN) ((EQL ~G271 #\}) :BRACE-CLOSE) ((EQL ~G271 #\') :QUOTE) ((EQL ~G271 #\`) :BACKQUOTE) ((EQL ~G271 #\") :DBLQUOTE) ((EQL ~G271 #\,) (CL:COND ((AHEAD? #\@ STR) (CL:PROGN (READ-CHAR STR) :QUASIQUOTE-SPLICE)) (T :QUASIQUOTE))) ((EQL ~G271 #\#) (CL:LABELS ((~G1129 (~G272) (CL:COND ((EQL ~G272 #\\) :CHAR) ((EQL ~G272 #\x) :HEXNUM) ((EQL ~G272 #\') :FUNCTION) ((EQL ~G272 #\() :ARRAY) ((EQL ~G272 #\|) (READ-COMMENT-BLOCK STR)) (T (ERROR "Reader macro #~A unsupported." !))))) (~G1129 (READ-CHAR STR)))) ((EQL ~G271 -1) :EOF)))) (~G1128 (READ-CHAR STR))))))) (CL:LABELS ((~G1130 (~G273) (CL:COND (~G273 ~G273) (T *PACKAGE*)))) (~G1130 PKG)) (LIST-STRING SYM)))) (~G1127 (CL:CAR ~G276))))) (~G1126 (CL:LABELS ((~G1131 (~G278) (CL:COND (~G278 ~G278) (T (%ERROR "Not enough VALUES."))))) (~G1131 (CL:CDR ~G275))))))) (~G1125 (CL:CAR ~G275))))) (~G1124 (CL:CDR ~G274))))) (~G1123 !))))))) (~G1122 (READ-SYMBOL-AND-PACKAGE STR))))))
(CL:DEFUN =-STREAM-LAST-CHAR (VAL ARR) (CL:BLOCK =-STREAM-LAST-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 6)))))
(CL:DEFUN STREAM-FUN-IN (ARR) (CL:BLOCK STREAM-FUN-IN (CL:BLOCK NIL (CL:AREF ARR 3))))
(CL:DEFUN READ-PEEKED-CHAR (STR) (CL:BLOCK READ-PEEKED-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1132 (~G226) (CL:PROGN (=-STREAM-PEEKED-CHAR NIL STR)) ~G226)) (~G1132 (STREAM-PEEKED-CHAR STR))))))
(CL:DEFUN NTHCDR (IDX X) (CL:BLOCK NTHCDR (CL:BLOCK NIL (CL:COND (X (CL:COND ((== 0 IDX) X) (T (NTHCDR (-- IDX) (CL:CDR X)))))))))
(CL:DEFUN FRESH-LINE? (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE? (CL:BLOCK NIL (CL:LABELS ((~G1133 (!) (CL:COND ((STREAM-LOCATION-TRACK? !) (== 1 (STREAM-LOCATION-COLUMN !)))))) (~G1133 (STREAM-OUTPUT-LOCATION STR))))))
(CL:DEFUN GET-STREAM-STRING (STR) (CL:BLOCK GET-STREAM-STRING (CL:BLOCK NIL (CL:LABELS ((~G1134 (~G167) (CL:PROGN (=-STREAM-USER-DETAIL (MAKE-QUEUE) STR)) ~G167)) (~G1134 (QUEUE-STRING (STREAM-USER-DETAIL STR)))))))
(CL:DEFUN FORCE-OUTPUT (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FORCE-OUTPUT (CL:BLOCK NIL (%FORCE-OUTPUT (STREAM-HANDLE STR)))))
(CL:DEFUN PRINT-HEXWORD (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINT-HEXWORD (CL:BLOCK NIL (PRINT-HEX X 4 STR))))
(CL:DEFUN PRINT-HEXBYTE (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINT-HEXBYTE (CL:BLOCK NIL (PRINT-HEX X 2 STR))))
(CL:DEFUN PRINC (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK PRINC (CL:BLOCK NIL (CL:LABELS ((~G1135 (~G172) (CL:LABELS ((~G1136 (S) (CL:LABELS ((~G1137 (~G173) (CL:COND (~G172 ~G173) (T (GET-STREAM-STRING S))))) (~G1137 (CL:PROGN (CL:COND ((NUMBER? X) (PRINC-NUMBER X S)) ((SYMBOL? X) (STREAM-PRINC (SYMBOL-NAME X) S)) (T (STREAM-PRINC X S))) X))))) (~G1136 (DEFAULT-STREAM ~G172))))) (~G1135 STR)))))
(CL:DEFUN LATE-PRINT (X CL:&OPTIONAL (STR *STANDARD-OUTPUT*) CL:&KEY (PRINT-INFO (MAKE-PRINT-INFO))) (CL:BLOCK LATE-PRINT (CL:BLOCK NIL (CL:LABELS ((~G1138 (~G224) (CL:LABELS ((~G1139 (S) (CL:LABELS ((~G1140 (~G225) (CL:COND (~G224 ~G225) (T (GET-STREAM-STRING S))))) (~G1140 (CL:PROGN (CL:COND ((CL:COND ((CONS? X) (CONS? (CL:CAR X)))) (CL:PROGN (%PRINT-INDENTATION S PRINT-INFO) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CONS (STREAM-LOCATION-COLUMN (STREAM-OUTPUT-LOCATION STR)) (PRINT-INFO-COLUMNS PRINT-INFO)) PRINT-INFO)) (PRINC "(" S) (%PRINT-BODY X S PRINT-INFO) (PRINC ")" S) (CL:LABELS ((~G1141 (RET) (CL:PROGN (=-PRINT-INFO-COLUMNS (CL:CDR (PRINT-INFO-COLUMNS PRINT-INFO)) PRINT-INFO)) RET)) (~G1141 (CL:CAR (PRINT-INFO-COLUMNS PRINT-INFO)))))) (T (%LATE-PRINT X S PRINT-INFO))) (CL:COND (*PRINT-AUTOMATIC-NEWLINE?* (CL:COND ((NOT (FRESH-LINE? S)) (TERPRI S)))))))))) (~G1139 (DEFAULT-STREAM ~G224))))) (~G1138 STR)) X)))
(CL:DEFUN TERPRI (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK TERPRI (CL:BLOCK NIL (CL:LABELS ((~G1142 (~G174) (CL:LABELS ((~G1143 (S) (CL:LABELS ((~G1144 (~G175) (CL:COND (~G174 ~G175) (T (GET-STREAM-STRING S))))) (~G1144 (CL:PROGN (STREAM-PRINC (CODE-CHAR 10) S) (FORCE-OUTPUT S) NIL))))) (~G1143 (DEFAULT-STREAM ~G174))))) (~G1142 STR)))))
(CL:DEFUN DEFAULT-STREAM (X) (CL:BLOCK DEFAULT-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1145 (~G168) (CL:COND ((EQL ~G168 NIL) (MAKE-STRING-STREAM)) ((EQL ~G168 T) *STANDARD-OUTPUT*) (T X)))) (~G1145 X)))))
(CL:DEFUN EXPANDER-EXPAND (EXPANDER EXPR) (CL:BLOCK EXPANDER-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1146 (~G354) (CL:COND (~G354 ~G354) (T (ERROR "Expander ~A is not defined." (EXPANDER-NAME EXPANDER)))))) (~G1146 (EXPANDER? EXPANDER))) (FUNCALL (EXPANDER-PRE EXPANDER)) (CL:LABELS ((~G1147 (~G355) (FUNCALL (EXPANDER-POST EXPANDER)) ~G355)) (~G1147 (REFINE (CL:LAMBDA (_) (CL:BLOCK NIL (EXPANDER-EXPAND-0 EXPANDER _))) EXPR))))))
(CL:DEFUN %MAP-ARGS (LISTS) (CL:BLOCK %MAP-ARGS (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1148 (I) (CL:LABELS ((~G1149 (NL) (CL:TAGBODY START (CL:COND ((NOT I) (CL:RETURN-FROM NIL (QUEUE-LIST NL)))) (CL:COND ((NOT (CL:CAR I)) (CL:RETURN-FROM NIL NIL))) (ENQUEUE NL (CL:CAR (CL:CAR I))) (CL:RPLACA I (CL:CDR (CL:CAR I))) (CL:SETQ I (CL:CDR I)) (CL:GO START)))) (~G1149 (MAKE-QUEUE))))) (~G1148 LISTS))))))
(CL:DEFUN -- (X) (CL:BLOCK -- (CL:BLOCK NIL (NUMBER- X 1))))
(CL:DEFUN ENQUEUE (X CL:&REST VALS) (CL:BLOCK ENQUEUE (CL:BLOCK NIL (CL:RPLACA X (CL:CDR (CL:RPLACD (CL:LABELS ((~G1150 (~G7) (CL:COND (~G7 ~G7) (T X)))) (~G1150 (CL:CAR X))) VALS))) VALS)))
(CL:DEFUN QUEUE-LIST (X) (CL:BLOCK QUEUE-LIST (CL:BLOCK NIL (CL:CDR X))))
(CL:DEFUN MAKE-QUEUE NIL (CL:BLOCK MAKE-QUEUE (CL:BLOCK NIL (CL:CONS NIL NIL))))
(CL:DEFUN CHAR-UPCASE (C) (CL:BLOCK CHAR-UPCASE (CL:BLOCK NIL (CL:COND ((LOWER-CASE? C) (CODE-CHAR (- (+ (CL:CHAR-CODE C) (CL:CHAR-CODE #\A)) (CL:CHAR-CODE #\a)))) (T C)))))
(CL:DEFUN MAKE-STREAM (CL:&KEY (HANDLE 'HANDLE) (FUN-IN 'FUN-IN) (FUN-OUT 'FUN-OUT) (FUN-EOF 'FUN-EOF) (LAST-CHAR 'LAST-CHAR) (PEEKED-CHAR 'PEEKED-CHAR) (INPUT-LOCATION 'INPUT-LOCATION) (OUTPUT-LOCATION 'OUTPUT-LOCATION) (USER-DETAIL 'USER-DETAIL)) (CL:BLOCK MAKE-STREAM (CL:BLOCK NIL (CL:LABELS ((~G1151 (~G153) (CL:PROGN (=-AREF 'STRUCT ~G153 0) (=-AREF 'STREAM ~G153 1)) (CL:PROGN (=-AREF (CL:COND ((EQ HANDLE 'HANDLE) NIL) (T HANDLE)) ~G153 2)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-IN 'FUN-IN) NIL) (T FUN-IN)) ~G153 3)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-OUT 'FUN-OUT) NIL) (T FUN-OUT)) ~G153 4)) (CL:PROGN (=-AREF (CL:COND ((EQ FUN-EOF 'FUN-EOF) NIL) (T FUN-EOF)) ~G153 5)) (CL:PROGN (=-AREF (CL:COND ((EQ LAST-CHAR 'LAST-CHAR) NIL) (T LAST-CHAR)) ~G153 6)) (CL:PROGN (=-AREF (CL:COND ((EQ PEEKED-CHAR 'PEEKED-CHAR) NIL) (T PEEKED-CHAR)) ~G153 7)) (CL:PROGN (=-AREF (CL:COND ((EQ INPUT-LOCATION 'INPUT-LOCATION) (MAKE-STREAM-LOCATION)) (T INPUT-LOCATION)) ~G153 8)) (CL:PROGN (=-AREF (CL:COND ((EQ OUTPUT-LOCATION 'OUTPUT-LOCATION) (MAKE-STREAM-LOCATION :TRACK? NIL)) (T OUTPUT-LOCATION)) ~G153 9)) (CL:PROGN (=-AREF (CL:COND ((EQ USER-DETAIL 'USER-DETAIL) NIL) (T USER-DETAIL)) ~G153 10)) ~G153)) (~G1151 (MAKE-ARRAY 11))))))
(CL:DEFUN %MACROEXPAND-BACKQUOTE (X) (CL:COND ((ATOM X) X) ((ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (CL:CONS (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR (CL:CAR X)))) (%MACROEXPAND-BACKQUOTE (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND-BACKQUOTE (CL:CAR X)) (%MACROEXPAND-BACKQUOTE (CL:CDR X))))))
(CL:DEFUN MAKE-STANDARD-STREAM NIL (CL:BLOCK MAKE-STANDARD-STREAM (CL:BLOCK NIL (MAKE-STREAM :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR NIL))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C NIL)) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF NIL)))))))
(CL:DEFUN MAKE-KEYWORD (X) (CL:BLOCK MAKE-KEYWORD (CL:BLOCK NIL (CL:COND (X (MAKE-SYMBOL (CL:COND ((SYMBOL? X) (SYMBOL-NAME X)) (T X)) *KEYWORD-PACKAGE*))))))
(CL:DEFUN UPCASE (STR) (CL:BLOCK UPCASE (CL:BLOCK NIL (LIST-STRING (DYNAMIC-MAP (CL:FUNCTION CHAR-UPCASE) (STRING-LIST STR))))))
(CL:DEFUN GENSYM-NUMBER NIL (CL:SETQ *GENSYM-COUNTER* (+ 1 *GENSYM-COUNTER*)))
(CL:DEFUN ARRAY-LIST (X) (CL:BLOCK ARRAY-LIST (CL:BLOCK NIL (CL:LABELS ((~G1152 (RESULT) (CL:LABELS ((~G1153 (~G51) (CL:COND ((< ~G51 0) (ERROR "DOTIMES: Number of iterations is negative: ~A." ~G51))) (CL:BLOCK NIL (CL:LABELS ((~G1154 (!) (CL:TAGBODY ~G52 (CL:COND ((== ! ~G51) (CL:RETURN-FROM NIL (CL:PROGN (QUEUE-LIST RESULT))))) (ENQUEUE RESULT (CL:AREF X !)) (CL:SETQ ! (NUMBER+ 1 !)) (CL:GO ~G52)))) (~G1154 0))))) (~G1153 (INTEGER (CL:LENGTH X)))))) (~G1152 (MAKE-QUEUE))))))
(CL:DEFUN STRING-LIST (X) (CL:BLOCK STRING-LIST (CL:BLOCK NIL (CL:LABELS ((~G1155 (L) (CL:LABELS ((~G1156 (S) (CL:BLOCK NIL (CL:LABELS ((~G1157 (I) (CL:TAGBODY ~G58 (CL:COND ((< I 0) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:PROGN (CL:SETQ S (CL:PROGN (CL:SETQ S (CL:CONS (ELT X I) S))))) (CL:SETQ I (-- I)) (CL:GO ~G58)))) (~G1157 (-- L)))) S)) (~G1156 NIL)))) (~G1155 (CL:LENGTH X))))))
(CL:DEFUN MAPCAR (FUNC CL:&REST LISTS) (CL:BLOCK MAPCAR (CL:BLOCK NIL (CL:LABELS ((~G1158 (ARGS) (CL:COND (ARGS (CL:CONS (CL:APPLY FUNC ARGS) (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS)))))) (~G1158 (%MAP-ARGS LISTS))))))
(CL:DEFUN BACKQUOTE? (X) (CL:BLOCK BACKQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'BACKQUOTE (CL:CAR X)) X)))))))
(CL:DEFUN QUOTE? (X) (CL:BLOCK QUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'CL:QUOTE (CL:CAR X)) X)))))))
(CL:DEFUN COMPILER-MACROEXPAND (X) (CL:BLOCK COMPILER-MACROEXPAND (CL:BLOCK NIL (EXPANDER-EXPAND *COMPILER-MACRO-EXPANDER* X))))
(CL:DEFUN CONSTANT-LITERAL? (X) (CL:BLOCK CONSTANT-LITERAL? (CL:BLOCK NIL (CL:LABELS ((~G1159 (~G422) (CL:COND (~G422 ~G422) (T (CL:LABELS ((~G1160 (~G423) (CL:COND (~G423 ~G423) (T (CL:LABELS ((~G1161 (~G424) (CL:COND (~G424 ~G424) (T (CL:LABELS ((~G1162 (~G425) (CL:COND (~G425 ~G425) (T (CL:LABELS ((~G1163 (~G426) (CL:COND (~G426 ~G426) (T (CL:LABELS ((~G1164 (~G427) (CL:COND (~G427 ~G427) (T (HASH-TABLE? X))))) (~G1164 (ARRAY? X))))))) (~G1163 (STRING? X))))))) (~G1162 (CHARACTER? X))))))) (~G1161 (NUMBER? X))))))) (~G1160 (EQ T X))))))) (~G1159 (NOT X))))))
(CL:DEFUN QUASIQUOTE-SPLICE? (X) (CL:BLOCK QUASIQUOTE-SPLICE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE-SPLICE (CL:CAR X)) X)))))))
(CL:DEFUN QUASIQUOTE? (X) (CL:BLOCK QUASIQUOTE? (CL:BLOCK NIL (CL:COND ((CONS? X) (CL:COND ((EQ 'QUASIQUOTE (CL:CAR X)) X)))))))
(CL:DEFUN %ERROR (MSG) (CL:BLOCK %ERROR (CL:BLOCK NIL (BREAK (FORMAT NIL "In file '~A':~%~A" *LOAD* MSG)))))
(CL:DEFUN FORMAT (STR TEXT CL:&REST ARGS) (CL:BLOCK FORMAT (CL:BLOCK NIL (CL:LABELS ((~G1165 (~G320) (CL:LABELS ((~G1166 (S) (CL:LABELS ((~G1167 (~G321) (CL:COND (~G320 ~G321) (T (GET-STREAM-STRING S))))) (~G1167 (CL:PROGN (CL:LABELS ((~G1168 (PROCESSED-ARGS) (CL:LABELS ((ERR-MISSING NIL (ERROR "Argument ~A specified in format \"~A\" is missing." PROCESSED-ARGS TEXT)) (EOL (TXT ARGS) (TERPRI S) (F TXT ARGS)) (D-PLACEHOLDER (TXT ARGS) (CL:COND (ARGS (CL:COND ((CONS? (CL:CAR ARGS)) (LATE-PRINT (CL:CAR ARGS) S)) (T (PRINC (CL:CAR ARGS) S)))) (T (ERR-MISSING))) (F TXT (CL:CDR ARGS))) (D-HEXADECIMAL (TXT ARGS) (CL:COND (ARGS (CL:COND ((CONS? (CL:CAR ARGS)) (LATE-PRINT (CL:CAR ARGS) S)) (T (CL:COND ((< (CL:CAR ARGS) 256) (PRINT-HEXBYTE (CL:CAR ARGS) S)) (T (PRINT-HEXWORD (CL:CAR ARGS) S)))))) (T (ERR-MISSING))) (F TXT (CL:CDR ARGS))) (D-FORCE-OUTPUT (TXT ARGS) (FORCE-OUTPUT S) (F TXT ARGS)) (D-FRESH-LINE (TXT ARGS) (FRESH-LINE S) (F TXT ARGS)) (TILDE (TXT ARGS) (PRINC #\~ S) (F TXT ARGS)) (DIRECTIVE (TXT ARGS) (CL:PROGN (CL:SETQ PROCESSED-ARGS (NUMBER+ PROCESSED-ARGS 1))) (CL:LABELS ((~G1169 (~G322) (CL:COND ((EQL ~G322 #\%) (EOL (CL:CDR TXT) ARGS)) ((EQL ~G322 #\A) (D-PLACEHOLDER (CL:CDR TXT) ARGS)) ((EQL ~G322 #\X) (D-HEXADECIMAL (CL:CDR TXT) ARGS)) ((EQL ~G322 #\F) (D-FORCE-OUTPUT (CL:CDR TXT) ARGS)) ((EQL ~G322 #\L) (D-FRESH-LINE (CL:CDR TXT) ARGS)) ((EQL ~G322 #\~) (CL:PROGN (PRINC (CL:CAR TXT) S) (F (CL:CDR TXT) ARGS))) (T (TILDE TXT ARGS))))) (~G1169 (CL:CAR TXT)))) (F (TXT ARGS) (CL:COND (TXT (CL:PROGN (CL:COND ((EQL (CL:CAR TXT) #\\) (CL:PROGN (PRINC (CL:CAR TXT) S) (PRINC (CL:CAR (CL:CDR TXT)) S) (F (CL:CDR (CL:CDR TXT)) ARGS))) ((EQL (CL:CAR TXT) #\~) (DIRECTIVE (CL:CDR TXT) ARGS)) (T (CL:PROGN (PRINC (CL:CAR TXT) S) (F (CL:CDR TXT) ARGS))))))))) (F (STRING-LIST TEXT) ARGS)))) (~G1168 0))))))) (~G1166 (DEFAULT-STREAM ~G320))))) (~G1165 STR)))))
(CL:DEFUN FRESH-LINE (CL:&OPTIONAL (STR *STANDARD-OUTPUT*)) (CL:BLOCK FRESH-LINE (CL:BLOCK NIL (CL:LABELS ((~G1170 (~G176) (CL:LABELS ((~G1171 (S) (CL:LABELS ((~G1172 (~G177) (CL:COND (~G176 ~G177) (T (GET-STREAM-STRING S))))) (~G1172 (CL:PROGN (CL:COND ((NOT (FRESH-LINE? S)) (CL:PROGN (TERPRI S) T)))))))) (~G1171 (DEFAULT-STREAM ~G176))))) (~G1170 STR)))))
(CL:DEFUN NTH (I X) (CL:BLOCK NTH (CL:BLOCK NIL (CL:CAR (NTHCDR I X)))))
(CL:DEFUN =-STREAM-PEEKED-CHAR (VAL ARR) (CL:BLOCK =-STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:PROGN (=-AREF VAL ARR 7)))))
(CL:DEFUN READ-CHAR-0 (STR) (CL:BLOCK READ-CHAR-0 (CL:BLOCK NIL (CL:LABELS ((~G1173 (~G227) (CL:COND (~G227 ~G227) (T (CL:PROGN (=-STREAM-LAST-CHAR (FUNCALL (STREAM-FUN-IN STR) STR) STR)))))) (~G1173 (READ-PEEKED-CHAR STR))))))
(CL:DEFUN STREAM-PEEKED-CHAR (ARR) (CL:BLOCK STREAM-PEEKED-CHAR (CL:BLOCK NIL (CL:AREF ARR 7))))
(CL:DEFUN READ-EXPR (STR) (CL:BLOCK READ-EXPR (CL:BLOCK NIL (CL:LABELS ((~G1174 (~G313) (CL:LABELS ((~G1175 (~G314) (CL:COND ((NOT (EQ (CL:CAR ~G313) *VALUES-MAGIC*)) (CL:PROGN (ERROR "VALUES expected instead of ~A." ~G313)))) (CL:LABELS ((~G1176 (TOKEN) (CL:LABELS ((~G1177 (~G315) (CL:LABELS ((~G1178 (PKG) (CL:LABELS ((~G1179 (~G316) (CL:LABELS ((~G1180 (SYM) (CL:LABELS ((~G1181 (~G312) (CL:COND ((EQL ~G312 NIL) NIL) ((EQL ~G312 :EOF) NIL) ((EQL ~G312 :PARENTHESIS-OPEN) (READ-CONS-SLOT STR)) ((EQL ~G312 :BRACKET-OPEN) (CL:CONS 'BRACKETS (READ-CONS-SLOT STR))) ((EQL ~G312 :BRACE-OPEN) (CL:CONS 'BRACES (READ-CONS-SLOT STR))) (T (CL:COND ((TOKEN-IS-QUOTE? TOKEN) (READ-QUOTE STR TOKEN)) (T (READ-ATOM STR TOKEN PKG SYM))))))) (~G1181 TOKEN)))) (~G1180 (CL:CAR ~G316))))) (~G1179 (CL:LABELS ((~G1182 (~G319) (CL:COND (~G319 ~G319) (T (%ERROR "Not enough VALUES."))))) (~G1182 (CL:CDR ~G315))))))) (~G1178 (CL:CAR ~G315))))) (~G1177 (CL:LABELS ((~G1183 (~G318) (CL:COND (~G318 ~G318) (T (%ERROR "Not enough VALUES."))))) (~G1183 (CL:CDR ~G314))))))) (~G1176 (CL:CAR ~G314))))) (~G1175 (CL:CDR ~G313))))) (~G1174 (READ-TOKEN STR))))))
(CL:DEFUN SEEK-CHAR (STR) (CL:BLOCK SEEK-CHAR (CL:BLOCK NIL (SKIP-SPACES STR) (PEEK-CHAR STR))))
(CL:DEFUN DOT-EXPAND-CONV (X) (CL:BLOCK DOT-EXPAND-CONV (CL:BLOCK NIL (CL:COND ((NO-DOT-NOTATION? X) X) (T (CL:LABELS ((~G1184 (SL) (CL:COND ((HAS-DOT-NOTATION? X) (DOT-EXPAND-LIST SL)) (T (CL:LABELS ((~G1185 (P) (CL:CONS '%SLOT-VALUE (CL:CONS (MAKE-SYMBOL (LIST-STRING (SUBSEQ SL 0 P))) (CL:CONS (DOT-EXPAND-CONV (MAKE-SYMBOL (LIST-STRING (SUBSEQ SL (++ P))))) NIL))))) (~G1185 (DOT-POSITION SL))))))) (~G1184 (STRING-LIST (SYMBOL-NAME X)))))))))
(CL:DEFUN %QUASIQUOTE-EXPAND (X) (CL:COND ((ATOM X) X) ((ATOM (CL:CAR X)) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'CL:QUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'BACKQUOTE) (CL:CONS (CL:CAR X) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE) (CL:CONS (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) ((EQ (CL:CAR (CL:CAR X)) 'QUASIQUOTE-SPLICE) (APPEND (EVAL (MACROEXPAND (CL:CAR (CL:CDR (CL:CAR X))))) (%QUASIQUOTE-EXPAND (CL:CDR X)))) (T (CL:CONS (%QUASIQUOTE-EXPAND (CL:CAR X)) (%QUASIQUOTE-EXPAND (CL:CDR X))))))
(CL:DEFUN MAKE-FILE-STREAM (CL:&KEY STREAM (INPUT-LOCATION (MAKE-STREAM-LOCATION)) (OUTPUT-LOCATION (MAKE-STREAM-LOCATION))) (CL:BLOCK MAKE-FILE-STREAM (CL:BLOCK NIL (MAKE-STREAM :HANDLE STREAM :INPUT-LOCATION INPUT-LOCATION :OUTPUT-LOCATION OUTPUT-LOCATION :FUN-IN (CL:LAMBDA (_) (CL:BLOCK NIL (%READ-CHAR (STREAM-HANDLE _)))) :FUN-OUT (CL:LAMBDA (C STR) (%PRINC C (STREAM-HANDLE STR))) :FUN-EOF (CL:LAMBDA (_) (CL:BLOCK NIL (%FEOF (STREAM-HANDLE _))))))))
(CL:DEFUN MAKE-STREAM-LOCATION (CL:&KEY (TRACK? 'TRACK?) (ID 'ID) (LINE 'LINE) (COLUMN 'COLUMN) (TABSIZE 'TABSIZE)) (CL:BLOCK MAKE-STREAM-LOCATION (CL:BLOCK NIL (CL:LABELS ((~G1186 (~G152) (CL:PROGN (=-AREF 'STRUCT ~G152 0) (=-AREF 'STREAM-LOCATION ~G152 1)) (CL:PROGN (=-AREF (CL:COND ((EQ TRACK? 'TRACK?) T) (T TRACK?)) ~G152 2)) (CL:PROGN (=-AREF (CL:COND ((EQ ID 'ID) NIL) (T ID)) ~G152 3)) (CL:PROGN (=-AREF (CL:COND ((EQ LINE 'LINE) 1) (T LINE)) ~G152 4)) (CL:PROGN (=-AREF (CL:COND ((EQ COLUMN 'COLUMN) 1) (T COLUMN)) ~G152 5)) (CL:PROGN (=-AREF (CL:COND ((EQ TABSIZE 'TABSIZE) *DEFAULT-STREAM-TABSIZE*) (T TABSIZE)) ~G152 6)) ~G152)) (~G1186 (MAKE-ARRAY 7))))))
(CL:DEFUN %FOPEN-DIRECTION (DIRECTION) (CL:BLOCK %FOPEN-DIRECTION (CL:BLOCK NIL (CL:LABELS ((~G1187 (~G170) (CL:COND ((EQL ~G170 'INPUT) "r") ((EQL ~G170 'OUTPUT) "w") ((EQL ~G170 'APPEND) "a") (T (ERROR ":DIRECTION isn't specified."))))) (~G1187 DIRECTION)))))
(CL:DEFUN STREAM-HANDLE (ARR) (CL:BLOCK STREAM-HANDLE (CL:BLOCK NIL (CL:AREF ARR 2))))
(CL:DEFUN FUNCALL (FUN CL:&REST X) (CL:APPLY FUN X))
(CL:DEFUN CDRLIST (~G37) (CL:BLOCK CDRLIST (CL:BLOCK NIL (FILTER (CL:FUNCTION CL:CDR) ~G37))))
(CL:DEFUN ARGUMENT-SYNONYM? (X) (CL:BLOCK ARGUMENT-SYNONYM? (CL:BLOCK NIL (CL:LABELS ((~G1188 (~G179) (CL:COND (~G179 ~G179) (T (%KEY? X))))) (~G1188 (%REST-OR-%BODY? X))))))
(CL:DEFUN %MACROEXPAND-REST (X) (CL:COND ((ATOM X) X) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
(CL:DEFUN ARGUMENT-EXPAND (FUN DEF VALS CL:&KEY (APPLY-VALUES? T) (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND (CL:BLOCK NIL (CL:LABELS ((~G1189 (!) (CL:COND ((CL:LABELS ((~G1190 (~G190) (CL:COND (~G190 ~G190) (T (EQ ! :ERROR))))) (~G1190 APPLY-VALUES?)) !) (T (CARLIST !))))) (~G1189 (ARGUMENT-EXPAND-0 FUN DEF VALS APPLY-VALUES? BREAK-ON-ERRORS?))))))
(CL:DEFUN PROPS-KLIST NIL)
(CL:DEFUN JSON-OBJECT? NIL)
(CL:DEFUN BUTLAST (PLIST) (CL:BLOCK BUTLAST (CL:BLOCK NIL (CL:COND ((CL:CDR PLIST) (CL:CONS (CL:CAR PLIST) (BUTLAST (CL:CDR PLIST))))))))
(CL:DEFUN LAST (X) (CL:BLOCK LAST (CL:BLOCK NIL (CL:COND ((CL:CDR X) (LAST (CL:CDR X))) (T X)))))
(CL:DEFUN GROUP (X SIZE) (CL:BLOCK GROUP (CL:BLOCK NIL (CL:COND (X (CL:PROGN (CL:CONS (LIST-SUBSEQ X 0 SIZE) (GROUP (NTHCDR SIZE X) SIZE))))))))
(CL:DEFUN MAKE-? (BODY) (CL:BLOCK MAKE-? (CL:BLOCK NIL (CL:LABELS ((~G1191 (TESTS) (CL:LABELS ((~G1192 (END) (CL:LABELS ((~G1193 (~G728) (CL:COND (~G728 ~G728) (T (ERROR "Body is missing."))))) (~G1193 BODY)) (CL:CONS 'CL:COND (CL:LABELS ((~G1194 (~G1628) (APPEND (CL:COND ((JSON-OBJECT? ~G1628) (PROPS-KLIST ~G1628)) (T ~G1628)) NIL))) (~G1194 (CL:COND ((CL:CDR END) TESTS) (T (+ (BUTLAST TESTS) (LIST (CL:CONS T END)))))))))) (~G1192 (CL:CAR (LAST TESTS)))))) (~G1191 (GROUP BODY 2))))))
(CL:DEFUN ARGUMENT-EXPAND-NAMES (FUN DEF) (CL:BLOCK ARGUMENT-EXPAND-NAMES (CL:BLOCK NIL (ARGUMENT-EXPAND FUN DEF NIL :APPLY-VALUES? NIL))))
(CL:DEFUN ENSURE-LIST (X) (CL:BLOCK ENSURE-LIST (CL:BLOCK NIL (CL:COND (X (CL:COND ((LIST? X) X) (T (LIST X))))))))
(CL:DEFUN %MACROEXPAND (X) (CL:COND ((ATOM X) X) ((CL:APPLY *MACRO?* (LIST X)) (CL:LABELS ((~G1195 (X) (CL:COND ((CONS? X) (CL:CONS (CL:CAR X) (%MACROEXPAND-REST (CL:CDR X)))) (T X)))) (~G1195 (CL:APPLY *MACROCALL* (LIST X))))) ((EQ (CL:CAR X) 'CL:QUOTE) X) ((EQ (CL:CAR X) 'BACKQUOTE) (CL:CONS 'BACKQUOTE (CL:APPLY *MACROEXPAND-BACKQUOTE* (LIST (CL:CDR X))))) ((EQ (CL:CAR X) 'QUASIQUOTE) (CL:CONS 'QUASIQUOTE (%MACROEXPAND (CL:CDR X)))) ((EQ (CL:CAR X) 'QUASIQUOTE-SPLICE) (CL:CONS 'QUASIQUOTE-SPLICE (%MACROEXPAND (CL:CDR X)))) (T (CL:CONS (%MACROEXPAND (CL:CAR X)) (%MACROEXPAND-REST (CL:CDR X))))))
(CL:DEFUN LIST? (X) (CL:BLOCK LIST? (CL:BLOCK NIL (CL:LABELS ((~G1196 (~G2) (CL:COND (~G2 ~G2) (T (NOT X))))) (~G1196 (CONS? X))))))
(CL:DEFUN LIST (CL:&REST X) X)
(CL:DEFUN ARGUMENT-EXPAND-VALUES (FUN DEF VALS CL:&KEY (BREAK-ON-ERRORS? T)) (CL:BLOCK ARGUMENT-EXPAND-VALUES (CL:BLOCK NIL (DYNAMIC-MAP (CL:LAMBDA (_) (CL:BLOCK NIL (CL:COND ((ARGUMENT-SYNONYM? _) (CL:CDR _)) (T _)))) (CDRLIST (ARGUMENT-EXPAND FUN DEF VALS :BREAK-ON-ERRORS? BREAK-ON-ERRORS?))))))
(CL:DEFUN ASSOC (KEY LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK ASSOC (CL:BLOCK NIL (CL:COND (LST (CL:BLOCK NIL (CL:LABELS ((~G1197 (~G109) (CL:LABELS ((~G1198 (I) (CL:TAGBODY ~G107 (CL:COND ((NOT ~G109) (CL:GO ~G108))) (CL:SETQ I (CL:CAR ~G109)) (CL:COND ((CONS? I) (CL:COND ((FUNCALL TEST KEY (CL:CAR I)) (CL:RETURN-FROM NIL I)))) (T (ERROR "Pair expected instead of ~A." I))) (CL:SETQ ~G109 (CL:CDR ~G109)) (CL:GO ~G107) ~G108 (CL:RETURN-FROM NIL (CL:PROGN))))) (~G1198 NIL)))) (~G1197 LST))))))))
(CL:DEFUN CLOSE (STR) (CL:BLOCK CLOSE (CL:BLOCK NIL (%FCLOSE (STREAM-HANDLE STR)))))
(CL:DEFUN OPEN (PATH CL:&KEY DIRECTION) (CL:BLOCK OPEN (CL:BLOCK NIL (CL:LABELS ((~G1199 (!) (CL:COND (! (MAKE-FILE-STREAM :STREAM ! :INPUT-LOCATION (MAKE-STREAM-LOCATION :ID PATH))) (T (ERROR "Couldn't open file `~A'." PATH))))) (~G1199 (%FOPEN PATH (%FOPEN-DIRECTION DIRECTION)))))))
(CL:DEFUN QUASIQUOTE-EXPAND (X) (CL:CAR (%QUASIQUOTE-EXPAND (LIST X))))
(CL:DEFUN DOT-EXPAND (X) (CL:BLOCK DOT-EXPAND (CL:BLOCK NIL (CL:COND ((SYMBOL? X) (DOT-EXPAND-CONV X)) ((CONS? X) (CL:CONS (DOT-EXPAND (CL:CAR X)) (DOT-EXPAND (CL:CDR X)))) (T X)))))
(CL:DEFUN READ (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK READ (CL:BLOCK NIL (CL:COND ((SEEK-CHAR STR) (READ-EXPR STR))))))
(CL:DEFUN PEEK-CHAR (CL:&OPTIONAL (STR *STANDARD-INPUT*)) (CL:BLOCK PEEK-CHAR (CL:BLOCK NIL (CL:LABELS ((~G1200 (~G228) (CL:COND (~G228 ~G228) (T (CL:PROGN (=-STREAM-PEEKED-CHAR (READ-CHAR-0 STR) STR)))))) (~G1200 (STREAM-PEEKED-CHAR STR))))))
(CL:DEFUN ELT (SEQ IDX) (CL:BLOCK ELT (CL:BLOCK NIL (CL:COND ((NOT SEQ) NIL) ((STRING? SEQ) (CHAR SEQ IDX)) ((CONS? SEQ) (NTH IDX SEQ)) (T (CL:AREF SEQ IDX))))))
(CL:DEFUN ERROR (MSG CL:&REST ARGS) (CL:BLOCK ERROR (CL:BLOCK NIL (CL:LABELS ((~G1201 (~G327) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* NIL)) (CL:LABELS ((~G1202 (~G328) (CL:PROGN (CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* ~G327)) ~G328)) (~G1202 (CL:PROGN (FRESH-LINE) (%ERROR (CL:APPLY (CL:FUNCTION FORMAT) NIL MSG ARGS))))))) (~G1201 *PRINT-AUTOMATIC-NEWLINE?*)))))
(CL:DEFUN QUOTE-EXPAND (X) (CL:BLOCK QUOTE-EXPAND (CL:BLOCK NIL (CL:LABELS ((ANY-QUASIQUOTE? (_) (CL:BLOCK NIL (CL:LABELS ((~G1203 (~G657) (CL:COND (~G657 ~G657) (T (QUASIQUOTE-SPLICE? _))))) (~G1203 (QUASIQUOTE? _))))) (ATOMIC (_) (CL:BLOCK NIL (CL:COND ((CONSTANT-LITERAL? _) _) (T (CL:CONS 'CL:QUOTE (CL:CONS _ NIL)))))) (STATIC (_) (CL:BLOCK NIL (CL:COND ((ATOM _) (ATOMIC _)) (T (CL:CONS 'CL:CONS (CL:CONS (STATIC (CL:CAR _)) (CL:CONS (STATIC (CL:CDR _)) NIL))))))) (QQ (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CADR (CL:CAR _))) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) (T (CL:CONS 'CL:CONS (CL:CONS (CADR (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (QQS (_) (CL:BLOCK NIL (CL:COND ((ANY-QUASIQUOTE? (CADR (CL:CAR _))) (ERROR "Illegal ~A as argument to ,@ (QUASIQUOTE-SPLICE)." (CADR (CL:CAR _)))) (T (CL:LABELS ((~G1204 (G) (COMPILER-MACROEXPAND (CL:CONS (CL:CONS 'CL:FUNCTION (CL:CONS (CL:CONS (CL:CONS G NIL) (CL:CONS (CL:CONS 'APPEND (CL:CONS (CL:CONS '? (CL:CONS (CL:CONS 'JSON-OBJECT? (CL:CONS G NIL)) (CL:CONS (CL:CONS 'PROPS-KLIST (CL:CONS G NIL)) (CL:CONS G NIL)))) (CL:CONS (BACKQ (CL:CDR _)) NIL))) NIL)) NIL)) (CL:CONS (CADR (CL:CAR _)) NIL))))) (~G1204 (GENSYM))))))) (BACKQ (_) (CL:BLOCK NIL (CL:COND ((ATOM _) (ATOMIC _)) (T (CL:LABELS ((~G1205 (~G658) (CL:COND ((ATOM ~G658) (CL:CONS 'CL:CONS (CL:CONS (ATOMIC (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL)))) ((QUASIQUOTE? ~G658) (QQ _)) ((QUASIQUOTE-SPLICE? ~G658) (QQS _)) (T (CL:CONS 'CL:CONS (CL:CONS (BACKQ (CL:CAR _)) (CL:CONS (BACKQ (CL:CDR _)) NIL))))))) (~G1205 (CL:CAR _))))))) (DISP (_) (CL:BLOCK NIL (CL:LABELS ((~G1206 (~G659) (CL:COND ((QUOTE? ~G659) (STATIC (CL:CAR (CL:CDR _)))) ((BACKQUOTE? ~G659) (BACKQ (CL:CAR (CL:CDR _)))) (T _)))) (~G1206 _)))) (WALK (_) (CL:BLOCK NIL (CL:COND ((ATOM _) (DISP _)) (T (CL:CONS (WALK (DISP (CL:CAR _))) (WALK (CL:CDR _)))))))) (CL:CAR (WALK (LIST X)))))))
(CL:DEFUN DYNAMIC-MAP (FUNC CL:&REST LISTS) (CL:BLOCK DYNAMIC-MAP (CL:BLOCK NIL (CL:COND ((STRING? (CL:CAR LISTS)) (LIST-STRING (CL:APPLY (CL:FUNCTION MAPCAR) FUNC (MAPCAR (CL:FUNCTION STRING-LIST) LISTS)))) ((ARRAY? (CL:CAR LISTS)) (CL:APPLY (CL:FUNCTION MAPCAR) FUNC (MAPCAR (CL:FUNCTION ARRAY-LIST) LISTS))) (T (CL:APPLY (CL:FUNCTION MAPCAR) FUNC LISTS))))))
(CL:DEFUN ATOM (X) (NOT (CONS? X)))
(CL:DEFUN EQUAL (X Y) (CL:BLOCK EQUAL (CL:BLOCK NIL (CL:COND ((CL:LABELS ((~G1207 (~G1) (CL:COND (~G1 ~G1) (T (ATOM Y))))) (~G1207 (ATOM X))) (EQL X Y)) ((EQUAL (CL:CAR X) (CL:CAR Y)) (EQUAL (CL:CDR X) (CL:CDR Y)))))))
(CL:DEFUN CADR (X) (CL:BLOCK CADR (CL:BLOCK NIL (CL:CAR (CL:CDR X)))))
(CL:DEFUN GENSYM (CL:&OPTIONAL (PREFIX "~G")) (CL:LABELS ((~G1208 (X) (CL:COND ((EQ (SYMBOL-VALUE X) X) (CL:COND ((SYMBOL-FUNCTION X) (GENSYM)) (T X))) (T (GENSYM))))) (~G1208 (MAKE-SYMBOL (STRING-CONCAT PREFIX (STRING (GENSYM-NUMBER)))))))
(CL:DEFUN + (CL:&REST X) (CL:LABELS ((~G1209 (A) (CL:COND (A (CL:APPLY (CL:COND ((CONS? A) (CL:FUNCTION APPEND)) ((STRING? A) (CL:FUNCTION STRING-CONCAT)) (T (CL:FUNCTION NUMBER+))) X)) (T (CL:COND ((CL:CDR X) (CL:APPLY (CL:FUNCTION +) (CL:CDR X)))))))) (~G1209 (CL:CAR X))))
(CL:DEFUN MEMBER (ELM LST CL:&KEY (TEST (CL:FUNCTION EQL))) (CL:BLOCK MEMBER (CL:BLOCK NIL (CL:BLOCK NIL (CL:LABELS ((~G1210 (I) (CL:TAGBODY ~G11 (CL:COND ((NOT I) (CL:RETURN-FROM NIL (CL:PROGN)))) (CL:COND ((FUNCALL TEST ELM (CL:CAR I)) (CL:RETURN-FROM NIL I))) (CL:SETQ I (CL:CDR I)) (CL:GO ~G11)))) (~G1210 LST))))))
(CL:DEFUN ACONS (KEY VAL LST) (CL:BLOCK ACONS (CL:BLOCK NIL (CL:CONS (CL:CONS KEY VAL) LST))))
(CL:DEFUN PRINT-DEFINITION (X) (CL:COND (*PRINT-DEFINITIONS?* (CL:APPLY *DEFINITION-PRINTER* (LIST X)))))
(CL:DEFUN PROPS-KLIST (X) (CL:BLOCK PROPS-KLIST (CL:BLOCK NIL (MAPCAN (CL:LAMBDA (_) (CL:BLOCK NIL (LIST (MAKE-KEYWORD (UPCASE _)) (CL:SLOT-VALUE X _)))) (KEYS X)))))
(CL:DEFUN JSON-OBJECT? (X) (CL:BLOCK JSON-OBJECT? (CL:BLOCK NIL X NIL)))
(CL:DEFUN IDENTITY (X) X)
"Section DELAYED-EXPRS"
(CL:SETQ *UNIVERSE* NIL)
(CL:SETQ *VARIABLES* NIL)
(CL:SETQ *LAUNCHFILE* NIL)
(CL:SETQ *POINTER-SIZE* 4)
(CL:SETQ *ASSERT?* NIL)
(CL:SETQ *ENDIANESS* NIL)
(CL:SETQ *CPU-TYPE* NIL)
(CL:SETQ *LIBC-PATH* NIL)
(CL:SETQ *RAND-MAX* NIL)
(CL:SETQ *PRINT-DEFINITIONS?* NIL)
(CL:SETQ *DEFAULT-STREAM-TABSIZE* 8)
(CL:SETQ *QUASIQUOTE-EXPAND* NIL)
(CL:SETQ *DOT-EXPAND* NIL)
(CL:SETQ *ARGV* *POSIX-ARGV*)
(CL:SETQ *ENVIRONMENT-PATH* ".")
(CL:SETQ *ENVIRONMENT-FILENAMES* NIL)
(CL:SETQ *EVAL* NIL)
(CL:SETQ *FUNCTIONS* NIL)
(CL:SETQ *LOAD* NIL)
(CL:SETQ *MACROEXPAND* NIL)
(CL:SETQ *SPECIAL-FORMS* NIL)
(CL:PUSH (CL:CONS (TRE-SYMBOL '%FN-QUIET) (CL:CONS '(NAME ARGS CL:&BODY BODY) (CL:LAMBDA (NAME ARGS BODY) (MAKE-%FN-QUIET NAME ARGS BODY)))) *SPECIAL-FORMS*)
(CL:PUSH (CL:CONS (TRE-SYMBOL '%FN) (CL:CONS '(NAME ARGS CL:&BODY BODY) (CL:LAMBDA (NAME ARGS BODY) (PRINT-DEFINITION `(%FN ,NAME ,ARGS)) (MAKE-%FN-QUIET NAME ARGS BODY)))) *SPECIAL-FORMS*)
(CL:PUSH (CL:CONS (TRE-SYMBOL '%DEFMACRO) (CL:CONS '(NAME ARGS CL:&BODY BODY) (CL:LAMBDA (NAME ARGS BODY) (PRINT-DEFINITION `(%DEFMACRO ,NAME ,ARGS)) `(CL:PUSH (CL:CONS ',NAME (CL:CONS ',(CL:CONS ARGS BODY) (CL:LAMBDA ,(ARGUMENT-EXPAND-NAMES '%DEFMACRO ARGS) ,@BODY))) ,(TRE-SYMBOL '*MACROS*))))) *SPECIAL-FORMS*)
(CL:PUSH (CL:CONS (TRE-SYMBOL '%DEFVAR) (CL:CONS '(NAME CL:&OPTIONAL (INIT NIL)) (CL:LAMBDA (NAME INIT) (PRINT-DEFINITION `(%DEFVAR ,NAME)) `(CL:PROGN (CL:PUSH (CL:CONS ',NAME ',INIT) *VARIABLES*) (CL:DEFVAR ,NAME ,INIT))))) *SPECIAL-FORMS*)
(CL:PUSH (CL:CONS (TRE-SYMBOL '?) (CL:CONS '(CL:&BODY BODY) (CL:LAMBDA (BODY) (MAKE-? BODY)))) *SPECIAL-FORMS*)
(CL:SETQ *KEYWORD-PACKAGE* (CL:FIND-PACKAGE "KEYWORD"))
(CL:SETQ *PACKAGE* "TRE")
(CL:PUSH (CL:CONS (TRE-SYMBOL 'DEFPACKAGE) (CL:CONS '(NAME CL:&REST OPTIONS) (CL:LAMBDA (NAME OPTIONS) (PRINT-DEFINITION `(DEFPACKAGE ,NAME ,@OPTIONS)) (CL:EVAL `(CL:DEFPACKAGE ,NAME ,@OPTIONS)) NIL))) *SPECIAL-FORMS*)
(CL:PUSH (CL:CONS (TRE-SYMBOL 'IN-PACKAGE) (CL:CONS '(NAME) (CL:LAMBDA (NAME) (PRINT-DEFINITION `(IN-PACKAGE ,NAME)) (CL:IN-PACKAGE NAME) (CL:PROGN (CL:SETQ *PACKAGE* NAME)) `(CL:PROGN (CL:IN-PACKAGE ,NAME) (= *PACKAGE* ,NAME))))) *SPECIAL-FORMS*)
(CL:DEFCONSTANT +UNIX-EPOCH-DIFFERENCE+ (CL:ENCODE-UNIVERSAL-TIME 0 0 0 1 1 1970 0))
(CL:SETQ *DEFINITION-PRINTER* (CL:FUNCTION CL:PRINT))
(CL:SETQ *PRINT-AUTOMATIC-NEWLINE?* T)
(CL:SETQ *STANDARD-INPUT* (MAKE-STANDARD-STREAM))
(CL:SETQ *MACROEXPAND-BACKQUOTE* (CL:FUNCTION %MACROEXPAND-BACKQUOTE))
(CL:SETQ *MACROCALL* NIL)
(CL:SETQ *MACRO?* NIL)
(CL:SETQ +CL-FUNCTION-IMPORTS+ (CL:CONS 'CL:APPLY (CL:CONS 'CL:CONS (CL:CONS 'CL:CAR (CL:CONS 'CL:CDR (CL:CONS 'CL:RPLACA (CL:CONS 'CL:RPLACD (CL:CONS 'CL:LENGTH (CL:CONS 'CL:MAKE-STRING (CL:CONS 'CL:MOD (CL:CONS 'CL:SQRT (CL:CONS 'CL:SIN (CL:CONS 'CL:COS (CL:CONS 'CL:TAN (CL:CONS 'CL:ASIN (CL:CONS 'CL:ACOS (CL:CONS 'CL:ATAN (CL:CONS 'CL:EXP (CL:CONS 'CL:ROUND (CL:CONS 'CL:FLOOR (CL:CONS 'CL:CEILING (CL:CONS 'CL:AREF (CL:CONS 'CL:CHAR-CODE (CL:CONS 'CL:MAKE-PACKAGE (CL:CONS 'CL:PACKAGE-NAME (CL:CONS 'CL:FIND-PACKAGE (CL:CONS 'CL:PRINT NIL)))))))))))))))))))))))))))
(CL:SETQ *VALUES-MAGIC* 'VALUES-~G45)
(CL:SETQ *STANDARD-OUTPUT* (MAKE-STANDARD-STREAM))
(CL:SETQ *COMPILER-MACRO-EXPANDER* (DEFINE-EXPANDER 'COMPILER :PRE (CL:FUNCTION INIT-COMPILER-MACROS)))
(CL:SETQ *GENSYM-COUNTER* 0)
(CL:SETQ *TAGBODY-REPLACEMENTS* NIL)
(CL:SETQ *EXPANDER-DUMP?* NIL)
(CL:SETQ *PRINTER-ABBREVIATIONS* (CL:CONS (CL:CONS 'CL:QUOTE (CL:CONS "'" NIL)) (CL:CONS (CL:CONS 'BACKQUOTE (CL:CONS "`" NIL)) (CL:CONS (CL:CONS 'QUASIQUOTE (CL:CONS "," NIL)) (CL:CONS (CL:CONS 'QUASIQUOTE-SPLICE (CL:CONS ",@" NIL)) NIL)))))
(CL:SETQ *TYPES* NIL)
(CL:SETQ *ALWAYS-PRINT-PACKAGE-NAMES?* NIL)
(CL:SETQ *INVISIBLE-PACKAGE-NAMES* (CL:CONS "TRE" (CL:CONS "TRE-CORE" NIL)))
(CL:SETQ *PRINTER-ARGUMENT-DEFINITIONS* (MAKE-HASH-TABLE :TEST (CL:FUNCTION EQ)))
"Section DUMMY"
(cl:in-package :tre)
(cl:format t "; Loading environment…\~%")
(cl:setq *package* "TRE")
(env-load "main.lisp")