anchor.diff:      (do ((line (read-line in nil nil)
   	       (read-line in nil nil)))
   	((null line))
  -      (let ((data (split-sequence #\Space line)))
  +      (let ((data (split-sequence #\Space line :remove-empty-subseqs t)))
   	(mapcar (lambda (id) (format out "~a ~a ~a~%" (car data) (cadr data) id))
   		(cddr data))))))
   
  -
  -
  +(defun rules-not-used (rules-file tablog-file &key (numeric nil))
  +  (with-open-files ((in tablog-file))
  +    (let ((tb (make-hash-table))
  +	  (rules (read-rules rules-file))) 
  +      (loop for line = (read-line in nil 'foo)
  +	    until (eq line 'foo)
  +	    do (incf (gethash (parse-integer (nth 2 (cl-ppcre:split "[ ]" line))) tb 0)))
  +      (loop for x from 0 to (length rules)
  +	    when (not (gethash x tb))
  +	    collect (if numeric x (nth x rules))))))
  
positive.code:              (= 2 (length token)))
             (valid-side (side)
               (every #'identity (mapcar #'valid-token (parse-side side)))))
      (when (valid-length rule)
        (and (valid-side (car rule)) (valid-side (cadr rule))))))
  
  (defun valid-regex-rule (rule) (valid-length rule))
  
  (defun compile-rule (rule)
    (if (valid-rule rule)
  
negative.code:           (format *debug-io* "compiled-lhs = ~a~%compiled-rhs = ~a~%" compiled-lhs compiled-rhs))
  	(list (create-scanner compiled-lhs)
  	      compiled-rhs (third rule) compiled-lhs compiled-rhs))
        (error rule "invalid rule")))
  
  (defun compile-regex-rule (rule)
    (if (valid-regex-rule rule)
        (let ((compiled-lhs (first rule))
  	    (compiled-rhs (second rule)))
  	(when *debug-compilation*
            (format *debug-io* "compiled-lhs = ~a~%compiled-rhs = ~a~%" compiled-lhs compiled-rhs))
  	(list (create-scanner compiled-lhs)
  	      compiled-rhs (third rule) compiled-lhs compiled-rhs))
        (error rule "invalid rule")))
  
  
  (defun apply-rule (rule line)
  