anchor.diff:  
   (in-package :kindista)
   
  -(defun create-gift (&key giver recipients text (created (get-universal-time)) old-id)
  +(defun create-gift (&key giver recipients text (created (get-universal-time)))
     (insert-db `(:type :gift
                  :giver ,giver
                  :recipients ,recipients
                  :text ,text
  -               :created ,created
  -               :old-id ,old-id)))
  +               :created ,created)))
   
   (defun index-gift (id data)
     (let* ((giver (db (getf data :giver)))
            (created (getf data :created))
            (recipients (getf data :recipients))
            (people (cons (getf data :giver) recipients))
  -         (result (make-result :latitude (getf author :lat)
  -                              :longitude (getf author :long)
  +         (result (make-result :latitude (getf giver :lat)
  +                              :longitude (getf giver :long)
                                 :people people
                                 :time created
                                 :type :gift
  
positive.code:          (see-other (or (post-parameter "next") (referer)))))
        (not-found))))
  
  (defun import-gifts (filename)
    (let ((existing ()))
      (iter (for (key item) in-hashtable *db*)
        (awhen (getf item :old-id)
          (push it existing)))
  
      (with-open-file (in filename :if-does-not-exist nil)
        (when in
          (with-standard-io-syntax
            (with-locked-hash-table (*db*)
              (loop
                (handler-case
                  (let ((item (read in)))
                    (unless (member (parse-integer (first item)) existing)
                      (when (third item)
                        (create-gift :giver (parse-integer (first (second item)))
                                     :recipients (iter (for id in (third item) by #'cddr)
                                                       (collect (parse-integer id)))
                                     :text (second (second item))
                                     :created (parse-integer (third (second item)))
                                     :old-id (parse-integer (first item))))))
                  (end-of-file (e) (declare (ignore e)) (return))))))))))
  
negative.code:         (asetf (gethash person *activity-person-index*)
                 (sort (push result it) #'> :key #'result-time))))
  
      (dolist (subject people)
        (let ((user (db subject)))
          (geo-index-insert *activity-geo-index* (make-result :latitude (getf user :lat)
                                                              :longitude (getf user :long)
  