
(/VERSIONCHECK 2) 

(DEFUN |HEUGCD;myNextPrime| (|val| |bound| $) (SPADCALL |val| (QREFELT $ 11))) 

(DEFUN |HEUGCD;constNotZero| (|f| $)
  (COND
   ((EQL (SPADCALL |f| (QREFELT $ 13)) 0)
    (COND ((SPADCALL |f| (QREFELT $ 15)) 'NIL) (#1='T 'T)))
   (#1# 'NIL))) 

(DEFUN |HEUGCD;negShiftz| (|n| |Modulus| $)
  (COND ((< |n| 0) (LETT |n| (+ |n| |Modulus|) |HEUGCD;negShiftz|))
        ((< (QUOTIENT2 |Modulus| 2) |n|) (- |n| |Modulus|)) ('T |n|))) 

(DEFUN |HEUGCD;height| (|f| $)
  (PROG (|k| #1=#:G1819)
    (RETURN
     (SEQ (LETT |k| 1 . #2=(|HEUGCD;height|))
          (SEQ G190
               (COND
                ((NULL
                  (COND
                   ((SPADCALL |f| (|spadConstant| $ 16) (QREFELT $ 17)) 'NIL)
                   ('T 'T)))
                 (GO G191)))
               (SEQ
                (LETT |k|
                      (MAX |k|
                           (PROG1
                               (LETT #1# (ABS (SPADCALL |f| (QREFELT $ 18)))
                                     . #2#)
                             (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                                              #1#)))
                      . #2#)
                (EXIT (LETT |f| (SPADCALL |f| (QREFELT $ 19)) . #2#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT |k|))))) 

(DEFUN |HEUGCD;genpoly| (|dval| |value| $)
  (PROG (|val| |d| |val1| |i|)
    (RETURN
     (SEQ (LETT |d| (|spadConstant| $ 16) . #1=(|HEUGCD;genpoly|))
          (LETT |val| |dval| . #1#)
          (SEQ (LETT |i| 0 . #1#) G190
               (COND ((NULL (COND ((EQL |val| 0) 'NIL) ('T 'T))) (GO G191)))
               (SEQ
                (LETT |val1|
                      (|HEUGCD;negShiftz| (REMAINDER2 |val| |value|) |value| $)
                      . #1#)
                (LETT |d|
                      (SPADCALL |d| (SPADCALL |val1| |i| (QREFELT $ 20))
                                (QREFELT $ 21))
                      . #1#)
                (EXIT (LETT |val| (QUOTIENT2 (- |val| |val1|) |value|) . #1#)))
               (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |d|))))) 

(DEFUN |HEUGCD;lintgcd;LI;6| (|lval| $)
  (PROG (|val| #1=#:G1843 |val1|)
    (RETURN
     (SEQ
      (COND ((NULL |lval|) 0) ((SPADCALL 1 |lval| (QREFELT $ 24)) 1)
            ('T
             (SEQ
              (LETT |lval| (SPADCALL (ELT $ 25) |lval| (QREFELT $ 27))
                    . #2=(|HEUGCD;lintgcd;LI;6|))
              (LETT |val| (|SPADfirst| |lval|) . #2#)
              (SEQ (LETT |val1| NIL . #2#) (LETT #1# (CDR |lval|) . #2#) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |val1| (CAR #1#) . #2#) NIL)
                         (NULL (COND ((EQL |val| 1) 'NIL) ('T 'T))))
                     (GO G191)))
                   (SEQ (EXIT (LETT |val| (GCD |val| |val1|) . #2#)))
                   (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
              (EXIT |val|)))))))) 

(DEFUN |HEUGCD;content;LL;7| (|listf| $)
  (PROG (#1=#:G1847 |f| #2=#:G1846)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|HEUGCD;content;LL;7|))
       (SEQ (LETT |f| NIL . #3#) (LETT #1# |listf| . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |f| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #2#
                    (CONS
                     (SPADCALL (SPADCALL |f| (QREFELT $ 29)) (QREFELT $ 28))
                     #2#)
                    . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |HEUGCD;contprim| (|listf| $)
  (PROG (#1=#:G1853 |c| #2=#:G1858 |f| #3=#:G1857)
    (RETURN
     (SEQ
      (PROGN
       (LETT #3# NIL . #4=(|HEUGCD;contprim|))
       (SEQ (LETT |f| NIL . #4#) (LETT #2# |listf| . #4#) G190
            (COND
             ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) . #4#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #3#
                    (CONS
                     (CONS
                      (LETT |c|
                            (SPADCALL (SPADCALL |f| (QREFELT $ 29))
                                      (QREFELT $ 28))
                            . #4#)
                      (PROG2
                          (LETT #1# (SPADCALL |f| |c| (QREFELT $ 33)) . #4#)
                          (QCDR #1#)
                        (|check-union| (QEQCAR #1# 0) (QREFELT $ 6) #1#)))
                     #3#)
                    . #4#)))
            (LETT #2# (CDR #2#) . #4#) (GO G190) G191
            (EXIT (NREVERSE0 #3#)))))))) 

(DEFUN |HEUGCD;constcase| (|listdeg| |listf| $)
  (PROG (#1=#:G1874 |lcf| #2=#:G1873 |d| |lclistf| #3=#:G1872 |f| #4=#:G1871
         #5=#:G1862 #6=#:G1861 #7=#:G1863 #8=#:G1870 |n| |lind|)
    (RETURN
     (SEQ
      (LETT |lind|
            (SPADCALL (CONS (|function| |HEUGCD;constNotZero|) $) |listf|
                      (QREFELT $ 35))
            . #9=(|HEUGCD;constcase|))
      (EXIT
       (COND
        ((NULL |lind|)
         (COND
          ((SPADCALL 1 |listdeg| (QREFELT $ 37))
           (|HEUGCD;lincase| |listdeg| |listf| $))
          (#10='T (|HEUGCD;localgcd| |listf| $))))
        ((PROGN
          (LETT #5# NIL . #9#)
          (SEQ (LETT |n| NIL . #9#) (LETT #8# |listdeg| . #9#) G190
               (COND
                ((OR (ATOM #8#) (PROGN (LETT |n| (CAR #8#) . #9#) NIL))
                 #11=(GO G191)))
               (SEQ
                (EXIT
                 (PROGN
                  (LETT #7# (< 0 |n|) . #9#)
                  (COND (#5# (LETT #6# (COND (#6# 'T) ('T #7#)) . #9#))
                        ('T
                         (PROGN (LETT #6# #7# . #9#) (LETT #5# 'T . #9#)))))))
               (LETT #8# (CDR #8#) . #9#) #12=(GO G190) G191 (EXIT NIL))
          (COND (#5# #6#) (#10# 'NIL)))
         (CONS (|spadConstant| $ 22) |listf|))
        (#10#
         (SEQ
          (LETT |lclistf|
                (PROGN
                 (LETT #4# NIL . #9#)
                 (SEQ (LETT |f| NIL . #9#) (LETT #3# |listf| . #9#) G190
                      (COND
                       ((OR (ATOM #3#) (PROGN (LETT |f| (CAR #3#) . #9#) NIL))
                        #11#))
                      (SEQ
                       (EXIT
                        (LETT #4# (CONS (SPADCALL |f| (QREFELT $ 18)) #4#)
                              . #9#)))
                      (LETT #3# (CDR #3#) . #9#) #12# G191
                      (EXIT (NREVERSE0 #4#))))
                . #9#)
          (LETT |d| (SPADCALL |lclistf| (QREFELT $ 28)) . #9#)
          (EXIT
           (COND ((EQL |d| 1) (CONS (|spadConstant| $ 22) |listf|))
                 (#10#
                  (CONS (SPADCALL |d| (QREFELT $ 38))
                        (PROGN
                         (LETT #2# NIL . #9#)
                         (SEQ (LETT |lcf| NIL . #9#) (LETT #1# |lclistf| . #9#)
                              G190
                              (COND
                               ((OR (ATOM #1#)
                                    (PROGN (LETT |lcf| (CAR #1#) . #9#) NIL))
                                #11#))
                              (SEQ
                               (EXIT
                                (LETT #2#
                                      (CONS
                                       (SPADCALL (QUOTIENT2 |lcf| |d|)
                                                 (QREFELT $ 38))
                                       #2#)
                                      . #9#)))
                              (LETT #1# (CDR #1#) . #9#) #12# G191
                              (EXIT (NREVERSE0 #2#)))))))))))))))) 

(DEFUN |HEUGCD;testDivide| (|listf| |g| $)
  (PROG (|result| #1=#:G1885 |f1| #2=#:G1886 |f|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |result| NIL . #3=(|HEUGCD;testDivide|))
            (SEQ (LETT |f| NIL . #3#) (LETT #2# |listf| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (SEQ (LETT |f1| (SPADCALL |f| |g| (QREFELT $ 39)) . #3#)
                       (EXIT
                        (COND
                         ((QEQCAR |f1| 1)
                          (PROGN
                           (LETT #1# (CONS 1 "failed") . #3#)
                           (GO #1#))))))
                  (EXIT (LETT |result| (CONS (QCDR |f1|) |result|) . #3#)))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 (NREVERSE |result|)))))
      #1# (EXIT #1#))))) 

(DEFUN |HEUGCD;lincase| (|listdeg| |listf| $)
  (PROG (|result| #1=#:G1902 |f1| #2=#:G1903 |f| |g| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |n| (SPADCALL 1 |listdeg| (QREFELT $ 42))
              . #3=(|HEUGCD;lincase|))
        (LETT |g| (SPADCALL |listf| |n| (QREFELT $ 43)) . #3#)
        (LETT |result| (LIST |g|) . #3#)
        (SEQ (LETT |f| NIL . #3#) (LETT #2# |listf| . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |f| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (SEQ (LETT |f1| (SPADCALL |f| |g| (QREFELT $ 39)) . #3#)
                   (EXIT
                    (COND
                     ((QEQCAR |f1| 1)
                      (PROGN
                       (LETT #1# (CONS (|spadConstant| $ 22) |listf|) . #3#)
                       (GO #1#))))))
              (EXIT (LETT |result| (CONS (QCDR |f1|) |result|) . #3#)))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT (REVERSE |result|))))
      #1# (EXIT #1#))))) 

(DEFUN |HEUGCD;mindegpol| (|f| |g| $)
  (COND ((< (SPADCALL |g| (QREFELT $ 13)) (SPADCALL |f| (QREFELT $ 13))) |g|)
        ('T |f|))) 

(DEFUN |HEUGCD;localgcd| (|listf| $)
  (PROG (#1=#:G1916 #2=#:G1938 |f| #3=#:G1937 |gg| |answr| #4=#:G1924 |nvalue|
         #5=#:G1931 |result| |flag| |f1| #6=#:G1936 |d| |contd| |dd| |dval|
         |listval| #7=#:G1935 #8=#:G1934 |k| #9=#:G1876 |minf| #10=#:G1912
         #11=#:G1911 #12=#:G1913 #13=#:G1933 |hgt| #14=#:G1908 #15=#:G1907
         #16=#:G1909 #17=#:G1932)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |hgt|
              (PROGN
               (LETT #14# NIL . #18=(|HEUGCD;localgcd|))
               (SEQ (LETT |f| NIL . #18#) (LETT #17# |listf| . #18#) G190
                    (COND
                     ((OR (ATOM #17#) (PROGN (LETT |f| (CAR #17#) . #18#) NIL))
                      #19=(GO G191)))
                    (SEQ
                     (EXIT
                      (COND
                       ((COND ((SPADCALL |f| (QREFELT $ 15)) 'NIL) (#20='T 'T))
                        (PROGN
                         (LETT #16# (|HEUGCD;height| |f| $) . #18#)
                         (COND (#14# (LETT #15# (MIN #15# #16#) . #18#))
                               ('T
                                (PROGN
                                 (LETT #15# #16# . #18#)
                                 (LETT #14# 'T . #18#)))))))))
                    (LETT #17# (CDR #17#) . #18#) #21=(GO G190) G191
                    (EXIT NIL))
               (COND (#14# #15#) (#20# (|IdentityError| '|min|))))
              . #18#)
        (LETT |answr| (+ 2 (* 2 |hgt|)) . #18#)
        (LETT |minf|
              (PROGN
               (LETT #10# NIL . #18#)
               (SEQ (LETT |f| NIL . #18#) (LETT #13# |listf| . #18#) G190
                    (COND
                     ((OR (ATOM #13#) (PROGN (LETT |f| (CAR #13#) . #18#) NIL))
                      #19#))
                    (SEQ
                     (EXIT
                      (COND
                       ((COND ((SPADCALL |f| (QREFELT $ 15)) 'NIL) (#20# 'T))
                        (PROGN
                         (LETT #12# |f| . #18#)
                         (COND
                          (#10#
                           (LETT #11# (|HEUGCD;mindegpol| #11# #12# $) . #18#))
                          ('T
                           (PROGN
                            (LETT #11# #12# . #18#)
                            (LETT #10# 'T . #18#)))))))))
                    (LETT #13# (CDR #13#) . #18#) #21# G191 (EXIT NIL))
               (COND (#10# #11#) (#20# (|IdentityError| '|mindegpol|))))
              . #18#)
        (EXIT
         (COND
          ((QEQCAR
            (LETT |result| (|HEUGCD;testDivide| |listf| |minf| $) . #18#) 0)
           (CONS |minf|
                 (PROG2
                     (LETT #9# |result| . #18#)
                     (QCDR #9#)
                   (|check-union| (QEQCAR #9# 0) (|List| (QREFELT $ 6)) #9#))))
          (#20#
           (SEQ
            (COND
             ((< (SPADCALL |minf| (QREFELT $ 13)) 100)
              (SEQ (LETT |k| 1 . #18#) G190 (COND ((QSGREATERP |k| 10) #19#))
                   (SEQ
                    (LETT |listval|
                          (PROGN
                           (LETT #8# NIL . #18#)
                           (SEQ (LETT |f| NIL . #18#) (LETT #7# |listf| . #18#)
                                G190
                                (COND
                                 ((OR (ATOM #7#)
                                      (PROGN (LETT |f| (CAR #7#) . #18#) NIL))
                                  #19#))
                                (SEQ
                                 (EXIT
                                  (LETT #8#
                                        (CONS
                                         (SPADCALL |f| |answr| (QREFELT $ 45))
                                         #8#)
                                        . #18#)))
                                (LETT #7# (CDR #7#) . #18#) #21# G191
                                (EXIT (NREVERSE0 #8#))))
                          . #18#)
                    (LETT |dval| (SPADCALL |listval| (QREFELT $ 28)) . #18#)
                    (LETT |dd| (|HEUGCD;genpoly| |dval| |answr| $) . #18#)
                    (LETT |contd| (SPADCALL |dd| (QREFELT $ 46)) . #18#)
                    (LETT |d|
                          (PROG2
                              (LETT #1# (SPADCALL |dd| |contd| (QREFELT $ 33))
                                    . #18#)
                              (QCDR #1#)
                            (|check-union| (QEQCAR #1# 0) (QREFELT $ 6) #1#))
                          . #18#)
                    (LETT |result| (LIST |d|) . #18#) (LETT |flag| 'T . #18#)
                    (SEQ (LETT |f| NIL . #18#) (LETT #6# |listf| . #18#) G190
                         (COND
                          ((OR (ATOM #6#)
                               (PROGN (LETT |f| (CAR #6#) . #18#) NIL)
                               (NULL |flag|))
                           #19#))
                         (SEQ
                          (LETT |f1| (SPADCALL |f| |d| (QREFELT $ 39)) . #18#)
                          (EXIT
                           (COND ((QEQCAR |f1| 1) (LETT |flag| 'NIL . #18#))
                                 ('T
                                  (LETT |result| (CONS (QCDR |f1|) |result|)
                                        . #18#)))))
                         (LETT #6# (CDR #6#) . #18#) #21# G191 (EXIT NIL))
                    (COND
                     (|flag|
                      (PROGN (LETT #5# (REVERSE |result|) . #18#) (GO #5#))))
                    (LETT |nvalue| (QUOTIENT2 (* |answr| 832040) 317811)
                          . #18#)
                    (COND
                     ((EQL (REMAINDER2 (+ |nvalue| |answr|) 2) 0)
                      (LETT |nvalue| (+ |nvalue| 1) . #18#)))
                    (EXIT
                     (LETT |answr|
                           (PROG1 (LETT #4# |nvalue| . #18#)
                             (|check-subtype| (> #4# 0) '(|PositiveInteger|)
                                              #4#))
                           . #18#)))
                   (LETT |k| (QSADD1 |k|) . #18#) #21# G191 (EXIT NIL))))
            (LETT |gg| (SPADCALL |listf| (QREFELT $ 47)) . #18#)
            (EXIT
             (CONS |gg|
                   (PROGN
                    (LETT #3# NIL . #18#)
                    (SEQ (LETT |f| NIL . #18#) (LETT #2# |listf| . #18#) G190
                         (COND
                          ((OR (ATOM #2#)
                               (PROGN (LETT |f| (CAR #2#) . #18#) NIL))
                           #19#))
                         (SEQ
                          (EXIT
                           (LETT #3#
                                 (CONS
                                  (PROG2
                                      (LETT #1#
                                            (SPADCALL |f| |gg| (QREFELT $ 39))
                                            . #18#)
                                      (QCDR #1#)
                                    (|check-union| (QEQCAR #1# 0) (QREFELT $ 6)
                                                   #1#))
                                  #3#)
                                 . #18#)))
                         (LETT #2# (CDR #2#) . #18#) #21# G191
                         (EXIT (NREVERSE0 #3#))))))))))))
      #5# (EXIT #5#))))) 

(DEFUN |HEUGCD;internal| (|flag| |listf| $)
  (PROG (|ans| #1=#:G1980 |p| #2=#:G1981 |q| #3=#:G1979 |result| |#G49| |#G48|
         #4=#:G1968 |f| #5=#:G1961 |lcg| #6=#:G1978 |g| |listdeg| #7=#:G1977
         #8=#:G1976 |minpol| #9=#:G1975 |term| #10=#:G1974 |contgcd| |Cgcd|
         #11=#:G1973 #12=#:G1972 |contlistf| #13=#:G1948 #14=#:G1971
         #15=#:G1970 |minpol1| |mdeg| #16=#:G1945 #17=#:G1944 #18=#:G1946
         #19=#:G1969 |nlf|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((SPADCALL |listf| NIL (QREFELT $ 48)) (LIST (|spadConstant| $ 22)))
        (#20='T
         (SEQ (LETT |nlf| (LENGTH |listf|) . #21=(|HEUGCD;internal|))
              (EXIT
               (COND
                ((EQL |nlf| 1)
                 (LIST (|SPADfirst| |listf|) (|spadConstant| $ 22)))
                (#20#
                 (SEQ (LETT |minpol| (|spadConstant| $ 22) . #21#)
                      (LETT |mdeg|
                            (PROGN
                             (LETT #16# NIL . #21#)
                             (SEQ (LETT |f| NIL . #21#)
                                  (LETT #19# |listf| . #21#) G190
                                  (COND
                                   ((OR (ATOM #19#)
                                        (PROGN
                                         (LETT |f| (CAR #19#) . #21#)
                                         NIL))
                                    #22=(GO G191)))
                                  (SEQ
                                   (EXIT
                                    (PROGN
                                     (LETT #18# (SPADCALL |f| (QREFELT $ 49))
                                           . #21#)
                                     (COND
                                      (#16# (LETT #17# (MIN #17# #18#) . #21#))
                                      ('T
                                       (PROGN
                                        (LETT #17# #18# . #21#)
                                        (LETT #16# 'T . #21#)))))))
                                  (LETT #19# (CDR #19#) . #21#) #23=(GO G190)
                                  G191 (EXIT NIL))
                             (COND (#16# #17#)
                                   (#20# (|IdentityError| '|min|))))
                            . #21#)
                      (COND
                       ((< 0 |mdeg|)
                        (SEQ
                         (LETT |minpol1| (SPADCALL 1 |mdeg| (QREFELT $ 20))
                               . #21#)
                         (LETT |listf|
                               (PROGN
                                (LETT #15# NIL . #21#)
                                (SEQ (LETT |f| NIL . #21#)
                                     (LETT #14# |listf| . #21#) G190
                                     (COND
                                      ((OR (ATOM #14#)
                                           (PROGN
                                            (LETT |f| (CAR #14#) . #21#)
                                            NIL))
                                       #22#))
                                     (SEQ
                                      (EXIT
                                       (LETT #15#
                                             (CONS
                                              (PROG2
                                                  (LETT #13#
                                                        (SPADCALL |f| |minpol1|
                                                                  (QREFELT $
                                                                           39))
                                                        . #21#)
                                                  (QCDR #13#)
                                                (|check-union| (QEQCAR #13# 0)
                                                               (QREFELT $ 6)
                                                               #13#))
                                              #15#)
                                             . #21#)))
                                     (LETT #14# (CDR #14#) . #21#) #23# G191
                                     (EXIT (NREVERSE0 #15#))))
                               . #21#)
                         (EXIT
                          (LETT |minpol|
                                (SPADCALL |minpol| |minpol1| (QREFELT $ 50))
                                . #21#)))))
                      (LETT |Cgcd| NIL . #21#) (LETT |contgcd| 1 . #21#)
                      (COND
                       ((OR (QEQCAR |flag| 1) (QEQCAR |flag| 3))
                        (SEQ
                         (LETT |contlistf| (|HEUGCD;contprim| |listf| $)
                               . #21#)
                         (LETT |Cgcd|
                               (PROGN
                                (LETT #12# NIL . #21#)
                                (SEQ (LETT |term| NIL . #21#)
                                     (LETT #11# |contlistf| . #21#) G190
                                     (COND
                                      ((OR (ATOM #11#)
                                           (PROGN
                                            (LETT |term| (CAR #11#) . #21#)
                                            NIL))
                                       #22#))
                                     (SEQ
                                      (EXIT
                                       (LETT #12# (CONS (QCAR |term|) #12#)
                                             . #21#)))
                                     (LETT #11# (CDR #11#) . #21#) #23# G191
                                     (EXIT (NREVERSE0 #12#))))
                               . #21#)
                         (LETT |contgcd| (SPADCALL |Cgcd| (QREFELT $ 28))
                               . #21#)
                         (LETT |listf|
                               (PROGN
                                (LETT #10# NIL . #21#)
                                (SEQ (LETT |term| NIL . #21#)
                                     (LETT #9# |contlistf| . #21#) G190
                                     (COND
                                      ((OR (ATOM #9#)
                                           (PROGN
                                            (LETT |term| (CAR #9#) . #21#)
                                            NIL))
                                       #22#))
                                     (SEQ
                                      (EXIT
                                       (LETT #10# (CONS (QCDR |term|) #10#)
                                             . #21#)))
                                     (LETT #9# (CDR #9#) . #21#) #23# G191
                                     (EXIT (NREVERSE0 #10#))))
                               . #21#)
                         (EXIT
                          (LETT |minpol|
                                (SPADCALL |contgcd| |minpol| (QREFELT $ 51))
                                . #21#)))))
                      (LETT |listdeg|
                            (PROGN
                             (LETT #8# NIL . #21#)
                             (SEQ (LETT |f| NIL . #21#)
                                  (LETT #7# |listf| . #21#) G190
                                  (COND
                                   ((OR (ATOM #7#)
                                        (PROGN
                                         (LETT |f| (CAR #7#) . #21#)
                                         NIL))
                                    #22#))
                                  (SEQ
                                   (EXIT
                                    (LETT #8#
                                          (CONS (SPADCALL |f| (QREFELT $ 13))
                                                #8#)
                                          . #21#)))
                                  (LETT #7# (CDR #7#) . #21#) #23# G191
                                  (EXIT (NREVERSE0 #8#))))
                            . #21#)
                      (LETT |f| (|SPADfirst| |listf|) . #21#)
                      (COND
                       ((NULL
                         (EQL
                          (SPADCALL (SPADCALL |f| (QREFELT $ 18))
                                    (QREFELT $ 10) (QREFELT $ 52))
                          0))
                        (SEQ
                         (EXIT
                          (SEQ (LETT |g| NIL . #21#)
                               (LETT #6# (CDR |listf|) . #21#) G190
                               (COND
                                ((OR (ATOM #6#)
                                     (PROGN (LETT |g| (CAR #6#) . #21#) NIL))
                                 #22#))
                               (SEQ
                                (LETT |lcg| (SPADCALL |g| (QREFELT $ 18))
                                      . #21#)
                                (COND
                                 ((EQL
                                   (SPADCALL |lcg| (QREFELT $ 10)
                                             (QREFELT $ 52))
                                   0)
                                  (PROGN
                                   (LETT #5# |$NoValue| . #21#)
                                   (GO #5#))))
                                (LETT |f|
                                      (SPADCALL |f| |g| (QREFELT $ 10)
                                                (QREFELT $ 54))
                                      . #21#)
                                (EXIT
                                 (COND
                                  ((EQL (SPADCALL |f| (QREFELT $ 13)) 0)
                                   (PROGN
                                    (LETT #4# (CONS |minpol| |listf|) . #21#)
                                    (GO #4#))))))
                               (LETT #6# (CDR #6#) . #21#) #23# G191
                               (EXIT NIL)))
                         #5# (EXIT #5#))))
                      (LETT |ans|
                            (COND
                             ((SPADCALL 0 |listdeg| (QREFELT $ 37))
                              (|HEUGCD;constcase| |listdeg| |listf| $))
                             ((SPADCALL 1 |listdeg| (QREFELT $ 37))
                              (|HEUGCD;lincase| |listdeg| |listf| $))
                             (#20# (|HEUGCD;localgcd| |listf| $)))
                            . #21#)
                      (PROGN
                       (LETT |#G48|
                             (SPADCALL (|SPADfirst| |ans|) |minpol|
                                       (QREFELT $ 50))
                             . #21#)
                       (LETT |#G49| (CDR |ans|) . #21#)
                       (LETT |result| |#G48| . #21#)
                       (LETT |ans| |#G49| . #21#))
                      (COND
                       ((QEQCAR |flag| 3)
                        (LETT |ans|
                              (PROGN
                               (LETT #3# NIL . #21#)
                               (SEQ (LETT |q| NIL . #21#)
                                    (LETT #2# |ans| . #21#)
                                    (LETT |p| NIL . #21#)
                                    (LETT #1# |Cgcd| . #21#) G190
                                    (COND
                                     ((OR (ATOM #1#)
                                          (PROGN
                                           (LETT |p| (CAR #1#) . #21#)
                                           NIL)
                                          (ATOM #2#)
                                          (PROGN
                                           (LETT |q| (CAR #2#) . #21#)
                                           NIL))
                                      #22#))
                                    (SEQ
                                     (EXIT
                                      (LETT #3#
                                            (CONS
                                             (SPADCALL
                                              (QUOTIENT2 |p| |contgcd|) |q|
                                              (QREFELT $ 51))
                                             #3#)
                                            . #21#)))
                                    (LETT #1#
                                          (PROG1 (CDR #1#)
                                            (LETT #2# (CDR #2#) . #21#))
                                          . #21#)
                                    #23# G191 (EXIT (NREVERSE0 #3#))))
                              . #21#)))
                      (EXIT (CONS |result| |ans|))))))))))
      #4# (EXIT #4#))))) 

(DEFUN |HEUGCD;gcdprim;LBP;15| (|listf| $)
  (|SPADfirst| (|HEUGCD;internal| (CONS 0 "gcdprim") |listf| $))) 

(DEFUN |HEUGCD;gcdcofactprim;2L;16| (|listf| $)
  (|HEUGCD;internal| (CONS 2 "gcdcofactprim") |listf| $)) 

(DEFUN |HEUGCD;gcd;LBP;17| (|listf| $)
  (|SPADfirst| (|HEUGCD;internal| (CONS 1 "gcd") |listf| $))) 

(DEFUN |HEUGCD;gcdcofact;2L;18| (|listf| $)
  (|HEUGCD;internal| (CONS 3 "gcdcofact") |listf| $)) 

(DEFUN |HeuGcd| (#1=#:G2006)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2007)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache| '|HeuGcd|)
                                           '|domainEqualList|)
                . #3=(|HeuGcd|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|HeuGcd;| #1#) (LETT #2# T . #3#))
            (COND ((NOT #2#) (HREM |$ConstructorCache| '|HeuGcd|))))))))))) 

(DEFUN |HeuGcd;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|HeuGcd|))
      (LETT |dv$| (LIST '|HeuGcd| DV$1) . #1#)
      (LETT $ (GETREFV 59) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|HeuGcd| (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 10 (SPADCALL (EXPT 2 26) (QREFELT $ 9)))
      (QSETREFV $ 44
                (|InnerModularGcd| (|Integer|) |#1| 67108859
                                   (CONS (|function| |HEUGCD;myNextPrime|) $)))
      $)))) 

(MAKEPROP '|HeuGcd| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Integer|)
              (|IntegerPrimesPackage| 7) (0 . |prevPrime|) '|bigPrime|
              (5 . |nextPrime|) (|NonNegativeInteger|) (10 . |degree|)
              (|Boolean|) (15 . |zero?|) (20 . |Zero|) (24 . =)
              (30 . |leadingCoefficient|) (35 . |reductum|) (40 . |monomial|)
              (46 . +) (52 . |One|) (|List| 7) (56 . |member?|) (62 . <)
              (|Mapping| 14 7 7) (68 . |sort|) |HEUGCD;lintgcd;LI;6|
              (74 . |coefficients|) (|List| 6) |HEUGCD;content;LL;7|
              (|Union| $ '"failed") (79 . |exquo|) (|Mapping| 14 6)
              (85 . |select|) (|List| 12) (91 . |member?|) (97 . |coerce|)
              (102 . |exquo|) (|PositiveInteger|) (108 . |One|)
              (112 . |position|) (118 . |elt|) 'IMG (124 . |elt|)
              (130 . |content|) (135 . |modularGcdPrimitive|) (140 . =)
              (146 . |minimumDegree|) (151 . *) (157 . *)
              (163 . |positiveRemainder|) (|ModularDistinctDegreeFactorizer| 6)
              (169 . |gcd|) |HEUGCD;gcdprim;LBP;15|
              |HEUGCD;gcdcofactprim;2L;16| |HEUGCD;gcd;LBP;17|
              |HEUGCD;gcdcofact;2L;18|)
           '#(|lintgcd| 176 |gcdprim| 181 |gcdcofactprim| 186 |gcdcofact| 191
              |gcd| 196 |content| 201)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 58
                                                 '(1 8 7 7 9 1 8 7 7 11 1 6 12
                                                   0 13 1 6 14 0 15 0 6 0 16 2
                                                   6 14 0 0 17 1 6 7 0 18 1 6 0
                                                   0 19 2 6 0 7 12 20 2 6 0 0 0
                                                   21 0 6 0 22 2 23 14 7 0 24 2
                                                   7 14 0 0 25 2 23 0 26 0 27 1
                                                   6 23 0 29 2 6 32 0 7 33 2 30
                                                   0 34 0 35 2 36 14 12 0 37 1
                                                   6 0 7 38 2 6 32 0 0 39 0 40
                                                   0 41 2 36 7 12 0 42 2 30 6 0
                                                   7 43 2 6 7 0 7 45 1 6 7 0 46
                                                   1 44 6 30 47 2 30 14 0 0 48
                                                   1 6 12 0 49 2 6 0 0 0 50 2 6
                                                   0 7 0 51 2 7 0 0 0 52 3 53 6
                                                   6 6 7 54 1 0 7 23 28 1 0 6
                                                   30 55 1 0 30 30 56 1 0 30 30
                                                   58 1 0 6 30 57 1 0 23 30
                                                   31)))))
           '|lookupComplete|)) 
