
(/VERSIONCHECK 2) 

(DEFUN |PGCD;failtest| (|f| |p1| |p2| $)
  (COND ((QEQCAR (SPADCALL |p1| |f| (QREFELT $ 19)) 1) 'T)
        ('T (QEQCAR (SPADCALL |p2| |f| (QREFELT $ 19)) 1)))) 

(DEFUN |PGCD;chooseVal| (|p1| |p2| |lvr| |ltry| $)
  (PROG (|dd| #1=#:G1864 #2=#:G1858 |f| #3=#:G1855 |uterm| |ugcd| #4=#:G1849
         |du| |u| |uf2| |uf1| |lval| |i| #5=#:G1865 |range| |nvr| |d2| |d1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |d1| (SPADCALL |p1| (QREFELT $ 21)) . #6=(|PGCD;chooseVal|))
            (LETT |d2| (SPADCALL |p2| (QREFELT $ 21)) . #6#)
            (LETT |dd| 0 . #6#) (LETT |nvr| (LENGTH |lvr|) . #6#)
            (LETT |lval| NIL . #6#) (LETT |range| 8 . #6#)
            (EXIT
             (SEQ G190 NIL
                  (SEQ (LETT |range| (SPADCALL 2 |range| (QREFELT $ 22)) . #6#)
                       (LETT |lval|
                             (PROGN
                              (LETT #5# NIL . #6#)
                              (SEQ (LETT |i| 1 . #6#) G190
                                   (COND ((QSGREATERP |i| |nvr|) (GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #5#
                                           (CONS
                                            (SPADCALL |range| (QREFELT $ 24))
                                            #5#)
                                           . #6#)))
                                   (LETT |i| (QSADD1 |i|) . #6#) #7=(GO G190)
                                   G191 (EXIT (NREVERSE0 #5#))))
                             . #6#)
                       (EXIT
                        (COND
                         ((SPADCALL |lval| |ltry| (QREFELT $ 28)) "new point")
                         ('T
                          (SEQ (LETT |ltry| (CONS |lval| |ltry|) . #6#)
                               (LETT |uf1|
                                     (SPADCALL |p1| |lvr| |lval|
                                               (QREFELT $ 31))
                                     . #6#)
                               (COND
                                ((NULL
                                  (EQL (SPADCALL |uf1| (QREFELT $ 32)) |d1|))
                                 (EXIT "new point")))
                               (LETT |uf2|
                                     (SPADCALL |p2| |lvr| |lval|
                                               (QREFELT $ 31))
                                     . #6#)
                               (COND
                                ((NULL
                                  (EQL (SPADCALL |uf2| (QREFELT $ 32)) |d2|))
                                 (EXIT "new point")))
                               (LETT |u| (SPADCALL |uf1| |uf2| (QREFELT $ 33))
                                     . #6#)
                               (LETT |du| (SPADCALL |u| (QREFELT $ 32)) . #6#)
                               (COND
                                ((EQL |du| 0)
                                 (PROGN
                                  (LETT #1#
                                        (CONS 0
                                              (VECTOR
                                               (LIST (|spadConstant| $ 36))
                                               |ltry| (|spadConstant| $ 37)))
                                        . #6#)
                                  (GO #1#))))
                               (LETT |ugcd|
                                     (LIST |u|
                                           (PROG2
                                               (LETT #4#
                                                     (SPADCALL |uf1| |u|
                                                               (QREFELT $ 38))
                                                     . #6#)
                                               (QCDR #4#)
                                             (|check-union| (QEQCAR #4# 0)
                                                            (|SparseUnivariatePolynomial|
                                                             (QREFELT $ 8))
                                                            #4#))
                                           (PROG2
                                               (LETT #4#
                                                     (SPADCALL |uf2| |u|
                                                               (QREFELT $ 38))
                                                     . #6#)
                                               (QCDR #4#)
                                             (|check-union| (QEQCAR #4# 0)
                                                            (|SparseUnivariatePolynomial|
                                                             (QREFELT $ 8))
                                                            #4#)))
                                     . #6#)
                               (LETT |uterm|
                                     (VECTOR |ugcd| |ltry|
                                             (|spadConstant| $ 37))
                                     . #6#)
                               (EXIT
                                (COND ((EQL |dd| 0) (LETT |dd| |du| . #6#))
                                      ((EQL |du| |dd|)
                                       (COND
                                        ((EQL |dd| |d1|)
                                         (SEQ
                                          (SEQ
                                           (LETT |f|
                                                 (SPADCALL |p2| |p1|
                                                           (QREFELT $ 19))
                                                 . #6#)
                                           (EXIT
                                            (COND
                                             ((NULL (QEQCAR |f| 1))
                                              (PROGN
                                               (LETT #1#
                                                     (CONS 0
                                                           (VECTOR (LIST |u|)
                                                                   |ltry|
                                                                   |p1|))
                                                     . #6#)
                                               (GO #1#))))))
                                          (EXIT
                                           (COND
                                            ((NULL (EQL |dd| |d2|))
                                             (LETT |dd|
                                                   (PROG1
                                                       (LETT #3# (- |dd| 1)
                                                             . #6#)
                                                     (|check-subtype|
                                                      (>= #3# 0)
                                                      '(|NonNegativeInteger|)
                                                      #3#))
                                                   . #6#))))))
                                        ((EQL |dd| |d2|)
                                         (SEQ
                                          (SEQ
                                           (LETT |f|
                                                 (SPADCALL |p1| |p2|
                                                           (QREFELT $ 19))
                                                 . #6#)
                                           (EXIT
                                            (COND
                                             ((NULL (QEQCAR |f| 1))
                                              (PROGN
                                               (LETT #1#
                                                     (CONS 0
                                                           (VECTOR (LIST |u|)
                                                                   |ltry|
                                                                   |p2|))
                                                     . #6#)
                                               (GO #1#))))))
                                          (EXIT
                                           (LETT |dd|
                                                 (PROG1
                                                     (LETT #2# (- |dd| 1)
                                                           . #6#)
                                                   (|check-subtype| (>= #2# 0)
                                                                    '(|NonNegativeInteger|)
                                                                    #2#))
                                                 . #6#))))
                                        ('T
                                         (PROGN
                                          (LETT #1# (CONS 0 |uterm|) . #6#)
                                          (GO #1#)))))
                                      ((< |du| |dd|)
                                       (LETT |dd| |du| . #6#)))))))))
                  NIL #7# G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |PGCD;good| (|f| |lvr| |ltry| $)
  (PROG (#1=#:G1872 |uf| |lval| |i| #2=#:G1873 |range| |nvr|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |nvr| (LENGTH |lvr|) . #3=(|PGCD;good|))
            (LETT |range| 1 . #3#)
            (EXIT
             (SEQ G190 (COND ((NULL 'T) #4=(GO G191)))
                  (SEQ (LETT |range| (SPADCALL 2 |range| (QREFELT $ 22)) . #3#)
                       (LETT |lval|
                             (PROGN
                              (LETT #2# NIL . #3#)
                              (SEQ (LETT |i| 1 . #3#) G190
                                   (COND ((QSGREATERP |i| |nvr|) #4#))
                                   (SEQ
                                    (EXIT
                                     (LETT #2#
                                           (CONS
                                            (SPADCALL |range| (QREFELT $ 24))
                                            #2#)
                                           . #3#)))
                                   (LETT |i| (QSADD1 |i|) . #3#) #5=(GO G190)
                                   G191 (EXIT (NREVERSE0 #2#))))
                             . #3#)
                       (EXIT
                        (COND
                         ((SPADCALL |lval| |ltry| (QREFELT $ 28)) "new point")
                         ('T
                          (SEQ (LETT |ltry| (CONS |lval| |ltry|) . #3#)
                               (LETT |uf|
                                     (SPADCALL |f| |lvr| |lval| (QREFELT $ 31))
                                     . #3#)
                               (EXIT
                                (COND
                                 ((EQL
                                   (SPADCALL
                                    (SPADCALL |uf|
                                              (SPADCALL |uf| (QREFELT $ 41))
                                              (QREFELT $ 33))
                                    (QREFELT $ 32))
                                   0)
                                  (PROGN
                                   (LETT #1# (CONS |uf| |ltry|) . #3#)
                                   (GO #1#))))))))))
                  NIL #5# G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |PGCD;imposelc| (|lipol| |lvar| |lval| |leadc| $)
  (PROG (|result| #1=#:G1878 |p1| #2=#:G1884 |pol| #3=#:G1885 |leadpol|)
    (RETURN
     (SEQ (LETT |result| NIL . #4=(|PGCD;imposelc|))
          (SEQ (LETT |leadpol| NIL . #4#) (LETT #3# |leadc| . #4#)
               (LETT |pol| NIL . #4#) (LETT #2# |lipol| . #4#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |pol| (CAR #2#) . #4#) NIL)
                     (ATOM #3#) (PROGN (LETT |leadpol| (CAR #3#) . #4#) NIL))
                 (GO G191)))
               (SEQ
                (LETT |p1|
                      (SPADCALL
                       (SPADCALL
                        (SPADCALL |leadpol| |lvar| |lval| (QREFELT $ 42))
                        (QREFELT $ 43))
                       |pol| (QREFELT $ 44))
                      . #4#)
                (EXIT
                 (LETT |result|
                       (CONS
                        (PROG2
                            (LETT #1#
                                  (SPADCALL |p1|
                                            (SPADCALL |pol| (QREFELT $ 45))
                                            (QREFELT $ 46))
                                  . #4#)
                            (QCDR #1#)
                          (|check-union| (QEQCAR #1# 0)
                                         (|SparseUnivariatePolynomial|
                                          (QREFELT $ 8))
                                         #1#))
                        |result|)
                       . #4#)))
               (LETT #2# (PROG1 (CDR #2#) (LETT #3# (CDR #3#) . #4#)) . #4#)
               (GO G190) G191 (EXIT NIL))
          (EXIT (REVERSE |result|)))))) 

(DEFUN |PGCD;notCoprime| (|g| |p2| |ldeg| |lvar1| |ltry| $)
  (PROG (|ulist| #1=#:G1894 #2=#:G1905 |uf| #3=#:G1904 |gd1| |dl| |ul| |l|
         |gd2| #4=#:G1903 |gdl| |lgcd| |lquo| |d| |lcpol| |ug1| |lval|
         |newchoice| |#G32| |#G31| |p2l| #5=#:G1887 |#G30| |#G29| |lg| |l1|
         |g1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |g1| (SPADCALL |g| (SPADCALL |g| (QREFELT $ 47)) (QREFELT $ 48))
              . #6=(|PGCD;notCoprime|))
        (LETT |l1|
              (PROG2
                  (LETT #5# (SPADCALL |g| |g1| (QREFELT $ 19)) . #6#)
                  (QCDR #5#)
                (|check-union| (QEQCAR #5# 0)
                               (|SparseUnivariatePolynomial| (QREFELT $ 9))
                               #5#))
              . #6#)
        (LETT |lg| (|PGCD;localgcd| |l1| |p2| |lvar1| |ltry| $) . #6#)
        (PROGN
         (LETT |#G29| (QCAR |lg|) . #6#)
         (LETT |#G30| (QCDR |lg|) . #6#)
         (LETT |l| |#G29| . #6#)
         (LETT |ltry| |#G30| . #6#))
        (LETT |lval| (|SPADfirst| |ltry|) . #6#)
        (LETT |p2l|
              (PROG2
                  (LETT #5# (SPADCALL |p2| |l| (QREFELT $ 19)) . #6#)
                  (QCDR #5#)
                (|check-union| (QEQCAR #5# 0)
                               (|SparseUnivariatePolynomial| (QREFELT $ 9))
                               #5#))
              . #6#)
        (PROGN
         (LETT |#G31| |l| . #6#)
         (LETT |#G32| |l| . #6#)
         (LETT |gd1| |#G31| . #6#)
         (LETT |gd2| |#G32| . #6#))
        (LETT |ul| (SPADCALL |l| |lvar1| |lval| (QREFELT $ 31)) . #6#)
        (LETT |dl| (SPADCALL |ul| (QREFELT $ 32)) . #6#)
        (COND
         ((NULL
           (EQL
            (SPADCALL
             (SPADCALL |ul| (SPADCALL |ul| (QREFELT $ 41)) (QREFELT $ 33))
             (QREFELT $ 32))
            0))
          (SEQ (LETT |newchoice| (|PGCD;good| |l| |lvar1| |ltry| $) . #6#)
               (LETT |ul| (QCAR |newchoice|) . #6#)
               (LETT |ltry| (QCDR |newchoice|) . #6#)
               (EXIT (LETT |lval| (|SPADfirst| |ltry|) . #6#)))))
        (LETT |ug1| (SPADCALL |g1| |lvar1| |lval| (QREFELT $ 31)) . #6#)
        (LETT |ulist|
              (LIST |ug1| (SPADCALL |p2l| |lvar1| |lval| (QREFELT $ 31)))
              . #6#)
        (LETT |lcpol|
              (LIST (SPADCALL |g1| (QREFELT $ 49))
                    (SPADCALL |p2| (QREFELT $ 49)))
              . #6#)
        (EXIT
         (SEQ G190 (COND ((NULL 'T) #7=(GO G191)))
              (SEQ
               (LETT |d| (SPADCALL (CONS |ul| |ulist|) (QREFELT $ 51)) . #6#)
               (COND
                ((EQL (SPADCALL |d| (QREFELT $ 32)) 0)
                 (PROGN (LETT #4# |gd1| . #6#) (GO #4#))))
               (LETT |lquo|
                     (PROG2
                         (LETT #1# (SPADCALL |ul| |d| (QREFELT $ 38)) . #6#)
                         (QCDR #1#)
                       (|check-union| (QEQCAR #1# 0)
                                      (|SparseUnivariatePolynomial|
                                       (QREFELT $ 8))
                                      #1#))
                     . #6#)
               (COND
                ((NULL (EQL (SPADCALL |lquo| (QREFELT $ 32)) 0))
                 (SEQ
                  (LETT |lgcd|
                        (SPADCALL (CONS (SPADCALL |l| (QREFELT $ 49)) |lcpol|)
                                  (QREFELT $ 53))
                        . #6#)
                  (LETT |gdl|
                        (|PGCD;lift| |l| |d| |lquo| |lgcd| |lvar1| |ldeg|
                         |lval| $)
                        . #6#)
                  (EXIT
                   (COND
                    ((QEQCAR |gdl| 1)
                     (PROGN
                      (LETT #4#
                            (|PGCD;notCoprime| |g| |p2| |ldeg| |lvar1| |ltry|
                             $)
                            . #6#)
                      (GO #4#)))
                    ('T
                     (SEQ (LETT |l| (LETT |gd2| (QCDR |gdl|) . #6#) . #6#)
                          (LETT |ul|
                                (SPADCALL |l| |lvar1| |lval| (QREFELT $ 31))
                                . #6#)
                          (EXIT
                           (LETT |dl| (SPADCALL |ul| (QREFELT $ 32))
                                 . #6#)))))))))
               (LETT |gd1| (SPADCALL |gd1| |gd2| (QREFELT $ 54)) . #6#)
               (EXIT
                (LETT |ulist|
                      (PROGN
                       (LETT #3# NIL . #6#)
                       (SEQ (LETT |uf| NIL . #6#) (LETT #2# |ulist| . #6#) G190
                            (COND
                             ((OR (ATOM #2#)
                                  (PROGN (LETT |uf| (CAR #2#) . #6#) NIL))
                              #7#))
                            (SEQ
                             (EXIT
                              (LETT #3#
                                    (CONS
                                     (PROG2
                                         (LETT #1#
                                               (SPADCALL |uf| |d|
                                                         (QREFELT $ 38))
                                               . #6#)
                                         (QCDR #1#)
                                       (|check-union| (QEQCAR #1# 0)
                                                      (|SparseUnivariatePolynomial|
                                                       (QREFELT $ 8))
                                                      #1#))
                                     #3#)
                                    . #6#)))
                            (LETT #2# (CDR #2#) . #6#) #8=(GO G190) G191
                            (EXIT (NREVERSE0 #3#))))
                      . #6#)))
              NIL #8# G191 (EXIT NIL)))))
      #4# (EXIT #4#))))) 

(DEFUN |PGCD;gcdPrimitive;3Sup;6| (|p1| |p2| $)
  (PROG (|result| |totResult| |ltry| |lvar| |d2| |d1| |#G39| |#G38| |#G37|
         |#G36|)
    (RETURN
     (SEQ
      (SEQ
       (LETT |d2| (SPADCALL |p2| (QREFELT $ 21))
             . #1=(|PGCD;gcdPrimitive;3Sup;6|))
       (LETT |d1| (SPADCALL |p1| (QREFELT $ 21)) . #1#)
       (EXIT
        (COND
         ((< |d2| |d1|)
          (SEQ
           (PROGN
            (LETT |#G36| |p2| . #1#)
            (LETT |#G37| |p1| . #1#)
            (LETT |p1| |#G36| . #1#)
            (LETT |p2| |#G37| . #1#))
           (EXIT
            (PROGN
             (LETT |#G38| |d2| . #1#)
             (LETT |#G39| |d1| . #1#)
             (LETT |d1| |#G38| . #1#)
             (LETT |d2| |#G39| . #1#))))))))
      (EXIT
       (COND
        ((EQL (SPADCALL |p1| (QREFELT $ 21)) 0)
         (COND
          ((SPADCALL |p1| (|spadConstant| $ 37) (QREFELT $ 55))
           (SPADCALL |p2| (QREFELT $ 56)))
          (#2='T (SPADCALL |p1| (QREFELT $ 56)))))
        (#2#
         (SEQ
          (LETT |lvar|
                (SPADCALL (CONS #'|PGCD;gcdPrimitive;3Sup;6!0| $)
                          (SPADCALL (SPADCALL |p1| (QREFELT $ 58))
                                    (SPADCALL |p2| (QREFELT $ 58))
                                    (QREFELT $ 59))
                          (QREFELT $ 61))
                . #1#)
          (EXIT
           (COND
            ((NULL |lvar|)
             (SPADCALL
              (SPADCALL (SPADCALL |p1| (QREFELT $ 62))
                        (SPADCALL |p2| (QREFELT $ 62)) (QREFELT $ 33))
              (QREFELT $ 63)))
            ((QEQCAR (SPADCALL |p2| |p1| (QREFELT $ 19)) 0)
             (SPADCALL |p1| (QREFELT $ 56)))
            (#2#
             (SEQ (LETT |ltry| NIL . #1#)
                  (LETT |totResult| (|PGCD;localgcd| |p1| |p2| |lvar| |ltry| $)
                        . #1#)
                  (LETT |result| (QCAR |totResult|) . #1#)
                  (EXIT
                   (COND
                    ((SPADCALL |result| (|spadConstant| $ 64) (QREFELT $ 55))
                     (|spadConstant| $ 64))
                    (#2#
                     (SEQ
                      (SEQ G190
                           (COND
                            ((NULL (|PGCD;failtest| |result| |p1| |p2| $))
                             (GO G191)))
                           (SEQ (LETT |ltry| (QCDR |totResult|) . #1#)
                                (LETT |totResult|
                                      (|PGCD;localgcd| |p1| |p2| |lvar| |ltry|
                                       $)
                                      . #1#)
                                (EXIT
                                 (LETT |result| (QCAR |totResult|) . #1#)))
                           NIL (GO G190) G191 (EXIT NIL))
                      (EXIT |result|))))))))))))))))) 

(DEFUN |PGCD;gcdPrimitive;3Sup;6!0| (|z1| |z2| $)
  (SPADCALL |z2| |z1| (QREFELT $ 57))) 

(DEFUN |PGCD;localgcd| (|p1| |p2| |lvar| |ltry| $)
  (PROG (#1=#:G1928 |h| |ldeg| |dd| |ud| |listpol| |uterm| #2=#:G1834)
    (RETURN
     (SEQ
      (LETT |uterm|
            (PROG2
                (LETT #2# (|PGCD;chooseVal| |p1| |p2| |lvar| |ltry| $)
                      . #3=(|PGCD;localgcd|))
                (QCDR #2#)
              (|check-union| (QEQCAR #2# 0)
                             (|Record|
                              (|:| |lpol|
                                   (|List|
                                    (|SparseUnivariatePolynomial|
                                     (QREFELT $ 8))))
                              (|:| |lint| (|List| (|List| (QREFELT $ 8))))
                              (|:| |mpol|
                                   (|SparseUnivariatePolynomial|
                                    (QREFELT $ 9))))
                             #2#))
            . #3#)
      (LETT |ltry| (QVELT |uterm| 1) . #3#)
      (LETT |listpol| (QVELT |uterm| 0) . #3#)
      (LETT |ud| (|SPADfirst| |listpol|) . #3#)
      (LETT |dd| (SPADCALL |ud| (QREFELT $ 32)) . #3#)
      (EXIT
       (COND ((EQL |dd| 0) (CONS (|spadConstant| $ 64) |ltry|))
             ((OR (EQL |dd| (SPADCALL |p1| (QREFELT $ 21)))
                  (EQL |dd| (SPADCALL |p2| (QREFELT $ 21))))
              (CONS (QVELT |uterm| 2) |ltry|))
             ('T
              (SEQ
               (LETT |ldeg|
                     (SPADCALL (ELT $ 66) (SPADCALL |p1| |lvar| (QREFELT $ 68))
                               (SPADCALL |p2| |lvar| (QREFELT $ 68))
                               (QREFELT $ 70))
                     . #3#)
               (LETT |h| (|PGCD;lift?| |p1| |p2| |uterm| |ldeg| |lvar| $)
                     . #3#)
               (EXIT
                (COND
                 ((QEQCAR |h| 2)
                  (CONS (|PGCD;notCoprime| |p1| |p2| |ldeg| |lvar| |ltry| $)
                        |ltry|))
                 ((QEQCAR |h| 1) (|PGCD;localgcd| |p1| |p2| |lvar| |ltry| $))
                 ('T
                  (CONS
                   (PROG2
                       (LETT #1# |h| . #3#)
                       (QCDR #1#)
                     (|check-union| (QEQCAR #1# 0)
                                    (|SparseUnivariatePolynomial|
                                     (QREFELT $ 9))
                                    #1#))
                   |ltry|)))))))))))) 

(DEFUN |PGCD;monomContent| (|p| $)
  (PROG (|md|)
    (RETURN
     (SEQ
      (COND ((EQL (SPADCALL |p| (QREFELT $ 21)) 0) (|spadConstant| $ 64))
            ('T
             (SEQ (LETT |md| (SPADCALL |p| (QREFELT $ 71)) |PGCD;monomContent|)
                  (EXIT
                   (SPADCALL
                    (SPADCALL (SPADCALL |p| (QREFELT $ 72)) (QREFELT $ 53))
                    |md| (QREFELT $ 73)))))))))) 

(DEFUN |PGCD;better| (|p1| |p2| $)
  (PROG (#1=#:G1941)
    (RETURN
     (COND ((SPADCALL |p1| (QREFELT $ 74)) 'T)
           ((SPADCALL |p2| (QREFELT $ 74)) 'NIL)
           ('T
            (<
             (SPADCALL |p1|
                       (PROG2
                           (LETT #1# (SPADCALL |p1| (QREFELT $ 76))
                                 . #2=(|PGCD;better|))
                           (QCDR #1#)
                         (|check-union| (QEQCAR #1# 0) (QREFELT $ 7) #1#))
                       (QREFELT $ 77))
             (SPADCALL |p2|
                       (PROG2
                           (LETT #1# (SPADCALL |p2| (QREFELT $ 76)) . #2#)
                           (QCDR #1#)
                         (|check-union| (QEQCAR #1# 0) (QREFELT $ 7) #1#))
                       (QREFELT $ 77)))))))) 

(DEFUN |PGCD;best_to_front| (|l| $)
  (PROG (|ress| |best| #1=#:G1951 |p|)
    (RETURN
     (SEQ (LETT |ress| NIL . #2=(|PGCD;best_to_front|))
          (LETT |best| (|SPADfirst| |l|) . #2#)
          (SEQ (LETT |p| NIL . #2#) (LETT #1# (CDR |l|) . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((|PGCD;better| |p| |best| $)
                   (SEQ (LETT |ress| (CONS |best| |ress|) . #2#)
                        (EXIT (LETT |best| |p| . #2#))))
                  ('T (LETT |ress| (CONS |p| |ress|) . #2#)))))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT (CONS |best| |ress|)))))) 

(DEFUN |PGCD;gcdTermList| (|p1| |p2| $)
  (PROG (|q| #1=#:G1958 |term| #2=#:G1959 |termList| #3=#:G1953)
    (RETURN
     (SEQ
      (LETT |termList|
            (|PGCD;best_to_front|
             (CONS |p1|
                   (SPADCALL
                    (SPADCALL |p2|
                              (PROG2
                                  (LETT #3# (SPADCALL |p2| (QREFELT $ 76))
                                        . #4=(|PGCD;gcdTermList|))
                                  (QCDR #3#)
                                (|check-union| (QEQCAR #3# 0) (QREFELT $ 7)
                                               #3#))
                              (QREFELT $ 79))
                    (QREFELT $ 72)))
             $)
            . #4#)
      (LETT |q| (|SPADfirst| |termList|) . #4#)
      (SEQ (LETT #2# NIL . #4#) (LETT |term| NIL . #4#)
           (LETT #1# (CDR |termList|) . #4#) G190
           (COND
            ((OR (ATOM #1#) (PROGN (LETT |term| (CAR #1#) . #4#) NIL) #2#)
             (GO G191)))
           (SEQ (EXIT (LETT |q| (SPADCALL |q| |term| (QREFELT $ 80)) . #4#)))
           (LETT #1#
                 (PROG1 (CDR #1#)
                   (LETT #2#
                         (SPADCALL |q| (|spadConstant| $ 40) (QREFELT $ 81))
                         . #4#))
                 . #4#)
           (GO G190) G191 (EXIT NIL))
      (EXIT |q|))))) 

(DEFUN |PGCD;gcd;3Sup;12| (|p1| |p2| $)
  (PROG (#1=#:G1962 |c2| |c1| |#G57| |#G56|)
    (RETURN
     (SEQ
      (COND
       ((< (SPADCALL |p2| (QREFELT $ 21)) (SPADCALL |p1| (QREFELT $ 21)))
        (PROGN
         (LETT |#G56| |p2| . #2=(|PGCD;gcd;3Sup;12|))
         (LETT |#G57| |p1| . #2#)
         (LETT |p1| |#G56| . #2#)
         (LETT |p2| |#G57| . #2#))))
      (EXIT
       (COND
        ((EQL (SPADCALL |p1| (QREFELT $ 21)) 0)
         (COND
          ((SPADCALL |p1| (|spadConstant| $ 37) (QREFELT $ 55))
           (SPADCALL |p2| (QREFELT $ 56)))
          ((SPADCALL |p1| (|spadConstant| $ 64) (QREFELT $ 55))
           (SPADCALL |p1| (QREFELT $ 56)))
          (#3='T
           (SPADCALL
            (SPADCALL (SPADCALL |p1| (QREFELT $ 49))
                      (SPADCALL |p2| (QREFELT $ 82)) (QREFELT $ 80))
            (QREFELT $ 83)))))
        ((SPADCALL (SPADCALL |p1| (QREFELT $ 84)) (|spadConstant| $ 37)
                   (QREFELT $ 55))
         (|PGCD;gcdMonom| |p1| (|PGCD;monomContent| |p2| $) $))
        (#3#
         (SEQ (LETT |c1| (|PGCD;monomContent| |p1| $) . #2#)
              (EXIT
               (COND
                ((SPADCALL (SPADCALL |p2| (QREFELT $ 84)) (|spadConstant| $ 37)
                           (QREFELT $ 55))
                 (|PGCD;gcdMonom| |c1| |p2| $))
                (#3#
                 (SEQ (LETT |c2| (|PGCD;monomContent| |p2| $) . #2#)
                      (LETT |p1|
                            (PROG2
                                (LETT #1# (SPADCALL |p1| |c1| (QREFELT $ 19))
                                      . #2#)
                                (QCDR #1#)
                              (|check-union| (QEQCAR #1# 0)
                                             (|SparseUnivariatePolynomial|
                                              (QREFELT $ 9))
                                             #1#))
                            . #2#)
                      (LETT |p2|
                            (PROG2
                                (LETT #1# (SPADCALL |p2| |c2| (QREFELT $ 19))
                                      . #2#)
                                (QCDR #1#)
                              (|check-union| (QEQCAR #1# 0)
                                             (|SparseUnivariatePolynomial|
                                              (QREFELT $ 9))
                                             #1#))
                            . #2#)
                      (EXIT
                       (SPADCALL (SPADCALL |p1| |p2| (QREFELT $ 65))
                                 (|PGCD;gcdMonom| |c1| |c2| $)
                                 (QREFELT $ 54))))))))))))))) 

(DEFUN |PGCD;gcdMonom| (|m1| |m2| $)
  (SPADCALL
   (SPADCALL (SPADCALL |m1| (QREFELT $ 49)) (SPADCALL |m2| (QREFELT $ 49))
             (QREFELT $ 80))
   (MIN (SPADCALL |m1| (QREFELT $ 21)) (SPADCALL |m2| (QREFELT $ 21)))
   (QREFELT $ 73))) 

(DEFUN |PGCD;lift?| (|p1| |p2| |uterm| |ldeg| |lvar| $)
  (PROG (|l| |lgcd| |f| #1=#:G1974 |nolift| #2=#:G1989 |uf| |listpol| |d|
         |lval| |#G66| |#G65| |leadpol|)
    (RETURN
     (SEQ (LETT |leadpol| 'NIL . #3=(|PGCD;lift?|))
          (PROGN
           (LETT |#G65| (QVELT |uterm| 0) . #3#)
           (LETT |#G66| (|SPADfirst| (QVELT |uterm| 1)) . #3#)
           (LETT |listpol| |#G65| . #3#)
           (LETT |lval| |#G66| . #3#))
          (LETT |d| (|SPADfirst| |listpol|) . #3#)
          (LETT |listpol| (CDR |listpol|) . #3#) (LETT |nolift| 'T . #3#)
          (SEQ
           (EXIT
            (SEQ (LETT |uf| NIL . #3#) (LETT #2# |listpol| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |uf| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (COND
                    ((EQL
                      (SPADCALL (SPADCALL |uf| |d| (QREFELT $ 33))
                                (QREFELT $ 32))
                      0)
                     (PROGN
                      (LETT #1# (LETT |nolift| 'NIL . #3#) . #3#)
                      (GO #1#))))))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL)))
           #1# (EXIT #1#))
          (EXIT
           (COND (|nolift| (CONS 2 "notCoprime"))
                 (#4='T
                  (SEQ
                   (LETT |f|
                         (SPADCALL (LIST |p1| |p2|)
                                   (SPADCALL |uf| |listpol| (QREFELT $ 86))
                                   (QREFELT $ 88))
                         . #3#)
                   (LETT |lgcd|
                         (SPADCALL (SPADCALL |p1| (QREFELT $ 49))
                                   (SPADCALL |p2| (QREFELT $ 49))
                                   (QREFELT $ 80))
                         . #3#)
                   (LETT |l|
                         (|PGCD;lift| |f| |d| |uf| |lgcd| |lvar| |ldeg| |lval|
                          $)
                         . #3#)
                   (EXIT
                    (COND ((QEQCAR |l| 1) (CONS 1 "failed"))
                          (#4# (CONS 0 (QCDR |l|))))))))))))) 

(DEFUN |PGCD;lift| (|f| |d| |uf| |lgcd| |lvar| |ldeg| |lval| $)
  (PROG (|p1| |p0| |#G82| |#G81| |#G80| |#G79| |plist| |pl| |lg| |leadlist|
         #1=#:G1995 |lcd| #2=#:G2010 |n0| #3=#:G2011 |n1| #4=#:G2009 |leadpol|
         |df| |lcf|)
    (RETURN
     (SEQ (LETT |leadpol| 'NIL . #5=(|PGCD;lift|))
          (LETT |lcf| (SPADCALL |f| (QREFELT $ 49)) . #5#)
          (LETT |df| (SPADCALL |f| (QREFELT $ 21)) . #5#)
          (LETT |leadlist| NIL . #5#)
          (COND
           ((NULL (SPADCALL |lgcd| (|spadConstant| $ 40) (QREFELT $ 81)))
            (SEQ (LETT |leadpol| 'T . #5#)
                 (LETT |f| (SPADCALL |lgcd| |f| (QREFELT $ 89)) . #5#)
                 (LETT |ldeg|
                       (PROGN
                        (LETT #4# NIL . #5#)
                        (SEQ (LETT |n1| NIL . #5#)
                             (LETT #3# (SPADCALL |lgcd| |lvar| (QREFELT $ 90))
                                   . #5#)
                             (LETT |n0| NIL . #5#) (LETT #2# |ldeg| . #5#) G190
                             (COND
                              ((OR (ATOM #2#)
                                   (PROGN (LETT |n0| (CAR #2#) . #5#) NIL)
                                   (ATOM #3#)
                                   (PROGN (LETT |n1| (CAR #3#) . #5#) NIL))
                               (GO G191)))
                             (SEQ
                              (EXIT (LETT #4# (CONS (+ |n0| |n1|) #4#) . #5#)))
                             (LETT #2#
                                   (PROG1 (CDR #2#) (LETT #3# (CDR #3#) . #5#))
                                   . #5#)
                             (GO G190) G191 (EXIT (NREVERSE0 #4#))))
                       . #5#)
                 (LETT |lcd| (SPADCALL |d| (QREFELT $ 45)) . #5#)
                 (COND
                  ((SPADCALL (SPADCALL |lgcd| (QREFELT $ 91))
                             (|spadConstant| $ 34) (QREFELT $ 92))
                   (LETT |d|
                         (PROG2
                             (LETT #1#
                                   (SPADCALL
                                    (SPADCALL (SPADCALL |lgcd| (QREFELT $ 93))
                                              |d| (QREFELT $ 94))
                                    |lcd| (QREFELT $ 46))
                                   . #5#)
                             (QCDR #1#)
                           (|check-union| (QEQCAR #1# 0)
                                          (|SparseUnivariatePolynomial|
                                           (QREFELT $ 8))
                                          #1#))
                         . #5#))
                  (#6='T
                   (LETT |d|
                         (PROG2
                             (LETT #1#
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |lgcd| |lvar| |lval|
                                                (QREFELT $ 42))
                                      (QREFELT $ 93))
                                     |d| (QREFELT $ 94))
                                    |lcd| (QREFELT $ 46))
                                   . #5#)
                             (QCDR #1#)
                           (|check-union| (QEQCAR #1# 0)
                                          (|SparseUnivariatePolynomial|
                                           (QREFELT $ 8))
                                          #1#))
                         . #5#)))
                 (EXIT
                  (LETT |uf| (SPADCALL |lcd| |uf| (QREFELT $ 94)) . #5#)))))
          (LETT |leadlist| (LIST |lgcd| |lcf|) . #5#)
          (LETT |lg|
                (|PGCD;imposelc| (LIST |d| |uf|) |lvar| |lval| |leadlist| $)
                . #5#)
          (LETT |pl|
                (SPADCALL |f| |lvar| |lg| |lval| |leadlist| |ldeg|
                          (QREFELT $ 16) (QREFELT $ 97))
                . #5#)
          (EXIT
           (COND ((QEQCAR |pl| 1) (CONS 1 "failed"))
                 (#6#
                  (SEQ (LETT |plist| (QCDR |pl|) . #5#)
                       (PROGN
                        (LETT |#G79| (|SPADfirst| |plist|) . #5#)
                        (LETT |#G80| (SPADCALL |plist| 2 (QREFELT $ 88)) . #5#)
                        (LETT |p0| |#G79| . #5#)
                        (LETT |p1| |#G80| . #5#))
                       (COND
                        ((NULL
                          (SPADCALL
                           (SPADCALL |p0| |lvar| |lval| (QREFELT $ 31))
                           (|SPADfirst| |lg|) (QREFELT $ 98)))
                         (PROGN
                          (LETT |#G81| |p1| . #5#)
                          (LETT |#G82| |p0| . #5#)
                          (LETT |p0| |#G81| . #5#)
                          (LETT |p1| |#G82| . #5#))))
                       (EXIT
                        (COND
                         (|leadpol|
                          (SPADCALL |p0| (SPADCALL |p0| (QREFELT $ 82))
                                    (QREFELT $ 99)))
                         (#6# (CONS 0 |p0|)))))))))))) 

(DEFUN |PGCD;gcd;3P;16| (|p1| |p2| $)
  (PROG (|mv2| #1=#:G2016 |mv1|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p1| (QREFELT $ 74))
        (SEQ
         (LETT |p1| (SPADCALL |p1| (QREFELT $ 100)) . #2=(|PGCD;gcd;3P;16|))
         (EXIT
          (COND ((SPADCALL |p1| (|spadConstant| $ 40) (QREFELT $ 81)) |p1|)
                ((SPADCALL |p1| (|spadConstant| $ 101) (QREFELT $ 81))
                 (SPADCALL |p2| (QREFELT $ 100)))
                (#3='T
                 (COND
                  ((SPADCALL |p2| (QREFELT $ 74))
                   (SPADCALL
                    (SPADCALL (SPADCALL |p1| (QREFELT $ 93))
                              (SPADCALL |p2| (QREFELT $ 93)) (QREFELT $ 102))
                    (QREFELT $ 103)))
                  (#3# (|PGCD;gcdTermList| |p1| |p2| $))))))))
       ((SPADCALL |p2| (QREFELT $ 74))
        (SEQ (LETT |p2| (SPADCALL |p2| (QREFELT $ 100)) . #2#)
             (EXIT
              (COND ((SPADCALL |p2| (|spadConstant| $ 40) (QREFELT $ 81)) |p2|)
                    ((SPADCALL |p2| (|spadConstant| $ 101) (QREFELT $ 81))
                     (SPADCALL |p1| (QREFELT $ 100)))
                    (#3# (|PGCD;gcdTermList| |p2| |p1| $))))))
       (#3#
        (SEQ (LETT |p1| (SPADCALL |p1| (QREFELT $ 100)) . #2#)
             (LETT |p2| (SPADCALL |p2| (QREFELT $ 100)) . #2#)
             (EXIT
              (COND ((SPADCALL |p1| |p2| (QREFELT $ 81)) |p1|)
                    (#3#
                     (SEQ
                      (LETT |mv1|
                            (PROG2
                                (LETT #1# (SPADCALL |p1| (QREFELT $ 76)) . #2#)
                                (QCDR #1#)
                              (|check-union| (QEQCAR #1# 0) (QREFELT $ 7) #1#))
                            . #2#)
                      (LETT |mv2|
                            (PROG2
                                (LETT #1# (SPADCALL |p2| (QREFELT $ 76)) . #2#)
                                (QCDR #1#)
                              (|check-union| (QEQCAR #1# 0) (QREFELT $ 7) #1#))
                            . #2#)
                      (EXIT
                       (COND
                        ((SPADCALL |mv1| |mv2| (QREFELT $ 104))
                         (SPADCALL
                          (SPADCALL (SPADCALL |p1| |mv1| (QREFELT $ 79))
                                    (SPADCALL |p2| |mv1| (QREFELT $ 79))
                                    (QREFELT $ 48))
                          |mv1| (QREFELT $ 105)))
                        ((SPADCALL |mv1| |mv2| (QREFELT $ 57))
                         (|PGCD;gcdTermList| |p1| |p2| $))
                        (#3# (|PGCD;gcdTermList| |p2| |p1| $))))))))))))))) 

(DEFUN |PGCD;gcd;LP;17| (|listp| $)
  (PROG (#1=#:G2026 |f| #2=#:G2027 |g| |lf|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |lf| (|PGCD;best_to_front| |listp| $) . #3=(|PGCD;gcd;LP;17|))
        (LETT |f| (|SPADfirst| |lf|) . #3#)
        (SEQ (LETT |g| NIL . #3#) (LETT #2# (CDR |lf|) . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |g| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ (LETT |f| (SPADCALL |f| |g| (QREFELT $ 80)) . #3#)
                  (EXIT
                   (COND
                    ((SPADCALL |f| (|spadConstant| $ 40) (QREFELT $ 81))
                     (PROGN (LETT #1# |f| . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT |f|)))
      #1# (EXIT #1#))))) 

(DEFUN |PGCD;gcd;LSup;18| (|listp| $)
  (PROG (#1=#:G2037 |f| #2=#:G2038 |g| |lf|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |lf|
              (SPADCALL (CONS #'|PGCD;gcd;LSup;18!0| $) |listp|
                        (QREFELT $ 108))
              . #3=(|PGCD;gcd;LSup;18|))
        (LETT |f| (|SPADfirst| |lf|) . #3#)
        (SEQ (LETT |g| NIL . #3#) (LETT #2# (CDR |lf|) . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |g| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ (LETT |f| (SPADCALL |f| |g| (QREFELT $ 48)) . #3#)
                  (EXIT
                   (COND
                    ((SPADCALL |f| (|spadConstant| $ 64) (QREFELT $ 55))
                     (PROGN (LETT #1# |f| . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT |f|)))
      #1# (EXIT #1#))))) 

(DEFUN |PGCD;gcd;LSup;18!0| (|z1| |z2| $)
  (SPADCALL (SPADCALL |z1| (QREFELT $ 21)) (SPADCALL |z2| (QREFELT $ 21))
            (QREFELT $ 106))) 

(DEFUN |PGCD;gcdPrimitive;3P;19| (|p1| |p2| $)
  (PROG (|up2| |up1| #1=#:G2044 |mp| |md| |mv2| #2=#:G2041 |mv1|)
    (RETURN
     (SEQ
      (LETT |p1| (SPADCALL |p1| (QREFELT $ 100))
            . #3=(|PGCD;gcdPrimitive;3P;19|))
      (LETT |p2| (SPADCALL |p2| (QREFELT $ 100)) . #3#)
      (EXIT
       (COND ((SPADCALL |p1| |p2| (QREFELT $ 81)) |p1|)
             ((SPADCALL |p1| (QREFELT $ 74))
              (COND
               ((SPADCALL |p2| (QREFELT $ 74))
                (SPADCALL
                 (SPADCALL (SPADCALL |p1| (QREFELT $ 93))
                           (SPADCALL |p2| (QREFELT $ 93)) (QREFELT $ 102))
                 (QREFELT $ 103)))
               ((SPADCALL |p1| (|spadConstant| $ 101) (QREFELT $ 81)) |p2|)
               (#4='T (|spadConstant| $ 40))))
             ((SPADCALL |p2| (QREFELT $ 74))
              (COND
               ((SPADCALL |p2| (|spadConstant| $ 101) (QREFELT $ 81)) |p1|)
               (#4# (|spadConstant| $ 40))))
             (#4#
              (SEQ
               (LETT |mv1|
                     (PROG2
                         (LETT #2# (SPADCALL |p1| (QREFELT $ 76)) . #3#)
                         (QCDR #2#)
                       (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                     . #3#)
               (LETT |mv2|
                     (PROG2
                         (LETT #2# (SPADCALL |p2| (QREFELT $ 76)) . #3#)
                         (QCDR #2#)
                       (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                     . #3#)
               (EXIT
                (COND
                 ((SPADCALL |mv1| |mv2| (QREFELT $ 104))
                  (SEQ
                   (LETT |md|
                         (MIN (SPADCALL |p1| |mv1| (QREFELT $ 110))
                              (SPADCALL |p2| |mv2| (QREFELT $ 110)))
                         . #3#)
                   (LETT |mp| (|spadConstant| $ 40) . #3#)
                   (COND
                    ((< 1 |md|)
                     (SEQ
                      (LETT |mp|
                            (SPADCALL (SPADCALL |mv1| (QREFELT $ 111)) |md|
                                      (QREFELT $ 112))
                            . #3#)
                      (LETT |p1|
                            (PROG2
                                (LETT #1# (SPADCALL |p1| |mp| (QREFELT $ 113))
                                      . #3#)
                                (QCDR #1#)
                              (|check-union| (QEQCAR #1# 0) (QREFELT $ 9) #1#))
                            . #3#)
                      (EXIT
                       (LETT |p2|
                             (PROG2
                                 (LETT #1# (SPADCALL |p2| |mp| (QREFELT $ 113))
                                       . #3#)
                                 (QCDR #1#)
                               (|check-union| (QEQCAR #1# 0) (QREFELT $ 9)
                                              #1#))
                             . #3#)))))
                   (LETT |up1| (SPADCALL |p1| |mv1| (QREFELT $ 79)) . #3#)
                   (LETT |up2| (SPADCALL |p2| |mv2| (QREFELT $ 79)) . #3#)
                   (EXIT
                    (SPADCALL |mp|
                              (SPADCALL (SPADCALL |up1| |up2| (QREFELT $ 65))
                                        |mv1| (QREFELT $ 105))
                              (QREFELT $ 114)))))
                 (#4# (|spadConstant| $ 40)))))))))))) 

(DEFUN |PGCD;gcdPrimitive;LP;20| (|listp| $)
  (PROG (#1=#:G2059 |f| #2=#:G2060 |g| |lf|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |lf|
              (SPADCALL (CONS (|function| |PGCD;better|) $) |listp|
                        (QREFELT $ 117))
              . #3=(|PGCD;gcdPrimitive;LP;20|))
        (LETT |f| (|SPADfirst| |lf|) . #3#)
        (SEQ (LETT |g| NIL . #3#) (LETT #2# (CDR |lf|) . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |g| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ (LETT |f| (SPADCALL |f| |g| (QREFELT $ 115)) . #3#)
                  (EXIT
                   (COND
                    ((SPADCALL |f| (|spadConstant| $ 40) (QREFELT $ 81))
                     (PROGN (LETT #1# |f| . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT |f|)))
      #1# (EXIT #1#))))) 

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

(DEFUN |PolynomialGcdPackage;| (|#1| |#2| |#3| |#4|)
  (PROG (|pv$| $ |dv$| DV$4 DV$3 DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|PolynomialGcdPackage|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT DV$3 (|devaluate| |#3|) . #1#)
      (LETT DV$4 (|devaluate| |#4|) . #1#)
      (LETT |dv$| (LIST '|PolynomialGcdPackage| DV$1 DV$2 DV$3 DV$4) . #1#)
      (LETT $ (GETREFV 119) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|PolynomialGcdPackage|
                  (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 |#3|)
      (QSETREFV $ 9 |#4|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 16
                (SPADCALL (SPADCALL (EXPT 2 26) (QREFELT $ 14))
                          (QREFELT $ 15)))
      $)))) 

(MAKEPROP '|PolynomialGcdPackage| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|local| |#3|) (|local| |#4|) (|PositiveInteger|) (0 . ^)
              (|Integer|) (|IntegerPrimesPackage| 12) (6 . |prevPrime|)
              (11 . |coerce|) '|pmod| (|Union| $ '"failed")
              (|SparseUnivariatePolynomial| 9) (16 . |exquo|)
              (|NonNegativeInteger|) (22 . |degree|) (27 . *)
              (|FactoringUtilities| 6 7 8 9) (33 . |ran|) (|Boolean|)
              (|List| 8) (|List| 26) (38 . |member?|)
              (|SparseUnivariatePolynomial| 8) (|List| 7) (44 . |completeEval|)
              (51 . |degree|) (56 . |gcd|) (62 . |Zero|) (66 . |Zero|)
              (70 . |One|) (74 . |Zero|) (78 . |exquo|) (84 . |One|)
              (88 . |One|) (92 . |differentiate|) (97 . |eval|)
              (104 . |univariate|) (109 . *) (115 . |leadingCoefficient|)
              (120 . |exquo|) (126 . |differentiate|) |PGCD;gcd;3Sup;12|
              (131 . |leadingCoefficient|) (|List| $) (136 . |gcd|) (|List| 9)
              |PGCD;gcd;LP;17| (141 . *) (147 . =) (153 . |unitCanonical|)
              (158 . <) (164 . |variables|) (169 . |setUnion|)
              (|Mapping| 25 7 7) (175 . |sort|) (181 . |lowerPolynomial|)
              (186 . |raisePolynomial|) (191 . |One|)
              |PGCD;gcdPrimitive;3Sup;6| (195 . |min|) (|List| 20)
              (201 . |degree|) (|Mapping| 20 20 20) (207 . |map|)
              (214 . |minimumDegree|) (219 . |coefficients|) (224 . |monomial|)
              (230 . |ground?|) (|Union| 7 '"failed") (235 . |mainVariable|)
              (240 . |degree|) (|SparseUnivariatePolynomial| $)
              (246 . |univariate|) |PGCD;gcd;3P;16| (252 . =) (258 . |content|)
              (263 . |coerce|) (268 . |reductum|) (|List| 29)
              (273 . |position|) (|List| 18) (279 . |elt|) (285 . *)
              (291 . |degree|) (297 . |degree|) (302 . =) (308 . |retract|)
              (313 . *) (|Union| 87 '"failed") (|MultivariateLifting| 6 7 8 9)
              (319 . |lifting|) (330 . =) (336 . |exquo|)
              (342 . |unitCanonical|) (347 . |Zero|) (351 . |gcd|)
              (357 . |coerce|) (362 . =) (368 . |multivariate|) (374 . <)
              (|Mapping| 25 18 18) (380 . |sort|) |PGCD;gcd;LSup;18|
              (386 . |minimumDegree|) (392 . |coerce|) (397 . ^)
              (403 . |exquo|) (409 . *) |PGCD;gcdPrimitive;3P;19|
              (|Mapping| 25 9 9) (415 . |sort|) |PGCD;gcdPrimitive;LP;20|)
           '#(|gcdPrimitive| 421 |gcd| 438) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 118
                                                 '(2 10 0 0 10 11 1 13 12 12 14
                                                   1 8 0 12 15 2 18 17 0 0 19 1
                                                   18 20 0 21 2 12 0 10 0 22 1
                                                   23 8 12 24 2 27 25 26 0 28 3
                                                   23 29 18 30 26 31 1 29 20 0
                                                   32 2 29 0 0 0 33 0 6 0 34 0
                                                   8 0 35 0 29 0 36 0 18 0 37 2
                                                   29 17 0 0 38 0 8 0 39 0 9 0
                                                   40 1 29 0 0 41 3 9 0 0 30 26
                                                   42 1 9 29 0 43 2 29 0 0 0 44
                                                   1 29 8 0 45 2 29 17 0 8 46 1
                                                   18 0 0 47 1 18 9 0 49 1 29 0
                                                   50 51 2 18 0 0 0 54 2 18 25
                                                   0 0 55 1 18 0 0 56 2 7 25 0
                                                   0 57 1 23 30 18 58 2 30 0 0
                                                   0 59 2 30 0 60 0 61 1 23 29
                                                   18 62 1 23 18 29 63 0 18 0
                                                   64 2 20 0 0 0 66 2 23 67 18
                                                   30 68 3 67 0 69 0 0 70 1 18
                                                   20 0 71 1 18 52 0 72 2 18 0
                                                   9 20 73 1 9 25 0 74 1 9 75 0
                                                   76 2 9 20 0 7 77 2 9 78 0 7
                                                   79 2 9 25 0 0 81 1 18 9 0 82
                                                   1 18 0 9 83 1 18 0 0 84 2 85
                                                   12 29 0 86 2 87 18 0 12 88 2
                                                   18 0 9 0 89 2 9 67 0 30 90 1
                                                   9 6 0 91 2 6 25 0 0 92 1 9 8
                                                   0 93 2 29 0 8 0 94 7 96 95
                                                   18 30 85 26 52 67 8 97 2 29
                                                   25 0 0 98 2 18 17 0 9 99 1 9
                                                   0 0 100 0 9 0 101 2 8 0 0 0
                                                   102 1 9 0 8 103 2 7 25 0 0
                                                   104 2 9 0 78 7 105 2 20 25 0
                                                   0 106 2 87 0 107 0 108 2 9
                                                   20 0 7 110 1 9 0 7 111 2 9 0
                                                   0 20 112 2 9 17 0 0 113 2 9
                                                   0 0 0 114 2 52 0 116 0 117 2
                                                   0 9 9 9 115 1 0 9 52 118 2 0
                                                   18 18 18 65 2 0 9 9 9 80 2 0
                                                   18 18 18 48 1 0 9 52 53 1 0
                                                   18 87 109)))))
           '|lookupComplete|)) 
