anchor.diff:    (let ((filename (merge-pathnames (apply #'file-name-for conditions) *prefab-base*)))
       (unless (and (probe-file filename)
                    (probe-file (make-pathname :type "png" :defaults filename))
  -                 (>= (unix-time-to-universal-time (sb-posix:stat-mtime (sb-posix:stat filename)))
  -                     *latest-result*))
  +                 (>= (file-write-date filename) *latest-result*))
         (apply #'generate-image-for conditions))))
   
   (defun url-for-image (&rest conditions)
  
positive.code:                                                                         (where
                                                                           (join result benchmark
                                                                                 :on (= result.b_name benchmark.name))
                                                                           (= result.m-name ,host)))))) :tuples))
           (date-boundaries (apply #'date-boundaries args))
           (earliest (first date-boundaries))
           (latest (second date-boundaries)))
  
negative.code:   (make-pathname :directory `(:relative ,(filesys-escape-name
                                            (md5-pathname-component
                                             (prin1-to-string implementations)))
                                          ,(filesys-escape-name
                                            (md5-pathname-component
                                             (prin1-to-string host)))
                                          ,(if only-release only-release "all"))
                   :name (filesys-escape-name benchmark)))
  
  (defun make-offset-table (&rest conditions)
    (let ((table (make-hash-table :test #'equal)))
      (values table
              (iterate (for (impl host) in-relation
                    (translate*
                     `(distinct (select ((++ b.v-name "," b.mode) r.m-name)
                                        (order-by
                                         ,(apply #'emit-where-clause conditions)
                                         ((++ b.v-name "," b.mode)) :desc))))
                    on-connection *dbconn*)
               (for offset from 0)
               (maximizing offset)
               (setf (gethash (list impl host) table) offset)))))
  
  (defun ploticus-offset-args (offset-table)
    (iterate (for ((impl host) offset) in-hashtable offset-table)
             (for pl-s = (if (= offset 0) "" (+ 2 (truncate offset 2))))
             ;; "name=SBCL" "y=2" "err=3" "name2=CMU Common Lisp" "y2=4" "err2=5"
             (collect (format nil "name~A=~A/~A" pl-s host (pprint-impl-and-mode impl)))
             (collect (format nil "y~A=~A" pl-s (+ 2 (* 2 offset))))
             (collect (format nil "err~A=~A" pl-s (+ 3 (* 2 offset))))))
  
  (defun generate-image-for (&rest conditions &key unit &allow-other-keys)
    (declare (optimize (speed 0) (space 0)
                       (debug 2)))
    (multiple-value-bind (offset-table max-offset) (apply #'make-offset-table conditions)
      (let ((filename (merge-pathnames (apply #'file-name-for conditions) *prefab-base*)))
  
        (with-open-file (f (ensure-directories-exist filename) :direction :output
                           :if-exists :supersede :if-does-not-exist :create)
          (iterate (for (date host name version mean stderr) in-relation
                        (translate* `(select (v.release-date r.m-name (++ b.v-name "," b.mode) v.version
                                                             (avg r.seconds) (/ (stddev r.seconds) (sqrt (count r.seconds))))
                                             (order-by
                                              (group-by ,(apply #'emit-where-clause conditions)
                                                        (v.release-date r.m-name (++ b.v-name "," b.mode) v.version))
                                              (v.release-date))))
                        on-connection *dbconn*)
                   (for offset = (gethash (list name host) offset-table))
                   (format f "~A~A~f~A~f~A~%"
                           version
                           (make-string (1+ (* 2 offset)) :initial-element #\Tab)
  