anchor.diff:  	 (equalp-with-case (cdr x) (cdr y))))
      ((and (typep x 'array)
   	 (= (array-rank x) 0))
  -    (equalp-with-case (aref x) (aref y)))
  +    (equalp-with-case (my-aref x) (my-aref y)))
      ((typep x 'vector)
       (and (typep y 'vector)
   	 (let ((x-len (length x))
   	       (y-len (length y)))
   	   (and (eql x-len y-len)
   		(loop
  -		 for e1 across x
  -		 for e2 across y
  +		 for i from 0 below x-len
  +		 for e1 = (my-aref x i)
  +		 for e2 = (my-aref y i)
   		 always (equalp-with-case e1 e2))))))
      ((and (typep x 'array)
   	 (typep y 'array)
   	 (not (equal (array-dimensions x)
   		     (array-dimensions y))))
       nil)
  +
      ((typep x 'array)
       (and (typep y 'array)
   	 (let ((size (array-total-size x)))
   	   (loop for i from 0 below size
  -		 always (equalp-with-case (row-major-aref x i)
  -					  (row-major-aref y i))))))
  +		 always (equalp-with-case (my-row-major-aref x i)
  +					  (my-row-major-aref y i))))))
  +
      (t (eql x y))))
   
   (defun do-entry (entry &optional
  
positive.code: #|----------------------------------------------------------------------------|
   | Copyright 1990 by the Massachusetts Institute of Technology, Cambridge MA. |
   |                                                                            |
  
negative.code: 		  *test* (form entry)
  		  (length (vals entry))
  		  (vals entry))
  	  (handler-case
  	   (let ((st (format nil "Actual value~P: ~
                        ~{~S~^~%~15t~}.~%"
  			    (length r) r)))
  	     (format s "~A" st))
  	   (error () (format s "Actual value: #<error during printing>~%")
  		  ))
  	  (finish-output s)
  	  ))))
    (when (not (pend entry)) *test*))
  
  (defun expanded-eval (form)
    "Split off top level of a form and eval separately.  This reduces the chance that
     compiler optimizations will fold away runtime computation."
    (if (not (consp form))
        (eval form)
     (let ((op (car form)))
       (cond
        ((eq op 'let)
         (let* ((bindings (loop for b in (cadr form)
  			      collect (if (consp b) b (list b nil))))
  	      (vars (mapcar #'car bindings))
  	      (binding-forms (mapcar #'cadr bindings)))
  	 (apply
  	  (the function
  	    (eval `(lambda ,vars ,@(cddr form))))
  	  (mapcar #'eval binding-forms))))
        ((and (eq op 'let*) (cadr form))
         (let* ((bindings (loop for b in (cadr form)
  			      collect (if (consp b) b (list b nil))))
  	      (vars (mapcar #'car bindings))
  	      (binding-forms (mapcar #'cadr bindings)))
  	 (funcall
  	  (the function
  	    (eval `(lambda (,(car vars) &aux ,@(cdr bindings)) ,@(cddr form))))
  	  (eval (car binding-forms)))))
        ((eq op 'progn)
         (loop for e on (cdr form)
  	     do (if (null (cdr e)) (return (eval (car e)))
  		  (eval (car e)))))
        ((and (symbolp op) (fboundp op)
  	    (not (macro-function op))
  	    (not (special-operator-p op)))
         (apply (symbol-function op)
  	      (mapcar #'eval (cdr form))))
        (t (eval form))))))
  
  (defun continue-testing ()
    (if *in-test*
  