anchor.diff:  		(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)))
  +(defun class-list-matches (class-list eqls-classes)
  +	(do ((x class-list (cdr x))
  +		  (y eqls-classes (cdr y)))
  +		((null x) t)
  +		(unless (if (consp (car x)) (and (consp (car y)) (eql (caar x) (caar 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)))
  +(defun find-method-table-method (table eqls-classes)
  +	(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)))))))
  +				(when (class-list-matches (car p) eqls-classes)
  +					(return (cadr p))))))
   					 
   ;;;
   ;;; Standard instances
  
positive.code: ;;; N.B. To avoid making a forward reference to a (setf xxx) generic function:
  (defun setf-slot-value-using-class (new-value class object slot-name)
    (setf (slot-value-using-class class object slot-name) new-value))
  
  (progn
  
  
negative.code:                     (generic-function-name
                        (method-generic-function method))
                      (method-qualifiers method)
                      (mapcar #'(lambda (x) (if (eql-specializer-p x) `(eql ,(class-name x)) (class-name x))) 
                              (method-specializers method))))
    method)
  
  