anchor.diff:            :seconds seconds :hours hours :days days)))
   
   (defun thread-pool-time-to-go (pool-name total-record-count)
  -  "Returns the amount of time left for the given pool to complete processing all the records."
  +  "Returns the amount of time left for the thread pool given by POOL-NAME to complete processing all the records, the total number of which is given in TOTAL-RECORD-COUNT."
     (time-to-go
      (change-per-second (lambda () (thread-pool-progress pool-name)) 10)
      (- total-record-count (thread-pool-progress pool-name))))
   
   (defun thread-pool-start-time (pool-name)
  -  "Retrieves the start-time for the given thread-pool."
  +  "Retrieves the start-time for thread-pool named in POOL-NAME."
     (getf *dc-thread-pool-start-time* pool-name))
   
   (defun thread-pool-stop-time (pool-name)
  -  "Retrieves the stop-time for the given thread-pool."
  +  "Retrieves the stop-time for the thread-pool named in POOL-NAME."
     (getf *dc-thread-pool-stop-time* pool-name))
   
   (defun thread-pool-run-time (pool-name)
  -  "Computes the number of seconds that the given thread-pool has been running."
  +  "Computes the number of seconds that the thread-pool named in POOL-NAME has been running."
     (let ((start (thread-pool-start-time pool-name))
           (stop (thread-pool-stop-time pool-name)))
       (if start (- (if stop stop (get-universal-time)) start) 0)))
   
   (defun thread-pool-progress (pool-name)
  -  "Retrieves the count of the records that the given thread pool has already processed."
  +  "Retrieves the count of the records that the thread pool given by POOL-NAME has already processed."
     (getf *dc-thread-pool-progress* pool-name))
   
   (defun job-queue (pool-name)
  -  "Retrieve the job-queue for the given thread pool."
  +  "Retrieve the job-queue for the thread pool given by POOL-NAME."
     (getf *dc-job-queue* pool-name))
   
   (defun thread-pool-start
       (pool-name thread-count job-queue fn-job &optional fn-finally)
  -  "Starts thread-count threads using pool-name to name the threads and runs fn-job with those threads.  Each thread runs fn-job, which takes no parameters, in a loop.  When all the threads are done, this function checks fn-finally.  If the caller provides fn-finally, then this function returns with the result of calling fn-finally.  If the caller doesn't provide fn-finally, then the this function exists with a sum of the return values of all the threads that ran."
  +  "Starts THREAD-COUNT threads using POOL-NAME to name the threads and runs FN-JOB with those threads.  Each thread runs FN-JOB, which takes no parameters, in a loop.  When all the threads are done, this function checks FN-FINALLY.  If the caller provides FN-FINALLY, then this function returns with the result of calling FN-FINALLY.  If the caller doesn't provide FN-FINALLY, then the this function exits with a sum of the return values of all the threads that ran."
     (setf (getf *dc-thread-pool-progress* pool-name) 0)
     (setf (getf *dc-progress-mutex* pool-name)
           (make-mutex :name (symbol-name pool-name)))
  
positive.code:      finally (return hash)))
  
  (defun distinct-elements (list)
    "Accepts a list of elements and returns a new list with distinct elements from the first list.  (Copies the original list, removes duplicate elements from the copy, and returns the copy.)"
    (loop with h = (make-hash-table :test 'equal)
       for v = 0 then (1+ v)
       for k in list do (unless (gethash k h)
  
negative.code: (defparameter *dc-timings* (make-hash-table :test #'equal))
  
  (defun to-ascii (s)
    "Converts the string S, which may contain non-ascii characters, into a string with nothing but ascii characters.  Non ascii characters are converted into spaces.  If S is a list, this function converts each element of the list into an all-ascii string."
    (if (atom s)
        (map 'string (lambda (c) (if (> (char-code c) 127) #\Space c)) s)
        (loop for a in s collect
  