anchor.diff:                         :if-does-not-exist :create
                          :element-type       'character
                          :external-format   external-format)
  -      (labels ((hash-file-writer (key val)
  -                 (format f "~%~A~%(:FILE      ~S~% :DIRECTORY ~S~% :NAME      ~S~% :TYPE      ~S)~%"
  -                         delim key (elt val 0) (elt val 1) (elt val 2)))
  -               (hash-file-mapper ()
  -                 #-sbcl (maphash #'hash-file-writer hash-table)
  -                 #+sbcl (if (sb-ext:hash-table-synchronized-p hash-table)
  -                            (sb-ext:with-locked-hash-table (hash-table)
  -                              (maphash #'hash-file-writer hash-table))
  -                            (maphash #'hash-file-writer hash-table))))
  -        (hash-file-mapper)
  -        hash-file-name))))
  +      (flet ((hash-file-writer (key val)
  +               (format f "~%~A~%(:FILE      ~S~% :DIRECTORY ~S~% :NAME      ~S~% :TYPE      ~S)~%"
  +                       delim key (elt val 0) (elt val 1) (elt val 2))))
  +        (with-hash-table-op (ht hash-table)
  +          (maphash #'hash-file-writer ht)))
  +      hash-file-name)))
   
   (defun image-hash-write-all-to-file (directory-pathname)
     (flet ((writer (hash-table)
              (image-hash-write-to-file (symbol-value hash-table)
                                        directory-pathname
                                        (string-trim '(#\*) (string-downcase hash-table)))))
  -    (mapcar #'writer
  -            (list '*bmp-hash* '*bmp-gz-hash*
  -                  '*jpg-hash* '*jpg-gz-hash*
  -                  '*tiff-hash* '*nef-hash* 
  -                  '*psd-hash* '*other-hash*))))
  +    (mapcar #'writer (list '*jpg-hash* '*jpg-gz-hash*
  +                           '*nef-hash* '*tiff-hash* 
  +                           '*bmp-hash* '*bmp-gz-hash*
  +                           '*psd-hash* '*other-hash*))))
   
   (defun image-hash-map-conversion-extension (source-hash conversion-hash conversion-extension &key (clear-conversion nil))
     (declare (string conversion-extension)
  
positive.code:                        (format s "~&~A~%;; Failed conversion ~%;; :FROM ~S~%;; :TO   ~S~%" delim from to)
                         (format t "~&~A~%;; Failed conversion ~%;; :FROM ~S~%;; :TO   ~S~%" delim from to)))))
               (hash-pair-to-args (key val)
                 (if 
                  (zerop 
                   (sb-ext:process-exit-code
                    (sb-ext:run-program *image-magick-convert-path* (list key "-compress" "zip" val))))
                  (progn 
                    (log-results t key val)
                    (when delete-on-success 
                      (delete-file key))
                    t)
                  (log-results nil key val)))
               (map-with-lock ()
                 (sb-ext:with-locked-hash-table (conversion-hash)
                   (maphash #'hash-pair-to-args conversion-hash))))
        (sb-thread:make-thread #'map-with-lock
                               :name (format nil "image-hash-conversion-perform-~D" (random most-positive-fixnum))))))
    
  
  ;;; ==============================
  
  
negative.code: (defun image-hash-reset-all ()
    ;; (image-hash-reset-all)
    (declare 
     (special *jpg-hash* *jpg-gz-hash*
              *nef-hash* *tiff-hash*
              *bmp-hash* *bmp-gz-hash* 
              *psd-hash* *other-hash*)
     (optimize (speed 3)))
    (flet ((clear-it (hash-to-clear))
           (with-hash-table-op (ht hash-to-clear)
             (clrhash ht)))
      ;; (mapc #'(lambda (hash) (sb-ext:with-locked-hash-table (hash) (clrhash hash)))
      (mapc #'clear-it (list *jpg-hash* *jpg-gz-hash*
                             *nef-hash* *tiff-hash*
                             *bmp-hash* *bmp-gz-hash*
                             *psd-hash* *other-hash*))))
  
  (defun image-hash-counts-report ()
    ;; (image-hash-counts-report)
    (declare (special *jpg-hash* *jpg-gz-hash*
                      *nef-hash* *tiff-hash*
                      *bmp-hash* *bmp-gz-hash*
                      *psd-hash* *other-hash*)
             (optimize (speed 3)))
    (flet ((ht-and-count (counting-hash)
             ;; (sb-ext:with-locked-hash-table (counting-hash)
             ;;   (hash-table-count counting-hash))
             (with-hash-table-op  (ht  counting-hash)
               (hash-table-count ht))))
      (pairlis (list '*jpg-hash* '*jpg-gz-hash*
                     '*nef-hash* '*tiff-hash*
                     '*bmp-hash* '*bmp-gz-hash*                   
                     '*psd-hash* '*other-hash*)
               (mapcar #'ht-and-count (list *jpg-hash*  *jpg-gz-hash* 
                                            *nef-hash*  *tiff-hash* 
                                            *bmp-hash*  *bmp-gz-hash*
                                            *psd-hash*  *other-hash*)))))
  
  (defun %walk-directory-images-to-hash (directory-pathname &key (clear-count t))
    (declare ((or pathname string) directory-pathname)
             (boolean clear-count)
  