
(/VERSIONCHECK 2) 

(DEFUN |EFSTRUC;realElem| (|f| |l| $)
  (SPADCALL (|EFSTRUC;smpElem| (SPADCALL |f| (QREFELT $ 21)) |l| $)
      (|EFSTRUC;smpElem| (SPADCALL |f| (QREFELT $ 22)) |l| $)
      (QREFELT $ 18))) 

(DEFUN |EFSTRUC;realElementary;FSF;2| (|f| |x| $)
  (|EFSTRUC;realElem| |f| (LIST |x|) $)) 

(DEFUN |EFSTRUC;realElementary;2F;3| (|f| $)
  (|EFSTRUC;realElem| |f| (SPADCALL |f| (QREFELT $ 25)) $)) 

(DEFUN |EFSTRUC;toY| (|ker| $)
  (PROG (#0=#:G1900 |k| #1=#:G1901 |func|)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|EFSTRUC;toY|))
             (SEQ (LETT |k| NIL . #2#) (LETT #1# |ker| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((SEQ (LETT |func|
                                      (|EFSTRUC;ktoY| |k| $) . #2#)
                                     (EXIT
                                      (COND
                                        ((SPADCALL |func|
                                          (|spadConstant| $ 28)
                                          (QREFELT $ 30))
                                         'NIL)
                                        ('T 'T))))
                                (LETT #0# (CONS |func| #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |EFSTRUC;toZ| (|ker| $)
  (PROG (#0=#:G1905 |k| #1=#:G1906 |func|)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|EFSTRUC;toZ|))
             (SEQ (LETT |k| NIL . #2#) (LETT #1# |ker| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((SEQ (LETT |func|
                                      (|EFSTRUC;ktoZ| |k| $) . #2#)
                                     (EXIT
                                      (COND
                                        ((SPADCALL |func|
                                          (|spadConstant| $ 28)
                                          (QREFELT $ 30))
                                         'NIL)
                                        ('T 'T))))
                                (LETT #0# (CONS |func| #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |EFSTRUC;toU| (|ker| $)
  (PROG (#0=#:G1910 |k| #1=#:G1911 |func|)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|EFSTRUC;toU|))
             (SEQ (LETT |k| NIL . #2#) (LETT #1# |ker| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((SEQ (LETT |func|
                                      (|EFSTRUC;ktoU| |k| $) . #2#)
                                     (EXIT
                                      (COND
                                        ((SPADCALL |func|
                                          (|spadConstant| $ 28)
                                          (QREFELT $ 30))
                                         'NIL)
                                        ('T 'T))))
                                (LETT #0# (CONS |func| #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |EFSTRUC;toV| (|ker| $)
  (PROG (#0=#:G1915 |k| #1=#:G1916 |func|)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|EFSTRUC;toV|))
             (SEQ (LETT |k| NIL . #2#) (LETT #1# |ker| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((SEQ (LETT |func|
                                      (|EFSTRUC;ktoV| |k| $) . #2#)
                                     (EXIT
                                      (COND
                                        ((SPADCALL |func|
                                          (|spadConstant| $ 28)
                                          (QREFELT $ 30))
                                         'NIL)
                                        ('T 'T))))
                                (LETT #0# (CONS |func| #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |EFSTRUC;rtNormalize| (|f| $)
  (QVELT (|EFSTRUC;rootNormalize0| |f| $) 0)) 

(DEFUN |EFSTRUC;toR| (|ker| |x| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|EFSTRUC;toR!0| (VECTOR |x| $)) |ker|
          (QREFELT $ 39))))) 

(DEFUN |EFSTRUC;toR!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |EFSTRUC;toR|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |#1| (SPADCALL "nthRoot" (QREFELT $ 10))
               (QREFELT $ 32))
           (SPADCALL
               (SPADCALL (SPADCALL |#1| (QREFELT $ 34)) (QREFELT $ 35))
               (QREFELT $$ 0) (QREFELT $ 30)))
          ('T (|spadConstant| $ 36))))))) 

(DEFUN |EFSTRUC;tanQ;F2F;10| (|c| |x| $)
  (PROG (#0=#:G1923)
    (RETURN
      (SPADCALL
          (SPADCALL
              (SPADCALL (SPADCALL |x|
                            (PROG1 (LETT #0#
                                    (SPADCALL |c| (QREFELT $ 41))
                                    |EFSTRUC;tanQ;F2F;10|)
                              (|check-subtype| (> #0# 0)
                                  '(|PositiveInteger|) #0#))
                            (QREFELT $ 45))
                        (QREFELT $ 47))
              (QREFELT $ 49))
          (SPADCALL |c| (QREFELT $ 50)) (QREFELT $ 51))))) 

(DEFUN |EFSTRUC;tanQ;F2F;11| (|c| |x| $)
  (PROG (#0=#:G1926)
    (RETURN
      (SPADCALL
          (SPADCALL
              (SPADCALL |x|
                  (PROG1 (LETT #0# (SPADCALL |c| (QREFELT $ 41))
                               |EFSTRUC;tanQ;F2F;11|)
                    (|check-subtype| (> #0# 0) '(|PositiveInteger|)
                        #0#))
                  (QREFELT $ 45))
              (QREFELT $ 47))
          (SPADCALL |c| (QREFELT $ 50)) (QREFELT $ 51))))) 

(DEFUN |EFSTRUC;tanSum| (|c| |l| $)
  (PROG (|k| |r| #0=#:G1936)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |k|
                            (SPADCALL |c| (QREFELT $ 19)
                                (QREFELT $ 18))
                            . #1=(|EFSTRUC;tanSum|))
                      (SEQ (LETT |r|
                                 (SPADCALL |k| (QREFELT $ 54)) . #1#)
                           (EXIT (COND
                                   ((QEQCAR |r| 0)
                                    (COND
                                      ((ODDP (QCDR |r|))
                                       (PROGN
                                         (LETT #0#
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |l|
                                             (QREFELT $ 55))
                                            (QREFELT $ 56))
                                           (QREFELT $ 17)) . #1#)
                                         (GO #0#))))))))
                      (EXIT (SPADCALL
                                (CONS (SPADCALL |c| (QREFELT $ 57))
                                      |l|)
                                (QREFELT $ 55)))))
           #0# (EXIT #0#))))) 

(DEFUN |EFSTRUC;rootNormalize0| (|f| $)
  (PROG (|ker| |n| |kk| #0=#:G1950 |i| |u| |rec| |rn| #1=#:G1949
               #2=#:G1945)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ker|
                            (SPADCALL
                                (CONS #'|EFSTRUC;rootNormalize0!0| $)
                                (SPADCALL |f| (QREFELT $ 60))
                                (QREFELT $ 61))
                            . #3=(|EFSTRUC;rootNormalize0|))
                      (EXIT (COND
                              ((NULL |ker|) (VECTOR |f| NIL NIL))
                              ('T
                               (SEQ (LETT |n|
                                     (- (LENGTH |ker|) 1) . #3#)
                                    (EXIT
                                     (COND
                                       ((< |n| 1) (VECTOR |f| NIL NIL))
                                       ('T
                                        (SEQ
                                         (SEQ
                                          (EXIT
                                           (SEQ (LETT |kk| NIL . #3#)
                                            (LETT #0#
                                             (CDR |ker|) . #3#)
                                            (LETT |i| 1 . #3#) G190
                                            (COND
                                              ((OR (QSGREATERP |i| |n|)
                                                (ATOM #0#)
                                                (PROGN
                                                  (LETT |kk|
                                                   (CAR #0#) . #3#)
                                                  NIL))
                                               (GO G191)))
                                            (SEQ
                                             (LETT |u|
                                              (|EFSTRUC;rootKernelNormalize|
                                               |f|
                                               (SPADCALL |ker| |i|
                                                (QREFELT $ 65))
                                               |kk| $) . #3#)
                                             (EXIT
                                              (COND
                                                ((QEQCAR |u| 0)
                                                 (PROGN
                                                   (LETT #2#
                                                    (SEQ
                                                     (LETT |rec|
                                                      (QCDR |u|) . #3#)
                                                     (LETT |rn|
                                                      (|EFSTRUC;rootNormalize0|
                                                       (QVELT |rec| 0)
                                                       $) . #3#)
                                                     (EXIT
                                                      (PROGN
                                                        (LETT #1#
                                                         (VECTOR
                                                          (QVELT |rn|
                                                           0)
                                                          (SPADCALL
                                                           (QVELT |rec|
                                                            1)
                                                           (QVELT |rn|
                                                            1)
                                                           (QREFELT $
                                                            66))
                                                          (SPADCALL
                                                           (QVELT |rec|
                                                            2)
                                                           (QVELT |rn|
                                                            2)
                                                           (QREFELT $
                                                            67))) . #3#)
                                                        (GO #1#)))) . #3#)
                                                   (GO #2#))))))
                                            (LETT |i|
                                             (PROG1 (QSADD1 |i|)
                                               (LETT #0#
                                                (CDR #0#) . #3#)) . #3#)
                                            (GO G190) G191 (EXIT NIL)))
                                          #2# (EXIT #2#))
                                         (EXIT (VECTOR |f| NIL NIL))))))))))))
           #1# (EXIT #1#))))) 

(DEFUN |EFSTRUC;rootNormalize0!0| (|#1| $)
  (COND
    ((SPADCALL |#1| (SPADCALL "nthRoot" (QREFELT $ 10)) (QREFELT $ 32))
     (SPADCALL
         (SPADCALL
             (SPADCALL (SPADCALL |#1| (QREFELT $ 34)) (QREFELT $ 35))
             (QREFELT $ 25))
         (QREFELT $ 58)))
    ('T (|spadConstant| $ 36)))) 

(DEFUN |EFSTRUC;deprel| (|ker| |k| |x| $)
  (PROG (#0=#:G1968 #1=#:G1969 #2=#:G1970 |g| #3=#:G1971 #4=#:G1972
            #5=#:G1973)
    (RETURN
      (SEQ (COND
             ((OR (SPADCALL |k| (SPADCALL "log" (QREFELT $ 10))
                      (QREFELT $ 32))
                  (SPADCALL |k| (SPADCALL "exp" (QREFELT $ 10))
                      (QREFELT $ 32)))
              (|EFSTRUC;qdeprel|
                  (PROGN
                    (LETT #0# NIL . #6=(|EFSTRUC;deprel|))
                    (SEQ (LETT |g| NIL . #6#)
                         (LETT #1# (|EFSTRUC;toY| |ker| $) . #6#) G190
                         (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |g| (CAR #1#) . #6#) NIL))
                            #7=(GO G191)))
                         (SEQ (EXIT (LETT #0#
                                     (CONS
                                      (SPADCALL |g| |x| (QREFELT $ 68))
                                      #0#) . #6#)))
                         (LETT #1# (CDR #1#) . #6#) #8=(GO G190) G191
                         (EXIT (NREVERSE0 #0#))))
                  (SPADCALL (|EFSTRUC;ktoY| |k| $) |x| (QREFELT $ 68))
                  $))
             ((OR (SPADCALL |k| (SPADCALL "atan" (QREFELT $ 10))
                      (QREFELT $ 32))
                  (SPADCALL |k| (SPADCALL "tan" (QREFELT $ 10))
                      (QREFELT $ 32)))
              (|EFSTRUC;qdeprel|
                  (PROGN
                    (LETT #2# NIL . #6#)
                    (SEQ (LETT |g| NIL . #6#)
                         (LETT #3# (|EFSTRUC;toU| |ker| $) . #6#) G190
                         (COND
                           ((OR (ATOM #3#)
                                (PROGN (LETT |g| (CAR #3#) . #6#) NIL))
                            #7#))
                         (SEQ (EXIT (LETT #2#
                                     (CONS
                                      (SPADCALL |g| |x| (QREFELT $ 68))
                                      #2#) . #6#)))
                         (LETT #3# (CDR #3#) . #6#) #8# G191
                         (EXIT (NREVERSE0 #2#))))
                  (SPADCALL (|EFSTRUC;ktoU| |k| $) |x| (QREFELT $ 68))
                  $))
             ('T
              (COND
                ((SPADCALL |k| (SPADCALL "nthRoot" (QREFELT $ 10))
                     (QREFELT $ 32))
                 (|EFSTRUC;rootDep| |ker| |k| $))
                ('T
                 (SEQ (COND
                        ((QREFELT $ 13)
                         (COND
                           ((SPADCALL |k|
                                (SPADCALL "factorial" (QREFELT $ 10))
                                (QREFELT $ 32))
                            (EXIT (|EFSTRUC;factdeprel|
                                      (PROGN
                                        (LETT #4# NIL . #6#)
                                        (SEQ (LETT |x| NIL . #6#)
                                         (LETT #5# |ker| . #6#) G190
                                         (COND
                                           ((OR (ATOM #5#)
                                             (PROGN
                                               (LETT |x|
                                                (CAR #5#) . #6#)
                                               NIL))
                                            #7#))
                                         (SEQ
                                          (EXIT
                                           (COND
                                             ((COND
                                                ((SPADCALL |x|
                                                  (SPADCALL "factorial"
                                                   (QREFELT $ 10))
                                                  (QREFELT $ 32))
                                                 (COND
                                                   ((SPADCALL |x| |k|
                                                     (QREFELT $ 69))
                                                    'NIL)
                                                   ('T 'T)))
                                                ('T 'NIL))
                                              (LETT #4#
                                               (CONS |x| #4#) . #6#)))))
                                         (LETT #5# (CDR #5#) . #6#) #8#
                                         G191 (EXIT (NREVERSE0 #4#))))
                                      |k| $))))))
                      (EXIT (CONS 2 'T))))))))))) 

(DEFUN |EFSTRUC;ktoY| (|k| $)
  (COND
    ((SPADCALL |k| (SPADCALL "log" (QREFELT $ 10)) (QREFELT $ 32))
     (SPADCALL |k| (QREFELT $ 71)))
    ((SPADCALL |k| (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 32))
     (|SPADfirst| (SPADCALL |k| (QREFELT $ 34))))
    ('T (|spadConstant| $ 28)))) 

(DEFUN |EFSTRUC;ktoZ| (|k| $)
  (COND
    ((SPADCALL |k| (SPADCALL "log" (QREFELT $ 10)) (QREFELT $ 32))
     (|SPADfirst| (SPADCALL |k| (QREFELT $ 34))))
    ((SPADCALL |k| (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 32))
     (SPADCALL |k| (QREFELT $ 71)))
    ('T (|spadConstant| $ 28)))) 

(DEFUN |EFSTRUC;ktoU| (|k| $)
  (COND
    ((SPADCALL |k| (SPADCALL "atan" (QREFELT $ 10)) (QREFELT $ 32))
     (SPADCALL |k| (QREFELT $ 71)))
    ((SPADCALL |k| (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 32))
     (|SPADfirst| (SPADCALL |k| (QREFELT $ 34))))
    ('T (|spadConstant| $ 28)))) 

(DEFUN |EFSTRUC;ktoV| (|k| $)
  (COND
    ((SPADCALL |k| (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 32))
     (SPADCALL |k| (QREFELT $ 71)))
    ((SPADCALL |k| (SPADCALL "atan" (QREFELT $ 10)) (QREFELT $ 32))
     (|SPADfirst| (SPADCALL |k| (QREFELT $ 34))))
    ('T (|spadConstant| $ 28)))) 

(DEFUN |EFSTRUC;smpElem| (|p| |l| $)
  (SPADCALL (CONS #'|EFSTRUC;smpElem!0| (VECTOR $ |l|))
      (CONS #'|EFSTRUC;smpElem!1| $) |p| (QREFELT $ 77))) 

(DEFUN |EFSTRUC;smpElem!1| (|#1| $) (SPADCALL |#1| (QREFELT $ 72))) 

(DEFUN |EFSTRUC;smpElem!0| (|#1| $$)
  (|EFSTRUC;k2Elem| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |EFSTRUC;k2Elem| (|k| |l| $)
  (PROG (|kf| #0=#:G2028 |v| #1=#:G2029 #2=#:G2030 |a| #3=#:G2031
              |args| |z| |op| |ez| |iez| |tz2|)
    (RETURN
      (SEQ (LETT |kf| (SPADCALL |k| (QREFELT $ 71))
                 . #4=(|EFSTRUC;k2Elem|))
           (COND
             ((NULL (NULL |l|))
              (COND
                ((NULL (PROGN
                         (LETT #0# NIL . #4#)
                         (SEQ (LETT |v| NIL . #4#)
                              (LETT #1#
                                    (SPADCALL |kf| (QREFELT $ 25)) . #4#)
                              G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |v| (CAR #1#) . #4#)
                                       NIL))
                                 #5=(GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((SPADCALL |v| |l|
                                        (QREFELT $ 78))
                                       (LETT #0# (CONS |v| #0#) . #4#)))))
                              (LETT #1# (CDR #1#) . #4#) #6=(GO G190)
                              G191 (EXIT (NREVERSE0 #0#)))))
                 (EXIT |kf|)))))
           (EXIT (COND
                   ((NULL (LETT |args|
                                (PROGN
                                  (LETT #2# NIL . #4#)
                                  (SEQ (LETT |a| NIL . #4#)
                                       (LETT #3#
                                        (SPADCALL |k| (QREFELT $ 34)) . #4#)
                                       G190
                                       (COND
                                         ((OR (ATOM #3#)
                                           (PROGN
                                             (LETT |a| (CAR #3#) . #4#)
                                             NIL))
                                          #5#))
                                       (SEQ
                                        (EXIT
                                         (LETT #2#
                                          (CONS
                                           (|EFSTRUC;realElem| |a| |l|
                                            $)
                                           #2#) . #4#)))
                                       (LETT #3# (CDR #3#) . #4#) #6#
                                       G191 (EXIT (NREVERSE0 #2#)))) . #4#))
                    |kf|)
                   ('T
                    (SEQ (LETT |z| (|SPADfirst| |args|) . #4#)
                         (EXIT (COND
                                 ((SPADCALL |k|
                                      (SPADCALL "%power"
                                       (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (COND
                                    ((SPADCALL |z| (QREFELT $ 79))
                                     (|spadConstant| $ 28))
                                    ('T
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |args| (QREFELT $ 80))
                                       (SPADCALL |z| (QREFELT $ 81))
                                       (QREFELT $ 82))
                                      (QREFELT $ 83)))))
                                 ((SPADCALL |k|
                                      (SPADCALL "cot" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL |z| (QREFELT $ 57))
                                      (QREFELT $ 56)))
                                 ((SPADCALL |k|
                                      (SPADCALL "acot" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL |z| (QREFELT $ 56))
                                      (QREFELT $ 84)))
                                 ((SPADCALL |k|
                                      (SPADCALL "asin" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL |z|
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 63)
                                         (SPADCALL |z| 2
                                          (QREFELT $ 85))
                                         (QREFELT $ 86))
                                        (QREFELT $ 87))
                                       (QREFELT $ 18))
                                      (QREFELT $ 84)))
                                 ((SPADCALL |k|
                                      (SPADCALL "acos" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 63)
                                         (SPADCALL |z| 2
                                          (QREFELT $ 85))
                                         (QREFELT $ 86))
                                        (QREFELT $ 87))
                                       |z| (QREFELT $ 18))
                                      (QREFELT $ 84)))
                                 ((SPADCALL |k|
                                      (SPADCALL "asec" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL (|spadConstant| $ 63)
                                        (SPADCALL |z| 2 (QREFELT $ 85))
                                        (QREFELT $ 86))
                                       (QREFELT $ 87))
                                      (QREFELT $ 84)))
                                 ((SPADCALL |k|
                                      (SPADCALL "acsc" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 63)
                                         (SPADCALL |z| 2
                                          (QREFELT $ 85))
                                         (QREFELT $ 86))
                                        (QREFELT $ 87))
                                       (QREFELT $ 56))
                                      (QREFELT $ 84)))
                                 ((SPADCALL |k|
                                      (SPADCALL "asinh" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 63)
                                         (SPADCALL |z| 2
                                          (QREFELT $ 85))
                                         (QREFELT $ 88))
                                        (QREFELT $ 87))
                                       |z| (QREFELT $ 88))
                                      (QREFELT $ 81)))
                                 ((SPADCALL |k|
                                      (SPADCALL "acosh" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |z| 2
                                          (QREFELT $ 85))
                                         (|spadConstant| $ 63)
                                         (QREFELT $ 86))
                                        (QREFELT $ 87))
                                       |z| (QREFELT $ 88))
                                      (QREFELT $ 81)))
                                 ((SPADCALL |k|
                                      (SPADCALL "atanh" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |z|
                                         (|spadConstant| $ 63)
                                         (QREFELT $ 88))
                                        (SPADCALL (|spadConstant| $ 63)
                                         |z| (QREFELT $ 86))
                                        (QREFELT $ 18))
                                       (QREFELT $ 81))
                                      (SPADCALL 2 (QREFELT $ 16))
                                      (QREFELT $ 18)))
                                 ((SPADCALL |k|
                                      (SPADCALL "acoth" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |z|
                                         (|spadConstant| $ 63)
                                         (QREFELT $ 88))
                                        (SPADCALL |z|
                                         (|spadConstant| $ 63)
                                         (QREFELT $ 86))
                                        (QREFELT $ 18))
                                       (QREFELT $ 81))
                                      (SPADCALL 2 (QREFELT $ 16))
                                      (QREFELT $ 18)))
                                 ((SPADCALL |k|
                                      (SPADCALL "asech" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |z| (QREFELT $ 56))
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |z| 2
                                           (QREFELT $ 85))
                                          (QREFELT $ 56))
                                         (|spadConstant| $ 63)
                                         (QREFELT $ 86))
                                        (QREFELT $ 87))
                                       (QREFELT $ 88))
                                      (QREFELT $ 81)))
                                 ((SPADCALL |k|
                                      (SPADCALL "acsch" (QREFELT $ 10))
                                      (QREFELT $ 32))
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |z| (QREFELT $ 56))
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 63)
                                         (SPADCALL
                                          (SPADCALL |z| 2
                                           (QREFELT $ 85))
                                          (QREFELT $ 56))
                                         (QREFELT $ 88))
                                        (QREFELT $ 87))
                                       (QREFELT $ 88))
                                      (QREFELT $ 81)))
                                 ((OR (SPADCALL |k|
                                       (SPADCALL "%paren"
                                        (QREFELT $ 10))
                                       (QREFELT $ 32))
                                      (SPADCALL |k|
                                       (SPADCALL "%box" (QREFELT $ 10))
                                       (QREFELT $ 32)))
                                  (COND
                                    ((NULL (CDR |args|)) |z|)
                                    ('T |kf|)))
                                 ('T
                                  (SEQ (COND
                                         ((SPADCALL
                                           (LETT |op|
                                            (SPADCALL |k|
                                             (QREFELT $ 90)) . #4#)
                                           (QREFELT $ 11)
                                           (QREFELT $ 91))
                                          (LETT |iez|
                                           (SPADCALL
                                            (LETT |ez|
                                             (SPADCALL |z|
                                              (QREFELT $ 83)) . #4#)
                                            (QREFELT $ 56)) . #4#)))
                                       (EXIT
                                        (COND
                                          ((SPADCALL |k|
                                            (SPADCALL "sinh"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (SPADCALL
                                            (SPADCALL |ez| |iez|
                                             (QREFELT $ 86))
                                            (SPADCALL 2 (QREFELT $ 16))
                                            (QREFELT $ 18)))
                                          ((SPADCALL |k|
                                            (SPADCALL "cosh"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (SPADCALL
                                            (SPADCALL |ez| |iez|
                                             (QREFELT $ 88))
                                            (SPADCALL 2 (QREFELT $ 16))
                                            (QREFELT $ 18)))
                                          ((SPADCALL |k|
                                            (SPADCALL "tanh"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (SPADCALL
                                            (SPADCALL |ez| |iez|
                                             (QREFELT $ 86))
                                            (SPADCALL |ez| |iez|
                                             (QREFELT $ 88))
                                            (QREFELT $ 18)))
                                          ((SPADCALL |k|
                                            (SPADCALL "coth"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (SPADCALL
                                            (SPADCALL |ez| |iez|
                                             (QREFELT $ 88))
                                            (SPADCALL |ez| |iez|
                                             (QREFELT $ 86))
                                            (QREFELT $ 18)))
                                          ((SPADCALL |k|
                                            (SPADCALL "sech"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (SPADCALL 2
                                            (SPADCALL
                                             (SPADCALL |ez| |iez|
                                              (QREFELT $ 88))
                                             (QREFELT $ 56))
                                            (QREFELT $ 92)))
                                          ((SPADCALL |k|
                                            (SPADCALL "csch"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (SPADCALL 2
                                            (SPADCALL
                                             (SPADCALL |ez| |iez|
                                              (QREFELT $ 86))
                                             (QREFELT $ 56))
                                            (QREFELT $ 92)))
                                          ('T
                                           (SEQ
                                            (COND
                                              ((SPADCALL |op|
                                                (QREFELT $ 12)
                                                (QREFELT $ 91))
                                               (LETT |tz2|
                                                (SPADCALL
                                                 (SPADCALL |z|
                                                  (SPADCALL 2
                                                   (QREFELT $ 16))
                                                  (QREFELT $ 18))
                                                 (QREFELT $ 57)) . #4#)))
                                            (EXIT
                                             (COND
                                               ((SPADCALL |k|
                                                 (SPADCALL "sin"
                                                  (QREFELT $ 10))
                                                 (QREFELT $ 32))
                                                (SPADCALL
                                                 (SPADCALL 2 |tz2|
                                                  (QREFELT $ 92))
                                                 (SPADCALL
                                                  (|spadConstant| $ 63)
                                                  (SPADCALL |tz2| 2
                                                   (QREFELT $ 85))
                                                  (QREFELT $ 88))
                                                 (QREFELT $ 18)))
                                               ((SPADCALL |k|
                                                 (SPADCALL "cos"
                                                  (QREFELT $ 10))
                                                 (QREFELT $ 32))
                                                (SPADCALL
                                                 (SPADCALL
                                                  (|spadConstant| $ 63)
                                                  (SPADCALL |tz2| 2
                                                   (QREFELT $ 85))
                                                  (QREFELT $ 86))
                                                 (SPADCALL
                                                  (|spadConstant| $ 63)
                                                  (SPADCALL |tz2| 2
                                                   (QREFELT $ 85))
                                                  (QREFELT $ 88))
                                                 (QREFELT $ 18)))
                                               ((SPADCALL |k|
                                                 (SPADCALL "sec"
                                                  (QREFELT $ 10))
                                                 (QREFELT $ 32))
                                                (SPADCALL
                                                 (SPADCALL
                                                  (|spadConstant| $ 63)
                                                  (SPADCALL |tz2| 2
                                                   (QREFELT $ 85))
                                                  (QREFELT $ 88))
                                                 (SPADCALL
                                                  (|spadConstant| $ 63)
                                                  (SPADCALL |tz2| 2
                                                   (QREFELT $ 85))
                                                  (QREFELT $ 86))
                                                 (QREFELT $ 18)))
                                               ((SPADCALL |k|
                                                 (SPADCALL "csc"
                                                  (QREFELT $ 10))
                                                 (QREFELT $ 32))
                                                (SPADCALL
                                                 (SPADCALL
                                                  (|spadConstant| $ 63)
                                                  (SPADCALL |tz2| 2
                                                   (QREFELT $ 85))
                                                  (QREFELT $ 88))
                                                 (SPADCALL 2 |tz2|
                                                  (QREFELT $ 92))
                                                 (QREFELT $ 18)))
                                               ('T
                                                (SPADCALL |op| |args|
                                                 (QREFELT $ 95))))))))))))))))))))) 

(DEFUN |EFSTRUC;depeval| (|f| |lk| |k| |v| $)
  (COND
    ((SPADCALL |k| (SPADCALL "log" (QREFELT $ 10)) (QREFELT $ 32))
     (|EFSTRUC;logeval| |f| |lk| |k| |v| $))
    ((SPADCALL |k| (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 32))
     (|EFSTRUC;expeval| |f| |lk| |k| |v| $))
    ((SPADCALL |k| (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 32))
     (|EFSTRUC;taneval| |f| |lk| |k| |v| $))
    ((SPADCALL |k| (SPADCALL "atan" (QREFELT $ 10)) (QREFELT $ 32))
     (|EFSTRUC;ataneval| |f| |lk| |k| |v| $))
    ((SPADCALL |k| (SPADCALL "nthRoot" (QREFELT $ 10)) (QREFELT $ 32))
     (|EFSTRUC;rooteval| |f| |lk| |k|
         (SPADCALL |v| (SPADCALL |v| (QREFELT $ 97)) (QREFELT $ 98)) $))
    ('T (VECTOR |f| NIL NIL)))) 

(DEFUN |EFSTRUC;rooteval| (|f| |lk| |k| |n| $)
  (PROG (|x| |m| |nv| #0=#:G2045 #1=#:G2046 |l| #2=#:G2047 |r|
             #3=#:G2048 |lv|)
    (RETURN
      (SEQ (LETT |nv|
                 (SPADCALL
                     (LETT |x|
                           (|SPADfirst| (SPADCALL |k| (QREFELT $ 34)))
                           . #4=(|EFSTRUC;rooteval|))
                     (LETT |m| (SPADCALL |n| (QREFELT $ 99)) . #4#)
                     (QREFELT $ 100)) . #4#)
           (LETT |l|
                 (PROGN
                   (LETT #0# NIL . #4#)
                   (SEQ (LETT |r| NIL . #4#)
                        (LETT #1#
                              (CONS |k| (|EFSTRUC;toR| |lk| |x| $)) . #4#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |r| (CAR #1#) . #4#) NIL))
                           #5=(GO G191)))
                        (SEQ (EXIT (COND
                                     ((COND
                                        ((EQL
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |r|
                                             (QREFELT $ 34))
                                            (QREFELT $ 101))
                                           (QREFELT $ 102))
                                          |m|)
                                         'NIL)
                                        ('T 'T))
                                      (LETT #0# (CONS |r| #0#) . #4#)))))
                        (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #4#)
           (LETT |lv|
                 (PROGN
                   (LETT #2# NIL . #4#)
                   (SEQ (LETT |r| NIL . #4#) (LETT #3# |l| . #4#) G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN (LETT |r| (CAR #3#) . #4#) NIL))
                           #5#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (SPADCALL |nv|
                                      (SPADCALL |n|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |r| (QREFELT $ 34))
                                          (QREFELT $ 101))
                                         (QREFELT $ 102))
                                        (QREFELT $ 103))
                                       (QREFELT $ 104))
                                      (QREFELT $ 105))
                                     #2#) . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6# G191
                        (EXIT (NREVERSE0 #2#)))) . #4#)
           (EXIT (VECTOR (SPADCALL |f| |l| |lv| (QREFELT $ 106)) |l|
                         |lv|)))))) 

(DEFUN |EFSTRUC;ataneval| (|f| |lk| |k| |v| $)
  (PROG (|w| #0=#:G2057 #1=#:G2059 #2=#:G2058 |s| |x| #3=#:G2061 |i|
             #4=#:G2060 #5=#:G2053 #6=#:G2051 #7=#:G2052 |d| |h| |g|)
    (RETURN
      (SEQ (LETT |w| (|SPADfirst| (SPADCALL |k| (QREFELT $ 34)))
                 . #8=(|EFSTRUC;ataneval|))
           (LETT |s|
                 (SPADCALL
                     (PROGN
                       (LETT #0# NIL . #8#)
                       (SEQ (LETT |x| NIL . #8#)
                            (LETT #1# (|EFSTRUC;toV| |lk| $) . #8#)
                            (LETT |i|
                                  (SPADCALL |v| (QREFELT $ 97)) . #8#)
                            (LETT #2# (QVSIZE |v|) . #8#) G190
                            (COND
                              ((OR (> |i| #2#) (ATOM #1#)
                                   (PROGN
                                     (LETT |x| (CAR #1#) . #8#)
                                     NIL))
                               #9=(GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL |v| |i|
                                           (QREFELT $ 107))
                                          |x| (QREFELT $ 52))
                                         #0#) . #8#)))
                            (LETT |i|
                                  (PROG1 (+ |i| 1)
                                    (LETT #1# (CDR #1#) . #8#)) . #8#)
                            #10=(GO G190) G191 (EXIT (NREVERSE0 #0#))))
                     (QREFELT $ 55)) . #8#)
           (LETT |g|
                 (PROGN
                   (LETT #7# NIL . #8#)
                   (SEQ (LETT |x| NIL . #8#)
                        (LETT #3# (|EFSTRUC;toU| |lk| $) . #8#)
                        (LETT |i| (SPADCALL |v| (QREFELT $ 97)) . #8#)
                        (LETT #4# (QVSIZE |v|) . #8#) G190
                        (COND
                          ((OR (> |i| #4#) (ATOM #3#)
                               (PROGN (LETT |x| (CAR #3#) . #8#) NIL))
                           #9#))
                        (SEQ (EXIT (PROGN
                                     (LETT #5#
                                      (SPADCALL
                                       (SPADCALL |v| |i|
                                        (QREFELT $ 107))
                                       |x| (QREFELT $ 108)) . #8#)
                                     (COND
                                       (#7#
                                        (LETT #6#
                                         (SPADCALL #6# #5#
                                          (QREFELT $ 88)) . #8#))
                                       ('T
                                        (PROGN
                                          (LETT #6# #5# . #8#)
                                          (LETT #7# 'T . #8#)))))))
                        (LETT |i|
                              (PROG1 (+ |i| 1)
                                (LETT #3# (CDR #3#) . #8#)) . #8#)
                        #10# G191 (EXIT NIL))
                   (COND (#7# #6#) ('T (|spadConstant| $ 28)))) . #8#)
           (LETT |h|
                 (COND
                   ((SPADCALL
                        (LETT |d|
                              (SPADCALL (|spadConstant| $ 63)
                                  (SPADCALL |s| |w| (QREFELT $ 82))
                                  (QREFELT $ 88)) . #8#)
                        (QREFELT $ 79))
                    (QREFELT $ 19))
                   ('T
                    (SPADCALL
                        (SPADCALL (SPADCALL |w| |s| (QREFELT $ 86)) |d|
                            (QREFELT $ 18))
                        (QREFELT $ 84)))) . #8#)
           (LETT |g| (SPADCALL |g| |h| (QREFELT $ 88)) . #8#)
           (EXIT (VECTOR (SPADCALL |f| (LIST |k|) (LIST |g|)
                             (QREFELT $ 106))
                         (LIST |k|) (LIST |g|))))))) 

(DEFUN |EFSTRUC;gdCoef?| (|c| |v| $)
  (PROG (|i| #0=#:G2069 #1=#:G2068 #2=#:G2066)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i|
                                       (SPADCALL |v| (QREFELT $ 97))
                                       . #3=(|EFSTRUC;gdCoef?|))
                                      (LETT #0# (QVSIZE |v|) . #3#)
                                      G190
                                      (COND ((> |i| #0#) (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((QEQCAR
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL |v| |i|
                                               (QREFELT $ 107))
                                              |c| (QREFELT $ 104))
                                             (QREFELT $ 109))
                                            1)
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |i| (+ |i| 1) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |EFSTRUC;goodCoef| (|v| |l| |s| $)
  (PROG (#0=#:G2103 |ll| #1=#:G2105 #2=#:G2104 |h1| |j| |h| |k|
            #3=#:G2107 |i| #4=#:G2106 |r| #5=#:G2102 #6=#:G2100)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |h| 0 . #7=(|EFSTRUC;goodCoef|))
                      (LETT |j| 0 . #7#) (LETT |ll| NIL . #7#)
                      (SEQ (LETT |k| NIL . #7#) (LETT #0# |l| . #7#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |k| (CAR #0#) . #7#)
                                    NIL))
                              #8=(GO G191)))
                           (SEQ (EXIT (COND
                                        ((OR
                                          (SPADCALL |k|
                                           (SPADCALL "log"
                                            (QREFELT $ 10))
                                           (QREFELT $ 32))
                                          (OR
                                           (SPADCALL |k|
                                            (SPADCALL "exp"
                                             (QREFELT $ 10))
                                            (QREFELT $ 32))
                                           (OR
                                            (SPADCALL |k|
                                             (SPADCALL "tan"
                                              (QREFELT $ 10))
                                             (QREFELT $ 32))
                                            (SPADCALL |k|
                                             (SPADCALL "atan"
                                              (QREFELT $ 10))
                                             (QREFELT $ 32)))))
                                         (SEQ
                                          (LETT |ll|
                                           (CONS |k| |ll|) . #7#)
                                          (EXIT
                                           (LETT |h| (+ |h| 1) . #7#)))))))
                           (LETT #0# (CDR #0#) . #7#) #9=(GO G190) G191
                           (EXIT NIL))
                      (COND
                        ((NULL (EQL |h|
                                    (+
                                     (- (QVSIZE |v|)
                                      (SPADCALL |v| (QREFELT $ 97)))
                                     1)))
                         (EXIT (CONS 1 "failed"))))
                      (LETT |h| 0 . #7#)
                      (LETT |ll| (REVERSE |ll|) . #7#)
                      (SEQ (LETT |k| NIL . #7#) (LETT #1# |ll| . #7#)
                           (LETT |i|
                                 (SPADCALL |v| (QREFELT $ 97)) . #7#)
                           (LETT #2# (QVSIZE |v|) . #7#) G190
                           (COND
                             ((OR (> |i| #2#) (ATOM #1#)
                                  (PROGN
                                    (LETT |k| (CAR #1#) . #7#)
                                    NIL))
                              #8#))
                           (SEQ (LETT |h1|
                                      (SPADCALL |k| (QREFELT $ 110)) . #7#)
                                (EXIT (COND
                                        ((< |h| |h1|)
                                         (SEQ (LETT |j| |i| . #7#)
                                          (EXIT (LETT |h| |h1| . #7#)))))))
                           (LETT |i|
                                 (PROG1 (+ |i| 1)
                                   (LETT #1# (CDR #1#) . #7#)) . #7#)
                           #9# G191 (EXIT NIL))
                      (SEQ (EXIT (SEQ (LETT |k| NIL . #7#)
                                      (LETT #3# |ll| . #7#)
                                      (LETT |i|
                                       (SPADCALL |v| (QREFELT $ 97)) . #7#)
                                      (LETT #4# (QVSIZE |v|) . #7#)
                                      G190
                                      (COND
                                        ((OR (> |i| #4#) (ATOM #3#)
                                          (PROGN
                                            (LETT |k| (CAR #3#) . #7#)
                                            NIL))
                                         #8#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((SPADCALL |k| |s|
                                            (QREFELT $ 32))
                                           (COND
                                             ((NULL (< |i| |j|))
                                              (SEQ
                                               (LETT |r|
                                                (SPADCALL
                                                 (SPADCALL |v| |i|
                                                  (QREFELT $ 107))
                                                 (QREFELT $ 112)) . #7#)
                                               (EXIT
                                                (COND
                                                  ((QEQCAR |r| 0)
                                                   (COND
                                                     ((QEQCAR
                                                       (SPADCALL
                                                        (QCDR |r|)
                                                        (QREFELT $ 109))
                                                       0)
                                                      (COND
                                                        ((|EFSTRUC;gdCoef?|
                                                          (SPADCALL |v|
                                                           |i|
                                                           (QREFELT $
                                                            107))
                                                          |v| $)
                                                         (PROGN
                                                           (LETT #6#
                                                            (PROGN
                                                              (LETT #5#
                                                               (CONS 0
                                                                (CONS
                                                                 |i|
                                                                 |k|)) . #7#)
                                                              (GO #5#)) . #7#)
                                                           (GO #6#))))))))))))))))
                                      (LETT |i|
                                       (PROG1 (+ |i| 1)
                                         (LETT #3# (CDR #3#) . #7#)) . #7#)
                                      #9# G191 (EXIT NIL)))
                           #6# (EXIT #6#))
                      (EXIT (CONS 1 "failed"))))
           #5# (EXIT #5#))))) 

(DEFUN |EFSTRUC;taneval| (|f| |lk| |k| |v| $)
  (PROG (|u| |fns| #0=#:G2125 #1=#:G2124 #2=#:G2111 #3=#:G2109
             #4=#:G2110 |c| |rec| |v0| #5=#:G2126 |i| #6=#:G2127 |lv|
             #7=#:G2128 |kk| #8=#:G2129 |l| #9=#:G2130 |x| #10=#:G2132
             |a| #11=#:G2131 |g|)
    (RETURN
      (SEQ (LETT |u| (|SPADfirst| (SPADCALL |k| (QREFELT $ 34)))
                 . #12=(|EFSTRUC;taneval|))
           (LETT |fns| (|EFSTRUC;toU| |lk| $) . #12#)
           (LETT |c|
                 (SPADCALL |u|
                     (PROGN
                       (LETT #4# NIL . #12#)
                       (SEQ (LETT |x| NIL . #12#)
                            (LETT #0# |fns| . #12#)
                            (LETT |i|
                                  (SPADCALL |v| (QREFELT $ 97)) . #12#)
                            (LETT #1# (QVSIZE |v|) . #12#) G190
                            (COND
                              ((OR (> |i| #1#) (ATOM #0#)
                                   (PROGN
                                     (LETT |x| (CAR #0#) . #12#)
                                     NIL))
                               #13=(GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #2#
                                          (SPADCALL
                                           (SPADCALL |v| |i|
                                            (QREFELT $ 107))
                                           |x| (QREFELT $ 108)) . #12#)
                                         (COND
                                           (#4#
                                            (LETT #3#
                                             (SPADCALL #3# #2#
                                              (QREFELT $ 88)) . #12#))
                                           ('T
                                            (PROGN
                                              (LETT #3# #2# . #12#)
                                              (LETT #4# 'T . #12#)))))))
                            (LETT |i|
                                  (PROG1 (+ |i| 1)
                                    (LETT #0# (CDR #0#) . #12#)) . #12#)
                            #14=(GO G190) G191 (EXIT NIL))
                       (COND (#4# #3#) (#15='T (|spadConstant| $ 28))))
                     (QREFELT $ 86)) . #12#)
           (LETT |rec|
                 (|EFSTRUC;goodCoef| |v| |lk|
                     (SPADCALL "tan" (QREFELT $ 10)) $) . #12#)
           (EXIT (COND
                   ((QEQCAR |rec| 1)
                    (|EFSTRUC;tannosimp| |f| |lk| |k| |v| |fns| |c| $))
                   (#15#
                    (SEQ (LETT |v0|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |v| (QCAR (QCDR |rec|))
                                     (QREFELT $ 107))
                                    (QREFELT $ 113))
                                   (QREFELT $ 99)) . #12#)
                         (LETT |lv|
                               (PROGN
                                 (LETT #5# NIL . #12#)
                                 (SEQ (LETT |i|
                                       (SPADCALL |v| (QREFELT $ 97)) . #12#)
                                      (LETT #6# (QVSIZE |v|) . #12#)
                                      G190 (COND ((> |i| #6#) #13#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((COND
                                             ((EQL |i|
                                               (QCAR (QCDR |rec|)))
                                              'NIL)
                                             ('T 'T))
                                           (LETT #5#
                                            (CONS
                                             (SPADCALL |v| |i|
                                              (QREFELT $ 107))
                                             #5#) . #12#)))))
                                      (LETT |i| (+ |i| 1) . #12#) #14#
                                      G191 (EXIT (NREVERSE0 #5#)))) . #12#)
                         (LETT |l|
                               (PROGN
                                 (LETT #7# NIL . #12#)
                                 (SEQ (LETT |kk| NIL . #12#)
                                      (LETT #8# |lk| . #12#) G190
                                      (COND
                                        ((OR (ATOM #8#)
                                          (PROGN
                                            (LETT |kk|
                                             (CAR #8#) . #12#)
                                            NIL))
                                         #13#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((COND
                                             ((SPADCALL |kk|
                                               (QCDR (QCDR |rec|))
                                               (QREFELT $ 69))
                                              'NIL)
                                             ('T 'T))
                                           (LETT #7#
                                            (CONS |kk| #7#) . #12#)))))
                                      (LETT #8# (CDR #8#) . #12#) #14#
                                      G191 (EXIT (NREVERSE0 #7#)))) . #12#)
                         (LETT |g|
                               (|EFSTRUC;tanSum|
                                   (SPADCALL
                                    (SPADCALL |v0| |c| (QREFELT $ 114))
                                    (QREFELT $ 17))
                                   (CONS
                                    (SPADCALL
                                     (SPADCALL |k| (QREFELT $ 71)) |v0|
                                     (QREFELT $ 51))
                                    (PROGN
                                      (LETT #9# NIL . #12#)
                                      (SEQ (LETT |x| NIL . #12#)
                                       (LETT #10#
                                        (|EFSTRUC;toV| |l| $) . #12#)
                                       (LETT |a| NIL . #12#)
                                       (LETT #11# |lv| . #12#) G190
                                       (COND
                                         ((OR (ATOM #11#)
                                           (PROGN
                                             (LETT |a|
                                              (CAR #11#) . #12#)
                                             NIL)
                                           (ATOM #10#)
                                           (PROGN
                                             (LETT |x|
                                              (CAR #10#) . #12#)
                                             NIL))
                                          #13#))
                                       (SEQ
                                        (EXIT
                                         (LETT #9#
                                          (CONS
                                           (SPADCALL |x|
                                            (-
                                             (SPADCALL
                                              (SPADCALL |a| |v0|
                                               (QREFELT $ 115))
                                              (QREFELT $ 99)))
                                            (QREFELT $ 51))
                                           #9#) . #12#)))
                                       (LETT #11#
                                        (PROG1 (CDR #11#)
                                          (LETT #10# (CDR #10#) . #12#)) . #12#)
                                       #14# G191
                                       (EXIT (NREVERSE0 #9#)))))
                                   $) . #12#)
                         (EXIT (VECTOR (SPADCALL |f|
                                        (LIST (QCDR (QCDR |rec|)))
                                        (LIST |g|) (QREFELT $ 106))
                                       (LIST (QCDR (QCDR |rec|)))
                                       (LIST |g|))))))))))) 

(DEFUN |EFSTRUC;tannosimp| (|f| |lk| |k| |v| |fns| |c| $)
  (PROG (|cd| |d| |dd| #0=#:G2144 |u| #1=#:G2145 |newt| #2=#:G2146
              #3=#:G2147 #4=#:G2148 |t| #5=#:G2150 #6=#:G2149 |newtan|
              #7=#:G2151 |x| #8=#:G2153 |i| #9=#:G2152 |h|)
    (RETURN
      (SEQ (COND
             ((SPADCALL (CONS #'|EFSTRUC;tannosimp!0| $) |lk|
                  (QREFELT $ 116))
              (SEQ (LETT |dd|
                         (SPADCALL
                             (LETT |d|
                                   (QCDR
                                    (LETT |cd|
                                     (SPADCALL |v| (QREFELT $ 119))
                                     . #10=(|EFSTRUC;tannosimp|))) . #10#)
                             (QREFELT $ 16)) . #10#)
                   (LETT |newt|
                         (PROGN
                           (LETT #0# NIL . #10#)
                           (SEQ (LETT |u| NIL . #10#)
                                (LETT #1# |fns| . #10#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |u| (CAR #1#) . #10#)
                                      NIL))
                                   #11=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |u| |dd|
                                          (QREFELT $ 18))
                                         (QREFELT $ 57))
                                        #0#) . #10#)))
                                (LETT #1# (CDR #1#) . #10#)
                                #12=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #10#)
                   (LETT |newtan|
                         (PROGN
                           (LETT #2# NIL . #10#)
                           (SEQ (LETT |t| NIL . #10#)
                                (LETT #3# |newt| . #10#) G190
                                (COND
                                  ((OR (ATOM #3#)
                                    (PROGN
                                      (LETT |t| (CAR #3#) . #10#)
                                      NIL))
                                   #11#))
                                (SEQ (EXIT
                                      (LETT #2#
                                       (CONS
                                        (SPADCALL |t| |d|
                                         (QREFELT $ 51))
                                        #2#) . #10#)))
                                (LETT #3# (CDR #3#) . #10#) #12# G191
                                (EXIT (NREVERSE0 #2#)))) . #10#)
                   (LETT |h|
                         (|EFSTRUC;tanSum| |c|
                             (PROGN
                               (LETT #4# NIL . #10#)
                               (SEQ (LETT |t| NIL . #10#)
                                    (LETT #5# |newt| . #10#)
                                    (LETT |i|
                                     (SPADCALL |v| (QREFELT $ 97)) . #10#)
                                    (LETT #6# (QVSIZE |v|) . #10#) G190
                                    (COND
                                      ((OR (> |i| #6#) (ATOM #5#)
                                        (PROGN
                                          (LETT |t| (CAR #5#) . #10#)
                                          NIL))
                                       #11#))
                                    (SEQ
                                     (EXIT
                                      (LETT #4#
                                       (CONS
                                        (SPADCALL |t|
                                         (SPADCALL (QCAR |cd|) |i|
                                          (QREFELT $ 121))
                                         (QREFELT $ 51))
                                        #4#) . #10#)))
                                    (LETT |i|
                                     (PROG1 (+ |i| 1)
                                       (LETT #5# (CDR #5#) . #10#)) . #10#)
                                    #12# G191 (EXIT (NREVERSE0 #4#))))
                             $) . #10#)
                   (LETT |lk| (CONS |k| |lk|) . #10#)
                   (LETT |newtan| (CONS |h| |newtan|) . #10#)
                   (EXIT (VECTOR (SPADCALL |f| |lk| |newtan|
                                     (QREFELT $ 106))
                                 |lk| |newtan|))))
             ('T
              (SEQ (LETT |h|
                         (|EFSTRUC;tanSum| |c|
                             (PROGN
                               (LETT #7# NIL . #10#)
                               (SEQ (LETT |x| NIL . #10#)
                                    (LETT #8#
                                     (|EFSTRUC;toV| |lk| $) . #10#)
                                    (LETT |i|
                                     (SPADCALL |v| (QREFELT $ 97)) . #10#)
                                    (LETT #9# (QVSIZE |v|) . #10#) G190
                                    (COND
                                      ((OR (> |i| #9#) (ATOM #8#)
                                        (PROGN
                                          (LETT |x| (CAR #8#) . #10#)
                                          NIL))
                                       #11#))
                                    (SEQ
                                     (EXIT
                                      (LETT #7#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |v| |i|
                                          (QREFELT $ 107))
                                         |x| (QREFELT $ 52))
                                        #7#) . #10#)))
                                    (LETT |i|
                                     (PROG1 (+ |i| 1)
                                       (LETT #8# (CDR #8#) . #10#)) . #10#)
                                    #12# G191 (EXIT (NREVERSE0 #7#))))
                             $) . #10#)
                   (EXIT (VECTOR (SPADCALL |f| (LIST |k|) (LIST |h|)
                                     (QREFELT $ 106))
                                 (LIST |k|) (LIST |h|)))))))))) 

(DEFUN |EFSTRUC;tannosimp!0| (|#1| $)
  (SPADCALL |#1| (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 32))) 

(DEFUN |EFSTRUC;expnosimp| (|f| |lk| |k| |v| |fns| |g| $)
  (PROG (|cd| |d| |dd| #0=#:G2246 #1=#:G2247 |newe| #2=#:G2248
              #3=#:G2249 |e| #4=#:G2251 #5=#:G2250 #6=#:G2199
              #7=#:G2197 #8=#:G2198 |newexp| |y| #9=#:G2253 |i|
              #10=#:G2252 #11=#:G2242 #12=#:G2240 #13=#:G2241 |h|)
    (RETURN
      (SEQ (COND
             ((SPADCALL (CONS #'|EFSTRUC;expnosimp!0| $) |lk|
                  (QREFELT $ 116))
              (SEQ (LETT |dd|
                         (SPADCALL
                             (LETT |d|
                                   (QCDR
                                    (LETT |cd|
                                     (SPADCALL |v| (QREFELT $ 119))
                                     . #14=(|EFSTRUC;expnosimp|))) . #14#)
                             (QREFELT $ 16)) . #14#)
                   (LETT |newe|
                         (PROGN
                           (LETT #0# NIL . #14#)
                           (SEQ (LETT |y| NIL . #14#)
                                (LETT #1# |fns| . #14#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |y| (CAR #1#) . #14#)
                                      NIL))
                                   #15=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL |y| |dd|
                                          (QREFELT $ 18))
                                         (QREFELT $ 83))
                                        #0#) . #14#)))
                                (LETT #1# (CDR #1#) . #14#)
                                #16=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #14#)
                   (LETT |newexp|
                         (PROGN
                           (LETT #2# NIL . #14#)
                           (SEQ (LETT |e| NIL . #14#)
                                (LETT #3# |newe| . #14#) G190
                                (COND
                                  ((OR (ATOM #3#)
                                    (PROGN
                                      (LETT |e| (CAR #3#) . #14#)
                                      NIL))
                                   #15#))
                                (SEQ (EXIT
                                      (LETT #2#
                                       (CONS
                                        (SPADCALL |e| |d|
                                         (QREFELT $ 122))
                                        #2#) . #14#)))
                                (LETT #3# (CDR #3#) . #14#) #16# G191
                                (EXIT (NREVERSE0 #2#)))) . #14#)
                   (LETT |h|
                         (SPADCALL
                             (PROGN
                               (LETT #8# NIL . #14#)
                               (SEQ (LETT |e| NIL . #14#)
                                    (LETT #4# |newe| . #14#)
                                    (LETT |i|
                                     (SPADCALL |v| (QREFELT $ 97)) . #14#)
                                    (LETT #5# (QVSIZE |v|) . #14#) G190
                                    (COND
                                      ((OR (> |i| #5#) (ATOM #4#)
                                        (PROGN
                                          (LETT |e| (CAR #4#) . #14#)
                                          NIL))
                                       #15#))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                        (LETT #6#
                                         (SPADCALL |e|
                                          (SPADCALL (QCAR |cd|) |i|
                                           (QREFELT $ 121))
                                          (QREFELT $ 122)) . #14#)
                                        (COND
                                          (#8#
                                           (LETT #7#
                                            (SPADCALL #7# #6#
                                             (QREFELT $ 82)) . #14#))
                                          ('T
                                           (PROGN
                                             (LETT #7# #6# . #14#)
                                             (LETT #8# 'T . #14#)))))))
                                    (LETT |i|
                                     (PROG1 (+ |i| 1)
                                       (LETT #4# (CDR #4#) . #14#)) . #14#)
                                    #16# G191 (EXIT NIL))
                               (COND
                                 (#8# #7#)
                                 ('T (|spadConstant| $ 63))))
                             |g| (QREFELT $ 82)) . #14#)
                   (LETT |lk| (CONS |k| |lk|) . #14#)
                   (LETT |newexp| (CONS |h| |newexp|) . #14#)
                   (EXIT (VECTOR (SPADCALL |f| |lk| |newexp|
                                     (QREFELT $ 106))
                                 |lk| |newexp|))))
             ('T
              (SEQ (LETT |h|
                         (SPADCALL
                             (PROGN
                               (LETT #13# NIL . #14#)
                               (SEQ (LETT |y| NIL . #14#)
                                    (LETT #9# |fns| . #14#)
                                    (LETT |i|
                                     (SPADCALL |v| (QREFELT $ 97)) . #14#)
                                    (LETT #10# (QVSIZE |v|) . #14#)
                                    G190
                                    (COND
                                      ((OR (> |i| #10#) (ATOM #9#)
                                        (PROGN
                                          (LETT |y| (CAR #9#) . #14#)
                                          NIL))
                                       #15#))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                        (LETT #11#
                                         (SPADCALL
                                          (SPADCALL |y| (QREFELT $ 83))
                                          (SPADCALL |v| |i|
                                           (QREFELT $ 107))
                                          (QREFELT $ 105)) . #14#)
                                        (COND
                                          (#13#
                                           (LETT #12#
                                            (SPADCALL #12# #11#
                                             (QREFELT $ 82)) . #14#))
                                          ('T
                                           (PROGN
                                             (LETT #12# #11# . #14#)
                                             (LETT #13# 'T . #14#)))))))
                                    (LETT |i|
                                     (PROG1 (+ |i| 1)
                                       (LETT #9# (CDR #9#) . #14#)) . #14#)
                                    #16# G191 (EXIT NIL))
                               (COND
                                 (#13# #12#)
                                 ('T (|spadConstant| $ 63))))
                             |g| (QREFELT $ 82)) . #14#)
                   (EXIT (VECTOR (SPADCALL |f| (LIST |k|) (LIST |h|)
                                     (QREFELT $ 106))
                                 (LIST |k|) (LIST |h|)))))))))) 

(DEFUN |EFSTRUC;expnosimp!0| (|#1| $)
  (SPADCALL |#1| (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 32))) 

(DEFUN |EFSTRUC;logeval| (|f| |lk| |k| |v| $)
  (PROG (|z| #0=#:G2270 #1=#:G2269 #2=#:G2257 #3=#:G2255 #4=#:G2256 |c|
             |x| #5=#:G2272 |i| #6=#:G2271 #7=#:G2266 #8=#:G2264
             #9=#:G2265 |g|)
    (RETURN
      (SEQ (LETT |z| (|SPADfirst| (SPADCALL |k| (QREFELT $ 34)))
                 . #10=(|EFSTRUC;logeval|))
           (LETT |c|
                 (SPADCALL |z|
                     (PROGN
                       (LETT #4# NIL . #10#)
                       (SEQ (LETT |i|
                                  (SPADCALL |v| (QREFELT $ 97)) . #10#)
                            (LETT #0# (QVSIZE |v|) . #10#)
                            (LETT |x| NIL . #10#)
                            (LETT #1# (|EFSTRUC;toZ| |lk| $) . #10#)
                            G190
                            (COND
                              ((OR (ATOM #1#)
                                   (PROGN
                                     (LETT |x| (CAR #1#) . #10#)
                                     NIL)
                                   (> |i| #0#))
                               #11=(GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #2#
                                          (SPADCALL |x|
                                           (SPADCALL |v| |i|
                                            (QREFELT $ 107))
                                           (QREFELT $ 105)) . #10#)
                                         (COND
                                           (#4#
                                            (LETT #3#
                                             (SPADCALL #3# #2#
                                              (QREFELT $ 82)) . #10#))
                                           ('T
                                            (PROGN
                                              (LETT #3# #2# . #10#)
                                              (LETT #4# 'T . #10#)))))))
                            (LETT #1#
                                  (PROG1 (CDR #1#)
                                    (LETT |i| (+ |i| 1) . #10#)) . #10#)
                            #12=(GO G190) G191 (EXIT NIL))
                       (COND (#4# #3#) (#13='T (|spadConstant| $ 63))))
                     (QREFELT $ 18)) . #10#)
           (LETT |g|
                 (SPADCALL
                     (PROGN
                       (LETT #9# NIL . #10#)
                       (SEQ (LETT |x| NIL . #10#)
                            (LETT #5# (|EFSTRUC;toY| |lk| $) . #10#)
                            (LETT |i|
                                  (SPADCALL |v| (QREFELT $ 97)) . #10#)
                            (LETT #6# (QVSIZE |v|) . #10#) G190
                            (COND
                              ((OR (> |i| #6#) (ATOM #5#)
                                   (PROGN
                                     (LETT |x| (CAR #5#) . #10#)
                                     NIL))
                               #11#))
                            (SEQ (EXIT (PROGN
                                         (LETT #7#
                                          (SPADCALL
                                           (SPADCALL |v| |i|
                                            (QREFELT $ 107))
                                           |x| (QREFELT $ 108)) . #10#)
                                         (COND
                                           (#9#
                                            (LETT #8#
                                             (SPADCALL #8# #7#
                                              (QREFELT $ 88)) . #10#))
                                           ('T
                                            (PROGN
                                              (LETT #8# #7# . #10#)
                                              (LETT #9# 'T . #10#)))))))
                            (LETT |i|
                                  (PROG1 (+ |i| 1)
                                    (LETT #5# (CDR #5#) . #10#)) . #10#)
                            #12# G191 (EXIT NIL))
                       (COND (#9# #8#) (#13# (|spadConstant| $ 28))))
                     (SPADCALL |c| (QREFELT $ 81)) (QREFELT $ 88)) . #10#)
           (EXIT (VECTOR (SPADCALL |f| (LIST |k|) (LIST |g|)
                             (QREFELT $ 106))
                         (LIST |k|) (LIST |g|))))))) 

(DEFUN |EFSTRUC;rischNormalize;FSR;30| (|f| |v| $)
  (PROG (|ker| |n| |kk| #0=#:G2289 |i| |klist| |c| |rec| #1=#:G2283
               |rn| #2=#:G2288)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL (LETT |ker|
                                (SPADCALL (SPADCALL |f| (QREFELT $ 60))
                                    |v| (QREFELT $ 124))
                                . #3=(|EFSTRUC;rischNormalize;FSR;30|)))
                    (VECTOR |f| NIL NIL))
                   ((NULL (SPADCALL (|SPADfirst| |ker|)
                              (SPADCALL |v| (QREFELT $ 125))
                              (QREFELT $ 69)))
                    (|error| "Cannot happen"))
                   ('T
                    (SEQ (LETT |ker| (CDR |ker|) . #3#)
                         (LETT |n| (- (LENGTH |ker|) 1) . #3#)
                         (EXIT (COND
                                 ((< |n| 1) (VECTOR |f| NIL NIL))
                                 ('T
                                  (SEQ (SEQ (LETT |kk| NIL . #3#)
                                        (LETT #0# (CDR |ker|) . #3#)
                                        (LETT |i| 1 . #3#) G190
                                        (COND
                                          ((OR (QSGREATERP |i| |n|)
                                            (ATOM #0#)
                                            (PROGN
                                              (LETT |kk|
                                               (CAR #0#) . #3#)
                                              NIL))
                                           (GO G191)))
                                        (SEQ
                                         (EXIT
                                          (SEQ
                                           (LETT |klist|
                                            (SPADCALL |ker| |i|
                                             (QREFELT $ 65)) . #3#)
                                           (SEQ
                                            (LETT |c|
                                             (|EFSTRUC;deprel| |klist|
                                              |kk| |v| $) . #3#)
                                            (EXIT
                                             (COND
                                               ((QEQCAR |c| 0)
                                                (COND
                                                  ((NULL
                                                    (SPADCALL (CDR |c|)
                                                     (QREFELT $ 126)))
                                                   (PROGN
                                                     (LETT #1#
                                                      (SEQ
                                                       (LETT |rec|
                                                        (|EFSTRUC;depeval|
                                                         |f| |klist|
                                                         |kk| (CDR |c|)
                                                         $) . #3#)
                                                       (LETT |rn|
                                                        (SPADCALL
                                                         (QVELT |rec|
                                                          0)
                                                         |v|
                                                         (QREFELT $
                                                          128)) . #3#)
                                                       (EXIT
                                                        (PROGN
                                                          (LETT #2#
                                                           (VECTOR
                                                            (QVELT |rn|
                                                             0)
                                                            (SPADCALL
                                                             (QVELT
                                                              |rec| 1)
                                                             (QVELT
                                                              |rn| 1)
                                                             (QREFELT $
                                                              66))
                                                            (SPADCALL
                                                             (QVELT
                                                              |rec| 2)
                                                             (QVELT
                                                              |rn| 2)
                                                             (QREFELT $
                                                              67))) . #3#)
                                                          (GO #2#)))) . #3#)
                                                     (GO #1#))))))))
                                           (EXIT
                                            (COND
                                              ((QEQCAR |c| 1)
                                               (SEQ
                                                (LETT |rn|
                                                 (SPADCALL
                                                  (SPADCALL |f|
                                                   (LIST |kk|)
                                                   (LIST (CDR |c|))
                                                   (QREFELT $ 106))
                                                  |v| (QREFELT $ 128)) . #3#)
                                                (EXIT
                                                 (PROGN
                                                   (LETT #2#
                                                    (VECTOR
                                                     (QVELT |rn| 0)
                                                     (CONS |kk|
                                                      (QVELT |rn| 1))
                                                     (CONS (CDR |c|)
                                                      (QVELT |rn| 2))) . #3#)
                                                   (GO #2#)))))))))
                                         #1# (EXIT #1#))
                                        (LETT |i|
                                         (PROG1 (QSADD1 |i|)
                                           (LETT #0# (CDR #0#) . #3#)) . #3#)
                                        (GO G190) G191 (EXIT NIL))
                                       (EXIT (VECTOR |f| NIL NIL))))))))))
           #2# (EXIT #2#))))) 

(DEFUN |EFSTRUC;rootNormalize;FKF;31| (|f| |k| $)
  (PROG (|u|)
    (RETURN
      (SEQ (LETT |u|
                 (|EFSTRUC;rootKernelNormalize| |f|
                     (|EFSTRUC;toR| (SPADCALL |f| (QREFELT $ 60))
                         (|SPADfirst| (SPADCALL |k| (QREFELT $ 34))) $)
                     |k| $)
                 |EFSTRUC;rootNormalize;FKF;31|)
           (EXIT (COND ((QEQCAR |u| 1) |f|) ('T (QVELT (QCDR |u|) 0)))))))) 

(DEFUN |EFSTRUC;rootKernelNormalize| (|f| |l| |k| $)
  (PROG (|c|)
    (RETURN
      (SEQ (LETT |c| (|EFSTRUC;rootDep| |l| |k| $)
                 |EFSTRUC;rootKernelNormalize|)
           (EXIT (COND
                   ((QEQCAR |c| 0)
                    (CONS 0
                          (|EFSTRUC;rooteval| |f| |l| |k|
                              (SPADCALL (CDR |c|)
                                  (SPADCALL (CDR |c|) (QREFELT $ 97))
                                  (QREFELT $ 98))
                              $)))
                   ('T (CONS 1 "failed")))))))) 

(DEFUN |EFSTRUC;localnorm| (|f| $)
  (PROG (|x| #0=#:G2309)
    (RETURN
      (SEQ (SEQ (LETT |x| NIL . #1=(|EFSTRUC;localnorm|))
                (LETT #0# (SPADCALL |f| (QREFELT $ 25)) . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |x| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |f|
                                 (QVELT (SPADCALL |f| |x|
                                         (QREFELT $ 128))
                                        0) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |f|))))) 

(DEFUN |EFSTRUC;validExponential;LFSU;34| (|twr| |eta| |x| $)
  (PROG (#0=#:G2356 |fns| #1=#:G2357 |c| |v| #2=#:G2359 #3=#:G2358
            #4=#:G2322 #5=#:G2320 #6=#:G2321 |g| |yy| #7=#:G2361 |i|
            #8=#:G2360 #9=#:G2349 #10=#:G2347 #11=#:G2348)
    (RETURN
      (SEQ (LETT |c|
                 (SPADCALL
                     (SPADCALL
                         (PROGN
                           (LETT #0# NIL
                                 . #12=(|EFSTRUC;validExponential;LFSU;34|))
                           (SEQ (LETT |g| NIL . #12#)
                                (LETT #1#
                                      (LETT |fns|
                                       (|EFSTRUC;toY| |twr| $) . #12#) . #12#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |g| (CAR #1#) . #12#)
                                      NIL))
                                   #13=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL |g| |x|
                                         (QREFELT $ 68))
                                        #0#) . #12#)))
                                (LETT #1# (CDR #1#) . #12#)
                                #14=(GO G190) G191
                                (EXIT (NREVERSE0 #0#))))
                         (QREFELT $ 131))
                     (SPADCALL |eta| |x| (QREFELT $ 68))
                     (QREFELT $ 134)) . #12#)
           (EXIT (COND
                   ((QEQCAR |c| 1) (CONS 1 "failed"))
                   (#15='T
                    (SEQ (LETT |v| (QCDR |c|) . #12#)
                         (LETT |g|
                               (SPADCALL |eta|
                                   (PROGN
                                     (LETT #6# NIL . #12#)
                                     (SEQ (LETT |yy| NIL . #12#)
                                      (LETT #2# |fns| . #12#)
                                      (LETT |i|
                                       (SPADCALL |v| (QREFELT $ 97)) . #12#)
                                      (LETT #3# (QVSIZE |v|) . #12#)
                                      G190
                                      (COND
                                        ((OR (> |i| #3#) (ATOM #2#)
                                          (PROGN
                                            (LETT |yy|
                                             (CAR #2#) . #12#)
                                            NIL))
                                         #13#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #4#
                                           (SPADCALL
                                            (SPADCALL |v| |i|
                                             (QREFELT $ 107))
                                            |yy| (QREFELT $ 108)) . #12#)
                                          (COND
                                            (#6#
                                             (LETT #5#
                                              (SPADCALL #5# #4#
                                               (QREFELT $ 88)) . #12#))
                                            ('T
                                             (PROGN
                                               (LETT #5# #4# . #12#)
                                               (LETT #6# 'T . #12#)))))))
                                      (LETT |i|
                                       (PROG1 (+ |i| 1)
                                         (LETT #2# (CDR #2#) . #12#)) . #12#)
                                      #14# G191 (EXIT NIL))
                                     (COND
                                       (#6# #5#)
                                       (#15# (|spadConstant| $ 28))))
                                   (QREFELT $ 86)) . #12#)
                         (EXIT (CONS 0
                                     (SPADCALL
                                      (PROGN
                                        (LETT #11# NIL . #12#)
                                        (SEQ (LETT |yy| NIL . #12#)
                                         (LETT #7# |fns| . #12#)
                                         (LETT |i|
                                          (SPADCALL |v| (QREFELT $ 97)) . #12#)
                                         (LETT #8# (QVSIZE |v|) . #12#)
                                         G190
                                         (COND
                                           ((OR (> |i| #8#) (ATOM #7#)
                                             (PROGN
                                               (LETT |yy|
                                                (CAR #7#) . #12#)
                                               NIL))
                                            #13#))
                                         (SEQ
                                          (EXIT
                                           (PROGN
                                             (LETT #9#
                                              (SPADCALL
                                               (SPADCALL |yy|
                                                (QREFELT $ 83))
                                               (SPADCALL |v| |i|
                                                (QREFELT $ 107))
                                               (QREFELT $ 105)) . #12#)
                                             (COND
                                               (#11#
                                                (LETT #10#
                                                 (SPADCALL #10# #9#
                                                  (QREFELT $ 82)) . #12#))
                                               ('T
                                                (PROGN
                                                  (LETT #10#
                                                   #9# . #12#)
                                                  (LETT #11# 'T . #12#)))))))
                                         (LETT |i|
                                          (PROG1 (+ |i| 1)
                                            (LETT #7# (CDR #7#) . #12#)) . #12#)
                                         #14# G191 (EXIT NIL))
                                        (COND
                                          (#11# #10#)
                                          (#15# (|spadConstant| $ 63))))
                                      (SPADCALL |g| (QREFELT $ 83))
                                      (QREFELT $ 82)))))))))))) 

(DEFUN |EFSTRUC;rootDep| (|ker| |k| $)
  (PROG (|r| #0=#:G2391 #1=#:G2388 #2=#:G2386 #3=#:G2387)
    (RETURN
      (SEQ (COND
             ((NULL (LETT |ker|
                          (|EFSTRUC;toR| |ker|
                              (|SPADfirst|
                                  (SPADCALL |k| (QREFELT $ 34)))
                              $)
                          . #4=(|EFSTRUC;rootDep|)))
              (CONS 2 'T))
             ('T
              (CONS 0
                    (SPADCALL 1
                        (SPADCALL
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |k| (QREFELT $ 34))
                                     (QREFELT $ 101))
                                    (QREFELT $ 102))
                                (PROGN
                                  (LETT #3# NIL . #4#)
                                  (SEQ (LETT |r| NIL . #4#)
                                       (LETT #0# |ker| . #4#) G190
                                       (COND
                                         ((OR (ATOM #0#)
                                           (PROGN
                                             (LETT |r| (CAR #0#) . #4#)
                                             NIL))
                                          (GO G191)))
                                       (SEQ
                                        (EXIT
                                         (PROGN
                                           (LETT #1#
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL |r|
                                               (QREFELT $ 34))
                                              (QREFELT $ 101))
                                             (QREFELT $ 102)) . #4#)
                                           (COND
                                             (#3#
                                              (LETT #2#
                                               (SPADCALL #2# #1#
                                                (QREFELT $ 137)) . #4#))
                                             ('T
                                              (PROGN
                                                (LETT #2# #1# . #4#)
                                                (LETT #3# 'T . #4#)))))))
                                       (LETT #0# (CDR #0#) . #4#)
                                       (GO G190) G191 (EXIT NIL))
                                  (COND (#3# #2#) ('T 1)))
                                (QREFELT $ 137))
                            (QREFELT $ 103))
                        (QREFELT $ 138))))))))) 

(DEFUN |EFSTRUC;qdeprel| (|l| |v| $)
  (PROG (|u| #0=#:G2396)
    (RETURN
      (COND
        ((QEQCAR (LETT |u|
                       (SPADCALL (SPADCALL |l| (QREFELT $ 131)) |v|
                           (QREFELT $ 134))
                       . #1=(|EFSTRUC;qdeprel|))
                 0)
         (CONS 0
               (PROG2 (LETT #0# |u| . #1#) (QCDR #0#)
                 (|check-union| (QEQCAR #0# 0)
                     (|Vector| (|Fraction| (|Integer|))) #0#))))
        ('T (CONS 2 'T)))))) 

(DEFUN |EFSTRUC;expeval| (|f| |lk| |k| |v| $)
  (PROG (|y| |fns| #0=#:G2419 #1=#:G2418 #2=#:G2403 #3=#:G2401
             #4=#:G2402 |g| |rec| |v0| #5=#:G2420 |i| #6=#:G2421 |lv|
             #7=#:G2422 |kk| #8=#:G2423 |l| |z| #9=#:G2425 |a|
             #10=#:G2424 #11=#:G2414 #12=#:G2412 #13=#:G2413 |h|)
    (RETURN
      (SEQ (LETT |y| (|SPADfirst| (SPADCALL |k| (QREFELT $ 34)))
                 . #14=(|EFSTRUC;expeval|))
           (LETT |fns| (|EFSTRUC;toY| |lk| $) . #14#)
           (LETT |g|
                 (SPADCALL |y|
                     (PROGN
                       (LETT #4# NIL . #14#)
                       (SEQ (LETT |z| NIL . #14#)
                            (LETT #0# |fns| . #14#)
                            (LETT |i|
                                  (SPADCALL |v| (QREFELT $ 97)) . #14#)
                            (LETT #1# (QVSIZE |v|) . #14#) G190
                            (COND
                              ((OR (> |i| #1#) (ATOM #0#)
                                   (PROGN
                                     (LETT |z| (CAR #0#) . #14#)
                                     NIL))
                               #15=(GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #2#
                                          (SPADCALL
                                           (SPADCALL |v| |i|
                                            (QREFELT $ 107))
                                           |z| (QREFELT $ 108)) . #14#)
                                         (COND
                                           (#4#
                                            (LETT #3#
                                             (SPADCALL #3# #2#
                                              (QREFELT $ 88)) . #14#))
                                           ('T
                                            (PROGN
                                              (LETT #3# #2# . #14#)
                                              (LETT #4# 'T . #14#)))))))
                            (LETT |i|
                                  (PROG1 (+ |i| 1)
                                    (LETT #0# (CDR #0#) . #14#)) . #14#)
                            #16=(GO G190) G191 (EXIT NIL))
                       (COND (#4# #3#) (#17='T (|spadConstant| $ 28))))
                     (QREFELT $ 86)) . #14#)
           (LETT |rec|
                 (|EFSTRUC;goodCoef| |v| |lk|
                     (SPADCALL "exp" (QREFELT $ 10)) $) . #14#)
           (EXIT (COND
                   ((QEQCAR |rec| 1)
                    (|EFSTRUC;expnosimp| |f| |lk| |k| |v| |fns|
                        (SPADCALL |g| (QREFELT $ 83)) $))
                   (#17#
                    (SEQ (LETT |v0|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL |v| (QCAR (QCDR |rec|))
                                     (QREFELT $ 107))
                                    (QREFELT $ 113))
                                   (QREFELT $ 99)) . #14#)
                         (LETT |lv|
                               (PROGN
                                 (LETT #5# NIL . #14#)
                                 (SEQ (LETT |i|
                                       (SPADCALL |v| (QREFELT $ 97)) . #14#)
                                      (LETT #6# (QVSIZE |v|) . #14#)
                                      G190 (COND ((> |i| #6#) #15#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((COND
                                             ((EQL |i|
                                               (QCAR (QCDR |rec|)))
                                              'NIL)
                                             ('T 'T))
                                           (LETT #5#
                                            (CONS
                                             (SPADCALL |v| |i|
                                              (QREFELT $ 107))
                                             #5#) . #14#)))))
                                      (LETT |i| (+ |i| 1) . #14#) #16#
                                      G191 (EXIT (NREVERSE0 #5#)))) . #14#)
                         (LETT |l|
                               (PROGN
                                 (LETT #7# NIL . #14#)
                                 (SEQ (LETT |kk| NIL . #14#)
                                      (LETT #8# |lk| . #14#) G190
                                      (COND
                                        ((OR (ATOM #8#)
                                          (PROGN
                                            (LETT |kk|
                                             (CAR #8#) . #14#)
                                            NIL))
                                         #15#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((COND
                                             ((SPADCALL |kk|
                                               (QCDR (QCDR |rec|))
                                               (QREFELT $ 69))
                                              'NIL)
                                             ('T 'T))
                                           (LETT #7#
                                            (CONS |kk| #7#) . #14#)))))
                                      (LETT #8# (CDR #8#) . #14#) #16#
                                      G191 (EXIT (NREVERSE0 #7#)))) . #14#)
                         (LETT |h|
                               (PROGN
                                 (LETT #13# NIL . #14#)
                                 (SEQ (LETT |z| NIL . #14#)
                                      (LETT #9#
                                       (|EFSTRUC;toY| |l| $) . #14#)
                                      (LETT |a| NIL . #14#)
                                      (LETT #10# |lv| . #14#) G190
                                      (COND
                                        ((OR (ATOM #10#)
                                          (PROGN
                                            (LETT |a|
                                             (CAR #10#) . #14#)
                                            NIL)
                                          (ATOM #9#)
                                          (PROGN
                                            (LETT |z| (CAR #9#) . #14#)
                                            NIL))
                                         #15#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #11#
                                           (SPADCALL
                                            (SPADCALL |z|
                                             (QREFELT $ 83))
                                            (-
                                             (SPADCALL
                                              (SPADCALL |a| |v0|
                                               (QREFELT $ 115))
                                              (QREFELT $ 99)))
                                            (QREFELT $ 122)) . #14#)
                                          (COND
                                            (#13#
                                             (LETT #12#
                                              (SPADCALL #12# #11#
                                               (QREFELT $ 82)) . #14#))
                                            ('T
                                             (PROGN
                                               (LETT #12# #11# . #14#)
                                               (LETT #13# 'T . #14#)))))))
                                      (LETT #10#
                                       (PROG1 (CDR #10#)
                                         (LETT #9# (CDR #9#) . #14#)) . #14#)
                                      #16# G191 (EXIT NIL))
                                 (COND
                                   (#13# #12#)
                                   (#17# (|spadConstant| $ 63)))) . #14#)
                         (LETT |h|
                               (SPADCALL
                                   (SPADCALL |h|
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |v0| |g|
                                       (QREFELT $ 114))
                                      (QREFELT $ 17))
                                     (QREFELT $ 83))
                                    (QREFELT $ 82))
                                   (SPADCALL
                                    (SPADCALL |k| (QREFELT $ 71)) |v0|
                                    (QREFELT $ 122))
                                   (QREFELT $ 82)) . #14#)
                         (EXIT (VECTOR (SPADCALL |f|
                                        (LIST (QCDR (QCDR |rec|)))
                                        (LIST |h|) (QREFELT $ 106))
                                       (LIST (QCDR (QCDR |rec|)))
                                       (LIST |h|))))))))))) 

(DEFUN |EFSTRUC;normalize;2F;38| (|f| $)
  (|EFSTRUC;rtNormalize|
      (|EFSTRUC;localnorm|
          (SPADCALL (SPADCALL |f| (QREFELT $ 26)) (QREFELT $ 139)) $)
      $)) 

(DEFUN |EFSTRUC;normalize;FSF;39| (|f| |x| $)
  (|EFSTRUC;rtNormalize|
      (QVELT (SPADCALL
                 (SPADCALL (SPADCALL |f| |x| (QREFELT $ 23)) |x|
                     (QREFELT $ 141))
                 |x| (QREFELT $ 128))
             0)
      $)) 

(DEFUN |EFSTRUC;factdeprel| (|l| |k| $)
  (PROG (|n| #0=#:G2468 |x| #1=#:G2470 |m| |r| |i| #2=#:G2471
             #3=#:G2465 #4=#:G2463 #5=#:G2464 #6=#:G2469 #7=#:G2466)
    (RETURN
      (SEQ (EXIT (SEQ (EXIT (SEQ (SEQ (LETT |r|
                                       (SPADCALL
                                        (LETT |n|
                                         (|SPADfirst|
                                          (SPADCALL |k| (QREFELT $ 34)))
                                         . #8=(|EFSTRUC;factdeprel|))
                                        (QREFELT $ 54)) . #8#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |r| 0)
                                          (COND
                                            ((< 0 (QCDR |r|))
                                             (PROGN
                                               (LETT #0#
                                                (CONS 1
                                                 (SPADCALL
                                                  (SPADCALL (QCDR |r|)
                                                   (QREFELT $ 144))
                                                  (QREFELT $ 16))) . #8#)
                                               (GO #0#))))))))
                                 (SEQ (LETT |x| NIL . #8#)
                                      (LETT #1# |l| . #8#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |x| (CAR #1#) . #8#)
                                            NIL))
                                         #9=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (SEQ
                                         (LETT |m|
                                          (|SPADfirst|
                                           (SPADCALL |x|
                                            (QREFELT $ 34))) . #8#)
                                         (LETT |r|
                                          (SPADCALL
                                           (SPADCALL |n| |m|
                                            (QREFELT $ 86))
                                           (QREFELT $ 54)) . #8#)
                                         (EXIT
                                          (COND
                                            ((QEQCAR |r| 0)
                                             (COND
                                               ((< 0 (QCDR |r|))
                                                (PROGN
                                                  (LETT #7#
                                                   (PROGN
                                                     (LETT #6#
                                                      (CONS 1
                                                       (SPADCALL
                                                        (PROGN
                                                          (LETT #5#
                                                           NIL . #8#)
                                                          (SEQ
                                                           (LETT |i|
                                                            1 . #8#)
                                                           (LETT #2#
                                                            (QCDR |r|) . #8#)
                                                           G190
                                                           (COND
                                                             ((QSGREATERP
                                                               |i| #2#)
                                                              #9#))
                                                           (SEQ
                                                            (EXIT
                                                             (PROGN
                                                               (LETT
                                                                #3#
                                                                (SPADCALL
                                                                 |m|
                                                                 (SPADCALL
                                                                  |i|
                                                                  (QREFELT
                                                                   $
                                                                   16))
                                                                 (QREFELT
                                                                  $ 88)) . #8#)
                                                               (COND
                                                                 (#5#
                                                                  (LETT
                                                                   #4#
                                                                   (SPADCALL
                                                                    #4#
                                                                    #3#
                                                                    (QREFELT
                                                                     $
                                                                     82)) . #8#))
                                                                 ('T
                                                                  (PROGN
                                                                    (LETT
                                                                     #4#
                                                                     #3# . #8#)
                                                                    (LETT
                                                                     #5#
                                                                     'T . #8#)))))))
                                                           (LETT |i|
                                                            (QSADD1
                                                             |i|) . #8#)
                                                           #10=(GO
                                                                G190)
                                                           G191
                                                           (EXIT NIL))
                                                          (COND
                                                            (#5# #4#)
                                                            ('T
                                                             (|spadConstant|
                                                              $ 63))))
                                                        (SPADCALL |x|
                                                         (QREFELT $ 71))
                                                        (QREFELT $ 82))) . #8#)
                                                     (GO #6#)) . #8#)
                                                  (GO #7#)))))))))
                                       #7# (EXIT #7#))
                                      (LETT #1# (CDR #1#) . #8#) #10#
                                      G191 (EXIT NIL))
                                 (EXIT (CONS 2 'T))))
                      #0# (EXIT #0#)))
           #6# (EXIT #6#))))) 

(DEFUN |EFSTRUC;normalize;2F;41| (|f| $)
  (|EFSTRUC;rtNormalize|
      (|EFSTRUC;localnorm| (SPADCALL |f| (QREFELT $ 26)) $) $)) 

(DEFUN |EFSTRUC;normalize;FSF;42| (|f| |x| $)
  (|EFSTRUC;rtNormalize|
      (QVELT (SPADCALL (SPADCALL |f| |x| (QREFELT $ 23)) |x|
                 (QREFELT $ 128))
             0)
      $)) 

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

(DEFUN |ElementaryFunctionStructurePackage;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|ElementaryFunctionStructurePackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$|
              (LIST '|ElementaryFunctionStructurePackage| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 145) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache|
            '|ElementaryFunctionStructurePackage| (LIST DV$1 DV$2)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 11 (SPADCALL "htrig" (QREFELT $ 10)))
        (QSETREFV $ 12 (SPADCALL "trig" (QREFELT $ 10)))
        (QSETREFV $ 13
            (|HasCategory| |#2| '(|CombinatorialOpsCategory|)))
        (QSETREFV $ 19
            (SPADCALL (SPADCALL (QREFELT $ 14))
                (SPADCALL (SPADCALL 2 (QREFELT $ 16)) (QREFELT $ 17))
                (QREFELT $ 18)))
        (COND
          ((|HasCategory| |#1| '(|GcdDomain|))
           (QSETREFV $ 52
               (CONS (|dispatchFunction| |EFSTRUC;tanQ;F2F;10|) $)))
          ('T
           (QSETREFV $ 52
               (CONS (|dispatchFunction| |EFSTRUC;tanQ;F2F;11|) $))))
        (COND
          ((|HasCategory| |#2| '(|CombinatorialOpsCategory|))
           (PROGN
             (QSETREFV $ 140
                 (CONS (|dispatchFunction| |EFSTRUC;normalize;2F;38|)
                       $))
             (QSETREFV $ 142
                 (CONS (|dispatchFunction| |EFSTRUC;normalize;FSF;39|)
                       $))))
          ('T
           (PROGN
             (QSETREFV $ 140
                 (CONS (|dispatchFunction| |EFSTRUC;normalize;2F;41|)
                       $))
             (QSETREFV $ 142
                 (CONS (|dispatchFunction| |EFSTRUC;normalize;FSF;42|)
                       $)))))
        $)))) 

(MAKEPROP '|ElementaryFunctionStructurePackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'HTRIG 'TRIG '|comb?|
             (5 . |pi|) (|Integer|) (9 . |coerce|) (14 . -) (19 . /)
             '|mpiover2| (|SparseMultivariatePolynomial| 6 70)
             (25 . |numer|) (30 . |denom|)
             |EFSTRUC;realElementary;FSF;2| (|List| 9)
             (35 . |variables|) |EFSTRUC;realElementary;2F;3|
             (40 . |Zero|) (44 . |Zero|) (|Boolean|) (48 . =)
             (|Kernel| 7) (54 . |is?|) (|List| 7) (60 . |argument|)
             (65 . |first|) (70 . |false|) (|Mapping| 29 31)
             (|List| 31) (74 . |select|) (|Fraction| 15) (80 . |denom|)
             (|SparseUnivariatePolynomial| 7) (|PositiveInteger|)
             (|TangentExpansions| 7) (85 . |tanAn|)
             (|SparseUnivariatePolynomial| $) (91 . |zeroOf|)
             (|AlgebraicManipulations| 6 7) (96 . |rootSimp|)
             (101 . |numer|) (106 . |tanNa|) (112 . |tanQ|)
             (|Union| 15 '"failed") (118 . |retractIfCan|)
             (123 . |tanSum|) (128 . |inv|) (133 . |tan|)
             (138 . |empty?|) (|List| 70) (143 . |tower|)
             (148 . |select!|) (154 . |One|) (158 . |One|)
             (|NonNegativeInteger|) (162 . |first|) (168 . |concat|)
             (174 . |concat|) (180 . |differentiate|) (186 . =)
             (|Kernel| $) (192 . |coerce|) (197 . |coerce|)
             (|Mapping| 7 31) (|Mapping| 7 6)
             (|SparseMultivariatePolynomial| 6 31)
             (|PolynomialCategoryLifting| (|IndexedExponents| 31) 31 6
                 75 7)
             (202 . |map|) (209 . |member?|) (215 . |zero?|)
             (220 . |last|) (225 . |log|) (230 . *) (236 . |exp|)
             (241 . |atan|) (246 . **) (252 . -) (258 . |sqrt|)
             (263 . +) (|BasicOperator|) (269 . |operator|)
             (274 . |has?|) (280 . *) (286 . |One|) (|List| $)
             (290 . |elt|) (|Vector| 40) (296 . |minIndex|)
             (301 . |elt|) (307 . |retract|) (312 . |nthRoot|)
             (318 . |second|) (323 . |retract|) (328 . |coerce|)
             (333 . /) (339 . **) (345 . |eval|) (352 . |qelt|)
             (358 . *) (364 . |retractIfCan|) (369 . |height|)
             (|Union| $ '"failed") (374 . |recip|) (379 . |inv|)
             (384 . *) (390 . *) (396 . |every?|)
             (|Record| (|:| |num| 120) (|:| |den| 15))
             (|InnerCommonDenominator| 15 40 120 96)
             (402 . |splitDenominator|) (|Vector| 15) (407 . |qelt|)
             (413 . **) (|IntegrationTools| 6 7) (419 . |varselect|)
             (425 . |kernel|) (430 . |empty?|)
             (|Record| (|:| |func| 7) (|:| |kers| 38) (|:| |vals| 33))
             |EFSTRUC;rischNormalize;FSR;30|
             |EFSTRUC;rootNormalize;FKF;31| (|Vector| 7)
             (435 . |construct|) (|Union| 96 '"failed")
             (|IntegerLinearDependence| 7) (440 . |solveLinearlyOverQ|)
             (|Union| 7 '"failed") |EFSTRUC;validExponential;LFSU;34|
             (446 . |lcm|) (452 . |new|) (458 . |factorials|)
             (463 . |normalize|) (468 . |factorials|)
             (474 . |normalize|) (480 . |Zero|) (484 . |factorial|))
          '#(|validExponential| 489 |tanQ| 496 |rootNormalize| 502
             |rischNormalize| 508 |realElementary| 514 |normalize| 525)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 144
                                '(1 9 0 8 10 0 7 0 14 1 7 0 15 16 1 7 0
                                  0 17 2 7 0 0 0 18 1 7 20 0 21 1 7 20
                                  0 22 1 7 24 0 25 0 6 0 27 0 7 0 28 2
                                  7 29 0 0 30 2 31 29 0 9 32 1 31 33 0
                                  34 1 33 7 0 35 0 29 0 36 2 38 0 37 0
                                  39 1 40 15 0 41 2 44 42 7 43 45 1 7 0
                                  46 47 1 48 7 7 49 1 40 15 0 50 2 44 7
                                  7 15 51 2 0 7 40 7 52 1 7 53 0 54 1
                                  44 7 33 55 1 7 0 0 56 1 7 0 0 57 1 24
                                  29 0 58 1 7 59 0 60 2 38 0 37 0 61 0
                                  6 0 62 0 7 0 63 2 38 0 0 64 65 2 38 0
                                  0 0 66 2 33 0 0 0 67 2 7 0 0 9 68 2
                                  31 29 0 0 69 1 7 0 70 71 1 7 0 6 72 3
                                  76 7 73 74 75 77 2 24 29 9 0 78 1 7
                                  29 0 79 1 33 7 0 80 1 7 0 0 81 2 7 0
                                  0 0 82 1 7 0 0 83 1 7 0 0 84 2 7 0 0
                                  43 85 2 7 0 0 0 86 1 7 0 0 87 2 7 0 0
                                  0 88 1 31 89 0 90 2 89 29 0 9 91 2 7
                                  0 43 0 92 0 75 0 93 2 7 0 89 94 95 1
                                  96 15 0 97 2 96 40 0 15 98 1 40 15 0
                                  99 2 7 0 0 15 100 1 33 7 0 101 1 7 15
                                  0 102 1 40 0 15 103 2 40 0 0 0 104 2
                                  7 0 0 40 105 3 7 0 0 59 94 106 2 96
                                  40 0 15 107 2 7 0 40 0 108 1 40 53 0
                                  109 1 31 64 0 110 1 40 111 0 112 1 40
                                  0 0 113 2 7 0 15 0 114 2 40 0 0 15
                                  115 2 38 29 37 0 116 1 118 117 96 119
                                  2 120 15 0 15 121 2 7 0 0 15 122 2
                                  123 38 38 9 124 1 31 0 9 125 1 96 29
                                  0 126 1 130 0 33 131 2 133 132 130 7
                                  134 2 15 0 0 0 137 2 96 0 64 40 138 1
                                  7 0 0 139 1 0 7 7 140 2 7 0 0 9 141 2
                                  0 7 7 9 142 0 40 0 143 1 15 0 0 144 3
                                  0 135 38 7 9 136 2 0 7 40 7 52 2 0 7
                                  7 31 129 2 0 127 7 9 128 1 0 7 7 26 2
                                  0 7 7 9 23 2 0 7 7 9 142 1 0 7 7 140)))))
          '|lookupComplete|)) 
