anchor.diff:  				   (mapcar #'cadar keys)
   				   (remove 'nil (mapcar #'third keys))
   				   (mapcar #'first aux)))
  -	   (default-slots (set-difference (mapcar #'first slots) assigned-slots)))
  +	   (default-slots (set-difference (mapcar #'structure-slot-name slots) assigned-slots)))
         `(defun ,name ,lambda-list
            (vector ,@(when leader-name (list `',leader-name))
                    ,@(mapcar (lambda (s)
  -                             (if (member (first s) default-slots)
  -                                 (third s)
  -                                 (first s)))
  +                             (if (member (structure-slot-name s) default-slots)
  +                                 (structure-slot-initform s)
  +                                 (structure-slot-name s)))
                              slots))))))
   
   (defun compute-defstruct-slots (conc-name slot-descriptions included-structure included-slot-descriptions)
  
positive.code:            (mapcar (lambda (s)
                       (incf n)
                       `(progn
                          (defun ,(second s) (object)
                            ,@(when (and named predicate)
                                (list `(check-type object (satisfies ,predicate))))
                            (aref object ,n))
                          ,@(unless (fifth s)
                              (list `(defun (setf ,(second s)) (new-value object)
                                       ,@(when (and named predicate)
                                           (list `(check-type object (satisfies ,predicate))))
                                       (setf (aref object ,n) (the ,(fourth s) new-value)))
                                    `(defun (cas ,(second s)) (old new object)
                                       ,@(when (and named predicate)
                                           (list `(check-type object (satisfies ,predicate))))
                                       (cas (aref object ,n) (the ,(fourth s) old) (the ,(fourth s) new)))))))
                     slots))
         ,@(mapcar (lambda (x)
                     (if (symbolp x)
  
negative.code: 				   (mapcar #'cadar keys)
  				   (remove 'nil (mapcar #'third keys))
  				   (mapcar #'first aux)))
  	   (default-slots (set-difference (mapcar #'structure-slot-name slots) assigned-slots)))
        `(defun ,name ,lambda-list
           (list ,@(when leader-name (list `',leader-name))
                 ,@(mapcar (lambda (s)
                             (if (member (structure-slot-name s) default-slots)
                                 (structure-slot-initform s)
                                 (structure-slot-name s)))
                           slots))))))
  
  (defun generate-simple-defstruct-vector-constructor (leader-name slots name area)
    `(defun ,name (&key ,@(mapcar (lambda (slot)
                                    (list (structure-slot-name slot) (structure-slot-initform slot)))
                                  slots))
       (vector ,@(when leader-name (list `',leader-name))
               ,@(mapcar #'structure-slot-name slots))))
  
  (defun generate-defstruct-vector-constructor (leader-name slots name lambda-list area)
    (multiple-value-bind (required optional rest enable-keys keys allow-other-keys aux)
  