
(/VERSIONCHECK 2) 

(DEFUN |FR;convert;$If;1| (|x| $)
  (PROG (|lf| |rec| #0=#:G1915 |iFactor| |iExpon| |iFun| |l|)
    (RETURN
      (SEQ (COND
             ((NULL (LETT |lf| (REVERSE (SPADCALL |x| (QREFELT $ 11)))
                          . #1=(|FR;convert;$If;1|)))
              (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 14)))
             ('T
              (SEQ (LETT |l| NIL . #1#)
                   (SEQ (LETT |rec| NIL . #1#) (LETT #0# |lf| . #1#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN
                                 (LETT |rec| (CAR #0#) . #1#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (COND
                                     ((SPADCALL (QVELT |rec| 1)
                                       (|spadConstant| $ 15)
                                       (QREFELT $ 17))
                                      (SPADCALL
                                       "WARNING (convert$Factored): 1 should not appear as factor."
                                       (QREFELT $ 21)))
                                     ('T
                                      (SEQ
                                       (LETT |iFactor|
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL "::"
                                           (QREFELT $ 23))
                                          (QREFELT $ 24))
                                         (LIST
                                          (SPADCALL (QVELT |rec| 1)
                                           (QREFELT $ 14))
                                          (|devaluate| (QREFELT $ 6)))
                                         (QREFELT $ 26)) . #1#)
                                       (LETT |iExpon|
                                        (SPADCALL (QVELT |rec| 2)
                                         (QREFELT $ 28)) . #1#)
                                       (LETT |iFun|
                                        (COND
                                          ((QEQCAR (QVELT |rec| 0) 0)
                                           (LIST
                                            (SPADCALL
                                             (SPADCALL "nilFactor"
                                              (QREFELT $ 23))
                                             (QREFELT $ 24))
                                            |iFactor| |iExpon|))
                                          ((QEQCAR (QVELT |rec| 0) 1)
                                           (LIST
                                            (SPADCALL
                                             (SPADCALL "sqfrFactor"
                                              (QREFELT $ 23))
                                             (QREFELT $ 24))
                                            |iFactor| |iExpon|))
                                          ((QEQCAR (QVELT |rec| 0) 3)
                                           (LIST
                                            (SPADCALL
                                             (SPADCALL "primeFactor"
                                              (QREFELT $ 23))
                                             (QREFELT $ 24))
                                            |iFactor| |iExpon|))
                                          ((QEQCAR (QVELT |rec| 0) 2)
                                           (LIST
                                            (SPADCALL
                                             (SPADCALL
                                              "irreducibleFactor"
                                              (QREFELT $ 23))
                                             (QREFELT $ 24))
                                            |iFactor| |iExpon|))
                                          ('T NIL)) . #1#)
                                       (EXIT
                                        (LETT |l|
                                         (CONS |iFun| |l|) . #1#)))))))
                        (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (COND
                           ((NULL |l|)
                            (SPADCALL (SPADCALL |x| (QREFELT $ 12))
                                (QREFELT $ 14)))
                           ('T
                            (SEQ (COND
                                   ((NULL
                                     (SPADCALL
                                      (SPADCALL |x| (QREFELT $ 12))
                                      (|spadConstant| $ 15)
                                      (QREFELT $ 17)))
                                    (LETT |l|
                                     (CONS
                                      (SPADCALL
                                       (SPADCALL |x| (QREFELT $ 12))
                                       (QREFELT $ 14))
                                      |l|) . #1#)))
                                 (EXIT (COND
                                         ((NULL (CDR |l|))
                                          (|SPADfirst| |l|))
                                         ('T
                                          (SPADCALL
                                           (SPADCALL '* (QREFELT $ 24))
                                           |l| (QREFELT $ 26)))))))))))))))) 

(DEFUN |FR;nilFactor;RI$;2| (|r| |i| $)
  (SPADCALL |r| |i| (CONS 0 "nil") (QREFELT $ 31))) 

(DEFUN |FR;sqfrFactor;RI$;3| (|r| |i| $)
  (SPADCALL |r| |i| (CONS 1 "sqfr") (QREFELT $ 31))) 

(DEFUN |FR;irreducibleFactor;RI$;4| (|r| |i| $)
  (SPADCALL |r| |i| (CONS 2 "irred") (QREFELT $ 31))) 

(DEFUN |FR;primeFactor;RI$;5| (|r| |i| $)
  (SPADCALL |r| |i| (CONS 3 "prime") (QREFELT $ 31))) 

(DEFUN |FR;unit?;$B;6| (|u| $)
  (COND
    ((NULL (QCDR |u|))
     (COND ((SPADCALL (QCAR |u|) (QREFELT $ 36)) 'NIL) ('T 'T)))
    ('T 'NIL))) 

(PUT '|FR;factorList;$L;7| '|SPADreplace| 'QCDR) 

(DEFUN |FR;factorList;$L;7| (|u| $) (QCDR |u|)) 

(PUT '|FR;unit;$R;8| '|SPADreplace| 'QCAR) 

(DEFUN |FR;unit;$R;8| (|u| $) (QCAR |u|)) 

(DEFUN |FR;numberOfFactors;$Nni;9| (|u| $) (LENGTH (QCDR |u|))) 

(DEFUN |FR;Zero;$;10| ($)
  (CONS (|spadConstant| $ 15)
        (LIST (VECTOR (CONS 0 "nil") (|spadConstant| $ 42) 1)))) 

(DEFUN |FR;zero?;$B;11| (|u| $)
  (COND
    ((EQL (LENGTH (QCDR |u|)) 1)
     (COND
       ((QEQCAR (QVELT (|SPADfirst| (QCDR |u|)) 0) 0)
        (COND
          ((SPADCALL (QVELT (|SPADfirst| (QCDR |u|)) 1) (QREFELT $ 36))
           (SPADCALL (QCAR |u|) (|spadConstant| $ 15) (QREFELT $ 17)))
          ('T 'NIL)))
       ('T 'NIL)))
    ('T 'NIL))) 

(DEFUN |FR;One;$;12| ($) (CONS (|spadConstant| $ 15) NIL)) 

(DEFUN |FR;one?;$B;13| (|u| $)
  (COND
    ((NULL (QCDR |u|))
     (SPADCALL (QCAR |u|) (|spadConstant| $ 15) (QREFELT $ 17)))
    ('T 'NIL))) 

(PUT '|FR;mkFF| '|SPADreplace| 'CONS) 

(DEFUN |FR;mkFF| (|r| |x| $) (CONS |r| |x|)) 

(DEFUN |FR;coerce;I$;15| (|j| $)
  (SPADCALL (SPADCALL |j| (QREFELT $ 45)) (QREFELT $ 46))) 

(DEFUN |FR;characteristic;Nni;16| ($) (SPADCALL (QREFELT $ 48))) 

(DEFUN |FR;*;I2$;17| (|i| |u| $)
  (SPADCALL (SPADCALL |i| (QREFELT $ 47)) |u| (QREFELT $ 50))) 

(DEFUN |FR;*;R2$;18| (|r| |u| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 46)) |u| (QREFELT $ 50))) 

(DEFUN |FR;factors;$L;19| (|u| $)
  (PROG (#0=#:G1992 |fe| #1=#:G1993)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|FR;factors;$L;19|))
             (SEQ (LETT |fe| NIL . #2#)
                  (LETT #1# (SPADCALL |u| (QREFELT $ 11)) . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |fe| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (CONS (QVELT |fe| 1)
                                     (QVELT |fe| 2))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |FR;expand;$R;20| (|u| $) (SPADCALL |u| (QREFELT $ 56))) 

(DEFUN |FR;negexp?| (|x| $)
  (PROG (|y| #0=#:G2000 #1=#:G1998 #2=#:G1996 #3=#:G1997)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|FR;negexp?|))
             (SEQ (LETT |y| NIL . #4#)
                  (LETT #0# (SPADCALL |x| (QREFELT $ 11)) . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |y| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1# (MINUSP (QVELT |y| 2)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (COND (#2# 'T) ('T #1#)) . #4#))
                                 ('T
                                  (PROGN
                                    (LETT #2# #1# . #4#)
                                    (LETT #3# 'T . #4#)))))))
                  (LETT #0# (CDR #0#) . #4#) (GO G190) G191 (EXIT NIL))
             (COND (#3# #2#) ('T 'NIL))))))) 

(DEFUN |FR;makeFR;RL$;22| (|u| |l| $)
  (SPADCALL (|FR;mkFF| |u| (|FR;SimplifyFactorization| |l| $) $)
      (QREFELT $ 58))) 

(PUT '|FR;rational?;$B;23| '|SPADreplace| '(XLAM (|x|) 'T)) 

(DEFUN |FR;rational?;$B;23| (|x| $) 'T) 

(DEFUN |FR;rationalIfCan;$U;24| (|x| $)
  (CONS 0 (SPADCALL |x| (QREFELT $ 62)))) 

(DEFUN |FR;rational;$F;25| (|x| $)
  (PROG (|f| #0=#:G2016 #1=#:G2014 #2=#:G2012 #3=#:G2013)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 65))
               (PROGN
                 (LETT #3# NIL . #4=(|FR;rational;$F;25|))
                 (SEQ (LETT |f| NIL . #4#)
                      (LETT #0# (SPADCALL |x| (QREFELT $ 11)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |f| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL (QVELT |f| 1)
                                       (QREFELT $ 65))
                                      (QREFELT $ 66))
                                     (QVELT |f| 2) (QREFELT $ 67)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 68)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 69))))
               (QREFELT $ 70)))))) 

(DEFUN |FR;elt;3$;26| (|x| |v| $)
  (SPADCALL |x| (SPADCALL |v| (QREFELT $ 57)) (QREFELT $ 71))) 

(DEFUN |FR;eval;$L$;27| (|x| |l| $)
  (PROG (#0=#:G2020 |e| #1=#:G2021)
    (RETURN
      (SEQ (SPADCALL |x|
               (PROGN
                 (LETT #0# NIL . #2=(|FR;eval;$L$;27|))
                 (SEQ (LETT |e| NIL . #2#) (LETT #1# |l| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |e| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |e| (QREFELT $ 74))
                                          (QREFELT $ 57))
                                         (SPADCALL
                                          (SPADCALL |e| (QREFELT $ 75))
                                          (QREFELT $ 57))
                                         (QREFELT $ 77))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 79)))))) 

(DEFUN |FR;eval;$LL$;28| (|x| |ls| |lv| $)
  (PROG (#0=#:G2024 |v| #1=#:G2025)
    (RETURN
      (SEQ (SPADCALL |x| |ls|
               (PROGN
                 (LETT #0# NIL . #2=(|FR;eval;$LL$;28|))
                 (SEQ (LETT |v| NIL . #2#) (LETT #1# |lv| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |v| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL |v| (QREFELT $ 57))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 84)))))) 

(DEFUN |FR;convert;$F;29| (|x| $)
  (PROG (|f| #0=#:G2035 #1=#:G2033 #2=#:G2031 #3=#:G2032)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 87))
               (PROGN
                 (LETT #3# NIL . #4=(|FR;convert;$F;29|))
                 (SEQ (LETT |f| NIL . #4#)
                      (LETT #0# (SPADCALL |x| (QREFELT $ 11)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |f| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL
                                     (SPADCALL (QVELT |f| 1)
                                      (QREFELT $ 87))
                                     (QVELT |f| 2) (QREFELT $ 88)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 89)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 90))))
               (QREFELT $ 89)))))) 

(DEFUN |FR;convert;$Df;30| (|x| $)
  (PROG (|f| #0=#:G2045 #1=#:G2043 #2=#:G2041 #3=#:G2042)
    (RETURN
      (SEQ (* (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 93))
              (PROGN
                (LETT #3# NIL . #4=(|FR;convert;$Df;30|))
                (SEQ (LETT |f| NIL . #4#)
                     (LETT #0# (SPADCALL |x| (QREFELT $ 11)) . #4#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |f| (CAR #0#) . #4#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (EXPT
                                         (SPADCALL (QVELT |f| 1)
                                          (QREFELT $ 93))
                                         (QVELT |f| 2)) . #4#)
                                  (COND
                                    (#3# (LETT #2# (* #2# #1#) . #4#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #4#)
                                       (LETT #3# 'T . #4#)))))))
                     (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) ('T 1.0)))))))) 

(DEFUN |FR;*;3$;31| (|u| |v| $)
  (COND
    ((OR (SPADCALL |u| (QREFELT $ 43)) (SPADCALL |v| (QREFELT $ 43)))
     (|spadConstant| $ 41))
    ('T
     (COND
       ((SPADCALL |u| (|spadConstant| $ 40) (QREFELT $ 95)) |v|)
       ((SPADCALL |v| (|spadConstant| $ 40) (QREFELT $ 95)) |u|)
       ('T
        (|FR;mkFF|
            (SPADCALL (SPADCALL |u| (QREFELT $ 12))
                (SPADCALL |v| (QREFELT $ 12)) (QREFELT $ 96))
            (|FR;SimplifyFactorization|
                (SPADCALL (SPADCALL |u| (QREFELT $ 11))
                    (SPADCALL (SPADCALL |v| (QREFELT $ 11))
                        (QREFELT $ 97))
                    (QREFELT $ 98))
                $)
            $)))))) 

(DEFUN |FR;**;$Nni$;32| (|u| |n| $)
  (PROG (#0=#:G2059 |x| #1=#:G2060)
    (RETURN
      (SEQ (|FR;mkFF|
               (SPADCALL (SPADCALL |u| (QREFELT $ 12)) |n|
                   (QREFELT $ 99))
               (PROGN
                 (LETT #0# NIL . #2=(|FR;**;$Nni$;32|))
                 (SEQ (LETT |x| NIL . #2#)
                      (LETT #1# (SPADCALL |u| (QREFELT $ 11)) . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |x| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (VECTOR (QVELT |x| 0)
                                         (QVELT |x| 1)
                                         (SPADCALL |n| (QVELT |x| 2)
                                          (QREFELT $ 100)))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               $))))) 

(DEFUN |FR;SimplifyFactorization| (|x| $)
  (SEQ (COND
         ((NULL |x|) NIL)
         ('T
          (SEQ (LETT |x|
                     (SPADCALL (CONS (|function| |FR;LispLessP|) $) |x|
                         (QREFELT $ 103))
                     . #0=(|FR;SimplifyFactorization|))
               (LETT |x|
                     (|FR;SimplifyFactorization1| (|SPADfirst| |x|)
                         (CDR |x|) $) . #0#)
               (COND
                 ((QREFELT $ 30)
                  (LETT |x|
                        (SPADCALL (CONS (|function| |FR;LispLessP|) $)
                            |x| (QREFELT $ 103)) . #0#)))
               (EXIT |x|)))))) 

(DEFUN |FR;SimplifyFactorization1| (|f| |x| $)
  (PROG (|f1| |l|)
    (RETURN
      (SEQ (COND
             ((NULL |x|)
              (COND
                ((ZEROP (QVELT |f| 2)) NIL)
                ('T (SPADCALL |f| (QREFELT $ 104)))))
             ('T
              (SEQ (LETT |f1| (|SPADfirst| |x|)
                         . #0=(|FR;SimplifyFactorization1|))
                   (EXIT (COND
                           ((SPADCALL (QVELT |f| 1) (QVELT |f1| 1)
                                (QREFELT $ 17))
                            (|FR;SimplifyFactorization1|
                                (VECTOR (|FR;stricterFlag|
                                         (QVELT |f| 0) (QVELT |f1| 0)
                                         $)
                                        (QVELT |f| 1)
                                        (+ (QVELT |f| 2)
                                         (QVELT |f1| 2)))
                                (CDR |x|) $))
                           ('T
                            (SEQ (LETT |l|
                                       (|FR;SimplifyFactorization1|
                                        (|SPADfirst| |x|) (CDR |x|) $) . #0#)
                                 (EXIT (COND
                                         ((ZEROP (QVELT |f| 2)) |l|)
                                         ('T (CONS |f| |l|))))))))))))))) 

(DEFUN |FR;coerce;$Of;35| (|x| $)
  (PROG (|lf| |rec| #0=#:G2091 |l| |e|)
    (RETURN
      (SEQ (COND
             ((NULL (LETT |lf| (REVERSE (SPADCALL |x| (QREFELT $ 11)))
                          . #1=(|FR;coerce;$Of;35|)))
              (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 105)))
             ('T
              (SEQ (LETT |l| NIL . #1#)
                   (SEQ (LETT |rec| NIL . #1#) (LETT #0# |lf| . #1#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN
                                 (LETT |rec| (CAR #0#) . #1#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (COND
                                     ((SPADCALL (QVELT |rec| 1)
                                       (|spadConstant| $ 15)
                                       (QREFELT $ 17))
                                      (SPADCALL
                                       "WARNING (coerce$Factored): 1 should not appear as factor."
                                       (QREFELT $ 21)))
                                     ((EQL (QVELT |rec| 2) 1)
                                      (LETT |l|
                                       (CONS
                                        (SPADCALL (QVELT |rec| 1)
                                         (QREFELT $ 105))
                                        |l|) . #1#))
                                     ('T
                                      (LETT |l|
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL (QVELT |rec| 1)
                                          (QREFELT $ 105))
                                         (SPADCALL (QVELT |rec| 2)
                                          (QREFELT $ 106))
                                         (QREFELT $ 107))
                                        |l|) . #1#)))))
                        (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (COND
                           ((NULL |l|)
                            (SPADCALL (SPADCALL |x| (QREFELT $ 12))
                                (QREFELT $ 105)))
                           ('T
                            (SEQ (LETT |e|
                                       (COND
                                         ((NULL (CDR |l|))
                                          (|SPADfirst| |l|))
                                         ('T
                                          (SPADCALL (ELT $ 108) |l|
                                           (QREFELT $ 111)))) . #1#)
                                 (EXIT (COND
                                         ((SPADCALL
                                           (|spadConstant| $ 15)
                                           (SPADCALL |x|
                                            (QREFELT $ 12))
                                           (QREFELT $ 17))
                                          |e|)
                                         ('T
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |x|
                                             (QREFELT $ 12))
                                            (QREFELT $ 105))
                                           |e| (QREFELT $ 108)))))))))))))))) 

(DEFUN |FR;retract;$R;36| (|u| $)
  (COND
    ((|FR;negexp?| |u| $)
     (|error| "Negative exponent in factored object"))
    ('T (|FR;qexpand| |u| $)))) 

(DEFUN |FR;qexpand| (|u| $)
  (PROG (|y| #0=#:G2101 #1=#:G2099 #2=#:G2097 #3=#:G2095 #4=#:G2096)
    (RETURN
      (SEQ (SPADCALL (SPADCALL |u| (QREFELT $ 12))
               (PROGN
                 (LETT #4# NIL . #5=(|FR;qexpand|))
                 (SEQ (LETT |y| NIL . #5#)
                      (LETT #0# (SPADCALL |u| (QREFELT $ 11)) . #5#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |y| (CAR #0#) . #5#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #2#
                                    (SPADCALL (QVELT |y| 1)
                                     (PROG1
                                      (LETT #1# (QVELT |y| 2) . #5#)
                                       (|check-subtype| (>= #1# 0)
                                        '(|NonNegativeInteger|) #1#))
                                     (QREFELT $ 99)) . #5#)
                                   (COND
                                     (#4#
                                      (LETT #3#
                                       (SPADCALL #3# #2#
                                        (QREFELT $ 96)) . #5#))
                                     ('T
                                      (PROGN
                                        (LETT #3# #2# . #5#)
                                        (LETT #4# 'T . #5#)))))))
                      (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#4# #3#) ('T (|spadConstant| $ 15))))
               (QREFELT $ 96)))))) 

(DEFUN |FR;retractIfCan;$U;38| (|u| $)
  (COND
    ((|FR;negexp?| |u| $) (CONS 1 "failed"))
    ('T (CONS 0 (|FR;qexpand| |u| $))))) 

(DEFUN |FR;LispLessP| (|y| |y1| $)
  (COND
    ((QREFELT $ 30)
     (SPADCALL (QVELT |y| 1) (QVELT |y1| 1) (QREFELT $ 115)))
    ((GGREATERP (QVELT |y| 1) (QVELT |y1| 1)) 'NIL)
    ('T 'T))) 

(DEFUN |FR;stricterFlag| (|fl1| |fl2| $)
  (COND
    ((QEQCAR |fl1| 3) |fl1|)
    ((QEQCAR |fl1| 2) (COND ((QEQCAR |fl2| 3) |fl2|) (#0='T |fl1|)))
    ((QEQCAR |fl1| 1) (COND ((QEQCAR |fl2| 0) |fl1|) (#0# |fl2|)))
    (#0# |fl2|))) 

(DEFUN |FR;coerce;R$;41| (|r| $) (SPADCALL |r| (QREFELT $ 118))) 

(DEFUN |FR;coerce;R$;42| (|r| $)
  (COND
    ((SPADCALL |r| (QREFELT $ 36)) (|spadConstant| $ 41))
    ((SPADCALL |r| (QREFELT $ 119)) (|FR;mkFF| |r| NIL $))
    ((|HasCategory| (QREFELT $ 6) '(|Field|))
     (|error| "zero divisor in a field"))
    ('T (SPADCALL (SPADCALL |r| (QREFELT $ 121)) (QREFELT $ 58))))) 

(DEFUN |FR;coerce;R$;43| (|r| $)
  (COND
    ((SPADCALL |r| (|spadConstant| $ 15) (QREFELT $ 17))
     (|spadConstant| $ 40))
    ('T
     (SPADCALL
         (|FR;mkFF| (|spadConstant| $ 15)
             (LIST (VECTOR (CONS 0 "nil") |r| 1)) $)
         (QREFELT $ 58))))) 

(DEFUN |FR;=;2$B;44| (|u| |v| $)
  (COND
    ((SPADCALL (SPADCALL |u| (QREFELT $ 12))
               (SPADCALL |v| (QREFELT $ 12)) (QREFELT $ 17))
     (COND
       ((EQL (LENGTH (QCDR |u|)) (LENGTH (QCDR |v|)))
        (SPADCALL
            (SPADCALL (SPADCALL |u| (QREFELT $ 55)) (QREFELT $ 123))
            (SPADCALL (SPADCALL |v| (QREFELT $ 55)) (QREFELT $ 123))
            (QREFELT $ 124)))
       ('T 'NIL)))
    ('T 'NIL))) 

(DEFUN |FR;-;2$;45| (|u| $)
  (COND
    ((SPADCALL |u| (QREFELT $ 43)) |u|)
    ('T
     (|FR;mkFF|
         (SPADCALL (SPADCALL |u| (QREFELT $ 12)) (QREFELT $ 125))
         (SPADCALL |u| (QREFELT $ 11)) $)))) 

(DEFUN |FR;recip;$U;46| (|u| $)
  (PROG (|r|)
    (RETURN
      (SEQ (COND
             ((NULL (NULL (SPADCALL |u| (QREFELT $ 11))))
              (CONS 1 "failed"))
             ('T
              (SEQ (LETT |r|
                         (SPADCALL (SPADCALL |u| (QREFELT $ 12))
                             (QREFELT $ 128))
                         |FR;recip;$U;46|)
                   (EXIT (COND
                           ((QEQCAR |r| 1) (CONS 1 "failed"))
                           ('T (CONS 0 (|FR;mkFF| (QCDR |r|) NIL $)))))))))))) 

(DEFUN |FR;reciprocal| (|u| $)
  (PROG (#0=#:G2163 #1=#:G2173 |y| #2=#:G2174)
    (RETURN
      (SEQ (|FR;mkFF|
               (PROG2 (LETT #0#
                            (SPADCALL (SPADCALL |u| (QREFELT $ 12))
                                (QREFELT $ 128))
                            . #3=(|FR;reciprocal|))
                      (QCDR #0#)
                 (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#))
               (PROGN
                 (LETT #1# NIL . #3#)
                 (SEQ (LETT |y| NIL . #3#)
                      (LETT #2# (SPADCALL |u| (QREFELT $ 11)) . #3#)
                      G190
                      (COND
                        ((OR (ATOM #2#)
                             (PROGN (LETT |y| (CAR #2#) . #3#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #1#
                                       (CONS
                                        (VECTOR (QVELT |y| 0)
                                         (QVELT |y| 1)
                                         (- (QVELT |y| 2)))
                                        #1#) . #3#)))
                      (LETT #2# (CDR #2#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #1#))))
               $))))) 

(DEFUN |FR;exponent;$I;48| (|u| $)
  (PROG (|fl|)
    (RETURN
      (COND
        ((OR (NULL (LETT |fl| (SPADCALL |u| (QREFELT $ 11))
                         |FR;exponent;$I;48|))
             (SPADCALL |u| (QREFELT $ 43)))
         0)
        ('T (QVELT (|SPADfirst| |fl|) 2)))))) 

(DEFUN |FR;nthExponent;$2I;49| (|u| |i| $)
  (PROG (|l|)
    (RETURN
      (SEQ (LETT |l| (SPADCALL |u| (QREFELT $ 11))
                 |FR;nthExponent;$2I;49|)
           (COND
             ((OR (OR (SPADCALL |u| (QREFELT $ 43)) (< |i| 1))
                  (< (LENGTH |l|) |i|))
              (EXIT 0)))
           (EXIT (QVELT (SPADCALL |l|
                            (- (+ (SPADCALL |l| (QREFELT $ 131)) |i|)
                               1)
                            (QREFELT $ 132))
                        2)))))) 

(DEFUN |FR;nthFactor;$IR;50| (|u| |i| $)
  (PROG (|l|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |u| (QREFELT $ 43)) (|spadConstant| $ 42))
             ((ZEROP |i|) (SPADCALL |u| (QREFELT $ 12)))
             ('T
              (SEQ (LETT |l| (SPADCALL |u| (QREFELT $ 11))
                         |FR;nthFactor;$IR;50|)
                   (COND
                     ((OR (MINUSP |i|) (< (LENGTH |l|) |i|))
                      (EXIT (|spadConstant| $ 15))))
                   (EXIT (QVELT (SPADCALL |l|
                                    (-
                                     (+ (SPADCALL |l| (QREFELT $ 131))
                                      |i|)
                                     1)
                                    (QREFELT $ 132))
                                1))))))))) 

(DEFUN |FR;nthFlag;$IU;51| (|u| |i| $)
  (PROG (|l|)
    (RETURN
      (SEQ (LETT |l| (SPADCALL |u| (QREFELT $ 11)) |FR;nthFlag;$IU;51|)
           (COND
             ((OR (OR (SPADCALL |u| (QREFELT $ 43)) (< |i| 1))
                  (< (LENGTH |l|) |i|))
              (EXIT (CONS 0 "nil"))))
           (EXIT (QVELT (SPADCALL |l|
                            (- (+ (SPADCALL |l| (QREFELT $ 131)) |i|)
                               1)
                            (QREFELT $ 132))
                        0)))))) 

(DEFUN |FR;flagFactor;RIU$;52| (|r| |i| |fl| $)
  (COND
    ((ZEROP |i|) (|spadConstant| $ 40))
    ((SPADCALL |r| (QREFELT $ 36)) (|spadConstant| $ 41))
    ('T
     (SPADCALL
         (|FR;mkFF| (|spadConstant| $ 15) (LIST (VECTOR |fl| |r| |i|))
             $)
         (QREFELT $ 58))))) 

(DEFUN |FR;differentiate;$M$;53| (|u| |deriv| $)
  (PROG (|ans| |fact| #0=#:G2225 #1=#:G2216 #2=#:G2221 #3=#:G2219
               #4=#:G2220)
    (RETURN
      (SEQ (LETT |ans|
                 (SPADCALL
                     (SPADCALL (SPADCALL |u| (QREFELT $ 12)) |deriv|)
                     (PROG2 (LETT #1#
                                  (SPADCALL |u|
                                      (SPADCALL
                                       (SPADCALL |u| (QREFELT $ 12))
                                       (QREFELT $ 46))
                                      (QREFELT $ 136))
                                  . #5=(|FR;differentiate;$M$;53|))
                            (QCDR #1#)
                       (|check-union| (QEQCAR #1# 0) $ #1#))
                     (QREFELT $ 52)) . #5#)
           (EXIT (SPADCALL |ans|
                     (PROGN
                       (LETT #4# NIL . #5#)
                       (SEQ (LETT |fact| NIL . #5#)
                            (LETT #0#
                                  (SPADCALL |u| (QREFELT $ 11)) . #5#)
                            G190
                            (COND
                              ((OR (ATOM #0#)
                                   (PROGN
                                     (LETT |fact| (CAR #0#) . #5#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #2#
                                          (SPADCALL
                                           (SPADCALL (QVELT |fact| 2)
                                            (SPADCALL (QVELT |fact| 1)
                                             |deriv|)
                                            (QREFELT $ 137))
                                           (PROG2
                                            (LETT #1#
                                             (SPADCALL |u|
                                              (SPADCALL
                                               (QVELT |fact| 1) 1
                                               (QREFELT $ 32))
                                              (QREFELT $ 136)) . #5#)
                                            (QCDR #1#)
                                             (|check-union|
                                              (QEQCAR #1# 0) $ #1#))
                                           (QREFELT $ 52)) . #5#)
                                         (COND
                                           (#4#
                                            (LETT #3#
                                             (SPADCALL #3# #2#
                                              (QREFELT $ 138)) . #5#))
                                           ('T
                                            (PROGN
                                              (LETT #3# #2# . #5#)
                                              (LETT #4# 'T . #5#)))))))
                            (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                            (EXIT NIL))
                       (COND (#4# #3#) ('T (|spadConstant| $ 41))))
                     (QREFELT $ 138))))))) 

(DEFUN |FR;map;M2$;54| (|fn| |u| $)
  (PROG (|f| #0=#:G2232 #1=#:G2230 #2=#:G2228 #3=#:G2229)
    (RETURN
      (SEQ (SPADCALL (SPADCALL (SPADCALL |u| (QREFELT $ 12)) |fn|)
               (PROGN
                 (LETT #3# NIL . #4=(|FR;map;M2$;54|))
                 (SEQ (LETT |f| NIL . #4#)
                      (LETT #0# (SPADCALL |u| (QREFELT $ 11)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |f| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL
                                     (SPADCALL (QVELT |f| 1) |fn|)
                                     (QVELT |f| 2) (QREFELT $ 34)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 50)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 40))))
               (QREFELT $ 52)))))) 

(DEFUN |FR;exquo;2$U;55| (|u| |v| $)
  (PROG (|v1| |goodQuotient| |x1|)
    (RETURN
      (SEQ (COND
             ((NULL (LETT |x1| (SPADCALL |v| (QREFELT $ 11))
                          . #0=(|FR;exquo;2$U;55|)))
              (CONS 0
                    (SPADCALL
                        (QVELT (SPADCALL (SPADCALL |v| (QREFELT $ 56))
                                   (QREFELT $ 143))
                               2)
                        |u| (QREFELT $ 52))))
             ((NULL (SPADCALL |u| (QREFELT $ 11))) (CONS 1 "failed"))
             ('T
              (SEQ (LETT |v1|
                         (SPADCALL |u| (|FR;reciprocal| |v| $)
                             (QREFELT $ 50)) . #0#)
                   (LETT |goodQuotient| 'T . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   (|goodQuotient|
                                    (COND ((NULL |x1|) 'NIL) ('T 'T)))
                                   ('T 'NIL)))
                           (GO G191)))
                        (SEQ (EXIT (COND
                                     ((< (QVELT (|SPADfirst| |x1|) 2)
                                       0)
                                      (LETT |goodQuotient| 'NIL . #0#))
                                     ('T (LETT |x1| (CDR |x1|) . #0#)))))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT (COND
                           (|goodQuotient| (CONS 0 |v1|))
                           ('T (CONS 1 "failed"))))))))))) 

(DEFUN |FR;unitNormal;$R;56| (|u| $)
  (PROG (|ur| |x| #0=#:G2269 |ucar| #1=#:G2254 |e| |un| |as| |vl|)
    (RETURN
      (SEQ (LETT |ur|
                 (SPADCALL
                     (LETT |un| (SPADCALL |u| (QREFELT $ 12))
                           . #2=(|FR;unitNormal;$R;56|))
                     (QREFELT $ 128)) . #2#)
           (EXIT (COND
                   ((QEQCAR |ur| 1)
                    (VECTOR (|spadConstant| $ 40) |u|
                            (|spadConstant| $ 40)))
                   ('T
                    (SEQ (LETT |as| (QCDR |ur|) . #2#)
                         (LETT |vl| NIL . #2#)
                         (SEQ (LETT |x| NIL . #2#)
                              (LETT #0#
                                    (SPADCALL |u| (QREFELT $ 11)) . #2#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |x| (CAR #0#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (LETT |ucar|
                                    (SPADCALL (QVELT |x| 1)
                                     (QREFELT $ 143)) . #2#)
                                   (LETT |e|
                                    (PROG1
                                     (LETT #1#
                                      (ABS (QVELT |x| 2)) . #2#)
                                      (|check-subtype| (>= #1# 0)
                                       '(|NonNegativeInteger|) #1#)) . #2#)
                                   (COND
                                     ((< (QVELT |x| 2) 0)
                                      (SEQ
                                       (LETT |un|
                                        (SPADCALL |un|
                                         (SPADCALL (QVELT |ucar| 2) |e|
                                          (QREFELT $ 99))
                                         (QREFELT $ 96)) . #2#)
                                       (EXIT
                                        (LETT |as|
                                         (SPADCALL |as|
                                          (SPADCALL (QVELT |ucar| 0)
                                           |e| (QREFELT $ 99))
                                          (QREFELT $ 96)) . #2#))))
                                     ('T
                                      (SEQ
                                       (LETT |un|
                                        (SPADCALL |un|
                                         (SPADCALL (QVELT |ucar| 0) |e|
                                          (QREFELT $ 99))
                                         (QREFELT $ 96)) . #2#)
                                       (EXIT
                                        (LETT |as|
                                         (SPADCALL |as|
                                          (SPADCALL (QVELT |ucar| 2)
                                           |e| (QREFELT $ 99))
                                          (QREFELT $ 96)) . #2#)))))
                                   (EXIT
                                    (COND
                                      ((NULL
                                        (SPADCALL (QVELT |ucar| 1)
                                         (|spadConstant| $ 15)
                                         (QREFELT $ 17)))
                                       (LETT |vl|
                                        (CONS
                                         (VECTOR (QVELT |x| 0)
                                          (QVELT |ucar| 1)
                                          (QVELT |x| 2))
                                         |vl|) . #2#)))))
                              (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT (VECTOR (|FR;mkFF| |un| NIL $)
                                       (|FR;mkFF| (|spadConstant| $ 15)
                                        (NREVERSE |vl|) $)
                                       (|FR;mkFF| |as| NIL $))))))))))) 

(DEFUN |FR;unitNormalize;2$;57| (|u| $)
  (PROG (|uca|)
    (RETURN
      (SEQ (LETT |uca| (SPADCALL |u| (QREFELT $ 144))
                 |FR;unitNormalize;2$;57|)
           (EXIT (|FR;mkFF|
                     (SPADCALL
                         (SPADCALL (QVELT |uca| 0) (QREFELT $ 12))
                         (SPADCALL (QVELT |uca| 1) (QREFELT $ 12))
                         (QREFELT $ 96))
                     (SPADCALL (QVELT |uca| 1) (QREFELT $ 11)) $)))))) 

(DEFUN |FR;+;3$;58| (|u| |v| $)
  (PROG (|u1| |v1|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |u| (QREFELT $ 43)) |v|)
             ((SPADCALL |v| (QREFELT $ 43)) |u|)
             ('T
              (SEQ (LETT |v1|
                         (|FR;reciprocal|
                             (LETT |u1|
                                   (SPADCALL |u| |v| (QREFELT $ 145))
                                   . #0=(|FR;+;3$;58|))
                             $) . #0#)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |u| |v1| (QREFELT $ 50))
                                     (QREFELT $ 57))
                                 (SPADCALL
                                     (SPADCALL |v| |v1| (QREFELT $ 50))
                                     (QREFELT $ 57))
                                 (QREFELT $ 146))
                             |u1| (QREFELT $ 52)))))))))) 

(DEFUN |FR;gcd;3$;59| (|u| |v| $)
  (PROG (|x| #0=#:G2301 |j| #1=#:G2302 |f2| |y| |i| |f1| |f3| |x1|)
    (RETURN
      (SEQ (COND
             ((OR (SPADCALL |u| (|spadConstant| $ 40) (QREFELT $ 95))
                  (SPADCALL |v| (|spadConstant| $ 40) (QREFELT $ 95)))
              (|spadConstant| $ 40))
             ('T
              (COND
                ((SPADCALL |u| (QREFELT $ 43)) |v|)
                ((SPADCALL |v| (QREFELT $ 43)) |u|)
                ('T
                 (SEQ (LETT |f1| NIL . #2=(|FR;gcd;3$;59|))
                      (LETT |f2| |f1| . #2#) (LETT |f3| NIL . #2#)
                      (LETT |x|
                            (SPADCALL (SPADCALL |u| (QREFELT $ 11))
                                (SPADCALL |v| (QREFELT $ 11))
                                (QREFELT $ 98)) . #2#)
                      (SEQ (LETT |i|
                                 (SPADCALL |x| (QREFELT $ 131)) . #2#)
                           (LETT #0#
                                 (SPADCALL |x| (QREFELT $ 147)) . #2#)
                           G190 (COND ((> |i| #0#) #3=(GO G191)))
                           (SEQ (EXIT (COND
                                        ((NULL
                                          (SPADCALL |i| |f1|
                                           (QREFELT $ 149)))
                                         (SEQ
                                          (LETT |f1|
                                           (CONS |i| |f1|) . #2#)
                                          (LETT |f2| (LIST |i|) . #2#)
                                          (SEQ
                                           (LETT |j| (+ |i| 1) . #2#)
                                           (LETT #1#
                                            (SPADCALL |x|
                                             (QREFELT $ 147)) . #2#)
                                           G190
                                           (COND ((> |j| #1#) #3#))
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((SPADCALL
                                                 (QVELT
                                                  (SPADCALL |x| |i|
                                                   (QREFELT $ 132))
                                                  1)
                                                 (QVELT
                                                  (SPADCALL |x| |j|
                                                   (QREFELT $ 132))
                                                  1)
                                                 (QREFELT $ 17))
                                                (SEQ
                                                 (LETT |f1|
                                                  (CONS |j| |f1|) . #2#)
                                                 (EXIT
                                                  (LETT |f2|
                                                   (CONS |j| |f2|) . #2#)))))))
                                           (LETT |j| (+ |j| 1) . #2#)
                                           #4=(GO G190) G191
                                           (EXIT NIL))
                                          (EXIT
                                           (LETT |f3|
                                            (CONS |f2| |f3|) . #2#)))))))
                           (LETT |i| (+ |i| 1) . #2#) #4# G191
                           (EXIT NIL))
                      (LETT |x1| NIL . #2#)
                      (SEQ G190
                           (COND
                             ((NULL (COND ((NULL |f3|) 'NIL) ('T 'T)))
                              #3#))
                           (SEQ (LETT |f1| (|SPADfirst| |f3|) . #2#)
                                (COND
                                  ((< 1 (LENGTH |f1|))
                                   (SEQ
                                    (LETT |i| (|SPADfirst| |f1|) . #2#)
                                    (LETT |y|
                                     (MOVEVEC (MAKE-VEC 3)
                                      (SPADCALL |x| |i|
                                       (QREFELT $ 132))) . #2#)
                                    (LETT |f1| (CDR |f1|) . #2#)
                                    (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           ((NULL |f1|) 'NIL)
                                           ('T 'T)))
                                        #3#))
                                     (SEQ
                                      (LETT |i|
                                       (|SPADfirst| |f1|) . #2#)
                                      (COND
                                        ((<
                                          (QVELT
                                           (SPADCALL |x| |i|
                                            (QREFELT $ 132))
                                           2)
                                          (QVELT |y| 2))
                                         (QSETVELT |y| 2
                                          (QVELT
                                           (SPADCALL |x| |i|
                                            (QREFELT $ 132))
                                           2))))
                                      (EXIT
                                       (LETT |f1| (CDR |f1|) . #2#)))
                                     NIL #4# G191 (EXIT NIL))
                                    (EXIT
                                     (LETT |x1| (CONS |y| |x1|) . #2#)))))
                                (EXIT (LETT |f3| (CDR |f3|) . #2#)))
                           NIL #4# G191 (EXIT NIL))
                      (COND
                        ((QREFELT $ 30)
                         (LETT |x1|
                               (SPADCALL
                                   (CONS (|function| |FR;LispLessP|) $)
                                   |x1| (QREFELT $ 103)) . #2#)))
                      (EXIT (|FR;mkFF| (|spadConstant| $ 15) |x1| $))))))))))) 

(DEFUN |FR;+;3$;60| (|u| |v| $)
  (COND
    ((SPADCALL |u| (QREFELT $ 43)) |v|)
    ((SPADCALL |v| (QREFELT $ 43)) |u|)
    ('T
     (SPADCALL
         (SPADCALL (SPADCALL |u| (QREFELT $ 57))
             (SPADCALL |v| (QREFELT $ 57)) (QREFELT $ 146))
         1 (QREFELT $ 34))))) 

(DEFUN |FR;prime?;$B;61| (|u| $)
  (PROG (|l|)
    (RETURN
      (COND
        ((OR (OR (NULL (LETT |l| (SPADCALL |u| (QREFELT $ 11))
                             |FR;prime?;$B;61|))
                 (NULL (NULL (CDR |l|))))
             (NULL (EQL (QVELT (|SPADfirst| |l|) 2) 1)))
         'NIL)
        ('T (QEQCAR (QVELT (|SPADfirst| |l|) 0) 3)))))) 

(DEFUN |Factored| (#0=#:G2321)
  (PROG ()
    (RETURN
      (PROG (#1=#:G2322)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache| '|Factored|)
                       '|domainEqualList|)
                   . #2=(|Factored|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|Factored;| #0#) (LETT #1# T . #2#))
               (COND
                 ((NOT #1#) (HREM |$ConstructorCache| '|Factored|))))))))))) 

(DEFUN |Factored;| (|#1|)
  (PROG (DV$1 |dv$| $ #0=#:G2320 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #1=(|Factored|))
        (LETT |dv$| (LIST '|Factored| DV$1) . #1#)
        (LETT $ (GETREFV 157) . #1#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1|
                                '(|InnerEvalable| (|Symbol|) $))
                            (|HasCategory| |#1| '(|Evalable| $))
                            (|HasCategory| |#1| '(|Eltable| $ $))
                            (|HasCategory| |#1|
                                '(|ConvertibleTo| (|InputForm|)))
                            (|HasCategory| |#1|
                                '(|UniqueFactorizationDomain|))
                            (|HasCategory| |#1| '(|RealConstant|))
                            (|HasCategory| |#1|
                                '(|RetractableTo|
                                     (|Fraction| (|Integer|))))
                            (|HasCategory| |#1|
                                '(|RetractableTo| (|Integer|)))
                            (|HasCategory| |#1|
                                (LIST '|InnerEvalable| '(|Symbol|)
                                      (|devaluate| |#1|)))
                            (|HasCategory| |#1|
                                (LIST '|Evalable| (|devaluate| |#1|)))
                            (|HasCategory| |#1|
                                (LIST '|Eltable| (|devaluate| |#1|)
                                      (|devaluate| |#1|)))
                            (|HasCategory| |#1|
                                '(|PartialDifferentialRing| (|Symbol|)))
                            (|HasCategory| |#1| '(|DifferentialRing|))
                            (|HasCategory| |#1|
                                '(|IntegerNumberSystem|))
                            (LETT #0#
                                  (|HasCategory| |#1| '(|GcdDomain|)) . #1#)
                            (OR #0#
                                (|HasCategory| |#1|
                                    '(|UniqueFactorizationDomain|))))) . #1#))
        (|haddProp| |$ConstructorCache| '|Factored| (LIST DV$1)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7
            (|Record| (|:| |unt| |#1|)
                (|:| |fct|
                     (|List| (|Record|
                                 (|:| |flg|
                                      (|Union| "nil" "sqfr" "irred"
                                       "prime"))
                                 (|:| |fctr| |#1|)
                                 (|:| |xpnt| (|Integer|)))))))
        (COND
          ((|testBitVector| |pv$| 4)
           (QSETREFV $ 29
               (CONS (|dispatchFunction| |FR;convert;$If;1|) $))))
        (QSETREFV $ 30 (|HasCategory| |#1| '(|OrderedSet|)))
        (COND
          ((|testBitVector| |pv$| 14)
           (PROGN
             (QSETREFV $ 60
                 (CONS (|dispatchFunction| |FR;rational?;$B;23|) $))
             (QSETREFV $ 64
                 (CONS (|dispatchFunction| |FR;rationalIfCan;$U;24|) $))
             (QSETREFV $ 62
                 (CONS (|dispatchFunction| |FR;rational;$F;25|) $)))))
        (COND
          ((|testBitVector| |pv$| 11)
           (QSETREFV $ 72 (CONS (|dispatchFunction| |FR;elt;3$;26|) $))))
        (COND
          ((|testBitVector| |pv$| 10)
           (QSETREFV $ 81
               (CONS (|dispatchFunction| |FR;eval;$L$;27|) $))))
        (COND
          ((|testBitVector| |pv$| 9)
           (QSETREFV $ 85
               (CONS (|dispatchFunction| |FR;eval;$LL$;28|) $))))
        (COND
          ((|testBitVector| |pv$| 6)
           (PROGN
             (QSETREFV $ 91
                 (CONS (|dispatchFunction| |FR;convert;$F;29|) $))
             (QSETREFV $ 94
                 (CONS (|dispatchFunction| |FR;convert;$Df;30|) $)))))
        (COND
          ((|testBitVector| |pv$| 14)
           (QSETREFV $ 46
               (CONS (|dispatchFunction| |FR;coerce;R$;41|) $)))
          ((|testBitVector| |pv$| 5)
           (QSETREFV $ 46
               (CONS (|dispatchFunction| |FR;coerce;R$;42|) $)))
          ('T
           (QSETREFV $ 46
               (CONS (|dispatchFunction| |FR;coerce;R$;43|) $))))
        (COND
          ((|testBitVector| |pv$| 15)
           (PROGN
             (QSETREFV $ 138
                 (CONS (|dispatchFunction| |FR;+;3$;58|) $))
             (QSETREFV $ 145
                 (CONS (|dispatchFunction| |FR;gcd;3$;59|) $))))
          ('T
           (QSETREFV $ 138 (CONS (|dispatchFunction| |FR;+;3$;60|) $))))
        (COND
          ((|testBitVector| |pv$| 5)
           (QSETREFV $ 150
               (CONS (|dispatchFunction| |FR;prime?;$B;61|) $))))
        $)))) 

(MAKEPROP '|Factored| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep|
             (|Union| '"nil" '"sqfr" '"irred" '"prime")
             (|Record| (|:| |flg| 8) (|:| |fctr| 6) (|:| |xpnt| 27))
             (|List| 9) |FR;factorList;$L;7| |FR;unit;$R;8|
             (|InputForm|) (0 . |convert|) (5 . |One|) (|Boolean|)
             (9 . =) (|Void|) (|String|) (|OutputForm|)
             (15 . |messagePrint|) (|Symbol|) (20 . |coerce|)
             (25 . |convert|) (|List| $) (30 . |binary|) (|Integer|)
             (36 . |convert|) (41 . |convert|) '|orderedR?|
             |FR;flagFactor;RIU$;52| |FR;nilFactor;RI$;2|
             |FR;sqfrFactor;RI$;3| |FR;irreducibleFactor;RI$;4|
             |FR;primeFactor;RI$;5| (46 . |zero?|) |FR;unit?;$B;6|
             (|NonNegativeInteger|) |FR;numberOfFactors;$Nni;9|
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |FR;One;$;12|) $))
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |FR;Zero;$;10|) $))
             (51 . |Zero|) |FR;zero?;$B;11| |FR;one?;$B;13|
             (55 . |coerce|) (60 . |coerce|) |FR;coerce;I$;15|
             (65 . |characteristic|) |FR;characteristic;Nni;16|
             |FR;*;3$;31| |FR;*;I2$;17| |FR;*;R2$;18|
             (|Record| (|:| |factor| 6) (|:| |exponent| 27))
             (|List| 53) |FR;factors;$L;19| |FR;retract;$R;36|
             |FR;expand;$R;20| |FR;unitNormalize;2$;57|
             |FR;makeFR;RL$;22| (69 . |rational?|) (|Fraction| 27)
             (74 . |rational|) (|Union| 61 '"failed")
             (79 . |rationalIfCan|) (84 . |convert|) (89 . |coerce|)
             (94 . **) (100 . *) (106 . |One|) (110 . *) (116 . |elt|)
             (122 . |elt|) (|Equation| $$) (128 . |lhs|) (133 . |rhs|)
             (|Equation| 6) (138 . =) (|List| 76) (144 . |eval|)
             (|List| 151) (150 . |eval|) (|List| 22) (|List| 6)
             (156 . |eval|) (163 . |eval|) (|Float|) (170 . |convert|)
             (175 . **) (181 . *) (187 . |One|) (191 . |convert|)
             (|DoubleFloat|) (196 . |convert|) (201 . |convert|)
             |FR;=;2$B;44| (206 . *) (212 . |copy|) (217 . |concat|)
             (223 . **) (229 . *) |FR;**;$Nni$;32| (|Mapping| 16 9 9)
             (235 . |sort!|) (241 . |list|) (246 . |coerce|)
             (251 . |coerce|) (256 . **) (262 . *) (|Mapping| 20 20 20)
             (|List| 20) (268 . |reduce|) |FR;coerce;$Of;35|
             (|Union| 6 '"failed") |FR;retractIfCan;$U;38| (274 . <)
             (|Factored| 6) (|IntegerFactorizationPackage| 6)
             (280 . |factor|) (285 . |unit?|) (|Factored| $)
             (290 . |squareFree|) (|Set| 53) (295 . |set|) (300 . =)
             (306 . -) |FR;-;2$;45| (|Union| $ '"failed")
             (311 . |recip|) |FR;recip;$U;46| |FR;exponent;$I;48|
             (316 . |minIndex|) (321 . |elt|) |FR;nthExponent;$2I;49|
             |FR;nthFactor;$IR;50| |FR;nthFlag;$IU;51|
             |FR;exquo;2$U;55| (327 . *) (333 . +) (|Mapping| 6 6)
             |FR;differentiate;$M$;53| |FR;map;M2$;54|
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (339 . |unitNormal|) |FR;unitNormal;$R;56| (344 . |gcd|)
             (350 . +) (356 . |maxIndex|) (|List| 27) (361 . |member?|)
             (367 . |prime?|) (|Equation| $)
             (|SparseUnivariatePolynomial| $) (|List| 38)
             (|Union| 27 '"failed") (|PositiveInteger|)
             (|SingleInteger|))
          '#(~= 372 |zero?| 378 |unitNormalize| 383 |unitNormal| 388
             |unitCanonical| 393 |unit?| 398 |unit| 403 |subtractIfCan|
             408 |squareFreePart| 414 |squareFree| 419 |sqfrFactor| 424
             |sample| 430 |retractIfCan| 434 |retract| 449 |recip| 464
             |rationalIfCan| 469 |rational?| 474 |rational| 479
             |primeFactor| 484 |prime?| 490 |one?| 495
             |numberOfFactors| 500 |nthFlag| 505 |nthFactor| 511
             |nthExponent| 517 |nilFactor| 523 |map| 529 |makeFR| 535
             |lcm| 541 |latex| 552 |irreducibleFactor| 557 |hash| 563
             |gcdPolynomial| 568 |gcd| 574 |flagFactor| 585 |factors|
             592 |factorList| 597 |factor| 602 |exquo| 607 |exponent|
             613 |expand| 618 |eval| 623 |elt| 703 |differentiate| 715
             |convert| 765 |coerce| 780 |characteristic| 805
             |associates?| 809 ^ 815 |Zero| 827 |One| 831 D 835 = 885 -
             891 + 902 ** 908 * 920)
          'NIL
          (CONS (|makeByteWordVec2| 16
                    '(5 16 0 0 0 0 0 0 0 0 12 13 0 0 0 0 0 0 0 0 0 0 0
                      0 0 0 0 0 0 0 0 2 6 10 0 0 0 0 0 0 1 2 3 4 6 6 7
                      8 9 10 11))
                (CONS '#(|UniqueFactorizationDomain&| |GcdDomain&|
                         |IntegralDomain&| |Algebra&|
                         |DifferentialExtension&| |Algebra&| NIL
                         |Module&| NIL |Module&|
                         |PartialDifferentialRing&| |DifferentialRing&|
                         NIL NIL |Ring&| NIL NIL NIL NIL NIL
                         |AbelianGroup&| NIL NIL |AbelianMonoid&|
                         |Monoid&| NIL |FullyEvalableOver&|
                         |SemiGroup&| |AbelianSemiGroup&|
                         |FullyRetractableTo&| |SetCategory&|
                         |Evalable&| NIL |Evalable&| |RetractableTo&|
                         NIL NIL NIL |BasicType&| NIL |InnerEvalable&|
                         |InnerEvalable&| NIL NIL NIL NIL
                         |RetractableTo&| |RetractableTo&|
                         |InnerEvalable&| |InnerEvalable&| NIL)
                      (CONS '#((|UniqueFactorizationDomain|)
                               (|GcdDomain|) (|IntegralDomain|)
                               (|Algebra| 6)
                               (|DifferentialExtension| 6)
                               (|Algebra| $$) (|CommutativeRing|)
                               (|Module| 6) (|EntireRing|)
                               (|Module| $$)
                               (|PartialDifferentialRing| 22)
                               (|DifferentialRing|) (|BiModule| 6 6)
                               (|BiModule| $$ $$) (|Ring|)
                               (|RightModule| 6) (|LeftModule| 6)
                               (|LeftModule| $$) (|Rng|)
                               (|RightModule| $$) (|AbelianGroup|)
                               (|CancellationAbelianMonoid|)
                               (|SemiRing|) (|AbelianMonoid|)
                               (|Monoid|) (|SemiRng|)
                               (|FullyEvalableOver| 6) (|SemiGroup|)
                               (|AbelianSemiGroup|)
                               (|FullyRetractableTo| 6) (|SetCategory|)
                               (|Evalable| $$) (|RealConstant|)
                               (|Evalable| 6) (|RetractableTo| 6)
                               (|noZeroDivisors|) (|CommutativeStar|)
                               (|unitsKnown|) (|BasicType|)
                               (|CoercibleTo| 20)
                               (|InnerEvalable| 22 $$)
                               (|InnerEvalable| $$ $$)
                               (|Eltable| $$ $$) (|ConvertibleTo| 13)
                               (|ConvertibleTo| 92)
                               (|ConvertibleTo| 86)
                               (|RetractableTo| 61)
                               (|RetractableTo| 27)
                               (|InnerEvalable| 22 6)
                               (|InnerEvalable| 6 6) (|Eltable| 6 $$))
                            (|makeByteWordVec2| 156
                                '(1 6 13 0 14 0 6 0 15 2 6 16 0 0 17 1
                                  20 18 19 21 1 22 0 19 23 1 13 0 22 24
                                  2 13 0 0 25 26 1 13 0 27 28 1 0 13 0
                                  29 1 6 16 0 36 0 6 0 42 1 6 0 27 45 1
                                  0 0 6 46 0 6 38 48 1 0 16 0 60 1 0 61
                                  0 62 1 0 63 0 64 1 6 27 0 65 1 61 0
                                  27 66 2 61 0 0 27 67 2 61 0 0 0 68 0
                                  61 0 69 2 61 0 27 0 70 2 0 0 0 6 71 2
                                  0 0 0 0 72 1 73 2 0 74 1 73 2 0 75 2
                                  76 0 6 6 77 2 0 0 0 78 79 2 0 0 0 80
                                  81 3 0 0 0 82 83 84 3 0 0 0 82 25 85
                                  1 6 86 0 87 2 86 0 0 27 88 2 86 0 0 0
                                  89 0 86 0 90 1 0 86 0 91 1 6 92 0 93
                                  1 0 92 0 94 2 6 0 0 0 96 1 10 0 0 97
                                  2 10 0 0 0 98 2 6 0 0 38 99 2 27 0 38
                                  0 100 2 10 0 102 0 103 1 10 0 9 104 1
                                  6 20 0 105 1 27 20 0 106 2 20 0 0 0
                                  107 2 20 0 0 0 108 2 110 20 109 0 111
                                  2 6 16 0 0 115 1 117 116 6 118 1 6 16
                                  0 119 1 6 120 0 121 1 122 0 54 123 2
                                  122 16 0 0 124 1 6 0 0 125 1 6 127 0
                                  128 1 10 27 0 131 2 10 9 0 27 132 2 6
                                  0 27 0 137 2 0 0 0 0 138 1 6 142 0
                                  143 2 0 0 0 0 145 2 6 0 0 0 146 1 10
                                  27 0 147 2 148 16 27 0 149 1 0 16 0
                                  150 2 0 16 0 0 1 1 0 16 0 43 1 0 0 0
                                  58 1 0 142 0 144 1 0 0 0 1 1 0 16 0
                                  37 1 0 6 0 12 2 0 127 0 0 1 1 5 0 0 1
                                  1 5 120 0 1 2 0 0 6 27 33 0 0 0 1 1 7
                                  63 0 1 1 8 154 0 1 1 0 113 0 114 1 7
                                  61 0 1 1 8 27 0 1 1 0 6 0 56 1 0 127
                                  0 129 1 14 63 0 64 1 14 16 0 60 1 14
                                  61 0 62 2 0 0 6 27 35 1 5 16 0 150 1
                                  0 16 0 44 1 0 38 0 39 2 0 8 0 27 135
                                  2 0 6 0 27 134 2 0 27 0 27 133 2 0 0
                                  6 27 32 2 0 0 139 0 141 2 0 0 6 10 59
                                  2 15 0 0 0 1 1 15 0 25 1 1 0 19 0 1 2
                                  0 0 6 27 34 1 0 156 0 1 2 15 152 152
                                  152 1 2 15 0 0 0 145 1 15 0 25 1 3 0
                                  0 6 27 8 31 1 0 54 0 55 1 0 10 0 11 1
                                  5 120 0 1 2 0 127 0 0 136 1 0 27 0
                                  130 1 0 6 0 57 3 2 0 0 0 0 1 3 2 0 0
                                  25 25 1 2 2 0 0 151 1 2 2 0 0 80 81 2
                                  10 0 0 78 79 3 10 0 0 6 6 1 2 10 0 0
                                  76 1 3 10 0 0 83 83 1 3 1 0 0 82 25
                                  85 3 1 0 0 22 0 1 3 9 0 0 22 6 1 3 9
                                  0 0 82 83 84 2 3 0 0 0 72 2 11 0 0 6
                                  71 2 13 0 0 38 1 1 13 0 0 1 3 12 0 0
                                  82 153 1 2 12 0 0 82 1 3 12 0 0 22 38
                                  1 2 12 0 0 22 1 2 0 0 0 139 140 3 0 0
                                  0 139 38 1 1 4 13 0 29 1 6 92 0 94 1
                                  6 86 0 91 1 7 0 61 1 1 0 0 6 46 1 0 0
                                  0 1 1 0 0 27 47 1 0 20 0 112 0 0 38
                                  49 2 0 16 0 0 1 2 0 0 0 38 1 2 0 0 0
                                  155 1 0 0 0 41 0 0 0 40 2 13 0 0 38 1
                                  1 13 0 0 1 3 12 0 0 22 38 1 3 12 0 0
                                  82 153 1 2 12 0 0 22 1 2 12 0 0 82 1
                                  3 0 0 0 139 38 1 2 0 0 0 139 1 2 0 16
                                  0 0 95 2 0 0 0 0 1 1 0 0 0 126 2 0 0
                                  0 0 138 2 0 0 0 38 101 2 0 0 0 155 1
                                  2 0 0 0 6 1 2 0 0 6 0 52 2 0 0 0 0 50
                                  2 0 0 27 0 51 2 0 0 38 0 1 2 0 0 155
                                  0 1)))))
          '|lookupComplete|)) 
