
(/VERSIONCHECK 2) 

(DEFUN |FR;convert;$If;1| (|x| $)
  (PROG (|l| |iFun| |iExpon| |iFactor| #1=#:G1903 |rec| |lf|)
    (RETURN
     (SEQ
      (COND
       ((NULL
         (LETT |lf| (REVERSE (SPADCALL |x| (QREFELT $ 11)))
               . #2=(|FR;convert;$If;1|)))
        (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 14)))
       (#3='T
        (SEQ (LETT |l| NIL . #2#)
             (SEQ (LETT |rec| NIL . #2#) (LETT #1# |lf| . #2#) G190
                  (COND
                   ((OR (ATOM #1#) (PROGN (LETT |rec| (CAR #1#) . #2#) 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 '|::| (QREFELT $ 23))
                                       (LIST
                                        (SPADCALL (QVELT |rec| 1)
                                                  (QREFELT $ 14))
                                        (|devaluate| (QREFELT $ 6)))
                                       (QREFELT $ 25))
                             . #2#)
                       (LETT |iExpon| (SPADCALL (QVELT |rec| 2) (QREFELT $ 27))
                             . #2#)
                       (LETT |iFun|
                             (COND
                              ((QEQCAR (QVELT |rec| 0) 0)
                               (LIST (SPADCALL '|nilFactor| (QREFELT $ 23))
                                     |iFactor| |iExpon|))
                              ((QEQCAR (QVELT |rec| 0) 1)
                               (LIST (SPADCALL '|sqfrFactor| (QREFELT $ 23))
                                     |iFactor| |iExpon|))
                              ((QEQCAR (QVELT |rec| 0) 3)
                               (LIST (SPADCALL '|primeFactor| (QREFELT $ 23))
                                     |iFactor| |iExpon|))
                              ((QEQCAR (QVELT |rec| 0) 2)
                               (LIST
                                (SPADCALL '|irreducibleFactor| (QREFELT $ 23))
                                |iFactor| |iExpon|))
                              ('T NIL))
                             . #2#)
                       (EXIT (LETT |l| (CONS |iFun| |l|) . #2#)))))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
             (EXIT
              (COND
               ((NULL |l|)
                (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 14)))
               (#3#
                (SEQ
                 (COND
                  ((NULL
                    (SPADCALL (SPADCALL |x| (QREFELT $ 12))
                              (|spadConstant| $ 15) (QREFELT $ 17)))
                   (LETT |l|
                         (CONS
                          (SPADCALL (SPADCALL |x| (QREFELT $ 12))
                                    (QREFELT $ 14))
                          |l|)
                         . #2#)))
                 (EXIT
                  (COND ((NULL (CDR |l|)) (|SPADfirst| |l|))
                        (#3#
                         (SPADCALL (SPADCALL '* (QREFELT $ 23)) |l|
                                   (QREFELT $ 25)))))))))))))))) 

(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) (#1='T 'T)))
   (#1# '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)))
       (#1='T 'NIL)))
     (#1# 'NIL)))
   (#1# '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 (#1=#:G1981 |fe| #2=#:G1980)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|FR;factors;$L;19|))
       (SEQ (LETT |fe| NIL . #3#)
            (LETT #1# (SPADCALL |u| (QREFELT $ 11)) . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |fe| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #2# (CONS (CONS (QVELT |fe| 1) (QVELT |fe| 2)) #2#)
                    . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

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

(DEFUN |FR;negexp?| (|x| $)
  (PROG (#1=#:G1985 #2=#:G1984 #3=#:G1986 #4=#:G1988 |y|)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #5=(|FR;negexp?|))
       (SEQ (LETT |y| NIL . #5#) (LETT #4# (SPADCALL |x| (QREFELT $ 11)) . #5#)
            G190
            (COND
             ((OR (ATOM #4#) (PROGN (LETT |y| (CAR #4#) . #5#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (PROGN
               (LETT #3# (MINUSP (QVELT |y| 2)) . #5#)
               (COND (#1# (LETT #2# (COND (#2# 'T) ('T #3#)) . #5#))
                     ('T (PROGN (LETT #2# #3# . #5#) (LETT #1# 'T . #5#)))))))
            (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL))
       (COND (#1# #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 (#1=#:G2004 #2=#:G2003 #3=#:G2005 #4=#:G2007 |f|)
    (RETURN
     (SEQ
      (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 65))
                (PROGN
                 (LETT #1# NIL . #5=(|FR;rational;$F;25|))
                 (SEQ (LETT |f| NIL . #5#)
                      (LETT #4# (SPADCALL |x| (QREFELT $ 11)) . #5#) G190
                      (COND
                       ((OR (ATOM #4#) (PROGN (LETT |f| (CAR #4#) . #5#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (PROGN
                         (LETT #3#
                               (SPADCALL
                                (SPADCALL
                                 (SPADCALL (QVELT |f| 1) (QREFELT $ 65))
                                 (QREFELT $ 66))
                                (QVELT |f| 2) (QREFELT $ 67))
                               . #5#)
                         (COND
                          (#1#
                           (LETT #2# (SPADCALL #2# #3# (QREFELT $ 68)) . #5#))
                          ('T
                           (PROGN
                            (LETT #2# #3# . #5#)
                            (LETT #1# 'T . #5#)))))))
                      (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL))
                 (COND (#1# #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 (#1=#:G2012 |e| #2=#:G2011)
    (RETURN
     (SEQ
      (SPADCALL |x|
                (PROGN
                 (LETT #2# NIL . #3=(|FR;eval;$L$;27|))
                 (SEQ (LETT |e| NIL . #3#) (LETT #1# |l| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |e| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #2#
                              (CONS
                               (SPADCALL
                                (SPADCALL (SPADCALL |e| (QREFELT $ 74))
                                          (QREFELT $ 57))
                                (SPADCALL (SPADCALL |e| (QREFELT $ 75))
                                          (QREFELT $ 57))
                                (QREFELT $ 77))
                               #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                (QREFELT $ 79)))))) 

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

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

(DEFUN |FR;convert;$Df;30| (|x| $)
  (PROG (#1=#:G2035 #2=#:G2034 #3=#:G2036 #4=#:G2038 |f|)
    (RETURN
     (SEQ
      (MUL-DF (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 93))
              (PROGN
               (LETT #1# NIL . #5=(|FR;convert;$Df;30|))
               (SEQ (LETT |f| NIL . #5#)
                    (LETT #4# (SPADCALL |x| (QREFELT $ 11)) . #5#) G190
                    (COND
                     ((OR (ATOM #4#) (PROGN (LETT |f| (CAR #4#) . #5#) NIL))
                      (GO G191)))
                    (SEQ
                     (EXIT
                      (PROGN
                       (LETT #3#
                             (EXPT-DF-I (SPADCALL (QVELT |f| 1) (QREFELT $ 93))
                                        (QVELT |f| 2))
                             . #5#)
                       (COND (#1# (LETT #2# (MUL-DF #2# #3#) . #5#))
                             ('T
                              (PROGN
                               (LETT #2# #3# . #5#)
                               (LETT #1# 'T . #5#)))))))
                    (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL))
               (COND (#1# #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 (#1=#:G2061 |x| #2=#:G2060)
    (RETURN
     (SEQ
      (|FR;mkFF| (SPADCALL (SPADCALL |u| (QREFELT $ 12)) |n| (QREFELT $ 99))
       (PROGN
        (LETT #2# NIL . #3=(|FR;^;$Nni$;32|))
        (SEQ (LETT |x| NIL . #3#)
             (LETT #1# (SPADCALL |u| (QREFELT $ 11)) . #3#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (LETT #2#
                     (CONS
                      (VECTOR (QVELT |x| 0) (QVELT |x| 1)
                              (SPADCALL |n| (QVELT |x| 2) (QREFELT $ 100)))
                      #2#)
                     . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       $))))) 

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

(DEFUN |FR;SimplifyFactorization1| (|f| |x| $)
  (PROG (|l| |f1|)
    (RETURN
     (SEQ
      (COND
       ((NULL |x|)
        (COND ((ZEROP (QVELT |f| 2)) NIL)
              (#1='T (SPADCALL |f| (QREFELT $ 104)))))
       (#1#
        (SEQ (LETT |f1| (|SPADfirst| |x|) . #2=(|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|) $))
               (#1#
                (SEQ
                 (LETT |l|
                       (|FR;SimplifyFactorization1| (|SPADfirst| |x|) (CDR |x|)
                        $)
                       . #2#)
                 (EXIT
                  (COND ((ZEROP (QVELT |f| 2)) |l|)
                        (#1# (CONS |f| |l|))))))))))))))) 

(DEFUN |FR;coerce;$Of;35| (|x| $)
  (PROG (|e| |l| #1=#:G2100 |rec| |lf|)
    (RETURN
     (SEQ
      (COND
       ((NULL
         (LETT |lf| (REVERSE (SPADCALL |x| (QREFELT $ 11)))
               . #2=(|FR;coerce;$Of;35|)))
        (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 105)))
       (#3='T
        (SEQ (LETT |l| NIL . #2#)
             (SEQ (LETT |rec| NIL . #2#) (LETT #1# |lf| . #2#) G190
                  (COND
                   ((OR (ATOM #1#) (PROGN (LETT |rec| (CAR #1#) . #2#) 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|)
                            . #2#))
                     ('T
                      (LETT |l|
                            (CONS
                             (SPADCALL
                              (SPADCALL (QVELT |rec| 1) (QREFELT $ 105))
                              (SPADCALL (QVELT |rec| 2) (QREFELT $ 106))
                              (QREFELT $ 107))
                             |l|)
                            . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
             (EXIT
              (COND
               ((NULL |l|)
                (SPADCALL (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 105)))
               (#3#
                (SEQ
                 (LETT |e|
                       (COND ((NULL (CDR |l|)) (|SPADfirst| |l|))
                             (#3# (SPADCALL (ELT $ 108) |l| (QREFELT $ 111))))
                       . #2#)
                 (EXIT
                  (COND
                   ((SPADCALL (|spadConstant| $ 15)
                              (SPADCALL |x| (QREFELT $ 12)) (QREFELT $ 17))
                    |e|)
                   (#3#
                    (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 (#1=#:G2105 #2=#:G2104 #3=#:G2106 #4=#:G2108 #5=#:G2110 |y|)
    (RETURN
     (SEQ
      (SPADCALL (SPADCALL |u| (QREFELT $ 12))
                (PROGN
                 (LETT #1# NIL . #6=(|FR;qexpand|))
                 (SEQ (LETT |y| NIL . #6#)
                      (LETT #5# (SPADCALL |u| (QREFELT $ 11)) . #6#) G190
                      (COND
                       ((OR (ATOM #5#) (PROGN (LETT |y| (CAR #5#) . #6#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (PROGN
                         (LETT #3#
                               (SPADCALL (QVELT |y| 1)
                                         (PROG1 (LETT #4# (QVELT |y| 2) . #6#)
                                           (|check-subtype| (>= #4# 0)
                                                            '(|NonNegativeInteger|)
                                                            #4#))
                                         (QREFELT $ 99))
                               . #6#)
                         (COND
                          (#1#
                           (LETT #2# (SPADCALL #2# #3# (QREFELT $ 96)) . #6#))
                          ('T
                           (PROGN
                            (LETT #2# #3# . #6#)
                            (LETT #1# 'T . #6#)))))))
                      (LETT #5# (CDR #5#) . #6#) (GO G190) G191 (EXIT NIL))
                 (COND (#1# #2#) ('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 $ 29) (SPADCALL (QVELT |y| 1) (QVELT |y1| 1) (QREFELT $ 115)))
   ((QREFELT $ 30) (SPADCALL (QVELT |y| 1) (QVELT |y1| 1) (QREFELT $ 116)))
   (#1='T (COND ((GGREATERP (QVELT |y| 1) (QVELT |y1| 1)) 'NIL) (#1# 'T))))) 

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

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

(DEFUN |FR;coerce;R$;42| (|r| $)
  (COND ((SPADCALL |r| (QREFELT $ 36)) (|spadConstant| $ 41))
        ((SPADCALL |r| (QREFELT $ 120)) (|FR;mkFF| |r| NIL $))
        ((|HasCategory| (QREFELT $ 6) '(|Field|))
         (|error| "zero divisor in a field"))
        ('T (SPADCALL (SPADCALL |r| (QREFELT $ 122)) (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 $ 124))
                (SPADCALL (SPADCALL |v| (QREFELT $ 55)) (QREFELT $ 124))
                (QREFELT $ 125)))
     (#1='T 'NIL)))
   (#1# 'NIL))) 

(DEFUN |FR;-;2$;45| (|u| $)
  (COND ((SPADCALL |u| (QREFELT $ 43)) |u|)
        ('T
         (|FR;mkFF| (SPADCALL (SPADCALL |u| (QREFELT $ 12)) (QREFELT $ 126))
          (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 $ 129))
                    |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 (#1=#:G2192 |y| #2=#:G2191 #3=#:G2181)
    (RETURN
     (SEQ
      (|FR;mkFF|
       (PROG2
           (LETT #3# (SPADCALL (SPADCALL |u| (QREFELT $ 12)) (QREFELT $ 129))
                 . #4=(|FR;reciprocal|))
           (QCDR #3#)
         (|check-union| (QEQCAR #3# 0) (QREFELT $ 6) #3#))
       (PROGN
        (LETT #2# NIL . #4#)
        (SEQ (LETT |y| NIL . #4#)
             (LETT #1# (SPADCALL |u| (QREFELT $ 11)) . #4#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |y| (CAR #1#) . #4#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (LETT #2#
                     (CONS
                      (VECTOR (QVELT |y| 0) (QVELT |y| 1) (- (QVELT |y| 2)))
                      #2#)
                     . #4#)))
             (LETT #1# (CDR #1#) . #4#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       $))))) 

(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 $ 132)) |i|) 1)
                      (QREFELT $ 133))
            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 $ 132)) |i|) 1)
                          (QREFELT $ 133))
                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 $ 132)) |i|) 1)
                      (QREFELT $ 133))
            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 (#1=#:G2238 #2=#:G2237 #3=#:G2239 #4=#:G2234 #5=#:G2243 |fact| |ans|)
    (RETURN
     (SEQ
      (LETT |ans|
            (SPADCALL (SPADCALL (SPADCALL |u| (QREFELT $ 12)) |deriv|)
                      (PROG2
                          (LETT #4#
                                (SPADCALL |u|
                                          (SPADCALL
                                           (SPADCALL |u| (QREFELT $ 12))
                                           (QREFELT $ 46))
                                          (QREFELT $ 137))
                                . #6=(|FR;differentiate;$M$;53|))
                          (QCDR #4#)
                        (|check-union| (QEQCAR #4# 0) $ #4#))
                      (QREFELT $ 52))
            . #6#)
      (EXIT
       (SPADCALL |ans|
                 (PROGN
                  (LETT #1# NIL . #6#)
                  (SEQ (LETT |fact| NIL . #6#)
                       (LETT #5# (SPADCALL |u| (QREFELT $ 11)) . #6#) G190
                       (COND
                        ((OR (ATOM #5#)
                             (PROGN (LETT |fact| (CAR #5#) . #6#) NIL))
                         (GO G191)))
                       (SEQ
                        (EXIT
                         (PROGN
                          (LETT #3#
                                (SPADCALL
                                 (SPADCALL (QVELT |fact| 2)
                                           (SPADCALL (QVELT |fact| 1) |deriv|)
                                           (QREFELT $ 138))
                                 (PROG2
                                     (LETT #4#
                                           (SPADCALL |u|
                                                     (SPADCALL (QVELT |fact| 1)
                                                               1
                                                               (QREFELT $ 32))
                                                     (QREFELT $ 137))
                                           . #6#)
                                     (QCDR #4#)
                                   (|check-union| (QEQCAR #4# 0) $ #4#))
                                 (QREFELT $ 52))
                                . #6#)
                          (COND
                           (#1#
                            (LETT #2# (SPADCALL #2# #3# (QREFELT $ 139))
                                  . #6#))
                           ('T
                            (PROGN
                             (LETT #2# #3# . #6#)
                             (LETT #1# 'T . #6#)))))))
                       (LETT #5# (CDR #5#) . #6#) (GO G190) G191 (EXIT NIL))
                  (COND (#1# #2#) ('T (|spadConstant| $ 41))))
                 (QREFELT $ 139))))))) 

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

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

(DEFUN |FR;unitNormal;$R;56| (|u| $)
  (PROG (|vl| |as| |un| |e| #1=#:G2272 |ucar| #2=#:G2287 |x| |ur|)
    (RETURN
     (SEQ
      (LETT |ur|
            (SPADCALL
             (LETT |un| (SPADCALL |u| (QREFELT $ 12))
                   . #3=(|FR;unitNormal;$R;56|))
             (QREFELT $ 129))
            . #3#)
      (EXIT
       (COND
        ((QEQCAR |ur| 1)
         (VECTOR (|spadConstant| $ 40) |u| (|spadConstant| $ 40)))
        ('T
         (SEQ (LETT |as| (QCDR |ur|) . #3#) (LETT |vl| NIL . #3#)
              (SEQ (LETT |x| NIL . #3#)
                   (LETT #2# (SPADCALL |u| (QREFELT $ 11)) . #3#) G190
                   (COND
                    ((OR (ATOM #2#) (PROGN (LETT |x| (CAR #2#) . #3#) NIL))
                     (GO G191)))
                   (SEQ
                    (LETT |ucar| (SPADCALL (QVELT |x| 1) (QREFELT $ 144))
                          . #3#)
                    (LETT |e|
                          (PROG1 (LETT #1# (ABS (QVELT |x| 2)) . #3#)
                            (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                             #1#))
                          . #3#)
                    (COND
                     ((< (QVELT |x| 2) 0)
                      (SEQ
                       (LETT |un|
                             (SPADCALL |un|
                                       (SPADCALL (QVELT |ucar| 2) |e|
                                                 (QREFELT $ 99))
                                       (QREFELT $ 96))
                             . #3#)
                       (EXIT
                        (LETT |as|
                              (SPADCALL |as|
                                        (SPADCALL (QVELT |ucar| 0) |e|
                                                  (QREFELT $ 99))
                                        (QREFELT $ 96))
                              . #3#))))
                     ('T
                      (SEQ
                       (LETT |un|
                             (SPADCALL |un|
                                       (SPADCALL (QVELT |ucar| 0) |e|
                                                 (QREFELT $ 99))
                                       (QREFELT $ 96))
                             . #3#)
                       (EXIT
                        (LETT |as|
                              (SPADCALL |as|
                                        (SPADCALL (QVELT |ucar| 2) |e|
                                                  (QREFELT $ 99))
                                        (QREFELT $ 96))
                              . #3#)))))
                    (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|)
                             . #3#)))))
                   (LETT #2# (CDR #2#) . #3#) (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 $ 145)) |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 (|v1| |u1|)
    (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 $ 146))
                           . #1=(|FR;+;3$;58|))
                     $)
                    . #1#)
              (EXIT
               (SPADCALL
                (SPADCALL
                 (SPADCALL (SPADCALL |u| |v1| (QREFELT $ 50)) (QREFELT $ 57))
                 (SPADCALL (SPADCALL |v| |v1| (QREFELT $ 50)) (QREFELT $ 57))
                 (QREFELT $ 147))
                |u1| (QREFELT $ 52)))))))))) 

(DEFUN |FR;gcd;3$;59| (|u| |v| $)
  (PROG (|x1| |f3| |f1| |i| |y| |f2| #1=#:G2323 |j| #2=#:G2322 |x|)
    (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 . #3=(|FR;gcd;3$;59|))
                    (LETT |f2| |f1| . #3#) (LETT |f3| NIL . #3#)
                    (LETT |x|
                          (SPADCALL (SPADCALL |u| (QREFELT $ 11))
                                    (SPADCALL |v| (QREFELT $ 11))
                                    (QREFELT $ 98))
                          . #3#)
                    (SEQ (LETT |i| (SPADCALL |x| (QREFELT $ 132)) . #3#)
                         (LETT #2# (SPADCALL |x| (QREFELT $ 148)) . #3#) G190
                         (COND ((> |i| #2#) #4=(GO G191)))
                         (SEQ
                          (EXIT
                           (COND
                            ((NULL (SPADCALL |i| |f1| (QREFELT $ 150)))
                             (SEQ (LETT |f1| (CONS |i| |f1|) . #3#)
                                  (LETT |f2| (LIST |i|) . #3#)
                                  (SEQ (LETT |j| (+ |i| 1) . #3#)
                                       (LETT #1# (SPADCALL |x| (QREFELT $ 148))
                                             . #3#)
                                       G190 (COND ((> |j| #1#) #4#))
                                       (SEQ
                                        (EXIT
                                         (COND
                                          ((SPADCALL
                                            (QVELT
                                             (SPADCALL |x| |i| (QREFELT $ 133))
                                             1)
                                            (QVELT
                                             (SPADCALL |x| |j| (QREFELT $ 133))
                                             1)
                                            (QREFELT $ 17))
                                           (SEQ
                                            (LETT |f1| (CONS |j| |f1|) . #3#)
                                            (EXIT
                                             (LETT |f2| (CONS |j| |f2|)
                                                   . #3#)))))))
                                       (LETT |j| (+ |j| 1) . #3#) #5=(GO G190)
                                       G191 (EXIT NIL))
                                  (EXIT
                                   (LETT |f3| (CONS |f2| |f3|) . #3#)))))))
                         (LETT |i| (+ |i| 1) . #3#) #5# G191 (EXIT NIL))
                    (LETT |x1| NIL . #3#)
                    (SEQ G190
                         (COND ((NULL (COND ((NULL |f3|) 'NIL) ('T 'T))) #4#))
                         (SEQ (LETT |f1| (|SPADfirst| |f3|) . #3#)
                              (COND
                               ((< 1 (LENGTH |f1|))
                                (SEQ (LETT |i| (|SPADfirst| |f1|) . #3#)
                                     (LETT |y|
                                           (MOVEVEC (MAKE-VEC 3)
                                                    (SPADCALL |x| |i|
                                                              (QREFELT $ 133)))
                                           . #3#)
                                     (LETT |f1| (CDR |f1|) . #3#)
                                     (SEQ G190
                                          (COND
                                           ((NULL
                                             (COND ((NULL |f1|) 'NIL) ('T 'T)))
                                            #4#))
                                          (SEQ
                                           (LETT |i| (|SPADfirst| |f1|) . #3#)
                                           (COND
                                            ((<
                                              (QVELT
                                               (SPADCALL |x| |i|
                                                         (QREFELT $ 133))
                                               2)
                                              (QVELT |y| 2))
                                             (QSETVELT |y| 2
                                                       (QVELT
                                                        (SPADCALL |x| |i|
                                                                  (QREFELT $
                                                                           133))
                                                        2))))
                                           (EXIT (LETT |f1| (CDR |f1|) . #3#)))
                                          NIL #5# G191 (EXIT NIL))
                                     (EXIT
                                      (LETT |x1| (CONS |y| |x1|) . #3#)))))
                              (EXIT (LETT |f3| (CDR |f3|) . #3#)))
                         NIL #5# G191 (EXIT NIL))
                    (COND
                     ((QREFELT $ 30)
                      (LETT |x1|
                            (SPADCALL (CONS (|function| |FR;LispLessP|) $) |x1|
                                      (QREFELT $ 103))
                            . #3#)))
                    (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 $ 147))
          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| (#1=#:G2347)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2348)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|Factored|)
                                           '|domainEqualList|)
                . #3=(|Factored|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|Factored;| #1#) (LETT #2# T . #3#))
            (COND ((NOT #2#) (HREM |$ConstructorCache| '|Factored|))))))))))) 

(DEFUN |Factored;| (|#1|)
  (PROG (|pv$| #1=#:G2346 $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #2=(|Factored|))
      (LETT |dv$| (LIST '|Factored| DV$1) . #2#)
      (LETT $ (GETREFV 158) . #2#)
      (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 #1#
                                                (|HasCategory| |#1|
                                                               '(|GcdDomain|))
                                                . #2#)
                                          (OR #1#
                                              (|HasCategory| |#1|
                                                             '(|UniqueFactorizationDomain|)))))
                      . #2#))
      (|haddProp| |$ConstructorCache| '|Factored| (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 7
                (|Record| (|:| |unt| |#1|)
                          (|:| |fct|
                               (|List|
                                (|Record|
                                 (|:| |flg|
                                      (|Union| "nil" "sqfr" "irred" "prime"))
                                 (|:| |fctr| |#1|)
                                 (|:| |xpnt| (|Integer|)))))))
      (COND
       ((|testBitVector| |pv$| 4)
        (QSETREFV $ 28 (CONS (|dispatchFunction| |FR;convert;$If;1|) $))))
      (QSETREFV $ 29 (|HasCategory| |#1| '(|OrderedSet|)))
      (QSETREFV $ 30 (|HasCategory| |#1| '(|Comparable|)))
      (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 $ 139 (CONS (|dispatchFunction| |FR;+;3$;58|) $))
         (QSETREFV $ 146 (CONS (|dispatchFunction| |FR;gcd;3$;59|) $))))
       ('T (QSETREFV $ 139 (CONS (|dispatchFunction| |FR;+;3$;60|) $))))
      (COND
       ((|testBitVector| |pv$| 5)
        (QSETREFV $ 151 (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| 26))
              (|List| 9) |FR;factorList;$L;7| |FR;unit;$R;8| (|InputForm|)
              (0 . |convert|) (5 . |One|) (|Boolean|) (9 . =) (|Void|)
              (|String|) (|OutputForm|) (15 . |messagePrint|) (|Symbol|)
              (20 . |convert|) (|List| $) (25 . |binary|) (|Integer|)
              (31 . |convert|) (36 . |convert|) '|orderedR?| '|comparableR?|
              |FR;flagFactor;RIU$;52| |FR;nilFactor;RI$;2|
              |FR;sqfrFactor;RI$;3| |FR;irreducibleFactor;RI$;4|
              |FR;primeFactor;RI$;5| (41 . |zero?|) |FR;unit?;$B;6|
              (|NonNegativeInteger|) |FR;numberOfFactors;$Nni;9|
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |FR;One;$;12|) $))
              (CONS IDENTITY (FUNCALL (|dispatchFunction| |FR;Zero;$;10|) $))
              (46 . |Zero|) |FR;zero?;$B;11| |FR;one?;$B;13| (50 . |coerce|)
              (55 . |coerce|) |FR;coerce;I$;15| (60 . |characteristic|)
              |FR;characteristic;Nni;16| |FR;*;3$;31| |FR;*;I2$;17|
              |FR;*;R2$;18| (|Record| (|:| |factor| 6) (|:| |exponent| 26))
              (|List| 53) |FR;factors;$L;19| |FR;retract;$R;36|
              |FR;expand;$R;20| |FR;unitNormalize;2$;57| |FR;makeFR;RL$;22|
              (64 . |rational?|) (|Fraction| 26) (69 . |rational|)
              (|Union| 61 '"failed") (74 . |rationalIfCan|) (79 . |convert|)
              (84 . |coerce|) (89 . ^) (95 . *) (101 . |One|) (105 . *)
              (111 . |elt|) (117 . |elt|) (|Equation| $$) (123 . |lhs|)
              (128 . |rhs|) (|Equation| 6) (133 . =) (|List| 76) (139 . |eval|)
              (|List| 152) (145 . |eval|) (|List| 22) (|List| 6) (151 . |eval|)
              (158 . |eval|) (|Float|) (165 . |convert|) (170 . ^) (176 . *)
              (182 . |One|) (186 . |convert|) (|DoubleFloat|) (191 . |convert|)
              (196 . |convert|) |FR;=;2$B;44| (201 . *) (207 . |copy|)
              (212 . |concat|) (218 . ^) (224 . *) |FR;^;$Nni$;32|
              (|Mapping| 16 9 9) (230 . |sort!|) (236 . |list|)
              (241 . |coerce|) (246 . |coerce|) (251 . ^) (257 . *)
              (|Mapping| 20 20 20) (|List| 20) (263 . |reduce|)
              |FR;coerce;$Of;35| (|Union| 6 '"failed") |FR;retractIfCan;$U;38|
              (269 . <) (275 . |smaller?|) (|Factored| 6)
              (|IntegerFactorizationPackage| 6) (281 . |factor|)
              (286 . |unit?|) (|Factored| $) (291 . |squareFree|) (|Set| 53)
              (296 . |set|) (301 . =) (307 . -) |FR;-;2$;45|
              (|Union| $ '"failed") (312 . |recip|) |FR;recip;$U;46|
              |FR;exponent;$I;48| (317 . |minIndex|) (322 . |elt|)
              |FR;nthExponent;$2I;49| |FR;nthFactor;$IR;50| |FR;nthFlag;$IU;51|
              |FR;exquo;2$U;55| (328 . *) (334 . +) (|Mapping| 6 6)
              |FR;differentiate;$M$;53| |FR;map;M2$;54|
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (340 . |unitNormal|) |FR;unitNormal;$R;56| (345 . |gcd|)
              (351 . +) (357 . |maxIndex|) (|List| 26) (362 . |member?|)
              (368 . |prime?|) (|Equation| $) (|SparseUnivariatePolynomial| $)
              (|List| 38) (|Union| 26 '"failed") (|PositiveInteger|)
              (|SingleInteger|))
           '#(~= 373 |zero?| 379 |unitNormalize| 384 |unitNormal| 389
              |unitCanonical| 394 |unit?| 399 |unit| 404 |subtractIfCan| 409
              |squareFreePart| 415 |squareFree| 420 |sqfrFactor| 425 |sample|
              431 |retractIfCan| 435 |retract| 450 |recip| 465 |rationalIfCan|
              470 |rational?| 475 |rational| 480 |primeFactor| 485 |prime?| 491
              |one?| 496 |numberOfFactors| 501 |nthFlag| 506 |nthFactor| 512
              |nthExponent| 518 |nilFactor| 524 |map| 530 |makeFR| 536 |lcm|
              542 |latex| 553 |irreducibleFactor| 558 |hash| 564
              |gcdPolynomial| 569 |gcd| 575 |flagFactor| 586 |factors| 593
              |factorList| 598 |factor| 603 |exquo| 608 |exponent| 614 |expand|
              619 |eval| 624 |elt| 704 |differentiate| 716 |convert| 766
              |coerce| 781 |characteristic| 806 |associates?| 810 ^ 816 |Zero|
              828 |One| 832 D 836 = 886 - 892 + 903 * 909)
           '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| 26) (|InnerEvalable| 22 6)
                 (|InnerEvalable| 6 6) (|Eltable| 6 $$))
              (|makeByteWordVec2| 157
                                  '(1 6 13 0 14 0 6 0 15 2 6 16 0 0 17 1 20 18
                                    19 21 1 13 0 22 23 2 13 0 0 24 25 1 13 0 26
                                    27 1 0 13 0 28 1 6 16 0 36 0 6 0 42 1 6 0
                                    26 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 26 0 65 1 61 0 26
                                    66 2 61 0 0 26 67 2 61 0 0 0 68 0 61 0 69 2
                                    61 0 26 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 24 85 1 6 86 0 87 2 86 0 0 26 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 26 0 38 0 100 2 10 0
                                    102 0 103 1 10 0 9 104 1 6 20 0 105 1 26 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 2 6 16 0 0 116
                                    1 118 117 6 119 1 6 16 0 120 1 6 121 0 122
                                    1 123 0 54 124 2 123 16 0 0 125 1 6 0 0 126
                                    1 6 128 0 129 1 10 26 0 132 2 10 9 0 26 133
                                    2 6 0 26 0 138 2 0 0 0 0 139 1 6 143 0 144
                                    2 0 0 0 0 146 2 6 0 0 0 147 1 10 26 0 148 2
                                    149 16 26 0 150 1 0 16 0 151 2 0 16 0 0 1 1
                                    0 16 0 43 1 0 0 0 58 1 0 143 0 145 1 0 0 0
                                    1 1 0 16 0 37 1 0 6 0 12 2 0 128 0 0 1 1 5
                                    0 0 1 1 5 121 0 1 2 0 0 6 26 33 0 0 0 1 1 7
                                    63 0 1 1 8 155 0 1 1 0 113 0 114 1 7 61 0 1
                                    1 8 26 0 1 1 0 6 0 56 1 0 128 0 130 1 14 63
                                    0 64 1 14 16 0 60 1 14 61 0 62 2 0 0 6 26
                                    35 1 5 16 0 151 1 0 16 0 44 1 0 38 0 39 2 0
                                    8 0 26 136 2 0 6 0 26 135 2 0 26 0 26 134 2
                                    0 0 6 26 32 2 0 0 140 0 142 2 0 0 6 10 59 2
                                    15 0 0 0 1 1 15 0 24 1 1 0 19 0 1 2 0 0 6
                                    26 34 1 0 157 0 1 2 15 153 153 153 1 2 15 0
                                    0 0 146 1 15 0 24 1 3 0 0 6 26 8 31 1 0 54
                                    0 55 1 0 10 0 11 1 5 121 0 1 2 0 128 0 0
                                    137 1 0 26 0 131 1 0 6 0 57 2 2 0 0 152 1 2
                                    2 0 0 80 81 3 2 0 0 0 0 1 3 2 0 0 24 24 1 2
                                    10 0 0 76 1 2 10 0 0 78 79 3 10 0 0 6 6 1 3
                                    10 0 0 83 83 1 3 1 0 0 22 0 1 3 1 0 0 82 24
                                    85 3 9 0 0 82 83 84 3 9 0 0 22 6 1 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 154 1 3 12 0 0 22 38 1 2 12 0 0
                                    22 1 2 12 0 0 82 1 2 0 0 0 140 141 3 0 0 0
                                    140 38 1 1 4 13 0 28 1 6 86 0 91 1 6 92 0
                                    94 1 7 0 61 1 1 0 0 6 46 1 0 0 0 1 1 0 0 26
                                    47 1 0 20 0 112 0 0 38 49 2 0 16 0 0 1 2 0
                                    0 0 38 101 2 0 0 0 156 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 154 1 2 12 0 0 82 1 2 12 0 0 22 1
                                    2 0 0 0 140 1 3 0 0 0 140 38 1 2 0 16 0 0
                                    95 2 0 0 0 0 1 1 0 0 0 127 2 0 0 0 0 139 2
                                    0 0 0 6 1 2 0 0 6 0 52 2 0 0 0 0 50 2 0 0
                                    26 0 51 2 0 0 38 0 1 2 0 0 156 0 1)))))
           '|lookupComplete|)) 
