* interp/cattable.boot: Use %true for truth value in VM expressions.

	* interp/clam.boot: Likewise.
	* interp/define.boot: Likewise.
	* interp/format.boot: Likewise.
	* interp/functor.boot: Likewise.
	* interp/g-opt.boot: Likewise.
	* interp/mark.boot: Likewise.
	* interp/pspad1.boot: Likewise.
	* interp/pspad2.boot: Likewise.
	* interp/slam.boot: Likewise.
	* interp/wi1.boot: Likewise.
	* interp/wi2.boot: Likewise.
	* interp/sys-constants.boot: Remove $true and $false as unused.

1 files changed, 348 insertions, 364 deletions

diff --git a/src/algebra/strap/POLYCAT-.lsp b/src/algebra/strap/POLYCAT-.lsp
index 439ed083..13c315ef 100644
--- a/src/algebra/strap/POLYCAT-.lsp
+++ b/src/algebra/strap/POLYCAT-.lsp
@@ -146,52 +146,53 @@
     (RETURN
       (SEQ (COND
              ((NULL |l|) |p|)
-             ('T
-              (SEQ (LET ((#0=#:G1691 |l|))
-                     (LOOP
-                       (COND
-                         ((ATOM #0#) (RETURN NIL))
-                         (T (LET ((|e| (CAR #0#)))
-                              (COND
-                                ((EQL (CAR
-                                       (SPADCALL
-                                        (SPADCALL |e|
-                                         (|getShellEntry| $ 14))
-                                        (|getShellEntry| $ 16)))
-                                      1)
-                                 (RETURN
-                                   (|error|
-                                    "cannot find a variable to evaluate")))))))
-                       (SETQ #0# (CDR #0#))))
-                   (LETT |lvar|
-                         (LET ((#1=#:G1693 |l|) (#2=#:G1692 NIL))
-                           (LOOP
-                             (COND
-                               ((ATOM #1#) (RETURN (NREVERSE #2#)))
-                               (T (LET ((|e| (CAR #1#)))
-                                    (SETQ #2#
-                                     (CONS
-                                      (SPADCALL
-                                       (SPADCALL |e|
-                                        (|getShellEntry| $ 14))
-                                       (|getShellEntry| $ 17))
-                                      #2#)))))
-                             (SETQ #1# (CDR #1#))))
-                         |POLYCAT-;eval;SLS;1|)
-                   (EXIT (SPADCALL |p| |lvar|
-                             (LET ((#3=#:G1695 |l|) (#4=#:G1694 NIL))
-                               (LOOP
-                                 (COND
-                                   ((ATOM #3#) (RETURN (NREVERSE #4#)))
-                                   (T
-                                    (LET ((|e| (CAR #3#)))
-                                      (SETQ #4#
+             (T (SEQ (LET ((#0=#:G1691 |l|))
+                       (LOOP
+                         (COND
+                           ((ATOM #0#) (RETURN NIL))
+                           (T (LET ((|e| (CAR #0#)))
+                                (COND
+                                  ((EQL
+                                    (CAR
+                                     (SPADCALL
+                                      (SPADCALL |e|
+                                       (|getShellEntry| $ 14))
+                                      (|getShellEntry| $ 16)))
+                                    1)
+                                   (RETURN
+                                     (|error|
+                                      "cannot find a variable to evaluate")))))))
+                         (SETQ #0# (CDR #0#))))
+                     (LETT |lvar|
+                           (LET ((#1=#:G1693 |l|) (#2=#:G1692 NIL))
+                             (LOOP
+                               (COND
+                                 ((ATOM #1#) (RETURN (NREVERSE #2#)))
+                                 (T (LET ((|e| (CAR #1#)))
+                                      (SETQ #2#
                                        (CONS
-                                        (SPADCALL |e|
-                                         (|getShellEntry| $ 18))
-                                        #4#)))))
-                                 (SETQ #3# (CDR #3#))))
-                             (|getShellEntry| $ 21)))))))))) 
+                                        (SPADCALL
+                                         (SPADCALL |e|
+                                          (|getShellEntry| $ 14))
+                                         (|getShellEntry| $ 17))
+                                        #2#)))))
+                               (SETQ #1# (CDR #1#))))
+                           |POLYCAT-;eval;SLS;1|)
+                     (EXIT (SPADCALL |p| |lvar|
+                               (LET ((#3=#:G1695 |l|) (#4=#:G1694 NIL))
+                                 (LOOP
+                                   (COND
+                                     ((ATOM #3#)
+                                      (RETURN (NREVERSE #4#)))
+                                     (T
+                                      (LET ((|e| (CAR #3#)))
+                                        (SETQ #4#
+                                         (CONS
+                                          (SPADCALL |e|
+                                           (|getShellEntry| $ 18))
+                                          #4#)))))
+                                   (SETQ #3# (CDR #3#))))
+                               (|getShellEntry| $ 21)))))))))) 
 
 (DEFUN |POLYCAT-;monomials;SL;2| (|p| $)
   (LET ((|ml| NIL))
@@ -214,7 +215,7 @@
         ((NULL (CDR (LETT |l| (SPADCALL |p| (|getShellEntry| $ 35))
                           |POLYCAT-;isPlus;SU;3|)))
          (CONS 1 "failed"))
-        ('T (CONS 0 |l|)))))) 
+        (T (CONS 0 |l|)))))) 
 
 (DEFUN |POLYCAT-;isTimes;SU;4| (|p| $)
   (PROG (|lv| |l| |r|)
@@ -225,38 +226,37 @@
                               |POLYCAT-;isTimes;SU;4|))
                   (NOT (SPADCALL |p| (|getShellEntry| $ 42))))
               (CONS 1 "failed"))
-             ('T
-              (SEQ (LETT |l|
-                         (LET ((#0=#:G1697 |lv|) (#1=#:G1696 NIL))
-                           (LOOP
-                             (COND
-                               ((ATOM #0#) (RETURN (NREVERSE #1#)))
-                               (T (LET ((|v| (CAR #0#)))
-                                    (SETQ #1#
-                                     (CONS
-                                      (SPADCALL (|spadConstant| $ 43)
-                                       |v|
-                                       (SPADCALL |p| |v|
-                                        (|getShellEntry| $ 46))
-                                       (|getShellEntry| $ 47))
-                                      #1#)))))
-                             (SETQ #0# (CDR #0#))))
-                         |POLYCAT-;isTimes;SU;4|)
-                   (EXIT (COND
-                           ((SPADCALL
-                                (LETT |r|
-                                      (SPADCALL |p|
-                                       (|getShellEntry| $ 48))
-                                      |POLYCAT-;isTimes;SU;4|)
-                                (|getShellEntry| $ 49))
-                            (COND
-                              ((NULL (CDR |lv|)) (CONS 1 "failed"))
-                              ('T (CONS 0 |l|))))
-                           ('T
-                            (CONS 0
-                                  (CONS (SPADCALL |r|
-                                         (|getShellEntry| $ 51))
-                                        |l|)))))))))))) 
+             (T (SEQ (LETT |l|
+                           (LET ((#0=#:G1697 |lv|) (#1=#:G1696 NIL))
+                             (LOOP
+                               (COND
+                                 ((ATOM #0#) (RETURN (NREVERSE #1#)))
+                                 (T (LET ((|v| (CAR #0#)))
+                                      (SETQ #1#
+                                       (CONS
+                                        (SPADCALL (|spadConstant| $ 43)
+                                         |v|
+                                         (SPADCALL |p| |v|
+                                          (|getShellEntry| $ 46))
+                                         (|getShellEntry| $ 47))
+                                        #1#)))))
+                               (SETQ #0# (CDR #0#))))
+                           |POLYCAT-;isTimes;SU;4|)
+                     (EXIT (COND
+                             ((SPADCALL
+                                  (LETT |r|
+                                        (SPADCALL |p|
+                                         (|getShellEntry| $ 48))
+                                        |POLYCAT-;isTimes;SU;4|)
+                                  (|getShellEntry| $ 49))
+                              (COND
+                                ((NULL (CDR |lv|)) (CONS 1 "failed"))
+                                (T (CONS 0 |l|))))
+                             (T (CONS 0
+                                      (CONS
+                                       (SPADCALL |r|
+                                        (|getShellEntry| $ 51))
+                                       |l|)))))))))))) 
 
 (DEFUN |POLYCAT-;isExpt;SU;5| (|p| $)
   (PROG (|d|)
@@ -273,7 +273,7 @@
                             (|getShellEntry| $ 47))
                         (|getShellEntry| $ 54))))
            (CONS 1 "failed"))
-          ('T (CONS 0 (CONS (CDR |u|) |d|)))))))) 
+          (T (CONS 0 (CONS (CDR |u|) |d|)))))))) 
 
 (DEFUN |POLYCAT-;coefficient;SVarSetNniS;6| (|p| |v| |n| $)
   (SPADCALL (SPADCALL |p| |v| (|getShellEntry| $ 59)) |n|
@@ -284,27 +284,25 @@
     ((NULL |lv|)
      (COND
        ((NULL |ln|) |p|)
-       ('T (|error| "mismatched lists in coefficient"))))
+       (T (|error| "mismatched lists in coefficient"))))
     ((NULL |ln|) (|error| "mismatched lists in coefficient"))
-    ('T
-     (SPADCALL
-         (SPADCALL
-             (SPADCALL |p| (|SPADfirst| |lv|) (|getShellEntry| $ 59))
-             (|SPADfirst| |ln|) (|getShellEntry| $ 61))
-         (CDR |lv|) (CDR |ln|) (|getShellEntry| $ 68))))) 
+    (T (SPADCALL
+           (SPADCALL
+               (SPADCALL |p| (|SPADfirst| |lv|) (|getShellEntry| $ 59))
+               (|SPADfirst| |ln|) (|getShellEntry| $ 61))
+           (CDR |lv|) (CDR |ln|) (|getShellEntry| $ 68))))) 
 
 (DEFUN |POLYCAT-;monomial;SLLS;8| (|p| |lv| |ln| $)
   (COND
     ((NULL |lv|)
      (COND
        ((NULL |ln|) |p|)
-       ('T (|error| "mismatched lists in monomial"))))
+       (T (|error| "mismatched lists in monomial"))))
     ((NULL |ln|) (|error| "mismatched lists in monomial"))
-    ('T
-     (SPADCALL
-         (SPADCALL |p| (|SPADfirst| |lv|) (|SPADfirst| |ln|)
-             (|getShellEntry| $ 47))
-         (CDR |lv|) (CDR |ln|) (|getShellEntry| $ 70))))) 
+    (T (SPADCALL
+           (SPADCALL |p| (|SPADfirst| |lv|) (|SPADfirst| |ln|)
+               (|getShellEntry| $ 47))
+           (CDR |lv|) (CDR |ln|) (|getShellEntry| $ 70))))) 
 
 (DEFUN |POLYCAT-;retract;SVarSet;9| (|p| $)
   (LET ((|q| (LET ((#0=#:G1478 (SPADCALL |p| (|getShellEntry| $ 53))))
@@ -315,7 +313,7 @@
       ((SPADCALL (SPADCALL |q| (|getShellEntry| $ 72)) |p|
            (|getShellEntry| $ 54))
        |q|)
-      ('T (|error| "Polynomial is not a single variable"))))) 
+      (T (|error| "Polynomial is not a single variable"))))) 
 
 (DEFUN |POLYCAT-;retractIfCan;SU;10| (|p| $)
   (PROG (|q| #0=#:G1486)
@@ -356,80 +354,78 @@
     (RETURN
       (SEQ (COND
              ((SPADCALL |p| (|getShellEntry| $ 78)) 0)
-             ('T
-              (SEQ (LETT |u|
-                         (SPADCALL |p|
-                             (LET ((#0=#:G1492
-                                    (SPADCALL |p|
-                                     (|getShellEntry| $ 53))))
-                               (|check-union| (ZEROP (CAR #0#))
-                                   (|getShellEntry| $ 9) #0#)
-                               (CDR #0#))
-                             (|getShellEntry| $ 59))
-                         |POLYCAT-;totalDegree;SNni;13|)
-                   (LETT |d| 0 |POLYCAT-;totalDegree;SNni;13|)
-                   (LOOP
-                     (COND
-                       ((NOT (SPADCALL |u| (|spadConstant| $ 80)
-                                 (|getShellEntry| $ 81)))
-                        (RETURN NIL))
-                       (T (SEQ (SETQ |d|
-                                     (MAX |d|
-                                      (+
-                                       (SPADCALL |u|
-                                        (|getShellEntry| $ 82))
-                                       (SPADCALL
+             (T (SEQ (LETT |u|
+                           (SPADCALL |p|
+                               (LET ((#0=#:G1492
+                                      (SPADCALL |p|
+                                       (|getShellEntry| $ 53))))
+                                 (|check-union| (ZEROP (CAR #0#))
+                                     (|getShellEntry| $ 9) #0#)
+                                 (CDR #0#))
+                               (|getShellEntry| $ 59))
+                           |POLYCAT-;totalDegree;SNni;13|)
+                     (LETT |d| 0 |POLYCAT-;totalDegree;SNni;13|)
+                     (LOOP
+                       (COND
+                         ((NOT (SPADCALL |u| (|spadConstant| $ 80)
+                                   (|getShellEntry| $ 81)))
+                          (RETURN NIL))
+                         (T (SEQ (SETQ |d|
+                                       (MAX |d|
+                                        (+
+                                         (SPADCALL |u|
+                                          (|getShellEntry| $ 82))
+                                         (SPADCALL
+                                          (SPADCALL |u|
+                                           (|getShellEntry| $ 83))
+                                          (|getShellEntry| $ 84)))))
+                                 (EXIT (SETQ |u|
                                         (SPADCALL |u|
-                                         (|getShellEntry| $ 83))
-                                        (|getShellEntry| $ 84)))))
-                               (EXIT (SETQ |u|
-                                      (SPADCALL |u|
-                                       (|getShellEntry| $ 87))))))))
-                   (EXIT |d|)))))))) 
+                                         (|getShellEntry| $ 87))))))))
+                     (EXIT |d|)))))))) 
 
 (DEFUN |POLYCAT-;totalDegree;SLNni;14| (|p| |lv| $)
   (PROG (|v| |u| |d| |w|)
     (RETURN
       (SEQ (COND
              ((SPADCALL |p| (|getShellEntry| $ 78)) 0)
-             ('T
-              (SEQ (LETT |u|
-                         (SPADCALL |p|
-                             (LETT |v|
-                                   (LET
-                                    ((#0=#:G1500
-                                      (SPADCALL |p|
-                                       (|getShellEntry| $ 53))))
-                                     (|check-union| (ZEROP (CAR #0#))
-                                      (|getShellEntry| $ 9) #0#)
-                                     (CDR #0#))
-                                   |POLYCAT-;totalDegree;SLNni;14|)
-                             (|getShellEntry| $ 59))
-                         |POLYCAT-;totalDegree;SLNni;14|)
-                   (LETT |d| 0 |POLYCAT-;totalDegree;SLNni;14|)
-                   (LETT |w| 0 |POLYCAT-;totalDegree;SLNni;14|)
-                   (COND
-                     ((SPADCALL |v| |lv| (|getShellEntry| $ 89))
-                      (SETQ |w| 1)))
-                   (LOOP
+             (T (SEQ (LETT |u|
+                           (SPADCALL |p|
+                               (LETT |v|
+                                     (LET
+                                      ((#0=#:G1500
+                                        (SPADCALL |p|
+                                         (|getShellEntry| $ 53))))
+                                       (|check-union| (ZEROP (CAR #0#))
+                                        (|getShellEntry| $ 9) #0#)
+                                       (CDR #0#))
+                                     |POLYCAT-;totalDegree;SLNni;14|)
+                               (|getShellEntry| $ 59))
+                           |POLYCAT-;totalDegree;SLNni;14|)
+                     (LETT |d| 0 |POLYCAT-;totalDegree;SLNni;14|)
+                     (LETT |w| 0 |POLYCAT-;totalDegree;SLNni;14|)
                      (COND
-                       ((NOT (SPADCALL |u| (|spadConstant| $ 80)
-                                 (|getShellEntry| $ 81)))
-                        (RETURN NIL))
-                       (T (SEQ (SETQ |d|
-                                     (MAX |d|
-                                      (+
-                                       (* |w|
-                                        (SPADCALL |u|
-                                         (|getShellEntry| $ 82)))
-                                       (SPADCALL
+                       ((SPADCALL |v| |lv| (|getShellEntry| $ 89))
+                        (SETQ |w| 1)))
+                     (LOOP
+                       (COND
+                         ((NOT (SPADCALL |u| (|spadConstant| $ 80)
+                                   (|getShellEntry| $ 81)))
+                          (RETURN NIL))
+                         (T (SEQ (SETQ |d|
+                                       (MAX |d|
+                                        (+
+                                         (* |w|
+                                          (SPADCALL |u|
+                                           (|getShellEntry| $ 82)))
+                                         (SPADCALL
+                                          (SPADCALL |u|
+                                           (|getShellEntry| $ 83))
+                                          |lv| (|getShellEntry| $ 92)))))
+                                 (EXIT (SETQ |u|
                                         (SPADCALL |u|
-                                         (|getShellEntry| $ 83))
-                                        |lv| (|getShellEntry| $ 92)))))
-                               (EXIT (SETQ |u|
-                                      (SPADCALL |u|
-                                       (|getShellEntry| $ 87))))))))
-                   (EXIT |d|)))))))) 
+                                         (|getShellEntry| $ 87))))))))
+                     (EXIT |d|)))))))) 
 
 (DEFUN |POLYCAT-;resultant;2SVarSetS;15| (|p1| |p2| |mvar| $)
   (SPADCALL (SPADCALL |p1| |mvar| (|getShellEntry| $ 59))
@@ -626,35 +622,35 @@
                                        #1#)))))
                               (SETQ #0# (CDR #0#))))
                           (|getShellEntry| $ 159)))))
-          ('T
-           (SEQ (LETT |up|
-                      (SPADCALL |p| (CDR |v|) (|getShellEntry| $ 59))
-                      |POLYCAT-;factor;SF;26|)
-                (LETT |ansSUP| (SPADCALL |up| (|getShellEntry| $ 143))
-                      |POLYCAT-;factor;SF;26|)
-                (EXIT (SPADCALL
-                          (SPADCALL
-                              (SPADCALL |ansSUP|
-                                  (|getShellEntry| $ 160))
-                              (CDR |v|) (|getShellEntry| $ 161))
-                          (LET ((#2=#:G1719
-                                    (SPADCALL |ansSUP|
-                                     (|getShellEntry| $ 164)))
-                                (#3=#:G1718 NIL))
-                            (LOOP
-                              (COND
-                                ((ATOM #2#) (RETURN (NREVERSE #3#)))
-                                (T (LET ((|ww| (CAR #2#)))
-                                     (SETQ #3#
-                                      (CONS
-                                       (VECTOR (QVELT |ww| 0)
-                                        (SPADCALL (QVELT |ww| 1)
-                                         (CDR |v|)
-                                         (|getShellEntry| $ 161))
-                                        (QVELT |ww| 2))
-                                       #3#)))))
-                              (SETQ #2# (CDR #2#))))
-                          (|getShellEntry| $ 159)))))))))) 
+          (T (SEQ (LETT |up|
+                        (SPADCALL |p| (CDR |v|) (|getShellEntry| $ 59))
+                        |POLYCAT-;factor;SF;26|)
+                  (LETT |ansSUP|
+                        (SPADCALL |up| (|getShellEntry| $ 143))
+                        |POLYCAT-;factor;SF;26|)
+                  (EXIT (SPADCALL
+                            (SPADCALL
+                                (SPADCALL |ansSUP|
+                                    (|getShellEntry| $ 160))
+                                (CDR |v|) (|getShellEntry| $ 161))
+                            (LET ((#2=#:G1719
+                                      (SPADCALL |ansSUP|
+                                       (|getShellEntry| $ 164)))
+                                  (#3=#:G1718 NIL))
+                              (LOOP
+                                (COND
+                                  ((ATOM #2#) (RETURN (NREVERSE #3#)))
+                                  (T (LET ((|ww| (CAR #2#)))
+                                       (SETQ #3#
+                                        (CONS
+                                         (VECTOR (QVELT |ww| 0)
+                                          (SPADCALL (QVELT |ww| 1)
+                                           (CDR |v|)
+                                           (|getShellEntry| $ 161))
+                                          (QVELT |ww| 2))
+                                         #3#)))))
+                                (SETQ #2# (CDR #2#))))
+                            (|getShellEntry| $ 159)))))))))) 
 
 (DEFUN |POLYCAT-;conditionP;MU;27| (|mat| $)
   (PROG (|nd| |vars| |degs| |deg1| |mons| |redmons| |ans| |i|)
@@ -747,7 +743,7 @@
                                                          |POLYCAT-;conditionP;MU;27|
                                                           (CONS 1
                                                            "failed")))
-                                                       ('T
+                                                       (T
                                                         (LET
                                                          ((#10=#:G1612
                                                            (CDR |nd|)))
@@ -810,86 +806,78 @@
                    |POLYCAT-;conditionP;MU;27|)
              (EXIT (COND
                      ((EQL (CAR |ans|) 1) (CONS 1 "failed"))
-                     ('T
-                      (SEQ (LETT |i| 0 |POLYCAT-;conditionP;MU;27|)
-                           (EXIT (CONS 0
-                                       (LET
-                                        ((#14=#:G1611
-                                          (|makeSimpleArray|
-                                           (|getVMType|
-                                            (|getShellEntry| $ 6))
-                                           (SIZE |monslist|))))
-                                         (LET
-                                          ((#15=#:G1728 |monslist|)
-                                           (#16=#:G1610 0))
-                                           (LOOP
-                                             (COND
-                                               ((ATOM #15#)
-                                                (RETURN #14#))
-                                               (T
+                     (T (SEQ (LETT |i| 0 |POLYCAT-;conditionP;MU;27|)
+                             (EXIT (CONS 0
+                                    (LET
+                                     ((#14=#:G1611
+                                       (|makeSimpleArray|
+                                        (|getVMType|
+                                         (|getShellEntry| $ 6))
+                                        (SIZE |monslist|))))
+                                      (LET
+                                       ((#15=#:G1728 |monslist|)
+                                        (#16=#:G1610 0))
+                                        (LOOP
+                                          (COND
+                                            ((ATOM #15#) (RETURN #14#))
+                                            (T
+                                             (LET ((|mons| (CAR #15#)))
+                                               (|setSimpleArrayEntry|
+                                                #14# #16#
                                                 (LET
-                                                 ((|mons| (CAR #15#)))
-                                                  (|setSimpleArrayEntry|
-                                                   #14# #16#
-                                                   (LET
-                                                    ((#17=#:G1604 NIL)
-                                                     (#18=#:G1605 T)
-                                                     (#19=#:G1729
-                                                      |mons|))
-                                                     (LOOP
-                                                       (COND
-                                                         ((ATOM #19#)
-                                                          (RETURN
-                                                            (COND
-                                                              (#18#
-                                                               (|spadConstant|
-                                                                $ 27))
-                                                              (T #17#))))
-                                                         (T
-                                                          (LET
-                                                           ((|m|
-                                                             (CAR #19#)))
-                                                            (LET
-                                                             ((#20=#:G1603
+                                                 ((#17=#:G1604 NIL)
+                                                  (#18=#:G1605 T)
+                                                  (#19=#:G1729 |mons|))
+                                                  (LOOP
+                                                    (COND
+                                                      ((ATOM #19#)
+                                                       (RETURN
+                                                         (COND
+                                                           (#18#
+                                                            (|spadConstant|
+                                                             $ 27))
+                                                           (T #17#))))
+                                                      (T
+                                                       (LET
+                                                        ((|m|
+                                                          (CAR #19#)))
+                                                         (LET
+                                                          ((#20=#:G1603
+                                                            (SPADCALL
+                                                             |m|
+                                                             (SPADCALL
+                                                              (SPADCALL
+                                                               (CDR
+                                                                |ans|)
+                                                               (SETQ
+                                                                |i|
+                                                                (+ |i|
+                                                                 1))
+                                                               (|getShellEntry|
+                                                                $ 181))
+                                                              (|getShellEntry|
+                                                               $ 51))
+                                                             (|getShellEntry|
+                                                              $ 182))))
+                                                           (COND
+                                                             (#18#
+                                                              (SETQ
+                                                               #17#
+                                                               #20#))
+                                                             (T
+                                                              (SETQ
+                                                               #17#
                                                                (SPADCALL
-                                                                |m|
-                                                                (SPADCALL
-                                                                 (SPADCALL
-                                                                  (CDR
-                                                                   |ans|)
-                                                                  (SETQ
-                                                                   |i|
-                                                                   (+
-                                                                    |i|
-                                                                    1))
-                                                                  (|getShellEntry|
-                                                                   $
-                                                                   181))
-                                                                 (|getShellEntry|
-                                                                  $ 51))
+                                                                #17#
+                                                                #20#
                                                                 (|getShellEntry|
-                                                                 $ 182))))
-                                                              (COND
-                                                                (#18#
-                                                                 (SETQ
-                                                                  #17#
-                                                                  #20#))
-                                                                (T
-                                                                 (SETQ
-                                                                  #17#
-                                                                  (SPADCALL
-                                                                   #17#
-                                                                   #20#
-                                                                   (|getShellEntry|
-                                                                    $
-                                                                    183)))))
-                                                              (SETQ
-                                                               #18#
-                                                               NIL)))))
-                                                       (SETQ #19#
-                                                        (CDR #19#))))))))
-                                             (SETQ #15# (CDR #15#))
-                                             (SETQ #16# (+ #16# 1)))))))))))))))) 
+                                                                 $ 183)))))
+                                                           (SETQ #18#
+                                                            NIL)))))
+                                                    (SETQ #19#
+                                                     (CDR #19#))))))))
+                                          (SETQ #15# (CDR #15#))
+                                          (SETQ #16# (+ #16# 1)))))))))))))))) 
 
 (DEFUN |POLYCAT-;charthRoot;SU;28| (|p| $)
   (PROG (|ans| |ch|)
@@ -903,14 +891,12 @@
                       |POLYCAT-;charthRoot;SU;28|)
                 (EXIT (COND
                         ((EQL (CAR |ans|) 1) (CONS 1 "failed"))
-                        ('T
-                         (CONS 0
-                               (SPADCALL (CDR |ans|)
-                                   (|getShellEntry| $ 51))))))))
-          ('T
-           (SEQ (LETT |ch| (|spadConstant| $ 169)
-                      |POLYCAT-;charthRoot;SU;28|)
-                (EXIT (|POLYCAT-;charthRootlv| |p| |vars| |ch| $))))))))) 
+                        (T (CONS 0
+                                 (SPADCALL (CDR |ans|)
+                                     (|getShellEntry| $ 51))))))))
+          (T (SEQ (LETT |ch| (|spadConstant| $ 169)
+                        |POLYCAT-;charthRoot;SU;28|)
+                  (EXIT (|POLYCAT-;charthRootlv| |p| |vars| |ch| $))))))))) 
 
 (DEFUN |POLYCAT-;charthRootlv| (|p| |vars| |ch| $)
   (PROG (|v| |d| |ans| |dd| |cp| |ansx|)
@@ -924,84 +910,84 @@
                          |POLYCAT-;charthRootlv|)
                    (EXIT (COND
                            ((EQL (CAR |ans|) 1) (CONS 1 "failed"))
-                           ('T
-                            (CONS 0
-                                  (SPADCALL (CDR |ans|)
-                                      (|getShellEntry| $ 51))))))))
-             ('T
-              (SEQ (LETT |v| (|SPADfirst| |vars|)
-                         |POLYCAT-;charthRootlv|)
-                   (SETQ |vars| (CDR |vars|))
-                   (LETT |d| (SPADCALL |p| |v| (|getShellEntry| $ 46))
-                         |POLYCAT-;charthRootlv|)
-                   (LETT |ans| (|spadConstant| $ 27)
-                         |POLYCAT-;charthRootlv|)
-                   (LOOP
-                     (COND
-                       ((NOT (PLUSP |d|)) (RETURN NIL))
-                       (T (SEQ (LETT |dd|
-                                     (SPADCALL |d| |ch|
-                                      (|getShellEntry| $ 173))
-                                     |POLYCAT-;charthRootlv|)
-                               (EXIT (COND
-                                       ((EQL (CAR |dd|) 1)
-                                        (RETURN-FROM
-                                         |POLYCAT-;charthRootlv|
-                                          (CONS 1 "failed")))
-                                       ('T
-                                        (SEQ
-                                         (LETT |cp|
-                                          (SPADCALL |p| |v| |d|
-                                           (|getShellEntry| $ 188))
-                                          |POLYCAT-;charthRootlv|)
-                                         (SETQ |p|
-                                          (SPADCALL |p|
-                                           (SPADCALL |cp| |v| |d|
-                                            (|getShellEntry| $ 47))
-                                           (|getShellEntry| $ 189)))
-                                         (LETT |ansx|
-                                          (|POLYCAT-;charthRootlv| |cp|
-                                           |vars| |ch| $)
-                                          |POLYCAT-;charthRootlv|)
-                                         (EXIT
-                                          (COND
-                                            ((EQL (CAR |ansx|) 1)
-                                             (RETURN-FROM
-                                              |POLYCAT-;charthRootlv|
-                                               (CONS 1 "failed")))
-                                            ('T
-                                             (SEQ
-                                              (SETQ |d|
-                                               (SPADCALL |p| |v|
-                                                (|getShellEntry| $ 46)))
-                                              (EXIT
-                                               (SETQ |ans|
-                                                (SPADCALL |ans|
-                                                 (SPADCALL (CDR |ansx|)
-                                                  |v|
-                                                  (LET
-                                                   ((#0=#:G1640
-                                                     (CDR |dd|)))
-                                                    (|check-subtype|
-                                                     (NOT (MINUSP #0#))
-                                                     '(|NonNegativeInteger|)
-                                                     #0#))
+                           (T (CONS 0
+                                    (SPADCALL (CDR |ans|)
+                                     (|getShellEntry| $ 51))))))))
+             (T (SEQ (LETT |v| (|SPADfirst| |vars|)
+                           |POLYCAT-;charthRootlv|)
+                     (SETQ |vars| (CDR |vars|))
+                     (LETT |d|
+                           (SPADCALL |p| |v| (|getShellEntry| $ 46))
+                           |POLYCAT-;charthRootlv|)
+                     (LETT |ans| (|spadConstant| $ 27)
+                           |POLYCAT-;charthRootlv|)
+                     (LOOP
+                       (COND
+                         ((NOT (PLUSP |d|)) (RETURN NIL))
+                         (T (SEQ (LETT |dd|
+                                       (SPADCALL |d| |ch|
+                                        (|getShellEntry| $ 173))
+                                       |POLYCAT-;charthRootlv|)
+                                 (EXIT (COND
+                                         ((EQL (CAR |dd|) 1)
+                                          (RETURN-FROM
+                                           |POLYCAT-;charthRootlv|
+                                            (CONS 1 "failed")))
+                                         (T
+                                          (SEQ
+                                           (LETT |cp|
+                                            (SPADCALL |p| |v| |d|
+                                             (|getShellEntry| $ 188))
+                                            |POLYCAT-;charthRootlv|)
+                                           (SETQ |p|
+                                            (SPADCALL |p|
+                                             (SPADCALL |cp| |v| |d|
+                                              (|getShellEntry| $ 47))
+                                             (|getShellEntry| $ 189)))
+                                           (LETT |ansx|
+                                            (|POLYCAT-;charthRootlv|
+                                             |cp| |vars| |ch| $)
+                                            |POLYCAT-;charthRootlv|)
+                                           (EXIT
+                                            (COND
+                                              ((EQL (CAR |ansx|) 1)
+                                               (RETURN-FROM
+                                                |POLYCAT-;charthRootlv|
+                                                 (CONS 1 "failed")))
+                                              (T
+                                               (SEQ
+                                                (SETQ |d|
+                                                 (SPADCALL |p| |v|
                                                   (|getShellEntry| $
-                                                   47))
-                                                 (|getShellEntry| $
-                                                  183))))))))))))))))
-                   (LETT |ansx|
-                         (|POLYCAT-;charthRootlv| |p| |vars| |ch| $)
-                         |POLYCAT-;charthRootlv|)
-                   (EXIT (COND
-                           ((EQL (CAR |ansx|) 1)
-                            (RETURN-FROM |POLYCAT-;charthRootlv|
-                              (CONS 1 "failed")))
-                           ('T
-                            (RETURN-FROM |POLYCAT-;charthRootlv|
-                              (CONS 0
-                                    (SPADCALL |ans| (CDR |ansx|)
-                                     (|getShellEntry| $ 183)))))))))))))) 
+                                                   46)))
+                                                (EXIT
+                                                 (SETQ |ans|
+                                                  (SPADCALL |ans|
+                                                   (SPADCALL
+                                                    (CDR |ansx|) |v|
+                                                    (LET
+                                                     ((#0=#:G1640
+                                                       (CDR |dd|)))
+                                                      (|check-subtype|
+                                                       (NOT
+                                                        (MINUSP #0#))
+                                                       '(|NonNegativeInteger|)
+                                                       #0#))
+                                                    (|getShellEntry| $
+                                                     47))
+                                                   (|getShellEntry| $
+                                                    183))))))))))))))))
+                     (LETT |ansx|
+                           (|POLYCAT-;charthRootlv| |p| |vars| |ch| $)
+                           |POLYCAT-;charthRootlv|)
+                     (EXIT (COND
+                             ((EQL (CAR |ansx|) 1)
+                              (RETURN-FROM |POLYCAT-;charthRootlv|
+                                (CONS 1 "failed")))
+                             (T (RETURN-FROM |POLYCAT-;charthRootlv|
+                                  (CONS 0
+                                        (SPADCALL |ans| (CDR |ansx|)
+                                         (|getShellEntry| $ 183)))))))))))))) 
 
 (DEFUN |POLYCAT-;monicDivide;2SVarSetR;30| (|p1| |p2| |mvar| $)
   (LET ((|result|
@@ -1084,11 +1070,10 @@
       ((SPADCALL |dq| |dp| (|getShellEntry| $ 214))
        (SPADCALL (SPADCALL |p| (|getShellEntry| $ 48))
            (|spadConstant| $ 28) (|getShellEntry| $ 215)))
-      ('T
-       (SPADCALL
-           (SPADCALL (SPADCALL |p| |q| (|getShellEntry| $ 189))
-               (|getShellEntry| $ 48))
-           (|spadConstant| $ 28) (|getShellEntry| $ 215)))))) 
+      (T (SPADCALL
+             (SPADCALL (SPADCALL |p| |q| (|getShellEntry| $ 189))
+                 (|getShellEntry| $ 48))
+             (|spadConstant| $ 28) (|getShellEntry| $ 215)))))) 
 
 (DEFUN |POLYCAT-;patternMatch;SP2Pmr;39| (|p| |pat| |l| $)
   (SPADCALL |p| |pat| |l| (|getShellEntry| $ 220))) 
@@ -1212,15 +1197,14 @@
                    (CONS (|dispatchFunction|
                              |POLYCAT-;squareFree;SF;31|)
                          $)))
-              ('T
-               (|setShellEntry| $ 195
-                   (CONS (|dispatchFunction|
-                             |POLYCAT-;squareFree;SF;32|)
-                         $)))))
-           ('T
-            (|setShellEntry| $ 195
-                (CONS (|dispatchFunction| |POLYCAT-;squareFree;SF;33|)
-                      $))))
+              (T (|setShellEntry| $ 195
+                     (CONS (|dispatchFunction|
+                               |POLYCAT-;squareFree;SF;32|)
+                           $)))))
+           (T (|setShellEntry| $ 195
+                  (CONS (|dispatchFunction|
+                            |POLYCAT-;squareFree;SF;33|)
+                        $))))
          (|setShellEntry| $ 203
              (CONS (|dispatchFunction| |POLYCAT-;squareFreePart;2S;34|)
                    $))