OUT-OF-DATE! Read http://shootout.alioth.debian.org/      

- all benchmarks - binary-trees chameneos-redux fannkuch fasta k-nucleotide mandelbrot meteor-contest n-body nsieve nsieve-bits partial-sums pidigits recursive regex-dna reverse-complement spectral-norm startup sum-file thread-ring - all languages - Ada 2005 GNAT BASIC FreeBASIC C CINT C GNU gcc C Intel C# Mono C++ GNU g++ C++ Intel CAL Clean D Digital Mars Eiffel SmartEiffel Erlang HiPE F# Mono Forth bigForth Forth GNU GForth Fortran G95 Fortran Intel Groovy Haskell GHC Icon Java 6 -client Java 6 -server Java 6 -Xint Java 6 -Xms64m Java GNU gcj JavaScript Rhino JavaScript SpiderMonkey Lisp SBCL Lua Lua LuaJIT Mercury Mozart/Oz Nice Oberon-2 OO2C OCaml Pascal Free Pascal Perl PHP Pike Prolog SWI Prolog YAP Python CPython Python IronPython Python Psyco Rebol Ruby 1.9 Ruby JRuby Ruby MRI Scala Scheme Chicken Scheme Ikarus Scheme PLT Smalltalk GNU Smalltalk Squeak Smalltalk VisualWorks SML MLton SML SML/NJ Tcl Zonnon Mono

 performance measurements

Each table row shows performance measurements for this Lisp SBCL program with a particular command-line input value N.

N	CPU secs	Elapsed secs	Memory KB	Code B	≈ CPU Load
12	0.43		21,320	553
14	0.95		28,260	553
16	3.72		36,324	553

Read the ↓ make, command line, and program output logs to see how this program was run.

Read binary-trees benchmark to see what this program should do.

 binary-trees Lisp SBCL #2 program source code

;;; -*- mode: lisp -*-
;;;
;;; http://shootout.alioth.debian.org/
;;;
;;; From: Manuel Giraud
;;; Nicer rewrite: Nicolas Neuss
;;; Modified by Juho Snellman 2005-10-26
;;;  * Change the node representation from a struct to an improper list
;;;    (saves 8 bytes for each node on SBCL/CMUCL)
;;;  * Use NIL for leaf nodes, as in the Haskell solution
;;;  * Add command-line parsing for non-CMUCL implementations
;;; De-optimized by Isaac Gouy

;;; Node is either NIL (for leaf nodes) or an improper list (DATA LEFT . RIGHT)
(defun build-btree (item depth)
  (declare (fixnum item depth))
  (if (zerop depth)
      (cons item
            (cons nil nil))
;;;      nil
      (let ((item2 (* 2 item))
            (depth-1 (1- depth)))
        (declare (fixnum item2 depth-1))
        (cons item
              (cons (build-btree (the fixnum (1- item2)) depth-1)
                    (build-btree item2 depth-1))))))

(defun check-node (node)
  (declare (values fixnum))
  (if node
      (let ((data (car node))
            (kids (cdr node)))
        (declare (fixnum data))
        (- (+ data (check-node (car kids)))
           (check-node (cdr kids))))
      0))

(defun loop-depths (max-depth &key (min-depth 4))
  (loop for d from min-depth by 2 upto max-depth do
        (let ((iterations (ash 1 (+ max-depth min-depth (- d)))))
          (format t "~D~C trees of depth ~D~C check: ~D~%"
                  (* iterations 2) #\tab d #\tab
                  (loop for i from 1 upto iterations
                        sum (check-node (build-btree i d))
                        sum (check-node (build-btree (- i) d)))))))

