
(/VERSIONCHECK 2) 

(DEFUN |RDETR;polyRDE;3UPIMU;1| (|aa| |bb| |cc| |d| |derivation| $)
  (PROG (|uansw| |answ| |b0?| |n| |baseCase?| |dt| |u|)
    (RETURN
     (SEQ
      (LETT |u| (|RDETR;SPDE| |aa| |bb| |cc| |d| |derivation| $)
            . #1=(|RDETR;polyRDE;3UPIMU;1|))
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 0 (CONS (|spadConstant| $ 9) 'T)))
             ((SPADCALL (QVELT (QCDR |u|) 1) (QREFELT $ 11))
              (CONS 0 (CONS (QVELT (QCDR |u|) 4) 'NIL)))
             (#2='T
              (SEQ
               (LETT |baseCase?|
                     (SPADCALL
                      (LETT |dt|
                            (SPADCALL
                             (SPADCALL (|spadConstant| $ 12) 1 (QREFELT $ 15))
                             |derivation|)
                            . #1#)
                      (|spadConstant| $ 13) (QREFELT $ 16))
                     . #1#)
               (LETT |n| (- (SPADCALL |dt| (QREFELT $ 17)) 1) . #1#)
               (LETT |b0?| (SPADCALL (QVELT (QCDR |u|) 0) (QREFELT $ 11))
                     . #1#)
               (COND
                ((SPADCALL |b0?| (QREFELT $ 18))
                 (COND
                  ((OR |baseCase?|
                       (< (MAX 0 |n|)
                          (SPADCALL (QVELT (QCDR |u|) 0) (QREFELT $ 17))))
                   (EXIT
                    (SEQ
                     (LETT |answ|
                           (|RDETR;SPDEnocancel1| (QVELT (QCDR |u|) 0)
                            (QVELT (QCDR |u|) 1) (QVELT (QCDR |u|) 2)
                            |derivation| $)
                           . #1#)
                     (EXIT
                      (CONS 0
                            (CONS
                             (SPADCALL
                              (SPADCALL (QVELT (QCDR |u|) 3) (QCAR |answ|)
                                        (QREFELT $ 19))
                              (QVELT (QCDR |u|) 4) (QREFELT $ 20))
                             (QCDR |answ|))))))))))
               (COND
                ((< 0 |n|)
                 (COND
                  ((OR |b0?|
                       (< (SPADCALL (QVELT (QCDR |u|) 0) (QREFELT $ 17)) |n|))
                   (EXIT
                    (SEQ
                     (LETT |uansw|
                           (|RDETR;SPDEnocancel2| (QVELT (QCDR |u|) 0)
                            (QVELT (QCDR |u|) 1) (QVELT (QCDR |u|) 2) |n|
                            (SPADCALL |dt| (QREFELT $ 23)) |derivation| $)
                           . #1#)
                     (EXIT
                      (COND
                       ((QEQCAR |uansw| 0)
                        (CONS 0
                              (CONS
                               (SPADCALL
                                (SPADCALL (QVELT (QCDR |u|) 3)
                                          (QCAR (CDR |uansw|)) (QREFELT $ 19))
                                (QVELT (QCDR |u|) 4) (QREFELT $ 20))
                               (QCDR (CDR |uansw|)))))
                       (#2#
                        (CONS 1
                              (VECTOR (QVELT (CDR |uansw|) 0)
                                      (QVELT (CDR |uansw|) 1)
                                      (QVELT (CDR |uansw|) 2)
                                      (SPADCALL (QVELT (QCDR |u|) 3)
                                                (QVELT (CDR |uansw|) 3)
                                                (QREFELT $ 19))
                                      (SPADCALL
                                       (SPADCALL (QVELT (QCDR |u|) 3)
                                                 (QVELT (CDR |uansw|) 4)
                                                 (QREFELT $ 19))
                                       (QVELT (QCDR |u|) 4)
                                       (QREFELT $ 20)))))))))))))
               (COND
                (|b0?|
                 (COND
                  (|baseCase?|
                   (EXIT
                    (COND
                     ((NULL
                       (< (SPADCALL (QVELT (QCDR |u|) 1) (QREFELT $ 17))
                          (QVELT (QCDR |u|) 2)))
                      (CONS 0 (CONS (|spadConstant| $ 9) 'T)))
                     ('T
                      (CONS 0
                            (CONS
                             (SPADCALL
                              (SPADCALL (QVELT (QCDR |u|) 3)
                                        (SPADCALL (QVELT (QCDR |u|) 1)
                                                  (QREFELT $ 24))
                                        (QREFELT $ 19))
                              (QVELT (QCDR |u|) 4) (QREFELT $ 20))
                             'NIL)))))))))
               (EXIT (CONS 1 (QCDR |u|))))))))))) 

(DEFUN |RDETR;SPDE| (|aa| |bb| |cc| |d| |derivation| $)
  (PROG (|v| |r| |qr| |bc| #1=#:G722 |a1| |ra| #2=#:G707 |u| |g|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |cc| (QREFELT $ 11))
        (CONS 0
              (VECTOR (|spadConstant| $ 9) (|spadConstant| $ 9) 0
                      (|spadConstant| $ 9) (|spadConstant| $ 9))))
       ((< |d| 0) (CONS 1 "failed"))
       (#3='T
        (SEQ
         (LETT |u|
               (SPADCALL |cc|
                         (LETT |g| (SPADCALL |aa| |bb| (QREFELT $ 31))
                               . #4=(|RDETR;SPDE|))
                         (QREFELT $ 33))
               . #4#)
         (EXIT
          (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
                (#3#
                 (SEQ
                  (LETT |aa|
                        (PROG2
                            (LETT #2# (SPADCALL |aa| |g| (QREFELT $ 33)) . #4#)
                            (QCDR #2#)
                          (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                        . #4#)
                  (LETT |bb|
                        (PROG2
                            (LETT #2# (SPADCALL |bb| |g| (QREFELT $ 33)) . #4#)
                            (QCDR #2#)
                          (|check-union| (QEQCAR #2# 0) (QREFELT $ 7) #2#))
                        . #4#)
                  (LETT |cc| (QCDR |u|) . #4#)
                  (LETT |ra| (SPADCALL |aa| (QREFELT $ 35)) . #4#)
                  (EXIT
                   (COND
                    ((QEQCAR |ra| 0)
                     (SEQ
                      (LETT |a1| (SPADCALL (QCDR |ra|) (QREFELT $ 36)) . #4#)
                      (EXIT
                       (CONS 0
                             (VECTOR (SPADCALL |a1| |bb| (QREFELT $ 37))
                                     (SPADCALL |a1| |cc| (QREFELT $ 37)) |d|
                                     (|spadConstant| $ 13)
                                     (|spadConstant| $ 9))))))
                    (#3#
                     (SEQ
                      (LETT |bc|
                            (PROG2
                                (LETT #1#
                                      (SPADCALL |bb| |aa| |cc| (QREFELT $ 40))
                                      . #4#)
                                (QCDR #1#)
                              (|check-union| (QEQCAR #1# 0)
                                             (|Record|
                                              (|:| |coef1| (QREFELT $ 7))
                                              (|:| |coef2| (QREFELT $ 7)))
                                             #1#))
                            . #4#)
                      (LETT |qr| (SPADCALL (QCAR |bc|) |aa| (QREFELT $ 42))
                            . #4#)
                      (LETT |r| (QCDR |qr|) . #4#)
                      (LETT |v|
                            (|RDETR;SPDE| |aa|
                             (SPADCALL |bb| (SPADCALL |aa| |derivation|)
                                       (QREFELT $ 20))
                             (SPADCALL
                              (SPADCALL (QCDR |bc|)
                                        (SPADCALL |bb| (QCAR |qr|)
                                                  (QREFELT $ 19))
                                        (QREFELT $ 20))
                              (SPADCALL |r| |derivation|) (QREFELT $ 43))
                             (- |d| (SPADCALL |aa| (QREFELT $ 17)))
                             |derivation| $)
                            . #4#)
                      (EXIT
                       (COND ((QEQCAR |v| 1) (CONS 1 "failed"))
                             (#3#
                              (CONS 0
                                    (VECTOR (QVELT (QCDR |v|) 0)
                                            (QVELT (QCDR |v|) 1)
                                            (QVELT (QCDR |v|) 2)
                                            (SPADCALL |aa| (QVELT (QCDR |v|) 3)
                                                      (QREFELT $ 19))
                                            (SPADCALL
                                             (SPADCALL |aa|
                                                       (QVELT (QCDR |v|) 4)
                                                       (QREFELT $ 19))
                                             |r|
                                             (QREFELT $ 20)))))))))))))))))))))) 

(DEFUN |RDETR;SPDEnocancel1| (|bb| |cc| |d| |derivation| $)
  (PROG (|q| |r| #1=#:G733 #2=#:G734 #3=#:G737 |n| |lb| |db|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |q| (|spadConstant| $ 9) . #4=(|RDETR;SPDEnocancel1|))
            (LETT |db| (SPADCALL |bb| (QREFELT $ 17)) . #4#)
            (LETT |lb| (SPADCALL |bb| (QREFELT $ 23)) . #4#)
            (SEQ G190
                 (COND
                  ((NULL
                    (COND
                     ((SPADCALL |cc| (|spadConstant| $ 9) (QREFELT $ 16)) 'NIL)
                     ('T 'T)))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (SEQ
                    (COND
                     ((< |d| 0)
                      (EXIT (PROGN (LETT #3# (CONS |q| 'T) . #4#) (GO #3#))))
                     ('T
                      (SEQ
                       (LETT |n| (- (SPADCALL |cc| (QREFELT $ 17)) |db|) . #4#)
                       (EXIT
                        (COND
                         ((OR (< |n| 0) (< |d| |n|))
                          (PROGN
                           (LETT #2#
                                 (PROGN
                                  (LETT #3# (CONS |q| 'T) . #4#)
                                  (GO #3#))
                                 . #4#)
                           (GO #2#))))))))
                    (LETT |r|
                          (SPADCALL
                           (SPADCALL (SPADCALL |cc| (QREFELT $ 23)) |lb|
                                     (QREFELT $ 44))
                           (PROG1 (LETT #1# |n| . #4#)
                             (|check-subtype| (>= #1# 0)
                                              '(|NonNegativeInteger|) #1#))
                           (QREFELT $ 15))
                          . #4#)
                    (LETT |cc|
                          (SPADCALL
                           (SPADCALL |cc| (SPADCALL |bb| |r| (QREFELT $ 19))
                                     (QREFELT $ 43))
                           (SPADCALL |r| |derivation|) (QREFELT $ 43))
                          . #4#)
                    (LETT |d| (- |n| 1) . #4#)
                    (EXIT (LETT |q| (SPADCALL |q| |r| (QREFELT $ 20)) . #4#))))
                  #2# (EXIT #2#))
                 NIL (GO G190) G191 (EXIT NIL))
            (EXIT (CONS |q| 'NIL))))
      #3# (EXIT #3#))))) 

(DEFUN |RDETR;SPDEnocancel2| (|bb| |cc| |d| |dtm1| |lt| |derivation| $)
  (PROG (|q| |r| #1=#:G752 |db| #2=#:G743 #3=#:G749 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |q| (|spadConstant| $ 9) . #4=(|RDETR;SPDEnocancel2|))
            (SEQ G190
                 (COND
                  ((NULL
                    (COND
                     ((SPADCALL |cc| (|spadConstant| $ 9) (QREFELT $ 16)) 'NIL)
                     ('T 'T)))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (SEQ
                    (COND
                     ((< |d| 0)
                      (EXIT
                       (PROGN
                        (LETT #1# (CONS 0 (CONS |q| 'T)) . #4#)
                        (GO #1#))))
                     ('T
                      (SEQ
                       (LETT |n| (- (SPADCALL |cc| (QREFELT $ 17)) |dtm1|)
                             . #4#)
                       (EXIT
                        (COND
                         ((OR (< |n| 0) (< |d| |n|))
                          (PROGN
                           (LETT #3#
                                 (PROGN
                                  (LETT #1# (CONS 0 (CONS |q| 'T)) . #4#)
                                  (GO #1#))
                                 . #4#)
                           (GO #3#))))))))
                    (EXIT
                     (COND
                      ((< 0 |n|)
                       (SEQ
                        (LETT |r|
                              (SPADCALL
                               (SPADCALL (SPADCALL |cc| (QREFELT $ 23))
                                         (SPADCALL |n| |lt| (QREFELT $ 45))
                                         (QREFELT $ 44))
                               (PROG1 (LETT #2# |n| . #4#)
                                 (|check-subtype| (>= #2# 0)
                                                  '(|NonNegativeInteger|) #2#))
                               (QREFELT $ 15))
                              . #4#)
                        (LETT |cc|
                              (SPADCALL
                               (SPADCALL |cc|
                                         (SPADCALL |bb| |r| (QREFELT $ 19))
                                         (QREFELT $ 43))
                               (SPADCALL |r| |derivation|) (QREFELT $ 43))
                              . #4#)
                        (LETT |d| (- |n| 1) . #4#)
                        (EXIT
                         (LETT |q| (SPADCALL |q| |r| (QREFELT $ 20)) . #4#))))
                      ('T
                       (SEQ
                        (LETT |db|
                              (COND ((SPADCALL |bb| (QREFELT $ 11)) 0)
                                    ('T (SPADCALL |bb| (QREFELT $ 17))))
                              . #4#)
                        (COND
                         ((NULL (EQL |db| (SPADCALL |cc| (QREFELT $ 17))))
                          (EXIT
                           (PROGN
                            (LETT #1# (CONS 0 (CONS |q| 'T)) . #4#)
                            (GO #1#)))))
                        (EXIT
                         (COND
                          ((ZEROP |db|)
                           (PROGN
                            (LETT #1#
                                  (CONS 1
                                        (VECTOR |bb| |cc| 0
                                                (|spadConstant| $ 13) |q|))
                                  . #4#)
                            (GO #1#)))
                          ('T
                           (SEQ
                            (LETT |r|
                                  (SPADCALL (SPADCALL |cc| (QREFELT $ 23))
                                            (SPADCALL |bb| (QREFELT $ 23))
                                            (QREFELT $ 44))
                                  . #4#)
                            (LETT |cc|
                                  (SPADCALL
                                   (SPADCALL |cc|
                                             (SPADCALL |r| |bb| (QREFELT $ 37))
                                             (QREFELT $ 43))
                                   (SPADCALL (SPADCALL |r| (QREFELT $ 46))
                                             |derivation|)
                                   (QREFELT $ 43))
                                  . #4#)
                            (LETT |d| -1 . #4#)
                            (EXIT
                             (LETT |q|
                                   (SPADCALL |q| (SPADCALL |r| (QREFELT $ 46))
                                             (QREFELT $ 20))
                                   . #4#))))))))))))
                  #3# (EXIT #3#))
                 NIL (GO G190) G191 (EXIT NIL))
            (EXIT (CONS 0 (CONS |q| 'NIL)))))
      #1# (EXIT #1#))))) 

(DEFUN |RDETR;monomRDE;2FMU;5| (|f| |g| |derivation| $)
  (PROG (|u| |aa| |tt| #1=#:G758 |gg| |e| |d|)
    (RETURN
     (SEQ
      (LETT |gg|
            (SPADCALL
             (LETT |d| (SPADCALL |f| |derivation| (QREFELT $ 49))
                   . #2=(|RDETR;monomRDE;2FMU;5|))
             (LETT |e| (SPADCALL |g| |derivation| (QREFELT $ 49)) . #2#)
             (QREFELT $ 31))
            . #2#)
      (LETT |tt|
            (PROG2
                (LETT #1#
                      (SPADCALL
                       (SPADCALL |e| (SPADCALL |e| (QREFELT $ 50))
                                 (QREFELT $ 31))
                       (SPADCALL |gg| (SPADCALL |gg| (QREFELT $ 50))
                                 (QREFELT $ 31))
                       (QREFELT $ 33))
                      . #2#)
                (QCDR #1#)
              (|check-union| (QEQCAR #1# 0) (QREFELT $ 7) #1#))
            . #2#)
      (LETT |u|
            (SPADCALL
             (SPADCALL |tt|
                       (LETT |aa| (SPADCALL |d| |tt| (QREFELT $ 19)) . #2#)
                       (QREFELT $ 19))
             |e| (QREFELT $ 33))
            . #2#)
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T
              (CONS 0
                    (VECTOR |aa|
                            (SPADCALL (SPADCALL |aa| |f| (QREFELT $ 51))
                                      (SPADCALL
                                       (SPADCALL |d|
                                                 (SPADCALL |tt| |derivation|)
                                                 (QREFELT $ 19))
                                       (QREFELT $ 52))
                                      (QREFELT $ 53))
                            (SPADCALL (SPADCALL (QCDR |u|) |e| (QREFELT $ 19))
                                      |g| (QREFELT $ 51))
                            |tt|))))))))) 

(DEFUN |RDETR;baseRDE;2FR;6| (|f| |g| $)
  (PROG (|v| #1=#:G773 |n| |cc| |bb| |u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL |f| |g| (ELT $ 50) (QREFELT $ 56))
            . #2=(|RDETR;baseRDE;2FR;6|))
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS (|spadConstant| $ 57) 'T))
             ('T
              (SEQ
               (LETT |n|
                     (|RDETR;getBound| (QVELT (QCDR |u|) 0)
                      (LETT |bb| (SPADCALL (QVELT (QCDR |u|) 1) (QREFELT $ 58))
                            . #2#)
                      (SPADCALL
                       (LETT |cc|
                             (SPADCALL (QVELT (QCDR |u|) 2) (QREFELT $ 58))
                             . #2#)
                       (QREFELT $ 17))
                      $)
                     . #2#)
               (LETT |v|
                     (PROG2
                         (LETT #1#
                               (SPADCALL (QVELT (QCDR |u|) 0) |bb| |cc| |n|
                                         (ELT $ 50) (QREFELT $ 30))
                               . #2#)
                         (QCDR #1#)
                       (|check-union| (QEQCAR #1# 0)
                                      (|Record| (|:| |ans| (QREFELT $ 7))
                                                (|:| |nosol| (|Boolean|)))
                                      #1#))
                     . #2#)
               (EXIT
                (CONS (SPADCALL (QCAR |v|) (QVELT (QCDR |u|) 3) (QREFELT $ 59))
                      (QCDR |v|))))))))))) 

(DEFUN |RDETR;getBound| (|a| |b| |dc| $)
  (PROG (|n| |db| |da|)
    (RETURN
     (SEQ (LETT |da| (SPADCALL |a| (QREFELT $ 17)) . #1=(|RDETR;getBound|))
          (EXIT
           (COND ((SPADCALL |b| (QREFELT $ 11)) (MAX 0 (+ (- |dc| |da|) 1)))
                 (#2='T
                  (SEQ (LETT |db| (SPADCALL |b| (QREFELT $ 17)) . #1#)
                       (EXIT
                        (COND ((< (+ |db| 1) |da|) (MAX 0 (+ (- |dc| |da|) 1)))
                              ((< |da| (+ |db| 1)) (- |dc| |db|))
                              (#2#
                               (SEQ
                                (LETT |n|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL (SPADCALL |b| (QREFELT $ 23))
                                                  (SPADCALL |a| (QREFELT $ 23))
                                                  (QREFELT $ 44))
                                        (QREFELT $ 62))
                                       (QREFELT $ 64))
                                      . #1#)
                                (EXIT
                                 (COND
                                  ((QEQCAR |n| 0)
                                   (MAX (QCDR |n|) (- |dc| |db|)))
                                  (#2# (- |dc| |db|)))))))))))))))) 

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

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

(MAKEPROP '|TranscendentalRischDE| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (0 . |Zero|) (4 . |Zero|) (|Boolean|) (8 . |zero?|) (13 . |One|)
              (17 . |One|) (|NonNegativeInteger|) (21 . |monomial|) (27 . =)
              (33 . |degree|) (38 . ~) (43 . *) (49 . +) (|Fraction| 28)
              (55 . |Zero|) (59 . |leadingCoefficient|) (64 . |integrate|)
              (|Record| (|:| |ans| 7) (|:| |nosol| 10))
              (|Record| (|:| |b| 7) (|:| |c| 7) (|:| |m| 28) (|:| |alpha| 7)
                        (|:| |beta| 7))
              (|Union| (|:| |ans| 25) (|:| |eq| 26)) (|Integer|)
              (|Mapping| 7 7) |RDETR;polyRDE;3UPIMU;1| (69 . |gcd|)
              (|Union| $ '"failed") (75 . |exquo|) (|Union| 6 '#1="failed")
              (81 . |retractIfCan|) (86 . |inv|) (91 . *)
              (|Record| (|:| |coef1| $) (|:| |coef2| $)) (|Union| 38 '"failed")
              (97 . |extendedEuclidean|)
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (104 . |divide|) (110 . -) (116 . /) (122 . *) (128 . |coerce|)
              (|Fraction| 7) (|MonomialExtensionTools| 6 7)
              (133 . |normalDenom|) (139 . |differentiate|) (144 . *)
              (150 . |coerce|) (155 . -)
              (|Record| (|:| |a| 7) (|:| |b| 47) (|:| |c| 47) (|:| |t| 7))
              (|Union| 54 '"failed") |RDETR;monomRDE;2FMU;5| (161 . |Zero|)
              (165 . |retract|) (170 . /)
              (|Record| (|:| |ans| 47) (|:| |nosol| 10)) |RDETR;baseRDE;2FR;6|
              (176 . -) (|Union| 28 '#1#) (181 . |retractIfCan|))
           '#(|polyRDE| 186 |monomRDE| 195 |baseRDE| 202) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 64
                                                 '(0 6 0 8 0 7 0 9 1 7 10 0 11
                                                   0 6 0 12 0 7 0 13 2 7 0 6 14
                                                   15 2 7 10 0 0 16 1 7 14 0 17
                                                   1 10 0 0 18 2 7 0 0 0 19 2 7
                                                   0 0 0 20 0 21 0 22 1 7 6 0
                                                   23 1 7 0 0 24 2 7 0 0 0 31 2
                                                   7 32 0 0 33 1 7 34 0 35 1 6
                                                   0 0 36 2 7 0 6 0 37 3 7 39 0
                                                   0 0 40 2 7 41 0 0 42 2 7 0 0
                                                   0 43 2 6 0 0 0 44 2 6 0 28 0
                                                   45 1 7 0 6 46 2 48 7 47 29
                                                   49 1 7 0 0 50 2 47 0 7 0 51
                                                   1 47 0 7 52 2 47 0 0 0 53 0
                                                   47 0 57 1 47 7 0 58 2 47 0 7
                                                   7 59 1 6 0 0 62 1 6 63 0 64
                                                   5 0 27 7 7 7 28 29 30 3 0 55
                                                   47 47 29 56 2 0 60 47 47
                                                   61)))))
           '|lookupComplete|)) 
