
(/VERSIONCHECK 2) 

(DEFUN |EF;pi;F;1| ($)
  (SPADCALL (SPADCALL (QREFELT $ 42)) (QREFELT $ 43))) 

(DEFUN |EF;pi;F;2| ($) (QREFELT $ 44)) 

(DEFUN |EF;pi;F;3| ($) (QREFELT $ 44)) 

(DEFUN |EF;iisqrt1| ($) (QREFELT $ 49)) 

(DEFUN |EF;iisqrt2;F;5| ($)
  (SPADCALL (SPADCALL (SPADCALL 2 (QREFELT $ 54)) (QREFELT $ 55))
      (QREFELT $ 43))) 

(DEFUN |EF;iisqrt3;F;6| ($)
  (SPADCALL (SPADCALL (SPADCALL 3 (QREFELT $ 54)) (QREFELT $ 55))
      (QREFELT $ 43))) 

(DEFUN |EF;iisqrt2;F;7| ($) (QREFELT $ 56)) 

(DEFUN |EF;iisqrt3;F;8| ($) (QREFELT $ 57)) 

(DEFUN |EF;iisqrt2;F;9| ($) (QREFELT $ 56)) 

(DEFUN |EF;iisqrt3;F;10| ($) (QREFELT $ 57)) 

(DEFUN |EF;ipi| (|l| $) (SPADCALL (QREFELT $ 47))) 

(DEFUN |EF;log;2F;12| (|x| $)
  (SPADCALL (QREFELT $ 16) |x| (QREFELT $ 61))) 

(DEFUN |EF;exp;2F;13| (|x| $)
  (SPADCALL (QREFELT $ 17) |x| (QREFELT $ 61))) 

(DEFUN |EF;sin;2F;14| (|x| $)
  (SPADCALL (QREFELT $ 18) |x| (QREFELT $ 61))) 

(DEFUN |EF;cos;2F;15| (|x| $)
  (SPADCALL (QREFELT $ 19) |x| (QREFELT $ 61))) 

(DEFUN |EF;tan;2F;16| (|x| $)
  (SPADCALL (QREFELT $ 20) |x| (QREFELT $ 61))) 

(DEFUN |EF;cot;2F;17| (|x| $)
  (SPADCALL (QREFELT $ 21) |x| (QREFELT $ 61))) 

(DEFUN |EF;sec;2F;18| (|x| $)
  (SPADCALL (QREFELT $ 22) |x| (QREFELT $ 61))) 

(DEFUN |EF;csc;2F;19| (|x| $)
  (SPADCALL (QREFELT $ 23) |x| (QREFELT $ 61))) 

(DEFUN |EF;asin;2F;20| (|x| $)
  (SPADCALL (QREFELT $ 24) |x| (QREFELT $ 61))) 

(DEFUN |EF;acos;2F;21| (|x| $)
  (SPADCALL (QREFELT $ 25) |x| (QREFELT $ 61))) 

(DEFUN |EF;atan;2F;22| (|x| $)
  (SPADCALL (QREFELT $ 26) |x| (QREFELT $ 61))) 

(DEFUN |EF;acot;2F;23| (|x| $)
  (SPADCALL (QREFELT $ 27) |x| (QREFELT $ 61))) 

(DEFUN |EF;asec;2F;24| (|x| $)
  (SPADCALL (QREFELT $ 28) |x| (QREFELT $ 61))) 

(DEFUN |EF;acsc;2F;25| (|x| $)
  (SPADCALL (QREFELT $ 29) |x| (QREFELT $ 61))) 

(DEFUN |EF;sinh;2F;26| (|x| $)
  (SPADCALL (QREFELT $ 30) |x| (QREFELT $ 61))) 

(DEFUN |EF;cosh;2F;27| (|x| $)
  (SPADCALL (QREFELT $ 31) |x| (QREFELT $ 61))) 

(DEFUN |EF;tanh;2F;28| (|x| $)
  (SPADCALL (QREFELT $ 32) |x| (QREFELT $ 61))) 

(DEFUN |EF;coth;2F;29| (|x| $)
  (SPADCALL (QREFELT $ 33) |x| (QREFELT $ 61))) 

(DEFUN |EF;sech;2F;30| (|x| $)
  (SPADCALL (QREFELT $ 34) |x| (QREFELT $ 61))) 

(DEFUN |EF;csch;2F;31| (|x| $)
  (SPADCALL (QREFELT $ 35) |x| (QREFELT $ 61))) 

(DEFUN |EF;asinh;2F;32| (|x| $)
  (SPADCALL (QREFELT $ 36) |x| (QREFELT $ 61))) 

(DEFUN |EF;acosh;2F;33| (|x| $)
  (SPADCALL (QREFELT $ 37) |x| (QREFELT $ 61))) 

(DEFUN |EF;atanh;2F;34| (|x| $)
  (SPADCALL (QREFELT $ 38) |x| (QREFELT $ 61))) 

(DEFUN |EF;acoth;2F;35| (|x| $)
  (SPADCALL (QREFELT $ 39) |x| (QREFELT $ 61))) 

(DEFUN |EF;asech;2F;36| (|x| $)
  (SPADCALL (QREFELT $ 40) |x| (QREFELT $ 61))) 

(DEFUN |EF;acsch;2F;37| (|x| $)
  (SPADCALL (QREFELT $ 41) |x| (QREFELT $ 61))) 

(DEFUN |EF;kernel| (|x| $) (SPADCALL |x| (QREFELT $ 89))) 

