anchor.diff:  
   #-(OR LISPWORKS-PERSONAL-EDITION)
   (when (run-benchmark-p 'SEARCH-SEQUENCE benchmarks-to-run)
  -  (format t "=== running #<benchmark SEARCH-SEQUENCE for 10 runs>~%")
  +  (format t "=== running #<benchmark SEARCH-SEQUENCE for 40 runs>~%")
     (force-output)
     (bench-gc)
     (funcall 'CL-BENCH.ARRAYS:BENCH-SEARCH-SEQUENCE-SETUP)
  -  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-SEARCH-SEQUENCE "SEARCH-SEQUENCE" 10))
  +  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-SEARCH-SEQUENCE "SEARCH-SEQUENCE" 40))
   (when (run-benchmark-p 'CLOS-DEFCLASS benchmarks-to-run)
  -  (format t "=== running #<benchmark CLOS/defclass for 1 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-DEFCLASS "CLOS/defclass" 1))
  +  (format t "=== running #<benchmark CLOS/defclass for 5 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-DEFCLASS "CLOS/defclass" 5))
   (when (run-benchmark-p 'CLOS-DEFMETHOD benchmarks-to-run)
  -  (format t "=== running #<benchmark CLOS/defmethod for 1 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-DEFMETHOD "CLOS/defmethod" 1))
  +  (format t "=== running #<benchmark CLOS/defmethod for 3 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-DEFMETHOD "CLOS/defmethod" 3))
   (when (run-benchmark-p 'CLOS-INSTANTIATE benchmarks-to-run)
     (format t "=== running #<benchmark CLOS/instantiate for 2 runs>~%")
     (force-output)
     (bench-gc)
     (BENCH-REPORT 'CL-BENCH.CLOS:MAKE-INSTANCES "CLOS/instantiate" 2))
   (when (run-benchmark-p 'CLOS-INSTANTIATE benchmarks-to-run)
  -  (format t "=== running #<benchmark CLOS/simple-instantiate for 1000 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:MAKE-INSTANCES/SIMPLE "CLOS/simple-instantiate" 1000))
  +  (format t "=== running #<benchmark CLOS/simple-instantiate for 8000 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:MAKE-INSTANCES/SIMPLE "CLOS/simple-instantiate" 8000))
   (when (run-benchmark-p 'METHODCALLS benchmarks-to-run)
  -  (format t "=== running #<benchmark CLOS/methodcalls for 5 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/SIMPLE "CLOS/methodcalls" 5))
  +  (format t "=== running #<benchmark CLOS/methodcalls for 60 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/SIMPLE "CLOS/methodcalls" 60))
   (when (run-benchmark-p 'METHODCALLS+AFTER benchmarks-to-run)
  -  (format t "=== running #<benchmark CLOS/method+after for 2 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/SIMPLE+AFTER "CLOS/method+after" 2))
  +  (format t "=== running #<benchmark CLOS/method+after for 8 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/SIMPLE+AFTER "CLOS/method+after" 8))
   
   #-(OR CLISP POPLOG)
   (when (run-benchmark-p 'METHODCALLS/COMPLEX benchmarks-to-run)
  -  (format t "=== running #<benchmark CLOS/complex-methods for 20 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/COMPLEX "CLOS/complex-methods" 20))
  +  (format t "=== running #<benchmark CLOS/complex-methods for 60 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/COMPLEX "CLOS/complex-methods" 60))
   (when (run-benchmark-p 'EQL-SPECIALIZED-FIB benchmarks-to-run)
  -  (format t "=== running #<benchmark EQL-SPECIALIZED-FIB for 33 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-EQL-FIB "EQL-SPECIALIZED-FIB" 33))
  +  (format t "=== running #<benchmark EQL-SPECIALIZED-FIB for 50 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-EQL-FIB "EQL-SPECIALIZED-FIB" 50))
   (when (run-benchmark-p 'MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE benchmarks-to-run)
  -  (format t "=== running #<benchmark MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE for 4 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.MISC:MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE "MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE" 4))
  +  (format t "=== running #<benchmark MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE for 5 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.MISC:MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE "MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE" 5))
   (when (run-benchmark-p 'MAKE-LIST-SEQUENTIAL/RPLACD benchmarks-to-run)
  -  (format t "=== running #<benchmark MAKE-LIST-SEQUENTIAL/RPLACD for 4 runs>~%")
  -  (force-output)
  -  (bench-gc)
  -  (BENCH-REPORT 'CL-BENCH.MISC:MAKE-LIST-SEQUENTIAL/RPLACD "MAKE-LIST-SEQUENTIAL/RPLACD" 4))
  +  (format t "=== running #<benchmark MAKE-LIST-SEQUENTIAL/RPLACD for 5 runs>~%")
  +  (force-output)
  +  (bench-gc)
  +  (BENCH-REPORT 'CL-BENCH.MISC:MAKE-LIST-SEQUENTIAL/RPLACD "MAKE-LIST-SEQUENTIAL/RPLACD" 5))
   (when (run-benchmark-p 'CORE-FILE-SIZE benchmarks-to-run)
     (format t "=== running #<benchmark CORE-FILE-SIZE for 1 runs>~%")
     (force-output)
  
positive.code:   (bench-gc)
    (BENCH-REPORT 'CL-BENCH.RATIOS:RUN-PI-RATIOS "PI-RATIOS" 6))
  (when (run-benchmark-p 'SLURP-LINES benchmarks-to-run)
    (format t "=== running #<benchmark SLURP-LINES for 45 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.HASH:RUN-SLURP-LINES "SLURP-LINES" 45))
  (when (run-benchmark-p 'HASH-STRINGS benchmarks-to-run)
    (format t "=== running #<benchmark HASH-STRINGS for 18 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.HASH:HASH-STRINGS "HASH-STRINGS" 18))
  (when (run-benchmark-p 'HASH-INTEGERS benchmarks-to-run)
    (format t "=== running #<benchmark HASH-INTEGERS for 34 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.HASH:HASH-INTEGERS "HASH-INTEGERS" 34))
  
  #-(OR LISPWORKS-PERSONAL-EDITION)
  (when (run-benchmark-p 'BOEHM-GC benchmarks-to-run)
    (format t "=== running #<benchmark BOEHM-GC for 2 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.BOEHM-GC:GC-BENCHMARK "BOEHM-GC" 2))
  (when (run-benchmark-p 'DEFLATE-FILE benchmarks-to-run)
    (format t "=== running #<benchmark DEFLATE-FILE for 815 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.DEFLATE:RUN-DEFLATE-FILE "DEFLATE-FILE" 815))
  
  #-(OR LISPWORKS-PERSONAL-EDITION)
  (when (run-benchmark-p '1D-ARRAYS benchmarks-to-run)
    (format t "=== running #<benchmark 1D-ARRAYS for 360 runs>~%")
    (force-output)
    (bench-gc)
    (funcall 'CL-BENCH.ARRAYS:BENCH-1D-ARRAYS-SETUP)
    (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-1D-ARRAYS "1D-ARRAYS" 360))
  
  #-(OR LISPWORKS-PERSONAL-EDITION)
  (when (run-benchmark-p '2D-ARRAYS benchmarks-to-run)
    (format t "=== running #<benchmark 2D-ARRAYS for 60 runs>~%")
    (force-output)
    (bench-gc)
    (funcall 'CL-BENCH.ARRAYS:BENCH-2D-ARRAYS-SETUP)
    (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-2D-ARRAYS "2D-ARRAYS" 60))
  
  #-(OR LISPWORKS-PERSONAL-EDITION)
  (when (run-benchmark-p '3D-ARRAYS benchmarks-to-run)
    (format t "=== running #<benchmark 3D-ARRAYS for 20 runs>~%")
    (force-output)
    (bench-gc)
    (funcall 'CL-BENCH.ARRAYS:BENCH-3D-ARRAYS-SETUP)
    (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-3D-ARRAYS "3D-ARRAYS" 20))
  (when (run-benchmark-p 'BITVECTORS benchmarks-to-run)
    (format t "=== running #<benchmark BITVECTORS for 7700 runs>~%")
    (force-output)
  
negative.code: 
  #-(OR ARMEDBEAR)
  (when (run-benchmark-p 'COMPILER benchmarks-to-run)
    (format t "=== running #<benchmark COMPILER for 10 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.MISC:RUN-COMPILER "COMPILER" 10))
  
  #-(OR ARMEDBEAR)
  (when (run-benchmark-p 'LOAD-FASL benchmarks-to-run)
    (format t "=== running #<benchmark LOAD-FASL for 272 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.MISC:RUN-FASLOAD "LOAD-FASL" 272))
  
  #-(OR LISPWORKS-PERSONAL-EDITION)
  (when (run-benchmark-p 'SUM-PERMUTATIONS benchmarks-to-run)
    (format t "=== running #<benchmark SUM-PERMUTATIONS for 7 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.MISC:RUN-PERMUTATIONS "SUM-PERMUTATIONS" 7))
  
  #-(OR LISPWORKS-PERSONAL-EDITION)
  (when (run-benchmark-p 'WALK-LIST/SEQ benchmarks-to-run)
    (format t "=== running #<benchmark WALK-LIST/SEQ for 1560 runs>~%")
    (force-output)
    (bench-gc)
    (funcall 'CL-BENCH.MISC::SETUP-WALK-LIST/SEQ)
    (BENCH-REPORT 'CL-BENCH.MISC:WALK-LIST/SEQ "WALK-LIST/SEQ" 1560))
  
  #-(OR LISPWORKS-PERSONAL-EDITION POPLOG)
  (when (run-benchmark-p 'WALK-LIST/MESS benchmarks-to-run)
    (format t "=== running #<benchmark WALK-LIST/MESS for 170 runs>~%")
    (force-output)
    (bench-gc)
    (funcall 'CL-BENCH.MISC::SETUP-WALK-LIST/MESS)
    (BENCH-REPORT 'CL-BENCH.MISC:WALK-LIST/MESS "WALK-LIST/MESS" 170))
  (when (run-benchmark-p 'BOYER benchmarks-to-run)
    (format t "=== running #<benchmark BOYER for 8 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:BOYER "BOYER" 8))
  (when (run-benchmark-p 'BROWSE benchmarks-to-run)
    (format t "=== running #<benchmark BROWSE for 300 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:BROWSE "BROWSE" 300))
  (when (run-benchmark-p 'DDERIV benchmarks-to-run)
    (format t "=== running #<benchmark DDERIV for 1500 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:DDERIV-RUN "DDERIV" 1500))
  (when (run-benchmark-p 'DERIV benchmarks-to-run)
    (format t "=== running #<benchmark DERIV for 1500 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:DERIV-RUN "DERIV" 1500))
  (when (run-benchmark-p 'DESTRUCTIVE benchmarks-to-run)
    (format t "=== running #<benchmark DESTRUCTIVE for 2000 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-DESTRUCTIVE "DESTRUCTIVE" 2000))
  (when (run-benchmark-p 'DIV2-TEST-1 benchmarks-to-run)
    (format t "=== running #<benchmark DIV2-TEST-1 for 3500 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-DIV2-TEST1 "DIV2-TEST-1" 3500))
  (when (run-benchmark-p 'DIV2-TEST-2 benchmarks-to-run)
    (format t "=== running #<benchmark DIV2-TEST-2 for 1950 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-DIV2-TEST2 "DIV2-TEST-2" 1950))
  (when (run-benchmark-p 'FFT benchmarks-to-run)
    (format t "=== running #<benchmark FFT for 3066 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FFT "FFT" 3066))
  (when (run-benchmark-p 'FRPOLY/FIXNUM benchmarks-to-run)
    (format t "=== running #<benchmark FRPOLY/FIXNUM for 1600 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FRPOLY/FIXNUM "FRPOLY/FIXNUM" 1600))
  (when (run-benchmark-p 'FRPOLY/BIGNUM benchmarks-to-run)
    (format t "=== running #<benchmark FRPOLY/BIGNUM for 420 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FRPOLY/BIGNUM "FRPOLY/BIGNUM" 420))
  (when (run-benchmark-p 'FRPOLY/FLOAT benchmarks-to-run)
    (format t "=== running #<benchmark FRPOLY/FLOAT for 1280 runs>~%")
    (force-output)
    (bench-gc)
    (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FRPOLY/FLOAT "FRPOLY/FLOAT" 1280))
  (when (run-benchmark-p 'PUZZLE benchmarks-to-run)
    (format t "=== running #<benchmark PUZZLE for 23793 runs>~%")
    (force-output)
  