anchor.diff:    (loop for option in options
        do (set-up-option option sheep)))
   (defun set-up-option (sheep option)
  -  (if (eql (sheep-metaobject sheep) =standard-sheep-metaobject=)
  +  (if (eql (sheep-metasheep sheep) =standard-sheep-metasheep=)
         (std-set-up-option sheep option)
  -      (set-up-option-using-metaobject
  -       (sheep-metaobject sheep) sheep option)))
  +      (set-up-option-using-metasheep
  +       (sheep-metasheep sheep) sheep option)))
   (defun std-set-up-option (sheep option)
     (let ((option (car option))
   	(value (cadr option)))
  
positive.code:        (eql (gethash secret-sheep-identifier sheep)
  	    secret-sheep-identifier)))
  
  (defun sheep-metaobject (sheep)
    (get-property sheep 'metaobject))
  
  ;;;
  ;;; Bootstrap
  ;;;
  (defvar =standard-sheep-metaobject=
    (let ((object (std-generate-sheep-instance)))
      (setf (gethash 'metaobject object) object)
      (setf (gethash 'nickname object) nil)
      (setf (gethash 'parents object) nil)
      (setf (gethash 'children object) nil)
  
negative.code: 			:function (eval (make-message-lambda '(new-value sheep) 
  							     `((setf (get-property sheep ',prop-name)
  								     new-value)))))))
  
  ;;;
  ;;; Inheritance setup
  ;;;
  (defun add-parent (new-parent child)
    (cond ((equal new-parent child)
  	 (error "Can't inherit from self."))
  	((not (equal (class-of new-parent)
  		     (class-of child)))
  	 (error "Wrong metaclass for parent"))
  	(t
  	 (handler-case
  	     (progn
  	       (pushnew new-parent (sheep-direct-parents child))
  	       (let ((pointer (make-weak-pointer child)))
  		 (pushnew pointer (sheep-direct-children new-parent))
  		 (finalize child (lambda () (setf (sheep-direct-children new-parent)
  						  (delete pointer 
  							  (sheep-direct-children new-parent))))))
  	       child)
  	   (sheep-hierarchy-error ()
  	     (progn
  	       (setf (sheep-direct-parents child) (delete new-parent (sheep-direct-parents child)))
  	       (error 'sheep-hierarchy-error))))))
    (finalize-sheep child))
  
  (defun remove-parent (parent child)
    (setf (sheep-direct-parents child)
  	(delete parent (sheep-direct-parents child)))
    (setf (sheep-direct-children parent)
  	(delete child (sheep-direct-children parent) :key #'weak-pointer-value))
    (when keep-properties
      (with-accessors ((parent-properties sheep-direct-properties))
  	parent
        (loop for property-name being the hash-keys of parent-properties
  	 using (hash-value value)
  	 do (unless (has-direct-property-p child property-name)
  	      (setf (get-property child property-name) value)))))
    (finalize-sheep child)
    child)
  
  ;;; Inheritance predicates
  (defun direct-parent-p (maybe-parent child)
    (when (member maybe-parent (sheep-direct-parents child))
      t))
  
  (defun ancestor-p (maybe-ancestor descendant)
    (when (and (not (equal maybe-ancestor descendant))
  	     (member maybe-ancestor (collect-parents descendant)))
      t))
  
  (defun direct-child-p (maybe-child parent)
    (direct-parent-p parent maybe-child))
  
  (defun descendant-p (maybe-descendant ancestor)
    (ancestor-p ancestor maybe-descendant))
  
  ;;;
  ;;; Buzzword setup
  