
(/VERSIONCHECK 2) 

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

(DEFUN |PFO;Q2F| (|x| $)
  (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 20)) (QREFELT $ 21))
            (SPADCALL (SPADCALL |x| (QREFELT $ 22)) (QREFELT $ 21))
            (QREFELT $ 23))) 

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

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

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

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

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

(DEFUN |PFO;klist| (|d| $)
  (PROG (#1=#:G1848 #2=#:G1847 #3=#:G1849 #4=#:G1851 |c|)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #5=(|PFO;klist|))
       (SEQ (LETT |c| NIL . #5#) (LETT #4# (SPADCALL |d| (QREFELT $ 39)) . #5#)
            G190
            (COND
             ((OR (ATOM #4#) (PROGN (LETT |c| (CAR #4#) . #5#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (PROGN
               (LETT #3# (SPADCALL |c| (QREFELT $ 41)) . #5#)
               (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 43)) . #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 (|IdentityError| '|setUnion|)))))))) 

(DEFUN |PFO;notIrr?| (|d| $)
  (< 1 (LENGTH (SPADCALL (SPADCALL |d| (QREFELT $ 52)) (QREFELT $ 55))))) 

(DEFUN |PFO;kbadBadNum| (|d| |m| $)
  (PROG (#1=#:G1877 |c| #2=#:G1876)
    (RETURN
     (SEQ
      (SPADCALL
       (PROGN
        (LETT #2# NIL . #3=(|PFO;kbadBadNum|))
        (SEQ (LETT |c| NIL . #3#)
             (LETT #1# (SPADCALL |d| (QREFELT $ 59)) . #3#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (LETT #2#
                     (CONS
                      (SPADCALL (SPADCALL |c| |m| (QREFELT $ 60))
                                (QREFELT $ 63))
                      #2#)
                     . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       (QREFELT $ 65)))))) 

(DEFUN |PFO;kbad3Num| (|h| |m| $)
  (PROG (#1=#:G1881 |c| #2=#:G1880)
    (RETURN
     (SEQ
      (SPADCALL
       (PROGN
        (LETT #2# NIL . #3=(|PFO;kbad3Num|))
        (SEQ (LETT |c| NIL . #3#)
             (LETT #1# (SPADCALL |h| (QREFELT $ 68)) . #3#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT (LETT #2# (CONS (|PFO;kbadBadNum| |c| |m| $) #2#) . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191 (EXIT (NREVERSE0 #2#))))
       (QREFELT $ 70)))))) 

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

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

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

(DEFUN |PFO;UP22UP!0| (|p1| $$)
  (PROG (|k| $)
    (LETT |k| (QREFELT $$ 1) . #1=(|PFO;UP22UP|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|PFO;UPQ2F| |p1| |k| $))))) 

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

(DEFUN |PFO;UP32UPUP!0| (|p1| $$)
  (PROG (|k| $)
    (LETT |k| (QREFELT $$ 1) . #1=(|PFO;UP32UPUP|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL (|PFO;UP22UP| |p1| |k| $) (QREFELT $ 87)))))) 

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

(DEFUN |PFO;cmult;LSmp;17| (|l| $)
  (PROG (#1=#:G1910 #2=#:G1909 #3=#:G1911 #4=#:G1913 #5=#:G1792)
    (RETURN
     (SEQ
      (PROGN
       (LETT #1# NIL . #6=(|PFO;cmult;LSmp;17|))
       (SEQ (LETT #5# NIL . #6#) (LETT #4# |l| . #6#) G190
            (COND
             ((OR (ATOM #4#) (PROGN (LETT #5# (CAR #4#) . #6#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (PROGN
               (LETT #3# #5# . #6#)
               (COND (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 95)) . #6#))
                     ('T (PROGN (LETT #2# #3# . #6#) (LETT #1# 'T . #6#)))))))
            (LETT #4# (CDR #4#) . #6#) (GO G190) G191 (EXIT NIL))
       (COND (#1# #2#) ('T (|spadConstant| $ 96)))))))) 

(DEFUN |PFO;doubleDisc| (|f| $)
  (PROG (#1=#:G1924 |c| #2=#:G1923 |e| |d| #3=#:G1918 |g|)
    (RETURN
     (SEQ (LETT |d| (SPADCALL |f| (QREFELT $ 97)) . #4=(|PFO;doubleDisc|))
          (LETT |g| (SPADCALL |d| (SPADCALL |d| (QREFELT $ 98)) (QREFELT $ 99))
                . #4#)
          (LETT |d|
                (PROG2
                    (LETT #3# (SPADCALL |d| |g| (QREFELT $ 101)) . #4#)
                    (QCDR #3#)
                  (|check-union| (QEQCAR #3# 0)
                                 (|SparseUnivariatePolynomial|
                                  (|SparseUnivariatePolynomial|
                                   (|Fraction| (|Integer|))))
                                 #3#))
                . #4#)
          (EXIT
           (COND
            ((SPADCALL (LETT |e| (SPADCALL |d| (QREFELT $ 103)) . #4#)
                       (QREFELT $ 104))
             0)
            ('T
             (SPADCALL
              (PROGN
               (LETT #2# NIL . #4#)
               (SEQ (LETT |c| NIL . #4#)
                    (LETT #1# (SPADCALL |e| (QREFELT $ 106)) . #4#) G190
                    (COND
                     ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#) . #4#) NIL))
                      (GO G191)))
                    (SEQ
                     (EXIT
                      (LETT #2# (CONS (SPADCALL |c| (QREFELT $ 107)) #2#)
                            . #4#)))
                    (LETT #1# (CDR #1#) . #4#) (GO G190) G191
                    (EXIT (NREVERSE0 #2#))))
              (QREFELT $ 108))))))))) 

(DEFUN |PFO;commonDen| (|p| $)
  (PROG (|l2| #1=#:G1929 |c| #2=#:G1928 |l1|)
    (RETURN
     (SEQ (LETT |l1| (SPADCALL |p| (QREFELT $ 39)) . #3=(|PFO;commonDen|))
          (LETT |l2|
                (PROGN
                 (LETT #2# NIL . #3#)
                 (SEQ (LETT |c| NIL . #3#) (LETT #1# |l1| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #2# (CONS (SPADCALL |c| (QREFELT $ 110)) #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                . #3#)
          (EXIT (SPADCALL |l2| (QREFELT $ 94))))))) 

(DEFUN |PFO;polyred| (|f| $)
  (PROG (#1=#:G2094 |c| #2=#:G2093)
    (RETURN
     (SEQ
      (SPADCALL
       (SPADCALL
        (SPADCALL
         (SPADCALL
          (SPADCALL
           (PROGN
            (LETT #2# NIL . #3=(|PFO;polyred|))
            (SEQ (LETT |c| NIL . #3#)
                 (LETT #1# (SPADCALL |f| (QREFELT $ 112)) . #3#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |c| (CAR #1#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #2#
                         (CONS
                          (|PFO;commonDen| (SPADCALL |c| (QREFELT $ 113)) $)
                          #2#)
                         . #3#)))
                 (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                 (EXIT (NREVERSE0 #2#))))
           (QREFELT $ 94))
          (QREFELT $ 114))
         (QREFELT $ 115))
        (QREFELT $ 87))
       |f| (QREFELT $ 116)))))) 

(DEFUN |PFO;aklist| (|f| $)
  (PROG (#1=#:G2102 #2=#:G2101 #3=#:G2103 #4=#:G2106 |c| |r|)
    (RETURN
     (SEQ (LETT |r| (SPADCALL |f| (QREFELT $ 118)) . #5=(|PFO;aklist|))
          (EXIT
           (COND
            ((QEQCAR |r| 1)
             (PROGN
              (LETT #1# NIL . #5#)
              (SEQ (LETT |c| NIL . #5#)
                   (LETT #4#
                         (SPADCALL (SPADCALL |f| (QREFELT $ 119))
                                   (QREFELT $ 112))
                         . #5#)
                   G190
                   (COND
                    ((OR (ATOM #4#) (PROGN (LETT |c| (CAR #4#) . #5#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (PROGN
                      (LETT #3# (|PFO;klist| (SPADCALL |c| (QREFELT $ 113)) $)
                            . #5#)
                      (COND
                       (#1# (LETT #2# (SPADCALL #2# #3# (QREFELT $ 43)) . #5#))
                       ('T
                        (PROGN (LETT #2# #3# . #5#) (LETT #1# 'T . #5#)))))))
                   (LETT #4# (CDR #4#) . #5#) (GO G190) G191 (EXIT NIL))
              (COND (#1# #2#) (#6='T (|IdentityError| '|setUnion|)))))
            (#6# (|PFO;klist| (SPADCALL (QCDR |r|) (QREFELT $ 113)) $)))))))) 

(DEFUN |PFO;alglist| (|d| $)
  (PROG (#1=#:G2110 #2=#:G2109 #3=#:G2111 #4=#:G2115 |i| |n|)
    (RETURN
     (SEQ
      (LETT |n|
            (SPADCALL
             (LETT |i| (SPADCALL |d| (QREFELT $ 121)) . #5=(|PFO;alglist|))
             (QREFELT $ 123))
            . #5#)
      (EXIT
       (SPADCALL (CONS #'|PFO;alglist!0| (VECTOR (QREFELT $ 11) $))
                 (SPADCALL (|PFO;klist| (SPADCALL |i| (QREFELT $ 128)) $)
                           (PROGN
                            (LETT #1# NIL . #5#)
                            (SEQ
                             (LETT |i| (SPADCALL |n| (QREFELT $ 129)) . #5#)
                             (LETT #4# (QVSIZE |n|) . #5#) G190
                             (COND ((> |i| #4#) (GO G191)))
                             (SEQ
                              (EXIT
                               (PROGN
                                (LETT #3# (|PFO;aklist| (QAREF1O |n| |i| 1) $)
                                      . #5#)
                                (COND
                                 (#1#
                                  (LETT #2# (SPADCALL #2# #3# (QREFELT $ 43))
                                        . #5#))
                                 ('T
                                  (PROGN
                                   (LETT #2# #3# . #5#)
                                   (LETT #1# 'T . #5#)))))))
                             (LETT |i| (+ |i| 1) . #5#) (GO G190) G191
                             (EXIT NIL))
                            (COND (#1# #2#)
                                  ('T (|IdentityError| '|setUnion|))))
                           (QREFELT $ 43))
                 (QREFELT $ 131))))))) 

(DEFUN |PFO;alglist!0| (|k1| $$)
  (PROG ($ ALGOP)
    (LETT $ (QREFELT $$ 1) . #1=(|PFO;alglist|))
    (LETT ALGOP (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |k1| (QREFELT $ 125)) ALGOP (QREFELT $ 127)))))) 

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

(DEFUN |PFO;krmod!0| (|z1| $$)
  (PROG (|k| $)
    (LETT |k| (QREFELT $$ 1) . #1=(|PFO;krmod|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|PFO;kqmod| |z1| |k| $))))) 

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

(DEFUN |PFO;raise| (|p| |k| $)
  (SPADCALL (SPADCALL (CONS (|function| |PFO;Q2F|) $) |p| (QREFELT $ 138))
            (SPADCALL |k| (QREFELT $ 81)) (QREFELT $ 139))) 

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

(DEFUN |PFO;raise2!0| (|z1| $$)
  (PROG (|k| $)
    (LETT |k| (QREFELT $$ 1) . #1=(|PFO;raise2|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|PFO;raise| |z1| |k| $))))) 

(DEFUN |PFO;algcurve| (|d| |rc| |k| $)
  (PROG (|sae| |alpha| |m| |gf| |mm| |pp| |p| |pr| |dd| |s| |b2| |b| |h| |hh|
         |mn| |n| |i|)
    (RETURN
     (SEQ
      (LETT |mn|
            (SPADCALL
             (LETT |n|
                   (SPADCALL
                    (LETT |i|
                          (SPADCALL (SPADCALL |d| (QREFELT $ 121))
                                    (QREFELT $ 140))
                          . #1=(|PFO;algcurve|))
                    (QREFELT $ 123))
                   . #1#)
             (QREFELT $ 129))
            . #1#)
      (LETT |h|
            (|PFO;kpmod|
             (SPADCALL
              (LETT |hh| (SPADCALL |n| (+ |mn| 1) (QREFELT $ 141)) . #1#)
              (QREFELT $ 119))
             |k| $)
            . #1#)
      (LETT |b2|
            (SPADCALL
             (|PFO;raise2|
              (LETT |b|
                    (|PFO;krmod|
                     (SPADCALL
                      (SPADCALL (SPADCALL |n| |mn| (QREFELT $ 141))
                                (QREFELT $ 142))
                      (QREFELT $ 113))
                     |k| $)
                    . #1#)
              |k| $)
             (QREFELT $ 143))
            . #1#)
      (LETT |s|
            (|PFO;kqmod|
             (SPADCALL
              (SPADCALL
               (QCAR
                (SPADCALL
                 (|PFO;raise2|
                  (|PFO;krmod|
                   (SPADCALL (SPADCALL |hh| (QREFELT $ 144)) (QREFELT $ 113))
                   |k| $)
                  |k| $)
                 |b2| (QREFELT $ 146)))
               (QREFELT $ 143))
              |b2| (QREFELT $ 147))
             |k| $)
            . #1#)
      (LETT |pr|
            (|PFO;kgetGoodPrime| |rc| |s| |h| |b|
             (LETT |dd| (|PFO;krmod| (SPADCALL |i| (QREFELT $ 128)) |k| $)
                   . #1#)
             $)
            . #1#)
      (LETT |p| (QCAR |pr|) . #1#)
      (LETT |pp| (|PFO;UP32UPUP| (QVELT |rc| 0) |k| $) . #1#)
      (LETT |mm| (QCDR |pr|) . #1#) (LETT |gf| (|InnerPrimeField| |p|) . #1#)
      (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|)))
            . #1#)
      (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|))
                . #1#)
          (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|)
                . #1#)
          (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| (|z1| $$)
  (PROG (|gf| $ |k| |sae|)
    (LETT |gf| (QREFELT $$ 3) . #1=(|PFO;algcurve|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |k| (QREFELT $$ 1) . #1#)
    (LETT |sae| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (SPADCALL
          (SPADCALL (CONS #'|PFO;algcurve!3| (VECTOR |gf| $))
                    (|PFO;kqmod| |z1| |k| $)
                    (|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|)))
                                 |sae|)))))))) 

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

(DEFUN |PFO;algcurve!2| (|z1| $$)
  (PROG (|gf| $ |k| |alpha|)
    (LETT |gf| (QREFELT $$ 3) . #1=(|PFO;algcurve|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |k| (QREFELT $$ 1) . #1#)
    (LETT |alpha| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG ()
        (RETURN
         (SPADCALL
          (SPADCALL (CONS #'|PFO;algcurve!1| (VECTOR |gf| $))
                    (|PFO;kqmod| |z1| |k| $)
                    (|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|)))
          |alpha|
          (|compiledLookupCheck| '|elt|
                                 (LIST (|devaluate| |gf|) '$
                                       (|devaluate| |gf|))
                                 (|SparseUnivariatePolynomial| |gf|))))))))) 

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

(DEFUN |PFO;algcurve!0| (|z1| $$)
  (PROG ($ |gf|)
    (LETT $ (QREFELT $$ 1) . #1=(|PFO;algcurve|))
    (LETT |gf| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL |z1| (QREFELT $ 107))
                (|compiledLookupCheck| '|coerce| (LIST '$ (LIST '|Integer|))
                                       |gf|)))))) 

(DEFUN |PFO;ratcurve| (|d| |rc| $)
  (PROG (|m| |n| |p| |pp| |bad| |r| |bd| |s| |b| |h| |hh| |mn| |nm| |i|)
    (RETURN
     (SEQ
      (LETT |mn|
            (SPADCALL
             (LETT |nm|
                   (SPADCALL
                    (LETT |i|
                          (SPADCALL (SPADCALL |d| (QREFELT $ 121))
                                    (QREFELT $ 140))
                          . #1=(|PFO;ratcurve|))
                    (QREFELT $ 123))
                   . #1#)
             (QREFELT $ 129))
            . #1#)
      (LETT |h|
            (|PFO;pmod|
             (SPADCALL
              (LETT |hh| (SPADCALL |nm| (+ |mn| 1) (QREFELT $ 141)) . #1#)
              (QREFELT $ 119))
             $)
            . #1#)
      (LETT |b|
            (|PFO;rmod|
             (SPADCALL
              (SPADCALL (SPADCALL |nm| |mn| (QREFELT $ 141)) (QREFELT $ 142))
              (QREFELT $ 113))
             $)
            . #1#)
      (LETT |s|
            (QCAR
             (SPADCALL
              (|PFO;rmod|
               (SPADCALL (SPADCALL |hh| (QREFELT $ 144)) (QREFELT $ 113)) $)
              |b| (QREFELT $ 150)))
            . #1#)
      (LETT |bd|
            (SPADCALL (|PFO;rmod| (SPADCALL |i| (QREFELT $ 128)) $)
                      (QREFELT $ 63))
            . #1#)
      (LETT |r| (SPADCALL |s| |b| (QREFELT $ 151)) . #1#)
      (LETT |bad|
            (SPADCALL
             (LIST (QCDR |rc|) (SPADCALL |r| (QREFELT $ 20))
                   (SPADCALL |r| (QREFELT $ 22)) (* (QCAR |bd|) (QCDR |bd|))
                   (SPADCALL |h| (QREFELT $ 152)))
             (QREFELT $ 70))
            . #1#)
      (LETT |pp| (|PFO;Q2UPUP| (QCAR |rc|) $) . #1#)
      (LETT |n|
            (|PFO;rat| |pp| |d|
             (LETT |p| (SPADCALL |bad| (QREFELT $ 154)) . #1#) $)
            . #1#)
      (EXIT
       (COND ((EQL |n| 1) |n|)
             (#2='T
              (SEQ
               (LETT |m|
                     (|PFO;rat| |pp| |d|
                      (SPADCALL (SPADCALL |p| |bad| (QREFELT $ 155))
                                (QREFELT $ 154))
                      $)
                     . #1#)
               (EXIT (COND ((EQL |n| |m|) |n|) (#2# 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| (|q1| $$)
  (PROG ($ |gf|)
    (LETT $ (QREFELT $$ 1) . #1=(|PFO;rat|))
    (LETT |gf| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|qq|)
        (RETURN
         (SEQ (LETT |qq| (|PFO;qmod| |q1| $) NIL)
              (EXIT
               (SPADCALL
                (SPADCALL (SPADCALL |qq| (QREFELT $ 20))
                          (|compiledLookupCheck| '|coerce|
                                                 (LIST '$ (LIST '|Integer|))
                                                 |gf|))
                (SPADCALL (SPADCALL |qq| (QREFELT $ 22))
                          (|compiledLookupCheck| '|coerce|
                                                 (LIST '$ (LIST '|Integer|))
                                                 |gf|))
                (|compiledLookupCheck| '/ (LIST '$ '$ '$) |gf|)))))))))) 

(DEFUN |PFO;possibleOrder| (|d| $)
  (PROG (|la|)
    (RETURN
     (COND
      ((OR (ZEROP (SPADCALL (QREFELT $ 157)))
           (EQL
            (QVSIZE (SPADCALL (SPADCALL |d| (QREFELT $ 121)) (QREFELT $ 123)))
            1))
       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"))
        (#1#
         (|PFO;algcurve| |d| (|PFO;selectIntegers| (|SPADfirst| |la|) $)
          (|SPADfirst| |la|) $)))))))) 

(DEFUN |PFO;selIntegers| ($)
  (PROG (|d| |r| |f|)
    (RETURN
     (SEQ (LETT |f| (SPADCALL (QREFELT $ 158)) . #1=(|PFO;selIntegers|))
          (SEQ G190
               (COND
                ((NULL
                  (ZEROP
                   (LETT |d|
                         (SPADCALL
                          (LETT |r|
                                (SPADCALL (|PFO;pmod| |f| $) (QREFELT $ 159))
                                . #1#)
                          (QREFELT $ 160))
                         . #1#)))
                 (GO G191)))
               (SEQ (EXIT (SPADCALL (QREFELT $ 162)))) NIL (GO G190) G191
               (EXIT NIL))
          (EXIT (CONS |r| |d|)))))) 

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

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

(DEFUN |PFO;toQ1!0| (|p1| $$)
  (PROG (|d| $)
    (LETT |d| (QREFELT $$ 1) . #1=(|PFO;toQ1|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|PFO;Q2F| (SPADCALL (SPADCALL |p1| |d| (QREFELT $ 60)) (QREFELT $ 168))
       $))))) 

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

(DEFUN |PFO;toQ2!0| (|p1| $$)
  (PROG (|d| $)
    (LETT |d| (QREFELT $$ 1) . #1=(|PFO;toQ2|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL (|PFO;toQ1| |p1| |d| $) (QREFELT $ 87)))))) 

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

(DEFUN |PFO;kpmod!0| (|p1| $$)
  (PROG ($ |k|)
    (LETT $ (QREFELT $$ 1) . #1=(|PFO;kpmod|))
    (LETT |k| (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|PFO;krmod| (SPADCALL |p1| (QREFELT $ 113)) |k| $))))) 

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

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

(DEFUN |PFO;goodRed| (|rec| |res| |h| |b| |d| |p| $)
  (PROG (|md| |mdg| #1=#:G2210 |ff| |l| #2=#:G2209 |f| #3=#:G2208 |gf|)
    (RETURN
     (SEQ
      (COND ((ZEROP (REMAINDER2 (QVELT |rec| 1) |p|)) (CONS 1 "failed"))
            (#4='T
             (SEQ (LETT |gf| (|InnerPrimeField| |p|) . #5=(|PFO;goodRed|))
                  (LETT |l|
                        (PROGN
                         (LETT #3# NIL . #5#)
                         (SEQ (LETT |f| NIL . #5#)
                              (LETT #2#
                                    (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|))))
                                    . #5#)
                              G190
                              (COND
                               ((OR (ATOM #2#)
                                    (PROGN (LETT |f| (CAR #2#) . #5#) NIL))
                                #6=(GO G191)))
                              (SEQ
                               (EXIT
                                (COND
                                 ((EQL (QCDR |f|) 1)
                                  (LETT #3# (CONS (QCAR |f|) #3#) . #5#)))))
                              (LETT #2# (CDR #2#) . #5#) #7=(GO G190) G191
                              (EXIT (NREVERSE0 #3#))))
                        . #5#)
                  (EXIT
                   (COND ((NULL |l|) (CONS 1 "failed"))
                         (#4#
                          (SEQ (LETT |mdg| (|SPADfirst| |l|) . #5#)
                               (SEQ (LETT |ff| NIL . #5#)
                                    (LETT #1# (CDR |l|) . #5#) G190
                                    (COND
                                     ((OR (ATOM #1#)
                                          (PROGN
                                           (LETT |ff| (CAR #1#) . #5#)
                                           NIL))
                                      #6#))
                                    (SEQ
                                     (EXIT
                                      (COND
                                       ((<
                                         (SPADCALL |ff|
                                                   (|compiledLookupCheck|
                                                    '|degree|
                                                    (LIST
                                                     (LIST
                                                      '|NonNegativeInteger|)
                                                     '$)
                                                    (|SparseUnivariatePolynomial|
                                                     |gf|)))
                                         (SPADCALL |mdg|
                                                   (|compiledLookupCheck|
                                                    '|degree|
                                                    (LIST
                                                     (LIST
                                                      '|NonNegativeInteger|)
                                                     '$)
                                                    (|SparseUnivariatePolynomial|
                                                     |gf|))))
                                        (LETT |mdg| |ff| . #5#)))))
                                    (LETT #1# (CDR #1#) . #5#) #7# 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|)))))
                                     . #5#)
                               (EXIT
                                (COND
                                 ((|PFO;good?| |res| |h| |b| |d| |p| |md| $)
                                  (CONS 0 |md|))
                                 (#4# (CONS 1 "failed"))))))))))))))) 

(DEFUN |PFO;goodRed!1| (|z1| $$)
  (PROG (|gf| $)
    (LETT |gf| (QREFELT $$ 1) . #1=(|PFO;goodRed|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL
       (SPADCALL |z1|
                 (|compiledLookupCheck| '|convert| (LIST (LIST '|Integer|) '$)
                                        |gf|))
       (QREFELT $ 176)))))) 

(DEFUN |PFO;goodRed!0| (|z1| $$)
  (PROG ($ |gf|)
    (LETT $ (QREFELT $$ 1) . #1=(|PFO;goodRed|))
    (LETT |gf| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (SPADCALL |z1| (QREFELT $ 107))
                (|compiledLookupCheck| '|coerce| (LIST '$ (LIST '|Integer|))
                                       |gf|)))))) 

(DEFUN |PFO;good?| (|res| |h| |b| |d| |p| |m| $)
  (PROG (|bd|)
    (RETURN
     (SEQ
      (LETT |bd| (SPADCALL (SPADCALL |res| |m| (QREFELT $ 60)) (QREFELT $ 63))
            |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 #1=#:G2218)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2219)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (|devaluateList| #1#)
                                           (HGET |$ConstructorCache|
                                                 '|PointsOfFiniteOrder|)
                                           '|domainEqualList|)
                . #3=(|PointsOfFiniteOrder|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (APPLY (|function| |PointsOfFiniteOrder;|) #1#)
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|PointsOfFiniteOrder|))))))))))) 

(DEFUN |PointsOfFiniteOrder;| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (|pv$| $ |dv$| DV$5 DV$4 DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|PointsOfFiniteOrder|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT DV$3 (|devaluate| |#3|) . #1#)
      (LETT DV$4 (|devaluate| |#4|) . #1#)
      (LETT DV$5 (|devaluate| |#5|) . #1#)
      (LETT |dv$| (LIST '|PointsOfFiniteOrder| DV$1 DV$2 DV$3 DV$4 DV$5) . #1#)
      (LETT $ (GETREFV 177) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|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 $ 11 '|%alg|)
      (QSETREFV $ 12 (|FunctionSpaceReduce| |#1| |#2|))
      (COND
       ((|HasCategory| |#1| '(|GcdDomain|))
        (QSETREFV $ 94 (CONS (|dispatchFunction| |PFO;cmult;LSmp;16|) $)))
       ('T (QSETREFV $ 94 (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|) 'ALGOP '|q|
              (|Union| 156 '"failed") (|FiniteDivisor| 7 8 9 10)
              |PFO;order;FdU;36| (|Boolean|) |PFO;torsion?;FdB;1| (|Integer|)
              (|Fraction| 18) (0 . |numer|) (5 . |coerce|) (10 . |denom|)
              (15 . /) (21 . |bringDown|) (|SparseUnivariatePolynomial| 19)
              (|Kernel| 7) (26 . |bringDown|) (|Mapping| 19 7)
              (|SparseUnivariatePolynomial| 7)
              (|SparseUnivariatePolynomialFunctions2| 7 19) (32 . |map|)
              (|SparseUnivariatePolynomial| (|Fraction| 25))
              (|MultipleMap| 7 8 9 19 25 32) (38 . |map|) (|Mapping| 7 19)
              (|MultipleMap| 19 25 32 7 8 9) (44 . |map|) (|List| 7)
              (50 . |coefficients|) (|List| 80) (55 . |kernels|) (|List| 26)
              (60 . |setUnion|) (66 . |One|) (70 . |One|) (74 . |One|)
              (78 . |One|) (82 . |One|) (86 . |One|) (|Factored| 25)
              (|RationalFactorize| 25) (90 . |factor|)
              (|Record| (|:| |factor| 25) (|:| |exponent| 18)) (|List| 53)
              (95 . |factors|) (100 . |One|) (|List| 25)
              (|SparseUnivariatePolynomial| 25) (104 . |coefficients|)
              (109 . |rem|) (|Record| (|:| |den| 18) (|:| |gcdnum| 18))
              (|PointsOfFiniteOrderTools| 25 32) (115 . |badNum|) (|List| 61)
              (120 . |mix|) (|List| 58) (|SparseUnivariatePolynomial| 58)
              (125 . |coefficients|) (|List| $) (130 . |lcm|) (135 . |reduce|)
              (140 . *) (|Union| 10 '"failed") (146 . |generator|)
              (|Record| (|:| |order| 156) (|:| |function| 10))
              (|Union| 75 '"failed") |PFO;torsionIfCan;FdU;12|
              (|UnivariatePolynomialCategoryFunctions2| 19 25 7 8)
              (151 . |map|) (|Kernel| $) (157 . |coerce|) (162 . |elt|)
              (|Mapping| 7 25)
              (|UnivariatePolynomialCategoryFunctions2| 25 58 7 8)
              (168 . |map|) (|Fraction| 8) (174 . |coerce|) (|Mapping| 86 58)
              (|UnivariatePolynomialCategoryFunctions2| 58 67 86 9)
              (179 . |map|) (|SparseMultivariatePolynomial| 6 26) (185 . |lcm|)
              (|List| 91) (190 . |cmult|) (195 . *) (201 . |One|)
              (205 . |discriminant|) (210 . |differentiate|) (215 . |gcd|)
              (|Union| $ '"failed") (221 . |exquo|) (227 . |discriminant|)
              (231 . |discriminant|) (236 . |zero?|) (|List| 19)
              (241 . |coefficients|) (246 . |retract|) (251 . |gcd|)
              (|SparseMultivariatePolynomial| 6 80) (256 . |denom|) (|List| 86)
              (261 . |coefficients|) (266 . |retract|) (271 . |coerce|)
              (276 . |coerce|) (281 . *) (|Union| 86 '"failed")
              (287 . |retractIfCan|) (292 . |lift|)
              (|FractionalIdeal| 8 86 9 10) (297 . |ideal|) (|Vector| 10)
              (302 . |numer|) (|BasicOperator|) (307 . |operator|) (|Symbol|)
              (312 . |has?|) (318 . |denom|) (323 . |minIndex|)
              (|Mapping| 16 26) (328 . |select!|) (|Mapping| 25 7)
              (|UnivariatePolynomialCategoryFunctions2| 7 8 25 58)
              (334 . |map|)
              (|UnivariatePolynomialCategoryFunctions2| 7 8 19 25)
              (340 . |map|) (|SparseUnivariatePolynomialFunctions2| 19 7)
              (346 . |map|) (352 . |elt|) (358 . |minimize|) (363 . |elt|)
              (369 . |retract|) (374 . |primitivePart|) (379 . |norm|)
              (|Record| (|:| |primePart| $) (|:| |commonPart| $))
              (384 . |separate|) (390 . |resultant|) (396 . |Zero|)
              (400 . |Zero|) (404 . |separate|) (410 . |resultant|)
              (416 . |badNum|) (|PositiveInteger|) (421 . |getGoodPrime|)
              (426 . *) (|NonNegativeInteger|) (432 . |genus|)
              (436 . |definingPolynomial|) (440 . |polyred|)
              (445 . |doubleDisc|) (|Void|) (450 . |newReduc|)
              (|SparseUnivariatePolynomial| $) (454 . |minPoly|)
              (|Record| (|:| |num| 25) (|:| |den| 18))
              (|UnivariatePolynomialCommonDenominator| 18 19 25)
              (459 . |splitDenominator|) (464 . |retract|) (469 . |reduce|)
              (|Mapping| 58 86)
              (|UnivariatePolynomialCategoryFunctions2| 86 9 58 67)
              (474 . |map|) (480 . |principal?|) (|IntegerPrimesPackage| 18)
              (485 . |nextPrime|) (490 . |coerce|))
           '#(|torsionIfCan| 495 |torsion?| 500 |order| 505 |cmult| 510) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 176
                                                 '(1 19 18 0 20 1 7 0 18 21 1
                                                   19 18 0 22 2 7 0 0 0 23 1 12
                                                   19 7 24 2 12 25 7 26 27 2 30
                                                   25 28 29 31 2 33 32 28 9 34
                                                   2 36 9 35 32 37 1 8 38 0 39
                                                   1 7 40 0 41 2 42 0 0 0 43 0
                                                   6 0 44 0 7 0 45 0 8 0 46 0 9
                                                   0 47 0 10 0 48 0 25 0 49 1
                                                   51 50 25 52 1 50 54 0 55 0
                                                   50 0 56 1 58 57 0 59 2 25 0
                                                   0 0 60 1 62 61 25 63 1 62 18
                                                   64 65 1 67 66 0 68 1 18 0 69
                                                   70 1 14 0 0 71 2 14 0 18 0
                                                   72 1 14 73 0 74 2 78 8 35 25
                                                   79 1 7 0 80 81 2 8 7 0 7 82
                                                   2 84 8 83 58 85 1 86 0 8 87
                                                   2 89 9 88 67 90 1 91 0 69 92
                                                   1 0 91 93 94 2 91 0 0 0 95 0
                                                   91 0 96 1 67 58 0 97 1 58 0
                                                   0 98 2 58 0 0 0 99 2 58 100
                                                   0 0 101 0 10 86 102 1 58 25
                                                   0 103 1 25 16 0 104 1 25 105
                                                   0 106 1 19 18 0 107 1 18 0
                                                   69 108 1 7 109 0 110 1 9 111
                                                   0 112 1 86 8 0 113 1 7 0 109
                                                   114 1 8 0 7 115 2 9 0 86 0
                                                   116 1 10 117 0 118 1 10 9 0
                                                   119 1 14 120 0 121 1 120 122
                                                   0 123 1 26 124 0 125 2 124
                                                   16 0 126 127 1 120 8 0 128 1
                                                   122 18 0 129 2 42 0 130 0
                                                   131 2 133 58 132 8 134 2 135
                                                   25 28 8 136 2 137 29 35 25
                                                   138 2 29 7 0 7 139 1 120 0 0
                                                   140 2 122 10 0 18 141 1 10
                                                   86 0 142 1 8 0 0 143 1 10 86
                                                   0 144 2 8 145 0 0 146 2 8 7
                                                   0 0 147 0 6 0 148 0 7 0 149
                                                   2 25 145 0 0 150 2 25 19 0 0
                                                   151 1 62 18 32 152 1 62 153
                                                   18 154 2 18 0 153 0 155 0 10
                                                   156 157 0 10 9 158 1 62 32
                                                   32 159 1 62 18 32 160 0 12
                                                   161 162 1 7 163 80 164 1 166
                                                   165 25 167 1 25 19 0 168 1
                                                   10 0 9 169 2 171 67 170 9
                                                   172 1 14 16 0 173 1 174 18
                                                   18 175 1 19 0 18 176 1 0 76
                                                   14 77 1 0 16 14 17 1 0 13 14
                                                   15 1 0 91 93 94)))))
           '|lookupComplete|)) 
