diff --git a/debug/compilation/nqueens-chicken-clo.scm b/debug/compilation/nqueens-chicken-clo.scm new file mode 100644 index 00000000..7f6b9ceb --- /dev/null +++ b/debug/compilation/nqueens-chicken-clo.scm @@ -0,0 +1,192 @@ +[closure-converted] +(##core#closure + (2) + (lambda (c224 k28) + (let ((k29 (##core#closure + (2) + (##core#lambda + (c226 r30) + (let ((k32 (##core#closure + (2) + (##core#lambda + (c228 r33) + (let ((t35 (set! nqueens + (##core#closure + (2) + (lambda (c230 k37 n1) + (let ((try3231 (##core#undefined))) + (let ((try3 (##core#box try3231))) + (let ((ok?4232 (##core#undefined))) + (let ((ok?4 (##core#box ok?4232))) + (let ((t64 (##core#updatebox + try3 + (##core#closure + (4) + (lambda (c234 k66 x10 y11 z12) + (if (##core#inline "C_i_nullp" x10) + (let ((r77 (##core#inline "C_i_nullp" y11))) + (k66 (##core#cond r77 '1 '0))) + (let ((k83 (##core#closure + (6) + (##core#lambda + (c237 r84) + (let ((k87 (##core#closure + (3) + (##core#lambda + (c239 r88) + ((##core#ref c239 (2)) + (##core#inline_allocate + ("C_a_i_plus" 4) + (##core#ref c239 (1)) + r88))) + r84 + (##core#ref c237 (5))))) + (let ((r92 (##core#inline "C_i_cdr" (##core#ref c237 (4))))) + (let ((r100 (##core#inline "C_i_car" (##core#ref c237 (4))))) + (let ((r96 (##core#inline_allocate + ("C_a_i_cons" 3) + r100 + (##core#ref c237 (3))))) + ((##core#unbox (##core#ref c237 (2)) ()) + k87 + r92 + r96 + (##core#ref c237 (1)))))))) + z12 + (##core#ref c234 (2)) + y11 + x10 + k66))) + (let ((k102 (##core#closure + (6) + (##core#lambda + (c244 r103) + (if r103 + (let ((k109 (##core#closure + (5) + (##core#lambda + (c246 r110) + (let ((r118 (##core#inline "C_i_car" (##core#ref c246 (4))))) + (let ((r114 (##core#inline_allocate + ("C_a_i_cons" 3) + r118 + (##core#ref c246 (3))))) + ((##core#unbox (##core#ref c246 (2)) ()) + (##core#ref c246 (1)) + r110 + '() + r114)))) + (##core#ref c244 (2)) + (##core#ref c244 (3)) + (##core#ref c244 (4)) + (##core#ref c244 (5))))) + (let ((r122 (##core#inline "C_i_cdr" (##core#ref c244 (5))))) + (append k109 r122 (##core#ref c244 (1))))) + ((##core#ref c244 (2)) '0))) + y11 + k83 + (##core#ref c234 (2)) + z12 + x10))) + (let ((r126 (##core#inline "C_i_car" x10))) + ((##core#unbox (##core#ref c234 (1)) ()) + k102 + r126 + '1 + z12)))))) + ok?4 + try3 + '#)))) + (let ((t128 (##core#updatebox + ok?4 + (##core#closure + (3) + (lambda (c252 k130 row13 dist14 placed15) + (if (##core#inline "C_i_nullp" placed15) + (k130 '#t) + (let ((r178 (##core#inline "C_i_car" placed15))) + (let ((r182 (##core#inline_allocate + ("C_a_i_plus" 4) + row13 + dist14))) + (if (##core#inline "C_i_nequalp" r178 r182) + (k130 '#f) + (let ((r166 (##core#inline "C_i_car" placed15))) + (let ((r170 (##core#inline_allocate + ("C_a_i_minus" 4) + row13 + dist14))) + (if (##core#inline "C_i_nequalp" r166 r170) + (k130 '#f) + (let ((r154 (##core#inline_allocate + ("C_a_i_plus" 4) + dist14 + '1))) + (let ((r158 (##core#inline "C_i_cdr" placed15))) + ((##core#unbox (##core#ref c252 (1)) ()) + k130 + row13 + r154 + r158))))))))))) + ok?4 + '#)))) + (let ((k188 (##core#closure + (3) + (##core#lambda + (c260 r189) + ((##core#unbox (##core#ref c260 (2)) ()) + (##core#ref c260 (1)) + r189 + '() + '())) + k37 + try3))) + (let ((loop6261 (##core#undefined))) + (let ((loop6 (##core#box loop6261))) + (let ((t44 (##core#updatebox + loop6 + (##core#closure + (3) + (lambda (c263 k46 i7 l8) + (if (##core#inline "C_i_nequalp" i7 '0) + (k46 l8) + (let ((r58 (##core#inline_allocate ("C_a_i_minus" 4) i7 '1))) + (let ((r62 (##core#inline_allocate ("C_a_i_cons" 3) i7 l8))) + ((##core#unbox (##core#ref c263 (1)) ()) + k46 + r58 + r62))))) + loop6 + '#)))) + ((##core#unbox loop6 ()) k188 n1 '())))))))))))) + '#)))) + (let ((k191 (##core#closure + (2) + (##core#lambda + (c267 r192) + (let ((k194 (##core#closure + (2) + (##core#lambda + (c269 r195) + ((##core#ref c269 (1)) (##core#undefined))) + (##core#ref c267 (1))))) + (let ((k197 (##core#closure + (2) + (##core#lambda + (c271 r198) + (r198 (##core#ref c271 (1)))) + k194))) + (##sys#implicit-exit-handler k197)))) + (##core#ref c228 (1))))) + (let ((k201 (##core#closure + (2) + (##core#lambda + (c273 r202) + (write (##core#ref c273 (1)) r202)) + k191))) + (nqueens k201 '8))))) + (##core#ref c226 (1))))) + (##core#callunit "eval" k32))) + k28))) + (##core#callunit "library" k29))) + '#) diff --git a/debug/compilation/nqueens-chicken-cps-after-opt.scm b/debug/compilation/nqueens-chicken-cps-after-opt.scm new file mode 100644 index 00000000..0a931efe --- /dev/null +++ b/debug/compilation/nqueens-chicken-cps-after-opt.scm @@ -0,0 +1,86 @@ +[optimized] +(lambda (k28) + (let ((k29 (##core#lambda + (r30) + (let ((k32 (##core#lambda + (r33) + (let ((t35 (set! nqueens + (lambda (k37 n1) + (let ((try3 (##core#undefined))) + (let ((ok?4 (##core#undefined))) + (let ((t64 (set! try3 + (lambda (k66 x10 y11 z12) + (if (##core#inline "C_i_nullp" x10) + (let ((r77 (##core#inline "C_i_nullp" y11))) + (k66 (##core#cond r77 '1 '0))) + (let ((k83 (##core#lambda + (r84) + (let ((k87 (##core#lambda + (r88) + (k66 (##core#inline_allocate ("C_a_i_plus" 4) r84 r88))))) + (let ((r92 (##core#inline "C_i_cdr" x10))) + (let ((r100 (##core#inline "C_i_car" x10))) + (let ((r96 (##core#inline_allocate + ("C_a_i_cons" 3) + r100 + y11))) + (try3 k87 r92 r96 z12)))))))) + (let ((k102 (##core#lambda + (r103) + (if r103 + (let ((k109 (##core#lambda + (r110) + (let ((r118 (##core#inline "C_i_car" x10))) + (let ((r114 (##core#inline_allocate + ("C_a_i_cons" 3) + r118 + z12))) + (try3 k83 r110 '() r114)))))) + (let ((r122 (##core#inline "C_i_cdr" x10))) + (append k109 r122 y11))) + (k83 '0))))) + (let ((r126 (##core#inline "C_i_car" x10))) + (ok?4 k102 r126 '1 z12))))))))) + (let ((t128 (set! ok?4 + (lambda (k130 row13 dist14 placed15) + (if (##core#inline "C_i_nullp" placed15) + (k130 '#t) + (let ((r178 (##core#inline "C_i_car" placed15))) + (let ((r182 (##core#inline_allocate + ("C_a_i_plus" 4) + row13 + dist14))) + (if (##core#inline "C_i_nequalp" r178 r182) + (k130 '#f) + (let ((r166 (##core#inline "C_i_car" placed15))) + (let ((r170 (##core#inline_allocate + ("C_a_i_minus" 4) + row13 + dist14))) + (if (##core#inline "C_i_nequalp" r166 r170) + (k130 '#f) + (let ((r154 (##core#inline_allocate + ("C_a_i_plus" 4) + dist14 + '1))) + (let ((r158 (##core#inline "C_i_cdr" placed15))) + (ok?4 k130 row13 r154 r158)))))))))))))) + (let ((k188 (##core#lambda (r189) (try3 k37 r189 '() '())))) + (let ((loop6 (##core#undefined))) + (let ((t44 (set! loop6 + (lambda (k46 i7 l8) + (if (##core#inline "C_i_nequalp" i7 '0) + (k46 l8) + (let ((r58 (##core#inline_allocate ("C_a_i_minus" 4) i7 '1))) + (let ((r62 (##core#inline_allocate ("C_a_i_cons" 3) i7 l8))) + (loop6 k46 r58 r62)))))))) + (loop6 k188 n1 '())))))))))))) + (let ((k191 (##core#lambda + (r192) + (let ((k194 (##core#lambda (r195) (k28 (##core#undefined))))) + (let ((k197 (##core#lambda (r198) (r198 k194)))) + (##sys#implicit-exit-handler k197)))))) + (let ((k201 (##core#lambda (r202) (write k191 r202)))) + (nqueens k201 '8))))))) + (##core#callunit "eval" k32))))) + (##core#callunit "library" k29))) diff --git a/debug/compilation/nqueens-chicken-cps.scm b/debug/compilation/nqueens-chicken-cps.scm new file mode 100644 index 00000000..f073313c --- /dev/null +++ b/debug/compilation/nqueens-chicken-cps.scm @@ -0,0 +1,158 @@ +[cps] +(lambda (k28) + (let ((k29 (##core#lambda + (r30) + (let ((t22 r30)) + (let ((k32 (##core#lambda + (r33) + (let ((t23 r33)) + (let ((t35 (set! nqueens + (lambda (k37 n1) + (let ((dec-to2 (##core#undefined))) + (let ((try3 (##core#undefined))) + (let ((ok?4 (##core#undefined))) + (let ((t38 (set! dec-to2 + (lambda (k40 n5) + (let ((k41 (##core#lambda (r42) (k40 r42)))) + (let ((loop6 (##core#undefined))) + (let ((t44 (set! loop6 + (lambda (k46 i7 l8) + (let ((k47 (##core#lambda (r48) (k46 r48)))) + (let ((k50 (##core#lambda + (r51) + (if r51 + (k47 l8) + (let ((k53 (##core#lambda (r54) (k47 r54)))) + (let ((k57 (##core#lambda + (r58) + (let ((a56 r58)) + (let ((k61 (##core#lambda + (r62) + (let ((a60 r62)) (loop6 k53 a56 a60))))) + (cons k61 i7 l8)))))) + (- k57 i7 '1))))))) + (= k50 i7 '0))))))) + (let ((t9 t44)) (loop6 k41 n5 '()))))))))) + (let ((t18 t38)) + (let ((t64 (set! try3 + (lambda (k66 x10 y11 z12) + (let ((k67 (##core#lambda (r68) (k66 r68)))) + (let ((k70 (##core#lambda + (r71) + (if r71 + (let ((k73 (##core#lambda (r74) (k67 r74)))) + (let ((k76 (##core#lambda (r77) (if r77 (k73 '1) (k73 '0))))) + (null? k76 y11))) + (let ((k79 (##core#lambda (r80) (k67 r80)))) + (let ((k83 (##core#lambda + (r84) + (let ((a82 r84)) + (let ((k87 (##core#lambda + (r88) + (let ((a86 r88)) (+ k79 a82 a86))))) + (let ((k91 (##core#lambda + (r92) + (let ((a90 r92)) + (let ((k95 (##core#lambda + (r96) + (let ((a94 r96)) (try3 k87 a90 a94 z12))))) + (let ((k99 (##core#lambda + (r100) + (let ((a98 r100)) (cons k95 a98 y11))))) + (car k99 x10))))))) + (cdr k91 x10))))))) + (let ((k102 (##core#lambda + (r103) + (if r103 + (let ((k105 (##core#lambda (r106) (k83 r106)))) + (let ((k109 (##core#lambda + (r110) + (let ((a108 r110)) + (let ((k113 (##core#lambda + (r114) + (let ((a112 r114)) (try3 k105 a108 '() a112))))) + (let ((k117 (##core#lambda + (r118) + (let ((a116 r118)) (cons k113 a116 z12))))) + (car k117 x10))))))) + (let ((k121 (##core#lambda + (r122) + (let ((a120 r122)) (append k109 a120 y11))))) + (cdr k121 x10)))) + (k83 '0))))) + (let ((k125 (##core#lambda + (r126) + (let ((a124 r126)) (ok?4 k102 a124 '1 z12))))) + (car k125 x10))))))))) + (null? k70 x10))))))) + (let ((t19 t64)) + (let ((t128 (set! ok?4 + (lambda (k130 row13 dist14 placed15) + (let ((k131 (##core#lambda (r132) (k130 r132)))) + (let ((k134 (##core#lambda + (r135) + (if r135 + (k131 '#t) + (let ((k137 (##core#lambda (r138) (k131 r138)))) + (let ((k140 (##core#lambda + (r141) + (if r141 + (let ((k143 (##core#lambda (r144) (k137 r144)))) + (let ((k146 (##core#lambda + (r147) + (if r147 + (let ((k149 (##core#lambda (r150) (k143 r150)))) + (let ((k153 (##core#lambda + (r154) + (let ((a152 r154)) + (let ((k157 (##core#lambda + (r158) + (let ((a156 r158)) (ok?4 k149 row13 a152 a156))))) + (cdr k157 placed15)))))) + (+ k153 dist14 '1))) + (k143 '#f))))) + (let ((k161 (##core#lambda + (r162) + (let ((a160 r162)) (not k146 a160))))) + (let ((k165 (##core#lambda + (r166) + (let ((a164 r166)) + (let ((k169 (##core#lambda + (r170) + (let ((a168 r170)) (= k161 a164 a168))))) + (- k169 row13 dist14)))))) + (car k165 placed15))))) + (k137 '#f))))) + (let ((k173 (##core#lambda + (r174) + (let ((a172 r174)) (not k140 a172))))) + (let ((k177 (##core#lambda + (r178) + (let ((a176 r178)) + (let ((k181 (##core#lambda + (r182) + (let ((a180 r182)) (= k173 a176 a180))))) + (+ k181 row13 dist14)))))) + (car k177 placed15))))))))) + (null? k134 placed15))))))) + (let ((t20 t128)) + (let ((k184 (##core#lambda (r185) (k37 r185)))) + (let ((k188 (##core#lambda + (r189) + (let ((a187 r189)) (try3 k184 a187 '() '()))))) + (dec-to2 k188 n1)))))))))))))))) + (let ((t24 t35)) + (let ((k191 (##core#lambda + (r192) + (let ((t25 r192)) + (let ((k194 (##core#lambda + (r195) + (let ((t26 r195)) (k28 (##core#undefined)))))) + (let ((k197 (##core#lambda (r198) (r198 k194)))) + (##sys#implicit-exit-handler k197))))))) + (let ((k201 (##core#lambda + (r202) + (let ((a200 r202)) (write k191 a200))))) + (nqueens k201 '8))))))))) + (##core#callunit "eval" k32)))))) + (##core#callunit "library" k29))) diff --git a/debug/compilation/nqueens-chicken.scm b/debug/compilation/nqueens-chicken.scm new file mode 100644 index 00000000..748903d8 --- /dev/null +++ b/debug/compilation/nqueens-chicken.scm @@ -0,0 +1,35 @@ +;(cond-expand +; (cyclone +; (import +; (scheme base) +; (scheme write)) +; ) +; (else #f)) + +(define (nqueens n) + + (define (dec-to n) + (let loop ((i n) (l '())) + (if (= i 0) l (loop (- i 1) (cons i l))))) + + (define (try x y z) + (if (null? x) + (if (null? y) + 1 + 0) + (+ (if (ok? (car x) 1 z) + (try (append (cdr x) y) '() (cons (car x) z)) + 0) + (try (cdr x) (cons (car x) y) z)))) + + (define (ok? row dist placed) + (if (null? placed) + #t + (and (not (= (car placed) (+ row dist))) + (not (= (car placed) (- row dist))) + (ok? row (+ dist 1) (cdr placed))))) + + (try (dec-to n) '() '())) + +(write + (nqueens 8)) diff --git a/debug/compilation/nqueens-cyclone-clo.scm b/debug/compilation/nqueens-cyclone-clo.scm new file mode 100644 index 00000000..519b2bb8 --- /dev/null +++ b/debug/compilation/nqueens-cyclone-clo.scm @@ -0,0 +1,483 @@ + +CHICKEN +(c)2008-2011 The Chicken Team +(c)2000-2007 Felix L. Winkelmann +Version 4.7.0 +linux-unix-gnu-x86 [ manyargs dload ptables ] +compiled 2011-10-17 on roseapple (Linux) + +; loading nqueens-cyclone-clo.scm ... +((define nqueens + (lambda (k$30 n$4) + ((%closure + (lambda (self$77 dec-to$10 ok?$9 try$8) + ((%closure + (lambda (self$78 dec-to$10) + ((%closure + (lambda (self$79 ok?$9) + ((%closure + (lambda (self$80 try$8) + ((%closure + (lambda (self$81 dec-to$13 try$12 ok?$11) + ((%closure + (lambda (self$93 r$67) + ((%closure + (lambda (self$94 r$31) + ((%closure + (lambda (self$111 r$50) + ((%closure + (lambda (self$112 r$32) + ((%closure + (lambda (self$125 r$37) + ((%closure + (lambda (self$126 r$33) + ((%closure-ref + (cell-get (%closure-ref self$126 1)) + 0) + (cell-get (%closure-ref self$126 1)) + (%closure + (lambda (self$127 r$34) + ((%closure + (lambda (self$128 r$35) + ((%closure + (lambda (self$129 r$36) + ((%closure-ref + (cell-get (%closure-ref self$129 4)) + 0) + (cell-get (%closure-ref self$129 4)) + (%closure-ref self$129 1) + (%closure-ref self$129 2) + (%closure-ref self$129 3) + r$36)) + (%closure-ref self$128 1) + (%closure-ref self$128 2) + r$35 + (%closure-ref self$128 3)) + '())) + (%closure-ref self$127 1) + r$34 + (%closure-ref self$127 2)) + '())) + (%closure-ref self$126 2) + (%closure-ref self$126 4)) + (%closure-ref self$126 3))) + (%closure-ref self$125 1) + (%closure-ref self$125 2) + (%closure-ref self$125 3) + (%closure-ref self$125 5)) + (set-cell! (%closure-ref self$125 4) r$37))) + (%closure-ref self$112 1) + (%closure-ref self$112 2) + (%closure-ref self$112 3) + (%closure-ref self$112 4) + (%closure-ref self$112 5)) + (%closure + (lambda (self$113 k$38 row$16 dist$15 placed$14) + ((%closure + (lambda (self$114 r$39) + (if r$39 + ((%closure-ref (%closure-ref self$114 2) 0) + (%closure-ref self$114 2) + #t) + ((%closure + (lambda (self$115 r$48) + ((%closure + (lambda (self$116 r$49) + ((%closure + (lambda (self$117 r$47) + ((%closure-ref not 0) + not + (%closure + (lambda (self$118 r$40) + (if r$40 + ((%closure + (lambda (self$119 r$45) + ((%closure + (lambda (self$120 r$46) + ((%closure + (lambda (self$121 r$44) + ((%closure-ref not 0) + not + (%closure + (lambda (self$122 r$41) + (if r$41 + ((%closure + (lambda (self$123 r$42) + ((%closure + (lambda (self$124 r$43) + ((%closure-ref + (cell-get (%closure-ref self$124 2)) + 0) + (cell-get (%closure-ref self$124 2)) + (%closure-ref self$124 1) + (%closure-ref self$124 4) + (%closure-ref self$124 3) + r$43)) + (%closure-ref self$123 1) + (%closure-ref self$123 2) + r$42 + (%closure-ref self$123 4)) + (cdr (%closure-ref self$123 3)))) + (%closure-ref self$122 2) + (%closure-ref self$122 3) + (%closure-ref self$122 4) + (%closure-ref self$122 5)) + (+ (%closure-ref self$122 1) 1)) + ((%closure-ref (%closure-ref self$122 2) 0) + (%closure-ref self$122 2) + #f))) + (%closure-ref self$121 1) + (%closure-ref self$121 2) + (%closure-ref self$121 3) + (%closure-ref self$121 4) + (%closure-ref self$121 5)) + r$44)) + (%closure-ref self$120 1) + (%closure-ref self$120 2) + (%closure-ref self$120 3) + (%closure-ref self$120 4) + (%closure-ref self$120 6)) + (= (%closure-ref self$120 5) r$46))) + (%closure-ref self$119 1) + (%closure-ref self$119 2) + (%closure-ref self$119 3) + (%closure-ref self$119 4) + r$45 + (%closure-ref self$119 5)) + (- (%closure-ref self$119 5) + (%closure-ref self$119 1)))) + (%closure-ref self$118 1) + (%closure-ref self$118 2) + (%closure-ref self$118 3) + (%closure-ref self$118 4) + (%closure-ref self$118 5)) + (car (%closure-ref self$118 4))) + ((%closure-ref (%closure-ref self$118 2) 0) + (%closure-ref self$118 2) + #f))) + (%closure-ref self$117 1) + (%closure-ref self$117 2) + (%closure-ref self$117 3) + (%closure-ref self$117 4) + (%closure-ref self$117 5)) + r$47)) + (%closure-ref self$116 1) + (%closure-ref self$116 2) + (%closure-ref self$116 3) + (%closure-ref self$116 4) + (%closure-ref self$116 6)) + (= (%closure-ref self$116 5) r$49))) + (%closure-ref self$115 1) + (%closure-ref self$115 2) + (%closure-ref self$115 3) + (%closure-ref self$115 4) + r$48 + (%closure-ref self$115 5)) + (+ (%closure-ref self$115 5) + (%closure-ref self$115 1)))) + (%closure-ref self$114 1) + (%closure-ref self$114 2) + (%closure-ref self$114 3) + (%closure-ref self$114 4) + (%closure-ref self$114 5)) + (car (%closure-ref self$114 4))))) + dist$15 + k$38 + (%closure-ref self$113 1) + placed$14 + row$16) + (null? placed$14))) + (%closure-ref self$112 4)))) + (%closure-ref self$111 1) + (%closure-ref self$111 2) + (%closure-ref self$111 3) + (%closure-ref self$111 4) + (%closure-ref self$111 5)) + (set-cell! (%closure-ref self$111 5) r$50))) + (%closure-ref self$94 1) + (%closure-ref self$94 2) + (%closure-ref self$94 3) + (%closure-ref self$94 4) + (%closure-ref self$94 5)) + (%closure + (lambda (self$95 k$51 x$19 y$18 z$17) + ((%closure + (lambda (self$96 r$52) + (if r$52 + ((%closure + (lambda (self$110 r$53) + (if r$53 + ((%closure-ref (%closure-ref self$110 1) 0) + (%closure-ref self$110 1) + 1) + ((%closure-ref (%closure-ref self$110 1) 0) + (%closure-ref self$110 1) + 0))) + (%closure-ref self$96 1)) + (null? (%closure-ref self$96 5))) + ((%closure + (lambda (self$102 k$59) + ((%closure + (lambda (self$103 r$66) + ((%closure-ref + (cell-get (%closure-ref self$103 2)) + 0) + (cell-get (%closure-ref self$103 2)) + (%closure + (lambda (self$104 r$60) + (if r$60 + ((%closure + (lambda (self$105 r$65) + ((%closure-ref append 0) + append + (%closure + (lambda (self$106 r$61) + ((%closure + (lambda (self$107 r$62) + ((%closure + (lambda (self$108 r$64) + ((%closure + (lambda (self$109 r$63) + ((%closure-ref + (cell-get (%closure-ref self$109 4)) + 0) + (cell-get (%closure-ref self$109 4)) + (%closure-ref self$109 1) + (%closure-ref self$109 2) + (%closure-ref self$109 3) + r$63)) + (%closure-ref self$108 1) + (%closure-ref self$108 2) + (%closure-ref self$108 3) + (%closure-ref self$108 4)) + (cons r$64 (%closure-ref self$108 5)))) + (%closure-ref self$107 1) + (%closure-ref self$107 2) + r$62 + (%closure-ref self$107 3) + (%closure-ref self$107 5)) + (car (%closure-ref self$107 4)))) + (%closure-ref self$106 1) + r$61 + (%closure-ref self$106 2) + (%closure-ref self$106 3) + (%closure-ref self$106 4)) + '())) + (%closure-ref self$105 1) + (%closure-ref self$105 2) + (%closure-ref self$105 3) + (%closure-ref self$105 5)) + r$65 + (%closure-ref self$105 4))) + (%closure-ref self$104 1) + (%closure-ref self$104 2) + (%closure-ref self$104 3) + (%closure-ref self$104 4) + (%closure-ref self$104 5)) + (cdr (%closure-ref self$104 3))) + ((%closure-ref (%closure-ref self$104 1) 0) + (%closure-ref self$104 1) + 0))) + (%closure-ref self$103 1) + (%closure-ref self$103 3) + (%closure-ref self$103 4) + (%closure-ref self$103 5) + (%closure-ref self$103 6)) + r$66 + 1 + (%closure-ref self$103 6))) + k$59 + (%closure-ref self$102 1) + (%closure-ref self$102 2) + (%closure-ref self$102 3) + (%closure-ref self$102 4) + (%closure-ref self$102 5)) + (car (%closure-ref self$102 3)))) + (%closure-ref self$96 2) + (%closure-ref self$96 3) + (%closure-ref self$96 4) + (%closure-ref self$96 5) + (%closure-ref self$96 6)) + (%closure + (lambda (self$97 r$54) + ((%closure + (lambda (self$98 r$56) + ((%closure + (lambda (self$99 r$58) + ((%closure + (lambda (self$100 r$57) + ((%closure-ref + (cell-get (%closure-ref self$100 4)) + 0) + (cell-get (%closure-ref self$100 4)) + (%closure + (lambda (self$101 r$55) + ((%closure-ref (%closure-ref self$101 1) 0) + (%closure-ref self$101 1) + (+ (%closure-ref self$101 2) r$55))) + (%closure-ref self$100 1) + (%closure-ref self$100 2)) + (%closure-ref self$100 3) + r$57 + (%closure-ref self$100 5))) + (%closure-ref self$99 1) + (%closure-ref self$99 2) + (%closure-ref self$99 3) + (%closure-ref self$99 4) + (%closure-ref self$99 6)) + (cons r$58 (%closure-ref self$99 5)))) + (%closure-ref self$98 1) + (%closure-ref self$98 2) + r$56 + (%closure-ref self$98 3) + (%closure-ref self$98 5) + (%closure-ref self$98 6)) + (car (%closure-ref self$98 4)))) + (%closure-ref self$97 1) + r$54 + (%closure-ref self$97 2) + (%closure-ref self$97 3) + (%closure-ref self$97 4) + (%closure-ref self$97 5)) + (cdr (%closure-ref self$97 3)))) + (%closure-ref self$96 1) + (%closure-ref self$96 3) + (%closure-ref self$96 4) + (%closure-ref self$96 5) + (%closure-ref self$96 6))))) + k$51 + (%closure-ref self$95 1) + (%closure-ref self$95 2) + x$19 + y$18 + z$17) + (null? x$19))) + (%closure-ref self$94 4) + (%closure-ref self$94 5)))) + (%closure-ref self$93 1) + (%closure-ref self$93 2) + (%closure-ref self$93 3) + (%closure-ref self$93 4) + (%closure-ref self$93 5)) + (set-cell! (%closure-ref self$93 1) r$67))) + (%closure-ref self$81 1) + (%closure-ref self$81 2) + (%closure-ref self$81 3) + (%closure-ref self$81 4) + (%closure-ref self$81 5)) + (%closure + (lambda (self$82 k$68 n$20) + ((%closure + (lambda (self$83 r$69) + ((%closure + (lambda (self$84 i$22 l$21) + ((%closure + (lambda (self$85 loop$23) + ((%closure + (lambda (self$86 loop$23) + ((%closure + (lambda (self$91 r$71) + ((%closure + (lambda (self$92 r$70) + ((%closure-ref + (cell-get (%closure-ref self$92 4)) + 0) + (cell-get (%closure-ref self$92 4)) + (%closure-ref self$92 2) + (%closure-ref self$92 1) + (%closure-ref self$92 3))) + (%closure-ref self$91 1) + (%closure-ref self$91 2) + (%closure-ref self$91 3) + (%closure-ref self$91 4)) + (set-cell! (%closure-ref self$91 4) r$71))) + (%closure-ref self$86 1) + (%closure-ref self$86 2) + (%closure-ref self$86 3) + loop$23) + (%closure + (lambda (self$87 k$72 i$25 l$24) + ((%closure + (lambda (self$88 r$73) + (if r$73 + ((%closure-ref (%closure-ref self$88 2) 0) + (%closure-ref self$88 2) + (%closure-ref self$88 3)) + ((%closure + (lambda (self$89 r$74) + ((%closure + (lambda (self$90 r$75) + ((%closure-ref + (cell-get (%closure-ref self$90 2)) + 0) + (cell-get (%closure-ref self$90 2)) + (%closure-ref self$90 1) + (%closure-ref self$90 3) + r$75)) + (%closure-ref self$89 2) + (%closure-ref self$89 4) + r$74) + (cons (%closure-ref self$89 1) + (%closure-ref self$89 3)))) + (%closure-ref self$88 1) + (%closure-ref self$88 2) + (%closure-ref self$88 3) + (%closure-ref self$88 4)) + (- (%closure-ref self$88 1) 1)))) + i$25 + k$72 + l$24 + (%closure-ref self$87 1)) + (= i$25 0))) + loop$23))) + (%closure-ref self$85 1) + (%closure-ref self$85 2) + (%closure-ref self$85 3)) + (cell loop$23))) + i$22 + (%closure-ref self$84 1) + l$21) + #f)) + (%closure-ref self$83 1)) + (%closure-ref self$83 2) + r$69)) + k$68 + n$20) + '()))))) + (%closure-ref self$80 1) + (%closure-ref self$80 2) + (%closure-ref self$80 3) + (%closure-ref self$80 4) + try$8) + #f + #f + #f)) + (%closure-ref self$79 1) + (%closure-ref self$79 2) + (%closure-ref self$79 3) + ok?$9) + (cell (%closure-ref self$79 4)))) + dec-to$10 + (%closure-ref self$78 1) + (%closure-ref self$78 2) + (%closure-ref self$78 4)) + (cell (%closure-ref self$78 3)))) + (%closure-ref self$77 1) + (%closure-ref self$77 2) + ok?$9 + try$8) + (cell dec-to$10))) + k$30 + n$4) + #f + #f + #f))) + ((lambda () + ((lambda (r$26) + ((%closure-ref nqueens 0) + nqueens + (%closure + (lambda (self$76 r$27) ((%closure-ref write 0) write %halt r$27))) + 8)) + 0)))) +#;1> diff --git a/debug/compilation/nqueens-cyclone-cps.scm b/debug/compilation/nqueens-cyclone-cps.scm new file mode 100644 index 00000000..5dc3f848 --- /dev/null +++ b/debug/compilation/nqueens-cyclone-cps.scm @@ -0,0 +1,115 @@ +; loading nqueens-cyclone-cps.scm ... +((define nqueens + (lambda (k$30 n$4) + ((lambda (dec-to$10 ok?$9 try$8) + ((lambda (dec-to$13 try$12 ok?$11) + ((lambda (r$67) + ((lambda (r$31) + ((lambda (r$50) + ((lambda (r$32) + ((lambda (r$37) + ((lambda (r$33) + (dec-to$10 + (lambda (r$34) + ((lambda (r$35) + ((lambda (r$36) (try$8 k$30 r$34 r$35 r$36)) '())) + '())) + n$4)) + (set! ok?$9 r$37))) + (lambda (k$38 row$16 dist$15 placed$14) + ((lambda (r$39) + (if r$39 + (k$38 #t) + ((lambda (r$48) + ((lambda (r$49) + ((lambda (r$47) + (not (lambda (r$40) + (if r$40 + ((lambda (r$45) + ((lambda (r$46) + ((lambda (r$44) + (not (lambda (r$41) + (if r$41 + ((lambda (r$42) + ((lambda (r$43) (ok?$9 k$38 row$16 r$42 r$43)) + (cdr placed$14))) + (+ dist$15 1)) + (k$38 #f))) + r$44)) + (= r$45 r$46))) + (- row$16 dist$15))) + (car placed$14)) + (k$38 #f))) + r$47)) + (= r$48 r$49))) + (+ row$16 dist$15))) + (car placed$14)))) + (null? placed$14))))) + (set! try$8 r$50))) + (lambda (k$51 x$19 y$18 z$17) + ((lambda (r$52) + (if r$52 + ((lambda (r$53) (if r$53 (k$51 1) (k$51 0))) + (null? y$18)) + ((lambda (k$59) + ((lambda (r$66) + (ok?$9 (lambda (r$60) + (if r$60 + ((lambda (r$65) + (append + (lambda (r$61) + ((lambda (r$62) + ((lambda (r$64) + ((lambda (r$63) (try$8 k$59 r$61 r$62 r$63)) + (cons r$64 z$17))) + (car x$19))) + '())) + r$65 + y$18)) + (cdr x$19)) + (k$59 0))) + r$66 + 1 + z$17)) + (car x$19))) + (lambda (r$54) + ((lambda (r$56) + ((lambda (r$58) + ((lambda (r$57) + (try$8 (lambda (r$55) (k$51 (+ r$54 r$55))) + r$56 + r$57 + z$17)) + (cons r$58 y$18))) + (car x$19))) + (cdr x$19)))))) + (null? x$19))))) + (set! dec-to$10 r$67))) + (lambda (k$68 n$20) + ((lambda (r$69) + ((lambda (i$22 l$21) + ((lambda (loop$23) + ((lambda (r$71) + ((lambda (r$70) (loop$23 k$68 i$22 l$21)) + (set! loop$23 r$71))) + (lambda (k$72 i$25 l$24) + ((lambda (r$73) + (if r$73 + (k$72 l$24) + ((lambda (r$74) + ((lambda (r$75) (loop$23 k$72 r$74 r$75)) + (cons i$25 l$24))) + (- i$25 1)))) + (= i$25 0))))) + #f)) + n$20 + r$69)) + '())))) + #f + #f + #f)) + #f + #f + #f))) + ((lambda () + ((lambda (r$26) (nqueens (lambda (r$27) (write %halt r$27)) 8)) 0))))