anchor.diff:      (destructuring-bind (origin-file origin-rank)
           (move-origin final-file final-rank board piece whitep capturep
                        :origin-file origin-file :origin-rank origin-rank)
  -      (setf (get-square board final-file final-rank)
  -            (if promotion
  -                (piece-char->symbol promotion whitep)
  -                (get-square board origin-file origin-rank))
  -            (get-square board origin-file origin-rank)
  -            nil)))
  +      (move-from-to board origin-file origin-rank final-file final-rank
  +                    :new-piece (when promotion
  +                                 (piece-char->symbol promotion whitep)))))
     board)
  
positive.code:               '((0 -1))))))
  
  (defun can-jump-p (piece-char)
    "Determines if a piece can move without concern for pieces on its path"
    (char-equal piece-char #\N))
  
  (defun being-attacked-p (file rank board white-attacker-p)
    "Searches for any pieces that could capture a certain square."
  
negative.code:               (char promotion 1))
              check))))
  
  (defun valid-check-sign-p (check-sign move board whitep)
    "Finds out if the check sign (empty string, hash, or plus) matches the
     the board's state after a move is performed."
    (let ((future-board (make-move move (duplicate-board board) whitep)))
      (and (not (check-p future-board whitep))
           (or (and (not check-sign)
                    (not (check-p future-board (not whitep))))
               (and (string= check-sign "+")
                    (check-p future-board (not whitep)))
               (and (string= check-sign "#")
                    (checkmate-p future-board (not whitep)))))))
  
  (defun valid-move-p (move board whitep)
    "Determines if a move can be performed on a given board."
    (when (destructure-move move)
      (destructuring-bind (piece origin-rank origin-file capturep
                                 final-file final-rank promotion check)
          (destructure-move move)
        (let ((origin (move-origin final-file final-rank board piece
                                   whitep capturep
                                   :origin-file origin-file
                                   :origin-rank origin-rank))
              (destination-square (get-square board final-file final-rank)))
          (and origin
               (if capturep
                   (if whitep
                       (black-piece-p destination-square)
                       (white-piece-p destination-square))
                   (null destination-square))
               (or (null promotion)
                   (can-promote-p piece final-rank whitep))
               (valid-check-sign-p check move board whitep))))))
  
  (defun move-from-to (board initial-file initial-rank final-file final-rank
                       &key new-piece)
    "Advances a single piece given an origin and a destination. The new-piece
     keyword parameter may be used to redefine a piece (promotion)."
    (setf (get-square board final-file final-rank)
          (if new-piece
              new-piece
              (get-square board initial-file initial-rank))
          (get-square board initial-file initial-rank)
          nil))
  
  (defun make-move (move board whitep)
    "Destructively modifies the board for the given move. The move parameter
     should be a string in algebraic chess notation. PRECONDITION: The move is
     valid on the given board."
    (destructuring-bind (piece origin-rank origin-file capturep
                               final-file final-rank promotion check)
        (destructure-move move)
  