
(/VERSIONCHECK 2) 

(DEFUN |SOLVETRA;solve;EL;1| (|oside| $)
  (PROG (|lv|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |oside| (QREFELT $ 9))
              (|error| "equation is always satisfied"))
             ('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"))
                           ('T
                            (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 |lside| |sol| (QREFELT $ 32))
                    (QREFELT $ 9))
                'T)
               ('T 'NIL))))) 

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

(DEFUN |SOLVETRA;solveInner| (|lside| |x| $)
  (PROG (|ausgabe1| X Y |bigX| |eq1| |fatt| #0=#:G1946 #1=#:G1918
            #2=#:G1916 #3=#:G1917 |lr| #4=#:G1947 |finv| |r1|
            #5=#:G1920 |bigXback| |ri| #6=#:G1948 #7=#:G1926 #8=#:G1924
            #9=#:G1925 |i| #10=#:G1949 |elR| |f| |lfatt| |ff|
            #11=#:G1950 #12=#:G1931 #13=#:G1929 #14=#:G1930 |secondsol|
            |j| #15=#:G1951 |newlist| |newlside| |listofkernels|
            |lfacts| |frec| #16=#:G1952 |sols| #17=#:G1945)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |lside|
                            (|SOLVETRA;eliminateRoot| |lside| |x| $)
                            . #18=(|SOLVETRA;solveInner|))
                      (LETT |ausgabe1|
                            (|SOLVETRA;tableXkernels| |lside| |x| $) . #18#)
                      (LETT X (SPADCALL (QREFELT $ 33)) . #18#)
                      (LETT Y
                            (SPADCALL (SPADCALL (QREFELT $ 33))
                                (QREFELT $ 34)) . #18#)
                      (EXIT (COND
                              ((EQL (LENGTH |ausgabe1|) 1)
                               (SEQ (LETT |bigX|
                                     (|SPADfirst| |ausgabe1|) . #18#)
                                    (LETT |eq1|
                                     (SPADCALL |lside|
                                      (SPADCALL |bigX|
                                       (SPADCALL X (QREFELT $ 34))
                                       (QREFELT $ 35))
                                      (QREFELT $ 32)) . #18#)
                                    (LETT |f|
                                     (SPADCALL |eq1|
                                      (|SPADfirst|
                                       (SPADCALL
                                        (SPADCALL X (QREFELT $ 34))
                                        (QREFELT $ 37)))
                                      (QREFELT $ 40)) . #18#)
                                    (LETT |lfatt|
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |f| (QREFELT $ 43))
                                       (QREFELT $ 46))
                                      (QREFELT $ 50)) . #18#)
                                    (LETT |lr|
                                     (PROGN
                                       (LETT #3# NIL . #18#)
                                       (SEQ (LETT |fatt| NIL . #18#)
                                        (LETT #0# |lfatt| . #18#) G190
                                        (COND
                                          ((OR (ATOM #0#)
                                            (PROGN
                                              (LETT |fatt|
                                               (CAR #0#) . #18#)
                                              NIL))
                                           #19=(GO G191)))
                                        (SEQ
                                         (EXIT
                                          (PROGN
                                            (LETT #1#
                                             (SPADCALL (QCAR |fatt|)
                                              |x| (QREFELT $ 52)) . #18#)
                                            (COND
                                              (#3#
                                               (LETT #2#
                                                (APPEND #2# #1#) . #18#))
                                              ('T
                                               (PROGN
                                                 (LETT #2# #1# . #18#)
                                                 (LETT #3# 'T . #18#)))))))
                                        (LETT #0# (CDR #0#) . #18#)
                                        #20=(GO G190) G191 (EXIT NIL))
                                       (COND (#3# #2#) ('T NIL))) . #18#)
                                    (LETT |r1| NIL . #18#)
                                    (SEQ (LETT |i| 1 . #18#)
                                     (LETT #4# (LENGTH |lr|) . #18#)
                                     G190
                                     (COND
                                       ((QSGREATERP |i| #4#) #19#))
                                     (SEQ
                                      (LETT |finv|
                                       (|SOLVETRA;funcinv| |bigX|
                                        (SPADCALL |lr| |i|
                                         (QREFELT $ 55))
                                        $) . #18#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |finv| 0)
                                          (LETT |r1|
                                           (CONS (QCDR |finv|) |r1|) . #18#)))))
                                     (LETT |i| (QSADD1 |i|) . #18#)
                                     #20# G191 (EXIT NIL))
                                    (LETT |bigXback|
                                     (PROG2
                                      (LETT #5#
                                       (|SOLVETRA;funcinv| |bigX|
                                        |bigX| $) . #18#)
                                      (QCDR #5#)
                                       (|check-union| (QEQCAR #5# 0)
                                        (|Expression| (QREFELT $ 6))
                                        #5#)) . #18#)
                                    (COND
                                      ((NULL
                                        (|SOLVETRA;testkernel|
                                         |bigXback| |x| $))
                                       (SEQ
                                        (COND
                                          ((SPADCALL |bigX| |bigXback|
                                            (QREFELT $ 56))
                                           (PROGN
                                             (LETT #17# NIL . #18#)
                                             (GO #17#))))
                                        (EXIT
                                         (PROGN
                                           (LETT #17#
                                            (PROGN
                                              (LETT #9# NIL . #18#)
                                              (SEQ
                                               (LETT |ri| NIL . #18#)
                                               (LETT #6# |r1| . #18#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #6#)
                                                   (PROGN
                                                     (LETT |ri|
                                                      (CAR #6#) . #18#)
                                                     NIL))
                                                  #19#))
                                               (SEQ
                                                (EXIT
                                                 (PROGN
                                                   (LETT #7#
                                                    (SPADCALL
                                                     (SPADCALL
                                                      |bigXback| |ri|
                                                      (QREFELT $ 24))
                                                     |x|
                                                     (QREFELT $ 20)) . #18#)
                                                   (COND
                                                     (#9#
                                                      (LETT #8#
                                                       (APPEND #8# #7#) . #18#))
                                                     ('T
                                                      (PROGN
                                                        (LETT #8#
                                                         #7# . #18#)
                                                        (LETT #9#
                                                         'T . #18#)))))))
                                               (LETT #6#
                                                (CDR #6#) . #18#)
                                               #20# G191 (EXIT NIL))
                                              (COND
                                                (#9# #8#)
                                                ('T NIL))) . #18#)
                                           (GO #17#))))))
                                    (LETT |newlist| NIL . #18#)
                                    (SEQ (LETT |i| 1 . #18#)
                                     (LETT #10# (LENGTH |r1|) . #18#)
                                     G190
                                     (COND
                                       ((QSGREATERP |i| #10#) #19#))
                                     (SEQ
                                      (LETT |elR|
                                       (|SOLVETRA;eliminateRoot|
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |bigXback|
                                           (SPADCALL |r1| |i|
                                            (QREFELT $ 55))
                                           (QREFELT $ 24))
                                          (QREFELT $ 58))
                                         (QREFELT $ 59))
                                        |x| $) . #18#)
                                      (LETT |f|
                                       (SPADCALL |elR|
                                        (SPADCALL |x| (QREFELT $ 61))
                                        (QREFELT $ 40)) . #18#)
                                      (LETT |lfatt|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |f| (QREFELT $ 43))
                                         (QREFELT $ 46))
                                        (QREFELT $ 50)) . #18#)
                                      (LETT |secondsol|
                                       (PROGN
                                         (LETT #14# NIL . #18#)
                                         (SEQ (LETT |ff| NIL . #18#)
                                          (LETT #11# |lfatt| . #18#)
                                          G190
                                          (COND
                                            ((OR (ATOM #11#)
                                              (PROGN
                                                (LETT |ff|
                                                 (CAR #11#) . #18#)
                                                NIL))
                                             #19#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #12#
                                               (SPADCALL (QCAR |ff|)
                                                |x| (QREFELT $ 52)) . #18#)
                                              (COND
                                                (#14#
                                                 (LETT #13#
                                                  (APPEND #13# #12#) . #18#))
                                                ('T
                                                 (PROGN
                                                   (LETT #13#
                                                    #12# . #18#)
                                                   (LETT #14#
                                                    'T . #18#)))))))
                                          (LETT #11# (CDR #11#) . #18#)
                                          #20# G191 (EXIT NIL))
                                         (COND (#14# #13#) ('T NIL))) . #18#)
                                      (EXIT
                                       (SEQ (LETT |j| 1 . #18#)
                                        (LETT #15#
                                         (LENGTH |secondsol|) . #18#)
                                        G190
                                        (COND
                                          ((QSGREATERP |j| #15#) #19#))
                                        (SEQ
                                         (EXIT
                                          (LETT |newlist|
                                           (CONS
                                            (SPADCALL
                                             (SPADCALL |x|
                                              (QREFELT $ 34))
                                             (SPADCALL
                                              (SPADCALL |secondsol| |j|
                                               (QREFELT $ 55))
                                              (QREFELT $ 63))
                                             (QREFELT $ 35))
                                            |newlist|) . #18#)))
                                        (LETT |j| (QSADD1 |j|) . #18#)
                                        #20# G191 (EXIT NIL))))
                                     (LETT |i| (QSADD1 |i|) . #18#)
                                     #20# G191 (EXIT NIL))
                                    (EXIT |newlist|)))
                              ('T
                               (SEQ (LETT |newlside|
                                     (|SOLVETRA;tryToTrans| |lside| |x|
                                      $) . #18#)
                                    (LETT |listofkernels|
                                     (|SOLVETRA;tableXkernels|
                                      |newlside| |x| $) . #18#)
                                    (EXIT
                                     (COND
                                       ((EQL (LENGTH |listofkernels|)
                                         1)
                                        (SPADCALL |newlside| |x|
                                         (QREFELT $ 20)))
                                       ('T
                                        (SEQ
                                         (LETT |lfacts|
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |lside|
                                             (QREFELT $ 58))
                                            (QREFELT $ 67))
                                           (QREFELT $ 70)) . #18#)
                                         (EXIT
                                          (COND
                                            ((< 1 (LENGTH |lfacts|))
                                             (SEQ
                                              (LETT |sols| NIL . #18#)
                                              (SEQ
                                               (LETT |frec| NIL . #18#)
                                               (LETT #16#
                                                |lfacts| . #18#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #16#)
                                                   (PROGN
                                                     (LETT |frec|
                                                      (CAR #16#) . #18#)
                                                     NIL))
                                                  #19#))
                                               (SEQ
                                                (EXIT
                                                 (LETT |sols|
                                                  (APPEND
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (QCAR |frec|)
                                                     (QREFELT $ 59))
                                                    |x| (QREFELT $ 20))
                                                   |sols|) . #18#)))
                                               (LETT #16#
                                                (CDR #16#) . #18#)
                                               #20# G191 (EXIT NIL))
                                              (EXIT |sols|)))
                                            ('T
                                             (PROGN
                                               (LETT #17# NIL . #18#)
                                               (GO #17#)))))))))))))))
           #17# (EXIT #17#))))) 

(DEFUN |SOLVETRA;simplifyingLog| (|f| $)
  (PROG (|u| #0=#:G1959 |rec|)
    (RETURN
      (SEQ (COND
             ((QEQCAR (LETT |u|
                            (SPADCALL |f|
                                (SPADCALL "exp" (QREFELT $ 79))
                                (QREFELT $ 82))
                            . #1=(|SOLVETRA;simplifyingLog|))
                      0)
              (SEQ (LETT |rec|
                         (PROG2 (LETT #0# |u| . #1#) (QCDR #0#)
                           (|check-union| (QEQCAR #0# 0)
                               (|Record|
                                   (|:| |var|
                                    (|Kernel|
                                     (|Expression| (QREFELT $ 6))))
                                   (|:| |exponent| (|Integer|)))
                               #0#)) . #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| $)
                 . #0=(|SOLVETRA;testkernel|))
           (LETT |listvar1|
                 (|SOLVETRA;tableXkernels| |var1| |y| $) . #0#)
           (EXIT (COND
                   ((EQL (LENGTH |listvar1|) 1)
                    (COND
                      ((OR (SPADCALL
                               (SPADCALL |listvar1| 1 (QREFELT $ 55))
                               (SPADCALL |y| (QREFELT $ 34))
                               (QREFELT $ 56))
                           (EQL (LENGTH |listvar1|) 0))
                       'T)
                      ('T 'NIL)))
                   ((EQL (LENGTH |listvar1|) 0) 'T)
                   ('T 'NIL))))))) 

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

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

(DEFUN |SOLVETRA;subsTan| (|exprvar| |y| $)
  (PROG (Z |listofkern| |varkern| Y |test| |fZ| |fN| |f| |secondfun|
           |g| H |newH| |result| #0=#:G2000 |result1| |resultnew|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT Z (SPADCALL (QREFELT $ 33))
                            . #1=(|SOLVETRA;subsTan|))
                      (LETT |listofkern|
                            (|SOLVETRA;tableXkernels| |exprvar| |y| $) . #1#)
                      (LETT |varkern| (|SPADfirst| |listofkern|) . #1#)
                      (LETT Y
                            (SPADCALL
                                (SPADCALL
                                    (|SPADfirst|
                                     (SPADCALL
                                      (|SPADfirst|
                                       (SPADCALL |varkern|
                                        (QREFELT $ 37)))
                                      (QREFELT $ 83)))
                                    (QREFELT $ 58))
                                (QREFELT $ 59)) . #1#)
                      (LETT |test|
                            (SPADCALL |varkern|
                                (SPADCALL
                                    (SPADCALL Y
                                     (SPADCALL 2 (QREFELT $ 98))
                                     (QREFELT $ 99))
                                    (QREFELT $ 100))
                                (QREFELT $ 56)) . #1#)
                      (COND
                        ((EQL (LENGTH |listofkern|) 1)
                         (COND
                           ((NULL |test|)
                            (PROGN
                              (LETT #0# |exprvar| . #1#)
                              (GO #0#)))))
                        ('T
                         (PROGN (LETT #0# |exprvar| . #1#) (GO #0#))))
                      (LETT |fZ|
                            (SPADCALL |exprvar|
                                (SPADCALL |varkern|
                                    (SPADCALL Z (QREFELT $ 34))
                                    (QREFELT $ 35))
                                (QREFELT $ 32)) . #1#)
                      (LETT |fN|
                            (SPADCALL (SPADCALL |fZ| (QREFELT $ 58))
                                (QREFELT $ 59)) . #1#)
                      (LETT |f|
                            (SPADCALL |fN|
                                (|SPADfirst|
                                    (SPADCALL
                                     (SPADCALL Z (QREFELT $ 34))
                                     (QREFELT $ 37)))
                                (QREFELT $ 40)) . #1#)
                      (LETT |secondfun|
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL 2 Y (QREFELT $ 102))
                                    (SPADCALL
                                     (SPADCALL Y 2 (QREFELT $ 103))
                                     (|spadConstant| $ 15)
                                     (QREFELT $ 24))
                                    (QREFELT $ 99))
                                (QREFELT $ 104)) . #1#)
                      (LETT |g|
                            (SPADCALL |secondfun|
                                (|SPADfirst|
                                    (SPADCALL
                                     (SPADCALL |y| (QREFELT $ 34))
                                     (QREFELT $ 37)))
                                (QREFELT $ 40)) . #1#)
                      (LETT H
                            (SPADCALL (SPADCALL (QREFELT $ 33))
                                (QREFELT $ 34)) . #1#)
                      (LETT |newH|
                            (SPADCALL H
                                (|SPADfirst|
                                    (SPADCALL
                                     (SPADCALL Z (QREFELT $ 34))
                                     (QREFELT $ 37)))
                                (QREFELT $ 40)) . #1#)
                      (LETT |result|
                            (SPADCALL |f| |g| |newH| (QREFELT $ 106)) . #1#)
                      (EXIT (COND
                              ((SPADCALL |result| |f| (QREFELT $ 107))
                               (PROGN
                                 (LETT #0# |exprvar| . #1#)
                                 (GO #0#)))
                              ('T
                               (SEQ (LETT |result1|
                                     (SPADCALL |result| H
                                      (QREFELT $ 109)) . #1#)
                                    (EXIT
                                     (LETT |resultnew|
                                      (SPADCALL |result1|
                                       (SPADCALL H
                                        (SPADCALL Y (QREFELT $ 100))
                                        (QREFELT $ 35))
                                       (QREFELT $ 32)) . #1#))))))))
           #0# (EXIT #0#))))) 

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

(DEFUN |SOLVETRA;eliminateRoot| (|var| |y| $)
  (PROG (|varlistk1| |i| #0=#:G2018 |var1|)
    (RETURN
      (SEQ (LETT |var1| |var| . #1=(|SOLVETRA;eliminateRoot|))
           (SEQ G190
                (COND
                  ((NULL (|SOLVETRA;testRootk| |var1| |y| $))
                   #2=(GO G191)))
                (SEQ (LETT |varlistk1|
                           (|SOLVETRA;tableXkernels| |var1| |y| $) . #1#)
                     (EXIT (SEQ (LETT |i| NIL . #1#)
                                (LETT #0# |varlistk1| . #1#) G190
                                (COND
                                  ((OR (ATOM #0#)
                                    (PROGN
                                      (LETT |i| (CAR #0#) . #1#)
                                      NIL))
                                   #2#))
                                (SEQ (EXIT
                                      (COND
                                        ((SPADCALL |i|
                                          (SPADCALL "nthRoot"
                                           (QREFELT $ 79))
                                          (QREFELT $ 117))
                                         (LETT |var1|
                                          (|SOLVETRA;eliminateKernRoot|
                                           |var1|
                                           (|SPADfirst|
                                            (SPADCALL |i|
                                             (QREFELT $ 37)))
                                           $) . #1#)))))
                                (LETT #0# (CDR #0#) . #1#) #3=(GO G190)
                                G191 (EXIT NIL))))
                NIL #3# G191 (EXIT NIL))
           (EXIT |var1|))))) 

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

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

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

(DEFUN |SOLVETRA;buildnexpr| (|expr| Z $)
  (PROG (|nlist| |n2list| |i| #0=#:G2053 |anscoeff| |ansmant|)
    (RETURN
      (SEQ (LETT |nlist| (|SOLVETRA;splitExpr| |expr| $)
                 . #1=(|SOLVETRA;buildnexpr|))
           (LETT |n2list|
                 (SPADCALL (SPADCALL |nlist| 1 (QREFELT $ 55)) |nlist|
                     (QREFELT $ 130)) . #1#)
           (LETT |anscoeff| (|spadConstant| $ 15) . #1#)
           (LETT |ansmant| (|spadConstant| $ 123) . #1#)
           (SEQ (LETT |i| NIL . #1#) (LETT #0# |n2list| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |i| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((SPADCALL |i| Z (QREFELT $ 132))
                              (LETT |anscoeff|
                                    (SPADCALL |i| |anscoeff|
                                     (QREFELT $ 125)) . #1#))
                             ('T (LETT |ansmant| |i| . #1#)))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (LIST |anscoeff|
                       (SPADCALL |ansmant|
                           (SPADCALL |nlist| 1 (QREFELT $ 55))
                           (QREFELT $ 125)))))))) 

(DEFUN |SOLVETRA;logexpp| (|expr1| |expr2| $)
  (SPADCALL
      (SPADCALL
          (|SPADfirst|
              (SPADCALL (|SPADfirst| (SPADCALL |expr1| (QREFELT $ 37)))
                  (QREFELT $ 83)))
          |expr2| (QREFELT $ 133))
      (QREFELT $ 85))) 

(DEFUN |SOLVETRA;combineLog| (|expr| Y $)
  (PROG (|exprtable| |loopexpr| |exprr| |ans| |i| #0=#:G2074 |ansexpr|)
    (RETURN
      (SEQ (LETT |exprtable| (SPADCALL (QREFELT $ 135))
                 . #1=(|SOLVETRA;combineLog|))
           (EXIT (COND
                   ((QEQCAR (SPADCALL |expr| (QREFELT $ 119)) 1)
                    |expr|)
                   ('T
                    (SEQ (LETT |ans| (|spadConstant| $ 123) . #1#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |expr|
                                           (|spadConstant| $ 123)
                                           (QREFELT $ 56))
                                          'NIL)
                                         ('T 'T)))
                                 #2=(GO G191)))
                              (SEQ (LETT |loopexpr|
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |expr| (QREFELT $ 58))
                                      (QREFELT $ 137))
                                     (QREFELT $ 59)) . #1#)
                                   (COND
                                     ((|SOLVETRA;testLog| |loopexpr| Y
                                       $)
                                      (COND
                                        ((EQL
                                          (LENGTH
                                           (|SOLVETRA;tableXkernels|
                                            |loopexpr| Y $))
                                          1)
                                         (SEQ
                                          (LETT |exprr|
                                           (|SOLVETRA;buildnexpr|
                                            |loopexpr| Y $) . #1#)
                                          (COND
                                            ((QEQCAR
                                              (SPADCALL
                                               (SPADCALL |exprr| 1
                                                (QREFELT $ 55))
                                               |exprtable|
                                               (QREFELT $ 139))
                                              1)
                                             (SPADCALL |exprtable|
                                              (SPADCALL |exprr| 1
                                               (QREFELT $ 55))
                                              (|spadConstant| $ 123)
                                              (QREFELT $ 140))))
                                          (EXIT
                                           (SPADCALL |exprtable|
                                            (SPADCALL |exprr| 1
                                             (QREFELT $ 55))
                                            (SPADCALL
                                             (SPADCALL |exprtable|
                                              (SPADCALL |exprr| 1
                                               (QREFELT $ 55))
                                              (QREFELT $ 141))
                                             (SPADCALL |exprr| 2
                                              (QREFELT $ 55))
                                             (QREFELT $ 124))
                                            (QREFELT $ 140)))))
                                        ('T
                                         (LETT |ans|
                                          (SPADCALL |ans| |loopexpr|
                                           (QREFELT $ 124)) . #1#))))
                                     ('T
                                      (LETT |ans|
                                       (SPADCALL |ans| |loopexpr|
                                        (QREFELT $ 124)) . #1#)))
                                   (EXIT
                                    (LETT |expr|
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |expr| (QREFELT $ 58))
                                       (QREFELT $ 142))
                                      (QREFELT $ 59)) . #1#)))
                              NIL #3=(GO G190) G191 (EXIT NIL))
                         (LETT |ansexpr| (|spadConstant| $ 123) . #1#)
                         (SEQ (LETT |i| NIL . #1#)
                              (LETT #0#
                                    (SPADCALL |exprtable|
                                     (QREFELT $ 143)) . #1#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |i| (CAR #0#) . #1#)
                                       NIL))
                                 #2#))
                              (SEQ (EXIT
                                    (LETT |ansexpr|
                                     (SPADCALL |ansexpr|
                                      (SPADCALL
                                       (|SOLVETRA;logsumtolog|
                                        (SPADCALL |exprtable| |i|
                                         (QREFELT $ 141))
                                        $)
                                       |i| (QREFELT $ 125))
                                      (QREFELT $ 124)) . #1#)))
                              (LETT #0# (CDR #0#) . #1#) #3# G191
                              (EXIT NIL))
                         (EXIT (LETT |ansexpr|
                                     (SPADCALL |ansexpr| |ans|
                                      (QREFELT $ 124)) . #1#)))))))))) 

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

(DEFUN |SOLVETRA;tableXkernels| (|evar| Z $)
  (PROG (|kOfvar| |i| #0=#:G2085 |listkOfvar|)
    (RETURN
      (SEQ (LETT |kOfvar| (SPADCALL |evar| (QREFELT $ 37))
                 . #1=(|SOLVETRA;tableXkernels|))
           (LETT |listkOfvar| NIL . #1#)
           (SEQ (LETT |i| NIL . #1#) (LETT #0# |kOfvar| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |i| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((NULL (SPADCALL
                                     (SPADCALL |i| (QREFELT $ 110)) Z
                                     (QREFELT $ 132)))
                              (LETT |listkOfvar|
                                    (CONS
                                     (SPADCALL |i| (QREFELT $ 110))
                                     |listkOfvar|) . #1#)))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |listkOfvar|))))) 

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

(DEFUN |SOLVETRA;testHTrig| (|eqnvar| Z $)
  (PROG (|testList| |kernelofeqnvar| |i| #0=#:G2099 #1=#:G2098)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |testList|
                            (LIST '|sinh| '|cosh| '|tanh| '|coth|
                                  '|sech| '|csch|)
                            . #2=(|SOLVETRA;testHTrig|))
                      (LETT |kernelofeqnvar|
                            (|SOLVETRA;tableXkernels| |eqnvar| Z $) . #2#)
                      (COND
                        ((EQL (LENGTH |kernelofeqnvar|) 0)
                         (PROGN (LETT #1# 'NIL . #2#) (GO #1#))))
                      (SEQ (LETT |i| NIL . #2#)
                           (LETT #0# |kernelofeqnvar| . #2#) G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |i| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (EXIT (COND
                                        ((SPADCALL
                                          (SPADCALL
                                           (|SPADfirst|
                                            (SPADCALL |i|
                                             (QREFELT $ 37)))
                                           (QREFELT $ 127))
                                          |testList| (QREFELT $ 128))
                                         (COND
                                           ((NULL
                                             (|SOLVETRA;testkernel|
                                              (|SPADfirst|
                                               (SPADCALL
                                                (|SPADfirst|
                                                 (SPADCALL |i|
                                                  (QREFELT $ 37)))
                                                (QREFELT $ 83)))
                                              Z $))
                                            (PROGN
                                              (LETT #1# 'NIL . #2#)
                                              (GO #1#)))))
                                        ('T
                                         (PROGN
                                           (LETT #1# 'NIL . #2#)
                                           (GO #1#))))))
                           (LETT #0# (CDR #0#) . #2#) (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 $ 146) (SPADCALL |l| (QREFELT $ 148))
         (QREFELT $ 152)))
    ('T (|error| "This should never happen")))) 

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

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

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

(DEFUN |SOLVETRA;smp2Poly!1| (|#1| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 122)) (QREFELT $ 192))) 

(DEFUN |SOLVETRA;smp2Poly!0| (|#1| $$)
  (|SOLVETRA;ker2Poly| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

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

(DEFUN |SOLVETRA;makeREpol| (|pol| $)
  (PROG (|lvar| #0=#:G2154 |v| #1=#:G2155 |lval|)
    (RETURN
      (SEQ (LETT |lvar| (SPADCALL |pol| (QREFELT $ 200))
                 . #2=(|SOLVETRA;makeREpol|))
           (LETT |lval|
                 (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |v| NIL . #2#) (LETT #1# |lvar| . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |v| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (SPADCALL |v| (QREFELT $ 34))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (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 $ 99))) 

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

(DEFUN |SOLVETRA;solve1Sys| (|plist| |lvar| $)
  (PROG (|rplist| |rlvar| |v| #0=#:G2169 |p| #1=#:G2168 |sol|
            #2=#:G2170 #3=#:G2164 #4=#:G2162 #5=#:G2163 |sols|)
    (RETURN
      (SEQ (LETT |rplist| (REVERSE |plist|)
                 . #6=(|SOLVETRA;solve1Sys|))
           (LETT |rlvar| (REVERSE |lvar|) . #6#)
           (LETT |sols| (SPADCALL NIL (QREFELT $ 207)) . #6#)
           (SEQ (LETT |v| NIL . #6#) (LETT #0# |rlvar| . #6#)
                (LETT |p| NIL . #6#) (LETT #1# |rplist| . #6#) G190
                (COND
                  ((OR (ATOM #1#)
                       (PROGN (LETT |p| (CAR #1#) . #6#) NIL)
                       (ATOM #0#)
                       (PROGN (LETT |v| (CAR #0#) . #6#) NIL))
                   #7=(GO G191)))
                (SEQ (EXIT (LETT |sols|
                                 (PROGN
                                   (LETT #5# NIL . #6#)
                                   (SEQ (LETT |sol| NIL . #6#)
                                    (LETT #2# |sols| . #6#) G190
                                    (COND
                                      ((OR (ATOM #2#)
                                        (PROGN
                                          (LETT |sol| (CAR #2#) . #6#)
                                          NIL))
                                       #7#))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                        (LETT #3#
                                         (|SOLVETRA;solve1Pol| |p| |v|
                                          |sol| $) . #6#)
                                        (COND
                                          (#5#
                                           (LETT #4#
                                            (APPEND #4# #3#) . #6#))
                                          ('T
                                           (PROGN
                                             (LETT #4# #3# . #6#)
                                             (LETT #5# 'T . #6#)))))))
                                    (LETT #2# (CDR #2#) . #6#)
                                    #8=(GO G190) G191 (EXIT NIL))
                                   (COND (#5# #4#) ('T NIL))) . #6#)))
                (LETT #1#
                      (PROG1 (CDR #1#) (LETT #0# (CDR #0#) . #6#)) . #6#)
                #8# G191 (EXIT NIL))
           (EXIT |sols|))))) 

(DEFUN |SOLVETRA;solveList| (|lexpr| |lvar| $)
  (PROG (|ans1| #0=#:G2177 |expr| #1=#:G2178 |lfrac| |trianglist|
                #2=#:G2179 |plist| #3=#:G2180 |l|)
    (RETURN
      (SEQ (LETT |ans1| (|SOLVETRA;solveRetract| |lexpr| |lvar| $)
                 . #4=(|SOLVETRA;solveList|))
           (EXIT (COND
                   ((QEQCAR |ans1| 1)
                    (SEQ (LETT |lfrac|
                               (PROGN
                                 (LETT #0# NIL . #4#)
                                 (SEQ (LETT |expr| NIL . #4#)
                                      (LETT #1# |lexpr| . #4#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |expr|
                                             (CAR #1#) . #4#)
                                            NIL))
                                         #5=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (|SOLVETRA;makeFracPoly|
                                           |expr| |lvar| $)
                                          #0#) . #4#)))
                                      (LETT #1# (CDR #1#) . #4#)
                                      #6=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #4#)
                         (LETT |trianglist|
                               (SPADCALL |lfrac| |lvar|
                                   (QREFELT $ 211)) . #4#)
                         (LETT |l|
                               (PROGN
                                 (LETT #2# NIL . #4#)
                                 (SEQ (LETT |plist| NIL . #4#)
                                      (LETT #3# |trianglist| . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |plist|
                                             (CAR #3#) . #4#)
                                            NIL))
                                         #5#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (|SOLVETRA;solve1Sys| |plist|
                                           |lvar| $)
                                          #2#) . #4#)))
                                      (LETT #3# (CDR #3#) . #4#) #6#
                                      G191 (EXIT (NREVERSE0 #2#)))) . #4#)
                         (EXIT (SPADCALL (ELT $ 212) |l| NIL
                                   (QREFELT $ 215)))))
                   ('T (QCDR |ans1|)))))))) 

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

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

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

(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| 53 '"failed")
             (42 . |retractIfCan|) (|Union| (|Fraction| 53) '"failed")
             (47 . |retractIfCan|) (|Equation| $) (52 . |eval|)
             (58 . |new|) (62 . |coerce|) (67 . =) (|List| 39)
             (73 . |kernels|) (|Fraction| 45) (|Kernel| $)
             (78 . |univariate|) (|SparseUnivariatePolynomial| 8)
             (|Fraction| 41) (84 . |numer|) (|Factored| 45)
             (|SparseUnivariatePolynomial| $) (89 . |factorPolynomial|)
             (|Record| (|:| |factor| 41) (|:| |exponent| 53))
             (|List| 47) (|Factored| 41) (94 . |factors|) (|List| $)
             (99 . |zerosOf|) (|Integer|) (|List| 8) (105 . |elt|)
             (111 . =) (|SparseMultivariatePolynomial| 6 39)
             (117 . |numer|) (122 . |coerce|) (|Kernel| 8)
             (127 . |kernel|) (|AlgebraicManipulations| 6 8)
             (132 . |rootSimp|) (|Factored| 65)
             (|SparseMultivariatePolynomial| 6 60)
             (|MultivariateFactorize| 60 (|IndexedExponents| 60) 6 65)
             (137 . |factor|)
             (|Record| (|:| |factor| 65) (|:| |exponent| 53))
             (|List| 68) (142 . |factors|) (147 . |One|)
             (|SparseUnivariatePolynomial| 13) (151 . |One|)
             (155 . |One|) (159 . |One|) (163 . |One|) (167 . |One|)
             (|String|) (171 . |coerce|)
             (|Record| (|:| |var| 39) (|:| |exponent| 53))
             (|Union| 80 '"failed") (176 . |isExpt|) (182 . |argument|)
             (187 . *) (193 . |log|)
             (|Union| (|Fraction| (|Polynomial| 6)) '"failed")
             (198 . |retractIfCan|) (|List| 18)
             (|List| (|Fraction| (|Polynomial| 6)))
             (|RadicalSolvePackage| 6) (203 . |radicalSolve|)
             (|TranscendentalManipulations| 6 8) (209 . |simplify|)
             (|ElementaryFunctionStructurePackage| 6 8)
             (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| 51 '"failed") (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| 144) (437 . |interval|) (|Complex| 144)
             (442 . |convert|) (|Complex| 145) (|Mapping| 145 144)
             (|ComplexFunctions2| 144 145) (447 . |map|) (453 . |asin|)
             (458 . |acos|) (463 . |atan|) (468 . |acot|)
             (473 . |asec|) (478 . |acsc|) (483 . |asinh|)
             (488 . |acosh|) (493 . |atanh|) (498 . |acoth|)
             (503 . |asech|) (508 . |acsch|) (513 . |cot|)
             (518 . |sin|) (523 . |cos|) (528 . |sec|) (533 . |csc|)
             (538 . |sinh|) (543 . |cosh|) (548 . |tanh|)
             (553 . |coth|) (558 . |sech|) (563 . |csch|)
             (|Expression| 149) (|Mapping| 149 6)
             (|ExpressionFunctions2| 6 149) (568 . |map|)
             (|Union| 149 '"failed") (574 . |retractIfCan|)
             (579 . |exp|) (584 . |imag|) (589 . |pi|) (593 . -)
             (598 . |inf|) (603 . <) (609 . |sup|) (614 . |normalize|)
             (|Polynomial| 8) (619 . |coerce|) (624 . |coerce|)
             (|Mapping| 190 60) (|Mapping| 190 6)
             (|PolynomialCategoryLifting| (|IndexedExponents| 60) 60 6
                 65 190)
             (629 . |map|) (636 . |denom|) (|Fraction| 190) (641 . /)
             (647 . |variables|) (652 . |eval|) (659 . |ground|)
             (664 . |numer|) (669 . |denom|) (|List| 31) (674 . |eval|)
             (680 . |list|) (|List| (|List| 190)) (|List| 198)
             (|SystemSolvePackage| 8) (685 . |triangularSystems|)
             (691 . |append|) (|Mapping| 88 88 88) (|List| 88)
             (697 . |reduce|) |SOLVETRA;solve;LLL;34|)
          '#(|solve| 704) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 216
                                '(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 0 19 0 33 1 8
                                  0 19 34 2 16 0 8 8 35 1 8 36 0 37 2 8
                                  38 0 39 40 1 42 41 0 43 1 8 44 45 46
                                  1 49 48 0 50 2 8 51 45 19 52 2 54 8 0
                                  53 55 2 8 7 0 0 56 1 8 57 0 58 1 8 0
                                  57 59 1 60 0 19 61 1 62 8 8 63 1 66
                                  64 65 67 1 64 69 0 70 0 42 0 71 0 72
                                  0 73 0 41 0 74 0 49 0 75 0 65 0 76 0
                                  64 0 77 1 19 0 78 79 2 8 81 0 19 82 1
                                  60 54 0 83 2 8 0 53 0 84 1 8 0 0 85 1
                                  8 86 0 87 2 90 88 89 10 91 1 92 8 8
                                  93 2 94 8 8 19 95 2 96 8 8 19 97 1 8
                                  0 53 98 2 8 0 0 0 99 1 8 0 0 100 2 8
                                  0 101 0 102 2 8 0 0 101 103 1 8 0 0
                                  104 3 105 42 42 42 42 106 2 42 7 0 0
                                  107 2 41 8 108 8 109 1 8 0 39 110 1
                                  54 8 0 111 1 8 53 0 112 2 41 0 8 113
                                  114 2 41 0 0 0 115 2 41 8 0 0 116 2 8
                                  7 0 19 117 1 8 118 0 119 1 65 6 0 120
                                  1 6 0 51 121 1 8 0 6 122 0 8 0 123 2
                                  8 0 0 0 124 2 8 0 0 0 125 0 6 0 126 1
                                  60 19 0 127 2 10 7 19 0 128 1 8 118 0
                                  129 2 54 0 8 0 130 0 53 0 131 2 8 7 0
                                  19 132 2 8 0 0 0 133 0 134 0 135 0 13
                                  0 136 1 65 0 0 137 2 134 138 8 0 139
                                  3 134 8 0 8 8 140 2 134 8 0 8 141 1
                                  65 0 0 142 1 134 54 0 143 1 145 0 144
                                  146 1 6 147 0 148 2 151 149 150 147
                                  152 1 8 0 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 2 178 176
                                  177 8 179 1 176 180 0 181 1 8 0 0 182
                                  1 149 145 0 183 0 144 0 184 1 144 0 0
                                  185 1 145 144 0 186 2 144 7 0 0 187 1
                                  145 144 0 188 1 94 8 8 189 1 190 0 19
                                  191 1 190 0 8 192 3 195 190 193 194
                                  65 196 1 8 57 0 197 2 198 0 190 190
                                  199 1 190 10 0 200 3 190 0 0 10 54
                                  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 2 210 208 209 10 211 2 88 0 0
                                  0 212 3 214 88 213 0 88 215 1 0 18 16
                                  25 1 0 18 8 21 2 0 18 16 19 26 2 0 88
                                  18 10 216 2 0 18 8 19 20)))))
          '|lookupComplete|)) 