(defun main (&optional (n (parse-integer
                           (or (car (last #+sbcl sb-ext:*posix-argv*
                                          #+cmu  extensions:*command-line-strings*
                                          #+gcl  si::*command-args*))
                               "1"))))
  (format t "stretch tree of depth ~D~C check: ~D~%" (1+ n) #\tab
          (check-node (build-btree 0 (1+ n))))
  (let ((*print-pretty* nil) (long-lived-tree (build-btree 0 n)))
    (loop-depths n)
    (format t "long lived tree of depth ~D~C check: ~D~%"
            n #\tab (check-node long-lived-tree))))

;;(main)

 notes

 

 make, command-line, and program output logs

BUILD COMMANDS FOR: binarytrees.sbcl-2.sbcl

Wed Jun 25 21:39:56 PDT 2008

SBCL built with: /usr/bin/sbcl --userinit /dev/null --sysinit /etc/sbclrc -batch -eval '(load "binarytrees.sbcl-2.sbcl_compile")'
### START binarytrees.sbcl-2.sbcl_compile
(proclaim '(optimize (speed 3) (safety 0) (debug 0) (compilation-speed 0) (space 0)))
(handler-bind ((sb-ext:defconstant-uneql      (lambda (c) (abort c))))      (load (compile-file "binarytrees.sbcl-2.sbcl" ))) (save-lisp-and-die "sbcl.core" :purify t)
### END binarytrees.sbcl-2.sbcl_compile

; loading system definition from
; /usr/share/common-lisp/systems/asdf-binary-locations.asd into
; #
; registering # as ASDF-BINARY-LOCATIONS

; compiling file "/home/dunham/gp4/shootout/bench/binarytrees/tmp/binarytrees.sbcl-2.sbcl" (written 25 JUN 2008 09:39:56 PM):
; compiling (DEFUN BUILD-BTREE ...)
; compiling (DEFUN CHECK-NODE ...)
; compiling (DEFUN LOOP-DEPTHS ...)
; file: /home/dunham/gp4/shootout/bench/binarytrees/tmp/binarytrees.sbcl-2.sbcl
; in: DEFUN LOOP-DEPTHS
;     (LOOP FOR D FROM MIN-DEPTH BY 2 UPTO MAX-DEPTH DO
;         (LET ((ITERATIONS (ASH 1 #)))
;           (FORMAT T "~D~C trees of depth ~D~C check: ~D~%" (* ITERATIONS 2)
;                   #\Tab D #\Tab
;                   (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE #) SUM
;                         (CHECK-NODE #)))))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY WHEN IF 
; ==>
;   (> D #:LOOP-LIMIT-5)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (+ MAX-DEPTH MIN-DEPTH (- D))
; --> + 
; ==>
;   (+ MAX-DEPTH MIN-DEPTH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
;   The second argument is a REAL, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.

; ==>
;   (+ (+ MAX-DEPTH MIN-DEPTH) (- D))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a RATIONAL.
;   The second argument is a REAL, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.

;     (LOOP FOR D FROM MIN-DEPTH BY 2 UPTO MAX-DEPTH DO
;         (LET ((ITERATIONS (ASH 1 #)))
;           (FORMAT T "~D~C trees of depth ~D~C check: ~D~%" (* ITERATIONS 2)
;                   #\Tab D #\Tab
;                   (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE #) SUM
;                         (CHECK-NODE #)))))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE 
; ==>
;   (+ D 2)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE (BUILD-BTREE I D)) SUM
;         (CHECK-NODE (BUILD-BTREE (- I) D)))
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-7 (CHECK-NODE (BUILD-BTREE I D)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (+ #:LOOP-SUM-7 (CHECK-NODE (BUILD-BTREE (- I) D)))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (LOOP FOR D FROM MIN-DEPTH BY 2 UPTO MAX-DEPTH DO
;         (LET ((ITERATIONS (ASH 1 #)))
;           (FORMAT T "~D~C trees of depth ~D~C check: ~D~%" (* ITERATIONS 2)
;                   #\Tab D #\Tab
;                   (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE #) SUM
;                         (CHECK-NODE #)))))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY WHEN IF 
; ==>
;   (> D #:LOOP-LIMIT-5)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       etc.

;     (+ MAX-DEPTH MIN-DEPTH (- D))
; --> + 
; ==>
;   (+ MAX-DEPTH MIN-DEPTH)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST
;                                                              T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST
;                                                              T).
;       etc.

;     (- D)
; ==>
;   (SB-KERNEL:%NEGATE D)
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST
;                                                              T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST
;                                                              T).
;       etc.

;     (+ MAX-DEPTH MIN-DEPTH (- D))
; ==>
;   (+ (+ MAX-DEPTH MIN-DEPTH) (- D))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 32) arithmetic (cost 5) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 32).
;       The second argument is a REAL, not a (SIGNED-BYTE 32).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES
;                                                          (SIGNED-BYTE 32) &REST
;                                                          T).
;       etc.

;     (ASH 1 (+ MAX-DEPTH MIN-DEPTH (- D)))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 29).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 29).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       etc.

;     (* ITERATIONS 2)
; ==>
;   (ASH SB-C::X 1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM
;                                                                       &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES
;                                                                (UNSIGNED-BYTE
;                                                                 32)
;                                                                &REST T).
;       etc.

;     (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE (BUILD-BTREE I D)) SUM
;         (CHECK-NODE (BUILD-BTREE (- I) D)))
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY WHEN IF 
; ==>
;   (> I #:LOOP-LIMIT-6)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER 1 536870912), not a FIXNUM.
;       The second argument is a UNSIGNED-BYTE, not a FIXNUM.

; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SETQ THE 
; ==>
;   (+ #:LOOP-SUM-7 (CHECK-NODE (BUILD-BTREE I D)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 32) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 32).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
;                                                                &REST T).
;       etc.

; ==>
;   (+ #:LOOP-SUM-7 (CHECK-NODE (BUILD-BTREE (- I) D)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 32) arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 32).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
;                                                                &REST T).
;       etc.

;     (LOOP FOR D FROM MIN-DEPTH BY 2 UPTO MAX-DEPTH DO
;         (LET ((ITERATIONS (ASH 1 #)))
;           (FORMAT T "~D~C trees of depth ~D~C check: ~D~%" (* ITERATIONS 2)
;                   #\Tab D #\Tab
;                   (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE #) SUM
;                         (CHECK-NODE #)))))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE 
; ==>
;   (+ D 2)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP FOR I FROM 1 UPTO ITERATIONS SUM (CHECK-NODE (BUILD-BTREE I D)) SUM
;         (CHECK-NODE (BUILD-BTREE (- I) D)))
; --> BLOCK LET LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ 
; ==>
;   (SETQ I (1+ I))
; 
; note: doing signed word to integer coercion (cost 20) to I

; compiling (DEFUN MAIN ...)
; file: /home/dunham/gp4/shootout/bench/binarytrees/tmp/binarytrees.sbcl-2.sbcl
; in: DEFUN MAIN
;     (1+ N)
; ==>
;   (+ N 1)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       etc.
; 
; compilation unit finished
;   printed 37 notes


; /home/dunham/gp4/shootout/bench/binarytrees/tmp/binarytrees.sbcl-2.fasl written
; compilation finished in 0:00:00
[undoing binding stack and other enclosing state... done]
[saving current Lisp image into /home/dunham/gp4/shootout/bench/binarytrees/tmp/sbcl.core:
writing 2976 bytes from the read-only space at 0x01000000
writing 2160 bytes from the static space at 0x01100000
writing 24678400 bytes from the dynamic space at 0x09000000
done]
### START binarytrees.sbcl-2.sbcl_run
(proclaim '(optimize (speed 3) (safety 0) (debug 0) (compilation-speed 0) (space 0)))
(main) (quit)
### END binarytrees.sbcl-2.sbcl_run


=================================================================
COMMAND LINE (%A is single numeric argument):

 /usr/bin/sbcl --noinform --core sbcl.core --userinit /dev/null --sysinit /etc/sbclrc --load binarytrees.sbcl-2.sbcl_run %A
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-DIRECTORY-NAME in DEFUN
STYLE-WARNING: redefining PATHNAME-PREFIX-P in DEFUN
STYLE-WARNING: redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-FOR-SYSTEM-AND-OPERATION (#
                                                     #
                                                     #
                                                     #
                                                     #) in DEFMETHOD
STYLE-WARNING: redefining OUTPUT-FILES-USING-MAPPINGS in DEFGENERIC
STYLE-WARNING:
   redefining OUTPUT-FILES-USING-MAPPINGS (#
                                           #
                                           #) in DEFMETHOD
STYLE-WARNING:
   redefining OUTPUT-FILES :AROUND (#
                                    #) in DEFMETHOD


PROGRAM OUTPUT
==============
stretch tree of depth 17	 check: -1
131072	 trees of depth 4	 check: -131072
32768	 trees of depth 6	 check: -32768
8192	 trees of depth 8	 check: -8192
2048	 trees of depth 10	 check: -2048
512	 trees of depth 12	 check: -512
128	 trees of depth 14	 check: -128
32	 trees of depth 16	 check: -32
long lived tree of depth 16	 check: -1

  Home   Flawed   Fastest   License   Help