
(/VERSIONCHECK 2) 

(DEFUN |SOLVETRA;solve;EL;1| (|oside| $)
  (PROG (|lv|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |oside| (QREFELT $ 9))
        (|error| "equation is always satisfied"))
       (#1='T
        (SEQ
         (LETT |lv| (SPADCALL |oside| (QREFELT $ 11)) |SOLVETRA;solve;EL;1|)
         (EXIT
          (COND ((NULL |lv|) (|error| "inconsistent equation"))
                ((< 1 (LENGTH |lv|)) (|error| "too many variables"))
                (#1#
                 (SPADCALL |oside| (|SPADfirst| |lv|) (QREFELT $ 20)))))))))))) 

(DEFUN |SOLVETRA;solve;EL;2| (|equ| $)
  (SPADCALL
   (SPADCALL (SPADCALL |equ| (QREFELT $ 22)) (SPADCALL |equ| (QREFELT $ 23))
             (QREFELT $ 24))
   (QREFELT $ 21))) 

(DEFUN |SOLVETRA;solve;ESL;3| (|equ| |x| $)
  (PROG (|oneside|)
    (RETURN
     (SEQ
      (LETT |oneside|
            (SPADCALL (SPADCALL |equ| (QREFELT $ 22))
                      (SPADCALL |equ| (QREFELT $ 23)) (QREFELT $ 24))
            |SOLVETRA;solve;ESL;3|)
      (EXIT (SPADCALL |oneside| |x| (QREFELT $ 20))))))) 

