
(/VERSIONCHECK 2) 

(DEFUN |SKICOMB;ski;3$;1| (|x| |y| $) (CONS 1 (CONS |x| |y|))) 

(PUT '|SKICOMB;ski;UT$;2| '|SPADreplace| '(XLAM (|t1|) (CONS 2 |t1|))) 

(DEFUN |SKICOMB;ski;UT$;2| (|t1| $) (CONS 2 |t1|)) 

(DEFUN |SKICOMB;I;$;3| ($) (CONS 0 'I)) 

(DEFUN |SKICOMB;K;$;4| ($) (CONS 0 'K)) 

(DEFUN |SKICOMB;S;$;5| ($) (CONS 0 'S)) 

(DEFUN |SKICOMB;parseBracketTerm| (|t1| |pin| $)
  (PROG (|p1| #1=#:G1853 |ch| |trm| |r2|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |p1| |pin| . #2=(|SKICOMB;parseBracketTerm|))
            (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16)) . #2#)
            (COND
             ((NULL
               (SPADCALL |ch| (SPADCALL "(" (QREFELT $ 17)) (QREFELT $ 19)))
              (SEQ (|error| "bracket term must start with (")
                   (EXIT
                    (PROGN
                     (LETT #1# (CONS (CONS 0 'I) |p1|) . #2#)
                     (GO #1#))))))
            (LETT |p1| (+ |p1| 1) . #2#)
            (COND
             ((SPADCALL |p1| (SPADCALL |t1| (QREFELT $ 20)) (QREFELT $ 21))
              (SEQ (|error| "opening but no closing bracket")
                   (EXIT
                    (PROGN
                     (LETT #1# (CONS (CONS 0 'I) |p1|) . #2#)
                     (GO #1#))))))
            (LETT |r2| (SPADCALL |t1| |p1| (QREFELT $ 24)) . #2#)
            (LETT |trm| (QCAR |r2|) . #2#) (LETT |p1| (QCDR |r2|) . #2#)
            (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16)) . #2#)
            (COND
             ((NULL
               (SPADCALL |ch| (SPADCALL ")" (QREFELT $ 17)) (QREFELT $ 19)))
              (SEQ (|error| "can't find closing bracket")
                   (EXIT
                    (PROGN
                     (LETT #1# (CONS (CONS 0 'I) |p1|) . #2#)
                     (GO #1#))))))
            (LETT |p1| (+ |p1| 1) . #2#) (EXIT (CONS |trm| |p1|))))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;parseCombinatorTerm| (|t1| |pin| $)
  (PROG (#1=#:G1858 |ch| |p1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |p1| |pin| . #2=(|SKICOMB;parseCombinatorTerm|))
            (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16)) . #2#)
            (COND
             ((SPADCALL |ch| (SPADCALL "I" (QREFELT $ 17)) (QREFELT $ 19))
              (PROGN (LETT #1# (CONS (CONS 0 'I) (+ |p1| 1)) . #2#) (GO #1#))))
            (COND
             ((SPADCALL |ch| (SPADCALL "K" (QREFELT $ 17)) (QREFELT $ 19))
              (PROGN (LETT #1# (CONS (CONS 0 'K) (+ |p1| 1)) . #2#) (GO #1#))))
            (COND
             ((SPADCALL |ch| (SPADCALL "S" (QREFELT $ 17)) (QREFELT $ 19))
              (PROGN (LETT #1# (CONS (CONS 0 'S) (+ |p1| 1)) . #2#) (GO #1#))))
            (|error| "invalid combinator")
            (EXIT (CONS (CONS 0 'I) (+ |p1| 1)))))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;parseOneTerm| (|t1| |pin| $)
  (PROG (|p1| |res| |r| |r2| |ch| #1=#:G1871)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |p1| |pin| . #2=(|SKICOMB;parseOneTerm|))
            (LETT |res| (CONS 0 'I) . #2#)
            (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16)) . #2#)
            (SEQ G190
                 (COND
                  ((NULL
                    (SPADCALL |ch| (SPADCALL " " (QREFELT $ 17))
                              (QREFELT $ 19)))
                   (GO G191)))
                 (SEQ (LETT |p1| (+ |p1| 1) . #2#)
                      (COND
                       ((SPADCALL |p1| (SPADCALL |t1| (QREFELT $ 20))
                                  (QREFELT $ 21))
                        (PROGN (LETT #1# (CONS |res| |p1|) . #2#) (GO #1#))))
                      (EXIT
                       (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16)) . #2#)))
                 NIL (GO G190) G191 (EXIT NIL))
            (COND
             ((SPADCALL |ch| (QREFELT $ 25))
              (SEQ
               (COND
                ((SPADCALL |ch| (QREFELT $ 26))
                 (SEQ
                  (LETT |r| (|SKICOMB;parseCombinatorTerm| |t1| |p1| $) . #2#)
                  (LETT |res| (QCAR |r|) . #2#)
                  (EXIT (LETT |p1| (QCDR |r|) . #2#)))))
               (EXIT
                (COND
                 ((SPADCALL |ch| (QREFELT $ 27))
                  (SEQ (LETT |r2| (SPADCALL |t1| |p1| (QREFELT $ 28)) . #2#)
                       (LETT |res| (SPADCALL (QCAR |r2|) (QREFELT $ 9)) . #2#)
                       (EXIT (LETT |p1| (QCDR |r2|) . #2#)))))))))
            (COND
             ((SPADCALL |ch| (SPADCALL "(" (QREFELT $ 17)) (QREFELT $ 19))
              (SEQ (LETT |r| (|SKICOMB;parseBracketTerm| |t1| |p1| $) . #2#)
                   (LETT |res| (QCAR |r|) . #2#)
                   (EXIT (LETT |p1| (QCDR |r|) . #2#)))))
            (EXIT (CONS |res| |p1|))))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;parseTerm;SNniR;9| (|t1| |pin| $)
  (PROG (|res| #1=#:G1898 |i| |ch| |stck| |p1| |r| #2=#:G1897)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |p1| |pin| . #3=(|SKICOMB;parseTerm;SNniR;9|))
            (LETT |r| (|SKICOMB;parseOneTerm| |t1| |p1| $) . #3#)
            (LETT |res| (QCAR |r|) . #3#) (LETT |p1| (QCDR |r|) . #3#)
            (COND
             ((SPADCALL |p1| (SPADCALL |t1| (QREFELT $ 20)) (QREFELT $ 21))
              (PROGN (LETT #2# (CONS |res| |p1|) . #3#) (GO #2#))))
            (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16)) . #3#)
            (LETT |stck| NIL . #3#)
            (SEQ G190
                 (COND
                  ((NULL
                    (COND
                     ((OR (SPADCALL |ch| (QREFELT $ 25))
                          (SPADCALL |ch| (SPADCALL " " (QREFELT $ 17))
                                    (QREFELT $ 19)))
                      'T)
                     ('T
                      (SPADCALL |ch| (SPADCALL "(" (QREFELT $ 17))
                                (QREFELT $ 19)))))
                   (GO G191)))
                 (SEQ (LETT |r| (|SKICOMB;parseOneTerm| |t1| |p1| $) . #3#)
                      (LETT |p1| (QCDR |r|) . #3#)
                      (LETT |stck| (SPADCALL |stck| (QCAR |r|) (QREFELT $ 30))
                            . #3#)
                      (EXIT
                       (COND
                        ((SPADCALL |p1| (SPADCALL |t1| (QREFELT $ 20))
                                   (QREFELT $ 21))
                         (LETT |ch| (SPADCALL "*" (QREFELT $ 17)) . #3#))
                        ('T
                         (LETT |ch| (SPADCALL |t1| |p1| (QREFELT $ 16))
                               . #3#)))))
                 NIL (GO G190) G191 (EXIT NIL))
            (SEQ (LETT |i| 1 . #3#)
                 (LETT #1# (SPADCALL |stck| (QREFELT $ 31)) . #3#) G190
                 (COND ((QSGREATERP |i| #1#) (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT |res|
                         (SPADCALL |res| (SPADCALL |stck| |i| (QREFELT $ 32))
                                   (QREFELT $ 8))
                         . #3#)))
                 (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191 (EXIT NIL))
            (EXIT (CONS |res| |p1|))))
      #2# (EXIT #2#))))) 

(DEFUN |SKICOMB;parseSki;S$;10| (|t1| $)
  (PROG (|r| #1=#:G1899)
    (RETURN
     (SEQ
      (LETT |r|
            (SPADCALL |t1|
                      (PROG1
                          (LETT #1# (SPADCALL |t1| (QREFELT $ 33))
                                . #2=(|SKICOMB;parseSki;S$;10|))
                        (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                         #1#))
                      (QREFELT $ 24))
            . #2#)
      (EXIT (QCAR |r|)))))) 

(DEFUN |SKICOMB;getChildren;$L;11| (|n| $)
  (PROG (#1=#:G1835 #2=#:G1905)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL |n| (QREFELT $ 35))
          (PROGN (LETT #2# NIL . #3=(|SKICOMB;getChildren;$L;11|)) (GO #2#))))
        (EXIT
         (LIST
          (QCAR
           (PROG2
               (LETT #1# |n| . #3#)
               (QCDR #1#)
             (|check-union| (QEQCAR #1# 1) (|Record| (|:| |c1| $) (|:| |c2| $))
                            #1#)))
          (QCDR
           (PROG2
               (LETT #1# |n| . #3#)
               (QCDR #1#)
             (|check-union| (QEQCAR #1# 1) (|Record| (|:| |c1| $) (|:| |c2| $))
                            #1#)))))))
      #2# (EXIT #2#))))) 

(DEFUN |SKICOMB;atom?;$B;12| (|n| $)
  (COND ((QEQCAR |n| 0) 'T) ('T (QEQCAR |n| 2)))) 

(PUT '|SKICOMB;variable?;$B;13| '|SPADreplace| '(XLAM (|n|) (QEQCAR |n| 2))) 

(DEFUN |SKICOMB;variable?;$B;13| (|n| $) (QEQCAR |n| 2)) 

(DEFUN |SKICOMB;isI?;$B;14| (|n| $)
  (PROG (#1=#:G1920)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((NULL (QEQCAR |n| 0))
          (PROGN (LETT #1# 'NIL . #2=(|SKICOMB;isI?;$B;14|)) (GO #1#))))
        (COND ((EQUAL (CDR |n|) 'I) (PROGN (LETT #1# 'T . #2#) (GO #1#))))
        (EXIT 'NIL)))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;isK?;$B;15| (|n| $)
  (PROG (#1=#:G1927)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((NULL (QEQCAR |n| 0))
          (PROGN (LETT #1# 'NIL . #2=(|SKICOMB;isK?;$B;15|)) (GO #1#))))
        (COND ((EQUAL (CDR |n|) 'K) (PROGN (LETT #1# 'T . #2#) (GO #1#))))
        (EXIT 'NIL)))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;isS?;$B;16| (|n| $)
  (PROG (#1=#:G1934)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((NULL (QEQCAR |n| 0))
          (PROGN (LETT #1# 'NIL . #2=(|SKICOMB;isS?;$B;16|)) (GO #1#))))
        (COND ((EQUAL (CDR |n|) 'S) (PROGN (LETT #1# 'T . #2#) (GO #1#))))
        (EXIT 'NIL)))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;getVariable;$UT;17| (|n| $)
  (PROG (#1=#:G1936)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((QEQCAR |n| 2)
          (PROGN (LETT #1# (CDR |n|) |SKICOMB;getVariable;$UT;17|) (GO #1#))))
        (EXIT (SPADCALL " " (QREFELT $ 42)))))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;freeVariable?;$UTB;18| (|n| |s| $)
  (PROG (#1=#:G1945)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((QEQCAR |n| 2)
          (COND
           ((SPADCALL (CDR |n|) |s| (QREFELT $ 44))
            (PROGN
             (LETT #1# 'NIL . #2=(|SKICOMB;freeVariable?;$UTB;18|))
             (GO #1#))))))
        (COND
         ((QEQCAR |n| 1)
          (COND
           ((SPADCALL (QCAR (CDR |n|)) |s| (QREFELT $ 45))
            (COND
             ((NULL (SPADCALL (QCDR (CDR |n|)) |s| (QREFELT $ 45)))
              (PROGN (LETT #1# 'NIL . #2#) (GO #1#)))))
           ('T (PROGN (LETT #1# 'NIL . #2#) (GO #1#))))))
        (EXIT 'T)))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;toString;$S;19| (|n| $)
  (PROG (|s|)
    (RETURN
     (SEQ (LETT |s| "" . #1=(|SKICOMB;toString;$S;19|))
          (COND
           ((QEQCAR |n| 0)
            (SEQ (COND ((EQUAL (CDR |n|) 'I) (LETT |s| "I" . #1#)))
                 (COND ((EQUAL (CDR |n|) 'K) (LETT |s| "K" . #1#)))
                 (EXIT (COND ((EQUAL (CDR |n|) 'S) (LETT |s| "S" . #1#)))))))
          (COND
           ((QEQCAR |n| 1)
            (COND
             ((SPADCALL (QCDR (CDR |n|)) (QREFELT $ 35))
              (COND
               ((SPADCALL (QCDR (CDR |n|)) (QREFELT $ 38))
                (LETT |s|
                      (SPADCALL
                       (LIST |s| (SPADCALL (QCAR (CDR |n|)) (QREFELT $ 46)) " "
                             (SPADCALL (QCDR (CDR |n|)) (QREFELT $ 46)))
                       (QREFELT $ 47))
                      . #1#))
               (#2='T
                (LETT |s|
                      (SPADCALL
                       (LIST |s| (SPADCALL (QCAR (CDR |n|)) (QREFELT $ 46))
                             (SPADCALL (QCDR (CDR |n|)) (QREFELT $ 46)))
                       (QREFELT $ 47))
                      . #1#))))
             (#2#
              (LETT |s|
                    (SPADCALL
                     (LIST |s| (SPADCALL (QCAR (CDR |n|)) (QREFELT $ 46)) "("
                           (SPADCALL (QCDR (CDR |n|)) (QREFELT $ 46)) ")")
                     (QREFELT $ 47))
                    . #1#)))))
          (COND
           ((QEQCAR |n| 2)
            (LETT |s| (SPADCALL (CDR |n|) (QREFELT $ 48)) . #1#)))
          (EXIT |s|))))) 

(DEFUN |SKICOMB;redux1| (|n| $)
  (PROG (#1=#:G1963 |leftleftright| |leftleftleft| |leftright| |leftleft|
         |right| |left|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((QEQCAR |n| 1)
          (SEQ
           (LETT |left| (|SKICOMB;redux1| (QCAR (CDR |n|)) $)
                 . #2=(|SKICOMB;redux1|))
           (LETT |right| (|SKICOMB;redux1| (QCDR (CDR |n|)) $) . #2#)
           (COND
            ((SPADCALL |left| (QREFELT $ 39))
             (PROGN (LETT #1# |right| . #2#) (GO #1#))))
           (COND
            ((NULL (QEQCAR |left| 1))
             (PROGN
              (LETT #1# (SPADCALL |left| |right| (QREFELT $ 8)) . #2#)
              (GO #1#))))
           (LETT |leftleft| (QCAR (CDR |left|)) . #2#)
           (LETT |leftright| (QCDR (CDR |left|)) . #2#)
           (COND
            ((SPADCALL |leftleft| (QREFELT $ 40))
             (PROGN (LETT #1# |leftright| . #2#) (GO #1#))))
           (COND
            ((NULL (QEQCAR |leftleft| 1))
             (PROGN
              (LETT #1# (SPADCALL |left| |right| (QREFELT $ 8)) . #2#)
              (GO #1#))))
           (LETT |leftleftleft| (QCAR (CDR |leftleft|)) . #2#)
           (LETT |leftleftright| (QCDR (CDR |leftleft|)) . #2#)
           (COND
            ((SPADCALL |leftleftleft| (QREFELT $ 41))
             (PROGN
              (LETT #1#
                    (SPADCALL (SPADCALL |leftleftright| |right| (QREFELT $ 8))
                              (SPADCALL |leftright| |right| (QREFELT $ 8))
                              (QREFELT $ 8))
                    . #2#)
              (GO #1#))))
           (EXIT
            (PROGN
             (LETT #1# (SPADCALL |left| |right| (QREFELT $ 8)) . #2#)
             (GO #1#))))))
        (EXIT |n|)))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;redux;2$;21| (|n| $)
  (PROG (|triesLeft| #1=#:G1965 |thisResult| |lastResult|)
    (RETURN
     (SEQ (LETT |lastResult| (CONS 0 'I) . #2=(|SKICOMB;redux;2$;21|))
          (LETT |thisResult| (|SKICOMB;redux1| |n| $) . #2#)
          (LETT |triesLeft| 20 . #2#)
          (SEQ G190
               (COND
                ((NULL
                  (COND
                   ((SPADCALL |lastResult| |thisResult| (QREFELT $ 49))
                    (SPADCALL |triesLeft| 1 (QREFELT $ 50)))
                   ('T 'NIL)))
                 (GO G191)))
               (SEQ (LETT |lastResult| |thisResult| . #2#)
                    (LETT |thisResult| (|SKICOMB;redux1| |lastResult| $) . #2#)
                    (LETT |triesLeft|
                          (PROG1 (LETT #1# (- |triesLeft| 1) . #2#)
                            (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                             #1#))
                          . #2#)
                    (EXIT
                     (|sayBrightly| (SPADCALL |lastResult| (QREFELT $ 46)))))
               NIL (GO G190) G191 (EXIT NIL))
          (EXIT |thisResult|))))) 

(DEFUN |SKICOMB;=;2$B;22| (|x| |y| $)
  (PROG (#1=#:G1982)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((QEQCAR |x| 0)
          (COND
           ((QEQCAR |y| 0)
            (SEQ
             (COND
              ((EQUAL (CDR |x|) (CDR |y|))
               (PROGN (LETT #1# 'T . #2=(|SKICOMB;=;2$B;22|)) (GO #1#))))
             (EXIT (PROGN (LETT #1# 'NIL . #2#) (GO #1#))))))))
        (COND
         ((QEQCAR |x| 2)
          (COND
           ((QEQCAR |y| 2)
            (SEQ
             (COND
              ((SPADCALL (CDR |x|) (CDR |y|) (QREFELT $ 44))
               (PROGN (LETT #1# 'T . #2#) (GO #1#))))
             (EXIT (PROGN (LETT #1# 'NIL . #2#) (GO #1#))))))))
        (COND
         ((QEQCAR |x| 1)
          (COND
           ((QEQCAR |y| 1)
            (SEQ
             (COND
              ((SPADCALL (QCAR (CDR |x|)) (QCAR (CDR |y|)) (QREFELT $ 52))
               (COND
                ((SPADCALL (QCDR (CDR |x|)) (QCDR (CDR |y|)) (QREFELT $ 52))
                 (PROGN (LETT #1# 'T . #2#) (GO #1#))))))
             (EXIT (PROGN (LETT #1# 'NIL . #2#) (GO #1#))))))))
        (EXIT 'NIL)))
      #1# (EXIT #1#))))) 

(DEFUN |SKICOMB;coerce;$Of;23| (|n| $)
  (SPADCALL (SPADCALL |n| (QREFELT $ 46)) (QREFELT $ 54))) 

(DEFUN |SKICombinators| (#1=#:G1984)
  (PROG ()
    (RETURN
     (PROG (#2=#:G1985)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|SKICombinators|)
                                           '|domainEqualList|)
                . #3=(|SKICombinators|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|SKICombinators;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#) (HREM |$ConstructorCache| '|SKICombinators|))))))))))) 

(DEFUN |SKICombinators;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|SKICombinators|))
      (LETT |dv$| (LIST '|SKICombinators| DV$1) . #1#)
      (LETT $ (GETREFV 56) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|SKICombinators| (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 7
                (|Union| (|:| |lf| (|Symbol|))
                         (|:| |nd| (|Record| (|:| |c1| $) (|:| |c2| $)))
                         (|:| |vr| |#1|)))
      $)))) 

(MAKEPROP '|SKICombinators| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep| |SKICOMB;ski;3$;1|
              |SKICOMB;ski;UT$;2| |SKICOMB;I;$;3| |SKICOMB;K;$;4|
              |SKICOMB;S;$;5| (|Character|) (|Integer|) (|String|) (0 . |qelt|)
              (6 . |char|) (|Boolean|) (11 . =) (17 . |maxIndex|) (22 . >)
              (|Record| (|:| |rft| $) (|:| |pout| 23)) (|NonNegativeInteger|)
              |SKICOMB;parseTerm;SNniR;9| (28 . |alphabetic?|)
              (33 . |upperCase?|) (38 . |lowerCase?|) (43 . |parseVarTerm|)
              (|List| $$) (49 . |concat|) (55 . |#|) (60 . |elt|)
              (66 . |minIndex|) |SKICOMB;parseSki;S$;10| |SKICOMB;atom?;$B;12|
              (|List| $) |SKICOMB;getChildren;$L;11| |SKICOMB;variable?;$B;13|
              |SKICOMB;isI?;$B;14| |SKICOMB;isK?;$B;15| |SKICOMB;isS?;$B;16|
              (71 . |var|) |SKICOMB;getVariable;$UT;17| (76 . =)
              |SKICOMB;freeVariable?;$UTB;18| |SKICOMB;toString;$S;19|
              (82 . |concat|) (87 . |toString|) (92 . ~=) (98 . >)
              |SKICOMB;redux;2$;21| |SKICOMB;=;2$B;22| (|OutputForm|)
              (104 . |coerce|) |SKICOMB;coerce;$Of;23|)
           '#(|variable?| 109 |toString| 114 |ski| 119 |redux| 130 |parseTerm|
              135 |parseSki| 141 |isS?| 146 |isK?| 151 |isI?| 156 |getVariable|
              161 |getChildren| 166 |freeVariable?| 171 |coerce| 177 |atom?|
              182 S 187 K 191 I 195 = 199)
           'NIL
           (CONS (|makeByteWordVec2| 1 '(0))
                 (CONS '#(NIL)
                       (CONS '#((|CoercibleTo| 53))
                             (|makeByteWordVec2| 55
                                                 '(2 15 13 0 14 16 1 13 0 15 17
                                                   2 13 18 0 0 19 1 15 14 0 20
                                                   2 14 18 0 0 21 1 13 18 0 25
                                                   1 13 18 0 26 1 13 18 0 27 2
                                                   6 22 15 23 28 2 29 0 0 2 30
                                                   1 29 23 0 31 2 29 2 0 14 32
                                                   1 15 14 0 33 1 6 0 15 42 2 6
                                                   18 0 0 44 1 15 0 36 47 1 6
                                                   15 0 48 2 7 18 2 2 49 2 23
                                                   18 0 0 50 1 15 53 0 54 1 0
                                                   18 0 38 1 0 15 0 46 1 0 0 6
                                                   9 2 0 0 0 0 8 1 0 0 0 51 2 0
                                                   22 15 23 24 1 0 0 15 34 1 0
                                                   18 0 41 1 0 18 0 40 1 0 18 0
                                                   39 1 0 6 0 43 1 0 36 0 37 2
                                                   0 18 0 6 45 1 0 53 0 55 1 0
                                                   18 0 35 0 0 0 12 0 0 0 11 0
                                                   0 0 10 2 0 18 0 0 52)))))
           '|lookupComplete|)) 
