
(/VERSIONCHECK 2) 

(DEFUN |STREAM;explicitlyEmpty?;$B;1| (|x| $)
  (EQ (SPADCALL |x| (QREFELT $ 10)) (QREFELT $ 7))) 

(DEFUN |STREAM;lazy?;$B;2| (|x| $)
  (EQ (SPADCALL |x| (QREFELT $ 10)) (QREFELT $ 8))) 

(PUT '|STREAM;frst;$S;3| '|SPADreplace| 'QCAR) 

(DEFUN |STREAM;frst;$S;3| (|x| $) (QCAR |x|)) 

(PUT '|STREAM;rst;2$;4| '|SPADreplace| 'QCDR) 

(DEFUN |STREAM;rst;2$;4| (|x| $) (QCDR |x|)) 

(DEFUN |STREAM;setfrst!| (|x| |s| $)
  (PROGN (RPLACA |x| |s|) (QCAR |x|))) 

(DEFUN |STREAM;setrst!| (|x| |y| $)
  (PROGN (RPLACD |x| |y|) (QCDR |x|))) 

(DEFUN |STREAM;setToNil!| (|x| $)
  (SEQ (|STREAM;setfrst!| |x| (QREFELT $ 7) $)
       (|STREAM;setrst!| |x| NIL $) (EXIT |x|))) 

(DEFUN |STREAM;getm| (|x| |le| |n| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 12)) |le|)
    ((SPADCALL |x| (QREFELT $ 13))
     (COND
       ((< 0 |n|)
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) |le|)
          ('T
           (|STREAM;getm| (SPADCALL |x| (QREFELT $ 14))
               (CONS (SPADCALL (SPADCALL |x| (QREFELT $ 10))
                               (QREFELT $ 17))
                     |le|)
               (- |n| 1) $))))
       ('T (CONS (SPADCALL "..." (QREFELT $ 19)) |le|))))
    ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 20))
     (CONS (SPADCALL
               (SPADCALL (SPADCALL |x| (QREFELT $ 10)) (QREFELT $ 17))
               (QREFELT $ 21))
           |le|))
    ((< 0 |n|)
     (|STREAM;getm| (SPADCALL |x| (QREFELT $ 14))
         (CONS (SPADCALL (SPADCALL |x| (QREFELT $ 10)) (QREFELT $ 17))
               |le|)
         (- |n| 1) $))
    ('T (CONS (SPADCALL "..." (QREFELT $ 19)) |le|)))) 

(DEFUN |STREAM;streamCountCoerce| (|x| $)
  (PROG (|count| |y| |fc| #0=#:G1923 |le| |i| #1=#:G1924 |pl| |pp|)
    (RETURN
      (SEQ (LETT |count| |$streamCount|
                 . #2=(|STREAM;streamCountCoerce|))
           (LETT |y| |x| . #2#)
           (SEQ (LETT |i| 1 . #2#) G190
                (COND
                  ((OR (QSGREATERP |i| |count|)
                       (NULL (COND
                               ((SPADCALL |y| (QREFELT $ 15)) 'NIL)
                               ('T 'T))))
                   #3=(GO G191)))
                (SEQ (EXIT (LETT |y|
                                 (SPADCALL |y| (QREFELT $ 14)) . #2#)))
                (LETT |i| (QSADD1 |i|) . #2#) #4=(GO G190) G191
                (EXIT NIL))
           (LETT |fc| (SPADCALL |count| |x| (QREFELT $ 24)) . #2#)
           (COND
             ((NULL (QVELT |fc| 0))
              (EXIT (SPADCALL
                        (NREVERSE (|STREAM;getm| |x| NIL |count| $))
                        (QREFELT $ 26)))))
           (LETT |le| NIL . #2#)
           (SEQ (LETT |i| 1 . #2#) (LETT #0# (QVELT |fc| 1) . #2#) G190
                (COND ((QSGREATERP |i| #0#) #3#))
                (SEQ (LETT |le|
                           (CONS (SPADCALL
                                     (SPADCALL |x| (QREFELT $ 27))
                                     (QREFELT $ 17))
                                 |le|) . #2#)
                     (EXIT (LETT |x|
                                 (SPADCALL |x| (QREFELT $ 28)) . #2#)))
                (LETT |i| (QSADD1 |i|) . #2#) #4# G191 (EXIT NIL))
           (LETT |pp|
                 (COND
                   ((EQL (QVELT |fc| 2) 1)
                    (SPADCALL
                        (SPADCALL (SPADCALL |x| (QREFELT $ 10))
                            (QREFELT $ 17))
                        (QREFELT $ 21)))
                   ('T
                    (SEQ (LETT |pl| NIL . #2#)
                         (SEQ (LETT |i| 1 . #2#)
                              (LETT #1# (QVELT |fc| 2) . #2#) G190
                              (COND ((QSGREATERP |i| #1#) #3#))
                              (SEQ (LETT |pl|
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL |x| (QREFELT $ 10))
                                      (QREFELT $ 17))
                                     |pl|) . #2#)
                                   (EXIT
                                    (LETT |x|
                                     (SPADCALL |x| (QREFELT $ 28)) . #2#)))
                              (LETT |i| (QSADD1 |i|) . #2#) #4# G191
                              (EXIT NIL))
                         (EXIT (SPADCALL
                                   (SPADCALL (NREVERSE |pl|)
                                    (QREFELT $ 29))
                                   (QREFELT $ 21)))))) . #2#)
           (EXIT (SPADCALL (NREVERSE (CONS |pp| |le|)) (QREFELT $ 26))))))) 

(DEFUN |STREAM;listm| (|x| |le| |n| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 12)) |le|)
    ((SPADCALL |x| (QREFELT $ 13))
     (COND
       ((< 0 |n|)
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) |le|)
          ('T
           (|STREAM;listm| (SPADCALL |x| (QREFELT $ 14))
               (CONS (SPADCALL (SPADCALL |x| (QREFELT $ 10))
                         (QREFELT $ 17))
                     |le|)
               (- |n| 1) $))))
       ('T (CONS (SPADCALL "..." (QREFELT $ 19)) |le|))))
    ('T
     (|STREAM;listm| (SPADCALL |x| (QREFELT $ 14))
         (CONS (SPADCALL (SPADCALL |x| (QREFELT $ 10)) (QREFELT $ 17))
               |le|)
         (- |n| 1) $)))) 

(DEFUN |STREAM;showAllElements;$Of;11| (|x| $)
  (PROG (|cycElt| |cycEnt| |le| |len| |i| |pl| |pp|)
    (RETURN
      (SEQ (SPADCALL |x| |$streamCount| (QREFELT $ 31))
           (LETT |cycElt| (SPADCALL |x| (QREFELT $ 34))
                 . #0=(|STREAM;showAllElements;$Of;11|))
           (EXIT (COND
                   ((QEQCAR |cycElt| 1)
                    (SEQ (LETT |le|
                               (|STREAM;listm| |x| NIL |$streamCount|
                                   $) . #0#)
                         (EXIT (SPADCALL (NREVERSE |le|)
                                   (QREFELT $ 26)))))
                   (#1='T
                    (SEQ (LETT |cycEnt|
                               (SPADCALL |x| (QCDR |cycElt|)
                                   (QREFELT $ 35)) . #0#)
                         (LETT |le| NIL . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |x| |cycEnt|
                                           (QREFELT $ 20))
                                          'NIL)
                                         ('T 'T)))
                                 #2=(GO G191)))
                              (SEQ (LETT |le|
                                    (CONS
                                     (SPADCALL
                                      (SPADCALL |x| (QREFELT $ 10))
                                      (QREFELT $ 17))
                                     |le|) . #0#)
                                   (EXIT
                                    (LETT |x|
                                     (SPADCALL |x| (QREFELT $ 14)) . #0#)))
                              NIL #3=(GO G190) G191 (EXIT NIL))
                         (LETT |len|
                               (SPADCALL (QCDR |cycElt|)
                                   (QREFELT $ 36)) . #0#)
                         (LETT |pp|
                               (COND
                                 ((EQL |len| 1)
                                  (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |x| (QREFELT $ 10))
                                       (QREFELT $ 17))
                                      (QREFELT $ 21)))
                                 (#1#
                                  (SEQ (LETT |pl| NIL . #0#)
                                       (SEQ (LETT |i| 1 . #0#) G190
                                        (COND
                                          ((QSGREATERP |i| |len|) #2#))
                                        (SEQ
                                         (LETT |pl|
                                          (CONS
                                           (SPADCALL
                                            (SPADCALL |x|
                                             (QREFELT $ 10))
                                            (QREFELT $ 17))
                                           |pl|) . #0#)
                                         (EXIT
                                          (LETT |x|
                                           (SPADCALL |x|
                                            (QREFELT $ 14)) . #0#)))
                                        (LETT |i| (QSADD1 |i|) . #0#)
                                        #3# G191 (EXIT NIL))
                                       (EXIT
                                        (SPADCALL
                                         (SPADCALL (NREVERSE |pl|)
                                          (QREFELT $ 29))
                                         (QREFELT $ 21)))))) . #0#)
                         (EXIT (SPADCALL (NREVERSE (CONS |pp| |le|))
                                   (QREFELT $ 26))))))))))) 

(DEFUN |STREAM;showAll?;B;12| ($)
  (COND ((NULL |$streamsShowAll|) 'NIL) ('T 'T))) 

(DEFUN |STREAM;coerce;$Of;13| (|x| $)
  (COND
    ((SPADCALL (QREFELT $ 38)) (SPADCALL |x| (QREFELT $ 37)))
    ('T (|STREAM;streamCountCoerce| |x| $)))) 

(DEFUN |STREAM;lazyCopy| (|x| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;lazyCopy!0| (VECTOR $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;lazyCopy!0| ($$)
  (PROG (|x| $)
    (LETT |x| (QREFELT $$ 1) . #0=(|STREAM;lazyCopy|))
    (LETT $ (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) (SPADCALL (QREFELT $ 40)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 41))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;copy;2$;15| (|x| $)
  (PROG (|cycElt| |ce| |len| |e| |d| |cycle| #0=#:G1965 |head|)
    (RETURN
      (SEQ (LETT |cycElt| (SPADCALL |x| (QREFELT $ 34))
                 . #1=(|STREAM;copy;2$;15|))
           (EXIT (COND
                   ((QEQCAR |cycElt| 1) (|STREAM;lazyCopy| |x| $))
                   (#2='T
                    (SEQ (LETT |ce| (QCDR |cycElt|) . #1#)
                         (LETT |len|
                               (SPADCALL |ce| (QREFELT $ 36)) . #1#)
                         (LETT |e|
                               (SPADCALL |x| |ce| (QREFELT $ 35)) . #1#)
                         (LETT |d|
                               (SPADCALL |x| |e| (QREFELT $ 45)) . #1#)
                         (LETT |cycle|
                               (SPADCALL
                                   (SPADCALL |e| |len| (QREFELT $ 46))
                                   (QREFELT $ 47)) . #1#)
                         (|STREAM;setrst!|
                             (SPADCALL |cycle| (QREFELT $ 48)) |cycle|
                             $)
                         (EXIT (COND
                                 ((EQL |d| 0) |cycle|)
                                 (#2#
                                  (SEQ (LETT |head|
                                        (SPADCALL
                                         (SPADCALL |x|
                                          (PROG1 (LETT #0# |d| . #1#)
                                            (|check-subtype| (>= #0# 0)
                                             '(|NonNegativeInteger|)
                                             #0#))
                                          (QREFELT $ 46))
                                         (QREFELT $ 47)) . #1#)
                                       (|STREAM;setrst!|
                                        (SPADCALL |head|
                                         (QREFELT $ 48))
                                        |cycle| $)
                                       (EXIT |head|))))))))))))) 

(DEFUN |STREAM;construct;L$;16| (|l| $)
  (COND
    ((NULL |l|) (SPADCALL (QREFELT $ 40)))
    ('T
     (SPADCALL (|SPADfirst| |l|) (SPADCALL (CDR |l|) (QREFELT $ 50))
         (QREFELT $ 42))))) 

(DEFUN |STREAM;elt;$IS;17| (|x| |n| $)
  (COND
    ((OR (< |n| 1) (SPADCALL |x| (QREFELT $ 15)))
     (|error| "elt: no such element"))
    ('T
     (COND
       ((EQL |n| 1) (SPADCALL |x| (QREFELT $ 10)))
       ('T
        (SPADCALL (SPADCALL |x| (QREFELT $ 14)) (- |n| 1)
            (QREFELT $ 51))))))) 

(DEFUN |STREAM;seteltt| (|x| |n| |s| $)
  (COND
    ((EQL |n| 1) (|STREAM;setfrst!| |x| |s| $))
    ('T
     (|STREAM;seteltt| (SPADCALL |x| (QREFELT $ 14)) (- |n| 1) |s| $)))) 

(DEFUN |STREAM;setelt;$I2S;19| (|x| |n| |s| $)
  (SEQ (COND
         ((OR (< |n| 1) (SPADCALL |x| (QREFELT $ 15)))
          (|error| "setelt: no such element"))
         ('T
          (SEQ (LETT |x| (|STREAM;expand!| |x| (+ (- |n| 1) 1) $)
                     |STREAM;setelt;$I2S;19|)
               (EXIT (|STREAM;seteltt| |x| |n| |s| $))))))) 

(DEFUN |STREAM;removee| (|p| |x| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;removee!0| (VECTOR |p| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;removee!0| ($$)
  (PROG (|x| $ |p|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;removee|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |p| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) (SPADCALL (QREFELT $ 40)))
          ((SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|)
           (SPADCALL |p| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 54)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL |p| (SPADCALL |x| (QREFELT $ 14))
                   (QREFELT $ 54))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;remove;M2$;21| (|p| |x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 12)) (SPADCALL (QREFELT $ 40)))
    ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 20))
     (COND
       ((SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|)
        (SPADCALL (QREFELT $ 40)))
       ('T |x|)))
    ('T (|STREAM;removee| |p| |x| $)))) 

(DEFUN |STREAM;selectt| (|p| |x| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;selectt!0| (VECTOR |p| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;selectt!0| ($$)
  (PROG (|x| $ |p|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;selectt|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |p| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) (SPADCALL (QREFELT $ 40)))
          ((NULL (SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|))
           (SPADCALL |p| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 55)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL |p| (SPADCALL |x| (QREFELT $ 14))
                   (QREFELT $ 55))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;select;M2$;23| (|p| |x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 12)) (SPADCALL (QREFELT $ 40)))
    ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 20))
     (COND
       ((SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|) |x|)
       ('T (SPADCALL (QREFELT $ 40)))))
    ('T (|STREAM;selectt| |p| |x| $)))) 

(DEFUN |STREAM;map;M2$;24| (|f| |x| $)
  (SPADCALL |f| |x| (QREFELT $ 59))) 

(DEFUN |STREAM;map;M3$;25| (|g| |x| |y| $)
  (PROG (|xs| |ys|)
    (RETURN
      (SEQ (LETT |xs| |x| . #0=(|STREAM;map;M3$;25|))
           (LETT |ys| |y| . #0#)
           (EXIT (SPADCALL |g| |xs| |ys| (QREFELT $ 63))))))) 

(DEFUN |STREAM;fill!;$S$;26| (|x| |s| $)
  (SEQ (|STREAM;setfrst!| |x| |s| $)
       (EXIT (|STREAM;setrst!| |x| |x| $)))) 

(DEFUN |STREAM;map!;M2$;27| (|f| |x| $)
  (PROG (|tail| #0=#:G2067 |y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 66))
              (SEQ (LETT |tail| (SPADCALL |x| (QREFELT $ 67))
                         . #1=(|STREAM;map!;M2$;27|))
                   (LETT |y| |x| . #1#)
                   (SEQ (LETT #0# NIL . #1#) G190
                        (COND (#0# #2=(GO G191)))
                        (SEQ (|STREAM;setfrst!| |y|
                                 (SPADCALL
                                     (SPADCALL |y| (QREFELT $ 10)) |f|)
                                 $)
                             (EXIT (LETT |y|
                                    (SPADCALL |y| (QREFELT $ 14)) . #1#)))
                        (LETT #0#
                              (SPADCALL |y| |tail| (QREFELT $ 68)) . #1#)
                        #3=(GO G190) G191 (EXIT NIL))
                   (EXIT |x|)))
             ((SPADCALL |x| (QREFELT $ 69))
              (SEQ (LETT |y| |x| . #1#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |y| (QREFELT $ 15)) 'NIL)
                                   ('T 'T)))
                           #2#))
                        (SEQ (|STREAM;setfrst!| |y|
                                 (SPADCALL
                                     (SPADCALL |y| (QREFELT $ 10)) |f|)
                                 $)
                             (EXIT (LETT |y|
                                    (SPADCALL |y| (QREFELT $ 14)) . #1#)))
                        NIL #3# G191 (EXIT NIL))
                   (EXIT |x|)))
             ('T (|error| "map!: stream with lazy evaluation"))))))) 

(DEFUN |STREAM;swap!;$2IV;28| (|x| |m| |n| $)
  (PROG (|xm| |xn|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |m| |x| (QREFELT $ 71))
              (COND
                ((NULL (SPADCALL |n| |x| (QREFELT $ 71)))
                 (EXIT (|error| "swap!: no such elements")))))
             ('T (EXIT (|error| "swap!: no such elements"))))
           (LETT |x| (|STREAM;expand!| |x| (+ (- (MAX |m| |n|) 1) 1) $)
                 . #0=(|STREAM;swap!;$2IV;28|))
           (LETT |xm| (SPADCALL |x| |m| (QREFELT $ 51)) . #0#)
           (LETT |xn| (SPADCALL |x| |n| (QREFELT $ 51)) . #0#)
           (SPADCALL |x| |m| |xn| (QREFELT $ 52))
           (SPADCALL |x| |n| |xm| (QREFELT $ 52)) (EXIT |x|))))) 

(DEFUN |STREAM;concat;$S$;29| (|x| |s| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;concat;$S$;29!0| (VECTOR |s| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;concat;$S$;29!0| ($$)
  (PROG (|x| $ |s|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;concat;$S$;29|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |s| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15))
           (SPADCALL |s| (SPADCALL (QREFELT $ 40)) (QREFELT $ 42)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL (SPADCALL |x| (QREFELT $ 14)) |s|
                   (QREFELT $ 74))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;concat;3$;30| (|x| |y| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;concat;3$;30!0| (VECTOR |y| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;concat;3$;30!0| ($$)
  (PROG (|x| $ |y|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;concat;3$;30|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |y| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) (SPADCALL |y| (QREFELT $ 41)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL (SPADCALL |x| (QREFELT $ 14)) |y|
                   (QREFELT $ 75))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;concat;L$;31| (|l| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;concat;L$;31!0| (VECTOR $ |l|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;concat;L$;31!0| ($$)
  (PROG (|l| $)
    (LETT |l| (QREFELT $$ 1) . #0=(|STREAM;concat;L$;31|))
    (LETT $ (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (PROG (|x|)
          (RETURN
            (COND
              ((SPADCALL |l| (QREFELT $ 77)) (SPADCALL (QREFELT $ 40)))
              ((SPADCALL (LETT |x| (SPADCALL |l| (QREFELT $ 78)) NIL)
                   (QREFELT $ 15))
               (SPADCALL (SPADCALL |l| (QREFELT $ 79)) (QREFELT $ 80)))
              ('T
               (SPADCALL (SPADCALL |x| (QREFELT $ 10))
                   (SPADCALL (SPADCALL |x| (QREFELT $ 14))
                       (SPADCALL (SPADCALL |l| (QREFELT $ 79))
                           (QREFELT $ 80))
                       (QREFELT $ 75))
                   (QREFELT $ 42)))))))))) 

(DEFUN |STREAM;setelt;$Us2S;32| (|x| |seg| |s| $)
  (PROG (|low| |high| #0=#:G2124 |i| #1=#:G2134 |y| #2=#:G2130)
    (RETURN
      (SEQ (LETT |low| (SPADCALL |seg| (QREFELT $ 82))
                 . #3=(|STREAM;setelt;$Us2S;32|))
           (EXIT (COND
                   ((SPADCALL |seg| (QREFELT $ 83))
                    (SEQ (LETT |high|
                               (SPADCALL |seg| (QREFELT $ 84)) . #3#)
                         (EXIT (COND
                                 ((< |high| |low|) |s|)
                                 ('T
                                  (SEQ (COND
                                         ((SPADCALL |low| |x|
                                           (QREFELT $ 71))
                                          (COND
                                            ((NULL
                                              (SPADCALL |high| |x|
                                               (QREFELT $ 71)))
                                             (EXIT
                                              (|error|
                                               "setelt: index out of range")))))
                                         ('T
                                          (EXIT
                                           (|error|
                                            "setelt: index out of range"))))
                                       (LETT |x|
                                        (|STREAM;expand!| |x|
                                         (+ (- |high| 1) 1) $) . #3#)
                                       (LETT |y|
                                        (SPADCALL |x|
                                         (PROG1
                                          (LETT #0# (- |low| 1) . #3#)
                                           (|check-subtype| (>= #0# 0)
                                            '(|NonNegativeInteger|)
                                            #0#))
                                         (QREFELT $ 85)) . #3#)
                                       (SEQ (LETT |i| 0 . #3#)
                                        (LETT #1#
                                         (- |high| |low|) . #3#)
                                        G190
                                        (COND
                                          ((QSGREATERP |i| #1#)
                                           (GO G191)))
                                        (SEQ
                                         (|STREAM;setfrst!| |y| |s| $)
                                         (EXIT
                                          (LETT |y|
                                           (SPADCALL |y|
                                            (QREFELT $ 14)) . #3#)))
                                        (LETT |i| (QSADD1 |i|) . #3#)
                                        (GO G190) G191 (EXIT NIL))
                                       (EXIT |s|)))))))
                   ((NULL (SPADCALL |low| |x| (QREFELT $ 71)))
                    (|error| "setelt: index out of range"))
                   ('T
                    (SEQ (LETT |x|
                               (SPADCALL |x|
                                   (PROG1 (LETT #2# (- |low| 1) . #3#)
                                     (|check-subtype| (>= #2# 0)
                                      '(|NonNegativeInteger|) #2#))
                                   (QREFELT $ 85)) . #3#)
                         (|STREAM;setrst!| |x| |x| $)
                         (EXIT (|STREAM;setfrst!| |x| |s| $)))))))))) 

(DEFUN |STREAM;empty;$;33| ($) (CONS (QREFELT $ 7) NIL)) 

(DEFUN |STREAM;lazyEval| (|x| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 14)))) 

(DEFUN |STREAM;lazyEvaluate;2$;35| (|x| $)
  (PROG (|st|)
    (RETURN
      (SEQ (LETT |st| (|STREAM;lazyEval| |x| $)
                 |STREAM;lazyEvaluate;2$;35|)
           (|STREAM;setfrst!| |x| (SPADCALL |st| (QREFELT $ 10)) $)
           (|STREAM;setrst!| |x|
               (COND
                 ((EQ (SPADCALL |st| (QREFELT $ 14)) |st|) |x|)
                 ('T (SPADCALL |st| (QREFELT $ 14))))
               $)
           (EXIT |x|))))) 

(DEFUN |STREAM;empty?;$B;36| (|x| $)
  (PROG (|st|)
    (RETURN
      (SEQ (SEQ G190
                (COND
                  ((NULL (SPADCALL |x| (QREFELT $ 13))) (GO G191)))
                (SEQ (LETT |st| (|STREAM;lazyEval| |x| $)
                           |STREAM;empty?;$B;36|)
                     (|STREAM;setfrst!| |x|
                         (SPADCALL |st| (QREFELT $ 10)) $)
                     (EXIT (|STREAM;setrst!| |x|
                               (COND
                                 ((EQ (SPADCALL |st| (QREFELT $ 14))
                                      |st|)
                                  |x|)
                                 ('T (SPADCALL |st| (QREFELT $ 14))))
                               $)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |x| (QREFELT $ 12))))))) 

(DEFUN |STREAM;first;$Nni$;37| (|x| |n| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;first;$Nni$;37!0| (VECTOR |x| $ |n|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;first;$Nni$;37!0| ($$)
  (PROG (|n| $ |x|)
    (LETT |n| (QREFELT $$ 2) . #0=(|STREAM;first;$Nni$;37|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |x| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (PROG (#1=#:G2177)
          (RETURN
            (COND
              ((OR (SPADCALL |n| (|spadConstant| $ 88) (QREFELT $ 90))
                   (SPADCALL |x| (QREFELT $ 15)))
               (SPADCALL (QREFELT $ 40)))
              ('T
               (SPADCALL (SPADCALL |x| (QREFELT $ 10))
                   (SPADCALL (SPADCALL |x| (QREFELT $ 14))
                       (PROG1 (LETT #1#
                                    (SPADCALL |n| (|spadConstant| $ 91)
                                     (QREFELT $ 93))
                                    NIL)
                         (|check-subtype| (>= #1# 0)
                             '(|NonNegativeInteger|) #1#))
                       (QREFELT $ 46))
                   (QREFELT $ 42)))))))))) 

(PUT '|STREAM;concat;S2$;38| '|SPADreplace| 'CONS) 

(DEFUN |STREAM;concat;S2$;38| (|s| |x| $) (CONS |s| |x|)) 

(DEFUN |STREAM;cons;S2$;39| (|s| |x| $)
  (SPADCALL |s| |x| (QREFELT $ 42))) 

(DEFUN |STREAM;cycleSplit!;2$;40| (|x| $)
  (PROG (|cycElt| |y| #0=#:G2193 |z|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |cycElt| (SPADCALL |x| (QREFELT $ 34))
                            . #1=(|STREAM;cycleSplit!;2$;40|))
                      (EXIT (COND
                              ((QEQCAR |cycElt| 1)
                               (|error| "cycleSplit!: non-cyclic stream"))
                              ('T
                               (SEQ (LETT |y|
                                     (SPADCALL |x| (QCDR |cycElt|)
                                      (QREFELT $ 35)) . #1#)
                                    (EXIT
                                     (COND
                                       ((SPADCALL |x| |y|
                                         (QREFELT $ 20))
                                        (SEQ (|STREAM;setToNil!| |x| $)
                                         (EXIT
                                          (PROGN
                                            (LETT #0# |y| . #1#)
                                            (GO #0#)))))
                                       ('T
                                        (SEQ
                                         (LETT |z|
                                          (SPADCALL |x| (QREFELT $ 14)) . #1#)
                                         (EXIT
                                          (SEQ G190 NIL
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((SPADCALL |y| |z|
                                                 (QREFELT $ 20))
                                                (SEQ
                                                 (SPADCALL |x|
                                                  (SPADCALL
                                                   (QREFELT $ 40))
                                                  (QREFELT $ 95))
                                                 (EXIT
                                                  (PROGN
                                                    (LETT #0#
                                                     |y| . #1#)
                                                    (GO #0#)))))
                                               ('T
                                                (SEQ
                                                 (LETT |x| |z| . #1#)
                                                 (EXIT
                                                  (LETT |z|
                                                   (SPADCALL |z|
                                                    (QREFELT $ 14)) . #1#)))))))
                                           NIL (GO G190) G191
                                           (EXIT NIL)))))))))))))
           #0# (EXIT #0#))))) 

(DEFUN |STREAM;expand!| (|x| |n| $)
  (PROG (|i| |cycElt| |d| |t| #0=#:G2203 |nLessD| |y| |e| #1=#:G2204)
    (RETURN
      (SEQ (COND
             ((< |n| 1) |x|)
             (#2='T
              (SEQ (LETT |y| |x| . #3=(|STREAM;expand!|))
                   (SEQ (LETT |i| 1 . #3#) G190
                        (COND
                          ((OR (QSGREATERP |i| |n|)
                               (NULL (COND
                                       ((SPADCALL |y| (QREFELT $ 15))
                                        'NIL)
                                       ('T 'T))))
                           (GO G191)))
                        (SEQ (EXIT (LETT |y|
                                    (SPADCALL |y| (QREFELT $ 14)) . #3#)))
                        (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                        (EXIT NIL))
                   (LETT |cycElt| (SPADCALL |x| (QREFELT $ 34)) . #3#)
                   (EXIT (COND
                           ((QEQCAR |cycElt| 1) |x|)
                           (#2#
                            (SEQ (LETT |e|
                                       (SPADCALL |x| (QCDR |cycElt|)
                                        (QREFELT $ 35)) . #3#)
                                 (LETT |d|
                                       (SPADCALL |x| |e|
                                        (QREFELT $ 45)) . #3#)
                                 (EXIT (COND
                                         ((< |d| |n|)
                                          (SEQ
                                           (COND
                                             ((EQL |d| 0)
                                              (SEQ (LETT |d| 1 . #3#)
                                               (LETT |t|
                                                (SPADCALL |e|
                                                 (QREFELT $ 67)) . #3#)
                                               (EXIT
                                                (COND
                                                  ((SPADCALL |t| |e|
                                                    (QREFELT $ 20))
                                                   (SEQ
                                                    (LETT |t|
                                                     (SPADCALL
                                                      (SPADCALL |t|
                                                       (QREFELT $ 10))
                                                      (SPADCALL
                                                       (QREFELT $ 40))
                                                      (QREFELT $ 42)) . #3#)
                                                    (LETT |e|
                                                     (|STREAM;setrst!|
                                                      |t| |t| $) . #3#)
                                                    (EXIT
                                                     (|STREAM;setrst!|
                                                      |x| |e| $))))
                                                  ('T
                                                   (SEQ
                                                    (|STREAM;setrst!|
                                                     |t|
                                                     (SPADCALL
                                                      (SPADCALL |e|
                                                       (QREFELT $ 10))
                                                      (SPADCALL |e|
                                                       (QREFELT $ 14))
                                                      (QREFELT $ 42))
                                                     $)
                                                    (EXIT
                                                     (LETT |e|
                                                      (SPADCALL |e|
                                                       (QREFELT $ 14)) . #3#)))))))))
                                           (LETT |nLessD|
                                            (PROG1
                                             (LETT #0#
                                              (- |n| |d|) . #3#)
                                              (|check-subtype|
                                               (>= #0# 0)
                                               '(|NonNegativeInteger|)
                                               #0#)) . #3#)
                                           (LETT |y|
                                            (SPADCALL
                                             (SPADCALL |e| |nLessD|
                                              (QREFELT $ 46))
                                             (QREFELT $ 47)) . #3#)
                                           (LETT |e|
                                            (SPADCALL |e| |nLessD|
                                             (QREFELT $ 85)) . #3#)
                                           (|STREAM;setrst!|
                                            (SPADCALL |y|
                                             (QREFELT $ 48))
                                            |e| $)
                                           (|STREAM;setrst!|
                                            (SPADCALL |x|
                                             (PROG1
                                              (LETT #1#
                                               (- |d| 1) . #3#)
                                               (|check-subtype|
                                                (>= #1# 0)
                                                '(|NonNegativeInteger|)
                                                #1#))
                                             (QREFELT $ 85))
                                            |y| $)
                                           (EXIT |x|)))
                                         (#2# |x|)))))))))))))) 

(DEFUN |STREAM;first;$S;42| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 15))
     (|error| "Can't take the first of an empty stream."))
    ('T (SPADCALL |x| (QREFELT $ 10))))) 

(DEFUN |STREAM;concat!;3$;43| (|x| |y| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 15)) |y|)
    ('T (|STREAM;setrst!| (SPADCALL |x| (QREFELT $ 48)) |y| $)))) 

(DEFUN |STREAM;concat!;$S$;44| (|x| |s| $)
  (SPADCALL |x| (SPADCALL |s| (SPADCALL (QREFELT $ 40)) (QREFELT $ 42))
      (QREFELT $ 97))) 

(DEFUN |STREAM;setfirst!;$2S;45| (|x| |s| $)
  (SPADCALL |x| 0 |s| (QREFELT $ 52))) 

(DEFUN |STREAM;setelt;$first2S;46| (|x| T0 |s| $)
  (SPADCALL |x| |s| (QREFELT $ 99))) 

(DEFUN |STREAM;setrest!;3$;47| (|x| |y| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 15)) (|error| "setrest!: empty stream"))
    ('T (|STREAM;setrst!| |x| |y| $)))) 

(DEFUN |STREAM;setelt;$rest2$;48| (|x| T1 |y| $)
  (SPADCALL |x| |y| (QREFELT $ 95))) 

(DEFUN |STREAM;setlast!;$2S;49| (|x| |s| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 15)) (|error| "setlast!: empty stream"))
    ('T (|STREAM;setfrst!| (SPADCALL |x| (QREFELT $ 48)) |s| $)))) 

(DEFUN |STREAM;setelt;$last2S;50| (|x| T2 |s| $)
  (SPADCALL |x| |s| (QREFELT $ 104))) 

(DEFUN |STREAM;split!;$I$;51| (|x| |n| $)
  (PROG (#0=#:G2223 |y|)
    (RETURN
      (SEQ (COND
             ((< |n| 1) (|error| "split!: index out of range"))
             ((EQL |n| 1)
              (SEQ (LETT |y| (SPADCALL (QREFELT $ 40))
                         . #1=(|STREAM;split!;$I$;51|))
                   (|STREAM;setfrst!| |y| (SPADCALL |x| (QREFELT $ 10))
                       $)
                   (|STREAM;setrst!| |y| (SPADCALL |x| (QREFELT $ 14))
                       $)
                   (|STREAM;setToNil!| |x| $) (EXIT |y|)))
             ('T
              (SEQ (LETT |x| (|STREAM;expand!| |x| (- |n| 1) $) . #1#)
                   (LETT |x|
                         (SPADCALL |x|
                             (PROG1 (LETT #0# (- (- |n| 1) 1) . #1#)
                               (|check-subtype| (>= #0# 0)
                                   '(|NonNegativeInteger|) #0#))
                             (QREFELT $ 85)) . #1#)
                   (LETT |y| (SPADCALL |x| (QREFELT $ 28)) . #1#)
                   (|STREAM;setrst!| |x| (SPADCALL (QREFELT $ 40)) $)
                   (EXIT |y|)))))))) 

(DEFUN |STREAM;coerce;L$;52| (|l| $) (SPADCALL |l| (QREFELT $ 50))) 

(DEFUN |STREAM;repeating;L$;53| (|l| $)
  (PROG (|x0| |x|)
    (RETURN
      (SEQ (COND
             ((NULL |l|)
              (|error| "Need a non-null list to make a repeating stream."))
             ('T
              (SEQ (LETT |x0|
                         (LETT |x| (SPADCALL |l| (QREFELT $ 50))
                               . #0=(|STREAM;repeating;L$;53|)) . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL
                                     (SPADCALL |x| (QREFELT $ 14))
                                     (QREFELT $ 15))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (EXIT (LETT |x|
                                    (SPADCALL |x| (QREFELT $ 14)) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT (|STREAM;setrst!| |x| |x0| $))))))))) 

(DEFUN |STREAM;repeating?;L$B;54| (|l| |x| $)
  (PROG (|x0| |s| #0=#:G2243 #1=#:G2242)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL |l|)
                    (|error| "Need a non-empty? list to make a repeating stream."))
                   ((NULL (CDR |l|))
                    (COND
                      ((OR (SPADCALL |x| (QREFELT $ 15))
                           (NULL (SPADCALL
                                     (SPADCALL |x| (QREFELT $ 10))
                                     (|SPADfirst| |l|) (QREFELT $ 110))))
                       'NIL)
                      ('T
                       (SPADCALL |x| (SPADCALL |x| (QREFELT $ 14))
                           (QREFELT $ 111)))))
                   ('T
                    (SEQ (LETT |x0| |x|
                               . #2=(|STREAM;repeating?;L$B;54|))
                         (SEQ (LETT |s| NIL . #2#) (LETT #0# |l| . #2#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |s| (CAR #0#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((OR
                                        (SPADCALL |x| (QREFELT $ 15))
                                        (NULL
                                         (SPADCALL |s|
                                          (SPADCALL |x| (QREFELT $ 10))
                                          (QREFELT $ 110))))
                                       (PROGN
                                         (LETT #1# 'NIL . #2#)
                                         (GO #1#)))
                                      ('T
                                       (LETT |x|
                                        (SPADCALL |x| (QREFELT $ 14)) . #2#)))))
                              (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT (SPADCALL |x| |x0| (QREFELT $ 20)))))))
           #1# (EXIT #1#))))) 

(DEFUN |STREAM;findCycle;Nni$R;55| (|n| |x| $)
  (PROG (|hd| |tl| |i| |per| |xp| |npp|)
    (RETURN
      (SEQ (LETT |hd| |x| . #0=(|STREAM;findCycle;Nni$R;55|))
           (LETT |tl| (SPADCALL |x| |n| (QREFELT $ 85)) . #0#)
           (EXIT (COND
                   ((SPADCALL |tl| (QREFELT $ 12)) (VECTOR 'NIL 0 0))
                   ('T
                    (SEQ (LETT |i| 0 . #0#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL |x| |tl|
                                           (QREFELT $ 20))
                                          'NIL)
                                         ('T 'T)))
                                 #1=(GO G191)))
                              (SEQ (LETT |x|
                                    (SPADCALL |x| (QREFELT $ 14)) . #0#)
                                   (EXIT (LETT |i| (+ |i| 1) . #0#)))
                              NIL #2=(GO G190) G191 (EXIT NIL))
                         (EXIT (COND
                                 ((EQL |i| |n|) (VECTOR 'NIL 0 0))
                                 ('T
                                  (SEQ (LETT |x|
                                        (SPADCALL |x| (QREFELT $ 14)) . #0#)
                                       (LETT |per| 1 . #0#)
                                       (SEQ G190
                                        (COND
                                          ((NULL
                                            (COND
                                              ((SPADCALL |x| |tl|
                                                (QREFELT $ 20))
                                               'NIL)
                                              ('T 'T)))
                                           #1#))
                                        (SEQ
                                         (LETT |x|
                                          (SPADCALL |x| (QREFELT $ 14)) . #0#)
                                         (EXIT
                                          (LETT |per|
                                           (+ |per| 1) . #0#)))
                                        NIL #2# G191 (EXIT NIL))
                                       (LETT |x| |hd| . #0#)
                                       (LETT |xp|
                                        (SPADCALL |hd| |per|
                                         (QREFELT $ 85)) . #0#)
                                       (LETT |npp| 0 . #0#)
                                       (SEQ G190
                                        (COND
                                          ((NULL
                                            (COND
                                              ((SPADCALL |x| |xp|
                                                (QREFELT $ 20))
                                               'NIL)
                                              ('T 'T)))
                                           #1#))
                                        (SEQ
                                         (LETT |x|
                                          (SPADCALL |x| (QREFELT $ 14)) . #0#)
                                         (LETT |xp|
                                          (SPADCALL |xp|
                                           (QREFELT $ 14)) . #0#)
                                         (EXIT
                                          (LETT |npp|
                                           (+ |npp| 1) . #0#)))
                                        NIL #2# G191 (EXIT NIL))
                                       (EXIT (VECTOR 'T |npp| |per|)))))))))))))) 

(DEFUN |STREAM;delay;M$;56| (|fs| $) (CONS (QREFELT $ 8) |fs|)) 

(DEFUN |STREAM;explicitEntries?;$B;57| (|x| $)
  (COND
    ((OR (SPADCALL |x| (QREFELT $ 12)) (SPADCALL |x| (QREFELT $ 13)))
     'NIL)
    ('T 'T))) 

(DEFUN |STREAM;numberOfComputedEntries;$Nni;58| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 113))
     (+ (SPADCALL (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 114)) 1))
    ('T 0))) 

(DEFUN |STREAM;output;I$V;59| (|n| |x| $)
  (SEQ (COND
         ((< 0 |n|)
          (COND
            ((SPADCALL |x| (QREFELT $ 15))
             (EXIT (SPADCALL (QREFELT $ 115))))))
         ('T (EXIT (SPADCALL (QREFELT $ 115)))))
       (|mathPrint|
           (SPADCALL (SPADCALL |x| (QREFELT $ 10)) (QREFELT $ 17)))
       (EXIT (SPADCALL (- |n| 1) (SPADCALL |x| (QREFELT $ 14))
                 (QREFELT $ 116))))) 

(DEFUN |STREAM;setrestt!| (|x| |n| |y| $)
  (COND
    ((EQL |n| 0) (|STREAM;setrst!| |x| |y| $))
    ('T
     (|STREAM;setrestt!| (SPADCALL |x| (QREFELT $ 14)) (- |n| 1) |y| $)))) 

(DEFUN |STREAM;setrest!;$I2$;61| (|x| |n| |y| $)
  (SEQ (COND
         ((OR (< |n| 0) (SPADCALL |x| (QREFELT $ 15)))
          (|error| "setrest!: no such rest"))
         ('T
          (SEQ (LETT |x| (|STREAM;expand!| |x| (+ |n| 1) $)
                     |STREAM;setrest!;$I2$;61|)
               (EXIT (|STREAM;setrestt!| |x| |n| |y| $))))))) 

(DEFUN |STREAM;generate;M$;62| (|f| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;generate;M$;62!0| (VECTOR $ |f|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;generate;M$;62!0| ($$)
  (PROG (|f| $)
    (LETT |f| (QREFELT $$ 1) . #0=(|STREAM;generate;M$;62|))
    (LETT $ (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (SPADCALL (SPADCALL |f|) (SPADCALL |f| (QREFELT $ 119))
            (QREFELT $ 42)))))) 

(DEFUN |STREAM;gen| (|f| |s| $)
  (PROG ()
    (RETURN
      (SEQ (SPADCALL (CONS #'|STREAM;gen!0| (VECTOR $ |f| |s|))
               (QREFELT $ 44)))))) 

(DEFUN |STREAM;gen!0| ($$)
  (PROG (|f| $)
    (LETT |f| (QREFELT $$ 1) . #0=(|STREAM;gen|))
    (LETT $ (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (PROG (|ss|)
          (RETURN
            (SEQ (LETT |ss| (SPADCALL (QREFELT $$ 2) |f|) NIL)
                 (EXIT (SPADCALL |ss| (|STREAM;gen| |f| |ss| $)
                           (QREFELT $ 42)))))))))) 

(DEFUN |STREAM;generate;MS$;64| (|f| |s| $)
  (SPADCALL |s| (|STREAM;gen| |f| |s| $) (QREFELT $ 42))) 

(DEFUN |STREAM;concat;3$;65| (|x| |y| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;concat;3$;65!0| (VECTOR |y| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;concat;3$;65!0| ($$)
  (PROG (|x| $ |y|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;concat;3$;65|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |y| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) |y|)
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL (SPADCALL |x| (QREFELT $ 14)) |y|
                   (QREFELT $ 75))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;swhilee| (|p| |x| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;swhilee!0| (VECTOR |p| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;swhilee!0| ($$)
  (PROG (|x| $ |p|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;swhilee|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |p| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((OR (SPADCALL |x| (QREFELT $ 15))
               (NULL (SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|)))
           (SPADCALL (QREFELT $ 40)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL |p| (SPADCALL |x| (QREFELT $ 14))
                   (QREFELT $ 121))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;filterWhile;M2$;67| (|p| |x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 12)) (SPADCALL (QREFELT $ 40)))
    ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 20))
     (COND
       ((SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|) |x|)
       ('T (SPADCALL (QREFELT $ 40)))))
    ('T (|STREAM;swhilee| |p| |x| $)))) 

(DEFUN |STREAM;suntill| (|p| |x| $)
  (PROG ()
    (RETURN
      (SPADCALL (CONS #'|STREAM;suntill!0| (VECTOR |p| $ |x|))
          (QREFELT $ 44))))) 

(DEFUN |STREAM;suntill!0| ($$)
  (PROG (|x| $ |p|)
    (LETT |x| (QREFELT $$ 2) . #0=(|STREAM;suntill|))
    (LETT $ (QREFELT $$ 1) . #0#)
    (LETT |p| (QREFELT $$ 0) . #0#)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL |x| (QREFELT $ 15)) (SPADCALL (QREFELT $ 40)))
          ((SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|)
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL (QREFELT $ 40)) (QREFELT $ 42)))
          ('T
           (SPADCALL (SPADCALL |x| (QREFELT $ 10))
               (SPADCALL |p| (SPADCALL |x| (QREFELT $ 14))
                   (QREFELT $ 122))
               (QREFELT $ 42)))))))) 

(DEFUN |STREAM;filterUntil;M2$;69| (|p| |x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 12)) (SPADCALL (QREFELT $ 40)))
    ((SPADCALL |x| (SPADCALL |x| (QREFELT $ 14)) (QREFELT $ 20))
     (COND
       ((SPADCALL (SPADCALL |x| (QREFELT $ 10)) |p|)
        (SPADCALL (SPADCALL |x| (QREFELT $ 10))
            (SPADCALL (QREFELT $ 40)) (QREFELT $ 42)))
       ('T |x|)))
    ('T (|STREAM;suntill| |p| |x| $)))) 

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

(DEFUN |Stream;| (|#1|)
  (PROG (DV$1 |dv$| $ #0=#:G2373 |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #1=(|Stream|))
        (LETT |dv$| (LIST '|Stream| DV$1) . #1#)
        (LETT $ (GETREFV 130) . #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|))))
                            (|HasCategory| |#1|
                                '(|ConvertibleTo| (|InputForm|)))
                            (|HasCategory| (|Integer|) '(|OrderedSet|)))) . #1#))
        (|haddProp| |$ConstructorCache| '|Stream| (LIST DV$1)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (AND (|HasCategory| $ '(|finiteAggregate|))
             (|augmentPredVector| $ 16))
        (AND (|HasCategory| $ '(|finiteAggregate|)) #0#
             (|augmentPredVector| $ 32))
        (AND (|HasCategory| $ '(|shallowlyMutable|))
             (|augmentPredVector| $ 64))
        (QSETREFV $ 7 |$NullStream|)
        (QSETREFV $ 8 |$NonNullStream|)
        (QSETREFV $ 9
            (|Record| (|:| |firstElt| |#1|) (|:| |restOfStream| $)))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 37
                 (CONS (|dispatchFunction|
                           |STREAM;showAllElements;$Of;11|)
                       $))
             (QSETREFV $ 38
                 (CONS (|dispatchFunction| |STREAM;showAll?;B;12|) $))
             (QSETREFV $ 39
                 (CONS (|dispatchFunction| |STREAM;coerce;$Of;13|) $)))))
        (COND
          ((|testBitVector| |pv$| 1)
           (QSETREFV $ 112
               (CONS (|dispatchFunction| |STREAM;repeating?;L$B;54|) $))))
        (COND
          ((|testBitVector| |pv$| 1)
           (QSETREFV $ 116
               (CONS (|dispatchFunction| |STREAM;output;I$V;59|) $))))
        $)))) 

(MAKEPROP '|Stream| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|NullStream|
             '|NonNullStream| '|Rep| |STREAM;frst;$S;3| (|Boolean|)
             |STREAM;explicitlyEmpty?;$B;1| |STREAM;lazy?;$B;2|
             |STREAM;rst;2$;4| |STREAM;empty?;$B;36| (|OutputForm|)
             (0 . |coerce|) (|String|) (5 . |message|) (10 . |eq?|)
             (16 . |overbar|)
             (|Record| (|:| |cycle?| 11) (|:| |prefix| 23)
                 (|:| |period| 23))
             (|NonNegativeInteger|) |STREAM;findCycle;Nni$R;55|
             (|List| $) (21 . |bracket|) |STREAM;first;$S;42|
             (26 . |rest|) (31 . |commaSeparate|) (|Integer|)
             (36 . |extend|) (|Union| $$ '"failed")
             (|CyclicStreamTools| 6 $$) (42 . |cycleElt|)
             (47 . |computeCycleEntry|) (53 . |computeCycleLength|)
             (58 . |showAllElements|) (63 . |showAll?|) (67 . |coerce|)
             |STREAM;empty;$;33| |STREAM;copy;2$;15|
             |STREAM;concat;S2$;38| (|Mapping| $) |STREAM;delay;M$;56|
             (72 . |distance|) |STREAM;first;$Nni$;37|
             (78 . |complete|) (83 . |tail|) (|List| 6)
             |STREAM;construct;L$;16| |STREAM;elt;$IS;17|
             |STREAM;setelt;$I2S;19| (|Mapping| 11 6)
             |STREAM;remove;M2$;21| |STREAM;select;M2$;23| (|Stream| 6)
             (|Mapping| 6 6) (|StreamFunctions2| 6 6) (88 . |map|)
             |STREAM;map;M2$;24| (|Mapping| 6 6 6)
             (|StreamFunctions3| 6 6 6) (94 . |map|)
             |STREAM;map;M3$;25| |STREAM;fill!;$S$;26|
             (101 . |cyclic?|) (106 . |cycleTail|) (111 . =)
             (117 . |explicitlyFinite?|) |STREAM;map!;M2$;27|
             (122 . |index?|) (|Void|) |STREAM;swap!;$2IV;28|
             |STREAM;concat;$S$;29| |STREAM;concat;3$;65| (|List| $$)
             (128 . |empty?|) (133 . |first|) (138 . |rest|)
             |STREAM;concat;L$;31| (|UniversalSegment| 30) (143 . |lo|)
             (148 . |hasHi|) (153 . |hi|) (158 . |rest|)
             |STREAM;setelt;$Us2S;32| |STREAM;lazyEvaluate;2$;35|
             (164 . |Zero|) (168 . |Zero|) (172 . =) (178 . |One|)
             (182 . |One|) (186 . -) |STREAM;cons;S2$;39|
             |STREAM;setrest!;3$;47| |STREAM;cycleSplit!;2$;40|
             |STREAM;concat!;3$;43| |STREAM;concat!;$S$;44|
             |STREAM;setfirst!;$2S;45| '"first"
             |STREAM;setelt;$first2S;46| '"rest"
             |STREAM;setelt;$rest2$;48| |STREAM;setlast!;$2S;49|
             '"last" |STREAM;setelt;$last2S;50| |STREAM;split!;$I$;51|
             |STREAM;coerce;L$;52| |STREAM;repeating;L$;53| (192 . =)
             (198 . =) (204 . |repeating?|)
             |STREAM;explicitEntries?;$B;57|
             |STREAM;numberOfComputedEntries;$Nni;58| (210 . |void|)
             (214 . |output|) |STREAM;setrest!;$I2$;61| (|Mapping| 6)
             |STREAM;generate;M$;62| |STREAM;generate;MS$;64|
             |STREAM;filterWhile;M2$;67| |STREAM;filterUntil;M2$;69|
             (|List| 124) (|Equation| 6) '"value" (|InputForm|)
             (|SingleInteger|) (|List| 30) (|Union| 6 '"failed"))
          '#(~= 220 |value| 226 |third| 231 |tail| 236 |swap!| 241
             |split!| 248 |size?| 254 |showAllElements| 260 |showAll?|
             265 |setvalue!| 269 |setrest!| 275 |setlast!| 288
             |setfirst!| 294 |setelt| 300 |setchildren!| 342 |select|
             348 |second| 354 |sample| 359 |rst| 363 |rest| 368
             |repeating?| 379 |repeating| 385 |removeDuplicates| 390
             |remove| 395 |reduce| 407 |qsetelt!| 428 |qelt| 435
             |possiblyInfinite?| 441 |parts| 446 |output| 451
             |numberOfComputedEntries| 457 |nodes| 462 |node?| 467
             |new| 473 |more?| 479 |minIndex| 485 |members| 490
             |member?| 495 |maxIndex| 501 |map!| 506 |map| 512 |less?|
             525 |leaves| 531 |leaf?| 536 |lazyEvaluate| 541 |lazy?|
             546 |latex| 551 |last| 556 |insert| 567 |indices| 581
             |index?| 586 |hash| 592 |generate| 597 |frst| 608 |first|
             613 |findCycle| 624 |find| 630 |filterWhile| 636
             |filterUntil| 642 |fill!| 648 |extend| 654
             |explicitlyFinite?| 660 |explicitlyEmpty?| 665
             |explicitEntries?| 670 |every?| 675 |eval| 681 |eq?| 707
             |entry?| 713 |entries| 719 |empty?| 724 |empty| 729 |elt|
             733 |distance| 776 |delete| 782 |delay| 794 |cyclic?| 799
             |cycleTail| 804 |cycleSplit!| 809 |cycleLength| 814
             |cycleEntry| 819 |count| 824 |copy| 836 |convert| 841
             |construct| 846 |cons| 851 |concat!| 857 |concat| 869
             |complete| 892 |coerce| 897 |children| 907 |child?| 912
             |any?| 918 = 924 |#| 930)
          'NIL
          (CONS (|makeByteWordVec2| 3
                    '(0 0 0 0 0 0 0 0 0 0 2 1 0 0 0 2 1 1 3))
                (CONS '#(|LazyStreamAggregate&| |StreamAggregate&|
                         |UnaryRecursiveAggregate&| |LinearAggregate&|
                         |RecursiveAggregate&| |Collection&|
                         |IndexedAggregate&| |HomogeneousAggregate&|
                         |EltableAggregate&| |Aggregate&| |Evalable&|
                         |SetCategory&| NIL NIL NIL |InnerEvalable&|
                         |BasicType&| NIL NIL)
                      (CONS '#((|LazyStreamAggregate| 6)
                               (|StreamAggregate| 6)
                               (|UnaryRecursiveAggregate| 6)
                               (|LinearAggregate| 6)
                               (|RecursiveAggregate| 6)
                               (|Collection| 6)
                               (|IndexedAggregate| 30 6)
                               (|HomogeneousAggregate| 6)
                               (|EltableAggregate| 30 6) (|Aggregate|)
                               (|Evalable| 6) (|SetCategory|)
                               (|shallowlyMutable|) (|Eltable| 30 6)
                               (|Type|) (|InnerEvalable| 6 6)
                               (|BasicType|) (|CoercibleTo| 16)
                               (|ConvertibleTo| 126))
                            (|makeByteWordVec2| 129
                                '(1 6 16 0 17 1 16 0 18 19 2 0 11 0 0
                                  20 1 16 0 0 21 1 16 0 25 26 1 0 0 0
                                  28 1 16 0 25 29 2 0 0 0 30 31 1 33 32
                                  2 34 2 33 2 2 2 35 1 33 23 2 36 1 0
                                  16 0 37 0 0 11 38 1 0 16 0 39 2 0 30
                                  0 0 45 1 0 0 0 47 1 0 0 0 48 2 58 56
                                  57 56 59 3 62 56 61 56 56 63 1 0 11 0
                                  66 1 0 0 0 67 2 9 11 2 2 68 1 0 11 0
                                  69 2 0 11 30 0 71 1 76 11 0 77 1 76 2
                                  0 78 1 76 0 0 79 1 81 30 0 82 1 81 11
                                  0 83 1 81 30 0 84 2 0 0 0 23 85 0 23
                                  0 88 0 30 0 89 2 23 11 0 0 90 0 23 0
                                  91 0 30 0 92 2 30 0 0 0 93 2 6 11 0 0
                                  110 2 0 11 0 0 111 2 0 11 49 0 112 0
                                  72 0 115 2 0 72 30 0 116 2 1 11 0 0 1
                                  1 0 6 0 1 1 0 6 0 1 1 0 0 0 48 3 7 72
                                  0 30 30 73 2 7 0 0 30 107 2 0 11 0 23
                                  1 1 1 16 0 37 0 1 11 38 2 7 6 0 6 1 2
                                  7 0 0 0 95 3 0 0 0 30 0 117 2 7 6 0 6
                                  104 2 7 6 0 6 99 3 7 6 0 30 6 52 3 7
                                  6 0 81 6 86 3 7 6 0 105 6 106 3 7 0 0
                                  102 0 103 3 7 6 0 100 6 101 3 7 6 0
                                  125 6 1 2 7 0 0 25 1 2 0 0 53 0 55 1
                                  0 6 0 1 0 0 0 1 1 0 0 0 14 2 0 0 0 23
                                  85 1 0 0 0 28 2 1 11 49 0 112 1 0 0
                                  49 109 1 6 0 0 1 2 6 0 6 0 1 2 0 0 53
                                  0 54 4 6 6 61 0 6 6 1 2 5 6 61 0 1 3
                                  5 6 61 0 6 1 3 7 6 0 30 6 1 2 0 6 0
                                  30 1 1 0 11 0 1 1 5 49 0 1 2 1 72 30
                                  0 116 1 0 23 0 114 1 0 25 0 1 2 1 11
                                  0 0 1 2 0 0 23 6 1 2 0 11 0 23 1 1 4
                                  30 0 1 1 5 49 0 1 2 6 11 6 0 1 1 4 30
                                  0 1 2 7 0 57 0 70 3 0 0 61 0 0 64 2 0
                                  0 57 0 60 2 0 11 0 23 1 1 0 49 0 1 1
                                  0 11 0 1 1 0 0 0 87 1 0 11 0 13 1 1
                                  18 0 1 2 0 0 0 23 1 1 0 6 0 1 3 0 0 6
                                  0 30 1 3 0 0 0 0 30 1 1 0 128 0 1 2 0
                                  11 30 0 71 1 1 127 0 1 2 0 0 57 6 120
                                  1 0 0 118 119 1 0 6 0 10 2 0 0 0 23
                                  46 1 0 6 0 27 2 0 22 23 0 24 2 0 129
                                  53 0 1 2 0 0 53 0 121 2 0 0 53 0 122
                                  2 7 0 0 6 65 2 0 0 0 30 31 1 0 11 0
                                  69 1 0 11 0 12 1 0 11 0 113 2 5 11 53
                                  0 1 3 2 0 0 6 6 1 3 2 0 0 49 49 1 2 2
                                  0 0 123 1 2 2 0 0 124 1 2 0 11 0 0 20
                                  2 6 11 6 0 1 1 0 49 0 1 1 0 11 0 15 0
                                  0 0 40 3 0 6 0 30 6 1 2 0 6 0 30 51 2
                                  0 0 0 81 1 2 0 6 0 105 1 2 0 0 0 102
                                  1 2 0 6 0 100 1 2 0 6 0 125 1 2 0 30
                                  0 0 45 2 0 0 0 30 1 2 0 0 0 81 1 1 0
                                  0 43 44 1 0 11 0 66 1 0 0 0 67 1 7 0
                                  0 96 1 0 23 0 1 1 0 0 0 1 2 6 23 6 0
                                  1 2 5 23 53 0 1 1 0 0 0 41 1 3 126 0
                                  1 1 0 0 49 50 2 0 0 6 0 94 2 7 0 0 6
                                  98 2 7 0 0 0 97 2 0 0 0 6 74 1 0 0 25
                                  80 2 0 0 0 0 75 2 0 0 6 0 42 1 0 0 0
                                  47 1 1 16 0 39 1 0 0 49 108 1 0 25 0
                                  1 2 1 11 0 0 1 2 5 11 53 0 1 2 1 11 0
                                  0 111 1 5 23 0 1)))))
          '|lookupComplete|)) 
