anchor.diff:  		(setf (uref x clos-instance-slots-offset) slots)
   		x))
   
  +(defun check-update (object)
  +    (when (clos-instance-p object)
  +        (let ((class (class-of object)) (signature (std-instance-signature object)))
  +            (unless (or (eq 0 signature) (eq (car signature) (class-effective-slots class))) (update-instance object class signature)))))
  +
   ;;; Standard instance allocation
   
   (defparameter secret-unbound-value (list "slot unbound"))
  
positive.code: 					(nreverse slots))
  				,@forms))))
  		
  ;;; redefine to add type support for TYPEP
  (defmacro defclass (name direct-superclasses slot-definitions
                      &rest options)
  	(let ((s1 (gensym))(s2 (gensym)))
  	  `(prog1
  			(ensure-class ',name
  			     :direct-superclasses
  			       ,(canonicalize-direct-superclasses direct-superclasses)
  			     :direct-slots
  			       ,(canonicalize-direct-slots slot-definitions)
  			     :shared-slots
  			       ,(canonicalize-shared-slots slot-definitions)
  				 :shared-slot-initforms
  				   ,(canonicalize-shared-slot-initforms slot-definitions)		
  			     ,@(canonicalize-defclass-options options))
  			(declare-type-specifier ,name (,s1 ,s2)
  				(and (or (cl::clos-instance-p ,s1) (structurep ,s1))
  					(cl::subclassp (class-of ,s1) (find-class ,s2)))))))
  
  ;;;
  ;;; setup parent class and metaclass for all structures
  ;;;
  (defclass structure-class (cl::standard-class) ())
  (defclass structure-object (t) () (:metaclass structure-class))
  
  (defun intern-structure-class (name superclasses) ; patch
      (setq superclasses (append superclasses (list #.(find-class 'structure-object))))
      (let ((class (find-class name nil)) structp)
          (if (and class (setq structp (eq (class-of class) #.(find-class 'structure-class)))
  		 (equal superclasses (class-direct-superclasses class))) class
              (progn (and class (not structp) (cerror "Continue anyway." "The Symbol ~a already names the ~a" name class))
                     (ensure-class name
                             :direct-superclasses superclasses
                             :metaclass 'structure-class
                             :direct-slots nil
  
negative.code:       the-class-standard-class)
  ;; (It's now okay to use class-... accessor).
  ;; 4. Fill in standard-class's class-slots.
  (setf (class-effective-slots the-class-standard-class) the-slots-of-standard-class)
  ;; (Skeleton built; it's now okay to call make-instance-standard-class.)
  ;; 5. Hand build the class t so that it has no direct superclasses.
  (setf (find-class 't) 
    (let ((class (std-allocate-instance the-class-standard-class)))
      (setf (class-name class) 't)
      (setf (class-documentation class) ())
      (setf (class-direct-subclasses class) ())
      (setf (class-direct-superclasses class) ())
      (setf (class-direct-methods class) ())
      (setf (class-direct-slots class) ())
      (setf (class-precedence-list class) (list class))
      (setf (class-effective-slots class) ())
      (setf (class-shared-slot-definitions class) ()) ; Shared Slots Bug
      (setf (class-shared-slots class) ())
      class))
  ;; (It's now okay to define subclasses of t.)
  ;; 6. Create the other superclass of standard-class (i.e., standard-object).
  (defclass standard-object (t) ())
  (defclass metaobject () ((name :initarg :name) (documentation :initform () :initarg :documentation)))
  (defclass forward-referenced-class (metaobject) ((direct-subclasses :initform ())))
  (defclass specializer (forward-referenced-class)
                                     ((direct-superclasses :initarg :direct-superclasses) class-precedence-list (direct-methods :initform ())))
  (defclass class (specializer))
  ;; 7. Define the full-blown version of standard-class.
  (setq the-class-standard-class
      (defclass standard-class (class)
                      (direct-slots effective-slots (shared-slot-definitions :initform ()) (shared-slots :initform ())
                       (direct-default-initargs :initform () :initarg :direct-default-initargs) (effective-default-initargs :initform ()))))
  ;; 8. Replace all existing pointers to the skeleton with real one.
  ;; and declare types other than t
  (mapc #'(lambda (x) (setf (std-instance-class (find-class x)) the-class-standard-class)
                                   (unless (eq t x)
                                       (install-type-specifier x #'(lambda (s1 s2)
                                                                                    (and (cl::clos-instance-p s1)
                                                                                            (cl::subclassp (class-of s1) (find-class s2)))))))
      '(t standard-object metaobject forward-referenced-class specializer class standard-class)) 
  ;; (Clear sailing from here on in).
  ;; 9. Define the other built-in classes.
  (defclass symbol (t) ())
  