(DEFUN |SOLVETRA;testZero?| (|lside| |sol| $)
  (SEQ
   (COND
    ((|HasCategory| (QREFELT $ 6) (LIST '|QuotientFieldCategory| '(|Integer|)))
     (COND
      ((QEQCAR (SPADCALL (SPADCALL |sol| (QREFELT $ 23)) (QREFELT $ 28)) 1)
       (EXIT 'T))))
    ((QEQCAR (SPADCALL (SPADCALL |sol| (QREFELT $ 23)) (QREFELT $ 30)) 1)
     (EXIT 'T)))
   (EXIT
    (COND
     ((SPADCALL
       (SPADCALL (SPADCALL |lside| |sol| (QREFELT $ 32)) (QREFELT $ 34))
       (QREFELT $ 9))
      'T)
     ('T 'NIL))))) 

(DEFUN |SOLVETRA;solve;ESL;5| (|lside| |x| $)
  (PROG (#1=#:G1928 |sol| #2=#:G1927)
    (RETURN
     (SEQ
      (PROGN
       (LETT #2# NIL . #3=(|SOLVETRA;solve;ESL;5|))
       (SEQ (LETT |sol| NIL . #3#)
            (LETT #1# (|SOLVETRA;solveInner| |lside| |x| $) . #3#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |sol| (CAR #1#) . #3#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (COND
               ((|SOLVETRA;testZero?| |lside| |sol| $)
                (LETT #2# (CONS |sol| #2#) . #3#)))))
            (LETT #1# (CDR #1#) . #3#) (GO G190) G191
            (EXIT (NREVERSE0 #2#)))))))) 

(DEFUN |SOLVETRA;solveInner| (|lside| |x| $)
  (PROG (#1=#:G1988 |sols| #2=#:G1995 |frec| |lfacts| |listofkernels|
         |newlside| |newlist| #3=#:G1994 |j| |secondsol| #4=#:G1973 #5=#:G1972
         #6=#:G1974 #7=#:G1993 |ff| |lfatt| |f| |elR| #8=#:G1992 |i| #9=#:G1965
         #10=#:G1964 #11=#:G1966 #12=#:G1991 |ri| |bigXback| #13=#:G1960 |r1|
         |finv| #14=#:G1990 |lr| #15=#:G1949 #16=#:G1948 #17=#:G1950
         #18=#:G1989 |fatt| |eq1| |bigX| Y X |ausgabe1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |lside| (|SOLVETRA;eliminateRoot| |lside| |x| $)
              . #19=(|SOLVETRA;solveInner|))
        (LETT |ausgabe1| (|SOLVETRA;tableXkernels| |lside| |x| $) . #19#)
        (LETT X (SPADCALL (QREFELT $ 35)) . #19#)
        (LETT Y (SPADCALL (SPADCALL (QREFELT $ 35)) (QREFELT $ 36)) . #19#)
        (EXIT
         (COND
          ((EQL (LENGTH |ausgabe1|) 1)
           (SEQ (LETT |bigX| (|SPADfirst| |ausgabe1|) . #19#)
                (LETT |eq1|
                      (SPADCALL |lside|
                                (SPADCALL |bigX| (SPADCALL X (QREFELT $ 36))
                                          (QREFELT $ 37))
                                (QREFELT $ 32))
                      . #19#)
                (LETT |f|
                      (SPADCALL |eq1|
                                (|SPADfirst|
                                 (SPADCALL (SPADCALL X (QREFELT $ 36))
                                           (QREFELT $ 40)))
                                (QREFELT $ 43))
                      . #19#)
                (LETT |lfatt|
                      (SPADCALL
                       (SPADCALL (SPADCALL |f| (QREFELT $ 46)) (QREFELT $ 49))
                       (QREFELT $ 53))
                      . #19#)
                (LETT |lr|
                      (PROGN
                       (LETT #15# NIL . #19#)
                       (SEQ (LETT |fatt| NIL . #19#) (LETT #18# |lfatt| . #19#)
                            G190
                            (COND
                             ((OR (ATOM #18#)
                                  (PROGN (LETT |fatt| (CAR #18#) . #19#) NIL))
                              #20=(GO G191)))
                            (SEQ
                             (EXIT
                              (PROGN
                               (LETT #17#
                                     (SPADCALL (QCAR |fatt|) |x|
                                               (QREFELT $ 55))
                                     . #19#)
                               (COND
                                (#15# (LETT #16# (APPEND #16# #17#) . #19#))
                                ('T
                                 (PROGN
                                  (LETT #16# #17# . #19#)
                                  (LETT #15# 'T . #19#)))))))
                            (LETT #18# (CDR #18#) . #19#) #21=(GO G190) G191
                            (EXIT NIL))
                       (COND (#15# #16#) (#22='T NIL)))
                      . #19#)
                (LETT |r1| NIL . #19#)
                (SEQ (LETT |i| 1 . #19#) (LETT #14# (LENGTH |lr|) . #19#) G190
                     (COND ((QSGREATERP |i| #14#) #20#))
                     (SEQ
                      (LETT |finv|
                            (|SOLVETRA;funcinv| |bigX|
                             (SPADCALL |lr| |i| (QREFELT $ 58)) $)
                            . #19#)
                      (EXIT
                       (COND
                        ((QEQCAR |finv| 0)
                         (LETT |r1| (CONS (QCDR |finv|) |r1|) . #19#)))))
                     (LETT |i| (QSADD1 |i|) . #19#) #21# G191 (EXIT NIL))
                (LETT |bigXback|
                      (PROG2
                          (LETT #13# (|SOLVETRA;funcinv| |bigX| |bigX| $)
                                . #19#)
                          (QCDR #13#)
                        (|check-union| (QEQCAR #13# 0)
                                       (|Expression| (QREFELT $ 6)) #13#))
                      . #19#)
                (COND
                 ((NULL (|SOLVETRA;testkernel| |bigXback| |x| $))
                  (SEQ
                   (COND
                    ((SPADCALL |bigX| |bigXback| (QREFELT $ 38))
                     (PROGN (LETT #1# NIL . #19#) (GO #1#))))
                   (EXIT
                    (PROGN
                     (LETT #1#
                           (PROGN
                            (LETT #9# NIL . #19#)
                            (SEQ (LETT |ri| NIL . #19#) (LETT #12# |r1| . #19#)
                                 G190
                                 (COND
                                  ((OR (ATOM #12#)
                                       (PROGN
                                        (LETT |ri| (CAR #12#) . #19#)
                                        NIL))
                                   #20#))
                                 (SEQ
                                  (EXIT
                                   (PROGN
                                    (LETT #11#
                                          (SPADCALL
                                           (SPADCALL |bigXback| |ri|
                                                     (QREFELT $ 24))
                                           |x| (QREFELT $ 20))
                                          . #19#)
                                    (COND
                                     (#9#
                                      (LETT #10# (APPEND #10# #11#) . #19#))
                                     ('T
                                      (PROGN
                                       (LETT #10# #11# . #19#)
                                       (LETT #9# 'T . #19#)))))))
                                 (LETT #12# (CDR #12#) . #19#) #21# G191
                                 (EXIT NIL))
                            (COND (#9# #10#) (#22# NIL)))
                           . #19#)
                     (GO #1#))))))
                (LETT |newlist| NIL . #19#)
                (SEQ (LETT |i| 1 . #19#) (LETT #8# (LENGTH |r1|) . #19#) G190
                     (COND ((QSGREATERP |i| #8#) #20#))
                     (SEQ
                      (LETT |elR|
                            (|SOLVETRA;eliminateRoot|
                             (SPADCALL
                              (SPADCALL
                               (SPADCALL |bigXback|
                                         (SPADCALL |r1| |i| (QREFELT $ 58))
                                         (QREFELT $ 24))
                               (QREFELT $ 60))
                              (QREFELT $ 61))
                             |x| $)
                            . #19#)
                      (LETT |f|
                            (SPADCALL |elR| (SPADCALL |x| (QREFELT $ 63))
                                      (QREFELT $ 43))
                            . #19#)
                      (LETT |lfatt|
                            (SPADCALL
                             (SPADCALL (SPADCALL |f| (QREFELT $ 46))
                                       (QREFELT $ 49))
                             (QREFELT $ 53))
                            . #19#)
                      (LETT |secondsol|
                            (PROGN
                             (LETT #4# NIL . #19#)
                             (SEQ (LETT |ff| NIL . #19#)
                                  (LETT #7# |lfatt| . #19#) G190
                                  (COND
                                   ((OR (ATOM #7#)
                                        (PROGN
                                         (LETT |ff| (CAR #7#) . #19#)
                                         NIL))
                                    #20#))
                                  (SEQ
                                   (EXIT
                                    (PROGN
                                     (LETT #6#
                                           (SPADCALL (QCAR |ff|) |x|
                                                     (QREFELT $ 55))
                                           . #19#)
                                     (COND
                                      (#4# (LETT #5# (APPEND #5# #6#) . #19#))
                                      ('T
                                       (PROGN
                                        (LETT #5# #6# . #19#)
                                        (LETT #4# 'T . #19#)))))))
                                  (LETT #7# (CDR #7#) . #19#) #21# G191
                                  (EXIT NIL))
                             (COND (#4# #5#) ('T NIL)))
                            . #19#)
                      (EXIT
                       (SEQ (LETT |j| 1 . #19#)
                            (LETT #3# (LENGTH |secondsol|) . #19#) G190
                            (COND ((QSGREATERP |j| #3#) #20#))
                            (SEQ
                             (EXIT
                              (LETT |newlist|
                                    (CONS
                                     (SPADCALL (SPADCALL |x| (QREFELT $ 36))
                                               (SPADCALL
                                                (SPADCALL |secondsol| |j|
                                                          (QREFELT $ 58))
                                                (QREFELT $ 65))
                                               (QREFELT $ 37))
                                     |newlist|)
                                    . #19#)))
                            (LETT |j| (QSADD1 |j|) . #19#) #21# G191
                            (EXIT NIL))))
                     (LETT |i| (QSADD1 |i|) . #19#) #21# G191 (EXIT NIL))
                (EXIT |newlist|)))
          (#22#
           (SEQ (LETT |newlside| (|SOLVETRA;tryToTrans| |lside| |x| $) . #19#)
                (LETT |listofkernels|
                      (|SOLVETRA;tableXkernels| |newlside| |x| $) . #19#)
                (EXIT
                 (COND
                  ((EQL (LENGTH |listofkernels|) 1)
                   (SPADCALL |newlside| |x| (QREFELT $ 20)))
                  (#22#
                   (SEQ
                    (LETT |lfacts|
                          (SPADCALL
                           (SPADCALL (SPADCALL |lside| (QREFELT $ 60))
                                     (QREFELT $ 69))
                           (QREFELT $ 72))
                          . #19#)
                    (EXIT
                     (COND
                      ((< 1 (LENGTH |lfacts|))
                       (SEQ (LETT |sols| NIL . #19#)
                            (SEQ (LETT |frec| NIL . #19#)
                                 (LETT #2# |lfacts| . #19#) G190
                                 (COND
                                  ((OR (ATOM #2#)
                                       (PROGN
                                        (LETT |frec| (CAR #2#) . #19#)
                                        NIL))
                                   #20#))
                                 (SEQ
                                  (EXIT
                                   (LETT |sols|
                                         (APPEND
                                          (SPADCALL
                                           (SPADCALL (QCAR |frec|)
                                                     (QREFELT $ 61))
                                           |x| (QREFELT $ 20))
                                          |sols|)
                                         . #19#)))
                                 (LETT #2# (CDR #2#) . #19#) #21# G191
                                 (EXIT NIL))
                            (EXIT |sols|)))
                      (#22# (PROGN (LETT #1# NIL . #19#) (GO #1#)))))))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;simplifyingLog| (|f| $)
  (PROG (|rec| |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL |f| '|exp| (QREFELT $ 82))
            . #1=(|SOLVETRA;simplifyingLog|))
      (EXIT
       (COND
        ((QEQCAR |u| 0)
         (SEQ (LETT |rec| (QCDR |u|) . #1#)
              (EXIT
               (SPADCALL (QCDR |rec|)
                         (|SPADfirst| (SPADCALL (QCAR |rec|) (QREFELT $ 83)))
                         (QREFELT $ 84)))))
        ('T (SPADCALL |f| (QREFELT $ 85))))))))) 

(DEFUN |SOLVETRA;testkernel| (|var1| |y| $)
  (PROG (|listvar1|)
    (RETURN
     (SEQ
      (LETT |var1| (|SOLVETRA;eliminateRoot| |var1| |y| $)
            . #1=(|SOLVETRA;testkernel|))
      (LETT |listvar1| (|SOLVETRA;tableXkernels| |var1| |y| $) . #1#)
      (EXIT
       (COND
        ((EQL (LENGTH |listvar1|) 1)
         (COND
          ((OR
            (SPADCALL (SPADCALL |listvar1| 1 (QREFELT $ 58))
                      (SPADCALL |y| (QREFELT $ 36)) (QREFELT $ 38))
            (EQL (LENGTH |listvar1|) 0))
           'T)
          ('T 'NIL)))
        ((EQL (LENGTH |listvar1|) 0) 'T) ('T 'NIL))))))) 

(DEFUN |SOLVETRA;solveRetract| (|lexpr| |lvar| $)
  (PROG (|nlexpr| #1=#:G2027 |rf| #2=#:G2028 |expr|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |nlexpr| NIL . #3=(|SOLVETRA;solveRetract|))
            (SEQ (LETT |expr| NIL . #3#) (LETT #2# |lexpr| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |expr| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ (LETT |rf| (SPADCALL |expr| (QREFELT $ 87)) . #3#)
                      (EXIT
                       (COND
                        ((QEQCAR |rf| 1)
                         (PROGN (LETT #1# (CONS 1 "failed") . #3#) (GO #1#)))
                        ('T
                         (LETT |nlexpr| (CONS (QCDR |rf|) |nlexpr|) . #3#)))))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 (SPADCALL |nlexpr| |lvar| (QREFELT $ 91))))))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;tryToTrans| (|lside| |x| $)
  (PROG (|resultLside| |numlside| |listcnorm| |cnormConvLside| |listConvLside|
         |NormConvLside| |convLside|)
    (RETURN
     (SEQ
      (COND
       ((OR (|SOLVETRA;testTrig| |lside| |x| $)
            (|SOLVETRA;testHTrig| |lside| |x| $))
        (SEQ
         (LETT |convLside| (SPADCALL |lside| (QREFELT $ 93))
               . #1=(|SOLVETRA;tryToTrans|))
         (LETT |resultLside| |convLside| . #1#)
         (LETT |listConvLside| (|SOLVETRA;tableXkernels| |convLside| |x| $)
               . #1#)
         (EXIT
          (COND
           ((< 1 (LENGTH |listConvLside|))
            (SEQ
             (LETT |NormConvLside| (SPADCALL |convLside| |x| (QREFELT $ 94))
                   . #1#)
             (LETT |NormConvLside| |NormConvLside| . #1#)
             (EXIT
              (LETT |resultLside| (|SOLVETRA;subsTan| |NormConvLside| |x| $)
                    . #1#))))))))
       ((|SOLVETRA;testLog| |lside| |x| $)
        (SEQ
         (LETT |numlside|
               (SPADCALL (SPADCALL |lside| (QREFELT $ 60)) (QREFELT $ 61))
               . #1#)
         (EXIT
          (LETT |resultLside| (|SOLVETRA;combineLog| |numlside| |x| $)
                . #1#))))
       ('T
        (SEQ (LETT |NormConvLside| (SPADCALL |lside| |x| (QREFELT $ 94)) . #1#)
             (LETT |NormConvLside| |NormConvLside| . #1#)
             (LETT |resultLside| |NormConvLside| . #1#)
             (LETT |listConvLside|
                   (|SOLVETRA;tableXkernels| |NormConvLside| |x| $) . #1#)
             (EXIT
              (COND
               ((< 1 (LENGTH |listConvLside|))
                (SEQ
                 (LETT |cnormConvLside| (SPADCALL |lside| |x| (QREFELT $ 96))
                       . #1#)
                 (LETT |cnormConvLside| |cnormConvLside| . #1#)
                 (LETT |resultLside| |cnormConvLside| . #1#)
                 (LETT |listcnorm|
                       (|SOLVETRA;tableXkernels| |cnormConvLside| |x| $) . #1#)
                 (EXIT
                  (COND
                   ((< 1 (LENGTH |listcnorm|))
                    (COND
                     ((|SOLVETRA;testLog| |cnormConvLside| |x| $)
                      (SEQ
                       (LETT |numlside|
                             (SPADCALL
                              (SPADCALL |cnormConvLside| (QREFELT $ 60))
                              (QREFELT $ 61))
                             . #1#)
                       (EXIT
                        (LETT |resultLside|
                              (|SOLVETRA;combineLog| |numlside| |x| $)
                              . #1#)))))))))))))))
      (EXIT |resultLside|))))) 

(DEFUN |SOLVETRA;subsTan| (|exprvar| |y| $)
  (PROG (|resultnew| |result1| #1=#:G2046 |result| |newH| H |g| |secondfun| |f|
         |fN| |fZ| |test| Y |varkern| |listofkern| Z)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT Z (SPADCALL (QREFELT $ 35)) . #2=(|SOLVETRA;subsTan|))
            (LETT |listofkern| (|SOLVETRA;tableXkernels| |exprvar| |y| $)
                  . #2#)
            (LETT |varkern| (|SPADfirst| |listofkern|) . #2#)
            (LETT Y
                  (SPADCALL
                   (SPADCALL
                    (|SPADfirst|
                     (SPADCALL
                      (|SPADfirst| (SPADCALL |varkern| (QREFELT $ 40)))
                      (QREFELT $ 83)))
                    (QREFELT $ 60))
                   (QREFELT $ 61))
                  . #2#)
            (LETT |test|
                  (SPADCALL |varkern|
                            (SPADCALL
                             (SPADCALL Y (SPADCALL 2 (QREFELT $ 97))
                                       (QREFELT $ 98))
                             (QREFELT $ 99))
                            (QREFELT $ 38))
                  . #2#)
            (COND
             ((EQL (LENGTH |listofkern|) 1)
              (COND
               ((NULL |test|) (PROGN (LETT #1# |exprvar| . #2#) (GO #1#)))))
             (#3='T (PROGN (LETT #1# |exprvar| . #2#) (GO #1#))))
            (LETT |fZ|
                  (SPADCALL |exprvar|
                            (SPADCALL |varkern| (SPADCALL Z (QREFELT $ 36))
                                      (QREFELT $ 37))
                            (QREFELT $ 32))
                  . #2#)
            (LETT |fN| (SPADCALL (SPADCALL |fZ| (QREFELT $ 60)) (QREFELT $ 61))
                  . #2#)
            (LETT |f|
                  (SPADCALL |fN|
                            (|SPADfirst|
                             (SPADCALL (SPADCALL Z (QREFELT $ 36))
                                       (QREFELT $ 40)))
                            (QREFELT $ 43))
                  . #2#)
            (LETT |secondfun|
                  (SPADCALL
                   (SPADCALL (SPADCALL 2 Y (QREFELT $ 101))
                             (SPADCALL (SPADCALL Y 2 (QREFELT $ 102))
                                       (|spadConstant| $ 15) (QREFELT $ 24))
                             (QREFELT $ 98))
                   (QREFELT $ 103))
                  . #2#)
            (LETT |g|
                  (SPADCALL |secondfun|
                            (|SPADfirst|
                             (SPADCALL (SPADCALL |y| (QREFELT $ 36))
                                       (QREFELT $ 40)))
                            (QREFELT $ 43))
                  . #2#)
            (LETT H (SPADCALL (SPADCALL (QREFELT $ 35)) (QREFELT $ 36)) . #2#)
            (LETT |newH|
                  (SPADCALL H
                            (|SPADfirst|
                             (SPADCALL (SPADCALL Z (QREFELT $ 36))
                                       (QREFELT $ 40)))
                            (QREFELT $ 43))
                  . #2#)
            (LETT |result| (SPADCALL |f| |g| |newH| (QREFELT $ 105)) . #2#)
            (EXIT
             (COND
              ((SPADCALL |result| |f| (QREFELT $ 106))
               (PROGN (LETT #1# |exprvar| . #2#) (GO #1#)))
              (#3#
               (SEQ
                (LETT |result1| (SPADCALL |result| H (QREFELT $ 108)) . #2#)
                (EXIT
                 (LETT |resultnew|
                       (SPADCALL |result1|
                                 (SPADCALL H (SPADCALL Y (QREFELT $ 99))
                                           (QREFELT $ 37))
                                 (QREFELT $ 32))
                       . #2#))))))))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;eliminateKernRoot| (|var| |varkern| $)
  (PROG (|resultvar| |var3| #1=#:G2057 |var2| |var1| X)
    (RETURN
     (SEQ
      (LETT X (SPADCALL (QREFELT $ 35)) . #2=(|SOLVETRA;eliminateKernRoot|))
      (LETT |var1|
            (SPADCALL |var|
                      (SPADCALL (SPADCALL |varkern| (QREFELT $ 109))
                                (SPADCALL X (QREFELT $ 36)) (QREFELT $ 37))
                      (QREFELT $ 32))
            . #2#)
      (LETT |var2|
            (SPADCALL
             (SPADCALL |var1|
                       (|SPADfirst|
                        (SPADCALL (SPADCALL X (QREFELT $ 36)) (QREFELT $ 40)))
                       (QREFELT $ 43))
             (QREFELT $ 46))
            . #2#)
      (LETT |var3|
            (SPADCALL
             (SPADCALL (|spadConstant| $ 15)
                       (PROG1
                           (LETT #1#
                                 (SPADCALL
                                  (SPADCALL (SPADCALL |varkern| (QREFELT $ 83))
                                            (QREFELT $ 110))
                                  (QREFELT $ 111))
                                 . #2#)
                         (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                          #1#))
                       (QREFELT $ 113))
             (SPADCALL (|SPADfirst| (SPADCALL |varkern| (QREFELT $ 83))) 0
                       (QREFELT $ 113))
             (QREFELT $ 114))
            . #2#)
      (EXIT
       (LETT |resultvar| (SPADCALL |var2| |var3| (QREFELT $ 115)) . #2#)))))) 

(DEFUN |SOLVETRA;eliminateRoot| (|var| |y| $)
  (PROG (|var1| #1=#:G2066 |i| |varlistk1|)
    (RETURN
     (SEQ (LETT |var1| |var| . #2=(|SOLVETRA;eliminateRoot|))
          (SEQ G190
               (COND ((NULL (|SOLVETRA;testRootk| |var1| |y| $)) #3=(GO G191)))
               (SEQ
                (LETT |varlistk1| (|SOLVETRA;tableXkernels| |var1| |y| $)
                      . #2#)
                (EXIT
                 (SEQ (LETT |i| NIL . #2#) (LETT #1# |varlistk1| . #2#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #2#) NIL))
                        #3#))
                      (SEQ
                       (EXIT
                        (COND
                         ((SPADCALL |i| '|nthRoot| (QREFELT $ 116))
                          (LETT |var1|
                                (|SOLVETRA;eliminateKernRoot| |var1|
                                 (|SPADfirst| (SPADCALL |i| (QREFELT $ 40))) $)
                                . #2#)))))
                      (LETT #1# (CDR #1#) . #2#) #4=(GO G190) G191
                      (EXIT NIL))))
               NIL #4# G191 (EXIT NIL))
          (EXIT |var1|))))) 

(DEFUN |SOLVETRA;logsumtolog| (|var| $)
  (PROG (|var2| #1=#:G2083 |i| |kernelofvar| |newexpr| |exprlist| #2=#:G2082
         |gcdcoeff| |listforgcd| |exprcoeff| #3=#:G2081 |listofexpr|)
    (RETURN
     (SEQ
      (LETT |listofexpr| (SPADCALL |var| (QREFELT $ 118))
            . #4=(|SOLVETRA;logsumtolog|))
      (EXIT
       (COND ((QEQCAR |listofexpr| 1) |var|)
             ('T
              (SEQ (LETT |listofexpr| (CONS 0 (QCDR |listofexpr|)) . #4#)
                   (LETT |listforgcd| NIL . #4#)
                   (SEQ (LETT |i| NIL . #4#)
                        (LETT #3# (QCDR |listofexpr|) . #4#) G190
                        (COND
                         ((OR (ATOM #3#)
                              (PROGN (LETT |i| (CAR #3#) . #4#) NIL))
                          #5=(GO G191)))
                        (SEQ
                         (LETT |exprcoeff|
                               (SPADCALL (SPADCALL |i| (QREFELT $ 60))
                                         (QREFELT $ 119))
                               . #4#)
                         (EXIT
                          (LETT |listforgcd| (CONS |exprcoeff| |listforgcd|)
                                . #4#)))
                        (LETT #3# (CDR #3#) . #4#) #6=(GO G190) G191
                        (EXIT NIL))
                   (LETT |gcdcoeff|
                         (SPADCALL (SPADCALL |listforgcd| (QREFELT $ 120))
                                   (QREFELT $ 121))
                         . #4#)
                   (LETT |newexpr| (|spadConstant| $ 122) . #4#)
                   (SEQ (LETT |i| NIL . #4#)
                        (LETT #2# (QCDR |listofexpr|) . #4#) G190
                        (COND
                         ((OR (ATOM #2#)
                              (PROGN (LETT |i| (CAR #2#) . #4#) NIL))
                          #5#))
                        (SEQ
                         (LETT |exprlist| (|SOLVETRA;splitExpr| |i| $) . #4#)
                         (EXIT
                          (LETT |newexpr|
                                (SPADCALL |newexpr|
                                          (|SOLVETRA;logexpp|
                                           (SPADCALL |exprlist| 2
                                                     (QREFELT $ 58))
                                           (SPADCALL
                                            (SPADCALL |exprlist| 1
                                                      (QREFELT $ 58))
                                            |gcdcoeff| (QREFELT $ 98))
                                           $)
                                          (QREFELT $ 123))
                                . #4#)))
                        (LETT #2# (CDR #2#) . #4#) #6# G191 (EXIT NIL))
                   (LETT |kernelofvar| (SPADCALL |newexpr| (QREFELT $ 40))
                         . #4#)
                   (LETT |var2| (|spadConstant| $ 15) . #4#)
                   (SEQ (LETT |i| NIL . #4#) (LETT #1# |kernelofvar| . #4#)
                        G190
                        (COND
                         ((OR (ATOM #1#)
                              (PROGN (LETT |i| (CAR #1#) . #4#) NIL))
                          #5#))
                        (SEQ
                         (EXIT
                          (LETT |var2|
                                (SPADCALL |var2|
                                          (|SPADfirst|
                                           (SPADCALL |i| (QREFELT $ 83)))
                                          (QREFELT $ 124))
                                . #4#)))
                        (LETT #1# (CDR #1#) . #4#) #6# G191 (EXIT NIL))
                   (EXIT
                    (SPADCALL |gcdcoeff| (SPADCALL |var2| (QREFELT $ 85))
                              (QREFELT $ 124))))))))))) 

(DEFUN |SOLVETRA;testLog| (|expr| Z $)
  (PROG (#1=#:G2089 #2=#:G2090 |i| |kernelofexpr| |testList|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |testList| (LIST '|log|) . #3=(|SOLVETRA;testLog|))
            (LETT |kernelofexpr| (|SOLVETRA;tableXkernels| |expr| Z $) . #3#)
            (COND
             ((EQL (LENGTH |kernelofexpr|) 0)
              (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))
            (SEQ (LETT |i| NIL . #3#) (LETT #2# |kernelofexpr| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (COND
                    ((SPADCALL
                      (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                                (QREFELT $ 126))
                      |testList| (QREFELT $ 127))
                     (COND
                      ((NULL
                        (|SOLVETRA;testkernel|
                         (|SPADfirst|
                          (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                                    (QREFELT $ 83)))
                         Z $))
                       (PROGN (LETT #1# 'NIL . #3#) (GO #1#)))))
                    ('T (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT 'T)))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;splitExpr| (|expr| $)
  (PROG (|listexpr| |exprwcoeff| |lcoeff|)
    (RETURN
     (SEQ
      (LETT |lcoeff|
            (SPADCALL (SPADCALL |expr| (QREFELT $ 60)) (QREFELT $ 119))
            . #1=(|SOLVETRA;splitExpr|))
      (LETT |exprwcoeff| |expr| . #1#)
      (LETT |listexpr| (SPADCALL |exprwcoeff| (QREFELT $ 128)) . #1#)
      (EXIT
       (COND ((QEQCAR |listexpr| 1) (LIST (|spadConstant| $ 15) |expr|))
             ('T
              (SEQ
               (LETT |listexpr|
                     (CONS 0
                           (SPADCALL (SPADCALL |lcoeff| (QREFELT $ 121))
                                     (QCDR |listexpr|) (QREFELT $ 129)))
                     . #1#)
               (EXIT
                (CONS (SPADCALL |lcoeff| (QREFELT $ 121))
                      (QCDR |listexpr|))))))))))) 

(DEFUN |SOLVETRA;buildnexpr| (|expr| Z $)
  (PROG (|ansmant| |anscoeff| #1=#:G2105 |i| |n2list| |nlist|)
    (RETURN
     (SEQ
      (LETT |nlist| (|SOLVETRA;splitExpr| |expr| $)
            . #2=(|SOLVETRA;buildnexpr|))
      (LETT |n2list|
            (SPADCALL (SPADCALL |nlist| 1 (QREFELT $ 58)) |nlist|
                      (QREFELT $ 129))
            . #2#)
      (LETT |anscoeff| (|spadConstant| $ 15) . #2#)
      (LETT |ansmant| (|spadConstant| $ 122) . #2#)
      (SEQ (LETT |i| NIL . #2#) (LETT #1# |n2list| . #2#) G190
           (COND
            ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #2#) NIL)) (GO G191)))
           (SEQ
            (EXIT
             (COND
              ((SPADCALL |i| Z (QREFELT $ 131))
               (LETT |anscoeff| (SPADCALL |i| |anscoeff| (QREFELT $ 124))
                     . #2#))
              ('T (LETT |ansmant| |i| . #2#)))))
           (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
      (EXIT
       (LIST |anscoeff|
             (SPADCALL |ansmant| (SPADCALL |nlist| 1 (QREFELT $ 58))
                       (QREFELT $ 124)))))))) 

(DEFUN |SOLVETRA;logexpp| (|expr1| |expr2| $)
  (SPADCALL
   (SPADCALL
    (|SPADfirst|
     (SPADCALL (|SPADfirst| (SPADCALL |expr1| (QREFELT $ 40))) (QREFELT $ 83)))
    |expr2| (QREFELT $ 132))
   (QREFELT $ 85))) 

(DEFUN |SOLVETRA;combineLog| (|expr| Y $)
  (PROG (|ansexpr| #1=#:G2127 |i| |ans| |exprr| |loopexpr| |exprtable|)
    (RETURN
     (SEQ
      (LETT |exprtable| (SPADCALL (QREFELT $ 134))
            . #2=(|SOLVETRA;combineLog|))
      (EXIT
       (COND ((QEQCAR (SPADCALL |expr| (QREFELT $ 118)) 1) |expr|)
             ('T
              (SEQ (LETT |ans| (|spadConstant| $ 122) . #2#)
                   (SEQ G190
                        (COND
                         ((NULL
                           (COND
                            ((SPADCALL |expr| (|spadConstant| $ 122)
                                       (QREFELT $ 38))
                             'NIL)
                            ('T 'T)))
                          #3=(GO G191)))
                        (SEQ
                         (LETT |loopexpr|
                               (SPADCALL
                                (SPADCALL (SPADCALL |expr| (QREFELT $ 60))
                                          (QREFELT $ 136))
                                (QREFELT $ 61))
                               . #2#)
                         (COND
                          ((|SOLVETRA;testLog| |loopexpr| Y $)
                           (COND
                            ((EQL
                              (LENGTH
                               (|SOLVETRA;tableXkernels| |loopexpr| Y $))
                              1)
                             (SEQ
                              (LETT |exprr|
                                    (|SOLVETRA;buildnexpr| |loopexpr| Y $)
                                    . #2#)
                              (COND
                               ((QEQCAR
                                 (SPADCALL (SPADCALL |exprr| 1 (QREFELT $ 58))
                                           |exprtable| (QREFELT $ 138))
                                 1)
                                (SPADCALL |exprtable|
                                          (SPADCALL |exprr| 1 (QREFELT $ 58))
                                          (|spadConstant| $ 122)
                                          (QREFELT $ 139))))
                              (EXIT
                               (SPADCALL |exprtable|
                                         (SPADCALL |exprr| 1 (QREFELT $ 58))
                                         (SPADCALL
                                          (SPADCALL |exprtable|
                                                    (SPADCALL |exprr| 1
                                                              (QREFELT $ 58))
                                                    (QREFELT $ 140))
                                          (SPADCALL |exprr| 2 (QREFELT $ 58))
                                          (QREFELT $ 123))
                                         (QREFELT $ 139)))))
                            ('T
                             (LETT |ans|
                                   (SPADCALL |ans| |loopexpr| (QREFELT $ 123))
                                   . #2#))))
                          ('T
                           (LETT |ans|
                                 (SPADCALL |ans| |loopexpr| (QREFELT $ 123))
                                 . #2#)))
                         (EXIT
                          (LETT |expr|
                                (SPADCALL
                                 (SPADCALL (SPADCALL |expr| (QREFELT $ 60))
                                           (QREFELT $ 141))
                                 (QREFELT $ 61))
                                . #2#)))
                        NIL #4=(GO G190) G191 (EXIT NIL))
                   (LETT |ansexpr| (|spadConstant| $ 122) . #2#)
                   (SEQ (LETT |i| NIL . #2#)
                        (LETT #1# (SPADCALL |exprtable| (QREFELT $ 142)) . #2#)
                        G190
                        (COND
                         ((OR (ATOM #1#)
                              (PROGN (LETT |i| (CAR #1#) . #2#) NIL))
                          #3#))
                        (SEQ
                         (EXIT
                          (LETT |ansexpr|
                                (SPADCALL |ansexpr|
                                          (SPADCALL
                                           (|SOLVETRA;logsumtolog|
                                            (SPADCALL |exprtable| |i|
                                                      (QREFELT $ 140))
                                            $)
                                           |i| (QREFELT $ 124))
                                          (QREFELT $ 123))
                                . #2#)))
                        (LETT #1# (CDR #1#) . #2#) #4# G191 (EXIT NIL))
                   (EXIT
                    (LETT |ansexpr| (SPADCALL |ansexpr| |ans| (QREFELT $ 123))
                          . #2#)))))))))) 

(DEFUN |SOLVETRA;testRootk| (|varlistk| |y| $)
  (PROG (#1=#:G2132 #2=#:G2133 |i| |kernelofeqnvar| |testList|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |testList| (LIST '|nthRoot|) . #3=(|SOLVETRA;testRootk|))
            (LETT |kernelofeqnvar| (|SOLVETRA;tableXkernels| |varlistk| |y| $)
                  . #3#)
            (COND
             ((EQL (LENGTH |kernelofeqnvar|) 0)
              (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))
            (SEQ (LETT |i| NIL . #3#) (LETT #2# |kernelofeqnvar| . #3#) G190
                 (COND
                  ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (COND
                    ((SPADCALL
                      (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                                (QREFELT $ 126))
                      |testList| (QREFELT $ 127))
                     (PROGN (LETT #1# 'T . #3#) (GO #1#))))))
                 (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT 'NIL)))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;tableXkernels| (|evar| Z $)
  (PROG (|listkOfvar| #1=#:G2138 |i| |kOfvar|)
    (RETURN
     (SEQ
      (LETT |kOfvar| (SPADCALL |evar| (QREFELT $ 40))
            . #2=(|SOLVETRA;tableXkernels|))
      (LETT |listkOfvar| NIL . #2#)
      (SEQ (LETT |i| NIL . #2#) (LETT #1# |kOfvar| . #2#) G190
           (COND
            ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #2#) NIL)) (GO G191)))
           (SEQ
            (EXIT
             (COND
              ((NULL
                (SPADCALL (SPADCALL |i| (QREFELT $ 109)) Z (QREFELT $ 131)))
               (LETT |listkOfvar|
                     (CONS (SPADCALL |i| (QREFELT $ 109)) |listkOfvar|)
                     . #2#)))))
           (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
      (EXIT |listkOfvar|))))) 

(DEFUN |SOLVETRA;testTrig| (|eqnvar| Z $)
  (PROG (#1=#:G2144 #2=#:G2145 |i| |kernelofeqnvar| |testList|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |testList| (LIST '|sin| '|cos| '|tan| '|cot| '|sec| '|csc|)
              . #3=(|SOLVETRA;testTrig|))
        (LETT |kernelofeqnvar| (|SOLVETRA;tableXkernels| |eqnvar| Z $) . #3#)
        (COND
         ((EQL (LENGTH |kernelofeqnvar|) 0)
          (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))
        (SEQ (LETT |i| NIL . #3#) (LETT #2# |kernelofeqnvar| . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (COND
                ((SPADCALL
                  (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                            (QREFELT $ 126))
                  |testList| (QREFELT $ 127))
                 (COND
                  ((NULL
                    (|SOLVETRA;testkernel|
                     (|SPADfirst|
                      (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                                (QREFELT $ 83)))
                     Z $))
                   (PROGN (LETT #1# 'NIL . #3#) (GO #1#)))))
                ('T (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT 'T)))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;testHTrig| (|eqnvar| Z $)
  (PROG (#1=#:G2151 #2=#:G2152 |i| |kernelofeqnvar| |testList|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |testList| (LIST '|sinh| '|cosh| '|tanh| '|coth| '|sech| '|csch|)
              . #3=(|SOLVETRA;testHTrig|))
        (LETT |kernelofeqnvar| (|SOLVETRA;tableXkernels| |eqnvar| Z $) . #3#)
        (COND
         ((EQL (LENGTH |kernelofeqnvar|) 0)
          (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))
        (SEQ (LETT |i| NIL . #3#) (LETT #2# |kernelofeqnvar| . #3#) G190
             (COND
              ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) . #3#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (COND
                ((SPADCALL
                  (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                            (QREFELT $ 126))
                  |testList| (QREFELT $ 127))
                 (COND
                  ((NULL
                    (|SOLVETRA;testkernel|
                     (|SPADfirst|
                      (SPADCALL (|SPADfirst| (SPADCALL |i| (QREFELT $ 40)))
                                (QREFELT $ 83)))
                     Z $))
                   (PROGN (LETT #1# 'NIL . #3#) (GO #1#)))))
                ('T (PROGN (LETT #1# 'NIL . #3#) (GO #1#))))))
             (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
        (EXIT 'T)))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;makeInterval| (|l| $)
  (COND
   ((|HasCategory| (QREFELT $ 6)
                   (LIST '|ConvertibleTo| (LIST '|Complex| '(|Float|))))
    (SPADCALL (ELT $ 145) (SPADCALL |l| (QREFELT $ 147)) (QREFELT $ 151)))
   ('T (|error| "This should never happen")))) 

(DEFUN |SOLVETRA;dropfun| (|x| $)
  (PROG (#1=#:G2170 |k|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |k| (SPADCALL |x| (QREFELT $ 153)) . #2=(|SOLVETRA;dropfun|))
         (EXIT
          (COND
           ((OR (QEQCAR |k| 1) (NULL (SPADCALL (QCDR |k|) (QREFELT $ 83))))
            (PROGN (LETT #1# (|spadConstant| $ 122) . #2#) (GO #1#))))))
        (EXIT (|SPADfirst| (SPADCALL (QCDR |k|) (QREFELT $ 83))))))
      #1# (EXIT #1#))))) 

(DEFUN |SOLVETRA;funcinv| (|k| |l| $)
  (PROG (|t| |fpi| |im| |z| |ze|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |k| '|sin| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|sin| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1='T (CONS 0 (SPADCALL |l| (QREFELT $ 154))))))
       ((SPADCALL |k| '|cos| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|cos| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 155))))))
       ((SPADCALL |k| '|tan| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|tan| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 156))))))
       ((SPADCALL |k| '|cot| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|cot| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 157))))))
       ((SPADCALL |k| '|sec| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         ((SPADCALL |l| '|sec| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 158))))))
       ((SPADCALL |k| '|csc| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         ((SPADCALL |l| '|csc| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 159))))))
       ((SPADCALL |k| '|sinh| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|sinh| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 160))))))
       ((SPADCALL |k| '|cosh| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|cosh| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 161))))))
       ((SPADCALL |k| '|tanh| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|tanh| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 162))))))
       ((SPADCALL |k| '|coth| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|coth| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 163))))))
       ((SPADCALL |k| '|sech| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|sech| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 164))))))
       ((SPADCALL |k| '|csch| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| '|csch| (QREFELT $ 116))
          (CONS 0 (|SOLVETRA;dropfun| |l| $)))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 165))))))
       ((SPADCALL |k| '|atan| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 99))))
       ((SPADCALL |k| '|acot| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 166))))))
       ((SPADCALL |k| '|asin| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 167))))
       ((SPADCALL |k| '|acos| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 168))))
       ((SPADCALL |k| '|asec| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 169))))
       ((SPADCALL |k| '|acsc| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 170))))))
       ((SPADCALL |k| '|asinh| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 171))))
       ((SPADCALL |k| '|acosh| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 172))))
       ((SPADCALL |k| '|atanh| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 173))))
       ((SPADCALL |k| '|acoth| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 174))))))
       ((SPADCALL |k| '|asech| (QREFELT $ 116))
        (CONS 0 (SPADCALL |l| (QREFELT $ 175))))
       ((SPADCALL |k| '|acsch| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 176))))))
       ((SPADCALL |k| '|exp| (QREFELT $ 116))
        (COND
         ((SPADCALL |l| (|spadConstant| $ 122) (QREFELT $ 38))
          (CONS 1 "failed"))
         (#1# (CONS 0 (|SOLVETRA;simplifyingLog| |l| $)))))
       ((SPADCALL |k| '|log| (QREFELT $ 116))
        (COND
         ((|HasCategory| (QREFELT $ 6)
                         (LIST '|ConvertibleTo| (LIST '|Complex| '(|Float|))))
          (SEQ
           (LETT |ze|
                 (SPADCALL (CONS (|function| |SOLVETRA;makeInterval|) $) |l|
                           (QREFELT $ 180))
                 . #2=(|SOLVETRA;funcinv|))
           (LETT |z| (SPADCALL |ze| (QREFELT $ 182)) . #2#)
           (EXIT
            (COND ((QEQCAR |z| 1) (CONS 0 (SPADCALL |l| (QREFELT $ 183))))
                  (#1#
                   (SEQ (LETT |im| (SPADCALL (QCDR |z|) (QREFELT $ 184)) . #2#)
                        (LETT |fpi| (SPADCALL (QREFELT $ 185)) . #2#)
                        (COND
                         ((SPADCALL (SPADCALL |fpi| (QREFELT $ 186))
                                    (SPADCALL |im| (QREFELT $ 187))
                                    (QREFELT $ 188))
                          (COND
                           ((NULL
                             (SPADCALL |fpi| (SPADCALL |im| (QREFELT $ 189))
                                       (QREFELT $ 188)))
                            (EXIT (CONS 0 (SPADCALL |l| (QREFELT $ 183))))))))
                        (EXIT (CONS 1 "failed"))))))))
         (#1# (CONS 0 (SPADCALL |l| (QREFELT $ 183))))))
       ((SPADCALL |k| '|%power| (QREFELT $ 116))
        (SEQ (LETT |t| (SPADCALL |l| (QREFELT $ 34)) . #2#)
             (EXIT
              (COND
               ((SPADCALL |t| (|spadConstant| $ 122) (QREFELT $ 38))
                (CONS 1 "failed"))
               (#1# (CONS 0 (SPADCALL |t| (QREFELT $ 85))))))))
       (#1# (CONS 0 |l|))))))) 

(DEFUN |SOLVETRA;ker2Poly| (|k| |lvar| $)
  (PROG (|nm|)
    (RETURN
     (COND
      ((SPADCALL (LETT |nm| (SPADCALL |k| (QREFELT $ 126)) |SOLVETRA;ker2Poly|)
                 |lvar| (QREFELT $ 127))
       (SPADCALL |nm| (QREFELT $ 191)))
      ('T (SPADCALL (SPADCALL |k| (QREFELT $ 109)) (QREFELT $ 192))))))) 

(DEFUN |SOLVETRA;smp2Poly| (|pol| |lvar| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|SOLVETRA;smp2Poly!0| (VECTOR $ |lvar|))
               (CONS #'|SOLVETRA;smp2Poly!1| $) |pol| (QREFELT $ 196))))) 

(DEFUN |SOLVETRA;smp2Poly!1| (|y| $)
  (SPADCALL (SPADCALL |y| (QREFELT $ 121)) (QREFELT $ 192))) 

(DEFUN |SOLVETRA;smp2Poly!0| (|x| $$)
  (PROG (|lvar| $)
    (LETT |lvar| (QREFELT $$ 1) . #1=(|SOLVETRA;smp2Poly|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|SOLVETRA;ker2Poly| |x| |lvar| $))))) 

(DEFUN |SOLVETRA;makeFracPoly| (|expr| |lvar| $)
  (SPADCALL (|SOLVETRA;smp2Poly| (SPADCALL |expr| (QREFELT $ 60)) |lvar| $)
            (|SOLVETRA;smp2Poly| (SPADCALL |expr| (QREFELT $ 197)) |lvar| $)
            (QREFELT $ 199))) 

(DEFUN |SOLVETRA;makeREpol| (|pol| $)
  (PROG (|lval| #1=#:G2240 |v| #2=#:G2239 |lvar|)
    (RETURN
     (SEQ
      (LETT |lvar| (SPADCALL |pol| (QREFELT $ 200))
            . #3=(|SOLVETRA;makeREpol|))
      (LETT |lval|
            (PROGN
             (LETT #2# NIL . #3#)
             (SEQ (LETT |v| NIL . #3#) (LETT #1# |lvar| . #3#) G190
                  (COND
                   ((OR (ATOM #1#) (PROGN (LETT |v| (CAR #1#) . #3#) NIL))
                    (GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #2# (CONS (SPADCALL |v| (QREFELT $ 36)) #2#) . #3#)))
                  (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                  (EXIT (NREVERSE0 #2#))))
            . #3#)
      (EXIT
       (SPADCALL (SPADCALL |pol| |lvar| |lval| (QREFELT $ 201))
                 (QREFELT $ 202))))))) 

(DEFUN |SOLVETRA;makeRE| (|frac| $)
  (SPADCALL (|SOLVETRA;makeREpol| (SPADCALL |frac| (QREFELT $ 203)) $)
            (|SOLVETRA;makeREpol| (SPADCALL |frac| (QREFELT $ 204)) $)
            (QREFELT $ 98))) 

(DEFUN |SOLVETRA;solve1Pol| (|pol| |var| |sol| $)
  (PROG (#1=#:G2246 |vsol| #2=#:G2245 |vsols| |repol|)
    (RETURN
     (SEQ
      (LETT |repol|
            (SPADCALL (|SOLVETRA;makeREpol| |pol| $) |sol| (QREFELT $ 206))
            . #3=(|SOLVETRA;solve1Pol|))
      (LETT |vsols| (SPADCALL |repol| |var| (QREFELT $ 20)) . #3#)
      (EXIT
       (PROGN
        (LETT #2# NIL . #3#)
        (SEQ (LETT |vsol| NIL . #3#) (LETT #1# |vsols| . #3#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |vsol| (CAR #1#) . #3#) NIL))
               (GO G191)))
             (SEQ (EXIT (LETT #2# (CONS (CONS |vsol| |sol|) #2#) . #3#)))
             (LETT #1# (CDR #1#) . #3#) (GO G190) G191
             (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |SOLVETRA;solve1Sys| (|plist| |lvar| $)
  (PROG (|sols| #1=#:G2248 #2=#:G2247 #3=#:G2249 #4=#:G2255 |sol| #5=#:G2253
         |p| #6=#:G2254 |v| |rlvar| |rplist|)
    (RETURN
     (SEQ (LETT |rplist| (REVERSE |plist|) . #7=(|SOLVETRA;solve1Sys|))
          (LETT |rlvar| (REVERSE |lvar|) . #7#)
          (LETT |sols| (SPADCALL NIL (QREFELT $ 207)) . #7#)
          (SEQ (LETT |v| NIL . #7#) (LETT #6# |rlvar| . #7#)
               (LETT |p| NIL . #7#) (LETT #5# |rplist| . #7#) G190
               (COND
                ((OR (ATOM #5#) (PROGN (LETT |p| (CAR #5#) . #7#) NIL)
                     (ATOM #6#) (PROGN (LETT |v| (CAR #6#) . #7#) NIL))
                 #8=(GO G191)))
               (SEQ
                (EXIT
                 (LETT |sols|
                       (PROGN
                        (LETT #1# NIL . #7#)
                        (SEQ (LETT |sol| NIL . #7#) (LETT #4# |sols| . #7#)
                             G190
                             (COND
                              ((OR (ATOM #4#)
                                   (PROGN (LETT |sol| (CAR #4#) . #7#) NIL))
                               #8#))
                             (SEQ
                              (EXIT
                               (PROGN
                                (LETT #3#
                                      (|SOLVETRA;solve1Pol| |p| |v| |sol| $)
                                      . #7#)
                                (COND (#1# (LETT #2# (APPEND #2# #3#) . #7#))
                                      ('T
                                       (PROGN
                                        (LETT #2# #3# . #7#)
                                        (LETT #1# 'T . #7#)))))))
                             (LETT #4# (CDR #4#) . #7#) #9=(GO G190) G191
                             (EXIT NIL))
                        (COND (#1# #2#) ('T NIL)))
                       . #7#)))
               (LETT #5# (PROG1 (CDR #5#) (LETT #6# (CDR #6#) . #7#)) . #7#)
               #9# G191 (EXIT NIL))
          (EXIT |sols|))))) 

(DEFUN |SOLVETRA;frac_to_expr| (|q| $)
  (SPADCALL (SPADCALL |q| (QREFELT $ 209)) (SPADCALL |q| (QREFELT $ 210))
            (QREFELT $ 211))) 

(DEFUN |SOLVETRA;tryLinear| (|lexpr| |lvar| $)
  (PROG (|eqs| #1=#:G2329 |i| #2=#:G2328 |sym| #3=#:G2327 |p| |zeron| |rhs|
         #4=#:G2301 |sol| |vece| #5=#:G2326 |q| #6=#:G2325 |mate| #7=#:G2324
         #8=#:G2323 #9=#:G2322 |row| #10=#:G2321 |r| |ps| #11=#:G2320 |expr|
         #12=#:G2319 #13=#:G2311 #14=#:G2318 |ker| |kers| |llk| #15=#:G2317
         #16=#:G2316 #17=#:G2262 #18=#:G2261 #19=#:G2263 #20=#:G2315
         #21=#:G2259 #22=#:G2258 #23=#:G2260 #24=#:G2314 |lvk| #25=#:G2313 |v|
         #26=#:G2312)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |lvk|
              (PROGN
               (LETT #26# NIL . #27=(|SOLVETRA;tryLinear|))
               (SEQ (LETT |v| NIL . #27#) (LETT #25# |lvar| . #27#) G190
                    (COND
                     ((OR (ATOM #25#) (PROGN (LETT |v| (CAR #25#) . #27#) NIL))
                      #28=(GO G191)))
                    (SEQ
                     (EXIT
                      (LETT #26# (CONS (SPADCALL |v| (QREFELT $ 63)) #26#)
                            . #27#)))
                    (LETT #25# (CDR #25#) . #27#) #29=(GO G190) G191
                    (EXIT (NREVERSE0 #26#))))
              . #27#)
        (EXIT
         (COND
          ((OR
            (PROGN
             (LETT #21# NIL . #27#)
             (SEQ (LETT |expr| NIL . #27#) (LETT #24# |lexpr| . #27#) G190
                  (COND
                   ((OR (ATOM #24#)
                        (PROGN (LETT |expr| (CAR #24#) . #27#) NIL))
                    #28#))
                  (SEQ
                   (EXIT
                    (PROGN
                     (LETT #23#
                           (< 1
                              (SPADCALL (SPADCALL |expr| (QREFELT $ 60)) |lvk|
                                        (QREFELT $ 216)))
                           . #27#)
                     (COND (#21# (LETT #22# (COND (#22# 'T) ('T #23#)) . #27#))
                           ('T
                            (PROGN
                             (LETT #22# #23# . #27#)
                             (LETT #21# 'T . #27#)))))))
                  (LETT #24# (CDR #24#) . #27#) #29# G191 (EXIT NIL))
             (COND (#21# #22#) (#30='T 'NIL)))
            (PROGN
             (LETT #17# NIL . #27#)
             (SEQ (LETT |expr| NIL . #27#) (LETT #20# |lexpr| . #27#) G190
                  (COND
                   ((OR (ATOM #20#)
                        (PROGN (LETT |expr| (CAR #20#) . #27#) NIL))
                    #28#))
                  (SEQ
                   (EXIT
                    (PROGN
                     (LETT #19#
                           (COND
                            ((NULL
                              (SPADCALL |lvk|
                                        (SPADCALL
                                         (SPADCALL |expr| (QREFELT $ 197))
                                         (QREFELT $ 217))
                                        (QREFELT $ 218)))
                             'NIL)
                            ('T 'T))
                           . #27#)
                     (COND (#17# (LETT #18# (COND (#18# 'T) ('T #19#)) . #27#))
                           ('T
                            (PROGN
                             (LETT #18# #19# . #27#)
                             (LETT #17# 'T . #27#)))))))
                  (LETT #20# (CDR #20#) . #27#) #29# G191 (EXIT NIL))
             (COND (#17# #18#) (#30# 'NIL))))
           (CONS 1 "failed"))
          ('T
           (SEQ
            (LETT |llk|
                  (PROGN
                   (LETT #16# NIL . #27#)
                   (SEQ (LETT |expr| NIL . #27#) (LETT #15# |lexpr| . #27#)
                        G190
                        (COND
                         ((OR (ATOM #15#)
                              (PROGN (LETT |expr| (CAR #15#) . #27#) NIL))
                          #28#))
                        (SEQ
                         (EXIT
                          (LETT #16#
                                (CONS (SPADCALL |expr| (QREFELT $ 219)) #16#)
                                . #27#)))
                        (LETT #15# (CDR #15#) . #27#) #29# G191
                        (EXIT (NREVERSE0 #16#))))
                  . #27#)
            (LETT |kers| (SPADCALL (ELT $ 221) |llk| (QREFELT $ 224)) . #27#)
            (SEQ (LETT |ker| NIL . #27#) (LETT #14# |kers| . #27#) G190
                 (COND
                  ((OR (ATOM #14#) (PROGN (LETT |ker| (CAR #14#) . #27#) NIL))
                   #28#))
                 (SEQ
                  (EXIT
                   (COND
                    ((QEQCAR (SPADCALL |ker| (QREFELT $ 226)) 0) "iterate")
                    ((NULL
                      (NULL
                       (SPADCALL |lvar|
                                 (SPADCALL (SPADCALL |ker| (QREFELT $ 109))
                                           (QREFELT $ 11))
                                 (QREFELT $ 227))))
                     (PROGN (LETT #13# (CONS 1 "failed") . #27#) (GO #13#))))))
                 (LETT #14# (CDR #14#) . #27#) #29# G191 (EXIT NIL))
            (LETT |ps|
                  (PROGN
                   (LETT #12# NIL . #27#)
                   (SEQ (LETT |expr| NIL . #27#) (LETT #11# |lexpr| . #27#)
                        G190
                        (COND
                         ((OR (ATOM #11#)
                              (PROGN (LETT |expr| (CAR #11#) . #27#) NIL))
                          #28#))
                        (SEQ
                         (EXIT
                          (LETT #12#
                                (CONS (SPADCALL |expr| (QREFELT $ 60)) #12#)
                                . #27#)))
                        (LETT #11# (CDR #11#) . #27#) #29# G191
                        (EXIT (NREVERSE0 #12#))))
                  . #27#)
            (LETT |r| (SPADCALL |ps| |lvk| (QREFELT $ 231)) . #27#)
            (LETT |mate|
                  (SPADCALL
                   (PROGN
                    (LETT #10# NIL . #27#)
                    (SEQ (LETT |row| NIL . #27#)
                         (LETT #9# (SPADCALL (QCAR |r|) (QREFELT $ 234))
                               . #27#)
                         G190
                         (COND
                          ((OR (ATOM #9#)
                               (PROGN (LETT |row| (CAR #9#) . #27#) NIL))
                           #28#))
                         (SEQ
                          (EXIT
                           (LETT #10#
                                 (CONS
                                  (PROGN
                                   (LETT #8# NIL . #27#)
                                   (SEQ (LETT |q| NIL . #27#)
                                        (LETT #7# |row| . #27#) G190
                                        (COND
                                         ((OR (ATOM #7#)
                                              (PROGN
                                               (LETT |q| (CAR #7#) . #27#)
                                               NIL))
                                          #28#))
                                        (SEQ
                                         (EXIT
                                          (LETT #8#
                                                (CONS
                                                 (|SOLVETRA;frac_to_expr| |q|
                                                  $)
                                                 #8#)
                                                . #27#)))
                                        (LETT #7# (CDR #7#) . #27#) #29# G191
                                        (EXIT (NREVERSE0 #8#))))
                                  #10#)
                                 . #27#)))
                         (LETT #9# (CDR #9#) . #27#) #29# G191
                         (EXIT (NREVERSE0 #10#))))
                   (QREFELT $ 237))
                  . #27#)
            (LETT |vece|
                  (SPADCALL
                   (PROGN
                    (LETT #6# NIL . #27#)
                    (SEQ (LETT |q| NIL . #27#)
                         (LETT #5# (SPADCALL (QCDR |r|) (QREFELT $ 240))
                               . #27#)
                         G190
                         (COND
                          ((OR (ATOM #5#)
                               (PROGN (LETT |q| (CAR #5#) . #27#) NIL))
                           #28#))
                         (SEQ
                          (EXIT
                           (LETT #6# (CONS (|SOLVETRA;frac_to_expr| |q| $) #6#)
                                 . #27#)))
                         (LETT #5# (CDR #5#) . #27#) #29# G191
                         (EXIT (NREVERSE0 #6#))))
                   (QREFELT $ 242))
                  . #27#)
            (LETT |sol| (SPADCALL |mate| |vece| (QREFELT $ 246)) . #27#)
            (EXIT
             (COND ((QEQCAR (QCAR |sol|) 1) (CONS 0 NIL))
                   (#30#
                    (SEQ
                     (LETT |rhs|
                           (PROG2
                               (LETT #4# (QCAR |sol|) . #27#)
                               (QCDR #4#)
                             (|check-union| (QEQCAR #4# 0)
                                            (|Vector|
                                             (|Expression| (QREFELT $ 6)))
                                            #4#))
                           . #27#)
                     (LETT |zeron| (SPADCALL (LENGTH |lvar|) (QREFELT $ 247))
                           . #27#)
                     (SEQ (LETT |p| NIL . #27#) (LETT #3# (QCDR |sol|) . #27#)
                          G190
                          (COND
                           ((OR (ATOM #3#)
                                (PROGN (LETT |p| (CAR #3#) . #27#) NIL))
                            #28#))
                          (SEQ
                           (EXIT
                            (COND
                             ((COND
                               ((SPADCALL |p| |zeron| (QREFELT $ 250)) 'NIL)
                               (#30# 'T))
                              (SEQ
                               (LETT |sym|
                                     (SPADCALL (SPADCALL (QREFELT $ 35))
                                               (QREFELT $ 36))
                                     . #27#)
                               (EXIT
                                (SEQ (LETT |i| 1 . #27#)
                                     (LETT #2# (LENGTH |lvar|) . #27#) G190
                                     (COND ((QSGREATERP |i| #2#) #28#))
                                     (SEQ
                                      (EXIT
                                       (SPADCALL |rhs| |i|
                                                 (SPADCALL
                                                  (SPADCALL |rhs| |i|
                                                            (QREFELT $ 251))
                                                  (SPADCALL |sym|
                                                            (SPADCALL |p| |i|
                                                                      (QREFELT
                                                                       $ 251))
                                                            (QREFELT $ 124))
                                                  (QREFELT $ 123))
                                                 (QREFELT $ 252))))
                                     (LETT |i| (QSADD1 |i|) . #27#) #29# G191
                                     (EXIT NIL))))))))
                          (LETT #3# (CDR #3#) . #27#) #29# G191 (EXIT NIL))
                     (LETT |eqs| NIL . #27#)
                     (SEQ (LETT |i| 1 . #27#) (LETT #1# (LENGTH |lvar|) . #27#)
                          G190 (COND ((QSGREATERP |i| #1#) #28#))
                          (SEQ
                           (EXIT
                            (LETT |eqs|
                                  (APPEND |eqs|
                                          (LIST
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |lvar| |i|
                                                       (QREFELT $ 253))
                                             (QREFELT $ 36))
                                            (SPADCALL |rhs| |i|
                                                      (QREFELT $ 251))
                                            (QREFELT $ 37))))
                                  . #27#)))
                          (LETT |i| (QSADD1 |i|) . #27#) #29# G191 (EXIT NIL))
                     (EXIT (CONS 0 (LIST |eqs|)))))))))))))
      #13# (EXIT #13#))))) 

(DEFUN |SOLVETRA;solveList| (|lexpr| |lvar| $)
  (PROG (|l| #1=#:G2342 |plist| #2=#:G2341 |trianglist| |lfrac| #3=#:G2340
         |expr| #4=#:G2339 |ans1|)
    (RETURN
     (SEQ
      (LETT |ans1| (|SOLVETRA;solveRetract| |lexpr| |lvar| $)
            . #5=(|SOLVETRA;solveList|))
      (EXIT
       (COND
        ((QEQCAR |ans1| 1)
         (SEQ (LETT |ans1| (|SOLVETRA;tryLinear| |lexpr| |lvar| $) . #5#)
              (EXIT
               (COND
                ((QEQCAR |ans1| 1)
                 (SEQ
                  (LETT |lfrac|
                        (PROGN
                         (LETT #4# NIL . #5#)
                         (SEQ (LETT |expr| NIL . #5#) (LETT #3# |lexpr| . #5#)
                              G190
                              (COND
                               ((OR (ATOM #3#)
                                    (PROGN (LETT |expr| (CAR #3#) . #5#) NIL))
                                #6=(GO G191)))
                              (SEQ
                               (EXIT
                                (LETT #4#
                                      (CONS
                                       (|SOLVETRA;makeFracPoly| |expr| |lvar|
                                        $)
                                       #4#)
                                      . #5#)))
                              (LETT #3# (CDR #3#) . #5#) #7=(GO G190) G191
                              (EXIT (NREVERSE0 #4#))))
                        . #5#)
                  (LETT |trianglist| (SPADCALL |lfrac| |lvar| (QREFELT $ 257))
                        . #5#)
                  (LETT |l|
                        (PROGN
                         (LETT #2# NIL . #5#)
                         (SEQ (LETT |plist| NIL . #5#)
                              (LETT #1# |trianglist| . #5#) G190
                              (COND
                               ((OR (ATOM #1#)
                                    (PROGN (LETT |plist| (CAR #1#) . #5#) NIL))
                                #6#))
                              (SEQ
                               (EXIT
                                (LETT #2#
                                      (CONS
                                       (|SOLVETRA;solve1Sys| |plist| |lvar| $)
                                       #2#)
                                      . #5#)))
                              (LETT #1# (CDR #1#) . #5#) #7# G191
                              (EXIT (NREVERSE0 #2#))))
                        . #5#)
                  (EXIT (SPADCALL (ELT $ 258) |l| NIL (QREFELT $ 261)))))
                (#8='T (QCDR |ans1|))))))
        (#8# (QCDR |ans1|)))))))) 

(DEFUN |SOLVETRA;solve;LLL;37| (|leqs| |lvar| $)
  (PROG (|lexpr| #1=#:G2347 |eq| #2=#:G2346)
    (RETURN
     (SEQ
      (LETT |lexpr|
            (PROGN
             (LETT #2# NIL . #3=(|SOLVETRA;solve;LLL;37|))
             (SEQ (LETT |eq| NIL . #3#) (LETT #1# |leqs| . #3#) G190
                  (COND
                   ((OR (ATOM #1#) (PROGN (LETT |eq| (CAR #1#) . #3#) NIL))
                    (GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #2#
                          (CONS
                           (SPADCALL (SPADCALL |eq| (QREFELT $ 22))
                                     (SPADCALL |eq| (QREFELT $ 23))
                                     (QREFELT $ 24))
                           #2#)
                          . #3#)))
                  (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                  (EXIT (NREVERSE0 #2#))))
            . #3#)
      (EXIT (|SOLVETRA;solveList| |lexpr| |lvar| $)))))) 

(DEFUN |TransSolvePackage| (#1=#:G2348)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2349)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|TransSolvePackage|)
                                           '|domainEqualList|)
                . #3=(|TransSolvePackage|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|TransSolvePackage;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|TransSolvePackage|))))))))))) 

(DEFUN |TransSolvePackage;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|TransSolvePackage|))
      (LETT |dv$| (LIST '|TransSolvePackage| DV$1) . #1#)
      (LETT $ (GETREFV 263) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|TransSolvePackage| (LIST DV$1)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (SETF |pv$| (QREFELT $ 3))
      $)))) 

(MAKEPROP '|TransSolvePackage| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Boolean|)
              (|Expression| 6) (0 . |zero?|) (|List| 19) (5 . |variables|)
              (10 . |One|) (|SparseUnivariatePolynomial| 6) (14 . |One|)
              (18 . |One|) (|Equation| 8) (22 . |One|) (|List| 16) (|Symbol|)
              |SOLVETRA;solve;ESL;5| |SOLVETRA;solve;EL;1| (26 . |lhs|)
              (31 . |rhs|) (36 . -) |SOLVETRA;solve;EL;2|
              |SOLVETRA;solve;ESL;3| (|Union| 56 '#1="failed")
              (42 . |retractIfCan|) (|Union| (|Fraction| 56) '#1#)
              (47 . |retractIfCan|) (|Equation| $) (52 . |eval|)
              (|ElementaryFunctionStructurePackage| 6 8) (58 . |normalize|)
              (63 . |new|) (67 . |coerce|) (72 . =) (78 . =) (|List| 42)
              (84 . |kernels|) (|Fraction| 48) (|Kernel| $) (89 . |univariate|)
              (|SparseUnivariatePolynomial| 8) (|Fraction| 44) (95 . |numer|)
              (|Factored| 48) (|SparseUnivariatePolynomial| $)
              (100 . |factorPolynomial|)
              (|Record| (|:| |factor| 44) (|:| |exponent| 56)) (|List| 50)
              (|Factored| 44) (105 . |factors|) (|List| $) (110 . |zerosOf|)
              (|Integer|) (|List| 8) (116 . |elt|)
              (|SparseMultivariatePolynomial| 6 42) (122 . |numer|)
              (127 . |coerce|) (|Kernel| 8) (132 . |kernel|)
              (|AlgebraicManipulations| 6 8) (137 . |rootSimp|) (|Factored| 67)
              (|SparseMultivariatePolynomial| 6 62)
              (|MultivariateFactorize| 62 (|IndexedExponents| 62) 6 67)
              (142 . |factor|) (|Record| (|:| |factor| 67) (|:| |exponent| 56))
              (|List| 70) (147 . |factors|) (152 . |One|)
              (|SparseUnivariatePolynomial| 13) (156 . |One|) (160 . |One|)
              (164 . |One|) (168 . |One|) (172 . |One|)
              (|Record| (|:| |var| 42) (|:| |exponent| 56))
              (|Union| 80 '#2="failed") (176 . |isExpt|) (182 . |argument|)
              (187 . *) (193 . |log|)
              (|Union| (|Fraction| (|Polynomial| 6)) '#1#)
              (198 . |retractIfCan|) (|List| 18)
              (|List| (|Fraction| (|Polynomial| 6))) (|RadicalSolvePackage| 6)
              (203 . |radicalSolve|) (|TranscendentalManipulations| 6 8)
              (209 . |simplify|) (214 . |normalize|)
              (|TrigonometricManipulations| 6 8) (220 . |complexNormalize|)
              (226 . |coerce|) (231 . /) (237 . |tan|) (|PositiveInteger|)
              (242 . *) (248 . ^) (254 . -) (|TransSolvePackageService| 6)
              (259 . |decomposeFunc|) (266 . =) (|Fraction| $) (272 . |elt|)
              (278 . |coerce|) (283 . |second|) (288 . |retract|)
              (|NonNegativeInteger|) (293 . |monomial|) (299 . -)
              (305 . |resultant|) (311 . |is?|) (|Union| 54 '#2#)
              (317 . |isPlus|) (322 . |leadingCoefficient|) (327 . |gcd|)
              (332 . |coerce|) (337 . |Zero|) (341 . +) (347 . *)
              (353 . |Zero|) (357 . |name|) (362 . |member?|) (368 . |isTimes|)
              (373 . |remove!|) (379 . |One|) (383 . |freeOf?|) (389 . ^)
              (|Table| 8 8) (395 . |table|) (399 . |Zero|)
              (403 . |leadingMonomial|) (|Union| 8 '"failed") (408 . |search|)
              (414 . |setelt|) (421 . |elt|) (427 . |reductum|) (432 . |keys|)
              (|Float|) (|Interval| 143) (437 . |interval|) (|Complex| 143)
              (442 . |convert|) (|Complex| 144) (|Mapping| 144 143)
              (|ComplexFunctions2| 143 144) (447 . |map|) (|Union| 42 '#1#)
              (453 . |retractIfCan|) (458 . |asin|) (463 . |acos|)
              (468 . |atan|) (473 . |acot|) (478 . |asec|) (483 . |acsc|)
              (488 . |asinh|) (493 . |acosh|) (498 . |atanh|) (503 . |acoth|)
              (508 . |asech|) (513 . |acsch|) (518 . |cot|) (523 . |sin|)
              (528 . |cos|) (533 . |sec|) (538 . |csc|) (543 . |sinh|)
              (548 . |cosh|) (553 . |tanh|) (558 . |coth|) (563 . |sech|)
              (568 . |csch|) (|Expression| 148) (|Mapping| 148 6)
              (|ExpressionFunctions2| 6 148) (573 . |map|) (|Union| 148 '#1#)
              (579 . |retractIfCan|) (584 . |exp|) (589 . |imag|) (594 . |pi|)
              (598 . -) (603 . |inf|) (608 . <) (614 . |sup|) (|Polynomial| 8)
              (619 . |coerce|) (624 . |coerce|) (|Mapping| 190 62)
              (|Mapping| 190 6)
              (|PolynomialCategoryLifting| (|IndexedExponents| 62) 62 6 67 190)
              (629 . |map|) (636 . |denom|) (|Fraction| 190) (641 . /)
              (647 . |variables|) (652 . |eval|) (659 . |ground|)
              (664 . |numer|) (669 . |denom|) (|List| 31) (674 . |eval|)
              (680 . |list|) (|Fraction| 67) (685 . |numer|) (690 . |denom|)
              (695 . /) (701 . |One|) (705 . |One|) (709 . |One|) (|List| 62)
              (713 . |totalDegree|) (719 . |variables|)
              (724 . |setIntersection|) (730 . |tower|) (735 . |setUnion|)
              (741 . |setUnion|) (|Mapping| 215 215 215) (|List| 215)
              (747 . |reduce|) (|Union| 19 '"failed") (753 . |symbolIfCan|)
              (758 . |setIntersection|)
              (|Record| (|:| |mat| 233) (|:| |vec| 239)) (|List| 67)
              (|LinearSystemPolynomialPackage| 6 (|IndexedExponents| 62) 62 67)
              (764 . |intoMatrix|) (|List| 238) (|Matrix| 208)
              (770 . |listOfLists|) (|List| 57) (|Matrix| 8) (775 . |matrix|)
              (|List| 208) (|Vector| 208) (780 . |parts|) (|Vector| 8)
              (785 . |vector|) (|Union| 241 '"failed")
              (|Record| (|:| |particular| 243) (|:| |basis| (|List| 241)))
              (|LinearSystemMatrixPackage| 8 241 241 236) (790 . |solve|)
              (796 . |zero|) (|Vector| $) (801 . |basis|) (805 . =)
              (811 . |elt|) (817 . |setelt|) (824 . |elt|)
              (|List| (|List| 190)) (|List| 198) (|SystemSolvePackage| 8)
              (830 . |triangularSystems|) (836 . |append|) (|Mapping| 88 88 88)
              (|List| 88) (842 . |reduce|) |SOLVETRA;solve;LLL;37|)
           '#(|solve| 849) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 262
                                                 '(1 8 7 0 9 1 8 10 0 11 0 6 0
                                                   12 0 13 0 14 0 8 0 15 0 16 0
                                                   17 1 16 8 0 22 1 16 8 0 23 2
                                                   8 0 0 0 24 1 8 27 0 28 1 8
                                                   29 0 30 2 8 0 0 31 32 1 33 8
                                                   8 34 0 19 0 35 1 8 0 19 36 2
                                                   16 0 8 8 37 2 8 7 0 0 38 1 8
                                                   39 0 40 2 8 41 0 42 43 1 45
                                                   44 0 46 1 8 47 48 49 1 52 51
                                                   0 53 2 8 54 48 19 55 2 57 8
                                                   0 56 58 1 8 59 0 60 1 8 0 59
                                                   61 1 62 0 19 63 1 64 8 8 65
                                                   1 68 66 67 69 1 66 71 0 72 0
                                                   45 0 73 0 74 0 75 0 44 0 76
                                                   0 52 0 77 0 67 0 78 0 66 0
                                                   79 2 8 81 0 19 82 1 62 57 0
                                                   83 2 8 0 56 0 84 1 8 0 0 85
                                                   1 8 86 0 87 2 90 88 89 10 91
                                                   1 92 8 8 93 2 33 8 8 19 94 2
                                                   95 8 8 19 96 1 8 0 56 97 2 8
                                                   0 0 0 98 1 8 0 0 99 2 8 0
                                                   100 0 101 2 8 0 0 100 102 1
                                                   8 0 0 103 3 104 45 45 45 45
                                                   105 2 45 7 0 0 106 2 44 8
                                                   107 8 108 1 8 0 42 109 1 57
                                                   8 0 110 1 8 56 0 111 2 44 0
                                                   8 112 113 2 44 0 0 0 114 2
                                                   44 8 0 0 115 2 8 7 0 19 116
                                                   1 8 117 0 118 1 67 6 0 119 1
                                                   6 0 54 120 1 8 0 6 121 0 8 0
                                                   122 2 8 0 0 0 123 2 8 0 0 0
                                                   124 0 6 0 125 1 62 19 0 126
                                                   2 10 7 19 0 127 1 8 117 0
                                                   128 2 57 0 8 0 129 0 56 0
                                                   130 2 8 7 0 19 131 2 8 0 0 0
                                                   132 0 133 0 134 0 13 0 135 1
                                                   67 0 0 136 2 133 137 8 0 138
                                                   3 133 8 0 8 8 139 2 133 8 0
                                                   8 140 1 67 0 0 141 1 133 57
                                                   0 142 1 144 0 143 145 1 6
                                                   146 0 147 2 150 148 149 146
                                                   151 1 8 152 0 153 1 8 0 0
                                                   154 1 8 0 0 155 1 8 0 0 156
                                                   1 8 0 0 157 1 8 0 0 158 1 8
                                                   0 0 159 1 8 0 0 160 1 8 0 0
                                                   161 1 8 0 0 162 1 8 0 0 163
                                                   1 8 0 0 164 1 8 0 0 165 1 8
                                                   0 0 166 1 8 0 0 167 1 8 0 0
                                                   168 1 8 0 0 169 1 8 0 0 170
                                                   1 8 0 0 171 1 8 0 0 172 1 8
                                                   0 0 173 1 8 0 0 174 1 8 0 0
                                                   175 1 8 0 0 176 2 179 177
                                                   178 8 180 1 177 181 0 182 1
                                                   8 0 0 183 1 148 144 0 184 0
                                                   143 0 185 1 143 0 0 186 1
                                                   144 143 0 187 2 143 7 0 0
                                                   188 1 144 143 0 189 1 190 0
                                                   19 191 1 190 0 8 192 3 195
                                                   190 193 194 67 196 1 8 59 0
                                                   197 2 198 0 190 190 199 1
                                                   190 10 0 200 3 190 0 0 10 57
                                                   201 1 190 8 0 202 1 198 190
                                                   0 203 1 198 190 0 204 2 8 0
                                                   0 205 206 1 88 0 18 207 1
                                                   208 67 0 209 1 208 67 0 210
                                                   2 8 0 59 59 211 0 148 0 212
                                                   0 190 0 213 0 198 0 214 2 67
                                                   112 0 215 216 1 67 215 0 217
                                                   2 215 0 0 0 218 1 8 39 0 219
                                                   2 18 0 0 0 220 2 215 0 0 0
                                                   221 2 223 215 222 0 224 1 62
                                                   225 0 226 2 10 0 0 0 227 2
                                                   230 228 229 215 231 1 233
                                                   232 0 234 1 236 0 235 237 1
                                                   239 238 0 240 1 241 0 57 242
                                                   2 245 244 236 241 246 1 241
                                                   0 112 247 0 148 248 249 2
                                                   241 7 0 0 250 2 241 8 0 56
                                                   251 3 241 8 0 56 8 252 2 10
                                                   19 0 56 253 2 256 254 255 10
                                                   257 2 88 0 0 0 258 3 260 88
                                                   259 0 88 261 1 0 18 16 25 1
                                                   0 18 8 21 2 0 18 16 19 26 2
                                                   0 88 18 10 262 2 0 18 8 19
                                                   20)))))
           '|lookupComplete|)) 
