
(/VERSIONCHECK 2) 

(DEFUN |PFO;torsion?;FdB;1| (|d| $)
  (QEQCAR (SPADCALL |d| (QREFELT $ 18)) 0)) 

(DEFUN |PFO;Q2F| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 23)) (QREFELT $ 24))
      (SPADCALL (SPADCALL |x| (QREFELT $ 25)) (QREFELT $ 24))
      (QREFELT $ 26))) 

(DEFUN |PFO;qmod| (|x| $) (SPADCALL |x| (QREFELT $ 27))) 

(DEFUN |PFO;kqmod| (|x| |k| $) (SPADCALL |x| |k| (QREFELT $ 30))) 

(DEFUN |PFO;fmod| (|p| $)
  (SPADCALL (CONS (|function| |PFO;qmod|) $) |p| (QREFELT $ 34))) 

(DEFUN |PFO;pmod| (|p| $)
  (SPADCALL (CONS (|function| |PFO;qmod|) $) |p| (QREFELT $ 37))) 

(DEFUN |PFO;Q2UPUP| (|p| $)
  (SPADCALL (CONS (|function| |PFO;Q2F|) $) |p| (QREFELT $ 40))) 

(DEFUN |PFO;klist| (|d| $)
  (PROG (|c| #0=#:G1855 #1=#:G1853 #2=#:G1851 #3=#:G1852)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|PFO;klist|))
             (SEQ (LETT |c| NIL . #4#)
                  (LETT #0# (SPADCALL |d| (QREFELT $ 42)) . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |c| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL |c| (QREFELT $ 44)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 46)) . #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 (|IdentityError| '|setUnion|)))))))) 

(DEFUN |PFO;notIrr?| (|d| $)
  (< 1
     (LENGTH (SPADCALL (SPADCALL |d| (QREFELT $ 51)) (QREFELT $ 54))))) 

(DEFUN |PFO;kbadBadNum| (|d| |m| $)
  (PROG (#0=#:G1867 |c| #1=#:G1868)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #2=(|PFO;kbadBadNum|))
                 (SEQ (LETT |c| NIL . #2#)
                      (LETT #1# (SPADCALL |d| (QREFELT $ 62)) . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |c| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |c| |m|
                                          (QREFELT $ 63))
                                         (QREFELT $ 66))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 68)))))) 

(DEFUN |PFO;kbad3Num| (|h| |m| $)
  (PROG (#0=#:G1871 |c| #1=#:G1872)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #2=(|PFO;kbad3Num|))
                 (SEQ (LETT |c| NIL . #2#)
                      (LETT #1# (SPADCALL |h| (QREFELT $ 71)) . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |c| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (|PFO;kbadBadNum| |c| |m| $)
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 73)))))) 

(DEFUN |PFO;torsionIfCan;FdU;12| (|d| $)
  (PROG (|n| |g|)
    (RETURN
      (SEQ (COND
             ((ZEROP (LETT |n|
                           (|PFO;possibleOrder|
                               (LETT |d| (SPADCALL |d| (QREFELT $ 74))
                                     . #0=(|PFO;torsionIfCan;FdU;12|))
                               $) . #0#))
              (CONS 1 "failed"))
             ('T
              (SEQ (LETT |g|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL |n| |d| (QREFELT $ 75))
                                 (QREFELT $ 74))
                             (QREFELT $ 77)) . #0#)
                   (EXIT (COND
                           ((QEQCAR |g| 1) (CONS 1 "failed"))
                           ('T (CONS 0 (CONS |n| (QCDR |g|))))))))))))) 

(DEFUN |PFO;UPQ2F| (|p| |k| $)
  (SPADCALL
      (SPADCALL (CONS (|function| |PFO;Q2F|) $) |p| (QREFELT $ 82))
      (SPADCALL |k| (QREFELT $ 84)) (QREFELT $ 85))) 

(DEFUN |PFO;UP22UP| (|p| |k| $)
  (SPADCALL (CONS #'|PFO;UP22UP!0| (VECTOR $ |k|)) |p| (QREFELT $ 88))) 

(DEFUN |PFO;UP22UP!0| (|#1| $$)
  (|PFO;UPQ2F| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |PFO;UP32UPUP| (|p| |k| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|PFO;UP32UPUP!0| (VECTOR $ |k|)) |p|
          (QREFELT $ 93))))) 

(DEFUN |PFO;UP32UPUP!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PFO;UP32UPUP|)
    (RETURN
      (PROGN
        (SPADCALL (|PFO;UP22UP| |#1| (QREFELT $$ 1) $) (QREFELT $ 90)))))) 

(DEFUN |PFO;cmult;LSmp;16| (|l| $) (SPADCALL |l| (QREFELT $ 95))) 

(DEFUN |PFO;cmult;LSmp;17| (|l| $)
  (PROG (#0=#:G1815 #1=#:G1900 #2=#:G1898 #3=#:G1896 #4=#:G1897)
    (RETURN
      (SEQ (PROGN
             (LETT #4# NIL . #5=(|PFO;cmult;LSmp;17|))
             (SEQ (LETT #0# NIL . #5#) (LETT #1# |l| . #5#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT #0# (CAR #1#) . #5#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #2# #0# . #5#)
                               (COND
                                 (#4# (LETT #3#
                                       (SPADCALL #3# #2#
                                        (QREFELT $ 98)) . #5#))
                                 ('T
                                  (PROGN
                                    (LETT #3# #2# . #5#)
                                    (LETT #4# 'T . #5#)))))))
                  (LETT #1# (CDR #1#) . #5#) (GO G190) G191 (EXIT NIL))
             (COND (#4# #3#) ('T (|spadConstant| $ 99)))))))) 

(DEFUN |PFO;doubleDisc| (|f| $)
  (PROG (|g| #0=#:G1905 |d| |e| #1=#:G1910 |c| #2=#:G1911)
    (RETURN
      (SEQ (LETT |d| (SPADCALL |f| (QREFELT $ 100))
                 . #3=(|PFO;doubleDisc|))
           (LETT |g|
                 (SPADCALL |d| (SPADCALL |d| (QREFELT $ 101))
                     (QREFELT $ 102)) . #3#)
           (LETT |d|
                 (PROG2 (LETT #0#
                              (SPADCALL |d| |g| (QREFELT $ 104)) . #3#)
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0)
                       (|SparseUnivariatePolynomial|
                           (|SparseUnivariatePolynomial|
                               (|Fraction| (|Integer|))))
                       #0#)) . #3#)
           (EXIT (COND
                   ((SPADCALL
                        (LETT |e| (SPADCALL |d| (QREFELT $ 106)) . #3#)
                        (QREFELT $ 107))
                    0)
                   ('T
                    (SPADCALL
                        (PROGN
                          (LETT #1# NIL . #3#)
                          (SEQ (LETT |c| NIL . #3#)
                               (LETT #2#
                                     (SPADCALL |e| (QREFELT $ 109)) . #3#)
                               G190
                               (COND
                                 ((OR (ATOM #2#)
                                      (PROGN
                                        (LETT |c| (CAR #2#) . #3#)
                                        NIL))
                                  (GO G191)))
                               (SEQ (EXIT
                                     (LETT #1#
                                      (CONS
                                       (SPADCALL |c| (QREFELT $ 110))
                                       #1#) . #3#)))
                               (LETT #2# (CDR #2#) . #3#) (GO G190)
                               G191 (EXIT (NREVERSE0 #1#))))
                        (QREFELT $ 111))))))))) 

(DEFUN |PFO;commonDen| (|p| $)
  (PROG (|l1| #0=#:G1915 |c| #1=#:G1916 |l2|)
    (RETURN
      (SEQ (LETT |l1| (SPADCALL |p| (QREFELT $ 42))
                 . #2=(|PFO;commonDen|))
           (LETT |l2|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |c| NIL . #2#) (LETT #1# |l1| . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |c| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |c| (QREFELT $ 113))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT (SPADCALL |l2| (QREFELT $ 97))))))) 

(DEFUN |PFO;polyred| (|f| $)
  (PROG (#0=#:G2080 |c| #1=#:G2081)
    (RETURN
      (SEQ (SPADCALL
               (SPADCALL
                   (SPADCALL
                       (SPADCALL
                           (SPADCALL
                               (PROGN
                                 (LETT #0# NIL . #2=(|PFO;polyred|))
                                 (SEQ (LETT |c| NIL . #2#)
                                      (LETT #1#
                                       (SPADCALL |f| (QREFELT $ 115)) . #2#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |c| (CAR #1#) . #2#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (|PFO;commonDen|
                                           (SPADCALL |c|
                                            (QREFELT $ 116))
                                           $)
                                          #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      (GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))
                               (QREFELT $ 97))
                           (QREFELT $ 117))
                       (QREFELT $ 118))
                   (QREFELT $ 90))
               |f| (QREFELT $ 119)))))) 

(DEFUN |PFO;aklist| (|f| $)
  (PROG (|r| |c| #0=#:G2093 #1=#:G2090 #2=#:G2088 #3=#:G2089)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |f| (QREFELT $ 121))
                 . #4=(|PFO;aklist|))
           (EXIT (COND
                   ((QEQCAR |r| 1)
                    (PROGN
                      (LETT #3# NIL . #4#)
                      (SEQ (LETT |c| NIL . #4#)
                           (LETT #0#
                                 (SPADCALL
                                     (SPADCALL |f| (QREFELT $ 122))
                                     (QREFELT $ 115)) . #4#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |c| (CAR #0#) . #4#)
                                    NIL))
                              (GO G191)))
                           (SEQ (EXIT (PROGN
                                        (LETT #1#
                                         (|PFO;klist|
                                          (SPADCALL |c|
                                           (QREFELT $ 116))
                                          $) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 46)) . #4#))
                                          ('T
                                           (PROGN
                                             (LETT #2# #1# . #4#)
                                             (LETT #3# 'T . #4#)))))))
                           (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                           (EXIT NIL))
                      (COND
                        (#3# #2#)
                        (#5='T (|IdentityError| '|setUnion|)))))
                   (#5#
                    (|PFO;klist| (SPADCALL (QCDR |r|) (QREFELT $ 116))
                        $)))))))) 

(DEFUN |PFO;alglist| (|d| $)
  (PROG (|n| |i| #0=#:G2100 #1=#:G2096 #2=#:G2094 #3=#:G2095)
    (RETURN
      (SEQ (LETT |n|
                 (SPADCALL
                     (LETT |i| (SPADCALL |d| (QREFELT $ 124))
                           . #4=(|PFO;alglist|))
                     (QREFELT $ 126)) . #4#)
           (EXIT (SPADCALL
                     (CONS #'|PFO;alglist!0| (VECTOR (QREFELT $ 14) $))
                     (SPADCALL
                         (|PFO;klist| (SPADCALL |i| (QREFELT $ 130)) $)
                         (PROGN
                           (LETT #3# NIL . #4#)
                           (SEQ (LETT |i|
                                      (SPADCALL |n| (QREFELT $ 131)) . #4#)
                                (LETT #0# (QVSIZE |n|) . #4#) G190
                                (COND ((> |i| #0#) (GO G191)))
                                (SEQ (EXIT
                                      (PROGN
                                        (LETT #1#
                                         (|PFO;aklist|
                                          (SPADCALL |n| |i|
                                           (QREFELT $ 132))
                                          $) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 46)) . #4#))
                                          ('T
                                           (PROGN
                                             (LETT #2# #1# . #4#)
                                             (LETT #3# 'T . #4#)))))))
                                (LETT |i| (+ |i| 1) . #4#) (GO G190)
                                G191 (EXIT NIL))
                           (COND
                             (#3# #2#)
                             ('T (|IdentityError| '|setUnion|))))
                         (QREFELT $ 46))
                     (QREFELT $ 134))))))) 

(DEFUN |PFO;alglist!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |PFO;alglist|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |#1| (QREFELT $ 128)) (QREFELT $$ 0)
            (QREFELT $ 129)))))) 

(DEFUN |PFO;krmod| (|p| |k| $)
  (SPADCALL (CONS #'|PFO;krmod!0| (VECTOR $ |k|)) |p| (QREFELT $ 137))) 

(DEFUN |PFO;krmod!0| (|#1| $$)
  (|PFO;kqmod| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |PFO;rmod| (|p| $)
  (SPADCALL (CONS (|function| |PFO;qmod|) $) |p| (QREFELT $ 139))) 

(DEFUN |PFO;raise| (|p| |k| $)
  (SPADCALL
      (SPADCALL (CONS (|function| |PFO;Q2F|) $) |p| (QREFELT $ 141))
      (SPADCALL |k| (QREFELT $ 84)) (QREFELT $ 142))) 

(DEFUN |PFO;raise2| (|p| |k| $)
  (SPADCALL (CONS #'|PFO;raise2!0| (VECTOR $ |k|)) |p| (QREFELT $ 88))) 

(DEFUN |PFO;raise2!0| (|#1| $$)
  (|PFO;raise| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |PFO;algcurve| (|d| |rc| |k| $)
  (PROG (|i| |n| |mn| |hh| |h| |b| |b2| |s| |dd| |pr| |p| |pp| |mm|
             |gf| |m| |alpha| |sae|)
    (RETURN
      (SEQ (LETT |mn|
                 (SPADCALL
                     (LETT |n|
                           (SPADCALL (LETT |i|
                                      (SPADCALL
                                       (SPADCALL |d| (QREFELT $ 124))
                                       (QREFELT $ 143))
                                      . #0=(|PFO;algcurve|))
                                     (QREFELT $ 126)) . #0#)
                     (QREFELT $ 131)) . #0#)
           (LETT |h|
                 (|PFO;kpmod|
                     (SPADCALL
                         (LETT |hh|
                               (SPADCALL |n| (+ |mn| 1)
                                   (QREFELT $ 144)) . #0#)
                         (QREFELT $ 122))
                     |k| $) . #0#)
           (LETT |b2|
                 (SPADCALL
                     (|PFO;raise2|
                         (LETT |b|
                               (|PFO;krmod|
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |n| |mn|
                                      (QREFELT $ 144))
                                     (QREFELT $ 145))
                                    (QREFELT $ 116))
                                   |k| $) . #0#)
                         |k| $)
                     (QREFELT $ 146)) . #0#)
           (LETT |s|
                 (|PFO;kqmod|
                     (SPADCALL
                         (SPADCALL
                             (QCAR (SPADCALL
                                    (|PFO;raise2|
                                     (|PFO;krmod|
                                      (SPADCALL
                                       (SPADCALL |hh| (QREFELT $ 147))
                                       (QREFELT $ 116))
                                      |k| $)
                                     |k| $)
                                    |b2| (QREFELT $ 149)))
                             (QREFELT $ 146))
                         |b2| (QREFELT $ 150))
                     |k| $) . #0#)
           (LETT |pr|
                 (|PFO;kgetGoodPrime| |rc| |s| |h| |b|
                     (LETT |dd|
                           (|PFO;krmod| (SPADCALL |i| (QREFELT $ 130))
                               |k| $) . #0#)
                     $) . #0#)
           (LETT |p| (QCAR |pr|) . #0#)
           (LETT |pp| (|PFO;UP32UPUP| (QVELT |rc| 0) |k| $) . #0#)
           (LETT |mm| (QCDR |pr|) . #0#)
           (LETT |gf| (|InnerPrimeField| |p|) . #0#)
           (LETT |m|
                 (SPADCALL (CONS #'|PFO;algcurve!0| (VECTOR |gf| $))
                     |mm|
                     (|compiledLookupCheck| '|map|
                         (LIST (LIST '|SparseUnivariatePolynomial|
                                     (|devaluate| |gf|))
                               (LIST '|Mapping| (|devaluate| |gf|)
                                     (LIST '|Fraction|
                                      (LIST '|Integer|)))
                               (LIST '|SparseUnivariatePolynomial|
                                     (LIST '|Fraction|
                                      (LIST '|Integer|))))
                         (|SparseUnivariatePolynomialFunctions2|
                             (|Fraction| (|Integer|)) |gf|))) . #0#)
           (EXIT (COND
                   ((EQL (SPADCALL |m|
                             (|compiledLookupCheck| '|degree|
                                 (LIST (LIST '|NonNegativeInteger|) '$)
                                 (|SparseUnivariatePolynomial| |gf|)))
                         1)
                    (SEQ (LETT |alpha|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |m| 0
                                     (|compiledLookupCheck|
                                      '|coefficient|
                                      (LIST (|devaluate| |gf|) '$
                                       (LIST '|NonNegativeInteger|))
                                      (|SparseUnivariatePolynomial|
                                       |gf|)))
                                    (SPADCALL |m|
                                     (|compiledLookupCheck|
                                      '|leadingCoefficient|
                                      (LIST (|devaluate| |gf|) '$)
                                      (|SparseUnivariatePolynomial|
                                       |gf|)))
                                    (|compiledLookupCheck| '/
                                     (LIST '$ '$ '$) |gf|))
                                   (|compiledLookupCheck| '-
                                    (LIST '$ '$) |gf|)) . #0#)
                         (EXIT (SPADCALL |d| |pp|
                                   (CONS #'|PFO;algcurve!2|
                                    (VECTOR |alpha| |k| $ |gf|))
                                   (|compiledLookupCheck| '|order|
                                    (LIST (LIST '|NonNegativeInteger|)
                                     (LIST '|FiniteDivisor|
                                      (|devaluate| (ELT $ 7))
                                      (|devaluate| (ELT $ 8))
                                      (|devaluate| (ELT $ 9))
                                      (|devaluate| (ELT $ 10)))
                                     (|devaluate| (ELT $ 9))
                                     (LIST '|Mapping|
                                      (|devaluate| |gf|)
                                      (|devaluate| (ELT $ 7))))
                                    (|ReducedDivisor| (ELT $ 7)
                                     (ELT $ 8) (ELT $ 9) (ELT $ 10)
                                     |gf|))))))
                   ('T
                    (SEQ (LETT |sae|
                               (|SimpleAlgebraicExtension| |gf|
                                   (|SparseUnivariatePolynomial| |gf|)
                                   |m|) . #0#)
                         (EXIT (SPADCALL |d| |pp|
                                   (CONS #'|PFO;algcurve!4|
                                    (VECTOR |sae| |k| $ |gf|))
                                   (|compiledLookupCheck| '|order|
                                    (LIST (LIST '|NonNegativeInteger|)
                                     (LIST '|FiniteDivisor|
                                      (|devaluate| (ELT $ 7))
                                      (|devaluate| (ELT $ 8))
                                      (|devaluate| (ELT $ 9))
                                      (|devaluate| (ELT $ 10)))
                                     (|devaluate| (ELT $ 9))
                                     (LIST '|Mapping|
                                      (|devaluate| |sae|)
                                      (|devaluate| (ELT $ 7))))
                                    (|ReducedDivisor| (ELT $ 7)
                                     (ELT $ 8) (ELT $ 9) (ELT $ 10)
                                     |sae|)))))))))))) 

(DEFUN |PFO;algcurve!4| (|#1| $$)
  (PROG (|gf| $)
    (LETT |gf| (QREFELT $$ 3) . #0=(|PFO;algcurve|))
    (LETT $ (QREFELT $$ 2) . #0#)
    (RETURN
      (PROGN
        (PROG ()
          (RETURN
            (SPADCALL
                (SPADCALL (CONS #'|PFO;algcurve!3| (VECTOR |gf| $))
                    (|PFO;kqmod| |#1| (QREFELT $$ 1) $)
                    (|compiledLookupCheck| '|map|
                        (LIST (LIST '|SparseUnivariatePolynomial|
                                    (|devaluate| |gf|))
                              (LIST '|Mapping| (|devaluate| |gf|)
                                    (LIST '|Fraction|
                                     (LIST '|Integer|)))
                              (LIST '|SparseUnivariatePolynomial|
                                    (LIST '|Fraction|
                                     (LIST '|Integer|))))
                        (|SparseUnivariatePolynomialFunctions2|
                            (|Fraction| (|Integer|)) |gf|)))
                (|compiledLookupCheck| '|reduce|
                    (LIST '$
                          (LIST '|SparseUnivariatePolynomial|
                                (|devaluate| |gf|)))
                    (QREFELT $$ 0))))))))) 

(DEFUN |PFO;algcurve!3| (|#1| $$)
  (PROG ($ |gf|)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |gf| (QREFELT $$ 0) NIL)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL (SPADCALL |#1| (QREFELT $ 23))
                (|compiledLookupCheck| '|coerce|
                    (LIST '$ (LIST '|Integer|)) |gf|))
            (SPADCALL (SPADCALL |#1| (QREFELT $ 25))
                (|compiledLookupCheck| '|coerce|
                    (LIST '$ (LIST '|Integer|)) |gf|))
            (|compiledLookupCheck| '/ (LIST '$ '$ '$) |gf|)))))) 

(DEFUN |PFO;algcurve!2| (|#1| $$)
  (PROG (|gf| $)
    (LETT |gf| (QREFELT $$ 3) . #0=(|PFO;algcurve|))
    (LETT $ (QREFELT $$ 2) . #0#)
    (RETURN
      (PROGN
        (PROG ()
          (RETURN
            (SPADCALL
                (SPADCALL (CONS #'|PFO;algcurve!1| (VECTOR |gf| $))
                    (|PFO;kqmod| |#1| (QREFELT $$ 1) $)
                    (|compiledLookupCheck| '|map|
                        (LIST (LIST '|SparseUnivariatePolynomial|
                                    (|devaluate| |gf|))
                              (LIST '|Mapping| (|devaluate| |gf|)
                                    (LIST '|Fraction|
                                     (LIST '|Integer|)))
                              (LIST '|SparseUnivariatePolynomial|
                                    (LIST '|Fraction|
                                     (LIST '|Integer|))))
                        (|SparseUnivariatePolynomialFunctions2|
                            (|Fraction| (|Integer|)) |gf|)))
                (QREFELT $$ 0)
                (|compiledLookupCheck| '|elt|
                    (LIST (|devaluate| |gf|) '$ (|devaluate| |gf|))
                    (|SparseUnivariatePolynomial| |gf|))))))))) 

(DEFUN |PFO;algcurve!1| (|#1| $$)
  (PROG ($ |gf|)
    (LETT $ (QREFELT $$ 1) NIL)
    (LETT |gf| (QREFELT $$ 0) NIL)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL (SPADCALL |#1| (QREFELT $ 23))
                (|compiledLookupCheck| '|coerce|
                    (LIST '$ (LIST '|Integer|)) |gf|))
            (SPADCALL (SPADCALL |#1| (QREFELT $ 25))
                (|compiledLookupCheck| '|coerce|
                    (LIST '$ (LIST '|Integer|)) |gf|))
            (|compiledLookupCheck| '/ (LIST '$ '$ '$) |gf|)))))) 

(DEFUN |PFO;algcurve!0| (|#1| $$)
  (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT $$ 1) 110))
      (|compiledLookupCheck| '|coerce| (LIST '$ (LIST '|Integer|))
          (QREFELT $$ 0)))) 

(DEFUN |PFO;ratcurve| (|d| |rc| $)
  (PROG (|i| |nm| |mn| |hh| |h| |b| |s| |bd| |r| |bad| |pp| |p| |n|
             |m|)
    (RETURN
      (SEQ (LETT |mn|
                 (SPADCALL
                     (LETT |nm|
                           (SPADCALL
                               (LETT |i|
                                     (SPADCALL
                                      (SPADCALL |d| (QREFELT $ 124))
                                      (QREFELT $ 143))
                                     . #0=(|PFO;ratcurve|))
                               (QREFELT $ 126)) . #0#)
                     (QREFELT $ 131)) . #0#)
           (LETT |h|
                 (|PFO;pmod|
                     (SPADCALL
                         (LETT |hh|
                               (SPADCALL |nm| (+ |mn| 1)
                                   (QREFELT $ 144)) . #0#)
                         (QREFELT $ 122))
                     $) . #0#)
           (LETT |b|
                 (|PFO;rmod|
                     (SPADCALL
                         (SPADCALL (SPADCALL |nm| |mn| (QREFELT $ 144))
                             (QREFELT $ 145))
                         (QREFELT $ 116))
                     $) . #0#)
           (LETT |s|
                 (QCAR (SPADCALL
                           (|PFO;rmod|
                               (SPADCALL
                                   (SPADCALL |hh| (QREFELT $ 147))
                                   (QREFELT $ 116))
                               $)
                           |b| (QREFELT $ 154))) . #0#)
           (LETT |bd|
                 (SPADCALL
                     (|PFO;rmod| (SPADCALL |i| (QREFELT $ 130)) $)
                     (QREFELT $ 66)) . #0#)
           (LETT |r| (SPADCALL |s| |b| (QREFELT $ 155)) . #0#)
           (LETT |bad|
                 (SPADCALL
                     (LIST (QCDR |rc|) (SPADCALL |r| (QREFELT $ 23))
                           (SPADCALL |r| (QREFELT $ 25))
                           (* (QCAR |bd|) (QCDR |bd|))
                           (SPADCALL |h| (QREFELT $ 156)))
                     (QREFELT $ 73)) . #0#)
           (LETT |pp| (|PFO;Q2UPUP| (QCAR |rc|) $) . #0#)
           (LETT |n|
                 (|PFO;rat| |pp| |d|
                     (LETT |p| (SPADCALL |bad| (QREFELT $ 158)) . #0#)
                     $) . #0#)
           (EXIT (COND
                   ((EQL |n| 1) |n|)
                   (#1='T
                    (SEQ (LETT |m|
                               (|PFO;rat| |pp| |d|
                                   (SPADCALL
                                    (SPADCALL |p| |bad|
                                     (QREFELT $ 159))
                                    (QREFELT $ 158))
                                   $) . #0#)
                         (EXIT (COND ((EQL |n| |m|) |n|) (#1# 0))))))))))) 

(DEFUN |PFO;rat| (|pp| |d| |p| $)
  (PROG (|gf|)
    (RETURN
      (SEQ (LETT |gf| (|InnerPrimeField| |p|) |PFO;rat|)
           (EXIT (SPADCALL |d| |pp|
                     (CONS #'|PFO;rat!0| (VECTOR |gf| $))
                     (|compiledLookupCheck| '|order|
                         (LIST (LIST '|NonNegativeInteger|)
                               (LIST '|FiniteDivisor|
                                     (|devaluate| (ELT $ 7))
                                     (|devaluate| (ELT $ 8))
                                     (|devaluate| (ELT $ 9))
                                     (|devaluate| (ELT $ 10)))
                               (|devaluate| (ELT $ 9))
                               (LIST '|Mapping| (|devaluate| |gf|)
                                     (|devaluate| (ELT $ 7))))
                         (|ReducedDivisor| (ELT $ 7) (ELT $ 8)
                             (ELT $ 9) (ELT $ 10) |gf|)))))))) 

(DEFUN |PFO;rat!0| (|#1| $$)
  (PROG ($ |gf|)
    (LETT $ (QREFELT $$ 1) . #0=(|PFO;rat|))
    (LETT |gf| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (PROG (|qq|)
          (RETURN
            (SEQ (LETT |qq| (|PFO;qmod| |#1| $) NIL)
                 (EXIT (SPADCALL
                           (SPADCALL (SPADCALL |qq| (QREFELT $ 23))
                               (|compiledLookupCheck| '|coerce|
                                   (LIST '$ (LIST '|Integer|)) |gf|))
                           (SPADCALL (SPADCALL |qq| (QREFELT $ 25))
                               (|compiledLookupCheck| '|coerce|
                                   (LIST '$ (LIST '|Integer|)) |gf|))
                           (|compiledLookupCheck| '/ (LIST '$ '$ '$)
                               |gf|)))))))))) 

(DEFUN |PFO;possibleOrder| (|d| $)
  (PROG (|la|)
    (RETURN
      (COND
        ((OR (ZEROP (SPADCALL (QREFELT $ 161)))
             (EQL (QVSIZE (SPADCALL (SPADCALL |d| (QREFELT $ 124))
                              (QREFELT $ 126)))
                  1))
         1)
        ('T
         (COND
           ((NULL (LETT |la| (|PFO;alglist| |d| $) |PFO;possibleOrder|))
            (|PFO;ratcurve| |d| (|PFO;selIntegers| $) $))
           ((NULL (NULL (CDR |la|)))
            (|error| "PFO::possibleOrder: more than 1 algebraic constant"))
           ('T
            (|PFO;algcurve| |d|
                (|PFO;selectIntegers| (|SPADfirst| |la|) $)
                (|SPADfirst| |la|) $)))))))) 

(DEFUN |PFO;selIntegers| ($)
  (PROG (|f| |r| |d|)
    (RETURN
      (SEQ (LETT |f| (SPADCALL (QREFELT $ 162))
                 . #0=(|PFO;selIntegers|))
           (SEQ G190
                (COND
                  ((NULL (ZEROP (LETT |d|
                                      (SPADCALL
                                       (LETT |r|
                                        (SPADCALL (|PFO;pmod| |f| $)
                                         (QREFELT $ 163)) . #0#)
                                       (QREFELT $ 164)) . #0#)))
                   (GO G191)))
                (SEQ (EXIT (SPADCALL (QREFELT $ 166)))) NIL (GO G190)
                G191 (EXIT NIL))
           (EXIT (CONS |r| |d|)))))) 

(DEFUN |PFO;selectIntegers| (|k| $)
  (PROG (|f| |g| |p| |r| |d|)
    (RETURN
      (SEQ (LETT |g|
                 (|PFO;polyred|
                     (LETT |f| (SPADCALL (QREFELT $ 162))
                           . #0=(|PFO;selectIntegers|))
                     $) . #0#)
           (LETT |p| (SPADCALL |k| (QREFELT $ 168)) . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((ZEROP (LETT |d|
                                    (|PFO;doubleDisc|
                                     (LETT |r|
                                      (|PFO;kpmod| |g| |k| $) . #0#)
                                     $) . #0#))
                            'T)
                           ('T (|PFO;notIrr?| (|PFO;fmod| |p| $) $))))
                   (GO G191)))
                (SEQ (EXIT (SPADCALL (QREFELT $ 166)))) NIL (GO G190)
                G191 (EXIT NIL))
           (EXIT (VECTOR |r| |d|
                         (QCAR (SPADCALL (|PFO;fmod| |p| $)
                                   (QREFELT $ 171))))))))) 

(DEFUN |PFO;toQ1| (|p| |d| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|PFO;toQ1!0| (VECTOR $ |d|)) |p|
          (QREFELT $ 88))))) 

(DEFUN |PFO;toQ1!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PFO;toQ1|)
    (RETURN
      (PROGN
        (|PFO;Q2F|
            (SPADCALL (SPADCALL |#1| (QREFELT $$ 1) (QREFELT $ 63))
                (QREFELT $ 172))
            $))))) 

(DEFUN |PFO;toQ2| (|p| |d| $)
  (PROG ()
    (RETURN
      (SPADCALL
          (SPADCALL (CONS #'|PFO;toQ2!0| (VECTOR $ |d|)) |p|
              (QREFELT $ 93))
          (QREFELT $ 173))))) 

(DEFUN |PFO;toQ2!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PFO;toQ2|)
    (RETURN
      (PROGN
        (SPADCALL (|PFO;toQ1| |#1| (QREFELT $$ 1) $) (QREFELT $ 90)))))) 

(DEFUN |PFO;kpmod| (|p| |k| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|PFO;kpmod!0| (VECTOR |k| $)) |p|
          (QREFELT $ 176))))) 

(DEFUN |PFO;kpmod!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |PFO;kpmod|)
    (RETURN
      (PROGN
        (|PFO;krmod| (SPADCALL |#1| (QREFELT $ 116)) (QREFELT $$ 0) $))))) 

(DEFUN |PFO;order;FdU;36| (|d| $)
  (PROG (|n|)
    (RETURN
      (COND
        ((OR (ZEROP (LETT |n|
                          (|PFO;possibleOrder|
                              (LETT |d| (SPADCALL |d| (QREFELT $ 74))
                                    . #0=(|PFO;order;FdU;36|))
                              $) . #0#))
             (NULL (SPADCALL
                       (SPADCALL (SPADCALL |n| |d| (QREFELT $ 75))
                           (QREFELT $ 74))
                       (QREFELT $ 177))))
         (CONS 1 "failed"))
        ('T (CONS 0 |n|)))))) 

(DEFUN |PFO;kgetGoodPrime| (|rec| |res| |h| |b| |d| $)
  (PROG (|u| #0=#:G2156 |p| #1=#:G2154)
    (RETURN
      (SEQ (LETT |p| 3 . #2=(|PFO;kgetGoodPrime|))
           (SEQ G190
                (COND
                  ((NULL (QEQCAR (LETT |u|
                                       (|PFO;goodRed| |rec| |res| |h|
                                        |b| |d| |p| $) . #2#)
                                 1))
                   (GO G191)))
                (SEQ (EXIT (LETT |p|
                                 (PROG1 (LETT #0#
                                         (SPADCALL |p| (QREFELT $ 179)) . #2#)
                                   (|check-subtype| (> #0# 0)
                                    '(|PositiveInteger|) #0#)) . #2#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (CONS |p|
                       (PROG2 (LETT #1# |u| . #2#) (QCDR #1#)
                         (|check-union| (QEQCAR #1# 0)
                             (|SparseUnivariatePolynomial|
                                 (|Fraction| (|Integer|)))
                             #1#)))))))) 

(DEFUN |PFO;goodRed| (|rec| |res| |h| |b| |d| |p| $)
  (PROG (|gf| #0=#:G2171 |f| #1=#:G2172 |l| |ff| #2=#:G2173 |mdg| |md|)
    (RETURN
      (SEQ (COND
             ((ZEROP (REMAINDER2 (QVELT |rec| 1) |p|))
              (CONS 1 "failed"))
             ('T
              (SEQ (LETT |gf| (|InnerPrimeField| |p|)
                         . #3=(|PFO;goodRed|))
                   (LETT |l|
                         (PROGN
                           (LETT #0# NIL . #3#)
                           (SEQ (LETT |f| NIL . #3#)
                                (LETT #1#
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL
                                         (CONS #'|PFO;goodRed!0|
                                          (VECTOR |gf| $))
                                         (QVELT |rec| 2)
                                         (|compiledLookupCheck| '|map|
                                          (LIST
                                           (LIST
                                            '|SparseUnivariatePolynomial|
                                            (|devaluate| |gf|))
                                           (LIST '|Mapping|
                                            (|devaluate| |gf|)
                                            (LIST '|Fraction|
                                             (LIST '|Integer|)))
                                           (LIST
                                            '|SparseUnivariatePolynomial|
                                            (LIST '|Fraction|
                                             (LIST '|Integer|))))
                                          (|SparseUnivariatePolynomialFunctions2|
                                           (|Fraction| (|Integer|))
                                           |gf|)))
                                        (|compiledLookupCheck|
                                         '|factor|
                                         (LIST
                                          (LIST '|Factored|
                                           (LIST
                                            '|SparseUnivariatePolynomial|
                                            (|devaluate| |gf|)))
                                          (LIST
                                           '|SparseUnivariatePolynomial|
                                           (|devaluate| |gf|)))
                                         (|DistinctDegreeFactorize|
                                          |gf|
                                          (|SparseUnivariatePolynomial|
                                           |gf|))))
                                       (|compiledLookupCheck|
                                        '|factors|
                                        (LIST
                                         (LIST '|List|
                                          (LIST '|Record|
                                           (LIST '|:| '|factor|
                                            (LIST
                                             '|SparseUnivariatePolynomial|
                                             (|devaluate| |gf|)))
                                           (LIST '|:| '|exponent|
                                            (LIST '|Integer|))))
                                         '$)
                                        (|Factored|
                                         (|SparseUnivariatePolynomial|
                                          |gf|)))) . #3#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |f| (CAR #1#) . #3#)
                                      NIL))
                                   #4=(GO G191)))
                                (SEQ (EXIT
                                      (COND
                                        ((EQL (QCDR |f|) 1)
                                         (LETT #0#
                                          (CONS (QCAR |f|) #0#) . #3#)))))
                                (LETT #1# (CDR #1#) . #3#) #5=(GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #3#)
                   (EXIT (COND
                           ((NULL |l|) (CONS 1 "failed"))
                           ('T
                            (SEQ (LETT |mdg| (|SPADfirst| |l|) . #3#)
                                 (SEQ (LETT |ff| NIL . #3#)
                                      (LETT #2# (CDR |l|) . #3#) G190
                                      (COND
                                        ((OR (ATOM #2#)
                                          (PROGN
                                            (LETT |ff| (CAR #2#) . #3#)
                                            NIL))
                                         #4#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((<
                                            (SPADCALL |ff|
                                             (|compiledLookupCheck|
                                              '|degree|
                                              (LIST
                                               (LIST
                                                '|NonNegativeInteger|)
                                               '$)
                                              (|SparseUnivariatePolynomial|
                                               |gf|)))
                                            (SPADCALL |mdg|
                                             (|compiledLookupCheck|
                                              '|degree|
                                              (LIST
                                               (LIST
                                                '|NonNegativeInteger|)
                                               '$)
                                              (|SparseUnivariatePolynomial|
                                               |gf|))))
                                           (LETT |mdg| |ff| . #3#)))))
                                      (LETT #2# (CDR #2#) . #3#) #5#
                                      G191 (EXIT NIL))
                                 (LETT |md|
                                       (SPADCALL
                                        (CONS #'|PFO;goodRed!1|
                                         (VECTOR $ |gf|))
                                        |mdg|
                                        (|compiledLookupCheck| '|map|
                                         (LIST
                                          (LIST
                                           '|SparseUnivariatePolynomial|
                                           (LIST '|Fraction|
                                            (LIST '|Integer|)))
                                          (LIST '|Mapping|
                                           (LIST '|Fraction|
                                            (LIST '|Integer|))
                                           (|devaluate| |gf|))
                                          (LIST
                                           '|SparseUnivariatePolynomial|
                                           (|devaluate| |gf|)))
                                         (|SparseUnivariatePolynomialFunctions2|
                                          |gf|
                                          (|Fraction| (|Integer|))))) . #3#)
                                 (EXIT (COND
                                         ((|PFO;good?| |res| |h| |b|
                                           |d| |p| |md| $)
                                          (CONS 0 |md|))
                                         ('T (CONS 1 "failed"))))))))))))))) 

(DEFUN |PFO;goodRed!1| (|#1| $$)
  (SPADCALL
      (SPADCALL |#1|
          (|compiledLookupCheck| '|convert| (LIST (LIST '|Integer|) '$)
              (QREFELT $$ 1)))
      (QREFELT (QREFELT $$ 0) 180))) 

(DEFUN |PFO;goodRed!0| (|#1| $$)
  (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT $$ 1) 110))
      (|compiledLookupCheck| '|coerce| (LIST '$ (LIST '|Integer|))
          (QREFELT $$ 0)))) 

(DEFUN |PFO;good?| (|res| |h| |b| |d| |p| |m| $)
  (PROG (|bd|)
    (RETURN
      (SEQ (LETT |bd|
                 (SPADCALL (SPADCALL |res| |m| (QREFELT $ 63))
                     (QREFELT $ 66))
                 |PFO;good?|)
           (EXIT (COND
                   ((OR (ZEROP (REMAINDER2 (QCAR |bd|) |p|))
                        (OR (ZEROP (REMAINDER2 (QCDR |bd|) |p|))
                            (OR (ZEROP (REMAINDER2
                                        (|PFO;kbadBadNum| |b| |m| $)
                                        |p|))
                                (OR (ZEROP
                                     (REMAINDER2
                                      (|PFO;kbadBadNum| |d| |m| $) |p|))
                                    (ZEROP
                                     (REMAINDER2
                                      (|PFO;kbad3Num| |h| |m| $) |p|))))))
                    'NIL)
                   ('T 'T))))))) 

(DEFUN |PointsOfFiniteOrder| (&REST #0=#:G2181)
  (PROG ()
    (RETURN
      (PROG (#1=#:G2182)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (|devaluateList| #0#)
                       (HGET |$ConstructorCache|
                             '|PointsOfFiniteOrder|)
                       '|domainEqualList|)
                   . #2=(|PointsOfFiniteOrder|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (APPLY (|function| |PointsOfFiniteOrder;|) #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|PointsOfFiniteOrder|))))))))))) 

(DEFUN |PointsOfFiniteOrder;| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (DV$1 DV$2 DV$3 DV$4 DV$5 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|PointsOfFiniteOrder|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT DV$5 (|devaluate| |#5|) . #0#)
        (LETT |dv$|
              (LIST '|PointsOfFiniteOrder| DV$1 DV$2 DV$3 DV$4 DV$5) . #0#)
        (LETT $ (GETREFV 181) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|PointsOfFiniteOrder|
            (LIST DV$1 DV$2 DV$3 DV$4 DV$5) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (QSETREFV $ 10 |#5|)
        (QSETREFV $ 14 (SPADCALL "%alg" (QREFELT $ 13)))
        (QSETREFV $ 15 (|FunctionSpaceReduce| |#1| |#2|))
        (COND
          ((|HasCategory| |#1| '(|GcdDomain|))
           (QSETREFV $ 97
               (CONS (|dispatchFunction| |PFO;cmult;LSmp;16|) $)))
          ('T
           (QSETREFV $ 97
               (CONS (|dispatchFunction| |PFO;cmult;LSmp;17|) $))))
        $)))) 

(MAKEPROP '|PointsOfFiniteOrder| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|local| |#5|) (|String|)
             (|Symbol|) (0 . |coerce|) 'ALGOP '|q|
             (|Union| 160 '"failed") (|FiniteDivisor| 7 8 9 10)
             |PFO;order;FdU;36| (|Boolean|) |PFO;torsion?;FdB;1|
             (|Integer|) (|Fraction| 21) (5 . |numer|) (10 . |coerce|)
             (15 . |denom|) (20 . /) (26 . |bringDown|)
             (|SparseUnivariatePolynomial| 22) (|Kernel| 7)
             (31 . |bringDown|) (|Mapping| 22 7)
             (|SparseUnivariatePolynomial| 7)
             (|SparseUnivariatePolynomialFunctions2| 7 22) (37 . |map|)
             (|SparseUnivariatePolynomial| (|Fraction| 28))
             (|MultipleMap| 7 8 9 22 28 35) (43 . |map|)
             (|Mapping| 7 22) (|MultipleMap| 22 28 35 7 8 9)
             (49 . |map|) (|List| 7) (55 . |coefficients|) (|List| 83)
             (60 . |kernels|) (|List| 29) (65 . |setUnion|)
             (71 . |One|) (75 . |One|) (|Factored| 28)
             (|RationalFactorize| 28) (79 . |factor|)
             (|Record| (|:| |factor| 28) (|:| |exponent| 21))
             (|List| 52) (84 . |factors|) (89 . |One|) (93 . |One|)
             (97 . |One|) (101 . |One|) (105 . |One|) (|List| 28)
             (|SparseUnivariatePolynomial| 28) (109 . |coefficients|)
             (114 . |rem|) (|Record| (|:| |den| 21) (|:| |gcdnum| 21))
             (|PointsOfFiniteOrderTools| 28 35) (120 . |badNum|)
             (|List| 64) (125 . |mix|) (|List| 61)
             (|SparseUnivariatePolynomial| 61) (130 . |coefficients|)
             (|List| $) (135 . |lcm|) (140 . |reduce|) (145 . *)
             (|Union| 10 '"failed") (151 . |generator|)
             (|Record| (|:| |order| 160) (|:| |function| 10))
             (|Union| 78 '"failed") |PFO;torsionIfCan;FdU;12|
             (|UnivariatePolynomialCategoryFunctions2| 22 28 7 8)
             (156 . |map|) (|Kernel| $) (162 . |coerce|) (167 . |elt|)
             (|Mapping| 7 28)
             (|UnivariatePolynomialCategoryFunctions2| 28 61 7 8)
             (173 . |map|) (|Fraction| 8) (179 . |coerce|)
             (|Mapping| 89 61)
             (|UnivariatePolynomialCategoryFunctions2| 61 70 89 9)
             (184 . |map|) (|SparseMultivariatePolynomial| 6 29)
             (190 . |lcm|) (|List| 94) (195 . |cmult|) (200 . *)
             (206 . |One|) (210 . |discriminant|)
             (215 . |differentiate|) (220 . |gcd|)
             (|Union| $ '"failed") (226 . |exquo|)
             (232 . |discriminant|) (236 . |discriminant|)
             (241 . |zero?|) (|List| 22) (246 . |coefficients|)
             (251 . |retract|) (256 . |gcd|)
             (|SparseMultivariatePolynomial| 6 83) (261 . |denom|)
             (|List| 89) (266 . |coefficients|) (271 . |retract|)
             (276 . |coerce|) (281 . |coerce|) (286 . *)
             (|Union| 89 '"failed") (292 . |retractIfCan|)
             (297 . |lift|) (|FractionalIdeal| 8 89 9 10)
             (302 . |ideal|) (|Vector| 10) (307 . |numer|)
             (|BasicOperator|) (312 . |operator|) (317 . |has?|)
             (323 . |denom|) (328 . |minIndex|) (333 . |qelt|)
             (|Mapping| 19 29) (339 . |select!|) (|Mapping| 28 7)
             (|UnivariatePolynomialCategoryFunctions2| 7 8 28 61)
             (345 . |map|)
             (|UnivariatePolynomialCategoryFunctions2| 7 8 22 28)
             (351 . |map|)
             (|SparseUnivariatePolynomialFunctions2| 22 7)
             (357 . |map|) (363 . |elt|) (369 . |minimize|)
             (374 . |elt|) (380 . |retract|) (385 . |primitivePart|)
             (390 . |norm|)
             (|Record| (|:| |primePart| $) (|:| |commonPart| $))
             (395 . |separate|) (401 . |resultant|) (407 . |Zero|)
             (411 . |Zero|) (415 . |numer|) (420 . |separate|)
             (426 . |resultant|) (432 . |badNum|) (|PositiveInteger|)
             (437 . |getGoodPrime|) (442 . *) (|NonNegativeInteger|)
             (448 . |genus|) (452 . |definingPolynomial|)
             (456 . |polyred|) (461 . |doubleDisc|) (|Void|)
             (466 . |newReduc|) (|SparseUnivariatePolynomial| $)
             (470 . |minPoly|) (|Record| (|:| |num| 28) (|:| |den| 21))
             (|UnivariatePolynomialCommonDenominator| 21 22 28)
             (475 . |splitDenominator|) (480 . |retract|)
             (485 . |reduce|) (|Mapping| 61 89)
             (|UnivariatePolynomialCategoryFunctions2| 89 9 61 70)
             (490 . |map|) (496 . |principal?|)
             (|IntegerPrimesPackage| 21) (501 . |nextPrime|)
             (506 . |coerce|))
          '#(|torsionIfCan| 511 |torsion?| 516 |order| 521 |cmult| 526)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 180
                                '(1 12 0 11 13 1 22 21 0 23 1 7 0 21 24
                                  1 22 21 0 25 2 7 0 0 0 26 1 15 22 7
                                  27 2 15 28 7 29 30 2 33 28 31 32 34 2
                                  36 35 31 9 37 2 39 9 38 35 40 1 8 41
                                  0 42 1 7 43 0 44 2 45 0 0 0 46 0 6 0
                                  47 0 7 0 48 1 50 49 28 51 1 49 53 0
                                  54 0 8 0 55 0 9 0 56 0 10 0 57 0 28 0
                                  58 0 49 0 59 1 61 60 0 62 2 28 0 0 0
                                  63 1 65 64 28 66 1 65 21 67 68 1 70
                                  69 0 71 1 21 0 72 73 1 17 0 0 74 2 17
                                  0 21 0 75 1 17 76 0 77 2 81 8 38 28
                                  82 1 7 0 83 84 2 8 7 0 7 85 2 87 8 86
                                  61 88 1 89 0 8 90 2 92 9 91 70 93 1
                                  94 0 72 95 1 0 94 96 97 2 94 0 0 0 98
                                  0 94 0 99 1 70 61 0 100 1 61 0 0 101
                                  2 61 0 0 0 102 2 61 103 0 0 104 0 10
                                  89 105 1 61 28 0 106 1 28 19 0 107 1
                                  28 108 0 109 1 22 21 0 110 1 21 0 72
                                  111 1 7 112 0 113 1 9 114 0 115 1 89
                                  8 0 116 1 7 0 112 117 1 8 0 7 118 2 9
                                  0 89 0 119 1 10 120 0 121 1 10 9 0
                                  122 1 17 123 0 124 1 123 125 0 126 1
                                  29 127 0 128 2 127 19 0 12 129 1 123
                                  8 0 130 1 125 21 0 131 2 125 10 0 21
                                  132 2 45 0 133 0 134 2 136 61 135 8
                                  137 2 138 28 31 8 139 2 140 32 38 28
                                  141 2 32 7 0 7 142 1 123 0 0 143 2
                                  125 10 0 21 144 1 10 89 0 145 1 8 0 0
                                  146 1 10 89 0 147 2 8 148 0 0 149 2 8
                                  7 0 0 150 0 6 0 151 0 7 0 152 1 7 112
                                  0 153 2 28 148 0 0 154 2 28 22 0 0
                                  155 1 65 21 35 156 1 65 157 21 158 2
                                  21 0 157 0 159 0 10 160 161 0 10 9
                                  162 1 65 35 35 163 1 65 21 35 164 0
                                  15 165 166 1 7 167 83 168 1 170 169
                                  28 171 1 28 22 0 172 1 10 0 9 173 2
                                  175 70 174 9 176 1 17 19 0 177 1 178
                                  21 21 179 1 22 0 21 180 1 0 79 17 80
                                  1 0 19 17 20 1 0 16 17 18 1 0 94 96
                                  97)))))
          '|lookupComplete|)) 
