anchor.diff:  
   (defmethod print-object ((object destination) stream)
     (print-unreadable-object (object stream :type t)
  -    (with-accessors ((x destination-x) (y destination-y)) object
  -      (format stream "(~a, ~a)" x y))))
  +    (with-accessors ((x destination-x) (y destination-y) (signature signature)) object
  +      (format stream "(~a, ~a) ~s" x y signature))))
   
   (defparameter *primitives*
     (loop with ht = (make-hash-table)
  
positive.code:             (= (length (landmark power)) 2))
      (if (limit power) (parse-integer (limit power)) :infinite)))
  
  (defun make-destination-object (x y signature)
    "Helper function: makes a DESTINATION"
    (make-instance 'destination :x x :y y :signature signature))
  
  
negative.code:   "Turns a funny notation item into a list of destinations."
    ;; Consider also turning things into target-squares here.
    (loop for power in (powers betza)
          append (parse-fragment power)))
  
  ;;         for riderp = (riderp power)
  ;;         for landmark = (aref (landmark power) 0)
  ;; (cond ((find landmark "QK")
  ;;               (list (make-destination-object 1 0 (if riderp (list :range riderp)))
  ;;                     (make-destination-object 1 1 (if riderp (list :range riderp)))))
  ;;              ((eql landmark #\R) (list (make-destination-object 1 0 (list :range riderp))))
  ;;              ((eql landmark #\B) (list (make-destination-object 1 1 (list :range riderp))))
  ;;              (t (list (make-destination-object (first (gethash landmark *primitives*))
  ;;                                                (second (gethash landmark *primitives*))
  ;;                                                (if riderp (list :range riderp))))))))
  
  (defun capturingp (modifiers)
    "Detects if a piece can capture or not"
  