
(/VERSIONCHECK 2) 

(PUT '|TREE;empty?;$B;1| '|SPADreplace| '(XLAM (|t|) (QEQCAR |t| 1))) 

(DEFUN |TREE;empty?;$B;1| (|t| $) (QEQCAR |t| 1)) 

(PUT '|TREE;empty;$;2| '|SPADreplace| '(XLAM NIL (CONS 1 "empty"))) 

(DEFUN |TREE;empty;$;2| ($) (CONS 1 "empty")) 

(DEFUN |TREE;children;$L;3| (|t| $)
  (COND
    ((QEQCAR |t| 1)
     (|error| "cannot take the children of an empty tree"))
    ('T (QCDR (CDR |t|))))) 

(DEFUN |TREE;setchildren!;$L$;4| (|t| |lt| $)
  (SEQ (COND
         ((QEQCAR |t| 1)
          (|error| "cannot set children of an empty tree"))
         ('T
          (SEQ (PROGN (RPLACD #0=(CDR |t|) |lt|) (QCDR #0#))
               (EXIT |t|)))))) 

(DEFUN |TREE;setvalue!;$2S;5| (|t| |s| $)
  (SEQ (COND
         ((QEQCAR |t| 1) (|error| "cannot set value of an empty tree"))
         ('T
          (SEQ (PROGN (RPLACA #0=(CDR |t|) |s|) (QCAR #0#)) (EXIT |s|)))))) 

(DEFUN |TREE;count;S$Nni;6| (|n| |t| $)
  (PROG (|c| #0=#:G1884 #1=#:G1878 #2=#:G1876 #3=#:G1877 |i|)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) 0)
             (#4='T
              (SEQ (LETT |i|
                         (PROGN
                           (LETT #3# NIL . #5=(|TREE;count;S$Nni;6|))
                           (SEQ (LETT |c| NIL . #5#)
                                (LETT #0#
                                      (SPADCALL |t| (QREFELT $ 12)) . #5#)
                                G190
                                (COND
                                  ((OR (ATOM #0#)
                                    (PROGN
                                      (LETT |c| (CAR #0#) . #5#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL |n| |c|
                                          (QREFELT $ 16)) . #5#)
                                        (COND
                                          (#3#
                                           (LETT #2# (+ #2# #1#) . #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# 0))) . #5#)
                   (EXIT (COND
                           ((SPADCALL (SPADCALL |t| (QREFELT $ 17)) |n|
                                (QREFELT $ 18))
                            (+ |i| 1))
                           ('T |i|)))))))))) 

(DEFUN |TREE;count;M$Nni;7| (|fn| |t| $)
  (PROG (|c| #0=#:G1891 #1=#:G1887 #2=#:G1885 #3=#:G1886 |i|)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) 0)
             (#4='T
              (SEQ (LETT |i|
                         (PROGN
                           (LETT #3# NIL . #5=(|TREE;count;M$Nni;7|))
                           (SEQ (LETT |c| NIL . #5#)
                                (LETT #0#
                                      (SPADCALL |t| (QREFELT $ 12)) . #5#)
                                G190
                                (COND
                                  ((OR (ATOM #0#)
                                    (PROGN
                                      (LETT |c| (CAR #0#) . #5#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL |fn| |c|
                                          (QREFELT $ 20)) . #5#)
                                        (COND
                                          (#3#
                                           (LETT #2# (+ #2# #1#) . #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# 0))) . #5#)
                   (EXIT (COND
                           ((SPADCALL (SPADCALL |t| (QREFELT $ 17))
                                |fn|)
                            (+ |i| 1))
                           ('T |i|)))))))))) 

(DEFUN |TREE;map;M2$;8| (|fn| |t| $)
  (PROG (#0=#:G1895 |c| #1=#:G1896)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) |t|)
             ('T
              (SPADCALL (SPADCALL (SPADCALL |t| (QREFELT $ 17)) |fn|)
                        (PROGN
                          (LETT #0# NIL . #2=(|TREE;map;M2$;8|))
                          (SEQ (LETT |c| NIL . #2#)
                               (LETT #1#
                                     (SPADCALL |t| (QREFELT $ 12)) . #2#)
                               G190
                               (COND
                                 ((OR (ATOM #1#)
                                      (PROGN
                                        (LETT |c| (CAR #1#) . #2#)
                                        NIL))
                                  (GO G191)))
                               (SEQ (EXIT
                                     (LETT #0#
                                      (CONS
                                       (SPADCALL |fn| |c|
                                        (QREFELT $ 22))
                                       #0#) . #2#)))
                               (LETT #1# (CDR #1#) . #2#) (GO G190)
                               G191 (EXIT (NREVERSE0 #0#))))
                        (QREFELT $ 23)))))))) 

(DEFUN |TREE;map!;M2$;9| (|fn| |t| $)
  (PROG (|c| #0=#:G1900)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) |t|)
             ('T
              (SEQ (SPADCALL |t|
                       (SPADCALL (SPADCALL |t| (QREFELT $ 17)) |fn|)
                       (QREFELT $ 14))
                   (EXIT (SEQ (LETT |c| NIL . #1=(|TREE;map!;M2$;9|))
                              (LETT #0#
                                    (SPADCALL |t| (QREFELT $ 12)) . #1#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |c| (CAR #0#) . #1#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (SPADCALL |fn| |c| (QREFELT $ 24))))
                              (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                              (EXIT NIL)))))))))) 

(DEFUN |TREE;tree;SL$;10| (|s| |lt| $) (CONS 0 (CONS |s| |lt|))) 

(DEFUN |TREE;tree;S$;11| (|s| $) (CONS 0 (CONS |s| NIL))) 

(DEFUN |TREE;tree;L$;12| (|ls| $)
  (PROG (#0=#:G1908 |s| #1=#:G1909)
    (RETURN
      (SEQ (COND
             ((NULL |ls|) (SPADCALL (QREFELT $ 10)))
             ('T
              (SPADCALL (|SPADfirst| |ls|)
                  (PROGN
                    (LETT #0# NIL . #2=(|TREE;tree;L$;12|))
                    (SEQ (LETT |s| NIL . #2#)
                         (LETT #1# (CDR |ls|) . #2#) G190
                         (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |s| (CAR #1#) . #2#) NIL))
                            (GO G191)))
                         (SEQ (EXIT (LETT #0#
                                     (CONS
                                      (SPADCALL |s| (QREFELT $ 25))
                                      #0#) . #2#)))
                         (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                         (EXIT (NREVERSE0 #0#))))
                  (QREFELT $ 23)))))))) 

(DEFUN |TREE;value;$S;13| (|t| $)
  (COND
    ((QEQCAR |t| 1) (|error| "cannot take the value of an empty tree"))
    ('T (QCAR (CDR |t|))))) 

(DEFUN |TREE;child?;2$B;14| (|t1| |t2| $)
  (COND
    ((SPADCALL |t2| (QREFELT $ 9)) 'NIL)
    ('T (SPADCALL |t1| (SPADCALL |t2| (QREFELT $ 12)) (QREFELT $ 29))))) 

(DEFUN |TREE;distance1| (|t1| |t2| $)
  (PROG (#0=#:G1923 |t| #1=#:G1924 |n| |u| #2=#:G1815 #3=#:G1925
            #4=#:G1920 #5=#:G1918 #6=#:G1919)
    (RETURN
      (SEQ (COND
             ((SPADCALL |t1| |t2| (QREFELT $ 31)) 0)
             ((QEQCAR |t2| 1) -1)
             (#7='T
              (SEQ (LETT |u|
                         (PROGN
                           (LETT #0# NIL . #8=(|TREE;distance1|))
                           (SEQ (LETT |t| NIL . #8#)
                                (LETT #1#
                                      (SPADCALL |t2| (QREFELT $ 12)) . #8#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |t| (CAR #1#) . #8#)
                                      NIL))
                                   #9=(GO G191)))
                                (SEQ (EXIT
                                      (COND
                                        ((SEQ
                                          (LETT |n|
                                           (|TREE;distance1| |t1| |t|
                                            $) . #8#)
                                          (EXIT
                                           (COND
                                             ((< |n| 0) 'NIL)
                                             (#7# 'T))))
                                         (LETT #0#
                                          (CONS |n| #0#) . #8#)))))
                                (LETT #1# (CDR #1#) . #8#)
                                #10=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #8#)
                   (EXIT (COND
                           ((< 0 (LENGTH |u|))
                            (+ 1
                               (PROGN
                                 (LETT #6# NIL . #8#)
                                 (SEQ (LETT #2# NIL . #8#)
                                      (LETT #3# |u| . #8#) G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT #2# (CAR #3#) . #8#)
                                            NIL))
                                         #9#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #4# #2# . #8#)
                                          (COND
                                            (#6#
                                             (LETT #5#
                                              (MIN #5# #4#) . #8#))
                                            ('T
                                             (PROGN
                                               (LETT #5# #4# . #8#)
                                               (LETT #6# 'T . #8#)))))))
                                      (LETT #3# (CDR #3#) . #8#) #10#
                                      G191 (EXIT NIL))
                                 (COND
                                   (#6# #5#)
                                   ('T (|IdentityError| '|min|))))))
                           ('T -1)))))))))) 

(DEFUN |TREE;distance;2$I;16| (|t1| |t2| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| (|TREE;distance1| |t1| |t2| $)
                 |TREE;distance;2$I;16|)
           (EXIT (COND
                   ((< |n| 0) (|TREE;distance1| |t2| |t1| $))
                   ('T |n|))))))) 

(DEFUN |TREE,node?;inode?| (|t| $) (SPADCALL |t1| |t| (QREFELT $ 34))) 

(DEFUN |TREE;node?;$B;18| (|t1| |t2| $)
  (COND
    ((SPADCALL |t1| |t2| (QREFELT $ 31)) 'T)
    ((QEQCAR |t| 1) 'NIL)
    ('T
     (SPADCALL (CONS (|function| |TREE;inode?|) $)
         (SPADCALL |t2| (QREFELT $ 12)) (QREFELT $ 36))))) 

(DEFUN |TREE;leaf?;$B;19| (|t| $)
  (COND
    ((QEQCAR |t| 1) 'NIL)
    ('T (SPADCALL (SPADCALL |t| (QREFELT $ 12)) (QREFELT $ 37))))) 

(DEFUN |TREE;leaves;$L;20| (|t| $)
  (PROG (|c| #0=#:G1943 #1=#:G1940 #2=#:G1938 #3=#:G1939)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) NIL)
             ((SPADCALL |t| (QREFELT $ 38))
              (LIST (SPADCALL |t| (QREFELT $ 17))))
             ('T
              (PROGN
                (LETT #3# NIL . #4=(|TREE;leaves;$L;20|))
                (SEQ (LETT |c| NIL . #4#)
                     (LETT #0# (SPADCALL |t| (QREFELT $ 12)) . #4#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |c| (CAR #0#) . #4#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL |c| (QREFELT $ 39)) . #4#)
                                  (COND
                                    (#3#
                                     (LETT #2# (APPEND #2# #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 |TREE;less?;$NniB;21| (|t| |n| $)
  (< (SPADCALL |t| (QREFELT $ 41)) |n|)) 

(DEFUN |TREE;more?;$NniB;22| (|t| |n| $)
  (< |n| (SPADCALL |t| (QREFELT $ 41)))) 

(DEFUN |TREE;nodes;$L;23| (|t| $)
  (PROG (#0=#:G1952 |c| #1=#:G1953 |nl| #2=#:G1816 #3=#:G1954
            #4=#:G1949 #5=#:G1947 #6=#:G1948)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) (SPADCALL (QREFELT $ 44)))
             (#7='T
              (SEQ (LETT |nl|
                         (PROGN
                           (LETT #0# NIL . #8=(|TREE;nodes;$L;23|))
                           (SEQ (LETT |c| NIL . #8#)
                                (LETT #1#
                                      (SPADCALL |t| (QREFELT $ 12)) . #8#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |c| (CAR #1#) . #8#)
                                      NIL))
                                   #9=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL |c| (QREFELT $ 45))
                                        #0#) . #8#)))
                                (LETT #1# (CDR #1#) . #8#)
                                #10=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #8#)
                   (EXIT (COND
                           ((SPADCALL |nl| NIL (QREFELT $ 47))
                            (LIST |t|))
                           (#7#
                            (SPADCALL |t|
                                (PROGN
                                  (LETT #6# NIL . #8#)
                                  (SEQ (LETT #2# NIL . #8#)
                                       (LETT #3# |nl| . #8#) G190
                                       (COND
                                         ((OR (ATOM #3#)
                                           (PROGN
                                             (LETT #2# (CAR #3#) . #8#)
                                             NIL))
                                          #9#))
                                       (SEQ
                                        (EXIT
                                         (PROGN
                                           (LETT #4# #2# . #8#)
                                           (COND
                                             (#6#
                                              (LETT #5#
                                               (SPADCALL #5# #4#
                                                (QREFELT $ 48)) . #8#))
                                             ('T
                                              (PROGN
                                                (LETT #5# #4# . #8#)
                                                (LETT #6# 'T . #8#)))))))
                                       (LETT #3# (CDR #3#) . #8#) #10#
                                       G191 (EXIT NIL))
                                  (COND
                                    (#6# #5#)
                                    (#7# (SPADCALL (QREFELT $ 40)))))
                                (QREFELT $ 49)))))))))))) 

(DEFUN |TREE;size?;$NniB;24| (|t| |n| $)
  (EQL (SPADCALL |t| (QREFELT $ 41)) |n|)) 

(DEFUN |TREE;any?;M$B;25| (|fn| |t| $)
  (PROG (|c| #0=#:G1963 #1=#:G1962)
    (RETURN
      (SEQ (EXIT (COND
                   ((QEQCAR |t| 1) 'NIL)
                   ((SPADCALL (SPADCALL |t| (QREFELT $ 17)) |fn|) 'T)
                   ('T
                    (SEQ (SEQ (LETT |c| NIL . #2=(|TREE;any?;M$B;25|))
                              (LETT #0#
                                    (SPADCALL |t| (QREFELT $ 12)) . #2#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |c| (CAR #0#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((SPADCALL |fn| |c|
                                        (QREFELT $ 51))
                                       (PROGN
                                         (LETT #1# 'T . #2#)
                                         (GO #1#))))))
                              (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT 'NIL)))))
           #1# (EXIT #1#))))) 

(DEFUN |TREE;every?;M$B;26| (|fn| |t| $)
  (PROG (|c| #0=#:G1969 #1=#:G1968)
    (RETURN
      (SEQ (EXIT (COND
                   ((QEQCAR |t| 1) 'T)
                   ((NULL (SPADCALL (SPADCALL |t| (QREFELT $ 17)) |fn|))
                    'NIL)
                   ('T
                    (SEQ (SEQ (LETT |c| NIL
                                    . #2=(|TREE;every?;M$B;26|))
                              (LETT #0#
                                    (SPADCALL |t| (QREFELT $ 12)) . #2#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |c| (CAR #0#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((COND
                                         ((SPADCALL |fn| |c|
                                           (QREFELT $ 52))
                                          'NIL)
                                         ('T 'T))
                                       (PROGN
                                         (LETT #1# 'NIL . #2#)
                                         (GO #1#))))))
                              (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT 'T)))))
           #1# (EXIT #1#))))) 

(DEFUN |TREE,member?;mem?| (|c| $) (SPADCALL |n| |c| (QREFELT $ 53))) 

(DEFUN |TREE;member?;$B;28| (|n| |t| $)
  (COND
    ((QEQCAR |t| 1) 'NIL)
    ((SPADCALL |n| (SPADCALL |t| (QREFELT $ 17)) (QREFELT $ 18)) 'T)
    ('T
     (SPADCALL (CONS (|function| |TREE;mem?|) $)
         (SPADCALL |t| (QREFELT $ 12)) (QREFELT $ 36))))) 

(DEFUN |TREE;members;$L;29| (|t| $) (SPADCALL |t| (QREFELT $ 54))) 

(DEFUN |TREE;parts;$L;30| (|t| $)
  (PROG (#0=#:G1983 |c| #1=#:G1984 |u| #2=#:G1817 #3=#:G1985 #4=#:G1980
            #5=#:G1978 #6=#:G1979)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) NIL)
             (#7='T
              (SEQ (LETT |u|
                         (PROGN
                           (LETT #0# NIL . #8=(|TREE;parts;$L;30|))
                           (SEQ (LETT |c| NIL . #8#)
                                (LETT #1#
                                      (SPADCALL |t| (QREFELT $ 12)) . #8#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |c| (CAR #1#) . #8#)
                                      NIL))
                                   #9=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL |c| (QREFELT $ 54))
                                        #0#) . #8#)))
                                (LETT #1# (CDR #1#) . #8#)
                                #10=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))) . #8#)
                   (EXIT (COND
                           ((SPADCALL |u| NIL (QREFELT $ 57))
                            (LIST (SPADCALL |t| (QREFELT $ 17))))
                           (#7#
                            (CONS (SPADCALL |t| (QREFELT $ 17))
                                  (PROGN
                                    (LETT #6# NIL . #8#)
                                    (SEQ (LETT #2# NIL . #8#)
                                     (LETT #3# |u| . #8#) G190
                                     (COND
                                       ((OR (ATOM #3#)
                                         (PROGN
                                           (LETT #2# (CAR #3#) . #8#)
                                           NIL))
                                        #9#))
                                     (SEQ
                                      (EXIT
                                       (PROGN
                                         (LETT #4# #2# . #8#)
                                         (COND
                                           (#6#
                                            (LETT #5#
                                             (APPEND #5# #4#) . #8#))
                                           ('T
                                            (PROGN
                                              (LETT #5# #4# . #8#)
                                              (LETT #6# 'T . #8#)))))))
                                     (LETT #3# (CDR #3#) . #8#) #10#
                                     G191 (EXIT NIL))
                                    (COND (#6# #5#) (#7# NIL)))))))))))))) 

(DEFUN |TREE;=;2$B;31| (|t1| |t2| $)
  (|TREE;equal?| |t1| |t2| |t1| |t2| 0 $)) 

(DEFUN |TREE;equal?| (|t1| |t2| |ot1| |ot2| |k| $)
  (PROG (|c1| |c2| #0=#:G1996 |y| #1=#:G2000 |x| #2=#:G1999 #3=#:G1998)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((EQL |k| 5)
                         (COND
                           ((OR (SPADCALL |ot1| (QREFELT $ 58))
                                (SPADCALL |ot2| (QREFELT $ 58)))
                            (EXIT (|error| "use cyclicEqual? to test equality on cyclic trees"))))))
                      (EXIT (COND
                              ((QEQCAR |t1| 1) (QEQCAR |t2| 1))
                              ((QEQCAR |t2| 1) 'NIL)
                              ('T
                               (SEQ (EXIT
                                     (SEQ
                                      (COND
                                        ((SPADCALL
                                          (SPADCALL |t1|
                                           (QREFELT $ 17))
                                          (SPADCALL |t2|
                                           (QREFELT $ 17))
                                          (QREFELT $ 18))
                                         (SEQ
                                          (LETT |c1|
                                           (SPADCALL |t1|
                                            (QREFELT $ 12))
                                           . #4=(|TREE;equal?|))
                                          (LETT |c2|
                                           (SPADCALL |t2|
                                            (QREFELT $ 12)) . #4#)
                                          (EXIT
                                           (COND
                                             ((NULL
                                               (SPADCALL |c1| |c2|
                                                (QREFELT $ 59)))
                                              (PROGN
                                                (LETT #0# 'NIL . #4#)
                                                (GO #0#)))))))
                                        ('T (EXIT 'NIL)))
                                      (SEQ (LETT |y| NIL . #4#)
                                       (LETT #1# |c2| . #4#)
                                       (LETT |x| NIL . #4#)
                                       (LETT #2# |c1| . #4#) G190
                                       (COND
                                         ((OR (ATOM #2#)
                                           (PROGN
                                             (LETT |x| (CAR #2#) . #4#)
                                             NIL)
                                           (ATOM #1#)
                                           (PROGN
                                             (LETT |y| (CAR #1#) . #4#)
                                             NIL))
                                          (GO G191)))
                                       (SEQ
                                        (EXIT
                                         (COND
                                           ((COND
                                              ((|TREE;equal?| |x| |y|
                                                |ot1| |ot2| (+ |k| 1)
                                                $)
                                               'NIL)
                                              ('T 'T))
                                            (PROGN
                                              (LETT #3# 'NIL . #4#)
                                              (GO #3#))))))
                                       (LETT #2#
                                        (PROG1 (CDR #2#)
                                          (LETT #1# (CDR #1#) . #4#)) . #4#)
                                       (GO G190) G191 (EXIT NIL))
                                      (EXIT 'T)))
                                    #0# (EXIT #0#)))))))
           #3# (EXIT #3#))))) 

(DEFUN |TREE;#;$Nni;33| (|t| $) (|TREE;treeCount| |t| |t| 0 $)) 

(DEFUN |TREE;treeCount| (|t| |origTree| |k| $)
  (PROG (|c| #0=#:G2014 #1=#:G2011 #2=#:G2009 #3=#:G2010)
    (RETURN
      (SEQ (COND
             ((EQL |k| 5)
              (COND
                ((SPADCALL |origTree| (QREFELT $ 58))
                 (EXIT (|error| "# is not defined on cyclic trees"))))))
           (EXIT (COND
                   ((QEQCAR |t| 1) 0)
                   (#4='T
                    (+ 1
                       (PROGN
                         (LETT #3# NIL . #5=(|TREE;treeCount|))
                         (SEQ (LETT |c| NIL . #5#)
                              (LETT #0#
                                    (SPADCALL |t| (QREFELT $ 12)) . #5#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |c| (CAR #0#) . #5#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (PROGN
                                      (LETT #1#
                                       (|TREE;treeCount| |c| |origTree|
                                        (+ |k| 1) $) . #5#)
                                      (COND
                                        (#3#
                                         (LETT #2# (+ #2# #1#) . #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# 0))))))))))) 

(DEFUN |TREE;copy;2$;35| (|t| $) (|TREE;copy1| |t| |t| 0 $)) 

(DEFUN |TREE;copy1| (|t| |origTree| |k| $)
  (PROG (#0=#:G2024 |x| #1=#:G2025)
    (RETURN
      (SEQ (COND
             ((EQL |k| 5)
              (COND
                ((SPADCALL |origTree| (QREFELT $ 58))
                 (EXIT (|error| "use cyclicCopy to copy a cyclic tree"))))))
           (EXIT (COND
                   ((QEQCAR |t| 1) |t|)
                   ((SPADCALL (SPADCALL |t| (QREFELT $ 12))
                        (QREFELT $ 37))
                    (SPADCALL (SPADCALL |t| (QREFELT $ 17))
                        (QREFELT $ 25)))
                   ('T
                    (SPADCALL (SPADCALL |t| (QREFELT $ 17))
                        (PROGN
                          (LETT #0# NIL . #2=(|TREE;copy1|))
                          (SEQ (LETT |x| NIL . #2#)
                               (LETT #1#
                                     (SPADCALL |t| (QREFELT $ 12)) . #2#)
                               G190
                               (COND
                                 ((OR (ATOM #1#)
                                      (PROGN
                                        (LETT |x| (CAR #1#) . #2#)
                                        NIL))
                                  (GO G191)))
                               (SEQ (EXIT
                                     (LETT #0#
                                      (CONS
                                       (|TREE;copy1| |x| |origTree|
                                        (+ |k| 1) $)
                                       #0#) . #2#)))
                               (LETT #1# (CDR #1#) . #2#) (GO G190)
                               G191 (EXIT (NREVERSE0 #0#))))
                        (QREFELT $ 23))))))))) 

(DEFUN |TREE;coerce;$Of;37| (|t| $)
  (|TREE;coerce1| |t| (SPADCALL (QREFELT $ 44))
      (SPADCALL |t| (QREFELT $ 61)) $)) 

(DEFUN |TREE;coerce1| (|t| |parents| |pl| $)
  (PROG (|k| |nodeForm| #0=#:G2036 |br| #1=#:G2037)
    (RETURN
      (SEQ (COND
             ((QEQCAR |t| 1) (SPADCALL NIL (QREFELT $ 64)))
             ((|TREE;eqMember?| |t| |parents| $)
              (|TREE;multipleOverbar| "."
                  (|TREE;eqMemberIndex| |t| |pl| 0 $) |pl| $))
             ((SPADCALL (SPADCALL |t| (QREFELT $ 12)) (QREFELT $ 37))
              (SPADCALL (SPADCALL |t| (QREFELT $ 17)) (QREFELT $ 65)))
             ('T
              (SEQ (LETT |nodeForm|
                         (SPADCALL (SPADCALL |t| (QREFELT $ 17))
                             (QREFELT $ 65))
                         . #2=(|TREE;coerce1|))
                   (SEQ (LETT |k|
                              (|TREE;eqMemberIndex| |t| |pl| 0 $) . #2#)
                        (EXIT (COND
                                ((< 0 |k|)
                                 (LETT |nodeForm|
                                       (|TREE;multipleOverbar|
                                        |nodeForm| |k| |pl| $) . #2#)))))
                   (EXIT (SPADCALL |nodeForm|
                             (PROGN
                               (LETT #0# NIL . #2#)
                               (SEQ (LETT |br| NIL . #2#)
                                    (LETT #1#
                                     (SPADCALL |t| (QREFELT $ 12)) . #2#)
                                    G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |br| (CAR #1#) . #2#)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|TREE;coerce1| |br|
                                         (SPADCALL |t| |parents|
                                          (QREFELT $ 49))
                                         |pl| $)
                                        #0#) . #2#)))
                                    (LETT #1# (CDR #1#) . #2#)
                                    (GO G190) G191
                                    (EXIT (NREVERSE0 #0#))))
                             (QREFELT $ 66)))))))))) 

(DEFUN |TREE;multipleOverbar| (|x| |k| |pl| $)
  (PROG (|s| |c|)
    (RETURN
      (SEQ (COND
             ((< |k| 1) |x|)
             ((EQL (SPADCALL |pl| (QREFELT $ 67)) 1)
              (SPADCALL |x| (QREFELT $ 68)))
             ('T
              (SEQ (LETT |s| "abcdefghijklmnopqrstuvwxyz"
                         . #0=(|TREE;multipleOverbar|))
                   (LETT |c|
                         (SPADCALL |s| (+ 1 (REMAINDER2 (- |k| 1) 26))
                             (QREFELT $ 71)) . #0#)
                   (EXIT (SPADCALL (SPADCALL |c| (QREFELT $ 72)) |x|
                             (QREFELT $ 73)))))))))) 

(DEFUN |TREE;cyclic?;$B;40| (|t| $)
  (|TREE;cyclic2?| |t| (SPADCALL (QREFELT $ 44)) $)) 

(DEFUN |TREE;cyclic2?| (|x| |parents| $)
  (PROG (|y| #0=#:G2051 #1=#:G2050 #2=#:G2046)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |x| (QREFELT $ 9)) 'NIL)
                   ((|TREE;eqMember?| |x| |parents| $) 'T)
                   ('T
                    (SEQ (SEQ (EXIT (SEQ
                                     (LETT |y| NIL
                                      . #3=(|TREE;cyclic2?|))
                                     (LETT #0#
                                      (SPADCALL |x| (QREFELT $ 12)) . #3#)
                                     G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |y| (CAR #0#) . #3#)
                                           NIL))
                                        (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((|TREE;cyclic2?| |y|
                                           (SPADCALL |x| |parents|
                                            (QREFELT $ 49))
                                           $)
                                          (PROGN
                                            (LETT #2#
                                             (PROGN
                                               (LETT #1# 'T . #3#)
                                               (GO #1#)) . #3#)
                                            (GO #2#))))))
                                     (LETT #0# (CDR #0#) . #3#)
                                     (GO G190) G191 (EXIT NIL)))
                              #2# (EXIT #2#))
                         (EXIT 'NIL)))))
           #1# (EXIT #1#))))) 

(DEFUN |TREE;cyclicCopy;2$;42| (|t| $)
  (|TREE;cyclicCopy2| |t| (SPADCALL |t| (QREFELT $ 74)) $)) 

(DEFUN |TREE;cyclicCopy2| (|t| |cycles| $)
  (PROG (#0=#:G2055 #1=#:G2056 |c| #2=#:G2057)
    (RETURN
      (SEQ (EXIT (COND
                   ((|TREE;eqMember?| |t| |cycles| $)
                    (PROGN
                      (LETT #0# (|TREE;copyCycle2| |t| |cycles| $)
                            . #3=(|TREE;cyclicCopy2|))
                      (GO #0#)))
                   ('T
                    (SPADCALL (SPADCALL |t| (QREFELT $ 17))
                        (PROGN
                          (LETT #1# NIL . #3#)
                          (SEQ (LETT |c| NIL . #3#)
                               (LETT #2#
                                     (SPADCALL |t| (QREFELT $ 12)) . #3#)
                               G190
                               (COND
                                 ((OR (ATOM #2#)
                                      (PROGN
                                        (LETT |c| (CAR #2#) . #3#)
                                        NIL))
                                  (GO G191)))
                               (SEQ (EXIT
                                     (LETT #1#
                                      (CONS
                                       (|TREE;cyclicCopy2| |c| |cycles|
                                        $)
                                       #1#) . #3#)))
                               (LETT #2# (CDR #2#) . #3#) (GO G190)
                               G191 (EXIT (NREVERSE0 #1#))))
                        (QREFELT $ 23)))))
           #0# (EXIT #0#))))) 

(DEFUN |TREE;copyCycle2| (|cycle| |cycleList| $)
  (PROG (|newCycle| #0=#:G2061 |c| #1=#:G2062)
    (RETURN
      (SEQ (LETT |newCycle|
                 (SPADCALL (SPADCALL |cycle| (QREFELT $ 17))
                     (SPADCALL (QREFELT $ 40)) (QREFELT $ 23))
                 . #2=(|TREE;copyCycle2|))
           (SPADCALL |newCycle|
               (PROGN
                 (LETT #0# NIL . #2#)
                 (SEQ (LETT |c| NIL . #2#)
                      (LETT #1#
                            (SPADCALL |cycle| (QREFELT $ 12)) . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |c| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (|TREE;copyCycle4| |c| |cycle|
                                         |newCycle| |cycleList| $)
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 13))
           (EXIT |newCycle|))))) 

(DEFUN |TREE;copyCycle4| (|t| |cycle| |newCycle| |cycleList| $)
  (PROG (#0=#:G2068 |c| #1=#:G2069)
    (RETURN
      (SEQ (COND
             ((SPADCALL |cycle| (QREFELT $ 9))
              (SPADCALL (QREFELT $ 10)))
             ((SPADCALL |t| |cycle| (QREFELT $ 76)) |newCycle|)
             ((|TREE;eqMember?| |t| |cycleList| $)
              (|TREE;copyCycle2| |t| |cycleList| $))
             ('T
              (SPADCALL (SPADCALL |t| (QREFELT $ 17))
                  (PROGN
                    (LETT #0# NIL . #2=(|TREE;copyCycle4|))
                    (SEQ (LETT |c| NIL . #2#)
                         (LETT #1# (SPADCALL |t| (QREFELT $ 12)) . #2#)
                         G190
                         (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |c| (CAR #1#) . #2#) NIL))
                            (GO G191)))
                         (SEQ (EXIT (LETT #0#
                                     (CONS
                                      (|TREE;copyCycle4| |c| |cycle|
                                       |newCycle| |cycleList| $)
                                      #0#) . #2#)))
                         (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                         (EXIT (NREVERSE0 #0#))))
                  (QREFELT $ 23)))))))) 

(DEFUN |TREE;cyclicEntries;$L;46| (|t| $)
  (|TREE;cyclicEntries3| |t| (SPADCALL (QREFELT $ 44))
      (SPADCALL (QREFELT $ 44)) $)) 

(DEFUN |TREE;cyclicEntries3| (|t| |parents| |cl| $)
  (PROG (|y| #0=#:G2076)
    (RETURN
      (SEQ (COND
             ((SPADCALL |t| (QREFELT $ 9)) |cl|)
             ((|TREE;eqMember?| |t| |parents| $)
              (|TREE;insert| |t| |cl| $))
             ('T
              (SEQ (LETT |parents|
                         (SPADCALL |t| |parents| (QREFELT $ 49))
                         . #1=(|TREE;cyclicEntries3|))
                   (SEQ (LETT |y| NIL . #1#)
                        (LETT #0# (SPADCALL |t| (QREFELT $ 12)) . #1#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |y| (CAR #0#) . #1#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT |cl|
                                    (|TREE;cyclicEntries3| |t|
                                     |parents| |cl| $) . #1#)))
                        (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT |cl|)))))))) 

(DEFUN |TREE;cyclicEqual?;2$B;48| (|t1| |t2| $)
  (PROG (|cp1| |cp2|)
    (RETURN
      (SEQ (LETT |cp1| (SPADCALL |t1| (QREFELT $ 61))
                 . #0=(|TREE;cyclicEqual?;2$B;48|))
           (LETT |cp2| (SPADCALL |t2| (QREFELT $ 61)) . #0#)
           (COND
             ((EQL (SPADCALL |cp1| (QREFELT $ 67))
                   (SPADCALL |cp2| (QREFELT $ 67)))
              (COND
                ((SPADCALL |cp1| (QREFELT $ 77))
                 (EXIT (SPADCALL |t1| |t2| (QREFELT $ 31))))))
             ('T (EXIT (SPADCALL |t1| |t2| (QREFELT $ 31)))))
           (EXIT (|TREE;cyclicEqual4?| |t1| |t2| |cp1| |cp2| $)))))) 

(DEFUN |TREE;cyclicEqual4?| (|t1| |t2| |cp1| |cp2| $)
  (PROG (|k| #0=#:G2090 |y| #1=#:G2093 |x| #2=#:G2092 #3=#:G2091)
    (RETURN
      (SEQ (EXIT (COND
                   ((QEQCAR |t1| 1) (QEQCAR |t2| 1))
                   ((QEQCAR |t2| 1) 'NIL)
                   ('T
                    (SEQ (EXIT (SEQ (SEQ
                                     (LETT |k|
                                      (|TREE;eqMemberIndex| |t1| |cp1|
                                       0 $)
                                      . #4=(|TREE;cyclicEqual4?|))
                                     (EXIT
                                      (COND
                                        ((NULL (EQL 0 |k|))
                                         (PROGN
                                           (LETT #0#
                                            (SPADCALL |t2|
                                             (SPADCALL |cp2| |k|
                                              (QREFELT $ 79))
                                             (QREFELT $ 76)) . #4#)
                                           (GO #0#))))))
                                    (EXIT
                                     (COND
                                       ((SPADCALL
                                         (SPADCALL |t1| (QREFELT $ 17))
                                         (SPADCALL |t2| (QREFELT $ 17))
                                         (QREFELT $ 80))
                                        'NIL)
                                       ('T
                                        (SEQ
                                         (SEQ (LETT |y| NIL . #4#)
                                          (LETT #1#
                                           (SPADCALL |t2|
                                            (QREFELT $ 12)) . #4#)
                                          (LETT |x| NIL . #4#)
                                          (LETT #2#
                                           (SPADCALL |t1|
                                            (QREFELT $ 12)) . #4#)
                                          G190
                                          (COND
                                            ((OR (ATOM #2#)
                                              (PROGN
                                                (LETT |x|
                                                 (CAR #2#) . #4#)
                                                NIL)
                                              (ATOM #1#)
                                              (PROGN
                                                (LETT |y|
                                                 (CAR #1#) . #4#)
                                                NIL))
                                             (GO G191)))
                                          (SEQ
                                           (EXIT
                                            (COND
                                              ((COND
                                                 ((|TREE;cyclicEqual4?|
                                                   |x| |y| |cp1| |cp2|
                                                   $)
                                                  'NIL)
                                                 ('T 'T))
                                               (PROGN
                                                 (LETT #3# 'NIL . #4#)
                                                 (GO #3#))))))
                                          (LETT #2#
                                           (PROG1 (CDR #2#)
                                             (LETT #1# (CDR #1#) . #4#)) . #4#)
                                          (GO G190) G191 (EXIT NIL))
                                         (EXIT 'T)))))))
                         #0# (EXIT #0#)))))
           #3# (EXIT #3#))))) 

(DEFUN |TREE;cyclicParents;$L;50| (|t| $)
  (|TREE;cyclicParents3| |t| (SPADCALL (QREFELT $ 44))
      (SPADCALL (QREFELT $ 44)) $)) 

(DEFUN |TREE;cyclicParents3| (|x| |parents| |pl| $)
  (PROG (#0=#:G2103 #1=#:G2104 |cycleMembers| |y| #2=#:G2105)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 9)) |pl|)
             ((|TREE;eqMember?| |x| |parents| $)
              (SEQ (LETT |cycleMembers|
                         (PROGN
                           (LETT #0# NIL . #3=(|TREE;cyclicParents3|))
                           (SEQ (LETT |y| NIL . #3#)
                                (LETT #1# |parents| . #3#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |y| (CAR #1#) . #3#)
                                      NIL)
                                    (NULL
                                     (COND
                                       ((SPADCALL |x| |y|
                                         (QREFELT $ 76))
                                        'NIL)
                                       ('T 'T))))
                                   #4=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0# (CONS |y| #0#) . #3#)))
                                (LETT #1# (CDR #1#) . #3#) #5=(GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))) . #3#)
                   (EXIT (|TREE;eqUnion|
                             (SPADCALL |x| |cycleMembers|
                                 (QREFELT $ 49))
                             |pl| $))))
             ('T
              (SEQ (LETT |parents|
                         (SPADCALL |x| |parents| (QREFELT $ 49)) . #3#)
                   (SEQ (LETT |y| NIL . #3#)
                        (LETT #2# (SPADCALL |x| (QREFELT $ 12)) . #3#)
                        G190
                        (COND
                          ((OR (ATOM #2#)
                               (PROGN (LETT |y| (CAR #2#) . #3#) NIL))
                           #4#))
                        (SEQ (EXIT (LETT |pl|
                                    (|TREE;cyclicParents3| |y|
                                     |parents| |pl| $) . #3#)))
                        (LETT #2# (CDR #2#) . #3#) #5# G191 (EXIT NIL))
                   (EXIT |pl|)))))))) 

(DEFUN |TREE;insert| (|x| |l| $)
  (COND
    ((|TREE;eqMember?| |x| |l| $) |l|)
    ('T (SPADCALL |x| |l| (QREFELT $ 49))))) 

(DEFUN |TREE;lastNode| (|l| $)
  (SEQ (COND
         ((SPADCALL |l| (QREFELT $ 37))
          (|error| "empty tree has no last node"))
         ('T
          (SEQ (SEQ G190
                    (COND
                      ((NULL (COND
                               ((SPADCALL (SPADCALL |l| (QREFELT $ 81))
                                    (QREFELT $ 37))
                                'NIL)
                               ('T 'T)))
                       (GO G191)))
                    (SEQ (EXIT (LETT |l| (SPADCALL |l| (QREFELT $ 81))
                                     |TREE;lastNode|)))
                    NIL (GO G190) G191 (EXIT NIL))
               (EXIT |l|)))))) 

(DEFUN |TREE;eqMember?| (|y| |l| $)
  (PROG (|x| #0=#:G2120 #1=#:G2119 #2=#:G2117)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |x| NIL
                                       . #3=(|TREE;eqMember?|))
                                      (LETT #0# |l| . #3#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |x| (CAR #0#) . #3#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((SPADCALL |x| |y|
                                            (QREFELT $ 76))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'T . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT #0# (CDR #0#) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'NIL)))
           #1# (EXIT #1#))))) 

(DEFUN |TREE;eqMemberIndex| (|x| |l| |k| $)
  (SEQ (COND
         ((SPADCALL |l| (QREFELT $ 77)) |k|)
         ('T
          (SEQ (LETT |k| (+ |k| 1) |TREE;eqMemberIndex|)
               (EXIT (COND
                       ((SPADCALL |x| (SPADCALL |l| (QREFELT $ 82))
                            (QREFELT $ 76))
                        |k|)
                       ('T
                        (|TREE;eqMemberIndex| |x|
                            (SPADCALL |l| (QREFELT $ 81)) |k| $))))))))) 

(DEFUN |TREE;eqUnion| (|u| |v| $)
  (PROG (|x| |newV|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |u| (QREFELT $ 77)) |v|)
             ('T
              (SEQ (LETT |x| (SPADCALL |u| (QREFELT $ 82))
                         . #0=(|TREE;eqUnion|))
                   (LETT |newV|
                         (COND
                           ((|TREE;eqMember?| |x| |v| $) |v|)
                           ('T (SPADCALL |x| |v| (QREFELT $ 49)))) . #0#)
                   (EXIT (|TREE;eqUnion| (SPADCALL |u| (QREFELT $ 81))
                             |newV| $))))))))) 

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

(DEFUN |Tree;| (|#1|)
  (PROG (DV$1 |dv$| $ #0=#:G2126 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #1=(|Tree|))
        (LETT |dv$| (LIST '|Tree| DV$1) . #1#)
        (LETT $ (GETREFV 87) . #1#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (LETT #0#
                                  (|HasCategory| |#1| '(|SetCategory|)) . #1#)
                            (AND #0#
                                 (|HasCategory| |#1|
                                     (LIST '|Evalable|
                                      (|devaluate| |#1|)))))) . #1#))
        (|haddProp| |$ConstructorCache| '|Tree| (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (AND (|HasCategory| $ '(|finiteAggregate|))
             (|augmentPredVector| $ 4))
        (AND (|HasCategory| $ '(|finiteAggregate|)) #0#
             (|augmentPredVector| $ 8))
        (AND (|HasCategory| $ '(|shallowlyMutable|))
             (|augmentPredVector| $ 16))
        (QSETREFV $ 7
            (|Union| (|:| |node|
                          (|Record| (|:| |value| |#1|)
                              (|:| |args| (|List| $))))
                     (|:| |empty| "empty")))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 63
                 (CONS (|dispatchFunction| |TREE;coerce;$Of;37|) $)))))
        $)))) 

(MAKEPROP '|Tree| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep| (|Boolean|)
             |TREE;empty?;$B;1| |TREE;empty;$;2| (|List| $)
             |TREE;children;$L;3| |TREE;setchildren!;$L$;4|
             |TREE;setvalue!;$2S;5| (|NonNegativeInteger|)
             |TREE;count;S$Nni;6| |TREE;value;$S;13| (0 . =)
             (|Mapping| 8 6) |TREE;count;M$Nni;7| (|Mapping| 6 6)
             |TREE;map;M2$;8| |TREE;tree;SL$;10| |TREE;map!;M2$;9|
             |TREE;tree;S$;11| (|List| 6) |TREE;tree;L$;12| (|List| $$)
             (6 . |member?|) |TREE;child?;2$B;14| |TREE;=;2$B;31|
             (|Integer|) |TREE;distance;2$I;16| (12 . |node?|)
             (|Mapping| 8 $$) (18 . |any?|) (24 . |empty?|)
             |TREE;leaf?;$B;19| |TREE;leaves;$L;20| (29 . |nil|)
             |TREE;#;$Nni;33| |TREE;less?;$NniB;21|
             |TREE;more?;$NniB;22| (33 . |empty|) |TREE;nodes;$L;23|
             (|List| 28) (37 . =) (43 . |append|) (49 . |cons|)
             |TREE;size?;$NniB;24| |TREE;any?;M$B;25|
             |TREE;every?;M$B;26| (55 . |member?|) |TREE;parts;$L;30|
             |TREE;members;$L;29| (|List| 26) (61 . =)
             |TREE;cyclic?;$B;40| (67 . =) |TREE;copy;2$;35|
             |TREE;cyclicParents;$L;50| (|OutputForm|) (73 . |coerce|)
             (78 . |coerce|) (83 . |coerce|) (88 . |prefix|) (94 . |#|)
             (99 . |overbar|) (|Character|) (|String|) (104 . |elt|)
             (110 . |coerce|) (115 . |overlabel|)
             |TREE;cyclicEntries;$L;46| |TREE;cyclicCopy;2$;42|
             (121 . |eq?|) (127 . |null|) |TREE;cyclicEqual?;2$B;48|
             (132 . |elt|) (138 . ~=) (144 . |rest|) (149 . |first|)
             (|List| 84) (|Equation| 6) '"value" (|SingleInteger|))
          '#(~= 154 |value| 160 |tree| 165 |size?| 181 |setvalue!| 187
             |setelt| 193 |setchildren!| 200 |sample| 206 |parts| 210
             |nodes| 215 |node?| 220 |more?| 226 |members| 232
             |member?| 237 |map!| 243 |map| 249 |less?| 255 |leaves|
             261 |leaf?| 266 |latex| 271 |hash| 276 |every?| 281 |eval|
             287 |eq?| 313 |empty?| 319 |empty| 324 |elt| 328
             |distance| 334 |cyclicParents| 340 |cyclicEqual?| 345
             |cyclicEntries| 351 |cyclicCopy| 356 |cyclic?| 361 |count|
             366 |copy| 378 |coerce| 383 |children| 388 |child?| 393
             |any?| 399 = 405 |#| 411)
          'NIL
          (CONS (|makeByteWordVec2| 2 '(0 0 0 2 1 0 0 0 2 1 1))
                (CONS '#(|RecursiveAggregate&| |HomogeneousAggregate&|
                         |Aggregate&| |Evalable&| |SetCategory&| NIL
                         NIL NIL |InnerEvalable&| |BasicType&| NIL)
                      (CONS '#((|RecursiveAggregate| 6)
                               (|HomogeneousAggregate| 6) (|Aggregate|)
                               (|Evalable| 6) (|SetCategory|) (|Type|)
                               (|shallowlyMutable|) (|finiteAggregate|)
                               (|InnerEvalable| 6 6) (|BasicType|)
                               (|CoercibleTo| 62))
                            (|makeByteWordVec2| 86
                                '(2 6 8 0 0 18 2 28 8 2 0 29 2 0 8 0 0
                                  34 2 28 8 35 0 36 1 28 8 0 37 0 28 0
                                  40 0 28 0 44 2 46 8 0 0 47 2 28 0 0 0
                                  48 2 28 0 2 0 49 2 0 8 6 0 53 2 56 8
                                  0 0 57 2 28 8 0 0 59 1 0 62 0 63 1 26
                                  62 0 64 1 6 62 0 65 2 62 0 0 11 66 1
                                  28 15 0 67 1 62 0 0 68 2 70 69 0 32
                                  71 1 69 62 0 72 2 62 0 0 0 73 2 0 8 0
                                  0 76 1 28 8 0 77 2 28 2 0 32 79 2 6 8
                                  0 0 80 1 28 0 0 81 1 28 2 0 82 2 1 8
                                  0 0 1 1 0 6 0 17 1 0 0 6 25 1 0 0 26
                                  27 2 0 0 6 11 23 2 0 8 0 15 50 2 5 6
                                  0 6 14 3 5 6 0 85 6 1 2 5 0 0 11 13 0
                                  0 0 1 1 3 26 0 54 1 0 11 0 45 2 1 8 0
                                  0 34 2 0 8 0 15 43 1 3 26 0 55 2 4 8
                                  6 0 53 2 5 0 21 0 24 2 0 0 21 0 22 2
                                  0 8 0 15 42 1 0 26 0 39 1 0 8 0 38 1
                                  1 70 0 1 1 1 86 0 1 2 3 8 19 0 52 3 2
                                  0 0 26 26 1 3 2 0 0 6 6 1 2 2 0 0 83
                                  1 2 2 0 0 84 1 2 0 8 0 0 76 1 0 8 0 9
                                  0 0 0 10 2 0 6 0 85 1 2 0 32 0 0 33 1
                                  0 11 0 61 2 0 8 0 0 78 1 0 11 0 74 1
                                  0 0 0 75 1 0 8 0 58 2 4 15 6 0 16 2 3
                                  15 19 0 20 1 0 0 0 60 1 1 62 0 63 1 0
                                  11 0 12 2 1 8 0 0 30 2 3 8 19 0 51 2
                                  1 8 0 0 31 1 3 15 0 41)))))
          '|lookupComplete|)) 
