anchor.diff:                   :defaults *load-truename*))
   
   (defun qmerge (pathname)
  +  "Return PATHNAME merged with the base Quicklisp directory."
     (merge-pathnames pathname *quicklisp-home*))
   
   (defun qenough (pathname)
  
positive.code:           (try)
            (try (require 'asdf))
            (try (load fasl :verbose nil))
            (try (load (compile-file source :verbose nil)))
            (error "Could not load ASDF ~S or newer" *required-asdf-version*))))))
  
  (ensure-asdf-loaded)
  
negative.code: ;;; ASDF is a hard requirement of quicklisp. Make sure it's either
  ;;; already loaded or load it from quicklisp's bundled version.
  
  (defvar *required-asdf-version* "2.011")
  
  ;;; Put ASDF's fasls in a separate directory
  
  (defun implementation-signature ()
    "Return a string suitable for discriminating different
  implementations, or similar implementations with possibly-incompatible
  FASLs."
    (let ((*print-pretty* nil))
      (format nil "lisp-implementation-type: ~A~%~
                   lisp-implementation-version: ~A~%~
                   machine-type: ~A~%~
                   machine-version: ~A~%"
              (lisp-implementation-type)
              (lisp-implementation-version)
              (machine-type)
              (machine-version))))
  
  (defun dumb-string-hash (string)
    "Produce a six-character hash of STRING."
    (let ((hash #xD13CCD13))
      (loop for char across string
            for value = (char-code char)
            do
            (setf hash (logand #xFFFFFFFF
                               (logxor (ash hash 5)
                                       (ash hash -27)
                                       value))))
      (subseq (format nil "~(~36,6,'0R~)" (mod hash 88888901))
              0 6)))
  
  (defun asdf-fasl-pathname ()
    "Return a pathname suitable for storing the ASDF FASL, separated
  from ASDF FASLs from incompatible implementations. Also, save a file
  in the directory with the implementation signature, if it doesn't
  already exist."
    (let* ((implementation-signature (implementation-signature))
           (original-fasl (compile-file-pathname (qmerge "asdf.lisp")))
           (fasl
            (qmerge (make-pathname
                     :defaults original-fasl
                     :directory
                     (list :relative "asdf-fasls"
                           (dumb-string-hash implementation-signature)))))
           (signature-file (merge-pathnames "signature.txt" fasl)))
      (ensure-directories-exist fasl)
      (unless (probe-file signature-file)
        (with-open-file (stream signature-file :direction :output)
          (write-string implementation-signature stream)))
      fasl))
  
  (defun ensure-asdf-loaded ()
    "Try several methods to make sure that a sufficiently-new ASDF is
  loaded: first try (require 'asdf), then loading the ASDF FASL, then
  compiling asdf.lisp to a FASL and then loading it."
    (let* ((source (qmerge "asdf.lisp"))
           (fasl (asdf-fasl-pathname)))
      (ensure-directories-exist fasl)
      (labels ((asdf-symbol (name)
                 (let ((asdf-package (find-package '#:asdf)))
                   (when asdf-package
  