anchor.diff:                  for cell = (entry-cell (read stream) x y)
                   do (setf (aref cells x y) cell)
                   if (typep cell 'blank-cell)
  -                do (setf (horiz cell) (svref curr-horiz-constraints x)
  -                         (verti cell) (svref curr-verti-constraints y))
  +                do (setf (constraint-row cell) (svref curr-horiz-constraints x)
  +                         (constraint-col cell) (svref curr-verti-constraints y))
                   else
                   if (typep cell 'wall-cell)
                   do (setf (svref curr-horiz-constraints x) nil
  
positive.code: (in-package :kakuro)
  
  (defconstant +max-digit+ 9)
  
  (defclass cell ()
    ((x :accessor x :initarg :x :type (integer 0 *)
        :documentation "x-coordinate of the cell, origin top-left, going down")
     (y :accessor y :initarg :y :type (integer 0 *)
        :documentation "y-coordinate of the cell, origin top-left, going right")
     (puzzle :accessor puzzle :initarg :puzzle :type puzzle
             :documentation "puzzle to which this cell belongs")))
  
  (defclass constraint-cell (cell)
    ((horiz :accessor horiz :initarg :horiz :initform nil
            :documentation "horizontal sum constraint")
     (verti :accessor verti :initarg :verti :initform nil
            :documentation "vertical sum constraint"))
    (:documentation "cell representing a constraint on the sum of other cells"))
  
  (defmethod print-object ((c constraint-cell) stream)
    (format stream "(~a ~a)" (verti c) (horiz c)))
  
  (defclass blank-cell (cell)
    ((horiz :accessor horiz :initarg :horiz :initform nil :type constraint-cell
            :documentation "horizontal constraint cell")
     (verti :accessor verti :initarg :verti :initform nil :type constraint-cell
            :documentation "vertical constraint cell")
     (mark :accessor mark :initarg :mark :initform nil
           :documentation "number written in the cell"))
    (:documentation "cell representing a player-fillable entry with constraints"))
  
negative.code:             if (typep cell 'blank-cell)
              collect cell))))
  
  (defun cell-col (cell)
    "list the cells with the same contiguous column as `cell`"
    (declare (cell cell))
    (delete-if-not #'(lambda (other-cell) (eql (constraint-col cell) (constraint-col other-cell)))
                   (blank-cells (puzzle-of cell))))
  
  (defun cell-row (cell)
    "list the cells with the same contiguous row as `cell`"
    (declare (cell cell))
    (delete-if-not #'(lambda (other-cell) (eql (constraint-row cell) (constraint-row other-cell)))
                   (blank-cells (puzzle-of cell))))
  
  (defun ways (sum len &optional other-cells)
    "calculate the ways to sum up to `sum` using `len` terms, optionally with already-marked cells"
  