anchor.diff:  (defun solve-nonogram (rows cols &optional puzzle)
     "Solve the nonogram puzzle represented by the given lists of solid lengths across each row and column.
   A full cell in a solution of the puzzle will be represented by T, and an empty cell by NIL."
  -  ;; Akin to the Sudoku solution, go through each combination of solids across a given row,
  -  ;; filtered based on the patterns for each column, which are adjusted accordingly.
  -  ;; Convert the inefficient tree recursion + mapcan implementation into an iterative tree search,
  -  ;; perhaps by recording lists of rows in place of each node (recursion) of the tree.
     (if (null rows)
         (list puzzle)
         ;; start from the last row
  
positive.code:                 ;; if every cell is compatible with the current state of columns
                  (when (every #'identity (mapcar #'car p))
                    (solve-nonogram (butlast rows)
                                    (mapcar #'cadr p)
                                    (cons row puzzle))))
                (generate-rows (car (last rows))))))
  
  ;; A column is represented as a list of numbers with last element possibly NIL, depending on if the last row can be filled.
  
  
negative.code:   "Separate COLS into firsts and rests based on whether row is T at each column."
    (loop for cell in row
          for col in cols
      if cell 
        collect (cons (column-first col) (column-rest col))
      else
        collect (cons T col)))
  
  (defun column-first (col)
    "Return T if a cell in the last row and same column as COL can be filled."
  