anchor.diff:  (defun remove-read-write-methods (class)
       (mapc #'(lambda (x)
                         (mapc #'(lambda (x)
  -                                        (let ((gf (find-generic-function x)))
  -                                            (remove-method gf (find-method gf () (if (consp x) (list (find-class t) class) (list class))))))
  +                                        (let* ((gf (find-generic-function x))
  +                                                 (meth (find-method gf () (if (= 2 (length (generic-function-required-args gf))) (list (find-class t) class) (list class)) nil)))
  +                                            (when meth (remove-method gf meth))))
                             (append (slot-definition-readers x) (slot-definition-writers x))))
           (class-direct-slots class)))
   
  
positive.code: (defmethod (setf class-shared-slots) (new-value (class forward-referenced-class)) (declare (ignore new-value)))
  
  (defmethod class-slots ((class forward-referenced-class)) (declare (ignore class)))
  (defmethod class-slots ((class standard-class)) (remove-duplicates (append (class-effective-slots class) (class-shared-slot-definitions class)) :from-end t :key #'slot-definition-name))
  
  (defmethod class-direct-default-initargs ((class forward-referenced-class)))
  (defmethod class-direct-default-initargs ((class standard-class)) (slot-value class 'direct-default-initargs))
  
negative.code: ;;; called until standard-class itself exists.
  
  (defun make-instance-standard-class (metaclass 
  		&key name direct-superclasses direct-slots &allow-other-keys)
  	(declare (ignore metaclass))
  	(let ((class (std-allocate-instance the-class-standard-class)))
  		(setf (class-name class) name)
  