(DEFUN |EF;posrem| (|n| |m| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (REMAINDER2 |n| |m|) |EF;posrem|)
           (EXIT (COND ((< |r| 0) (+ |r| |m|)) ('T |r|))))))) 

(DEFUN |EF;valueOrPole| (|rec| $)
  (COND ((QCDR |rec|) (|error| "Invalid argument")) ('T (QCAR |rec|)))) 

(DEFUN |EF;belong?;BoB;41| (|op| $)
  (SPADCALL |op| (QREFELT $ 11) (QREFELT $ 93))) 

(DEFUN |EF;operator;2Bo;42| (|op| $)
  (COND
    ((SPADCALL |op| (SPADCALL "pi" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 15))
    ((SPADCALL |op| (SPADCALL "log" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 16))
    ((SPADCALL |op| (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 17))
    ((SPADCALL |op| (SPADCALL "sin" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 18))
    ((SPADCALL |op| (SPADCALL "cos" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 19))
    ((SPADCALL |op| (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 20))
    ((SPADCALL |op| (SPADCALL "cot" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 21))
    ((SPADCALL |op| (SPADCALL "sec" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 22))
    ((SPADCALL |op| (SPADCALL "csc" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 23))
    ((SPADCALL |op| (SPADCALL "asin" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 24))
    ((SPADCALL |op| (SPADCALL "acos" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 25))
    ((SPADCALL |op| (SPADCALL "atan" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 26))
    ((SPADCALL |op| (SPADCALL "acot" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 27))
    ((SPADCALL |op| (SPADCALL "asec" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 28))
    ((SPADCALL |op| (SPADCALL "acsc" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 29))
    ((SPADCALL |op| (SPADCALL "sinh" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 30))
    ((SPADCALL |op| (SPADCALL "cosh" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 31))
    ((SPADCALL |op| (SPADCALL "tanh" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 32))
    ((SPADCALL |op| (SPADCALL "coth" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 33))
    ((SPADCALL |op| (SPADCALL "sech" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 34))
    ((SPADCALL |op| (SPADCALL "csch" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 35))
    ((SPADCALL |op| (SPADCALL "asinh" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 36))
    ((SPADCALL |op| (SPADCALL "acosh" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 37))
    ((SPADCALL |op| (SPADCALL "atanh" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 38))
    ((SPADCALL |op| (SPADCALL "acoth" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 39))
    ((SPADCALL |op| (SPADCALL "asech" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 40))
    ((SPADCALL |op| (SPADCALL "acsch" (QREFELT $ 10)) (QREFELT $ 95))
     (QREFELT $ 41))
    ('T (|error| "Not an elementary operator")))) 

(DEFUN |EF;dropfun| (|x| $)
  (PROG (|k| #0=#:G2053)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |k| (SPADCALL |x| (QREFELT $ 98))
                                 . #1=(|EF;dropfun|))
                           (EXIT (COND
                                   ((OR (QEQCAR |k| 1)
                                     (NULL
                                      (SPADCALL (QCDR |k|)
                                       (QREFELT $ 101))))
                                    (PROGN
                                      (LETT #0#
                                       (|spadConstant| $ 91) . #1#)
                                      (GO #0#))))))
                      (EXIT (|SPADfirst|
                                (SPADCALL (QCDR |k|) (QREFELT $ 101))))))
           #0# (EXIT #0#))))) 

(DEFUN |EF;specialTrigs;FLU;44| (|x| |values| $)
  (PROG (|y| |r| |q| |m| |n| |s|)
    (RETURN
      (SEQ (LETT |r|
                 (SPADCALL
                     (LETT |y|
                           (SPADCALL |x| (SPADCALL (QREFELT $ 47))
                               (QREFELT $ 102))
                           . #0=(|EF;specialTrigs;FLU;44|))
                     (QREFELT $ 104)) . #0#)
           (EXIT (COND
                   ((QEQCAR |r| 1) (CONS 1 "failed"))
                   (#1='T
                    (SEQ (LETT |q| (QCDR |r|) . #0#)
                         (LETT |m|
                               (SPADCALL |values| (QREFELT $ 107)) . #0#)
                         (LETT |n|
                               (SPADCALL |q| (QREFELT $ 110)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |n| 0)
                                  (COND
                                    ((SPADCALL (QCDR |n|)
                                      (QREFELT $ 111))
                                     (CONS 0
                                      (|EF;valueOrPole|
                                       (SPADCALL |values| |m|
                                        (QREFELT $ 112))
                                       $)))
                                    ('T
                                     (CONS 0
                                      (|EF;valueOrPole|
                                       (SPADCALL |values| (+ |m| 1)
                                        (QREFELT $ 112))
                                       $)))))
                                 (#1#
                                  (SEQ (LETT |n|
                                        (SPADCALL
                                         (SPADCALL 2 |q|
                                          (QREFELT $ 115))
                                         (QREFELT $ 110)) . #0#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR |n| 0)
                                           (SEQ
                                            (LETT |s|
                                             (|EF;posrem| (QCDR |n|) 4
                                              $) . #0#)
                                            (EXIT
                                             (COND
                                               ((EQL |s| 1)
                                                (CONS 0
                                                 (|EF;valueOrPole|
                                                  (SPADCALL |values|
                                                   (+ |m| 2)
                                                   (QREFELT $ 112))
                                                  $)))
                                               (#1#
                                                (CONS 0
                                                 (|EF;valueOrPole|
                                                  (SPADCALL |values|
                                                   (+ |m| 3)
                                                   (QREFELT $ 112))
                                                  $)))))))
                                          (#1#
                                           (SEQ
                                            (LETT |n|
                                             (SPADCALL
                                              (SPADCALL 3 |q|
                                               (QREFELT $ 115))
                                              (QREFELT $ 110)) . #0#)
                                            (EXIT
                                             (COND
                                               ((QEQCAR |n| 0)
                                                (SEQ
                                                 (LETT |s|
                                                  (|EF;posrem|
                                                   (QCDR |n|) 6 $) . #0#)
                                                 (EXIT
                                                  (COND
                                                    ((EQL |s| 1)
                                                     (CONS 0
                                                      (|EF;valueOrPole|
                                                       (SPADCALL
                                                        |values|
                                                        (+ |m| 4)
                                                        (QREFELT $ 112))
                                                       $)))
                                                    ((EQL |s| 2)
                                                     (CONS 0
                                                      (|EF;valueOrPole|
                                                       (SPADCALL
                                                        |values|
                                                        (+ |m| 5)
                                                        (QREFELT $ 112))
                                                       $)))
                                                    ((EQL |s| 4)
                                                     (CONS 0
                                                      (|EF;valueOrPole|
                                                       (SPADCALL
                                                        |values|
                                                        (+ |m| 6)
                                                        (QREFELT $ 112))
                                                       $)))
                                                    (#1#
                                                     (CONS 0
                                                      (|EF;valueOrPole|
                                                       (SPADCALL
                                                        |values|
                                                        (+ |m| 7)
                                                        (QREFELT $ 112))
                                                       $)))))))
                                               (#1#
                                                (SEQ
                                                 (LETT |n|
                                                  (SPADCALL
                                                   (SPADCALL 4 |q|
                                                    (QREFELT $ 115))
                                                   (QREFELT $ 110)) . #0#)
                                                 (EXIT
                                                  (COND
                                                    ((QEQCAR |n| 0)
                                                     (SEQ
                                                      (LETT |s|
                                                       (|EF;posrem|
                                                        (QCDR |n|) 8 $) . #0#)
                                                      (EXIT
                                                       (COND
                                                         ((EQL |s| 1)
                                                          (CONS 0
                                                           (|EF;valueOrPole|
                                                            (SPADCALL
                                                             |values|
                                                             (+ |m| 8)
                                                             (QREFELT $
                                                              112))
                                                            $)))
                                                         ((EQL |s| 3)
                                                          (CONS 0
                                                           (|EF;valueOrPole|
                                                            (SPADCALL
                                                             |values|
                                                             (+ |m| 9)
                                                             (QREFELT $
                                                              112))
                                                            $)))
                                                         ((EQL |s| 5)
                                                          (CONS 0
                                                           (|EF;valueOrPole|
                                                            (SPADCALL
                                                             |values|
                                                             (+ |m| 10)
                                                             (QREFELT $
                                                              112))
                                                            $)))
                                                         (#1#
                                                          (CONS 0
                                                           (|EF;valueOrPole|
                                                            (SPADCALL
                                                             |values|
                                                             (+ |m| 11)
                                                             (QREFELT $
                                                              112))
                                                            $)))))))
                                                    (#1#
                                                     (SEQ
                                                      (LETT |n|
                                                       (SPADCALL
                                                        (SPADCALL 6 |q|
                                                         (QREFELT $
                                                          115))
                                                        (QREFELT $ 110)) . #0#)
                                                      (EXIT
                                                       (COND
                                                         ((QEQCAR |n|
                                                           0)
                                                          (SEQ
                                                           (LETT |s|
                                                            (|EF;posrem|
                                                             (QCDR |n|)
                                                             12 $) . #0#)
                                                           (EXIT
                                                            (COND
                                                              ((EQL |s|
                                                                1)
                                                               (CONS 0
                                                                (|EF;valueOrPole|
                                                                 (SPADCALL
                                                                  |values|
                                                                  (+
                                                                   |m|
                                                                   12)
                                                                  (QREFELT
                                                                   $
                                                                   112))
                                                                 $)))
                                                              ((EQL |s|
                                                                5)
                                                               (CONS 0
                                                                (|EF;valueOrPole|
                                                                 (SPADCALL
                                                                  |values|
                                                                  (+
                                                                   |m|
                                                                   13)
                                                                  (QREFELT
                                                                   $
                                                                   112))
                                                                 $)))
                                                              ((EQL |s|
                                                                7)
                                                               (CONS 0
                                                                (|EF;valueOrPole|
                                                                 (SPADCALL
                                                                  |values|
                                                                  (+
                                                                   |m|
                                                                   14)
                                                                  (QREFELT
                                                                   $
                                                                   112))
                                                                 $)))
                                                              (#1#
                                                               (CONS 0
                                                                (|EF;valueOrPole|
                                                                 (SPADCALL
                                                                  |values|
                                                                  (+
                                                                   |m|
                                                                   15)
                                                                  (QREFELT
                                                                   $
                                                                   112))
                                                                 $)))))))
                                                         (#1#
                                                          (CONS 1
                                                           "failed")))))))))))))))))))))))))))) 

(PUT '|EF;specialTrigs;FLU;45| '|SPADreplace|
     '(XLAM (|x| |values|) (CONS 1 "failed"))) 

(DEFUN |EF;specialTrigs;FLU;45| (|x| |values| $) (CONS 1 "failed")) 

(DEFUN |EF;isin| (|x| $)
  (PROG (|y| |h| |s2| |s3| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 91))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) . #0=(|EF;isin|))
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 24)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 25)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL (|spadConstant| $ 50)
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 26)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 27)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 28)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 29)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ('T
                            (SEQ (LETT |h|
                                       (SPADCALL
                                        (SPADCALL 2 (QREFELT $ 58))
                                        (QREFELT $ 123)) . #0#)
                                 (LETT |s2|
                                       (SPADCALL |h|
                                        (SPADCALL (QREFELT $ 59))
                                        (QREFELT $ 124)) . #0#)
                                 (LETT |s3|
                                       (SPADCALL |h|
                                        (SPADCALL (QREFELT $ 60))
                                        (QREFELT $ 124)) . #0#)
                                 (LETT |u|
                                       (SPADCALL |x|
                                        (LIST
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL))
                                        (QREFELT $ 117)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 0) (QCDR |u|))
                                         ('T
                                          (SPADCALL (QREFELT $ 18) |x|
                                           (QREFELT $ 125)))))))))))))))) 

(DEFUN |EF;icos| (|x| $)
  (PROG (|y| |h| |s2| |s3| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 50))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) . #0=(|EF;icos|))
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 24)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL (|spadConstant| $ 50)
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 25)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 26)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 27)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 28)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 29)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ('T
                            (SEQ (LETT |h|
                                       (SPADCALL
                                        (SPADCALL 2 (QREFELT $ 58))
                                        (QREFELT $ 123)) . #0#)
                                 (LETT |s2|
                                       (SPADCALL |h|
                                        (SPADCALL (QREFELT $ 59))
                                        (QREFELT $ 124)) . #0#)
                                 (LETT |s3|
                                       (SPADCALL |h|
                                        (SPADCALL (QREFELT $ 60))
                                        (QREFELT $ 124)) . #0#)
                                 (LETT |u|
                                       (SPADCALL |x|
                                        (LIST
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL))
                                        (QREFELT $ 117)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 0) (QCDR |u|))
                                         ('T
                                          (SPADCALL (QREFELT $ 19) |x|
                                           (QREFELT $ 125)))))))))))))))) 

(DEFUN |EF;itan| (|x| $)
  (PROG (|y| |s3| |s33| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 91))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) . #0=(|EF;itan|))
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 24)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 25)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 26)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 27)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 28)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (|spadConstant| $ 50)
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 29)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ('T
                            (SEQ (LETT |s33|
                                       (SPADCALL
                                        (LETT |s3|
                                         (SPADCALL (QREFELT $ 60)) . #0#)
                                        (SPADCALL 3 (QREFELT $ 58))
                                        (QREFELT $ 102)) . #0#)
                                 (LETT |u|
                                       (SPADCALL |x|
                                        (LIST
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s33| 'NIL)
                                         (CONS
                                          (SPADCALL |s33|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s33| 'NIL)
                                         (CONS
                                          (SPADCALL |s33|
                                           (QREFELT $ 51))
                                          'NIL))
                                        (QREFELT $ 117)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 0) (QCDR |u|))
                                         ('T
                                          (SPADCALL (QREFELT $ 20) |x|
                                           (QREFELT $ 125)))))))))))))))) 

(DEFUN |EF;icot| (|x| $)
  (PROG (|y| |s3| |s33| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) . #0=(|EF;icot|))
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 24)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 25)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 26)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 27)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 28)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 29)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (|spadConstant| $ 50)
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ('T
                            (SEQ (LETT |s33|
                                       (SPADCALL
                                        (LETT |s3|
                                         (SPADCALL (QREFELT $ 60)) . #0#)
                                        (SPADCALL 3 (QREFELT $ 58))
                                        (QREFELT $ 102)) . #0#)
                                 (LETT |u|
                                       (SPADCALL |x|
                                        (LIST
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'NIL)
                                         (CONS |s33| 'NIL)
                                         (CONS
                                          (SPADCALL |s33|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s33| 'NIL)
                                         (CONS
                                          (SPADCALL |s33|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL))
                                        (QREFELT $ 117)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 0) (QCDR |u|))
                                         ('T
                                          (SPADCALL (QREFELT $ 21) |x|
                                           (QREFELT $ 125)))))))))))))))) 

(DEFUN |EF;isec| (|x| $)
  (PROG (|y| |s2| |s3| |h| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 50))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) . #0=(|EF;isec|))
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 24)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 25)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 26)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL (|spadConstant| $ 50)
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (QREFELT $ 122))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 27)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 28)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 29)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ('T
                            (SEQ (LETT |s2|
                                       (SPADCALL (QREFELT $ 59)) . #0#)
                                 (LETT |s3|
                                       (SPADCALL
                                        (SPADCALL 2
                                         (SPADCALL (QREFELT $ 60))
                                         (QREFELT $ 126))
                                        (SPADCALL 3 (QREFELT $ 58))
                                        (QREFELT $ 102)) . #0#)
                                 (LETT |h|
                                       (SPADCALL 2 (QREFELT $ 58)) . #0#)
                                 (LETT |u|
                                       (SPADCALL |x|
                                        (LIST
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS |h| 'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL))
                                        (QREFELT $ 117)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 0) (QCDR |u|))
                                         ('T
                                          (SPADCALL (QREFELT $ 22) |x|
                                           (QREFELT $ 125)))))))))))))))) 

