anchor.diff:  
   ;;;; Colors
   
  -(declaim (inline make-color get-color put-pixel))
  -(defstruct color
  -  (r 0 :type u8)
  -  (g 0 :type u8)
  -  (b 0 :type u8))
  -
  -(defun get-color (index)
  -  (let* ((base (* index 3))
  +(declaim (inline get-color put-pixel))
  +(defmethod get-color ((ppu ppu) vram-index)
  +  (let* ((color-index (logand (read-vram ppu vram-index) #x3f))
  +         (base (* color-index 3))
            (red   (aref *color-palette* (+ 2 base)))
            (green (aref *color-palette* (+ 1 base)))
            (blue  (aref *color-palette* (+ 0 base))))
  
positive.code: 
  (defgeneric render-scanline (ppu)
    (:method ((ppu ppu)) ;; TODO: Mirroring. Scrolling?
      (let* ((bd-index (logand (read-vram ppu #x3f00) #x3f))
             (bd-color (get-color bd-index)))
        (dotimes (x +width+)
          (let* ((bg-color (when (show-bg ppu)
                             (get-bg-pixel ppu x)))
  
negative.code:                      (y (- (ppu-scanline ppu) (sprite-y sprite))))
                   (when (flip-h sprite) (setf x (- 7 x)))
                   (when (flip-v sprite) (setf y (- 7 y)))
                   (setf pattern-color (get-pattern-color ppu :sprite tile x y))))
                (list
                 (error "8x16 sprite rendering unimplemented!")))
              (unless (zerop pattern-color)
                (return nil))
              (when (and (zerop i) opaque-p)
                (set-sprite-zero-hit ppu 1))
              (let ((tile-color (logior (ash (palette sprite) 2) pattern-color)))
                (return (get-color ppu (+ #x3f00 tile-color))))))))
  
  ;;;; Misc Helpers
  
  (defun get-visible-sprites (ppu)
    ; TODO: Did I mistranslate semantics here?
    (with-accessors ((oam ppu-oam)) ppu
      (loop with count = 0 with result = (make-array 8 :initial-element nil)
         for i from 0 to 64 for sprite = (get-sprite ppu i)
         when (on-scanline sprite ppu)
         do (if (< count 8)
                (setf (aref result count) i
                      count (1+ count))
                (set-sprite-overflow ppu 1))
         finally (return result))))
  
  (defun on-top (x y)
    (declare (ignore x)) ; TODO: determine sprite priority
    y)
  
  ;;;; Core
  
  (defun buffered-read (ppu)
    (let* ((addr (ppu-addr ppu))
           (result (read-vram ppu addr)))
      (incf (ppu-addr ppu) (vram-step ppu))
      (if (< addr #x3f00)
          (prog1
              (ppu-buffer ppu)
            (setf (ppu-buffer ppu) result))
          result)))
  
  (defun get-byte-ppu% (addr)
    (let ((ppu (nes-ppu *nes*)))
  