anchor.diff:  	 child)))
   
   (defun remove-parent (parent child)
  -  (if (and (eql =standard-sheep-metaobject= (sheep-metaobject child))
  -	   (eql =standard-sheep-metaobject= (sheep-metaobject new-parent)))
  +  (if (and (eql =standard-sheep-metasheep= (sheep-metasheep child))
  +	   (eql =standard-sheep-metasheep= (sheep-metasheep new-parent)))
         (std-remove-parent parent child)
  -      (remove-parent-using-metaobjects
  -       (sheep-metaobject parent) (sheep-metaobject child)
  +      (remove-parent-using-metasheeps
  +       (sheep-metasheep parent) (sheep-metasheep child)
          parent child)))
   (defun std-remove-parent (parent child)
     (setf (sheep-direct-parents child)
  
positive.code: ) ; end buzzword table closure
  
  (defun available-messages (sheep)
    (if (eql =standard-sheep-metaobject= (sheep-metaobject sheep))
        (std-available-messages sheep)
        (available-messages-using-metaobject (sheep-metaobject sheep))))
  
  (defun std-finalize-buzzword (buzzword)
    (let ((name (buzzword-name buzzword)))
  
negative.code:        (values sheep nil)))
  
  ;;;
  ;;; Now we create the buzzword, message, and role metasheeps
  ;;;
  (defvar =standard-buzzword-metasheep=
    (eval the-standard-buzzword-metasheep-form))
  (defvar =standard-message-metasheep=
    (eval the-standard-message-metasheep-form))
  (defvar =standard-role-metasheep=
    (eval the-standard-role-metasheep-form))
  
  ;;;
  ;;; Safe to define buzzwords and messages now, as well as use CLONE normally
  ;;;
  (defbuzzword sheep-p-using-sheep)
  (defmessage sheep-p-using-sheep (sheep)
    (std-sheep-object-p sheep))
  
  (defbuzzword print-sheep
      (:documentation "Defines the expression print-object uses."))
  