
(/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) ('T 'T)))
    ('T '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 (#0=#:G1841 |k|)
    (RETURN
      (SEQ (LETT |k| 1 . #1=(|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 #0#
                                        (ABS
                                         (SPADCALL |f| (QREFELT $ 18))) . #1#)
                                  (|check-subtype| (> #0# 0)
                                      '(|PositiveInteger|) #0#))) . #1#)
                     (EXIT (LETT |f|
                                 (SPADCALL |f| (QREFELT $ 19)) . #1#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |k|))))) 

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

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

(DEFUN |HEUGCD;lintgcd;LI;6!0| (|#1| |#2| $)
  (SPADCALL |#1| |#2| (QREFELT $ 25))) 

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

(DEFUN |HEUGCD;contprim| (|listf| $)
  (PROG (#0=#:G1870 |f| #1=#:G1871 |c| #2=#:G1866)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #3=(|HEUGCD;contprim|))
             (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 #0#
                                   (CONS
                                    (CONS
                                     (LETT |c|
                                      (SPADCALL
                                       (SPADCALL |f| (QREFELT $ 30))
                                       (QREFELT $ 29)) . #3#)
                                     (PROG2
                                      (LETT #2#
                                       (SPADCALL |f| |c|
                                        (QREFELT $ 34)) . #3#)
                                      (QCDR #2#)
                                       (|check-union| (QEQCAR #2# 0)
                                        (QREFELT $ 6) #2#)))
                                    #0#) . #3#)))
                  (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |HEUGCD;constcase| (|listdeg| |listf| $)
  (PROG (|lind| |n| #0=#:G1883 #1=#:G1876 #2=#:G1874 #3=#:G1875
                #4=#:G1884 |f| #5=#:G1885 |lclistf| |d| #6=#:G1886
                |lcf| #7=#:G1887)
    (RETURN
      (SEQ (LETT |lind|
                 (SPADCALL (CONS (|function| |HEUGCD;constNotZero|) $)
                     |listf| (QREFELT $ 36))
                 . #8=(|HEUGCD;constcase|))
           (EXIT (COND
                   ((NULL |lind|)
                    (COND
                      ((SPADCALL 1 |listdeg| (QREFELT $ 38))
                       (|HEUGCD;lincase| |listdeg| |listf| $))
                      ('T (|HEUGCD;localgcd| |listf| $))))
                   ((PROGN
                      (LETT #3# NIL . #8#)
                      (SEQ (LETT |n| NIL . #8#)
                           (LETT #0# |listdeg| . #8#) G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |n| (CAR #0#) . #8#)
                                    NIL))
                              #9=(GO G191)))
                           (SEQ (EXIT (PROGN
                                        (LETT #1# (< 0 |n|) . #8#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (COND (#2# 'T) ('T #1#)) . #8#))
                                          ('T
                                           (PROGN
                                             (LETT #2# #1# . #8#)
                                             (LETT #3# 'T . #8#)))))))
                           (LETT #0# (CDR #0#) . #8#) #10=(GO G190)
                           G191 (EXIT NIL))
                      (COND (#3# #2#) ('T 'NIL)))
                    (CONS (|spadConstant| $ 22) |listf|))
                   ('T
                    (SEQ (LETT |lclistf|
                               (PROGN
                                 (LETT #4# NIL . #8#)
                                 (SEQ (LETT |f| NIL . #8#)
                                      (LETT #5# |listf| . #8#) G190
                                      (COND
                                        ((OR (ATOM #5#)
                                          (PROGN
                                            (LETT |f| (CAR #5#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (LETT #4#
                                         (CONS
                                          (SPADCALL |f| (QREFELT $ 18))
                                          #4#) . #8#)))
                                      (LETT #5# (CDR #5#) . #8#) #10#
                                      G191 (EXIT (NREVERSE0 #4#)))) . #8#)
                         (LETT |d|
                               (SPADCALL |lclistf| (QREFELT $ 29)) . #8#)
                         (EXIT (COND
                                 ((EQL |d| 1)
                                  (CONS (|spadConstant| $ 22) |listf|))
                                 ('T
                                  (CONS (SPADCALL |d| (QREFELT $ 39))
                                        (PROGN
                                          (LETT #6# NIL . #8#)
                                          (SEQ (LETT |lcf| NIL . #8#)
                                           (LETT #7# |lclistf| . #8#)
                                           G190
                                           (COND
                                             ((OR (ATOM #7#)
                                               (PROGN
                                                 (LETT |lcf|
                                                  (CAR #7#) . #8#)
                                                 NIL))
                                              #9#))
                                           (SEQ
                                            (EXIT
                                             (LETT #6#
                                              (CONS
                                               (SPADCALL
                                                (QUOTIENT2 |lcf| |d|)
                                                (QREFELT $ 39))
                                               #6#) . #8#)))
                                           (LETT #7# (CDR #7#) . #8#)
                                           #10# G191
                                           (EXIT (NREVERSE0 #6#)))))))))))))))) 

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

(DEFUN |HEUGCD;lincase| (|listdeg| |listf| $)
  (PROG (|n| |g| |f| #0=#:G1908 |f1| #1=#:G1907 |result|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL 1 |listdeg| (QREFELT $ 43))
                            . #2=(|HEUGCD;lincase|))
                      (LETT |g|
                            (SPADCALL |listf| |n| (QREFELT $ 44)) . #2#)
                      (LETT |result| (LIST |g|) . #2#)
                      (SEQ (LETT |f| NIL . #2#)
                           (LETT #0# |listf| . #2#) G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |f| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (SEQ (LETT |f1|
                                      (SPADCALL |f| |g| (QREFELT $ 40)) . #2#)
                                     (EXIT
                                      (COND
                                        ((QEQCAR |f1| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS (|spadConstant| $ 22)
                                             |listf|) . #2#)
                                           (GO #1#))))))
                                (EXIT (LETT |result|
                                       (CONS (QCDR |f1|) |result|) . #2#)))
                           (LETT #0# (CDR #0#) . #2#) (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 (#0=#:G1934 #1=#:G1914 #2=#:G1912 #3=#:G1913 |hgt| #4=#:G1935
            #5=#:G1918 #6=#:G1916 #7=#:G1917 |minf| #8=#:G1889 |k|
            #9=#:G1936 #10=#:G1937 |listval| |dval| |dd| |contd| |d|
            #11=#:G1938 |f1| |flag| |result| #12=#:G1933 |nvalue|
            #13=#:G1926 |answr| |gg| #14=#:G1939 |f| #15=#:G1940
            #16=#:G1921)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |hgt|
                            (PROGN
                              (LETT #3# NIL . #17=(|HEUGCD;localgcd|))
                              (SEQ (LETT |f| NIL . #17#)
                                   (LETT #0# |listf| . #17#) G190
                                   (COND
                                     ((OR (ATOM #0#)
                                       (PROGN
                                         (LETT |f| (CAR #0#) . #17#)
                                         NIL))
                                      #18=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (COND
                                       ((COND
                                          ((SPADCALL |f|
                                            (QREFELT $ 15))
                                           'NIL)
                                          ('T 'T))
                                        (PROGN
                                          (LETT #1#
                                           (|HEUGCD;height| |f| $) . #17#)
                                          (COND
                                            (#3#
                                             (LETT #2#
                                              (MIN #2# #1#) . #17#))
                                            ('T
                                             (PROGN
                                               (LETT #2# #1# . #17#)
                                               (LETT #3# 'T . #17#)))))))))
                                   (LETT #0# (CDR #0#) . #17#)
                                   #19=(GO G190) G191 (EXIT NIL))
                              (COND
                                (#3# #2#)
                                (#20='T (|IdentityError| '|min|)))) . #17#)
                      (LETT |answr| (+ 2 (* 2 |hgt|)) . #17#)
                      (LETT |minf|
                            (PROGN
                              (LETT #7# NIL . #17#)
                              (SEQ (LETT |f| NIL . #17#)
                                   (LETT #4# |listf| . #17#) G190
                                   (COND
                                     ((OR (ATOM #4#)
                                       (PROGN
                                         (LETT |f| (CAR #4#) . #17#)
                                         NIL))
                                      #18#))
                                   (SEQ
                                    (EXIT
                                     (COND
                                       ((COND
                                          ((SPADCALL |f|
                                            (QREFELT $ 15))
                                           'NIL)
                                          ('T 'T))
                                        (PROGN
                                          (LETT #5# |f| . #17#)
                                          (COND
                                            (#7#
                                             (LETT #6#
                                              (|HEUGCD;mindegpol| #6#
                                               #5# $) . #17#))
                                            ('T
                                             (PROGN
                                               (LETT #6# #5# . #17#)
                                               (LETT #7# 'T . #17#)))))))))
                                   (LETT #4# (CDR #4#) . #17#) #19#
                                   G191 (EXIT NIL))
                              (COND
                                (#7# #6#)
                                (#20# (|IdentityError| '|mindegpol|)))) . #17#)
                      (EXIT (COND
                              ((QEQCAR (LETT |result|
                                        (|HEUGCD;testDivide| |listf|
                                         |minf| $) . #17#)
                                       0)
                               (CONS |minf|
                                     (PROG2 (LETT #8# |result| . #17#)
                                      (QCDR #8#)
                                       (|check-union| (QEQCAR #8# 0)
                                        (|List| (QREFELT $ 6)) #8#))))
                              ('T
                               (SEQ (COND
                                      ((<
                                        (SPADCALL |minf|
                                         (QREFELT $ 13))
                                        100)
                                       (SEQ (LETT |k| 1 . #17#) G190
                                        (COND
                                          ((QSGREATERP |k| 10) #18#))
                                        (SEQ
                                         (LETT |listval|
                                          (PROGN
                                            (LETT #9# NIL . #17#)
                                            (SEQ (LETT |f| NIL . #17#)
                                             (LETT #10# |listf| . #17#)
                                             G190
                                             (COND
                                               ((OR (ATOM #10#)
                                                 (PROGN
                                                   (LETT |f|
                                                    (CAR #10#) . #17#)
                                                   NIL))
                                                #18#))
                                             (SEQ
                                              (EXIT
                                               (LETT #9#
                                                (CONS
                                                 (SPADCALL |f| |answr|
                                                  (QREFELT $ 46))
                                                 #9#) . #17#)))
                                             (LETT #10#
                                              (CDR #10#) . #17#)
                                             #19# G191
                                             (EXIT (NREVERSE0 #9#)))) . #17#)
                                         (LETT |dval|
                                          (SPADCALL |listval|
                                           (QREFELT $ 29)) . #17#)
                                         (LETT |dd|
                                          (|HEUGCD;genpoly| |dval|
                                           |answr| $) . #17#)
                                         (LETT |contd|
                                          (SPADCALL |dd|
                                           (QREFELT $ 47)) . #17#)
                                         (LETT |d|
                                          (PROG2
                                           (LETT #16#
                                            (SPADCALL |dd| |contd|
                                             (QREFELT $ 34)) . #17#)
                                           (QCDR #16#)
                                            (|check-union|
                                             (QEQCAR #16# 0)
                                             (QREFELT $ 6) #16#)) . #17#)
                                         (LETT |result|
                                          (LIST |d|) . #17#)
                                         (LETT |flag| 'T . #17#)
                                         (SEQ (LETT |f| NIL . #17#)
                                          (LETT #11# |listf| . #17#)
                                          G190
                                          (COND
                                            ((OR (ATOM #11#)
                                              (PROGN
                                                (LETT |f|
                                                 (CAR #11#) . #17#)
                                                NIL)
                                              (NULL |flag|))
                                             #18#))
                                          (SEQ
                                           (LETT |f1|
                                            (SPADCALL |f| |d|
                                             (QREFELT $ 40)) . #17#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |f1| 1)
                                               (LETT |flag|
                                                'NIL . #17#))
                                              ('T
                                               (LETT |result|
                                                (CONS (QCDR |f1|)
                                                 |result|) . #17#)))))
                                          (LETT #11# (CDR #11#) . #17#)
                                          #19# G191 (EXIT NIL))
                                         (COND
                                           (|flag|
                                            (PROGN
                                              (LETT #12#
                                               (REVERSE |result|) . #17#)
                                              (GO #12#))))
                                         (LETT |nvalue|
                                          (QUOTIENT2 (* |answr| 832040)
                                           317811) . #17#)
                                         (COND
                                           ((EQL
                                             (REMAINDER2
                                              (+ |nvalue| |answr|) 2)
                                             0)
                                            (LETT |nvalue|
                                             (+ |nvalue| 1) . #17#)))
                                         (EXIT
                                          (LETT |answr|
                                           (PROG1
                                            (LETT #13# |nvalue| . #17#)
                                             (|check-subtype|
                                              (> #13# 0)
                                              '(|PositiveInteger|)
                                              #13#)) . #17#)))
                                        (LETT |k| (QSADD1 |k|) . #17#)
                                        #19# G191 (EXIT NIL))))
                                    (LETT |gg|
                                     (SPADCALL |listf| (QREFELT $ 48)) . #17#)
                                    (EXIT
                                     (CONS |gg|
                                      (PROGN
                                        (LETT #14# NIL . #17#)
                                        (SEQ (LETT |f| NIL . #17#)
                                         (LETT #15# |listf| . #17#)
                                         G190
                                         (COND
                                           ((OR (ATOM #15#)
                                             (PROGN
                                               (LETT |f|
                                                (CAR #15#) . #17#)
                                               NIL))
                                            #18#))
                                         (SEQ
                                          (EXIT
                                           (LETT #14#
                                            (CONS
                                             (PROG2
                                              (LETT #16#
                                               (SPADCALL |f| |gg|
                                                (QREFELT $ 40)) . #17#)
                                              (QCDR #16#)
                                               (|check-union|
                                                (QEQCAR #16# 0)
                                                (QREFELT $ 6) #16#))
                                             #14#) . #17#)))
                                         (LETT #15# (CDR #15#) . #17#)
                                         #19# G191
                                         (EXIT (NREVERSE0 #14#))))))))))))
           #12# (EXIT #12#))))) 

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

(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| (#0=#:G2008)
  (PROG ()
    (RETURN
      (PROG (#1=#:G2009)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache| '|HeuGcd|)
                       '|domainEqualList|)
                   . #2=(|HeuGcd|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|HeuGcd;| #0#) (LETT #1# T . #2#))
               (COND ((NOT #1#) (HREM |$ConstructorCache| '|HeuGcd|))))))))))) 

(DEFUN |HeuGcd;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|HeuGcd|))
        (LETT |dv$| (LIST '|HeuGcd| DV$1) . #0#)
        (LETT $ (GETREFV 60) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|HeuGcd| (LIST DV$1)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 10 (SPADCALL (EXPT 2 26) (QREFELT $ 9)))
        (QSETREFV $ 45
            (|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|)
             (74 . ~=) |HEUGCD;lintgcd;LI;6| (80 . |coefficients|)
             (|List| 6) |HEUGCD;content;LL;7| (|Union| $ '"failed")
             (85 . |exquo|) (|Mapping| 14 6) (91 . |select|)
             (|List| 12) (97 . |member?|) (103 . |coerce|)
             (108 . |exquo|) (|PositiveInteger|) (114 . |One|)
             (118 . |position|) (124 . |elt|) 'IMG (130 . |elt|)
             (136 . |content|) (141 . |modularGcdPrimitive|) (146 . =)
             (152 . |minimumDegree|) (157 . *) (163 . *)
             (169 . |positiveRemainder|)
             (|ModularDistinctDegreeFactorizer| 6) (175 . |gcd|)
             |HEUGCD;gcdprim;LBP;15| |HEUGCD;gcdcofactprim;2L;16|
             |HEUGCD;gcd;LBP;17| |HEUGCD;gcdcofact;2L;18|)
          '#(|lintgcd| 182 |gcdprim| 187 |gcdcofactprim| 192
             |gcdcofact| 197 |gcd| 202 |content| 207)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 59
                                '(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 2 7 14 0 0 28 1 6
                                  23 0 30 2 6 33 0 7 34 2 31 0 35 0 36
                                  2 37 14 12 0 38 1 6 0 7 39 2 6 33 0 0
                                  40 0 41 0 42 2 37 7 12 0 43 2 31 6 0
                                  7 44 2 6 7 0 7 46 1 6 7 0 47 1 45 6
                                  31 48 2 31 14 0 0 49 1 6 12 0 50 2 6
                                  0 0 0 51 2 6 0 7 0 52 2 7 0 0 0 53 3
                                  54 6 6 6 7 55 1 0 7 23 29 1 0 6 31 56
                                  1 0 31 31 57 1 0 31 31 59 1 0 6 31 58
                                  1 0 23 31 32)))))
          '|lookupComplete|)) 
