anchor.diff:  
   (defun init-settings ()
     (setf *pixel-size* 600)
  -  (setf *cells-count* 200)
  +  (setf *cells-count* 100)
     (setf *cell-size* (/ *pixel-size* *cells-count*))
     (setf *matrix* (matrix-create *cells-count*))
  -  (matrix-iterate #'(lambda (x y)
  -		      (matrix-set x y (= (random 2) 0)))
  -		  *cells-count*)
  +  (iterate #'(lambda (x y)
  +	       (matrix-set *matrix* x y (= (random 2) 0)))
  +	   *cells-count*)
     (setf *dead-color* (sdl:color :r 255 :g 0 :b 0))
     (setf *alive-color* (sdl:color :r 0 :g 0 :b 0)))
   
  
positive.code: 	  do (push (make-array size) matrix))
      matrix))
  
  (defun matrix-iterate (f size)
    (let ((bounds (sub1 size)))
      (loop for x from 0 to bounds
  	  do (loop for y from 0 to bounds
  		   do (funcall f x y)))))
  
  (defun matrix-iterate-near (f x y)
    (let ((x0 (sub1 x))
  	(x2 (add1 x))
  	(y0 (sub1 y))
  
negative.code: ;;; ============
  
  (defun game-step ()
    (iterate #'(lambda (x y)
  	       (let ((count (game-count-alive x y))
  		     (alive (matrix-get *matrix* x y)))
  		 (if alive
  		     (if (or (= count 2) (= count 3))
  			 'survives
  		       (matrix-set *matrix* x y nil))
  		   (if (= count 3)
  		       (matrix-set *matrix* x y t)
  		     'left-empty))))
  	   *cells-count*))
  
  (defun game-count-alive (x0 y0)
    (let ((alive-count 0))
      (iterate-near #'(lambda (x y)
  		      (when (matrix-get *matrix* x y)
  			(setf alive-count (add1 alive-count))))
  		  x0
  		  y0)
      alive-count))
  
  ;;; Draw
  ;;; ====
  
  (defun draw-matrix ()
    (iterate #'(lambda (x y)
  	       (draw-cell x y (matrix-get *matrix* x y)))
  	   *cells-count*))
  
  (defun draw-cell (x y alive-p)
    (sdl:draw-box (sdl:rectangle-from-midpoint-* (* *cell-size* x)
  