anchor.diff:  	(when sets 
   	  (let ((set (merge-sets (length definitions) (length relations) sets)))
   	    (when set
  -	      (let* ((result-actions (all-result-actions set tokens actions))
  +	      (let* ((result-actions (result-actions set tokens actions))
   		     (final-actions (rest result-actions))) 
   		(when (examine-actions final-actions) 
  -		  (mapcar #'(lambda (result-action) (apply-action result-action))
  -			  final-actions)
  -		  (format *error-output* "Sentence ~a changed by tranform ~a ~%"
  -			  (sentence-id sentence) transform-index)
  -		  (first result-actions))))))))))
  +		  (let ((results (mapcar #'(lambda (result-action) (apply-action result-action))
  +					 final-actions)))
  +		    (format *error-output* "Transformation ~a changed ~a tokens of Sentenca ~a ~%"
  +			    rule-index (length results) sent-id)
  +		    (cons (first result-actions) results)))))))))))
   
   
   ;; part 1
   
  -(defun transformation (transformation)
  -  (list :definitions (definitions (first transformation)) 
  -	:relations (relations (nth 1 transformation))
  -	:actions (actions (nth 2 transformation))))
  -
  -(defun definitions (definitions &optional (index 1) (result-defs nil))
  +(defun definitions (definitions &optional (index 1) result-defs)
     (if definitions
         (let ((first-def (first definitions)))
   	(definitions (rest definitions) (1+ index)
  
positive.code: 
  (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)))
  	  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
  
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)
  