From a27cc2ac7bf6a0ad60cc6c9f949a988d0444bb4e Mon Sep 17 00:00:00 2001
From: dos-reis <gdr@axiomatics.org>
Date: Mon, 28 Jan 2008 04:16:25 +0000
Subject: 	* boot/Makefile.pamphlet: Remove. 	*
 boot/translator.boot: New. 	* boot/translator.boot: Remove. 	*
 boot/tokens.boot: New. 	* boot/tokens.boot.pamphlet: Remove. 	*
 boot/scanner.boot: New. 	* boot/scanner.boot.pamphlet: Remove. 	*
 boot/pile.boot: New. 	* boot/pile.boot.pamphlet: Remove. 	*
 boot/parser.boot: New. 	* boot/parser.boot.pamphlet: New. 	*
 boot/initial-env.lisp: New. 	* boot/initial-env.lisp.pamphlet: Remove. 
 * boot/includer.boot: New. 	* boot/includer.boot.pamphlet: Remove. 	*
 boot/ast.boot: New. 	* boot/ast.boot.pamphlet: Remove.

---
 src/boot/strap/ast.clisp | 2086 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 2086 insertions(+)
 create mode 100644 src/boot/strap/ast.clisp

(limited to 'src/boot/strap/ast.clisp')

diff --git a/src/boot/strap/ast.clisp b/src/boot/strap/ast.clisp
new file mode 100644
index 00000000..591bd9bf
--- /dev/null
+++ b/src/boot/strap/ast.clisp
@@ -0,0 +1,2086 @@
+(EVAL-WHEN (:COMPILE-TOPLEVEL) (PROVIDE "boot-ast"))
+
+(IMPORT-MODULE "includer")
+
+(IN-PACKAGE "BOOTTRAN")
+
+(DEFPARAMETER |$bfClamming| NIL)
+
+(DEFTYPE |String| () 'STRING)
+
+(DEFTYPE |Symbol| () 'SYMBOL)
+
+(DEFTYPE |Sequence| () 'SEQUENCE)
+
+(DEFTYPE |List| () '(OR NIL CONS))
+
+(DEFUN |Name| #0=(|bfVar#1|) (CONS '|Name| (LIST . #0#)))
+
+(DEFUN |Command| #0=(|bfVar#2|) (CONS '|Command| (LIST . #0#)))
+
+(DEFUN |Module| #0=(|bfVar#3|) (CONS '|Module| (LIST . #0#)))
+
+(DEFUN |Import| #0=(|bfVar#4|) (CONS '|Import| (LIST . #0#)))
+
+(DEFUN |ImportSignature| #0=(|bfVar#5| |bfVar#6|)
+  (CONS '|ImportSignature| (LIST . #0#)))
+
+(DEFUN |TypeAlias| #0=(|bfVar#7| |bfVar#8| |bfVar#9|)
+  (CONS '|TypeAlias| (LIST . #0#)))
+
+(DEFUN |Signature| #0=(|bfVar#10| |bfVar#11|)
+  (CONS '|Signature| (LIST . #0#)))
+
+(DEFUN |Mapping| #0=(|bfVar#12| |bfVar#13|)
+  (CONS '|Mapping| (LIST . #0#)))
+
+(DEFUN |SuffixDot| #0=(|bfVar#14|) (CONS '|SuffixDot| (LIST . #0#)))
+
+(DEFUN |Quote| #0=(|bfVar#15|) (CONS '|Quote| (LIST . #0#)))
+
+(DEFUN |EqualName| #0=(|bfVar#16|) (CONS '|EqualName| (LIST . #0#)))
+
+(DEFUN |Colon| #0=(|bfVar#17|) (CONS '|Colon| (LIST . #0#)))
+
+(DEFUN |QualifiedName| #0=(|bfVar#18| |bfVar#19|)
+  (CONS '|QualifiedName| (LIST . #0#)))
+
+(DEFUN |Bracket| #0=(|bfVar#20|) (CONS '|Bracket| (LIST . #0#)))
+
+(DEFUN |UnboundedSegment| #0=(|bfVar#21|)
+  (CONS '|UnboundedSegment| (LIST . #0#)))
+
+(DEFUN |BoundedSgement| #0=(|bfVar#22| |bfVar#23|)
+  (CONS '|BoundedSgement| (LIST . #0#)))
+
+(DEFUN |Tuple| #0=(|bfVar#24|) (CONS '|Tuple| (LIST . #0#)))
+
+(DEFUN |ColonAppend| #0=(|bfVar#25| |bfVar#26|)
+  (CONS '|ColonAppend| (LIST . #0#)))
+
+(DEFUN |Is| #0=(|bfVar#27| |bfVar#28|) (CONS '|Is| (LIST . #0#)))
+
+(DEFUN |Isnt| #0=(|bfVar#29| |bfVar#30|) (CONS '|Isnt| (LIST . #0#)))
+
+(DEFUN |Reduce| #0=(|bfVar#31| |bfVar#32|)
+  (CONS '|Reduce| (LIST . #0#)))
+
+(DEFUN |PrefixExpr| #0=(|bfVar#33| |bfVar#34|)
+  (CONS '|PrefixExpr| (LIST . #0#)))
+
+(DEFUN |Call| #0=(|bfVar#35| |bfVar#36|) (CONS '|Call| (LIST . #0#)))
+
+(DEFUN |InfixExpr| #0=(|bfVar#37| |bfVar#38| |bfVar#39|)
+  (CONS '|InfixExpr| (LIST . #0#)))
+
+(DEFUN |ConstantDefinition| #0=(|bfVar#40| |bfVar#41|)
+  (CONS '|ConstantDefinition| (LIST . #0#)))
+
+(DEFUN |Definition| #0=(|bfVar#42| |bfVar#43| |bfVar#44| |bfVar#45|)
+  (CONS '|Definition| (LIST . #0#)))
+
+(DEFUN |Macro| #0=(|bfVar#46| |bfVar#47| |bfVar#48|)
+  (CONS '|Macro| (LIST . #0#)))
+
+(DEFUN |SuchThat| #0=(|bfVar#49|) (CONS '|SuchThat| (LIST . #0#)))
+
+(DEFUN |Assignment| #0=(|bfVar#50| |bfVar#51|)
+  (CONS '|Assignment| (LIST . #0#)))
+
+(DEFUN |While| #0=(|bfVar#52|) (CONS '|While| (LIST . #0#)))
+
+(DEFUN |Until| #0=(|bfVar#53|) (CONS '|Until| (LIST . #0#)))
+
+(DEFUN |For| #0=(|bfVar#54| |bfVar#55| |bfVar#56|)
+  (CONS '|For| (LIST . #0#)))
+
+(DEFUN |Exit| #0=(|bfVar#57| |bfVar#58|) (CONS '|Exit| (LIST . #0#)))
+
+(DEFUN |Iterators| #0=(|bfVar#59|) (CONS '|Iterators| (LIST . #0#)))
+
+(DEFUN |Cross| #0=(|bfVar#60|) (CONS '|Cross| (LIST . #0#)))
+
+(DEFUN |Repeat| #0=(|bfVar#61| |bfVar#62|)
+  (CONS '|Repeat| (LIST . #0#)))
+
+(DEFUN |Pile| #0=(|bfVar#63|) (CONS '|Pile| (LIST . #0#)))
+
+(DEFUN |Append| #0=(|bfVar#64|) (CONS '|Append| (LIST . #0#)))
+
+(DEFUN |Case| #0=(|bfVar#65| |bfVar#66|) (CONS '|Case| (LIST . #0#)))
+
+(DEFUN |Return| #0=(|bfVar#67|) (CONS '|Return| (LIST . #0#)))
+
+(DEFUN |Where| #0=(|bfVar#68| |bfVar#69|)
+  (CONS '|Where| (LIST . #0#)))
+
+(DEFUN |Structure| #0=(|bfVar#70| |bfVar#71|)
+  (CONS '|Structure| (LIST . #0#)))
+
+(DEFPARAMETER |$inDefIS| NIL)
+
+(DEFUN |bfGenSymbol| ()
+  (PROG ()
+    (DECLARE (SPECIAL |$GenVarCounter|))
+    (RETURN
+      (PROGN
+        (SETQ |$GenVarCounter| (+ |$GenVarCounter| 1))
+        (INTERN (CONCAT "bfVar#" (STRINGIMAGE |$GenVarCounter|)))))))
+
+(DEFUN |bfListOf| (|x|) (PROG () (RETURN |x|)))
+
+(DEFUN |bfColon| (|x|) (PROG () (RETURN (LIST 'COLON |x|))))
+
+(DEFUN |bfColonColon| (|package| |name|)
+  (PROG () (RETURN (INTERN (SYMBOL-NAME |name|) |package|))))
+
+(DEFUN |bfSymbol| (|x|)
+  (PROG () (RETURN (COND ((STRINGP |x|) |x|) ('T (LIST 'QUOTE |x|))))))
+
+(DEFUN |bfDot| () (PROG () (RETURN 'DOT)))
+
+(DEFUN |bfSuffixDot| (|x|) (PROG () (RETURN (LIST |x| 'DOT))))
+
+(DEFUN |bfEqual| (|name|) (PROG () (RETURN (LIST 'EQUAL |name|))))
+
+(DEFUN |bfBracket| (|part|) (PROG () (RETURN |part|)))
+
+(DEFUN |bfPile| (|part|) (PROG () (RETURN |part|)))
+
+(DEFUN |bfAppend| (|x|) (PROG () (RETURN (APPLY #'APPEND |x|))))
+
+(DEFUN |bfColonAppend| (|x| |y|)
+  (PROG (|a|)
+    (RETURN
+      (COND
+        ((NULL |x|)
+         (COND
+           ((AND (CONSP |y|) (EQ (CAR |y|) 'BVQUOTE)
+                 (PROGN (SETQ |a| (CDR |y|)) 'T))
+            (LIST '&REST (CONS 'QUOTE |a|)))
+           (#0='T (LIST '&REST |y|))))
+        (#0# (CONS (CAR |x|) (|bfColonAppend| (CDR |x|) |y|)))))))
+
+(DEFUN |bfDefinition| (|bflhsitems| |bfrhs| |body|)
+  (PROG () (RETURN (LIST 'DEF |bflhsitems| |bfrhs| |body|))))
+
+(DEFUN |bfMDefinition| (|bflhsitems| |bfrhs| |body|)
+  (PROG () (RETURN (|bfMDef| 'MDEF |bflhsitems| |bfrhs| |body|))))
+
+(DEFUN |bfCompDef| (|x|)
+  (PROG (|body| |ISTMP#3| |args| |ISTMP#2| |op| |ISTMP#1| |def|
+                |bfVar#73| |bfVar#72|)
+    (RETURN
+      (PROGN
+        (SETQ |bfVar#72| |x|)
+        (SETQ |bfVar#73| (CDR |bfVar#72|))
+        (CASE (CAR |bfVar#72|)
+          (|ConstantDefinition|
+              (LET ((|n| (CAR |bfVar#73|)) (|e| (CADR |bfVar#73|)))
+                |x|))
+          (T (COND
+               ((AND (CONSP |x|)
+                     (PROGN
+                       (SETQ |def| (CAR |x|))
+                       (SETQ |ISTMP#1| (CDR |x|))
+                       (AND (CONSP |ISTMP#1|)
+                            (PROGN
+                              (SETQ |op| (CAR |ISTMP#1|))
+                              (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                              (AND (CONSP |ISTMP#2|)
+                                   (PROGN
+                                     (SETQ |args| (CAR |ISTMP#2|))
+                                     (SETQ |ISTMP#3| (CDR |ISTMP#2|))
+                                     (AND (CONSP |ISTMP#3|)
+                                      (EQ (CDR |ISTMP#3|) NIL)
+                                      (PROGN
+                                        (SETQ |body| (CAR |ISTMP#3|))
+                                        'T))))))))
+                (|bfDef| |def| |op| |args| |body|))
+               ('T (|coreError| "invalid AST")))))))))
+
+(DEFUN |bfBeginsDollar| (|x|)
+  (PROG () (RETURN (EQL (ELT "$" 0) (ELT (PNAME |x|) 0)))))
+
+(DEFUN |compFluid| (|id|) (PROG () (RETURN (LIST 'FLUID |id|))))
+
+(DEFUN |compFluidize| (|x|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((AND (IDENTP |x|) (|bfBeginsDollar| |x|)) (|compFluid| |x|))
+        ((ATOM |x|) |x|)
+        ((EQCAR |x| 'QUOTE) |x|)
+        ('T
+         (CONS (|compFluidize| (CAR |x|)) (|compFluidize| (CDR |x|))))))))
+
+(DEFUN |bfTuple| (|x|) (PROG () (RETURN (CONS 'TUPLE |x|))))
+
+(DEFUN |bfTupleP| (|x|) (PROG () (RETURN (EQCAR |x| 'TUPLE))))
+
+(DEFUN |bfTupleIf| (|x|)
+  (PROG ()
+    (RETURN (COND ((|bfTupleP| |x|) |x|) ('T (|bfTuple| |x|))))))
+
+(DEFUN |bfTupleConstruct| (|b|)
+  (PROG (|ISTMP#1| |a|)
+    (RETURN
+      (PROGN
+        (SETQ |a| (COND ((|bfTupleP| |b|) (CDR |b|)) ('T (LIST |b|))))
+        (COND
+          ((LET ((|bfVar#75| NIL) (|bfVar#74| |a|) (|x| NIL))
+             (LOOP
+               (COND
+                 ((OR (ATOM |bfVar#74|)
+                      (PROGN (SETQ |x| (CAR |bfVar#74|)) NIL))
+                  (RETURN |bfVar#75|))
+                 ('T
+                  (PROGN
+                    (SETQ |bfVar#75|
+                          (AND (CONSP |x|) (EQ (CAR |x|) 'COLON)
+                               (PROGN
+                                 (SETQ |ISTMP#1| (CDR |x|))
+                                 (AND (CONSP |ISTMP#1|)
+                                      (EQ (CDR |ISTMP#1|) NIL)))))
+                    (COND (|bfVar#75| (RETURN |bfVar#75|))))))
+               (SETQ |bfVar#74| (CDR |bfVar#74|))))
+           (|bfMakeCons| |a|))
+          ('T (CONS 'LIST |a|)))))))
+
+(DEFUN |bfConstruct| (|b|)
+  (PROG (|a|)
+    (RETURN
+      (PROGN
+        (SETQ |a| (COND ((|bfTupleP| |b|) (CDR |b|)) ('T (LIST |b|))))
+        (|bfMakeCons| |a|)))))
+
+(DEFUN |bfMakeCons| (|l|)
+  (PROG (|l1| |a| |ISTMP#2| |ISTMP#1|)
+    (RETURN
+      (COND
+        ((NULL |l|) NIL)
+        ((AND (CONSP |l|)
+              (PROGN
+                (SETQ |ISTMP#1| (CAR |l|))
+                (AND (CONSP |ISTMP#1|) (EQ (CAR |ISTMP#1|) 'COLON)
+                     (PROGN
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |a| (CAR |ISTMP#2|)) #0='T)))))
+              (PROGN (SETQ |l1| (CDR |l|)) #0#))
+         (COND
+           (|l1| (LIST 'APPEND |a| (|bfMakeCons| |l1|)))
+           (#1='T |a|)))
+        (#1# (LIST 'CONS (CAR |l|) (|bfMakeCons| (CDR |l|))))))))
+
+(DEFUN |bfFor| (|bflhs| U |step|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((EQCAR U '|tails|) (|bfForTree| 'ON |bflhs| (CADR U)))
+        ((EQCAR U 'SEGMENT)
+         (|bfSTEP| |bflhs| (CADR U) |step| (CADDR U)))
+        ('T (|bfForTree| 'IN |bflhs| U))))))
+
+(DEFUN |bfForTree| (OP |lhs| |whole|)
+  (PROG (G)
+    (RETURN
+      (PROGN
+        (SETQ |whole|
+              (COND
+                ((|bfTupleP| |whole|) (|bfMakeCons| (CDR |whole|)))
+                (#0='T |whole|)))
+        (COND
+          ((ATOM |lhs|) (|bfINON| (LIST OP |lhs| |whole|)))
+          (#1='T
+           (PROGN
+             (SETQ |lhs|
+                   (COND
+                     ((|bfTupleP| |lhs|) (CADR |lhs|))
+                     (#0# |lhs|)))
+             (COND
+               ((EQCAR |lhs| 'L%T)
+                (PROGN
+                  (SETQ G (CADR |lhs|))
+                  (APPEND (|bfINON| (LIST OP G |whole|))
+                          (|bfSuchthat| (|bfIS| G (CADDR |lhs|))))))
+               (#1#
+                (PROGN
+                  (SETQ G (|bfGenSymbol|))
+                  (APPEND (|bfINON| (LIST OP G |whole|))
+                          (|bfSuchthat| (|bfIS| G |lhs|)))))))))))))
+
+(DEFUN |bfSTEP| (|id| |fst| |step| |lst|)
+  (PROG (|suc| |ex| |pred| |final| |g2| |inc| |g1| |initval| |initvar|)
+    (RETURN
+      (PROGN
+        (SETQ |initvar| (LIST |id|))
+        (SETQ |initval| (LIST |fst|))
+        (SETQ |inc|
+              (COND
+                ((ATOM |step|) |step|)
+                (#0='T (SETQ |g1| (|bfGenSymbol|))
+                 (SETQ |initvar| (CONS |g1| |initvar|))
+                 (SETQ |initval| (CONS |step| |initval|)) |g1|)))
+        (SETQ |final|
+              (COND
+                ((ATOM |lst|) |lst|)
+                (#0# (SETQ |g2| (|bfGenSymbol|))
+                 (SETQ |initvar| (CONS |g2| |initvar|))
+                 (SETQ |initval| (CONS |lst| |initval|)) |g2|)))
+        (SETQ |ex|
+              (COND
+                ((NULL |lst|) NIL)
+                ((INTEGERP |inc|)
+                 (PROGN
+                   (SETQ |pred| (COND ((MINUSP |inc|) '<) (#0# '>)))
+                   (LIST (LIST |pred| |id| |final|))))
+                ('T
+                 (LIST (LIST 'COND
+                             (LIST (LIST 'MINUSP |inc|)
+                                   (LIST '< |id| |final|))
+                             (LIST 'T (LIST '> |id| |final|)))))))
+        (SETQ |suc| (LIST (LIST 'SETQ |id| (LIST '+ |id| |inc|))))
+        (LIST (LIST |initvar| |initval| |suc| NIL |ex| NIL))))))
+
+(DEFUN |bfINON| (|x|)
+  (PROG (|whole| |id| |op|)
+    (RETURN
+      (PROGN
+        (SETQ |op| (CAR |x|))
+        (SETQ |id| (CADR . #0=(|x|)))
+        (SETQ |whole| (CADDR . #0#))
+        (COND
+          ((EQ |op| 'ON) (|bfON| |id| |whole|))
+          ('T (|bfIN| |id| |whole|)))))))
+
+(DEFUN |bfIN| (|x| E)
+  (PROG (|g|)
+    (RETURN
+      (PROGN
+        (SETQ |g| (|bfGenSymbol|))
+        (LIST (LIST (LIST |g| |x|) (LIST E NIL)
+                    (LIST (LIST 'SETQ |g| (LIST 'CDR |g|))) NIL
+                    (LIST (LIST 'OR (LIST 'ATOM |g|)
+                                (LIST 'PROGN
+                                      (LIST 'SETQ |x| (LIST 'CAR |g|))
+                                      'NIL)))
+                    NIL))))))
+
+(DEFUN |bfON| (|x| E)
+  (PROG ()
+    (RETURN
+      (LIST (LIST (LIST |x|) (LIST E)
+                  (LIST (LIST 'SETQ |x| (LIST 'CDR |x|))) NIL
+                  (LIST (LIST 'ATOM |x|)) NIL)))))
+
+(DEFUN |bfSuchthat| (|p|)
+  (PROG () (RETURN (LIST (LIST NIL NIL NIL (LIST |p|) NIL NIL)))))
+
+(DEFUN |bfWhile| (|p|)
+  (PROG ()
+    (RETURN (LIST (LIST NIL NIL NIL NIL (LIST (|bfNOT| |p|)) NIL)))))
+
+(DEFUN |bfUntil| (|p|)
+  (PROG (|g|)
+    (RETURN
+      (PROGN
+        (SETQ |g| (|bfGenSymbol|))
+        (LIST (LIST (LIST |g|) (LIST NIL) (LIST (LIST 'SETQ |g| |p|))
+                    NIL (LIST |g|) NIL))))))
+
+(DEFUN |bfIterators| (|x|) (PROG () (RETURN (CONS 'ITERATORS |x|))))
+
+(DEFUN |bfCross| (|x|) (PROG () (RETURN (CONS 'CROSS |x|))))
+
+(DEFUN |bfLp| (|iters| |body|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((EQCAR |iters| 'ITERATORS) (|bfLp1| (CDR |iters|) |body|))
+        ('T (|bfLpCross| (CDR |iters|) |body|))))))
+
+(DEFUN |bfLpCross| (|iters| |body|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL (CDR |iters|)) (|bfLp| (CAR |iters|) |body|))
+        ('T (|bfLp| (CAR |iters|) (|bfLpCross| (CDR |iters|) |body|)))))))
+
+(DEFUN |bfSep| (|iters|)
+  (PROG (|r| |f|)
+    (RETURN
+      (COND
+        ((NULL |iters|) (LIST NIL NIL NIL NIL NIL NIL))
+        ('T (SETQ |f| (CAR |iters|)) (SETQ |r| (|bfSep| (CDR |iters|)))
+         (LET ((|bfVar#78| NIL) (|bfVar#76| |f|) (|i| NIL)
+               (|bfVar#77| |r|) (|j| NIL))
+           (LOOP
+             (COND
+               ((OR (ATOM |bfVar#76|)
+                    (PROGN (SETQ |i| (CAR |bfVar#76|)) NIL)
+                    (ATOM |bfVar#77|)
+                    (PROGN (SETQ |j| (CAR |bfVar#77|)) NIL))
+                (RETURN (NREVERSE |bfVar#78|)))
+               ('T
+                (SETQ |bfVar#78| (CONS (APPEND |i| |j|) |bfVar#78|))))
+             (SETQ |bfVar#76| (CDR |bfVar#76|))
+             (SETQ |bfVar#77| (CDR |bfVar#77|)))))))))
+
+(DEFUN |bfReduce| (|op| |y|)
+  (PROG (|it| |ny| |g2| |body| |g1| |g| |init| |a|)
+    (RETURN
+      (PROGN
+        (SETQ |a|
+              (COND ((EQCAR |op| 'QUOTE) (CADR |op|)) (#0='T |op|)))
+        (SETQ |op| (|bfReName| |a|))
+        (SETQ |init| (GET |op| 'SHOETHETA))
+        (SETQ |g| (|bfGenSymbol|))
+        (SETQ |g1| (|bfGenSymbol|))
+        (SETQ |body| (LIST 'SETQ |g| (LIST |op| |g| |g1|)))
+        (COND
+          ((NULL |init|) (SETQ |g2| (|bfGenSymbol|))
+           (SETQ |init| (LIST 'CAR |g2|)) (SETQ |ny| (LIST 'CDR |g2|))
+           (SETQ |it|
+                 (CONS 'ITERATORS
+                       (LIST (LIST (LIST (LIST |g|) (LIST |init|) NIL
+                                    NIL NIL (LIST |g|)))
+                             (|bfIN| |g1| |ny|))))
+           (|bfMKPROGN|
+               (LIST (LIST 'L%T |g2| |y|) (|bfLp| |it| |body|))))
+          (#0# (SETQ |init| (CAR |init|))
+           (SETQ |it|
+                 (CONS 'ITERATORS
+                       (LIST (LIST (LIST (LIST |g|) (LIST |init|) NIL
+                                    NIL NIL (LIST |g|)))
+                             (|bfIN| |g1| |y|))))
+           (|bfLp| |it| |body|)))))))
+
+(DEFUN |bfReduceCollect| (|op| |y|)
+  (PROG (|init| |a| |itl| |body|)
+    (RETURN
+      (COND
+        ((EQCAR |y| 'COLLECT) (SETQ |body| (ELT |y| 1))
+         (SETQ |itl| (ELT |y| 2))
+         (SETQ |a|
+               (COND ((EQCAR |op| 'QUOTE) (CADR |op|)) (#0='T |op|)))
+         (SETQ |op| (|bfReName| |a|))
+         (SETQ |init| (GET |op| 'SHOETHETA))
+         (|bfOpReduce| |op| |init| |body| |itl|))
+        (#0# (SETQ |a| (|bfTupleConstruct| (ELT |y| 1)))
+         (|bfReduce| |op| |a|))))))
+
+(DEFUN |bfDCollect| (|y| |itl|)
+  (PROG () (RETURN (LIST 'COLLECT |y| |itl|))))
+
+(DEFUN |bfDTuple| (|x|) (PROG () (RETURN (LIST 'DTUPLE |x|))))
+
+(DEFUN |bfCollect| (|y| |itl|)
+  (PROG (|newBody| |a| |ISTMP#1|)
+    (RETURN
+      (COND
+        ((AND (CONSP |y|) (EQ (CAR |y|) 'COLON)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |y|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |a| (CAR |ISTMP#1|)) 'T))))
+         (|bf0APPEND| |a| |itl|))
+        ((AND (CONSP |y|) (EQ (CAR |y|) 'TUPLE))
+         (PROGN
+           (SETQ |newBody| (|bfConstruct| |y|))
+           (|bf0APPEND| |newBody| |itl|)))
+        ('T (|bf0COLLECT| |y| |itl|))))))
+
+(DEFUN |bf0COLLECT| (|y| |itl|)
+  (PROG () (RETURN (|bfListReduce| 'CONS |y| |itl|))))
+
+(DEFUN |bf0APPEND| (|y| |itl|)
+  (PROG (|extrait| |body| |g|)
+    (RETURN
+      (PROGN
+        (SETQ |g| (|bfGenSymbol|))
+        (SETQ |body|
+              (LIST 'SETQ |g| (LIST 'APPEND (LIST 'REVERSE |y|) |g|)))
+        (SETQ |extrait|
+              (LIST (LIST (LIST |g|) (LIST NIL) NIL NIL NIL
+                          (LIST (LIST 'NREVERSE |g|)))))
+        (|bfLp2| |extrait| |itl| |body|)))))
+
+(DEFUN |bfListReduce| (|op| |y| |itl|)
+  (PROG (|extrait| |body| |g|)
+    (RETURN
+      (PROGN
+        (SETQ |g| (|bfGenSymbol|))
+        (SETQ |body| (LIST 'SETQ |g| (LIST |op| |y| |g|)))
+        (SETQ |extrait|
+              (LIST (LIST (LIST |g|) (LIST NIL) NIL NIL NIL
+                          (LIST (LIST 'NREVERSE |g|)))))
+        (|bfLp2| |extrait| |itl| |body|)))))
+
+(DEFUN |bfLp1| (|iters| |body|)
+  (PROG (|loop| |nbody| |value| |exits| |filters| |sucs| |inits| |vars|
+                |LETTMP#1|)
+    (RETURN
+      (PROGN
+        (SETQ |LETTMP#1| (|bfSep| (|bfAppend| |iters|)))
+        (SETQ |vars| (CAR |LETTMP#1|))
+        (SETQ |inits| (CADR . #0=(|LETTMP#1|)))
+        (SETQ |sucs| (CADDR . #0#))
+        (SETQ |filters| (CADDDR . #0#))
+        (SETQ |exits| (CAR #1=(CDDDDR . #0#)))
+        (SETQ |value| (CADR #1#))
+        (SETQ |nbody|
+              (COND
+                ((NULL |filters|) |body|)
+                (#2='T (|bfAND| (APPEND |filters| (CONS |body| NIL))))))
+        (SETQ |value| (COND ((NULL |value|) 'NIL) (#2# (CAR |value|))))
+        (SETQ |exits|
+              (LIST 'COND
+                    (LIST (|bfOR| |exits|) (LIST 'RETURN |value|))
+                    (LIST ''T |nbody|)))
+        (SETQ |loop| (CONS 'LOOP (CONS |exits| |sucs|)))
+        (COND
+          (|vars| (SETQ |loop|
+                        (LIST 'LET
+                              (LET ((|bfVar#81| NIL)
+                                    (|bfVar#79| |vars|) (|v| NIL)
+                                    (|bfVar#80| |inits|) (|i| NIL))
+                                (LOOP
+                                  (COND
+                                    ((OR (ATOM |bfVar#79|)
+                                      (PROGN
+                                        (SETQ |v| (CAR |bfVar#79|))
+                                        NIL)
+                                      (ATOM |bfVar#80|)
+                                      (PROGN
+                                        (SETQ |i| (CAR |bfVar#80|))
+                                        NIL))
+                                     (RETURN (NREVERSE |bfVar#81|)))
+                                    ('T
+                                     (SETQ |bfVar#81|
+                                      (CONS (LIST |v| |i|) |bfVar#81|))))
+                                  (SETQ |bfVar#79| (CDR |bfVar#79|))
+                                  (SETQ |bfVar#80| (CDR |bfVar#80|))))
+                              |loop|))))
+        |loop|))))
+
+(DEFUN |bfLp2| (|extrait| |itl| |body|)
+  (PROG (|iters|)
+    (RETURN
+      (COND
+        ((EQCAR |itl| 'ITERATORS)
+         (|bfLp1| (CONS |extrait| (CDR |itl|)) |body|))
+        ('T
+         (PROGN
+           (SETQ |iters| (CDR |itl|))
+           (|bfLpCross|
+               (CONS (CONS 'ITERATORS (CONS |extrait| (CDAR |iters|)))
+                     (CDR |iters|))
+               |body|)))))))
+
+(DEFUN |bfOpReduce| (|op| |init| |y| |itl|)
+  (PROG (|extrait| |g1| |body| |g|)
+    (RETURN
+      (PROGN
+        (SETQ |g| (|bfGenSymbol|))
+        (SETQ |body|
+              (COND
+                ((EQ |op| 'AND)
+                 (|bfMKPROGN|
+                     (LIST (LIST 'SETQ |g| |y|)
+                           (LIST 'COND
+                                 (LIST (LIST 'NOT |g|)
+                                       (LIST 'RETURN 'NIL))))))
+                ((EQ |op| 'OR)
+                 (|bfMKPROGN|
+                     (LIST (LIST 'SETQ |g| |y|)
+                           (LIST 'COND (LIST |g| (LIST 'RETURN |g|))))))
+                ('T (LIST 'SETQ |g| (LIST |op| |g| |y|)))))
+        (COND
+          ((NULL |init|) (SETQ |g1| (|bfGenSymbol|))
+           (SETQ |init| (LIST 'CAR |g1|)) (SETQ |y| (LIST 'CDR |g1|))
+           (SETQ |extrait|
+                 (LIST (LIST (LIST |g|) (LIST |init|) NIL NIL NIL
+                             (LIST |g|))))
+           (|bfMKPROGN|
+               (LIST (LIST 'L%T |g1| |y|)
+                     (|bfLp2| |extrait| |itl| |body|))))
+          ('T (SETQ |init| (CAR |init|))
+           (SETQ |extrait|
+                 (LIST (LIST (LIST |g|) (LIST |init|) NIL NIL NIL
+                             (LIST |g|))))
+           (|bfLp2| |extrait| |itl| |body|)))))))
+
+(DEFUN |bfLoop1| (|body|)
+  (PROG () (RETURN (|bfLp| (|bfIterators| NIL) |body|))))
+
+(DEFUN |bfSegment1| (|lo|)
+  (PROG () (RETURN (LIST 'SEGMENT |lo| NIL))))
+
+(DEFUN |bfSegment2| (|lo| |hi|)
+  (PROG () (RETURN (LIST 'SEGMENT |lo| |hi|))))
+
+(DEFUN |bfForInBy| (|variable| |collection| |step|)
+  (PROG () (RETURN (|bfFor| |variable| |collection| |step|))))
+
+(DEFUN |bfForin| (|lhs| U) (PROG () (RETURN (|bfFor| |lhs| U 1))))
+
+(DEFUN |bfLocal| (|a| |b|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((EQ |b| 'FLUID) (|compFluid| |a|))
+        ((EQ |b| '|fluid|) (|compFluid| |a|))
+        ((EQ |b| '|local|) (|compFluid| |a|))
+        ('T |a|)))))
+
+(DEFUN |bfTake| (|n| |x|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL |x|) |x|)
+        ((EQL |n| 0) NIL)
+        ('T (CONS (CAR |x|) (|bfTake| (- |n| 1) (CDR |x|))))))))
+
+(DEFUN |bfDrop| (|n| |x|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((OR (NULL |x|) (EQL |n| 0)) |x|)
+        ('T (|bfDrop| (- |n| 1) (CDR |x|)))))))
+
+(DEFUN |bfDefSequence| (|l|) (PROG () (RETURN (CONS 'SEQ |l|))))
+
+(DEFUN |bfReturnNoName| (|a|) (PROG () (RETURN (LIST 'RETURN |a|))))
+
+(DEFUN |bfSUBLIS| (|p| |e|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((ATOM |e|) (|bfSUBLIS1| |p| |e|))
+        ((EQCAR |e| 'QUOTE) |e|)
+        ('T
+         (CONS (|bfSUBLIS| |p| (CAR |e|)) (|bfSUBLIS| |p| (CDR |e|))))))))
+
+(DEFUN |bfSUBLIS1| (|p| |e|)
+  (PROG (|f|)
+    (RETURN
+      (COND
+        ((NULL |p|) |e|)
+        (#0='T
+         (PROGN
+           (SETQ |f| (CAR |p|))
+           (COND
+             ((EQ (CAR |f|) |e|) (|bfSUBLIS| |p| (CDR |f|)))
+             (#0# (|bfSUBLIS1| (CDR |p|) |e|)))))))))
+
+(DEFUN |defSheepAndGoats| (|x|)
+  (PROG (|defstack| |op1| |opassoc| |argl| |body| |args| |op| |def|)
+    (DECLARE (SPECIAL |$op|))
+    (RETURN
+      (COND
+        ((EQCAR |x| 'DEF)
+         (PROGN
+           (SETQ |def| (CAR |x|))
+           (SETQ |op| (CADR . #0=(|x|)))
+           (SETQ |args| (CADDR . #0#))
+           (SETQ |body| (CADDDR . #0#))
+           (SETQ |argl|
+                 (COND
+                   ((|bfTupleP| |args|) (CDR |args|))
+                   (#1='T (LIST |args|))))
+           (COND
+             ((NULL |argl|) (SETQ |opassoc| (LIST (CONS |op| |body|)))
+              (LIST |opassoc| NIL NIL))
+             (#1#
+              (SETQ |op1|
+                    (INTERN (CONCAT (PNAME |$op|) "," (PNAME |op|))))
+              (SETQ |opassoc| (LIST (CONS |op| |op1|)))
+              (SETQ |defstack| (LIST (LIST 'DEF |op1| |args| |body|)))
+              (LIST |opassoc| |defstack| NIL)))))
+        ((EQCAR |x| 'SEQ) (|defSheepAndGoatsList| (CDR |x|)))
+        ('T (LIST NIL NIL (LIST |x|)))))))
+
+(DEFUN |defSheepAndGoatsList| (|x|)
+  (PROG (|nondefs1| |defs1| |opassoc1| |nondefs| |defs| |opassoc|
+            |LETTMP#1|)
+    (RETURN
+      (COND
+        ((NULL |x|) (LIST NIL NIL NIL))
+        ('T (SETQ |LETTMP#1| (|defSheepAndGoats| (CAR |x|)))
+         (SETQ |opassoc| (CAR |LETTMP#1|))
+         (SETQ |defs| (CADR . #0=(|LETTMP#1|)))
+         (SETQ |nondefs| (CADDR . #0#))
+         (SETQ |LETTMP#1| (|defSheepAndGoatsList| (CDR |x|)))
+         (SETQ |opassoc1| (CAR |LETTMP#1|))
+         (SETQ |defs1| (CADR . #1=(|LETTMP#1|)))
+         (SETQ |nondefs1| (CADDR . #1#))
+         (LIST (APPEND |opassoc| |opassoc1|) (APPEND |defs| |defs1|)
+               (APPEND |nondefs| |nondefs1|)))))))
+
+(DEFUN |bfLetForm| (|lhs| |rhs|)
+  (PROG () (RETURN (LIST 'L%T |lhs| |rhs|))))
+
+(DEFUN |bfLET1| (|lhs| |rhs|)
+  (PROG (|let1| |g| |l2| |l1| |name| |rhs1| |ISTMP#1|)
+    (DECLARE (SPECIAL |$letGenVarCounter|))
+    (RETURN
+      (COND
+        ((IDENTP |lhs|) (|bfLetForm| |lhs| |rhs|))
+        ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'FLUID)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |lhs|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL))))
+         (|bfLetForm| |lhs| |rhs|))
+        ((AND (IDENTP |rhs|) (NULL (|bfCONTAINED| |rhs| |lhs|)))
+         (PROGN
+           (SETQ |rhs1| (|bfLET2| |lhs| |rhs|))
+           (COND
+             ((EQCAR |rhs1| 'L%T) (|bfMKPROGN| (LIST |rhs1| |rhs|)))
+             ((EQCAR |rhs1| 'PROGN) (APPEND |rhs1| (LIST |rhs|)))
+             (#0='T
+              (PROGN
+                (COND
+                  ((IDENTP (CAR |rhs1|))
+                   (SETQ |rhs1| (CONS |rhs1| NIL))))
+                (|bfMKPROGN| (APPEND |rhs1| (CONS |rhs| NIL))))))))
+        ((AND (CONSP |rhs|) (EQCAR |rhs| 'L%T)
+              (IDENTP (SETQ |name| (CADR |rhs|))))
+         (PROGN
+           (SETQ |l1| (|bfLET1| |name| (CADDR |rhs|)))
+           (SETQ |l2| (|bfLET1| |lhs| |name|))
+           (COND
+             ((EQCAR |l2| 'PROGN) (|bfMKPROGN| (CONS |l1| (CDR |l2|))))
+             (#0#
+              (PROGN
+                (COND
+                  ((IDENTP (CAR |l2|)) (SETQ |l2| (CONS |l2| NIL))))
+                (|bfMKPROGN|
+                    (CONS |l1| (APPEND |l2| (CONS |name| NIL)))))))))
+        (#0#
+         (PROGN
+           (SETQ |g|
+                 (INTERN (CONCAT "LETTMP#"
+                                 (STRINGIMAGE |$letGenVarCounter|))))
+           (SETQ |$letGenVarCounter| (+ |$letGenVarCounter| 1))
+           (SETQ |rhs1| (LIST 'L%T |g| |rhs|))
+           (SETQ |let1| (|bfLET1| |lhs| |g|))
+           (COND
+             ((EQCAR |let1| 'PROGN)
+              (|bfMKPROGN| (CONS |rhs1| (CDR |let1|))))
+             (#0#
+              (PROGN
+                (COND
+                  ((IDENTP (CAR |let1|))
+                   (SETQ |let1| (CONS |let1| NIL))))
+                (|bfMKPROGN|
+                    (CONS |rhs1| (APPEND |let1| (CONS |g| NIL)))))))))))))
+
+(DEFUN |bfCONTAINED| (|x| |y|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((EQ |x| |y|) T)
+        ((ATOM |y|) NIL)
+        ('T
+         (OR (|bfCONTAINED| |x| (CAR |y|))
+             (|bfCONTAINED| |x| (CDR |y|))))))))
+
+(DEFUN |bfLET2| (|lhs| |rhs|)
+  (PROG (|isPred| |val1| |ISTMP#3| |g| |rev| |patrev| |l2| |l1| |var2|
+            |var1| |b| |ISTMP#2| |a| |ISTMP#1|)
+    (DECLARE (SPECIAL |$inDefIS| |$letGenVarCounter|))
+    (RETURN
+      (COND
+        ((IDENTP |lhs|) (|bfLetForm| |lhs| |rhs|))
+        ((NULL |lhs|) NIL)
+        ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'FLUID)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |lhs|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL))))
+         (|bfLetForm| |lhs| |rhs|))
+        ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'L%T)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |lhs|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |a| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |b| (CAR |ISTMP#2|)) #0='T))))))
+         (PROGN
+           (SETQ |a| (|bfLET2| |a| |rhs|))
+           (COND
+             ((NULL (SETQ |b| (|bfLET2| |b| |rhs|))) |a|)
+             ((ATOM |b|) (LIST |a| |b|))
+             ((CONSP (CAR |b|)) (CONS |a| |b|))
+             (#1='T (LIST |a| |b|)))))
+        ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'CONS)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |lhs|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |var1| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |var2| (CAR |ISTMP#2|)) #0#))))))
+         (COND
+           ((OR (EQ |var1| 'DOT)
+                (AND (CONSP |var1|) (EQCAR |var1| 'QUOTE)))
+            (|bfLET2| |var2| (|addCARorCDR| 'CDR |rhs|)))
+           (#1#
+            (PROGN
+              (SETQ |l1| (|bfLET2| |var1| (|addCARorCDR| 'CAR |rhs|)))
+              (COND
+                ((OR (NULL |var2|) (EQ |var2| 'DOT)) |l1|)
+                (#1#
+                 (PROGN
+                   (COND
+                     ((AND (CONSP |l1|) (ATOM (CAR |l1|)))
+                      (SETQ |l1| (CONS |l1| NIL))))
+                   (COND
+                     ((IDENTP |var2|)
+                      (APPEND |l1|
+                              (CONS (|bfLetForm| |var2|
+                                     (|addCARorCDR| 'CDR |rhs|))
+                                    NIL)))
+                     (#1#
+                      (PROGN
+                        (SETQ |l2|
+                              (|bfLET2| |var2|
+                                  (|addCARorCDR| 'CDR |rhs|)))
+                        (COND
+                          ((AND (CONSP |l2|) (ATOM (CAR |l2|)))
+                           (SETQ |l2| (CONS |l2| NIL))))
+                        (APPEND |l1| |l2|)))))))))))
+        ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'APPEND)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |lhs|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |var1| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |var2| (CAR |ISTMP#2|)) #0#))))))
+         (PROGN
+           (SETQ |patrev| (|bfISReverse| |var2| |var1|))
+           (SETQ |rev| (LIST 'REVERSE |rhs|))
+           (SETQ |g|
+                 (INTERN (CONCAT "LETTMP#"
+                                 (STRINGIMAGE |$letGenVarCounter|))))
+           (SETQ |$letGenVarCounter| (+ |$letGenVarCounter| 1))
+           (SETQ |l2| (|bfLET2| |patrev| |g|))
+           (COND
+             ((AND (CONSP |l2|) (ATOM (CAR |l2|)))
+              (SETQ |l2| (CONS |l2| NIL))))
+           (COND
+             ((EQ |var1| 'DOT) (CONS (LIST 'L%T |g| |rev|) |l2|))
+             ((PROGN
+                (SETQ |ISTMP#1| (|last| |l2|))
+                (AND (CONSP |ISTMP#1|) (EQ (CAR |ISTMP#1|) 'L%T)
+                     (PROGN
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|)
+                            (EQUAL (CAR |ISTMP#2|) |var1|)
+                            (PROGN
+                              (SETQ |ISTMP#3| (CDR |ISTMP#2|))
+                              (AND (CONSP |ISTMP#3|)
+                                   (EQ (CDR |ISTMP#3|) NIL)
+                                   (PROGN
+                                     (SETQ |val1| (CAR |ISTMP#3|))
+                                     #0#)))))))
+              (CONS (LIST 'L%T |g| |rev|)
+                    (APPEND (REVERSE (CDR (REVERSE |l2|)))
+                            (CONS (|bfLetForm| |var1|
+                                      (LIST 'NREVERSE |val1|))
+                                  NIL))))
+             (#1#
+              (CONS (LIST 'L%T |g| |rev|)
+                    (APPEND |l2|
+                            (CONS (|bfLetForm| |var1|
+                                      (LIST 'NREVERSE |var1|))
+                                  NIL)))))))
+        ((AND (CONSP |lhs|) (EQ (CAR |lhs|) 'EQUAL)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |lhs|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |var1| (CAR |ISTMP#1|)) #0#))))
+         (LIST 'COND (LIST (LIST 'EQUAL |var1| |rhs|) |var1|)))
+        (#1#
+         (PROGN
+           (SETQ |isPred|
+                 (COND
+                   (|$inDefIS| (|bfIS1| |rhs| |lhs|))
+                   (#1# (|bfIS| |rhs| |lhs|))))
+           (LIST 'COND (LIST |isPred| |rhs|))))))))
+
+(DEFUN |bfLET| (|lhs| |rhs|)
+  (PROG (|$letGenVarCounter|)
+    (DECLARE (SPECIAL |$letGenVarCounter|))
+    (RETURN
+      (PROGN (SETQ |$letGenVarCounter| 1) (|bfLET1| |lhs| |rhs|)))))
+
+(DEFUN |addCARorCDR| (|acc| |expr|)
+  (PROG (|funsR| |funsA| |p| |funs|)
+    (RETURN
+      (COND
+        ((NULL (CONSP |expr|)) (LIST |acc| |expr|))
+        ((AND (EQ |acc| 'CAR) (EQCAR |expr| 'REVERSE))
+         (LIST 'CAR (CONS 'LAST (CDR |expr|))))
+        (#0='T
+         (PROGN
+           (SETQ |funs|
+                 '(CAR CDR CAAR CDAR CADR CDDR CAAAR CADAR CAADR CADDR
+                       CDAAR CDDAR CDADR CDDDR))
+           (SETQ |p| (|bfPosition| (CAR |expr|) |funs|))
+           (COND
+             ((EQUAL |p| (- 1)) (LIST |acc| |expr|))
+             (#0#
+              (PROGN
+                (SETQ |funsA|
+                      '(CAAR CADR CAAAR CADAR CAADR CADDR CAAAAR CAADAR
+                             CAAADR CAADDR CADAAR CADDAR CADADR CADDDR))
+                (SETQ |funsR|
+                      '(CDAR CDDR CDAAR CDDAR CDADR CDDDR CDAAAR CDADAR
+                             CDAADR CDADDR CDDAAR CDDDAR CDDADR CDDDDR))
+                (COND
+                  ((EQ |acc| 'CAR)
+                   (CONS (ELT |funsA| |p|) (CDR |expr|)))
+                  ('T (CONS (ELT |funsR| |p|) (CDR |expr|)))))))))))))
+
+(DEFUN |bfPosition| (|x| |l|) (PROG () (RETURN (|bfPosn| |x| |l| 0))))
+
+(DEFUN |bfPosn| (|x| |l| |n|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL |l|) (- 1))
+        ((EQUAL |x| (CAR |l|)) |n|)
+        ('T (|bfPosn| |x| (CDR |l|) (+ |n| 1)))))))
+
+(DEFUN |bfISApplication| (|op| |left| |right|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((EQ |op| 'IS) (|bfIS| |left| |right|))
+        ((EQ |op| 'ISNT) (|bfNOT| (|bfIS| |left| |right|)))
+        ('T (LIST |op| |left| |right|))))))
+
+(DEFUN |bfIS| (|left| |right|)
+  (PROG (|$inDefIS| |$isGenVarCounter|)
+    (DECLARE (SPECIAL |$inDefIS| |$isGenVarCounter|))
+    (RETURN
+      (PROGN
+        (SETQ |$isGenVarCounter| 1)
+        (SETQ |$inDefIS| T)
+        (|bfIS1| |left| |right|)))))
+
+(DEFUN |bfISReverse| (|x| |a|)
+  (PROG (|y|)
+    (RETURN
+      (COND
+        ((AND (CONSP |x|) (EQ (CAR |x|) 'CONS))
+         (COND
+           ((NULL (CADDR |x|)) (LIST 'CONS (CADR |x|) |a|))
+           (#0='T
+            (PROGN
+              (SETQ |y| (|bfISReverse| (CADDR |x|) NIL))
+              (RPLACA (CDDR |y|) (LIST 'CONS (CADR |x|) |a|))
+              |y|))))
+        (#0#
+         (PROGN
+           (|bpSpecificErrorHere| "Error in bfISReverse")
+           (|bpTrap|)))))))
+
+(DEFUN |bfIS1| (|lhs| |rhs|)
+  (PROG (|l2| |rev| |patrev| |cls| |b1| |a1| |b| |g| |l| |d| |ISTMP#2|
+              |c| |a| |ISTMP#1|)
+    (DECLARE (SPECIAL |$isGenVarCounter|))
+    (RETURN
+      (COND
+        ((NULL |rhs|) (LIST 'NULL |lhs|))
+        ((STRINGP |rhs|) (LIST 'EQ |lhs| (LIST 'QUOTE (INTERN |rhs|))))
+        ((NUMBERP |rhs|) (LIST 'EQUAL |lhs| |rhs|))
+        ((ATOM |rhs|) (LIST 'PROGN (|bfLetForm| |rhs| |lhs|) ''T))
+        ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'QUOTE)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |rhs|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0='T))))
+         (COND
+           ((IDENTP |a|) (LIST 'EQ |lhs| |rhs|))
+           (#1='T (LIST 'EQUAL |lhs| |rhs|))))
+        ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'L%T)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |rhs|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |c| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |d| (CAR |ISTMP#2|)) #0#))))))
+         (PROGN
+           (SETQ |l| (|bfLET| |c| |lhs|))
+           (|bfAND| (LIST (|bfIS1| |lhs| |d|)
+                          (|bfMKPROGN| (LIST |l| ''T))))))
+        ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'EQUAL)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |rhs|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0#))))
+         (LIST 'EQUAL |lhs| |a|))
+        ((CONSP |lhs|)
+         (PROGN
+           (SETQ |g|
+                 (INTERN (CONCAT "ISTMP#"
+                                 (STRINGIMAGE |$isGenVarCounter|))))
+           (SETQ |$isGenVarCounter| (+ |$isGenVarCounter| 1))
+           (|bfMKPROGN|
+               (LIST (LIST 'L%T |g| |lhs|) (|bfIS1| |g| |rhs|)))))
+        ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'CONS)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |rhs|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |a| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |b| (CAR |ISTMP#2|)) #0#))))))
+         (COND
+           ((EQ |a| 'DOT)
+            (COND
+              ((NULL |b|)
+               (|bfAND| (LIST (LIST 'CONSP |lhs|)
+                              (LIST 'EQ (LIST 'CDR |lhs|) 'NIL))))
+              (#1#
+               (|bfAND| (LIST (LIST 'CONSP |lhs|)
+                              (|bfIS1| (LIST 'CDR |lhs|) |b|))))))
+           ((NULL |b|)
+            (|bfAND| (LIST (LIST 'CONSP |lhs|)
+                           (LIST 'EQ (LIST 'CDR |lhs|) 'NIL)
+                           (|bfIS1| (LIST 'CAR |lhs|) |a|))))
+           ((EQ |b| 'DOT)
+            (|bfAND| (LIST (LIST 'CONSP |lhs|)
+                           (|bfIS1| (LIST 'CAR |lhs|) |a|))))
+           (#1#
+            (PROGN
+              (SETQ |a1| (|bfIS1| (LIST 'CAR |lhs|) |a|))
+              (SETQ |b1| (|bfIS1| (LIST 'CDR |lhs|) |b|))
+              (COND
+                ((AND (CONSP |a1|) (EQ (CAR |a1|) 'PROGN)
+                      (PROGN
+                        (SETQ |ISTMP#1| (CDR |a1|))
+                        (AND (CONSP |ISTMP#1|)
+                             (PROGN
+                               (SETQ |c| (CAR |ISTMP#1|))
+                               (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                               (AND (CONSP |ISTMP#2|)
+                                    (EQ (CDR |ISTMP#2|) NIL)
+                                    (EQUAL (CAR |ISTMP#2|) ''T)))))
+                      (CONSP |b1|) (EQ (CAR |b1|) 'PROGN)
+                      (PROGN (SETQ |cls| (CDR |b1|)) #0#))
+                 (|bfAND| (LIST (LIST 'CONSP |lhs|)
+                                (|bfMKPROGN| (CONS |c| |cls|)))))
+                (#1# (|bfAND| (LIST (LIST 'CONSP |lhs|) |a1| |b1|))))))))
+        ((AND (CONSP |rhs|) (EQ (CAR |rhs|) 'APPEND)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |rhs|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |a| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |b| (CAR |ISTMP#2|)) #0#))))))
+         (PROGN
+           (SETQ |patrev| (|bfISReverse| |b| |a|))
+           (SETQ |g|
+                 (INTERN (CONCAT "ISTMP#"
+                                 (STRINGIMAGE |$isGenVarCounter|))))
+           (SETQ |$isGenVarCounter| (+ |$isGenVarCounter| 1))
+           (SETQ |rev|
+                 (|bfAND| (LIST (LIST 'CONSP |lhs|)
+                                (LIST 'PROGN
+                                      (LIST 'L%T |g|
+                                       (LIST 'REVERSE |lhs|))
+                                      ''T))))
+           (SETQ |l2| (|bfIS1| |g| |patrev|))
+           (COND
+             ((AND (CONSP |l2|) (ATOM (CAR |l2|)))
+              (SETQ |l2| (CONS |l2| NIL))))
+           (COND
+             ((EQ |a| 'DOT) (|bfAND| (CONS |rev| |l2|)))
+             (#1#
+              (|bfAND| (CONS |rev|
+                             (APPEND |l2|
+                                     (CONS
+                                      (LIST 'PROGN
+                                       (|bfLetForm| |a|
+                                        (LIST 'NREVERSE |a|))
+                                       ''T)
+                                      NIL))))))))
+        (#1#
+         (PROGN
+           (|bpSpecificErrorHere| "bad IS code is generated")
+           (|bpTrap|)))))))
+
+(DEFUN |bfApplication| (|bfop| |bfarg|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((|bfTupleP| |bfarg|) (CONS |bfop| (CDR |bfarg|)))
+        ('T (CONS |bfop| (LIST |bfarg|)))))))
+
+(DEFUN |bfGetOldBootName| (|x|)
+  (PROG (|a|)
+    (RETURN
+      (COND ((SETQ |a| (GET |x| 'OLD-BOOT)) (CAR |a|)) ('T |x|)))))
+
+(DEFUN |bfSameMeaning| (|x|) (PROG () (RETURN (GET |x| 'RENAME-OK))))
+
+(DEFUN |bfReName| (|x|)
+  (PROG (|oldName| |newName| |a|)
+    (DECLARE (SPECIAL |$translatingOldBoot|))
+    (RETURN
+      (PROGN
+        (SETQ |newName|
+              (COND
+                ((SETQ |a| (GET |x| 'SHOERENAME)) (CAR |a|))
+                (#0='T |x|)))
+        (COND
+          ((AND |$translatingOldBoot| (NULL (|bfSameMeaning| |x|)))
+           (PROGN
+             (SETQ |oldName| (|bfGetOldBootName| |x|))
+             (COND
+               ((NOT (EQUAL |newName| |oldName|))
+                (|warn| (LIST (PNAME |x|) " as `" (PNAME |newName|)
+                              "' differs from Old Boot `"
+                              (PNAME |oldName|) "'"))))
+             |oldName|))
+          (#0# |newName|))))))
+
+(DEFUN |bfInfApplication| (|op| |left| |right|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((EQ |op| 'EQUAL) (|bfQ| |left| |right|))
+        ((EQ |op| '/=) (|bfNOT| (|bfQ| |left| |right|)))
+        ((EQ |op| '>) (|bfLessp| |right| |left|))
+        ((EQ |op| '<) (|bfLessp| |left| |right|))
+        ((EQ |op| '<=) (|bfNOT| (|bfLessp| |right| |left|)))
+        ((EQ |op| '>=) (|bfNOT| (|bfLessp| |left| |right|)))
+        ((EQ |op| 'OR) (|bfOR| (LIST |left| |right|)))
+        ((EQ |op| 'AND) (|bfAND| (LIST |left| |right|)))
+        ('T (LIST |op| |left| |right|))))))
+
+(DEFUN |bfNOT| (|x|)
+  (PROG (|a| |ISTMP#1|)
+    (RETURN
+      (COND
+        ((AND (CONSP |x|) (EQ (CAR |x|) 'NOT)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |x|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0='T))))
+         |a|)
+        ((AND (CONSP |x|) (EQ (CAR |x|) 'NULL)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |x|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0#))))
+         |a|)
+        ('T (LIST 'NOT |x|))))))
+
+(DEFUN |bfFlatten| (|op| |x|)
+  (PROG ()
+    (RETURN (COND ((EQCAR |x| |op|) (CDR |x|)) ('T (LIST |x|))))))
+
+(DEFUN |bfOR| (|l|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL |l|) NIL)
+        ((NULL (CDR |l|)) (CAR |l|))
+        ('T
+         (CONS 'OR
+               (LET ((|bfVar#83| NIL) (|bfVar#82| |l|) (|c| NIL))
+                 (LOOP
+                   (COND
+                     ((OR (ATOM |bfVar#82|)
+                          (PROGN (SETQ |c| (CAR |bfVar#82|)) NIL))
+                      (RETURN (NREVERSE |bfVar#83|)))
+                     ('T
+                      (SETQ |bfVar#83|
+                            (APPEND (REVERSE (|bfFlatten| 'OR |c|))
+                                    |bfVar#83|))))
+                   (SETQ |bfVar#82| (CDR |bfVar#82|))))))))))
+
+(DEFUN |bfAND| (|l|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL |l|) 'T)
+        ((NULL (CDR |l|)) (CAR |l|))
+        ('T
+         (CONS 'AND
+               (LET ((|bfVar#85| NIL) (|bfVar#84| |l|) (|c| NIL))
+                 (LOOP
+                   (COND
+                     ((OR (ATOM |bfVar#84|)
+                          (PROGN (SETQ |c| (CAR |bfVar#84|)) NIL))
+                      (RETURN (NREVERSE |bfVar#85|)))
+                     ('T
+                      (SETQ |bfVar#85|
+                            (APPEND (REVERSE (|bfFlatten| 'AND |c|))
+                                    |bfVar#85|))))
+                   (SETQ |bfVar#84| (CDR |bfVar#84|))))))))))
+
+(DEFUN |defQuoteId| (|x|)
+  (PROG () (RETURN (AND (EQCAR |x| 'QUOTE) (IDENTP (CADR |x|))))))
+
+(DEFUN |bfSmintable| (|x|)
+  (PROG ()
+    (RETURN
+      (OR (INTEGERP |x|)
+          (AND (CONSP |x|) (MEMQ (CAR |x|) '(SIZE LENGTH)))))))
+
+(DEFUN |bfQ| (|l| |r|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((OR (|bfSmintable| |l|) (|bfSmintable| |r|))
+         (LIST 'EQL |l| |r|))
+        ((OR (|defQuoteId| |l|) (|defQuoteId| |r|)) (LIST 'EQ |l| |r|))
+        ((NULL |l|) (LIST 'NULL |r|))
+        ((NULL |r|) (LIST 'NULL |l|))
+        ('T (LIST 'EQUAL |l| |r|))))))
+
+(DEFUN |bfLessp| (|l| |r|)
+  (PROG ()
+    (RETURN
+      (COND ((EQL |r| 0) (LIST 'MINUSP |l|)) ('T (LIST '< |l| |r|))))))
+
+(DEFUN |bfMDef| (|defOp| |op| |args| |body|)
+  (PROG (|def| |lamex| |sb2| |sb| |largl| |nargl| |sgargl| |gargl|
+               |LETTMP#1| |argl|)
+    (DECLARE (SPECIAL |$wheredefs|))
+    (RETURN
+      (PROGN
+        (SETQ |argl|
+              (COND
+                ((|bfTupleP| |args|) (CDR |args|))
+                ('T (LIST |args|))))
+        (SETQ |LETTMP#1| (|bfGargl| |argl|))
+        (SETQ |gargl| (CAR |LETTMP#1|))
+        (SETQ |sgargl| (CADR . #0=(|LETTMP#1|)))
+        (SETQ |nargl| (CADDR . #0#))
+        (SETQ |largl| (CADDDR . #0#))
+        (SETQ |sb|
+              (LET ((|bfVar#88| NIL) (|bfVar#86| |nargl|) (|i| NIL)
+                    (|bfVar#87| |sgargl|) (|j| NIL))
+                (LOOP
+                  (COND
+                    ((OR (ATOM |bfVar#86|)
+                         (PROGN (SETQ |i| (CAR |bfVar#86|)) NIL)
+                         (ATOM |bfVar#87|)
+                         (PROGN (SETQ |j| (CAR |bfVar#87|)) NIL))
+                     (RETURN (NREVERSE |bfVar#88|)))
+                    (#1='T
+                     (SETQ |bfVar#88| (CONS (CONS |i| |j|) |bfVar#88|))))
+                  (SETQ |bfVar#86| (CDR |bfVar#86|))
+                  (SETQ |bfVar#87| (CDR |bfVar#87|)))))
+        (SETQ |body| (SUBLIS |sb| |body|))
+        (SETQ |sb2|
+              (LET ((|bfVar#91| NIL) (|bfVar#89| |sgargl|) (|i| NIL)
+                    (|bfVar#90| |largl|) (|j| NIL))
+                (LOOP
+                  (COND
+                    ((OR (ATOM |bfVar#89|)
+                         (PROGN (SETQ |i| (CAR |bfVar#89|)) NIL)
+                         (ATOM |bfVar#90|)
+                         (PROGN (SETQ |j| (CAR |bfVar#90|)) NIL))
+                     (RETURN (NREVERSE |bfVar#91|)))
+                    (#1#
+                     (SETQ |bfVar#91|
+                           (CONS (LIST 'CONS (LIST 'QUOTE |i|) |j|)
+                                 |bfVar#91|))))
+                  (SETQ |bfVar#89| (CDR |bfVar#89|))
+                  (SETQ |bfVar#90| (CDR |bfVar#90|)))))
+        (SETQ |body|
+              (LIST 'SUBLIS (CONS 'LIST |sb2|) (LIST 'QUOTE |body|)))
+        (SETQ |lamex| (LIST 'MLAMBDA |gargl| |body|))
+        (SETQ |def| (LIST |op| |lamex|))
+        (|bfTuple|
+            (CONS (|shoeComp| |def|)
+                  (LET ((|bfVar#93| NIL) (|bfVar#92| |$wheredefs|)
+                        (|d| NIL))
+                    (LOOP
+                      (COND
+                        ((OR (ATOM |bfVar#92|)
+                             (PROGN (SETQ |d| (CAR |bfVar#92|)) NIL))
+                         (RETURN (NREVERSE |bfVar#93|)))
+                        (#1#
+                         (SETQ |bfVar#93|
+                               (APPEND (REVERSE
+                                        (|shoeComps| (|bfDef1| |d|)))
+                                       |bfVar#93|))))
+                      (SETQ |bfVar#92| (CDR |bfVar#92|))))))))))
+
+(DEFUN |bfGargl| (|argl|)
+  (PROG (|f| |d| |c| |b| |a| |LETTMP#1|)
+    (RETURN
+      (COND
+        ((NULL |argl|) (LIST NIL NIL NIL NIL))
+        (#0='T (SETQ |LETTMP#1| (|bfGargl| (CDR |argl|)))
+         (SETQ |a| (CAR |LETTMP#1|))
+         (SETQ |b| (CADR . #1=(|LETTMP#1|))) (SETQ |c| (CADDR . #1#))
+         (SETQ |d| (CADDDR . #1#))
+         (COND
+           ((EQ (CAR |argl|) '&REST)
+            (LIST (CONS (CAR |argl|) |b|) |b| |c|
+                  (CONS (LIST 'CONS (LIST 'QUOTE 'LIST) (CAR |d|))
+                        (CDR |d|))))
+           (#0# (SETQ |f| (|bfGenSymbol|))
+            (LIST (CONS |f| |a|) (CONS |f| |b|) (CONS (CAR |argl|) |c|)
+                  (CONS |f| |d|)))))))))
+
+(DEFUN |bfDef1| (|bfVar#94|)
+  (PROG (|arglp| |control| |quotes| |LETTMP#1| |argl| |body| |args|
+                 |op| |defOp|)
+    (RETURN
+      (PROGN
+        (SETQ |defOp| (CAR |bfVar#94|))
+        (SETQ |op| (CADR . #0=(|bfVar#94|)))
+        (SETQ |args| (CADDR . #0#))
+        (SETQ |body| (CADDDR . #0#))
+        (SETQ |argl|
+              (COND
+                ((|bfTupleP| |args|) (CDR |args|))
+                ('T (LIST |args|))))
+        (SETQ |LETTMP#1| (|bfInsertLet| |argl| |body|))
+        (SETQ |quotes| (CAR |LETTMP#1|))
+        (SETQ |control| (CADR . #1=(|LETTMP#1|)))
+        (SETQ |arglp| (CADDR . #1#))
+        (SETQ |body| (CADDDR . #1#))
+        (COND
+          (|quotes| (|shoeLAM| |op| |arglp| |control| |body|))
+          ('T (LIST (LIST |op| (LIST 'LAMBDA |arglp| |body|)))))))))
+
+(DEFUN |shoeLAM| (|op| |args| |control| |body|)
+  (PROG (|innerfunc| |margs|)
+    (RETURN
+      (PROGN
+        (SETQ |margs| (|bfGenSymbol|))
+        (SETQ |innerfunc| (INTERN (CONCAT (PNAME |op|) '|,LAM|)))
+        (LIST (LIST |innerfunc| (LIST 'LAMBDA |args| |body|))
+              (LIST |op|
+                    (LIST 'MLAMBDA (LIST '&REST |margs|)
+                          (LIST 'CONS (LIST 'QUOTE |innerfunc|)
+                                (LIST 'WRAP |margs|
+                                      (LIST 'QUOTE |control|))))))))))
+
+(DEFUN |bfDef| (|defOp| |op| |args| |body|)
+  (PROG (|body1| |arg1| |op1| |LETTMP#1|)
+    (DECLARE (SPECIAL |$wheredefs| |$bfClamming|))
+    (RETURN
+      (COND
+        (|$bfClamming|
+            (PROGN
+              (SETQ |LETTMP#1|
+                    (|shoeComp|
+                        (CAR (|bfDef1|
+                                 (LIST |defOp| |op| |args| |body|)))))
+              (SETQ |op1| (CADR . #0=(|LETTMP#1|)))
+              (SETQ |arg1| (CADDR . #0#))
+              (SETQ |body1| (CDDDR . #0#))
+              (|bfCompHash| |op1| |arg1| |body1|)))
+        ('T
+         (|bfTuple|
+             (LET ((|bfVar#96| NIL)
+                   (|bfVar#95|
+                       (CONS (LIST |defOp| |op| |args| |body|)
+                             |$wheredefs|))
+                   (|d| NIL))
+               (LOOP
+                 (COND
+                   ((OR (ATOM |bfVar#95|)
+                        (PROGN (SETQ |d| (CAR |bfVar#95|)) NIL))
+                    (RETURN (NREVERSE |bfVar#96|)))
+                   ('T
+                    (SETQ |bfVar#96|
+                          (APPEND (REVERSE (|shoeComps| (|bfDef1| |d|)))
+                                  |bfVar#96|))))
+                 (SETQ |bfVar#95| (CDR |bfVar#95|))))))))))
+
+(DEFUN |shoeComps| (|x|)
+  (PROG ()
+    (RETURN
+      (LET ((|bfVar#98| NIL) (|bfVar#97| |x|) (|def| NIL))
+        (LOOP
+          (COND
+            ((OR (ATOM |bfVar#97|)
+                 (PROGN (SETQ |def| (CAR |bfVar#97|)) NIL))
+             (RETURN (NREVERSE |bfVar#98|)))
+            ('T (SETQ |bfVar#98| (CONS (|shoeComp| |def|) |bfVar#98|))))
+          (SETQ |bfVar#97| (CDR |bfVar#97|)))))))
+
+(DEFUN |shoeComp| (|x|)
+  (PROG (|a|)
+    (RETURN
+      (PROGN
+        (SETQ |a| (|shoeCompTran| (CADR |x|)))
+        (COND
+          ((EQCAR |a| 'LAMBDA)
+           (CONS 'DEFUN (CONS (CAR |x|) (CONS (CADR |a|) (CDDR |a|)))))
+          ('T
+           (CONS 'DEFMACRO
+                 (CONS (CAR |x|) (CONS (CADR |a|) (CDDR |a|))))))))))
+
+(DEFUN |bfInsertLet| (|x| |body|)
+  (PROG (|body2| |name2| |norq1| |b1| |body1| |name1| |norq| |LETTMP#1|
+                 |b| |a| |ISTMP#1|)
+    (RETURN
+      (COND
+        ((NULL |x|) (LIST NIL NIL |x| |body|))
+        ((AND (CONSP |x|) (EQ (CAR |x|) '&REST)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |x|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |a| (CAR |ISTMP#1|)) #0='T))))
+         (COND
+           ((AND (CONSP |a|) (EQ (CAR |a|) 'QUOTE)
+                 (PROGN
+                   (SETQ |ISTMP#1| (CDR |a|))
+                   (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                        (PROGN (SETQ |b| (CAR |ISTMP#1|)) #0#))))
+            (LIST T 'QUOTE (LIST '&REST |b|) |body|))
+           (#1='T (LIST NIL NIL |x| |body|))))
+        (#1# (SETQ |LETTMP#1| (|bfInsertLet1| (CAR |x|) |body|))
+         (SETQ |b| (CAR |LETTMP#1|))
+         (SETQ |norq| (CADR . #2=(|LETTMP#1|)))
+         (SETQ |name1| (CADDR . #2#)) (SETQ |body1| (CADDDR . #2#))
+         (SETQ |LETTMP#1| (|bfInsertLet| (CDR |x|) |body1|))
+         (SETQ |b1| (CAR |LETTMP#1|))
+         (SETQ |norq1| (CADR . #3=(|LETTMP#1|)))
+         (SETQ |name2| (CADDR . #3#)) (SETQ |body2| (CADDDR . #3#))
+         (LIST (OR |b| |b1|) (CONS |norq| |norq1|)
+               (CONS |name1| |name2|) |body2|))))))
+
+(DEFUN |bfInsertLet1| (|y| |body|)
+  (PROG (|g| |b| |r| |ISTMP#2| |l| |ISTMP#1|)
+    (RETURN
+      (COND
+        ((AND (CONSP |y|) (EQ (CAR |y|) 'L%T)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |y|))
+                (AND (CONSP |ISTMP#1|)
+                     (PROGN
+                       (SETQ |l| (CAR |ISTMP#1|))
+                       (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                       (AND (CONSP |ISTMP#2|) (EQ (CDR |ISTMP#2|) NIL)
+                            (PROGN (SETQ |r| (CAR |ISTMP#2|)) #0='T))))))
+         (LIST NIL NIL |l|
+               (|bfMKPROGN| (LIST (|bfLET| |r| |l|) |body|))))
+        ((IDENTP |y|) (LIST NIL NIL |y| |body|))
+        ((AND (CONSP |y|) (EQ (CAR |y|) 'BVQUOTE)
+              (PROGN
+                (SETQ |ISTMP#1| (CDR |y|))
+                (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                     (PROGN (SETQ |b| (CAR |ISTMP#1|)) #0#))))
+         (LIST T 'QUOTE |b| |body|))
+        ('T (SETQ |g| (|bfGenSymbol|))
+         (COND
+           ((ATOM |y|) (LIST NIL NIL |g| |body|))
+           ('T
+            (LIST NIL NIL |g|
+                  (|bfMKPROGN|
+                      (LIST (|bfLET| (|compFluidize| |y|) |g|) |body|))))))))))
+
+(DEFUN |shoeCompTran| (|x|)
+  (PROG (|$dollarVars| |$locVars| |$fluidVars| |fvs| |fl| |fvars|
+            |lvars| |body| |args| |lamtype|)
+    (DECLARE (SPECIAL |$typings| |$dollarVars| |$fluidVars| |$locVars|))
+    (RETURN
+      (PROGN
+        (SETQ |lamtype| (CAR |x|))
+        (SETQ |args| (CADR |x|))
+        (SETQ |body| (CDDR |x|))
+        (SETQ |$fluidVars| NIL)
+        (SETQ |$locVars| NIL)
+        (SETQ |$dollarVars| NIL)
+        (|shoeCompTran1| |body|)
+        (SETQ |$locVars|
+              (SETDIFFERENCE (SETDIFFERENCE |$locVars| |$fluidVars|)
+                  (|shoeATOMs| |args|)))
+        (SETQ |body|
+              (COND
+                ((OR |$fluidVars| |$locVars| |$dollarVars| |$typings|)
+                 (SETQ |lvars| (APPEND |$fluidVars| |$locVars|))
+                 (SETQ |$fluidVars| (UNION |$fluidVars| |$dollarVars|))
+                 (COND
+                   ((NULL |$fluidVars|)
+                    (COND
+                      ((NULL |$typings|) (|shoePROG| |lvars| |body|))
+                      (#0='T
+                       (|shoePROG| |lvars|
+                           (CONS (CONS 'DECLARE |$typings|) |body|)))))
+                   (#1='T
+                    (SETQ |fvars|
+                          (LIST 'DECLARE (CONS 'SPECIAL |$fluidVars|)))
+                    (COND
+                      ((NULL |$typings|)
+                       (|shoePROG| |lvars| (CONS |fvars| |body|)))
+                      (#0#
+                       (|shoePROG| |lvars|
+                           (CONS |fvars|
+                                 (CONS (CONS 'DECLARE |$typings|)
+                                       |body|))))))))
+                (#1# (|shoePROG| NIL |body|))))
+        (SETQ |fl| (|shoeFluids| |args|))
+        (SETQ |body|
+              (COND
+                (|fl| (SETQ |fvs| (LIST 'DECLARE (CONS 'SPECIAL |fl|)))
+                      (CONS |fvs| |body|))
+                (#1# |body|)))
+        (CONS |lamtype| (CONS |args| |body|))))))
+
+(DEFUN |shoePROG| (|v| |b|)
+  (PROG (|blist| |blast| |LETTMP#1|)
+    (RETURN
+      (COND
+        ((NULL |b|) (LIST (LIST 'PROG |v|)))
+        ('T
+         (PROGN
+           (SETQ |LETTMP#1| (REVERSE |b|))
+           (SETQ |blast| (CAR |LETTMP#1|))
+           (SETQ |blist| (NREVERSE (CDR |LETTMP#1|)))
+           (LIST (CONS 'PROG
+                       (CONS |v|
+                             (APPEND |blist|
+                                     (CONS (LIST 'RETURN |blast|) NIL)))))))))))
+
+(DEFUN |shoeFluids| (|x|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL |x|) NIL)
+        ((AND (IDENTP |x|) (|bfBeginsDollar| |x|)) (LIST |x|))
+        ((EQCAR |x| 'QUOTE) NIL)
+        ((ATOM |x|) NIL)
+        ('T (APPEND (|shoeFluids| (CAR |x|)) (|shoeFluids| (CDR |x|))))))))
+
+(DEFUN |shoeATOMs| (|x|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL |x|) NIL)
+        ((ATOM |x|) (LIST |x|))
+        ('T (APPEND (|shoeATOMs| (CAR |x|)) (|shoeATOMs| (CDR |x|))))))))
+
+(DEFUN |shoeCompTran1| (|x|)
+  (PROG (|res| |newbindings| |r| |ISTMP#2| |l| |ISTMP#1| U)
+    (DECLARE (SPECIAL |$fluidVars| |$locVars| |$dollarVars|))
+    (RETURN
+      (COND
+        ((ATOM |x|)
+         (COND
+           ((AND (IDENTP |x|) (|bfBeginsDollar| |x|))
+            (SETQ |$dollarVars|
+                  (COND
+                    ((MEMQ |x| |$dollarVars|) |$dollarVars|)
+                    (#0='T (CONS |x| |$dollarVars|)))))
+           (#0# NIL)))
+        (#0#
+         (PROGN
+           (SETQ U (CAR |x|))
+           (COND
+             ((EQ U 'QUOTE) NIL)
+             ((AND (CONSP |x|) (EQ (CAR |x|) 'L%T)
+                   (PROGN
+                     (SETQ |ISTMP#1| (CDR |x|))
+                     (AND (CONSP |ISTMP#1|)
+                          (PROGN
+                            (SETQ |l| (CAR |ISTMP#1|))
+                            (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                            (AND (CONSP |ISTMP#2|)
+                                 (EQ (CDR |ISTMP#2|) NIL)
+                                 (PROGN (SETQ |r| (CAR |ISTMP#2|)) 'T))))))
+              (PROGN
+                (RPLACA |x| 'SETQ)
+                (|shoeCompTran1| |r|)
+                (COND
+                  ((IDENTP |l|)
+                   (COND
+                     ((NULL (|bfBeginsDollar| |l|))
+                      (SETQ |$locVars|
+                            (COND
+                              ((MEMQ |l| |$locVars|) |$locVars|)
+                              (#0# (CONS |l| |$locVars|)))))
+                     (#0#
+                      (SETQ |$dollarVars|
+                            (COND
+                              ((MEMQ |l| |$dollarVars|) |$dollarVars|)
+                              (#0# (CONS |l| |$dollarVars|)))))))
+                  ((EQCAR |l| 'FLUID)
+                   (PROGN
+                     (SETQ |$fluidVars|
+                           (COND
+                             ((MEMQ (CADR |l|) |$fluidVars|)
+                              |$fluidVars|)
+                             (#0# (CONS (CADR |l|) |$fluidVars|))))
+                     (RPLACA (CDR |x|) (CADR |l|)))))))
+             ((MEMQ U '(PROG LAMBDA))
+              (PROGN
+                (SETQ |newbindings| NIL)
+                (LET ((|bfVar#99| (CADR |x|)) (|y| NIL))
+                  (LOOP
+                    (COND
+                      ((OR (ATOM |bfVar#99|)
+                           (PROGN (SETQ |y| (CAR |bfVar#99|)) NIL))
+                       (RETURN NIL))
+                      (#1='T
+                       (COND
+                         ((NULL (MEMQ |y| |$locVars|))
+                          (IDENTITY
+                              (PROGN
+                                (SETQ |$locVars| (CONS |y| |$locVars|))
+                                (SETQ |newbindings|
+                                      (CONS |y| |newbindings|))))))))
+                    (SETQ |bfVar#99| (CDR |bfVar#99|))))
+                (SETQ |res| (|shoeCompTran1| (CDDR |x|)))
+                (SETQ |$locVars|
+                      (LET ((|bfVar#101| NIL) (|bfVar#100| |$locVars|)
+                            (|y| NIL))
+                        (LOOP
+                          (COND
+                            ((OR (ATOM |bfVar#100|)
+                                 (PROGN
+                                   (SETQ |y| (CAR |bfVar#100|))
+                                   NIL))
+                             (RETURN (NREVERSE |bfVar#101|)))
+                            (#1#
+                             (AND (NULL (MEMQ |y| |newbindings|))
+                                  (SETQ |bfVar#101|
+                                        (CONS |y| |bfVar#101|)))))
+                          (SETQ |bfVar#100| (CDR |bfVar#100|)))))))
+             (#0#
+              (PROGN
+                (|shoeCompTran1| (CAR |x|))
+                (|shoeCompTran1| (CDR |x|)))))))))))
+
+(DEFUN |bfTagged| (|a| |b|)
+  (PROG ()
+    (DECLARE (SPECIAL |$typings|))
+    (RETURN
+      (COND
+        ((IDENTP |a|)
+         (COND
+           ((EQ |b| 'FLUID) (|bfLET| (|compFluid| |a|) NIL))
+           ((EQ |b| '|fluid|) (|bfLET| (|compFluid| |a|) NIL))
+           ((EQ |b| '|local|) (|bfLET| (|compFluid| |a|) NIL))
+           (#0='T
+            (PROGN
+              (SETQ |$typings| (CONS (LIST 'TYPE |b| |a|) |$typings|))
+              |a|))))
+        (#0# (LIST 'THE |b| |a|))))))
+
+(DEFUN |bfAssign| (|l| |r|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((|bfTupleP| |l|) (|bfSetelt| (CADR |l|) (CDDR |l|) |r|))
+        ('T (|bfLET| |l| |r|))))))
+
+(DEFUN |bfSetelt| (|e| |l| |r|)
+  (PROG ()
+    (RETURN
+      (COND
+        ((NULL (CDR |l|)) (|defSETELT| |e| (CAR |l|) |r|))
+        ('T (|bfSetelt| (|bfElt| |e| (CAR |l|)) (CDR |l|) |r|))))))
+
+(DEFUN |bfElt| (|expr| |sel|)
+  (PROG (|y|)
+    (RETURN
+      (PROGN
+        (SETQ |y| (AND (SYMBOLP |sel|) (GET |sel| 'SHOESELFUNCTION)))
+        (COND
+          (|y| (COND
+                 ((INTEGERP |y|) (LIST 'ELT |expr| |y|))
+                 (#0='T (LIST |y| |expr|))))
+          (#0# (LIST 'ELT |expr| |sel|)))))))
+
+(DEFUN |defSETELT| (|var| |sel| |expr|)
+  (PROG (|y|)
+    (RETURN
+      (PROGN
+        (SETQ |y| (AND (SYMBOLP |sel|) (GET |sel| 'SHOESELFUNCTION)))
+        (COND
+          (|y| (COND
+                 ((INTEGERP |y|)
+                  (LIST 'SETF (LIST 'ELT |var| |y|) |expr|))
+                 (#0='T (LIST 'SETF (LIST |y| |var|) |expr|))))
+          (#0# (LIST 'SETF (LIST 'ELT |var| |sel|) |expr|)))))))
+
+(DEFUN |bfIfThenOnly| (|a| |b|)
+  (PROG (|b1|)
+    (RETURN
+      (PROGN
+        (SETQ |b1|
+              (COND ((EQCAR |b| 'PROGN) (CDR |b|)) ('T (LIST |b|))))
+        (LIST 'COND (CONS |a| |b1|))))))
+
+(DEFUN |bfIf| (|a| |b| |c|)
+  (PROG (|c1| |b1|)
+    (RETURN
+      (PROGN
+        (SETQ |b1|
+              (COND ((EQCAR |b| 'PROGN) (CDR |b|)) (#0='T (LIST |b|))))
+        (COND
+          ((EQCAR |c| 'COND)
+           (CONS 'COND (CONS (CONS |a| |b1|) (CDR |c|))))
+          ('T
+           (PROGN
+             (SETQ |c1|
+                   (COND
+                     ((EQCAR |c| 'PROGN) (CDR |c|))
+                     (#0# (LIST |c|))))
+             (LIST 'COND (CONS |a| |b1|) (CONS ''T |c1|)))))))))
+
+(DEFUN |bfExit| (|a| |b|)
+  (PROG () (RETURN (LIST 'COND (LIST |a| (LIST 'IDENTITY |b|))))))
+
+(DEFUN |bfMKPROGN| (|l|)
+  (PROG (|a|)
+    (RETURN
+      (PROGN
+        (SETQ |a|
+              (LET ((|bfVar#102| NIL) (|c| |l|))
+                (LOOP
+                  (COND
+                    ((ATOM |c|) (RETURN (NREVERSE |bfVar#102|)))
+                    ('T
+                     (SETQ |bfVar#102|
+                           (APPEND (REVERSE (|bfFlattenSeq| |c|))
+                                   |bfVar#102|))))
+                  (SETQ |c| (CDR |c|)))))
+        (COND
+          ((NULL |a|) NIL)
+          ((NULL (CDR |a|)) (CAR |a|))
+          ('T (CONS 'PROGN |a|)))))))
+
+(DEFUN |bfFlattenSeq| (|x|)
+  (PROG (|f|)
+    (RETURN
+      (COND
+        ((NULL |x|) NIL)
+        (#0='T
+         (PROGN
+           (SETQ |f| (CAR |x|))
+           (COND
+             ((ATOM |f|) (COND ((CDR |x|) NIL) ('T (LIST |f|))))
+             ((EQCAR |f| 'PROGN)
+              (COND
+                ((CDR |x|)
+                 (LET ((|bfVar#104| NIL) (|bfVar#103| (CDR |f|))
+                       (|i| NIL))
+                   (LOOP
+                     (COND
+                       ((OR (ATOM |bfVar#103|)
+                            (PROGN (SETQ |i| (CAR |bfVar#103|)) NIL))
+                        (RETURN (NREVERSE |bfVar#104|)))
+                       ('T
+                        (AND (NULL (ATOM |i|))
+                             (SETQ |bfVar#104| (CONS |i| |bfVar#104|)))))
+                     (SETQ |bfVar#103| (CDR |bfVar#103|)))))
+                (#0# (CDR |f|))))
+             (#0# (LIST |f|)))))))))
+
+(DEFUN |bfSequence| (|l|)
+  (PROG (|f| |aft| |before| |no| |transform| |b| |ISTMP#5| |ISTMP#4|
+             |ISTMP#3| |a| |ISTMP#2| |ISTMP#1|)
+    (RETURN
+      (COND
+        ((NULL |l|) NIL)
+        (#0='T
+         (PROGN
+           (SETQ |transform|
+                 (LET ((|bfVar#106| NIL) (|bfVar#105| |l|) (|x| NIL))
+                   (LOOP
+                     (COND
+                       ((OR (ATOM |bfVar#105|)
+                            (PROGN (SETQ |x| (CAR |bfVar#105|)) NIL)
+                            (NOT (AND (CONSP |x|) (EQ (CAR |x|) 'COND)
+                                      (PROGN
+                                        (SETQ |ISTMP#1| (CDR |x|))
+                                        (AND (CONSP |ISTMP#1|)
+                                         (EQ (CDR |ISTMP#1|) NIL)
+                                         (PROGN
+                                           (SETQ |ISTMP#2|
+                                            (CAR |ISTMP#1|))
+                                           (AND (CONSP |ISTMP#2|)
+                                            (PROGN
+                                              (SETQ |a|
+                                               (CAR |ISTMP#2|))
+                                              (SETQ |ISTMP#3|
+                                               (CDR |ISTMP#2|))
+                                              (AND (CONSP |ISTMP#3|)
+                                               (EQ (CDR |ISTMP#3|) NIL)
+                                               (PROGN
+                                                 (SETQ |ISTMP#4|
+                                                  (CAR |ISTMP#3|))
+                                                 (AND (CONSP |ISTMP#4|)
+                                                  (EQ (CAR |ISTMP#4|)
+                                                   'IDENTITY)
+                                                  (PROGN
+                                                    (SETQ |ISTMP#5|
+                                                     (CDR |ISTMP#4|))
+                                                    (AND
+                                                     (CONSP |ISTMP#5|)
+                                                     (EQ
+                                                      (CDR |ISTMP#5|)
+                                                      NIL)
+                                                     (PROGN
+                                                       (SETQ |b|
+                                                        (CAR |ISTMP#5|))
+                                                       'T))))))))))))))
+                        (RETURN (NREVERSE |bfVar#106|)))
+                       ('T
+                        (SETQ |bfVar#106|
+                              (CONS (LIST |a| |b|) |bfVar#106|))))
+                     (SETQ |bfVar#105| (CDR |bfVar#105|)))))
+           (SETQ |no| (LENGTH |transform|))
+           (SETQ |before| (|bfTake| |no| |l|))
+           (SETQ |aft| (|bfDrop| |no| |l|))
+           (COND
+             ((NULL |before|)
+              (COND
+                ((NULL (CDR |l|))
+                 (PROGN
+                   (SETQ |f| (CAR |l|))
+                   (COND
+                     ((EQCAR |f| 'PROGN) (|bfSequence| (CDR |f|)))
+                     ('T |f|))))
+                (#0#
+                 (|bfMKPROGN|
+                     (LIST (CAR |l|) (|bfSequence| (CDR |l|)))))))
+             ((NULL |aft|) (CONS 'COND |transform|))
+             (#0#
+              (CONS 'COND
+                    (APPEND |transform|
+                            (CONS (LIST ''T (|bfSequence| |aft|)) NIL)))))))))))
+
+(DEFUN |bfWhere| (|context| |expr|)
+  (PROG (|a| |body| |ISTMP#3| |args| |ISTMP#2| |op| |ISTMP#1| |def|
+             |nondefs| |defs| |opassoc| |LETTMP#1|)
+    (DECLARE (SPECIAL |$wheredefs|))
+    (RETURN
+      (PROGN
+        (SETQ |LETTMP#1| (|defSheepAndGoats| |context|))
+        (SETQ |opassoc| (CAR |LETTMP#1|))
+        (SETQ |defs| (CADR . #0=(|LETTMP#1|)))
+        (SETQ |nondefs| (CADDR . #0#))
+        (SETQ |a|
+              (LET ((|bfVar#108| NIL) (|bfVar#107| |defs|) (|d| NIL))
+                (LOOP
+                  (COND
+                    ((OR (ATOM |bfVar#107|)
+                         (PROGN (SETQ |d| (CAR |bfVar#107|)) NIL))
+                     (RETURN (NREVERSE |bfVar#108|)))
+                    ('T
+                     (AND (CONSP |d|)
+                          (PROGN
+                            (SETQ |def| (CAR |d|))
+                            (SETQ |ISTMP#1| (CDR |d|))
+                            (AND (CONSP |ISTMP#1|)
+                                 (PROGN
+                                   (SETQ |op| (CAR |ISTMP#1|))
+                                   (SETQ |ISTMP#2| (CDR |ISTMP#1|))
+                                   (AND (CONSP |ISTMP#2|)
+                                    (PROGN
+                                      (SETQ |args| (CAR |ISTMP#2|))
+                                      (SETQ |ISTMP#3| (CDR |ISTMP#2|))
+                                      (AND (CONSP |ISTMP#3|)
+                                       (EQ (CDR |ISTMP#3|) NIL)
+                                       (PROGN
+                                         (SETQ |body| (CAR |ISTMP#3|))
+                                         'T)))))))
+                          (SETQ |bfVar#108|
+                                (CONS (LIST |def| |op| |args|
+                                       (|bfSUBLIS| |opassoc| |body|))
+                                      |bfVar#108|)))))
+                  (SETQ |bfVar#107| (CDR |bfVar#107|)))))
+        (SETQ |$wheredefs| (APPEND |a| |$wheredefs|))
+        (|bfMKPROGN|
+            (|bfSUBLIS| |opassoc| (NCONC |nondefs| (LIST |expr|))))))))
+
+(DEFUN |bfReadLisp| (|string|)
+  (PROG () (RETURN (|bfTuple| (|shoeReadLispString| |string| 0)))))
+
+(DEFUN |bfCompHash| (|op| |argl| |body|)
+  (PROG (|computeFunction| |auxfn|)
+    (RETURN
+      (PROGN
+        (SETQ |auxfn| (INTERN (CONCAT (PNAME |op|) ";")))
+        (SETQ |computeFunction|
+              (CONS 'DEFUN (CONS |auxfn| (CONS |argl| |body|))))
+        (|bfTuple| (CONS |computeFunction| (|bfMain| |auxfn| |op|)))))))
+
+(DEFUN |shoeCompileTimeEvaluation| (|x|)
+  (PROG () (RETURN (LIST 'EVAL-WHEN (LIST :COMPILE-TOPLEVEL) |x|))))
+
+(DEFUN |shoeEVALANDFILEACTQ| (|x|)
+  (PROG ()
+    (RETURN (LIST 'EVAL-WHEN (LIST :EXECUTE :LOAD-TOPLEVEL) |x|))))
+
+(DEFUN |bfMain| (|auxfn| |op|)
+  (PROG (|cacheVector| |cacheCountCode| |cacheResetCode| |cacheType|
+            |mainFunction| |codeBody| |thirdPredPair| |putCode|
+            |secondPredPair| |getCode| |g2| |cacheName| |computeValue|
+            |arg| |g1|)
+    (RETURN
+      (PROGN
+        (SETQ |g1| (|bfGenSymbol|))
+        (SETQ |arg| (LIST '&REST |g1|))
+        (SETQ |computeValue|
+              (LIST 'APPLY (LIST 'FUNCTION |auxfn|) |g1|))
+        (SETQ |cacheName| (INTERN (CONCAT (PNAME |op|) ";AL")))
+        (SETQ |g2| (|bfGenSymbol|))
+        (SETQ |getCode| (LIST 'GETHASH |g1| |cacheName|))
+        (SETQ |secondPredPair| (LIST (LIST 'SETQ |g2| |getCode|) |g2|))
+        (SETQ |putCode| (LIST 'SETF |getCode| |computeValue|))
+        (SETQ |thirdPredPair| (LIST ''T |putCode|))
+        (SETQ |codeBody|
+              (LIST 'PROG (LIST |g2|)
+                    (LIST 'RETURN
+                          (LIST 'COND |secondPredPair| |thirdPredPair|))))
+        (SETQ |mainFunction| (LIST 'DEFUN |op| |arg| |codeBody|))
+        (SETQ |cacheType| '|hash-table|)
+        (SETQ |cacheResetCode|
+              (LIST 'SETQ |cacheName|
+                    (LIST 'MAKE-HASHTABLE (LIST 'QUOTE 'UEQUAL))))
+        (SETQ |cacheCountCode| (LIST '|hashCount| |cacheName|))
+        (SETQ |cacheVector|
+              (LIST |op| |cacheName| |cacheType| |cacheResetCode|
+                    |cacheCountCode|))
+        (LIST |mainFunction|
+              (|shoeEVALANDFILEACTQ|
+                  (LIST 'SETF
+                        (LIST 'GET (LIST 'QUOTE |op|)
+                              (LIST 'QUOTE '|cacheInfo|))
+                        (LIST 'QUOTE |cacheVector|)))
+              (|shoeEVALANDFILEACTQ| |cacheResetCode|))))))
+
+(DEFUN |bfNameOnly| (|x|)
+  (PROG () (RETURN (COND ((EQ |x| '|t|) (LIST 'T)) ('T (LIST |x|))))))
+
+(DEFUN |bfNameArgs| (|x| |y|)
+  (PROG ()
+    (RETURN
+      (PROGN
+        (SETQ |y|
+              (COND ((EQCAR |y| 'TUPLE) (CDR |y|)) ('T (LIST |y|))))
+        (CONS |x| |y|)))))
+
+(DEFUN |bfStruct| (|name| |arglist|)
+  (PROG ()
+    (RETURN
+      (|bfTuple|
+          (LET ((|bfVar#110| NIL) (|bfVar#109| |arglist|) (|i| NIL))
+            (LOOP
+              (COND
+                ((OR (ATOM |bfVar#109|)
+                     (PROGN (SETQ |i| (CAR |bfVar#109|)) NIL))
+                 (RETURN (NREVERSE |bfVar#110|)))
+                ('T
+                 (SETQ |bfVar#110|
+                       (CONS (|bfCreateDef| |i|) |bfVar#110|))))
+              (SETQ |bfVar#109| (CDR |bfVar#109|))))))))
+
+(DEFUN |bfCreateDef| (|x|)
+  (PROG (|a| |f|)
+    (RETURN
+      (COND
+        ((NULL (CDR |x|)) (SETQ |f| (CAR |x|))
+         (LIST 'SETQ |f| (LIST 'LIST (LIST 'QUOTE |f|))))
+        ('T
+         (SETQ |a|
+               (LET ((|bfVar#112| NIL) (|bfVar#111| (CDR |x|))
+                     (|i| NIL))
+                 (LOOP
+                   (COND
+                     ((OR (ATOM |bfVar#111|)
+                          (PROGN (SETQ |i| (CAR |bfVar#111|)) NIL))
+                      (RETURN (NREVERSE |bfVar#112|)))
+                     ('T
+                      (SETQ |bfVar#112|
+                            (CONS (|bfGenSymbol|) |bfVar#112|))))
+                   (SETQ |bfVar#111| (CDR |bfVar#111|)))))
+         (LIST 'DEFUN (CAR |x|) |a|
+               (LIST 'CONS (LIST 'QUOTE (CAR |x|)) (CONS 'LIST |a|))))))))
+
+(DEFUN |bfCaseItem| (|x| |y|) (PROG () (RETURN (LIST |x| |y|))))
+
+(DEFUN |bfCase| (|x| |y|)
+  (PROG (|c| |b| |a| |g1| |g|)
+    (RETURN
+      (PROGN
+        (SETQ |g| (|bfGenSymbol|))
+        (SETQ |g1| (|bfGenSymbol|))
+        (SETQ |a| (|bfLET| |g| |x|))
+        (SETQ |b| (|bfLET| |g1| (LIST 'CDR |g|)))
+        (SETQ |c| (|bfCaseItems| |g1| |y|))
+        (|bfMKPROGN|
+            (LIST |a| |b| (CONS 'CASE (CONS (LIST 'CAR |g|) |c|))))))))
+
+(DEFUN |bfCaseItems| (|g| |x|)
+  (PROG (|j| |ISTMP#1| |i|)
+    (RETURN
+      (LET ((|bfVar#115| NIL) (|bfVar#114| |x|) (|bfVar#113| NIL))
+        (LOOP
+          (COND
+            ((OR (ATOM |bfVar#114|)
+                 (PROGN (SETQ |bfVar#113| (CAR |bfVar#114|)) NIL))
+             (RETURN (NREVERSE |bfVar#115|)))
+            ('T
+             (AND (CONSP |bfVar#113|)
+                  (PROGN
+                    (SETQ |i| (CAR |bfVar#113|))
+                    (SETQ |ISTMP#1| (CDR |bfVar#113|))
+                    (AND (CONSP |ISTMP#1|) (EQ (CDR |ISTMP#1|) NIL)
+                         (PROGN (SETQ |j| (CAR |ISTMP#1|)) 'T)))
+                  (SETQ |bfVar#115|
+                        (CONS (|bfCI| |g| |i| |j|) |bfVar#115|)))))
+          (SETQ |bfVar#114| (CDR |bfVar#114|)))))))
+
+(DEFUN |bfCI| (|g| |x| |y|)
+  (PROG (|b| |a|)
+    (RETURN
+      (PROGN
+        (SETQ |a| (CDR |x|))
+        (COND
+          ((NULL |a|) (LIST (CAR |x|) |y|))
+          ('T
+           (SETQ |b|
+                 (LET ((|bfVar#117| NIL) (|bfVar#116| |a|) (|i| NIL)
+                       (|j| 0))
+                   (LOOP
+                     (COND
+                       ((OR (ATOM |bfVar#116|)
+                            (PROGN (SETQ |i| (CAR |bfVar#116|)) NIL))
+                        (RETURN (NREVERSE |bfVar#117|)))
+                       ('T
+                        (SETQ |bfVar#117|
+                              (CONS (LIST |i| (|bfCARCDR| |j| |g|))
+                                    |bfVar#117|))))
+                     (SETQ |bfVar#116| (CDR |bfVar#116|))
+                     (SETQ |j| (+ |j| 1)))))
+           (LIST (CAR |x|) (LIST 'LET |b| |y|))))))))
+
+(DEFUN |bfCARCDR| (|n| |g|)
+  (PROG ()
+    (RETURN (LIST (INTERN (CONCAT "CA" (|bfDs| |n|) "R")) |g|))))
+
+(DEFUN |bfDs| (|n|)
+  (PROG ()
+    (RETURN
+      (COND ((EQL |n| 0) "") ('T (CONCAT "D" (|bfDs| (- |n| 1))))))))
+
-- 
cgit v1.2.3