bump up the token limit again

Current state of code in the Mu computer:
  (
    (globals . (
      (hline1 . (fn () (screen y lo hi color)
                  (if (>= lo hi)
                    ()
                    ((fn ()
                       (pixel screen lo y color)
                       (hline1 screen y (+ lo 1) hi color))))))
      (vline1 . (fn () (screen x lo hi color)
                  (if (>= lo hi)
                    ()
                    ((fn ()
                       (pixel screen x lo color)
                       (vline1 screen x (+ lo 1) hi color))))))
      (hline . (fn () (screen y color)
                 (hline1 screen y 0 (width screen) color)))
      (vline . (fn () (screen y color)
                 (vline1 screen y 0 (height screen) color)))
      (andf . (fn () (a b)
                (if a
                  (if b
                    1
                    ())
                  ())))
      (brline . (fn () (screen x0 y0 x1 y1 color)
                   ((fn (dx dy sx sy)
                      ((fn (err)
                         (brline1 screen x0 y0 x1 y1 dx dy sx sy err color))
                       (+ dx dy)))
                    (abs (- x1 x0))
                    (- 0 (abs (- y1 y0)))
                    (sgn (- x1 x0))
                    (sgn (- y1 y0)))))
      (brline1 . (fn () (screen x y xmax ymax dx dy sx sy err color)
                   (pixel screen x y color)
                   (if (andf (= x xmax) (= y ymax))
                     ()
                     ((fn (e2)
                        (brline1 screen
                          (if (>= e2 dy)
                            (+ x sx)
                            x)
                          (if (<= e2 dx)
                            (+ y sy)
                            y)
                          xmax
                          ymax
                          dx
                          dy
                          sx
                          sy
                          (+ err
                             (+
                               (if (>= e2 dy)
                                 dy
                                 0)
                               (if (<= e2 dx)
                                 dx
                                 0)))
                          color))
                      (* err 2)))))
      (read_line_2 . (fn () (keyboard stream)
                       ((fn (c)
                         (if (= c 10)
                           stream
                           (if (= c 0)
                             stream
                             (read_line_2 keyboard (write stream c)))))
                        (key keyboard))))
      (read_line . (fn () (keyboard)
                     (read_line_2 keyboard (stream))))
      (fill_rect . (fn () (screen x1 y1 x2 y2 fill_color)
                     (if (>= y1 y2)
                       ()
                       ((fn ()
                          (hline1 screen y1 x1 x2 fill_color)
                          (fill_rect screen x1 (+ y1 1) x2 y2 fill_color))))))
      (chessboard . (fn () (screen px)
                      (chessboard1 screen px 0 15)))
      (chessboard1 . (fn () (screen px y color)
                      (if (>= y (height screen))
                        ()
                        ((fn ()
                           (chessboard2 screen px y 0 color)
                           (chessboard1 screen px (+ y px) (- 15 color)))))))
      (chessboard2 . (fn () (screen px y x color)
                      (if (>= x (width screen))
                        ()
                        ((fn ()
                           (fill_rect screen x y (+ x px) (+ y px) color)
                           (chessboard2 screen px y (+ x px) (- 15 color)))))))
    ))
    (sandbox . (chessboard screen 8))
  )

shell/read.mu

@@ -1,5 +1,5 @@
 fn read-cell in: (addr gap-buffer), out: (addr handle cell), trace: (addr trace) {
-  var tokens-storage: (stream cell 0x200)
+  var tokens-storage: (stream cell 0x400)
   var tokens/ecx: (addr stream cell) <- address tokens-storage
   tokenize in, tokens, trace
   var error?/eax: boolean <- has-errors? trace