anchor.diff:  
         ;; Steps
         (dotimes (i steps)
  -        (map nil #'stmt (smt-plan-step-stmts state-vars concrete-actions i)))
  +        (map nil #'stmt (smt-plan-step-stmts state-vars ground-actions i)))
   
         ;; goal state
         (stmt (smt-comment "Goal State"))
         (stmt (smt-assert (rewrite-exp goal steps))))
   
       (values (reverse smt-statements)
  -            (smt-plan-step-ops concrete-actions steps))))
  +            (smt-plan-step-ops ground-actions steps))))
   
   (defun smt-plan-parse (assignments)
     (let ((plan))
  
positive.code:          (state-vars (or state-vars
                           (create-state-variables (pddl-operators-predicates operators)
                                                   type-map)))
           (concrete-actions (or concrete-actions
                                 (smt-concrete-actions (pddl-operators-actions operators)
                                                        type-map)))
           (initial-true (unless initial-state (or initial-true (pddl-facts-init facts))))
           (initial-false (unless initial-state (or initial-false
  
negative.code:                          (rec (cdr rest)))))))
          (rec things)))))
  
  (defun ground-action-modified-variables (action)
    (destructuring-bind (-and &rest things) (ground-action-effect action)
      (check-symbol -and 'and)
      (loop for exp in things
         collect
  