anchor.diff:                        (add-to-function (node-name call-tree) (node-time call-tree) data)
                         data)))
       (let loop
  -        ((d (new-data))
  +        ((d new-data)
            (nodes (node-children call-tree)))
         (if (null? nodes)
             d
  
positive.code: (define (add-to-function fname time data)
    (let ((existing (assoc fname data)))
      (if (null? existing)
          (acons fname time data)
          (acons fname (+ time (cadr existing)) (dissoc fname data)))))
  
  
  ;;; type can be prim, func, or all
  
negative.code:                            (cond ((and (eq? (mode d) 'exit)
                                         (eq? (name d) f-name))
                                    (list (time d) ch))
                                   ((eq? (mode d) 'enter)
                                    (let ((children (cons (read-function-call d f) ch))) 
                                      (loop (read f) children))))))
             (children (cadr children-end))
             (end-time (car children-end)))
        (list (- end-time start-time) f-type f-name children)))
  