
(/VERSIONCHECK 2) 

(DEFUN |GENPGCD;gcdPolynomial;3Sup;1| (|p1| |p2| $)
  (PROG (|#G8| |#G9| |c1| |c2| #0=#:G1861 |vp1| |vp2| |pp1| |pp2| |v1|
               |g| #1=#:G1892 |v| |v2|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |p1| (QREFELT $ 12)) |p2|)
                   ((SPADCALL |p2| (QREFELT $ 12)) |p1|)
                   ((EQL 0 (SPADCALL |p1| (QREFELT $ 18)))
                    (|GENPGCD;gcdTrivial| |p1| |p2| $))
                   ((EQL 0 (SPADCALL |p2| (QREFELT $ 18)))
                    (|GENPGCD;gcdTrivial| |p2| |p1| $))
                   ('T
                    (SEQ (COND
                           ((< (SPADCALL |p1| (QREFELT $ 18))
                               (SPADCALL |p2| (QREFELT $ 18)))
                            (PROGN
                              (LETT |#G8| |p2|
                                    . #2=(|GENPGCD;gcdPolynomial;3Sup;1|))
                              (LETT |#G9| |p1| . #2#)
                              (LETT |p1| |#G8| . #2#)
                              (LETT |p2| |#G9| . #2#))))
                         (EXIT (COND
                                 ((QEQCAR (SPADCALL |p1| |p2|
                                           (QREFELT $ 20))
                                          0)
                                  (QVELT (SPADCALL |p2| (QREFELT $ 22))
                                         1))
                                 ('T
                                  (SEQ (LETT |c1|
                                        (|GENPGCD;monomContentSup| |p1|
                                         $) . #2#)
                                       (LETT |c2|
                                        (|GENPGCD;monomContentSup| |p2|
                                         $) . #2#)
                                       (LETT |p1|
                                        (PROG2
                                         (LETT #0#
                                          (SPADCALL |p1| |c1|
                                           (QREFELT $ 20)) . #2#)
                                         (QCDR #0#)
                                          (|check-union| (QEQCAR #0# 0)
                                           (|SparseUnivariatePolynomial|
                                            (QREFELT $ 9))
                                           #0#)) . #2#)
                                       (LETT |p2|
                                        (PROG2
                                         (LETT #0#
                                          (SPADCALL |p2| |c2|
                                           (QREFELT $ 20)) . #2#)
                                         (QCDR #0#)
                                          (|check-union| (QEQCAR #0# 0)
                                           (|SparseUnivariatePolynomial|
                                            (QREFELT $ 9))
                                           #0#)) . #2#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR
                                            (SPADCALL |p1| |p2|
                                             (QREFELT $ 20))
                                            0)
                                           (SPADCALL
                                            (QVELT
                                             (SPADCALL |p2|
                                              (QREFELT $ 22))
                                             1)
                                            (SPADCALL |c1| |c2|
                                             (QREFELT $ 23))
                                            (QREFELT $ 24)))
                                          ('T
                                           (SEQ
                                            (LETT |vp1|
                                             (|GENPGCD;variables| |p1|
                                              $) . #2#)
                                            (LETT |vp2|
                                             (|GENPGCD;variables| |p2|
                                              $) . #2#)
                                            (LETT |v1|
                                             (SPADCALL |vp1| |vp2|
                                              (QREFELT $ 26)) . #2#)
                                            (LETT |v2|
                                             (SPADCALL |vp2| |vp1|
                                              (QREFELT $ 26)) . #2#)
                                            (COND
                                              ((EQL (LENGTH |v1|) 0)
                                               (COND
                                                 ((EQL (LENGTH |v2|) 0)
                                                  (EXIT
                                                   (SPADCALL
                                                    (|GENPGCD;gcdSameVariables|
                                                     |p1| |p2| |vp1| $)
                                                    (SPADCALL |c1| |c2|
                                                     (QREFELT $ 23))
                                                    (QREFELT $ 24)))))))
                                            (LETT |v|
                                             (SPADCALL |vp1| |v1|
                                              (QREFELT $ 26)) . #2#)
                                            (LETT |pp1|
                                             (|GENPGCD;flatten| |p1|
                                              |v1| $) . #2#)
                                            (LETT |pp2|
                                             (|GENPGCD;flatten| |p2|
                                              |v2| $) . #2#)
                                            (LETT |g|
                                             (|GENPGCD;gcdSameVariables|
                                              |pp1| |pp2| |v| $) . #2#)
                                            (EXIT
                                             (COND
                                               ((SPADCALL |g|
                                                 (|spadConstant| $ 29)
                                                 (QREFELT $ 30))
                                                (SPADCALL |c1| |c2|
                                                 (QREFELT $ 23)))
                                               ('T
                                                (SEQ
                                                 (COND
                                                   ((OR
                                                     (EQL (LENGTH |v1|)
                                                      0)
                                                     (NULL
                                                      (QEQCAR
                                                       (SPADCALL |p1|
                                                        |g|
                                                        (QREFELT $ 20))
                                                       1)))
                                                    (COND
                                                      ((OR
                                                        (EQL
                                                         (LENGTH |v2|)
                                                         0)
                                                        (NULL
                                                         (QEQCAR
                                                          (SPADCALL
                                                           |p2| |g|
                                                           (QREFELT $
                                                            20))
                                                          1)))
                                                       (EXIT
                                                        (SPADCALL |g|
                                                         (SPADCALL |c1|
                                                          |c2|
                                                          (QREFELT $
                                                           23))
                                                         (QREFELT $ 24)))))))
                                                 (LETT |v|
                                                  (|GENPGCD;variables|
                                                   |g| $) . #2#)
                                                 (LETT |v1|
                                                  (SPADCALL |vp1| |v|
                                                   (QREFELT $ 26)) . #2#)
                                                 (LETT |v2|
                                                  (SPADCALL |vp2| |v|
                                                   (QREFELT $ 26)) . #2#)
                                                 (COND
                                                   ((EQL (LENGTH |v1|)
                                                     0)
                                                    (LETT |g|
                                                     (|GENPGCD;gcdSameVariables|
                                                      |g|
                                                      (|GENPGCD;flatten|
                                                       |p2| |v2| $)
                                                      |v| $) . #2#))
                                                   ((EQL (LENGTH |v2|)
                                                     0)
                                                    (LETT |g|
                                                     (|GENPGCD;gcdSameVariables|
                                                      |g|
                                                      (|GENPGCD;flatten|
                                                       |p1| |v1| $)
                                                      |v| $) . #2#))
                                                   ('T
                                                    (LETT |g|
                                                     (|GENPGCD;gcdSameVariables|
                                                      |g|
                                                      (SPADCALL
                                                       (|GENPGCD;flatten|
                                                        |p1| |v1| $)
                                                       (|GENPGCD;flatten|
                                                        |p2| |v2| $)
                                                       (QREFELT $ 31))
                                                      |v| $) . #2#)))
                                                 (EXIT
                                                  (COND
                                                    ((SPADCALL |g|
                                                      (|spadConstant| $
                                                       29)
                                                      (QREFELT $ 30))
                                                     (SPADCALL |c1|
                                                      |c2|
                                                      (QREFELT $ 23)))
                                                    ('T
                                                     (SEQ
                                                      (COND
                                                        ((OR
                                                          (EQL
                                                           (LENGTH
                                                            |v1|)
                                                           0)
                                                          (NULL
                                                           (QEQCAR
                                                            (SPADCALL
                                                             |p1| |g|
                                                             (QREFELT $
                                                              20))
                                                            1)))
                                                         (COND
                                                           ((OR
                                                             (EQL
                                                              (LENGTH
                                                               |v2|)
                                                              0)
                                                             (NULL
                                                              (QEQCAR
                                                               (SPADCALL
                                                                |p2|
                                                                |g|
                                                                (QREFELT
                                                                 $ 20))
                                                               1)))
                                                            (EXIT
                                                             (SPADCALL
                                                              |g|
                                                              (SPADCALL
                                                               |c1|
                                                               |c2|
                                                               (QREFELT
                                                                $ 23))
                                                              (QREFELT
                                                               $ 24)))))))
                                                      (LETT |v|
                                                       (|GENPGCD;variables|
                                                        |g| $) . #2#)
                                                      (LETT |v1|
                                                       (SPADCALL |vp1|
                                                        |v|
                                                        (QREFELT $ 26)) . #2#)
                                                      (COND
                                                        ((NULL
                                                          (EQL
                                                           (LENGTH
                                                            |v1|)
                                                           0))
                                                         (SEQ
                                                          (LETT |g|
                                                           (|GENPGCD;recursivelyGCDCoefficients|
                                                            |g| |v|
                                                            |p1| |v1|
                                                            $) . #2#)
                                                          (EXIT
                                                           (COND
                                                             ((SPADCALL
                                                               |g|
                                                               (|spadConstant|
                                                                $ 29)
                                                               (QREFELT
                                                                $ 30))
                                                              (PROGN
                                                                (LETT
                                                                 #1#
                                                                 (SPADCALL
                                                                  |c1|
                                                                  |c2|
                                                                  (QREFELT
                                                                   $
                                                                   23)) . #2#)
                                                                (GO
                                                                 #1#)))
                                                             ('T
                                                              (LETT |v|
                                                               (|GENPGCD;variables|
                                                                |g| $) . #2#)))))))
                                                      (LETT |v2|
                                                       (SPADCALL |vp2|
                                                        |v|
                                                        (QREFELT $ 26)) . #2#)
                                                      (EXIT
                                                       (SPADCALL
                                                        (|GENPGCD;recursivelyGCDCoefficients|
                                                         |g| |v| |p2|
                                                         |v2| $)
                                                        (SPADCALL |c1|
                                                         |c2|
                                                         (QREFELT $ 23))
                                                        (QREFELT $ 24)))))))))))))))))))))))
           #1# (EXIT #1#))))) 

(DEFUN |GENPGCD;randomR;R;2| ($)
  (PROG (|v|)
    (RETURN
      (SEQ (LETT |v| (SPADCALL (QREFELT $ 34) (QREFELT $ 35))
                 |GENPGCD;randomR;R;2|)
           (EXIT (COND
                   ((QEQCAR |v| 0)
                    (SEQ (SETELT $ 34 (QCDR |v|)) (EXIT (QCDR |v|))))
                   ('T
                    (SEQ (SAY "Taking next stepthrough range in GeneralPolynomialGcdPackage")
                         (SETELT $ 34 (|spadConstant| $ 33))
                         (EXIT (QREFELT $ 34)))))))))) 

(DEFUN |GENPGCD;randomR;R;3| ($)
  (SPADCALL (RANDOM 100) (QREFELT $ 38))) 

(DEFUN |GENPGCD;gcdSameVariables| (|p1| |p2| |lv| $)
  (PROG (|gcdLC| #0=#:G1939 #1=#:G1940 #2=#:G1941 #3=#:G1942 #4=#:G1943
                 #5=#:G1944 #6=#:G1945 |vv| #7=#:G1946 |lrr| |vp1|
                 |vp2| |v| |u| |lr| |up1| #8=#:G1920 |up2| |count| |r|
                 |uu| |ans| #9=#:G1938 #10=#:G1925)
    (RETURN
      (SEQ (EXIT (COND
                   ((EQL (LENGTH |lv|) 0)
                    (SPADCALL (CONS #'|GENPGCD;gcdSameVariables!0| $)
                        (SPADCALL
                            (SPADCALL (ELT $ 40) |p1| (QREFELT $ 44))
                            (SPADCALL (ELT $ 40) |p2| (QREFELT $ 44))
                            (QREFELT $ 46))
                        (QREFELT $ 49)))
                   ((EQL (SPADCALL |p2| (QREFELT $ 18)) 1)
                    (COND
                      ((QEQCAR (SPADCALL |p1| |p2| (QREFELT $ 20)) 0)
                       |p2|)
                      ('T (|spadConstant| $ 29))))
                   ('T
                    (SEQ (LETT |gcdLC|
                               (SPADCALL (SPADCALL |p1| (QREFELT $ 50))
                                   (SPADCALL |p2| (QREFELT $ 50))
                                   (QREFELT $ 51))
                               . #11=(|GENPGCD;gcdSameVariables|))
                         (LETT |lr|
                               (PROGN
                                 (LETT #0# NIL . #11#)
                                 (SEQ (LETT |vv| NIL . #11#)
                                      (LETT #1# |lv| . #11#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |vv|
                                             (CAR #1#) . #11#)
                                            NIL))
                                         #12=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL (QREFELT $ 36))
                                          #0#) . #11#)))
                                      (LETT #1# (CDR #1#) . #11#)
                                      #13=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #11#)
                         (LETT |count| 0 . #11#)
                         (SEQ G190 (COND ((NULL (< |count| 10)) #12#))
                              (SEQ (SEQ G190
                                    (COND
                                      ((NULL
                                        (COND
                                          ((SPADCALL
                                            (SPADCALL |gcdLC| |lv| |lr|
                                             (QREFELT $ 53))
                                            (QREFELT $ 54))
                                           (< |count| 10))
                                          ('T 'NIL)))
                                       #12#))
                                    (SEQ
                                     (LETT |lr|
                                      (PROGN
                                        (LETT #2# NIL . #11#)
                                        (SEQ (LETT |vv| NIL . #11#)
                                         (LETT #3# |lv| . #11#) G190
                                         (COND
                                           ((OR (ATOM #3#)
                                             (PROGN
                                               (LETT |vv|
                                                (CAR #3#) . #11#)
                                               NIL))
                                            #12#))
                                         (SEQ
                                          (EXIT
                                           (LETT #2#
                                            (CONS
                                             (SPADCALL (QREFELT $ 36))
                                             #2#) . #11#)))
                                         (LETT #3# (CDR #3#) . #11#)
                                         #13# G191
                                         (EXIT (NREVERSE0 #2#)))) . #11#)
                                     (EXIT
                                      (LETT |count|
                                       (+ |count| 1) . #11#)))
                                    NIL #13# G191 (EXIT NIL))
                                   (EXIT
                                    (COND
                                      ((EQL |count| 10)
                                       (|error|
                                        "too many evaluations in GCD code"))
                                      ('T
                                       (SEQ
                                        (LETT |up1|
                                         (SPADCALL
                                          (CONS
                                           #'|GENPGCD;gcdSameVariables!1|
                                           (VECTOR $ |lr| |lv|))
                                          |p1| (QREFELT $ 44)) . #11#)
                                        (LETT |up2|
                                         (SPADCALL
                                          (CONS
                                           #'|GENPGCD;gcdSameVariables!2|
                                           (VECTOR $ |lr| |lv|))
                                          |p2| (QREFELT $ 44)) . #11#)
                                        (LETT |u|
                                         (SPADCALL |up1| |up2|
                                          (QREFELT $ 46)) . #11#)
                                        (EXIT
                                         (COND
                                           ((EQL
                                             (SPADCALL |u|
                                              (QREFELT $ 55))
                                             0)
                                            (PROGN
                                              (LETT #9#
                                               (|spadConstant| $ 29) . #11#)
                                              (GO #9#)))
                                           ('T
                                            (SEQ
                                             (LETT |lrr|
                                              (PROGN
                                                (LETT #4# NIL . #11#)
                                                (SEQ
                                                 (LETT |vv| NIL . #11#)
                                                 (LETT #5# |lv| . #11#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #5#)
                                                     (PROGN
                                                       (LETT |vv|
                                                        (CAR #5#) . #11#)
                                                       NIL))
                                                    #12#))
                                                 (SEQ
                                                  (EXIT
                                                   (LETT #4#
                                                    (CONS
                                                     (SPADCALL
                                                      (QREFELT $ 36))
                                                     #4#) . #11#)))
                                                 (LETT #5#
                                                  (CDR #5#) . #11#)
                                                 #13# G191
                                                 (EXIT (NREVERSE0 #4#)))) . #11#)
                                             (SEQ G190
                                              (COND
                                                ((NULL
                                                  (COND
                                                    ((SPADCALL
                                                      (SPADCALL |gcdLC|
                                                       |lv| |lrr|
                                                       (QREFELT $ 53))
                                                      (QREFELT $ 54))
                                                     (< |count| 10))
                                                    ('T 'NIL)))
                                                 #12#))
                                              (SEQ
                                               (LETT |lrr|
                                                (PROGN
                                                  (LETT #6# NIL . #11#)
                                                  (SEQ
                                                   (LETT |vv|
                                                    NIL . #11#)
                                                   (LETT #7#
                                                    |lv| . #11#)
                                                   G190
                                                   (COND
                                                     ((OR (ATOM #7#)
                                                       (PROGN
                                                         (LETT |vv|
                                                          (CAR #7#) . #11#)
                                                         NIL))
                                                      #12#))
                                                   (SEQ
                                                    (EXIT
                                                     (LETT #6#
                                                      (CONS
                                                       (SPADCALL
                                                        (QREFELT $ 36))
                                                       #6#) . #11#)))
                                                   (LETT #7#
                                                    (CDR #7#) . #11#)
                                                   #13# G191
                                                   (EXIT
                                                    (NREVERSE0 #6#)))) . #11#)
                                               (EXIT
                                                (LETT |count|
                                                 (+ |count| 1) . #11#)))
                                              NIL #13# G191 (EXIT NIL))
                                             (EXIT
                                              (COND
                                                ((EQL |count| 10)
                                                 (|error|
                                                  "too many evaluations in GCD code"))
                                                ('T
                                                 (SEQ
                                                  (LETT |vp1|
                                                   (SPADCALL
                                                    (CONS
                                                     #'|GENPGCD;gcdSameVariables!3|
                                                     (VECTOR $ |lrr|
                                                      |lv|))
                                                    |p1|
                                                    (QREFELT $ 44)) . #11#)
                                                  (LETT |vp2|
                                                   (SPADCALL
                                                    (CONS
                                                     #'|GENPGCD;gcdSameVariables!4|
                                                     (VECTOR $ |lrr|
                                                      |lv|))
                                                    |p2|
                                                    (QREFELT $ 44)) . #11#)
                                                  (LETT |v|
                                                   (SPADCALL |vp1|
                                                    |vp2|
                                                    (QREFELT $ 46)) . #11#)
                                                  (EXIT
                                                   (COND
                                                     ((EQL
                                                       (SPADCALL |v|
                                                        (QREFELT $ 55))
                                                       0)
                                                      (PROGN
                                                        (LETT #9#
                                                         (|spadConstant|
                                                          $ 29) . #11#)
                                                        (GO #9#)))
                                                     ('T
                                                      (SEQ
                                                       (COND
                                                         ((<
                                                           (SPADCALL
                                                            |v|
                                                            (QREFELT $
                                                             55))
                                                           (SPADCALL
                                                            |u|
                                                            (QREFELT $
                                                             55)))
                                                          (SEQ
                                                           (LETT |u|
                                                            |v| . #11#)
                                                           (LETT |up1|
                                                            |vp1| . #11#)
                                                           (LETT |up2|
                                                            |vp2| . #11#)
                                                           (EXIT
                                                            (LETT |lr|
                                                             |lrr| . #11#)))))
                                                       (LETT |up1|
                                                        (PROG2
                                                         (LETT #8#
                                                          (SPADCALL
                                                           |up1| |u|
                                                           (QREFELT $
                                                            56)) . #11#)
                                                         (QCDR #8#)
                                                          (|check-union|
                                                           (QEQCAR #8#
                                                            0)
                                                           (|SparseUnivariatePolynomial|
                                                            (QREFELT $
                                                             8))
                                                           #8#)) . #11#)
                                                       (EXIT
                                                        (COND
                                                          ((EQL
                                                            (SPADCALL
                                                             (SPADCALL
                                                              |u| |up1|
                                                              (QREFELT
                                                               $ 57))
                                                             (QREFELT $
                                                              55))
                                                            0)
                                                           (SEQ
                                                            (LETT |ans|
                                                             (|GENPGCD;lift|
                                                              |u| |p1|
                                                              |up1|
                                                              |lv| |lr|
                                                              $) . #11#)
                                                            (EXIT
                                                             (COND
                                                               ((QEQCAR
                                                                 |ans|
                                                                 0)
                                                                (PROGN
                                                                  (LETT
                                                                   #9#
                                                                   (QCDR
                                                                    |ans|) . #11#)
                                                                  (GO
                                                                   #9#)))
                                                               ('T
                                                                "next")))))
                                                          ('T
                                                           (SEQ
                                                            (LETT |up2|
                                                             (PROG2
                                                              (LETT #8#
                                                               (SPADCALL
                                                                |up2|
                                                                |u|
                                                                (QREFELT
                                                                 $ 56)) . #11#)
                                                              (QCDR
                                                               #8#)
                                                               (|check-union|
                                                                (QEQCAR
                                                                 #8# 0)
                                                                (|SparseUnivariatePolynomial|
                                                                 (QREFELT
                                                                  $ 8))
                                                                #8#)) . #11#)
                                                            (EXIT
                                                             (COND
                                                               ((EQL
                                                                 (SPADCALL
                                                                  (SPADCALL
                                                                   |u|
                                                                   |up2|
                                                                   (QREFELT
                                                                    $
                                                                    57))
                                                                  (QREFELT
                                                                   $
                                                                   55))
                                                                 0)
                                                                (SEQ
                                                                 (LETT
                                                                  |ans|
                                                                  (|GENPGCD;lift|
                                                                   |u|
                                                                   |p2|
                                                                   |up2|
                                                                   |lv|
                                                                   |lr|
                                                                   $) . #11#)
                                                                 (EXIT
                                                                  (COND
                                                                    ((QEQCAR
                                                                      |ans|
                                                                      0)
                                                                     (PROGN
                                                                       (LETT
                                                                        #9#
                                                                        (QCDR
                                                                         |ans|) . #11#)
                                                                       (GO
                                                                        #9#)))
                                                                    ('T
                                                                     "next")))))
                                                               ('T
                                                                (SEQ
                                                                 (LETT
                                                                  |count|
                                                                  0 . #11#)
                                                                 (SEQ
                                                                  G190
                                                                  (COND
                                                                    ((NULL
                                                                      (<
                                                                       |count|
                                                                       10))
                                                                     #12#))
                                                                  (SEQ
                                                                   (EXIT
                                                                    (SEQ
                                                                     (LETT
                                                                      |r|
                                                                      (SPADCALL
                                                                       (QREFELT
                                                                        $
                                                                        36)) . #11#)
                                                                     (LETT
                                                                      |uu|
                                                                      (SPADCALL
                                                                       |up1|
                                                                       (SPADCALL
                                                                        |r|
                                                                        |up2|
                                                                        (QREFELT
                                                                         $
                                                                         58))
                                                                       (QREFELT
                                                                        $
                                                                        59)) . #11#)
                                                                     (EXIT
                                                                      (COND
                                                                        ((EQL
                                                                          (SPADCALL
                                                                           (SPADCALL
                                                                            |u|
                                                                            |uu|
                                                                            (QREFELT
                                                                             $
                                                                             57))
                                                                           (QREFELT
                                                                            $
                                                                            55))
                                                                          0)
                                                                         (PROGN
                                                                           (LETT
                                                                            #10#
                                                                            (SEQ
                                                                             (LETT
                                                                              |ans|
                                                                              (|GENPGCD;lift|
                                                                               |u|
                                                                               (SPADCALL
                                                                                |p1|
                                                                                (SPADCALL
                                                                                 (SPADCALL
                                                                                  |r|
                                                                                  (QREFELT
                                                                                   $
                                                                                   39))
                                                                                 |p2|
                                                                                 (QREFELT
                                                                                  $
                                                                                  60))
                                                                                (QREFELT
                                                                                 $
                                                                                 61))
                                                                               |uu|
                                                                               |lv|
                                                                               |lr|
                                                                               $) . #11#)
                                                                             (EXIT
                                                                              (COND
                                                                                ((QEQCAR
                                                                                  |ans|
                                                                                  0)
                                                                                 (PROGN
                                                                                   (LETT
                                                                                    #9#
                                                                                    (QCDR
                                                                                     |ans|) . #11#)
                                                                                   (GO
                                                                                    #9#)))
                                                                                ('T
                                                                                 "next")))) . #11#)
                                                                           (GO
                                                                            #10#)))))))
                                                                   #10#
                                                                   (EXIT
                                                                    #10#))
                                                                  NIL
                                                                  #13#
                                                                  G191
                                                                  (EXIT
                                                                   NIL))
                                                                 (EXIT
                                                                  (|error|
                                                                   "too many evaluations in GCD code")))))))))))))))))))))))))))
                              NIL #13# G191 (EXIT NIL))
                         (EXIT (COND
                                 ((NULL (< |count| 10))
                                  (|error| "too many evaluations in GCD code"))))))))
           #9# (EXIT #9#))))) 

(DEFUN |GENPGCD;gcdSameVariables!4| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GENPGCD;gcdSameVariables|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 53))
            (QREFELT $ 40)))))) 

(DEFUN |GENPGCD;gcdSameVariables!3| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GENPGCD;gcdSameVariables|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 53))
            (QREFELT $ 40)))))) 

(DEFUN |GENPGCD;gcdSameVariables!2| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GENPGCD;gcdSameVariables|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 53))
            (QREFELT $ 40)))))) 

(DEFUN |GENPGCD;gcdSameVariables!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GENPGCD;gcdSameVariables|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 53))
            (QREFELT $ 40)))))) 

(DEFUN |GENPGCD;gcdSameVariables!0| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 39))) 

(DEFUN |GENPGCD;lift| (|gR| |p| |cfR| |lv| |lr| $)
  (PROG (|lcp| |v| |r| |thisp| |c| #0=#:G1969 #1=#:G1953 #2=#:G1951
               #3=#:G1952 |d| |prime| |origFactors| |n| |Ecart|
               #4=#:G1964 |step| |g| |cf| |pn| #5=#:G1968 #6=#:G1965)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |lcp| (SPADCALL |p| (QREFELT $ 50))
                            . #7=(|GENPGCD;lift|))
                      (LETT |g|
                            (SPADCALL
                                (SPADCALL |lcp|
                                    (SPADCALL |gR| (QREFELT $ 55))
                                    (QREFELT $ 62))
                                (SPADCALL (CONS #'|GENPGCD;lift!0| $)
                                    (SPADCALL |gR| (QREFELT $ 63))
                                    (QREFELT $ 49))
                                (QREFELT $ 61)) . #7#)
                      (LETT |cf|
                            (SPADCALL
                                (SPADCALL |lcp|
                                    (SPADCALL |cfR| (QREFELT $ 55))
                                    (QREFELT $ 62))
                                (SPADCALL (CONS #'|GENPGCD;lift!1| $)
                                    (SPADCALL |cfR| (QREFELT $ 63))
                                    (QREFELT $ 49))
                                (QREFELT $ 61)) . #7#)
                      (LETT |p|
                            (SPADCALL |lcp| |p| (QREFELT $ 60)) . #7#)
                      (SEQ G190
                           (COND
                             ((NULL (COND
                                      ((SPADCALL |lv| NIL
                                        (QREFELT $ 64))
                                       'NIL)
                                      ('T 'T)))
                              #8=(GO G191)))
                           (SEQ (EXIT (SEQ
                                       (LETT |v|
                                        (|SPADfirst| |lv|) . #7#)
                                       (LETT |r|
                                        (|SPADfirst| |lr|) . #7#)
                                       (LETT |lv| (CDR |lv|) . #7#)
                                       (LETT |lr| (CDR |lr|) . #7#)
                                       (LETT |thisp|
                                        (SPADCALL
                                         (CONS #'|GENPGCD;lift!2|
                                          (VECTOR $ |lr| |lv|))
                                         |p| (QREFELT $ 66)) . #7#)
                                       (LETT |d|
                                        (PROGN
                                          (LETT #3# NIL . #7#)
                                          (SEQ (LETT |c| NIL . #7#)
                                           (LETT #0#
                                            (SPADCALL |p|
                                             (QREFELT $ 68)) . #7#)
                                           G190
                                           (COND
                                             ((OR (ATOM #0#)
                                               (PROGN
                                                 (LETT |c|
                                                  (CAR #0#) . #7#)
                                                 NIL))
                                              #8#))
                                           (SEQ
                                            (EXIT
                                             (PROGN
                                               (LETT #1#
                                                (SPADCALL |c| |v|
                                                 (QREFELT $ 69)) . #7#)
                                               (COND
                                                 (#3#
                                                  (LETT #2#
                                                   (MAX #2# #1#) . #7#))
                                                 ('T
                                                  (PROGN
                                                    (LETT #2#
                                                     #1# . #7#)
                                                    (LETT #3# 'T . #7#)))))))
                                           (LETT #0# (CDR #0#) . #7#)
                                           #9=(GO G190) G191
                                           (EXIT NIL))
                                          (COND
                                            (#3# #2#)
                                            ('T
                                             (|IdentityError| '|max|)))) . #7#)
                                       (LETT |prime|
                                        (SPADCALL
                                         (SPADCALL |v| (QREFELT $ 70))
                                         (SPADCALL |r| (QREFELT $ 39))
                                         (QREFELT $ 71)) . #7#)
                                       (LETT |pn| |prime| . #7#)
                                       (LETT |origFactors|
                                        (LIST |g| |cf|) . #7#)
                                       (SEQ
                                        (EXIT
                                         (SEQ (LETT |n| 1 . #7#) G190
                                          (COND
                                            ((QSGREATERP |n| |d|) #8#))
                                          (SEQ
                                           (LETT |Ecart|
                                            (SPADCALL
                                             (SPADCALL |thisp|
                                              (SPADCALL |g| |cf|
                                               (QREFELT $ 24))
                                              (QREFELT $ 31))
                                             |pn| (QREFELT $ 72)) . #7#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |Ecart| 1)
                                               (|error|
                                                "failed lifting in hensel in Complex Polynomial GCD"))
                                              ((SPADCALL (QCDR |Ecart|)
                                                (QREFELT $ 12))
                                               (PROGN
                                                 (LETT #4#
                                                  |$NoValue| . #7#)
                                                 (GO #4#)))
                                              ('T
                                               (SEQ
                                                (LETT |step|
                                                 (SPADCALL
                                                  |origFactors|
                                                  (SPADCALL
                                                   (CONS
                                                    #'|GENPGCD;lift!3|
                                                    (VECTOR $ |r| |v|))
                                                   (QCDR |Ecart|)
                                                   (QREFELT $ 66))
                                                  (QREFELT $ 76)) . #7#)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |step| 1)
                                                    (PROGN
                                                      (LETT #5#
                                                       (CONS 1
                                                        "failed") . #7#)
                                                      (GO #5#)))
                                                   ('T
                                                    (SEQ
                                                     (LETT |g|
                                                      (SPADCALL |g|
                                                       (SPADCALL |pn|
                                                        (|SPADfirst|
                                                         (QCDR |step|))
                                                        (QREFELT $ 60))
                                                       (QREFELT $ 61)) . #7#)
                                                     (LETT |cf|
                                                      (SPADCALL |cf|
                                                       (SPADCALL |pn|
                                                        (SPADCALL
                                                         (QCDR |step|)
                                                         (QREFELT $ 78))
                                                        (QREFELT $ 60))
                                                       (QREFELT $ 61)) . #7#)
                                                     (EXIT
                                                      (LETT |pn|
                                                       (SPADCALL |pn|
                                                        |prime|
                                                        (QREFELT $ 79)) . #7#)))))))))))
                                          (LETT |n| (QSADD1 |n|) . #7#)
                                          #9# G191 (EXIT NIL)))
                                        #4# (EXIT #4#))
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL |thisp|
                                             (SPADCALL |g| |cf|
                                              (QREFELT $ 24))
                                             (QREFELT $ 30)))
                                           (PROGN
                                             (LETT #6#
                                              (PROGN
                                                (LETT #5#
                                                 (CONS 1 "failed") . #7#)
                                                (GO #5#)) . #7#)
                                             (GO #6#)))))))
                                #6# (EXIT #6#))
                           NIL #9# G191 (EXIT NIL))
                      (EXIT (CONS 0 |g|))))
           #5# (EXIT #5#))))) 

(DEFUN |GENPGCD;lift!3| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 73))) 

(DEFUN |GENPGCD;lift!2| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 53))) 

(DEFUN |GENPGCD;lift!1| (|#1| $) (SPADCALL |#1| (QREFELT $ 39))) 

(DEFUN |GENPGCD;lift!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 39))) 

(DEFUN |GENPGCD;recursivelyGCDCoefficients| (|g| |v| |p| |pv| $)
  (PROG (|mv| |u| #0=#:G1978 #1=#:G1972 #2=#:G1970 #3=#:G1971 |d| |i|
              |p1| |oldg| #4=#:G1977 |oldv|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |mv| (|SPADfirst| |pv|)
                            . #5=(|GENPGCD;recursivelyGCDCoefficients|))
                      (LETT |pv| (CDR |pv|) . #5#)
                      (LETT |d|
                            (PROGN
                              (LETT #3# NIL . #5#)
                              (SEQ (LETT |u| NIL . #5#)
                                   (LETT #0#
                                    (SPADCALL |p| (QREFELT $ 68)) . #5#)
                                   G190
                                   (COND
                                     ((OR (ATOM #0#)
                                       (PROGN
                                         (LETT |u| (CAR #0#) . #5#)
                                         NIL))
                                      #6=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (PROGN
                                       (LETT #1#
                                        (SPADCALL |u| |mv|
                                         (QREFELT $ 69)) . #5#)
                                       (COND
                                         (#3#
                                          (LETT #2#
                                           (MAX #2# #1#) . #5#))
                                         ('T
                                          (PROGN
                                            (LETT #2# #1# . #5#)
                                            (LETT #3# 'T . #5#)))))))
                                   (LETT #0# (CDR #0#) . #5#)
                                   #7=(GO G190) G191 (EXIT NIL))
                              (COND
                                (#3# #2#)
                                ('T (|IdentityError| '|max|)))) . #5#)
                      (SEQ (LETT |i| 0 . #5#) G190
                           (COND ((QSGREATERP |i| |d|) #6#))
                           (SEQ (LETT |p1|
                                      (SPADCALL
                                       (CONS
                                        #'|GENPGCD;recursivelyGCDCoefficients!0|
                                        (VECTOR $ |i| |mv|))
                                       |p| (QREFELT $ 66)) . #5#)
                                (LETT |oldg| |g| . #5#)
                                (COND
                                  ((SPADCALL |pv| NIL (QREFELT $ 64))
                                   (LETT |g|
                                    (|GENPGCD;gcdSameVariables| |g|
                                     |p1| |v| $) . #5#))
                                  ('T
                                   (LETT |g|
                                    (|GENPGCD;recursivelyGCDCoefficients|
                                     |p| |v| |p1| |pv| $) . #5#)))
                                (EXIT (COND
                                        ((SPADCALL |g|
                                          (|spadConstant| $ 29)
                                          (QREFELT $ 30))
                                         (PROGN
                                           (LETT #4#
                                            (|spadConstant| $ 29) . #5#)
                                           (GO #4#)))
                                        ((NULL
                                          (SPADCALL |g| |oldg|
                                           (QREFELT $ 30)))
                                         (SEQ (LETT |oldv| |v| . #5#)
                                          (LETT |v|
                                           (|GENPGCD;variables| |g| $) . #5#)
                                          (EXIT
                                           (LETT |pv|
                                            (SPADCALL |pv|
                                             (SPADCALL |v| |oldv|
                                              (QREFELT $ 26))
                                             (QREFELT $ 81)) . #5#)))))))
                           (LETT |i| (QSADD1 |i|) . #5#) #7# G191
                           (EXIT NIL))
                      (EXIT |g|)))
           #4# (EXIT #4#))))) 

(DEFUN |GENPGCD;recursivelyGCDCoefficients!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 80))) 

(DEFUN |GENPGCD;flatten| (|p1| |lv| $)
  (PROG (#0=#:G1986 #1=#:G1987 |dg| |ans| #2=#:G1988 |vv| #3=#:G1989
            |lr|)
    (RETURN
      (SEQ (COND
             ((EQL (LENGTH |lv|) 0) |p1|)
             ('T
              (SEQ (LETT |lr|
                         (PROGN
                           (LETT #0# NIL . #4=(|GENPGCD;flatten|))
                           (SEQ (LETT |vv| NIL . #4#)
                                (LETT #1# |lv| . #4#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |vv| (CAR #1#) . #4#)
                                      NIL))
                                   #5=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS (SPADCALL (QREFELT $ 36))
                                        #0#) . #4#)))
                                (LETT #1# (CDR #1#) . #4#) #6=(GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #4#)
                   (LETT |dg| (SPADCALL |p1| (QREFELT $ 18)) . #4#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((EQL |dg|
                                     (SPADCALL
                                      (LETT |ans|
                                       (SPADCALL
                                        (CONS #'|GENPGCD;flatten!0|
                                         (VECTOR $ |lr| |lv|))
                                        |p1| (QREFELT $ 66)) . #4#)
                                      (QREFELT $ 18)))
                                    'NIL)
                                   ('T 'T)))
                           #5#))
                        (SEQ (EXIT (LETT |lr|
                                    (PROGN
                                      (LETT #2# NIL . #4#)
                                      (SEQ (LETT |vv| NIL . #4#)
                                       (LETT #3# |lv| . #4#) G190
                                       (COND
                                         ((OR (ATOM #3#)
                                           (PROGN
                                             (LETT |vv|
                                              (CAR #3#) . #4#)
                                             NIL))
                                          #5#))
                                       (SEQ
                                        (EXIT
                                         (LETT #2#
                                          (CONS
                                           (SPADCALL (QREFELT $ 36))
                                           #2#) . #4#)))
                                       (LETT #3# (CDR #3#) . #4#) #6#
                                       G191 (EXIT (NREVERSE0 #2#)))) . #4#)))
                        NIL #6# G191 (EXIT NIL))
                   (EXIT |ans|)))))))) 

(DEFUN |GENPGCD;flatten!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 53))) 

(DEFUN |GENPGCD;variables| (|p1| $)
  (PROG (|u| #0=#:G1994 #1=#:G1992 #2=#:G1990 #3=#:G1991)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #3# NIL . #4=(|GENPGCD;variables|))
                 (SEQ (LETT |u| NIL . #4#)
                      (LETT #0# (SPADCALL |p1| (QREFELT $ 68)) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |u| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (PROGN
                                   (LETT #1#
                                    (SPADCALL |u| (QREFELT $ 82)) . #4#)
                                   (COND
                                     (#3#
                                      (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 83)) . #4#))
                                     ('T
                                      (PROGN
                                        (LETT #2# #1# . #4#)
                                        (LETT #3# 'T . #4#)))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|IdentityError| '|concat|))))
               (QREFELT $ 84)))))) 

(DEFUN |GENPGCD;gcdTrivial| (|p1| |p2| $)
  (PROG (|cp1| |un?|)
    (RETURN
      (SEQ (LETT |cp1| (SPADCALL |p1| (QREFELT $ 50))
                 . #0=(|GENPGCD;gcdTrivial|))
           (EXIT (COND
                   ((SPADCALL |cp1| (|spadConstant| $ 28)
                        (QREFELT $ 85))
                    (|spadConstant| $ 29))
                   ((EQL (SPADCALL |p2| (QREFELT $ 18)) 0)
                    (SPADCALL
                        (SPADCALL |cp1| (SPADCALL |p2| (QREFELT $ 50))
                            (QREFELT $ 51))
                        (QREFELT $ 86)))
                   ('T
                    (SEQ (LETT |un?|
                               (SPADCALL |cp1| (QREFELT $ 87)) . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((OR
                                           (SPADCALL |p2|
                                            (QREFELT $ 12))
                                           |un?|)
                                          'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |cp1|
                                    (SPADCALL
                                     (SPADCALL |p2| (QREFELT $ 50))
                                     |cp1| (QREFELT $ 51)) . #0#)
                                   (LETT |un?|
                                    (SPADCALL |cp1| (QREFELT $ 87)) . #0#)
                                   (EXIT
                                    (LETT |p2|
                                     (SPADCALL |p2| (QREFELT $ 88)) . #0#)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (COND
                                 (|un?| (|spadConstant| $ 29))
                                 ('T (SPADCALL |cp1| (QREFELT $ 86))))))))))))) 

(DEFUN |GENPGCD;monomContentSup| (|u| $)
  (PROG (|md|)
    (RETURN
      (SEQ (COND
             ((EQL (SPADCALL |u| (QREFELT $ 18)) 0)
              (|spadConstant| $ 29))
             ('T
              (SEQ (LETT |md| (SPADCALL |u| (QREFELT $ 89))
                         |GENPGCD;monomContentSup|)
                   (EXIT (SPADCALL
                             (SPADCALL
                                 (SPADCALL
                                     (CONS
                                      (|function| |GENPGCD;better|) $)
                                     (SPADCALL |u| (QREFELT $ 68))
                                     (QREFELT $ 91))
                                 (QREFELT $ 93))
                             (SPADCALL (|spadConstant| $ 28) |md|
                                 (QREFELT $ 62))
                             (QREFELT $ 60)))))))))) 

(DEFUN |GENPGCD;better| (|p1| |p2| $)
  (PROG (#0=#:G2010)
    (RETURN
      (COND
        ((SPADCALL |p1| (QREFELT $ 94)) 'T)
        ((SPADCALL |p2| (QREFELT $ 94)) 'NIL)
        ('T
         (< (SPADCALL |p1|
                      (PROG2 (LETT #0# (SPADCALL |p1| (QREFELT $ 96))
                                   . #1=(|GENPGCD;better|))
                             (QCDR #0#)
                        (|check-union| (QEQCAR #0# 0) (QREFELT $ 7)
                            #0#))
                      (QREFELT $ 69))
            (SPADCALL |p2|
                (PROG2 (LETT #0# (SPADCALL |p2| (QREFELT $ 96)) . #1#)
                       (QCDR #0#)
                  (|check-union| (QEQCAR #0# 0) (QREFELT $ 7) #0#))
                (QREFELT $ 69)))))))) 

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

(DEFUN |GeneralPolynomialGcdPackage;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|GeneralPolynomialGcdPackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|GeneralPolynomialGcdPackage| DV$1 DV$2 DV$3 DV$4) . #0#)
        (LETT $ (GETREFV 97) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|GeneralPolynomialGcdPackage|
            (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (COND
          ((|HasCategory| |#3| '(|StepThrough|))
           (PROGN
             (QSETREFV $ 34 (|spadConstant| $ 33))
             (QSETREFV $ 36
                 (CONS (|dispatchFunction| |GENPGCD;randomR;R;2|) $))))
          ('T
           (QSETREFV $ 36
               (CONS (|dispatchFunction| |GENPGCD;randomR;R;3|) $))))
        $)))) 

(MAKEPROP '|GeneralPolynomialGcdPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|Boolean|)
             (|SparseUnivariatePolynomial| 9) (0 . |zero?|)
             (5 . |Zero|) (9 . |Zero|) (13 . |Zero|) (17 . |Zero|)
             (|NonNegativeInteger|) (21 . |degree|)
             (|Union| $ '"failed") (26 . |exquo|)
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (32 . |unitNormal|) (37 . |gcd|) (43 . *) (|List| 7)
             (49 . |setDifference|) (55 . |One|) (59 . |One|)
             (63 . |One|) (67 . =) (73 . -)
             |GENPGCD;gcdPolynomial;3Sup;1| (79 . |init|)
             '|randomCount| (83 . |nextItem|) (88 . |randomR|)
             (|Integer|) (92 . |coerce|) (97 . |coerce|)
             (102 . |ground|) (|SparseUnivariatePolynomial| 8)
             (|Mapping| 8 9)
             (|UnivariatePolynomialCategoryFunctions2| 9 11 8 41)
             (107 . |map|) (|SparseUnivariatePolynomial| $)
             (113 . |gcdPolynomial|) (|Mapping| 9 8)
             (|UnivariatePolynomialCategoryFunctions2| 8 41 9 11)
             (119 . |map|) (125 . |leadingCoefficient|) (130 . |gcd|)
             (|List| 8) (136 . |eval|) (143 . |zero?|) (148 . |degree|)
             (153 . |exquo|) (159 . |gcd|) (165 . *) (171 . +)
             (177 . *) (183 . +) (189 . |monomial|) (195 . |reductum|)
             (200 . =) (|Mapping| 9 9) (206 . |map|) (|List| 9)
             (212 . |coefficients|) (217 . |degree|) (223 . |coerce|)
             (228 . -) (234 . |exquo|) (240 . |eval|)
             (|Union| 75 '"failed") (|List| 45)
             (247 . |solveLinearPolynomialEquation|) (|List| 11)
             (253 . |second|) (258 . *) (264 . |coefficient|)
             (271 . |setUnion|) (277 . |variables|) (282 . |concat|)
             (288 . |removeDuplicates|) (293 . =) (299 . |coerce|)
             (304 . |unit?|) (309 . |reductum|) (314 . |minimumDegree|)
             (|Mapping| 10 9 9) (319 . |sort|) (|List| $) (325 . |gcd|)
             (330 . |ground?|) (|Union| 7 '"failed")
             (335 . |mainVariable|))
          '#(|randomR| 340 |gcdPolynomial| 344) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 96
                                '(1 11 10 0 12 0 6 0 13 0 8 0 14 0 9 0
                                  15 0 11 0 16 1 11 17 0 18 2 11 19 0 0
                                  20 1 11 21 0 22 2 11 0 0 0 23 2 11 0
                                  0 0 24 2 25 0 0 0 26 0 8 0 27 0 9 0
                                  28 0 11 0 29 2 11 10 0 0 30 2 11 0 0
                                  0 31 0 8 0 33 1 8 19 0 35 0 0 8 36 1
                                  8 0 37 38 1 9 0 8 39 1 9 8 0 40 2 43
                                  41 42 11 44 2 8 45 45 45 46 2 48 11
                                  47 41 49 1 11 9 0 50 2 9 0 0 0 51 3 9
                                  0 0 25 52 53 1 9 10 0 54 1 41 17 0 55
                                  2 41 19 0 0 56 2 41 0 0 0 57 2 41 0 8
                                  0 58 2 41 0 0 0 59 2 11 0 9 0 60 2 11
                                  0 0 0 61 2 11 0 9 17 62 1 41 0 0 63 2
                                  25 10 0 0 64 2 11 0 65 0 66 1 11 67 0
                                  68 2 9 17 0 7 69 1 9 0 7 70 2 9 0 0 0
                                  71 2 11 19 0 9 72 3 9 0 0 7 8 73 2 9
                                  74 75 45 76 1 77 11 0 78 2 9 0 0 0 79
                                  3 9 0 0 7 17 80 2 25 0 0 0 81 1 9 25
                                  0 82 2 25 0 0 0 83 1 25 0 0 84 2 9 10
                                  0 0 85 1 11 0 9 86 1 9 10 0 87 1 11 0
                                  0 88 1 11 17 0 89 2 67 0 90 0 91 1 9
                                  0 92 93 1 9 10 0 94 1 9 95 0 96 0 0 8
                                  36 2 0 11 11 11 32)))))
          '|lookupComplete|)) 
