anchor.diff:  
   (defun token-matchers (definition tokens)
     (reduce #'(lambda (result-matchers token)
  -	      (let ((token-matched (token-match definition token)))
  -		(if token-matched
  -		    (cons token-matched result-matchers)
  -		    result-matchers)))
  +	      (if (all-defs-test token (getf definition :defs))
  +		  (cons token result-matchers)
  +		  result-matchers))
   	  tokens :initial-value nil))  
   
  -(defun token-match (definition token)
  -  (when (all-defs-test token (getf definition :defs))
  -    token))
   
   (defun all-defs-test (token defs) 
     (if defs
  
positive.code: 
  ;; part 2
  
  (defun node-matchers (tokens definitions &optional (result-nodes nil))
    (if definitions
        (let* ((first-def (first definitions))
  	     (tokens-matchers (token-matchers first-def tokens)))
  
negative.code: 			   actions :initial-value nil))))
  
  (defun action (expression)
    (unless (string= (first expression) 'last)
      (if (= (length expression) 5)
  	(list t   (nth 1 expression) (nth 3 expression) (nth 2 expression) (nth 4 expression))
  	(list nil (nth 1 expression) (nth 2 expression) (stringp nth-3) (nth 3 expression)))))
  
  
  (defun get-field-value (field token)
    (let ((value (slot-value token (intern (symbol-name field) "CL-CONLLU"))))
      (if (integerp value)
  	(write-to-string value)
  	value)))
  
  
  (defun normalize-shorthand (expression operator)
    (if (string= (first expression) '>)
        (nth 1 (reduce #'(lambda (result node-2)
  			 (list node-2
  			       (cons `(,operator ,node-2 ,(first result) head id)
  