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:             if (typep cell 'blank-cell)
              collect cell))))
  
  (defun cell-col (c)
    "list the cells with the same vertical constraint cell as `c`"
    (declare (cell c))
    (delete-if-not #'(lambda (x) (eql (verti c) (verti x)))
                   (blank-cells (puzzle c))))
  
  (defun cell-row (c)
    "list the cells with the same horizontal constraint cell as `c`"
    (declare (cell c))
    (delete-if-not #'(lambda (x) (eql (horiz c) (horiz x)))
                   (blank-cells (puzzle c))))
  
  (defun ways (sum len &optional other-cells)
    "calculate the ways to sum up to `sum` using `len` terms, optionally with already-marked cells"
  
negative.code: (in-package :kakuro)
  
  (defconstant +max-digit+ 9)
  (defconstant +usage-notes+
    "usage: kakuro [< input_file] [> output_file]")
  
  (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-of :initarg :puzzle :type puzzle
             :documentation "puzzle to which this cell belongs")))
  
  (defclass constraint-cell (cell)
    ((horizontal-constraint :accessor horizontal-constraint :initarg :horizontal-constraint :initform nil
            :documentation "required sum of the cells in the same row as this constraint cell")
     (vertical-constraint :accessor vertical-constraint :initarg :vertical-constraint :initform nil
            :documentation "required sum of the cells in the same column as this constraint cell"))
    (:documentation "cell representing a constraint on the sum of other cells"))
  
  (defmethod print-object ((c constraint-cell) stream)
    ;; constraint on column is displayed left of constraint on row
    (format stream "(~a ~a)" (vertical-constraint c) (horizontal-constraint c)))
  
  (defclass blank-cell (cell)
    ((constraint-row :accessor constraint-row :initarg :constraint-row :initform nil :type constraint-cell
            :documentation "the constraint cell in whose row this cell belongs")
     (constraint-col :accessor constraint-col :initarg :constraint-col :initform nil :type constraint-cell
            :documentation "the constraint cell in whose column this cell belongs")
     (mark :accessor mark :initarg :mark :initform nil
           :documentation "number written in the cell"))
    (:documentation "cell representing a player-fillable entry with constraints"))
  