
(/VERSIONCHECK 2) 

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

(DEFUN |HEUGCD;constNotZero| (|f| $)
  (COND
   ((EQL (SPADCALL |f| (QREFELT $ 12)) 0)
    (COND ((SPADCALL |f| (QREFELT $ 14)) '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=#:G1816)
    (RETURN
     (SEQ (LETT |k| 1 . #2=(|HEUGCD;height|))
          (SEQ G190
               (COND
                ((NULL
                  (COND
                   ((SPADCALL |f| (|spadConstant| $ 15) (QREFELT $ 16)) 'NIL)
                   ('T 'T)))
                 (GO G191)))
               (SEQ
                (LETT |k|
                      (MAX |k|
                           (PROG1
                               (LETT #1# (ABS (SPADCALL |f| (QREFELT $ 17)))
                                     . #2#)
                             (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                                              #1#)))
                      . #2#)
                (EXIT (LETT |f| (SPADCALL |f| (QREFELT $ 18)) . #2#)))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT |k|))))) 

(DEFUN |HEUGCD;genpoly| (|dval| |value| $)
  (PROG (|val| |d| |val1| |i|)
    (RETURN
     (SEQ (LETT |d| (|spadConstant| $ 15) . #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 $ 19))
                                (QREFELT $ 20))
                      . #1#)
                (EXIT (LETT |val| (QUOTIENT2 (- |val| |val1|) |value|) . #1#)))
               (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |d|))))) 

(DEFUN |HEUGCD;smallest_to_front| (|l| $)
  (PROG (|ress| |smallest| #1=#:G1838 |p|)
    (RETURN
     (SEQ (LETT |ress| NIL . #2=(|HEUGCD;smallest_to_front|))
          (LETT |smallest| (|SPADfirst| |l|) . #2#)
          (SEQ (LETT |p| NIL . #2#) (LETT #1# (CDR |l|) . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (COND
                  ((< |p| |smallest|)
                   (SEQ (LETT |ress| (CONS |smallest| |ress|) . #2#)
                        (EXIT (LETT |smallest| |p| . #2#))))
                  ('T (LETT |ress| (CONS |p| |ress|) . #2#)))))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT (CONS |smallest| |ress|)))))) 

(DEFUN |HEUGCD;lintgcd;LI;7| (|lval| $)
  (PROG (|val| #1=#:G1844 |val1|)
    (RETURN
     (SEQ
      (COND ((NULL |lval|) 0) ((SPADCALL 1 |lval| (QREFELT $ 23)) 1)
            ('T
             (SEQ
              (LETT |lval| (|HEUGCD;smallest_to_front| |lval| $)
                    . #2=(|HEUGCD;lintgcd;LI;7|))
              (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;8| (|listf| $)
  (PROG (#1=#:G1848 |f| #2=#:G1847)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|HEUGCD;content;LL;8|))
       (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 $ 25)) (QREFELT $ 24))
                     #2#)
                    . #3#)))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |HEUGCD;contprim| (|listf| $)
  (PROG (#1=#:G1854 |c| #2=#:G1859 |f| #3=#:G1858)
    (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 $ 25))
                                      (QREFELT $ 24))
                            . #4#)
                      (PROG2
                          (LETT #1# (SPADCALL |f| |c| (QREFELT $ 29)) . #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=#:G1876 |lcf| #2=#:G1875 |d| |lclistf| #3=#:G1874 |f| #4=#:G1873
         #5=#:G1864 #6=#:G1863 #7=#:G1865 #8=#:G1872 |n| |lind|)
    (RETURN
     (SEQ
      (LETT |lind|
            (SPADCALL (CONS (|function| |HEUGCD;constNotZero|) $) |listf|
                      (QREFELT $ 31))
            . #9=(|HEUGCD;constcase|))
      (EXIT
       (COND
        ((NULL |lind|)
         (COND
          ((SPADCALL 1 |listdeg| (QREFELT $ 33))
           (|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| $ 21) |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 $ 17)) #4#)
                              . #9#)))
                      (LETT #3# (CDR #3#) . #9#) #12# G191
                      (EXIT (NREVERSE0 #4#))))
                . #9#)
          (LETT |d| (SPADCALL |lclistf| (QREFELT $ 24)) . #9#)
          (EXIT
           (COND ((EQL |d| 1) (CONS (|spadConstant| $ 21) |listf|))
                 (#10#
                  (CONS (SPADCALL |d| (QREFELT $ 34))
                        (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 $ 34))
                                       #2#)
                                      . #9#)))
                              (LETT #1# (CDR #1#) . #9#) #12# G191
                              (EXIT (NREVERSE0 #2#)))))))))))))))) 

(DEFUN |HEUGCD;testDivide| (|listf| |g| $)
  (PROG (|result| #1=#:G1887 |f1| #2=#:G1888 |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 $ 35)) . #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=#:G1908 |f1| #2=#:G1909 |f| |g| |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |n| (SPADCALL 1 |listdeg| (QREFELT $ 38))
              . #3=(|HEUGCD;lincase|))
        (LETT |g| (SPADCALL |listf| |n| (QREFELT $ 39)) . #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 $ 35)) . #3#)
                   (EXIT
                    (COND
                     ((QEQCAR |f1| 1)
                      (PROGN
                       (LETT #1# (CONS (|spadConstant| $ 21) |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 $ 12)) (SPADCALL |f| (QREFELT $ 12))) |g|)
        ('T |f|))) 

(DEFUN |HEUGCD;localgcd| (|listf| $)
  (PROG (#1=#:G1924 #2=#:G1945 |f| #3=#:G1944 |gg| |answr| #4=#:G1932 |nvalue|
         #5=#:G1938 |result| |flag| |f1| #6=#:G1943 |d| |contd| |dd| |dval|
         |listval| #7=#:G1942 #8=#:G1941 |k| |minf| #9=#:G1920 #10=#:G1919
         #11=#:G1921 #12=#:G1940 |hgt| #13=#:G1916 #14=#:G1915 #15=#:G1917
         #16=#:G1939)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |hgt|
              (PROGN
               (LETT #13# NIL . #17=(|HEUGCD;localgcd|))
               (SEQ (LETT |f| NIL . #17#) (LETT #16# |listf| . #17#) G190
                    (COND
                     ((OR (ATOM #16#) (PROGN (LETT |f| (CAR #16#) . #17#) NIL))
                      #18=(GO G191)))
                    (SEQ
                     (EXIT
                      (COND
                       ((COND ((SPADCALL |f| (QREFELT $ 14)) 'NIL) (#19='T 'T))
                        (PROGN
                         (LETT #15# (|HEUGCD;height| |f| $) . #17#)
                         (COND (#13# (LETT #14# (MIN #14# #15#) . #17#))
                               ('T
                                (PROGN
                                 (LETT #14# #15# . #17#)
                                 (LETT #13# 'T . #17#)))))))))
                    (LETT #16# (CDR #16#) . #17#) #20=(GO G190) G191
                    (EXIT NIL))
               (COND (#13# #14#) (#19# (|IdentityError| '|min|))))
              . #17#)
        (LETT |answr| (+ 2 (* 2 |hgt|)) . #17#)
        (LETT |minf|
              (PROGN
               (LETT #9# NIL . #17#)
               (SEQ (LETT |f| NIL . #17#) (LETT #12# |listf| . #17#) G190
                    (COND
                     ((OR (ATOM #12#) (PROGN (LETT |f| (CAR #12#) . #17#) NIL))
                      #18#))
                    (SEQ
                     (EXIT
                      (COND
                       ((COND ((SPADCALL |f| (QREFELT $ 14)) 'NIL) (#19# 'T))
                        (PROGN
                         (LETT #11# |f| . #17#)
                         (COND
                          (#9#
                           (LETT #10# (|HEUGCD;mindegpol| #10# #11# $) . #17#))
                          ('T
                           (PROGN
                            (LETT #10# #11# . #17#)
                            (LETT #9# 'T . #17#)))))))))
                    (LETT #12# (CDR #12#) . #17#) #20# G191 (EXIT NIL))
               (COND (#9# #10#) (#19# (|IdentityError| '|mindegpol|))))
              . #17#)
        (LETT |result| (|HEUGCD;testDivide| |listf| |minf| $) . #17#)
        (EXIT
         (COND ((QEQCAR |result| 0) (CONS |minf| (QCDR |result|)))
               (#19#
                (SEQ
                 (SEQ (LETT |k| 1 . #17#) G190
                      (COND ((QSGREATERP |k| 10) #18#))
                      (SEQ
                       (LETT |listval|
                             (PROGN
                              (LETT #8# NIL . #17#)
                              (SEQ (LETT |f| NIL . #17#)
                                   (LETT #7# |listf| . #17#) G190
                                   (COND
                                    ((OR (ATOM #7#)
                                         (PROGN
                                          (LETT |f| (CAR #7#) . #17#)
                                          NIL))
                                     #18#))
                                   (SEQ
                                    (EXIT
                                     (LETT #8#
                                           (CONS
                                            (SPADCALL |f| |answr|
                                                      (QREFELT $ 41))
                                            #8#)
                                           . #17#)))
                                   (LETT #7# (CDR #7#) . #17#) #20# G191
                                   (EXIT (NREVERSE0 #8#))))
                             . #17#)
                       (LETT |dval| (SPADCALL |listval| (QREFELT $ 24)) . #17#)
                       (LETT |dd| (|HEUGCD;genpoly| |dval| |answr| $) . #17#)
                       (LETT |contd| (SPADCALL |dd| (QREFELT $ 42)) . #17#)
                       (LETT |d|
                             (PROG2
                                 (LETT #1#
                                       (SPADCALL |dd| |contd| (QREFELT $ 29))
                                       . #17#)
                                 (QCDR #1#)
                               (|check-union| (QEQCAR #1# 0) (QREFELT $ 6)
                                              #1#))
                             . #17#)
                       (LETT |result| (LIST |d|) . #17#)
                       (LETT |flag| 'T . #17#)
                       (SEQ (LETT |f| NIL . #17#) (LETT #6# |listf| . #17#)
                            G190
                            (COND
                             ((OR (ATOM #6#)
                                  (PROGN (LETT |f| (CAR #6#) . #17#) NIL)
                                  (NULL |flag|))
                              #18#))
                            (SEQ
                             (LETT |f1| (SPADCALL |f| |d| (QREFELT $ 35))
                                   . #17#)
                             (EXIT
                              (COND ((QEQCAR |f1| 1) (LETT |flag| 'NIL . #17#))
                                    ('T
                                     (LETT |result| (CONS (QCDR |f1|) |result|)
                                           . #17#)))))
                            (LETT #6# (CDR #6#) . #17#) #20# G191 (EXIT NIL))
                       (COND
                        (|flag|
                         (PROGN
                          (LETT #5# (REVERSE |result|) . #17#)
                          (GO #5#))))
                       (LETT |nvalue| (QUOTIENT2 (* |answr| 832040) 317811)
                             . #17#)
                       (COND
                        ((EQL (REMAINDER2 (+ |nvalue| |answr|) 2) 0)
                         (LETT |nvalue| (+ |nvalue| 1) . #17#)))
                       (EXIT
                        (LETT |answr|
                              (PROG1 (LETT #4# |nvalue| . #17#)
                                (|check-subtype| (> #4# 0) '(|PositiveInteger|)
                                                 #4#))
                              . #17#)))
                      (LETT |k| (QSADD1 |k|) . #17#) #20# G191 (EXIT NIL))
                 (LETT |gg| (SPADCALL |listf| (QREFELT $ 43)) . #17#)
                 (EXIT
                  (CONS |gg|
                        (PROGN
                         (LETT #3# NIL . #17#)
                         (SEQ (LETT |f| NIL . #17#) (LETT #2# |listf| . #17#)
                              G190
                              (COND
                               ((OR (ATOM #2#)
                                    (PROGN (LETT |f| (CAR #2#) . #17#) NIL))
                                #18#))
                              (SEQ
                               (EXIT
                                (LETT #3#
                                      (CONS
                                       (PROG2
                                           (LETT #1#
                                                 (SPADCALL |f| |gg|
                                                           (QREFELT $ 35))
                                                 . #17#)
                                           (QCDR #1#)
                                         (|check-union| (QEQCAR #1# 0)
                                                        (QREFELT $ 6) #1#))
                                       #3#)
                                      . #17#)))
                              (LETT #2# (CDR #2#) . #17#) #20# G191
                              (EXIT (NREVERSE0 #3#))))))))))))
      #5# (EXIT #5#))))) 

(DEFUN |HEUGCD;internal| (|flag| |listf| $)
  (PROG (|ans| #1=#:G1988 |p| #2=#:G1989 |q| #3=#:G1987 |result| |#G53| |#G52|
         #4=#:G1976 |fa| |ga| #5=#:G1968 |lcg| #6=#:G1986 |g| |f| |listdeg|
         #7=#:G1985 #8=#:G1984 |minpol| #9=#:G1983 |term| #10=#:G1982 |contgcd|
         |Cgcd| #11=#:G1981 #12=#:G1980 |contlistf| #13=#:G1955 #14=#:G1979
         #15=#:G1978 |minpol1| |mdeg| #16=#:G1952 #17=#:G1951 #18=#:G1953
         #19=#:G1977 |nlf|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((SPADCALL |listf| NIL (QREFELT $ 44)) (LIST (|spadConstant| $ 21)))
        (#20='T
         (SEQ (LETT |nlf| (LENGTH |listf|) . #21=(|HEUGCD;internal|))
              (EXIT
               (COND
                ((EQL |nlf| 1)
                 (LIST (|SPADfirst| |listf|) (|spadConstant| $ 21)))
                (#20#
                 (SEQ (LETT |minpol| (|spadConstant| $ 21) . #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 $ 45))
                                           . #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 $ 19))
                               . #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 $
                                                                           35))
                                                        . #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 $ 46))
                                . #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 $ 24))
                               . #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 $ 47))
                                . #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 $ 12))
                                                #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 $ 17)) (QREFELT $ 7)
                                    (QREFELT $ 48))
                          0))
                        (SEQ
                         (LETT |fa|
                               (SPADCALL (SPADCALL |f| (QREFELT $ 50))
                                         (QREFELT $ 7) (QREFELT $ 53))
                               . #21#)
                         (EXIT
                          (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 $ 17))
                                        . #21#)
                                  (COND
                                   ((EQL
                                     (SPADCALL |lcg| (QREFELT $ 7)
                                               (QREFELT $ 48))
                                     0)
                                    (PROGN
                                     (LETT #5# |$NoValue| . #21#)
                                     (GO #5#))))
                                  (LETT |ga|
                                        (SPADCALL (SPADCALL |g| (QREFELT $ 50))
                                                  (QREFELT $ 7) (QREFELT $ 53))
                                        . #21#)
                                  (LETT |fa|
                                        (SPADCALL |fa| |ga| (QREFELT $ 7)
                                                  (QREFELT $ 54))
                                        . #21#)
                                  (EXIT
                                   (COND
                                    ((EQL (SPADCALL |fa| (QREFELT $ 55)) 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 $ 33))
                              (|HEUGCD;constcase| |listdeg| |listf| $))
                             ((SPADCALL 1 |listdeg| (QREFELT $ 33))
                              (|HEUGCD;lincase| |listdeg| |listf| $))
                             (#20# (|HEUGCD;localgcd| |listf| $)))
                            . #21#)
                      (PROGN
                       (LETT |#G52|
                             (SPADCALL (|SPADfirst| |ans|) |minpol|
                                       (QREFELT $ 46))
                             . #21#)
                       (LETT |#G53| (CDR |ans|) . #21#)
                       (LETT |result| |#G52| . #21#)
                       (LETT |ans| |#G53| . #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 $ 47))
                                             #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;16| (|listf| $)
  (|SPADfirst| (|HEUGCD;internal| (CONS 0 "gcdprim") |listf| $))) 

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

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

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

(DEFUN |HeuGcd| (#1=#:G2014)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2015)
       (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 62) . #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|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 7 4010021)
      (QSETREFV $ 40
                (|InnerModularGcd| (|Integer|) |#1| 67108859
                                   (CONS (|function| |HEUGCD;myNextPrime|) $)))
      $)))) 

(MAKEPROP '|HeuGcd| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|bigPrime| (|Integer|)
              (|IntegerPrimesPackage| 8) (0 . |nextPrime|)
              (|NonNegativeInteger|) (5 . |degree|) (|Boolean|) (10 . |zero?|)
              (15 . |Zero|) (19 . =) (25 . |leadingCoefficient|)
              (30 . |reductum|) (35 . |monomial|) (41 . +) (47 . |One|)
              (|List| 8) (51 . |member?|) |HEUGCD;lintgcd;LI;7|
              (57 . |coefficients|) (|List| 6) |HEUGCD;content;LL;8|
              (|Union| $ '"failed") (62 . |exquo|) (|Mapping| 13 6)
              (68 . |select|) (|List| 11) (74 . |member?|) (80 . |coerce|)
              (85 . |exquo|) (|PositiveInteger|) (91 . |One|) (95 . |position|)
              (101 . |elt|) 'IMG (107 . |elt|) (113 . |content|)
              (118 . |modularGcdPrimitive|) (123 . =) (129 . |minimumDegree|)
              (134 . *) (140 . *) (146 . |positiveRemainder|)
              (|SparseUnivariatePolynomial| 8) (152 . |makeSUP|) (|U32Vector|)
              (|U32VectorPolynomialOperations|) (157 . |to_mod_pa|)
              (163 . |gcd|) (170 . |degree|) (175 . |Zero|) (179 . |One|)
              |HEUGCD;gcdprim;LBP;16| |HEUGCD;gcdcofactprim;2L;17|
              |HEUGCD;gcd;LBP;18| |HEUGCD;gcdcofact;2L;19|)
           '#(|lintgcd| 183 |gcdprim| 188 |gcdcofactprim| 193 |gcdcofact| 198
              |gcd| 203 |content| 208)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 61
                                                 '(1 9 8 8 10 1 6 11 0 12 1 6
                                                   13 0 14 0 6 0 15 2 6 13 0 0
                                                   16 1 6 8 0 17 1 6 0 0 18 2 6
                                                   0 8 11 19 2 6 0 0 0 20 0 6 0
                                                   21 2 22 13 8 0 23 1 6 22 0
                                                   25 2 6 28 0 8 29 2 26 0 30 0
                                                   31 2 32 13 11 0 33 1 6 0 8
                                                   34 2 6 28 0 0 35 0 36 0 37 2
                                                   32 8 11 0 38 2 26 6 0 8 39 2
                                                   6 8 0 8 41 1 6 8 0 42 1 40 6
                                                   26 43 2 26 13 0 0 44 1 6 11
                                                   0 45 2 6 0 0 0 46 2 6 0 8 0
                                                   47 2 8 0 0 0 48 1 6 49 0 50
                                                   2 52 51 49 8 53 3 52 51 51
                                                   51 8 54 1 52 8 51 55 0 49 0
                                                   56 0 49 0 57 1 0 8 22 24 1 0
                                                   6 26 58 1 0 26 26 59 1 0 26
                                                   26 61 1 0 6 26 60 1 0 22 26
                                                   27)))))
           '|lookupComplete|)) 
