anchor.diff:  (defvar *module-data-table*
     (make-array (ash 1 +module-bits+) :initial-element nil))
   
  -(declaim (notinline module-ref))
  +#-debug (declaim (inline module-ref))
   (defun module-ref (i) (svref *module-table* i))
   
  -(declaim (notinline data-ref))
  +#-debug (declaim (inline data-ref))
   (defun data-ref (i) (svref *module-data-table* i))
   
   ;;;;
  
positive.code:                    (and data (data-name data)))
              :test #'string=))
  
  (declaim (notinline bash))
  (defun bash (idx module-number kind)
    (logior kind
            (ash (logior module-number
                         (ash idx +module-bits+))
                 +kind-bits+)))
  
  (declaim (notinline ldb-module))
  (defun ldb-module (x)
    (ldb (byte +module-bits+ +kind-bits+) x))
  
  (defun ldb-kind (x)
    (ldb (byte +kind-bits+ 0) x))
  
  (declaim (notinline unbash))
  (defun unbash (x)
    (values (ldb (byte 16 (+ +module-bits+ +kind-bits+)) x)
            (ldb-module x)
            (ldb (byte +kind-bits+ 0) x)))
  
  (defun unbash* (x expected-kind)
    (multiple-value-bind (idx <module> kind)
        (unbash x)
      (assert (eql kind expected-kind))
      (values idx <module> kind)))
  
  
  
negative.code: (defun qmethod-struct (<method>)
    (multiple-value-bind (idx <module>)
        (unbash* <method> +method+)
      #+debug (assert (<= 0 idx (data-nmethods (data-ref <module>))))
      (cffi:mem-aref (data-methods (data-ref <module>))
                     '|struct Method|
                     idx)))
  