
(/VERSIONCHECK 2) 

(DEFUN |QALGSET;factorset| (|y| $)
  (PROG (#0=#:G1840 |j| #1=#:G1841)
    (RETURN
      (SEQ (COND
             ((SPADCALL |y| (QREFELT $ 12)) NIL)
             ('T
              (PROGN
                (LETT #0# NIL . #2=(|QALGSET;factorset|))
                (SEQ (LETT |j| NIL . #2#)
                     (LETT #1#
                           (SPADCALL (SPADCALL |y| (QREFELT $ 15))
                               (QREFELT $ 18)) . #2#)
                     G190
                     (COND
                       ((OR (ATOM #1#)
                            (PROGN (LETT |j| (CAR #1#) . #2#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (LETT #0# (CONS (QCAR |j|) #0#) . #2#)))
                     (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                     (EXIT (NREVERSE0 #0#)))))))))) 

(DEFUN |QALGSET;simplify;2$;2| (|x| $)
  (PROG (|pnzero| |nzro| #0=#:G1858 |p| #1=#:G1859 #2=#:G1860
            #3=#:G1861 |mset| #4=#:G1862 |s| #5=#:G1863 #6=#:G1815
            #7=#:G1864 #8=#:G1850 #9=#:G1848 #10=#:G1849 |zro|
            #11=#:G1816 #12=#:G1865 #13=#:G1854 #14=#:G1852
            #15=#:G1853)
    (RETURN
      (SEQ (COND
             ((QEQCAR (QVELT |x| 0) 1)
              (LETT |x|
                    (SPADCALL
                        (LETT |zro|
                              (SPADCALL (QVELT |x| 1) (QREFELT $ 21))
                              . #16=(|QALGSET;simplify;2$;2|))
                        (SPADCALL (QVELT |x| 2) |zro| (QREFELT $ 23))
                        (QREFELT $ 24)) . #16#)))
           (LETT |pnzero| (QVELT |x| 2) . #16#)
           (EXIT (COND
                   ((SPADCALL |pnzero| (|spadConstant| $ 27)
                        (QREFELT $ 28))
                    (SPADCALL (QREFELT $ 29)))
                   ('T
                    (SEQ (LETT |nzro|
                               (|QALGSET;factorset| |pnzero| $) . #16#)
                         (LETT |mset|
                               (|QALGSET;minset|
                                   (PROGN
                                     (LETT #0# NIL . #16#)
                                     (SEQ (LETT |p| NIL . #16#)
                                      (LETT #1# (QVELT |x| 1) . #16#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |p| (CAR #1#) . #16#)
                                            NIL))
                                         #17=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (|QALGSET;factorset| |p| $)
                                          #0#) . #16#)))
                                      (LETT #1# (CDR #1#) . #16#)
                                      #18=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))
                                   $) . #16#)
                         (LETT |mset|
                               (PROGN
                                 (LETT #2# NIL . #16#)
                                 (SEQ (LETT |s| NIL . #16#)
                                      (LETT #3# |mset| . #16#) G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |s| (CAR #3#) . #16#)
                                            NIL))
                                         #17#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (SPADCALL |s| |nzro|
                                           (QREFELT $ 30))
                                          #2#) . #16#)))
                                      (LETT #3# (CDR #3#) . #16#) #18#
                                      G191 (EXIT (NREVERSE0 #2#)))) . #16#)
                         (LETT |zro|
                               (SPADCALL
                                   (PROGN
                                     (LETT #4# NIL . #16#)
                                     (SEQ (LETT |s| NIL . #16#)
                                      (LETT #5# |mset| . #16#) G190
                                      (COND
                                        ((OR (ATOM #5#)
                                          (PROGN
                                            (LETT |s| (CAR #5#) . #16#)
                                            NIL))
                                         #17#))
                                      (SEQ
                                       (EXIT
                                        (LETT #4#
                                         (CONS
                                          (PROGN
                                            (LETT #10# NIL . #16#)
                                            (SEQ (LETT #6# NIL . #16#)
                                             (LETT #7# |s| . #16#) G190
                                             (COND
                                               ((OR (ATOM #7#)
                                                 (PROGN
                                                   (LETT #6#
                                                    (CAR #7#) . #16#)
                                                   NIL))
                                                #17#))
                                             (SEQ
                                              (EXIT
                                               (PROGN
                                                 (LETT #8# #6# . #16#)
                                                 (COND
                                                   (#10#
                                                    (LETT #9#
                                                     (SPADCALL #9# #8#
                                                      (QREFELT $ 31)) . #16#))
                                                   ('T
                                                    (PROGN
                                                      (LETT #9#
                                                       #8# . #16#)
                                                      (LETT #10#
                                                       'T . #16#)))))))
                                             (LETT #7#
                                              (CDR #7#) . #16#)
                                             #18# G191 (EXIT NIL))
                                            (COND
                                              (#10# #9#)
                                              ('T
                                               (|spadConstant| $ 32))))
                                          #4#) . #16#)))
                                      (LETT #5# (CDR #5#) . #16#) #18#
                                      G191 (EXIT (NREVERSE0 #4#))))
                                   (QREFELT $ 21)) . #16#)
                         (EXIT (COND
                                 ((SPADCALL (|spadConstant| $ 32) |zro|
                                      (QREFELT $ 33))
                                  (SPADCALL (QREFELT $ 29)))
                                 ('T
                                  (VECTOR (QVELT |x| 0) |zro|
                                          (SPADCALL
                                           (SPADCALL
                                            (PROGN
                                              (LETT #15# NIL . #16#)
                                              (SEQ
                                               (LETT #11# NIL . #16#)
                                               (LETT #12#
                                                |nzro| . #16#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #12#)
                                                   (PROGN
                                                     (LETT #11#
                                                      (CAR #12#) . #16#)
                                                     NIL))
                                                  #17#))
                                               (SEQ
                                                (EXIT
                                                 (PROGN
                                                   (LETT #13#
                                                    #11# . #16#)
                                                   (COND
                                                     (#15#
                                                      (LETT #14#
                                                       (SPADCALL #14#
                                                        #13#
                                                        (QREFELT $ 31)) . #16#))
                                                     ('T
                                                      (PROGN
                                                        (LETT #14#
                                                         #13# . #16#)
                                                        (LETT #15#
                                                         'T . #16#)))))))
                                               (LETT #12#
                                                (CDR #12#) . #16#)
                                               #18# G191 (EXIT NIL))
                                              (COND
                                                (#15# #14#)
                                                ('T
                                                 (|spadConstant| $ 32))))
                                            |zro| (QREFELT $ 23))
                                           (QREFELT $ 34)))))))))))))) 

(DEFUN |QALGSET;npoly| (|f| $)
  (COND
    ((SPADCALL |f| (QREFELT $ 36)) (|spadConstant| $ 38))
    ('T
     (SPADCALL
         (SPADCALL (SPADCALL |f| (QREFELT $ 39))
             (SPADCALL 0 (SPADCALL |f| (QREFELT $ 40)) (QREFELT $ 43))
             (QREFELT $ 44))
         (|QALGSET;npoly| (SPADCALL |f| (QREFELT $ 45)) $)
         (QREFELT $ 46))))) 

(DEFUN |QALGSET;oldpoly| (|q| $)
  (PROG (|dq| |n| |g|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |q| (|spadConstant| $ 38) (QREFELT $ 47))
              (CONS 0 (|spadConstant| $ 27)))
             (#0='T
              (SEQ (LETT |dq| (SPADCALL |q| (QREFELT $ 48))
                         . #1=(|QALGSET;oldpoly|))
                   (LETT |n| (SPADCALL |dq| (QREFELT $ 49)) . #1#)
                   (EXIT (COND
                           ((EQL |n| 0)
                            (SEQ (LETT |g|
                                       (|QALGSET;oldpoly|
                                        (SPADCALL |q| (QREFELT $ 50))
                                        $) . #1#)
                                 (EXIT (COND
                                         ((QEQCAR |g| 1)
                                          (CONS 1 "failed"))
                                         (#0#
                                          (CONS 0
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |q|
                                              (QREFELT $ 51))
                                             (SPADCALL |dq|
                                              (QREFELT $ 52))
                                             (QREFELT $ 53))
                                            (QCDR |g|) (QREFELT $ 54))))))))
                           (#0# (CONS 1 "failed"))))))))))) 

(DEFUN |QALGSET;coerce;$Of;5| (|x| $)
  (PROG (#0=#:G1884 |f| #1=#:G1885)
    (RETURN
      (SEQ (COND
             ((SPADCALL (QVELT |x| 0) (CONS 0 'T) (QREFELT $ 56))
              "Empty")
             ('T
              (SPADCALL
                  (LIST (SPADCALL
                            (PROGN
                              (LETT #0# NIL
                                    . #2=(|QALGSET;coerce;$Of;5|))
                              (SEQ (LETT |f| NIL . #2#)
                                   (LETT #1# (QVELT |x| 1) . #2#) G190
                                   (COND
                                     ((OR (ATOM #1#)
                                       (PROGN
                                         (LETT |f| (CAR #1#) . #2#)
                                         NIL))
                                      (GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #0#
                                      (CONS
                                       (SPADCALL
                                        (SPADCALL |f| (QREFELT $ 58))
                                        " = 0" (QREFELT $ 59))
                                       #0#) . #2#)))
                                   (LETT #1# (CDR #1#) . #2#) (GO G190)
                                   G191 (EXIT (NREVERSE0 #0#))))
                            (QREFELT $ 61))
                        (SPADCALL
                            (SPADCALL (QVELT |x| 2) (QREFELT $ 58))
                            " != 0" (QREFELT $ 59)))
                  (QREFELT $ 63)))))))) 

(DEFUN |QALGSET;empty?;$B;6| (|x| $)
  (PROG (#0=#:G1887)
    (RETURN
      (SEQ (COND
             ((QEQCAR (QVELT |x| 0) 1)
              (LETT |x| (SPADCALL |x| (QREFELT $ 65))
                    . #1=(|QALGSET;empty?;$B;6|))))
           (EXIT (PROG2 (LETT #0# (QVELT |x| 0) . #1#) (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (|Boolean|) #0#))))))) 

(DEFUN |QALGSET;empty;$;7| ($)
  (VECTOR (CONS 0 'T) (LIST (|spadConstant| $ 32))
          (|spadConstant| $ 27))) 

(PUT '|QALGSET;status;$U;8| '|SPADreplace| '(XLAM (|x|) (QVELT |x| 0))) 

(DEFUN |QALGSET;status;$U;8| (|x| $) (QVELT |x| 0)) 

(DEFUN |QALGSET;setStatus;$U$;9| (|x| |t| $)
  (VECTOR |t| (QVELT |x| 1) (QVELT |x| 2))) 

(PUT '|QALGSET;definingEquations;$L;10| '|SPADreplace|
     '(XLAM (|x|) (QVELT |x| 1))) 

(DEFUN |QALGSET;definingEquations;$L;10| (|x| $) (QVELT |x| 1)) 

(PUT '|QALGSET;definingInequation;$Dpoly;11| '|SPADreplace|
     '(XLAM (|x|) (QVELT |x| 2))) 

(DEFUN |QALGSET;definingInequation;$Dpoly;11| (|x| $) (QVELT |x| 2)) 

(DEFUN |QALGSET;quasiAlgebraicSet;LDpoly$;12| (|z0| |n0| $)
  (VECTOR (CONS 1 "failed") |z0| |n0|)) 

(DEFUN |QALGSET;idealSimplify;2$;13| (|x| $)
  (PROG (|z0| |n0| |tp| #0=#:G1925 |g| #1=#:G1926 |f| |gb| |ngb|)
    (RETURN
      (SEQ (COND
             ((QEQCAR (QVELT |x| 0) 0) |x|)
             ('T
              (SEQ (LETT |z0| (QVELT |x| 1)
                         . #2=(|QALGSET;idealSimplify;2$;13|))
                   (LETT |n0| (QVELT |x| 2) . #2#)
                   (EXIT (COND
                           ((NULL |z0|)
                            (VECTOR (CONS 0 'NIL) |z0| |n0|))
                           ((SPADCALL (|spadConstant| $ 32) |z0|
                                (QREFELT $ 33))
                            (SPADCALL (QREFELT $ 29)))
                           ('T
                            (SEQ (LETT |tp|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (|spadConstant| $ 71)
                                          (SPADCALL 1
                                           (|spadConstant| $ 26)
                                           (QREFELT $ 43))
                                          (QREFELT $ 44))
                                         (|QALGSET;npoly| |n0| $)
                                         (QREFELT $ 72))
                                        (|spadConstant| $ 73)
                                        (QREFELT $ 74)) . #2#)
                                 (LETT |ngb|
                                       (SPADCALL
                                        (CONS |tp|
                                         (PROGN
                                           (LETT #0# NIL . #2#)
                                           (SEQ (LETT |g| NIL . #2#)
                                            (LETT #1# |z0| . #2#) G190
                                            (COND
                                              ((OR (ATOM #1#)
                                                (PROGN
                                                  (LETT |g|
                                                   (CAR #1#) . #2#)
                                                  NIL))
                                               #3=(GO G191)))
                                            (SEQ
                                             (EXIT
                                              (LETT #0#
                                               (CONS
                                                (|QALGSET;npoly| |g| $)
                                                #0#) . #2#)))
                                            (LETT #1# (CDR #1#) . #2#)
                                            #4=(GO G190) G191
                                            (EXIT (NREVERSE0 #0#)))))
                                        (QREFELT $ 77)) . #2#)
                                 (EXIT (COND
                                         ((SPADCALL
                                           (|spadConstant| $ 73) |ngb|
                                           (QREFELT $ 78))
                                          (SPADCALL (QREFELT $ 29)))
                                         ('T
                                          (SEQ (LETT |gb| NIL . #2#)
                                           (SEQ G190
                                            (COND
                                              ((NULL
                                                (COND
                                                  ((NULL |ngb|) 'NIL)
                                                  ('T 'T)))
                                               #3#))
                                            (SEQ
                                             (SEQ
                                              (LETT |f|
                                               (|QALGSET;oldpoly|
                                                (|SPADfirst| |ngb|) $) . #2#)
                                              (EXIT
                                               (COND
                                                 ((QEQCAR |f| 0)
                                                  (LETT |gb|
                                                   (CONS (QCDR |f|)
                                                    |gb|) . #2#)))))
                                             (EXIT
                                              (LETT |ngb|
                                               (CDR |ngb|) . #2#)))
                                            NIL #4# G191 (EXIT NIL))
                                           (EXIT
                                            (VECTOR (CONS 0 'NIL) |gb|
                                             (SPADCALL
                                              (SPADCALL |n0| |gb|
                                               (QREFELT $ 23))
                                              (QREFELT $ 34))))))))))))))))))) 

(DEFUN |QALGSET;minset| (|lset| $)
  (PROG (#0=#:G1931 |s| #1=#:G1932)
    (RETURN
      (SEQ (COND
             ((NULL |lset|) |lset|)
             ('T
              (PROGN
                (LETT #0# NIL . #2=(|QALGSET;minset|))
                (SEQ (LETT |s| NIL . #2#) (LETT #1# |lset| . #2#) G190
                     (COND
                       ((OR (ATOM #1#)
                            (PROGN (LETT |s| (CAR #1#) . #2#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (COND
                                  ((COND
                                     ((|QALGSET;overset?| |s| |lset| $)
                                      'NIL)
                                     ('T 'T))
                                   (LETT #0# (CONS |s| #0#) . #2#)))))
                     (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                     (EXIT (NREVERSE0 #0#)))))))))) 

(DEFUN |QALGSET;overset?| (|p| |qlist| $)
  (PROG (|q| #0=#:G1938 #1=#:G1935 #2=#:G1933 #3=#:G1934)
    (RETURN
      (SEQ (COND
             ((NULL |qlist|) 'NIL)
             ('T
              (PROGN
                (LETT #3# NIL . #4=(|QALGSET;overset?|))
                (SEQ (LETT |q| NIL . #4#) (LETT #0# |qlist| . #4#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |q| (CAR #0#) . #4#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL
                                         (SPADCALL |q| (QREFELT $ 80))
                                         (SPADCALL |p| (QREFELT $ 80))
                                         (QREFELT $ 81)) . #4#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (COND (#2# 'T) ('T #1#)) . #4#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #4#)
                                       (LETT #3# 'T . #4#)))))))
                     (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) ('T 'NIL))))))))) 

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

(DEFUN |QuasiAlgebraicSet;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|QuasiAlgebraicSet|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|QuasiAlgebraicSet| DV$1 DV$2 DV$3 DV$4) . #0#)
        (LETT $ (GETREFV 84) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (AND (|HasCategory| |#1|
                                     '(|CharacteristicZero|))
                                 (|HasCategory| |#1|
                                     '(|EuclideanDomain|))))) . #0#))
        (|haddProp| |$ConstructorCache| '|QuasiAlgebraicSet|
            (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (QSETREFV $ 10
            (|Record| (|:| |status| (|Union| (|Boolean|) "failed"))
                (|:| |zero| (|List| |#4|)) (|:| |nzero| |#4|)))
        (COND
          ((|HasCategory| |#1| '(|EuclideanDomain|))
           (COND
             ((|HasCategory| |#1| '(|CharacteristicZero|))
              (PROGN
                (QSETREFV $ 35
                    (CONS (|dispatchFunction| |QALGSET;simplify;2$;2|)
                          $)))))))
        $)))) 

(MAKEPROP '|QuasiAlgebraicSet| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) '|Rep| (|Boolean|)
             (0 . |ground?|) (|Factored| 9)
             (|MultivariateFactorize| 7 8 6 9) (5 . |factor|)
             (|Record| (|:| |factor| 9) (|:| |exponent| (|Integer|)))
             (|List| 16) (10 . |factors|) (|List| 9)
             (|GroebnerPackage| 6 8 7 9) (15 . |groebner|)
             (|GroebnerInternalPackage| 6 8 7 9) (20 . |redPol|)
             |QALGSET;quasiAlgebraicSet;LDpoly$;12| (26 . |Zero|)
             (30 . |Zero|) (34 . |Zero|) (38 . =) |QALGSET;empty;$;7|
             (44 . |setDifference|) (50 . *) (56 . |One|)
             (60 . |member?|) (66 . |primitivePart|) (71 . |simplify|)
             (76 . |zero?|) (|PolynomialRing| 6 42) (81 . |Zero|)
             (85 . |leadingCoefficient|) (90 . |degree|)
             (|NonNegativeInteger|) (|Product| 41 8) (95 . |makeprod|)
             (101 . |monomial|) (107 . |reductum|) (112 . +) (118 . =)
             (124 . |degree|) (129 . |selectfirst|) (134 . |reductum|)
             (139 . |leadingCoefficient|) (144 . |selectsecond|)
             (149 . |monomial|) (155 . +) (|Union| 11 '"failed")
             (161 . =) (|OutputForm|) (167 . |coerce|)
             (172 . |hconcat|) (|List| 57) (178 . |coerce|) (|List| $)
             (183 . |bracket|) |QALGSET;coerce;$Of;5|
             |QALGSET;idealSimplify;2$;13| |QALGSET;empty?;$B;6|
             |QALGSET;status;$U;8| |QALGSET;setStatus;$U$;9|
             |QALGSET;definingEquations;$L;10|
             |QALGSET;definingInequation;$Dpoly;11| (188 . |One|)
             (192 . *) (198 . |One|) (202 . -) (|List| 37)
             (|GroebnerPackage| 6 42 7 37) (208 . |groebner|)
             (213 . |member?|) (|Set| 9) (219 . |brace|) (224 . <)
             (|String|) (|SingleInteger|))
          '#(~= 230 |status| 236 |simplify| 241 |setStatus| 246
             |quasiAlgebraicSet| 252 |latex| 258 |idealSimplify| 263
             |hash| 268 |empty?| 273 |empty| 278 |definingInequation|
             282 |definingEquations| 287 |coerce| 292 = 297)
          'NIL
          (CONS (|makeByteWordVec2| 1 '(0 0 0))
                (CONS '#(|SetCategory&| |BasicType&| NIL)
                      (CONS '#((|SetCategory|) (|BasicType|)
                               (|CoercibleTo| 57))
                            (|makeByteWordVec2| 83
                                '(1 9 11 0 12 1 14 13 9 15 1 13 17 0 18
                                  1 20 19 19 21 2 22 9 9 19 23 0 6 0 25
                                  0 8 0 26 0 9 0 27 2 9 11 0 0 28 2 19
                                  0 0 0 30 2 9 0 0 0 31 0 9 0 32 2 19
                                  11 9 0 33 1 9 0 0 34 1 0 0 0 35 1 9
                                  11 0 36 0 37 0 38 1 9 6 0 39 1 9 8 0
                                  40 2 42 0 41 8 43 2 37 0 6 42 44 1 9
                                  0 0 45 2 37 0 0 0 46 2 37 11 0 0 47 1
                                  37 42 0 48 1 42 41 0 49 1 37 0 0 50 1
                                  37 6 0 51 1 42 8 0 52 2 9 0 6 8 53 2
                                  9 0 0 0 54 2 55 11 0 0 56 1 9 57 0 58
                                  2 57 0 0 0 59 1 60 57 0 61 1 57 0 62
                                  63 0 6 0 71 2 37 0 0 0 72 0 37 0 73 2
                                  37 0 0 0 74 1 76 75 75 77 2 75 11 37
                                  0 78 1 79 0 19 80 2 79 11 0 0 81 2 0
                                  11 0 0 1 1 0 55 0 67 1 1 0 0 35 2 0 0
                                  0 55 68 2 0 0 19 9 24 1 0 82 0 1 1 0
                                  0 0 65 1 0 83 0 1 1 0 11 0 66 0 0 0
                                  29 1 0 9 0 70 1 0 19 0 69 1 0 57 0 64
                                  2 0 11 0 0 1)))))
          '|lookupComplete|)) 
