
(/VERSIONCHECK 2) 

(DEFUN |TABLBUMP;bumprow;MLLR;1| (|cf| |x| |lls| $)
  (PROG (|y| |rw|)
    (RETURN
      (SEQ (COND
             ((NULL |lls|) (VECTOR 'NIL |x| (LIST |x|)))
             ('T
              (SEQ (LETT |y| (|SPADfirst| |lls|)
                         . #0=(|TABLBUMP;bumprow;MLLR;1|))
                   (EXIT (COND
                           ((SPADCALL (SPADCALL |x| 2 (QREFELT $ 9))
                                (SPADCALL |y| 2 (QREFELT $ 9)) |cf|)
                            (VECTOR 'T
                                    (LIST
                                     (SPADCALL |x| 1 (QREFELT $ 9))
                                     (SPADCALL |y| 2 (QREFELT $ 9)))
                                    (CONS
                                     (LIST
                                      (SPADCALL |y| 1 (QREFELT $ 9))
                                      (SPADCALL |x| 2 (QREFELT $ 9)))
                                     (CDR |lls|))))
                           ('T
                            (SEQ (LETT |rw|
                                       (SPADCALL |cf| |x| (CDR |lls|)
                                        (QREFELT $ 13)) . #0#)
                                 (EXIT (VECTOR (QVELT |rw| 0)
                                        (QVELT |rw| 1)
                                        (CONS (|SPADfirst| |lls|)
                                         (QVELT |rw| 2))))))))))))))) 

(DEFUN |TABLBUMP;bumptab;ML2L;2| (|cf| |x| |llls| $)
  (PROG (|rw|)
    (RETURN
      (SEQ (COND
             ((NULL |llls|) (LIST (LIST |x|)))
             ('T
              (SEQ (LETT |rw|
                         (SPADCALL |cf| |x| (|SPADfirst| |llls|)
                             (QREFELT $ 13))
                         |TABLBUMP;bumptab;ML2L;2|)
                   (EXIT (COND
                           ((QVELT |rw| 0)
                            (CONS (QVELT |rw| 2)
                                  (SPADCALL |cf| (QVELT |rw| 1)
                                      (CDR |llls|) (QREFELT $ 15))))
                           ('T (CONS (QVELT |rw| 2) (CDR |llls|)))))))))))) 

(DEFUN |TABLBUMP;bumptab1;L2L;3| (|x| |llls| $)
  (SPADCALL (CONS #'|TABLBUMP;bumptab1;L2L;3!0| $) |x| |llls|
      (QREFELT $ 15))) 

(DEFUN |TABLBUMP;bumptab1;L2L;3!0| (|#1| |#2| $)
  (SPADCALL |#1| |#2| (QREFELT $ 17))) 

(DEFUN |TABLBUMP;tab1;LL;4| (|lls| $)
  (SPADCALL NIL (ELT $ 18) (SPADCALL |lls| (QREFELT $ 20))
      (QREFELT $ 23))) 

(DEFUN |TABLBUMP;lexorder| (|p1| |p2| $)
  (COND
    ((SPADCALL (SPADCALL |p1| 1 (QREFELT $ 9))
         (SPADCALL |p2| 1 (QREFELT $ 9)) (QREFELT $ 25))
     (SPADCALL (SPADCALL |p1| 2 (QREFELT $ 9))
         (SPADCALL |p2| 2 (QREFELT $ 9)) (QREFELT $ 17)))
    ('T
     (SPADCALL (SPADCALL |p1| 1 (QREFELT $ 9))
         (SPADCALL |p2| 1 (QREFELT $ 9)) (QREFELT $ 17))))) 

(DEFUN |TABLBUMP;lex;2L;6| (|lp| $)
  (SPADCALL (CONS #'|TABLBUMP;lex;2L;6!0| $) |lp| (QREFELT $ 27))) 

(DEFUN |TABLBUMP;lex;2L;6!0| (|#1| |#2| $)
  (|TABLBUMP;lexorder| |#1| |#2| $)) 

(DEFUN |TABLBUMP;slex;LL;7| (|ls| $)
  (PROG (#0=#:G1840 |j| #1=#:G1842 |i| #2=#:G1841)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #3=(|TABLBUMP;slex;LL;7|))
                 (SEQ (LETT |j| NIL . #3#) (LETT #1# |ls| . #3#)
                      (LETT |i| NIL . #3#)
                      (LETT #2#
                            (SPADCALL (CONS #'|TABLBUMP;slex;LL;7!0| $)
                                |ls| (QREFELT $ 29)) . #3#)
                      G190
                      (COND
                        ((OR (ATOM #2#)
                             (PROGN (LETT |i| (CAR #2#) . #3#) NIL)
                             (ATOM #1#)
                             (PROGN (LETT |j| (CAR #1#) . #3#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS (LIST |i| |j|) #0#) . #3#)))
                      (LETT #2#
                            (PROG1 (CDR #2#)
                              (LETT #1# (CDR #1#) . #3#)) . #3#)
                      (GO G190) G191 (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 28)))))) 

(DEFUN |TABLBUMP;slex;LL;7!0| (|#1| |#2| $)
  (SPADCALL |#1| |#2| (QREFELT $ 17))) 

(DEFUN |TABLBUMP;inverse;2L;8| (|ls| $)
  (PROG (#0=#:G1846 |lss| #1=#:G1848 |j| #2=#:G1850 |i| #3=#:G1849
            #4=#:G1847)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #5=(|TABLBUMP;inverse;2L;8|))
             (SEQ (LETT |lss| NIL . #5#)
                  (LETT #4#
                        (SPADCALL
                            (PROGN
                              (LETT #1# NIL . #5#)
                              (SEQ (LETT |j| NIL . #5#)
                                   (LETT #2# |ls| . #5#)
                                   (LETT |i| NIL . #5#)
                                   (LETT #3#
                                    (SPADCALL
                                     (CONS #'|TABLBUMP;inverse;2L;8!0|
                                      $)
                                     |ls| (QREFELT $ 29)) . #5#)
                                   G190
                                   (COND
                                     ((OR (ATOM #3#)
                                       (PROGN
                                         (LETT |i| (CAR #3#) . #5#)
                                         NIL)
                                       (ATOM #2#)
                                       (PROGN
                                         (LETT |j| (CAR #2#) . #5#)
                                         NIL))
                                      #6=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #1#
                                      (CONS (LIST |j| |i|) #1#) . #5#)))
                                   (LETT #3#
                                    (PROG1 (CDR #3#)
                                      (LETT #2# (CDR #2#) . #5#)) . #5#)
                                   #7=(GO G190) G191
                                   (EXIT (NREVERSE0 #1#))))
                            (QREFELT $ 28)) . #5#)
                  G190
                  (COND
                    ((OR (ATOM #4#)
                         (PROGN (LETT |lss| (CAR #4#) . #5#) NIL))
                     #6#))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL |lss| 2 (QREFELT $ 9))
                                    #0#) . #5#)))
                  (LETT #4# (CDR #4#) . #5#) #7# G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |TABLBUMP;inverse;2L;8!0| (|#1| |#2| $)
  (SPADCALL |#1| |#2| (QREFELT $ 17))) 

(DEFUN |TABLBUMP;tab;LT;9| (|ls| $)
  (SPADCALL (SPADCALL (SPADCALL |ls| (QREFELT $ 30)) (QREFELT $ 24))
      (QREFELT $ 33))) 

(DEFUN |TABLBUMP;maxrow;LLL3LR;10| (|n| |a| |b| |c| |d| |llls| $)
  (PROG (|fst| |rst|)
    (RETURN
      (SEQ (COND
             ((OR (NULL |llls|) (NULL (|SPADfirst| |llls|)))
              (VECTOR |n| |a| |b| |c|))
             ('T
              (SEQ (LETT |fst| (|SPADfirst| (|SPADfirst| |llls|))
                         . #0=(|TABLBUMP;maxrow;LLL3LR;10|))
                   (LETT |rst| (CDR (|SPADfirst| |llls|)) . #0#)
                   (EXIT (COND
                           ((SPADCALL (SPADCALL |n| 1 (QREFELT $ 9))
                                (SPADCALL |fst| 1 (QREFELT $ 9))
                                (QREFELT $ 17))
                            (SPADCALL |fst| |d| |rst| (CDR |llls|)
                                (CONS (|SPADfirst| |llls|) |d|)
                                (CDR |llls|) (QREFELT $ 36)))
                           ('T
                            (SPADCALL |n| |a| |b| |c|
                                (CONS (|SPADfirst| |llls|) |d|)
                                (CDR |llls|) (QREFELT $ 36)))))))))))) 

(DEFUN |TABLBUMP;mr;LR;11| (|llls| $)
  (SPADCALL (|SPADfirst| (|SPADfirst| |llls|)) NIL
      (CDR (|SPADfirst| |llls|)) (CDR |llls|) NIL |llls|
      (QREFELT $ 36))) 

(DEFUN |TABLBUMP;untab;LLL;12| (|lp| |llls| $)
  (PROG (|rc| |rv|)
    (RETURN
      (SEQ (COND
             ((NULL |llls|) |lp|)
             ('T
              (SEQ (LETT |rc| (SPADCALL |llls| (QREFELT $ 37))
                         . #0=(|TABLBUMP;untab;LLL;12|))
                   (LETT |rv|
                         (REVERSE (SPADCALL
                                      (CONS #'|TABLBUMP;untab;LLL;12!0|
                                       $)
                                      (QVELT |rc| 0) (QVELT |rc| 1)
                                      (QREFELT $ 15))) . #0#)
                   (EXIT (SPADCALL
                             (CONS (|SPADfirst| (|SPADfirst| |rv|))
                                   |lp|)
                             (APPEND (CDR |rv|)
                                     (COND
                                       ((NULL (QVELT |rc| 2)) NIL)
                                       ('T
                                        (CONS (QVELT |rc| 2)
                                         (QVELT |rc| 3)))))
                             (QREFELT $ 38)))))))))) 

(DEFUN |TABLBUMP;untab;LLL;12!0| (|#1| |#2| $)
  (SPADCALL |#2| |#1| (QREFELT $ 17))) 

(DEFUN |TABLBUMP;bat1;LL;13| (|llls| $)
  (PROG (#0=#:G1865 |lls| #1=#:G1866)
    (RETURN
      (SEQ (SPADCALL NIL
               (PROGN
                 (LETT #0# NIL . #2=(|TABLBUMP;bat1;LL;13|))
                 (SEQ (LETT |lls| NIL . #2#) (LETT #1# |llls| . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |lls| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS (REVERSE |lls|) #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 38)))))) 

(DEFUN |TABLBUMP;bat;TL;14| (|tb| $)
  (SPADCALL (SPADCALL |tb| (QREFELT $ 40)) (QREFELT $ 39))) 

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

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

(MAKEPROP '|TableauxBumpers| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Integer|)
             (|List| 6) (0 . |elt|)
             (|Record| (|:| |fs| 16) (|:| |sd| 8) (|:| |td| 12))
             (|Mapping| 16 6 6) (|List| 8) |TABLBUMP;bumprow;MLLR;1|
             (|List| 12) |TABLBUMP;bumptab;ML2L;2| (|Boolean|) (6 . <)
             |TABLBUMP;bumptab1;L2L;3| (|Stream| 8) (12 . |coerce|)
             (|Mapping| 14 8 14) (|StreamFunctions2| 8 14)
             (17 . |reduce|) |TABLBUMP;tab1;LL;4| (24 . =)
             (|Mapping| 16 8 8) (30 . |sort|) |TABLBUMP;lex;2L;6|
             (36 . |sort|) |TABLBUMP;slex;LL;7| |TABLBUMP;inverse;2L;8|
             (|Tableau| 8) (42 . |tableau|) |TABLBUMP;tab;LT;9|
             (|Record| (|:| |f1| 8) (|:| |f2| 14) (|:| |f3| 12)
                 (|:| |f4| 14))
             |TABLBUMP;maxrow;LLL3LR;10| |TABLBUMP;mr;LR;11|
             |TABLBUMP;untab;LLL;12| |TABLBUMP;bat1;LL;13|
             (47 . |listOfLists|) |TABLBUMP;bat;TL;14|)
          '#(|untab| 52 |tab1| 58 |tab| 63 |slex| 68 |mr| 73 |maxrow|
             78 |lex| 88 |inverse| 93 |bumptab1| 98 |bumptab| 104
             |bumprow| 111 |bat1| 118 |bat| 123)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 41
                                '(2 8 6 0 7 9 2 6 16 0 0 17 1 19 0 12
                                  20 3 22 14 14 21 19 23 2 6 16 0 0 25
                                  2 12 0 26 0 27 2 8 0 11 0 29 1 32 0
                                  14 33 1 32 14 0 40 2 0 12 12 14 38 1
                                  0 14 12 24 1 0 32 8 34 1 0 12 8 30 1
                                  0 35 14 37 6 0 35 8 14 12 14 14 14 36
                                  1 0 12 12 28 1 0 8 8 31 2 0 14 8 14
                                  18 3 0 14 11 8 14 15 3 0 10 11 8 12
                                  13 1 0 12 14 39 1 0 12 32 41)))))
          '|lookupComplete|)) 
