
(/VERSIONCHECK 2) 

(DEFUN |AF;belong?;BoB;1| (|op| $) (SPADCALL |op| (QREFELT $ 8) (QREFELT $ 16))) 

(DEFUN |AF;dalg| (|l| $)
  (SPADCALL (SPADCALL |l| (QREFELT $ 19)) (QREFELT $ 21))) 

(DEFUN |AF;rootOf;SupSF;3| (|p| |x| $)
  (PROG (|n| |f| |r| |k|)
    (RETURN
     (SEQ (LETT |k| (SPADCALL |x| (QREFELT $ 23)) . #1=(|AF;rootOf;SupSF;3|))
          (LETT |r| (SPADCALL |p| (QREFELT $ 26)) . #1#)
          (EXIT
           (COND
            ((QEQCAR |r| 1)
             (SPADCALL |p| (SPADCALL |k| (QREFELT $ 28)) (QREFELT $ 29)))
            (#2='T
             (SEQ
              (LETT |n|
                    (SPADCALL
                     (LETT |f| (SPADCALL (QCDR |r|) |k| (QREFELT $ 31)) . #1#)
                     (QREFELT $ 33))
                    . #1#)
              (EXIT
               (COND
                ((< 0 (SPADCALL (SPADCALL |f| (QREFELT $ 38)) (QREFELT $ 40)))
                 (|error| "roofOf: variable appears in denom"))
                (#2#
                 (SPADCALL |n| (SPADCALL |k| (QREFELT $ 28))
                           (QREFELT $ 29))))))))))))) 

(DEFUN |AF;dvalg| (|l| |x| $)
  (PROG (|alpha| |p|)
    (RETURN
     (SEQ
      (LETT |p|
            (SPADCALL
             (SPADCALL (|SPADfirst| |l|)
                       (SPADCALL (SPADCALL |l| (QREFELT $ 19)) (QREFELT $ 42))
                       (QREFELT $ 31))
             (QREFELT $ 33))
            . #1=(|AF;dvalg|))
      (LETT |alpha| (SPADCALL (QREFELT $ 13) |l| (QREFELT $ 44)) . #1#)
      (EXIT
       (SPADCALL
        (SPADCALL
         (SPADCALL
          (SPADCALL (CONS #'|AF;dvalg!0| (VECTOR $ |x|)) |p| (QREFELT $ 47))
          |alpha| (QREFELT $ 48))
         (SPADCALL (SPADCALL |p| (QREFELT $ 49)) |alpha| (QREFELT $ 48))
         (QREFELT $ 50))
        (QREFELT $ 51))))))) 

(DEFUN |AF;dvalg!0| (|s| $$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #1=(|AF;dvalg|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |s| |x| (QREFELT $ 45)))))) 

(DEFUN |AF;ialg| (|l| $)
  (PROG (|f| |x| |p|)
    (RETURN
     (SEQ
      (LETT |f|
            (SPADCALL (LETT |p| (|SPADfirst| |l|) . #1=(|AF;ialg|))
                      (SPADCALL (LETT |x| (SPADCALL |l| (QREFELT $ 19)) . #1#)
                                (QREFELT $ 42))
                      (QREFELT $ 31))
            . #1#)
      (EXIT
       (COND
        ((< 0 (SPADCALL (SPADCALL |f| (QREFELT $ 38)) (QREFELT $ 40)))
         (|error| "roofOf: variable appears in denom"))
        ('T (SPADCALL (SPADCALL |f| (QREFELT $ 33)) |x| (QREFELT $ 29))))))))) 

(DEFUN |AF;operator;2Bo;6| (|op| $)
  (COND ((SPADCALL |op| '|rootOf| (QREFELT $ 52)) (QREFELT $ 13))
        ((SPADCALL |op| '|nthRoot| (QREFELT $ 52)) (QREFELT $ 14))
        ('T (|error| "Unknown operator")))) 

(DEFUN |AF;inrootof;Sup2F;7| (|q| |x| $)
  (PROG (#1=#:G1897 |r| |rx| #2=#:G1898 |d|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |q| (QREFELT $ 54)) (|spadConstant| $ 35))
            (#3='T
             (SEQ
              (EXIT
               (SEQ
                (SEQ
                 (LETT |d| (SPADCALL |q| (QREFELT $ 40))
                       . #4=(|AF;inrootof;Sup2F;7|))
                 (EXIT
                  (COND
                   ((NULL (< 0 |d|))
                    (PROGN
                     (LETT #2# (|error| "rootOf: constant polynomial") . #4#)
                     (GO #2#))))))
                (EXIT
                 (COND
                  ((EQL |d| 1)
                   (SPADCALL
                    (SPADCALL
                     (SPADCALL (SPADCALL |q| (QREFELT $ 57)) (QREFELT $ 58))
                     (SPADCALL |q| (QREFELT $ 58)) (QREFELT $ 50))
                    (QREFELT $ 51)))
                  (#3#
                   (SEQ
                    (EXIT
                     (SEQ
                      (SEQ (LETT |rx| (SPADCALL |x| (QREFELT $ 60)) . #4#)
                           (EXIT
                            (COND
                             ((QEQCAR |rx| 0)
                              (SEQ (LETT |r| (|AF;UP2R| |q| $) . #4#)
                                   (EXIT
                                    (COND
                                     ((QEQCAR |r| 0)
                                      (PROGN
                                       (LETT #1#
                                             (SPADCALL
                                              (SPADCALL (QCDR |r|) (QCDR |rx|)
                                                        (QREFELT $ 62))
                                              (QREFELT $ 63))
                                             . #4#)
                                       (GO #1#))))))))))
                      (EXIT
                       (SPADCALL (QREFELT $ 13)
                                 (LIST (SPADCALL |q| |x| (QREFELT $ 48)) |x|)
                                 (QREFELT $ 44)))))
                    #1# (EXIT #1#)))))))
              #2# (EXIT #2#)))))))) 

(DEFUN |AF;UP2R| (|p| $)
  (PROG (|ans| #1=#:G1914 |r|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |ans| (|spadConstant| $ 65) . #2=(|AF;UP2R|))
            (SEQ G190
                 (COND
                  ((NULL
                    (COND
                     ((SPADCALL |p| (|spadConstant| $ 36) (QREFELT $ 66)) 'NIL)
                     ('T 'T)))
                   (GO G191)))
                 (SEQ
                  (LETT |r|
                        (SPADCALL (SPADCALL |p| (QREFELT $ 58)) (QREFELT $ 68))
                        . #2#)
                  (EXIT
                   (COND
                    ((QEQCAR |r| 1)
                     (PROGN (LETT #1# (CONS 1 "failed") . #2#) (GO #1#)))
                    ('T
                     (SEQ
                      (LETT |ans|
                            (SPADCALL |ans|
                                      (SPADCALL (QCDR |r|)
                                                (SPADCALL |p| (QREFELT $ 40))
                                                (QREFELT $ 69))
                                      (QREFELT $ 70))
                            . #2#)
                      (EXIT
                       (LETT |p| (SPADCALL |p| (QREFELT $ 57)) . #2#)))))))
                 NIL (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 |ans|))))
      #1# (EXIT #1#))))) 

(DEFUN |AF;inrootof;Sup2F;9| (|q| |x| $)
  (PROG (#1=#:G1916 |d|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |q| (QREFELT $ 54)) (|spadConstant| $ 35))
            (#2='T
             (SEQ
              (EXIT
               (SEQ
                (SEQ
                 (LETT |d| (SPADCALL |q| (QREFELT $ 40))
                       . #3=(|AF;inrootof;Sup2F;9|))
                 (EXIT
                  (COND
                   ((NULL (< 0 |d|))
                    (PROGN
                     (LETT #1# (|error| "rootOf: constant polynomial") . #3#)
                     (GO #1#))))))
                (EXIT
                 (COND
                  ((EQL |d| 1)
                   (SPADCALL
                    (SPADCALL
                     (SPADCALL (SPADCALL |q| (QREFELT $ 57)) (QREFELT $ 58))
                     (SPADCALL |q| (QREFELT $ 58)) (QREFELT $ 50))
                    (QREFELT $ 51)))
                  (#2#
                   (SPADCALL (QREFELT $ 13)
                             (LIST (SPADCALL |q| |x| (QREFELT $ 48)) |x|)
                             (QREFELT $ 44)))))))
              #1# (EXIT #1#)))))))) 

(DEFUN |AF;lzero| (|l| $) (|spadConstant| $ 35)) 

(DEFUN |AF;droot;LOf;11| (|l| $)
  (PROG (|n| |x|)
    (RETURN
     (SEQ
      (LETT |x| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 21))
            . #1=(|AF;droot;LOf;11|))
      (LETT |n| (SPADCALL (SPADCALL |l| (QREFELT $ 19)) (QREFELT $ 79)) . #1#)
      (EXIT
       (COND ((EQL |n| 2) (SPADCALL |x| (QREFELT $ 80)))
             ('T
              (SPADCALL |x| (SPADCALL |n| (QREFELT $ 81)) (QREFELT $ 82))))))))) 

(DEFUN |AF;dvroot| (|l| $)
  (PROG (|n|)
    (RETURN
     (SEQ
      (LETT |n| (SPADCALL (SPADCALL |l| (QREFELT $ 19)) (QREFELT $ 79))
            |AF;dvroot|)
      (EXIT
       (SPADCALL
        (SPADCALL (|SPADfirst| |l|) (SPADCALL (- 1 |n|) |n| (QREFELT $ 87))
                  (QREFELT $ 88))
        (SPADCALL |n| (QREFELT $ 89)) (QREFELT $ 50))))))) 

(DEFUN |AF;^;FFF;13| (|x| |q| $)
  (PROG (|qr|)
    (RETURN
     (SEQ
      (LETT |qr|
            (DIVIDE2 (SPADCALL |q| (QREFELT $ 90))
                     (SPADCALL |q| (QREFELT $ 91)))
            |AF;^;FFF;13|)
      (EXIT
       (SPADCALL (SPADCALL |x| (QCAR |qr|) (QREFELT $ 92))
                 (SPADCALL
                  (|AF;inroot|
                   (LIST |x|
                         (SPADCALL (SPADCALL |q| (QREFELT $ 91))
                                   (QREFELT $ 89)))
                   $)
                  (QCDR |qr|) (QREFELT $ 92))
                 (QREFELT $ 93))))))) 

(DEFUN |AF;hackroot| (|x| |n| $)
  (PROG (#1=#:G1945 |rx| |dx|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((OR (EQL |n| 1) (SPADCALL |x| (|spadConstant| $ 56) (QREFELT $ 94)))
         |x|)
        ('T
         (SEQ
          (SEQ (LETT |dx| (SPADCALL |x| (QREFELT $ 96)) . #2=(|AF;hackroot|))
               (EXIT
                (COND
                 ((NULL (SPADCALL |dx| (|spadConstant| $ 85) (QREFELT $ 97)))
                  (SEQ (LETT |rx| (SPADCALL |dx| (QREFELT $ 99)) . #2#)
                       (EXIT
                        (COND
                         ((QEQCAR |rx| 0)
                          (COND
                           ((SPADCALL (QCDR |rx|) (QREFELT $ 100))
                            (PROGN
                             (LETT #1#
                                   (SPADCALL
                                    (|AF;hackroot|
                                     (SPADCALL (SPADCALL |x| (QREFELT $ 101))
                                               (QREFELT $ 102))
                                     |n| $)
                                    (|AF;hackroot|
                                     (SPADCALL (QCDR |rx|) (QREFELT $ 89)) |n|
                                     $)
                                    (QREFELT $ 50))
                                   . #2#)
                             (GO #1#))))))))))))
          (COND
           ((SPADCALL |x| (SPADCALL (|spadConstant| $ 56) (QREFELT $ 51))
                      (QREFELT $ 94))
            (COND
             ((EQL |n| 4)
              (EXIT
               (SPADCALL
                (SPADCALL
                 (SPADCALL (SPADCALL (|spadConstant| $ 56) (QREFELT $ 51))
                           (SPADCALL (|spadConstant| $ 103)
                                     (SPADCALL 2 (QREFELT $ 104))
                                     (QREFELT $ 105))
                           (QREFELT $ 88))
                 (|spadConstant| $ 56) (QREFELT $ 106))
                (SPADCALL (SPADCALL 2 (QREFELT $ 89))
                          (SPADCALL (|spadConstant| $ 103)
                                    (SPADCALL 2 (QREFELT $ 104))
                                    (QREFELT $ 105))
                          (QREFELT $ 88))
                (QREFELT $ 50)))))))
          (EXIT
           (SPADCALL (QREFELT $ 14) (LIST |x| (SPADCALL |n| (QREFELT $ 89)))
                     (QREFELT $ 44)))))))
      #1# (EXIT #1#))))) 

(DEFUN |AF;inroot| (|l| $)
  (PROG (|pr| #1=#:G1957 |u| |r| #2=#:G1963 |x| |n|)
    (RETURN
     (SEQ
      (COND
       ((ZEROP
         (LETT |n| (SPADCALL (SPADCALL |l| (QREFELT $ 19)) (QREFELT $ 79))
               . #3=(|AF;inroot|)))
        (|error| "root: exponent = 0"))
       (#4='T
        (SEQ
         (EXIT
          (SEQ
           (SEQ (LETT |x| (|SPADfirst| |l|) . #3#)
                (EXIT
                 (COND
                  ((OR (SPADCALL |x| (|spadConstant| $ 56) (QREFELT $ 94))
                       (EQL |n| 1))
                   (PROGN (LETT #2# |x| . #3#) (GO #2#))))))
           (LETT |r| (SPADCALL |x| (QREFELT $ 68)) . #3#)
           (EXIT
            (COND ((QEQCAR |r| 0) (SPADCALL (QCDR |r|) |n| (QREFELT $ 107)))
                  ((QEQCAR (LETT |u| (SPADCALL |x| (QREFELT $ 110)) . #3#) 0)
                   (SEQ
                    (LETT |pr|
                          (PROG2
                              (LETT #1# |u| . #3#)
                              (QCDR #1#)
                            (|check-union| (QEQCAR #1# 0)
                                           (|Record|
                                            (|:| |var|
                                                 (|Kernel| (QREFELT $ 7)))
                                            (|:| |exponent| (|Integer|)))
                                           #1#))
                          . #3#)
                    (COND
                     ((SPADCALL (QCAR |pr|) (QREFELT $ 14) (QREFELT $ 111))
                      (COND
                       ((EQL (LENGTH (SPADCALL (QCAR |pr|) (QREFELT $ 112))) 2)
                        (EXIT
                         (SPADCALL
                          (|SPADfirst| (SPADCALL (QCAR |pr|) (QREFELT $ 112)))
                          (SPADCALL (QCDR |pr|)
                                    (* |n|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL (QCAR |pr|) (QREFELT $ 112))
                                         (QREFELT $ 19))
                                        (QREFELT $ 79)))
                                    (QREFELT $ 87))
                          (QREFELT $ 88)))))))
                    (EXIT (|AF;inroot0| |x| |n| 'NIL 'NIL $))))
                  (#4# (|AF;inroot0| |x| |n| 'NIL 'NIL $))))))
         #2# (EXIT #2#)))))))) 

(DEFUN |AF;inroot0| (|x| |n| |num?| |den?| $)
  (PROG (#1=#:G1967 |rec| #2=#:G1978 #3=#:G1973 #4=#:G1969 |rd| |rn|)
    (RETURN
     (SEQ
      (LETT |rn|
            (COND (|num?| (CONS 1 "failed"))
                  (#5='T
                   (SPADCALL (SPADCALL |x| (QREFELT $ 101)) (QREFELT $ 99))))
            . #6=(|AF;inroot0|))
      (LETT |rd|
            (COND (|den?| (CONS 1 "failed"))
                  (#5#
                   (SPADCALL (SPADCALL |x| (QREFELT $ 96)) (QREFELT $ 99))))
            . #6#)
      (COND
       ((QEQCAR |rn| 0)
        (COND
         ((QEQCAR |rd| 0)
          (EXIT
           (SEQ
            (LETT |rec|
                  (SPADCALL (SPADCALL (QCDR |rn|) (QCDR |rd|) (QREFELT $ 87))
                            (PROG1 (LETT #4# |n| . #6#)
                              (|check-subtype| (>= #4# 0)
                                               '(|NonNegativeInteger|) #4#))
                            (QREFELT $ 115))
                  . #6#)
            (EXIT
             (SPADCALL (QVELT |rec| 1)
                       (|AF;hackroot| (QVELT |rec| 2) (QVELT |rec| 0) $)
                       (QREFELT $ 93)))))))))
      (EXIT
       (COND
        ((QEQCAR |rn| 0)
         (SEQ
          (LETT |rec|
                (SPADCALL (SPADCALL (QCDR |rn|) (QREFELT $ 104))
                          (PROG1 (LETT #3# |n| . #6#)
                            (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                                             #3#))
                          (QREFELT $ 115))
                . #6#)
          (EXIT
           (SPADCALL (QVELT |rec| 1)
                     (|AF;inroot0|
                      (SPADCALL
                       (SPADCALL (QVELT |rec| 2)
                                 (PROG2
                                     (LETT #1#
                                           (SPADCALL |n| (QVELT |rec| 0)
                                                     (QREFELT $ 117))
                                           . #6#)
                                     (QCDR #1#)
                                   (|check-union| (QEQCAR #1# 0) (|Integer|)
                                                  #1#))
                                 (QREFELT $ 92))
                       (SPADCALL (SPADCALL |x| (QREFELT $ 96)) (QREFELT $ 102))
                       (QREFELT $ 50))
                      |n| 'T |den?| $)
                     (QREFELT $ 93)))))
        ((QEQCAR |rd| 0)
         (SEQ
          (LETT |rec|
                (SPADCALL (SPADCALL (QCDR |rd|) (QREFELT $ 104))
                          (PROG1 (LETT #2# |n| . #6#)
                            (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|)
                                             #2#))
                          (QREFELT $ 115))
                . #6#)
          (EXIT
           (SPADCALL
            (|AF;inroot0|
             (SPADCALL
              (SPADCALL (SPADCALL |x| (QREFELT $ 101)) (QREFELT $ 102))
              (SPADCALL (QVELT |rec| 2)
                        (PROG2
                            (LETT #1#
                                  (SPADCALL |n| (QVELT |rec| 0)
                                            (QREFELT $ 117))
                                  . #6#)
                            (QCDR #1#)
                          (|check-union| (QEQCAR #1# 0) (|Integer|) #1#))
                        (QREFELT $ 92))
              (QREFELT $ 50))
             |n| |num?| 'T $)
            (QVELT |rec| 1) (QREFELT $ 50)))))
        (#5# (|AF;hackroot| |x| |n| $)))))))) 

(DEFUN |AF;iroot;RIF;17| (|r| |n| $)
  (SPADCALL (SPADCALL |r| |n| (QREFELT $ 118)) (QREFELT $ 63))) 

(DEFUN |AF;iroot;RIF;18| (|r| |n| $)
  (SPADCALL (SPADCALL |r| |n| (QREFELT $ 118)) (QREFELT $ 63))) 

(DEFUN |AF;iroot;RIF;19| (|r| |n| $)
  (COND
   ((OR (ODDP |n|) (NULL (SPADCALL |r| (|spadConstant| $ 34) (QREFELT $ 119))))
    (SPADCALL (SPADCALL |r| |n| (QREFELT $ 118)) (QREFELT $ 63)))
   ('T (|AF;iroot0| |r| |n| $)))) 

(DEFUN |AF;iroot;RIF;20| (|r| |n| $) (|AF;iroot0| |r| |n| $)) 

(DEFUN |AF;iroot0| (|r| |n| $)
  (PROG (|rec| #1=#:G1989)
    (RETURN
     (SEQ
      (LETT |rec|
            (SPADCALL |r|
                      (PROG1 (LETT #1# |n| . #2=(|AF;iroot0|))
                        (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                         #1#))
                      (QREFELT $ 120))
            . #2#)
      (EXIT
       (SPADCALL (QVELT |rec| 1)
                 (|AF;hackroot| (QVELT |rec| 2) (QVELT |rec| 0) $)
                 (QREFELT $ 93))))))) 

(DEFUN |AF;definingPolynomial;2F;22| (|x| $)
  (PROG (|k| |r|)
    (RETURN
     (SEQ
      (LETT |r| (SPADCALL |x| (QREFELT $ 122))
            . #1=(|AF;definingPolynomial;2F;22|))
      (EXIT
       (COND
        ((QEQCAR |r| 0)
         (COND
          ((SPADCALL (LETT |k| (QCDR |r|) . #1#) (QREFELT $ 13)
                     (QREFELT $ 111))
           (|SPADfirst| (SPADCALL |k| (QREFELT $ 112))))
          ((SPADCALL |k| (QREFELT $ 14) (QREFELT $ 111))
           (SPADCALL
            (SPADCALL (QREFELT $ 77)
                      (SPADCALL
                       (SPADCALL (SPADCALL |k| (QREFELT $ 112)) (QREFELT $ 19))
                       (QREFELT $ 79))
                      (QREFELT $ 92))
            (|SPADfirst| (SPADCALL |k| (QREFELT $ 112))) (QREFELT $ 123)))
          (#2='T (SPADCALL (QREFELT $ 77) |x| (QREFELT $ 123)))))
        (#2# (SPADCALL (QREFELT $ 77) |x| (QREFELT $ 123))))))))) 

(DEFUN |AF;minPoly;KSup;23| (|k| $)
  (PROG (#1=#:G2003)
    (RETURN
     (COND
      ((SPADCALL |k| (QREFELT $ 13) (QREFELT $ 111))
       (SPADCALL
        (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 112)))
                  (SPADCALL
                   (SPADCALL (SPADCALL |k| (QREFELT $ 112)) (QREFELT $ 19))
                   (QREFELT $ 42))
                  (QREFELT $ 31))
        (QREFELT $ 33)))
      ((SPADCALL |k| (QREFELT $ 14) (QREFELT $ 111))
       (SPADCALL
        (SPADCALL (|spadConstant| $ 56)
                  (PROG1
                      (LETT #1#
                            (SPADCALL
                             (SPADCALL (SPADCALL |k| (QREFELT $ 112))
                                       (QREFELT $ 19))
                             (QREFELT $ 79))
                            |AF;minPoly;KSup;23|)
                    (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
                  (QREFELT $ 125))
        (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 112))) (QREFELT $ 126))
        (QREFELT $ 127)))
      ('T
       (SPADCALL (SPADCALL (|spadConstant| $ 56) 1 (QREFELT $ 125))
                 (SPADCALL (SPADCALL |k| (QREFELT $ 28)) (QREFELT $ 126))
                 (QREFELT $ 127))))))) 

(DEFUN |AF;droot;LOf;24| (|l| $)
  (PROG (|n| |x|)
    (RETURN
     (SEQ
      (LETT |x| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 21))
            . #1=(|AF;droot;LOf;24|))
      (LETT |n| (SPADCALL |l| (QREFELT $ 19)) . #1#)
      (EXIT
       (COND
        ((SPADCALL |n| (SPADCALL 2 (QREFELT $ 89)) (QREFELT $ 94))
         (SPADCALL |x| (QREFELT $ 80)))
        ('T (SPADCALL |x| (SPADCALL |n| (QREFELT $ 21)) (QREFELT $ 82))))))))) 

(DEFUN |AF;minPoly;KSup;25| (|k| $)
  (COND
   ((SPADCALL |k| (QREFELT $ 13) (QREFELT $ 111))
    (SPADCALL
     (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 112)))
               (SPADCALL
                (SPADCALL (SPADCALL |k| (QREFELT $ 112)) (QREFELT $ 19))
                (QREFELT $ 42))
               (QREFELT $ 31))
     (QREFELT $ 33)))
   ('T
    (SPADCALL (SPADCALL (|spadConstant| $ 56) 1 (QREFELT $ 125))
              (SPADCALL (SPADCALL |k| (QREFELT $ 28)) (QREFELT $ 126))
              (QREFELT $ 127))))) 

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

(DEFUN |AlgebraicFunction;| (|#1| |#2|)
  (PROG (|pv$| $ |dv$| DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|AlgebraicFunction|))
      (LETT DV$2 (|devaluate| |#2|) . #1#)
      (LETT |dv$| (LIST '|AlgebraicFunction| DV$1 DV$2) . #1#)
      (LETT $ (GETREFV 131) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#1|
                                                         '(|RetractableTo|
                                                           (|Integer|)))))
                      . #1#))
      (|haddProp| |$ConstructorCache| '|AlgebraicFunction| (LIST DV$1 DV$2)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (QSETREFV $ 8 '|%alg|)
      (QSETREFV $ 13 (SPADCALL '|rootOf| (QREFELT $ 12)))
      (QSETREFV $ 14 (SPADCALL '|nthRoot| (QREFELT $ 12)))
      (COND
       ((|HasCategory| |#1| '(|AlgebraicallyClosedField|))
        (PROGN
         (QSETREFV $ 29 (CONS (|dispatchFunction| |AF;inrootof;Sup2F;7|) $))))
       ('T
        (QSETREFV $ 29 (CONS (|dispatchFunction| |AF;inrootof;Sup2F;9|) $))))
      (SPADCALL (QREFELT $ 13) (CONS (|function| |AF;ialg|) $) (QREFELT $ 73))
      (SPADCALL (QREFELT $ 13) '|%specialDiff| (CONS (|function| |AF;dvalg|) $)
                (QREFELT $ 75))
      (SPADCALL (QREFELT $ 13) '|%specialDisp| (CONS (|function| |AF;dalg|) $)
                (QREFELT $ 75))
      (COND
       ((|testBitVector| |pv$| 1)
        (PROGN
         (QSETREFV $ 77 (SPADCALL '|%%var| (QREFELT $ 76)))
         NIL
         NIL
         NIL
         NIL
         NIL
         (QSETREFV $ 83 (CONS (|dispatchFunction| |AF;droot;LOf;11|) $))
         (QSETREFV $ 88 (CONS (|dispatchFunction| |AF;^;FFF;13|) $))
         (COND
          ((|HasCategory| |#1| '(|AlgebraicallyClosedField|))
           (QSETREFV $ 107 (CONS (|dispatchFunction| |AF;iroot;RIF;17|) $)))
          ('T
           (PROGN
            (COND
             ((|HasCategory| |#1| '(|RadicalCategory|))
              (COND
               ((|HasSignature| |#1|
                                (LIST '|imaginary| (LIST (|devaluate| |#1|))))
                (QSETREFV $ 107
                          (CONS (|dispatchFunction| |AF;iroot;RIF;18|) $)))
               ('T
                (QSETREFV $ 107
                          (CONS (|dispatchFunction| |AF;iroot;RIF;19|) $)))))
             ('T
              (QSETREFV $ 107
                        (CONS (|dispatchFunction| |AF;iroot;RIF;20|) $)))))))
         (QSETREFV $ 124
                   (CONS (|dispatchFunction| |AF;definingPolynomial;2F;22|) $))
         (QSETREFV $ 128 (CONS (|dispatchFunction| |AF;minPoly;KSup;23|) $))
         (SPADCALL (QREFELT $ 14) (CONS (|function| |AF;inroot|) $)
                   (QREFELT $ 73))
         (SPADCALL (QREFELT $ 14)
                   (LIST (CONS (|function| |AF;dvroot|) $)
                         (CONS (|function| |AF;lzero|) $))
                   (QREFELT $ 130))))
       ('T
        (PROGN
         (QSETREFV $ 83 (CONS (|dispatchFunction| |AF;droot;LOf;24|) $))
         (QSETREFV $ 128 (CONS (|dispatchFunction| |AF;minPoly;KSup;25|) $)))))
      (SPADCALL (QREFELT $ 14) '|%specialDisp| (ELT $ 83) (QREFELT $ 75))
      $)))) 

(MAKEPROP '|AlgebraicFunction| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) 'ALGOP
              (|BasicOperator|) (|Symbol|) (|CommonOperators|) (0 . |operator|)
              '|opalg| '|oproot| (|Boolean|) (5 . |has?|) |AF;belong?;BoB;1|
              (|List| 7) (11 . |second|) (|OutputForm|) (16 . |coerce|)
              (|Kernel| 7) (21 . |kernel|) (|Union| 7 '#1="failed")
              (|SparseUnivariatePolynomial| 7) (26 . |retractIfCan|)
              (|Kernel| $) (31 . |coerce|) (36 . |inrootof|) (|Fraction| 61)
              (42 . |univariate|) (|Fraction| 25) (48 . |numer|) (53 . |Zero|)
              (57 . |Zero|) (61 . |Zero|) (65 . |Zero|) (69 . |denom|)
              (|NonNegativeInteger|) (74 . |degree|) |AF;rootOf;SupSF;3|
              (79 . |retract|) (|List| $) (84 . |kernel|)
              (90 . |differentiate|) (|Mapping| 7 7) (96 . |map|) (102 . |elt|)
              (108 . |differentiate|) (113 . /) (119 . -) (124 . |is?|)
              |AF;operator;2Bo;6| (130 . |monomial?|) (135 . |One|)
              (139 . |One|) (143 . |reductum|) (148 . |leadingCoefficient|)
              (|Union| 10 '#1#) (153 . |retractIfCan|)
              (|SparseUnivariatePolynomial| $) (158 . |rootOf|)
              (164 . |coerce|) (|SparseUnivariatePolynomial| 6) (169 . |Zero|)
              (173 . =) (|Union| 6 '#1#) (179 . |retractIfCan|)
              (184 . |monomial|) (190 . +) (|Mapping| 7 18)
              (|BasicOperatorFunctions1| 7) (196 . |evaluate|) (|None|)
              (202 . |setProperty|) (209 . |coerce|) '|dumvar| (|Integer|)
              (214 . |retract|) (219 . |root|) (224 . |coerce|) (229 . |root|)
              (235 . |droot|) (|SparseMultivariatePolynomial| 6 22)
              (240 . |One|) (|Fraction| 78) (244 . /) (250 . ^)
              (256 . |coerce|) (261 . |numer|) (266 . |denom|) (271 . ^)
              (277 . *) (283 . =) (|SparseMultivariatePolynomial| 6 27)
              (289 . |denom|) (294 . =) (|Union| 78 '#1#)
              (300 . |retractIfCan|) (305 . |positive?|) (310 . |numer|)
              (315 . |coerce|) (320 . |One|) (324 . |coerce|) (329 . /)
              (335 . +) (341 . |iroot|)
              (|Record| (|:| |var| 27) (|:| |exponent| 78))
              (|Union| 108 '"failed") (347 . |isExpt|) (352 . |is?|)
              (358 . |argument|)
              (|Record| (|:| |exponent| 39) (|:| |coef| 7) (|:| |radicand| 7))
              (|PolynomialRoots| (|IndexedExponents| 22) 22 6 84 7)
              (363 . |qroot|) (|Union| $ '"failed") (369 . |exquo|)
              (375 . |nthRoot|) (381 . |smaller?|) (387 . |rroot|)
              (|Union| 27 '#1#) (393 . |retractIfCan|) (398 . -)
              (404 . |definingPolynomial|) (409 . |monomial|) (415 . |coerce|)
              (420 . -) (426 . |minPoly|) (|List| 71) (431 . |derivative|))
           '#(|rootOf| 437 |operator| 443 |minPoly| 448 |iroot| 453 |inrootof|
              459 |droot| 465 |definingPolynomial| 470 |belong?| 475 ^ 480)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 130
                                                 '(1 11 9 10 12 2 9 15 0 10 16
                                                   1 18 7 0 19 1 7 20 0 21 1 22
                                                   0 10 23 1 25 24 0 26 1 7 0
                                                   27 28 2 0 7 25 7 29 2 7 30 0
                                                   27 31 1 32 25 0 33 0 6 0 34
                                                   0 7 0 35 0 25 0 36 0 32 0 37
                                                   1 32 25 0 38 1 25 39 0 40 1
                                                   7 27 0 42 2 7 0 9 43 44 2 7
                                                   0 0 10 45 2 25 0 46 0 47 2
                                                   25 7 0 7 48 1 25 0 0 49 2 7
                                                   0 0 0 50 1 7 0 0 51 2 9 15 0
                                                   10 52 1 25 15 0 54 0 6 0 55
                                                   0 7 0 56 1 25 0 0 57 1 25 7
                                                   0 58 1 7 59 0 60 2 6 0 61 10
                                                   62 1 7 0 6 63 0 64 0 65 2 25
                                                   15 0 0 66 1 7 67 0 68 2 64 0
                                                   6 39 69 2 64 0 0 0 70 2 72 9
                                                   9 71 73 3 9 0 0 10 74 75 1 7
                                                   0 10 76 1 7 78 0 79 1 20 0 0
                                                   80 1 78 20 0 81 2 20 0 0 0
                                                   82 1 0 20 18 83 0 84 0 85 2
                                                   86 0 78 78 87 2 0 7 7 86 88
                                                   1 7 0 78 89 1 86 78 0 90 1
                                                   86 78 0 91 2 7 0 0 78 92 2 7
                                                   0 0 0 93 2 7 15 0 0 94 1 7
                                                   95 0 96 2 84 15 0 0 97 1 84
                                                   98 0 99 1 78 15 0 100 1 7 95
                                                   0 101 1 7 0 95 102 0 86 0
                                                   103 1 86 0 78 104 2 86 0 0 0
                                                   105 2 7 0 0 0 106 2 0 7 6 78
                                                   107 1 7 109 0 110 2 22 15 0
                                                   9 111 1 22 18 0 112 2 114
                                                   113 86 39 115 2 78 116 0 0
                                                   117 2 6 0 0 78 118 2 6 15 0
                                                   0 119 2 114 113 6 39 120 1 7
                                                   121 0 122 2 7 0 0 0 123 1 0
                                                   7 7 124 2 25 0 7 39 125 1 25
                                                   0 7 126 2 25 0 0 0 127 1 0
                                                   25 22 128 2 72 9 9 129 130 2
                                                   0 7 25 10 41 1 0 9 9 53 1 1
                                                   25 22 128 2 1 7 6 78 107 2 0
                                                   7 25 7 29 1 0 20 18 83 1 1 7
                                                   7 124 1 0 15 9 17 2 1 7 7 86
                                                   88)))))
           '|lookupComplete|)) 
