anchor.diff:    (if (clos-instance-p x)
         (std-instance-class x)
         (built-in-class-of x)))
  -
  -(defun class-of-with-eql (object)
  -	(or
  -		(gethash object *clos-singleton-specializers*)
  -		(class-of object)))
   
   ;;; N.B. This version of built-in-class-of is straightforward but very slow.
   ;;; This is only for booting, a faster method is used later -RGC
  
positive.code: 		(setf (method-table-cached-method-types table) types))
  	table)
  
  (defun equal-class-list (list1 list2)
  	(do* ((x list1 (cdr x))
  		  (y list2 (cdr y)))
  		((and (null x)(null y)) t)
  		(unless (and x y (eq (car x)(car y)))
  			(return nil))))
  
  (defun class-list-matches-args (class-list args)
  	(do* ((x class-list (cdr x))
  		  (y args (cdr y)))
  		((null x) t)
  		(unless (and x y (eq (car x)(class-of (car y))))
  			(return nil))))
  
  (defun class-list-matches-args-with-eql (class-list args)
  	(do* ((x class-list (cdr x))
  		  (y args (cdr y)))
  		((null x) t)
  		(unless (and x y (eq (car x)(class-of-with-eql (car y))))
  			(return nil))))
  
  (defun find-method-table-method (table args)
  	(if (method-table-eql-specializers table)
  		(with-synchronization (method-table-sync table)
  			(do* ((p (method-table-method-list table) (cddr p)))
  				((null p)(return nil))
  				(if (class-list-matches-args-with-eql (car p) args)
  					(return (cadr p)))))
  		(with-synchronization (method-table-sync table)
  			(do* ((p (method-table-method-list table) (cddr p)))
  				((null p)(return nil))
  				(if (class-list-matches-args (car p) args)
  					(return (cadr p)))))))
  					 
  ;;;
  ;;; Standard instances
  
negative.code:   `(list ,@(mapcar #'canonicalize-specializer specializers)))
  
  (defun canonicalize-specializer (specializer)
    (if (and (listp specializer) (eq (car specializer) 'eql))
        `(intern-eql-specializer ,(cadr specializer) ',(cadr specializer))
        `(find-class ',specializer)))
  
  (defun specalization-vars (specialized-lambda-list)
      (let ((vars '()))
  