
(/VERSIONCHECK 2) 

(DEFUN |XPBWPOLY;outForm| (|t| $)
  (COND
    ((SPADCALL (QCDR |t|) (|spadConstant| $ 9) (QREFELT $ 11))
     (SPADCALL (QCAR |t|) (QREFELT $ 14)))
    ((SPADCALL (QCAR |t|) (|spadConstant| $ 15) (QREFELT $ 16))
     (SPADCALL (QCDR |t|) (QREFELT $ 17)))
    ('T
     (SPADCALL (SPADCALL (QCDR |t|) (QREFELT $ 17))
         (SPADCALL (QCAR |t|) (QREFELT $ 14)) (QREFELT $ 18))))) 

(DEFUN |XPBWPOLY;prod1| (|b| |p| $)
  (PROG (|t| #0=#:G1838 #1=#:G1836 #2=#:G1834 #3=#:G1835)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|XPBWPOLY;prod1|))
             (SEQ (LETT |t| NIL . #4#) (LETT #0# |p| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL (QCDR |t|)
                                      (|XPBWPOLY;prod| |b| (QCAR |t|)
                                       $)
                                      (QREFELT $ 19)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 20)) . #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 (|spadConstant| $ 21)))))))) 

(DEFUN |XPBWPOLY;prod2| (|p| |b| $)
  (PROG (|t| #0=#:G1843 #1=#:G1841 #2=#:G1839 #3=#:G1840)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|XPBWPOLY;prod2|))
             (SEQ (LETT |t| NIL . #4#) (LETT #0# |p| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL (QCDR |t|)
                                      (|XPBWPOLY;prod| (QCAR |t|) |b|
                                       $)
                                      (QREFELT $ 19)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 20)) . #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 (|spadConstant| $ 21)))))))) 

(DEFUN |XPBWPOLY;prod11| (|b| |p| |n| $)
  (PROG (|limit| |t| #0=#:G1850 #1=#:G1847 #2=#:G1845 #3=#:G1846)
    (RETURN
      (SEQ (LETT |limit| (- |n| (SPADCALL |b| (QREFELT $ 23)))
                 . #4=(|XPBWPOLY;prod11|))
           (EXIT (PROGN
                   (LETT #3# NIL . #4#)
                   (SEQ (LETT |t| NIL . #4#) (LETT #0# |p| . #4#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (COND
                                     ((COND
                                        ((< |limit|
                                          (SPADCALL (QCAR |t|)
                                           (QREFELT $ 23)))
                                         'NIL)
                                        ('T 'T))
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL (QCDR |t|)
                                          (|XPBWPOLY;prod| |b|
                                           (QCAR |t|) $)
                                          (QREFELT $ 19)) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 20)) . #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 (|spadConstant| $ 21))))))))) 

(DEFUN |XPBWPOLY;prod22| (|p| |b| |n| $)
  (PROG (|limit| |t| #0=#:G1857 #1=#:G1854 #2=#:G1852 #3=#:G1853)
    (RETURN
      (SEQ (LETT |limit| (- |n| (SPADCALL |b| (QREFELT $ 23)))
                 . #4=(|XPBWPOLY;prod22|))
           (EXIT (PROGN
                   (LETT #3# NIL . #4#)
                   (SEQ (LETT |t| NIL . #4#) (LETT #0# |p| . #4#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (COND
                                     ((COND
                                        ((< |limit|
                                          (SPADCALL (QCAR |t|)
                                           (QREFELT $ 23)))
                                         'NIL)
                                        ('T 'T))
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL (QCDR |t|)
                                          (|XPBWPOLY;prod| (QCAR |t|)
                                           |b| $)
                                          (QREFELT $ 19)) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 20)) . #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 (|spadConstant| $ 21))))))))) 

(DEFUN |XPBWPOLY;prod| (|g| |d| $)
  (COND
    ((SPADCALL |d| (|spadConstant| $ 15) (QREFELT $ 16))
     (SPADCALL |g| (|spadConstant| $ 9) (QREFELT $ 25)))
    ((SPADCALL |g| (|spadConstant| $ 15) (QREFELT $ 16))
     (SPADCALL |d| (|spadConstant| $ 9) (QREFELT $ 25)))
    ('T
     (|XPBWPOLY;process| (REVERSE (SPADCALL |g| (QREFELT $ 27)))
         (SPADCALL |d| (QREFELT $ 29))
         (CDR (SPADCALL |d| (QREFELT $ 27))) $)))) 

(DEFUN |XPBWPOLY;Dexpand| (|b| $)
  (PROG (|l| #0=#:G1863 #1=#:G1861 #2=#:G1859 #3=#:G1860)
    (RETURN
      (SEQ (COND
             ((SPADCALL |b| (|spadConstant| $ 15) (QREFELT $ 16))
              (|spadConstant| $ 31))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|XPBWPOLY;Dexpand|))
                (SEQ (LETT |l| NIL . #5#)
                     (LETT #0# (SPADCALL |b| (QREFELT $ 27)) . #5#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |l| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL
                                         (SPADCALL |l| (QREFELT $ 33))
                                         (QREFELT $ 34)) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 35)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 31)))))))))) 

(DEFUN |XPBWPOLY;Rexpand| (|b| $)
  (PROG (|l| #0=#:G1868 #1=#:G1866 #2=#:G1864 #3=#:G1865)
    (RETURN
      (SEQ (COND
             ((SPADCALL |b| (|spadConstant| $ 15) (QREFELT $ 16))
              (|spadConstant| $ 37))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|XPBWPOLY;Rexpand|))
                (SEQ (LETT |l| NIL . #5#)
                     (LETT #0# (SPADCALL |b| (QREFELT $ 27)) . #5#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |l| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL
                                         (SPADCALL |l| (QREFELT $ 33))
                                         (QREFELT $ 38)) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 39)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 37)))))))))) 

(DEFUN |XPBWPOLY;mirror1| (|b| $)
  (PROG (|lp|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |b| (|spadConstant| $ 15) (QREFELT $ 16))
              (|spadConstant| $ 24))
             ('T
              (SEQ (LETT |lp|
                         (SPADCALL (SPADCALL |b| (QREFELT $ 29))
                             (QREFELT $ 33))
                         . #0=(|XPBWPOLY;mirror1|))
                   (LETT |lp| (SPADCALL |lp| (QREFELT $ 40)) . #0#)
                   (EXIT (SPADCALL
                             (|XPBWPOLY;mirror1|
                                 (SPADCALL |b| (QREFELT $ 41)) $)
                             (SPADCALL |lp| (QREFELT $ 42))
                             (QREFELT $ 43)))))))))) 

(DEFUN |XPBWPOLY;process| (|gauche| |x| |droite| $)
  (PROG (|p| #0=#:G1891 #1=#:G1877 #2=#:G1875 #3=#:G1876 |rd| |fd|
             #4=#:G1892 #5=#:G1881 #6=#:G1879 #7=#:G1880 #8=#:G1893
             #9=#:G1884 #10=#:G1882 #11=#:G1883 |r1| |t| #12=#:G1894
             #13=#:G1887 #14=#:G1885 #15=#:G1886 |r2|)
    (RETURN
      (SEQ (COND
             ((NULL |gauche|)
              (SPADCALL (CONS |x| |droite|) (|spadConstant| $ 9)
                  (QREFELT $ 25)))
             ((NULL (SPADCALL (|SPADfirst| |gauche|) |x|
                        (QREFELT $ 44)))
              (SPADCALL (APPEND (REVERSE |gauche|) (CONS |x| |droite|))
                  (|spadConstant| $ 9) (QREFELT $ 25)))
             ('T
              (SEQ (LETT |p|
                         (SPADCALL (|SPADfirst| |gauche|) |x|
                             (QREFELT $ 45))
                         . #16=(|XPBWPOLY;process|))
                   (EXIT (COND
                           ((NULL |droite|)
                            (SEQ (LETT |r1|
                                       (PROGN
                                         (LETT #3# NIL . #16#)
                                         (SEQ (LETT |t| NIL . #16#)
                                          (LETT #0#
                                           (SPADCALL |p|
                                            (QREFELT $ 48)) . #16#)
                                          G190
                                          (COND
                                            ((OR (ATOM #0#)
                                              (PROGN
                                                (LETT |t|
                                                 (CAR #0#) . #16#)
                                                NIL))
                                             #17=(GO G191)))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #1#
                                               (SPADCALL (QCDR |t|)
                                                (|XPBWPOLY;process|
                                                 (CDR |gauche|)
                                                 (QCAR |t|) |droite| $)
                                                (QREFELT $ 19)) . #16#)
                                              (COND
                                                (#3#
                                                 (LETT #2#
                                                  (SPADCALL #2# #1#
                                                   (QREFELT $ 20)) . #16#))
                                                ('T
                                                 (PROGN
                                                   (LETT #2#
                                                    #1# . #16#)
                                                   (LETT #3# 'T . #16#)))))))
                                          (LETT #0# (CDR #0#) . #16#)
                                          #18=(GO G190) G191
                                          (EXIT NIL))
                                         (COND
                                           (#3# #2#)
                                           (#19='T
                                            (|spadConstant| $ 21)))) . #16#)
                                 (LETT |r2|
                                       (|XPBWPOLY;process|
                                        (CDR |gauche|) |x|
                                        (SPADCALL
                                         (|SPADfirst| |gauche|)
                                         (QREFELT $ 49))
                                        $) . #16#)
                                 (EXIT (SPADCALL |r1| |r2|
                                        (QREFELT $ 20)))))
                           (#19#
                            (SEQ (LETT |rd| (CDR |droite|) . #16#)
                                 (LETT |fd|
                                       (|SPADfirst| |droite|) . #16#)
                                 (LETT |r1|
                                       (PROGN
                                         (LETT #7# NIL . #16#)
                                         (SEQ (LETT |t| NIL . #16#)
                                          (LETT #4#
                                           (SPADCALL |p|
                                            (QREFELT $ 48)) . #16#)
                                          G190
                                          (COND
                                            ((OR (ATOM #4#)
                                              (PROGN
                                                (LETT |t|
                                                 (CAR #4#) . #16#)
                                                NIL))
                                             #17#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #5#
                                               (SPADCALL (QCDR |t|)
                                                (|XPBWPOLY;process|
                                                 (SPADCALL (QCAR |t|)
                                                  (QREFELT $ 49))
                                                 |fd| |rd| $)
                                                (QREFELT $ 19)) . #16#)
                                              (COND
                                                (#7#
                                                 (LETT #6#
                                                  (SPADCALL #6# #5#
                                                   (QREFELT $ 20)) . #16#))
                                                ('T
                                                 (PROGN
                                                   (LETT #6#
                                                    #5# . #16#)
                                                   (LETT #7# 'T . #16#)))))))
                                          (LETT #4# (CDR #4#) . #16#)
                                          #18# G191 (EXIT NIL))
                                         (COND
                                           (#7# #6#)
                                           (#19# (|spadConstant| $ 21)))) . #16#)
                                 (LETT |r1|
                                       (PROGN
                                         (LETT #11# NIL . #16#)
                                         (SEQ (LETT |t| NIL . #16#)
                                          (LETT #8# |r1| . #16#) G190
                                          (COND
                                            ((OR (ATOM #8#)
                                              (PROGN
                                                (LETT |t|
                                                 (CAR #8#) . #16#)
                                                NIL))
                                             #17#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #9#
                                               (SPADCALL (QCDR |t|)
                                                (|XPBWPOLY;process|
                                                 (CDR |gauche|)
                                                 (SPADCALL (QCAR |t|)
                                                  (QREFELT $ 29))
                                                 (CDR
                                                  (SPADCALL (QCAR |t|)
                                                   (QREFELT $ 27)))
                                                 $)
                                                (QREFELT $ 19)) . #16#)
                                              (COND
                                                (#11#
                                                 (LETT #10#
                                                  (SPADCALL #10# #9#
                                                   (QREFELT $ 20)) . #16#))
                                                ('T
                                                 (PROGN
                                                   (LETT #10#
                                                    #9# . #16#)
                                                   (LETT #11#
                                                    'T . #16#)))))))
                                          (LETT #8# (CDR #8#) . #16#)
                                          #18# G191 (EXIT NIL))
                                         (COND
                                           (#11# #10#)
                                           (#19# (|spadConstant| $ 21)))) . #16#)
                                 (LETT |r2|
                                       (|XPBWPOLY;process|
                                        (LIST (|SPADfirst| |gauche|)
                                         |x|)
                                        |fd| |rd| $) . #16#)
                                 (LETT |r2|
                                       (PROGN
                                         (LETT #15# NIL . #16#)
                                         (SEQ (LETT |t| NIL . #16#)
                                          (LETT #12# |r2| . #16#) G190
                                          (COND
                                            ((OR (ATOM #12#)
                                              (PROGN
                                                (LETT |t|
                                                 (CAR #12#) . #16#)
                                                NIL))
                                             #17#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #13#
                                               (SPADCALL (QCDR |t|)
                                                (|XPBWPOLY;process|
                                                 (CDR |gauche|)
                                                 (SPADCALL (QCAR |t|)
                                                  (QREFELT $ 29))
                                                 (CDR
                                                  (SPADCALL (QCAR |t|)
                                                   (QREFELT $ 27)))
                                                 $)
                                                (QREFELT $ 19)) . #16#)
                                              (COND
                                                (#15#
                                                 (LETT #14#
                                                  (SPADCALL #14# #13#
                                                   (QREFELT $ 20)) . #16#))
                                                ('T
                                                 (PROGN
                                                   (LETT #14#
                                                    #13# . #16#)
                                                   (LETT #15#
                                                    'T . #16#)))))))
                                          (LETT #12# (CDR #12#) . #16#)
                                          #18# G191 (EXIT NIL))
                                         (COND
                                           (#15# #14#)
                                           (#19# (|spadConstant| $ 21)))) . #16#)
                                 (EXIT (SPADCALL |r1| |r2|
                                        (QREFELT $ 20)))))))))))))) 

(DEFUN |XPBWPOLY;One;$;11| ($)
  (SPADCALL (|spadConstant| $ 15) (|spadConstant| $ 9) (QREFELT $ 25))) 

(DEFUN |XPBWPOLY;coerce;R$;12| (|r| $)
  (LIST (CONS (|spadConstant| $ 15) |r|))) 

(DEFUN |XPBWPOLY;coerce;$Of;13| (|p| $)
  (PROG (|rec| #0=#:G1901 |le|)
    (RETURN
      (SEQ (COND
             ((NULL |p|)
              (SPADCALL (|spadConstant| $ 51) (QREFELT $ 17)))
             ('T
              (SEQ (LETT |le| NIL . #1=(|XPBWPOLY;coerce;$Of;13|))
                   (SEQ (LETT |rec| NIL . #1#) (LETT #0# |p| . #1#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN
                                 (LETT |rec| (CAR #0#) . #1#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT |le|
                                    (CONS (|XPBWPOLY;outForm| |rec| $)
                                     |le|) . #1#)))
                        (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (SPADCALL (ELT $ 52) |le| (QREFELT $ 55)))))))))) 

(DEFUN |XPBWPOLY;coerce;VarSet$;14| (|v| $)
  (SPADCALL (SPADCALL |v| (QREFELT $ 57)) (|spadConstant| $ 9)
      (QREFELT $ 25))) 

(DEFUN |XPBWPOLY;coerce;Lp$;15| (|p| $)
  (PROG (#0=#:G1906 |t| #1=#:G1907)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|XPBWPOLY;coerce;Lp$;15|))
             (SEQ (LETT |t| NIL . #2#)
                  (LETT #1# (SPADCALL |p| (QREFELT $ 48)) . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |t| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (CONS
                                     (SPADCALL (QCAR |t|)
                                      (QREFELT $ 59))
                                     (QCDR |t|))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |XPBWPOLY;coerce;$Xdp;16| (|p| $)
  (PROG (|t| #0=#:G1912 #1=#:G1910 #2=#:G1908 #3=#:G1909)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|XPBWPOLY;coerce;$Xdp;16|))
             (SEQ (LETT |t| NIL . #4#) (LETT #0# |p| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL (QCDR |t|)
                                      (|XPBWPOLY;Dexpand| (QCAR |t|) $)
                                      (QREFELT $ 60)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 61)) . #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 (|spadConstant| $ 62)))))))) 

(DEFUN |XPBWPOLY;coerce;$Xrp;17| (|p| $)
  (PROG (|t| #0=#:G1917 #1=#:G1915 #2=#:G1913 #3=#:G1914)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
              (|spadConstant| $ 65))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|XPBWPOLY;coerce;$Xrp;17|))
                (SEQ (LETT |t| NIL . #5#) (LETT #0# |p| . #5#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |t| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL (QCDR |t|)
                                         (|XPBWPOLY;Rexpand| (QCAR |t|)
                                          $)
                                         (QREFELT $ 66)) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 67)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 65)))))))))) 

(DEFUN |XPBWPOLY;constant?;$B;18| (|p| $)
  (COND
    ((NULL |p|) 'T)
    ('T
     (SPADCALL (SPADCALL |p| (QREFELT $ 69)) (|spadConstant| $ 15)
         (QREFELT $ 16))))) 

(DEFUN |XPBWPOLY;constant;$R;19| (|p| $)
  (COND
    ((OR (NULL |p|)
         (NULL (SPADCALL (QCAR (SPADCALL |p| '|last| (QREFELT $ 73)))
                   (|spadConstant| $ 15) (QREFELT $ 16))))
     (|spadConstant| $ 51))
    ('T (QCDR (SPADCALL |p| '|last| (QREFELT $ 73)))))) 

(DEFUN |XPBWPOLY;quasiRegular?;$B;20| (|p| $)
  (COND
    ((OR (SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
         (NULL (SPADCALL (QCAR (SPADCALL |p| '|last| (QREFELT $ 73)))
                   (|spadConstant| $ 15) (QREFELT $ 16))))
     'T)
    ('T 'NIL))) 

(DEFUN |XPBWPOLY;quasiRegular;2$;21| (|p| $)
  (COND
    ((OR (SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
         (NULL (SPADCALL (QCAR (SPADCALL |p| '|last| (QREFELT $ 73)))
                   (|spadConstant| $ 15) (QREFELT $ 16))))
     |p|)
    ('T (SPADCALL |p| (SPADCALL |p| (QREFELT $ 77)) (QREFELT $ 78))))) 

(DEFUN |XPBWPOLY;*;3$;22| (|x| |y| $)
  (PROG (|t| #0=#:G1930 #1=#:G1928 #2=#:G1926 #3=#:G1927)
    (RETURN
      (SEQ (COND
             ((SPADCALL |y| (|spadConstant| $ 21) (QREFELT $ 64))
              (|spadConstant| $ 21))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|XPBWPOLY;*;3$;22|))
                (SEQ (LETT |t| NIL . #5#) (LETT #0# |x| . #5#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |t| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL (QCDR |t|)
                                         (|XPBWPOLY;prod1| (QCAR |t|)
                                          |y| $)
                                         (QREFELT $ 19)) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 20)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 21)))))))))) 

(DEFUN |XPBWPOLY;varList;$L;23| (|p| $)
  (PROG (|b| #0=#:G1936 #1=#:G1933 #2=#:G1931 #3=#:G1932 |lv|)
    (RETURN
      (SEQ (LETT |lv|
                 (PROGN
                   (LETT #3# NIL . #4=(|XPBWPOLY;varList;$L;23|))
                   (SEQ (LETT |b| NIL . #4#) (LETT #0# |p| . #4#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |b| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #1#
                                      (SPADCALL (QCAR |b|)
                                       (QREFELT $ 81)) . #4#)
                                     (COND
                                       (#3#
                                        (LETT #2#
                                         (SPADCALL #2# #1#
                                          (QREFELT $ 82)) . #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 (|IdentityError| '|setUnion|)))) . #4#)
           (EXIT (SPADCALL |lv| (QREFELT $ 83))))))) 

(DEFUN |XPBWPOLY;degree;$Nni;24| (|p| $)
  (COND
    ((SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
     (|error| "null polynomial"))
    ('T (SPADCALL (SPADCALL |p| (QREFELT $ 69)) (QREFELT $ 23))))) 

(DEFUN |XPBWPOLY;trunc;$Nni$;25| (|p| |n| $)
  (COND
    ((OR (SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
         (NULL (< |n| (SPADCALL |p| (QREFELT $ 85)))))
     |p|)
    ('T (SPADCALL (SPADCALL |p| (QREFELT $ 86)) |n| (QREFELT $ 87))))) 

(DEFUN |XPBWPOLY;product;2$Nni$;26| (|x| |y| |n| $)
  (PROG (|t| #0=#:G1944 #1=#:G1942 #2=#:G1940 #3=#:G1941)
    (RETURN
      (SEQ (COND
             ((OR (SPADCALL |x| (|spadConstant| $ 21) (QREFELT $ 64))
                  (SPADCALL |y| (|spadConstant| $ 21) (QREFELT $ 64)))
              (|spadConstant| $ 21))
             ('T
              (PROGN
                (LETT #3# NIL . #4=(|XPBWPOLY;product;2$Nni$;26|))
                (SEQ (LETT |t| NIL . #4#) (LETT #0# |x| . #4#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL (QCDR |t|)
                                         (|XPBWPOLY;prod11| (QCAR |t|)
                                          |y| |n| $)
                                         (QREFELT $ 19)) . #4#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 20)) . #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 (|spadConstant| $ 21)))))))))) 

(DEFUN |XPBWPOLY;exp;$Nni$;27| (|p| |n| $)
  (PROG (|i| |k1| |k2| |s| |r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
              (|spadConstant| $ 24))
             ((NULL (SPADCALL |p| (QREFELT $ 75)))
              (|error| "a proper polynomial is required"))
             ('T
              (SEQ (LETT |s| (|spadConstant| $ 24)
                         . #0=(|XPBWPOLY;exp;$Nni$;27|))
                   (LETT |r| (|spadConstant| $ 24) . #0#)
                   (SEQ (LETT |i| 1 . #0#) G190
                        (COND ((QSGREATERP |i| |n|) (GO G191)))
                        (SEQ (LETT |k1|
                                   (SPADCALL 1 |i| (QREFELT $ 90)) . #0#)
                             (LETT |k2|
                                   (SPADCALL |k1| (|spadConstant| $ 9)
                                    (QREFELT $ 91)) . #0#)
                             (LETT |s|
                                   (SPADCALL |k2|
                                    (SPADCALL |p| |s| |n|
                                     (QREFELT $ 88))
                                    (QREFELT $ 19)) . #0#)
                             (EXIT (LETT |r|
                                    (SPADCALL |r| |s| (QREFELT $ 20)) . #0#)))
                        (LETT |i| (QSADD1 |i|) . #0#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT |r|)))))))) 

(DEFUN |XPBWPOLY;log;$Nni$;28| (|p| |n| $)
  (PROG (|p1| |i| |k1| |k2| |s| |r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (|spadConstant| $ 24) (QREFELT $ 64))
              (|spadConstant| $ 21))
             ('T
              (SEQ (LETT |p1|
                         (SPADCALL (|spadConstant| $ 24) |p|
                             (QREFELT $ 93))
                         . #0=(|XPBWPOLY;log;$Nni$;28|))
                   (COND
                     ((NULL (SPADCALL |p1| (QREFELT $ 75)))
                      (EXIT (|error| "constant term <> 1, impossible log "))))
                   (LETT |s|
                         (SPADCALL (|spadConstant| $ 24)
                             (QREFELT $ 94)) . #0#)
                   (LETT |r| (|spadConstant| $ 21) . #0#)
                   (SEQ (LETT |i| 1 . #0#) G190
                        (COND ((QSGREATERP |i| |n|) (GO G191)))
                        (SEQ (LETT |k1|
                                   (SPADCALL 1 |i| (QREFELT $ 90)) . #0#)
                             (LETT |k2|
                                   (SPADCALL |k1| (|spadConstant| $ 9)
                                    (QREFELT $ 91)) . #0#)
                             (LETT |s|
                                   (SPADCALL |p1| |s| |n|
                                    (QREFELT $ 88)) . #0#)
                             (EXIT (LETT |r|
                                    (SPADCALL
                                     (SPADCALL |k2| |s| (QREFELT $ 19))
                                     |r| (QREFELT $ 20)) . #0#)))
                        (LETT |i| (QSADD1 |i|) . #0#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT |r|)))))))) 

(DEFUN |XPBWPOLY;LiePolyIfCan;$U;29| (|p| $)
  (PROG (#0=#:G1969 #1=#:G1960 #2=#:G1958 #3=#:G1959 #4=#:G1970 |t|
            #5=#:G1971 |lt|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (|spadConstant| $ 21) (QREFELT $ 64))
              (CONS 0 (|spadConstant| $ 96)))
             ((PROGN
                (LETT #3# NIL . #6=(|XPBWPOLY;LiePolyIfCan;$U;29|))
                (SEQ (LETT |t| NIL . #6#) (LETT #0# |p| . #6#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |t| (CAR #0#) . #6#) NIL))
                        #7=(GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL (QCAR |t|)
                                         (QREFELT $ 97)) . #6#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (COND (#2# #1#) ('T 'NIL)) . #6#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #6#)
                                       (LETT #3# 'T . #6#)))))))
                     (LETT #0# (CDR #0#) . #6#) #8=(GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) ('T 'T)))
              (SEQ (LETT |lt|
                         (PROGN
                           (LETT #4# NIL . #6#)
                           (SEQ (LETT |t| NIL . #6#)
                                (LETT #5# |p| . #6#) G190
                                (COND
                                  ((OR (ATOM #5#)
                                    (PROGN
                                      (LETT |t| (CAR #5#) . #6#)
                                      NIL))
                                   #7#))
                                (SEQ (EXIT
                                      (LETT #4#
                                       (CONS
                                        (CONS
                                         (SPADCALL (QCAR |t|)
                                          (QREFELT $ 98))
                                         (QCDR |t|))
                                        #4#) . #6#)))
                                (LETT #5# (CDR #5#) . #6#) #8# G191
                                (EXIT (NREVERSE0 #4#)))) . #6#)
                   (EXIT (CONS 0 |lt|))))
             ('T (CONS 1 "failed"))))))) 

(DEFUN |XPBWPOLY;mirror;2$;30| (|p| $)
  (PROG (|t| #0=#:G1976 #1=#:G1974 #2=#:G1972 #3=#:G1973)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|XPBWPOLY;mirror;2$;30|))
             (SEQ (LETT |t| NIL . #4#) (LETT #0# |p| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |t| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL (QCDR |t|)
                                      (|XPBWPOLY;mirror1| (QCAR |t|) $)
                                      (QREFELT $ 19)) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 20)) . #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 (|spadConstant| $ 21)))))))) 

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

(DEFUN |XPBWPolynomial;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|XPBWPolynomial|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|XPBWPolynomial| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 114) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#2| '(|noZeroDivisors|))
                            (|HasCategory| |#2| '(|CommutativeRing|))
                            (|HasCategory| |#2|
                                '(|Module| (|Fraction| (|Integer|)))))) . #0#))
        (|haddProp| |$ConstructorCache| '|XPBWPolynomial|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8
            (|List| (|Record|
                        (|:| |k|
                             (|PoincareBirkhoffWittLyndonBasis| |#1|))
                        (|:| |c| |#2|))))
        (COND
          ((|testBitVector| |pv$| 3)
           (PROGN
             (QSETREFV $ 92
                 (CONS (|dispatchFunction| |XPBWPOLY;exp;$Nni$;27|) $))
             (QSETREFV $ 95
                 (CONS (|dispatchFunction| |XPBWPOLY;log;$Nni$;28|) $)))))
        $)))) 

(MAKEPROP '|XPBWPolynomial| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL (|FreeModule1| 7 13) (|local| |#1|)
             (|local| |#2|) '|Rep| (0 . |One|) (|Boolean|) (4 . =)
             (|OutputForm|) (|PoincareBirkhoffWittLyndonBasis| 6)
             (10 . |coerce|) (15 . |One|) (19 . =) (25 . |coerce|)
             (30 . *) (36 . *) (42 . +) (48 . |Zero|)
             (|NonNegativeInteger|) (52 . |length|)
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |XPBWPOLY;One;$;11|) $))
             (57 . |monom|) (|List| 28) (63 . |ListOfTerms|)
             (|LyndonWord| 6) (68 . |first|)
             (|XDistributedPolynomial| 6 7) (73 . |One|)
             (|LiePolynomial| 6 7) (77 . |LiePoly|) (82 . |coerce|)
             (87 . *) (|XRecursivePolynomial| 6 7) (93 . |One|)
             (97 . |coerce|) (102 . *) (108 . |mirror|) (113 . |rest|)
             |XPBWPOLY;coerce;Lp$;15| |XPBWPOLY;*;3$;22|
             (118 . |lexico|) (124 . |construct|)
             (|Record| (|:| |k| 28) (|:| |c| 7)) (|List| 46)
             (130 . |ListOfTerms|) (135 . |list|)
             |XPBWPOLY;coerce;R$;12| (140 . |Zero|) (144 . +)
             (|Mapping| 12 12 12) (|List| 12) (150 . |reduce|)
             |XPBWPOLY;coerce;$Of;13| (156 . |coerce|)
             |XPBWPOLY;coerce;VarSet$;14| (161 . |coerce|) (166 . *)
             (172 . +) (178 . |Zero|) |XPBWPOLY;coerce;$Xdp;16|
             (182 . =) (188 . |Zero|) (192 . *) (198 . +)
             |XPBWPOLY;coerce;$Xrp;17| (204 . |leadingMonomial|)
             |XPBWPOLY;constant?;$B;18|
             (|Record| (|:| |k| 13) (|:| |c| 7)) '"last" (209 . |elt|)
             |XPBWPOLY;constant;$R;19| |XPBWPOLY;quasiRegular?;$B;20|
             (|Integer|) (215 . |maxIndex|) (220 . |delete|)
             |XPBWPOLY;quasiRegular;2$;21| (|List| 6) (226 . |varList|)
             (231 . |setUnion|) (237 . |sort|) |XPBWPOLY;varList;$L;23|
             |XPBWPOLY;degree;$Nni;24| (242 . |reductum|)
             |XPBWPOLY;trunc;$Nni$;25| |XPBWPOLY;product;2$Nni$;26|
             (|Fraction| 76) (247 . /) (253 . *) (259 . |exp|)
             (265 . -) (271 . -) (276 . |log|) (282 . |Zero|)
             (286 . |retractable?|) (291 . |retract|)
             (|Union| 32 '"failed") |XPBWPOLY;LiePolyIfCan;$U;29|
             |XPBWPOLY;mirror;2$;30| (|Union| 13 '"failed") (|List| 71)
             (|List| $) (|List| 7) (|OrderedFreeMonoid| 6)
             (|Mapping| 7 7) (|Record| (|:| |k| 106) (|:| |c| 7))
             (|Union| 106 '"failed") (|Union| $ '"failed")
             (|PositiveInteger|) (|SingleInteger|) (|String|))
          '#(~= 296 |zero?| 302 |varList| 307 |trunc| 312
             |subtractIfCan| 318 |sh| 324 |sample| 336 |rquo| 340
             |retractIfCan| 358 |retract| 368 |reductum| 378 |recip|
             383 |quasiRegular?| 388 |quasiRegular| 393 |product| 398
             |one?| 405 |numberOfMonomials| 410 |monomials| 415
             |monomial?| 420 |monom| 425 |mirror| 437 |mindegTerm| 442
             |mindeg| 447 |maxdeg| 452 |map| 457 |lquo| 463 |log| 481
             |leadingTerm| 487 |leadingMonomial| 492
             |leadingCoefficient| 497 |latex| 502 |hash| 507 |exp| 512
             |degree| 518 |constant?| 523 |constant| 528 |coerce| 533
             |coefficients| 578 |coefficient| 583 |coef| 589
             |characteristic| 601 ^ 605 |Zero| 617 |One| 621
             |ListOfTerms| 625 |LiePolyIfCan| 630 = 635 - 641 + 652 **
             658 * 670)
          'NIL
          (CONS (|makeByteWordVec2| 2
                    '(0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
                      0 1))
                (CONS '#(NIL NIL NIL NIL |Algebra&| |Module&| NIL
                         |Ring&| NIL NIL NIL NIL |AbelianGroup&| NIL
                         NIL |AbelianMonoid&| |Monoid&| NIL
                         |SemiGroup&| |AbelianSemiGroup&|
                         |SetCategory&| |RetractableTo&|
                         |RetractableTo&| NIL |BasicType&| NIL NIL)
                      (CONS '#((|XPolynomialsCat| 6 7)
                               (|XFreeAlgebra| 6 7) (|XAlgebra| 7)
                               (|FreeModuleCat| 7
                                   (|PoincareBirkhoffWittLyndonBasis|
                                    6))
                               (|Algebra| 7) (|Module| 7)
                               (|BiModule| 7 7) (|Ring|)
                               (|LeftModule| 7) (|Rng|)
                               (|RightModule| 7) (|LeftModule| $$)
                               (|AbelianGroup|)
                               (|CancellationAbelianMonoid|)
                               (|SemiRing|) (|AbelianMonoid|)
                               (|Monoid|) (|SemiRng|) (|SemiGroup|)
                               (|AbelianSemiGroup|) (|SetCategory|)
                               (|RetractableTo|
                                   (|PoincareBirkhoffWittLyndonBasis|
                                    6))
                               (|RetractableTo|
                                   (|OrderedFreeMonoid| 6))
                               (|unitsKnown|) (|BasicType|)
                               (|CoercibleTo| 12) (|noZeroDivisors|))
                            (|makeByteWordVec2| 113
                                '(0 7 0 9 2 7 10 0 0 11 1 13 12 0 14 0
                                  13 0 15 2 13 10 0 0 16 1 7 12 0 17 2
                                  12 0 0 0 18 2 0 0 7 0 19 2 0 0 0 0 20
                                  0 0 0 21 1 13 22 0 23 2 0 0 13 7 25 1
                                  13 26 0 27 1 13 28 0 29 0 30 0 31 1
                                  32 0 28 33 1 32 30 0 34 2 30 0 0 0 35
                                  0 36 0 37 1 32 36 0 38 2 36 0 0 0 39
                                  1 32 0 0 40 1 13 0 0 41 2 28 10 0 0
                                  44 2 32 0 28 28 45 1 32 47 0 48 1 26
                                  0 28 49 0 7 0 51 2 12 0 0 0 52 2 54
                                  12 53 0 55 1 13 0 6 57 1 13 0 28 59 2
                                  30 0 7 0 60 2 30 0 0 0 61 0 30 0 62 2
                                  0 10 0 0 64 0 36 0 65 2 36 0 7 0 66 2
                                  36 0 0 0 67 1 0 13 0 69 2 8 71 0 72
                                  73 1 8 76 0 77 2 8 0 0 76 78 1 13 80
                                  0 81 2 80 0 0 0 82 1 80 0 0 83 1 0 0
                                  0 86 2 89 0 76 76 90 2 7 0 89 0 91 2
                                  0 0 0 22 92 2 0 0 0 0 93 1 0 0 0 94 2
                                  0 0 0 22 95 0 32 0 96 1 13 10 0 97 1
                                  13 28 0 98 2 0 10 0 0 1 1 0 10 0 1 1
                                  0 80 0 84 2 0 0 0 22 87 2 0 110 0 0 1
                                  2 2 0 0 22 1 2 2 0 0 0 1 0 0 0 1 2 0
                                  0 0 0 1 2 0 0 0 6 1 2 0 0 0 106 1 1 0
                                  102 0 1 1 0 109 0 1 1 0 13 0 1 1 0
                                  106 0 1 1 0 0 0 86 1 0 110 0 1 1 0 10
                                  0 75 1 0 0 0 79 3 0 0 0 0 22 88 1 0
                                  10 0 1 1 0 22 0 1 1 0 104 0 1 1 0 10
                                  0 1 2 0 0 13 7 25 2 0 0 106 7 1 1 0 0
                                  0 101 1 0 108 0 1 1 0 106 0 1 1 0 106
                                  0 1 2 0 0 107 0 1 2 0 0 0 106 1 2 0 0
                                  0 0 1 2 0 0 0 6 1 2 3 0 0 22 95 1 0
                                  71 0 1 1 0 13 0 69 1 0 7 0 1 1 0 113
                                  0 1 1 0 112 0 1 2 3 0 0 22 92 1 0 22
                                  0 85 1 0 10 0 70 1 0 7 0 74 1 0 30 0
                                  63 1 0 36 0 68 1 0 0 32 42 1 0 0 13 1
                                  1 0 0 6 58 1 0 0 106 1 1 0 0 7 50 1 0
                                  0 76 1 1 0 12 0 56 1 0 105 0 1 2 0 7
                                  0 13 1 2 0 7 0 0 1 2 0 7 0 106 1 0 0
                                  22 1 2 0 0 0 22 1 2 0 0 0 111 1 0 0 0
                                  21 0 0 0 24 1 0 103 0 1 1 0 99 0 100
                                  2 0 10 0 0 64 2 0 0 0 0 93 1 0 0 0 94
                                  2 0 0 0 0 20 2 0 0 0 22 1 2 0 0 0 111
                                  1 2 0 0 7 13 1 2 0 0 6 0 1 2 0 0 0 7
                                  1 2 0 0 7 0 19 2 0 0 0 0 43 2 0 0 76
                                  0 1 2 0 0 22 0 1 2 0 0 111 0 1)))))
          '|lookupComplete|)) 
