;;; auto-generated from file #P"generate.lisp"
(IN-PACKAGE :CL-USER)
(LOAD #P"defpackage.lisp")
(LOAD (COMPILE-FILE-PATHNAME #P"files/arrays.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/bignum.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/boehm-gc.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/clos.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/crc40.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/deflate.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/gabriel.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/hash.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/math.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/ratios.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/richards.olisp"))
(LOAD (COMPILE-FILE-PATHNAME #P"files/misc.olisp"))
(COMPILE-FILE #P"support.lisp")
(LOAD (COMPILE-FILE-PATHNAME #P"support.lisp"))
(IN-PACKAGE :CL-BENCH)
(defun run-benchmarks ()
 (with-open-file (f (benchmark-report-file)
                    :direction :output
                    :if-does-not-exist :create
                    :if-exists :supersede)
   (let ((*benchmark-output* f)
         (*print-length* nil)
         (*load-verbose* nil)
         (*compile-verbose* nil)
         (*compile-print* nil)
	 (benchmarks-to-run
	  (with-open-file (f #p"benchmarks-to-run"
			   :direction :input
			   :if-does-not-exist :create)
	   (let ((*read-eval* nil))
	     (read f nil nil)))))
     (bench-report-header)

#-(OR ARMEDBEAR)
(when (run-benchmark-p 'COMPILER benchmarks-to-run)
  (format t "=== running #<benchmark COMPILER for 3 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MISC:RUN-COMPILER "COMPILER" 3))

#-(OR ARMEDBEAR)
(when (run-benchmark-p 'LOAD-FASL benchmarks-to-run)
  (format t "=== running #<benchmark LOAD-FASL for 20 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MISC:RUN-FASLOAD "LOAD-FASL" 20))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p 'SUM-PERMUTATIONS benchmarks-to-run)
  (format t "=== running #<benchmark SUM-PERMUTATIONS for 2 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MISC:RUN-PERMUTATIONS "SUM-PERMUTATIONS" 2))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p 'WALK-LIST/SEQ benchmarks-to-run)
  (format t "=== running #<benchmark WALK-LIST/SEQ for 2 runs>~%")
  (force-output)
  (bench-gc)
  (funcall 'CL-BENCH.MISC::SETUP-WALK-LIST/SEQ)
  (BENCH-REPORT 'CL-BENCH.MISC:WALK-LIST/SEQ "WALK-LIST/SEQ" 2))

#-(OR LISPWORKS-PERSONAL-EDITION POPLOG)
(when (run-benchmark-p 'WALK-LIST/MESS benchmarks-to-run)
  (format t "=== running #<benchmark WALK-LIST/MESS for 1 runs>~%")
  (force-output)
  (bench-gc)
  (funcall 'CL-BENCH.MISC::SETUP-WALK-LIST/MESS)
  (BENCH-REPORT 'CL-BENCH.MISC:WALK-LIST/MESS "WALK-LIST/MESS" 1))
(when (run-benchmark-p 'BOYER benchmarks-to-run)
  (format t "=== running #<benchmark BOYER for 30 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:BOYER "BOYER" 30))
(when (run-benchmark-p 'BROWSE benchmarks-to-run)
  (format t "=== running #<benchmark BROWSE for 10 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:BROWSE "BROWSE" 10))
(when (run-benchmark-p 'DDERIV benchmarks-to-run)
  (format t "=== running #<benchmark DDERIV for 50 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:DDERIV-RUN "DDERIV" 50))
(when (run-benchmark-p 'DERIV benchmarks-to-run)
  (format t "=== running #<benchmark DERIV for 60 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:DERIV-RUN "DERIV" 60))
(when (run-benchmark-p 'DESTRUCTIVE benchmarks-to-run)
  (format t "=== running #<benchmark DESTRUCTIVE for 100 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-DESTRUCTIVE "DESTRUCTIVE" 100))
(when (run-benchmark-p 'DIV2-TEST-1 benchmarks-to-run)
  (format t "=== running #<benchmark DIV2-TEST-1 for 200 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-DIV2-TEST1 "DIV2-TEST-1" 200))
(when (run-benchmark-p 'DIV2-TEST-2 benchmarks-to-run)
  (format t "=== running #<benchmark DIV2-TEST-2 for 200 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-DIV2-TEST2 "DIV2-TEST-2" 200))
(when (run-benchmark-p 'FFT benchmarks-to-run)
  (format t "=== running #<benchmark FFT for 30 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FFT "FFT" 30))
(when (run-benchmark-p 'FRPOLY/FIXNUM benchmarks-to-run)
  (format t "=== running #<benchmark FRPOLY/FIXNUM for 100 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FRPOLY/FIXNUM "FRPOLY/FIXNUM" 100))
(when (run-benchmark-p 'FRPOLY/BIGNUM benchmarks-to-run)
  (format t "=== running #<benchmark FRPOLY/BIGNUM for 30 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FRPOLY/BIGNUM "FRPOLY/BIGNUM" 30))
(when (run-benchmark-p 'FRPOLY/FLOAT benchmarks-to-run)
  (format t "=== running #<benchmark FRPOLY/FLOAT for 100 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-FRPOLY/FLOAT "FRPOLY/FLOAT" 100))
(when (run-benchmark-p 'PUZZLE benchmarks-to-run)
  (format t "=== running #<benchmark PUZZLE for 1500 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-PUZZLE "PUZZLE" 1500))
(when (run-benchmark-p 'TAK benchmarks-to-run)
  (format t "=== running #<benchmark TAK for 500 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-TAK "TAK" 500))
(when (run-benchmark-p 'CTAK benchmarks-to-run)
  (format t "=== running #<benchmark CTAK for 900 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-CTAK "CTAK" 900))
(when (run-benchmark-p 'TRTAK benchmarks-to-run)
  (format t "=== running #<benchmark TRTAK for 500 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-TRTAK "TRTAK" 500))
(when (run-benchmark-p 'TAKL benchmarks-to-run)
  (format t "=== running #<benchmark TAKL for 150 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-TAKL "TAKL" 150))
(when (run-benchmark-p 'STAK benchmarks-to-run)
  (format t "=== running #<benchmark STAK for 200 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-STAK "STAK" 200))
(when (run-benchmark-p 'FPRINT/UGLY benchmarks-to-run)
  (format t "=== running #<benchmark FPRINT/UGLY for 200 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:FPRINT/UGLY "FPRINT/UGLY" 200))
(when (run-benchmark-p 'FPRINT/PRETTY benchmarks-to-run)
  (format t "=== running #<benchmark FPRINT/PRETTY for 100 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:FPRINT/PRETTY "FPRINT/PRETTY" 100))
(when (run-benchmark-p 'TRAVERSE benchmarks-to-run)
  (format t "=== running #<benchmark TRAVERSE for 15 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-TRAVERSE "TRAVERSE" 15))
(when (run-benchmark-p 'TRIANGLE benchmarks-to-run)
  (format t "=== running #<benchmark TRIANGLE for 5 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.GABRIEL:RUN-TRIANGLE "TRIANGLE" 5))
(when (run-benchmark-p 'RICHARDS benchmarks-to-run)
  (format t "=== running #<benchmark RICHARDS for 5 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.RICHARDS:RICHARDS "RICHARDS" 5))
(when (run-benchmark-p 'FACTORIAL benchmarks-to-run)
  (format t "=== running #<benchmark FACTORIAL for 1000 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-FACTORIAL "FACTORIAL" 1000))
(when (run-benchmark-p 'FIB benchmarks-to-run)
  (format t "=== running #<benchmark FIB for 50 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-FIB "FIB" 50))
(when (run-benchmark-p 'FIB-RATIO benchmarks-to-run)
  (format t "=== running #<benchmark FIB-RATIO for 500 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-FIB-RATIO "FIB-RATIO" 500))
(when (run-benchmark-p 'ACKERMANN benchmarks-to-run)
  (format t "=== running #<benchmark ACKERMANN for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-ACKERMANN "ACKERMANN" 1))
(when (run-benchmark-p 'MANDELBROT/COMPLEX benchmarks-to-run)
  (format t "=== running #<benchmark MANDELBROT/COMPLEX for 1000 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-MANDELBROT/COMPLEX "MANDELBROT/COMPLEX" 1000))
(when (run-benchmark-p 'MANDELBROT/DFLOAT benchmarks-to-run)
  (format t "=== running #<benchmark MANDELBROT/DFLOAT for 1000 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-MANDELBROT/DFLOAT "MANDELBROT/DFLOAT" 1000))
(when (run-benchmark-p 'MRG32K3A benchmarks-to-run)
  (format t "=== running #<benchmark MRG32K3A for 20 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.MATH:RUN-MRG32K3A "MRG32K3A" 20))
(when (run-benchmark-p 'CRC40 benchmarks-to-run)
  (format t "=== running #<benchmark CRC40 for 2 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.CRC:RUN-CRC40 "CRC40" 2))
(when (run-benchmark-p 'BIGNUM/ELEM-100-1000 benchmarks-to-run)
  (format t "=== running #<benchmark BIGNUM/ELEM-100-1000 for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-ELEM-100-1000 "BIGNUM/ELEM-100-1000" 1))
(when (run-benchmark-p 'BIGNUM/ELEM-1000-100 benchmarks-to-run)
  (format t "=== running #<benchmark BIGNUM/ELEM-1000-100 for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-ELEM-1000-100 "BIGNUM/ELEM-1000-100" 1))
(when (run-benchmark-p 'BIGNUM/ELEM-10000-1 benchmarks-to-run)
  (format t "=== running #<benchmark BIGNUM/ELEM-10000-1 for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-ELEM-10000-1 "BIGNUM/ELEM-10000-1" 1))
(when (run-benchmark-p 'BIGNUM/PARI-100-10 benchmarks-to-run)
  (format t "=== running #<benchmark BIGNUM/PARI-100-10 for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-PARI-100-10 "BIGNUM/PARI-100-10" 1))
(when (run-benchmark-p 'BIGNUM/PARI-200-5 benchmarks-to-run)
  (format t "=== running #<benchmark BIGNUM/PARI-200-5 for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-PARI-200-5 "BIGNUM/PARI-200-5" 1))
(when (run-benchmark-p 'PI-DECIMAL/SMALL benchmarks-to-run)
  (format t "=== running #<benchmark PI-DECIMAL/SMALL for 100 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-PI-DECIMAL/SMALL "PI-DECIMAL/SMALL" 100))
(when (run-benchmark-p 'PI-DECIMAL/BIG benchmarks-to-run)
  (format t "=== running #<benchmark PI-DECIMAL/BIG for 2 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-PI-DECIMAL/BIG "PI-DECIMAL/BIG" 2))
(when (run-benchmark-p 'PI-ATAN benchmarks-to-run)
  (format t "=== running #<benchmark PI-ATAN for 200 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BIGNUM:RUN-PI-ATAN "PI-ATAN" 200))
(when (run-benchmark-p 'PI-RATIOS benchmarks-to-run)
  (format t "=== running #<benchmark PI-RATIOS for 2 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.RATIOS:RUN-PI-RATIOS "PI-RATIOS" 2))
(when (run-benchmark-p 'SLURP-LINES benchmarks-to-run)
  (format t "=== running #<benchmark SLURP-LINES for 30 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.HASH:RUN-SLURP-LINES "SLURP-LINES" 30))
(when (run-benchmark-p 'HASH-STRINGS benchmarks-to-run)
  (format t "=== running #<benchmark HASH-STRINGS for 2 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.HASH:HASH-STRINGS "HASH-STRINGS" 2))
(when (run-benchmark-p 'HASH-INTEGERS benchmarks-to-run)
  (format t "=== running #<benchmark HASH-INTEGERS for 10 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.HASH:HASH-INTEGERS "HASH-INTEGERS" 10))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p 'BOEHM-GC benchmarks-to-run)
  (format t "=== running #<benchmark BOEHM-GC for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.BOEHM-GC:GC-BENCHMARK "BOEHM-GC" 1))
(when (run-benchmark-p 'DEFLATE-FILE benchmarks-to-run)
  (format t "=== running #<benchmark DEFLATE-FILE for 100 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.DEFLATE:RUN-DEFLATE-FILE "DEFLATE-FILE" 100))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p '1D-ARRAYS benchmarks-to-run)
  (format t "=== running #<benchmark 1D-ARRAYS for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-1D-ARRAYS "1D-ARRAYS" 1))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p '2D-ARRAYS benchmarks-to-run)
  (format t "=== running #<benchmark 2D-ARRAYS for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-2D-ARRAYS "2D-ARRAYS" 1))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p '3D-ARRAYS benchmarks-to-run)
  (format t "=== running #<benchmark 3D-ARRAYS for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-3D-ARRAYS "3D-ARRAYS" 1))
(when (run-benchmark-p 'BITVECTORS benchmarks-to-run)
  (format t "=== running #<benchmark BITVECTORS for 3 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-BITVECTORS "BITVECTORS" 3))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p 'BENCH-STRINGS benchmarks-to-run)
  (format t "=== running #<benchmark BENCH-STRINGS for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-STRINGS "BENCH-STRINGS" 1))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p 'FILL-STRINGS/ADJUST benchmarks-to-run)
  (format t "=== running #<benchmark fill-strings/adjustable for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-STRINGS/ADJUSTABLE "fill-strings/adjustable" 1))

#-(OR ALLEGRO LISPWORKS-PERSONAL-EDITION POPLOG)
(when (run-benchmark-p 'STRING-CONCAT benchmarks-to-run)
  (format t "=== running #<benchmark STRING-CONCAT for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-STRING-CONCAT "STRING-CONCAT" 1))

#-(OR LISPWORKS-PERSONAL-EDITION)
(when (run-benchmark-p 'SEARCH-SEQUENCE benchmarks-to-run)
  (format t "=== running #<benchmark SEARCH-SEQUENCE for 1 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.ARRAYS:BENCH-SEARCH-SEQUENCE "SEARCH-SEQUENCE" 1))
(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))
(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))
(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 200 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.CLOS:MAKE-INSTANCES/SIMPLE "CLOS/simple-instantiate" 200))
(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))
(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))

#-(OR CLISP POPLOG)
(when (run-benchmark-p 'METHODCALLS/COMPLEX benchmarks-to-run)
  (format t "=== running #<benchmark CLOS/complex-methods for 5 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.CLOS:METHODCALLS/COMPLEX "CLOS/complex-methods" 5))
(when (run-benchmark-p 'EQL-SPECIALIZED-FIB benchmarks-to-run)
  (format t "=== running #<benchmark EQL-SPECIALIZED-FIB for 2 runs>~%")
  (force-output)
  (bench-gc)
  (BENCH-REPORT 'CL-BENCH.CLOS:RUN-EQL-FIB "EQL-SPECIALIZED-FIB" 2))
(when (run-benchmark-p 'MAKE-LIST-SEQUENTIAL/PUSH-NREVERSE benchmarks-to-run)
  (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 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)
  (bench-gc)
  (BENCH-REPORT-UNTIMED 'CL-BENCH.MISC:CORE-FILE-SIZE "CORE-FILE-SIZE" 1))
(bench-report-footer))))
(run-benchmarks)
