
(/VERSIONCHECK 2) 

(DEFUN |FSINT;K2KG| (|k| $)
  (SPADCALL
      (SPADCALL
          (SPADCALL (|SPADfirst| (SPADCALL |k| (QREFELT $ 21)))
              (QREFELT $ 24))
          (QREFELT $ 25))
      (QREFELT $ 27))) 

(DEFUN |FSINT;tan2temp| (|k| $)
  (SPADCALL (QREFELT $ 18) (SPADCALL |k| (QREFELT $ 21))
      (SPADCALL |k| (QREFELT $ 28)) (QREFELT $ 29))) 

(DEFUN |FSINT;trans?| (|f| $)
  (SPADCALL (CONS #'|FSINT;trans?!0| $) (SPADCALL |f| (QREFELT $ 34))
      (QREFELT $ 36))) 

(DEFUN |FSINT;trans?!0| (|#1| $)
  (COND
    ((OR (SPADCALL |#1| (SPADCALL "log" (QREFELT $ 10)) (QREFELT $ 31))
         (SPADCALL |#1| (SPADCALL "exp" (QREFELT $ 10)) (QREFELT $ 31)))
     (|spadConstant| $ 32))
    ('T
     (SPADCALL |#1| (SPADCALL "atan" (QREFELT $ 10)) (QREFELT $ 31))))) 

(DEFUN |FSINT;mkPrimh| (|f| |x| |h| |comp| $)
  (PROG (|g|)
    (RETURN
      (SEQ (LETT |f| (SPADCALL |f| (QREFELT $ 38))
                 . #0=(|FSINT;mkPrimh|))
           (COND
             (|comp| (LETT |f| (SPADCALL |f| (QREFELT $ 40)) . #0#)))
           (LETT |g| (SPADCALL |f| |x| (QREFELT $ 42)) . #0#)
           (COND
             (|h| (COND
                    ((|FSINT;trans?| |g| $)
                     (EXIT (SPADCALL |g| (QREFELT $ 43)))))))
           (EXIT |g|))))) 

(DEFUN |FSINT;rinteg| (|i| |f| |x| |h| |comp| $)
  (PROG (#0=#:G1843 #1=#:G1844 |l|)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL |i| (QREFELT $ 45)))
              (CONS 0 (SPADCALL |f| |x| (QREFELT $ 46))))
             ('T
              (COND
                ((NULL (CDR (LETT |l|
                                  (PROGN
                                    (LETT #0# NIL
                                     . #2=(|FSINT;rinteg|))
                                    (SEQ (LETT |f| NIL . #2#)
                                     (LETT #1#
                                      (SPADCALL |i| (QREFELT $ 48)) . #2#)
                                     G190
                                     (COND
                                       ((OR (ATOM #1#)
                                         (PROGN
                                           (LETT |f| (CAR #1#) . #2#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT #0#
                                        (CONS
                                         (|FSINT;mkPrimh| |f| |x| |h|
                                          |comp| $)
                                         #0#) . #2#)))
                                     (LETT #1# (CDR #1#) . #2#)
                                     (GO G190) G191
                                     (EXIT (NREVERSE0 #0#)))) . #2#)))
                 (CONS 0 (|SPADfirst| |l|)))
                ('T (CONS 1 |l|))))))))) 

(DEFUN |FSINT;halfangle| (|a| $)
  (SEQ (LETT |a| (SPADCALL 2 |a| (QREFELT $ 50)) |FSINT;halfangle|)
       (EXIT (SPADCALL
                 (SPADCALL (|spadConstant| $ 52)
                     (SPADCALL |a| (QREFELT $ 53)) (QREFELT $ 54))
                 (SPADCALL (|spadConstant| $ 52)
                     (SPADCALL |a| (QREFELT $ 53)) (QREFELT $ 55))
                 (QREFELT $ 56))))) 

(DEFUN |FSINT;Khalf| (|k| $)
  (PROG (|a|)
    (RETURN
      (SEQ (LETT |a|
                 (SPADCALL 2
                     (|SPADfirst| (SPADCALL |k| (QREFELT $ 21)))
                     (QREFELT $ 50))
                 |FSINT;Khalf|)
           (EXIT (SPADCALL (SPADCALL |a| (QREFELT $ 57))
                     (SPADCALL (|spadConstant| $ 52)
                         (SPADCALL |a| (QREFELT $ 53)) (QREFELT $ 55))
                     (QREFELT $ 56))))))) 

(DEFUN |FSINT;postSubst| (|f| |lv| |lk| |comp| |ltan| |x| $)
  (PROG (#0=#:G1868 |v| #1=#:G1867 |u| |kk| #2=#:G1869 #3=#:G1870
            |ltemp| #4=#:G1871 #5=#:G1872 #6=#:G1873 |k| #7=#:G1874)
    (RETURN
      (SEQ (SEQ (LETT |k| NIL . #8=(|FSINT;postSubst|))
                (LETT #0# |lk| . #8#) (LETT |v| NIL . #8#)
                (LETT #1# |lv| . #8#) G190
                (COND
                  ((OR (ATOM #1#)
                       (PROGN (LETT |v| (CAR #1#) . #8#) NIL)
                       (ATOM #0#)
                       (PROGN (LETT |k| (CAR #0#) . #8#) NIL))
                   #9=(GO G191)))
                (SEQ (LETT |u| (SPADCALL |v| (QREFELT $ 59)) . #8#)
                     (EXIT (COND
                             ((QEQCAR |u| 0)
                              (SEQ (COND
                                     ((SPADCALL
                                       (SPADCALL
                                        (LETT |kk| (QCDR |u|) . #8#)
                                        (QREFELT $ 60))
                                       (QREFELT $ 14) (QREFELT $ 61))
                                      (LETT |f|
                                       (SPADCALL
                                        (SPADCALL |f| |kk|
                                         (SPADCALL |kk| (QREFELT $ 63))
                                         (QREFELT $ 66))
                                        (SPADCALL |kk| (QREFELT $ 67))
                                        (QREFELT $ 68)) . #8#)))
                                   (EXIT
                                    (LETT |f|
                                     (SPADCALL |f| (LIST (QCDR |u|))
                                      (LIST
                                       (SPADCALL |k| (QREFELT $ 67)))
                                      (QREFELT $ 71)) . #8#)))))))
                (LETT #1#
                      (PROG1 (CDR #1#) (LETT #0# (CDR #0#) . #8#)) . #8#)
                #10=(GO G190) G191 (EXIT NIL))
           (COND
             ((NULL |comp|)
              (COND
                ((NULL (NULL |ltan|))
                 (SEQ (LETT |ltemp|
                            (PROGN
                              (LETT #2# NIL . #8#)
                              (SEQ (LETT |k| NIL . #8#)
                                   (LETT #3# |ltan| . #8#) G190
                                   (COND
                                     ((OR (ATOM #3#)
                                       (PROGN
                                         (LETT |k| (CAR #3#) . #8#)
                                         NIL))
                                      #9#))
                                   (SEQ
                                    (EXIT
                                     (LETT #2#
                                      (CONS (|FSINT;tan2temp| |k| $)
                                       #2#) . #8#)))
                                   (LETT #3# (CDR #3#) . #8#) #10# G191
                                   (EXIT (NREVERSE0 #2#)))) . #8#)
                      (LETT |f|
                            (SPADCALL |f| |ltan|
                                (PROGN
                                  (LETT #4# NIL . #8#)
                                  (SEQ (LETT |k| NIL . #8#)
                                       (LETT #5# |ltemp| . #8#) G190
                                       (COND
                                         ((OR (ATOM #5#)
                                           (PROGN
                                             (LETT |k| (CAR #5#) . #8#)
                                             NIL))
                                          #9#))
                                       (SEQ
                                        (EXIT
                                         (LETT #4#
                                          (CONS
                                           (SPADCALL |k|
                                            (QREFELT $ 67))
                                           #4#) . #8#)))
                                       (LETT #5# (CDR #5#) . #8#) #10#
                                       G191 (EXIT (NREVERSE0 #4#))))
                                (QREFELT $ 71)) . #8#)
                      (LETT |f|
                            (SPADCALL |f|
                                (SPADCALL "%temptan" (QREFELT $ 10)) 2
                                (CONS (|function| |FSINT;halfangle|) $)
                                (QREFELT $ 73)) . #8#)
                      (EXIT (LETT |f|
                                  (SPADCALL |f| |ltemp|
                                      (PROGN
                                        (LETT #6# NIL . #8#)
                                        (SEQ (LETT |k| NIL . #8#)
                                         (LETT #7# |ltemp| . #8#) G190
                                         (COND
                                           ((OR (ATOM #7#)
                                             (PROGN
                                               (LETT |k|
                                                (CAR #7#) . #8#)
                                               NIL))
                                            #9#))
                                         (SEQ
                                          (EXIT
                                           (LETT #6#
                                            (CONS (|FSINT;Khalf| |k| $)
                                             #6#) . #8#)))
                                         (LETT #7# (CDR #7#) . #8#)
                                         #10# G191
                                         (EXIT (NREVERSE0 #6#))))
                                      (QREFELT $ 71)) . #8#)))))))
           (EXIT (SPADCALL |f| |x| (QREFELT $ 74))))))) 

(DEFUN |FSINT;goComplex?| (|rt| |l| |ltan| $)
  (COND ((NULL |ltan|) |rt|) ((NULL (CDR (CDR |l|))) 'NIL) ('T 'T))) 

(DEFUN |FSINT;integrate;FSU;10| (|f| |x| $)
  (PROG (#0=#:G1897 #1=#:G1898 |tf| |ltf| |ht| |rec| |g| #2=#:G1899
            #3=#:G1900 |tg| |rtg| |el| |comp| #4=#:G1901 |k| #5=#:G1902
            |i| |ltg| |u| #6=#:G1903 |h| #7=#:G1904)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL |f| (QREFELT $ 75)))
              (CONS 0 (SPADCALL |f| |x| (QREFELT $ 77))))
             ('T
              (SEQ (LETT |f|
                         (SPADCALL |f| (SPADCALL |x| (QREFELT $ 78))
                             (QREFELT $ 79))
                         . #8=(|FSINT;integrate;FSU;10|))
                   (LETT |tf|
                         (PROGN
                           (LETT #0# NIL . #8#)
                           (SEQ (LETT |k| NIL . #8#)
                                (LETT #1#
                                      (SPADCALL |f| (QREFELT $ 80)) . #8#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |k| (CAR #1#) . #8#)
                                      NIL))
                                   #9=(GO G191)))
                                (SEQ (EXIT
                                      (COND
                                        ((SPADCALL |x|
                                          (SPADCALL
                                           (SPADCALL |k|
                                            (QREFELT $ 67))
                                           (QREFELT $ 82))
                                          (QREFELT $ 83))
                                         (LETT #0#
                                          (CONS |k| #0#) . #8#)))))
                                (LETT #1# (CDR #1#) . #8#)
                                #10=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #8#)
                   (LETT |ltf|
                         (SPADCALL
                             (CONS #'|FSINT;integrate;FSU;10!0| $) |tf|
                             (QREFELT $ 86)) . #8#)
                   (LETT |ht|
                         (SPADCALL
                             (CONS #'|FSINT;integrate;FSU;10!1|
                                   (VECTOR (QREFELT $ 12) $))
                             |tf| (QREFELT $ 87)) . #8#)
                   (LETT |rec|
                         (SPADCALL (SPADCALL |f| |x| (QREFELT $ 89))
                             |x| (QREFELT $ 91)) . #8#)
                   (LETT |g|
                         (SPADCALL (QVELT |rec| 0) (QREFELT $ 93)) . #8#)
                   (LETT |tg|
                         (PROGN
                           (LETT #2# NIL . #8#)
                           (SEQ (LETT |k| NIL . #8#)
                                (LETT #3#
                                      (SPADCALL |g| (QREFELT $ 80)) . #8#)
                                G190
                                (COND
                                  ((OR (ATOM #3#)
                                    (PROGN
                                      (LETT |k| (CAR #3#) . #8#)
                                      NIL))
                                   #9#))
                                (SEQ (EXIT
                                      (COND
                                        ((SPADCALL |x|
                                          (SPADCALL
                                           (SPADCALL |k|
                                            (QREFELT $ 67))
                                           (QREFELT $ 82))
                                          (QREFELT $ 83))
                                         (LETT #2#
                                          (CONS |k| #2#) . #8#)))))
                                (LETT #3# (CDR #3#) . #8#) #10# G191
                                (EXIT (NREVERSE0 #2#)))) . #8#)
                   (LETT |ltg|
                         (SPADCALL
                             (CONS #'|FSINT;integrate;FSU;10!2| $) |tg|
                             (QREFELT $ 86)) . #8#)
                   (LETT |rtg|
                         (SPADCALL
                             (CONS #'|FSINT;integrate;FSU;10!3|
                                   (VECTOR (QREFELT $ 11) $))
                             |tg| (QREFELT $ 87)) . #8#)
                   (LETT |el|
                         (SPADCALL
                             (CONS #'|FSINT;integrate;FSU;10!4|
                                   (VECTOR (QREFELT $ 13) $))
                             |tg| (QREFELT $ 87)) . #8#)
                   (SEQ (LETT |comp|
                              (|FSINT;goComplex?| |rtg| |tg| |ltg| $) . #8#)
                        (EXIT (COND
                                (|comp| (LETT |i|
                                         (SPADCALL (ELT $ 94)
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |g|
                                             (QREFELT $ 24))
                                            (PROGN
                                              (LETT #4# NIL . #8#)
                                              (SEQ (LETT |k| NIL . #8#)
                                               (LETT #5# |tf| . #8#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #5#)
                                                   (PROGN
                                                     (LETT |k|
                                                      (CAR #5#) . #8#)
                                                     NIL))
                                                  #9#))
                                               (SEQ
                                                (EXIT
                                                 (COND
                                                   ((COND
                                                      ((SPADCALL |k|
                                                        (SPADCALL "tan"
                                                         (QREFELT $ 10))
                                                        (QREFELT $ 95))
                                                       'T)
                                                      ('T
                                                       (SPADCALL |k|
                                                        (SPADCALL "cot"
                                                         (QREFELT $ 10))
                                                        (QREFELT $ 95))))
                                                    (LETT #4#
                                                     (CONS
                                                      (|FSINT;K2KG| |k|
                                                       $)
                                                      #4#) . #8#)))))
                                               (LETT #5#
                                                (CDR #5#) . #8#)
                                               #10# G191
                                               (EXIT (NREVERSE0 #4#))))
                                            (LIST |x|) (QREFELT $ 97))
                                           |x| (QREFELT $ 100))
                                          (QREFELT $ 103)) . #8#))
                                (#11='T
                                 (LETT |i|
                                       (SPADCALL |g| |x|
                                        (QREFELT $ 105)) . #8#)))))
                   (LETT |ltg|
                         (SPADCALL |ltg| |ltf| (QREFELT $ 106)) . #8#)
                   (LETT |u|
                         (|FSINT;rinteg| |i| |f| |x|
                             (COND (|el| |ht|) (#11# 'NIL)) |comp| $) . #8#)
                   (EXIT (COND
                           ((QEQCAR |u| 0)
                            (CONS 0
                                  (|FSINT;postSubst| (QCDR |u|)
                                      (QVELT |rec| 2) (QVELT |rec| 1)
                                      |comp| |ltg| |x| $)))
                           (#11#
                            (CONS 1
                                  (PROGN
                                    (LETT #6# NIL . #8#)
                                    (SEQ (LETT |h| NIL . #8#)
                                     (LETT #7# (QCDR |u|) . #8#) G190
                                     (COND
                                       ((OR (ATOM #7#)
                                         (PROGN
                                           (LETT |h| (CAR #7#) . #8#)
                                           NIL))
                                        #9#))
                                     (SEQ
                                      (EXIT
                                       (LETT #6#
                                        (CONS
                                         (|FSINT;postSubst| |h|
                                          (QVELT |rec| 2)
                                          (QVELT |rec| 1) |comp| |ltg|
                                          |x| $)
                                         #6#) . #8#)))
                                     (LETT #7# (CDR #7#) . #8#) #10#
                                     G191 (EXIT (NREVERSE0 #6#))))))))))))))) 

(DEFUN |FSINT;integrate;FSU;10!4| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |FSINT;integrate;FSU;10|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |#1| (QREFELT $ 60)) (QREFELT $$ 0)
            (QREFELT $ 61)))))) 

(DEFUN |FSINT;integrate;FSU;10!3| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |FSINT;integrate;FSU;10|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |#1| (QREFELT $ 60)) (QREFELT $$ 0)
            (QREFELT $ 61)))))) 

(DEFUN |FSINT;integrate;FSU;10!2| (|#1| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 60))
      (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 31))) 

(DEFUN |FSINT;integrate;FSU;10!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |FSINT;integrate;FSU;10|)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |#1| (QREFELT $ 60)) (QREFELT $$ 0)
            (QREFELT $ 61)))))) 

(DEFUN |FSINT;integrate;FSU;10!0| (|#1| $)
  (SPADCALL (SPADCALL |#1| (QREFELT $ 60))
      (SPADCALL "tan" (QREFELT $ 10)) (QREFELT $ 31))) 

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

(DEFUN |FunctionSpaceIntegration;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|FunctionSpaceIntegration|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|FunctionSpaceIntegration| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 109) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|FunctionSpaceIntegration|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 11 (SPADCALL "rtrig" (QREFELT $ 10)))
        (QSETREFV $ 12 (SPADCALL "htrig" (QREFELT $ 10)))
        (QSETREFV $ 13 (SPADCALL "elem" (QREFELT $ 10)))
        (QSETREFV $ 14 (SPADCALL "%alg" (QREFELT $ 10)))
        (QSETREFV $ 18
            (SPADCALL (SPADCALL "%temptan" (QREFELT $ 10)) 1
                (QREFELT $ 17)))
        $)))) 

(MAKEPROP '|FunctionSpaceIntegration| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|String|) (|Symbol|) (0 . |coerce|) 'RTRIG 'HTRIG 'ELEM
             'ALGOP (|NonNegativeInteger|) (|BasicOperator|)
             (5 . |operator|) '|optemp| (|List| 7) (|Kernel| 7)
             (11 . |argument|) (|Expression| (|Complex| 6))
             (|InnerTrigonometricManipulations| 6 7 22) (16 . F2FG)
             (21 . |tan|) (|Kernel| $) (26 . |retract|) (31 . |height|)
             (36 . |kernel|) (|Boolean|) (43 . |is?|) (49 . |true|)
             (|List| 16) (53 . |operators|) (|Mapping| 30 16)
             (58 . |any?|) (|TrigonometricManipulations| 6 7)
             (64 . |real|) (|TranscendentalManipulations| 6 7)
             (69 . |removeSinSq|) (|IntegrationTools| 6 7)
             (74 . |mkPrim|) (80 . |htrigs|) (|IntegrationResult| 7)
             (85 . |elem?|) (90 . |integral|)
             (|IntegrationResultToFunction| 6 7) (96 . |expand|)
             (|PositiveInteger|) (101 . *) (107 . |One|) (111 . |One|)
             (115 . |cos|) (120 . -) (126 . +) (132 . /) (138 . |sin|)
             (|Union| 26 '"failed") (143 . |retractIfCan|)
             (148 . |operator|) (153 . |has?|)
             (|SparseUnivariatePolynomial| $) (159 . |minPoly|)
             (|SparseUnivariatePolynomial| 7)
             (|PolynomialCategoryQuotientFunctions|
                 (|IndexedExponents| 20) 20 6
                 (|SparseMultivariatePolynomial| 6 20) 7)
             (164 . |univariate|) (171 . |coerce|) (176 . |elt|)
             (|List| 26) (|List| $) (182 . |eval|) (|Mapping| $ $)
             (189 . |eval|) (197 . |removeConstantTerm|)
             (203 . |real?|) (|FunctionSpaceComplexIntegration| 6 7)
             (208 . |complexIntegrate|) (214 . |coerce|)
             (219 . |distribute|) (225 . |tower|) (|List| 9)
             (230 . |variables|) (235 . |member?|) (|Mapping| 30 20)
             (|List| 20) (241 . |select|) (247 . |any?|)
             (|ElementaryFunctionStructurePackage| 6 7)
             (253 . |realElementary|)
             (|Record| (|:| |func| 7) (|:| |kers| 85) (|:| |vals| 19))
             (259 . |rischNormalize|) (|AlgebraicManipulations| 6 7)
             (265 . |rootSimp|) (270 . FG2F) (275 . |is?|)
             (|List| (|Kernel| 22)) (281 . |trigs2explogs|)
             (|IntegrationResult| 22)
             (|ElementaryIntegration| (|Complex| 6) 22)
             (288 . |lfintegrate|) (|Mapping| 7 22)
             (|IntegrationResultFunctions2| 22 7) (294 . |map|)
             (|ElementaryIntegration| 6 7) (300 . |lfintegrate|)
             (306 . |setDifference|) (|Union| 7 19)
             |FSINT;integrate;FSU;10|)
          '#(|integrate| 312) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 108
                                '(1 9 0 8 10 2 16 0 9 15 17 1 20 19 0
                                  21 1 23 22 7 24 1 22 0 0 25 1 22 26 0
                                  27 1 20 15 0 28 3 20 0 16 19 15 29 2
                                  16 30 0 9 31 0 30 0 32 1 7 33 0 34 2
                                  33 30 35 0 36 1 37 7 7 38 1 39 7 7 40
                                  2 41 7 7 9 42 1 39 7 7 43 1 44 30 0
                                  45 2 7 0 0 9 46 1 47 19 44 48 2 7 0
                                  49 0 50 0 6 0 51 0 7 0 52 1 7 0 0 53
                                  2 7 0 0 0 54 2 7 0 0 0 55 2 7 0 0 0
                                  56 1 7 0 0 57 1 7 58 0 59 1 20 16 0
                                  60 2 16 30 0 9 61 1 7 62 26 63 3 65
                                  64 7 20 64 66 1 7 0 26 67 2 64 7 0 7
                                  68 3 7 0 0 69 70 71 4 7 0 0 9 15 72
                                  73 2 41 7 7 9 74 1 37 30 7 75 2 76 7
                                  7 9 77 1 7 0 9 78 2 7 0 0 0 79 1 7 69
                                  0 80 1 7 81 0 82 2 81 30 9 0 83 2 85
                                  0 84 0 86 2 85 30 84 0 87 2 88 7 7 9
                                  89 2 88 90 7 9 91 1 92 7 7 93 1 23 7
                                  22 94 2 20 30 0 9 95 3 23 22 22 96 81
                                  97 2 99 98 22 9 100 2 102 44 101 98
                                  103 2 104 44 7 9 105 2 85 0 0 0 106 2
                                  0 107 7 9 108)))))
          '|lookupComplete|)) 