(DEFUN |EF;icsc| (|x| $)
  (PROG (|y| |s2| |s3| |h| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) . #0=(|EF;icsc|))
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 24)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 25)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 26)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 27)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL (|spadConstant| $ 50)
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (QREFELT $ 122))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 28)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 29)
                                (QREFELT $ 119))
                            |y|)
                           ('T
                            (SEQ (LETT |s2|
                                       (SPADCALL (QREFELT $ 59)) . #0#)
                                 (LETT |s3|
                                       (SPADCALL
                                        (SPADCALL 2
                                         (SPADCALL (QREFELT $ 60))
                                         (QREFELT $ 126))
                                        (SPADCALL 3 (QREFELT $ 58))
                                        (QREFELT $ 102)) . #0#)
                                 (LETT |h|
                                       (SPADCALL 2 (QREFELT $ 58)) . #0#)
                                 (LETT |u|
                                       (SPADCALL |x|
                                        (LIST
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS (|spadConstant| $ 91)
                                          'T)
                                         (CONS (|spadConstant| $ 50)
                                          'NIL)
                                         (CONS
                                          (SPADCALL
                                           (|spadConstant| $ 50)
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS |s3| 'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s3|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS |s2| 'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |s2|
                                           (QREFELT $ 51))
                                          'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS |h| 'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL)
                                         (CONS
                                          (SPADCALL |h| (QREFELT $ 51))
                                          'NIL))
                                        (QREFELT $ 117)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR |u| 0) (QCDR |u|))
                                         ('T
                                          (SPADCALL (QREFELT $ 23) |x|
                                           (QREFELT $ 125)))))))))))))))) 

(DEFUN |EF;iasin| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 91))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (SPADCALL (SPADCALL (QREFELT $ 47))
                  (SPADCALL 2 (QREFELT $ 58)) (QREFELT $ 102)))
             ('T
              (COND
                ((SPADCALL |x|
                     (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                     (QREFELT $ 127))
                 (SPADCALL
                     (SPADCALL (SPADCALL (QREFELT $ 47))
                         (SPADCALL 2 (QREFELT $ 58)) (QREFELT $ 102))
                     (QREFELT $ 51)))
                ('T
                 (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;iasin|)
                      (EXIT (COND
                              ((SPADCALL |x| (QREFELT $ 18)
                                   (QREFELT $ 119))
                               |y|)
                              ((SPADCALL |x| (QREFELT $ 19)
                                   (QREFELT $ 119))
                               (SPADCALL
                                   (SPADCALL (SPADCALL (QREFELT $ 47))
                                    (SPADCALL 2 (QREFELT $ 58))
                                    (QREFELT $ 102))
                                   |y| (QREFELT $ 121)))
                              ('T
                               (SPADCALL (QREFELT $ 24) |x|
                                   (QREFELT $ 125)))))))))))))) 

(DEFUN |EF;iacos| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (SPADCALL (SPADCALL (QREFELT $ 47))
                  (SPADCALL 2 (QREFELT $ 58)) (QREFELT $ 102)))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (|spadConstant| $ 91))
             ('T
              (COND
                ((SPADCALL |x|
                     (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                     (QREFELT $ 127))
                 (SPADCALL (QREFELT $ 47)))
                ('T
                 (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;iacos|)
                      (EXIT (COND
                              ((SPADCALL |x| (QREFELT $ 18)
                                   (QREFELT $ 119))
                               (SPADCALL
                                   (SPADCALL (SPADCALL (QREFELT $ 47))
                                    (SPADCALL 2 (QREFELT $ 58))
                                    (QREFELT $ 102))
                                   |y| (QREFELT $ 121)))
                              ((SPADCALL |x| (QREFELT $ 19)
                                   (QREFELT $ 119))
                               |y|)
                              ('T
                               (SPADCALL (QREFELT $ 25) |x|
                                   (QREFELT $ 125)))))))))))))) 

(DEFUN |EF;iatan| (|x| $)
  (PROG (|r3| |y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 91))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (SPADCALL (SPADCALL (QREFELT $ 47))
                  (SPADCALL 4 (QREFELT $ 58)) (QREFELT $ 102)))
             ('T
              (COND
                ((SPADCALL |x|
                     (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                     (QREFELT $ 127))
                 (SPADCALL
                     (SPADCALL (SPADCALL (QREFELT $ 47))
                         (SPADCALL 4 (QREFELT $ 58)) (QREFELT $ 102))
                     (QREFELT $ 51)))
                ('T
                 (SEQ (LETT |r3| (SPADCALL (QREFELT $ 60))
                            . #0=(|EF;iatan|))
                      (EXIT (COND
                              ((SPADCALL |x| |r3| (QREFELT $ 127))
                               (SPADCALL (SPADCALL (QREFELT $ 47))
                                   (SPADCALL 3 (QREFELT $ 58))
                                   (QREFELT $ 102)))
                              ((SPADCALL
                                   (SPADCALL |x| |r3| (QREFELT $ 124))
                                   (|spadConstant| $ 50)
                                   (QREFELT $ 127))
                               (SPADCALL (SPADCALL (QREFELT $ 47))
                                   (SPADCALL 6 (QREFELT $ 58))
                                   (QREFELT $ 102)))
                              ('T
                               (SEQ (LETT |y|
                                     (|EF;dropfun| |x| $) . #0#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |x| (QREFELT $ 20)
                                         (QREFELT $ 119))
                                        |y|)
                                       ((SPADCALL |x| (QREFELT $ 21)
                                         (QREFELT $ 119))
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL (QREFELT $ 47))
                                          (SPADCALL 2 (QREFELT $ 58))
                                          (QREFELT $ 102))
                                         |y| (QREFELT $ 121)))
                                       ('T
                                        (SPADCALL (QREFELT $ 26) |x|
                                         (QREFELT $ 125)))))))))))))))))) 

(DEFUN |EF;iacot| (|x| $)
  (PROG (|r3| |xx| |y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (SPADCALL (SPADCALL (QREFELT $ 47))
                  (SPADCALL 2 (QREFELT $ 58)) (QREFELT $ 102)))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (SPADCALL (SPADCALL (QREFELT $ 47))
                  (SPADCALL 4 (QREFELT $ 58)) (QREFELT $ 102)))
             ('T
              (COND
                ((SPADCALL |x|
                     (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                     (QREFELT $ 127))
                 (SPADCALL
                     (SPADCALL 3 (SPADCALL (QREFELT $ 47))
                         (QREFELT $ 126))
                     (SPADCALL 4 (QREFELT $ 58)) (QREFELT $ 102)))
                ('T
                 (SEQ (LETT |r3| (SPADCALL (QREFELT $ 60))
                            . #0=(|EF;iacot|))
                      (EXIT (COND
                              ((SPADCALL |x| |r3| (QREFELT $ 127))
                               (SPADCALL (SPADCALL (QREFELT $ 47))
                                   (SPADCALL 6 (QREFELT $ 58))
                                   (QREFELT $ 102)))
                              ((SPADCALL |x|
                                   (SPADCALL |r3| (QREFELT $ 51))
                                   (QREFELT $ 127))
                               (SPADCALL
                                   (SPADCALL 5
                                    (SPADCALL (QREFELT $ 47))
                                    (QREFELT $ 126))
                                   (SPADCALL 6 (QREFELT $ 58))
                                   (QREFELT $ 102)))
                              ('T
                               (SEQ (LETT |xx|
                                     (SPADCALL |x| |r3|
                                      (QREFELT $ 124)) . #0#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |xx|
                                         (|spadConstant| $ 50)
                                         (QREFELT $ 127))
                                        (SPADCALL
                                         (SPADCALL (QREFELT $ 47))
                                         (SPADCALL 3 (QREFELT $ 58))
                                         (QREFELT $ 102)))
                                       ((SPADCALL |xx|
                                         (SPADCALL
                                          (|spadConstant| $ 50)
                                          (QREFELT $ 51))
                                         (QREFELT $ 127))
                                        (SPADCALL
                                         (SPADCALL 2
                                          (SPADCALL (QREFELT $ 47))
                                          (QREFELT $ 126))
                                         (SPADCALL 3 (QREFELT $ 58))
                                         (QREFELT $ 102)))
                                       ('T
                                        (SEQ
                                         (LETT |y|
                                          (|EF;dropfun| |x| $) . #0#)
                                         (EXIT
                                          (COND
                                            ((SPADCALL |x|
                                              (QREFELT $ 20)
                                              (QREFELT $ 119))
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL
                                                (QREFELT $ 47))
                                               (SPADCALL 2
                                                (QREFELT $ 58))
                                               (QREFELT $ 102))
                                              |y| (QREFELT $ 121)))
                                            ((SPADCALL |x|
                                              (QREFELT $ 21)
                                              (QREFELT $ 119))
                                             |y|)
                                            ('T
                                             (SPADCALL (QREFELT $ 27)
                                              |x| (QREFELT $ 125)))))))))))))))))))))) 

