anchor.diff:              d
               (loop (compute-by-function (car nodes) f-type d) (cdr nodes))))))
   
  -  (let ((call-data (let loop ((trees call-trees)
  +  (let ((name-width 20)
  +        (count-width 5)
  +        (total-width 10)
  +        (avg-width 10)
  +        (call-data (let loop ((trees call-trees)
                                 (data '()))
                        (if (nil? trees)
                            data
                            (loop (cdr trees) (compute-by-function (car trees) f-type data))))))
  -    (format #t "~20A | ~5@A | ~10@A | ~10A~%" "Function" "count" "total time" "avg time")
  -    (format #t "---------------------+-------+------------+-----------~%")
  +    (format #t "~VA | ~V@A | ~V@A | ~VA~%" name-width "Function" count-width "count" total-width "total time" avg-width "avg time")
  +    (format #t "~V~+~V~+~V~+~V~~%" (+ 1 name-width) (+ 2 count-width) (+ 2 total-width) (+ 1 avg-width))
       (for-each (lambda (d)
                   (let ((name (car d))
                         (count (cadr d))
                         (time (caddr d)))
  -                  (format #t "~20A | ~5@A | ~10@A | ~10A~%" name count time (/ time count))))
  +                  (format #t "~VA | ~V@A | ~V@A | ~VA~%" name-width name count-width count total-width time avg-width (/ time count))))
                 call-data)
  -    (format #t "---------------------+-------+------------+-----------~%")))
  +    (format #t "~V~+~V~+~V~+~V~~%" (+ 1 name-width) (+ 2 count-width) (+ 2 total-width) (+ 1 avg-width))))
   
  +
  +;;; --------------------------------------------------------------------------------
  +;;; Print out the call tree
   
   (define (print-tree)
     (define (inner-print-tree node level)
  
positive.code: ;;; Use of this source code is governed by a BSD-style
  ;;; license that can be found in the LICENSE file.
  
  (define time first)
  (define guid second)
  (define mode third)
  (define type fourth)
  (define name fifth)
  
  (define node-time first)
  (define node-type second)
  (define node-name third)
  (define node-children fourth)
  
  (define call-trees nil)
  
  
  (define (load-profile filename)
    (define (read-function-call start-data f)
      (let* ((start-time (time start-data))
             (f-guid (guid start-data))
             (f-type (type start-data))
             (f-name (name start-data))
             (children-end (let loop
                               ((d (read f))
                                (ch '()))
                             (cond ((eof-object? d)
                                    d)
                                   ((and (eq? (mode d) 'exit)
                                         (eq? (guid d) f-guid))
                                    (list (time d) ch))
                                   ((eq? (mode d) 'enter)
                                    (let ((children (cons (read-function-call d f) ch))) 
                                      (loop (read f) children))))))
             (end-time (car children-end))
             (children (cadr children-end)))
        (if (eof-object? children-end)
            children-end
            (list (- end-time start-time) f-type f-name children))))
  
    (define (read-profile-data f)
      (let loop ((result '()))
  
negative.code:     (close-port f)))
  
  
  ;;; --------------------------------------------------------------------------------
  ;;; produce a report summarizing data on each function called
  ;;; type can be prim, func, or all
  
  (define (by-function f-type)
  
    (define (add-to-function fname time data)
  