
(/VERSIONCHECK 2) 

(DEFUN |AF;belong?;BoB;1| (|op| $)
  (SPADCALL |op| (QREFELT $ 11) (QREFELT $ 18))) 

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

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

(DEFUN |AF;dvalg| (|l| |x| $)
  (PROG (|p| |alpha|)
    (RETURN
      (SEQ (LETT |p|
                 (SPADCALL
                     (SPADCALL (|SPADfirst| |l|)
                         (SPADCALL (SPADCALL |l| (QREFELT $ 21))
                             (QREFELT $ 44))
                         (QREFELT $ 33))
                     (QREFELT $ 35))
                 . #0=(|AF;dvalg|))
           (LETT |alpha|
                 (SPADCALL (QREFELT $ 15) |l| (QREFELT $ 46)) . #0#)
           (EXIT (SPADCALL
                     (SPADCALL
                         (SPADCALL
                             (SPADCALL
                                 (CONS #'|AF;dvalg!0| (VECTOR $ |x|))
                                 |p| (QREFELT $ 50))
                             |alpha| (QREFELT $ 51))
                         (SPADCALL (SPADCALL |p| (QREFELT $ 52))
                             |alpha| (QREFELT $ 51))
                         (QREFELT $ 53))
                     (QREFELT $ 54))))))) 

(DEFUN |AF;dvalg!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 47))) 

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

(DEFUN |AF;operator;2Bo;6| (|op| $)
  (COND
    ((SPADCALL |op| (SPADCALL "rootOf" (QREFELT $ 10)) (QREFELT $ 55))
     (QREFELT $ 15))
    ((SPADCALL |op| (SPADCALL "nthRoot" (QREFELT $ 10)) (QREFELT $ 55))
     (QREFELT $ 16))
    ('T (|error| "Unknown operator")))) 

(DEFUN |AF;inrootof;Sup2F;7| (|q| |x| $)
  (PROG (|d| #0=#:G1866 |rx| |r| #1=#:G1865)
    (RETURN
      (SEQ (COND
             ((SPADCALL |q| (QREFELT $ 57)) (|spadConstant| $ 37))
             ('T
              (SEQ (EXIT (SEQ (SEQ (LETT |d|
                                    (SPADCALL |q| (QREFELT $ 42))
                                    . #2=(|AF;inrootof;Sup2F;7|))
                                   (EXIT
                                    (COND
                                      ((NULL (< 0 |d|))
                                       (PROGN
                                         (LETT #0#
                                          (|error|
                                           "rootOf: constant polynomial") . #2#)
                                         (GO #0#))))))
                              (EXIT (COND
                                      ((EQL |d| 1)
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |q| (QREFELT $ 60))
                                          (QREFELT $ 61))
                                         (SPADCALL |q| (QREFELT $ 61))
                                         (QREFELT $ 53))
                                        (QREFELT $ 54)))
                                      ('T
                                       (SEQ
                                        (EXIT
                                         (SEQ
                                          (SEQ
                                           (LETT |rx|
                                            (SPADCALL |x|
                                             (QREFELT $ 63)) . #2#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |rx| 0)
                                               (SEQ
                                                (LETT |r|
                                                 (|AF;UP2R| |q| $) . #2#)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |r| 0)
                                                    (PROGN
                                                      (LETT #1#
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (QCDR |r|)
                                                         (QCDR |rx|)
                                                         (QREFELT $ 65))
                                                        (QREFELT $ 66)) . #2#)
                                                      (GO #1#))))))))))
                                          (EXIT
                                           (SPADCALL (QREFELT $ 15)
                                            (LIST
                                             (SPADCALL |q| |x|
                                              (QREFELT $ 51))
                                             |x|)
                                            (QREFELT $ 46)))))
                                        #1# (EXIT #1#)))))))
                   #0# (EXIT #0#)))))))) 

(DEFUN |AF;UP2R| (|p| $)
  (PROG (|r| #0=#:G1882 |ans|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ans| (|spadConstant| $ 68)
                            . #1=(|AF;UP2R|))
                      (SEQ G190
                           (COND
                             ((NULL (COND
                                      ((SPADCALL |p|
                                        (|spadConstant| $ 39)
                                        (QREFELT $ 69))
                                       'NIL)
                                      ('T 'T)))
                              (GO G191)))
                           (SEQ (LETT |r|
                                      (SPADCALL
                                       (SPADCALL |p| (QREFELT $ 61))
                                       (QREFELT $ 71)) . #1#)
                                (EXIT (COND
                                        ((QEQCAR |r| 1)
                                         (PROGN
                                           (LETT #0#
                                            (CONS 1 "failed") . #1#)
                                           (GO #0#)))
                                        ('T
                                         (SEQ
                                          (LETT |ans|
                                           (SPADCALL |ans|
                                            (SPADCALL (QCDR |r|)
                                             (SPADCALL |p|
                                              (QREFELT $ 42))
                                             (QREFELT $ 72))
                                            (QREFELT $ 73)) . #1#)
                                          (EXIT
                                           (LETT |p|
                                            (SPADCALL |p|
                                             (QREFELT $ 60)) . #1#)))))))
                           NIL (GO G190) G191 (EXIT NIL))
                      (EXIT (CONS 0 |ans|))))
           #0# (EXIT #0#))))) 

(DEFUN |AF;inrootof;Sup2F;9| (|q| |x| $)
  (PROG (|d| #0=#:G1884)
    (RETURN
      (SEQ (COND
             ((SPADCALL |q| (QREFELT $ 57)) (|spadConstant| $ 37))
             ('T
              (SEQ (EXIT (SEQ (SEQ (LETT |d|
                                    (SPADCALL |q| (QREFELT $ 42))
                                    . #1=(|AF;inrootof;Sup2F;9|))
                                   (EXIT
                                    (COND
                                      ((NULL (< 0 |d|))
                                       (PROGN
                                         (LETT #0#
                                          (|error|
                                           "rootOf: constant polynomial") . #1#)
                                         (GO #0#))))))
                              (EXIT (COND
                                      ((EQL |d| 1)
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |q| (QREFELT $ 60))
                                          (QREFELT $ 61))
                                         (SPADCALL |q| (QREFELT $ 61))
                                         (QREFELT $ 53))
                                        (QREFELT $ 54)))
                                      ('T
                                       (SPADCALL (QREFELT $ 15)
                                        (LIST
                                         (SPADCALL |q| |x|
                                          (QREFELT $ 51))
                                         |x|)
                                        (QREFELT $ 46)))))))
                   #0# (EXIT #0#)))))))) 

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

(DEFUN |AF;droot;LOf;11| (|l| $)
  (PROG (|x| |n|)
    (RETURN
      (SEQ (LETT |x| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 23))
                 . #0=(|AF;droot;LOf;11|))
           (LETT |n|
                 (SPADCALL (SPADCALL |l| (QREFELT $ 21))
                     (QREFELT $ 82)) . #0#)
           (EXIT (COND
                   ((EQL |n| 2) (SPADCALL |x| (QREFELT $ 83)))
                   ('T
                    (SPADCALL |x| (SPADCALL |n| (QREFELT $ 84))
                        (QREFELT $ 85))))))))) 

(DEFUN |AF;dvroot| (|l| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n|
                 (SPADCALL (SPADCALL |l| (QREFELT $ 21))
                     (QREFELT $ 82))
                 |AF;dvroot|)
           (EXIT (SPADCALL
                     (SPADCALL (|SPADfirst| |l|)
                         (SPADCALL (- 1 |n|) |n| (QREFELT $ 90))
                         (QREFELT $ 91))
                     (SPADCALL |n| (QREFELT $ 92)) (QREFELT $ 53))))))) 

(DEFUN |AF;**;FFF;13| (|x| |q| $)
  (PROG (|qr|)
    (RETURN
      (SEQ (LETT |qr|
                 (DIVIDE2 (SPADCALL |q| (QREFELT $ 93))
                          (SPADCALL |q| (QREFELT $ 94)))
                 |AF;**;FFF;13|)
           (EXIT (SPADCALL (SPADCALL |x| (QCAR |qr|) (QREFELT $ 95))
                     (SPADCALL
                         (|AF;inroot|
                             (LIST |x|
                                   (SPADCALL
                                    (SPADCALL |q| (QREFELT $ 94))
                                    (QREFELT $ 92)))
                             $)
                         (QCDR |qr|) (QREFELT $ 95))
                     (QREFELT $ 96))))))) 

(DEFUN |AF;hackroot| (|x| |n| $)
  (PROG (|dx| |rx| #0=#:G1906)
    (RETURN
      (SEQ (EXIT (COND
                   ((OR (EQL |n| 1)
                        (SPADCALL |x| (|spadConstant| $ 59)
                            (QREFELT $ 97)))
                    |x|)
                   ('T
                    (SEQ (SEQ (LETT |dx| (SPADCALL |x| (QREFELT $ 99))
                                    . #1=(|AF;hackroot|))
                              (EXIT (COND
                                      ((NULL
                                        (SPADCALL |dx|
                                         (|spadConstant| $ 88)
                                         (QREFELT $ 100)))
                                       (SEQ
                                        (LETT |rx|
                                         (SPADCALL |dx|
                                          (QREFELT $ 102)) . #1#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |rx| 0)
                                            (COND
                                              ((SPADCALL (QCDR |rx|)
                                                (QREFELT $ 103))
                                               (PROGN
                                                 (LETT #0#
                                                  (SPADCALL
                                                   (|AF;hackroot|
                                                    (SPADCALL
                                                     (SPADCALL |x|
                                                      (QREFELT $ 104))
                                                     (QREFELT $ 105))
                                                    |n| $)
                                                   (|AF;hackroot|
                                                    (SPADCALL
                                                     (QCDR |rx|)
                                                     (QREFELT $ 92))
                                                    |n| $)
                                                   (QREFELT $ 53)) . #1#)
                                                 (GO #0#))))))))))))
                         (COND
                           ((SPADCALL |x|
                                (SPADCALL (|spadConstant| $ 59)
                                    (QREFELT $ 54))
                                (QREFELT $ 97))
                            (COND
                              ((EQL |n| 4)
                               (EXIT (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 59)
                                         (QREFELT $ 54))
                                        (SPADCALL
                                         (|spadConstant| $ 106)
                                         (SPADCALL 2 (QREFELT $ 107))
                                         (QREFELT $ 108))
                                        (QREFELT $ 91))
                                       (|spadConstant| $ 59)
                                       (QREFELT $ 109))
                                      (SPADCALL
                                       (SPADCALL 2 (QREFELT $ 92))
                                       (SPADCALL (|spadConstant| $ 106)
                                        (SPADCALL 2 (QREFELT $ 107))
                                        (QREFELT $ 108))
                                       (QREFELT $ 91))
                                      (QREFELT $ 53)))))))
                         (EXIT (SPADCALL (QREFELT $ 16)
                                   (LIST |x|
                                    (SPADCALL |n| (QREFELT $ 92)))
                                   (QREFELT $ 46)))))))
           #0# (EXIT #0#))))) 

(DEFUN |AF;inroot| (|l| $)
  (PROG (|n| |x| #0=#:G1924 |r| |u| #1=#:G1918 |pr|)
    (RETURN
      (SEQ (COND
             ((ZEROP (LETT |n|
                           (SPADCALL (SPADCALL |l| (QREFELT $ 21))
                               (QREFELT $ 82))
                           . #2=(|AF;inroot|)))
              (|error| "root: exponent = 0"))
             ('T
              (SEQ (EXIT (SEQ (SEQ (LETT |x| (|SPADfirst| |l|) . #2#)
                                   (EXIT
                                    (COND
                                      ((OR
                                        (SPADCALL |x|
                                         (|spadConstant| $ 59)
                                         (QREFELT $ 97))
                                        (EQL |n| 1))
                                       (PROGN
                                         (LETT #0# |x| . #2#)
                                         (GO #0#))))))
                              (LETT |r|
                                    (SPADCALL |x| (QREFELT $ 71)) . #2#)
                              (EXIT (COND
                                      ((QEQCAR |r| 0)
                                       (SPADCALL (QCDR |r|) |n|
                                        (QREFELT $ 110)))
                                      ((QEQCAR
                                        (LETT |u|
                                         (SPADCALL |x| (QREFELT $ 113)) . #2#)
                                        0)
                                       (SEQ
                                        (LETT |pr|
                                         (PROG2 (LETT #1# |u| . #2#)
                                          (QCDR #1#)
                                           (|check-union|
                                            (QEQCAR #1# 0)
                                            (|Record|
                                             (|:| |var|
                                              (|Kernel| (QREFELT $ 7)))
                                             (|:| |exponent|
                                              (|Integer|)))
                                            #1#)) . #2#)
                                        (COND
                                          ((SPADCALL (QCAR |pr|)
                                            (QREFELT $ 16)
                                            (QREFELT $ 114))
                                           (COND
                                             ((EQL
                                               (LENGTH
                                                (SPADCALL (QCAR |pr|)
                                                 (QREFELT $ 115)))
                                               2)
                                              (EXIT
                                               (SPADCALL
                                                (|SPADfirst|
                                                 (SPADCALL (QCAR |pr|)
                                                  (QREFELT $ 115)))
                                                (SPADCALL (QCDR |pr|)
                                                 (* |n|
                                                  (SPADCALL
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (QCAR |pr|)
                                                     (QREFELT $ 115))
                                                    (QREFELT $ 21))
                                                   (QREFELT $ 82)))
                                                 (QREFELT $ 90))
                                                (QREFELT $ 91)))))))
                                        (EXIT
                                         (|AF;inroot0| |x| |n| 'NIL
                                          'NIL $))))
                                      ('T
                                       (|AF;inroot0| |x| |n| 'NIL 'NIL
                                        $))))))
                   #0# (EXIT #0#)))))))) 

(DEFUN |AF;inroot0| (|x| |n| |num?| |den?| $)
  (PROG (|rn| |rd| #0=#:G1930 #1=#:G1934 #2=#:G1939 |rec| #3=#:G1928)
    (RETURN
      (SEQ (LETT |rn|
                 (COND
                   (|num?| (CONS 1 "failed"))
                   (#4='T
                    (SPADCALL (SPADCALL |x| (QREFELT $ 104))
                        (QREFELT $ 102))))
                 . #5=(|AF;inroot0|))
           (LETT |rd|
                 (COND
                   (|den?| (CONS 1 "failed"))
                   (#4#
                    (SPADCALL (SPADCALL |x| (QREFELT $ 99))
                        (QREFELT $ 102)))) . #5#)
           (COND
             ((QEQCAR |rn| 0)
              (COND
                ((QEQCAR |rd| 0)
                 (EXIT (SEQ (LETT |rec|
                                  (SPADCALL
                                      (SPADCALL (QCDR |rn|) (QCDR |rd|)
                                       (QREFELT $ 90))
                                      (PROG1 (LETT #0# |n| . #5#)
                                        (|check-subtype| (>= #0# 0)
                                         '(|NonNegativeInteger|) #0#))
                                      (QREFELT $ 118)) . #5#)
                            (EXIT (SPADCALL (QVELT |rec| 1)
                                      (|AF;hackroot| (QVELT |rec| 2)
                                       (QVELT |rec| 0) $)
                                      (QREFELT $ 96)))))))))
           (EXIT (COND
                   ((QEQCAR |rn| 0)
                    (SEQ (LETT |rec|
                               (SPADCALL
                                   (SPADCALL (QCDR |rn|)
                                    (QREFELT $ 107))
                                   (PROG1 (LETT #1# |n| . #5#)
                                     (|check-subtype| (>= #1# 0)
                                      '(|NonNegativeInteger|) #1#))
                                   (QREFELT $ 118)) . #5#)
                         (EXIT (SPADCALL (QVELT |rec| 1)
                                   (|AF;inroot0|
                                    (SPADCALL
                                     (SPADCALL (QVELT |rec| 2)
                                      (PROG2
                                       (LETT #3#
                                        (SPADCALL |n| (QVELT |rec| 0)
                                         (QREFELT $ 120)) . #5#)
                                       (QCDR #3#)
                                        (|check-union| (QEQCAR #3# 0)
                                         (|Integer|) #3#))
                                      (QREFELT $ 95))
                                     (SPADCALL
                                      (SPADCALL |x| (QREFELT $ 99))
                                      (QREFELT $ 105))
                                     (QREFELT $ 53))
                                    |n| 'T |den?| $)
                                   (QREFELT $ 96)))))
                   ((QEQCAR |rd| 0)
                    (SEQ (LETT |rec|
                               (SPADCALL
                                   (SPADCALL (QCDR |rd|)
                                    (QREFELT $ 107))
                                   (PROG1 (LETT #2# |n| . #5#)
                                     (|check-subtype| (>= #2# 0)
                                      '(|NonNegativeInteger|) #2#))
                                   (QREFELT $ 118)) . #5#)
                         (EXIT (SPADCALL
                                   (|AF;inroot0|
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |x| (QREFELT $ 104))
                                      (QREFELT $ 105))
                                     (SPADCALL (QVELT |rec| 2)
                                      (PROG2
                                       (LETT #3#
                                        (SPADCALL |n| (QVELT |rec| 0)
                                         (QREFELT $ 120)) . #5#)
                                       (QCDR #3#)
                                        (|check-union| (QEQCAR #3# 0)
                                         (|Integer|) #3#))
                                      (QREFELT $ 95))
                                     (QREFELT $ 53))
                                    |n| |num?| 'T $)
                                   (QVELT |rec| 1) (QREFELT $ 53)))))
                   (#4# (|AF;hackroot| |x| |n| $)))))))) 

(DEFUN |AF;iroot;RIF;17| (|r| |n| $)
  (SPADCALL (SPADCALL |r| |n| (QREFELT $ 121)) (QREFELT $ 66))) 

(DEFUN |AF;iroot;RIF;18| (|r| |n| $)
  (SPADCALL (SPADCALL |r| |n| (QREFELT $ 121)) (QREFELT $ 66))) 

(DEFUN |AF;iroot;RIF;19| (|r| |n| $)
  (COND
    ((OR (ODDP |n|)
         (NULL (SPADCALL |r| (|spadConstant| $ 36) (QREFELT $ 122))))
     (SPADCALL (SPADCALL |r| |n| (QREFELT $ 121)) (QREFELT $ 66)))
    ('T (|AF;iroot0| |r| |n| $)))) 

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

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

(DEFUN |AF;definingPolynomial;2F;22| (|x| $)
  (PROG (|r| |k|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 125))
                 . #0=(|AF;definingPolynomial;2F;22|))
           (EXIT (COND
                   ((QEQCAR |r| 0)
                    (COND
                      ((SPADCALL (LETT |k| (QCDR |r|) . #0#)
                           (QREFELT $ 15) (QREFELT $ 114))
                       (|SPADfirst| (SPADCALL |k| (QREFELT $ 115))))
                      ((SPADCALL |k| (QREFELT $ 16) (QREFELT $ 114))
                       (SPADCALL
                           (SPADCALL (QREFELT $ 80)
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |k| (QREFELT $ 115))
                                    (QREFELT $ 21))
                                   (QREFELT $ 82))
                               (QREFELT $ 95))
                           (|SPADfirst| (SPADCALL |k| (QREFELT $ 115)))
                           (QREFELT $ 126)))
                      ('T
                       (SPADCALL (QREFELT $ 80) |x| (QREFELT $ 126)))))
                   ('T (SPADCALL (QREFELT $ 80) |x| (QREFELT $ 126))))))))) 

(DEFUN |AF;minPoly;KSup;23| (|k| $)
  (PROG (#0=#:G1963)
    (RETURN
      (COND
        ((SPADCALL |k| (QREFELT $ 15) (QREFELT $ 114))
         (SPADCALL
             (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 115)))
                 (SPADCALL
                     (SPADCALL (SPADCALL |k| (QREFELT $ 115))
                         (QREFELT $ 21))
                     (QREFELT $ 44))
                 (QREFELT $ 33))
             (QREFELT $ 35)))
        ((SPADCALL |k| (QREFELT $ 16) (QREFELT $ 114))
         (SPADCALL
             (SPADCALL (|spadConstant| $ 59)
                 (PROG1 (LETT #0#
                              (SPADCALL
                                  (SPADCALL
                                      (SPADCALL |k| (QREFELT $ 115))
                                      (QREFELT $ 21))
                                  (QREFELT $ 82))
                              |AF;minPoly;KSup;23|)
                   (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                       #0#))
                 (QREFELT $ 128))
             (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 115)))
                 (QREFELT $ 129))
             (QREFELT $ 130)))
        ('T
         (SPADCALL (SPADCALL (|spadConstant| $ 59) 1 (QREFELT $ 128))
             (SPADCALL (SPADCALL |k| (QREFELT $ 30)) (QREFELT $ 129))
             (QREFELT $ 130))))))) 

(DEFUN |AF;droot;LOf;24| (|l| $)
  (PROG (|x| |n|)
    (RETURN
      (SEQ (LETT |x| (SPADCALL (|SPADfirst| |l|) (QREFELT $ 23))
                 . #0=(|AF;droot;LOf;24|))
           (LETT |n| (SPADCALL |l| (QREFELT $ 21)) . #0#)
           (EXIT (COND
                   ((SPADCALL |n| (SPADCALL 2 (QREFELT $ 92))
                        (QREFELT $ 97))
                    (SPADCALL |x| (QREFELT $ 83)))
                   ('T
                    (SPADCALL |x| (SPADCALL |n| (QREFELT $ 23))
                        (QREFELT $ 85))))))))) 

(DEFUN |AF;minPoly;KSup;25| (|k| $)
  (COND
    ((SPADCALL |k| (QREFELT $ 15) (QREFELT $ 114))
     (SPADCALL
         (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 115)))
             (SPADCALL
                 (SPADCALL (SPADCALL |k| (QREFELT $ 115))
                     (QREFELT $ 21))
                 (QREFELT $ 44))
             (QREFELT $ 33))
         (QREFELT $ 35)))
    ('T
     (SPADCALL (SPADCALL (|spadConstant| $ 59) 1 (QREFELT $ 128))
         (SPADCALL (SPADCALL |k| (QREFELT $ 30)) (QREFELT $ 129))
         (QREFELT $ 130))))) 

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

(DEFUN |AlgebraicFunction;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|AlgebraicFunction|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|AlgebraicFunction| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 134) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1|
                                '(|RetractableTo| (|Integer|))))) . #0#))
        (|haddProp| |$ConstructorCache| '|AlgebraicFunction|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 11 (SPADCALL "%alg" (QREFELT $ 10)))
        (QSETREFV $ 15
            (SPADCALL (SPADCALL "rootOf" (QREFELT $ 10))
                (QREFELT $ 14)))
        (QSETREFV $ 16
            (SPADCALL (SPADCALL "nthRoot" (QREFELT $ 10))
                (QREFELT $ 14)))
        (COND
          ((|HasCategory| |#1| '(|AlgebraicallyClosedField|))
           (PROGN
             (QSETREFV $ 31
                 (CONS (|dispatchFunction| |AF;inrootof;Sup2F;7|) $))))
          ('T
           (QSETREFV $ 31
               (CONS (|dispatchFunction| |AF;inrootof;Sup2F;9|) $))))
        (SPADCALL (QREFELT $ 15) (CONS (|function| |AF;ialg|) $)
            (QREFELT $ 76))
        (SPADCALL (QREFELT $ 15)
            (SPADCALL "%specialDiff" (QREFELT $ 10))
            (CONS (|function| |AF;dvalg|) $) (QREFELT $ 78))
        (SPADCALL (QREFELT $ 15)
            (SPADCALL "%specialDisp" (QREFELT $ 10))
            (CONS (|function| |AF;dalg|) $) (QREFELT $ 78))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 80
                 (SPADCALL (SPADCALL "%%var" (QREFELT $ 10))
                     (QREFELT $ 79)))
             NIL
             NIL
             NIL
             NIL
             NIL
             (QSETREFV $ 86
                 (CONS (|dispatchFunction| |AF;droot;LOf;11|) $))
             (QSETREFV $ 91
                 (CONS (|dispatchFunction| |AF;**;FFF;13|) $))
             (COND
               ((|HasCategory| |#1| '(|AlgebraicallyClosedField|))
                (QSETREFV $ 110
                    (CONS (|dispatchFunction| |AF;iroot;RIF;17|) $)))
               ('T
                (PROGN
                  (COND
                    ((|HasCategory| |#1| '(|RadicalCategory|))
                     (COND
                       ((|HasSignature| |#1|
                            (LIST '|imaginary|
                                  (LIST (|devaluate| |#1|))))
                        (QSETREFV $ 110
                            (CONS (|dispatchFunction|
                                      |AF;iroot;RIF;18|)
                                  $)))
                       ('T
                        (QSETREFV $ 110
                            (CONS (|dispatchFunction|
                                      |AF;iroot;RIF;19|)
                                  $)))))
                    ('T
                     (QSETREFV $ 110
                         (CONS (|dispatchFunction| |AF;iroot;RIF;20|)
                               $)))))))
             (QSETREFV $ 127
                 (CONS (|dispatchFunction|
                           |AF;definingPolynomial;2F;22|)
                       $))
             (QSETREFV $ 131
                 (CONS (|dispatchFunction| |AF;minPoly;KSup;23|) $))
             (SPADCALL (QREFELT $ 16) (CONS (|function| |AF;inroot|) $)
                 (QREFELT $ 76))
             (SPADCALL (QREFELT $ 16)
                 (LIST (CONS (|function| |AF;dvroot|) $)
                       (CONS (|function| |AF;lzero|) $))
                 (QREFELT $ 133))))
          ('T
           (PROGN
             (QSETREFV $ 86
                 (CONS (|dispatchFunction| |AF;droot;LOf;24|) $))
             (QSETREFV $ 131
                 (CONS (|dispatchFunction| |AF;minPoly;KSup;25|) $)))))
        (SPADCALL (QREFELT $ 16)
            (SPADCALL "%specialDisp" (QREFELT $ 10)) (ELT $ 86)
            (QREFELT $ 78))
        $)))) 

(MAKEPROP '|AlgebraicFunction| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'ALGOP
             (|BasicOperator|) (|CommonOperators|) (5 . |operator|)
             '|opalg| '|oproot| (|Boolean|) (10 . |has?|)
             |AF;belong?;BoB;1| (|List| 7) (16 . |second|)
             (|OutputForm|) (21 . |coerce|) (|Kernel| 7)
             (26 . |kernel|) (|Union| 7 '"failed")
             (|SparseUnivariatePolynomial| 7) (31 . |retractIfCan|)
             (|Kernel| $) (36 . |coerce|) (41 . |inrootof|)
             (|Fraction| 64) (47 . |univariate|) (|Fraction| 27)
             (53 . |numer|) (58 . |Zero|) (62 . |Zero|) (66 . |denom|)
             (71 . |Zero|) (75 . |Zero|) (|NonNegativeInteger|)
             (79 . |degree|) |AF;rootOf;SupSF;3| (84 . |retract|)
             (|List| $) (89 . |kernel|) (95 . |differentiate|)
             (101 . |differentiate|) (|Mapping| 7 7) (107 . |map|)
             (113 . |elt|) (119 . |differentiate|) (124 . /) (130 . -)
             (135 . |is?|) |AF;operator;2Bo;6| (141 . |monomial?|)
             (146 . |One|) (150 . |One|) (154 . |reductum|)
             (159 . |leadingCoefficient|) (|Union| 9 '"failed")
             (164 . |retractIfCan|) (|SparseUnivariatePolynomial| $)
             (169 . |rootOf|) (175 . |coerce|)
             (|SparseUnivariatePolynomial| 6) (180 . |Zero|) (184 . =)
             (|Union| 6 '"failed") (190 . |retractIfCan|)
             (195 . |monomial|) (201 . +) (|Mapping| 7 20)
             (|BasicOperatorFunctions1| 7) (207 . |evaluate|) (|None|)
             (213 . |setProperty|) (220 . |coerce|) '|dumvar|
             (|Integer|) (225 . |retract|) (230 . |root|)
             (235 . |coerce|) (240 . |root|) (246 . |droot|)
             (|SparseMultivariatePolynomial| 6 24) (251 . |One|)
             (|Fraction| 81) (255 . /) (261 . **) (267 . |coerce|)
             (272 . |numer|) (277 . |denom|) (282 . **) (288 . *)
             (294 . =) (|SparseMultivariatePolynomial| 6 29)
             (300 . |denom|) (305 . =) (|Union| 81 '"failed")
             (311 . |retractIfCan|) (316 . |positive?|) (321 . |numer|)
             (326 . |coerce|) (331 . |One|) (335 . |coerce|) (340 . /)
             (346 . +) (352 . |iroot|)
             (|Record| (|:| |var| 29) (|:| |exponent| 81))
             (|Union| 111 '"failed") (358 . |isExpt|) (363 . |is?|)
             (369 . |argument|)
             (|Record| (|:| |exponent| 41) (|:| |coef| 7)
                 (|:| |radicand| 7))
             (|PolynomialRoots| (|IndexedExponents| 24) 24 6 87 7)
             (374 . |qroot|) (|Union| $ '"failed") (380 . |exquo|)
             (386 . |nthRoot|) (392 . <) (398 . |rroot|)
             (|Union| 29 '"failed") (404 . |retractIfCan|) (409 . -)
             (415 . |definingPolynomial|) (420 . |monomial|)
             (426 . |coerce|) (431 . -) (437 . |minPoly|) (|List| 74)
             (442 . |derivative|))
          '#(|rootOf| 448 |operator| 454 |minPoly| 459 |iroot| 464
             |inrootof| 470 |droot| 476 |definingPolynomial| 481
             |belong?| 486 ** 491)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 133
                                '(1 9 0 8 10 1 13 12 9 14 2 12 17 0 9
                                  18 1 20 7 0 21 1 7 22 0 23 1 24 0 9
                                  25 1 27 26 0 28 1 7 0 29 30 2 0 7 27
                                  7 31 2 7 32 0 29 33 1 34 27 0 35 0 6
                                  0 36 0 7 0 37 1 34 27 0 38 0 27 0 39
                                  0 34 0 40 1 27 41 0 42 1 7 29 0 44 2
                                  7 0 12 45 46 2 7 0 0 9 47 2 27 0 0 9
                                  48 2 27 0 49 0 50 2 27 7 0 7 51 1 27
                                  0 0 52 2 7 0 0 0 53 1 7 0 0 54 2 12
                                  17 0 9 55 1 27 17 0 57 0 6 0 58 0 7 0
                                  59 1 27 0 0 60 1 27 7 0 61 1 7 62 0
                                  63 2 6 0 64 9 65 1 7 0 6 66 0 67 0 68
                                  2 27 17 0 0 69 1 7 70 0 71 2 67 0 6
                                  41 72 2 67 0 0 0 73 2 75 12 12 74 76
                                  3 12 0 0 9 77 78 1 7 0 9 79 1 7 81 0
                                  82 1 22 0 0 83 1 81 22 0 84 2 22 0 0
                                  0 85 1 0 22 20 86 0 87 0 88 2 89 0 81
                                  81 90 2 0 7 7 89 91 1 7 0 81 92 1 89
                                  81 0 93 1 89 81 0 94 2 7 0 0 81 95 2
                                  7 0 0 0 96 2 7 17 0 0 97 1 7 98 0 99
                                  2 87 17 0 0 100 1 87 101 0 102 1 81
                                  17 0 103 1 7 98 0 104 1 7 0 98 105 0
                                  89 0 106 1 89 0 81 107 2 89 0 0 0 108
                                  2 7 0 0 0 109 2 0 7 6 81 110 1 7 112
                                  0 113 2 24 17 0 12 114 1 24 20 0 115
                                  2 117 116 89 41 118 2 81 119 0 0 120
                                  2 6 0 0 81 121 2 6 17 0 0 122 2 117
                                  116 6 41 123 1 7 124 0 125 2 7 0 0 0
                                  126 1 0 7 7 127 2 27 0 7 41 128 1 27
                                  0 7 129 2 27 0 0 0 130 1 0 27 24 131
                                  2 75 12 12 132 133 2 0 7 27 9 43 1 0
                                  12 12 56 1 1 27 24 131 2 1 7 6 81 110
                                  2 0 7 27 7 31 1 0 22 20 86 1 1 7 7
                                  127 1 0 17 12 19 2 1 7 7 89 91)))))
          '|lookupComplete|)) 