(DEFUN |EF;iasec| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (|spadConstant| $ 91))
             ('T
              (COND
                ((SPADCALL |x|
                     (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                     (QREFELT $ 127))
                 (SPADCALL (QREFELT $ 47)))
                ('T
                 (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;iasec|)
                      (EXIT (COND
                              ((SPADCALL |x| (QREFELT $ 22)
                                   (QREFELT $ 119))
                               |y|)
                              ((SPADCALL |x| (QREFELT $ 23)
                                   (QREFELT $ 119))
                               (SPADCALL
                                   (SPADCALL (SPADCALL (QREFELT $ 47))
                                    (SPADCALL 2 (QREFELT $ 58))
                                    (QREFELT $ 102))
                                   |y| (QREFELT $ 121)))
                              ('T
                               (SPADCALL (QREFELT $ 28) |x|
                                   (QREFELT $ 125)))))))))))))) 

(DEFUN |EF;iacsc| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (SPADCALL (SPADCALL (QREFELT $ 47))
                  (SPADCALL 2 (QREFELT $ 58)) (QREFELT $ 102)))
             ('T
              (COND
                ((SPADCALL |x|
                     (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                     (QREFELT $ 127))
                 (SPADCALL
                     (SPADCALL (SPADCALL (QREFELT $ 47))
                         (SPADCALL 2 (QREFELT $ 58)) (QREFELT $ 102))
                     (QREFELT $ 51)))
                ('T
                 (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;iacsc|)
                      (EXIT (COND
                              ((SPADCALL |x| (QREFELT $ 22)
                                   (QREFELT $ 119))
                               (SPADCALL
                                   (SPADCALL (SPADCALL (QREFELT $ 47))
                                    (SPADCALL 2 (QREFELT $ 58))
                                    (QREFELT $ 102))
                                   |y| (QREFELT $ 121)))
                              ((SPADCALL |x| (QREFELT $ 23)
                                   (QREFELT $ 119))
                               |y|)
                              ('T
                               (SPADCALL (QREFELT $ 29) |x|
                                   (QREFELT $ 125)))))))))))))) 

