anchor.diff:                    (if (not body)
                       (if (not (find pattern atomics :test #'equal))
                         (setf atomics (cons pattern atomics)))
  -                    (format t "~a~%" `(ptr-add-goal-recipe (,goal ,pattern ,(format nil "~a" (list pattern body)) ,score) ,@body)))
  +                    (format t "~a~%" `(ptr-add-goal-recipe (,goal ,pattern ,(format nil "~a" (list pattern body)) ,score) ,@body))
  +                    )
                     ))
                 ;;(format t "PATS: ~a~%" patterns)
                 ;;(format t "BDS: ~a~%" bodies)
                 ;;(format t "ATS: ~a~%" atomics)
                 )))))
  -    atomics))
  +    (values atomics nilary)))
  
positive.code:             call-pattern)))
  
  (defun get-recipes (goal pattern bindings)
    (let* ((atomics nil)
           (pattern-string (format nil "~a" pattern))
           (pattern-string (subseq pattern-string 1 (- (length pattern-string) 1)))
           ;;(pattern-string (concatenate 'string (fmp/name goal) " " pattern-string))
  
negative.code:                          (pattern (read-from-string pattern))
                           (parent-k (search (vector parent) ids))
                           (bound-call-pattern (get-bound-call-pattern pattern call-pattern bindings)))
                      (if (equal (string-upcase (format nil "~a" (car bound-call-pattern))) 
                                 (string-upcase (format nil "~a" 'with-failure-handling)))
                        (let* ((parent-pattern (if parent-k
                                                 (elt patterns parent-k)
                                                 nil)))
                          (setf bound-call-pattern (append bound-call-pattern parent-pattern))
                          ))
                      (if (equal (length bound-call-pattern) 1)
                        (setf nilary (cons (car bound-call-pattern) nilary)))
                      (setf (elt patterns k) bound-call-pattern)
                      (if (and (< -1 parent) parent-k)
                        (setf (elt bodies parent-k)
  