(
  (globals . (
    (hline1 . (fn () (screen y lo hi color)
                (while (< lo hi)
                  (pixel screen lo y color)
                  (set lo (+ lo 1)))))
    (vline1 . (fn () (screen x lo hi color)
                (while (< lo hi)
                  (pixel screen x lo color)
                  (set lo (+ lo 1)))))
    (hline . (fn () (screen y color)
               (hline1 screen y 0 (width screen) color)))
    (vline . (fn () (screen y color)
               (vline1 screen y 0 (height screen) color)))
    (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)
                 (while (or (< x xmax) (< y ymax))
                   (pixel screen x y color)
                   ((fn (e2)
                      (if (>= e2 dy)
                        (set x (+ x sx))
                        ())
                      (if (<= e2 dx)
                        (set y (+ y sy)))
                      (set err (+ err
                           (+
                             (if (>= e2 dy)
                               dy
                               0)
                             (if (<= e2 dx)
                               dx
                               0)))))
                    (* 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)
                   (while (< y1 y2)
                     (hline1 screen y1 x1 x2 fill_color)
                     (set y1 (+ y1 1)))))
    (chessboard . (fn () (screen px)
                    (chessboard1 screen px 0 15)))
    (chessboard1 . (fn () (screen px y color)
                     (clear screen)
                     (while (< y (height screen))
                       (chessboard2 screen px y 0 color)
                       (set y (+ y px))
                       (chessboard2 screen px y px color)
                       (set y (+ y px)))))
    (chessboard2 . (fn () (screen px y x color)
                     (while (< x (width screen))
                       (fill_rect screen x y (+ x px) (+ y px) color)
                       (set x (+ x px))
                       (set x (+ x px)))))
    (main . (fn () (screen keyboard)
              (chessboard screen 16)))
  ))
  (sandbox . (+ 1 2))
)