floyd-warshall on sbcl-0.9.9-darwin-ppc - Details

Author:Robert P. Goldman
Version:0.01
Started at:2006-04-16 00:52:00
Ended at:2006-04-16 00:52:09
Elapsed time (seconds):9
Error:erred while invoking #<COMPILE-OP NIL {40006FE1}> on #<CL-SOURCE-FILE \"shortest-path\" {40006FF1}>
Most recent change:2006-01-23 22:32:36
Most recent file:/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/albert-docs/classxfloyd-warshallxfw-graph.html

REPL Output

;;; ASDF-INSTALL: Downloading 28483 bytes from http://rpgoldman.real-time.com/lisp/floyd-warshall_0.01.tgz to /Users/gwking/temporary/asdf-test/FLOYD-WARSHALL.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/FLOYD-WARSHALL.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
floyd-warshall_0.01/
floyd-warshall_0.01/albert-docs/
floyd-warshall_0.01/albert-docs/FLOYD-WARSHALL/
floyd-warshall_0.01/albert-docs/FLOYD-WARSHALL/FW-GRAPH.xml
floyd-warshall_0.01/albert-docs/FLOYD-WARSHALL/SAVE-OBJECT.xml
floyd-warshall_0.01/albert-docs/FLOYD-WARSHALL/contentlist.xml
floyd-warshall_0.01/albert-docs/FLOYD-WARSHALL/RAW-SHORTEST-PATH.xml
floyd-warshall_0.01/albert-docs/FLOYD-WARSHALL/SHORTEST-PATH.xml
floyd-warshall_0.01/albert-docs/global-index.xml
floyd-warshall_0.01/albert-docs/book.xml
floyd-warshall_0.01/albert-docs/index.html
floyd-warshall_0.01/albert-docs/packagexfloyd-warshall.html
floyd-warshall_0.01/albert-docs/packagexcontentxfloyd-warshall.html
floyd-warshall_0.01/albert-docs/classxfloyd-warshallxfw-graph.html
floyd-warshall_0.01/albert-docs/methxfloyd-warshallxsave-object.html
floyd-warshall_0.01/albert-docs/packagexfloyd-warshallxcontent.html
floyd-warshall_0.01/albert-docs/indexreference.html
floyd-warshall_0.01/albert-docs/globalindex.html
floyd-warshall_0.01/albert-docs/albert.css
floyd-warshall_0.01/albert-docs/exported.png
floyd-warshall_0.01/albert-docs/gnome_up.png
floyd-warshall_0.01/albert-docs/gnome_index.png
floyd-warshall_0.01/albert-docs/gnome_no.png
floyd-warshall_0.01/albert-docs/internal.png
floyd-warshall_0.01/albert-docs/gnome_right.png
floyd-warshall_0.01/albert-docs/gnome_home.png
floyd-warshall_0.01/albert-docs/README
floyd-warshall_0.01/albert-docs/gnome_left.png
floyd-warshall_0.01/albert-docs/gnome_yes.png
floyd-warshall_0.01/albert-docs/gnome_down.png
floyd-warshall_0.01/decls.lisp
floyd-warshall_0.01/floyd-warshall.asd
floyd-warshall_0.01/license.html
floyd-warshall_0.01/package.lisp
floyd-warshall_0.01/preamble.html
floyd-warshall_0.01/shortest-path.lisp
floyd-warshall_0.01/test.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/package.lisp" (written 02 DEC 2005 12:10:13 PM):
; compiling (IN-PACKAGE "COMMON-LISP-USER")
; compiling (DEFPACKAGE :FLOYD-WARSHALL ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/decls.lisp" (written 02 DEC 2005 12:10:13 PM):
; compiling (IN-PACKAGE "FLOYD-WARSHALL")
; compiling (DEFGENERIC SAVE-OBJECT ...)
; compiling (DEFGENERIC RAW-SHORTEST-PATH ...)
; compiling (DEFGENERIC SHORTEST-PATH ...)
; compiling (DEFCLASS FW-GRAPH ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/decls.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/shortest-path.lisp" (written 02 DEC 2005 12:10:13 PM):
; compiling (IN-PACKAGE "FLOYD-WARSHALL")
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFCONSTANT +OK-TESTS+ ...)
; compiling (DEFUN ALL-SHORTEST-PATHS ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/shortest-path.lisp
; in: DEFUN ALL-SHORTEST-PATHS
;     (MEMBER FLOYD-WARSHALL::TEST FLOYD-WARSHALL::+OK-TESTS+)
; --> IF FUNCALL 
; ==>
;   '#<FUNCTION EQ>
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF 
; ==>
;   (FUNCALL SB-C::TEST SB-C::E '#<FUNCTION EQ>)
; 
; note: The third argument never returns a value.

; ==>
;   '(#<FUNCTION EQ> #<FUNCTION EQL> #<FUNCTION EQUAL> #<FUNCTION EQUALP>)
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF IF FUNCALL 
; ==>
;   '#<FUNCTION EQL>
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF IF 
; ==>
;   (FUNCALL SB-C::TEST SB-C::E '#<FUNCTION EQL>)
; 
; note: The third argument never returns a value.

; ==>
;   '(#<FUNCTION EQL> #<FUNCTION EQUAL> #<FUNCTION EQUALP>)
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF IF IF FUNCALL 
; ==>
;   '#<FUNCTION EQUAL>
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF IF IF 
; ==>
;   (FUNCALL SB-C::TEST SB-C::E '#<FUNCTION EQUAL>)
; 
; note: The third argument never returns a value.

; ==>
;   '(#<FUNCTION EQUAL> #<FUNCTION EQUALP>)
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF IF IF IF FUNCALL 
; ==>
;   '#<FUNCTION EQUALP>
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

; --> IF IF IF IF 
; ==>
;   (FUNCALL SB-C::TEST SB-C::E '#<FUNCTION EQUALP>)
; 
; note: The third argument never returns a value.

; ==>
;   '(#<FUNCTION EQUALP>)
; 
; caught ERROR:
;   Objects of type FUNCTION can't be dumped into fasl files.

;     (ERROR "Bad value for node comparison test: ~A" FLOYD-WARSHALL::TEST)
; ==>
;   "Bad value for node comparison test: ~A"
; 
; note: deleting unreachable code

;     (NULL FLOYD-WARSHALL::ROOTS)
; --> IF 
; ==>
;   FLOYD-WARSHALL::ROOTS
; 
; note: deleting unreachable code

;     (NULL FLOYD-WARSHALL::ROOT)
; --> IF 
; ==>
;   FLOYD-WARSHALL::ROOT
; 
; note: deleting unreachable code

;     (ERROR "Must specify root or roots of the graph.")
; ==>
;   "Must specify root or roots of the graph."
; 
; note: deleting unreachable code

;     (AND FLOYD-WARSHALL::ROOTS FLOYD-WARSHALL::ROOT)
; --> IF 
; ==>
;   FLOYD-WARSHALL::ROOTS
; 
; note: deleting unreachable code

; --> IF AND 
; ==>
;   FLOYD-WARSHALL::ROOT
; 
; note: deleting unreachable code

;     (ERROR "Must specify EITHER root or roots, but not both.")
; ==>
;   "Must specify EITHER root or roots, but not both."
; 
; note: deleting unreachable code

;     (WHEN FLOYD-WARSHALL::ROOT
;     (SETF FLOYD-WARSHALL::ROOTS (LIST FLOYD-WARSHALL::ROOT)))
; --> COND IF 
; ==>
;   FLOYD-WARSHALL::ROOT
; 
; note: deleting unreachable code

;     (LIST FLOYD-WARSHALL::ROOT)
; ==>
;   FLOYD-WARSHALL::ROOT
; 
; note: deleting unreachable code

;     (LET ((FLOYD-WARSHALL::OBJ
;          (MAKE-INSTANCE 'FLOYD-WARSHALL::FW-GRAPH :TEST FLOYD-WARSHALL::TEST))
;         FLOYD-WARSHALL::N)
;     (WITH-SLOTS (FLOYD-WARSHALL::NODE-HASH)
;                 FLOYD-WARSHALL::OBJ
;                 (SETF FLOYD-WARSHALL::N
;                         (LOOP FLOYD-WARSHALL::WITH
;                               OPEN
;                               =
;                               (COPY-LIST FLOYD-WARSHALL::ROOTS)
;                               FLOYD-WARSHALL::WITH
;                               FLOYD-WARSHALL::VISITED-HASH
;                               =
;                               (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;                               FLOYD-WARSHALL::WITH
;                               FLOYD-WARSHALL::INDEX
;                               =
;                               ...))
;                 (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;                   (FORMAT *DEBUG-IO* "~&Index table is built.~%"))
;                 (LET ((FLOYD-WARSHALL::ARR1 #) (FLOYD-WARSHALL::ARR2 #))
;                   (LOOP FLOYD-WARSHALL::WITH
;                         OPEN
;                         =
;                         (COPY-LIST FLOYD-WARSHALL::ROOTS)
;                         FLOYD-WARSHALL::WITH
;                         FLOYD-WARSHALL::VISITED-HASH
;                         =
;                         (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;                         FLOYD-WARSHALL::WITH
;                         FLOYD-WARSHALL::CHILDREN
;                         AND
;                         ...)
;                   (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;                     (FORMAT *DEBUG-IO*
;                             "~&Initial connection table is built.~%"))
;                   (LOOP FLOYD-WARSHALL::FOR
;                         FLOYD-WARSHALL::I
;                         FLOYD-WARSHALL::FROM
;                         0
;                         FLOYD-WARSHALL::BELOW
;                         FLOYD-WARSHALL::N
;                         DO
;                         (SETF # 0))
;                   (SETF (SLOT-VALUE FLOYD-WARSHALL::OBJ
;                                     'FLOYD-WARSHALL::DISTANCE-ARRAY)
;                           (LOOP FLOYD-WARSHALL::WITH
;                                 FLOYD-WARSHALL::ARR
;                                 =
;                                 FLOYD-WARSHALL::ARR1
;                                 FLOYD-WARSHALL::WITH
;                                 FLOYD-WARSHALL::ARR-PRIME
;                                 =
;                                 FLOYD-WARSHALL::ARR2
;                                 FLOYD-WARSHALL::FOR
;                                 FLOYD-WARSHALL::K
;                                 FLOYD-WARSHALL::FROM
;                                 ...))))
;     FLOYD-WARSHALL::OBJ)
; 
; note: deleting unreachable code

; ==>
;   FLOYD-WARSHALL::OBJ
; 
; note: deleting unreachable code

;     (RETURN FLOYD-WARSHALL::ARR)
; --> RETURN-FROM 
; ==>
;   FLOYD-WARSHALL::ARR
; 
; note: deleting unreachable code

;     (FORMAT *DEBUG-IO*
;           "~&~Dth iteration of dynamic program loop.~%"
;           FLOYD-WARSHALL::K)
; ==>
;   *DEBUG-IO*
; 
; note: deleting unreachable code

;     (FORMAT *DEBUG-IO* "~&Initial connection table is built.~%")
; ==>
;   *DEBUG-IO*
; 
; note: deleting unreachable code

;     (FORMAT *DEBUG-IO* "~&Index table is built.~%")
; ==>
;   *DEBUG-IO*
; 
; note: deleting unreachable code

;     (LET ((FLOYD-WARSHALL::OBJ
;          (MAKE-INSTANCE 'FLOYD-WARSHALL::FW-GRAPH :TEST FLOYD-WARSHALL::TEST))
;         FLOYD-WARSHALL::N)
;     (WITH-SLOTS (FLOYD-WARSHALL::NODE-HASH)
;                 FLOYD-WARSHALL::OBJ
;                 (SETF FLOYD-WARSHALL::N
;                         (LOOP FLOYD-WARSHALL::WITH
;                               OPEN
;                               =
;                               (COPY-LIST FLOYD-WARSHALL::ROOTS)
;                               FLOYD-WARSHALL::WITH
;                               FLOYD-WARSHALL::VISITED-HASH
;                               =
;                               (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;                               FLOYD-WARSHALL::WITH
;                               FLOYD-WARSHALL::INDEX
;                               =
;                               ...))
;                 (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;                   (FORMAT *DEBUG-IO* "~&Index table is built.~%"))
;                 (LET ((FLOYD-WARSHALL::ARR1 #) (FLOYD-WARSHALL::ARR2 #))
;                   (LOOP FLOYD-WARSHALL::WITH
;                         OPEN
;                         =
;                         (COPY-LIST FLOYD-WARSHALL::ROOTS)
;                         FLOYD-WARSHALL::WITH
;                         FLOYD-WARSHALL::VISITED-HASH
;                         =
;                         (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;                         FLOYD-WARSHALL::WITH
;                         FLOYD-WARSHALL::CHILDREN
;                         AND
;                         ...)
;                   (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;                     (FORMAT *DEBUG-IO*
;                             "~&Initial connection table is built.~%"))
;                   (LOOP FLOYD-WARSHALL::FOR
;                         FLOYD-WARSHALL::I
;                         FLOYD-WARSHALL::FROM
;                         0
;                         FLOYD-WARSHALL::BELOW
;                         FLOYD-WARSHALL::N
;                         DO
;                         (SETF # 0))
;                   (SETF (SLOT-VALUE FLOYD-WARSHALL::OBJ
;                                     'FLOYD-WARSHALL::DISTANCE-ARRAY)
;                           (LOOP FLOYD-WARSHALL::WITH
;                                 FLOYD-WARSHALL::ARR
;                                 =
;                                 FLOYD-WARSHALL::ARR1
;                                 FLOYD-WARSHALL::WITH
;                                 FLOYD-WARSHALL::ARR-PRIME
;                                 =
;                                 FLOYD-WARSHALL::ARR2
;                                 FLOYD-WARSHALL::FOR
;                                 FLOYD-WARSHALL::K
;                                 FLOYD-WARSHALL::FROM
;                                 ...))))
;     FLOYD-WARSHALL::OBJ)
; 
; note: deleting unreachable code

;     (COPY-LIST FLOYD-WARSHALL::ROOTS)
; ==>
;   FLOYD-WARSHALL::ROOTS
; 
; note: deleting unreachable code

;     (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
; ==>
;   FLOYD-WARSHALL::TEST
; 
; note: deleting unreachable code

;     (POP OPEN)
; --> LET* 
; ==>
;   OPEN
; 
; note: deleting unreachable code

;     (GETHASH FLOYD-WARSHALL::NODE FLOYD-WARSHALL::VISITED-HASH)
; --> SB-IMPL::GETHASH2 
; ==>
;   FLOYD-WARSHALL::NODE
; 
; note: deleting unreachable code

;     (SETF (GETHASH FLOYD-WARSHALL::NODE FLOYD-WARSHALL::VISITED-HASH) T)
; --> LET* 
; ==>
;   FLOYD-WARSHALL::NODE
; 
; note: deleting unreachable code

; ==>
;   FLOYD-WARSHALL::VISITED-HASH
; 
; note: deleting unreachable code

;     (SETF (GETHASH FLOYD-WARSHALL::NODE FLOYD-WARSHALL::NODE-HASH)
;           FLOYD-WARSHALL::INDEX)
; --> LET* 
; ==>
;   FLOYD-WARSHALL::NODE
; 
; note: deleting unreachable code

; --> LET* MULTIPLE-VALUE-BIND LET 
; ==>
;   FLOYD-WARSHALL::INDEX
; 
; note: deleting unreachable code

;     (INCF FLOYD-WARSHALL::INDEX)
; --> LET* + 
; ==>
;   FLOYD-WARSHALL::INDEX
; 
; note: deleting unreachable code

;     (FUNCALL FLOYD-WARSHALL::CHILDREN-FUNCTION FLOYD-WARSHALL::NODE)
; ==>
;   FLOYD-WARSHALL::CHILDREN-FUNCTION
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::WITH
;         OPEN
;         =
;         (COPY-LIST FLOYD-WARSHALL::ROOTS)
;         FLOYD-WARSHALL::WITH
;         FLOYD-WARSHALL::VISITED-HASH
;         =
;         (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;         FLOYD-WARSHALL::WITH
;         FLOYD-WARSHALL::INDEX
;         =
;         ...)
; --> BLOCK LET LET LET LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT 
; --> IF 
; ==>
;   OPEN
; 
; note: deleting unreachable code

;     (RETURN FLOYD-WARSHALL::INDEX)
; --> RETURN-FROM 
; ==>
;   FLOYD-WARSHALL::INDEX
; 
; note: deleting unreachable code

;     (>= FLOYD-WARSHALL::VERBOSE 1)
; --> IF < 
; ==>
;   FLOYD-WARSHALL::VERBOSE
; 
; note: deleting unreachable code

;     (LET ((FLOYD-WARSHALL::ARR1
;          (MAKE-ARRAY (LIST FLOYD-WARSHALL::N FLOYD-WARSHALL::N)
;                      :INITIAL-ELEMENT
;                      NIL
;                      :ELEMENT-TYPE
;                      '(OR NULL NUMBER)))
;         (FLOYD-WARSHALL::ARR2
;          (MAKE-ARRAY (LIST FLOYD-WARSHALL::N FLOYD-WARSHALL::N)
;                      :INITIAL-ELEMENT
;                      NIL
;                      :ELEMENT-TYPE
;                      '(OR NULL NUMBER))))
;     (LOOP FLOYD-WARSHALL::WITH
;           OPEN
;           =
;           (COPY-LIST FLOYD-WARSHALL::ROOTS)
;           FLOYD-WARSHALL::WITH
;           FLOYD-WARSHALL::VISITED-HASH
;           =
;           (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;           FLOYD-WARSHALL::WITH
;           FLOYD-WARSHALL::CHILDREN
;           AND
;           ...)
;     (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;       (FORMAT *DEBUG-IO* "~&Initial connection table is built.~%"))
;     (LOOP FLOYD-WARSHALL::FOR
;           FLOYD-WARSHALL::I
;           FLOYD-WARSHALL::FROM
;           0
;           FLOYD-WARSHALL::BELOW
;           FLOYD-WARSHALL::N
;           DO
;           (SETF (AREF FLOYD-WARSHALL::ARR1 FLOYD-WARSHALL::I FLOYD-WARSHALL::I)
;                   0))
;     (SETF (SLOT-VALUE FLOYD-WARSHALL::OBJ 'FLOYD-WARSHALL::DISTANCE-ARRAY)
;             (LOOP FLOYD-WARSHALL::WITH
;                   FLOYD-WARSHALL::ARR
;                   =
;                   FLOYD-WARSHALL::ARR1
;                   FLOYD-WARSHALL::WITH
;                   FLOYD-WARSHALL::ARR-PRIME
;                   =
;                   FLOYD-WARSHALL::ARR2
;                   FLOYD-WARSHALL::FOR
;                   FLOYD-WARSHALL::K
;                   FLOYD-WARSHALL::FROM
;                   ...)))
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (COPY-LIST FLOYD-WARSHALL::ROOTS)
; ==>
;   FLOYD-WARSHALL::ROOTS
; 
; note: deleting unreachable code

;     (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
; ==>
;   FLOYD-WARSHALL::TEST
; 
; note: deleting unreachable code

;     (SETF (GETHASH FLOYD-WARSHALL::NODE FLOYD-WARSHALL::VISITED-HASH) T)
; --> LET* 
; ==>
;   FLOYD-WARSHALL::NODE
; 
; note: deleting unreachable code

; ==>
;   FLOYD-WARSHALL::VISITED-HASH
; 
; note: deleting unreachable code

;     (FUNCALL FLOYD-WARSHALL::CHILDREN-FUNCTION FLOYD-WARSHALL::NODE)
; ==>
;   FLOYD-WARSHALL::CHILDREN-FUNCTION
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::CHILD
;         FLOYD-WARSHALL::IN
;         FLOYD-WARSHALL::CHILDREN
;         FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::WEIGHT
;         FLOYD-WARSHALL::IN
;         FLOYD-WARSHALL::COSTS
;         FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::CHILD-INDEX
;         =
;         ...)
; --> BLOCK LET 
; ==>
;   FLOYD-WARSHALL::CHILDREN
; 
; note: deleting unreachable code

; --> BLOCK LET LET 
; ==>
;   FLOYD-WARSHALL::COSTS
; 
; note: deleting unreachable code

;     (GETHASH FLOYD-WARSHALL::CHILD FLOYD-WARSHALL::NODE-HASH)
; --> SB-IMPL::GETHASH2 
; ==>
;   FLOYD-WARSHALL::CHILD
; 
; note: deleting unreachable code

;     (SETF (AREF FLOYD-WARSHALL::ARR1
;               FLOYD-WARSHALL::INDEX
;               FLOYD-WARSHALL::CHILD-INDEX)
;           FLOYD-WARSHALL::WEIGHT)
; --> SB-KERNEL:%ASET 
; ==>
;   FLOYD-WARSHALL::ARR1
; 
; note: deleting unreachable code

;     (APPEND OPEN FLOYD-WARSHALL::CHILDREN)
; ==>
;   OPEN
; 
; note: deleting unreachable code

;     (POP OPEN)
; --> LET* 
; ==>
;   OPEN
; 
; note: deleting unreachable code

;     (GETHASH FLOYD-WARSHALL::NODE FLOYD-WARSHALL::NODE-HASH)
; --> SB-IMPL::GETHASH2 
; ==>
;   FLOYD-WARSHALL::NODE
; 
; note: deleting unreachable code

;     (GETHASH FLOYD-WARSHALL::NODE FLOYD-WARSHALL::VISITED-HASH)
; --> SB-IMPL::GETHASH2 
; ==>
;   FLOYD-WARSHALL::NODE
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::WITH
;         OPEN
;         =
;         (COPY-LIST FLOYD-WARSHALL::ROOTS)
;         FLOYD-WARSHALL::WITH
;         FLOYD-WARSHALL::VISITED-HASH
;         =
;         (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;         FLOYD-WARSHALL::WITH
;         FLOYD-WARSHALL::CHILDREN
;         AND
;         ...)
; --> BLOCK LET LET LET LET LET SB-LOOP::LOOP-BODY TAGBODY UNLESS COND IF NOT 
; --> IF 
; ==>
;   OPEN
; 
; note: deleting unreachable code

;     (>= FLOYD-WARSHALL::VERBOSE 1)
; --> IF < 
; ==>
;   FLOYD-WARSHALL::VERBOSE
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::I
;         FLOYD-WARSHALL::FROM
;         0
;         FLOYD-WARSHALL::BELOW
;         FLOYD-WARSHALL::N
;         DO
;         (SETF (AREF FLOYD-WARSHALL::ARR1 FLOYD-WARSHALL::I FLOYD-WARSHALL::I)
;                 0))
; --> BLOCK LET 
; ==>
;   FLOYD-WARSHALL::N
; 
; note: deleting unreachable code

;     (SETF (AREF FLOYD-WARSHALL::ARR1 FLOYD-WARSHALL::I FLOYD-WARSHALL::I) 0)
; --> SB-KERNEL:%ASET 
; ==>
;   FLOYD-WARSHALL::ARR1
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::I
;         FLOYD-WARSHALL::FROM
;         0
;         FLOYD-WARSHALL::BELOW
;         FLOYD-WARSHALL::N
;         DO
;         (SETF (AREF FLOYD-WARSHALL::ARR1 FLOYD-WARSHALL::I FLOYD-WARSHALL::I)
;                 0))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF < 
; ==>
;   FLOYD-WARSHALL::I
; 
; note: deleting unreachable code

;     (SETF (SLOT-VALUE FLOYD-WARSHALL::OBJ 'FLOYD-WARSHALL::DISTANCE-ARRAY)
;           (LOOP FLOYD-WARSHALL::WITH
;                 FLOYD-WARSHALL::ARR
;                 =
;                 FLOYD-WARSHALL::ARR1
;                 FLOYD-WARSHALL::WITH
;                 FLOYD-WARSHALL::ARR-PRIME
;                 =
;                 FLOYD-WARSHALL::ARR2
;                 FLOYD-WARSHALL::FOR
;                 FLOYD-WARSHALL::K
;                 FLOYD-WARSHALL::FROM
;                 ...))
; --> SB-PCL::SET-SLOT-VALUE SB-PCL::ACCESSOR-SET-SLOT-VALUE LET 
; ==>
;   FLOYD-WARSHALL::OBJ
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::WITH
;         FLOYD-WARSHALL::ARR
;         =
;         FLOYD-WARSHALL::ARR1
;         FLOYD-WARSHALL::WITH
;         FLOYD-WARSHALL::ARR-PRIME
;         =
;         FLOYD-WARSHALL::ARR2
;         FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::K
;         FLOYD-WARSHALL::FROM
;         ...)
; --> BLOCK LET 
; ==>
;   FLOYD-WARSHALL::ARR1
; 
; note: deleting unreachable code

; --> BLOCK LET LET 
; ==>
;   FLOYD-WARSHALL::ARR2
; 
; note: deleting unreachable code

; --> BLOCK LET LET LET 
; ==>
;   FLOYD-WARSHALL::N
; 
; note: deleting unreachable code

; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ 
; --> SETQ THE 1+ + 
; ==>
;   FLOYD-WARSHALL::K
; 
; note: deleting unreachable code

; --> BLOCK LET LET LET SB-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF < 
; ==>
;   FLOYD-WARSHALL::K
; 
; note: deleting unreachable code

;     (>= FLOYD-WARSHALL::VERBOSE 2)
; --> IF < 
; ==>
;   FLOYD-WARSHALL::VERBOSE
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::I
;         FLOYD-WARSHALL::FROM
;         0
;         FLOYD-WARSHALL::BELOW
;         FLOYD-WARSHALL::N
;         DO
;         (LOOP FLOYD-WARSHALL::FOR
;               FLOYD-WARSHALL::J
;               FLOYD-WARSHALL::FROM
;               0
;               FLOYD-WARSHALL::BELOW
;               FLOYD-WARSHALL::N
;               DO
;               (SETF (AREF FLOYD-WARSHALL::ARR-PRIME
;                           FLOYD-WARSHALL::I
;                           FLOYD-WARSHALL::J)
;                       (FLOYD-WARSHALL::EMIN
;                        (AREF FLOYD-WARSHALL::ARR
;                              FLOYD-WARSHALL::I
;                              FLOYD-WARSHALL::J)
;                        (FLOYD-WARSHALL::EPLUS # #)))))
; --> BLOCK LET 
; ==>
;   FLOYD-WARSHALL::N
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::J
;         FLOYD-WARSHALL::FROM
;         0
;         FLOYD-WARSHALL::BELOW
;         FLOYD-WARSHALL::N
;         DO
;         (SETF (AREF FLOYD-WARSHALL::ARR-PRIME
;                     FLOYD-WARSHALL::I
;                     FLOYD-WARSHALL::J)
;                 (FLOYD-WARSHALL::EMIN
;                  (AREF FLOYD-WARSHALL::ARR FLOYD-WARSHALL::I FLOYD-WARSHALL::J)
;                  (FLOYD-WARSHALL::EPLUS
;                   (AREF FLOYD-WARSHALL::ARR
;                         FLOYD-WARSHALL::I
;                         FLOYD-WARSHALL::K)
;                   (AREF FLOYD-WARSHALL::ARR
;                         FLOYD-WARSHALL::K
;                         FLOYD-WARSHALL::J)))))
; --> BLOCK LET 
; ==>
;   FLOYD-WARSHALL::N
; 
; note: deleting unreachable code

;     (SETF (AREF FLOYD-WARSHALL::ARR-PRIME FLOYD-WARSHALL::I FLOYD-WARSHALL::J)
;           (FLOYD-WARSHALL::EMIN
;            (AREF FLOYD-WARSHALL::ARR FLOYD-WARSHALL::I FLOYD-WARSHALL::J)
;            (FLOYD-WARSHALL::EPLUS
;             (AREF FLOYD-WARSHALL::ARR FLOYD-WARSHALL::I FLOYD-WARSHALL::K)
;             (AREF FLOYD-WARSHALL::ARR FLOYD-WARSHALL::K FLOYD-WARSHALL::J))))
; --> SB-KERNEL:%ASET 
; ==>
;   FLOYD-WARSHALL::ARR-PRIME
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::J
;         FLOYD-WARSHALL::FROM
;         0
;         FLOYD-WARSHALL::BELOW
;         FLOYD-WARSHALL::N
;         DO
;         (SETF (AREF FLOYD-WARSHALL::ARR-PRIME
;                     FLOYD-WARSHALL::I
;                     FLOYD-WARSHALL::J)
;                 (FLOYD-WARSHALL::EMIN
;                  (AREF FLOYD-WARSHALL::ARR FLOYD-WARSHALL::I FLOYD-WARSHALL::J)
;                  (FLOYD-WARSHALL::EPLUS
;                   (AREF FLOYD-WARSHALL::ARR
;                         FLOYD-WARSHALL::I
;                         FLOYD-WARSHALL::K)
;                   (AREF FLOYD-WARSHALL::ARR
;                         FLOYD-WARSHALL::K
;                         FLOYD-WARSHALL::J)))))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF < 
; ==>
;   FLOYD-WARSHALL::J
; 
; note: deleting unreachable code

;     (LOOP FLOYD-WARSHALL::FOR
;         FLOYD-WARSHALL::I
;         FLOYD-WARSHALL::FROM
;         0
;         FLOYD-WARSHALL::BELOW
;         FLOYD-WARSHALL::N
;         DO
;         (LOOP FLOYD-WARSHALL::FOR
;               FLOYD-WARSHALL::J
;               FLOYD-WARSHALL::FROM
;               0
;               FLOYD-WARSHALL::BELOW
;               FLOYD-WARSHALL::N
;               DO
;               (SETF (AREF FLOYD-WARSHALL::ARR-PRIME
;                           FLOYD-WARSHALL::I
;                           FLOYD-WARSHALL::J)
;                       (FLOYD-WARSHALL::EMIN
;                        (AREF FLOYD-WARSHALL::ARR
;                              FLOYD-WARSHALL::I
;                              FLOYD-WARSHALL::J)
;                        (FLOYD-WARSHALL::EPLUS # #)))))
; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY SB-LOOP::LOOP-REALLY-DESETQ SETQ THE 
; --> 1+ + 
; ==>
;   FLOYD-WARSHALL::I
; 
; note: deleting unreachable code

; --> BLOCK LET SB-LOOP::LOOP-BODY TAGBODY WHEN COND IF >= IF < 
; ==>
;   FLOYD-WARSHALL::I
; 
; note: deleting unreachable code

;     (ROTATEF FLOYD-WARSHALL::ARR FLOYD-WARSHALL::ARR-PRIME)
; --> LET* MULTIPLE-VALUE-BIND LET 
; ==>
;   FLOYD-WARSHALL::ARR-PRIME
; 
; note: deleting unreachable code

; --> LET* MULTIPLE-VALUE-BIND LET MULTIPLE-VALUE-BIND LET 
; ==>
;   FLOYD-WARSHALL::ARR
; 
; note: deleting unreachable code

;     (MAKE-INSTANCE 'FLOYD-WARSHALL::FW-GRAPH :TEST FLOYD-WARSHALL::TEST)
; --> LOCALLY LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SB-PCL::CTOR FLOYD-WARSHALL::FW-GRAPH :TEST SB-PCL::|.P0.|) :TYPE #<SB-KERNEL:BUILT-IN-CLASSOID FUNCTION (read-only)> :WHERE-FROM :DEFINED :KIND :GLOBAL-FUNCTION {400DF6D9}> 
; ==>
;   FLOYD-WARSHALL::TEST
; 
; note: deleting unreachable code

;     (LET ((FLOYD-WARSHALL::OBJ
;          (MAKE-INSTANCE 'FLOYD-WARSHALL::FW-GRAPH :TEST FLOYD-WARSHALL::TEST))
;         FLOYD-WARSHALL::N)
;     (WITH-SLOTS (FLOYD-WARSHALL::NODE-HASH)
;                 FLOYD-WARSHALL::OBJ
;                 (SETF FLOYD-WARSHALL::N
;                         (LOOP FLOYD-WARSHALL::WITH
;                               OPEN
;                               =
;                               (COPY-LIST FLOYD-WARSHALL::ROOTS)
;                               FLOYD-WARSHALL::WITH
;                               FLOYD-WARSHALL::VISITED-HASH
;                               =
;                               (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;                               FLOYD-WARSHALL::WITH
;                               FLOYD-WARSHALL::INDEX
;                               =
;                               ...))
;                 (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;                   (FORMAT *DEBUG-IO* "~&Index table is built.~%"))
;                 (LET ((FLOYD-WARSHALL::ARR1 #) (FLOYD-WARSHALL::ARR2 #))
;                   (LOOP FLOYD-WARSHALL::WITH
;                         OPEN
;                         =
;                         (COPY-LIST FLOYD-WARSHALL::ROOTS)
;                         FLOYD-WARSHALL::WITH
;                         FLOYD-WARSHALL::VISITED-HASH
;                         =
;                         (MAKE-HASH-TABLE :TEST FLOYD-WARSHALL::TEST)
;                         FLOYD-WARSHALL::WITH
;                         FLOYD-WARSHALL::CHILDREN
;                         AND
;                         ...)
;                   (WHEN (>= FLOYD-WARSHALL::VERBOSE 1)
;                     (FORMAT *DEBUG-IO*
;                             "~&Initial connection table is built.~%"))
;                   (LOOP FLOYD-WARSHALL::FOR
;                         FLOYD-WARSHALL::I
;                         FLOYD-WARSHALL::FROM
;                         0
;                         FLOYD-WARSHALL::BELOW
;                         FLOYD-WARSHALL::N
;                         DO
;                         (SETF # 0))
;                   (SETF (SLOT-VALUE FLOYD-WARSHALL::OBJ
;                                     'FLOYD-WARSHALL::DISTANCE-ARRAY)
;                           (LOOP FLOYD-WARSHALL::WITH
;                                 FLOYD-WARSHALL::ARR
;                                 =
;                                 FLOYD-WARSHALL::ARR1
;                                 FLOYD-WARSHALL::WITH
;                                 FLOYD-WARSHALL::ARR-PRIME
;                                 =
;                                 FLOYD-WARSHALL::ARR2
;                                 FLOYD-WARSHALL::FOR
;                                 FLOYD-WARSHALL::K
;                                 FLOYD-WARSHALL::FROM
;                                 ...))))
;     FLOYD-WARSHALL::OBJ)
; 
; note: deleting unreachable code

; compiling (DEFUN EMIN ...)
; compiling (DEFUN EPLUS ...)
; compiling (DEFINE-CONDITION UNREACHABLE ...)
; compiling (DEFMETHOD NODE-INDEX ...)
; compiling (DEFMETHOD RAW-SHORTEST-PATH ...)
; compiling (DEFMETHOD SHORTEST-PATH ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/floyd-warshall_0.01/shortest-path.fasl written
; compilation finished in 0:00:01
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {40006FE1}> on
   #<CL-SOURCE-FILE "shortest-path" {40006FF1}>.
; 
; compilation unit aborted
;   caught 1 fatal ERROR condition
;   caught 8 ERROR conditions
;   printed 70 notes
erred while invoking #<COMPILE-OP NIL {40006FE1}> on
#<CL-SOURCE-FILE "shortest-path" {40006FF1}>