(DEFUN |EF;isinh| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 91))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;isinh|)
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 36)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 37)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (|spadConstant| $ 50)
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 38)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 39)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |y| 2 (QREFELT $ 120))
                                      (|spadConstant| $ 50)
                                      (QREFELT $ 121))
                                     (QREFELT $ 52))
                                    (QREFELT $ 123))
                                (QREFELT $ 51)))
                           ((SPADCALL |x| (QREFELT $ 40)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 41)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ('T
                            (SPADCALL (QREFELT $ 30) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;icosh| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 50))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;icosh|)
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 36)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (|spadConstant| $ 50)
                                    (QREFELT $ 122))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 37)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 38)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 39)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 40)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 41)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ('T
                            (SPADCALL (QREFELT $ 31) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;itanh| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 91))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;itanh|)
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 36)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 37)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 38)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 39)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 40)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL (|spadConstant| $ 50)
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 41)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ('T
                            (SPADCALL (QREFELT $ 32) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;icoth| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;icoth|)
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 36)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 37)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 38)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 39)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 40)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 41)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (|spadConstant| $ 50)
                                    (QREFELT $ 122))
                                (QREFELT $ 52)))
                           ('T
                            (SPADCALL (QREFELT $ 33) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;isech| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 50))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;isech|)
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 36)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 37)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 38)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL (|spadConstant| $ 50)
                                    (SPADCALL |y| 2 (QREFELT $ 120))
                                    (QREFELT $ 121))
                                (QREFELT $ 52)))
                           ((SPADCALL |x| (QREFELT $ 39)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 40)
                                (QREFELT $ 119))
                            |y|)
                           ((SPADCALL |x| (QREFELT $ 41)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 122))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ('T
                            (SPADCALL (QREFELT $ 34) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;icsch| (|x| $)
  (PROG (|y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ('T
              (SEQ (LETT |y| (|EF;dropfun| |x| $) |EF;icsch|)
                   (EXIT (COND
                           ((SPADCALL |x| (QREFELT $ 36)
                                (QREFELT $ 119))
                            (SPADCALL |y| (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 37)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 123)))
                           ((SPADCALL |x| (QREFELT $ 38)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                |y| (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 39)
                                (QREFELT $ 119))
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (|spadConstant| $ 50)
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 51)))
                           ((SPADCALL |x| (QREFELT $ 40)
                                (QREFELT $ 119))
                            (SPADCALL |y|
                                (SPADCALL
                                    (SPADCALL (|spadConstant| $ 50)
                                     (SPADCALL |y| 2 (QREFELT $ 120))
                                     (QREFELT $ 121))
                                    (QREFELT $ 52))
                                (QREFELT $ 102)))
                           ((SPADCALL |x| (QREFELT $ 41)
                                (QREFELT $ 119))
                            |y|)
                           ('T
                            (SPADCALL (QREFELT $ 35) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;iasinh| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 30) (QREFELT $ 119))
     (|SPADfirst| (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
    ('T (SPADCALL (QREFELT $ 36) |x| (QREFELT $ 125))))) 

(DEFUN |EF;iacosh| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 31) (QREFELT $ 119))
     (|SPADfirst| (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
    ('T (SPADCALL (QREFELT $ 37) |x| (QREFELT $ 125))))) 

(DEFUN |EF;iatanh| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 32) (QREFELT $ 119))
     (|SPADfirst| (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
    ('T (SPADCALL (QREFELT $ 38) |x| (QREFELT $ 125))))) 

(DEFUN |EF;iacoth| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 33) (QREFELT $ 119))
     (|SPADfirst| (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
    ('T (SPADCALL (QREFELT $ 39) |x| (QREFELT $ 125))))) 

(DEFUN |EF;iasech| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 34) (QREFELT $ 119))
     (|SPADfirst| (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
    ('T (SPADCALL (QREFELT $ 40) |x| (QREFELT $ 125))))) 

(DEFUN |EF;iacsch| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 35) (QREFELT $ 119))
     (|SPADfirst| (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
    ('T (SPADCALL (QREFELT $ 41) |x| (QREFELT $ 125))))) 

(DEFUN |EF;iexp| (|x| $)
  (PROG (|i| |xi| |y| |h| |s2| |s3| |u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118)) (|spadConstant| $ 50))
             ((SPADCALL |x| (QREFELT $ 16) (QREFELT $ 119))
              (|SPADfirst|
                  (SPADCALL (|EF;kernel| |x| $) (QREFELT $ 101))))
             ('T
              (SEQ (COND
                     ((SPADCALL |x| (|spadConstant| $ 91)
                          (QREFELT $ 128))
                      (COND
                        ((NULL (SPADCALL |x| (QREFELT $ 130)))
                         (EXIT (SPADCALL
                                   (|EF;iexp|
                                    (SPADCALL |x| (QREFELT $ 51)) $)
                                   (QREFELT $ 123)))))))
                   (EXIT (COND
                           ((|HasCategory| (QREFELT $ 6)
                                (LIST '|RetractableTo| '(|Integer|)))
                            (SEQ (LETT |i| (|EF;iisqrt1| $)
                                       . #0=(|EF;iexp|))
                                 (LETT |xi|
                                       (SPADCALL |x| |i|
                                        (QREFELT $ 102)) . #0#)
                                 (LETT |y|
                                       (SPADCALL |xi|
                                        (SPADCALL (QREFELT $ 47))
                                        (QREFELT $ 102)) . #0#)
                                 (EXIT (COND
                                         ((QEQCAR
                                           (SPADCALL |y|
                                            (QREFELT $ 104))
                                           1)
                                          (SPADCALL (QREFELT $ 17) |x|
                                           (QREFELT $ 125)))
                                         ('T
                                          (SEQ
                                           (LETT |h|
                                            (SPADCALL
                                             (SPADCALL 2
                                              (QREFELT $ 58))
                                             (QREFELT $ 123)) . #0#)
                                           (LETT |s2|
                                            (SPADCALL |h|
                                             (SPADCALL (QREFELT $ 59))
                                             (QREFELT $ 124)) . #0#)
                                           (LETT |s3|
                                            (SPADCALL |h|
                                             (SPADCALL (QREFELT $ 60))
                                             (QREFELT $ 124)) . #0#)
                                           (LETT |u|
                                            (SPADCALL |xi|
                                             (LIST
                                              (CONS
                                               (|spadConstant| $ 50)
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (|spadConstant| $ 50)
                                                (QREFELT $ 51))
                                               'NIL)
                                              (CONS |i| 'NIL)
                                              (CONS
                                               (SPADCALL |i|
                                                (QREFELT $ 51))
                                               'NIL)
                                              (CONS
                                               (SPADCALL |h|
                                                (SPADCALL |i| |s3|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 122))
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |h|
                                                 (QREFELT $ 51))
                                                (SPADCALL |i| |s3|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 122))
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |h|
                                                 (QREFELT $ 51))
                                                (SPADCALL |i| |s3|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 121))
                                               'NIL)
                                              (CONS
                                               (SPADCALL |h|
                                                (SPADCALL |i| |s3|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 121))
                                               'NIL)
                                              (CONS
                                               (SPADCALL |s2|
                                                (SPADCALL |i| |s2|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 122))
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |s2|
                                                 (QREFELT $ 51))
                                                (SPADCALL |i| |s2|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 122))
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |s2|
                                                 (QREFELT $ 51))
                                                (SPADCALL |i| |s2|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 121))
                                               'NIL)
                                              (CONS
                                               (SPADCALL |s2|
                                                (SPADCALL |i| |s2|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 121))
                                               'NIL)
                                              (CONS
                                               (SPADCALL |s3|
                                                (SPADCALL |i| |h|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 122))
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |s3|
                                                 (QREFELT $ 51))
                                                (SPADCALL |i| |h|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 122))
                                               'NIL)
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |s3|
                                                 (QREFELT $ 51))
                                                (SPADCALL |i| |h|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 121))
                                               'NIL)
                                              (CONS
                                               (SPADCALL |s3|
                                                (SPADCALL |i| |h|
                                                 (QREFELT $ 124))
                                                (QREFELT $ 121))
                                               'NIL))
                                             (QREFELT $ 117)) . #0#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |u| 0)
                                               (QCDR |u|))
                                              ('T
                                               (SPADCALL (QREFELT $ 17)
                                                |x| (QREFELT $ 125)))))))))))
                           ('T
                            (SPADCALL (QREFELT $ 17) |x|
                                (QREFELT $ 125)))))))))))) 

(DEFUN |EF;localReal?;FB;71| (|x| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u| (SPADCALL |x| (QREFELT $ 132))
                 |EF;localReal?;FB;71|)
           (EXIT (COND
                   ((QEQCAR |u| 0)
                    (SPADCALL (QCDR |u|)
                        (SPADCALL (QCDR |u|) (QREFELT $ 133))
                        (QREFELT $ 134)))
                   ('T 'NIL))))))) 

(PUT '|EF;localReal?;FB;72| '|SPADreplace| '(XLAM (|x|) 'T)) 

(DEFUN |EF;localReal?;FB;72| (|x| $) 'T) 

(PUT '|EF;localReal?;FB;73| '|SPADreplace| '(XLAM (|x|) 'T)) 

(DEFUN |EF;localReal?;FB;73| (|x| $) 'T) 

(DEFUN |EF;iiilog| (|x| $)
  (PROG (|u| #0=#:G2297 |rec| |arg|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 118))
              (|error| "Invalid argument"))
             ((SPADCALL |x| (|spadConstant| $ 50) (QREFELT $ 127))
              (|spadConstant| $ 91))
             ('T
              (COND
                ((QEQCAR (LETT |u|
                               (SPADCALL |x| (QREFELT $ 17)
                                   (QREFELT $ 138))
                               . #1=(|EF;iiilog|))
                         0)
                 (SEQ (LETT |rec|
                            (PROG2 (LETT #0# |u| . #1#) (QCDR #0#)
                              (|check-union| (QEQCAR #0# 0)
                                  (|Record|
                                      (|:| |var|
                                       (|Kernel| (QREFELT $ 7)))
                                      (|:| |exponent| (|Integer|)))
                                  #0#)) . #1#)
                      (LETT |arg|
                            (|SPADfirst|
                                (SPADCALL (QCAR |rec|) (QREFELT $ 101))) . #1#)
                      (EXIT (COND
                              ((SPADCALL |arg| (QREFELT $ 135))
                               (SPADCALL (QCDR |rec|)
                                   (|SPADfirst|
                                    (SPADCALL (QCAR |rec|)
                                     (QREFELT $ 101)))
                                   (QREFELT $ 139)))
                              ('T (|EF;ilog| |x| $))))))
                ('T (|EF;ilog| |x| $))))))))) 

(DEFUN |EF;ilog| (|x| $)
  (PROG (|num| |num1| |den| #0=#:G2309)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |num1|
                                 (SPADCALL
                                     (LETT |num|
                                      (SPADCALL |x| (QREFELT $ 141))
                                      . #1=(|EF;ilog|))
                                     (|spadConstant| $ 143)
                                     (QREFELT $ 144)) . #1#)
                           (EXIT (COND
                                   ((OR |num1|
                                     (SPADCALL |num|
                                      (SPADCALL (|spadConstant| $ 143)
                                       (QREFELT $ 146))
                                      (QREFELT $ 144)))
                                    (SEQ
                                     (LETT |den|
                                      (SPADCALL |x| (QREFELT $ 145)) . #1#)
                                     (EXIT
                                      (COND
                                        ((NULL
                                          (SPADCALL |den|
                                           (|spadConstant| $ 143)
                                           (QREFELT $ 144)))
                                         (COND
                                           ((NULL
                                             (SPADCALL |x|
                                              (QREFELT $ 130)))
                                            (PROGN
                                              (LETT #0#
                                               (SPADCALL
                                                (SPADCALL
                                                 (QREFELT $ 16)
                                                 (SPADCALL
                                                  (COND
                                                    (|num1| |den|)
                                                    ('T
                                                     (SPADCALL |den|
                                                      (QREFELT $ 146))))
                                                  (QREFELT $ 147))
                                                 (QREFELT $ 125))
                                                (QREFELT $ 51)) . #1#)
                                              (GO #0#))))))))))))
                      (EXIT (SPADCALL (QREFELT $ 16) |x|
                                (QREFELT $ 125)))))
           #0# (EXIT #0#))))) 

(DEFUN |EF;iilog;2F;76| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iilog;2F;76|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iiilog| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 148))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiexp;2F;77| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiexp;2F;77|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iexp| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 150))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iilog;2F;78| (|x| $) (|EF;iiilog| |x| $)) 

(DEFUN |EF;iiexp;2F;79| (|x| $) (|EF;iexp| |x| $)) 

(DEFUN |EF;iisin;2F;80| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iisin;2F;80|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;isin| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 152))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iicos;2F;81| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iicos;2F;81|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;icos| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 154))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iitan;2F;82| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iitan;2F;82|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;itan| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 156))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iicot;2F;83| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iicot;2F;83|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;icot| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 158))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iisec;2F;84| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iisec;2F;84|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;isec| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 160))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iicsc;2F;85| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iicsc;2F;85|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;icsc| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 162))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iisin;2F;86| (|x| $) (|EF;isin| |x| $)) 

(DEFUN |EF;iicos;2F;87| (|x| $) (|EF;icos| |x| $)) 

(DEFUN |EF;iitan;2F;88| (|x| $) (|EF;itan| |x| $)) 

(DEFUN |EF;iicot;2F;89| (|x| $) (|EF;icot| |x| $)) 

(DEFUN |EF;iisec;2F;90| (|x| $) (|EF;isec| |x| $)) 

(DEFUN |EF;iicsc;2F;91| (|x| $) (|EF;icsc| |x| $)) 

(DEFUN |EF;iiasin;2F;92| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiasin;2F;92|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iasin| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 164))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiacos;2F;93| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiacos;2F;93|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iacos| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 166))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiatan;2F;94| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiatan;2F;94|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iatan| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 168))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiacot;2F;95| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiacot;2F;95|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iacot| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 170))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiasec;2F;96| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiasec;2F;96|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iasec| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 172))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiacsc;2F;97| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iiacsc;2F;97|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iacsc| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 174))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiasin;2F;98| (|x| $) (|EF;iasin| |x| $)) 

(DEFUN |EF;iiacos;2F;99| (|x| $) (|EF;iacos| |x| $)) 

(DEFUN |EF;iiatan;2F;100| (|x| $) (|EF;iatan| |x| $)) 

(DEFUN |EF;iiacot;2F;101| (|x| $) (|EF;iacot| |x| $)) 

(DEFUN |EF;iiasec;2F;102| (|x| $) (|EF;iasec| |x| $)) 

(DEFUN |EF;iiacsc;2F;103| (|x| $) (|EF;iacsc| |x| $)) 

(DEFUN |EF;iisinh;2F;104| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iisinh;2F;104|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;isinh| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 176))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iicosh;2F;105| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iicosh;2F;105|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;icosh| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 178))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iitanh;2F;106| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iitanh;2F;106|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;itanh| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 180))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iicoth;2F;107| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iicoth;2F;107|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;icoth| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 182))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iisech;2F;108| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iisech;2F;108|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;isech| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 184))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iicsch;2F;109| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132)) |EF;iicsch;2F;109|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;icsch| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 186))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iisinh;2F;110| (|x| $) (|EF;isinh| |x| $)) 

(DEFUN |EF;iicosh;2F;111| (|x| $) (|EF;icosh| |x| $)) 

(DEFUN |EF;iitanh;2F;112| (|x| $) (|EF;itanh| |x| $)) 

(DEFUN |EF;iicoth;2F;113| (|x| $) (|EF;icoth| |x| $)) 

(DEFUN |EF;iisech;2F;114| (|x| $) (|EF;isech| |x| $)) 

(DEFUN |EF;iicsch;2F;115| (|x| $) (|EF;icsch| |x| $)) 

(DEFUN |EF;iiasinh;2F;116| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132))
                 |EF;iiasinh;2F;116|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iasinh| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 188))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiacosh;2F;117| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132))
                 |EF;iiacosh;2F;117|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iacosh| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 190))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiatanh;2F;118| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132))
                 |EF;iiatanh;2F;118|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iatanh| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 192))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiacoth;2F;119| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132))
                 |EF;iiacoth;2F;119|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iacoth| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 194))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiasech;2F;120| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132))
                 |EF;iiasech;2F;120|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iasech| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 196))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiacsch;2F;121| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 132))
                 |EF;iiacsch;2F;121|)
           (EXIT (COND
                   ((QEQCAR |r| 1) (|EF;iacsch| |x| $))
                   ('T
                    (SPADCALL (SPADCALL (QCDR |r|) (QREFELT $ 198))
                        (QREFELT $ 43))))))))) 

(DEFUN |EF;iiasinh;2F;122| (|x| $) (|EF;iasinh| |x| $)) 

(DEFUN |EF;iiacosh;2F;123| (|x| $) (|EF;iacosh| |x| $)) 

(DEFUN |EF;iiatanh;2F;124| (|x| $) (|EF;iatanh| |x| $)) 

(DEFUN |EF;iiacoth;2F;125| (|x| $) (|EF;iacoth| |x| $)) 

(DEFUN |EF;iiasech;2F;126| (|x| $) (|EF;iasech| |x| $)) 

(DEFUN |EF;iiacsch;2F;127| (|x| $) (|EF;iacsch| |x| $)) 

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

