anchor.diff:    (dolist (subclass (class-direct-subclasses class))
       (std-after-reinitialization-for-classes subclass)))
   
  -(defmethod reinitialize-instance :after ((class standard-class) &rest args &key direct-superclasses &allow-other-keys)
  -  (apply #'std-after-reinitialization-for-classes
  -         class
  -         :direct-superclasses (or direct-superclasses
  -                                  (list (find-class 'standard-object)))
  -         args))
  -
  -(defmethod reinitialize-instance :after ((class funcallable-standard-class) &rest args &key direct-superclasses &allow-other-keys)
  -  (apply #'std-after-reinitialization-for-classes
  -         class
  -         :direct-superclasses (or direct-superclasses
  -                                  (list (find-class 'funcallable-standard-object)))
  -         args))
  +(defmethod reinitialize-instance :after ((class std-class) &rest args &key direct-superclasses &allow-other-keys)
  +  (apply #'std-after-reinitialization-for-classes class args))
   
   (defun remove-reader-method (class reader slot-name)
     (declare (ignore slot-name))
  
positive.code:                `(,key ,value)))))
  
  (defun ensure-class (name &rest all-keys
                            &key
                              (metaclass *the-class-standard-class*)
                              direct-superclasses
                              direct-default-initargs
                            &allow-other-keys)
    (when (symbolp metaclass)
      (setf metaclass (find-class metaclass)))
    (let ((existing (find-class name nil)))
      (cond ((and (not existing)
                  (standardish-class-p metaclass))
             ;; Non-MOP path. Used when creating a new standard (funcallable) class.
             ;; Avoids generic function dispatch.
             (let ((class (apply #'make-instance-clos-class
                                 metaclass
                                 :name name
                                 (compute-class-initialization-arguments all-keys))))
               (setf (find-class name) class)
               class))
            (t
             ;; MOP path.
             (apply #'ensure-class-using-class
                    existing
                    name
                    all-keys)))))
  
  ;;; make-instance-standard-class creates and initializes an instance of
  ;;; standard-class without falling into method lookup.  However, it cannot be
  
negative.code:   (or (eql metaclass *the-class-standard-class*)
        (eql metaclass *the-class-funcallable-standard-class*)))
  
  (defun convert-to-direct-slot-definition (class canonicalized-slot)
    (apply #'make-instance
           (apply #'direct-slot-definition-class
  