anchor.diff:  	   #+sbcl sb-sys:without-gcing
   	   (dotimes (i repeat)
   	     (funcall fun i)))
  -    (let ((run1 (get-internal-run-time)))
  -      (round (* (- run1 run0)
  -		(/ 1000000000 internal-time-units-per-second)
  -		(/ repeat))))))
  +    (let* ((run1 (get-internal-run-time))
  +	   (q
  +	    (float (* (- run1 run0)
  +		      (/ 1000000000 internal-time-units-per-second)
  +		      (/ repeat)))))
  +      (if (< q 10)
  +	  q
  +	  (round q)))))
   
   (defparameter *repeat*
     50000)
  
positive.code:     (let ((*standard-output* (make-broadcast-stream *standard-output* s))
  	  (*repeat* (choose-repeat-count)))
        (format s ":repeat-count ~D~%" *repeat*)
        (ensure-smoke :qtcore)
        (ensure-smoke :qtgui)
        (init/cffi)
        (format s ":results (~%")
        (dolist (fun '(bench/nop
  
negative.code:       (iter (for object in-vector others)
  	    (#_delete object)))))
  
  (defun bench-interpret-new-qobject (&optional (repeat *repeat*))
    (let ((objects (make-array repeat)))
      (prog1
  	(measure-dotimes (x repeat)
  	  (setf (elt objects x) (interpret-new "QObject")))
        (iter (for object in-vector objects)
  	    (#_delete object)))))
  
  (defun bench-interpret-new-qcolor (&optional (repeat *repeat*))
    (let ((objects (make-array repeat)))
      (prog1
  	(measure-dotimes (x repeat)
  	  (setf (elt objects x) (interpret-new "QColor")))
        (iter (for object in-vector objects)
  	    (#_delete object)))))
  
  (defun bench-interpret-new-qcolor/3 (&optional (repeat *repeat*))
    (let ((objects (make-array repeat)))
      (prog1
  	(measure-dotimes (x repeat)
  	  (setf (elt objects x) (interpret-new "QColor" #xca #xfe #xba)))
        (iter (for object in-vector objects)
  	    (#_delete object)))))
  
  (defun bench-interpret-new-qcolor/4 (&optional (repeat *repeat*))
    (let ((objects (make-array repeat)))
      (prog1
  	(measure-dotimes (x repeat)
  	  (setf (elt objects x) (interpret-new "QColor" #xca #xfe #xba #xbe)))
        (iter (for object in-vector objects)
  	    (#_delete object)))))
  
  (defun bench-interpret-delete-qobject (&optional (repeat *repeat*))
    (let ((objects (make-array repeat)))
      (dotimes (i repeat)
        (setf (elt objects i)
  	    (#_new QObject)))
      (measure-dotimes (i repeat)
        (interpret-delete (elt objects i)))))
  
  (defun bench-interpret-call-parent (&optional (repeat *repeat*))
    (measure-on-qobjects (lambda (objects i)
  			 (interpret-call (elt objects i) "parent"))
  		       repeat))
  
  (defun bench-interpret-call-setparent0 (&optional (repeat *repeat*))
    (let ((x (null-qobject (find-qclass "QObject"))))
      (measure-on-qobjects (lambda (objects i)
  			   (interpret-call (elt objects i) "setParent" x))
  			 repeat)))
  
  (defun bench-interpret-call-setparent (&optional (repeat *repeat*))
    (let ((others (make-array repeat)))
      (dotimes (i repeat)
        (setf (elt others i)
  	    (#_new QObject)))
      (prog1
  	(measure-on-qobjects (lambda (objects i)
  			       (interpret-call (elt objects i)
  					       "setParent"
  					       (elt others i)))
  			     repeat)
        (iter (for object in-vector others)
  	    (#_delete object)))))
  
  (defun bench/nop (&optional (repeat *repeat*))
    (measure-on-qobjects (lambda (objects i)
  