(DEFUN |ElementaryFunction;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|ElementaryFunction|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|ElementaryFunction| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 208) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|ElementaryFunction|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 11 (SPADCALL "elem" (QREFELT $ 10)))
        (QSETREFV $ 15
            (SPADCALL (SPADCALL "pi" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 16
            (SPADCALL (SPADCALL "log" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 17
            (SPADCALL (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 18
            (SPADCALL (SPADCALL "sin" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 19
            (SPADCALL (SPADCALL "cos" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 20
            (SPADCALL (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 21
            (SPADCALL (SPADCALL "cot" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 22
            (SPADCALL (SPADCALL "sec" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 23
            (SPADCALL (SPADCALL "csc" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 24
            (SPADCALL (SPADCALL "asin" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 25
            (SPADCALL (SPADCALL "acos" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 26
            (SPADCALL (SPADCALL "atan" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 27
            (SPADCALL (SPADCALL "acot" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 28
            (SPADCALL (SPADCALL "asec" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 29
            (SPADCALL (SPADCALL "acsc" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 30
            (SPADCALL (SPADCALL "sinh" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 31
            (SPADCALL (SPADCALL "cosh" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 32
            (SPADCALL (SPADCALL "tanh" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 33
            (SPADCALL (SPADCALL "coth" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 34
            (SPADCALL (SPADCALL "sech" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 35
            (SPADCALL (SPADCALL "csch" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 36
            (SPADCALL (SPADCALL "asinh" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 37
            (SPADCALL (SPADCALL "acosh" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 38
            (SPADCALL (SPADCALL "atanh" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 39
            (SPADCALL (SPADCALL "acoth" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 40
            (SPADCALL (SPADCALL "asech" (QREFELT $ 10)) (QREFELT $ 14)))
        (QSETREFV $ 41
            (SPADCALL (SPADCALL "acsch" (QREFELT $ 10)) (QREFELT $ 14)))
        (COND
          ((|HasCategory| |#1| '(|TranscendentalFunctionCategory|))
           (QSETREFV $ 44
               (SPADCALL (SPADCALL (QREFELT $ 42)) (QREFELT $ 43))))
          ('T
           (SETELT $ 44 (SPADCALL (QREFELT $ 15) NIL (QREFELT $ 46)))))
        (COND
          ((|HasCategory| |#1| '(|TranscendentalFunctionCategory|))
           (COND
             ((|HasCategory| |#1| '(|arbitraryPrecision|))
              (QSETREFV $ 47 (CONS (|dispatchFunction| |EF;pi;F;1|) $)))
             ('T
              (QSETREFV $ 47 (CONS (|dispatchFunction| |EF;pi;F;2|) $)))))
          ('T
           (QSETREFV $ 47 (CONS (|dispatchFunction| |EF;pi;F;3|) $))))
        (COND
          ((|HasSignature| |#1|
               (LIST '|imaginary| (LIST (|devaluate| |#1|))))
           (QSETREFV $ 49
               (SPADCALL (SPADCALL (QREFELT $ 48)) (QREFELT $ 43))))
          ('T
           (SETELT $ 49
                   (SPADCALL
                       (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
                       (QREFELT $ 52)))))
        (COND
          ((|HasCategory| |#1| '(|RadicalCategory|))
           (PROGN
             (QSETREFV $ 56
                 (SPADCALL
                     (SPADCALL (SPADCALL 2 (QREFELT $ 54))
                         (QREFELT $ 55))
                     (QREFELT $ 43)))
             (QSETREFV $ 57
                 (SPADCALL
                     (SPADCALL (SPADCALL 3 (QREFELT $ 54))
                         (QREFELT $ 55))
                     (QREFELT $ 43)))))
          ('T
           (PROGN
             (SETELT $ 56
                     (SPADCALL (SPADCALL 2 (QREFELT $ 58))
                         (QREFELT $ 52)))
             (SETELT $ 57
                     (SPADCALL (SPADCALL 3 (QREFELT $ 58))
                         (QREFELT $ 52))))))
        (COND
          ((|HasCategory| |#1| '(|RadicalCategory|))
           (COND
             ((|HasCategory| |#1| '(|arbitraryPrecision|))
              (PROGN
                (QSETREFV $ 59
                    (CONS (|dispatchFunction| |EF;iisqrt2;F;5|) $))
                (QSETREFV $ 60
                    (CONS (|dispatchFunction| |EF;iisqrt3;F;6|) $))))
             ('T
              (PROGN
                (QSETREFV $ 59
                    (CONS (|dispatchFunction| |EF;iisqrt2;F;7|) $))
                (QSETREFV $ 60
                    (CONS (|dispatchFunction| |EF;iisqrt3;F;8|) $))))))
          ('T
           (PROGN
             (QSETREFV $ 59
                 (CONS (|dispatchFunction| |EF;iisqrt2;F;9|) $))
             (QSETREFV $ 60
                 (CONS (|dispatchFunction| |EF;iisqrt3;F;10|) $)))))
        (COND
          ((|HasCategory| |#1| '(|RetractableTo| (|Integer|)))
           (QSETREFV $ 117
               (CONS (|dispatchFunction| |EF;specialTrigs;FLU;44|) $)))
          ('T
           (QSETREFV $ 117
               (CONS (|dispatchFunction| |EF;specialTrigs;FLU;45|) $))))
        (COND
          ((|HasSignature| |#1|
               (LIST '|imaginary| (LIST (|devaluate| |#1|))))
           (COND
             ((|HasSignature| |#1|
                  (LIST '|conjugate|
                        (LIST (|devaluate| |#1|) (|devaluate| |#1|))))
              (QSETREFV $ 135
                  (CONS (|dispatchFunction| |EF;localReal?;FB;71|) $)))
             ('T
              (QSETREFV $ 135
                  (CONS (|dispatchFunction| |EF;localReal?;FB;72|) $)))))
          ('T
           (QSETREFV $ 135
               (CONS (|dispatchFunction| |EF;localReal?;FB;73|) $))))
        (COND
          ((|HasCategory| |#1| '(|ElementaryFunctionCategory|))
           (PROGN
             (QSETREFV $ 149
                 (CONS (|dispatchFunction| |EF;iilog;2F;76|) $))
             (QSETREFV $ 151
                 (CONS (|dispatchFunction| |EF;iiexp;2F;77|) $))))
          ('T
           (PROGN
             (QSETREFV $ 149
                 (CONS (|dispatchFunction| |EF;iilog;2F;78|) $))
             (QSETREFV $ 151
                 (CONS (|dispatchFunction| |EF;iiexp;2F;79|) $)))))
        (COND
          ((|HasCategory| |#1| '(|TrigonometricFunctionCategory|))
           (PROGN
             (QSETREFV $ 153
                 (CONS (|dispatchFunction| |EF;iisin;2F;80|) $))
             (QSETREFV $ 155
                 (CONS (|dispatchFunction| |EF;iicos;2F;81|) $))
             (QSETREFV $ 157
                 (CONS (|dispatchFunction| |EF;iitan;2F;82|) $))
             (QSETREFV $ 159
                 (CONS (|dispatchFunction| |EF;iicot;2F;83|) $))
             (QSETREFV $ 161
                 (CONS (|dispatchFunction| |EF;iisec;2F;84|) $))
             (QSETREFV $ 163
                 (CONS (|dispatchFunction| |EF;iicsc;2F;85|) $))))
          ('T
           (PROGN
             (QSETREFV $ 153
                 (CONS (|dispatchFunction| |EF;iisin;2F;86|) $))
             (QSETREFV $ 155
                 (CONS (|dispatchFunction| |EF;iicos;2F;87|) $))
             (QSETREFV $ 157
                 (CONS (|dispatchFunction| |EF;iitan;2F;88|) $))
             (QSETREFV $ 159
                 (CONS (|dispatchFunction| |EF;iicot;2F;89|) $))
             (QSETREFV $ 161
                 (CONS (|dispatchFunction| |EF;iisec;2F;90|) $))
             (QSETREFV $ 163
                 (CONS (|dispatchFunction| |EF;iicsc;2F;91|) $)))))
        (COND
          ((|HasCategory| |#1| '(|ArcTrigonometricFunctionCategory|))
           (PROGN
             (QSETREFV $ 165
                 (CONS (|dispatchFunction| |EF;iiasin;2F;92|) $))
             (QSETREFV $ 167
                 (CONS (|dispatchFunction| |EF;iiacos;2F;93|) $))
             (QSETREFV $ 169
                 (CONS (|dispatchFunction| |EF;iiatan;2F;94|) $))
             (QSETREFV $ 171
                 (CONS (|dispatchFunction| |EF;iiacot;2F;95|) $))
             (QSETREFV $ 173
                 (CONS (|dispatchFunction| |EF;iiasec;2F;96|) $))
             (QSETREFV $ 175
                 (CONS (|dispatchFunction| |EF;iiacsc;2F;97|) $))))
          ('T
           (PROGN
             (QSETREFV $ 165
                 (CONS (|dispatchFunction| |EF;iiasin;2F;98|) $))
             (QSETREFV $ 167
                 (CONS (|dispatchFunction| |EF;iiacos;2F;99|) $))
             (QSETREFV $ 169
                 (CONS (|dispatchFunction| |EF;iiatan;2F;100|) $))
             (QSETREFV $ 171
                 (CONS (|dispatchFunction| |EF;iiacot;2F;101|) $))
             (QSETREFV $ 173
                 (CONS (|dispatchFunction| |EF;iiasec;2F;102|) $))
             (QSETREFV $ 175
                 (CONS (|dispatchFunction| |EF;iiacsc;2F;103|) $)))))
        (COND
          ((|HasCategory| |#1| '(|HyperbolicFunctionCategory|))
           (PROGN
             (QSETREFV $ 177
                 (CONS (|dispatchFunction| |EF;iisinh;2F;104|) $))
             (QSETREFV $ 179
                 (CONS (|dispatchFunction| |EF;iicosh;2F;105|) $))
             (QSETREFV $ 181
                 (CONS (|dispatchFunction| |EF;iitanh;2F;106|) $))
             (QSETREFV $ 183
                 (CONS (|dispatchFunction| |EF;iicoth;2F;107|) $))
             (QSETREFV $ 185
                 (CONS (|dispatchFunction| |EF;iisech;2F;108|) $))
             (QSETREFV $ 187
                 (CONS (|dispatchFunction| |EF;iicsch;2F;109|) $))))
          ('T
           (PROGN
             (QSETREFV $ 177
                 (CONS (|dispatchFunction| |EF;iisinh;2F;110|) $))
             (QSETREFV $ 179
                 (CONS (|dispatchFunction| |EF;iicosh;2F;111|) $))
             (QSETREFV $ 181
                 (CONS (|dispatchFunction| |EF;iitanh;2F;112|) $))
             (QSETREFV $ 183
                 (CONS (|dispatchFunction| |EF;iicoth;2F;113|) $))
             (QSETREFV $ 185
                 (CONS (|dispatchFunction| |EF;iisech;2F;114|) $))
             (QSETREFV $ 187
                 (CONS (|dispatchFunction| |EF;iicsch;2F;115|) $)))))
        (COND
          ((|HasCategory| |#1| '(|ArcHyperbolicFunctionCategory|))
           (PROGN
             (QSETREFV $ 189
                 (CONS (|dispatchFunction| |EF;iiasinh;2F;116|) $))
             (QSETREFV $ 191
                 (CONS (|dispatchFunction| |EF;iiacosh;2F;117|) $))
             (QSETREFV $ 193
                 (CONS (|dispatchFunction| |EF;iiatanh;2F;118|) $))
             (QSETREFV $ 195
                 (CONS (|dispatchFunction| |EF;iiacoth;2F;119|) $))
             (QSETREFV $ 197
                 (CONS (|dispatchFunction| |EF;iiasech;2F;120|) $))
             (QSETREFV $ 199
                 (CONS (|dispatchFunction| |EF;iiacsch;2F;121|) $))))
          ('T
           (PROGN
             (QSETREFV $ 189
                 (CONS (|dispatchFunction| |EF;iiasinh;2F;122|) $))
             (QSETREFV $ 191
                 (CONS (|dispatchFunction| |EF;iiacosh;2F;123|) $))
             (QSETREFV $ 193
                 (CONS (|dispatchFunction| |EF;iiatanh;2F;124|) $))
             (QSETREFV $ 195
                 (CONS (|dispatchFunction| |EF;iiacoth;2F;125|) $))
             (QSETREFV $ 197
                 (CONS (|dispatchFunction| |EF;iiasech;2F;126|) $))
             (QSETREFV $ 199
                 (CONS (|dispatchFunction| |EF;iiacsch;2F;127|) $)))))
        (SPADCALL (QREFELT $ 15) (CONS (|function| |EF;ipi|) $)
            (QREFELT $ 202))
        (SPADCALL (QREFELT $ 16) (ELT $ 149) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 17) (ELT $ 151) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 18) (ELT $ 153) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 19) (ELT $ 155) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 20) (ELT $ 157) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 21) (ELT $ 159) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 22) (ELT $ 161) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 23) (ELT $ 163) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 24) (ELT $ 165) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 25) (ELT $ 167) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 26) (ELT $ 169) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 27) (ELT $ 171) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 28) (ELT $ 173) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 29) (ELT $ 175) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 30) (ELT $ 177) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 31) (ELT $ 179) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 32) (ELT $ 181) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 33) (ELT $ 183) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 34) (ELT $ 185) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 35) (ELT $ 187) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 36) (ELT $ 189) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 37) (ELT $ 191) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 38) (ELT $ 193) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 39) (ELT $ 195) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 40) (ELT $ 197) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 41) (ELT $ 199) (QREFELT $ 204))
        (SPADCALL (QREFELT $ 17) (ELT $ 63) (QREFELT $ 205))
        (SPADCALL (QREFELT $ 16) (ELT $ 123) (QREFELT $ 205))
        (SPADCALL (QREFELT $ 18) (ELT $ 65) (QREFELT $ 205))
        (SPADCALL (QREFELT $ 19) (CONS #'|ElementaryFunction!0| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 20) (CONS #'|ElementaryFunction!1| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 21) (CONS #'|ElementaryFunction!2| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 22) (CONS #'|ElementaryFunction!3| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 23) (CONS #'|ElementaryFunction!4| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 24) (CONS #'|ElementaryFunction!5| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 25) (CONS #'|ElementaryFunction!6| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 26) (CONS #'|ElementaryFunction!7| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 27) (CONS #'|ElementaryFunction!8| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 28) (CONS #'|ElementaryFunction!9| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 29) (CONS #'|ElementaryFunction!10| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 30) (ELT $ 77) (QREFELT $ 205))
        (SPADCALL (QREFELT $ 31) (ELT $ 76) (QREFELT $ 205))
        (SPADCALL (QREFELT $ 32) (CONS #'|ElementaryFunction!11| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 33) (CONS #'|ElementaryFunction!12| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 34) (CONS #'|ElementaryFunction!13| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 35) (CONS #'|ElementaryFunction!14| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 36) (CONS #'|ElementaryFunction!15| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 37) (CONS #'|ElementaryFunction!16| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 38) (CONS #'|ElementaryFunction!17| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 39) (CONS #'|ElementaryFunction!18| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 40) (CONS #'|ElementaryFunction!19| $)
            (QREFELT $ 205))
        (SPADCALL (QREFELT $ 41) (CONS #'|ElementaryFunction!20| $)
            (QREFELT $ 205))
        $)))) 

(DEFUN |ElementaryFunction!20| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL |#1|
              (SPADCALL
                  (SPADCALL (|spadConstant| $ 50)
                      (SPADCALL |#1| 2 (QREFELT $ 120))
                      (QREFELT $ 122))
                  (QREFELT $ 52))
              (QREFELT $ 124))
          (QREFELT $ 123))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!19| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL |#1|
              (SPADCALL
                  (SPADCALL (|spadConstant| $ 50)
                      (SPADCALL |#1| 2 (QREFELT $ 120))
                      (QREFELT $ 121))
                  (QREFELT $ 52))
              (QREFELT $ 124))
          (QREFELT $ 123))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!18| (|#1| $)
  (SPADCALL
      (SPADCALL (|spadConstant| $ 50) (SPADCALL |#1| 2 (QREFELT $ 120))
          (QREFELT $ 121))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!17| (|#1| $)
  (SPADCALL
      (SPADCALL (|spadConstant| $ 50) (SPADCALL |#1| 2 (QREFELT $ 120))
          (QREFELT $ 121))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!16| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL (SPADCALL |#1| 2 (QREFELT $ 120))
              (|spadConstant| $ 50) (QREFELT $ 121))
          (QREFELT $ 52))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!15| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL (|spadConstant| $ 50)
              (SPADCALL |#1| 2 (QREFELT $ 120)) (QREFELT $ 122))
          (QREFELT $ 52))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!14| (|#1| $)
  (SPADCALL
      (SPADCALL (SPADCALL |#1| (QREFELT $ 79))
          (SPADCALL |#1| (QREFELT $ 81)) (QREFELT $ 124))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!13| (|#1| $)
  (SPADCALL
      (SPADCALL (SPADCALL |#1| (QREFELT $ 78))
          (SPADCALL |#1| (QREFELT $ 80)) (QREFELT $ 124))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!12| (|#1| $)
  (SPADCALL (|spadConstant| $ 50)
      (SPADCALL (SPADCALL |#1| (QREFELT $ 79)) 2 (QREFELT $ 206))
      (QREFELT $ 121))) 

(DEFUN |ElementaryFunction!11| (|#1| $)
  (SPADCALL (|spadConstant| $ 50)
      (SPADCALL (SPADCALL |#1| (QREFELT $ 78)) 2 (QREFELT $ 206))
      (QREFELT $ 121))) 

(DEFUN |ElementaryFunction!10| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL |#1|
              (SPADCALL
                  (SPADCALL (SPADCALL |#1| 2 (QREFELT $ 120))
                      (|spadConstant| $ 50) (QREFELT $ 121))
                  (QREFELT $ 52))
              (QREFELT $ 124))
          (QREFELT $ 123))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!9| (|#1| $)
  (SPADCALL
      (SPADCALL |#1|
          (SPADCALL
              (SPADCALL (SPADCALL |#1| 2 (QREFELT $ 120))
                  (|spadConstant| $ 50) (QREFELT $ 121))
              (QREFELT $ 52))
          (QREFELT $ 124))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!8| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL (|spadConstant| $ 50)
              (SPADCALL |#1| 2 (QREFELT $ 120)) (QREFELT $ 122))
          (QREFELT $ 123))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!7| (|#1| $)
  (SPADCALL
      (SPADCALL (|spadConstant| $ 50) (SPADCALL |#1| 2 (QREFELT $ 120))
          (QREFELT $ 122))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!6| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL
              (SPADCALL (|spadConstant| $ 50)
                  (SPADCALL |#1| 2 (QREFELT $ 120)) (QREFELT $ 121))
              (QREFELT $ 52))
          (QREFELT $ 123))
      (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!5| (|#1| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL (|spadConstant| $ 50)
              (SPADCALL |#1| 2 (QREFELT $ 120)) (QREFELT $ 121))
          (QREFELT $ 52))
      (QREFELT $ 123))) 

(DEFUN |ElementaryFunction!4| (|#1| $)
  (SPADCALL (SPADCALL (SPADCALL |#1| (QREFELT $ 67))
                (SPADCALL |#1| (QREFELT $ 69)) (QREFELT $ 124))
            (QREFELT $ 51))) 

(DEFUN |ElementaryFunction!3| (|#1| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 66))
      (SPADCALL |#1| (QREFELT $ 68)) (QREFELT $ 124))) 

(DEFUN |ElementaryFunction!2| (|#1| $)
  (SPADCALL (SPADCALL (|spadConstant| $ 50) (QREFELT $ 51))
            (SPADCALL (SPADCALL |#1| (QREFELT $ 67)) 2 (QREFELT $ 206))
            (QREFELT $ 121))) 

(DEFUN |ElementaryFunction!1| (|#1| $)
  (SPADCALL (|spadConstant| $ 50)
      (SPADCALL (SPADCALL |#1| (QREFELT $ 66)) 2 (QREFELT $ 206))
      (QREFELT $ 122))) 

(DEFUN |ElementaryFunction!0| (|#1| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 64)) (QREFELT $ 51))) 

(MAKEPROP '|ElementaryFunction| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'ELEM
             (|BasicOperator|) (|CommonOperators|) (5 . |operator|)
             '|oppi| '|oplog| '|opexp| '|opsin| '|opcos| '|optan|
             '|opcot| '|opsec| '|opcsc| '|opasin| '|opacos| '|opatan|
             '|opacot| '|opasec| '|opacsc| '|opsinh| '|opcosh|
             '|optanh| '|opcoth| '|opsech| '|opcsch| '|opasinh|
             '|opacosh| '|opatanh| '|opacoth| '|opasech| '|opacsch|
             (10 . |pi|) (14 . |coerce|) '|Pie| (|List| $)
             (19 . |kernel|) (25 . |pi|) (29 . |imaginary|) '|isqrt1|
             (33 . |One|) (37 . -) (42 . |sqrt|) (|Integer|)
             (47 . |coerce|) (52 . |sqrt|) '|isqrt2| '|isqrt3|
             (57 . |coerce|) (62 . |iisqrt2|) (66 . |iisqrt3|)
             (70 . |elt|) |EF;log;2F;12| |EF;exp;2F;13| |EF;sin;2F;14|
             |EF;cos;2F;15| |EF;tan;2F;16| |EF;cot;2F;17|
             |EF;sec;2F;18| |EF;csc;2F;19| |EF;asin;2F;20|
             |EF;acos;2F;21| |EF;atan;2F;22| |EF;acot;2F;23|
             |EF;asec;2F;24| |EF;acsc;2F;25| |EF;sinh;2F;26|
             |EF;cosh;2F;27| |EF;tanh;2F;28| |EF;coth;2F;29|
             |EF;sech;2F;30| |EF;csch;2F;31| |EF;asinh;2F;32|
             |EF;acosh;2F;33| |EF;atanh;2F;34| |EF;acoth;2F;35|
             |EF;asech;2F;36| |EF;acsch;2F;37| (|Kernel| $)
             (76 . |retract|) (81 . |Zero|) (85 . |Zero|) (|Boolean|)
             (89 . |has?|) |EF;belong?;BoB;41| (95 . |is?|)
             |EF;operator;2Bo;42| (|Union| 88 '"failed")
             (101 . |retractIfCan|) (|List| 7) (|Kernel| 7)
             (106 . |argument|) (111 . /) (|Union| 109 '"failed")
             (117 . |retractIfCan|)
             (|Record| (|:| |func| 7) (|:| |pole| 92)) (|List| 105)
             (122 . |minIndex|) (|Union| 53 '"failed") (|Fraction| 53)
             (127 . |retractIfCan|) (132 . |even?|) (137 . |elt|)
             (143 . |One|) (|PositiveInteger|) (147 . *)
             (|Union| 7 '"failed") (153 . |specialTrigs|)
             (159 . |zero?|) (164 . |is?|) (170 . **) (176 . -)
             (182 . +) (188 . |inv|) (193 . *) (199 . |kernel|)
             (205 . *) (211 . =) (217 . <) (|List| 9)
             (223 . |variables|) (|Union| 6 '"failed")
             (228 . |retractIfCan|) (233 . |conjugate|) (238 . =)
             (244 . |localReal?|)
             (|Record| (|:| |var| 88) (|:| |exponent| 53))
             (|Union| 136 '"failed") (249 . |isExpt|) (255 . *)
             (|SparseMultivariatePolynomial| 6 88) (261 . |numer|)
             (|SparseMultivariatePolynomial| 6 100) (266 . |One|)
             (270 . =) (276 . |denom|) (281 . -) (286 . |coerce|)
             (291 . |log|) (296 . |iilog|) (301 . |exp|)
             (306 . |iiexp|) (311 . |sin|) (316 . |iisin|)
             (321 . |cos|) (326 . |iicos|) (331 . |tan|)
             (336 . |iitan|) (341 . |cot|) (346 . |iicot|)
             (351 . |sec|) (356 . |iisec|) (361 . |csc|)
             (366 . |iicsc|) (371 . |asin|) (376 . |iiasin|)
             (381 . |acos|) (386 . |iiacos|) (391 . |atan|)
             (396 . |iiatan|) (401 . |acot|) (406 . |iiacot|)
             (411 . |asec|) (416 . |iiasec|) (421 . |acsc|)
             (426 . |iiacsc|) (431 . |sinh|) (436 . |iisinh|)
             (441 . |cosh|) (446 . |iicosh|) (451 . |tanh|)
             (456 . |iitanh|) (461 . |coth|) (466 . |iicoth|)
             (471 . |sech|) (476 . |iisech|) (481 . |csch|)
             (486 . |iicsch|) (491 . |asinh|) (496 . |iiasinh|)
             (501 . |acosh|) (506 . |iiacosh|) (511 . |atanh|)
             (516 . |iiatanh|) (521 . |acoth|) (526 . |iiacoth|)
             (531 . |asech|) (536 . |iiasech|) (541 . |acsch|)
             (546 . |iiacsch|) (|Mapping| 7 99)
             (|BasicOperatorFunctions1| 7) (551 . |evaluate|)
             (|Mapping| 7 7) (557 . |evaluate|) (563 . |derivative|)
             (569 . **) (575 . -))
          '#(|tanh| 580 |tan| 585 |specialTrigs| 590 |sinh| 596 |sin|
             601 |sech| 606 |sec| 611 |pi| 616 |operator| 620 |log| 625
             |localReal?| 630 |iitanh| 635 |iitan| 640 |iisqrt3| 645
             |iisqrt2| 649 |iisinh| 653 |iisin| 658 |iisech| 663
             |iisec| 668 |iilog| 673 |iiexp| 678 |iicsch| 683 |iicsc|
             688 |iicoth| 693 |iicot| 698 |iicosh| 703 |iicos| 708
             |iiatanh| 713 |iiatan| 718 |iiasinh| 723 |iiasin| 728
             |iiasech| 733 |iiasec| 738 |iiacsch| 743 |iiacsc| 748
             |iiacoth| 753 |iiacot| 758 |iiacosh| 763 |iiacos| 768
             |exp| 773 |csch| 778 |csc| 783 |coth| 788 |cot| 793 |cosh|
             798 |cos| 803 |belong?| 808 |atanh| 813 |atan| 818 |asinh|
             823 |asin| 828 |asech| 833 |asec| 838 |acsch| 843 |acsc|
             848 |acoth| 853 |acot| 858 |acosh| 863 |acos| 868)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 207
                                '(1 9 0 8 10 1 13 12 9 14 0 6 0 42 1 7
                                  0 6 43 2 7 0 12 45 46 0 0 7 47 0 6 0
                                  48 0 7 0 50 1 7 0 0 51 1 7 0 0 52 1 6
                                  0 53 54 1 6 0 0 55 1 7 0 53 58 0 0 7
                                  59 0 0 7 60 2 7 0 12 0 61 1 7 88 0 89
                                  0 6 0 90 0 7 0 91 2 12 92 0 9 93 2 12
                                  92 0 9 95 1 7 97 0 98 1 100 99 0 101
                                  2 7 0 0 0 102 1 7 103 0 104 1 106 53
                                  0 107 1 109 108 0 110 1 53 92 0 111 2
                                  106 105 0 53 112 0 6 0 113 2 109 0
                                  114 0 115 2 0 116 7 106 117 1 7 92 0
                                  118 2 7 92 0 12 119 2 7 0 0 114 120 2
                                  7 0 0 0 121 2 7 0 0 0 122 1 7 0 0 123
                                  2 7 0 0 0 124 2 7 0 12 0 125 2 7 0
                                  114 0 126 2 7 92 0 0 127 2 7 92 0 0
                                  128 1 7 129 0 130 1 7 131 0 132 1 6 0
                                  0 133 2 6 92 0 0 134 1 0 92 7 135 2 7
                                  137 0 12 138 2 7 0 53 0 139 1 7 140 0
                                  141 0 142 0 143 2 142 92 0 0 144 1 7
                                  140 0 145 1 142 0 0 146 1 7 0 140 147
                                  1 6 0 0 148 1 0 7 7 149 1 6 0 0 150 1
                                  0 7 7 151 1 6 0 0 152 1 0 7 7 153 1 6
                                  0 0 154 1 0 7 7 155 1 6 0 0 156 1 0 7
                                  7 157 1 6 0 0 158 1 0 7 7 159 1 6 0 0
                                  160 1 0 7 7 161 1 6 0 0 162 1 0 7 7
                                  163 1 6 0 0 164 1 0 7 7 165 1 6 0 0
                                  166 1 0 7 7 167 1 6 0 0 168 1 0 7 7
                                  169 1 6 0 0 170 1 0 7 7 171 1 6 0 0
                                  172 1 0 7 7 173 1 6 0 0 174 1 0 7 7
                                  175 1 6 0 0 176 1 0 7 7 177 1 6 0 0
                                  178 1 0 7 7 179 1 6 0 0 180 1 0 7 7
                                  181 1 6 0 0 182 1 0 7 7 183 1 6 0 0
                                  184 1 0 7 7 185 1 6 0 0 186 1 0 7 7
                                  187 1 6 0 0 188 1 0 7 7 189 1 6 0 0
                                  190 1 0 7 7 191 1 6 0 0 192 1 0 7 7
                                  193 1 6 0 0 194 1 0 7 7 195 1 6 0 0
                                  196 1 0 7 7 197 1 6 0 0 198 1 0 7 7
                                  199 2 201 12 12 200 202 2 201 12 12
                                  203 204 2 201 12 12 203 205 2 7 0 0
                                  53 206 1 6 0 0 207 1 0 7 7 78 1 0 7 7
                                  66 2 0 116 7 106 117 1 0 7 7 76 1 0 7
                                  7 64 1 0 7 7 80 1 0 7 7 68 0 0 7 47 1
                                  0 12 12 96 1 0 7 7 62 1 0 92 7 135 1
                                  0 7 7 181 1 0 7 7 157 0 0 7 60 0 0 7
                                  59 1 0 7 7 177 1 0 7 7 153 1 0 7 7
                                  185 1 0 7 7 161 1 0 7 7 149 1 0 7 7
                                  151 1 0 7 7 187 1 0 7 7 163 1 0 7 7
                                  183 1 0 7 7 159 1 0 7 7 179 1 0 7 7
                                  155 1 0 7 7 193 1 0 7 7 169 1 0 7 7
                                  189 1 0 7 7 165 1 0 7 7 197 1 0 7 7
                                  173 1 0 7 7 199 1 0 7 7 175 1 0 7 7
                                  195 1 0 7 7 171 1 0 7 7 191 1 0 7 7
                                  167 1 0 7 7 63 1 0 7 7 81 1 0 7 7 69
                                  1 0 7 7 79 1 0 7 7 67 1 0 7 7 77 1 0
                                  7 7 65 1 0 92 12 94 1 0 7 7 84 1 0 7
                                  7 72 1 0 7 7 82 1 0 7 7 70 1 0 7 7 86
                                  1 0 7 7 74 1 0 7 7 87 1 0 7 7 75 1 0
                                  7 7 85 1 0 7 7 73 1 0 7 7 83 1 0 7 7
                                  71)))))
          '|lookupComplete|)) 
