
(/VERSIONCHECK 2) 

(DEFUN |PRS;*;R2V;1| (|r| |v| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 13)) |v| (QREFELT $ 15))) 

(DEFUN |PRS;exquo;VRV;2| (|v| |r| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|PRS;exquo;VRV;2!0| (VECTOR (QREFELT $ 7) $ |r|)) |v|
               (QREFELT $ 20))))) 

(DEFUN |PRS;exquo;VRV;2!0| (|p1| $$)
  (PROG (|r| $ |polR|)
    (LETT |r| (QREFELT $$ 2) . #1=(|PRS;exquo;VRV;2|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |polR| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (#2=#:G841)
        (RETURN
         (PROG2
             (LETT #2# (SPADCALL |p1| |r| (QREFELT $ 18)) NIL)
             (QCDR #2#)
           (|check-union| (QEQCAR #2# 0) |polR| #2#)))))))) 

(DEFUN |PRS;pseudoDivide;2polRR;3| (P Q $)
  (PROG (#1=#:G857 |quot| |mon| #2=#:G849 |i| #3=#:G848 |delta| |#G1| |co|
         #4=#:G846 |degQ| |degP| |#G11| |#G10| |lcQ|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((SPADCALL Q (QREFELT $ 23))
         (|error| "PseudoDivide$PRS : division by 0"))
        ((SPADCALL P (QREFELT $ 23))
         (VECTOR (|spadConstant| $ 8) (|spadConstant| $ 24) P))
        (#5='T
         (SEQ
          (LETT |lcQ| (SPADCALL Q (QREFELT $ 25))
                . #6=(|PRS;pseudoDivide;2polRR;3|))
          (PROGN
           (LETT |#G10| (SPADCALL P (QREFELT $ 26)) . #6#)
           (LETT |#G11| (SPADCALL Q (QREFELT $ 26)) . #6#)
           (LETT |degP| |#G10| . #6#)
           (LETT |degQ| |#G11| . #6#))
          (EXIT
           (COND
            ((< |degP| |degQ|)
             (VECTOR (|spadConstant| $ 8) (|spadConstant| $ 24) P))
            (#5#
             (SEQ (LETT Q (SPADCALL Q (QREFELT $ 27)) . #6#)
                  (LETT |i|
                        (PROG1 (LETT #4# (+ (- |degP| |degQ|) 1) . #6#)
                          (|check-subtype| (>= #4# 0) '(|NonNegativeInteger|)
                                           #4#))
                        . #6#)
                  (LETT |co| (SPADCALL |lcQ| |i| (QREFELT $ 28)) . #6#)
                  (LETT |quot| (|spadConstant| $ 24) . #6#)
                  (SEQ G190
                       (COND
                        ((NULL
                          (SEQ
                           (LETT |#G1| (- (SPADCALL P (QREFELT $ 26)) |degQ|)
                                 . #6#)
                           (LETT |delta| |#G1| . #6#)
                           (EXIT (COND ((< |#G1| 0) 'NIL) ('T 'T)))))
                         (GO G191)))
                       (SEQ
                        (LETT |i|
                              (PROG1 (LETT #3# (- |i| 1) . #6#)
                                (|check-subtype| (>= #3# 0)
                                                 '(|NonNegativeInteger|) #3#))
                              . #6#)
                        (LETT |mon|
                              (SPADCALL (SPADCALL P (QREFELT $ 25))
                                        (PROG1 (LETT #2# |delta| . #6#)
                                          (|check-subtype| (>= #2# 0)
                                                           '(|NonNegativeInteger|)
                                                           #2#))
                                        (QREFELT $ 11))
                              . #6#)
                        (LETT |quot|
                              (SPADCALL |quot|
                                        (SPADCALL
                                         (SPADCALL |lcQ| |i| (QREFELT $ 28))
                                         |mon| (QREFELT $ 30))
                                        (QREFELT $ 31))
                              . #6#)
                        (EXIT
                         (LETT P
                               (SPADCALL
                                (SPADCALL |lcQ| (SPADCALL P (QREFELT $ 27))
                                          (QREFELT $ 30))
                                (SPADCALL |mon| Q (QREFELT $ 32))
                                (QREFELT $ 33))
                               . #6#)))
                       NIL (GO G190) G191 (EXIT NIL))
                  (LETT P
                        (SPADCALL (SPADCALL |lcQ| |i| (QREFELT $ 28)) P
                                  (QREFELT $ 30))
                        . #6#)
                  (EXIT
                   (PROGN
                    (LETT #1# (VECTOR |co| |quot| P) . #6#)
                    (GO #1#)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;divide;2polRR;4| (F G $)
  (PROG (#1=#:G873 |quot| |mon| #2=#:G867 #3=#:G865 |delta| #4=#:G860 |degG|
         |lcG|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |lcG| (SPADCALL G (QREFELT $ 25)) . #5=(|PRS;divide;2polRR;4|))
        (LETT |degG| (SPADCALL G (QREFELT $ 26)) . #5#)
        (EXIT
         (COND
          ((ZEROP |degG|)
           (SEQ
            (LETT F
                  (PROG2
                      (LETT #4# (SPADCALL F |lcG| (QREFELT $ 18)) . #5#)
                      (QCDR #4#)
                    (|check-union| (QEQCAR #4# 0) (QREFELT $ 7) #4#))
                  . #5#)
            (EXIT
             (PROGN
              (LETT #1# (CONS F (|spadConstant| $ 24)) . #5#)
              (GO #1#)))))
          ('T
           (SEQ (LETT G (SPADCALL G (QREFELT $ 27)) . #5#)
                (LETT |quot| (|spadConstant| $ 24) . #5#)
                (SEQ G190
                     (COND
                      ((NULL
                        (SEQ
                         (LETT |delta| (- (SPADCALL F (QREFELT $ 26)) |degG|)
                               . #5#)
                         (EXIT (COND ((< |delta| 0) 'NIL) ('T 'T)))))
                       (GO G191)))
                     (SEQ
                      (LETT |mon|
                            (SPADCALL
                             (PROG2
                                 (LETT #3#
                                       (SPADCALL (SPADCALL F (QREFELT $ 25))
                                                 |lcG| (QREFELT $ 36))
                                       . #5#)
                                 (QCDR #3#)
                               (|check-union| (QEQCAR #3# 0) (QREFELT $ 6)
                                              #3#))
                             (PROG1 (LETT #2# |delta| . #5#)
                               (|check-subtype| (>= #2# 0)
                                                '(|NonNegativeInteger|) #2#))
                             (QREFELT $ 11))
                            . #5#)
                      (LETT |quot| (SPADCALL |quot| |mon| (QREFELT $ 31))
                            . #5#)
                      (EXIT
                       (LETT F
                             (SPADCALL (SPADCALL F (QREFELT $ 27))
                                       (SPADCALL |mon| G (QREFELT $ 32))
                                       (QREFELT $ 33))
                             . #5#)))
                     NIL (GO G190) G191 (EXIT NIL))
                (EXIT (PROGN (LETT #1# (CONS |quot| F) . #5#) (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;resultantnaif;2polRR;5| (P Q $)
  (PROG (|#G23| |#G22| |a| #1=#:G878 U #2=#:G884 |degQ| |degP| |#G21| |#G20|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |a| (|spadConstant| $ 8) . #3=(|PRS;resultantnaif;2polRR;5|))
            (EXIT
             (SEQ G190 NIL
                  (SEQ
                   (EXIT
                    (COND
                     ((SPADCALL Q (QREFELT $ 23))
                      (PROGN (LETT #2# (|spadConstant| $ 29) . #3#) (GO #2#)))
                     ('T
                      (SEQ
                       (PROGN
                        (LETT |#G20| (SPADCALL P (QREFELT $ 26)) . #3#)
                        (LETT |#G21| (SPADCALL Q (QREFELT $ 26)) . #3#)
                        (LETT |degP| |#G20| . #3#)
                        (LETT |degQ| |#G21| . #3#))
                       (COND
                        ((ODDP |degP|)
                         (COND
                          ((ODDP |degQ|)
                           (LETT |a| (SPADCALL |a| (QREFELT $ 39)) . #3#)))))
                       (EXIT
                        (COND
                         ((ZEROP |degQ|)
                          (PROGN
                           (LETT #2#
                                 (SPADCALL |a|
                                           (SPADCALL
                                            (SPADCALL Q (QREFELT $ 25)) |degP|
                                            (QREFELT $ 28))
                                           (QREFELT $ 40))
                                 . #3#)
                           (GO #2#)))
                         ('T
                          (SEQ
                           (LETT U (QCDR (SPADCALL P Q (QREFELT $ 38))) . #3#)
                           (LETT |a|
                                 (SPADCALL |a|
                                           (SPADCALL
                                            (SPADCALL Q (QREFELT $ 25))
                                            (PROG1
                                                (LETT #1#
                                                      (- |degP|
                                                         (SPADCALL U
                                                                   (QREFELT $
                                                                            26)))
                                                      . #3#)
                                              (|check-subtype| (>= #1# 0)
                                                               '(|NonNegativeInteger|)
                                                               #1#))
                                            (QREFELT $ 28))
                                           (QREFELT $ 40))
                                 . #3#)
                           (EXIT
                            (PROGN
                             (LETT |#G22| Q . #3#)
                             (LETT |#G23| U . #3#)
                             (LETT P |#G22| . #3#)
                             (LETT Q |#G23| . #3#))))))))))))
                  NIL (GO G190) G191 (EXIT NIL)))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;resultantEuclideannaif;2polRR;6| (P Q $)
  (PROG (|cf2| |cf1| |oldcf2| |oldcf1| |#G33| |#G32| |#G31| |#G30| |#G29|
         |#G28| |a| #1=#:G894 |divid| #2=#:G900 #3=#:G889 |degQ| |degP| |#G27|
         |#G26|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |a| (|spadConstant| $ 8)
              . #4=(|PRS;resultantEuclideannaif;2polRR;6|))
        (LETT |oldcf1| (|spadConstant| $ 9) . #4#)
        (LETT |cf1| (|spadConstant| $ 24) . #4#)
        (LETT |oldcf2| (|spadConstant| $ 24) . #4#)
        (LETT |cf2| (|spadConstant| $ 9) . #4#)
        (EXIT
         (SEQ G190 NIL
              (SEQ
               (EXIT
                (COND
                 ((SPADCALL Q (QREFELT $ 23))
                  (PROGN
                   (LETT #2#
                         (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                                 (|spadConstant| $ 29))
                         . #4#)
                   (GO #2#)))
                 ('T
                  (SEQ
                   (PROGN
                    (LETT |#G26| (SPADCALL P (QREFELT $ 26)) . #4#)
                    (LETT |#G27| (SPADCALL Q (QREFELT $ 26)) . #4#)
                    (LETT |degP| |#G26| . #4#)
                    (LETT |degQ| |#G27| . #4#))
                   (COND
                    ((ODDP |degP|)
                     (COND
                      ((ODDP |degQ|)
                       (LETT |a| (SPADCALL |a| (QREFELT $ 39)) . #4#)))))
                   (COND
                    ((ZEROP |degQ|)
                     (SEQ
                      (LETT |a|
                            (SPADCALL |a|
                                      (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                                (PROG1
                                                    (LETT #3# (- |degP| 1)
                                                          . #4#)
                                                  (|check-subtype| (>= #3# 0)
                                                                   '(|NonNegativeInteger|)
                                                                   #3#))
                                                (QREFELT $ 28))
                                      (QREFELT $ 40))
                            . #4#)
                      (EXIT
                       (PROGN
                        (LETT #2#
                              (VECTOR (SPADCALL |a| |cf1| (QREFELT $ 30))
                                      (SPADCALL |a| |cf2| (QREFELT $ 30))
                                      (SPADCALL |a| (SPADCALL Q (QREFELT $ 25))
                                                (QREFELT $ 40)))
                              . #4#)
                        (GO #2#))))))
                   (LETT |divid| (SPADCALL P Q (QREFELT $ 38)) . #4#)
                   (LETT |a|
                         (SPADCALL |a|
                                   (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                             (PROG1
                                                 (LETT #1#
                                                       (- |degP|
                                                          (SPADCALL
                                                           (QCDR |divid|)
                                                           (QREFELT $ 26)))
                                                       . #4#)
                                               (|check-subtype| (>= #1# 0)
                                                                '(|NonNegativeInteger|)
                                                                #1#))
                                             (QREFELT $ 28))
                                   (QREFELT $ 40))
                         . #4#)
                   (PROGN
                    (LETT |#G28| Q . #4#)
                    (LETT |#G29| (QCDR |divid|) . #4#)
                    (LETT P |#G28| . #4#)
                    (LETT Q |#G29| . #4#))
                   (EXIT
                    (PROGN
                     (LETT |#G30| |cf1| . #4#)
                     (LETT |#G31| |cf2| . #4#)
                     (LETT |#G32|
                           (SPADCALL |oldcf1|
                                     (SPADCALL (QCAR |divid|) |cf1|
                                               (QREFELT $ 32))
                                     (QREFELT $ 33))
                           . #4#)
                     (LETT |#G33|
                           (SPADCALL |oldcf2|
                                     (SPADCALL (QCAR |divid|) |cf2|
                                               (QREFELT $ 32))
                                     (QREFELT $ 33))
                           . #4#)
                     (LETT |oldcf1| |#G30| . #4#)
                     (LETT |oldcf2| |#G31| . #4#)
                     (LETT |cf1| |#G32| . #4#)
                     (LETT |cf2| |#G33| . #4#))))))))
              NIL (GO G190) G191 (EXIT NIL)))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;semiResultantEuclideannaif;2polRR;7| (P Q $)
  (PROG (|cf2| |oldcf2| |#G41| |#G40| |#G39| |#G38| |a| #1=#:G910 |divid|
         #2=#:G916 #3=#:G905 |degQ| |degP| |#G37| |#G36|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |a| (|spadConstant| $ 8)
              . #4=(|PRS;semiResultantEuclideannaif;2polRR;7|))
        (LETT |oldcf2| (|spadConstant| $ 24) . #4#)
        (LETT |cf2| (|spadConstant| $ 9) . #4#)
        (EXIT
         (SEQ G190 NIL
              (SEQ
               (EXIT
                (COND
                 ((SPADCALL Q (QREFELT $ 23))
                  (PROGN
                   (LETT #2# (CONS (|spadConstant| $ 24) (|spadConstant| $ 29))
                         . #4#)
                   (GO #2#)))
                 ('T
                  (SEQ
                   (PROGN
                    (LETT |#G36| (SPADCALL P (QREFELT $ 26)) . #4#)
                    (LETT |#G37| (SPADCALL Q (QREFELT $ 26)) . #4#)
                    (LETT |degP| |#G36| . #4#)
                    (LETT |degQ| |#G37| . #4#))
                   (COND
                    ((ODDP |degP|)
                     (COND
                      ((ODDP |degQ|)
                       (LETT |a| (SPADCALL |a| (QREFELT $ 39)) . #4#)))))
                   (COND
                    ((ZEROP |degQ|)
                     (SEQ
                      (LETT |a|
                            (SPADCALL |a|
                                      (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                                (PROG1
                                                    (LETT #3# (- |degP| 1)
                                                          . #4#)
                                                  (|check-subtype| (>= #3# 0)
                                                                   '(|NonNegativeInteger|)
                                                                   #3#))
                                                (QREFELT $ 28))
                                      (QREFELT $ 40))
                            . #4#)
                      (EXIT
                       (PROGN
                        (LETT #2#
                              (CONS (SPADCALL |a| |cf2| (QREFELT $ 30))
                                    (SPADCALL |a| (SPADCALL Q (QREFELT $ 25))
                                              (QREFELT $ 40)))
                              . #4#)
                        (GO #2#))))))
                   (LETT |divid| (SPADCALL P Q (QREFELT $ 38)) . #4#)
                   (LETT |a|
                         (SPADCALL |a|
                                   (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                             (PROG1
                                                 (LETT #1#
                                                       (- |degP|
                                                          (SPADCALL
                                                           (QCDR |divid|)
                                                           (QREFELT $ 26)))
                                                       . #4#)
                                               (|check-subtype| (>= #1# 0)
                                                                '(|NonNegativeInteger|)
                                                                #1#))
                                             (QREFELT $ 28))
                                   (QREFELT $ 40))
                         . #4#)
                   (PROGN
                    (LETT |#G38| Q . #4#)
                    (LETT |#G39| (QCDR |divid|) . #4#)
                    (LETT P |#G38| . #4#)
                    (LETT Q |#G39| . #4#))
                   (EXIT
                    (PROGN
                     (LETT |#G40| |cf2| . #4#)
                     (LETT |#G41|
                           (SPADCALL |oldcf2|
                                     (SPADCALL (QCAR |divid|) |cf2|
                                               (QREFELT $ 32))
                                     (QREFELT $ 33))
                           . #4#)
                     (LETT |oldcf2| |#G40| . #4#)
                     (LETT |cf2| |#G41| . #4#))))))))
              NIL (GO G190) G191 (EXIT NIL)))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;Lazard;2RNniR;8| (|x| |y| |n| $)
  (PROG (#1=#:G923 |c| #2=#:G921 |a| #3=#:G929 #4=#:G919 |b|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((ZEROP |n|) (|error| "Lazard$PRS : n = 0")) ((EQL |n| 1) |x|)
             ('T
              (SEQ (LETT |a| 1 . #5=(|PRS;Lazard;2RNniR;8|))
                   (SEQ G190
                        (COND
                         ((NULL
                           (SEQ
                            (LETT |b| (SPADCALL 2 |a| (QREFELT $ 47)) . #5#)
                            (EXIT (COND ((< |n| |b|) 'NIL) ('T 'T)))))
                          (GO G191)))
                        (SEQ (EXIT (LETT |a| |b| . #5#))) NIL #6=(GO G190) G191
                        (EXIT NIL))
                   (LETT |c| |x| . #5#)
                   (LETT |n|
                         (PROG1 (LETT #4# (- |n| |a|) . #5#)
                           (|check-subtype| (>= #4# 0) '(|NonNegativeInteger|)
                                            #4#))
                         . #5#)
                   (EXIT
                    (SEQ G190 NIL
                         (SEQ
                          (EXIT
                           (COND
                            ((EQL |a| 1) (PROGN (LETT #3# |c| . #5#) (GO #3#)))
                            ('T
                             (SEQ (LETT |a| (QUOTIENT2 |a| 2) . #5#)
                                  (LETT |c|
                                        (PROG2
                                            (LETT #2#
                                                  (SPADCALL
                                                   (SPADCALL |c| |c|
                                                             (QREFELT $ 40))
                                                   |y| (QREFELT $ 36))
                                                  . #5#)
                                            (QCDR #2#)
                                          (|check-union| (QEQCAR #2# 0)
                                                         (QREFELT $ 6) #2#))
                                        . #5#)
                                  (EXIT
                                   (COND
                                    ((NULL (< |n| |a|))
                                     (SEQ
                                      (LETT |c|
                                            (PROG2
                                                (LETT #2#
                                                      (SPADCALL
                                                       (SPADCALL |c| |x|
                                                                 (QREFELT $
                                                                          40))
                                                       |y| (QREFELT $ 36))
                                                      . #5#)
                                                (QCDR #2#)
                                              (|check-union| (QEQCAR #2# 0)
                                                             (QREFELT $ 6)
                                                             #2#))
                                            . #5#)
                                      (EXIT
                                       (LETT |n|
                                             (PROG1
                                                 (LETT #1# (- |n| |a|) . #5#)
                                               (|check-subtype| (>= #1# 0)
                                                                '(|NonNegativeInteger|)
                                                                #1#))
                                             . #5#)))))))))))
                         NIL #6# G191 (EXIT NIL)))))))
      #3# (EXIT #3#))))) 

(DEFUN |PRS;Lazard2;polR2RNnipolR;9| (F |x| |y| |n| $)
  (PROG (#1=#:G936 #2=#:G932 #3=#:G930)
    (RETURN
     (SEQ
      (EXIT
       (COND ((ZEROP |n|) (|error| "Lazard2$PRS : n = 0")) ((EQL |n| 1) F)
             ('T
              (SEQ
               (LETT |x|
                     (SPADCALL |x| |y|
                               (PROG1
                                   (LETT #3# (- |n| 1)
                                         . #4=(|PRS;Lazard2;polR2RNnipolR;9|))
                                 (|check-subtype| (>= #3# 0)
                                                  '(|NonNegativeInteger|) #3#))
                               (QREFELT $ 48))
                     . #4#)
               (EXIT
                (PROGN
                 (LETT #1#
                       (PROG2
                           (LETT #2#
                                 (SPADCALL (SPADCALL |x| F (QREFELT $ 30)) |y|
                                           (QREFELT $ 18))
                                 . #4#)
                           (QCDR #2#)
                         (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                       . #4#)
                 (GO #1#)))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;Lazard3| (V |x| |y| |n| $)
  (PROG (#1=#:G940 #2=#:G937)
    (RETURN
     (SEQ
      (EXIT
       (COND ((ZEROP |n|) (|error| "Lazard2$prs : n = 0")) ((EQL |n| 1) V)
             ('T
              (SEQ
               (LETT |x|
                     (SPADCALL |x| |y|
                               (PROG1 (LETT #2# (- |n| 1) . #3=(|PRS;Lazard3|))
                                 (|check-subtype| (>= #2# 0)
                                                  '(|NonNegativeInteger|) #2#))
                               (QREFELT $ 48))
                     . #3#)
               (EXIT
                (PROGN
                 (LETT #1#
                       (SPADCALL (SPADCALL |x| V (QREFELT $ 16)) |y|
                                 (QREFELT $ 21))
                       . #3#)
                 (GO #1#)))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;nextsousResultant2;3polRRpolR;11| (P Q Z |s| $)
  (PROG (#1=#:G952 A #2=#:G942 H #3=#:G953 |i| |#G66| |#G65| |#G64| |e| |d|
         |#G63| |#G62| |se| |c| |lcP| |#G61| |#G60| |#G59|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (PROGN
         (LETT |#G59| (SPADCALL P (QREFELT $ 25))
               . #4=(|PRS;nextsousResultant2;3polRRpolR;11|))
         (LETT |#G60| (SPADCALL Q (QREFELT $ 25)) . #4#)
         (LETT |#G61| (SPADCALL Z (QREFELT $ 25)) . #4#)
         (LETT |lcP| |#G59| . #4#)
         (LETT |c| |#G60| . #4#)
         (LETT |se| |#G61| . #4#))
        (PROGN
         (LETT |#G62| (SPADCALL P (QREFELT $ 26)) . #4#)
         (LETT |#G63| (SPADCALL Q (QREFELT $ 26)) . #4#)
         (LETT |d| |#G62| . #4#)
         (LETT |e| |#G63| . #4#))
        (PROGN
         (LETT |#G64| (SPADCALL P (QREFELT $ 27)) . #4#)
         (LETT |#G65| (SPADCALL Q (QREFELT $ 27)) . #4#)
         (LETT |#G66| (SPADCALL (SPADCALL Z (QREFELT $ 27)) (QREFELT $ 50))
               . #4#)
         (LETT P |#G64| . #4#)
         (LETT Q |#G65| . #4#)
         (LETT H |#G66| . #4#))
        (LETT A (SPADCALL (SPADCALL P |e| (QREFELT $ 51)) H (QREFELT $ 30))
              . #4#)
        (SEQ (LETT |i| (+ |e| 1) . #4#) (LETT #3# (- |d| 1) . #4#) G190
             (COND ((> |i| #3#) #5=(GO G191)))
             (SEQ
              (LETT H
                    (COND
                     ((EQL (SPADCALL H (QREFELT $ 26)) (- |e| 1))
                      (SPADCALL
                       (SPADCALL (QREFELT $ 12) (SPADCALL H (QREFELT $ 27))
                                 (QREFELT $ 32))
                       (PROG2
                           (LETT #2#
                                 (SPADCALL
                                  (SPADCALL (SPADCALL H (QREFELT $ 25)) Q
                                            (QREFELT $ 30))
                                  |c| (QREFELT $ 18))
                                 . #4#)
                           (QCDR #2#)
                         (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                       (QREFELT $ 33)))
                     ('T (SPADCALL (QREFELT $ 12) H (QREFELT $ 32))))
                    . #4#)
              (EXIT
               (LETT A
                     (SPADCALL
                      (SPADCALL (SPADCALL P |i| (QREFELT $ 51)) H
                                (QREFELT $ 30))
                      A (QREFELT $ 31))
                     . #4#)))
             (LETT |i| (+ |i| 1) . #4#) #6=(GO G190) G191 (EXIT NIL))
        (SEQ G190
             (COND
              ((NULL (COND ((< (SPADCALL P (QREFELT $ 26)) |e|) 'NIL) ('T 'T)))
               #5#))
             (SEQ (EXIT (LETT P (SPADCALL P (QREFELT $ 27)) . #4#))) NIL #6#
             G191 (EXIT NIL))
        (LETT A (SPADCALL A (SPADCALL |se| P (QREFELT $ 30)) (QREFELT $ 31))
              . #4#)
        (LETT A
              (PROG2
                  (LETT #2# (SPADCALL A |lcP| (QREFELT $ 18)) . #4#)
                  (QCDR #2#)
                (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
              . #4#)
        (LETT A
              (COND
               ((EQL (SPADCALL H (QREFELT $ 26)) (- |e| 1))
                (SPADCALL
                 (SPADCALL |c|
                           (SPADCALL
                            (SPADCALL (QREFELT $ 12)
                                      (SPADCALL H (QREFELT $ 27))
                                      (QREFELT $ 32))
                            A (QREFELT $ 31))
                           (QREFELT $ 30))
                 (SPADCALL (SPADCALL H (QREFELT $ 25)) Q (QREFELT $ 30))
                 (QREFELT $ 33)))
               (#7='T
                (SPADCALL |c|
                          (SPADCALL (SPADCALL (QREFELT $ 12) H (QREFELT $ 32))
                                    A (QREFELT $ 31))
                          (QREFELT $ 30))))
              . #4#)
        (LETT A
              (PROG2
                  (LETT #2# (SPADCALL A |s| (QREFELT $ 18)) . #4#)
                  (QCDR #2#)
                (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
              . #4#)
        (EXIT
         (PROGN
          (LETT #1#
                (COND ((ODDP (- |d| |e|)) A) (#7# (SPADCALL A (QREFELT $ 50))))
                . #4#)
          (GO #1#)))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;nextsousResultant3| (VP VQ |s| |ss| $)
  (PROG (#1=#:G966 #2=#:G958 #3=#:G967 |i| |divid| |rr| |r| |#G77| |#G76|
         #4=#:G954 |delta| |e| |c| |lcP| |#G75| |#G74| Q P |#G73| |#G72|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (PROGN
         (LETT |#G72| (SPADCALL VP 1 (QREFELT $ 54))
               . #5=(|PRS;nextsousResultant3|))
         (LETT |#G73| (SPADCALL VQ 1 (QREFELT $ 54)) . #5#)
         (LETT P |#G72| . #5#)
         (LETT Q |#G73| . #5#))
        (PROGN
         (LETT |#G74| (SPADCALL P (QREFELT $ 25)) . #5#)
         (LETT |#G75| (SPADCALL Q (QREFELT $ 25)) . #5#)
         (LETT |lcP| |#G74| . #5#)
         (LETT |c| |#G75| . #5#))
        (LETT |e| (SPADCALL Q (QREFELT $ 26)) . #5#)
        (SEQ (LETT |delta| (- (SPADCALL P (QREFELT $ 26)) |e|) . #5#)
             (EXIT
              (COND
               ((EQL |delta| 1)
                (SEQ
                 (LETT VP
                       (SPADCALL (SPADCALL |c| VP (QREFELT $ 16))
                                 (SPADCALL (SPADCALL P |e| (QREFELT $ 51)) VQ
                                           (QREFELT $ 16))
                                 (QREFELT $ 55))
                       . #5#)
                 (LETT VP (SPADCALL VP |lcP| (QREFELT $ 21)) . #5#)
                 (LETT VP
                       (SPADCALL
                        (SPADCALL |c|
                                  (SPADCALL VP
                                            (SPADCALL (QREFELT $ 12) VQ
                                                      (QREFELT $ 15))
                                            (QREFELT $ 55))
                                  (QREFELT $ 16))
                        (SPADCALL
                         (SPADCALL Q
                                   (PROG1 (LETT #4# (- |e| 1) . #5#)
                                     (|check-subtype| (>= #4# 0)
                                                      '(|NonNegativeInteger|)
                                                      #4#))
                                   (QREFELT $ 51))
                         VQ (QREFELT $ 16))
                        (QREFELT $ 56))
                       . #5#)
                 (EXIT (LETT VP (SPADCALL VP |s| (QREFELT $ 21)) . #5#))))
               (#6='T
                (SEQ
                 (PROGN
                  (LETT |#G76| (SPADCALL |s| |lcP| (QREFELT $ 40)) . #5#)
                  (LETT |#G77| (SPADCALL |ss| |c| (QREFELT $ 40)) . #5#)
                  (LETT |r| |#G76| . #5#)
                  (LETT |rr| |#G77| . #5#))
                 (LETT |divid|
                       (SPADCALL (SPADCALL |rr| P (QREFELT $ 30)) Q
                                 (QREFELT $ 38))
                       . #5#)
                 (SPADCALL VP 1
                           (PROG2
                               (LETT #2#
                                     (SPADCALL (QCDR |divid|) |r|
                                               (QREFELT $ 18))
                                     . #5#)
                               (QCDR #2#)
                             (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                           (QREFELT $ 57))
                 (EXIT
                  (SEQ (LETT |i| 2 . #5#) (LETT #3# (QVSIZE VP) . #5#) G190
                       (COND ((QSGREATERP |i| #3#) (GO G191)))
                       (SEQ
                        (SPADCALL VP |i|
                                  (SPADCALL
                                   (SPADCALL |rr|
                                             (SPADCALL VP |i| (QREFELT $ 54))
                                             (QREFELT $ 30))
                                   (SPADCALL (SPADCALL VQ |i| (QREFELT $ 54))
                                             (QCAR |divid|) (QREFELT $ 32))
                                   (QREFELT $ 33))
                                  (QREFELT $ 57))
                        (EXIT
                         (SPADCALL VP |i|
                                   (PROG2
                                       (LETT #2#
                                             (SPADCALL
                                              (SPADCALL VP |i| (QREFELT $ 54))
                                              |r| (QREFELT $ 18))
                                             . #5#)
                                       (QCDR #2#)
                                     (|check-union| (QEQCAR #2# 0)
                                                    (QREFELT $ 7) #2#))
                                   (QREFELT $ 57))))
                       (LETT |i| (QSADD1 |i|) . #5#) (GO G190) G191
                       (EXIT NIL))))))))
        (EXIT
         (PROGN
          (LETT #1#
                (COND ((ODDP |delta|) VP) (#6# (SPADCALL VP (QREFELT $ 58))))
                . #5#)
          (GO #1#)))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;algonew| (P Q $)
  (PROG (|s| |#G84| |#G83| #1=#:G975 Z |delta| #2=#:G969 |#G82| |#G81|
         #3=#:G968)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |delta|
              (PROG1
                  (LETT #3#
                        (- (SPADCALL P (QREFELT $ 26))
                           (SPADCALL Q (QREFELT $ 26)))
                        . #4=(|PRS;algonew|))
                (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|) #3#))
              . #4#)
        (LETT |s| (SPADCALL (SPADCALL Q (QREFELT $ 25)) |delta| (QREFELT $ 28))
              . #4#)
        (PROGN
         (LETT |#G81| Q . #4#)
         (LETT |#G82| (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 59))
               . #4#)
         (LETT P |#G81| . #4#)
         (LETT Q |#G82| . #4#))
        (EXIT
         (SEQ G190 NIL
              (SEQ
               (EXIT
                (COND
                 ((SPADCALL Q (QREFELT $ 23))
                  (PROGN (LETT #1# (|spadConstant| $ 29) . #4#) (GO #1#)))
                 ('T
                  (SEQ
                   (LETT |delta|
                         (PROG1
                             (LETT #2#
                                   (- (SPADCALL P (QREFELT $ 26))
                                      (SPADCALL Q (QREFELT $ 26)))
                                   . #4#)
                           (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|)
                                            #2#))
                         . #4#)
                   (LETT Z
                         (SPADCALL Q (SPADCALL Q (QREFELT $ 25)) |s| |delta|
                                   (QREFELT $ 49))
                         . #4#)
                   (EXIT
                    (COND
                     ((ZEROP (SPADCALL Z (QREFELT $ 26)))
                      (PROGN
                       (LETT #1# (SPADCALL Z (QREFELT $ 25)) . #4#)
                       (GO #1#)))
                     ('T
                      (SEQ
                       (PROGN
                        (LETT |#G83| Q . #4#)
                        (LETT |#G84| (SPADCALL P Q Z |s| (QREFELT $ 52)) . #4#)
                        (LETT P |#G83| . #4#)
                        (LETT Q |#G84| . #4#))
                       (EXIT
                        (LETT |s| (SPADCALL Z (QREFELT $ 25)) . #4#)))))))))))
              NIL (GO G190) G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;resultant;2polRR;14| (P Q $)
  (PROG (#1=#:G982 |#G88| |#G87|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (|spadConstant| $ 29))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (PROGN
              (LETT |#G87| Q . #2=(|PRS;resultant;2polRR;14|))
              (LETT |#G88| P . #2#)
              (LETT P |#G87| . #2#)
              (LETT Q |#G88| . #2#))
             (EXIT
              (COND
               ((ODDP (SPADCALL P (QREFELT $ 26)))
                (COND
                 ((ODDP (SPADCALL Q (QREFELT $ 26)))
                  (LETT Q (SPADCALL Q (QREFELT $ 50)) . #2#)))))))))
          (EXIT
           (COND
            ((ZEROP (SPADCALL Q (QREFELT $ 26)))
             (SPADCALL (SPADCALL Q (QREFELT $ 25)) (SPADCALL P (QREFELT $ 26))
                       (QREFELT $ 28)))
            ((|HasCategory| (QREFELT $ 6) '(|Finite|))
             (SPADCALL P Q (QREFELT $ 41)))
            ('T (PROGN (LETT #1# (|PRS;algonew| P Q $) . #2#) (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;subResultantEuclidean| (P Q $)
  (PROG (|s| VQ VP |#G94| |#G93| |ss| #1=#:G994 |l| |delta| #2=#:G987 |e|
         |#G92| |#G91| |pdiv| #3=#:G985)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |s|
              (SPADCALL (SPADCALL Q (QREFELT $ 25))
                        (PROG1
                            (LETT #3#
                                  (- (SPADCALL P (QREFELT $ 26))
                                     (SPADCALL Q (QREFELT $ 26)))
                                  . #4=(|PRS;subResultantEuclidean|))
                          (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                                           #3#))
                        (QREFELT $ 28))
              . #4#)
        (LETT VP (VECTOR Q (|spadConstant| $ 24) (|spadConstant| $ 9)) . #4#)
        (LETT |pdiv| (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
              . #4#)
        (LETT VQ
              (VECTOR (QVELT |pdiv| 2)
                      (SPADCALL (QVELT |pdiv| 0) (QREFELT $ 13))
                      (QVELT |pdiv| 1))
              . #4#)
        (EXIT
         (SEQ G190 NIL
              (SEQ
               (PROGN
                (LETT |#G91| (SPADCALL VP 1 (QREFELT $ 54)) . #4#)
                (LETT |#G92| (SPADCALL VQ 1 (QREFELT $ 54)) . #4#)
                (LETT P |#G91| . #4#)
                (LETT Q |#G92| . #4#))
               (EXIT
                (COND
                 ((SPADCALL Q (QREFELT $ 23))
                  (PROGN
                   (LETT #1#
                         (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                                 (|spadConstant| $ 29))
                         . #4#)
                   (GO #1#)))
                 ('T
                  (SEQ (LETT |e| (SPADCALL Q (QREFELT $ 26)) . #4#)
                       (LETT |delta|
                             (PROG1
                                 (LETT #2# (- (SPADCALL P (QREFELT $ 26)) |e|)
                                       . #4#)
                               (|check-subtype| (>= #2# 0)
                                                '(|NonNegativeInteger|) #2#))
                             . #4#)
                       (COND
                        ((ZEROP |e|)
                         (SEQ
                          (LETT |l|
                                (|PRS;Lazard3| VQ (SPADCALL Q (QREFELT $ 25))
                                 |s| |delta| $)
                                . #4#)
                          (EXIT
                           (PROGN
                            (LETT #1#
                                  (VECTOR (SPADCALL |l| 2 (QREFELT $ 54))
                                          (SPADCALL |l| 3 (QREFELT $ 54))
                                          (SPADCALL
                                           (SPADCALL |l| 1 (QREFELT $ 54))
                                           (QREFELT $ 25)))
                                  . #4#)
                            (GO #1#))))))
                       (LETT |ss|
                             (SPADCALL (SPADCALL Q (QREFELT $ 25)) |s| |delta|
                                       (QREFELT $ 48))
                             . #4#)
                       (PROGN
                        (LETT |#G93| VQ . #4#)
                        (LETT |#G94|
                              (|PRS;nextsousResultant3| VP VQ |s| |ss| $)
                              . #4#)
                        (LETT VP |#G93| . #4#)
                        (LETT VQ |#G94| . #4#))
                       (EXIT (LETT |s| |ss| . #4#)))))))
              NIL (GO G190) G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;resultantEuclidean;2polRR;16| (P Q $)
  (PROG (#1=#:G1007 |s| #2=#:G1002 |degP| |l| |e|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL P (QREFELT $ 23)) (SPADCALL Q (QREFELT $ 23)))
         (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                 (|spadConstant| $ 29)))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |e|
                   (COND
                    ((ODDP (SPADCALL P (QREFELT $ 26)))
                     (COND ((ODDP (SPADCALL Q (QREFELT $ 26))) -1) (#3='T 1)))
                    (#3# 1))
                   . #4=(|PRS;resultantEuclidean;2polRR;16|))
             (LETT |l|
                   (SPADCALL Q (SPADCALL |e| P (QREFELT $ 61)) (QREFELT $ 62))
                   . #4#)
             (EXIT
              (PROGN
               (LETT #1#
                     (VECTOR (SPADCALL |e| (QVELT |l| 1) (QREFELT $ 61))
                             (QVELT |l| 0) (QVELT |l| 2))
                     . #4#)
               (GO #1#))))))
          (COND
           ((ZEROP (SPADCALL Q (QREFELT $ 26)))
            (SEQ (LETT |degP| (SPADCALL P (QREFELT $ 26)) . #4#)
                 (EXIT
                  (COND
                   ((ZEROP |degP|)
                    (|error| "resultantEuclidean$PRS : constant polynomials"))
                   (#3#
                    (SEQ
                     (LETT |s|
                           (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                     (PROG1 (LETT #2# (- |degP| 1) . #4#)
                                       (|check-subtype| (>= #2# 0)
                                                        '(|NonNegativeInteger|)
                                                        #2#))
                                     (QREFELT $ 28))
                           . #4#)
                     (EXIT
                      (PROGN
                       (LETT #1#
                             (VECTOR (|spadConstant| $ 24)
                                     (SPADCALL |s| (QREFELT $ 13))
                                     (SPADCALL |s| (SPADCALL Q (QREFELT $ 25))
                                               (QREFELT $ 40)))
                             . #4#)
                       (GO #1#))))))))))
          (EXIT
           (COND
            ((|HasCategory| (QREFELT $ 6) '(|Finite|))
             (SPADCALL P Q (QREFELT $ 43)))
            (#3#
             (PROGN
              (LETT #1# (|PRS;subResultantEuclidean| P Q $) . #4#)
              (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiSubResultantEuclidean| (P Q $)
  (PROG (|s| VQ VP |#G102| |#G101| |ss| #1=#:G1019 |l| |delta| #2=#:G1012 |e|
         |#G100| |#G99| |pdiv| #3=#:G1010)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |s|
              (SPADCALL (SPADCALL Q (QREFELT $ 25))
                        (PROG1
                            (LETT #3#
                                  (- (SPADCALL P (QREFELT $ 26))
                                     (SPADCALL Q (QREFELT $ 26)))
                                  . #4=(|PRS;semiSubResultantEuclidean|))
                          (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                                           #3#))
                        (QREFELT $ 28))
              . #4#)
        (LETT VP (VECTOR Q (|spadConstant| $ 9)) . #4#)
        (LETT |pdiv| (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
              . #4#)
        (LETT VQ (VECTOR (QVELT |pdiv| 2) (QVELT |pdiv| 1)) . #4#)
        (EXIT
         (SEQ G190 NIL
              (SEQ
               (PROGN
                (LETT |#G99| (SPADCALL VP 1 (QREFELT $ 54)) . #4#)
                (LETT |#G100| (SPADCALL VQ 1 (QREFELT $ 54)) . #4#)
                (LETT P |#G99| . #4#)
                (LETT Q |#G100| . #4#))
               (EXIT
                (COND
                 ((SPADCALL Q (QREFELT $ 23))
                  (PROGN
                   (LETT #1# (CONS (|spadConstant| $ 24) (|spadConstant| $ 29))
                         . #4#)
                   (GO #1#)))
                 ('T
                  (SEQ (LETT |e| (SPADCALL Q (QREFELT $ 26)) . #4#)
                       (LETT |delta|
                             (PROG1
                                 (LETT #2# (- (SPADCALL P (QREFELT $ 26)) |e|)
                                       . #4#)
                               (|check-subtype| (>= #2# 0)
                                                '(|NonNegativeInteger|) #2#))
                             . #4#)
                       (COND
                        ((ZEROP |e|)
                         (SEQ
                          (LETT |l|
                                (|PRS;Lazard3| VQ (SPADCALL Q (QREFELT $ 25))
                                 |s| |delta| $)
                                . #4#)
                          (EXIT
                           (PROGN
                            (LETT #1#
                                  (CONS (SPADCALL |l| 2 (QREFELT $ 54))
                                        (SPADCALL
                                         (SPADCALL |l| 1 (QREFELT $ 54))
                                         (QREFELT $ 25)))
                                  . #4#)
                            (GO #1#))))))
                       (LETT |ss|
                             (SPADCALL (SPADCALL Q (QREFELT $ 25)) |s| |delta|
                                       (QREFELT $ 48))
                             . #4#)
                       (PROGN
                        (LETT |#G101| VQ . #4#)
                        (LETT |#G102|
                              (|PRS;nextsousResultant3| VP VQ |s| |ss| $)
                              . #4#)
                        (LETT VP |#G101| . #4#)
                        (LETT VQ |#G102| . #4#))
                       (EXIT (LETT |s| |ss| . #4#)))))))
              NIL (GO G190) G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiResultantEuclidean2;2polRR;18| (P Q $)
  (PROG (#1=#:G1029 |s| #2=#:G1023 |degP|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL P (QREFELT $ 23)) (SPADCALL Q (QREFELT $ 23)))
         (CONS (|spadConstant| $ 24) (|spadConstant| $ 29)))
        ('T
         (COND
          ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
           (|error| "semiResultantEuclidean2 : bad degrees"))
          (#3='T
           (SEQ
            (COND
             ((ZEROP (SPADCALL Q (QREFELT $ 26)))
              (SEQ
               (LETT |degP| (SPADCALL P (QREFELT $ 26))
                     . #4=(|PRS;semiResultantEuclidean2;2polRR;18|))
               (EXIT
                (COND
                 ((ZEROP |degP|)
                  (|error| "semiResultantEuclidean2 : constant polynomials"))
                 (#3#
                  (SEQ
                   (LETT |s|
                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                   (PROG1 (LETT #2# (- |degP| 1) . #4#)
                                     (|check-subtype| (>= #2# 0)
                                                      '(|NonNegativeInteger|)
                                                      #2#))
                                   (QREFELT $ 28))
                         . #4#)
                   (EXIT
                    (PROGN
                     (LETT #1#
                           (CONS (SPADCALL |s| (QREFELT $ 13))
                                 (SPADCALL |s| (SPADCALL Q (QREFELT $ 25))
                                           (QREFELT $ 40)))
                           . #4#)
                     (GO #1#))))))))))
            (EXIT
             (COND
              ((|HasCategory| (QREFELT $ 6) '(|Finite|))
               (SPADCALL P Q (QREFELT $ 45)))
              (#3#
               (PROGN
                (LETT #1# (|PRS;semiSubResultantEuclidean| P Q $) . #4#)
                (GO #1#)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiResultantEuclidean1;2polRR;19| (P Q $)
  (PROG (|result|)
    (RETURN
     (SEQ
      (LETT |result| (SPADCALL P Q (QREFELT $ 62))
            |PRS;semiResultantEuclidean1;2polRR;19|)
      (EXIT (CONS (QVELT |result| 0) (QVELT |result| 2))))))) 

(DEFUN |PRS;indiceSubResultant;2polRNnipolR;20| (P Q |i| $)
  (PROG (|s| |#G117| |#G116| #1=#:G1055 Z #2=#:G1048 |degQ| |degP| |#G115|
         |#G114| |#G113| |#G112| #3=#:G1046 #4=#:G1041 |delta| #5=#:G1039
         |#G111| |#G110|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (|spadConstant| $ 24))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (PROGN
              (LETT |#G110| Q . #6=(|PRS;indiceSubResultant;2polRNnipolR;20|))
              (LETT |#G111| P . #6#)
              (LETT P |#G110| . #6#)
              (LETT Q |#G111| . #6#))
             (EXIT
              (COND
               ((ODDP (- (SPADCALL P (QREFELT $ 26)) |i|))
                (COND
                 ((ODDP (- (SPADCALL Q (QREFELT $ 26)) |i|))
                  (LETT Q (SPADCALL Q (QREFELT $ 50)) . #6#)))))))))
          (COND
           ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |delta|
                   (PROG1
                       (LETT #5#
                             (- (SPADCALL P (QREFELT $ 26))
                                (SPADCALL Q (QREFELT $ 26)))
                             . #6#)
                     (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|) #5#))
                   . #6#)
             (EXIT
              (COND
               ((ZEROP |delta|)
                (|error| "indiceSubResultant$PRS : bad degrees"))
               (#7='T
                (SEQ
                 (LETT |s|
                       (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                 (PROG1 (LETT #4# (- |delta| 1) . #6#)
                                   (|check-subtype| (>= #4# 0)
                                                    '(|NonNegativeInteger|)
                                                    #4#))
                                 (QREFELT $ 28))
                       . #6#)
                 (EXIT
                  (PROGN
                   (LETT #1# (SPADCALL |s| Q (QREFELT $ 30)) . #6#)
                   (GO #1#))))))))))
          (EXIT
           (COND ((< (SPADCALL Q (QREFELT $ 26)) |i|) (|spadConstant| $ 24))
                 (#7#
                  (SEQ
                   (LETT |s|
                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                   (PROG1
                                       (LETT #3#
                                             (- (SPADCALL P (QREFELT $ 26))
                                                (SPADCALL Q (QREFELT $ 26)))
                                             . #6#)
                                     (|check-subtype| (>= #3# 0)
                                                      '(|NonNegativeInteger|)
                                                      #3#))
                                   (QREFELT $ 28))
                         . #6#)
                   (PROGN
                    (LETT |#G112| Q . #6#)
                    (LETT |#G113|
                          (SPADCALL P (SPADCALL Q (QREFELT $ 50))
                                    (QREFELT $ 59))
                          . #6#)
                    (LETT P |#G112| . #6#)
                    (LETT Q |#G113| . #6#))
                   (EXIT
                    (SEQ G190 NIL
                         (SEQ
                          (PROGN
                           (LETT |#G114| (SPADCALL P (QREFELT $ 26)) . #6#)
                           (LETT |#G115| (SPADCALL Q (QREFELT $ 26)) . #6#)
                           (LETT |degP| |#G114| . #6#)
                           (LETT |degQ| |#G115| . #6#))
                          (EXIT
                           (COND
                            ((EQL |i| (- |degP| 1))
                             (PROGN (LETT #1# Q . #6#) (GO #1#)))
                            ((OR (SPADCALL Q (QREFELT $ 23)) (< |degQ| |i|))
                             (PROGN
                              (LETT #1# (|spadConstant| $ 24) . #6#)
                              (GO #1#)))
                            ('T
                             (SEQ
                              (LETT Z
                                    (SPADCALL Q (SPADCALL Q (QREFELT $ 25)) |s|
                                              (PROG1
                                                  (LETT #2# (- |degP| |degQ|)
                                                        . #6#)
                                                (|check-subtype| (>= #2# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #2#))
                                              (QREFELT $ 49))
                                    . #6#)
                              (EXIT
                               (COND
                                ((EQL |i| |degQ|)
                                 (PROGN (LETT #1# Z . #6#) (GO #1#)))
                                ('T
                                 (SEQ
                                  (PROGN
                                   (LETT |#G116| Q . #6#)
                                   (LETT |#G117|
                                         (SPADCALL P Q Z |s| (QREFELT $ 52))
                                         . #6#)
                                   (LETT P |#G116| . #6#)
                                   (LETT Q |#G117| . #6#))
                                  (EXIT
                                   (LETT |s| (SPADCALL Z (QREFELT $ 25))
                                         . #6#)))))))))))
                         NIL (GO G190) G191 (EXIT NIL)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;indiceSubResultantEuclidean;2polRNniR;21| (P Q |i| $)
  (PROG (|s| VQ VP |#G130| |#G129| |ss| #1=#:G1081 VZ #2=#:G1073 |degQ| |degP|
         |#G128| |#G127| |#G126| |#G125| |pdiv| #3=#:G1071 #4=#:G1066 |delta|
         #5=#:G1064 |l| |e|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                 (|spadConstant| $ 24)))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |e|
                   (COND
                    ((ODDP (- (SPADCALL P (QREFELT $ 26)) |i|))
                     (COND
                      ((ODDP (- (SPADCALL Q (QREFELT $ 26)) |i|))
                       (SPADCALL (|spadConstant| $ 8) (QREFELT $ 39)))
                      (#6='T (|spadConstant| $ 8))))
                    (#6# (|spadConstant| $ 8)))
                   . #7=(|PRS;indiceSubResultantEuclidean;2polRNniR;21|))
             (LETT |l|
                   (SPADCALL Q (SPADCALL |e| P (QREFELT $ 30)) |i|
                             (QREFELT $ 68))
                   . #7#)
             (EXIT
              (PROGN
               (LETT #1#
                     (VECTOR (SPADCALL |e| (QVELT |l| 1) (QREFELT $ 30))
                             (QVELT |l| 0) (QVELT |l| 2))
                     . #7#)
               (GO #1#))))))
          (COND
           ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |delta|
                   (PROG1
                       (LETT #5#
                             (- (SPADCALL P (QREFELT $ 26))
                                (SPADCALL Q (QREFELT $ 26)))
                             . #7#)
                     (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|) #5#))
                   . #7#)
             (EXIT
              (COND
               ((ZEROP |delta|)
                (|error| "indiceSubResultantEuclidean$PRS : bad degrees"))
               (#6#
                (SEQ
                 (LETT |s|
                       (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                 (PROG1 (LETT #4# (- |delta| 1) . #7#)
                                   (|check-subtype| (>= #4# 0)
                                                    '(|NonNegativeInteger|)
                                                    #4#))
                                 (QREFELT $ 28))
                       . #7#)
                 (EXIT
                  (PROGN
                   (LETT #1#
                         (VECTOR (|spadConstant| $ 24)
                                 (SPADCALL |s| (QREFELT $ 13))
                                 (SPADCALL |s| Q (QREFELT $ 30)))
                         . #7#)
                   (GO #1#))))))))))
          (EXIT
           (COND
            ((< (SPADCALL Q (QREFELT $ 26)) |i|)
             (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                     (|spadConstant| $ 24)))
            (#6#
             (SEQ
              (LETT |s|
                    (SPADCALL (SPADCALL Q (QREFELT $ 25))
                              (PROG1
                                  (LETT #3#
                                        (- (SPADCALL P (QREFELT $ 26))
                                           (SPADCALL Q (QREFELT $ 26)))
                                        . #7#)
                                (|check-subtype| (>= #3# 0)
                                                 '(|NonNegativeInteger|) #3#))
                              (QREFELT $ 28))
                    . #7#)
              (LETT VP (VECTOR Q (|spadConstant| $ 24) (|spadConstant| $ 9))
                    . #7#)
              (LETT |pdiv|
                    (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                    . #7#)
              (LETT VQ
                    (VECTOR (QVELT |pdiv| 2)
                            (SPADCALL (QVELT |pdiv| 0) (QREFELT $ 13))
                            (QVELT |pdiv| 1))
                    . #7#)
              (EXIT
               (SEQ G190 NIL
                    (SEQ
                     (PROGN
                      (LETT |#G125| (SPADCALL VP 1 (QREFELT $ 54)) . #7#)
                      (LETT |#G126| (SPADCALL VQ 1 (QREFELT $ 54)) . #7#)
                      (LETT P |#G125| . #7#)
                      (LETT Q |#G126| . #7#))
                     (EXIT
                      (COND
                       ((SPADCALL Q (QREFELT $ 23))
                        (PROGN
                         (LETT #1#
                               (VECTOR (|spadConstant| $ 24)
                                       (|spadConstant| $ 24)
                                       (|spadConstant| $ 24))
                               . #7#)
                         (GO #1#)))
                       ('T
                        (SEQ
                         (PROGN
                          (LETT |#G127| (SPADCALL P (QREFELT $ 26)) . #7#)
                          (LETT |#G128| (SPADCALL Q (QREFELT $ 26)) . #7#)
                          (LETT |degP| |#G127| . #7#)
                          (LETT |degQ| |#G128| . #7#))
                         (EXIT
                          (COND
                           ((EQL |i| (- |degP| 1))
                            (PROGN
                             (LETT #1#
                                   (VECTOR (SPADCALL VQ 2 (QREFELT $ 54))
                                           (SPADCALL VQ 3 (QREFELT $ 54))
                                           (SPADCALL VQ 1 (QREFELT $ 54)))
                                   . #7#)
                             (GO #1#)))
                           ((< |degQ| |i|)
                            (PROGN
                             (LETT #1#
                                   (VECTOR (|spadConstant| $ 24)
                                           (|spadConstant| $ 24)
                                           (|spadConstant| $ 24))
                                   . #7#)
                             (GO #1#)))
                           ('T
                            (SEQ
                             (LETT VZ
                                   (|PRS;Lazard3| VQ
                                    (SPADCALL Q (QREFELT $ 25)) |s|
                                    (PROG1 (LETT #2# (- |degP| |degQ|) . #7#)
                                      (|check-subtype| (>= #2# 0)
                                                       '(|NonNegativeInteger|)
                                                       #2#))
                                    $)
                                   . #7#)
                             (EXIT
                              (COND
                               ((EQL |i| |degQ|)
                                (PROGN
                                 (LETT #1#
                                       (VECTOR (SPADCALL VZ 2 (QREFELT $ 54))
                                               (SPADCALL VZ 3 (QREFELT $ 54))
                                               (SPADCALL VZ 1 (QREFELT $ 54)))
                                       . #7#)
                                 (GO #1#)))
                               ('T
                                (SEQ
                                 (LETT |ss|
                                       (SPADCALL (SPADCALL VZ 1 (QREFELT $ 54))
                                                 (QREFELT $ 25))
                                       . #7#)
                                 (PROGN
                                  (LETT |#G129| VQ . #7#)
                                  (LETT |#G130|
                                        (|PRS;nextsousResultant3| VP VQ |s|
                                         |ss| $)
                                        . #7#)
                                  (LETT VP |#G129| . #7#)
                                  (LETT VQ |#G130| . #7#))
                                 (EXIT (LETT |s| |ss| . #7#)))))))))))))))
                    NIL (GO G190) G191 (EXIT NIL)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiIndiceSubResultantEuclidean;2polRNniR;22| (P Q |i| $)
  (PROG (|s| VQ VP |#G139| |#G138| |ss| #1=#:G1104 VZ #2=#:G1094 |degQ| |degP|
         |#G137| |#G136| |#G135| |#G134| |pdiv| #3=#:G1092 #4=#:G1087 |delta|
         #5=#:G1085)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (CONS (|spadConstant| $ 24) (|spadConstant| $ 24)))
        ('T
         (COND
          ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
           (|error| "semiIndiceSubResultantEuclidean$PRS : bad degrees"))
          (#6='T
           (SEQ
            (COND
             ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
              (SEQ
               (LETT |delta|
                     (PROG1
                         (LETT #5#
                               (- (SPADCALL P (QREFELT $ 26))
                                  (SPADCALL Q (QREFELT $ 26)))
                               . #7=(|PRS;semiIndiceSubResultantEuclidean;2polRNniR;22|))
                       (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|)
                                        #5#))
                     . #7#)
               (EXIT
                (COND
                 ((ZEROP |delta|)
                  (|error|
                   "semiIndiceSubResultantEuclidean$PRS : bad degrees"))
                 (#6#
                  (SEQ
                   (LETT |s|
                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                   (PROG1 (LETT #4# (- |delta| 1) . #7#)
                                     (|check-subtype| (>= #4# 0)
                                                      '(|NonNegativeInteger|)
                                                      #4#))
                                   (QREFELT $ 28))
                         . #7#)
                   (EXIT
                    (PROGN
                     (LETT #1#
                           (CONS (SPADCALL |s| (QREFELT $ 13))
                                 (SPADCALL |s| Q (QREFELT $ 30)))
                           . #7#)
                     (GO #1#))))))))))
            (EXIT
             (COND
              ((< (SPADCALL Q (QREFELT $ 26)) |i|)
               (CONS (|spadConstant| $ 24) (|spadConstant| $ 24)))
              (#6#
               (SEQ
                (LETT |s|
                      (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                (PROG1
                                    (LETT #3#
                                          (- (SPADCALL P (QREFELT $ 26))
                                             (SPADCALL Q (QREFELT $ 26)))
                                          . #7#)
                                  (|check-subtype| (>= #3# 0)
                                                   '(|NonNegativeInteger|)
                                                   #3#))
                                (QREFELT $ 28))
                      . #7#)
                (LETT VP (VECTOR Q (|spadConstant| $ 9)) . #7#)
                (LETT |pdiv|
                      (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                      . #7#)
                (LETT VQ (VECTOR (QVELT |pdiv| 2) (QVELT |pdiv| 1)) . #7#)
                (EXIT
                 (SEQ G190 NIL
                      (SEQ
                       (PROGN
                        (LETT |#G134| (SPADCALL VP 1 (QREFELT $ 54)) . #7#)
                        (LETT |#G135| (SPADCALL VQ 1 (QREFELT $ 54)) . #7#)
                        (LETT P |#G134| . #7#)
                        (LETT Q |#G135| . #7#))
                       (EXIT
                        (COND
                         ((SPADCALL Q (QREFELT $ 23))
                          (PROGN
                           (LETT #1#
                                 (CONS (|spadConstant| $ 24)
                                       (|spadConstant| $ 24))
                                 . #7#)
                           (GO #1#)))
                         ('T
                          (SEQ
                           (PROGN
                            (LETT |#G136| (SPADCALL P (QREFELT $ 26)) . #7#)
                            (LETT |#G137| (SPADCALL Q (QREFELT $ 26)) . #7#)
                            (LETT |degP| |#G136| . #7#)
                            (LETT |degQ| |#G137| . #7#))
                           (EXIT
                            (COND
                             ((EQL |i| (- |degP| 1))
                              (PROGN
                               (LETT #1#
                                     (CONS (SPADCALL VQ 2 (QREFELT $ 54))
                                           (SPADCALL VQ 1 (QREFELT $ 54)))
                                     . #7#)
                               (GO #1#)))
                             ((< |degQ| |i|)
                              (PROGN
                               (LETT #1#
                                     (CONS (|spadConstant| $ 24)
                                           (|spadConstant| $ 24))
                                     . #7#)
                               (GO #1#)))
                             ('T
                              (SEQ
                               (LETT VZ
                                     (|PRS;Lazard3| VQ
                                      (SPADCALL Q (QREFELT $ 25)) |s|
                                      (PROG1 (LETT #2# (- |degP| |degQ|) . #7#)
                                        (|check-subtype| (>= #2# 0)
                                                         '(|NonNegativeInteger|)
                                                         #2#))
                                      $)
                                     . #7#)
                               (EXIT
                                (COND
                                 ((EQL |i| |degQ|)
                                  (PROGN
                                   (LETT #1#
                                         (CONS (SPADCALL VZ 2 (QREFELT $ 54))
                                               (SPADCALL VZ 1 (QREFELT $ 54)))
                                         . #7#)
                                   (GO #1#)))
                                 ('T
                                  (SEQ
                                   (LETT |ss|
                                         (SPADCALL
                                          (SPADCALL VZ 1 (QREFELT $ 54))
                                          (QREFELT $ 25))
                                         . #7#)
                                   (PROGN
                                    (LETT |#G138| VQ . #7#)
                                    (LETT |#G139|
                                          (|PRS;nextsousResultant3| VP VQ |s|
                                           |ss| $)
                                          . #7#)
                                    (LETT VP |#G138| . #7#)
                                    (LETT VQ |#G139| . #7#))
                                   (EXIT (LETT |s| |ss| . #7#)))))))))))))))
                      NIL (GO G190) G191 (EXIT NIL)))))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;degreeSubResultant;2polRNnipolR;23| (P Q |i| $)
  (PROG (|s| |#G152| |#G151| Z #1=#:G1118 #2=#:G1124 |#G150| |#G149| #3=#:G1115
         #4=#:G1110 |delta| #5=#:G1108 |#G148| |#G147|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (|spadConstant| $ 24))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (PROGN
             (LETT |#G147| Q . #6=(|PRS;degreeSubResultant;2polRNnipolR;23|))
             (LETT |#G148| P . #6#)
             (LETT P |#G147| . #6#)
             (LETT Q |#G148| . #6#))))
          (COND
           ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |delta|
                   (PROG1
                       (LETT #5#
                             (- (SPADCALL P (QREFELT $ 26))
                                (SPADCALL Q (QREFELT $ 26)))
                             . #6#)
                     (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|) #5#))
                   . #6#)
             (EXIT
              (COND
               ((ZEROP |delta|)
                (|error| "degreeSubResultant$PRS : bad degrees"))
               (#7='T
                (SEQ
                 (LETT |s|
                       (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                 (PROG1 (LETT #4# (- |delta| 1) . #6#)
                                   (|check-subtype| (>= #4# 0)
                                                    '(|NonNegativeInteger|)
                                                    #4#))
                                 (QREFELT $ 28))
                       . #6#)
                 (EXIT
                  (PROGN
                   (LETT #2# (SPADCALL |s| Q (QREFELT $ 30)) . #6#)
                   (GO #2#))))))))))
          (EXIT
           (COND ((< (SPADCALL Q (QREFELT $ 26)) |i|) (|spadConstant| $ 24))
                 (#7#
                  (SEQ
                   (LETT |s|
                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                   (PROG1
                                       (LETT #3#
                                             (- (SPADCALL P (QREFELT $ 26))
                                                (SPADCALL Q (QREFELT $ 26)))
                                             . #6#)
                                     (|check-subtype| (>= #3# 0)
                                                      '(|NonNegativeInteger|)
                                                      #3#))
                                   (QREFELT $ 28))
                         . #6#)
                   (PROGN
                    (LETT |#G149| Q . #6#)
                    (LETT |#G150|
                          (SPADCALL P (SPADCALL Q (QREFELT $ 50))
                                    (QREFELT $ 59))
                          . #6#)
                    (LETT P |#G149| . #6#)
                    (LETT Q |#G150| . #6#))
                   (EXIT
                    (SEQ G190 NIL
                         (SEQ
                          (EXIT
                           (COND
                            ((OR (SPADCALL Q (QREFELT $ 23))
                                 (< (SPADCALL Q (QREFELT $ 26)) |i|))
                             (PROGN
                              (LETT #2# (|spadConstant| $ 24) . #6#)
                              (GO #2#)))
                            ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
                             (PROGN (LETT #2# Q . #6#) (GO #2#)))
                            ('T
                             (SEQ
                              (LETT Z
                                    (SPADCALL Q (SPADCALL Q (QREFELT $ 25)) |s|
                                              (PROG1
                                                  (LETT #1#
                                                        (-
                                                         (SPADCALL P
                                                                   (QREFELT $
                                                                            26))
                                                         (SPADCALL Q
                                                                   (QREFELT $
                                                                            26)))
                                                        . #6#)
                                                (|check-subtype| (>= #1# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #1#))
                                              (QREFELT $ 49))
                                    . #6#)
                              (PROGN
                               (LETT |#G151| Q . #6#)
                               (LETT |#G152|
                                     (SPADCALL P Q Z |s| (QREFELT $ 52)) . #6#)
                               (LETT P |#G151| . #6#)
                               (LETT Q |#G152| . #6#))
                              (EXIT
                               (LETT |s| (SPADCALL Z (QREFELT $ 25))
                                     . #6#)))))))
                         NIL (GO G190) G191 (EXIT NIL)))))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;degreeSubResultantEuclidean;2polRNniR;24| (P Q |i| $)
  (PROG (|s| VQ VP |#G162| |#G161| |ss| #1=#:G1141 #2=#:G1147 |#G160| |#G159|
         |pdiv| #3=#:G1137 #4=#:G1132 |delta| #5=#:G1130 |l|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                 (|spadConstant| $ 24)))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |l| (SPADCALL Q P |i| (QREFELT $ 72))
                   . #6=(|PRS;degreeSubResultantEuclidean;2polRNniR;24|))
             (EXIT
              (PROGN
               (LETT #2# (VECTOR (QVELT |l| 1) (QVELT |l| 0) (QVELT |l| 2))
                     . #6#)
               (GO #2#))))))
          (COND
           ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |delta|
                   (PROG1
                       (LETT #5#
                             (- (SPADCALL P (QREFELT $ 26))
                                (SPADCALL Q (QREFELT $ 26)))
                             . #6#)
                     (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|) #5#))
                   . #6#)
             (EXIT
              (COND
               ((ZEROP |delta|)
                (|error| "degreeSubResultantEuclidean$PRS : bad degrees"))
               (#7='T
                (SEQ
                 (LETT |s|
                       (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                 (PROG1 (LETT #4# (- |delta| 1) . #6#)
                                   (|check-subtype| (>= #4# 0)
                                                    '(|NonNegativeInteger|)
                                                    #4#))
                                 (QREFELT $ 28))
                       . #6#)
                 (EXIT
                  (PROGN
                   (LETT #2#
                         (VECTOR (|spadConstant| $ 24)
                                 (SPADCALL |s| (QREFELT $ 13))
                                 (SPADCALL |s| Q (QREFELT $ 30)))
                         . #6#)
                   (GO #2#))))))))))
          (EXIT
           (COND
            ((< (SPADCALL Q (QREFELT $ 26)) |i|)
             (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                     (|spadConstant| $ 24)))
            (#7#
             (SEQ
              (LETT |s|
                    (SPADCALL (SPADCALL Q (QREFELT $ 25))
                              (PROG1
                                  (LETT #3#
                                        (- (SPADCALL P (QREFELT $ 26))
                                           (SPADCALL Q (QREFELT $ 26)))
                                        . #6#)
                                (|check-subtype| (>= #3# 0)
                                                 '(|NonNegativeInteger|) #3#))
                              (QREFELT $ 28))
                    . #6#)
              (LETT VP (VECTOR Q (|spadConstant| $ 24) (|spadConstant| $ 9))
                    . #6#)
              (LETT |pdiv|
                    (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                    . #6#)
              (LETT VQ
                    (VECTOR (QVELT |pdiv| 2)
                            (SPADCALL (QVELT |pdiv| 0) (QREFELT $ 13))
                            (QVELT |pdiv| 1))
                    . #6#)
              (EXIT
               (SEQ G190 NIL
                    (SEQ
                     (PROGN
                      (LETT |#G159| (SPADCALL VP 1 (QREFELT $ 54)) . #6#)
                      (LETT |#G160| (SPADCALL VQ 1 (QREFELT $ 54)) . #6#)
                      (LETT P |#G159| . #6#)
                      (LETT Q |#G160| . #6#))
                     (COND
                      ((OR (SPADCALL Q (QREFELT $ 23))
                           (< (SPADCALL Q (QREFELT $ 26)) |i|))
                       (EXIT
                        (PROGN
                         (LETT #2#
                               (VECTOR (|spadConstant| $ 24)
                                       (|spadConstant| $ 24)
                                       (|spadConstant| $ 24))
                               . #6#)
                         (GO #2#)))))
                     (EXIT
                      (COND
                       ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
                        (PROGN
                         (LETT #2#
                               (VECTOR (SPADCALL VQ 2 (QREFELT $ 54))
                                       (SPADCALL VQ 3 (QREFELT $ 54))
                                       (SPADCALL VQ 1 (QREFELT $ 54)))
                               . #6#)
                         (GO #2#)))
                       ('T
                        (SEQ
                         (LETT |ss|
                               (SPADCALL (SPADCALL Q (QREFELT $ 25)) |s|
                                         (PROG1
                                             (LETT #1#
                                                   (-
                                                    (SPADCALL P (QREFELT $ 26))
                                                    (SPADCALL Q
                                                              (QREFELT $ 26)))
                                                   . #6#)
                                           (|check-subtype| (>= #1# 0)
                                                            '(|NonNegativeInteger|)
                                                            #1#))
                                         (QREFELT $ 48))
                               . #6#)
                         (PROGN
                          (LETT |#G161| VQ . #6#)
                          (LETT |#G162|
                                (|PRS;nextsousResultant3| VP VQ |s| |ss| $)
                                . #6#)
                          (LETT VP |#G161| . #6#)
                          (LETT VQ |#G162| . #6#))
                         (EXIT (LETT |s| |ss| . #6#)))))))
                    NIL (GO G190) G191 (EXIT NIL)))))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;semiDegreeSubResultantEuclidean;2polRNniR;25| (P Q |i| $)
  (PROG (|s| VQ VP |#G169| |#G168| |ss| #1=#:G1162 #2=#:G1169 |#G167| |#G166|
         |pdiv| #3=#:G1158 #4=#:G1153 |delta| #5=#:G1151)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (CONS (|spadConstant| $ 24) (|spadConstant| $ 24)))
        ('T
         (COND
          ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
           (|error| "semiDegreeSubResultantEuclidean$PRS : bad degrees"))
          (#6='T
           (SEQ
            (COND
             ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
              (SEQ
               (LETT |delta|
                     (PROG1
                         (LETT #5#
                               (- (SPADCALL P (QREFELT $ 26))
                                  (SPADCALL Q (QREFELT $ 26)))
                               . #7=(|PRS;semiDegreeSubResultantEuclidean;2polRNniR;25|))
                       (|check-subtype| (>= #5# 0) '(|NonNegativeInteger|)
                                        #5#))
                     . #7#)
               (EXIT
                (COND
                 ((ZEROP |delta|)
                  (|error|
                   "semiDegreeSubResultantEuclidean$PRS : bad degrees"))
                 (#6#
                  (SEQ
                   (LETT |s|
                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                   (PROG1 (LETT #4# (- |delta| 1) . #7#)
                                     (|check-subtype| (>= #4# 0)
                                                      '(|NonNegativeInteger|)
                                                      #4#))
                                   (QREFELT $ 28))
                         . #7#)
                   (EXIT
                    (PROGN
                     (LETT #2#
                           (CONS (SPADCALL |s| (QREFELT $ 13))
                                 (SPADCALL |s| Q (QREFELT $ 30)))
                           . #7#)
                     (GO #2#))))))))))
            (EXIT
             (COND
              ((< (SPADCALL Q (QREFELT $ 26)) |i|)
               (CONS (|spadConstant| $ 24) (|spadConstant| $ 24)))
              (#6#
               (SEQ
                (LETT |s|
                      (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                (PROG1
                                    (LETT #3#
                                          (- (SPADCALL P (QREFELT $ 26))
                                             (SPADCALL Q (QREFELT $ 26)))
                                          . #7#)
                                  (|check-subtype| (>= #3# 0)
                                                   '(|NonNegativeInteger|)
                                                   #3#))
                                (QREFELT $ 28))
                      . #7#)
                (LETT VP (VECTOR Q (|spadConstant| $ 9)) . #7#)
                (LETT |pdiv|
                      (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                      . #7#)
                (LETT VQ (VECTOR (QVELT |pdiv| 2) (QVELT |pdiv| 1)) . #7#)
                (EXIT
                 (SEQ G190 NIL
                      (SEQ
                       (PROGN
                        (LETT |#G166| (SPADCALL VP 1 (QREFELT $ 54)) . #7#)
                        (LETT |#G167| (SPADCALL VQ 1 (QREFELT $ 54)) . #7#)
                        (LETT P |#G166| . #7#)
                        (LETT Q |#G167| . #7#))
                       (COND
                        ((OR (SPADCALL Q (QREFELT $ 23))
                             (< (SPADCALL Q (QREFELT $ 26)) |i|))
                         (EXIT
                          (PROGN
                           (LETT #2#
                                 (CONS (|spadConstant| $ 24)
                                       (|spadConstant| $ 24))
                                 . #7#)
                           (GO #2#)))))
                       (EXIT
                        (COND
                         ((EQL |i| (SPADCALL Q (QREFELT $ 26)))
                          (PROGN
                           (LETT #2#
                                 (CONS (SPADCALL VQ 2 (QREFELT $ 54))
                                       (SPADCALL VQ 1 (QREFELT $ 54)))
                                 . #7#)
                           (GO #2#)))
                         ('T
                          (SEQ
                           (LETT |ss|
                                 (SPADCALL (SPADCALL Q (QREFELT $ 25)) |s|
                                           (PROG1
                                               (LETT #1#
                                                     (-
                                                      (SPADCALL P
                                                                (QREFELT $ 26))
                                                      (SPADCALL Q
                                                                (QREFELT $
                                                                         26)))
                                                     . #7#)
                                             (|check-subtype| (>= #1# 0)
                                                              '(|NonNegativeInteger|)
                                                              #1#))
                                           (QREFELT $ 48))
                                 . #7#)
                           (PROGN
                            (LETT |#G168| VQ . #7#)
                            (LETT |#G169|
                                  (|PRS;nextsousResultant3| VP VQ |s| |ss| $)
                                  . #7#)
                            (LETT VP |#G168| . #7#)
                            (LETT VQ |#G169| . #7#))
                           (EXIT (LETT |s| |ss| . #7#)))))))
                      NIL (GO G190) G191 (EXIT NIL)))))))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;lastSubResultant;3polR;26| (P Q $)
  (PROG (|s| |#G180| |#G179| #1=#:G1182 Z #2=#:G1175 |#G178| |#G177| #3=#:G1174
         |#G176| |#G175|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (|spadConstant| $ 24))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (PROGN
             (LETT |#G175| Q . #4=(|PRS;lastSubResultant;3polR;26|))
             (LETT |#G176| P . #4#)
             (LETT P |#G175| . #4#)
             (LETT Q |#G176| . #4#))))
          (EXIT
           (COND
            ((ZEROP (SPADCALL Q (QREFELT $ 26)))
             (SPADCALL
              (SPADCALL (SPADCALL Q (QREFELT $ 25)) (SPADCALL P (QREFELT $ 26))
                        (QREFELT $ 28))
              (QREFELT $ 13)))
            ('T
             (SEQ
              (LETT |s|
                    (SPADCALL (SPADCALL Q (QREFELT $ 25))
                              (PROG1
                                  (LETT #3#
                                        (- (SPADCALL P (QREFELT $ 26))
                                           (SPADCALL Q (QREFELT $ 26)))
                                        . #4#)
                                (|check-subtype| (>= #3# 0)
                                                 '(|NonNegativeInteger|) #3#))
                              (QREFELT $ 28))
                    . #4#)
              (PROGN
               (LETT |#G177| Q . #4#)
               (LETT |#G178|
                     (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 59))
                     . #4#)
               (LETT P |#G177| . #4#)
               (LETT Q |#G178| . #4#))
              (LETT Z P . #4#)
              (EXIT
               (SEQ G190 NIL
                    (SEQ
                     (EXIT
                      (COND
                       ((SPADCALL Q (QREFELT $ 23))
                        (PROGN (LETT #1# Z . #4#) (GO #1#)))
                       ('T
                        (SEQ
                         (LETT Z
                               (SPADCALL Q (SPADCALL Q (QREFELT $ 25)) |s|
                                         (PROG1
                                             (LETT #2#
                                                   (-
                                                    (SPADCALL P (QREFELT $ 26))
                                                    (SPADCALL Q
                                                              (QREFELT $ 26)))
                                                   . #4#)
                                           (|check-subtype| (>= #2# 0)
                                                            '(|NonNegativeInteger|)
                                                            #2#))
                                         (QREFELT $ 49))
                               . #4#)
                         (EXIT
                          (COND
                           ((ZEROP (SPADCALL Z (QREFELT $ 26)))
                            (PROGN (LETT #1# Z . #4#) (GO #1#)))
                           ('T
                            (SEQ
                             (PROGN
                              (LETT |#G179| Q . #4#)
                              (LETT |#G180| (SPADCALL P Q Z |s| (QREFELT $ 52))
                                    . #4#)
                              (LETT P |#G179| . #4#)
                              (LETT Q |#G180| . #4#))
                             (EXIT
                              (LETT |s| (SPADCALL Z (QREFELT $ 25))
                                    . #4#)))))))))))
                    NIL (GO G190) G191 (EXIT NIL)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;lastSubResultantEuclidean;2polRR;27| (P Q $)
  (PROG (|s| VQ VP |#G186| |#G185| |ss| #1=#:G1202 VZ #2=#:G1196 Z |#G184|
         |#G183| |pdiv| #3=#:G1194 #4=#:G1189 |degP| |l|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                 (|spadConstant| $ 24)))
        ('T
         (SEQ
          (COND
           ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
            (SEQ
             (LETT |l| (SPADCALL Q P (QREFELT $ 75))
                   . #5=(|PRS;lastSubResultantEuclidean;2polRR;27|))
             (EXIT
              (PROGN
               (LETT #1# (VECTOR (QVELT |l| 1) (QVELT |l| 0) (QVELT |l| 2))
                     . #5#)
               (GO #1#))))))
          (COND
           ((ZEROP (SPADCALL Q (QREFELT $ 26)))
            (SEQ (LETT |degP| (SPADCALL P (QREFELT $ 26)) . #5#)
                 (EXIT
                  (COND
                   ((ZEROP |degP|)
                    (|error|
                     "lastSubResultantEuclidean$PRS : constant polynomials"))
                   ('T
                    (SEQ
                     (LETT |s|
                           (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                     (PROG1 (LETT #4# (- |degP| 1) . #5#)
                                       (|check-subtype| (>= #4# 0)
                                                        '(|NonNegativeInteger|)
                                                        #4#))
                                     (QREFELT $ 28))
                           . #5#)
                     (EXIT
                      (PROGN
                       (LETT #1#
                             (VECTOR (|spadConstant| $ 24)
                                     (SPADCALL |s| (QREFELT $ 13))
                                     (SPADCALL |s| Q (QREFELT $ 30)))
                             . #5#)
                       (GO #1#))))))))))
          (LETT |s|
                (SPADCALL (SPADCALL Q (QREFELT $ 25))
                          (PROG1
                              (LETT #3#
                                    (- (SPADCALL P (QREFELT $ 26))
                                       (SPADCALL Q (QREFELT $ 26)))
                                    . #5#)
                            (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                                             #3#))
                          (QREFELT $ 28))
                . #5#)
          (LETT VP (VECTOR Q (|spadConstant| $ 24) (|spadConstant| $ 9)) . #5#)
          (LETT |pdiv| (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                . #5#)
          (LETT VQ
                (VECTOR (QVELT |pdiv| 2)
                        (SPADCALL (QVELT |pdiv| 0) (QREFELT $ 13))
                        (QVELT |pdiv| 1))
                . #5#)
          (LETT VZ (SPADCALL VP (QREFELT $ 76)) . #5#)
          (EXIT
           (SEQ G190 NIL
                (SEQ
                 (PROGN
                  (LETT |#G183| (SPADCALL VQ 1 (QREFELT $ 54)) . #5#)
                  (LETT |#G184| (SPADCALL VZ 1 (QREFELT $ 54)) . #5#)
                  (LETT Q |#G183| . #5#)
                  (LETT Z |#G184| . #5#))
                 (EXIT
                  (COND
                   ((SPADCALL Q (QREFELT $ 23))
                    (PROGN
                     (LETT #1#
                           (VECTOR (SPADCALL VZ 2 (QREFELT $ 54))
                                   (SPADCALL VZ 3 (QREFELT $ 54))
                                   (SPADCALL VZ 1 (QREFELT $ 54)))
                           . #5#)
                     (GO #1#)))
                   ('T
                    (SEQ
                     (LETT VZ
                           (|PRS;Lazard3| VQ (SPADCALL Q (QREFELT $ 25)) |s|
                            (PROG1
                                (LETT #2#
                                      (- (SPADCALL Z (QREFELT $ 26))
                                         (SPADCALL Q (QREFELT $ 26)))
                                      . #5#)
                              (|check-subtype| (>= #2# 0)
                                               '(|NonNegativeInteger|) #2#))
                            $)
                           . #5#)
                     (EXIT
                      (COND
                       ((ZEROP (SPADCALL Q (QREFELT $ 26)))
                        (PROGN
                         (LETT #1#
                               (VECTOR (SPADCALL VZ 2 (QREFELT $ 54))
                                       (SPADCALL VZ 3 (QREFELT $ 54))
                                       (SPADCALL VZ 1 (QREFELT $ 54)))
                               . #5#)
                         (GO #1#)))
                       ('T
                        (SEQ
                         (LETT |ss|
                               (SPADCALL (SPADCALL VZ 1 (QREFELT $ 54))
                                         (QREFELT $ 25))
                               . #5#)
                         (PROGN
                          (LETT |#G185| VQ . #5#)
                          (LETT |#G186|
                                (|PRS;nextsousResultant3| VP VQ |s| |ss| $)
                                . #5#)
                          (LETT VP |#G185| . #5#)
                          (LETT VQ |#G186| . #5#))
                         (EXIT (LETT |s| |ss| . #5#)))))))))))
                NIL (GO G190) G191 (EXIT NIL)))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiLastSubResultantEuclidean;2polRR;28| (P Q $)
  (PROG (|s| VQ VP |#G192| |#G191| |ss| #1=#:G1221 VZ #2=#:G1214 Z |#G190|
         |#G189| |pdiv| #3=#:G1212 #4=#:G1207 |degP|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23)))
         (CONS (|spadConstant| $ 24) (|spadConstant| $ 24)))
        ('T
         (COND
          ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
           (|error| "semiLastSubResultantEuclidean$PRS : bad degrees"))
          (#5='T
           (SEQ
            (COND
             ((ZEROP (SPADCALL Q (QREFELT $ 26)))
              (SEQ
               (LETT |degP| (SPADCALL P (QREFELT $ 26))
                     . #6=(|PRS;semiLastSubResultantEuclidean;2polRR;28|))
               (EXIT
                (COND
                 ((ZEROP |degP|)
                  (|error|
                   "semiLastSubResultantEuclidean$PRS : constant polynomials"))
                 (#5#
                  (SEQ
                   (LETT |s|
                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                   (PROG1 (LETT #4# (- |degP| 1) . #6#)
                                     (|check-subtype| (>= #4# 0)
                                                      '(|NonNegativeInteger|)
                                                      #4#))
                                   (QREFELT $ 28))
                         . #6#)
                   (EXIT
                    (PROGN
                     (LETT #1#
                           (CONS (SPADCALL |s| (QREFELT $ 13))
                                 (SPADCALL |s| Q (QREFELT $ 30)))
                           . #6#)
                     (GO #1#))))))))))
            (LETT |s|
                  (SPADCALL (SPADCALL Q (QREFELT $ 25))
                            (PROG1
                                (LETT #3#
                                      (- (SPADCALL P (QREFELT $ 26))
                                         (SPADCALL Q (QREFELT $ 26)))
                                      . #6#)
                              (|check-subtype| (>= #3# 0)
                                               '(|NonNegativeInteger|) #3#))
                            (QREFELT $ 28))
                  . #6#)
            (LETT VP (VECTOR Q (|spadConstant| $ 9)) . #6#)
            (LETT |pdiv|
                  (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                  . #6#)
            (LETT VQ (VECTOR (QVELT |pdiv| 2) (QVELT |pdiv| 1)) . #6#)
            (LETT VZ (SPADCALL VP (QREFELT $ 76)) . #6#)
            (EXIT
             (SEQ G190 NIL
                  (SEQ
                   (PROGN
                    (LETT |#G189| (SPADCALL VQ 1 (QREFELT $ 54)) . #6#)
                    (LETT |#G190| (SPADCALL VZ 1 (QREFELT $ 54)) . #6#)
                    (LETT Q |#G189| . #6#)
                    (LETT Z |#G190| . #6#))
                   (EXIT
                    (COND
                     ((SPADCALL Q (QREFELT $ 23))
                      (PROGN
                       (LETT #1#
                             (CONS (SPADCALL VZ 2 (QREFELT $ 54))
                                   (SPADCALL VZ 1 (QREFELT $ 54)))
                             . #6#)
                       (GO #1#)))
                     ('T
                      (SEQ
                       (LETT VZ
                             (|PRS;Lazard3| VQ (SPADCALL Q (QREFELT $ 25)) |s|
                              (PROG1
                                  (LETT #2#
                                        (- (SPADCALL Z (QREFELT $ 26))
                                           (SPADCALL Q (QREFELT $ 26)))
                                        . #6#)
                                (|check-subtype| (>= #2# 0)
                                                 '(|NonNegativeInteger|) #2#))
                              $)
                             . #6#)
                       (EXIT
                        (COND
                         ((ZEROP (SPADCALL Q (QREFELT $ 26)))
                          (PROGN
                           (LETT #1#
                                 (CONS (SPADCALL VZ 2 (QREFELT $ 54))
                                       (SPADCALL VZ 1 (QREFELT $ 54)))
                                 . #6#)
                           (GO #1#)))
                         ('T
                          (SEQ
                           (LETT |ss|
                                 (SPADCALL (SPADCALL VZ 1 (QREFELT $ 54))
                                           (QREFELT $ 25))
                                 . #6#)
                           (PROGN
                            (LETT |#G191| VQ . #6#)
                            (LETT |#G192|
                                  (|PRS;nextsousResultant3| VP VQ |s| |ss| $)
                                  . #6#)
                            (LETT VP |#G191| . #6#)
                            (LETT VQ |#G192| . #6#))
                           (EXIT (LETT |s| |ss| . #6#)))))))))))
                  NIL (GO G190) G191 (EXIT NIL)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;chainSubResultants;2polRL;29| (P Q $)
  (PROG (|s| |#G202| |#G201| #1=#:G1236 L Z |delta| #2=#:G1229 |#G200| |#G199|
         #3=#:G1228 |#G198| |#G197|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23))) NIL)
             ('T
              (SEQ
               (COND
                ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
                 (SEQ
                  (PROGN
                   (LETT |#G197| Q . #4=(|PRS;chainSubResultants;2polRL;29|))
                   (LETT |#G198| P . #4#)
                   (LETT P |#G197| . #4#)
                   (LETT Q |#G198| . #4#))
                  (EXIT
                   (COND
                    ((ODDP (SPADCALL P (QREFELT $ 26)))
                     (COND
                      ((ODDP (SPADCALL Q (QREFELT $ 26)))
                       (LETT Q (SPADCALL Q (QREFELT $ 50)) . #4#)))))))))
               (LETT L NIL . #4#)
               (EXIT
                (COND ((ZEROP (SPADCALL Q (QREFELT $ 26))) L)
                      ('T
                       (SEQ (LETT L (LIST Q) . #4#)
                            (LETT |s|
                                  (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                            (PROG1
                                                (LETT #3#
                                                      (-
                                                       (SPADCALL P
                                                                 (QREFELT $
                                                                          26))
                                                       (SPADCALL Q
                                                                 (QREFELT $
                                                                          26)))
                                                      . #4#)
                                              (|check-subtype| (>= #3# 0)
                                                               '(|NonNegativeInteger|)
                                                               #3#))
                                            (QREFELT $ 28))
                                  . #4#)
                            (PROGN
                             (LETT |#G199| Q . #4#)
                             (LETT |#G200|
                                   (SPADCALL P (SPADCALL Q (QREFELT $ 50))
                                             (QREFELT $ 59))
                                   . #4#)
                             (LETT P |#G199| . #4#)
                             (LETT Q |#G200| . #4#))
                            (EXIT
                             (SEQ G190 NIL
                                  (SEQ
                                   (EXIT
                                    (COND
                                     ((SPADCALL Q (QREFELT $ 23))
                                      (PROGN (LETT #1# L . #4#) (GO #1#)))
                                     ('T
                                      (SEQ (LETT L (CONS Q L) . #4#)
                                           (LETT |delta|
                                                 (PROG1
                                                     (LETT #2#
                                                           (-
                                                            (SPADCALL P
                                                                      (QREFELT
                                                                       $ 26))
                                                            (SPADCALL Q
                                                                      (QREFELT
                                                                       $ 26)))
                                                           . #4#)
                                                   (|check-subtype| (>= #2# 0)
                                                                    '(|NonNegativeInteger|)
                                                                    #2#))
                                                 . #4#)
                                           (LETT Z
                                                 (SPADCALL Q
                                                           (SPADCALL Q
                                                                     (QREFELT $
                                                                              25))
                                                           |s| |delta|
                                                           (QREFELT $ 49))
                                                 . #4#)
                                           (COND
                                            ((< 1 |delta|)
                                             (LETT L (CONS Z L) . #4#)))
                                           (EXIT
                                            (COND
                                             ((ZEROP
                                               (SPADCALL Z (QREFELT $ 26)))
                                              (PROGN
                                               (LETT #1# L . #4#)
                                               (GO #1#)))
                                             ('T
                                              (SEQ
                                               (PROGN
                                                (LETT |#G201| Q . #4#)
                                                (LETT |#G202|
                                                      (SPADCALL P Q Z |s|
                                                                (QREFELT $ 52))
                                                      . #4#)
                                                (LETT P |#G201| . #4#)
                                                (LETT Q |#G202| . #4#))
                                               (EXIT
                                                (LETT |s|
                                                      (SPADCALL Z
                                                                (QREFELT $ 25))
                                                      . #4#)))))))))))
                                  NIL (GO G190) G191 (EXIT NIL)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;schema;2polRL;30| (P Q $)
  (PROG (|s| |#G210| |#G209| #1=#:G1249 L Z |delta| #2=#:G1242 |e| |#G208|
         |#G207| #3=#:G1241 |#G206| |#G205|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((OR (SPADCALL Q (QREFELT $ 23)) (SPADCALL P (QREFELT $ 23))) NIL)
             ('T
              (SEQ
               (COND
                ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
                 (PROGN
                  (LETT |#G205| Q . #4=(|PRS;schema;2polRL;30|))
                  (LETT |#G206| P . #4#)
                  (LETT P |#G205| . #4#)
                  (LETT Q |#G206| . #4#))))
               (EXIT
                (COND ((ZEROP (SPADCALL Q (QREFELT $ 26))) (LIST 0))
                      ('T
                       (SEQ (LETT L NIL . #4#)
                            (LETT |s|
                                  (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                            (PROG1
                                                (LETT #3#
                                                      (-
                                                       (SPADCALL P
                                                                 (QREFELT $
                                                                          26))
                                                       (SPADCALL Q
                                                                 (QREFELT $
                                                                          26)))
                                                      . #4#)
                                              (|check-subtype| (>= #3# 0)
                                                               '(|NonNegativeInteger|)
                                                               #3#))
                                            (QREFELT $ 28))
                                  . #4#)
                            (PROGN
                             (LETT |#G207| Q . #4#)
                             (LETT |#G208| (SPADCALL P Q (QREFELT $ 59)) . #4#)
                             (LETT P |#G207| . #4#)
                             (LETT Q |#G208| . #4#))
                            (EXIT
                             (SEQ G190 NIL
                                  (SEQ
                                   (EXIT
                                    (COND
                                     ((SPADCALL Q (QREFELT $ 23))
                                      (PROGN (LETT #1# L . #4#) (GO #1#)))
                                     ('T
                                      (SEQ
                                       (LETT |e| (SPADCALL Q (QREFELT $ 26))
                                             . #4#)
                                       (LETT L (CONS |e| L) . #4#)
                                       (LETT |delta|
                                             (PROG1
                                                 (LETT #2#
                                                       (-
                                                        (SPADCALL P
                                                                  (QREFELT $
                                                                           26))
                                                        |e|)
                                                       . #4#)
                                               (|check-subtype| (>= #2# 0)
                                                                '(|NonNegativeInteger|)
                                                                #2#))
                                             . #4#)
                                       (LETT Z
                                             (SPADCALL Q
                                                       (SPADCALL Q
                                                                 (QREFELT $
                                                                          25))
                                                       |s| |delta|
                                                       (QREFELT $ 49))
                                             . #4#)
                                       (COND
                                        ((< 1 |delta|)
                                         (LETT L (CONS |e| L) . #4#)))
                                       (EXIT
                                        (COND
                                         ((ZEROP |e|)
                                          (PROGN (LETT #1# L . #4#) (GO #1#)))
                                         ('T
                                          (SEQ
                                           (PROGN
                                            (LETT |#G209| Q . #4#)
                                            (LETT |#G210|
                                                  (SPADCALL P Q Z |s|
                                                            (QREFELT $ 52))
                                                  . #4#)
                                            (LETT P |#G209| . #4#)
                                            (LETT Q |#G210| . #4#))
                                           (EXIT
                                            (LETT |s|
                                                  (SPADCALL Z (QREFELT $ 25))
                                                  . #4#)))))))))))
                                  NIL (GO G190) G191 (EXIT NIL)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;subResultantGcd;3polR;31| (P Q $)
  (PROG (|s| |#G218| |#G217| Z #1=#:G1255 #2=#:G1264 |#G216| |#G215| #3=#:G1254
         |#G214| |#G213|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL P (QREFELT $ 23))
          (COND ((SPADCALL Q (QREFELT $ 23)) (EXIT (|spadConstant| $ 24))))))
        (EXIT
         (COND ((SPADCALL P (QREFELT $ 23)) Q) ((SPADCALL Q (QREFELT $ 23)) P)
               (#4='T
                (SEQ
                 (COND
                  ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
                   (PROGN
                    (LETT |#G213| Q . #5=(|PRS;subResultantGcd;3polR;31|))
                    (LETT |#G214| P . #5#)
                    (LETT P |#G213| . #5#)
                    (LETT Q |#G214| . #5#))))
                 (EXIT
                  (COND
                   ((ZEROP (SPADCALL Q (QREFELT $ 26))) (|spadConstant| $ 9))
                   (#4#
                    (SEQ
                     (LETT |s|
                           (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                     (PROG1
                                         (LETT #3#
                                               (- (SPADCALL P (QREFELT $ 26))
                                                  (SPADCALL Q (QREFELT $ 26)))
                                               . #5#)
                                       (|check-subtype| (>= #3# 0)
                                                        '(|NonNegativeInteger|)
                                                        #3#))
                                     (QREFELT $ 28))
                           . #5#)
                     (PROGN
                      (LETT |#G215| Q . #5#)
                      (LETT |#G216|
                            (SPADCALL P (SPADCALL Q (QREFELT $ 50))
                                      (QREFELT $ 59))
                            . #5#)
                      (LETT P |#G215| . #5#)
                      (LETT Q |#G216| . #5#))
                     (EXIT
                      (SEQ G190 NIL
                           (SEQ
                            (EXIT
                             (COND
                              ((SPADCALL Q (QREFELT $ 23))
                               (PROGN (LETT #2# P . #5#) (GO #2#)))
                              ((ZEROP (SPADCALL Q (QREFELT $ 26)))
                               (PROGN
                                (LETT #2# (|spadConstant| $ 9) . #5#)
                                (GO #2#)))
                              ('T
                               (SEQ
                                (LETT Z
                                      (SPADCALL Q (SPADCALL Q (QREFELT $ 25))
                                                |s|
                                                (PROG1
                                                    (LETT #1#
                                                          (-
                                                           (SPADCALL P
                                                                     (QREFELT $
                                                                              26))
                                                           (SPADCALL Q
                                                                     (QREFELT $
                                                                              26)))
                                                          . #5#)
                                                  (|check-subtype| (>= #1# 0)
                                                                   '(|NonNegativeInteger|)
                                                                   #1#))
                                                (QREFELT $ 49))
                                      . #5#)
                                (PROGN
                                 (LETT |#G217| Q . #5#)
                                 (LETT |#G218|
                                       (SPADCALL P Q Z |s| (QREFELT $ 52))
                                       . #5#)
                                 (LETT P |#G217| . #5#)
                                 (LETT Q |#G218| . #5#))
                                (EXIT
                                 (LETT |s| (SPADCALL Z (QREFELT $ 25))
                                       . #5#)))))))
                           NIL (GO G190) G191 (EXIT NIL)))))))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;subResultantGcdEuclidean;2polRR;32| (P Q $)
  (PROG (|s| VQ VP |#G224| |#G223| |ss| #1=#:G1274 #2=#:G1283 |e| |#G222|
         |#G221| |pdiv| #3=#:G1272 |l|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL P (QREFELT $ 23))
          (COND
           ((SPADCALL Q (QREFELT $ 23))
            (EXIT
             (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                     (|spadConstant| $ 24)))))))
        (EXIT
         (COND
          ((SPADCALL P (QREFELT $ 23))
           (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 9) Q))
          ((SPADCALL Q (QREFELT $ 23))
           (VECTOR (|spadConstant| $ 9) (|spadConstant| $ 24) P))
          (#4='T
           (SEQ
            (COND
             ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
              (SEQ
               (LETT |l| (SPADCALL Q P (QREFELT $ 84))
                     . #5=(|PRS;subResultantGcdEuclidean;2polRR;32|))
               (EXIT
                (PROGN
                 (LETT #2# (VECTOR (QVELT |l| 1) (QVELT |l| 0) (QVELT |l| 2))
                       . #5#)
                 (GO #2#))))))
            (EXIT
             (COND
              ((ZEROP (SPADCALL Q (QREFELT $ 26)))
               (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 9) Q))
              (#4#
               (SEQ
                (LETT |s|
                      (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                (PROG1
                                    (LETT #3#
                                          (- (SPADCALL P (QREFELT $ 26))
                                             (SPADCALL Q (QREFELT $ 26)))
                                          . #5#)
                                  (|check-subtype| (>= #3# 0)
                                                   '(|NonNegativeInteger|)
                                                   #3#))
                                (QREFELT $ 28))
                      . #5#)
                (LETT VP (VECTOR Q (|spadConstant| $ 24) (|spadConstant| $ 9))
                      . #5#)
                (LETT |pdiv|
                      (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                      . #5#)
                (LETT VQ
                      (VECTOR (QVELT |pdiv| 2)
                              (SPADCALL (QVELT |pdiv| 0) (QREFELT $ 13))
                              (QVELT |pdiv| 1))
                      . #5#)
                (EXIT
                 (SEQ G190 NIL
                      (SEQ
                       (PROGN
                        (LETT |#G221| (SPADCALL VP 1 (QREFELT $ 54)) . #5#)
                        (LETT |#G222| (SPADCALL VQ 1 (QREFELT $ 54)) . #5#)
                        (LETT P |#G221| . #5#)
                        (LETT Q |#G222| . #5#))
                       (EXIT
                        (COND
                         ((SPADCALL Q (QREFELT $ 23))
                          (PROGN
                           (LETT #2#
                                 (VECTOR (SPADCALL VP 2 (QREFELT $ 54))
                                         (SPADCALL VP 3 (QREFELT $ 54)) P)
                                 . #5#)
                           (GO #2#)))
                         ('T
                          (SEQ (LETT |e| (SPADCALL Q (QREFELT $ 26)) . #5#)
                               (EXIT
                                (COND
                                 ((ZEROP |e|)
                                  (PROGN
                                   (LETT #2#
                                         (VECTOR (SPADCALL VQ 2 (QREFELT $ 54))
                                                 (SPADCALL VQ 3 (QREFELT $ 54))
                                                 Q)
                                         . #5#)
                                   (GO #2#)))
                                 ('T
                                  (SEQ
                                   (LETT |ss|
                                         (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                                   |s|
                                                   (PROG1
                                                       (LETT #1#
                                                             (-
                                                              (SPADCALL P
                                                                        (QREFELT
                                                                         $ 26))
                                                              |e|)
                                                             . #5#)
                                                     (|check-subtype|
                                                      (>= #1# 0)
                                                      '(|NonNegativeInteger|)
                                                      #1#))
                                                   (QREFELT $ 48))
                                         . #5#)
                                   (PROGN
                                    (LETT |#G223| VQ . #5#)
                                    (LETT |#G224|
                                          (|PRS;nextsousResultant3| VP VQ |s|
                                           |ss| $)
                                          . #5#)
                                    (LETT VP |#G223| . #5#)
                                    (LETT VQ |#G224| . #5#))
                                   (EXIT (LETT |s| |ss| . #5#)))))))))))
                      NIL (GO G190) G191 (EXIT NIL)))))))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;semiSubResultantGcdEuclidean2;2polRR;33| (P Q $)
  (PROG (|s| VQ VP |#G230| |#G229| |ss| #1=#:G1290 #2=#:G1301 |e| |#G228|
         |#G227| |pdiv| #3=#:G1288)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL P (QREFELT $ 23))
          (COND
           ((SPADCALL Q (QREFELT $ 23))
            (EXIT (CONS (|spadConstant| $ 24) (|spadConstant| $ 24)))))))
        (EXIT
         (COND ((SPADCALL P (QREFELT $ 23)) (CONS (|spadConstant| $ 9) Q))
               ((SPADCALL Q (QREFELT $ 23)) (CONS (|spadConstant| $ 24) P))
               ((< (SPADCALL P (QREFELT $ 26)) (SPADCALL Q (QREFELT $ 26)))
                (|error| "semiSubResultantGcdEuclidean2$PRS : bad degrees"))
               ((ZEROP (SPADCALL Q (QREFELT $ 26)))
                (CONS (|spadConstant| $ 9) Q))
               ('T
                (SEQ
                 (LETT |s|
                       (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                 (PROG1
                                     (LETT #3#
                                           (- (SPADCALL P (QREFELT $ 26))
                                              (SPADCALL Q (QREFELT $ 26)))
                                           . #4=(|PRS;semiSubResultantGcdEuclidean2;2polRR;33|))
                                   (|check-subtype| (>= #3# 0)
                                                    '(|NonNegativeInteger|)
                                                    #3#))
                                 (QREFELT $ 28))
                       . #4#)
                 (LETT VP (VECTOR Q (|spadConstant| $ 9)) . #4#)
                 (LETT |pdiv|
                       (SPADCALL P (SPADCALL Q (QREFELT $ 50)) (QREFELT $ 35))
                       . #4#)
                 (LETT VQ (VECTOR (QVELT |pdiv| 2) (QVELT |pdiv| 1)) . #4#)
                 (EXIT
                  (SEQ G190 NIL
                       (SEQ
                        (PROGN
                         (LETT |#G227| (SPADCALL VP 1 (QREFELT $ 54)) . #4#)
                         (LETT |#G228| (SPADCALL VQ 1 (QREFELT $ 54)) . #4#)
                         (LETT P |#G227| . #4#)
                         (LETT Q |#G228| . #4#))
                        (EXIT
                         (COND
                          ((SPADCALL Q (QREFELT $ 23))
                           (PROGN
                            (LETT #2# (CONS (SPADCALL VP 2 (QREFELT $ 54)) P)
                                  . #4#)
                            (GO #2#)))
                          ('T
                           (SEQ (LETT |e| (SPADCALL Q (QREFELT $ 26)) . #4#)
                                (EXIT
                                 (COND
                                  ((ZEROP |e|)
                                   (PROGN
                                    (LETT #2#
                                          (CONS (SPADCALL VQ 2 (QREFELT $ 54))
                                                Q)
                                          . #4#)
                                    (GO #2#)))
                                  ('T
                                   (SEQ
                                    (LETT |ss|
                                          (SPADCALL (SPADCALL Q (QREFELT $ 25))
                                                    |s|
                                                    (PROG1
                                                        (LETT #1#
                                                              (-
                                                               (SPADCALL P
                                                                         (QREFELT
                                                                          $
                                                                          26))
                                                               |e|)
                                                              . #4#)
                                                      (|check-subtype|
                                                       (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                                    (QREFELT $ 48))
                                          . #4#)
                                    (PROGN
                                     (LETT |#G229| VQ . #4#)
                                     (LETT |#G230|
                                           (|PRS;nextsousResultant3| VP VQ |s|
                                            |ss| $)
                                           . #4#)
                                     (LETT VP |#G229| . #4#)
                                     (LETT VQ |#G230| . #4#))
                                    (EXIT (LETT |s| |ss| . #4#)))))))))))
                       NIL (GO G190) G191 (EXIT NIL)))))))))
      #2# (EXIT #2#))))) 

(DEFUN |PRS;semiSubResultantGcdEuclidean1;2polRR;34| (P Q $)
  (PROG (|result|)
    (RETURN
     (SEQ
      (LETT |result| (SPADCALL P Q (QREFELT $ 84))
            |PRS;semiSubResultantGcdEuclidean1;2polRR;34|)
      (EXIT (CONS (QVELT |result| 0) (QVELT |result| 2))))))) 

(DEFUN |PRS;discriminant;polRR;35| (P $)
  (PROG (#1=#:G1316 #2=#:G1312 #3=#:G1309 |d| |r| |dP| |a| #4=#:G1307)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |d| (SPADCALL P (QREFELT $ 26))
              . #5=(|PRS;discriminant;polRR;35|))
        (EXIT
         (COND ((ZEROP |d|) (|error| "cannot take discriminant of constants"))
               (#6='T
                (SEQ (LETT |a| (QUOTIENT2 (* |d| (- |d| 1)) 2) . #5#)
                     (LETT |a|
                           (EXPT -1
                                 (PROG1 (LETT #4# |a| . #5#)
                                   (|check-subtype| (>= #4# 0)
                                                    '(|NonNegativeInteger|)
                                                    #4#)))
                           . #5#)
                     (LETT |dP| (SPADCALL P (QREFELT $ 89)) . #5#)
                     (LETT |r| (SPADCALL P |dP| (QREFELT $ 60)) . #5#)
                     (LETT |d| (- (- |d| (SPADCALL |dP| (QREFELT $ 26))) 1)
                           . #5#)
                     (EXIT
                      (PROGN
                       (LETT #1#
                             (COND
                              ((ZEROP |d|)
                               (SPADCALL |a|
                                         (PROG2
                                             (LETT #3#
                                                   (SPADCALL |r|
                                                             (SPADCALL P
                                                                       (QREFELT
                                                                        $ 25))
                                                             (QREFELT $ 36))
                                                   . #5#)
                                             (QCDR #3#)
                                           (|check-union| (QEQCAR #3# 0)
                                                          (QREFELT $ 6) #3#))
                                         (QREFELT $ 90)))
                              (#6#
                               (SPADCALL (SPADCALL |a| |r| (QREFELT $ 90))
                                         (SPADCALL (SPADCALL P (QREFELT $ 25))
                                                   (PROG1
                                                       (LETT #2# (- |d| 1)
                                                             . #5#)
                                                     (|check-subtype|
                                                      (>= #2# 0)
                                                      '(|NonNegativeInteger|)
                                                      #2#))
                                                   (QREFELT $ 28))
                                         (QREFELT $ 40))))
                             . #5#)
                       (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;discriminantEuclidean;polRR;36| (P $)
  (PROG (#1=#:G1343 |cr| #2=#:G1337 |c2| #3=#:G1335 |c1| #4=#:G1330 #5=#:G1323
         #6=#:G1320 |d| |rE| |dP| |a| #7=#:G1318)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |d| (SPADCALL P (QREFELT $ 26))
              . #8=(|PRS;discriminantEuclidean;polRR;36|))
        (EXIT
         (COND ((ZEROP |d|) (|error| "cannot take discriminant of constants"))
               (#9='T
                (SEQ (LETT |a| (QUOTIENT2 (* |d| (- |d| 1)) 2) . #8#)
                     (LETT |a|
                           (EXPT -1
                                 (PROG1 (LETT #7# |a| . #8#)
                                   (|check-subtype| (>= #7# 0)
                                                    '(|NonNegativeInteger|)
                                                    #7#)))
                           . #8#)
                     (LETT |dP| (SPADCALL P (QREFELT $ 89)) . #8#)
                     (LETT |rE| (SPADCALL P |dP| (QREFELT $ 62)) . #8#)
                     (LETT |d| (- (- |d| (SPADCALL |dP| (QREFELT $ 26))) 1)
                           . #8#)
                     (COND
                      ((ZEROP |d|)
                       (SEQ
                        (LETT |c1|
                              (SPADCALL |a|
                                        (PROG2
                                            (LETT #6#
                                                  (SPADCALL (QVELT |rE| 0)
                                                            (SPADCALL P
                                                                      (QREFELT
                                                                       $ 25))
                                                            (QREFELT $ 18))
                                                  . #8#)
                                            (QCDR #6#)
                                          (|check-union| (QEQCAR #6# 0)
                                                         (QREFELT $ 7) #6#))
                                        (QREFELT $ 61))
                              . #8#)
                        (LETT |c2|
                              (SPADCALL |a|
                                        (PROG2
                                            (LETT #6#
                                                  (SPADCALL (QVELT |rE| 1)
                                                            (SPADCALL P
                                                                      (QREFELT
                                                                       $ 25))
                                                            (QREFELT $ 18))
                                                  . #8#)
                                            (QCDR #6#)
                                          (|check-union| (QEQCAR #6# 0)
                                                         (QREFELT $ 7) #6#))
                                        (QREFELT $ 61))
                              . #8#)
                        (EXIT
                         (LETT |cr|
                               (SPADCALL |a|
                                         (PROG2
                                             (LETT #5#
                                                   (SPADCALL (QVELT |rE| 2)
                                                             (SPADCALL P
                                                                       (QREFELT
                                                                        $ 25))
                                                             (QREFELT $ 36))
                                                   . #8#)
                                             (QCDR #5#)
                                           (|check-union| (QEQCAR #5# 0)
                                                          (QREFELT $ 6) #5#))
                                         (QREFELT $ 90))
                               . #8#))))
                      (#9#
                       (SEQ
                        (LETT |c1|
                              (SPADCALL
                               (SPADCALL |a| (QVELT |rE| 0) (QREFELT $ 61))
                               (SPADCALL (SPADCALL P (QREFELT $ 25))
                                         (PROG1 (LETT #4# (- |d| 1) . #8#)
                                           (|check-subtype| (>= #4# 0)
                                                            '(|NonNegativeInteger|)
                                                            #4#))
                                         (QREFELT $ 28))
                               (QREFELT $ 92))
                              . #8#)
                        (LETT |c2|
                              (SPADCALL
                               (SPADCALL |a| (QVELT |rE| 1) (QREFELT $ 61))
                               (SPADCALL (SPADCALL P (QREFELT $ 25))
                                         (PROG1 (LETT #3# (- |d| 1) . #8#)
                                           (|check-subtype| (>= #3# 0)
                                                            '(|NonNegativeInteger|)
                                                            #3#))
                                         (QREFELT $ 28))
                               (QREFELT $ 92))
                              . #8#)
                        (EXIT
                         (LETT |cr|
                               (SPADCALL
                                (SPADCALL |a| (QVELT |rE| 2) (QREFELT $ 90))
                                (SPADCALL (SPADCALL P (QREFELT $ 25))
                                          (PROG1 (LETT #2# (- |d| 1) . #8#)
                                            (|check-subtype| (>= #2# 0)
                                                             '(|NonNegativeInteger|)
                                                             #2#))
                                          (QREFELT $ 28))
                                (QREFELT $ 40))
                               . #8#)))))
                     (EXIT
                      (PROGN
                       (LETT #1# (VECTOR |c1| |c2| |cr|) . #8#)
                       (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiDiscriminantEuclidean;polRR;37| (P $)
  (PROG (#1=#:G1365 |cr| #2=#:G1359 |c2| #3=#:G1357 #4=#:G1350 #5=#:G1347 |d|
         |rE| |dP| |a| #6=#:G1345)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |d| (SPADCALL P (QREFELT $ 26))
              . #7=(|PRS;semiDiscriminantEuclidean;polRR;37|))
        (EXIT
         (COND ((ZEROP |d|) (|error| "cannot take discriminant of constants"))
               (#8='T
                (SEQ (LETT |a| (QUOTIENT2 (* |d| (- |d| 1)) 2) . #7#)
                     (LETT |a|
                           (EXPT -1
                                 (PROG1 (LETT #6# |a| . #7#)
                                   (|check-subtype| (>= #6# 0)
                                                    '(|NonNegativeInteger|)
                                                    #6#)))
                           . #7#)
                     (LETT |dP| (SPADCALL P (QREFELT $ 89)) . #7#)
                     (LETT |rE| (SPADCALL P |dP| (QREFELT $ 63)) . #7#)
                     (LETT |d| (- (- |d| (SPADCALL |dP| (QREFELT $ 26))) 1)
                           . #7#)
                     (COND
                      ((ZEROP |d|)
                       (SEQ
                        (LETT |c2|
                              (SPADCALL |a|
                                        (PROG2
                                            (LETT #5#
                                                  (SPADCALL (QCAR |rE|)
                                                            (SPADCALL P
                                                                      (QREFELT
                                                                       $ 25))
                                                            (QREFELT $ 18))
                                                  . #7#)
                                            (QCDR #5#)
                                          (|check-union| (QEQCAR #5# 0)
                                                         (QREFELT $ 7) #5#))
                                        (QREFELT $ 61))
                              . #7#)
                        (EXIT
                         (LETT |cr|
                               (SPADCALL |a|
                                         (PROG2
                                             (LETT #4#
                                                   (SPADCALL (QCDR |rE|)
                                                             (SPADCALL P
                                                                       (QREFELT
                                                                        $ 25))
                                                             (QREFELT $ 36))
                                                   . #7#)
                                             (QCDR #4#)
                                           (|check-union| (QEQCAR #4# 0)
                                                          (QREFELT $ 6) #4#))
                                         (QREFELT $ 90))
                               . #7#))))
                      (#8#
                       (SEQ
                        (LETT |c2|
                              (SPADCALL
                               (SPADCALL |a| (QCAR |rE|) (QREFELT $ 61))
                               (SPADCALL (SPADCALL P (QREFELT $ 25))
                                         (PROG1 (LETT #3# (- |d| 1) . #7#)
                                           (|check-subtype| (>= #3# 0)
                                                            '(|NonNegativeInteger|)
                                                            #3#))
                                         (QREFELT $ 28))
                               (QREFELT $ 92))
                              . #7#)
                        (EXIT
                         (LETT |cr|
                               (SPADCALL
                                (SPADCALL |a| (QCDR |rE|) (QREFELT $ 90))
                                (SPADCALL (SPADCALL P (QREFELT $ 25))
                                          (PROG1 (LETT #2# (- |d| 1) . #7#)
                                            (|check-subtype| (>= #2# 0)
                                                             '(|NonNegativeInteger|)
                                                             #2#))
                                          (QREFELT $ 28))
                                (QREFELT $ 40))
                               . #7#)))))
                     (EXIT
                      (PROGN (LETT #1# (CONS |c2| |cr|) . #7#) (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;resultantReduit;2polRR;38| (P Q $)
  (PROG (#1=#:G1372 #2=#:G1368 |l| |UVs| UV)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT UV (SPADCALL P Q (QREFELT $ 84))
              . #3=(|PRS;resultantReduit;2polRR;38|))
        (LETT |UVs| (QVELT UV 2) . #3#)
        (EXIT
         (COND ((< 0 (SPADCALL |UVs| (QREFELT $ 26))) (|spadConstant| $ 29))
               ('T
                (SEQ
                 (LETT |l|
                       (SPADCALL (SPADCALL (QVELT UV 0) (QREFELT $ 98))
                                 (SPADCALL (QVELT UV 1) (QREFELT $ 98))
                                 (QREFELT $ 99))
                       . #3#)
                 (EXIT
                  (PROGN
                   (LETT #1#
                         (PROG2
                             (LETT #2#
                                   (SPADCALL (SPADCALL |UVs| (QREFELT $ 25))
                                             (SPADCALL |l| (QREFELT $ 101))
                                             (QREFELT $ 36))
                                   . #3#)
                             (QCDR #2#)
                           (|check-union| (QEQCAR #2# 0) (QREFELT $ 6) #2#))
                         . #3#)
                   (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;resultantReduitEuclidean;2polRR;39| (P Q $)
  (PROG (#1=#:G1384 |rr| #2=#:G1379 |c2| #3=#:G1376 |c1| |gl| |l| |UVs| UV)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT UV (SPADCALL P Q (QREFELT $ 84))
              . #4=(|PRS;resultantReduitEuclidean;2polRR;39|))
        (LETT |UVs| (QVELT UV 2) . #4#)
        (EXIT
         (COND
          ((< 0 (SPADCALL |UVs| (QREFELT $ 26)))
           (VECTOR (|spadConstant| $ 24) (|spadConstant| $ 24)
                   (|spadConstant| $ 29)))
          ('T
           (SEQ
            (LETT |l|
                  (SPADCALL (SPADCALL (QVELT UV 0) (QREFELT $ 98))
                            (SPADCALL (QVELT UV 1) (QREFELT $ 98))
                            (QREFELT $ 99))
                  . #4#)
            (LETT |gl| (SPADCALL |l| (QREFELT $ 101)) . #4#)
            (LETT |c1|
                  (PROG2
                      (LETT #3# (SPADCALL (QVELT UV 0) |gl| (QREFELT $ 18))
                            . #4#)
                      (QCDR #3#)
                    (|check-union| (QEQCAR #3# 0) (QREFELT $ 7) #3#))
                  . #4#)
            (LETT |c2|
                  (PROG2
                      (LETT #3# (SPADCALL (QVELT UV 1) |gl| (QREFELT $ 18))
                            . #4#)
                      (QCDR #3#)
                    (|check-union| (QEQCAR #3# 0) (QREFELT $ 7) #3#))
                  . #4#)
            (LETT |rr|
                  (PROG2
                      (LETT #2#
                            (SPADCALL (SPADCALL |UVs| (QREFELT $ 25)) |gl|
                                      (QREFELT $ 36))
                            . #4#)
                      (QCDR #2#)
                    (|check-union| (QEQCAR #2# 0) (QREFELT $ 6) #2#))
                  . #4#)
            (EXIT
             (PROGN (LETT #1# (VECTOR |c1| |c2| |rr|) . #4#) (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;semiResultantReduitEuclidean;2polRR;40| (P Q $)
  (PROG (#1=#:G1396 |rr| #2=#:G1391 |c2| #3=#:G1388 |gl| |l| |UVs| UV)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT UV (SPADCALL P Q (QREFELT $ 84))
              . #4=(|PRS;semiResultantReduitEuclidean;2polRR;40|))
        (LETT |UVs| (QVELT UV 2) . #4#)
        (EXIT
         (COND
          ((< 0 (SPADCALL |UVs| (QREFELT $ 26)))
           (CONS (|spadConstant| $ 24) (|spadConstant| $ 29)))
          ('T
           (SEQ
            (LETT |l|
                  (SPADCALL (SPADCALL (QVELT UV 0) (QREFELT $ 98))
                            (SPADCALL (QVELT UV 1) (QREFELT $ 98))
                            (QREFELT $ 99))
                  . #4#)
            (LETT |gl| (SPADCALL |l| (QREFELT $ 101)) . #4#)
            (LETT |c2|
                  (PROG2
                      (LETT #3# (SPADCALL (QVELT UV 1) |gl| (QREFELT $ 18))
                            . #4#)
                      (QCDR #3#)
                    (|check-union| (QEQCAR #3# 0) (QREFELT $ 7) #3#))
                  . #4#)
            (LETT |rr|
                  (PROG2
                      (LETT #2#
                            (SPADCALL (SPADCALL |UVs| (QREFELT $ 25)) |gl|
                                      (QREFELT $ 36))
                            . #4#)
                      (QCDR #2#)
                    (|check-union| (QEQCAR #2# 0) (QREFELT $ 6) #2#))
                  . #4#)
            (EXIT (PROGN (LETT #1# (CONS |c2| |rr|) . #4#) (GO #1#)))))))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;gcdnaif| (P Q $)
  (PROG (|#G250| |#G249| #1=#:G1405 #2=#:G1398)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((SPADCALL P (QREFELT $ 23))
         (PROG2
             (LETT #2# (SPADCALL Q (SPADCALL Q (QREFELT $ 25)) (QREFELT $ 18))
                   . #3=(|PRS;gcdnaif|))
             (QCDR #2#)
           (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#)))
        ('T
         (SEQ G190 NIL
              (SEQ
               (EXIT
                (COND
                 ((SPADCALL Q (QREFELT $ 23))
                  (PROGN
                   (LETT #1#
                         (PROG2
                             (LETT #2#
                                   (SPADCALL P (SPADCALL P (QREFELT $ 25))
                                             (QREFELT $ 18))
                                   . #3#)
                             (QCDR #2#)
                           (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                         . #3#)
                   (GO #1#)))
                 ((ZEROP (SPADCALL Q (QREFELT $ 26)))
                  (PROGN (LETT #1# (|spadConstant| $ 9) . #3#) (GO #1#)))
                 ('T
                  (PROGN
                   (LETT |#G249| Q . #3#)
                   (LETT |#G250| (QCDR (SPADCALL P Q (QREFELT $ 38))) . #3#)
                   (LETT P |#G249| . #3#)
                   (LETT Q |#G250| . #3#))))))
              NIL (GO G190) G191 (EXIT NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |PRS;gcd;3polR;42| (P Q $)
  (PROG (#1=#:G1412 G #2=#:G1407 |cQ| |cP|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((|HasCategory| (QREFELT $ 6) '(|Finite|)) (|PRS;gcdnaif| P Q $))
             ((SPADCALL P (QREFELT $ 23)) Q) ((SPADCALL Q (QREFELT $ 23)) P)
             ('T
              (SEQ
               (LETT |cP| (SPADCALL P (QREFELT $ 107))
                     . #3=(|PRS;gcd;3polR;42|))
               (LETT |cQ| (SPADCALL Q (QREFELT $ 107)) . #3#)
               (LETT P
                     (PROG2
                         (LETT #2# (SPADCALL P |cP| (QREFELT $ 18)) . #3#)
                         (QCDR #2#)
                       (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                     . #3#)
               (LETT Q
                     (PROG2
                         (LETT #2# (SPADCALL Q |cQ| (QREFELT $ 18)) . #3#)
                         (QCDR #2#)
                       (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                     . #3#)
               (LETT G (SPADCALL P Q (QREFELT $ 82)) . #3#)
               (EXIT
                (PROGN
                 (LETT #1#
                       (SPADCALL (SPADCALL |cP| |cQ| (QREFELT $ 108))
                                 (SPADCALL G (QREFELT $ 109)) (QREFELT $ 30))
                       . #3#)
                 (GO #1#)))))))
      #1# (EXIT #1#))))) 

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

(DEFUN |PseudoRemainderSequence;| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|PseudoRemainderSequence|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|PseudoRemainderSequence| DV$1 DV$2) . #1#)
      (LETT $ (GETREFV 111) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#1| '(|GcdDomain|))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|PseudoRemainderSequence|
                  (LIST DV$1 DV$2) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 12 (SPADCALL (|spadConstant| $ 8) 1 (QREFELT $ 11)))
      (COND
       ((|testBitVector| |pv$| 1)
        (PROGN
         (QSETREFV $ 102
                   (CONS (|dispatchFunction| |PRS;resultantReduit;2polRR;38|)
                         $))
         (QSETREFV $ 104
                   (CONS
                    (|dispatchFunction|
                     |PRS;resultantReduitEuclidean;2polRR;39|)
                    $))
         (QSETREFV $ 106
                   (CONS
                    (|dispatchFunction|
                     |PRS;semiResultantReduitEuclidean;2polRR;40|)
                    $))
         (QSETREFV $ 110 (CONS (|dispatchFunction| |PRS;gcd;3polR;42|) $)))))
      $)))) 

(MAKEPROP '|PseudoRemainderSequence| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) (0 . |One|)
              (4 . |One|) (|NonNegativeInteger|) (8 . |monomial|) 'X
              (14 . |coerce|) (|Vector| 7) (19 . *) |PRS;*;R2V;1|
              (|Union| $ '"failed") (25 . |exquo|) (|Mapping| 7 7) (31 . |map|)
              |PRS;exquo;VRV;2| (|Boolean|) (37 . |zero?|) (42 . |Zero|)
              (46 . |leadingCoefficient|) (51 . |degree|) (56 . |reductum|)
              (61 . ^) (67 . |Zero|) (71 . *) (77 . +) (83 . *) (89 . -)
              (|Record| (|:| |coef| 6) (|:| |quotient| 7) (|:| |remainder| 7))
              |PRS;pseudoDivide;2polRR;3| (95 . |exquo|)
              (|Record| (|:| |quotient| 7) (|:| |remainder| 7))
              |PRS;divide;2polRR;4| (101 . -) (106 . *)
              |PRS;resultantnaif;2polRR;5|
              (|Record| (|:| |coef1| 7) (|:| |coef2| 7) (|:| |resultant| 6))
              |PRS;resultantEuclideannaif;2polRR;6|
              (|Record| (|:| |coef2| 7) (|:| |resultant| 6))
              |PRS;semiResultantEuclideannaif;2polRR;7| (|PositiveInteger|)
              (112 . *) |PRS;Lazard;2RNniR;8| |PRS;Lazard2;polR2RNnipolR;9|
              (118 . -) (123 . |coefficient|)
              |PRS;nextsousResultant2;3polRRpolR;11| (|Integer|) (129 . |elt|)
              (135 . -) (141 . +) (147 . |setelt|) (154 . -)
              (159 . |pseudoRemainder|) |PRS;resultant;2polRR;14| (165 . *)
              |PRS;resultantEuclidean;2polRR;16|
              |PRS;semiResultantEuclidean2;2polRR;18|
              (|Record| (|:| |coef1| 7) (|:| |resultant| 6))
              |PRS;semiResultantEuclidean1;2polRR;19|
              |PRS;indiceSubResultant;2polRNnipolR;20|
              (|Record| (|:| |coef1| 7) (|:| |coef2| 7) (|:| |subResultant| 7))
              |PRS;indiceSubResultantEuclidean;2polRNniR;21|
              (|Record| (|:| |coef2| 7) (|:| |subResultant| 7))
              |PRS;semiIndiceSubResultantEuclidean;2polRNniR;22|
              |PRS;degreeSubResultant;2polRNnipolR;23|
              |PRS;degreeSubResultantEuclidean;2polRNniR;24|
              |PRS;semiDegreeSubResultantEuclidean;2polRNniR;25|
              |PRS;lastSubResultant;3polR;26|
              |PRS;lastSubResultantEuclidean;2polRR;27| (171 . |copy|)
              |PRS;semiLastSubResultantEuclidean;2polRR;28| (|List| 7)
              |PRS;chainSubResultants;2polRL;29| (|List| 10)
              |PRS;schema;2polRL;30| |PRS;subResultantGcd;3polR;31|
              (|Record| (|:| |coef1| 7) (|:| |coef2| 7) (|:| |gcd| 7))
              |PRS;subResultantGcdEuclidean;2polRR;32|
              (|Record| (|:| |coef2| 7) (|:| |gcd| 7))
              |PRS;semiSubResultantGcdEuclidean2;2polRR;33|
              (|Record| (|:| |coef1| 7) (|:| |gcd| 7))
              |PRS;semiSubResultantGcdEuclidean1;2polRR;34|
              (176 . |differentiate|) (181 . *) |PRS;discriminant;polRR;35|
              (187 . *)
              (|Record| (|:| |coef1| 7) (|:| |coef2| 7) (|:| |discriminant| 6))
              |PRS;discriminantEuclidean;polRR;36|
              (|Record| (|:| |coef2| 7) (|:| |discriminant| 6))
              |PRS;semiDiscriminantEuclidean;polRR;37| (|List| 6)
              (193 . |coefficients|) (198 . |concat|) (|List| $) (204 . |gcd|)
              (209 . |resultantReduit|)
              (|Record| (|:| |coef1| 7) (|:| |coef2| 7)
                        (|:| |resultantReduit| 6))
              (215 . |resultantReduitEuclidean|)
              (|Record| (|:| |coef2| 7) (|:| |resultantReduit| 6))
              (221 . |semiResultantReduitEuclidean|) (227 . |content|)
              (232 . |gcd|) (238 . |primitivePart|) (243 . |gcd|))
           '#(|subResultantGcdEuclidean| 249 |subResultantGcd| 255
              |semiSubResultantGcdEuclidean2| 261
              |semiSubResultantGcdEuclidean1| 267
              |semiResultantReduitEuclidean| 273 |semiResultantEuclideannaif|
              279 |semiResultantEuclidean2| 285 |semiResultantEuclidean1| 291
              |semiLastSubResultantEuclidean| 297
              |semiIndiceSubResultantEuclidean| 303 |semiDiscriminantEuclidean|
              310 |semiDegreeSubResultantEuclidean| 315 |schema| 322
              |resultantnaif| 328 |resultantReduitEuclidean| 334
              |resultantReduit| 340 |resultantEuclideannaif| 346
              |resultantEuclidean| 352 |resultant| 358 |pseudoDivide| 364
              |nextsousResultant2| 370 |lastSubResultantEuclidean| 378
              |lastSubResultant| 384 |indiceSubResultantEuclidean| 390
              |indiceSubResultant| 397 |gcd| 404 |exquo| 410 |divide| 416
              |discriminantEuclidean| 422 |discriminant| 427
              |degreeSubResultantEuclidean| 432 |degreeSubResultant| 439
              |chainSubResultants| 446 |Lazard2| 452 |Lazard| 460 * 467)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 110
                                                 '(0 6 0 8 0 7 0 9 2 7 0 6 10
                                                   11 1 7 0 6 13 2 14 0 7 0 15
                                                   2 7 17 0 6 18 2 14 0 19 0 20
                                                   1 7 22 0 23 0 7 0 24 1 7 6 0
                                                   25 1 7 10 0 26 1 7 0 0 27 2
                                                   6 0 0 10 28 0 6 0 29 2 7 0 6
                                                   0 30 2 7 0 0 0 31 2 7 0 0 0
                                                   32 2 7 0 0 0 33 2 6 17 0 0
                                                   36 1 6 0 0 39 2 6 0 0 0 40 2
                                                   10 0 46 0 47 1 7 0 0 50 2 7
                                                   6 0 10 51 2 14 7 0 53 54 2
                                                   14 0 0 0 55 2 14 0 0 0 56 3
                                                   14 7 0 53 7 57 1 14 0 0 58 2
                                                   7 0 0 0 59 2 7 0 53 0 61 1
                                                   14 0 0 76 1 7 0 0 89 2 6 0
                                                   53 0 90 2 7 0 0 6 92 1 7 97
                                                   0 98 2 97 0 0 0 99 1 6 0 100
                                                   101 2 0 6 7 7 102 2 0 103 7
                                                   7 104 2 0 105 7 7 106 1 7 6
                                                   0 107 2 6 0 0 0 108 1 7 0 0
                                                   109 2 0 7 7 7 110 2 0 83 7 7
                                                   84 2 0 7 7 7 82 2 0 85 7 7
                                                   86 2 0 87 7 7 88 2 1 105 7 7
                                                   106 2 0 44 7 7 45 2 0 44 7 7
                                                   63 2 0 64 7 7 65 2 0 69 7 7
                                                   77 3 0 69 7 7 10 70 1 0 95 7
                                                   96 3 0 69 7 7 10 73 2 0 80 7
                                                   7 81 2 0 6 7 7 41 2 1 103 7
                                                   7 104 2 1 6 7 7 102 2 0 42 7
                                                   7 43 2 0 42 7 7 62 2 0 6 7 7
                                                   60 2 0 34 7 7 35 4 0 7 7 7 7
                                                   6 52 2 0 67 7 7 75 2 0 7 7 7
                                                   74 3 0 67 7 7 10 68 3 0 7 7
                                                   7 10 66 2 1 7 7 7 110 2 0 14
                                                   14 6 21 2 0 37 7 7 38 1 0 93
                                                   7 94 1 0 6 7 91 3 0 67 7 7
                                                   10 72 3 0 7 7 7 10 71 2 0 78
                                                   7 7 79 4 0 7 7 6 6 10 49 3 0
                                                   6 6 6 10 48 2 0 14 6 14
                                                   16)))))
           '|lookupComplete|)) 
