From 230ca4e2eb92dcfd91bc286311f9094e4633b27f Mon Sep 17 00:00:00 2001 From: Bram Vandenbogaerde Date: Thu, 26 Dec 2024 15:36:24 +0100 Subject: [PATCH] ase: cummulative updates --- analyses/simpleactor/app/ASE/Benchmark.hs | 72 +- .../simpleactor/benchmarks-in/games_snake.rkt | 4 +- .../benchmarks-in/games_tetris.rkt | 14 +- .../benchmarks-out/games_snake.rkt | 5214 +++++++++++- .../benchmarks-out/games_tetris.rkt | 7545 +++++++++++++++-- .../benchmarks-out/games_zombie.rkt | 5458 +++++++++++- .../benchmarks-out/mochi_fold-div.rkt | 3181 ++++++- .../simpleactor/benchmarks-out/mochi_hors.rkt | 3146 ++++++- .../simpleactor/benchmarks-out/mochi_hrec.rkt | 3165 ++++++- .../benchmarks-out/mochi_l-zipunzip.rkt | 3239 ++++++- .../benchmarks-out/mochi_map-foldr.rkt | 3224 ++++++- .../benchmarks-out/mochi_mappend.rkt | 3198 ++++++- .../simpleactor/benchmarks-out/mochi_mem.rkt | 3197 ++++++- .../simpleactor/benchmarks-out/mochi_mult.rkt | 3146 ++++++- .../simpleactor/benchmarks-out/mochi_neg.rkt | 3128 ++++++- .../simpleactor/benchmarks-out/mochi_nth0.rkt | 3126 ++++++- .../benchmarks-out/mochi_r-file.rkt | 3259 ++++++- .../benchmarks-out/mochi_r-lock.rkt | 3127 ++++++- .../benchmarks-out/mochi_reverse.rkt | 3138 ++++++- .../simpleactor/benchmarks-out/mochi_sum.rkt | 3086 ++++++- .../simpleactor/benchmarks-out/mochi_zip.rkt | 3181 ++++++- .../benchmarks-out/sergey_blur.rkt | 3096 ++++++- .../simpleactor/benchmarks-out/sergey_eta.rkt | 3067 ++++++- .../benchmarks-out/sergey_kcfa2.rkt | 3095 ++++++- .../benchmarks-out/sergey_kcfa3.rkt | 3115 ++++++- .../benchmarks-out/sergey_loop2.rkt | 3133 ++++++- .../benchmarks-out/sergey_mj09.rkt | 3080 ++++++- .../simpleactor/benchmarks-out/sergey_sat.rkt | 3239 ++++++- .../benchmarks-out/softy_append.rkt | 3107 ++++++- .../benchmarks-out/softy_cpstak.rkt | 3159 ++++++- .../benchmarks-out/softy_last-pair.rkt | 3084 ++++++- .../simpleactor/benchmarks-out/softy_last.rkt | 3163 ++++++- .../benchmarks-out/softy_length-acc.rkt | 3101 ++++++- .../benchmarks-out/softy_length.rkt | 3092 ++++++- .../benchmarks-out/softy_member.rkt | 3086 ++++++- .../benchmarks-out/softy_recursive-div2.rkt | 3126 ++++++- .../benchmarks-out/softy_subst.rkt | 3061 ++++++- .../simpleactor/benchmarks-out/softy_tak.rkt | 3135 ++++++- .../simpleactor/racket/run/translate-full.rkt | 16 +- .../racket/simpleactor-prelude.scm | 371 +- .../racket/translations/actor-translation.rkt | 39 + .../racket/translations/add-prelude.scm | 10 + .../simpleactor/racket/translations/anf.rkt | 33 +- .../racket/translations/cc-combinator.rkt | 45 +- .../translations/contract-out-translation.rkt | 44 +- .../racket/translations/undefiner.rkt | 27 +- analyses/simpleactor/racket/utils.rkt | 4 + .../src/Analysis/SimpleActor/Semantics.hs | 1 + analyses/simpleactor/src/Syntax/AST.hs | 4 +- analyses/simpleactor/src/Syntax/Compiler.hs | 4 + 50 files changed, 117012 insertions(+), 2373 deletions(-) create mode 100644 analyses/simpleactor/racket/translations/add-prelude.scm diff --git a/analyses/simpleactor/app/ASE/Benchmark.hs b/analyses/simpleactor/app/ASE/Benchmark.hs index f30223d6..ed037bad 100644 --- a/analyses/simpleactor/app/ASE/Benchmark.hs +++ b/analyses/simpleactor/app/ASE/Benchmark.hs @@ -44,7 +44,7 @@ benchmarkOptions = BenchmarkOptions <$> strOption ( long "file" <> short 'f' <> benchmarkCmd :: BenchmarkOptions -> IO () benchmarkCmd (BenchmarkOptions { .. }) = do - let benchmarks = testBenchmarkPrograms + let benchmarks = benchmarkPrograms putStrLn "Running precision benchmarks" runPrecisionBenchmarks benchmarks precisionBenchmarkOutput putStrLn "Running time benchmarks" @@ -59,41 +59,41 @@ benchmarkCmd (BenchmarkOptions { .. }) = do benchmarkPrograms :: [String] benchmarkPrograms = [ - "games_snake.rkt", - "games_tetris.rkt", - "games_zombie.rkt", - "mochi_fold-div.rkt", - "mochi_hors.rkt", - "mochi_hrec.rkt", - "mochi_l-zipunzip.rkt", - "mochi_map-foldr.rkt", - "mochi_mappend.rkt", - "mochi_mem.rkt", - "mochi_mult.rkt", - "mochi_neg.rkt", - "mochi_nth0.rkt", - "mochi_r-file.rkt", - "mochi_r-lock.rkt", - "mochi_reverse.rkt", - "mochi_sum.rkt", - "mochi_zip.rkt", - "sergey_blur.rkt", - "sergey_eta.rkt", - "sergey_kcfa2.rkt", - "sergey_kcfa3.rkt", - "sergey_loop2.rkt", - "sergey_mj09.rkt", - "sergey_sat.rkt", - "softy_append.rkt", - "softy_cpstak.rkt", - "softy_last-pair.rkt", - "softy_last.rkt", - "softy_length-acc.rkt", - "softy_length.rkt", - "softy_member.rkt", - "softy_recursive-div2.rkt", - "softy_subst.rkt", - "softy_tak.rkt" + "benchmarks-out/games_snake.rkt", + "benchmarks-out/games_tetris.rkt", + "benchmarks-out/games_zombie.rkt", + "benchmarks-out/mochi_fold-div.rkt", + "benchmarks-out/mochi_hors.rkt", + "benchmarks-out/mochi_hrec.rkt", + "benchmarks-out/mochi_l-zipunzip.rkt", + "benchmarks-out/mochi_map-foldr.rkt", + "benchmarks-out/mochi_mappend.rkt", + "benchmarks-out/mochi_mem.rkt", + "benchmarks-out/mochi_mult.rkt", + "benchmarks-out/mochi_neg.rkt", + "benchmarks-out/mochi_nth0.rkt", + "benchmarks-out/mochi_r-file.rkt", + "benchmarks-out/mochi_r-lock.rkt", + "benchmarks-out/mochi_reverse.rkt", + "benchmarks-out/mochi_sum.rkt", + "benchmarks-out/mochi_zip.rkt", + "benchmarks-out/sergey_blur.rkt", + "benchmarks-out/sergey_eta.rkt", + "benchmarks-out/sergey_kcfa2.rkt", + "benchmarks-out/sergey_kcfa3.rkt", + "benchmarks-out/sergey_loop2.rkt", + "benchmarks-out/sergey_mj09.rkt", + "benchmarks-out/sergey_sat.rkt", + "benchmarks-out/softy_append.rkt", + "benchmarks-out/softy_cpstak.rkt", + "benchmarks-out/softy_last-pair.rkt", + "benchmarks-out/softy_last.rkt", + "benchmarks-out/softy_length-acc.rkt", + "benchmarks-out/softy_length.rkt", + "benchmarks-out/softy_member.rkt", + "benchmarks-out/softy_recursive-div2.rkt", + "benchmarks-out/softy_subst.rkt", + "benchmarks-out/softy_tak.rkt" ] testBenchmarkPrograms :: [String] diff --git a/analyses/simpleactor/benchmarks-in/games_snake.rkt b/analyses/simpleactor/benchmarks-in/games_snake.rkt index b1d5e4b1..d43e5cae 100644 --- a/analyses/simpleactor/benchmarks-in/games_snake.rkt +++ b/analyses/simpleactor/benchmarks-in/games_snake.rkt @@ -21,8 +21,8 @@ (struct snake (dir segs)) (struct world (snake food)) (define DIR/C (one-of/c 'up 'down 'left 'right)) -(define POSN/C (struct/c posn real? real?)) -(define SNAKE/C (struct/c snake DIR/C (and/c cons? (listof POSN/C)))) +(define POSN/C (struct/c posn real?/c real?/c)) +(define SNAKE/C (struct/c snake DIR/C (and/c cons?/c (listof POSN/C)))) (define WORLD/C (struct/c world SNAKE/C POSN/C)) diff --git a/analyses/simpleactor/benchmarks-in/games_tetris.rkt b/analyses/simpleactor/benchmarks-in/games_tetris.rkt index 73400839..11000fe6 100644 --- a/analyses/simpleactor/benchmarks-in/games_tetris.rkt +++ b/analyses/simpleactor/benchmarks-in/games_tetris.rkt @@ -9,8 +9,8 @@ (struct world (tetra blocks)) (struct posn (x y)) (define COLOR/C symbol?) -(define POSN/C (struct/c posn real? real?)) -(define BLOCK/C (struct/c block real? real? COLOR/C)) +(define POSN/C (struct/c posn real?/c real?/c)) +(define BLOCK/C (struct/c block real?/c real?/c COLOR/C)) (define BSET/C (listof BLOCK/C)) (define TETRA/C (struct/c tetra POSN/C BSET/C)) (define WORLD/C (struct/c world TETRA/C BSET/C)) @@ -455,15 +455,15 @@ [overlay (-> image? image? image?)] [circle (-> real?/c real?/c string?/c image?)] [rectangle (-> real?/c real?/c COLOR/C COLOR/C image?)] - [place-image (-> image?/c real?/c real?/c image?/c image?/c)] + [place-image (-> image/c real?/c real?/c image/c image/c)] [empty-scene (-> real?/c real?/c image?)] ;; aux [list-pick-random (-> (and/c cons?/c (listof TETRA/C)) TETRA/C)] [neg-1 integer?/c] ;; ha! ;; visual - [world->image (-> WORLD/C image?/c)] - [blocks->image (-> BSET/C image?/c)] - [block->image (-> BLOCK/C image?/c)] - [place-block (-> BLOCK/C image?/c image?/c)] + [world->image (-> WORLD/C image/c)] + [blocks->image (-> BSET/C image/c)] + [block->image (-> BLOCK/C image/c)] + [place-block (-> BLOCK/C image/c image/c)] [world0 (-> (and/c cons?/c (listof TETRA/C)) WORLD/C)] )) diff --git a/analyses/simpleactor/benchmarks-out/games_snake.rkt b/analyses/simpleactor/benchmarks-out/games_snake.rkt index 0f799d06..28c9d353 100644 --- a/analyses/simpleactor/benchmarks-out/games_snake.rkt +++ b/analyses/simpleactor/benchmarks-out/games_snake.rkt @@ -1,278 +1,4942 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7351 #t)) g7351))) + (meta (lambda (v) (letrec ((g7352 v)) g7352))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7353 + (letrec ((g7354 + (letrec ((x-e7355 lst)) + (match + x-e7355 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7356 (eq? v v1))) + (if x-cnd7356 #t (member v vs))))))))) + g7354))) + g7353))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (struct image ()) - (define image/c (struct/c image)) - (define (circle r m c) (image)) - (define (empty-scene w h) (image)) - (define (place-image i₁ r c i₂) (image)) - (struct posn (x y)) - (define (posn=? p1 p2) - (and (= (posn-x p1) (posn-x p2)) (= (posn-y p1) (posn-y p2)))) - (struct snake (dir segs)) - (struct world (snake food)) - (define DIR/C (one-of/c 'up 'down 'left 'right)) - (define POSN/C (struct/c posn real? real?)) - (define SNAKE/C (struct/c snake DIR/C (and/c cons? (listof POSN/C)))) - (define WORLD/C (struct/c world SNAKE/C POSN/C)) - (define GRID-SIZE 30) - (define BOARD-HEIGHT 20) - (define BOARD-WIDTH 30) - (define BOARD-HEIGHT-PIXELS (* GRID-SIZE BOARD-HEIGHT)) - (define BOARD-WIDTH-PIXELS (* GRID-SIZE BOARD-WIDTH)) - (define BACKGROUND (empty-scene BOARD-WIDTH-PIXELS BOARD-HEIGHT-PIXELS)) - (define SEGMENT-RADIUS (/ GRID-SIZE 2)) - (define SEGMENT-IMAGE (circle SEGMENT-RADIUS solid red)) - (define FOOD-RADIUS SEGMENT-RADIUS) - (define FOOD-IMAGE (circle FOOD-RADIUS solid green)) - (define WORLD (world (snake 'right (cons (posn 5 3) empty)) (posn 8 12))) - (define (snake-wall-collide? snk) (head-collide? (car (snake-segs snk)))) - (define (head-collide? p) - (or (<= (posn-x p) 0) - (>= (posn-x p) BOARD-WIDTH) - (<= (posn-y p) 0) - (>= (posn-y p) BOARD-HEIGHT))) - (define (snake-self-collide? snk) - (segs-self-collide? (car (snake-segs snk)) (cdr (snake-segs snk)))) - (define (segs-self-collide? h segs) - (cond - ((empty? segs) #f) - (else (or (posn=? (car segs) h) (segs-self-collide? h (cdr segs)))))) - (define (cut-tail segs) - (let ((r (cdr segs))) - (cond ((empty? r) empty) (else (cons (car segs) (cut-tail r)))))) - (define (next-head seg dir) - (cond - ((equal? 'right dir) (posn (add1 (posn-x seg)) (posn-y seg))) - ((equal? 'left dir) (posn (sub1 (posn-x seg)) (posn-y seg))) - ((equal? 'down dir) (posn (posn-x seg) (sub1 (posn-y seg)))) - (else (posn (posn-x seg) (add1 (posn-y seg)))))) - (define (snake-slither snk) - (let ((d (snake-dir snk))) - (snake - d - (cons - (next-head (car (snake-segs snk)) d) - (cut-tail (snake-segs snk)))))) - (define (snake-grow snk) - (let ((d (snake-dir snk))) - (snake - d - (cons (next-head (car (snake-segs snk)) d) (snake-segs snk))))) - (define (world->world w) - (cond - ((eating? w) (snake-eat w)) - (else (world (snake-slither (world-snake w)) (world-food w))))) - (define (eating? w) - (posn=? (world-food w) (car (snake-segs (world-snake w))))) - (define (snake-change-direction snk dir) (snake dir (snake-segs snk))) - (define (world-change-dir w dir) - (world (snake-change-direction (world-snake w) dir) (world-food w))) - (define (snake-eat w) - (world - (snake-grow (world-snake w)) - (posn (- BOARD-WIDTH 1) (- BOARD-HEIGHT 1)))) - (define (handle-key w ke) - (cond - ((equal? ke w) (world-change-dir w 'up)) - ((equal? ke s) (world-change-dir w 'down)) - ((equal? ke a) (world-change-dir w 'left)) - ((equal? ke d) (world-change-dir w 'right)) - (else w))) - (define (game-over? w) - (or (snake-wall-collide? (world-snake w)) - (snake-self-collide? (world-snake w)))) - (define (world->scene w) - (snake+scene (world-snake w) (food+scene (world-food w) BACKGROUND))) - (define (food+scene f scn) - (place-image-on-grid FOOD-IMAGE (posn-x f) (posn-y f) scn)) - (define (place-image-on-grid img x y scn) - (place-image - img - (* GRID-SIZE x) - (- BOARD-HEIGHT-PIXELS (* GRID-SIZE y)) - scn)) - (define (snake+scene snk scn) (segments+scene (snake-segs snk) scn)) - (define (segments+scene segs scn) - (cond - ((empty? segs) scn) - (else (segments+scene (cdr segs) (segment+scene (car segs) scn))))) - (define (segment+scene seg scn) - (place-image-on-grid SEGMENT-IMAGE (posn-x seg) (posn-y seg) scn)) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - (boolean? - j3985 - k3986 - (f3987 (POSN/C j3985 k3986 g3983) (POSN/C j3985 k3986 g3984))))) - 'module - 'importer - posn=?) - (input) - (input)) - (WORLD/C 'module 'importer WORLD) - (image/c 'module 'importer BACKGROUND) - (image/c 'module 'importer FOOD-IMAGE) - (image/c 'module 'importer SEGMENT-IMAGE) - (real? 'module 'importer GRID-SIZE) - (real? 'module 'importer BOARD-HEIGHT-PIXELS) - (real? 'module 'importer BOARD-WIDTH) - (real? 'module 'importer BOARD-HEIGHT) - (((lambda (j3989 k3990 f3991) - (lambda (g3988) - (boolean? j3989 k3990 (f3991 (SNAKE/C j3989 k3990 g3988))))) - 'module - 'importer - snake-wall-collide?) - (input)) - (((lambda (j3993 k3994 f3995) - (lambda (g3992) - (boolean? j3993 k3994 (f3995 (SNAKE/C j3993 k3994 g3992))))) - 'module - 'importer - snake-self-collide?) - (input)) - (((lambda (j3997 k3998 f3999) - (lambda (g3996) - ((listof POSN/C) - j3997 - k3998 - (f3999 ((and/c cons? (listof POSN/C)) j3997 k3998 g3996))))) - 'module - 'importer - cut-tail) - (input)) - (((lambda (j4001 k4002 f4003) - (lambda (g4000) - (SNAKE/C j4001 k4002 (f4003 (SNAKE/C j4001 k4002 g4000))))) - 'module - 'importer - snake-slither) - (input)) - (((lambda (j4005 k4006 f4007) - (lambda (g4004) - (SNAKE/C j4005 k4006 (f4007 (SNAKE/C j4005 k4006 g4004))))) - 'module - 'importer - snake-grow) - (input)) - (((lambda (j4010 k4011 f4012) - (lambda (g4008 g4009) - (WORLD/C - j4010 - k4011 - (f4012 (WORLD/C j4010 k4011 g4008) (DIR/C j4010 k4011 g4009))))) - 'module - 'importer - world-change-dir) - (input) - (input)) - (((lambda (j4014 k4015 f4016) - (lambda (g4013) - (WORLD/C j4014 k4015 (f4016 (WORLD/C j4014 k4015 g4013))))) - 'module - 'importer - world->world) - (input)) - (((lambda (j4019 k4020 f4021) - (lambda (g4017 g4018) - (WORLD/C - j4019 - k4020 - (f4021 - (WORLD/C j4019 k4020 g4017) - (string? j4019 k4020 g4018))))) - 'module - 'importer - handle-key) - (input) - (input)) - (((lambda (j4023 k4024 f4025) - (lambda (g4022) - (boolean? j4023 k4024 (f4025 (WORLD/C j4023 k4024 g4022))))) - 'module - 'importer - game-over?) - (input)) - (((lambda (j4027 k4028 f4029) - (lambda (g4026) - (image/c j4027 k4028 (f4029 (WORLD/C j4027 k4028 g4026))))) - 'module - 'importer - world->scene) - (input)) - (((lambda (j4032 k4033 f4034) - (lambda (g4030 g4031) - (image/c - j4032 - k4033 - (f4034 (POSN/C j4032 k4033 g4030) (image/c j4032 k4033 g4031))))) - 'module - 'importer - food+scene) - (input) - (input)) - (((lambda (j4039 k4040 f4041) - (lambda (g4035 g4036 g4037 g4038) - (image/c - j4039 - k4040 - (f4041 - (image/c j4039 k4040 g4035) - (real? j4039 k4040 g4036) - (real? j4039 k4040 g4037) - (image/c j4039 k4040 g4038))))) - 'module - 'importer - place-image-on-grid) - (input) - (input) - (input) - (input)) - (((lambda (j4044 k4045 f4046) - (lambda (g4042 g4043) - (image/c - j4044 - k4045 - (f4046 - (SNAKE/C j4044 k4045 g4042) - (image/c j4044 k4045 g4043))))) - 'module - 'importer - snake+scene) - (input) - (input)) - (((lambda (j4049 k4050 f4051) - (lambda (g4047 g4048) - (image/c - j4049 - k4050 - (f4051 - ((listof POSN/C) j4049 k4050 g4047) - (image/c j4049 k4050 g4048))))) - 'module - 'importer - segments+scene) - (input) - (input)) - (((lambda (j4054 k4055 f4056) - (lambda (g4052 g4053) - (image/c - j4054 - k4055 - (f4056 (POSN/C j4054 k4055 g4052) (image/c j4054 k4055 g4053))))) - 'module - 'importer - segment+scene) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7357 (lambda (v) (letrec ((g7358 v)) g7358)))) g7357))) + (nonzero? + (lambda (v) + (letrec ((g7359 (letrec ((x7360 (= v 0))) (not x7360)))) g7359)))) + (letrec ((g7361 + (letrec ((g7362 + (letrec ((real/c + (lambda (g7164 g7165 g7166) + (letrec ((g7363 + (letrec ((x-cnd7364 (real? g7166))) + (if x-cnd7364 + g7166 + (blame g7164 'real?))))) + g7363))) + (boolean?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7365 + (letrec ((x-cnd7366 + (boolean? g7169))) + (if x-cnd7366 + g7169 + (blame g7167 'boolean?))))) + g7365))) + (number?/c + (lambda (g7170 g7171 g7172) + (letrec ((g7367 + (letrec ((x-cnd7368 + (number? g7172))) + (if x-cnd7368 + g7172 + (blame g7170 'number?))))) + g7367))) + (any/c + (lambda (g7173 g7174 g7175) + (letrec ((g7369 + (letrec ((x-cnd7370 + ((lambda (v) #t) g7175))) + (if x-cnd7370 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7369))) + (any?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7371 + (letrec ((x-cnd7372 + ((lambda (v) #t) g7178))) + (if x-cnd7372 + g7178 + (blame + g7176 + '(lambda (v) #t)))))) + g7371))) + (image? any/c) + (cons?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7373 + (letrec ((x-cnd7374 (pair? g7181))) + (if x-cnd7374 + g7181 + (blame g7179 'pair?))))) + g7373))) + (pair?/c + (lambda (g7182 g7183 g7184) + (letrec ((g7375 + (letrec ((x-cnd7376 (pair? g7184))) + (if x-cnd7376 + g7184 + (blame g7182 'pair?))))) + g7375))) + (integer? + (lambda (g7185 g7186 g7187) + (letrec ((g7377 + (letrec ((x-cnd7378 + (integer? g7187))) + (if x-cnd7378 + g7187 + (blame g7185 'integer?))))) + g7377))) + (and/c + (lambda (c1 c2) + (letrec ((g7379 + (lambda (k j v) + (letrec ((g7380 + (letrec ((x-cnd7381 + (c1 k j v))) + (if x-cnd7381 + (c2 k j v) + #f)))) + g7380)))) + g7379))) + (list-of + (lambda (contract) + (letrec ((g7382 + (lambda (k j v) + (letrec ((g7383 + (letrec ((x-cnd7384 + (null? v))) + (if x-cnd7384 + '() + (letrec ((x7388 + (letrec ((x7389 + (car + v))) + (contract + k + j + x7389))) + (x7385 + (letrec ((x7387 + (list-of + contract)) + (x7386 + (cdr + v))) + (x7387 + k + j + x7386)))) + (cons + x7388 + x7385)))))) + g7383)))) + g7382))) + (any? (lambda (v) (letrec ((g7390 #t)) g7390))) + (nonzero? + (lambda (v) + (letrec ((g7391 + (letrec ((x7392 (= v 0))) + (not x7392)))) + g7391))) + (nonzero?/c + (lambda (g7188 g7189 g7190) + (letrec ((g7393 + (letrec ((x-cnd7394 + ((lambda (v) + (not (= v 0))) + g7190))) + (if x-cnd7394 + g7190 + (blame + g7188 + '(lambda (v) + (not (= v 0)))))))) + g7393))) + (meta (lambda (v) (letrec ((g7395 v)) g7395))) + (orig-+ +) + (+ + ((lambda (j7193 k7194 f7195) + (lambda (g7191 g7192) + (number?/c + j7193 + k7194 + (f7195 + (number?/c j7193 k7194 g7191) + (number?/c j7193 k7194 g7192))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7198 k7199 f7200) + (lambda (g7196 g7197) + (number?/c + j7198 + k7199 + (f7200 + (number?/c j7198 k7199 g7196) + (number?/c j7198 k7199 g7197))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7203 k7204 f7205) + (lambda (g7201 g7202) + (number?/c + j7203 + k7204 + (f7205 + (number?/c j7203 k7204 g7201) + (number?/c j7203 k7204 g7202))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7208 k7209 f7210) + (lambda (g7206 g7207) + (number?/c + j7208 + k7209 + (f7210 + (number?/c j7208 k7209 g7206) + (number?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7216 k7217 f7218) + (lambda (g7215) + (any/c + j7216 + k7217 + (f7218 (pair?/c j7216 k7217 g7215))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7221 k7222 f7223) + (lambda (g7219 g7220) + (pair?/c + j7221 + k7222 + (f7223 + (any/c j7221 k7222 g7219) + (any/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7225 k7226 f7227) + (lambda (g7224) + (integer?/c + j7225 + k7226 + (f7227 (vector?/c j7225 k7226 g7224))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7230 k7231 f7232) + (lambda (g7228 g7229) + (any/c + j7230 + k7231 + (f7232 + (vector?/c j7230 k7231 g7228) + (integer?/c j7230 k7231 g7229))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7396 #t)) g7396))) + (cdddr + (lambda (x) + (letrec ((g7397 + (letrec ((x7398 + (letrec ((x7399 (cdr x))) + (cdr x7399)))) + (cdr x7398)))) + g7397))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7400 + (letrec ((x7403 (procedure? f))) + (assert x7403))) + (g7401 + (letrec ((x7404 (list? l))) + (assert x7404))) + (g7402 + (letrec ((x-cnd7405 (null? l))) + (if x-cnd7405 + '() + (letrec ((x7408 + (letrec ((x7409 + (car l))) + (f x7409))) + (x7406 + (letrec ((x7407 + (cdr l))) + (map f x7407)))) + (cons x7408 x7406)))))) + g7402))) + (cdar + (lambda (x) + (letrec ((g7410 + (letrec ((x7411 (car x))) + (cdr x7411)))) + g7410))) + (cadadr + (lambda (x) + (letrec ((g7412 + (letrec ((x7413 + (letrec ((x7414 + (letrec ((x7415 + (cdr + x))) + (car + x7415)))) + (cdr x7414)))) + (car x7413)))) + g7412))) + (cdadar + (lambda (x) + (letrec ((g7416 + (letrec ((x7417 + (letrec ((x7418 + (letrec ((x7419 + (car + x))) + (cdr + x7419)))) + (car x7418)))) + (cdr x7417)))) + g7416))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7420 + (letrec ((x7423 + (string? filename))) + (assert x7423))) + (g7421 + (letrec ((x7424 (procedure? proc))) + (assert x7424))) + (g7422 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7425 + (close-output-port + output-port)) + (g7426 res)) + g7426)))) + g7422))) + (caddr + (lambda (x) + (letrec ((g7427 + (letrec ((x7428 + (letrec ((x7429 (cdr x))) + (cdr x7429)))) + (car x7428)))) + g7427))) + (cdaadr + (lambda (x) + (letrec ((g7430 + (letrec ((x7431 + (letrec ((x7432 + (letrec ((x7433 + (cdr + x))) + (car + x7433)))) + (car x7432)))) + (cdr x7431)))) + g7430))) + (assq + (lambda (k l) + (letrec ((g7434 + (letrec ((x7436 (list? l))) + (assert x7436))) + (g7435 + (letrec ((x-cnd7437 (null? l))) + (if x-cnd7437 + #f + (letrec ((x-cnd7438 + (letrec ((x7439 + (caar l))) + (eq? x7439 k)))) + (if x-cnd7438 + (car l) + (letrec ((x7440 (cdr l))) + (assq k x7440)))))))) + g7435))) + (even? + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 (modulo x 2))) + (= 0 x7442)))) + g7441))) + (list->string + (lambda (l) + (letrec ((g7443 + (letrec ((x7445 (list? l))) + (assert x7445))) + (g7444 + (letrec ((x-cnd7446 (null? l))) + (if x-cnd7446 + "" + (letrec ((x7449 + (letrec ((x7450 + (car l))) + (char->string + x7450))) + (x7447 + (letrec ((x7448 + (cdr l))) + (list->string + x7448)))) + (string-append + x7449 + x7447)))))) + g7444))) + (char<=? + (lambda (c1 c2) + (letrec ((g7451 + (letrec ((x7454 (char? c1))) + (assert x7454))) + (g7452 + (letrec ((x7455 (char? c2))) + (assert x7455))) + (g7453 + (letrec ((val7143 (char=? c x7472)))) + (if x-cnd7471 + (letrec ((x7473 #\z)) + (char-ci<=? c x7473)) + #f)))) + g7470))) + (<= + (lambda (x y) + (letrec ((g7474 + (letrec ((x7476 (number? x))) + (assert x7476))) + (g7475 + (letrec ((val7144 (< x y))) + (letrec ((g7477 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7478 + (if val7145 + val7145 + #f))) + g7478))))) + g7477)))) + g7475))) + (char-whitespace? + (lambda (c) + (letrec ((g7479 + (letrec ((val7146 + (letrec ((x7480 + (char->integer + c))) + (= x7480 9)))) + (letrec ((g7481 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7482 + (char->integer + c))) + (= + x7482 + 10)))) + (letrec ((g7483 + (if val7147 + val7147 + (letrec ((x7484 + (char->integer + c))) + (= + x7484 + 32))))) + g7483))))) + g7481)))) + g7479))) + (cddar + (lambda (x) + (letrec ((g7485 + (letrec ((x7486 + (letrec ((x7487 (car x))) + (cdr x7487)))) + (cdr x7486)))) + g7485))) + (positive? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 (> x 0))) + g7489))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7491 #f)) g7491))) + (cddr + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 (cdr x))) + (cdr x7493)))) + g7492))) + (truncate + (lambda (x) + (letrec ((g7494 + (letrec ((x7496 (number? x))) + (assert x7496))) + (g7495 + (letrec ((x-cnd7497 (< x 0))) + (if x-cnd7497 + (ceiling x) + (floor x))))) + g7495))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7498 + (letrec ((val7148 (eq? a b))) + (letrec ((g7499 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7501 + (null? + a)) + (x7500 + (null? + b))) + (and x7501 + x7500)))) + (letrec ((g7502 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7505 + (string? + a)) + (x7504 + (string? + b)) + (x7503 + (string=? + a + b))) + (and x7505 + x7504 + x7503)))) + (letrec ((g7506 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7514 + (pair? + a)) + (x7513 + (pair? + b)) + (x7510 + (letrec ((x7512 + (car + a)) + (x7511 + (car + b))) + (equal? + x7512 + x7511))) + (x7507 + (letrec ((x7509 + (cdr + a)) + (x7508 + (cdr + b))) + (equal? + x7509 + x7508)))) + (and x7514 + x7513 + x7510 + x7507)))) + (letrec ((g7515 + (if val7151 + val7151 + (letrec ((x7534 + (vector? + a)) + (x7533 + (vector? + b)) + (x7516 + (letrec ((x7530 + (letrec ((x7531 + (letrec ((x7532 + (vector-length + a))) + (n + x7532)))) + (x7531))) + (x7517 + (letrec ((x7528 + (letrec ((x7529 + (vector-length + b))) + (= + x7529 + n))) + (x7518 + (letrec ((loop + (lambda (i) + (letrec ((g7519 + (letrec ((x7526 + (= + i + n)) + (x7520 + (letrec ((x7523 + (letrec ((x7525 + (vector-ref + a + i)) + (x7524 + (vector-ref + b + i))) + (equal? + x7525 + x7524))) + (x7521 + (letrec ((x7522 + (+ + i + 1))) + (loop + x7522)))) + (and x7523 + x7521)))) + (or x7526 + x7520)))) + g7519)))) + (letrec ((g7527 + (loop + 0))) + g7527)))) + (and x7528 + x7518)))) + (let x7530 x7517)))) + (and x7534 + x7533 + x7516))))) + g7515))))) + g7506))))) + g7502))))) + g7499)))) + g7498))) + (cdaaar + (lambda (x) + (letrec ((g7535 + (letrec ((x7536 + (letrec ((x7537 + (letrec ((x7538 + (car + x))) + (car + x7538)))) + (car x7537)))) + (cdr x7536)))) + g7535))) + (caaddr + (lambda (x) + (letrec ((g7539 + (letrec ((x7540 + (letrec ((x7541 + (letrec ((x7542 + (cdr + x))) + (cdr + x7542)))) + (car x7541)))) + (car x7540)))) + g7539))) + (eqv? + (lambda (x y) + (letrec ((g7543 (eq? x y))) g7543))) + (>= + (lambda (x y) + (letrec ((g7544 + (letrec ((x7546 (number? x))) + (assert x7546))) + (g7545 + (letrec ((val7152 (> x y))) + (letrec ((g7547 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7548 + (if val7153 + val7153 + #f))) + g7548))))) + g7547)))) + g7545))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7549 + (letrec ((x7552 + (string? filename))) + (assert x7552))) + (g7550 + (letrec ((x7553 (procedure? proc))) + (assert x7553))) + (g7551 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7554 + (close-input-port + input-port)) + (g7555 res)) + g7555)))) + g7551))) + (ref + (lambda (x) + (letrec ((g7556 (cons x '()))) g7556))) + (char>=? + (lambda (c1 c2) + (letrec ((g7557 + (letrec ((x7560 (char? c1))) + (assert x7560))) + (g7558 + (letrec ((x7561 (char? c2))) + (assert x7561))) + (g7559 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7562 + (if val7154 + val7154 + (char=? c1 c2)))) + g7562)))) + g7559))) + (cdaar + (lambda (x) + (letrec ((g7563 + (letrec ((x7564 + (letrec ((x7565 (car x))) + (car x7565)))) + (cdr x7564)))) + g7563))) + (cdaddr + (lambda (x) + (letrec ((g7566 + (letrec ((x7567 + (letrec ((x7568 + (letrec ((x7569 + (cdr + x))) + (cdr + x7569)))) + (car x7568)))) + (cdr x7567)))) + g7566))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7570 + (letrec ((x7571 + (letrec ((x7572 (car x))) + (cdr x7572)))) + (car x7571)))) + g7570))) + (caadr + (lambda (x) + (letrec ((g7573 + (letrec ((x7574 + (letrec ((x7575 (cdr x))) + (car x7575)))) + (car x7574)))) + g7573))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7576 + (letrec ((x7579 (char? c1))) + (assert x7579))) + (g7577 + (letrec ((x7580 (char? c2))) + (assert x7580))) + (g7578 + (letrec ((x7581 + (char-ci<=? c1 c2))) + (not x7581)))) + g7578))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7582 + (letrec ((x7583 + (letrec ((x7584 + (letrec ((x7585 + (car + x))) + (car + x7585)))) + (car x7584)))) + (car x7583)))) + g7582))) + (negative? + (lambda (x) + (letrec ((g7586 + (letrec ((x7588 (number? x))) + (assert x7588))) + (g7587 (< x 0))) + g7587))) + (memv + (lambda (e l) + (letrec ((g7589 (memq e l))) g7589))) + (caaar + (lambda (x) + (letrec ((g7590 + (letrec ((x7591 + (letrec ((x7592 (car x))) + (car x7592)))) + (car x7591)))) + g7590))) + (debug + (lambda (e) (letrec ((g7593 '())) g7593))) + (reverse + (lambda (l) + (letrec ((g7594 + (letrec ((x7596 (list? l))) + (assert x7596))) + (g7595 + (letrec ((x-cnd7597 (null? l))) + (if x-cnd7597 + '() + (letrec ((x7600 + (letrec ((x7601 + (cdr l))) + (reverse x7601))) + (x7598 + (letrec ((x7599 + (car l))) + (list x7599)))) + (append x7600 x7598)))))) + g7595))) + (caaadr + (lambda (x) + (letrec ((g7602 + (letrec ((x7603 + (letrec ((x7604 + (letrec ((x7605 + (cdr + x))) + (car + x7605)))) + (car x7604)))) + (car x7603)))) + g7602))) + (cddadr + (lambda (x) + (letrec ((g7606 + (letrec ((x7607 + (letrec ((x7608 + (letrec ((x7609 + (cdr + x))) + (car + x7609)))) + (cdr x7608)))) + (cdr x7607)))) + g7606))) + (odd? + (lambda (x) + (letrec ((g7610 + (letrec ((x7612 (number? x))) + (assert x7612))) + (g7611 + (letrec ((x7613 (modulo x 2))) + (= 1 x7613)))) + g7611))) + (caadar + (lambda (x) + (letrec ((g7614 + (letrec ((x7615 + (letrec ((x7616 + (letrec ((x7617 + (car + x))) + (cdr + x7617)))) + (car x7616)))) + (car x7615)))) + g7614))) + (apply + (lambda (proc args) + (letrec ((g7618 + (letrec ((x7621 (procedure? proc))) + (assert x7621))) + (g7619 + (letrec ((x7622 (list? args))) + (assert x7622))) + (g7620 + (if cnd + (letrec ((g7623 (proc))) g7623) + (if cnd + (letrec ((g7624 + (letrec ((x7625 + (car + args))) + (proc x7625)))) + g7624) + (if cnd + (letrec ((g7626 + (letrec ((x7628 + (car + args)) + (x7627 + (cadr + args))) + (proc + x7628 + x7627)))) + g7626) + (if cnd + (letrec ((g7629 + (letrec ((x7632 + (car + args)) + (x7631 + (cadr + args)) + (x7630 + (caddr + args))) + (proc + x7632 + x7631 + x7630)))) + g7629) + (if cnd + (letrec ((g7633 + (letrec ((x7637 + (car + args)) + (x7636 + (cadr + args)) + (x7635 + (caddr + args)) + (x7634 + (cadddr + args))) + (proc + x7637 + x7636 + x7635 + x7634)))) + g7633) + (if cnd + (letrec ((g7638 + (letrec ((x7644 + (car + args)) + (x7643 + (cadr + args)) + (x7642 + (caddr + args)) + (x7641 + (cadddr + args)) + (x7639 + (letrec ((x7640 + (cddddr + args))) + (car + x7640)))) + (proc + x7644 + x7643 + x7642 + x7641 + x7639)))) + g7638) + (if cnd + (letrec ((g7645 + (letrec ((x7653 + (car + args)) + (x7652 + (cadr + args)) + (x7651 + (caddr + args)) + (x7650 + (cadddr + args)) + (x7648 + (letrec ((x7649 + (cddddr + args))) + (car + x7649))) + (x7646 + (letrec ((x7647 + (cddddr + args))) + (cadr + x7647)))) + (proc + x7653 + x7652 + x7651 + x7650 + x7648 + x7646)))) + g7645) + (if cnd + (letrec ((g7654 + (letrec ((x7664 + (car + args)) + (x7663 + (cadr + args)) + (x7662 + (caddr + args)) + (x7661 + (cadddr + args)) + (x7659 + (letrec ((x7660 + (cddddr + args))) + (car + x7660))) + (x7657 + (letrec ((x7658 + (cddddr + args))) + (cadr + x7658))) + (x7655 + (letrec ((x7656 + (cddddr + args))) + (caddr + x7656)))) + (proc + x7664 + x7663 + x7662 + x7661 + x7659 + x7657 + x7655)))) + g7654) + (letrec ((g7665 + (error + "Unsupported call."))) + g7665))))))))))) + g7620))) + (member + (lambda (e l) + (letrec ((g7666 + (letrec ((x7668 (list? l))) + (assert x7668))) + (g7667 + (letrec ((x-cnd7669 (null? l))) + (if x-cnd7669 + #f + (letrec ((x-cnd7670 + (letrec ((x7671 + (car l))) + (equal? x7671 e)))) + (if x-cnd7670 + l + (letrec ((x7672 (cdr l))) + (member e x7672)))))))) + g7667))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7673 + (letrec ((x7674 + (letrec ((x7675 + (letrec ((x7676 + (cdr + x))) + (cdr + x7676)))) + (cdr x7675)))) + (cdr x7674)))) + g7673))) + (cadddr + (lambda (x) + (letrec ((g7677 + (letrec ((x7678 + (letrec ((x7679 + (letrec ((x7680 + (cdr + x))) + (cdr + x7680)))) + (cdr x7679)))) + (car x7678)))) + g7677))) + (int-top + (lambda () + (letrec ((g7681 (random 42))) g7681))) + (zero? + (lambda (x) + (letrec ((g7682 + (letrec ((x7684 (number? x))) + (assert x7684))) + (g7683 (= x 0))) + g7683))) + (string>=? + (lambda (s1 s2) + (letrec ((g7685 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7686 + (if val7155 + val7155 + (string=? s1 s2)))) + g7686)))) + g7685))) + (cadr + (lambda (x) + (letrec ((g7687 + (letrec ((x7688 (cdr x))) + (car x7688)))) + g7687))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7689 + (letrec ((val7156 + (letrec ((x7692 + (pair? l)) + (x7690 + (letrec ((x7691 + (cdr + l))) + (list? + x7691)))) + (and x7692 x7690)))) + (letrec ((g7693 + (if val7156 + val7156 + (null? l)))) + g7693)))) + g7689))) + (cddaar + (lambda (x) + (letrec ((g7694 + (letrec ((x7695 + (letrec ((x7696 + (letrec ((x7697 + (car + x))) + (car + x7697)))) + (cdr x7696)))) + (cdr x7695)))) + g7694))) + (char-numeric? + (lambda (c) + (letrec ((g7698 + (letrec ((x-cnd7699 + (letrec ((x7700 #\0)) + (char<=? x7700 c)))) + (if x-cnd7699 + (letrec ((x7701 #\9)) + (char<=? c x7701)) + #f)))) + g7698))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7702 + (letrec ((x7704 (list? l))) + (assert x7704))) + (g7703 + (letrec ((x-cnd7705 (null? l))) + (if x-cnd7705 + #f + (letrec ((x-cnd7706 + (letrec ((x7707 + (caar l))) + (eqv? x7707 k)))) + (if x-cnd7706 + (car l) + (letrec ((x7708 (cdr l))) + (assq k x7708)))))))) + g7703))) + (not + (lambda (x) + (letrec ((g7709 (if x #f #t))) g7709))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7710 (append l1 l2))) g7710))) + (memq + (lambda (e l) + (letrec ((g7711 + (letrec ((x7713 (list? l))) + (assert x7713))) + (g7712 + (letrec ((x-cnd7714 (null? l))) + (if x-cnd7714 + #f + (letrec ((x-cnd7715 + (letrec ((x7716 + (car l))) + (eq? x7716 e)))) + (if x-cnd7715 + l + (letrec ((x7717 (cdr l))) + (memq e x7717)))))))) + g7712))) + (cadaar + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 + (letrec ((x7721 + (car + x))) + (car + x7721)))) + (cdr x7720)))) + (car x7719)))) + g7718))) + (length + (lambda (l) + (letrec ((g7722 + (letrec ((x7724 (list? l))) + (assert x7724))) + (g7723 + (letrec ((rec + (lambda (l) + (letrec ((g7725 + (letrec ((x-cnd7726 + (null? + l))) + (if x-cnd7726 + 0 + (letrec ((x7727 + (letrec ((x7728 + (cdr + l))) + (rec + x7728)))) + (+ + 1 + x7727)))))) + g7725)))) + (letrec ((g7729 (rec l))) + g7729)))) + g7723))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7730 + (letrec ((x7733 (char? c1))) + (assert x7733))) + (g7731 + (letrec ((x7734 (char? c2))) + (assert x7734))) + (g7732 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7736 + (letrec ((x7737 (string<=? s1 s2))) + (not x7737)))) + g7736))) + (cdadr + (lambda (x) + (letrec ((g7738 + (letrec ((x7739 + (letrec ((x7740 (cdr x))) + (car x7740)))) + (cdr x7739)))) + g7738))) + (assoc + (lambda (k l) + (letrec ((g7741 + (letrec ((x7743 (list? l))) + (assert x7743))) + (g7742 + (letrec ((x-cnd7744 (null? l))) + (if x-cnd7744 + #f + (letrec ((x-cnd7745 + (letrec ((x7746 + (caar l))) + (equal? x7746 k)))) + (if x-cnd7745 + (car l) + (letrec ((x7747 (cdr l))) + (assoc k x7747)))))))) + g7742))) + (caar + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 (car x))) + (car x7749)))) + g7748))) + (char>? + (lambda (c1 c2) + (letrec ((g7750 + (letrec ((x7753 (char? c1))) + (assert x7753))) + (g7751 + (letrec ((x7754 (char? c2))) + (assert x7754))) + (g7752 + (letrec ((x7755 (char<=? c1 c2))) + (not x7755)))) + g7752))) + (string<=? + (lambda (s1 s2) + (letrec ((g7756 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7773 + (letrec ((x7776 (char? c1))) + (assert x7776))) + (g7774 + (letrec ((x7777 (char? c2))) + (assert x7777))) + (g7775 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7778 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7778)))) + g7775))) + (caddar + (lambda (x) + (letrec ((g7779 + (letrec ((x7780 + (letrec ((x7781 + (letrec ((x7782 + (car + x))) + (cdr + x7782)))) + (cdr x7781)))) + (car x7780)))) + g7779))) + (newline + (lambda () (letrec ((g7783 #f)) g7783))) + (lcm + (lambda (m n) + (letrec ((g7784 + (letrec ((x7786 + (letrec ((x7787 (* m n))) + (abs x7787))) + (x7785 (gcd m n))) + (/ x7786 x7785)))) + g7784))) + (deref car) + (> + (lambda (x y) + (letrec ((g7788 + (letrec ((x7790 (number? x))) + (assert x7790))) + (g7789 + (letrec ((x7791 (<= x y))) + (not x7791)))) + g7789))) + (list-ref + (lambda (l index) + (letrec ((g7792 + (letrec ((x7796 (list? l))) + (assert x7796))) + (g7793 + (letrec ((x7797 (number? index))) + (assert x7797))) + (g7794 + (letrec ((x7798 + (letrec ((x7799 + (length l))) + (< index x7799)))) + (assert x7798))) + (g7795 + (letrec ((x-cnd7800 (= index 0))) + (if x-cnd7800 + (car l) + (letrec ((x7802 (cdr l)) + (x7801 (- index 1))) + (list-ref x7802 x7801)))))) + g7795))) + (gcd + (lambda (a b) + (letrec ((g7803 + (letrec ((x-cnd7804 (= b 0))) + (if x-cnd7804 + a + (letrec ((x7805 (modulo a b))) + (gcd b x7805)))))) + g7803))) + (real/c + (lambda (g7164 g7165 g7166) + (letrec ((g7806 + (letrec ((x-cnd7807 (real? g7166))) + (if x-cnd7807 + g7166 + (blame g7164 'real?))))) + g7806))) + (boolean?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7808 + (letrec ((x-cnd7809 + (boolean? g7169))) + (if x-cnd7809 + g7169 + (blame g7167 'boolean?))))) + g7808))) + (number?/c + (lambda (g7170 g7171 g7172) + (letrec ((g7810 + (letrec ((x-cnd7811 + (number? g7172))) + (if x-cnd7811 + g7172 + (blame g7170 'number?))))) + g7810))) + (any/c + (lambda (g7173 g7174 g7175) + (letrec ((g7812 + (letrec ((x-cnd7813 + ((lambda (v) #t) g7175))) + (if x-cnd7813 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7812))) + (any?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7814 + (letrec ((x-cnd7815 + ((lambda (v) #t) g7178))) + (if x-cnd7815 + g7178 + (blame + g7176 + '(lambda (v) #t)))))) + g7814))) + (image? any/c) + (cons?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7816 + (letrec ((x-cnd7817 (pair? g7181))) + (if x-cnd7817 + g7181 + (blame g7179 'pair?))))) + g7816))) + (pair?/c + (lambda (g7182 g7183 g7184) + (letrec ((g7818 + (letrec ((x-cnd7819 (pair? g7184))) + (if x-cnd7819 + g7184 + (blame g7182 'pair?))))) + g7818))) + (integer? + (lambda (g7185 g7186 g7187) + (letrec ((g7820 + (letrec ((x-cnd7821 + (integer? g7187))) + (if x-cnd7821 + g7187 + (blame g7185 'integer?))))) + g7820))) + (and/c + (lambda (c1 c2) + (letrec ((g7822 + (lambda (k j v) + (letrec ((g7823 + (letrec ((x-cnd7824 + (c1 k j v))) + (if x-cnd7824 + (c2 k j v) + #f)))) + g7823)))) + g7822))) + (list-of + (lambda (contract) + (letrec ((g7825 + (lambda (k j v) + (letrec ((g7826 + (letrec ((x-cnd7827 + (null? v))) + (if x-cnd7827 + '() + (letrec ((x7831 + (letrec ((x7832 + (car + v))) + (contract + k + j + x7832))) + (x7828 + (letrec ((x7830 + (list-of + contract)) + (x7829 + (cdr + v))) + (x7830 + k + j + x7829)))) + (cons + x7831 + x7828)))))) + g7826)))) + g7825))) + (any? (lambda (v) (letrec ((g7833 #t)) g7833))) + (nonzero? + (lambda (v) + (letrec ((g7834 + (letrec ((x7835 (= v 0))) + (not x7835)))) + g7834))) + (nonzero?/c + (lambda (g7188 g7189 g7190) + (letrec ((g7836 + (letrec ((x-cnd7837 + ((lambda (v) + (not (= v 0))) + g7190))) + (if x-cnd7837 + g7190 + (blame + g7188 + '(lambda (v) + (not (= v 0)))))))) + g7836))) + (meta (lambda (v) (letrec ((g7838 v)) g7838))) + (orig-+ +) + (+ + ((lambda (j7193 k7194 f7195) + (lambda (g7191 g7192) + (number?/c + j7193 + k7194 + (f7195 + (number?/c j7193 k7194 g7191) + (number?/c j7193 k7194 g7192))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7198 k7199 f7200) + (lambda (g7196 g7197) + (number?/c + j7198 + k7199 + (f7200 + (number?/c j7198 k7199 g7196) + (number?/c j7198 k7199 g7197))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7203 k7204 f7205) + (lambda (g7201 g7202) + (number?/c + j7203 + k7204 + (f7205 + (number?/c j7203 k7204 g7201) + (number?/c j7203 k7204 g7202))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7208 k7209 f7210) + (lambda (g7206 g7207) + (number?/c + j7208 + k7209 + (f7210 + (number?/c j7208 k7209 g7206) + (number?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7216 k7217 f7218) + (lambda (g7215) + (any/c + j7216 + k7217 + (f7218 (pair?/c j7216 k7217 g7215))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7221 k7222 f7223) + (lambda (g7219 g7220) + (pair?/c + j7221 + k7222 + (f7223 + (any/c j7221 k7222 g7219) + (any/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7225 k7226 f7227) + (lambda (g7224) + (integer?/c + j7225 + k7226 + (f7227 (vector?/c j7225 k7226 g7224))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7230 k7231 f7232) + (lambda (g7228 g7229) + (any/c + j7230 + k7231 + (f7232 + (vector?/c j7230 k7231 g7228) + (integer?/c j7230 k7231 g7229))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7839 #t)) g7839))) + (cdddr + (lambda (x) + (letrec ((g7840 + (letrec ((x7841 + (letrec ((x7842 (cdr x))) + (cdr x7842)))) + (cdr x7841)))) + g7840))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7843 + (letrec ((x7846 (procedure? f))) + (assert x7846))) + (g7844 + (letrec ((x7847 (list? l))) + (assert x7847))) + (g7845 + (letrec ((x-cnd7848 (null? l))) + (if x-cnd7848 + '() + (letrec ((x7851 + (letrec ((x7852 + (car l))) + (f x7852))) + (x7849 + (letrec ((x7850 + (cdr l))) + (map f x7850)))) + (cons x7851 x7849)))))) + g7845))) + (cdar + (lambda (x) + (letrec ((g7853 + (letrec ((x7854 (car x))) + (cdr x7854)))) + g7853))) + (cadadr + (lambda (x) + (letrec ((g7855 + (letrec ((x7856 + (letrec ((x7857 + (letrec ((x7858 + (cdr + x))) + (car + x7858)))) + (cdr x7857)))) + (car x7856)))) + g7855))) + (cdadar + (lambda (x) + (letrec ((g7859 + (letrec ((x7860 + (letrec ((x7861 + (letrec ((x7862 + (car + x))) + (cdr + x7862)))) + (car x7861)))) + (cdr x7860)))) + g7859))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7863 + (letrec ((x7866 + (string? filename))) + (assert x7866))) + (g7864 + (letrec ((x7867 (procedure? proc))) + (assert x7867))) + (g7865 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7868 + (close-output-port + output-port)) + (g7869 res)) + g7869)))) + g7865))) + (caddr + (lambda (x) + (letrec ((g7870 + (letrec ((x7871 + (letrec ((x7872 (cdr x))) + (cdr x7872)))) + (car x7871)))) + g7870))) + (cdaadr + (lambda (x) + (letrec ((g7873 + (letrec ((x7874 + (letrec ((x7875 + (letrec ((x7876 + (cdr + x))) + (car + x7876)))) + (car x7875)))) + (cdr x7874)))) + g7873))) + (assq + (lambda (k l) + (letrec ((g7877 + (letrec ((x7879 (list? l))) + (assert x7879))) + (g7878 + (letrec ((x-cnd7880 (null? l))) + (if x-cnd7880 + #f + (letrec ((x-cnd7881 + (letrec ((x7882 + (caar l))) + (eq? x7882 k)))) + (if x-cnd7881 + (car l) + (letrec ((x7883 (cdr l))) + (assq k x7883)))))))) + g7878))) + (even? + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 (modulo x 2))) + (= 0 x7885)))) + g7884))) + (list->string + (lambda (l) + (letrec ((g7886 + (letrec ((x7888 (list? l))) + (assert x7888))) + (g7887 + (letrec ((x-cnd7889 (null? l))) + (if x-cnd7889 + "" + (letrec ((x7892 + (letrec ((x7893 + (car l))) + (char->string + x7893))) + (x7890 + (letrec ((x7891 + (cdr l))) + (list->string + x7891)))) + (string-append + x7892 + x7890)))))) + g7887))) + (char<=? + (lambda (c1 c2) + (letrec ((g7894 + (letrec ((x7897 (char? c1))) + (assert x7897))) + (g7895 + (letrec ((x7898 (char? c2))) + (assert x7898))) + (g7896 + (letrec ((val7143 (char=? c x7915)))) + (if x-cnd7914 + (letrec ((x7916 #\z)) + (char-ci<=? c x7916)) + #f)))) + g7913))) + (<= + (lambda (x y) + (letrec ((g7917 + (letrec ((x7919 (number? x))) + (assert x7919))) + (g7918 + (letrec ((val7144 (< x y))) + (letrec ((g7920 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7921 + (if val7145 + val7145 + #f))) + g7921))))) + g7920)))) + g7918))) + (char-whitespace? + (lambda (c) + (letrec ((g7922 + (letrec ((val7146 + (letrec ((x7923 + (char->integer + c))) + (= x7923 9)))) + (letrec ((g7924 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7925 + (char->integer + c))) + (= + x7925 + 10)))) + (letrec ((g7926 + (if val7147 + val7147 + (letrec ((x7927 + (char->integer + c))) + (= + x7927 + 32))))) + g7926))))) + g7924)))) + g7922))) + (cddar + (lambda (x) + (letrec ((g7928 + (letrec ((x7929 + (letrec ((x7930 (car x))) + (cdr x7930)))) + (cdr x7929)))) + g7928))) + (positive? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 (> x 0))) + g7932))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7934 #f)) g7934))) + (cddr + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 (cdr x))) + (cdr x7936)))) + g7935))) + (truncate + (lambda (x) + (letrec ((g7937 + (letrec ((x7939 (number? x))) + (assert x7939))) + (g7938 + (letrec ((x-cnd7940 (< x 0))) + (if x-cnd7940 + (ceiling x) + (floor x))))) + g7938))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7941 + (letrec ((val7148 (eq? a b))) + (letrec ((g7942 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7944 + (null? + a)) + (x7943 + (null? + b))) + (and x7944 + x7943)))) + (letrec ((g7945 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7948 + (string? + a)) + (x7947 + (string? + b)) + (x7946 + (string=? + a + b))) + (and x7948 + x7947 + x7946)))) + (letrec ((g7949 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7957 + (pair? + a)) + (x7956 + (pair? + b)) + (x7953 + (letrec ((x7955 + (car + a)) + (x7954 + (car + b))) + (equal? + x7955 + x7954))) + (x7950 + (letrec ((x7952 + (cdr + a)) + (x7951 + (cdr + b))) + (equal? + x7952 + x7951)))) + (and x7957 + x7956 + x7953 + x7950)))) + (letrec ((g7958 + (if val7151 + val7151 + (letrec ((x7977 + (vector? + a)) + (x7976 + (vector? + b)) + (x7959 + (letrec ((x7973 + (letrec ((x7974 + (letrec ((x7975 + (vector-length + a))) + (n + x7975)))) + (x7974))) + (x7960 + (letrec ((x7971 + (letrec ((x7972 + (vector-length + b))) + (= + x7972 + n))) + (x7961 + (letrec ((loop + (lambda (i) + (letrec ((g7962 + (letrec ((x7969 + (= + i + n)) + (x7963 + (letrec ((x7966 + (letrec ((x7968 + (vector-ref + a + i)) + (x7967 + (vector-ref + b + i))) + (equal? + x7968 + x7967))) + (x7964 + (letrec ((x7965 + (+ + i + 1))) + (loop + x7965)))) + (and x7966 + x7964)))) + (or x7969 + x7963)))) + g7962)))) + (letrec ((g7970 + (loop + 0))) + g7970)))) + (and x7971 + x7961)))) + (let x7973 x7960)))) + (and x7977 + x7976 + x7959))))) + g7958))))) + g7949))))) + g7945))))) + g7942)))) + g7941))) + (cdaaar + (lambda (x) + (letrec ((g7978 + (letrec ((x7979 + (letrec ((x7980 + (letrec ((x7981 + (car + x))) + (car + x7981)))) + (car x7980)))) + (cdr x7979)))) + g7978))) + (caaddr + (lambda (x) + (letrec ((g7982 + (letrec ((x7983 + (letrec ((x7984 + (letrec ((x7985 + (cdr + x))) + (cdr + x7985)))) + (car x7984)))) + (car x7983)))) + g7982))) + (eqv? + (lambda (x y) + (letrec ((g7986 (eq? x y))) g7986))) + (>= + (lambda (x y) + (letrec ((g7987 + (letrec ((x7989 (number? x))) + (assert x7989))) + (g7988 + (letrec ((val7152 (> x y))) + (letrec ((g7990 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7991 + (if val7153 + val7153 + #f))) + g7991))))) + g7990)))) + g7988))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7992 + (letrec ((x7995 + (string? filename))) + (assert x7995))) + (g7993 + (letrec ((x7996 (procedure? proc))) + (assert x7996))) + (g7994 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7997 + (close-input-port + input-port)) + (g7998 res)) + g7998)))) + g7994))) + (ref + (lambda (x) + (letrec ((g7999 (cons x '()))) g7999))) + (char>=? + (lambda (c1 c2) + (letrec ((g8000 + (letrec ((x8003 (char? c1))) + (assert x8003))) + (g8001 + (letrec ((x8004 (char? c2))) + (assert x8004))) + (g8002 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g8005 + (if val7154 + val7154 + (char=? c1 c2)))) + g8005)))) + g8002))) + (cdaar + (lambda (x) + (letrec ((g8006 + (letrec ((x8007 + (letrec ((x8008 (car x))) + (car x8008)))) + (cdr x8007)))) + g8006))) + (cdaddr + (lambda (x) + (letrec ((g8009 + (letrec ((x8010 + (letrec ((x8011 + (letrec ((x8012 + (cdr + x))) + (cdr + x8012)))) + (car x8011)))) + (cdr x8010)))) + g8009))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g8013 + (letrec ((x8014 + (letrec ((x8015 (car x))) + (cdr x8015)))) + (car x8014)))) + g8013))) + (caadr + (lambda (x) + (letrec ((g8016 + (letrec ((x8017 + (letrec ((x8018 (cdr x))) + (car x8018)))) + (car x8017)))) + g8016))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g8019 + (letrec ((x8022 (char? c1))) + (assert x8022))) + (g8020 + (letrec ((x8023 (char? c2))) + (assert x8023))) + (g8021 + (letrec ((x8024 + (char-ci<=? c1 c2))) + (not x8024)))) + g8021))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g8025 + (letrec ((x8026 + (letrec ((x8027 + (letrec ((x8028 + (car + x))) + (car + x8028)))) + (car x8027)))) + (car x8026)))) + g8025))) + (negative? + (lambda (x) + (letrec ((g8029 + (letrec ((x8031 (number? x))) + (assert x8031))) + (g8030 (< x 0))) + g8030))) + (memv + (lambda (e l) + (letrec ((g8032 (memq e l))) g8032))) + (caaar + (lambda (x) + (letrec ((g8033 + (letrec ((x8034 + (letrec ((x8035 (car x))) + (car x8035)))) + (car x8034)))) + g8033))) + (debug + (lambda (e) (letrec ((g8036 '())) g8036))) + (reverse + (lambda (l) + (letrec ((g8037 + (letrec ((x8039 (list? l))) + (assert x8039))) + (g8038 + (letrec ((x-cnd8040 (null? l))) + (if x-cnd8040 + '() + (letrec ((x8043 + (letrec ((x8044 + (cdr l))) + (reverse x8044))) + (x8041 + (letrec ((x8042 + (car l))) + (list x8042)))) + (append x8043 x8041)))))) + g8038))) + (caaadr + (lambda (x) + (letrec ((g8045 + (letrec ((x8046 + (letrec ((x8047 + (letrec ((x8048 + (cdr + x))) + (car + x8048)))) + (car x8047)))) + (car x8046)))) + g8045))) + (cddadr + (lambda (x) + (letrec ((g8049 + (letrec ((x8050 + (letrec ((x8051 + (letrec ((x8052 + (cdr + x))) + (car + x8052)))) + (cdr x8051)))) + (cdr x8050)))) + g8049))) + (odd? + (lambda (x) + (letrec ((g8053 + (letrec ((x8055 (number? x))) + (assert x8055))) + (g8054 + (letrec ((x8056 (modulo x 2))) + (= 1 x8056)))) + g8054))) + (caadar + (lambda (x) + (letrec ((g8057 + (letrec ((x8058 + (letrec ((x8059 + (letrec ((x8060 + (car + x))) + (cdr + x8060)))) + (car x8059)))) + (car x8058)))) + g8057))) + (apply + (lambda (proc args) + (letrec ((g8061 + (letrec ((x8064 (procedure? proc))) + (assert x8064))) + (g8062 + (letrec ((x8065 (list? args))) + (assert x8065))) + (g8063 + (if cnd + (letrec ((g8066 (proc))) g8066) + (if cnd + (letrec ((g8067 + (letrec ((x8068 + (car + args))) + (proc x8068)))) + g8067) + (if cnd + (letrec ((g8069 + (letrec ((x8071 + (car + args)) + (x8070 + (cadr + args))) + (proc + x8071 + x8070)))) + g8069) + (if cnd + (letrec ((g8072 + (letrec ((x8075 + (car + args)) + (x8074 + (cadr + args)) + (x8073 + (caddr + args))) + (proc + x8075 + x8074 + x8073)))) + g8072) + (if cnd + (letrec ((g8076 + (letrec ((x8080 + (car + args)) + (x8079 + (cadr + args)) + (x8078 + (caddr + args)) + (x8077 + (cadddr + args))) + (proc + x8080 + x8079 + x8078 + x8077)))) + g8076) + (if cnd + (letrec ((g8081 + (letrec ((x8087 + (car + args)) + (x8086 + (cadr + args)) + (x8085 + (caddr + args)) + (x8084 + (cadddr + args)) + (x8082 + (letrec ((x8083 + (cddddr + args))) + (car + x8083)))) + (proc + x8087 + x8086 + x8085 + x8084 + x8082)))) + g8081) + (if cnd + (letrec ((g8088 + (letrec ((x8096 + (car + args)) + (x8095 + (cadr + args)) + (x8094 + (caddr + args)) + (x8093 + (cadddr + args)) + (x8091 + (letrec ((x8092 + (cddddr + args))) + (car + x8092))) + (x8089 + (letrec ((x8090 + (cddddr + args))) + (cadr + x8090)))) + (proc + x8096 + x8095 + x8094 + x8093 + x8091 + x8089)))) + g8088) + (if cnd + (letrec ((g8097 + (letrec ((x8107 + (car + args)) + (x8106 + (cadr + args)) + (x8105 + (caddr + args)) + (x8104 + (cadddr + args)) + (x8102 + (letrec ((x8103 + (cddddr + args))) + (car + x8103))) + (x8100 + (letrec ((x8101 + (cddddr + args))) + (cadr + x8101))) + (x8098 + (letrec ((x8099 + (cddddr + args))) + (caddr + x8099)))) + (proc + x8107 + x8106 + x8105 + x8104 + x8102 + x8100 + x8098)))) + g8097) + (letrec ((g8108 + (error + "Unsupported call."))) + g8108))))))))))) + g8063))) + (member + (lambda (e l) + (letrec ((g8109 + (letrec ((x8111 (list? l))) + (assert x8111))) + (g8110 + (letrec ((x-cnd8112 (null? l))) + (if x-cnd8112 + #f + (letrec ((x-cnd8113 + (letrec ((x8114 + (car l))) + (equal? x8114 e)))) + (if x-cnd8113 + l + (letrec ((x8115 (cdr l))) + (member e x8115)))))))) + g8110))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8116 + (letrec ((x8117 + (letrec ((x8118 + (letrec ((x8119 + (cdr + x))) + (cdr + x8119)))) + (cdr x8118)))) + (cdr x8117)))) + g8116))) + (cadddr + (lambda (x) + (letrec ((g8120 + (letrec ((x8121 + (letrec ((x8122 + (letrec ((x8123 + (cdr + x))) + (cdr + x8123)))) + (cdr x8122)))) + (car x8121)))) + g8120))) + (int-top + (lambda () + (letrec ((g8124 (random 42))) g8124))) + (zero? + (lambda (x) + (letrec ((g8125 + (letrec ((x8127 (number? x))) + (assert x8127))) + (g8126 (= x 0))) + g8126))) + (string>=? + (lambda (s1 s2) + (letrec ((g8128 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8129 + (if val7155 + val7155 + (string=? s1 s2)))) + g8129)))) + g8128))) + (cadr + (lambda (x) + (letrec ((g8130 + (letrec ((x8131 (cdr x))) + (car x8131)))) + g8130))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8132 + (letrec ((val7156 + (letrec ((x8135 + (pair? l)) + (x8133 + (letrec ((x8134 + (cdr + l))) + (list? + x8134)))) + (and x8135 x8133)))) + (letrec ((g8136 + (if val7156 + val7156 + (null? l)))) + g8136)))) + g8132))) + (cddaar + (lambda (x) + (letrec ((g8137 + (letrec ((x8138 + (letrec ((x8139 + (letrec ((x8140 + (car + x))) + (car + x8140)))) + (cdr x8139)))) + (cdr x8138)))) + g8137))) + (char-numeric? + (lambda (c) + (letrec ((g8141 + (letrec ((x-cnd8142 + (letrec ((x8143 #\0)) + (char<=? x8143 c)))) + (if x-cnd8142 + (letrec ((x8144 #\9)) + (char<=? c x8144)) + #f)))) + g8141))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8145 + (letrec ((x8147 (list? l))) + (assert x8147))) + (g8146 + (letrec ((x-cnd8148 (null? l))) + (if x-cnd8148 + #f + (letrec ((x-cnd8149 + (letrec ((x8150 + (caar l))) + (eqv? x8150 k)))) + (if x-cnd8149 + (car l) + (letrec ((x8151 (cdr l))) + (assq k x8151)))))))) + g8146))) + (not + (lambda (x) + (letrec ((g8152 (if x #f #t))) g8152))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8153 (append l1 l2))) g8153))) + (memq + (lambda (e l) + (letrec ((g8154 + (letrec ((x8156 (list? l))) + (assert x8156))) + (g8155 + (letrec ((x-cnd8157 (null? l))) + (if x-cnd8157 + #f + (letrec ((x-cnd8158 + (letrec ((x8159 + (car l))) + (eq? x8159 e)))) + (if x-cnd8158 + l + (letrec ((x8160 (cdr l))) + (memq e x8160)))))))) + g8155))) + (cadaar + (lambda (x) + (letrec ((g8161 + (letrec ((x8162 + (letrec ((x8163 + (letrec ((x8164 + (car + x))) + (car + x8164)))) + (cdr x8163)))) + (car x8162)))) + g8161))) + (length + (lambda (l) + (letrec ((g8165 + (letrec ((x8167 (list? l))) + (assert x8167))) + (g8166 + (letrec ((rec + (lambda (l) + (letrec ((g8168 + (letrec ((x-cnd8169 + (null? + l))) + (if x-cnd8169 + 0 + (letrec ((x8170 + (letrec ((x8171 + (cdr + l))) + (rec + x8171)))) + (+ + 1 + x8170)))))) + g8168)))) + (letrec ((g8172 (rec l))) + g8172)))) + g8166))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8173 + (letrec ((x8176 (char? c1))) + (assert x8176))) + (g8174 + (letrec ((x8177 (char? c2))) + (assert x8177))) + (g8175 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8179 + (letrec ((x8180 (string<=? s1 s2))) + (not x8180)))) + g8179))) + (cdadr + (lambda (x) + (letrec ((g8181 + (letrec ((x8182 + (letrec ((x8183 (cdr x))) + (car x8183)))) + (cdr x8182)))) + g8181))) + (assoc + (lambda (k l) + (letrec ((g8184 + (letrec ((x8186 (list? l))) + (assert x8186))) + (g8185 + (letrec ((x-cnd8187 (null? l))) + (if x-cnd8187 + #f + (letrec ((x-cnd8188 + (letrec ((x8189 + (caar l))) + (equal? x8189 k)))) + (if x-cnd8188 + (car l) + (letrec ((x8190 (cdr l))) + (assoc k x8190)))))))) + g8185))) + (caar + (lambda (x) + (letrec ((g8191 + (letrec ((x8192 (car x))) + (car x8192)))) + g8191))) + (char>? + (lambda (c1 c2) + (letrec ((g8193 + (letrec ((x8196 (char? c1))) + (assert x8196))) + (g8194 + (letrec ((x8197 (char? c2))) + (assert x8197))) + (g8195 + (letrec ((x8198 (char<=? c1 c2))) + (not x8198)))) + g8195))) + (string<=? + (lambda (s1 s2) + (letrec ((g8199 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8216 + (letrec ((x8219 (char? c1))) + (assert x8219))) + (g8217 + (letrec ((x8220 (char? c2))) + (assert x8220))) + (g8218 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8221 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8221)))) + g8218))) + (caddar + (lambda (x) + (letrec ((g8222 + (letrec ((x8223 + (letrec ((x8224 + (letrec ((x8225 + (car + x))) + (cdr + x8225)))) + (cdr x8224)))) + (car x8223)))) + g8222))) + (newline + (lambda () (letrec ((g8226 #f)) g8226))) + (lcm + (lambda (m n) + (letrec ((g8227 + (letrec ((x8229 + (letrec ((x8230 (* m n))) + (abs x8230))) + (x8228 (gcd m n))) + (/ x8229 x8228)))) + g8227))) + (deref car) + (> + (lambda (x y) + (letrec ((g8231 + (letrec ((x8233 (number? x))) + (assert x8233))) + (g8232 + (letrec ((x8234 (<= x y))) + (not x8234)))) + g8232))) + (list-ref + (lambda (l index) + (letrec ((g8235 + (letrec ((x8239 (list? l))) + (assert x8239))) + (g8236 + (letrec ((x8240 (number? index))) + (assert x8240))) + (g8237 + (letrec ((x8241 + (letrec ((x8242 + (length l))) + (< index x8242)))) + (assert x8241))) + (g8238 + (letrec ((x-cnd8243 (= index 0))) + (if x-cnd8243 + (car l) + (letrec ((x8245 (cdr l)) + (x8244 (- index 1))) + (list-ref x8245 x8244)))))) + g8238))) + (gcd + (lambda (a b) + (letrec ((g8246 + (letrec ((x-cnd8247 (= b 0))) + (if x-cnd8247 + a + (letrec ((x8248 (modulo a b))) + (gcd b x8248)))))) + g8246)))) + (letrec ((g8249 + (letrec ((g8250 + (letrec ((image + (lambda () + (letrec ((g8251 + (cons + 'image + '()))) + g8251))) + (image? + (lambda (image7335) + (letrec ((g8252 + (letrec ((x8253 + (car + image7335))) + (eq? + x8253 + 'image)))) + g8252))) + (image + (lambda () + (letrec ((g8254 + (cons + 'image + '()))) + g8254))) + (image? + (lambda (image7335) + (letrec ((g8255 + (letrec ((x8256 + (car + image7335))) + (eq? + x8256 + 'image)))) + g8255))) + (image/c + (lambda (j7234 + k7235 + v7233) + (letrec ((g8257 + (cons + image + '()))) + g8257))) + (circle + (lambda (r m c) + (letrec ((g8258 + (image))) + g8258))) + (empty-scene + (lambda (w h) + (letrec ((g8259 + (image))) + g8259))) + (place-image + (lambda (i₁ r c i₂) + (letrec ((g8260 + (image))) + g8260)))) + (letrec ((g8261 + (letrec ((posn + (lambda (x7337 + y7338) + (letrec ((g8262 + (letrec ((x8263 + (letrec ((x8264 + (cons + y7338 + '()))) + (cons + x7337 + x8264)))) + (cons + 'posn + x8263)))) + g8262))) + (posn? + (lambda (posn7336) + (letrec ((g8265 + (letrec ((x8266 + (car + posn7336))) + (eq? + x8266 + 'posn)))) + g8265))) + (posn-x + (lambda (posn) + (letrec ((g8267 + (letrec ((x8268 + (cdr + posn))) + (car + x8268)))) + g8267))) + (posn-y + (lambda (posn) + (letrec ((g8269 + (letrec ((x8270 + (letrec ((x8271 + (cdr + posn))) + (cdr + x8271)))) + (car + x8270)))) + g8269))) + (posn + (lambda (x7337 + y7338) + (letrec ((g8272 + (letrec ((x8273 + (letrec ((x8274 + (cons + y7338 + '()))) + (cons + x7337 + x8274)))) + (cons + 'posn + x8273)))) + g8272))) + (posn? + (lambda (posn7336) + (letrec ((g8275 + (letrec ((x8276 + (car + posn7336))) + (eq? + x8276 + 'posn)))) + g8275))) + (posn-x + (lambda (posn) + (letrec ((g8277 + (letrec ((x8278 + (cdr + posn))) + (car + x8278)))) + g8277))) + (posn-y + (lambda (posn) + (letrec ((g8279 + (letrec ((x8280 + (letrec ((x8281 + (cdr + posn))) + (cdr + x8281)))) + (car + x8280)))) + g8279))) + (posn=? + (lambda (p1 + p2) + (letrec ((g8282 + (letrec ((x-cnd8283 + (letrec ((x8285 + (posn-x + p1)) + (x8284 + (posn-x + p2))) + (= + x8285 + x8284)))) + (if x-cnd8283 + (letrec ((x8287 + (posn-y + p1)) + (x8286 + (posn-y + p2))) + (= + x8287 + x8286)) + #f)))) + g8282)))) + (letrec ((g8288 + (letrec ((snake + (lambda (dir7342 + segs7343) + (letrec ((g8289 + (letrec ((x8290 + (letrec ((x8291 + (cons + segs7343 + '()))) + (cons + dir7342 + x8291)))) + (cons + 'snake + x8290)))) + g8289))) + (snake? + (lambda (snake7341) + (letrec ((g8292 + (letrec ((x8293 + (car + snake7341))) + (eq? + x8293 + 'snake)))) + g8292))) + (snake-dir + (lambda (snake) + (letrec ((g8294 + (letrec ((x8295 + (cdr + snake))) + (car + x8295)))) + g8294))) + (snake-segs + (lambda (snake) + (letrec ((g8296 + (letrec ((x8297 + (letrec ((x8298 + (cdr + snake))) + (cdr + x8298)))) + (car + x8297)))) + g8296))) + (snake + (lambda (dir7342 + segs7343) + (letrec ((g8299 + (letrec ((x8300 + (letrec ((x8301 + (cons + segs7343 + '()))) + (cons + dir7342 + x8301)))) + (cons + 'snake + x8300)))) + g8299))) + (snake? + (lambda (snake7341) + (letrec ((g8302 + (letrec ((x8303 + (car + snake7341))) + (eq? + x8303 + 'snake)))) + g8302))) + (snake-dir + (lambda (snake) + (letrec ((g8304 + (letrec ((x8305 + (cdr + snake))) + (car + x8305)))) + g8304))) + (snake-segs + (lambda (snake) + (letrec ((g8306 + (letrec ((x8307 + (letrec ((x8308 + (cdr + snake))) + (cdr + x8308)))) + (car + x8307)))) + g8306)))) + (letrec ((g8309 + (letrec ((world + (lambda (snake7347 + food7348) + (letrec ((g8310 + (letrec ((x8311 + (letrec ((x8312 + (cons + food7348 + '()))) + (cons + snake7347 + x8312)))) + (cons + 'world + x8311)))) + g8310))) + (world? + (lambda (world7346) + (letrec ((g8313 + (letrec ((x8314 + (car + world7346))) + (eq? + x8314 + 'world)))) + g8313))) + (world-snake + (lambda (world) + (letrec ((g8315 + (letrec ((x8316 + (cdr + world))) + (car + x8316)))) + g8315))) + (world-food + (lambda (world) + (letrec ((g8317 + (letrec ((x8318 + (letrec ((x8319 + (cdr + world))) + (cdr + x8319)))) + (car + x8318)))) + g8317))) + (world + (lambda (snake7347 + food7348) + (letrec ((g8320 + (letrec ((x8321 + (letrec ((x8322 + (cons + food7348 + '()))) + (cons + snake7347 + x8322)))) + (cons + 'world + x8321)))) + g8320))) + (world? + (lambda (world7346) + (letrec ((g8323 + (letrec ((x8324 + (car + world7346))) + (eq? + x8324 + 'world)))) + g8323))) + (world-snake + (lambda (world) + (letrec ((g8325 + (letrec ((x8326 + (cdr + world))) + (car + x8326)))) + g8325))) + (world-food + (lambda (world) + (letrec ((g8327 + (letrec ((x8328 + (letrec ((x8329 + (cdr + world))) + (cdr + x8329)))) + (car + x8328)))) + g8327))) + (DIR/C + (lambda (g7240 + g7241 + g7242) + (letrec ((g8330 + (letrec ((x-cnd8331 + ((lambda (v7239) + (if (eq? + 'up + v7239) + #t + (if (eq? + 'down + v7239) + #t + (if (eq? + 'left + v7239) + #t + (eq? + 'right + v7239))))) + g7242))) + (if x-cnd8331 + g7242 + (blame + g7240 + '(lambda (v7239) + (if (eq? + 'up + v7239) + #t + (if (eq? + 'down + v7239) + #t + (if (eq? + 'left + v7239) + #t + (eq? + 'right + v7239)))))))))) + g8330))) + (POSN/C + (lambda (j7244 + k7245 + v7243) + (letrec ((g8332 + (letrec ((checked7246 + (letrec ((x8333 + (car + v7243))) + (real?/c + 'j7244 + 'k7245 + x8333)))) + (letrec ((g8334 + (letrec ((checked7247 + (letrec ((x8335 + (letrec ((x8336 + (cdr + v7243))) + (car + x8336)))) + (real?/c + 'j7244 + 'k7245 + x8335)))) + (letrec ((g8337 + (letrec ((x8338 + (letrec ((x8339 + (cons + checked7247 + '()))) + (cons + checked7246 + x8339)))) + (cons + posn + x8338)))) + g8337)))) + g8334)))) + g8332))) + (SNAKE/C + (lambda (j7250 + k7251 + v7249) + (letrec ((g8340 + (letrec ((checked7252 + (letrec ((x8341 + (car + v7249))) + (DIR/C + 'j7250 + 'k7251 + x8341)))) + (letrec ((g8342 + (letrec ((checked7253 + (letrec ((x8345 + (letrec ((x8346 + (listof + POSN/C))) + (and/c + cons?/c + x8346))) + (x8343 + (letrec ((x8344 + (cdr + v7249))) + (car + x8344)))) + (x8345 + 'j7250 + 'k7251 + x8343)))) + (letrec ((g8347 + (letrec ((x8348 + (letrec ((x8349 + (cons + checked7253 + '()))) + (cons + checked7252 + x8349)))) + (cons + snake + x8348)))) + g8347)))) + g8342)))) + g8340))) + (WORLD/C + (lambda (j7256 + k7257 + v7255) + (letrec ((g8350 + (letrec ((checked7258 + (letrec ((x8351 + (car + v7255))) + (SNAKE/C + 'j7256 + 'k7257 + x8351)))) + (letrec ((g8352 + (letrec ((checked7259 + (letrec ((x8353 + (letrec ((x8354 + (cdr + v7255))) + (car + x8354)))) + (POSN/C + 'j7256 + 'k7257 + x8353)))) + (letrec ((g8355 + (letrec ((x8356 + (letrec ((x8357 + (cons + checked7259 + '()))) + (cons + checked7258 + x8357)))) + (cons + world + x8356)))) + g8355)))) + g8352)))) + g8350))) + (GRID-SIZE + 30) + (BOARD-HEIGHT + 20) + (BOARD-WIDTH + 30) + (BOARD-HEIGHT-PIXELS + (* + GRID-SIZE + BOARD-HEIGHT)) + (BOARD-WIDTH-PIXELS + (* + GRID-SIZE + BOARD-WIDTH)) + (BACKGROUND + (empty-scene + BOARD-WIDTH-PIXELS + BOARD-HEIGHT-PIXELS)) + (SEGMENT-RADIUS + (/ + GRID-SIZE + 2)) + (SEGMENT-IMAGE + (circle + SEGMENT-RADIUS + "solid" + "red")) + (FOOD-RADIUS + SEGMENT-RADIUS) + (FOOD-IMAGE + (circle + FOOD-RADIUS + "solid" + "green")) + (WORLD + (letrec ((x8359 + (letrec ((x8360 + (letrec ((x8361 + (posn + 5 + 3))) + (cons + x8361 + empty)))) + (snake + 'right + x8360))) + (x8358 + (posn + 8 + 12))) + (world + x8359 + x8358))) + (snake-wall-collide? + (lambda (snk) + (letrec ((g8362 + (letrec ((x8363 + (letrec ((x8364 + (snake-segs + snk))) + (car + x8364)))) + (head-collide? + x8363)))) + g8362))) + (head-collide? + (lambda (p) + (letrec ((g8365 + (letrec ((val7160 + (letrec ((x8366 + (posn-x + p))) + (<= + x8366 + 0)))) + (letrec ((g8367 + (if val7160 + val7160 + (letrec ((val7161 + (letrec ((x8368 + (posn-x + p))) + (>= + x8368 + BOARD-WIDTH)))) + (letrec ((g8369 + (if val7161 + val7161 + (letrec ((val7162 + (letrec ((x8370 + (posn-y + p))) + (<= + x8370 + 0)))) + (letrec ((g8371 + (if val7162 + val7162 + (letrec ((x8372 + (posn-y + p))) + (>= + x8372 + BOARD-HEIGHT))))) + g8371))))) + g8369))))) + g8367)))) + g8365))) + (snake-self-collide? + (lambda (snk) + (letrec ((g8373 + (letrec ((x8376 + (letrec ((x8377 + (snake-segs + snk))) + (car + x8377))) + (x8374 + (letrec ((x8375 + (snake-segs + snk))) + (cdr + x8375)))) + (segs-self-collide? + x8376 + x8374)))) + g8373))) + (segs-self-collide? + (lambda (h + segs) + (letrec ((g8378 + (if cnd + (letrec ((g8379 + #f)) + g8379) + (letrec ((g8380 + (letrec ((x8383 + (letrec ((x8384 + (car + segs))) + (posn=? + x8384 + h))) + (x8381 + (letrec ((x8382 + (cdr + segs))) + (segs-self-collide? + h + x8382)))) + (or x8383 + x8381)))) + g8380)))) + g8378))) + (cut-tail + (lambda (segs) + (letrec ((g8385 + (letrec ((r + (cdr + segs))) + (letrec ((g8386 + (if cnd + (letrec ((g8387 + empty)) + g8387) + (letrec ((g8388 + (letrec ((x8390 + (car + segs)) + (x8389 + (cut-tail + r))) + (cons + x8390 + x8389)))) + g8388)))) + g8386)))) + g8385))) + (next-head + (lambda (seg + dir) + (letrec ((g8391 + (if cnd + (letrec ((g8392 + (letrec ((x8394 + (letrec ((x8395 + (posn-x + seg))) + (add1 + x8395))) + (x8393 + (posn-y + seg))) + (posn + x8394 + x8393)))) + g8392) + (if cnd + (letrec ((g8396 + (letrec ((x8398 + (letrec ((x8399 + (posn-x + seg))) + (sub1 + x8399))) + (x8397 + (posn-y + seg))) + (posn + x8398 + x8397)))) + g8396) + (if cnd + (letrec ((g8400 + (letrec ((x8403 + (posn-x + seg)) + (x8401 + (letrec ((x8402 + (posn-y + seg))) + (sub1 + x8402)))) + (posn + x8403 + x8401)))) + g8400) + (letrec ((g8404 + (letrec ((x8407 + (posn-x + seg)) + (x8405 + (letrec ((x8406 + (posn-y + seg))) + (add1 + x8406)))) + (posn + x8407 + x8405)))) + g8404)))))) + g8391))) + (snake-slither + (lambda (snk) + (letrec ((g8408 + (letrec ((d + (snake-dir + snk))) + (letrec ((g8409 + (letrec ((x8410 + (letrec ((x8413 + (letrec ((x8414 + (letrec ((x8415 + (snake-segs + snk))) + (car + x8415)))) + (next-head + x8414 + d))) + (x8411 + (letrec ((x8412 + (snake-segs + snk))) + (cut-tail + x8412)))) + (cons + x8413 + x8411)))) + (snake + d + x8410)))) + g8409)))) + g8408))) + (snake-grow + (lambda (snk) + (letrec ((g8416 + (letrec ((d + (snake-dir + snk))) + (letrec ((g8417 + (letrec ((x8418 + (letrec ((x8420 + (letrec ((x8421 + (letrec ((x8422 + (snake-segs + snk))) + (car + x8422)))) + (next-head + x8421 + d))) + (x8419 + (snake-segs + snk))) + (cons + x8420 + x8419)))) + (snake + d + x8418)))) + g8417)))) + g8416))) + (world->world + (lambda (w) + (letrec ((g8423 + (if cnd + (letrec ((g8424 + (snake-eat + w))) + g8424) + (letrec ((g8425 + (letrec ((x8427 + (letrec ((x8428 + (world-snake + w))) + (snake-slither + x8428))) + (x8426 + (world-food + w))) + (world + x8427 + x8426)))) + g8425)))) + g8423))) + (eating? + (lambda (w) + (letrec ((g8429 + (letrec ((x8433 + (world-food + w)) + (x8430 + (letrec ((x8431 + (letrec ((x8432 + (world-snake + w))) + (snake-segs + x8432)))) + (car + x8431)))) + (posn=? + x8433 + x8430)))) + g8429))) + (snake-change-direction + (lambda (snk + dir) + (letrec ((g8434 + (letrec ((x8435 + (snake-segs + snk))) + (snake + dir + x8435)))) + g8434))) + (world-change-dir + (lambda (w + dir) + (letrec ((g8436 + (letrec ((x8438 + (letrec ((x8439 + (world-snake + w))) + (snake-change-direction + x8439 + dir))) + (x8437 + (world-food + w))) + (world + x8438 + x8437)))) + g8436))) + (snake-eat + (lambda (w) + (letrec ((g8440 + (letrec ((x8444 + (letrec ((x8445 + (world-snake + w))) + (snake-grow + x8445))) + (x8441 + (letrec ((x8443 + (- + BOARD-WIDTH + 1)) + (x8442 + (- + BOARD-HEIGHT + 1))) + (posn + x8443 + x8442)))) + (world + x8444 + x8441)))) + g8440))) + (handle-key + (lambda (w + ke) + (letrec ((g8446 + (if cnd + (letrec ((g8447 + (world-change-dir + w + 'up))) + g8447) + (if cnd + (letrec ((g8448 + (world-change-dir + w + 'down))) + g8448) + (if cnd + (letrec ((g8449 + (world-change-dir + w + 'left))) + g8449) + (if cnd + (letrec ((g8450 + (world-change-dir + w + 'right))) + g8450) + (letrec ((g8451 + w)) + g8451))))))) + g8446))) + (game-over? + (lambda (w) + (letrec ((g8452 + (letrec ((val7163 + (letrec ((x8453 + (world-snake + w))) + (snake-wall-collide? + x8453)))) + (letrec ((g8454 + (if val7163 + val7163 + (letrec ((x8455 + (world-snake + w))) + (snake-self-collide? + x8455))))) + g8454)))) + g8452))) + (world->scene + (lambda (w) + (letrec ((g8456 + (letrec ((x8459 + (world-snake + w)) + (x8457 + (letrec ((x8458 + (world-food + w))) + (food+scene + x8458 + BACKGROUND)))) + (snake+scene + x8459 + x8457)))) + g8456))) + (food+scene + (lambda (f + scn) + (letrec ((g8460 + (letrec ((x8462 + (posn-x + f)) + (x8461 + (posn-y + f))) + (place-image-on-grid + FOOD-IMAGE + x8462 + x8461 + scn)))) + g8460))) + (place-image-on-grid + (lambda (img + x + y + scn) + (letrec ((g8463 + (letrec ((x8466 + (* + GRID-SIZE + x)) + (x8464 + (letrec ((x8465 + (* + GRID-SIZE + y))) + (- + BOARD-HEIGHT-PIXELS + x8465)))) + (place-image + img + x8466 + x8464 + scn)))) + g8463))) + (snake+scene + (lambda (snk + scn) + (letrec ((g8467 + (letrec ((x8468 + (snake-segs + snk))) + (segments+scene + x8468 + scn)))) + g8467))) + (segments+scene + (lambda (segs + scn) + (letrec ((g8469 + (if cnd + (letrec ((g8470 + scn)) + g8470) + (letrec ((g8471 + (letrec ((x8474 + (cdr + segs)) + (x8472 + (letrec ((x8473 + (car + segs))) + (segment+scene + x8473 + scn)))) + (segments+scene + x8474 + x8472)))) + g8471)))) + g8469))) + (segment+scene + (lambda (seg + scn) + (letrec ((g8475 + (letrec ((x8477 + (posn-x + seg)) + (x8476 + (posn-y + seg))) + (place-image-on-grid + SEGMENT-IMAGE + x8477 + x8476 + scn)))) + g8475)))) + (letrec ((g8478 + (letrec ((g8479 + (letrec ((g8480 + (letrec ((x8514 + ((lambda (j7263 + k7264 + f7265) + (lambda (g7261 + g7262) + (boolean?/c + j7263 + k7264 + (f7265 + (POSN/C + j7263 + k7264 + g7261) + (POSN/C + j7263 + k7264 + g7262))))) + 'module + 'importer + posn=?)) + (x8509 + (letrec ((x8510 + (letrec ((x8513 + (input)) + (x8511 + (letrec ((x8512 + (input))) + (cons + x8512 + '())))) + (cons + x8513 + x8511)))) + (cons + 'posn + x8510))) + (x8504 + (letrec ((x8505 + (letrec ((x8508 + (input)) + (x8506 + (letrec ((x8507 + (input))) + (cons + x8507 + '())))) + (cons + x8508 + x8506)))) + (cons + 'posn + x8505)))) + (x8514 + x8509 + x8504))) + (g8481 + (WORLD/C + 'module + 'importer + WORLD)) + (g8482 + (image/c + 'module + 'importer + BACKGROUND)) + (g8483 + (image/c + 'module + 'importer + FOOD-IMAGE)) + (g8484 + (image/c + 'module + 'importer + SEGMENT-IMAGE)) + (g8485 + (real? + 'module + 'importer + GRID-SIZE)) + (g8486 + (real? + 'module + 'importer + BOARD-HEIGHT-PIXELS)) + (g8487 + (real? + 'module + 'importer + BOARD-WIDTH)) + (g8488 + (real? + 'module + 'importer + BOARD-HEIGHT)) + (g8489 + (letrec ((x8520 + ((lambda (j7267 + k7268 + f7269) + (lambda (g7266) + (boolean?/c + j7267 + k7268 + (f7269 + (SNAKE/C + j7267 + k7268 + g7266))))) + 'module + 'importer + snake-wall-collide?)) + (x8515 + (letrec ((x8516 + (letrec ((x8519 + (input)) + (x8517 + (letrec ((x8518 + (input))) + (cons + x8518 + '())))) + (cons + x8519 + x8517)))) + (cons + 'snake + x8516)))) + (x8520 + x8515))) + (g8490 + (letrec ((x8526 + ((lambda (j7271 + k7272 + f7273) + (lambda (g7270) + (boolean?/c + j7271 + k7272 + (f7273 + (SNAKE/C + j7271 + k7272 + g7270))))) + 'module + 'importer + snake-self-collide?)) + (x8521 + (letrec ((x8522 + (letrec ((x8525 + (input)) + (x8523 + (letrec ((x8524 + (input))) + (cons + x8524 + '())))) + (cons + x8525 + x8523)))) + (cons + 'snake + x8522)))) + (x8526 + x8521))) + (g8491 + (letrec ((x8528 + ((lambda (j7275 + k7276 + f7277) + (lambda (g7274) + ((listof + POSN/C) + j7275 + k7276 + (f7277 + ((and/c + cons?/c + (listof + POSN/C)) + j7275 + k7276 + g7274))))) + 'module + 'importer + cut-tail)) + (x8527 + (input))) + (x8528 + x8527))) + (g8492 + (letrec ((x8534 + ((lambda (j7279 + k7280 + f7281) + (lambda (g7278) + (SNAKE/C + j7279 + k7280 + (f7281 + (SNAKE/C + j7279 + k7280 + g7278))))) + 'module + 'importer + snake-slither)) + (x8529 + (letrec ((x8530 + (letrec ((x8533 + (input)) + (x8531 + (letrec ((x8532 + (input))) + (cons + x8532 + '())))) + (cons + x8533 + x8531)))) + (cons + 'snake + x8530)))) + (x8534 + x8529))) + (g8493 + (letrec ((x8540 + ((lambda (j7283 + k7284 + f7285) + (lambda (g7282) + (SNAKE/C + j7283 + k7284 + (f7285 + (SNAKE/C + j7283 + k7284 + g7282))))) + 'module + 'importer + snake-grow)) + (x8535 + (letrec ((x8536 + (letrec ((x8539 + (input)) + (x8537 + (letrec ((x8538 + (input))) + (cons + x8538 + '())))) + (cons + x8539 + x8537)))) + (cons + 'snake + x8536)))) + (x8540 + x8535))) + (g8494 + (letrec ((x8555 + ((lambda (j7288 + k7289 + f7290) + (lambda (g7286 + g7287) + (WORLD/C + j7288 + k7289 + (f7290 + (WORLD/C + j7288 + k7289 + g7286) + (DIR/C + j7288 + k7289 + g7287))))) + 'module + 'importer + world-change-dir)) + (x8542 + (letrec ((x8543 + (letrec ((x8550 + (letrec ((x8551 + (letrec ((x8554 + (input)) + (x8552 + (letrec ((x8553 + (input))) + (cons + x8553 + '())))) + (cons + x8554 + x8552)))) + (cons + 'snake + x8551))) + (x8544 + (letrec ((x8545 + (letrec ((x8546 + (letrec ((x8549 + (input)) + (x8547 + (letrec ((x8548 + (input))) + (cons + x8548 + '())))) + (cons + x8549 + x8547)))) + (cons + 'posn + x8546)))) + (cons + x8545 + '())))) + (cons + x8550 + x8544)))) + (cons + 'world + x8543))) + (x8541 + (input))) + (x8555 + x8542 + x8541))) + (g8495 + (letrec ((x8569 + ((lambda (j7292 + k7293 + f7294) + (lambda (g7291) + (WORLD/C + j7292 + k7293 + (f7294 + (WORLD/C + j7292 + k7293 + g7291))))) + 'module + 'importer + world->world)) + (x8556 + (letrec ((x8557 + (letrec ((x8564 + (letrec ((x8565 + (letrec ((x8568 + (input)) + (x8566 + (letrec ((x8567 + (input))) + (cons + x8567 + '())))) + (cons + x8568 + x8566)))) + (cons + 'snake + x8565))) + (x8558 + (letrec ((x8559 + (letrec ((x8560 + (letrec ((x8563 + (input)) + (x8561 + (letrec ((x8562 + (input))) + (cons + x8562 + '())))) + (cons + x8563 + x8561)))) + (cons + 'posn + x8560)))) + (cons + x8559 + '())))) + (cons + x8564 + x8558)))) + (cons + 'world + x8557)))) + (x8569 + x8556))) + (g8496 + (letrec ((x8584 + ((lambda (j7297 + k7298 + f7299) + (lambda (g7295 + g7296) + (WORLD/C + j7297 + k7298 + (f7299 + (WORLD/C + j7297 + k7298 + g7295) + (string?/c + j7297 + k7298 + g7296))))) + 'module + 'importer + handle-key)) + (x8571 + (letrec ((x8572 + (letrec ((x8579 + (letrec ((x8580 + (letrec ((x8583 + (input)) + (x8581 + (letrec ((x8582 + (input))) + (cons + x8582 + '())))) + (cons + x8583 + x8581)))) + (cons + 'snake + x8580))) + (x8573 + (letrec ((x8574 + (letrec ((x8575 + (letrec ((x8578 + (input)) + (x8576 + (letrec ((x8577 + (input))) + (cons + x8577 + '())))) + (cons + x8578 + x8576)))) + (cons + 'posn + x8575)))) + (cons + x8574 + '())))) + (cons + x8579 + x8573)))) + (cons + 'world + x8572))) + (x8570 + (input))) + (x8584 + x8571 + x8570))) + (g8497 + (letrec ((x8598 + ((lambda (j7301 + k7302 + f7303) + (lambda (g7300) + (boolean?/c + j7301 + k7302 + (f7303 + (WORLD/C + j7301 + k7302 + g7300))))) + 'module + 'importer + game-over?)) + (x8585 + (letrec ((x8586 + (letrec ((x8593 + (letrec ((x8594 + (letrec ((x8597 + (input)) + (x8595 + (letrec ((x8596 + (input))) + (cons + x8596 + '())))) + (cons + x8597 + x8595)))) + (cons + 'snake + x8594))) + (x8587 + (letrec ((x8588 + (letrec ((x8589 + (letrec ((x8592 + (input)) + (x8590 + (letrec ((x8591 + (input))) + (cons + x8591 + '())))) + (cons + x8592 + x8590)))) + (cons + 'posn + x8589)))) + (cons + x8588 + '())))) + (cons + x8593 + x8587)))) + (cons + 'world + x8586)))) + (x8598 + x8585))) + (g8498 + (letrec ((x8612 + ((lambda (j7305 + k7306 + f7307) + (lambda (g7304) + (image/c + j7305 + k7306 + (f7307 + (WORLD/C + j7305 + k7306 + g7304))))) + 'module + 'importer + world->scene)) + (x8599 + (letrec ((x8600 + (letrec ((x8607 + (letrec ((x8608 + (letrec ((x8611 + (input)) + (x8609 + (letrec ((x8610 + (input))) + (cons + x8610 + '())))) + (cons + x8611 + x8609)))) + (cons + 'snake + x8608))) + (x8601 + (letrec ((x8602 + (letrec ((x8603 + (letrec ((x8606 + (input)) + (x8604 + (letrec ((x8605 + (input))) + (cons + x8605 + '())))) + (cons + x8606 + x8604)))) + (cons + 'posn + x8603)))) + (cons + x8602 + '())))) + (cons + x8607 + x8601)))) + (cons + 'world + x8600)))) + (x8612 + x8599))) + (g8499 + (letrec ((x8619 + ((lambda (j7310 + k7311 + f7312) + (lambda (g7308 + g7309) + (image/c + j7310 + k7311 + (f7312 + (POSN/C + j7310 + k7311 + g7308) + (image/c + j7310 + k7311 + g7309))))) + 'module + 'importer + food+scene)) + (x8614 + (letrec ((x8615 + (letrec ((x8618 + (input)) + (x8616 + (letrec ((x8617 + (input))) + (cons + x8617 + '())))) + (cons + x8618 + x8616)))) + (cons + 'posn + x8615))) + (x8613 + (cons + 'image + '()))) + (x8619 + x8614 + x8613))) + (g8500 + (letrec ((x8624 + ((lambda (j7317 + k7318 + f7319) + (lambda (g7313 + g7314 + g7315 + g7316) + (image/c + j7317 + k7318 + (f7319 + (image/c + j7317 + k7318 + g7313) + (real?/c + j7317 + k7318 + g7314) + (real?/c + j7317 + k7318 + g7315) + (image/c + j7317 + k7318 + g7316))))) + 'module + 'importer + place-image-on-grid)) + (x8623 + (cons + 'image + '())) + (x8622 + (input)) + (x8621 + (input)) + (x8620 + (cons + 'image + '()))) + (x8624 + x8623 + x8622 + x8621 + x8620))) + (g8501 + (letrec ((x8631 + ((lambda (j7322 + k7323 + f7324) + (lambda (g7320 + g7321) + (image/c + j7322 + k7323 + (f7324 + (SNAKE/C + j7322 + k7323 + g7320) + (image/c + j7322 + k7323 + g7321))))) + 'module + 'importer + snake+scene)) + (x8626 + (letrec ((x8627 + (letrec ((x8630 + (input)) + (x8628 + (letrec ((x8629 + (input))) + (cons + x8629 + '())))) + (cons + x8630 + x8628)))) + (cons + 'snake + x8627))) + (x8625 + (cons + 'image + '()))) + (x8631 + x8626 + x8625))) + (g8502 + (letrec ((x8634 + ((lambda (j7327 + k7328 + f7329) + (lambda (g7325 + g7326) + (image/c + j7327 + k7328 + (f7329 + ((listof + POSN/C) + j7327 + k7328 + g7325) + (image/c + j7327 + k7328 + g7326))))) + 'module + 'importer + segments+scene)) + (x8633 + (input)) + (x8632 + (cons + 'image + '()))) + (x8634 + x8633 + x8632))) + (g8503 + (letrec ((x8641 + ((lambda (j7332 + k7333 + f7334) + (lambda (g7330 + g7331) + (image/c + j7332 + k7333 + (f7334 + (POSN/C + j7332 + k7333 + g7330) + (image/c + j7332 + k7333 + g7331))))) + 'module + 'importer + segment+scene)) + (x8636 + (letrec ((x8637 + (letrec ((x8640 + (input)) + (x8638 + (letrec ((x8639 + (input))) + (cons + x8639 + '())))) + (cons + x8640 + x8638)))) + (cons + 'posn + x8637))) + (x8635 + (cons + 'image + '()))) + (x8641 + x8636 + x8635)))) + g8503))) + g8479))) + g8478)))) + g8309)))) + g8288)))) + g8261)))) + g8250))) + g8249)))) + g7362))) + g7361)) diff --git a/analyses/simpleactor/benchmarks-out/games_tetris.rkt b/analyses/simpleactor/benchmarks-out/games_tetris.rkt index 0fdba178..70eefda6 100644 --- a/analyses/simpleactor/benchmarks-out/games_tetris.rkt +++ b/analyses/simpleactor/benchmarks-out/games_tetris.rkt @@ -1,693 +1,6858 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7495 #t)) g7495))) + (meta (lambda (v) (letrec ((g7496 v)) g7496))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7497 + (letrec ((g7498 + (letrec ((x-e7499 lst)) + (match + x-e7499 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7500 (eq? v v1))) + (if x-cnd7500 #t (member v vs))))))))) + g7498))) + g7497))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (struct block (x y color)) - (struct tetra (center blocks)) - (struct world (tetra blocks)) - (struct posn (x y)) - (define COLOR/C symbol?) - (define POSN/C (struct/c posn real? real?)) - (define BLOCK/C (struct/c block real? real? COLOR/C)) - (define BSET/C (listof BLOCK/C)) - (define TETRA/C (struct/c tetra POSN/C BSET/C)) - (define WORLD/C (struct/c world TETRA/C BSET/C)) - (define (posn=? p1 p2) - (and (= (posn-x p1) (posn-x p2)) (= (posn-y p1) (posn-y p2)))) - (define block-size 20) - (define board-height 20) - (define board-width 10) - (define (block=? b1 b2) - (and (= (block-x b1) (block-x b2)) (= (block-y b1) (block-y b2)))) - (define (block-move dx dy b) - (block (+ dx (block-x b)) (+ dy (block-y b)) (block-color b))) - (define (block-rotate-ccw c b) - (block - (+ (posn-x c) (- (posn-y c) (block-y b))) - (+ (posn-y c) (- (block-x b) (posn-x c))) - (block-color b))) - (define (block-rotate-cw c b) - (block-rotate-ccw c (block-rotate-ccw c (block-rotate-ccw c b)))) - (define (ormap p? xs) - (cond ((null? xs) #f) (else (or (p? (car xs)) (ormap p? (cdr xs)))))) - (define (andmap p? xs) - (cond ((null? xs) #t) (else (and (p? (car xs)) (andmap p? (cdr xs)))))) - (define (map f xs) - (cond ((null? xs) null) (else (cons (f (car xs)) (map f (cdr xs)))))) - (define (filter p? xs) - (cond - ((null? xs) null) - ((p? (car xs)) (cons (car xs) (filter p? (cdr xs)))) - (else (filter p? (cdr xs))))) - (define (append l r) - (cond ((null? l) r) (else (cons (car l) (append (cdr l) r))))) - (define (length xs) (cond ((null? xs) 0) (else (+ 1 (length (cdr xs)))))) - (define (foldr f a xs) - (cond ((null? xs) a) (else (f (car xs) (foldr f a (cdr xs)))))) - (define (blocks-contains? bs b) (ormap (λ (c) (block=? b c)) bs)) - (define (blocks-subset? bs1 bs2) - (andmap (λ (b) (blocks-contains? bs2 b)) bs1)) - (define (blocks=? bs1 bs2) - (and (blocks-subset? bs1 bs2) (blocks-subset? bs2 bs1))) - (define (blocks-intersect bs1 bs2) - (filter (λ (b) (blocks-contains? bs2 b)) bs1)) - (define (blocks-count bs) (length bs)) - (define (blocks-move dx dy bs) (map (λ (b) (block-move dx dy b)) bs)) - (define (blocks-rotate-ccw c bs) (map (λ (b) (block-rotate-ccw c b)) bs)) - (define (blocks-rotate-cw c bs) (map (λ (b) (block-rotate-cw c b)) bs)) - (define (blocks-change-color bs c) - (map (λ (b) (block (block-x b) (block-y b) c)) bs)) - (define (blocks-row bs i) (filter (λ (b) (= i (block-y b))) bs)) - (define (full-row? bs i) (= board-width (blocks-count (blocks-row bs i)))) - (define (blocks-overflow? bs) (ormap (λ (b) (<= (block-y b) 0)) bs)) - (define (blocks-union bs1 bs2) - (foldr - (λ (b bs) (cond ((blocks-contains? bs b) bs) (else (cons b bs)))) - bs2 - bs1)) - (define (blocks-max-y bs) (foldr (λ (b n) (max (block-y b) n)) 0 bs)) - (define (blocks-min-x bs) - (foldr (λ (b n) (min (block-x b) n)) board-width bs)) - (define (blocks-max-x bs) (foldr (λ (b n) (max (block-x b) n)) 0 bs)) - (define (eliminate-full-rows bs) (elim-row bs board-height 0)) - (define (elim-row bs i offset) - (cond - ((< i 0) empty) - ((full-row? bs i) (elim-row bs (sub1 i) (add1 offset))) - (else - (blocks-union - (elim-row bs (sub1 i) offset) - (blocks-move 0 offset (blocks-row bs i)))))) - (define (tetra-move dx dy t) - (tetra - (posn (+ dx (posn-x (tetra-center t))) (+ dy (posn-y (tetra-center t)))) - (blocks-move dx dy (tetra-blocks t)))) - (define (tetra-rotate-ccw t) - (tetra - (tetra-center t) - (blocks-rotate-ccw (tetra-center t) (tetra-blocks t)))) - (define (tetra-rotate-cw t) - (tetra - (tetra-center t) - (blocks-rotate-cw (tetra-center t) (tetra-blocks t)))) - (define (tetra-overlaps-blocks? t bs) - (false? (false? (blocks-intersect (tetra-blocks t) bs)))) - (define (tetra-change-color t c) - (tetra (tetra-center t) (blocks-change-color (tetra-blocks t) c))) - (define (build-tetra-blocks color xc yc x1 y1 x2 y2 x3 y3 x4 y4) - (tetra-move - 3 - 0 - (tetra - (posn xc yc) - (list - (block x1 y1 color) - (block x2 y2 color) - (block x3 y3 color) - (block x4 y4 color))))) - (define (touchdown w tetras) - (world - (list-pick-random tetras) - (eliminate-full-rows - (blocks-union (tetra-blocks (world-tetra w)) (world-blocks w))))) - (define (world-jump-down w) - (cond - ((landed? w) w) - (else - (world-jump-down - (world (tetra-move 0 1 (world-tetra w)) (world-blocks w)))))) - (define (landed-on-blocks? w) - (tetra-overlaps-blocks? - (tetra-move 0 1 (world-tetra w)) - (world-blocks w))) - (define (landed-on-floor? w) - (= (blocks-max-y (tetra-blocks (world-tetra w))) (sub1 board-height))) - (define (landed? w) (or (landed-on-blocks? w) (landed-on-floor? w))) - (define (next-world w tetras) - (cond - ((landed? w) (touchdown w tetras)) - (else (world (tetra-move 0 1 (world-tetra w)) (world-blocks w))))) - (define (try-new-tetra w new-tetra) - (cond - ((or (< (blocks-min-x (tetra-blocks new-tetra)) 0) - (>= (blocks-max-x (tetra-blocks new-tetra)) board-width) - (tetra-overlaps-blocks? new-tetra (world-blocks w))) - w) - (else (world new-tetra (world-blocks w))))) - (define (world-move dx dy w) - (try-new-tetra w (tetra-move dx dy (world-tetra w)))) - (define (world-rotate-ccw w) - (try-new-tetra w (tetra-rotate-ccw (world-tetra w)))) - (define (world-rotate-cw w) - (try-new-tetra w (tetra-rotate-cw (world-tetra w)))) - (define (ghost-blocks w) - (tetra-blocks - (tetra-change-color (world-tetra (world-jump-down w)) 'gray))) - (define (world-key-move w k) - (cond - ((equal? k left) (world-move neg-1 0 w)) - ((equal? k right) (world-move 1 0 w)) - ((equal? k down) (world-jump-down w)) - ((equal? k a) (world-rotate-ccw w)) - ((equal? k s) (world-rotate-cw w)) - (else w))) - (struct image ()) - (define (overlay i₁ i₂) (image)) - (define (circle r m c) (image)) - (define (rectangle w h m c) (image)) - (define (place-image i₁ r c i₂) (image)) - (define (empty-scene w h) (image)) - (define (list-pick-random xs) - (cond ((null? (cdr xs)) (car xs)) (else (list-pick-random (cdr xs))))) - (define neg-1 (random 10)) - (define (world->image w) - (place-image - (blocks->image - (append - (tetra-blocks (world-tetra w)) - (append (ghost-blocks w) (world-blocks w)))) - 0 - 0 - (empty-scene (* board-width block-size) (* board-height block-size)))) - (define (blocks->image bs) - (foldr - (λ (b img) (cond ((<= 0 (block-y b)) (place-block b img)) (else img))) - (empty-scene - (add1 (* board-width block-size)) - (add1 (* board-height block-size))) - bs)) - (define (block->image b) - (overlay - (rectangle (add1 block-size) (add1 block-size) 'solid (block-color b)) - (rectangle (add1 block-size) (add1 block-size) 'outline 'black))) - (define (place-block b scene) - (place-image - (block->image b) - (+ (* (block-x b) block-size) (/ block-size 2)) - (+ (* (block-y b) block-size) (/ block-size 2)) - scene)) - (define (world0 tetras) (world (list-pick-random tetras) null)) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - (boolean? - j3985 - k3986 - (f3987 (POSN/C j3985 k3986 g3983) (POSN/C j3985 k3986 g3984))))) - 'module - 'importer - posn=?) - (input) - (input)) - (any/c 'module 'importer COLOR/C) - (any/c 'module 'importer POSN/C) - (any/c 'module 'importer BLOCK/C) - (any/c 'module 'importer TETRA/C) - (any/c 'module 'importer WORLD/C) - (any/c 'module 'importer BSET/C) - (integer? 'module 'importer block-size) - (integer? 'module 'importer board-width) - (integer? 'module 'importer board-height) - (((lambda (j3990 k3991 f3992) - (lambda (g3988 g3989) - (BLOCK/C - j3990 - k3991 - (f3992 (POSN/C j3990 k3991 g3988) (BLOCK/C j3990 k3991 g3989))))) - 'module - 'importer - block-rotate-ccw) - (input) - (input)) - (((lambda (j3995 k3996 f3997) - (lambda (g3993 g3994) - (BLOCK/C - j3995 - k3996 - (f3997 (POSN/C j3995 k3996 g3993) (BLOCK/C j3995 k3996 g3994))))) - 'module - 'importer - block-rotate-cw) - (input) - (input)) - (((lambda (j4000 k4001 f4002) - (lambda (g3998 g3999) - (boolean? - j4000 - k4001 - (f4002 - (BLOCK/C j4000 k4001 g3998) - (BLOCK/C j4000 k4001 g3999))))) - 'module - 'importer - block=?) - (input) - (input)) - (((lambda (j4006 k4007 f4008) - (lambda (g4003 g4004 g4005) - (BLOCK/C - j4006 - k4007 - (f4008 - (real? j4006 k4007 g4003) - (real? j4006 k4007 g4004) - (BLOCK/C j4006 k4007 g4005))))) - 'module - 'importer - block-move) - (input) - (input) - (input)) - (((lambda (j4011 k4012 f4013) - (lambda (g4009 g4010) - (boolean? - j4011 - k4012 - (f4013 (BSET/C j4011 k4012 g4009) (BLOCK/C j4011 k4012 g4010))))) - 'module - 'importer - blocks-contains?) - (input) - (input)) - (((lambda (j4016 k4017 f4018) - (lambda (g4014 g4015) - (boolean? - j4016 - k4017 - (f4018 (BSET/C j4016 k4017 g4014) (BSET/C j4016 k4017 g4015))))) - 'module - 'importer - blocks=?) - (input) - (input)) - (((lambda (j4021 k4022 f4023) - (lambda (g4019 g4020) - (boolean? - j4021 - k4022 - (f4023 (BSET/C j4021 k4022 g4019) (BSET/C j4021 k4022 g4020))))) - 'module - 'importer - blocks-subset?) - (input) - (input)) - (((lambda (j4026 k4027 f4028) - (lambda (g4024 g4025) - (BSET/C - j4026 - k4027 - (f4028 (BSET/C j4026 k4027 g4024) (BSET/C j4026 k4027 g4025))))) - 'module - 'importer - blocks-intersect) - (input) - (input)) - (((lambda (j4030 k4031 f4032) - (lambda (g4029) - (real? j4030 k4031 (f4032 (BSET/C j4030 k4031 g4029))))) - 'module - 'importer - blocks-count) - (input)) - (((lambda (j4034 k4035 f4036) - (lambda (g4033) - (boolean? j4034 k4035 (f4036 (BSET/C j4034 k4035 g4033))))) - 'module - 'importer - blocks-overflow?) - (input)) - (((lambda (j4040 k4041 f4042) - (lambda (g4037 g4038 g4039) - (BSET/C - j4040 - k4041 - (f4042 - (real? j4040 k4041 g4037) - (real? j4040 k4041 g4038) - (BSET/C j4040 k4041 g4039))))) - 'module - 'importer - blocks-move) - (input) - (input) - (input)) - (((lambda (j4045 k4046 f4047) - (lambda (g4043 g4044) - (BSET/C - j4045 - k4046 - (f4047 (POSN/C j4045 k4046 g4043) (BSET/C j4045 k4046 g4044))))) - 'module - 'importer - blocks-rotate-cw) - (input) - (input)) - (((lambda (j4050 k4051 f4052) - (lambda (g4048 g4049) - (BSET/C - j4050 - k4051 - (f4052 (POSN/C j4050 k4051 g4048) (BSET/C j4050 k4051 g4049))))) - 'module - 'importer - blocks-rotate-ccw) - (input) - (input)) - (((lambda (j4055 k4056 f4057) - (lambda (g4053 g4054) - (BSET/C - j4055 - k4056 - (f4057 (BSET/C j4055 k4056 g4053) (COLOR/C j4055 k4056 g4054))))) - 'module - 'importer - blocks-change-color) - (input) - (input)) - (((lambda (j4060 k4061 f4062) - (lambda (g4058 g4059) - (BSET/C - j4060 - k4061 - (f4062 (BSET/C j4060 k4061 g4058) (real? j4060 k4061 g4059))))) - 'module - 'importer - blocks-row) - (input) - (input)) - (((lambda (j4065 k4066 f4067) - (lambda (g4063 g4064) - (boolean? - j4065 - k4066 - (f4067 (BSET/C j4065 k4066 g4063) (real? j4065 k4066 g4064))))) - 'module - 'importer - full-row?) - (input) - (input)) - (((lambda (j4070 k4071 f4072) - (lambda (g4068 g4069) - (BSET/C - j4070 - k4071 - (f4072 (BSET/C j4070 k4071 g4068) (BSET/C j4070 k4071 g4069))))) - 'module - 'importer - blocks-union) - (input) - (input)) - (((lambda (j4074 k4075 f4076) - (lambda (g4073) - (real? j4074 k4075 (f4076 (BSET/C j4074 k4075 g4073))))) - 'module - 'importer - blocks-max-x) - (input)) - (((lambda (j4078 k4079 f4080) - (lambda (g4077) - (real? j4078 k4079 (f4080 (BSET/C j4078 k4079 g4077))))) - 'module - 'importer - blocks-min-x) - (input)) - (((lambda (j4082 k4083 f4084) - (lambda (g4081) - (real? j4082 k4083 (f4084 (BSET/C j4082 k4083 g4081))))) - 'module - 'importer - blocks-max-y) - (input)) - (((lambda (j4086 k4087 f4088) - (lambda (g4085) - (BSET/C j4086 k4087 (f4088 (BSET/C j4086 k4087 g4085))))) - 'module - 'importer - eliminate-full-rows) - (input)) - (((lambda (j4092 k4093 f4094) - (lambda (g4089 g4090 g4091) - (TETRA/C - j4092 - k4093 - (f4094 - (integer? j4092 k4093 g4089) - (integer? j4092 k4093 g4090) - (TETRA/C j4092 k4093 g4091))))) - 'module - 'importer - tetra-move) - (input) - (input) - (input)) - (((lambda (j4096 k4097 f4098) - (lambda (g4095) - (TETRA/C j4096 k4097 (f4098 (TETRA/C j4096 k4097 g4095))))) - 'module - 'importer - tetra-rotate-ccw) - (input)) - (((lambda (j4100 k4101 f4102) - (lambda (g4099) - (TETRA/C j4100 k4101 (f4102 (TETRA/C j4100 k4101 g4099))))) - 'module - 'importer - tetra-rotate-cw) - (input)) - (((lambda (j4105 k4106 f4107) - (lambda (g4103 g4104) - (boolean? - j4105 - k4106 - (f4107 (TETRA/C j4105 k4106 g4103) (BSET/C j4105 k4106 g4104))))) - 'module - 'importer - tetra-overlaps-blocks?) - (input) - (input)) - (((lambda (j4119 k4120 f4121) - (lambda (g4108 - g4109 - g4110 - g4111 - g4112 - g4113 - g4114 - g4115 - g4116 - g4117 - g4118) - (TETRA/C - j4119 - k4120 - (f4121 - (COLOR/C j4119 k4120 g4108) - (real? j4119 k4120 g4109) - (real? j4119 k4120 g4110) - (integer? j4119 k4120 g4111) - (integer? j4119 k4120 g4112) - (integer? j4119 k4120 g4113) - (integer? j4119 k4120 g4114) - (integer? j4119 k4120 g4115) - (integer? j4119 k4120 g4116) - (integer? j4119 k4120 g4117) - (integer? j4119 k4120 g4118))))) - 'module - 'importer - build-tetra-blocks) - (input) - (input) - (input) - (input) - (input) - (input) - (input) - (input) - (input) - (input) - (input)) - (((lambda (j4124 k4125 f4126) - (lambda (g4122 g4123) - (TETRA/C - j4124 - k4125 - (f4126 - (TETRA/C j4124 k4125 g4122) - (COLOR/C j4124 k4125 g4123))))) - 'module - 'importer - tetra-change-color) - (input) - (input)) - (((lambda (j4129 k4130 f4131) - (lambda (g4127 g4128) - (WORLD/C - j4129 - k4130 - (f4131 - (WORLD/C j4129 k4130 g4127) - (string? j4129 k4130 g4128))))) - 'module - 'importer - world-key-move) - (input) - (input)) - (((lambda (j4134 k4135 f4136) - (lambda (g4132 g4133) - (WORLD/C - j4134 - k4135 - (f4136 - (WORLD/C j4134 k4135 g4132) - ((and/c cons? (listof TETRA/C)) j4134 k4135 g4133))))) - 'module - 'importer - next-world) - (input) - (input)) - (((lambda (j4138 k4139 f4140) - (lambda (g4137) - (BSET/C j4138 k4139 (f4140 (WORLD/C j4138 k4139 g4137))))) - 'module - 'importer - ghost-blocks) - (input)) - (((lambda (j4142 k4143 f4144) - (lambda (g4141) - (boolean? j4142 k4143 (f4144 (any/c j4142 k4143 g4141))))) - 'module - 'importer - image?) - (input)) - (((lambda (j4147 k4148 f4149) - (lambda (g4145 g4146) - (image? - j4147 - k4148 - (f4149 (image? j4147 k4148 g4145) (image? j4147 k4148 g4146))))) - 'module - 'importer - overlay) - (input) - (input)) - (((lambda (j4153 k4154 f4155) - (lambda (g4150 g4151 g4152) - (image? - j4153 - k4154 - (f4155 - (real? j4153 k4154 g4150) - (real? j4153 k4154 g4151) - (string? j4153 k4154 g4152))))) - 'module - 'importer - circle) - (input) - (input) - (input)) - (((lambda (j4160 k4161 f4162) - (lambda (g4156 g4157 g4158 g4159) - (image? - j4160 - k4161 - (f4162 - (real? j4160 k4161 g4156) - (real? j4160 k4161 g4157) - (COLOR/C j4160 k4161 g4158) - (COLOR/C j4160 k4161 g4159))))) - 'module - 'importer - rectangle) - (input) - (input) - (input) - (input)) - (((lambda (j4167 k4168 f4169) - (lambda (g4163 g4164 g4165 g4166) - (image? - j4167 - k4168 - (f4169 - (image? j4167 k4168 g4163) - (real? j4167 k4168 g4164) - (real? j4167 k4168 g4165) - (image? j4167 k4168 g4166))))) - 'module - 'importer - place-image) - (input) - (input) - (input) - (input)) - (((lambda (j4172 k4173 f4174) - (lambda (g4170 g4171) - (image? - j4172 - k4173 - (f4174 (real? j4172 k4173 g4170) (real? j4172 k4173 g4171))))) - 'module - 'importer - empty-scene) - (input) - (input)) - (((lambda (j4176 k4177 f4178) - (lambda (g4175) - (TETRA/C - j4176 - k4177 - (f4178 ((and/c cons? (listof TETRA/C)) j4176 k4177 g4175))))) - 'module - 'importer - list-pick-random) - (input)) - (integer? 'module 'importer neg-1) - (((lambda (j4180 k4181 f4182) - (lambda (g4179) - (image? j4180 k4181 (f4182 (WORLD/C j4180 k4181 g4179))))) - 'module - 'importer - world->image) - (input)) - (((lambda (j4184 k4185 f4186) - (lambda (g4183) - (image? j4184 k4185 (f4186 (BSET/C j4184 k4185 g4183))))) - 'module - 'importer - blocks->image) - (input)) - (((lambda (j4188 k4189 f4190) - (lambda (g4187) - (image? j4188 k4189 (f4190 (BLOCK/C j4188 k4189 g4187))))) - 'module - 'importer - block->image) - (input)) - (((lambda (j4193 k4194 f4195) - (lambda (g4191 g4192) - (image? - j4193 - k4194 - (f4195 (BLOCK/C j4193 k4194 g4191) (image? j4193 k4194 g4192))))) - 'module - 'importer - place-block) - (input) - (input)) - (((lambda (j4197 k4198 f4199) - (lambda (g4196) - (WORLD/C - j4197 - k4198 - (f4199 ((and/c cons? (listof TETRA/C)) j4197 k4198 g4196))))) - 'module - 'importer - world0) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7501 (lambda (v) (letrec ((g7502 v)) g7502)))) g7501))) + (nonzero? + (lambda (v) + (letrec ((g7503 (letrec ((x7504 (= v 0))) (not x7504)))) g7503)))) + (letrec ((g7505 + (letrec ((g7506 + (letrec ((real/c + (lambda (g7161 g7162 g7163) + (letrec ((g7507 + (letrec ((x-cnd7508 (real? g7163))) + (if x-cnd7508 + g7163 + (blame g7161 'real?))))) + g7507))) + (boolean?/c + (lambda (g7164 g7165 g7166) + (letrec ((g7509 + (letrec ((x-cnd7510 + (boolean? g7166))) + (if x-cnd7510 + g7166 + (blame g7164 'boolean?))))) + g7509))) + (number?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7511 + (letrec ((x-cnd7512 + (number? g7169))) + (if x-cnd7512 + g7169 + (blame g7167 'number?))))) + g7511))) + (any/c + (lambda (g7170 g7171 g7172) + (letrec ((g7513 + (letrec ((x-cnd7514 + ((lambda (v) #t) g7172))) + (if x-cnd7514 + g7172 + (blame + g7170 + '(lambda (v) #t)))))) + g7513))) + (any?/c + (lambda (g7173 g7174 g7175) + (letrec ((g7515 + (letrec ((x-cnd7516 + ((lambda (v) #t) g7175))) + (if x-cnd7516 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7515))) + (image? any/c) + (cons?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7517 + (letrec ((x-cnd7518 (pair? g7178))) + (if x-cnd7518 + g7178 + (blame g7176 'pair?))))) + g7517))) + (pair?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7519 + (letrec ((x-cnd7520 (pair? g7181))) + (if x-cnd7520 + g7181 + (blame g7179 'pair?))))) + g7519))) + (integer? + (lambda (g7182 g7183 g7184) + (letrec ((g7521 + (letrec ((x-cnd7522 + (integer? g7184))) + (if x-cnd7522 + g7184 + (blame g7182 'integer?))))) + g7521))) + (and/c + (lambda (c1 c2) + (letrec ((g7523 + (lambda (k j v) + (letrec ((g7524 + (letrec ((x-cnd7525 + (c1 k j v))) + (if x-cnd7525 + (c2 k j v) + #f)))) + g7524)))) + g7523))) + (list-of + (lambda (contract) + (letrec ((g7526 + (lambda (k j v) + (letrec ((g7527 + (letrec ((x-cnd7528 + (null? v))) + (if x-cnd7528 + '() + (letrec ((x7532 + (letrec ((x7533 + (car + v))) + (contract + k + j + x7533))) + (x7529 + (letrec ((x7531 + (list-of + contract)) + (x7530 + (cdr + v))) + (x7531 + k + j + x7530)))) + (cons + x7532 + x7529)))))) + g7527)))) + g7526))) + (any? (lambda (v) (letrec ((g7534 #t)) g7534))) + (nonzero? + (lambda (v) + (letrec ((g7535 + (letrec ((x7536 (= v 0))) + (not x7536)))) + g7535))) + (nonzero?/c + (lambda (g7185 g7186 g7187) + (letrec ((g7537 + (letrec ((x-cnd7538 + ((lambda (v) + (not (= v 0))) + g7187))) + (if x-cnd7538 + g7187 + (blame + g7185 + '(lambda (v) + (not (= v 0)))))))) + g7537))) + (meta (lambda (v) (letrec ((g7539 v)) g7539))) + (orig-+ +) + (+ + ((lambda (j7190 k7191 f7192) + (lambda (g7188 g7189) + (number?/c + j7190 + k7191 + (f7192 + (number?/c j7190 k7191 g7188) + (number?/c j7190 k7191 g7189))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7195 k7196 f7197) + (lambda (g7193 g7194) + (number?/c + j7195 + k7196 + (f7197 + (number?/c j7195 k7196 g7193) + (number?/c j7195 k7196 g7194))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7200 k7201 f7202) + (lambda (g7198 g7199) + (number?/c + j7200 + k7201 + (f7202 + (number?/c j7200 k7201 g7198) + (number?/c j7200 k7201 g7199))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7205 k7206 f7207) + (lambda (g7203 g7204) + (number?/c + j7205 + k7206 + (f7207 + (number?/c j7205 k7206 g7203) + (number?/c j7205 k7206 g7204))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7209 k7210 f7211) + (lambda (g7208) + (any/c + j7209 + k7210 + (f7211 (pair?/c j7209 k7210 g7208))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7213 k7214 f7215) + (lambda (g7212) + (any/c + j7213 + k7214 + (f7215 (pair?/c j7213 k7214 g7212))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7218 k7219 f7220) + (lambda (g7216 g7217) + (pair?/c + j7218 + k7219 + (f7220 + (any/c j7218 k7219 g7216) + (any/c j7218 k7219 g7217))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7222 k7223 f7224) + (lambda (g7221) + (integer?/c + j7222 + k7223 + (f7224 (vector?/c j7222 k7223 g7221))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7227 k7228 f7229) + (lambda (g7225 g7226) + (any/c + j7227 + k7228 + (f7229 + (vector?/c j7227 k7228 g7225) + (integer?/c j7227 k7228 g7226))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7540 #t)) g7540))) + (cdddr + (lambda (x) + (letrec ((g7541 + (letrec ((x7542 + (letrec ((x7543 (cdr x))) + (cdr x7543)))) + (cdr x7542)))) + g7541))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7544 + (letrec ((x7547 (procedure? f))) + (assert x7547))) + (g7545 + (letrec ((x7548 (list? l))) + (assert x7548))) + (g7546 + (letrec ((x-cnd7549 (null? l))) + (if x-cnd7549 + '() + (letrec ((x7552 + (letrec ((x7553 + (car l))) + (f x7553))) + (x7550 + (letrec ((x7551 + (cdr l))) + (map f x7551)))) + (cons x7552 x7550)))))) + g7546))) + (cdar + (lambda (x) + (letrec ((g7554 + (letrec ((x7555 (car x))) + (cdr x7555)))) + g7554))) + (cadadr + (lambda (x) + (letrec ((g7556 + (letrec ((x7557 + (letrec ((x7558 + (letrec ((x7559 + (cdr + x))) + (car + x7559)))) + (cdr x7558)))) + (car x7557)))) + g7556))) + (cdadar + (lambda (x) + (letrec ((g7560 + (letrec ((x7561 + (letrec ((x7562 + (letrec ((x7563 + (car + x))) + (cdr + x7563)))) + (car x7562)))) + (cdr x7561)))) + g7560))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7564 + (letrec ((x7567 + (string? filename))) + (assert x7567))) + (g7565 + (letrec ((x7568 (procedure? proc))) + (assert x7568))) + (g7566 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7569 + (close-output-port + output-port)) + (g7570 res)) + g7570)))) + g7566))) + (caddr + (lambda (x) + (letrec ((g7571 + (letrec ((x7572 + (letrec ((x7573 (cdr x))) + (cdr x7573)))) + (car x7572)))) + g7571))) + (cdaadr + (lambda (x) + (letrec ((g7574 + (letrec ((x7575 + (letrec ((x7576 + (letrec ((x7577 + (cdr + x))) + (car + x7577)))) + (car x7576)))) + (cdr x7575)))) + g7574))) + (assq + (lambda (k l) + (letrec ((g7578 + (letrec ((x7580 (list? l))) + (assert x7580))) + (g7579 + (letrec ((x-cnd7581 (null? l))) + (if x-cnd7581 + #f + (letrec ((x-cnd7582 + (letrec ((x7583 + (caar l))) + (eq? x7583 k)))) + (if x-cnd7582 + (car l) + (letrec ((x7584 (cdr l))) + (assq k x7584)))))))) + g7579))) + (even? + (lambda (x) + (letrec ((g7585 + (letrec ((x7586 (modulo x 2))) + (= 0 x7586)))) + g7585))) + (list->string + (lambda (l) + (letrec ((g7587 + (letrec ((x7589 (list? l))) + (assert x7589))) + (g7588 + (letrec ((x-cnd7590 (null? l))) + (if x-cnd7590 + "" + (letrec ((x7593 + (letrec ((x7594 + (car l))) + (char->string + x7594))) + (x7591 + (letrec ((x7592 + (cdr l))) + (list->string + x7592)))) + (string-append + x7593 + x7591)))))) + g7588))) + (char<=? + (lambda (c1 c2) + (letrec ((g7595 + (letrec ((x7598 (char? c1))) + (assert x7598))) + (g7596 + (letrec ((x7599 (char? c2))) + (assert x7599))) + (g7597 + (letrec ((val7143 (char=? c x7616)))) + (if x-cnd7615 + (letrec ((x7617 #\z)) + (char-ci<=? c x7617)) + #f)))) + g7614))) + (<= + (lambda (x y) + (letrec ((g7618 + (letrec ((x7620 (number? x))) + (assert x7620))) + (g7619 + (letrec ((val7144 (< x y))) + (letrec ((g7621 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7622 + (if val7145 + val7145 + #f))) + g7622))))) + g7621)))) + g7619))) + (char-whitespace? + (lambda (c) + (letrec ((g7623 + (letrec ((val7146 + (letrec ((x7624 + (char->integer + c))) + (= x7624 9)))) + (letrec ((g7625 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7626 + (char->integer + c))) + (= + x7626 + 10)))) + (letrec ((g7627 + (if val7147 + val7147 + (letrec ((x7628 + (char->integer + c))) + (= + x7628 + 32))))) + g7627))))) + g7625)))) + g7623))) + (cddar + (lambda (x) + (letrec ((g7629 + (letrec ((x7630 + (letrec ((x7631 (car x))) + (cdr x7631)))) + (cdr x7630)))) + g7629))) + (positive? + (lambda (x) + (letrec ((g7632 + (letrec ((x7634 (number? x))) + (assert x7634))) + (g7633 (> x 0))) + g7633))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7635 #f)) g7635))) + (cddr + (lambda (x) + (letrec ((g7636 + (letrec ((x7637 (cdr x))) + (cdr x7637)))) + g7636))) + (truncate + (lambda (x) + (letrec ((g7638 + (letrec ((x7640 (number? x))) + (assert x7640))) + (g7639 + (letrec ((x-cnd7641 (< x 0))) + (if x-cnd7641 + (ceiling x) + (floor x))))) + g7639))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7642 + (letrec ((val7148 (eq? a b))) + (letrec ((g7643 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7645 + (null? + a)) + (x7644 + (null? + b))) + (and x7645 + x7644)))) + (letrec ((g7646 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7649 + (string? + a)) + (x7648 + (string? + b)) + (x7647 + (string=? + a + b))) + (and x7649 + x7648 + x7647)))) + (letrec ((g7650 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7658 + (pair? + a)) + (x7657 + (pair? + b)) + (x7654 + (letrec ((x7656 + (car + a)) + (x7655 + (car + b))) + (equal? + x7656 + x7655))) + (x7651 + (letrec ((x7653 + (cdr + a)) + (x7652 + (cdr + b))) + (equal? + x7653 + x7652)))) + (and x7658 + x7657 + x7654 + x7651)))) + (letrec ((g7659 + (if val7151 + val7151 + (letrec ((x7678 + (vector? + a)) + (x7677 + (vector? + b)) + (x7660 + (letrec ((x7674 + (letrec ((x7675 + (letrec ((x7676 + (vector-length + a))) + (n + x7676)))) + (x7675))) + (x7661 + (letrec ((x7672 + (letrec ((x7673 + (vector-length + b))) + (= + x7673 + n))) + (x7662 + (letrec ((loop + (lambda (i) + (letrec ((g7663 + (letrec ((x7670 + (= + i + n)) + (x7664 + (letrec ((x7667 + (letrec ((x7669 + (vector-ref + a + i)) + (x7668 + (vector-ref + b + i))) + (equal? + x7669 + x7668))) + (x7665 + (letrec ((x7666 + (+ + i + 1))) + (loop + x7666)))) + (and x7667 + x7665)))) + (or x7670 + x7664)))) + g7663)))) + (letrec ((g7671 + (loop + 0))) + g7671)))) + (and x7672 + x7662)))) + (let x7674 x7661)))) + (and x7678 + x7677 + x7660))))) + g7659))))) + g7650))))) + g7646))))) + g7643)))) + g7642))) + (cdaaar + (lambda (x) + (letrec ((g7679 + (letrec ((x7680 + (letrec ((x7681 + (letrec ((x7682 + (car + x))) + (car + x7682)))) + (car x7681)))) + (cdr x7680)))) + g7679))) + (caaddr + (lambda (x) + (letrec ((g7683 + (letrec ((x7684 + (letrec ((x7685 + (letrec ((x7686 + (cdr + x))) + (cdr + x7686)))) + (car x7685)))) + (car x7684)))) + g7683))) + (eqv? + (lambda (x y) + (letrec ((g7687 (eq? x y))) g7687))) + (>= + (lambda (x y) + (letrec ((g7688 + (letrec ((x7690 (number? x))) + (assert x7690))) + (g7689 + (letrec ((val7152 (> x y))) + (letrec ((g7691 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7692 + (if val7153 + val7153 + #f))) + g7692))))) + g7691)))) + g7689))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7693 + (letrec ((x7696 + (string? filename))) + (assert x7696))) + (g7694 + (letrec ((x7697 (procedure? proc))) + (assert x7697))) + (g7695 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7698 + (close-input-port + input-port)) + (g7699 res)) + g7699)))) + g7695))) + (ref + (lambda (x) + (letrec ((g7700 (cons x '()))) g7700))) + (char>=? + (lambda (c1 c2) + (letrec ((g7701 + (letrec ((x7704 (char? c1))) + (assert x7704))) + (g7702 + (letrec ((x7705 (char? c2))) + (assert x7705))) + (g7703 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7706 + (if val7154 + val7154 + (char=? c1 c2)))) + g7706)))) + g7703))) + (cdaar + (lambda (x) + (letrec ((g7707 + (letrec ((x7708 + (letrec ((x7709 (car x))) + (car x7709)))) + (cdr x7708)))) + g7707))) + (cdaddr + (lambda (x) + (letrec ((g7710 + (letrec ((x7711 + (letrec ((x7712 + (letrec ((x7713 + (cdr + x))) + (cdr + x7713)))) + (car x7712)))) + (cdr x7711)))) + g7710))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7714 + (letrec ((x7715 + (letrec ((x7716 (car x))) + (cdr x7716)))) + (car x7715)))) + g7714))) + (caadr + (lambda (x) + (letrec ((g7717 + (letrec ((x7718 + (letrec ((x7719 (cdr x))) + (car x7719)))) + (car x7718)))) + g7717))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7720 + (letrec ((x7723 (char? c1))) + (assert x7723))) + (g7721 + (letrec ((x7724 (char? c2))) + (assert x7724))) + (g7722 + (letrec ((x7725 + (char-ci<=? c1 c2))) + (not x7725)))) + g7722))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7726 + (letrec ((x7727 + (letrec ((x7728 + (letrec ((x7729 + (car + x))) + (car + x7729)))) + (car x7728)))) + (car x7727)))) + g7726))) + (negative? + (lambda (x) + (letrec ((g7730 + (letrec ((x7732 (number? x))) + (assert x7732))) + (g7731 (< x 0))) + g7731))) + (memv + (lambda (e l) + (letrec ((g7733 (memq e l))) g7733))) + (caaar + (lambda (x) + (letrec ((g7734 + (letrec ((x7735 + (letrec ((x7736 (car x))) + (car x7736)))) + (car x7735)))) + g7734))) + (debug + (lambda (e) (letrec ((g7737 '())) g7737))) + (reverse + (lambda (l) + (letrec ((g7738 + (letrec ((x7740 (list? l))) + (assert x7740))) + (g7739 + (letrec ((x-cnd7741 (null? l))) + (if x-cnd7741 + '() + (letrec ((x7744 + (letrec ((x7745 + (cdr l))) + (reverse x7745))) + (x7742 + (letrec ((x7743 + (car l))) + (list x7743)))) + (append x7744 x7742)))))) + g7739))) + (caaadr + (lambda (x) + (letrec ((g7746 + (letrec ((x7747 + (letrec ((x7748 + (letrec ((x7749 + (cdr + x))) + (car + x7749)))) + (car x7748)))) + (car x7747)))) + g7746))) + (cddadr + (lambda (x) + (letrec ((g7750 + (letrec ((x7751 + (letrec ((x7752 + (letrec ((x7753 + (cdr + x))) + (car + x7753)))) + (cdr x7752)))) + (cdr x7751)))) + g7750))) + (odd? + (lambda (x) + (letrec ((g7754 + (letrec ((x7756 (number? x))) + (assert x7756))) + (g7755 + (letrec ((x7757 (modulo x 2))) + (= 1 x7757)))) + g7755))) + (caadar + (lambda (x) + (letrec ((g7758 + (letrec ((x7759 + (letrec ((x7760 + (letrec ((x7761 + (car + x))) + (cdr + x7761)))) + (car x7760)))) + (car x7759)))) + g7758))) + (apply + (lambda (proc args) + (letrec ((g7762 + (letrec ((x7765 (procedure? proc))) + (assert x7765))) + (g7763 + (letrec ((x7766 (list? args))) + (assert x7766))) + (g7764 + (if cnd + (letrec ((g7767 (proc))) g7767) + (if cnd + (letrec ((g7768 + (letrec ((x7769 + (car + args))) + (proc x7769)))) + g7768) + (if cnd + (letrec ((g7770 + (letrec ((x7772 + (car + args)) + (x7771 + (cadr + args))) + (proc + x7772 + x7771)))) + g7770) + (if cnd + (letrec ((g7773 + (letrec ((x7776 + (car + args)) + (x7775 + (cadr + args)) + (x7774 + (caddr + args))) + (proc + x7776 + x7775 + x7774)))) + g7773) + (if cnd + (letrec ((g7777 + (letrec ((x7781 + (car + args)) + (x7780 + (cadr + args)) + (x7779 + (caddr + args)) + (x7778 + (cadddr + args))) + (proc + x7781 + x7780 + x7779 + x7778)))) + g7777) + (if cnd + (letrec ((g7782 + (letrec ((x7788 + (car + args)) + (x7787 + (cadr + args)) + (x7786 + (caddr + args)) + (x7785 + (cadddr + args)) + (x7783 + (letrec ((x7784 + (cddddr + args))) + (car + x7784)))) + (proc + x7788 + x7787 + x7786 + x7785 + x7783)))) + g7782) + (if cnd + (letrec ((g7789 + (letrec ((x7797 + (car + args)) + (x7796 + (cadr + args)) + (x7795 + (caddr + args)) + (x7794 + (cadddr + args)) + (x7792 + (letrec ((x7793 + (cddddr + args))) + (car + x7793))) + (x7790 + (letrec ((x7791 + (cddddr + args))) + (cadr + x7791)))) + (proc + x7797 + x7796 + x7795 + x7794 + x7792 + x7790)))) + g7789) + (if cnd + (letrec ((g7798 + (letrec ((x7808 + (car + args)) + (x7807 + (cadr + args)) + (x7806 + (caddr + args)) + (x7805 + (cadddr + args)) + (x7803 + (letrec ((x7804 + (cddddr + args))) + (car + x7804))) + (x7801 + (letrec ((x7802 + (cddddr + args))) + (cadr + x7802))) + (x7799 + (letrec ((x7800 + (cddddr + args))) + (caddr + x7800)))) + (proc + x7808 + x7807 + x7806 + x7805 + x7803 + x7801 + x7799)))) + g7798) + (letrec ((g7809 + (error + "Unsupported call."))) + g7809))))))))))) + g7764))) + (member + (lambda (e l) + (letrec ((g7810 + (letrec ((x7812 (list? l))) + (assert x7812))) + (g7811 + (letrec ((x-cnd7813 (null? l))) + (if x-cnd7813 + #f + (letrec ((x-cnd7814 + (letrec ((x7815 + (car l))) + (equal? x7815 e)))) + (if x-cnd7814 + l + (letrec ((x7816 (cdr l))) + (member e x7816)))))))) + g7811))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 + (letrec ((x7819 + (letrec ((x7820 + (cdr + x))) + (cdr + x7820)))) + (cdr x7819)))) + (cdr x7818)))) + g7817))) + (cadddr + (lambda (x) + (letrec ((g7821 + (letrec ((x7822 + (letrec ((x7823 + (letrec ((x7824 + (cdr + x))) + (cdr + x7824)))) + (cdr x7823)))) + (car x7822)))) + g7821))) + (int-top + (lambda () + (letrec ((g7825 (random 42))) g7825))) + (zero? + (lambda (x) + (letrec ((g7826 + (letrec ((x7828 (number? x))) + (assert x7828))) + (g7827 (= x 0))) + g7827))) + (string>=? + (lambda (s1 s2) + (letrec ((g7829 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7830 + (if val7155 + val7155 + (string=? s1 s2)))) + g7830)))) + g7829))) + (cadr + (lambda (x) + (letrec ((g7831 + (letrec ((x7832 (cdr x))) + (car x7832)))) + g7831))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7833 + (letrec ((val7156 + (letrec ((x7836 + (pair? l)) + (x7834 + (letrec ((x7835 + (cdr + l))) + (list? + x7835)))) + (and x7836 x7834)))) + (letrec ((g7837 + (if val7156 + val7156 + (null? l)))) + g7837)))) + g7833))) + (cddaar + (lambda (x) + (letrec ((g7838 + (letrec ((x7839 + (letrec ((x7840 + (letrec ((x7841 + (car + x))) + (car + x7841)))) + (cdr x7840)))) + (cdr x7839)))) + g7838))) + (char-numeric? + (lambda (c) + (letrec ((g7842 + (letrec ((x-cnd7843 + (letrec ((x7844 #\0)) + (char<=? x7844 c)))) + (if x-cnd7843 + (letrec ((x7845 #\9)) + (char<=? c x7845)) + #f)))) + g7842))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7846 + (letrec ((x7848 (list? l))) + (assert x7848))) + (g7847 + (letrec ((x-cnd7849 (null? l))) + (if x-cnd7849 + #f + (letrec ((x-cnd7850 + (letrec ((x7851 + (caar l))) + (eqv? x7851 k)))) + (if x-cnd7850 + (car l) + (letrec ((x7852 (cdr l))) + (assq k x7852)))))))) + g7847))) + (not + (lambda (x) + (letrec ((g7853 (if x #f #t))) g7853))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7854 (append l1 l2))) g7854))) + (memq + (lambda (e l) + (letrec ((g7855 + (letrec ((x7857 (list? l))) + (assert x7857))) + (g7856 + (letrec ((x-cnd7858 (null? l))) + (if x-cnd7858 + #f + (letrec ((x-cnd7859 + (letrec ((x7860 + (car l))) + (eq? x7860 e)))) + (if x-cnd7859 + l + (letrec ((x7861 (cdr l))) + (memq e x7861)))))))) + g7856))) + (cadaar + (lambda (x) + (letrec ((g7862 + (letrec ((x7863 + (letrec ((x7864 + (letrec ((x7865 + (car + x))) + (car + x7865)))) + (cdr x7864)))) + (car x7863)))) + g7862))) + (length + (lambda (l) + (letrec ((g7866 + (letrec ((x7868 (list? l))) + (assert x7868))) + (g7867 + (letrec ((rec + (lambda (l) + (letrec ((g7869 + (letrec ((x-cnd7870 + (null? + l))) + (if x-cnd7870 + 0 + (letrec ((x7871 + (letrec ((x7872 + (cdr + l))) + (rec + x7872)))) + (+ + 1 + x7871)))))) + g7869)))) + (letrec ((g7873 (rec l))) + g7873)))) + g7867))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7874 + (letrec ((x7877 (char? c1))) + (assert x7877))) + (g7875 + (letrec ((x7878 (char? c2))) + (assert x7878))) + (g7876 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7880 + (letrec ((x7881 (string<=? s1 s2))) + (not x7881)))) + g7880))) + (cdadr + (lambda (x) + (letrec ((g7882 + (letrec ((x7883 + (letrec ((x7884 (cdr x))) + (car x7884)))) + (cdr x7883)))) + g7882))) + (assoc + (lambda (k l) + (letrec ((g7885 + (letrec ((x7887 (list? l))) + (assert x7887))) + (g7886 + (letrec ((x-cnd7888 (null? l))) + (if x-cnd7888 + #f + (letrec ((x-cnd7889 + (letrec ((x7890 + (caar l))) + (equal? x7890 k)))) + (if x-cnd7889 + (car l) + (letrec ((x7891 (cdr l))) + (assoc k x7891)))))))) + g7886))) + (caar + (lambda (x) + (letrec ((g7892 + (letrec ((x7893 (car x))) + (car x7893)))) + g7892))) + (char>? + (lambda (c1 c2) + (letrec ((g7894 + (letrec ((x7897 (char? c1))) + (assert x7897))) + (g7895 + (letrec ((x7898 (char? c2))) + (assert x7898))) + (g7896 + (letrec ((x7899 (char<=? c1 c2))) + (not x7899)))) + g7896))) + (string<=? + (lambda (s1 s2) + (letrec ((g7900 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7917 + (letrec ((x7920 (char? c1))) + (assert x7920))) + (g7918 + (letrec ((x7921 (char? c2))) + (assert x7921))) + (g7919 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7922 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7922)))) + g7919))) + (caddar + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (car + x))) + (cdr + x7926)))) + (cdr x7925)))) + (car x7924)))) + g7923))) + (newline + (lambda () (letrec ((g7927 #f)) g7927))) + (lcm + (lambda (m n) + (letrec ((g7928 + (letrec ((x7930 + (letrec ((x7931 (* m n))) + (abs x7931))) + (x7929 (gcd m n))) + (/ x7930 x7929)))) + g7928))) + (deref car) + (> + (lambda (x y) + (letrec ((g7932 + (letrec ((x7934 (number? x))) + (assert x7934))) + (g7933 + (letrec ((x7935 (<= x y))) + (not x7935)))) + g7933))) + (list-ref + (lambda (l index) + (letrec ((g7936 + (letrec ((x7940 (list? l))) + (assert x7940))) + (g7937 + (letrec ((x7941 (number? index))) + (assert x7941))) + (g7938 + (letrec ((x7942 + (letrec ((x7943 + (length l))) + (< index x7943)))) + (assert x7942))) + (g7939 + (letrec ((x-cnd7944 (= index 0))) + (if x-cnd7944 + (car l) + (letrec ((x7946 (cdr l)) + (x7945 (- index 1))) + (list-ref x7946 x7945)))))) + g7939))) + (gcd + (lambda (a b) + (letrec ((g7947 + (letrec ((x-cnd7948 (= b 0))) + (if x-cnd7948 + a + (letrec ((x7949 (modulo a b))) + (gcd b x7949)))))) + g7947))) + (real/c + (lambda (g7161 g7162 g7163) + (letrec ((g7950 + (letrec ((x-cnd7951 (real? g7163))) + (if x-cnd7951 + g7163 + (blame g7161 'real?))))) + g7950))) + (boolean?/c + (lambda (g7164 g7165 g7166) + (letrec ((g7952 + (letrec ((x-cnd7953 + (boolean? g7166))) + (if x-cnd7953 + g7166 + (blame g7164 'boolean?))))) + g7952))) + (number?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7954 + (letrec ((x-cnd7955 + (number? g7169))) + (if x-cnd7955 + g7169 + (blame g7167 'number?))))) + g7954))) + (any/c + (lambda (g7170 g7171 g7172) + (letrec ((g7956 + (letrec ((x-cnd7957 + ((lambda (v) #t) g7172))) + (if x-cnd7957 + g7172 + (blame + g7170 + '(lambda (v) #t)))))) + g7956))) + (any?/c + (lambda (g7173 g7174 g7175) + (letrec ((g7958 + (letrec ((x-cnd7959 + ((lambda (v) #t) g7175))) + (if x-cnd7959 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7958))) + (image? any/c) + (cons?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7960 + (letrec ((x-cnd7961 (pair? g7178))) + (if x-cnd7961 + g7178 + (blame g7176 'pair?))))) + g7960))) + (pair?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7962 + (letrec ((x-cnd7963 (pair? g7181))) + (if x-cnd7963 + g7181 + (blame g7179 'pair?))))) + g7962))) + (integer? + (lambda (g7182 g7183 g7184) + (letrec ((g7964 + (letrec ((x-cnd7965 + (integer? g7184))) + (if x-cnd7965 + g7184 + (blame g7182 'integer?))))) + g7964))) + (and/c + (lambda (c1 c2) + (letrec ((g7966 + (lambda (k j v) + (letrec ((g7967 + (letrec ((x-cnd7968 + (c1 k j v))) + (if x-cnd7968 + (c2 k j v) + #f)))) + g7967)))) + g7966))) + (list-of + (lambda (contract) + (letrec ((g7969 + (lambda (k j v) + (letrec ((g7970 + (letrec ((x-cnd7971 + (null? v))) + (if x-cnd7971 + '() + (letrec ((x7975 + (letrec ((x7976 + (car + v))) + (contract + k + j + x7976))) + (x7972 + (letrec ((x7974 + (list-of + contract)) + (x7973 + (cdr + v))) + (x7974 + k + j + x7973)))) + (cons + x7975 + x7972)))))) + g7970)))) + g7969))) + (any? (lambda (v) (letrec ((g7977 #t)) g7977))) + (nonzero? + (lambda (v) + (letrec ((g7978 + (letrec ((x7979 (= v 0))) + (not x7979)))) + g7978))) + (nonzero?/c + (lambda (g7185 g7186 g7187) + (letrec ((g7980 + (letrec ((x-cnd7981 + ((lambda (v) + (not (= v 0))) + g7187))) + (if x-cnd7981 + g7187 + (blame + g7185 + '(lambda (v) + (not (= v 0)))))))) + g7980))) + (meta (lambda (v) (letrec ((g7982 v)) g7982))) + (orig-+ +) + (+ + ((lambda (j7190 k7191 f7192) + (lambda (g7188 g7189) + (number?/c + j7190 + k7191 + (f7192 + (number?/c j7190 k7191 g7188) + (number?/c j7190 k7191 g7189))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7195 k7196 f7197) + (lambda (g7193 g7194) + (number?/c + j7195 + k7196 + (f7197 + (number?/c j7195 k7196 g7193) + (number?/c j7195 k7196 g7194))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7200 k7201 f7202) + (lambda (g7198 g7199) + (number?/c + j7200 + k7201 + (f7202 + (number?/c j7200 k7201 g7198) + (number?/c j7200 k7201 g7199))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7205 k7206 f7207) + (lambda (g7203 g7204) + (number?/c + j7205 + k7206 + (f7207 + (number?/c j7205 k7206 g7203) + (number?/c j7205 k7206 g7204))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7209 k7210 f7211) + (lambda (g7208) + (any/c + j7209 + k7210 + (f7211 (pair?/c j7209 k7210 g7208))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7213 k7214 f7215) + (lambda (g7212) + (any/c + j7213 + k7214 + (f7215 (pair?/c j7213 k7214 g7212))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7218 k7219 f7220) + (lambda (g7216 g7217) + (pair?/c + j7218 + k7219 + (f7220 + (any/c j7218 k7219 g7216) + (any/c j7218 k7219 g7217))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7222 k7223 f7224) + (lambda (g7221) + (integer?/c + j7222 + k7223 + (f7224 (vector?/c j7222 k7223 g7221))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7227 k7228 f7229) + (lambda (g7225 g7226) + (any/c + j7227 + k7228 + (f7229 + (vector?/c j7227 k7228 g7225) + (integer?/c j7227 k7228 g7226))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7983 #t)) g7983))) + (cdddr + (lambda (x) + (letrec ((g7984 + (letrec ((x7985 + (letrec ((x7986 (cdr x))) + (cdr x7986)))) + (cdr x7985)))) + g7984))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7987 + (letrec ((x7990 (procedure? f))) + (assert x7990))) + (g7988 + (letrec ((x7991 (list? l))) + (assert x7991))) + (g7989 + (letrec ((x-cnd7992 (null? l))) + (if x-cnd7992 + '() + (letrec ((x7995 + (letrec ((x7996 + (car l))) + (f x7996))) + (x7993 + (letrec ((x7994 + (cdr l))) + (map f x7994)))) + (cons x7995 x7993)))))) + g7989))) + (cdar + (lambda (x) + (letrec ((g7997 + (letrec ((x7998 (car x))) + (cdr x7998)))) + g7997))) + (cadadr + (lambda (x) + (letrec ((g7999 + (letrec ((x8000 + (letrec ((x8001 + (letrec ((x8002 + (cdr + x))) + (car + x8002)))) + (cdr x8001)))) + (car x8000)))) + g7999))) + (cdadar + (lambda (x) + (letrec ((g8003 + (letrec ((x8004 + (letrec ((x8005 + (letrec ((x8006 + (car + x))) + (cdr + x8006)))) + (car x8005)))) + (cdr x8004)))) + g8003))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g8007 + (letrec ((x8010 + (string? filename))) + (assert x8010))) + (g8008 + (letrec ((x8011 (procedure? proc))) + (assert x8011))) + (g8009 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g8012 + (close-output-port + output-port)) + (g8013 res)) + g8013)))) + g8009))) + (caddr + (lambda (x) + (letrec ((g8014 + (letrec ((x8015 + (letrec ((x8016 (cdr x))) + (cdr x8016)))) + (car x8015)))) + g8014))) + (cdaadr + (lambda (x) + (letrec ((g8017 + (letrec ((x8018 + (letrec ((x8019 + (letrec ((x8020 + (cdr + x))) + (car + x8020)))) + (car x8019)))) + (cdr x8018)))) + g8017))) + (assq + (lambda (k l) + (letrec ((g8021 + (letrec ((x8023 (list? l))) + (assert x8023))) + (g8022 + (letrec ((x-cnd8024 (null? l))) + (if x-cnd8024 + #f + (letrec ((x-cnd8025 + (letrec ((x8026 + (caar l))) + (eq? x8026 k)))) + (if x-cnd8025 + (car l) + (letrec ((x8027 (cdr l))) + (assq k x8027)))))))) + g8022))) + (even? + (lambda (x) + (letrec ((g8028 + (letrec ((x8029 (modulo x 2))) + (= 0 x8029)))) + g8028))) + (list->string + (lambda (l) + (letrec ((g8030 + (letrec ((x8032 (list? l))) + (assert x8032))) + (g8031 + (letrec ((x-cnd8033 (null? l))) + (if x-cnd8033 + "" + (letrec ((x8036 + (letrec ((x8037 + (car l))) + (char->string + x8037))) + (x8034 + (letrec ((x8035 + (cdr l))) + (list->string + x8035)))) + (string-append + x8036 + x8034)))))) + g8031))) + (char<=? + (lambda (c1 c2) + (letrec ((g8038 + (letrec ((x8041 (char? c1))) + (assert x8041))) + (g8039 + (letrec ((x8042 (char? c2))) + (assert x8042))) + (g8040 + (letrec ((val7143 (char=? c x8059)))) + (if x-cnd8058 + (letrec ((x8060 #\z)) + (char-ci<=? c x8060)) + #f)))) + g8057))) + (<= + (lambda (x y) + (letrec ((g8061 + (letrec ((x8063 (number? x))) + (assert x8063))) + (g8062 + (letrec ((val7144 (< x y))) + (letrec ((g8064 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g8065 + (if val7145 + val7145 + #f))) + g8065))))) + g8064)))) + g8062))) + (char-whitespace? + (lambda (c) + (letrec ((g8066 + (letrec ((val7146 + (letrec ((x8067 + (char->integer + c))) + (= x8067 9)))) + (letrec ((g8068 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x8069 + (char->integer + c))) + (= + x8069 + 10)))) + (letrec ((g8070 + (if val7147 + val7147 + (letrec ((x8071 + (char->integer + c))) + (= + x8071 + 32))))) + g8070))))) + g8068)))) + g8066))) + (cddar + (lambda (x) + (letrec ((g8072 + (letrec ((x8073 + (letrec ((x8074 (car x))) + (cdr x8074)))) + (cdr x8073)))) + g8072))) + (positive? + (lambda (x) + (letrec ((g8075 + (letrec ((x8077 (number? x))) + (assert x8077))) + (g8076 (> x 0))) + g8076))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g8078 #f)) g8078))) + (cddr + (lambda (x) + (letrec ((g8079 + (letrec ((x8080 (cdr x))) + (cdr x8080)))) + g8079))) + (truncate + (lambda (x) + (letrec ((g8081 + (letrec ((x8083 (number? x))) + (assert x8083))) + (g8082 + (letrec ((x-cnd8084 (< x 0))) + (if x-cnd8084 + (ceiling x) + (floor x))))) + g8082))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g8085 + (letrec ((val7148 (eq? a b))) + (letrec ((g8086 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x8088 + (null? + a)) + (x8087 + (null? + b))) + (and x8088 + x8087)))) + (letrec ((g8089 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x8092 + (string? + a)) + (x8091 + (string? + b)) + (x8090 + (string=? + a + b))) + (and x8092 + x8091 + x8090)))) + (letrec ((g8093 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x8101 + (pair? + a)) + (x8100 + (pair? + b)) + (x8097 + (letrec ((x8099 + (car + a)) + (x8098 + (car + b))) + (equal? + x8099 + x8098))) + (x8094 + (letrec ((x8096 + (cdr + a)) + (x8095 + (cdr + b))) + (equal? + x8096 + x8095)))) + (and x8101 + x8100 + x8097 + x8094)))) + (letrec ((g8102 + (if val7151 + val7151 + (letrec ((x8121 + (vector? + a)) + (x8120 + (vector? + b)) + (x8103 + (letrec ((x8117 + (letrec ((x8118 + (letrec ((x8119 + (vector-length + a))) + (n + x8119)))) + (x8118))) + (x8104 + (letrec ((x8115 + (letrec ((x8116 + (vector-length + b))) + (= + x8116 + n))) + (x8105 + (letrec ((loop + (lambda (i) + (letrec ((g8106 + (letrec ((x8113 + (= + i + n)) + (x8107 + (letrec ((x8110 + (letrec ((x8112 + (vector-ref + a + i)) + (x8111 + (vector-ref + b + i))) + (equal? + x8112 + x8111))) + (x8108 + (letrec ((x8109 + (+ + i + 1))) + (loop + x8109)))) + (and x8110 + x8108)))) + (or x8113 + x8107)))) + g8106)))) + (letrec ((g8114 + (loop + 0))) + g8114)))) + (and x8115 + x8105)))) + (let x8117 x8104)))) + (and x8121 + x8120 + x8103))))) + g8102))))) + g8093))))) + g8089))))) + g8086)))) + g8085))) + (cdaaar + (lambda (x) + (letrec ((g8122 + (letrec ((x8123 + (letrec ((x8124 + (letrec ((x8125 + (car + x))) + (car + x8125)))) + (car x8124)))) + (cdr x8123)))) + g8122))) + (caaddr + (lambda (x) + (letrec ((g8126 + (letrec ((x8127 + (letrec ((x8128 + (letrec ((x8129 + (cdr + x))) + (cdr + x8129)))) + (car x8128)))) + (car x8127)))) + g8126))) + (eqv? + (lambda (x y) + (letrec ((g8130 (eq? x y))) g8130))) + (>= + (lambda (x y) + (letrec ((g8131 + (letrec ((x8133 (number? x))) + (assert x8133))) + (g8132 + (letrec ((val7152 (> x y))) + (letrec ((g8134 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g8135 + (if val7153 + val7153 + #f))) + g8135))))) + g8134)))) + g8132))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g8136 + (letrec ((x8139 + (string? filename))) + (assert x8139))) + (g8137 + (letrec ((x8140 (procedure? proc))) + (assert x8140))) + (g8138 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g8141 + (close-input-port + input-port)) + (g8142 res)) + g8142)))) + g8138))) + (ref + (lambda (x) + (letrec ((g8143 (cons x '()))) g8143))) + (char>=? + (lambda (c1 c2) + (letrec ((g8144 + (letrec ((x8147 (char? c1))) + (assert x8147))) + (g8145 + (letrec ((x8148 (char? c2))) + (assert x8148))) + (g8146 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g8149 + (if val7154 + val7154 + (char=? c1 c2)))) + g8149)))) + g8146))) + (cdaar + (lambda (x) + (letrec ((g8150 + (letrec ((x8151 + (letrec ((x8152 (car x))) + (car x8152)))) + (cdr x8151)))) + g8150))) + (cdaddr + (lambda (x) + (letrec ((g8153 + (letrec ((x8154 + (letrec ((x8155 + (letrec ((x8156 + (cdr + x))) + (cdr + x8156)))) + (car x8155)))) + (cdr x8154)))) + g8153))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g8157 + (letrec ((x8158 + (letrec ((x8159 (car x))) + (cdr x8159)))) + (car x8158)))) + g8157))) + (caadr + (lambda (x) + (letrec ((g8160 + (letrec ((x8161 + (letrec ((x8162 (cdr x))) + (car x8162)))) + (car x8161)))) + g8160))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g8163 + (letrec ((x8166 (char? c1))) + (assert x8166))) + (g8164 + (letrec ((x8167 (char? c2))) + (assert x8167))) + (g8165 + (letrec ((x8168 + (char-ci<=? c1 c2))) + (not x8168)))) + g8165))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g8169 + (letrec ((x8170 + (letrec ((x8171 + (letrec ((x8172 + (car + x))) + (car + x8172)))) + (car x8171)))) + (car x8170)))) + g8169))) + (negative? + (lambda (x) + (letrec ((g8173 + (letrec ((x8175 (number? x))) + (assert x8175))) + (g8174 (< x 0))) + g8174))) + (memv + (lambda (e l) + (letrec ((g8176 (memq e l))) g8176))) + (caaar + (lambda (x) + (letrec ((g8177 + (letrec ((x8178 + (letrec ((x8179 (car x))) + (car x8179)))) + (car x8178)))) + g8177))) + (debug + (lambda (e) (letrec ((g8180 '())) g8180))) + (reverse + (lambda (l) + (letrec ((g8181 + (letrec ((x8183 (list? l))) + (assert x8183))) + (g8182 + (letrec ((x-cnd8184 (null? l))) + (if x-cnd8184 + '() + (letrec ((x8187 + (letrec ((x8188 + (cdr l))) + (reverse x8188))) + (x8185 + (letrec ((x8186 + (car l))) + (list x8186)))) + (append x8187 x8185)))))) + g8182))) + (caaadr + (lambda (x) + (letrec ((g8189 + (letrec ((x8190 + (letrec ((x8191 + (letrec ((x8192 + (cdr + x))) + (car + x8192)))) + (car x8191)))) + (car x8190)))) + g8189))) + (cddadr + (lambda (x) + (letrec ((g8193 + (letrec ((x8194 + (letrec ((x8195 + (letrec ((x8196 + (cdr + x))) + (car + x8196)))) + (cdr x8195)))) + (cdr x8194)))) + g8193))) + (odd? + (lambda (x) + (letrec ((g8197 + (letrec ((x8199 (number? x))) + (assert x8199))) + (g8198 + (letrec ((x8200 (modulo x 2))) + (= 1 x8200)))) + g8198))) + (caadar + (lambda (x) + (letrec ((g8201 + (letrec ((x8202 + (letrec ((x8203 + (letrec ((x8204 + (car + x))) + (cdr + x8204)))) + (car x8203)))) + (car x8202)))) + g8201))) + (apply + (lambda (proc args) + (letrec ((g8205 + (letrec ((x8208 (procedure? proc))) + (assert x8208))) + (g8206 + (letrec ((x8209 (list? args))) + (assert x8209))) + (g8207 + (if cnd + (letrec ((g8210 (proc))) g8210) + (if cnd + (letrec ((g8211 + (letrec ((x8212 + (car + args))) + (proc x8212)))) + g8211) + (if cnd + (letrec ((g8213 + (letrec ((x8215 + (car + args)) + (x8214 + (cadr + args))) + (proc + x8215 + x8214)))) + g8213) + (if cnd + (letrec ((g8216 + (letrec ((x8219 + (car + args)) + (x8218 + (cadr + args)) + (x8217 + (caddr + args))) + (proc + x8219 + x8218 + x8217)))) + g8216) + (if cnd + (letrec ((g8220 + (letrec ((x8224 + (car + args)) + (x8223 + (cadr + args)) + (x8222 + (caddr + args)) + (x8221 + (cadddr + args))) + (proc + x8224 + x8223 + x8222 + x8221)))) + g8220) + (if cnd + (letrec ((g8225 + (letrec ((x8231 + (car + args)) + (x8230 + (cadr + args)) + (x8229 + (caddr + args)) + (x8228 + (cadddr + args)) + (x8226 + (letrec ((x8227 + (cddddr + args))) + (car + x8227)))) + (proc + x8231 + x8230 + x8229 + x8228 + x8226)))) + g8225) + (if cnd + (letrec ((g8232 + (letrec ((x8240 + (car + args)) + (x8239 + (cadr + args)) + (x8238 + (caddr + args)) + (x8237 + (cadddr + args)) + (x8235 + (letrec ((x8236 + (cddddr + args))) + (car + x8236))) + (x8233 + (letrec ((x8234 + (cddddr + args))) + (cadr + x8234)))) + (proc + x8240 + x8239 + x8238 + x8237 + x8235 + x8233)))) + g8232) + (if cnd + (letrec ((g8241 + (letrec ((x8251 + (car + args)) + (x8250 + (cadr + args)) + (x8249 + (caddr + args)) + (x8248 + (cadddr + args)) + (x8246 + (letrec ((x8247 + (cddddr + args))) + (car + x8247))) + (x8244 + (letrec ((x8245 + (cddddr + args))) + (cadr + x8245))) + (x8242 + (letrec ((x8243 + (cddddr + args))) + (caddr + x8243)))) + (proc + x8251 + x8250 + x8249 + x8248 + x8246 + x8244 + x8242)))) + g8241) + (letrec ((g8252 + (error + "Unsupported call."))) + g8252))))))))))) + g8207))) + (member + (lambda (e l) + (letrec ((g8253 + (letrec ((x8255 (list? l))) + (assert x8255))) + (g8254 + (letrec ((x-cnd8256 (null? l))) + (if x-cnd8256 + #f + (letrec ((x-cnd8257 + (letrec ((x8258 + (car l))) + (equal? x8258 e)))) + (if x-cnd8257 + l + (letrec ((x8259 (cdr l))) + (member e x8259)))))))) + g8254))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8260 + (letrec ((x8261 + (letrec ((x8262 + (letrec ((x8263 + (cdr + x))) + (cdr + x8263)))) + (cdr x8262)))) + (cdr x8261)))) + g8260))) + (cadddr + (lambda (x) + (letrec ((g8264 + (letrec ((x8265 + (letrec ((x8266 + (letrec ((x8267 + (cdr + x))) + (cdr + x8267)))) + (cdr x8266)))) + (car x8265)))) + g8264))) + (int-top + (lambda () + (letrec ((g8268 (random 42))) g8268))) + (zero? + (lambda (x) + (letrec ((g8269 + (letrec ((x8271 (number? x))) + (assert x8271))) + (g8270 (= x 0))) + g8270))) + (string>=? + (lambda (s1 s2) + (letrec ((g8272 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8273 + (if val7155 + val7155 + (string=? s1 s2)))) + g8273)))) + g8272))) + (cadr + (lambda (x) + (letrec ((g8274 + (letrec ((x8275 (cdr x))) + (car x8275)))) + g8274))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8276 + (letrec ((val7156 + (letrec ((x8279 + (pair? l)) + (x8277 + (letrec ((x8278 + (cdr + l))) + (list? + x8278)))) + (and x8279 x8277)))) + (letrec ((g8280 + (if val7156 + val7156 + (null? l)))) + g8280)))) + g8276))) + (cddaar + (lambda (x) + (letrec ((g8281 + (letrec ((x8282 + (letrec ((x8283 + (letrec ((x8284 + (car + x))) + (car + x8284)))) + (cdr x8283)))) + (cdr x8282)))) + g8281))) + (char-numeric? + (lambda (c) + (letrec ((g8285 + (letrec ((x-cnd8286 + (letrec ((x8287 #\0)) + (char<=? x8287 c)))) + (if x-cnd8286 + (letrec ((x8288 #\9)) + (char<=? c x8288)) + #f)))) + g8285))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8289 + (letrec ((x8291 (list? l))) + (assert x8291))) + (g8290 + (letrec ((x-cnd8292 (null? l))) + (if x-cnd8292 + #f + (letrec ((x-cnd8293 + (letrec ((x8294 + (caar l))) + (eqv? x8294 k)))) + (if x-cnd8293 + (car l) + (letrec ((x8295 (cdr l))) + (assq k x8295)))))))) + g8290))) + (not + (lambda (x) + (letrec ((g8296 (if x #f #t))) g8296))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8297 (append l1 l2))) g8297))) + (memq + (lambda (e l) + (letrec ((g8298 + (letrec ((x8300 (list? l))) + (assert x8300))) + (g8299 + (letrec ((x-cnd8301 (null? l))) + (if x-cnd8301 + #f + (letrec ((x-cnd8302 + (letrec ((x8303 + (car l))) + (eq? x8303 e)))) + (if x-cnd8302 + l + (letrec ((x8304 (cdr l))) + (memq e x8304)))))))) + g8299))) + (cadaar + (lambda (x) + (letrec ((g8305 + (letrec ((x8306 + (letrec ((x8307 + (letrec ((x8308 + (car + x))) + (car + x8308)))) + (cdr x8307)))) + (car x8306)))) + g8305))) + (length + (lambda (l) + (letrec ((g8309 + (letrec ((x8311 (list? l))) + (assert x8311))) + (g8310 + (letrec ((rec + (lambda (l) + (letrec ((g8312 + (letrec ((x-cnd8313 + (null? + l))) + (if x-cnd8313 + 0 + (letrec ((x8314 + (letrec ((x8315 + (cdr + l))) + (rec + x8315)))) + (+ + 1 + x8314)))))) + g8312)))) + (letrec ((g8316 (rec l))) + g8316)))) + g8310))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8317 + (letrec ((x8320 (char? c1))) + (assert x8320))) + (g8318 + (letrec ((x8321 (char? c2))) + (assert x8321))) + (g8319 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8323 + (letrec ((x8324 (string<=? s1 s2))) + (not x8324)))) + g8323))) + (cdadr + (lambda (x) + (letrec ((g8325 + (letrec ((x8326 + (letrec ((x8327 (cdr x))) + (car x8327)))) + (cdr x8326)))) + g8325))) + (assoc + (lambda (k l) + (letrec ((g8328 + (letrec ((x8330 (list? l))) + (assert x8330))) + (g8329 + (letrec ((x-cnd8331 (null? l))) + (if x-cnd8331 + #f + (letrec ((x-cnd8332 + (letrec ((x8333 + (caar l))) + (equal? x8333 k)))) + (if x-cnd8332 + (car l) + (letrec ((x8334 (cdr l))) + (assoc k x8334)))))))) + g8329))) + (caar + (lambda (x) + (letrec ((g8335 + (letrec ((x8336 (car x))) + (car x8336)))) + g8335))) + (char>? + (lambda (c1 c2) + (letrec ((g8337 + (letrec ((x8340 (char? c1))) + (assert x8340))) + (g8338 + (letrec ((x8341 (char? c2))) + (assert x8341))) + (g8339 + (letrec ((x8342 (char<=? c1 c2))) + (not x8342)))) + g8339))) + (string<=? + (lambda (s1 s2) + (letrec ((g8343 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8360 + (letrec ((x8363 (char? c1))) + (assert x8363))) + (g8361 + (letrec ((x8364 (char? c2))) + (assert x8364))) + (g8362 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8365 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8365)))) + g8362))) + (caddar + (lambda (x) + (letrec ((g8366 + (letrec ((x8367 + (letrec ((x8368 + (letrec ((x8369 + (car + x))) + (cdr + x8369)))) + (cdr x8368)))) + (car x8367)))) + g8366))) + (newline + (lambda () (letrec ((g8370 #f)) g8370))) + (lcm + (lambda (m n) + (letrec ((g8371 + (letrec ((x8373 + (letrec ((x8374 (* m n))) + (abs x8374))) + (x8372 (gcd m n))) + (/ x8373 x8372)))) + g8371))) + (deref car) + (> + (lambda (x y) + (letrec ((g8375 + (letrec ((x8377 (number? x))) + (assert x8377))) + (g8376 + (letrec ((x8378 (<= x y))) + (not x8378)))) + g8376))) + (list-ref + (lambda (l index) + (letrec ((g8379 + (letrec ((x8383 (list? l))) + (assert x8383))) + (g8380 + (letrec ((x8384 (number? index))) + (assert x8384))) + (g8381 + (letrec ((x8385 + (letrec ((x8386 + (length l))) + (< index x8386)))) + (assert x8385))) + (g8382 + (letrec ((x-cnd8387 (= index 0))) + (if x-cnd8387 + (car l) + (letrec ((x8389 (cdr l)) + (x8388 (- index 1))) + (list-ref x8389 x8388)))))) + g8382))) + (gcd + (lambda (a b) + (letrec ((g8390 + (letrec ((x-cnd8391 (= b 0))) + (if x-cnd8391 + a + (letrec ((x8392 (modulo a b))) + (gcd b x8392)))))) + g8390)))) + (letrec ((g8393 + (letrec ((g8394 + (letrec ((block + (lambda (x7473 + y7474 + color7475) + (letrec ((g8395 + (letrec ((x8396 + (letrec ((x8397 + (letrec ((x8398 + (cons + color7475 + '()))) + (cons + y7474 + x8398)))) + (cons + x7473 + x8397)))) + (cons + 'block + x8396)))) + g8395))) + (block? + (lambda (block7472) + (letrec ((g8399 + (letrec ((x8400 + (car + block7472))) + (eq? + x8400 + 'block)))) + g8399))) + (block-x + (lambda (block) + (letrec ((g8401 + (letrec ((x8402 + (cdr + block))) + (car + x8402)))) + g8401))) + (block-y + (lambda (block) + (letrec ((g8403 + (letrec ((x8404 + (letrec ((x8405 + (cdr + block))) + (cdr + x8405)))) + (car + x8404)))) + g8403))) + (block-color + (lambda (block) + (letrec ((g8406 + (letrec ((x8407 + (letrec ((x8408 + (letrec ((x8409 + (cdr + block))) + (cdr + x8409)))) + (cdr + x8408)))) + (car + x8407)))) + g8406))) + (block + (lambda (x7473 + y7474 + color7475) + (letrec ((g8410 + (letrec ((x8411 + (letrec ((x8412 + (letrec ((x8413 + (cons + color7475 + '()))) + (cons + y7474 + x8413)))) + (cons + x7473 + x8412)))) + (cons + 'block + x8411)))) + g8410))) + (block? + (lambda (block7472) + (letrec ((g8414 + (letrec ((x8415 + (car + block7472))) + (eq? + x8415 + 'block)))) + g8414))) + (block-x + (lambda (block) + (letrec ((g8416 + (letrec ((x8417 + (cdr + block))) + (car + x8417)))) + g8416))) + (block-y + (lambda (block) + (letrec ((g8418 + (letrec ((x8419 + (letrec ((x8420 + (cdr + block))) + (cdr + x8420)))) + (car + x8419)))) + g8418))) + (block-color + (lambda (block) + (letrec ((g8421 + (letrec ((x8422 + (letrec ((x8423 + (letrec ((x8424 + (cdr + block))) + (cdr + x8424)))) + (cdr + x8423)))) + (car + x8422)))) + g8421)))) + (letrec ((g8425 + (letrec ((tetra + (lambda (center7480 + blocks7481) + (letrec ((g8426 + (letrec ((x8427 + (letrec ((x8428 + (cons + blocks7481 + '()))) + (cons + center7480 + x8428)))) + (cons + 'tetra + x8427)))) + g8426))) + (tetra? + (lambda (tetra7479) + (letrec ((g8429 + (letrec ((x8430 + (car + tetra7479))) + (eq? + x8430 + 'tetra)))) + g8429))) + (tetra-center + (lambda (tetra) + (letrec ((g8431 + (letrec ((x8432 + (cdr + tetra))) + (car + x8432)))) + g8431))) + (tetra-blocks + (lambda (tetra) + (letrec ((g8433 + (letrec ((x8434 + (letrec ((x8435 + (cdr + tetra))) + (cdr + x8435)))) + (car + x8434)))) + g8433))) + (tetra + (lambda (center7480 + blocks7481) + (letrec ((g8436 + (letrec ((x8437 + (letrec ((x8438 + (cons + blocks7481 + '()))) + (cons + center7480 + x8438)))) + (cons + 'tetra + x8437)))) + g8436))) + (tetra? + (lambda (tetra7479) + (letrec ((g8439 + (letrec ((x8440 + (car + tetra7479))) + (eq? + x8440 + 'tetra)))) + g8439))) + (tetra-center + (lambda (tetra) + (letrec ((g8441 + (letrec ((x8442 + (cdr + tetra))) + (car + x8442)))) + g8441))) + (tetra-blocks + (lambda (tetra) + (letrec ((g8443 + (letrec ((x8444 + (letrec ((x8445 + (cdr + tetra))) + (cdr + x8445)))) + (car + x8444)))) + g8443)))) + (letrec ((g8446 + (letrec ((world + (lambda (tetra7485 + blocks7486) + (letrec ((g8447 + (letrec ((x8448 + (letrec ((x8449 + (cons + blocks7486 + '()))) + (cons + tetra7485 + x8449)))) + (cons + 'world + x8448)))) + g8447))) + (world? + (lambda (world7484) + (letrec ((g8450 + (letrec ((x8451 + (car + world7484))) + (eq? + x8451 + 'world)))) + g8450))) + (world-tetra + (lambda (world) + (letrec ((g8452 + (letrec ((x8453 + (cdr + world))) + (car + x8453)))) + g8452))) + (world-blocks + (lambda (world) + (letrec ((g8454 + (letrec ((x8455 + (letrec ((x8456 + (cdr + world))) + (cdr + x8456)))) + (car + x8455)))) + g8454))) + (world + (lambda (tetra7485 + blocks7486) + (letrec ((g8457 + (letrec ((x8458 + (letrec ((x8459 + (cons + blocks7486 + '()))) + (cons + tetra7485 + x8459)))) + (cons + 'world + x8458)))) + g8457))) + (world? + (lambda (world7484) + (letrec ((g8460 + (letrec ((x8461 + (car + world7484))) + (eq? + x8461 + 'world)))) + g8460))) + (world-tetra + (lambda (world) + (letrec ((g8462 + (letrec ((x8463 + (cdr + world))) + (car + x8463)))) + g8462))) + (world-blocks + (lambda (world) + (letrec ((g8464 + (letrec ((x8465 + (letrec ((x8466 + (cdr + world))) + (cdr + x8466)))) + (car + x8465)))) + g8464)))) + (letrec ((g8467 + (letrec ((posn + (lambda (x7490 + y7491) + (letrec ((g8468 + (letrec ((x8469 + (letrec ((x8470 + (cons + y7491 + '()))) + (cons + x7490 + x8470)))) + (cons + 'posn + x8469)))) + g8468))) + (posn? + (lambda (posn7489) + (letrec ((g8471 + (letrec ((x8472 + (car + posn7489))) + (eq? + x8472 + 'posn)))) + g8471))) + (posn-x + (lambda (posn) + (letrec ((g8473 + (letrec ((x8474 + (cdr + posn))) + (car + x8474)))) + g8473))) + (posn-y + (lambda (posn) + (letrec ((g8475 + (letrec ((x8476 + (letrec ((x8477 + (cdr + posn))) + (cdr + x8477)))) + (car + x8476)))) + g8475))) + (posn + (lambda (x7490 + y7491) + (letrec ((g8478 + (letrec ((x8479 + (letrec ((x8480 + (cons + y7491 + '()))) + (cons + x7490 + x8480)))) + (cons + 'posn + x8479)))) + g8478))) + (posn? + (lambda (posn7489) + (letrec ((g8481 + (letrec ((x8482 + (car + posn7489))) + (eq? + x8482 + 'posn)))) + g8481))) + (posn-x + (lambda (posn) + (letrec ((g8483 + (letrec ((x8484 + (cdr + posn))) + (car + x8484)))) + g8483))) + (posn-y + (lambda (posn) + (letrec ((g8485 + (letrec ((x8486 + (letrec ((x8487 + (cdr + posn))) + (cdr + x8487)))) + (car + x8486)))) + g8485))) + (COLOR/C + symbol?) + (POSN/C + (lambda (j7231 + k7232 + v7230) + (letrec ((g8488 + (letrec ((checked7233 + (letrec ((x8489 + (car + v7230))) + (real?/c + 'j7231 + 'k7232 + x8489)))) + (letrec ((g8490 + (letrec ((checked7234 + (letrec ((x8491 + (letrec ((x8492 + (cdr + v7230))) + (car + x8492)))) + (real?/c + 'j7231 + 'k7232 + x8491)))) + (letrec ((g8493 + (letrec ((x8494 + (letrec ((x8495 + (cons + checked7234 + '()))) + (cons + checked7233 + x8495)))) + (cons + posn + x8494)))) + g8493)))) + g8490)))) + g8488))) + (BLOCK/C + (lambda (j7237 + k7238 + v7236) + (letrec ((g8496 + (letrec ((checked7239 + (letrec ((x8497 + (car + v7236))) + (real?/c + 'j7237 + 'k7238 + x8497)))) + (letrec ((g8498 + (letrec ((checked7240 + (letrec ((x8499 + (letrec ((x8500 + (cdr + v7236))) + (car + x8500)))) + (real?/c + 'j7237 + 'k7238 + x8499)))) + (letrec ((g8501 + (letrec ((checked7241 + (letrec ((x8502 + (letrec ((x8503 + (letrec ((x8504 + (cdr + v7236))) + (cdr + x8504)))) + (car + x8503)))) + (COLOR/C + 'j7237 + 'k7238 + x8502)))) + (letrec ((g8505 + (letrec ((x8506 + (letrec ((x8507 + (letrec ((x8508 + (cons + checked7241 + '()))) + (cons + checked7240 + x8508)))) + (cons + checked7239 + x8507)))) + (cons + block + x8506)))) + g8505)))) + g8501)))) + g8498)))) + g8496))) + (BSET/C + (listof + BLOCK/C)) + (TETRA/C + (lambda (j7244 + k7245 + v7243) + (letrec ((g8509 + (letrec ((checked7246 + (letrec ((x8510 + (car + v7243))) + (POSN/C + 'j7244 + 'k7245 + x8510)))) + (letrec ((g8511 + (letrec ((checked7247 + (letrec ((x8512 + (letrec ((x8513 + (cdr + v7243))) + (car + x8513)))) + (BSET/C + 'j7244 + 'k7245 + x8512)))) + (letrec ((g8514 + (letrec ((x8515 + (letrec ((x8516 + (cons + checked7247 + '()))) + (cons + checked7246 + x8516)))) + (cons + tetra + x8515)))) + g8514)))) + g8511)))) + g8509))) + (WORLD/C + (lambda (j7250 + k7251 + v7249) + (letrec ((g8517 + (letrec ((checked7252 + (letrec ((x8518 + (car + v7249))) + (TETRA/C + 'j7250 + 'k7251 + x8518)))) + (letrec ((g8519 + (letrec ((checked7253 + (letrec ((x8520 + (letrec ((x8521 + (cdr + v7249))) + (car + x8521)))) + (BSET/C + 'j7250 + 'k7251 + x8520)))) + (letrec ((g8522 + (letrec ((x8523 + (letrec ((x8524 + (cons + checked7253 + '()))) + (cons + checked7252 + x8524)))) + (cons + world + x8523)))) + g8522)))) + g8519)))) + g8517))) + (posn=? + (lambda (p1 + p2) + (letrec ((g8525 + (letrec ((x-cnd8526 + (letrec ((x8528 + (posn-x + p1)) + (x8527 + (posn-x + p2))) + (= + x8528 + x8527)))) + (if x-cnd8526 + (letrec ((x8530 + (posn-y + p1)) + (x8529 + (posn-y + p2))) + (= + x8530 + x8529)) + #f)))) + g8525))) + (block-size + 20) + (board-height + 20) + (board-width + 10) + (block=? + (lambda (b1 + b2) + (letrec ((g8531 + (letrec ((x-cnd8532 + (letrec ((x8534 + (block-x + b1)) + (x8533 + (block-x + b2))) + (= + x8534 + x8533)))) + (if x-cnd8532 + (letrec ((x8536 + (block-y + b1)) + (x8535 + (block-y + b2))) + (= + x8536 + x8535)) + #f)))) + g8531))) + (block-move + (lambda (dx + dy + b) + (letrec ((g8537 + (letrec ((x8541 + (letrec ((x8542 + (block-x + b))) + (+ + dx + x8542))) + (x8539 + (letrec ((x8540 + (block-y + b))) + (+ + dy + x8540))) + (x8538 + (block-color + b))) + (block + x8541 + x8539 + x8538)))) + g8537))) + (block-rotate-ccw + (lambda (c + b) + (letrec ((g8543 + (letrec ((x8550 + (letrec ((x8554 + (posn-x + c)) + (x8551 + (letrec ((x8553 + (posn-y + c)) + (x8552 + (block-y + b))) + (- + x8553 + x8552)))) + (+ + x8554 + x8551))) + (x8545 + (letrec ((x8549 + (posn-y + c)) + (x8546 + (letrec ((x8548 + (block-x + b)) + (x8547 + (posn-x + c))) + (- + x8548 + x8547)))) + (+ + x8549 + x8546))) + (x8544 + (block-color + b))) + (block + x8550 + x8545 + x8544)))) + g8543))) + (block-rotate-cw + (lambda (c + b) + (letrec ((g8555 + (letrec ((x8556 + (letrec ((x8557 + (block-rotate-ccw + c + b))) + (block-rotate-ccw + c + x8557)))) + (block-rotate-ccw + c + x8556)))) + g8555))) + (ormap + (lambda (p? + xs) + (letrec ((g8558 + (if cnd + (letrec ((g8559 + #f)) + g8559) + (letrec ((g8560 + (letrec ((x8563 + (letrec ((x8564 + (car + xs))) + (p? + x8564))) + (x8561 + (letrec ((x8562 + (cdr + xs))) + (ormap + p? + x8562)))) + (or x8563 + x8561)))) + g8560)))) + g8558))) + (andmap + (lambda (p? + xs) + (letrec ((g8565 + (if cnd + (letrec ((g8566 + #t)) + g8566) + (letrec ((g8567 + (letrec ((x8570 + (letrec ((x8571 + (car + xs))) + (p? + x8571))) + (x8568 + (letrec ((x8569 + (cdr + xs))) + (andmap + p? + x8569)))) + (and x8570 + x8568)))) + g8567)))) + g8565))) + (map + (lambda (f + xs) + (letrec ((g8572 + (if cnd + (letrec ((g8573 + null)) + g8573) + (letrec ((g8574 + (letrec ((x8577 + (letrec ((x8578 + (car + xs))) + (f + x8578))) + (x8575 + (letrec ((x8576 + (cdr + xs))) + (map + f + x8576)))) + (cons + x8577 + x8575)))) + g8574)))) + g8572))) + (filter + (lambda (p? + xs) + (letrec ((g8579 + (if cnd + (letrec ((g8580 + null)) + g8580) + (if cnd + (letrec ((g8581 + (letrec ((x8584 + (car + xs)) + (x8582 + (letrec ((x8583 + (cdr + xs))) + (filter + p? + x8583)))) + (cons + x8584 + x8582)))) + g8581) + (letrec ((g8585 + (letrec ((x8586 + (cdr + xs))) + (filter + p? + x8586)))) + g8585))))) + g8579))) + (append + (lambda (l + r) + (letrec ((g8587 + (if cnd + (letrec ((g8588 + r)) + g8588) + (letrec ((g8589 + (letrec ((x8592 + (car + l)) + (x8590 + (letrec ((x8591 + (cdr + l))) + (append + x8591 + r)))) + (cons + x8592 + x8590)))) + g8589)))) + g8587))) + (length + (lambda (xs) + (letrec ((g8593 + (if cnd + (letrec ((g8594 + 0)) + g8594) + (letrec ((g8595 + (letrec ((x8596 + (letrec ((x8597 + (cdr + xs))) + (length + x8597)))) + (+ + 1 + x8596)))) + g8595)))) + g8593))) + (foldr + (lambda (f + a + xs) + (letrec ((g8598 + (if cnd + (letrec ((g8599 + a)) + g8599) + (letrec ((g8600 + (letrec ((x8603 + (car + xs)) + (x8601 + (letrec ((x8602 + (cdr + xs))) + (foldr + f + a + x8602)))) + (f + x8603 + x8601)))) + g8600)))) + g8598))) + (blocks-contains? + (lambda (bs + b) + (letrec ((g8604 + (letrec ((x8605 + (letrec ((x8607 + (c)) + (x8606 + (block=? + b + c))) + (λ x8607 + x8606)))) + (ormap + x8605 + bs)))) + g8604))) + (blocks-subset? + (lambda (bs1 + bs2) + (letrec ((g8608 + (letrec ((x8609 + (letrec ((x8611 + (b)) + (x8610 + (blocks-contains? + bs2 + b))) + (λ x8611 + x8610)))) + (andmap + x8609 + bs1)))) + g8608))) + (blocks=? + (lambda (bs1 + bs2) + (letrec ((g8612 + (letrec ((x-cnd8613 + (blocks-subset? + bs1 + bs2))) + (if x-cnd8613 + (blocks-subset? + bs2 + bs1) + #f)))) + g8612))) + (blocks-intersect + (lambda (bs1 + bs2) + (letrec ((g8614 + (letrec ((x8615 + (letrec ((x8617 + (b)) + (x8616 + (blocks-contains? + bs2 + b))) + (λ x8617 + x8616)))) + (filter + x8615 + bs1)))) + g8614))) + (blocks-count + (lambda (bs) + (letrec ((g8618 + (length + bs))) + g8618))) + (blocks-move + (lambda (dx + dy + bs) + (letrec ((g8619 + (letrec ((x8620 + (letrec ((x8622 + (b)) + (x8621 + (block-move + dx + dy + b))) + (λ x8622 + x8621)))) + (map + x8620 + bs)))) + g8619))) + (blocks-rotate-ccw + (lambda (c + bs) + (letrec ((g8623 + (letrec ((x8624 + (letrec ((x8626 + (b)) + (x8625 + (block-rotate-ccw + c + b))) + (λ x8626 + x8625)))) + (map + x8624 + bs)))) + g8623))) + (blocks-rotate-cw + (lambda (c + bs) + (letrec ((g8627 + (letrec ((x8628 + (letrec ((x8630 + (b)) + (x8629 + (block-rotate-cw + c + b))) + (λ x8630 + x8629)))) + (map + x8628 + bs)))) + g8627))) + (blocks-change-color + (lambda (bs + c) + (letrec ((g8631 + (letrec ((x8632 + (letrec ((x8636 + (b)) + (x8633 + (letrec ((x8635 + (block-x + b)) + (x8634 + (block-y + b))) + (block + x8635 + x8634 + c)))) + (λ x8636 + x8633)))) + (map + x8632 + bs)))) + g8631))) + (blocks-row + (lambda (bs + i) + (letrec ((g8637 + (letrec ((x8638 + (letrec ((x8641 + (b)) + (x8639 + (letrec ((x8640 + (block-y + b))) + (= + i + x8640)))) + (λ x8641 + x8639)))) + (filter + x8638 + bs)))) + g8637))) + (full-row? + (lambda (bs + i) + (letrec ((g8642 + (letrec ((x8643 + (letrec ((x8644 + (blocks-row + bs + i))) + (blocks-count + x8644)))) + (= + board-width + x8643)))) + g8642))) + (blocks-overflow? + (lambda (bs) + (letrec ((g8645 + (letrec ((x8646 + (letrec ((x8649 + (b)) + (x8647 + (letrec ((x8648 + (block-y + b))) + (<= + x8648 + 0)))) + (λ x8649 + x8647)))) + (ormap + x8646 + bs)))) + g8645))) + (blocks-union + (lambda (bs1 + bs2) + (letrec ((g8650 + (letrec ((x8651 + (letrec ((x8655 + (b + bs)) + (x8652 + (if cnd + (letrec ((g8653 + bs)) + g8653) + (letrec ((g8654 + (cons + b + bs))) + g8654)))) + (λ x8655 + x8652)))) + (foldr + x8651 + bs2 + bs1)))) + g8650))) + (blocks-max-y + (lambda (bs) + (letrec ((g8656 + (letrec ((x8657 + (letrec ((x8660 + (b + n)) + (x8658 + (letrec ((x8659 + (block-y + b))) + (max + x8659 + n)))) + (λ x8660 + x8658)))) + (foldr + x8657 + 0 + bs)))) + g8656))) + (blocks-min-x + (lambda (bs) + (letrec ((g8661 + (letrec ((x8662 + (letrec ((x8665 + (b + n)) + (x8663 + (letrec ((x8664 + (block-x + b))) + (min + x8664 + n)))) + (λ x8665 + x8663)))) + (foldr + x8662 + board-width + bs)))) + g8661))) + (blocks-max-x + (lambda (bs) + (letrec ((g8666 + (letrec ((x8667 + (letrec ((x8670 + (b + n)) + (x8668 + (letrec ((x8669 + (block-x + b))) + (max + x8669 + n)))) + (λ x8670 + x8668)))) + (foldr + x8667 + 0 + bs)))) + g8666))) + (eliminate-full-rows + (lambda (bs) + (letrec ((g8671 + (elim-row + bs + board-height + 0))) + g8671))) + (elim-row + (lambda (bs + i + offset) + (letrec ((g8672 + (if cnd + (letrec ((g8673 + empty)) + g8673) + (if cnd + (letrec ((g8674 + (letrec ((x8676 + (sub1 + i)) + (x8675 + (add1 + offset))) + (elim-row + bs + x8676 + x8675)))) + g8674) + (letrec ((g8677 + (letrec ((x8680 + (letrec ((x8681 + (sub1 + i))) + (elim-row + bs + x8681 + offset))) + (x8678 + (letrec ((x8679 + (blocks-row + bs + i))) + (blocks-move + 0 + offset + x8679)))) + (blocks-union + x8680 + x8678)))) + g8677))))) + g8672))) + (tetra-move + (lambda (dx + dy + t) + (letrec ((g8682 + (letrec ((x8685 + (letrec ((x8689 + (letrec ((x8690 + (letrec ((x8691 + (tetra-center + t))) + (posn-x + x8691)))) + (+ + dx + x8690))) + (x8686 + (letrec ((x8687 + (letrec ((x8688 + (tetra-center + t))) + (posn-y + x8688)))) + (+ + dy + x8687)))) + (posn + x8689 + x8686))) + (x8683 + (letrec ((x8684 + (tetra-blocks + t))) + (blocks-move + dx + dy + x8684)))) + (tetra + x8685 + x8683)))) + g8682))) + (tetra-rotate-ccw + (lambda (t) + (letrec ((g8692 + (letrec ((x8696 + (tetra-center + t)) + (x8693 + (letrec ((x8695 + (tetra-center + t)) + (x8694 + (tetra-blocks + t))) + (blocks-rotate-ccw + x8695 + x8694)))) + (tetra + x8696 + x8693)))) + g8692))) + (tetra-rotate-cw + (lambda (t) + (letrec ((g8697 + (letrec ((x8701 + (tetra-center + t)) + (x8698 + (letrec ((x8700 + (tetra-center + t)) + (x8699 + (tetra-blocks + t))) + (blocks-rotate-cw + x8700 + x8699)))) + (tetra + x8701 + x8698)))) + g8697))) + (tetra-overlaps-blocks? + (lambda (t + bs) + (letrec ((g8702 + (letrec ((x8703 + (letrec ((x8704 + (letrec ((x8705 + (tetra-blocks + t))) + (blocks-intersect + x8705 + bs)))) + (false? + x8704)))) + (false? + x8703)))) + g8702))) + (tetra-change-color + (lambda (t + c) + (letrec ((g8706 + (letrec ((x8709 + (tetra-center + t)) + (x8707 + (letrec ((x8708 + (tetra-blocks + t))) + (blocks-change-color + x8708 + c)))) + (tetra + x8709 + x8707)))) + g8706))) + (build-tetra-blocks + (lambda (color + xc + yc + x1 + y1 + x2 + y2 + x3 + y3 + x4 + y4) + (letrec ((g8710 + (letrec ((x8711 + (letrec ((x8717 + (posn + xc + yc)) + (x8712 + (letrec ((x8716 + (block + x1 + y1 + color)) + (x8715 + (block + x2 + y2 + color)) + (x8714 + (block + x3 + y3 + color)) + (x8713 + (block + x4 + y4 + color))) + (list + x8716 + x8715 + x8714 + x8713)))) + (tetra + x8717 + x8712)))) + (tetra-move + 3 + 0 + x8711)))) + g8710))) + (touchdown + (lambda (w + tetras) + (letrec ((g8718 + (letrec ((x8724 + (list-pick-random + tetras)) + (x8719 + (letrec ((x8720 + (letrec ((x8722 + (letrec ((x8723 + (world-tetra + w))) + (tetra-blocks + x8723))) + (x8721 + (world-blocks + w))) + (blocks-union + x8722 + x8721)))) + (eliminate-full-rows + x8720)))) + (world + x8724 + x8719)))) + g8718))) + (world-jump-down + (lambda (w) + (letrec ((g8725 + (if cnd + (letrec ((g8726 + w)) + g8726) + (letrec ((g8727 + (letrec ((x8728 + (letrec ((x8730 + (letrec ((x8731 + (world-tetra + w))) + (tetra-move + 0 + 1 + x8731))) + (x8729 + (world-blocks + w))) + (world + x8730 + x8729)))) + (world-jump-down + x8728)))) + g8727)))) + g8725))) + (landed-on-blocks? + (lambda (w) + (letrec ((g8732 + (letrec ((x8734 + (letrec ((x8735 + (world-tetra + w))) + (tetra-move + 0 + 1 + x8735))) + (x8733 + (world-blocks + w))) + (tetra-overlaps-blocks? + x8734 + x8733)))) + g8732))) + (landed-on-floor? + (lambda (w) + (letrec ((g8736 + (letrec ((x8738 + (letrec ((x8739 + (letrec ((x8740 + (world-tetra + w))) + (tetra-blocks + x8740)))) + (blocks-max-y + x8739))) + (x8737 + (sub1 + board-height))) + (= + x8738 + x8737)))) + g8736))) + (landed? + (lambda (w) + (letrec ((g8741 + (letrec ((val7160 + (landed-on-blocks? + w))) + (letrec ((g8742 + (if val7160 + val7160 + (landed-on-floor? + w)))) + g8742)))) + g8741))) + (next-world + (lambda (w + tetras) + (letrec ((g8743 + (if cnd + (letrec ((g8744 + (touchdown + w + tetras))) + g8744) + (letrec ((g8745 + (letrec ((x8747 + (letrec ((x8748 + (world-tetra + w))) + (tetra-move + 0 + 1 + x8748))) + (x8746 + (world-blocks + w))) + (world + x8747 + x8746)))) + g8745)))) + g8743))) + (try-new-tetra + (lambda (w + new-tetra) + (letrec ((g8749 + (if cnd + (letrec ((g8750 + w)) + g8750) + (letrec ((g8751 + (letrec ((x8752 + (world-blocks + w))) + (world + new-tetra + x8752)))) + g8751)))) + g8749))) + (world-move + (lambda (dx + dy + w) + (letrec ((g8753 + (letrec ((x8754 + (letrec ((x8755 + (world-tetra + w))) + (tetra-move + dx + dy + x8755)))) + (try-new-tetra + w + x8754)))) + g8753))) + (world-rotate-ccw + (lambda (w) + (letrec ((g8756 + (letrec ((x8757 + (letrec ((x8758 + (world-tetra + w))) + (tetra-rotate-ccw + x8758)))) + (try-new-tetra + w + x8757)))) + g8756))) + (world-rotate-cw + (lambda (w) + (letrec ((g8759 + (letrec ((x8760 + (letrec ((x8761 + (world-tetra + w))) + (tetra-rotate-cw + x8761)))) + (try-new-tetra + w + x8760)))) + g8759))) + (ghost-blocks + (lambda (w) + (letrec ((g8762 + (letrec ((x8763 + (letrec ((x8764 + (letrec ((x8765 + (world-jump-down + w))) + (world-tetra + x8765)))) + (tetra-change-color + x8764 + 'gray)))) + (tetra-blocks + x8763)))) + g8762))) + (world-key-move + (lambda (w + k) + (letrec ((g8766 + (if cnd + (letrec ((g8767 + (world-move + neg-1 + 0 + w))) + g8767) + (if cnd + (letrec ((g8768 + (world-move + 1 + 0 + w))) + g8768) + (if cnd + (letrec ((g8769 + (world-jump-down + w))) + g8769) + (if cnd + (letrec ((g8770 + (world-rotate-ccw + w))) + g8770) + (if cnd + (letrec ((g8771 + (world-rotate-cw + w))) + g8771) + (letrec ((g8772 + w)) + g8772)))))))) + g8766)))) + (letrec ((g8773 + (letrec ((image + (lambda () + (letrec ((g8774 + (cons + 'image + '()))) + g8774))) + (image? + (lambda (image7494) + (letrec ((g8775 + (letrec ((x8776 + (car + image7494))) + (eq? + x8776 + 'image)))) + g8775))) + (image + (lambda () + (letrec ((g8777 + (cons + 'image + '()))) + g8777))) + (image? + (lambda (image7494) + (letrec ((g8778 + (letrec ((x8779 + (car + image7494))) + (eq? + x8779 + 'image)))) + g8778))) + (overlay + (lambda (i₁ + i₂) + (letrec ((g8780 + (image))) + g8780))) + (circle + (lambda (r + m + c) + (letrec ((g8781 + (image))) + g8781))) + (rectangle + (lambda (w + h + m + c) + (letrec ((g8782 + (image))) + g8782))) + (place-image + (lambda (i₁ + r + c + i₂) + (letrec ((g8783 + (image))) + g8783))) + (empty-scene + (lambda (w + h) + (letrec ((g8784 + (image))) + g8784))) + (list-pick-random + (lambda (xs) + (letrec ((g8785 + (if cnd + (letrec ((g8786 + (car + xs))) + g8786) + (letrec ((g8787 + (letrec ((x8788 + (cdr + xs))) + (list-pick-random + x8788)))) + g8787)))) + g8785))) + (neg-1 + (random + 10)) + (world->image + (lambda (w) + (letrec ((g8789 + (letrec ((x8793 + (letrec ((x8794 + (letrec ((x8798 + (letrec ((x8799 + (world-tetra + w))) + (tetra-blocks + x8799))) + (x8795 + (letrec ((x8797 + (ghost-blocks + w)) + (x8796 + (world-blocks + w))) + (append + x8797 + x8796)))) + (append + x8798 + x8795)))) + (blocks->image + x8794))) + (x8790 + (letrec ((x8792 + (* + board-width + block-size)) + (x8791 + (* + board-height + block-size))) + (empty-scene + x8792 + x8791)))) + (place-image + x8793 + 0 + 0 + x8790)))) + g8789))) + (blocks->image + (lambda (bs) + (letrec ((g8800 + (letrec ((x8806 + (letrec ((x8810 + (b + img)) + (x8807 + (if cnd + (letrec ((g8808 + (place-block + b + img))) + g8808) + (letrec ((g8809 + img)) + g8809)))) + (λ x8810 + x8807))) + (x8801 + (letrec ((x8804 + (letrec ((x8805 + (* + board-width + block-size))) + (add1 + x8805))) + (x8802 + (letrec ((x8803 + (* + board-height + block-size))) + (add1 + x8803)))) + (empty-scene + x8804 + x8802)))) + (foldr + x8806 + x8801 + bs)))) + g8800))) + (block->image + (lambda (b) + (letrec ((g8811 + (letrec ((x8815 + (letrec ((x8818 + (add1 + block-size)) + (x8817 + (add1 + block-size)) + (x8816 + (block-color + b))) + (rectangle + x8818 + x8817 + 'solid + x8816))) + (x8812 + (letrec ((x8814 + (add1 + block-size)) + (x8813 + (add1 + block-size))) + (rectangle + x8814 + x8813 + 'outline + 'black)))) + (overlay + x8815 + x8812)))) + g8811))) + (place-block + (lambda (b + scene) + (letrec ((g8819 + (letrec ((x8828 + (block->image + b)) + (x8824 + (letrec ((x8826 + (letrec ((x8827 + (block-x + b))) + (* + x8827 + block-size))) + (x8825 + (/ + block-size + 2))) + (+ + x8826 + x8825))) + (x8820 + (letrec ((x8822 + (letrec ((x8823 + (block-y + b))) + (* + x8823 + block-size))) + (x8821 + (/ + block-size + 2))) + (+ + x8822 + x8821)))) + (place-image + x8828 + x8824 + x8820 + scene)))) + g8819))) + (world0 + (lambda (tetras) + (letrec ((g8829 + (letrec ((x8830 + (list-pick-random + tetras))) + (world + x8830 + null)))) + g8829)))) + (letrec ((g8831 + (letrec ((g8832 + (letrec ((g8833 + (letrec ((x8896 + ((lambda (j7257 + k7258 + f7259) + (lambda (g7255 + g7256) + (boolean?/c + j7257 + k7258 + (f7259 + (POSN/C + j7257 + k7258 + g7255) + (POSN/C + j7257 + k7258 + g7256))))) + 'module + 'importer + posn=?)) + (x8891 + (letrec ((x8892 + (letrec ((x8895 + (input)) + (x8893 + (letrec ((x8894 + (input))) + (cons + x8894 + '())))) + (cons + x8895 + x8893)))) + (cons + 'posn + x8892))) + (x8886 + (letrec ((x8887 + (letrec ((x8890 + (input)) + (x8888 + (letrec ((x8889 + (input))) + (cons + x8889 + '())))) + (cons + x8890 + x8888)))) + (cons + 'posn + x8887)))) + (x8896 + x8891 + x8886))) + (g8834 + (any/c + 'module + 'importer + COLOR/C)) + (g8835 + (any/c + 'module + 'importer + POSN/C)) + (g8836 + (any/c + 'module + 'importer + BLOCK/C)) + (g8837 + (any/c + 'module + 'importer + TETRA/C)) + (g8838 + (any/c + 'module + 'importer + WORLD/C)) + (g8839 + (any/c + 'module + 'importer + BSET/C)) + (g8840 + (integer? + 'module + 'importer + block-size)) + (g8841 + (integer? + 'module + 'importer + board-width)) + (g8842 + (integer? + 'module + 'importer + board-height)) + (g8843 + (letrec ((x8909 + ((lambda (j7262 + k7263 + f7264) + (lambda (g7260 + g7261) + (BLOCK/C + j7262 + k7263 + (f7264 + (POSN/C + j7262 + k7263 + g7260) + (BLOCK/C + j7262 + k7263 + g7261))))) + 'module + 'importer + block-rotate-ccw)) + (x8904 + (letrec ((x8905 + (letrec ((x8908 + (input)) + (x8906 + (letrec ((x8907 + (input))) + (cons + x8907 + '())))) + (cons + x8908 + x8906)))) + (cons + 'posn + x8905))) + (x8897 + (letrec ((x8898 + (letrec ((x8903 + (input)) + (x8899 + (letrec ((x8902 + (input)) + (x8900 + (letrec ((x8901 + (input))) + (cons + x8901 + '())))) + (cons + x8902 + x8900)))) + (cons + x8903 + x8899)))) + (cons + 'block + x8898)))) + (x8909 + x8904 + x8897))) + (g8844 + (letrec ((x8922 + ((lambda (j7267 + k7268 + f7269) + (lambda (g7265 + g7266) + (BLOCK/C + j7267 + k7268 + (f7269 + (POSN/C + j7267 + k7268 + g7265) + (BLOCK/C + j7267 + k7268 + g7266))))) + 'module + 'importer + block-rotate-cw)) + (x8917 + (letrec ((x8918 + (letrec ((x8921 + (input)) + (x8919 + (letrec ((x8920 + (input))) + (cons + x8920 + '())))) + (cons + x8921 + x8919)))) + (cons + 'posn + x8918))) + (x8910 + (letrec ((x8911 + (letrec ((x8916 + (input)) + (x8912 + (letrec ((x8915 + (input)) + (x8913 + (letrec ((x8914 + (input))) + (cons + x8914 + '())))) + (cons + x8915 + x8913)))) + (cons + x8916 + x8912)))) + (cons + 'block + x8911)))) + (x8922 + x8917 + x8910))) + (g8845 + (letrec ((x8937 + ((lambda (j7272 + k7273 + f7274) + (lambda (g7270 + g7271) + (boolean?/c + j7272 + k7273 + (f7274 + (BLOCK/C + j7272 + k7273 + g7270) + (BLOCK/C + j7272 + k7273 + g7271))))) + 'module + 'importer + block=?)) + (x8930 + (letrec ((x8931 + (letrec ((x8936 + (input)) + (x8932 + (letrec ((x8935 + (input)) + (x8933 + (letrec ((x8934 + (input))) + (cons + x8934 + '())))) + (cons + x8935 + x8933)))) + (cons + x8936 + x8932)))) + (cons + 'block + x8931))) + (x8923 + (letrec ((x8924 + (letrec ((x8929 + (input)) + (x8925 + (letrec ((x8928 + (input)) + (x8926 + (letrec ((x8927 + (input))) + (cons + x8927 + '())))) + (cons + x8928 + x8926)))) + (cons + x8929 + x8925)))) + (cons + 'block + x8924)))) + (x8937 + x8930 + x8923))) + (g8846 + (letrec ((x8947 + ((lambda (j7278 + k7279 + f7280) + (lambda (g7275 + g7276 + g7277) + (BLOCK/C + j7278 + k7279 + (f7280 + (real?/c + j7278 + k7279 + g7275) + (real?/c + j7278 + k7279 + g7276) + (BLOCK/C + j7278 + k7279 + g7277))))) + 'module + 'importer + block-move)) + (x8946 + (input)) + (x8945 + (input)) + (x8938 + (letrec ((x8939 + (letrec ((x8944 + (input)) + (x8940 + (letrec ((x8943 + (input)) + (x8941 + (letrec ((x8942 + (input))) + (cons + x8942 + '())))) + (cons + x8943 + x8941)))) + (cons + x8944 + x8940)))) + (cons + 'block + x8939)))) + (x8947 + x8946 + x8945 + x8938))) + (g8847 + (letrec ((x8956 + ((lambda (j7283 + k7284 + f7285) + (lambda (g7281 + g7282) + (boolean?/c + j7283 + k7284 + (f7285 + (BSET/C + j7283 + k7284 + g7281) + (BLOCK/C + j7283 + k7284 + g7282))))) + 'module + 'importer + blocks-contains?)) + (x8955 + (input)) + (x8948 + (letrec ((x8949 + (letrec ((x8954 + (input)) + (x8950 + (letrec ((x8953 + (input)) + (x8951 + (letrec ((x8952 + (input))) + (cons + x8952 + '())))) + (cons + x8953 + x8951)))) + (cons + x8954 + x8950)))) + (cons + 'block + x8949)))) + (x8956 + x8955 + x8948))) + (g8848 + (letrec ((x8959 + ((lambda (j7288 + k7289 + f7290) + (lambda (g7286 + g7287) + (boolean?/c + j7288 + k7289 + (f7290 + (BSET/C + j7288 + k7289 + g7286) + (BSET/C + j7288 + k7289 + g7287))))) + 'module + 'importer + blocks=?)) + (x8958 + (input)) + (x8957 + (input))) + (x8959 + x8958 + x8957))) + (g8849 + (letrec ((x8962 + ((lambda (j7293 + k7294 + f7295) + (lambda (g7291 + g7292) + (boolean?/c + j7293 + k7294 + (f7295 + (BSET/C + j7293 + k7294 + g7291) + (BSET/C + j7293 + k7294 + g7292))))) + 'module + 'importer + blocks-subset?)) + (x8961 + (input)) + (x8960 + (input))) + (x8962 + x8961 + x8960))) + (g8850 + (letrec ((x8965 + ((lambda (j7298 + k7299 + f7300) + (lambda (g7296 + g7297) + (BSET/C + j7298 + k7299 + (f7300 + (BSET/C + j7298 + k7299 + g7296) + (BSET/C + j7298 + k7299 + g7297))))) + 'module + 'importer + blocks-intersect)) + (x8964 + (input)) + (x8963 + (input))) + (x8965 + x8964 + x8963))) + (g8851 + (letrec ((x8967 + ((lambda (j7302 + k7303 + f7304) + (lambda (g7301) + (real?/c + j7302 + k7303 + (f7304 + (BSET/C + j7302 + k7303 + g7301))))) + 'module + 'importer + blocks-count)) + (x8966 + (input))) + (x8967 + x8966))) + (g8852 + (letrec ((x8969 + ((lambda (j7306 + k7307 + f7308) + (lambda (g7305) + (boolean?/c + j7306 + k7307 + (f7308 + (BSET/C + j7306 + k7307 + g7305))))) + 'module + 'importer + blocks-overflow?)) + (x8968 + (input))) + (x8969 + x8968))) + (g8853 + (letrec ((x8973 + ((lambda (j7312 + k7313 + f7314) + (lambda (g7309 + g7310 + g7311) + (BSET/C + j7312 + k7313 + (f7314 + (real?/c + j7312 + k7313 + g7309) + (real?/c + j7312 + k7313 + g7310) + (BSET/C + j7312 + k7313 + g7311))))) + 'module + 'importer + blocks-move)) + (x8972 + (input)) + (x8971 + (input)) + (x8970 + (input))) + (x8973 + x8972 + x8971 + x8970))) + (g8854 + (letrec ((x8980 + ((lambda (j7317 + k7318 + f7319) + (lambda (g7315 + g7316) + (BSET/C + j7317 + k7318 + (f7319 + (POSN/C + j7317 + k7318 + g7315) + (BSET/C + j7317 + k7318 + g7316))))) + 'module + 'importer + blocks-rotate-cw)) + (x8975 + (letrec ((x8976 + (letrec ((x8979 + (input)) + (x8977 + (letrec ((x8978 + (input))) + (cons + x8978 + '())))) + (cons + x8979 + x8977)))) + (cons + 'posn + x8976))) + (x8974 + (input))) + (x8980 + x8975 + x8974))) + (g8855 + (letrec ((x8987 + ((lambda (j7322 + k7323 + f7324) + (lambda (g7320 + g7321) + (BSET/C + j7322 + k7323 + (f7324 + (POSN/C + j7322 + k7323 + g7320) + (BSET/C + j7322 + k7323 + g7321))))) + 'module + 'importer + blocks-rotate-ccw)) + (x8982 + (letrec ((x8983 + (letrec ((x8986 + (input)) + (x8984 + (letrec ((x8985 + (input))) + (cons + x8985 + '())))) + (cons + x8986 + x8984)))) + (cons + 'posn + x8983))) + (x8981 + (input))) + (x8987 + x8982 + x8981))) + (g8856 + (letrec ((x8990 + ((lambda (j7327 + k7328 + f7329) + (lambda (g7325 + g7326) + (BSET/C + j7327 + k7328 + (f7329 + (BSET/C + j7327 + k7328 + g7325) + (COLOR/C + j7327 + k7328 + g7326))))) + 'module + 'importer + blocks-change-color)) + (x8989 + (input)) + (x8988 + (input))) + (x8990 + x8989 + x8988))) + (g8857 + (letrec ((x8993 + ((lambda (j7332 + k7333 + f7334) + (lambda (g7330 + g7331) + (BSET/C + j7332 + k7333 + (f7334 + (BSET/C + j7332 + k7333 + g7330) + (real?/c + j7332 + k7333 + g7331))))) + 'module + 'importer + blocks-row)) + (x8992 + (input)) + (x8991 + (input))) + (x8993 + x8992 + x8991))) + (g8858 + (letrec ((x8996 + ((lambda (j7337 + k7338 + f7339) + (lambda (g7335 + g7336) + (boolean?/c + j7337 + k7338 + (f7339 + (BSET/C + j7337 + k7338 + g7335) + (real?/c + j7337 + k7338 + g7336))))) + 'module + 'importer + full-row?)) + (x8995 + (input)) + (x8994 + (input))) + (x8996 + x8995 + x8994))) + (g8859 + (letrec ((x8999 + ((lambda (j7342 + k7343 + f7344) + (lambda (g7340 + g7341) + (BSET/C + j7342 + k7343 + (f7344 + (BSET/C + j7342 + k7343 + g7340) + (BSET/C + j7342 + k7343 + g7341))))) + 'module + 'importer + blocks-union)) + (x8998 + (input)) + (x8997 + (input))) + (x8999 + x8998 + x8997))) + (g8860 + (letrec ((x9001 + ((lambda (j7346 + k7347 + f7348) + (lambda (g7345) + (real?/c + j7346 + k7347 + (f7348 + (BSET/C + j7346 + k7347 + g7345))))) + 'module + 'importer + blocks-max-x)) + (x9000 + (input))) + (x9001 + x9000))) + (g8861 + (letrec ((x9003 + ((lambda (j7350 + k7351 + f7352) + (lambda (g7349) + (real?/c + j7350 + k7351 + (f7352 + (BSET/C + j7350 + k7351 + g7349))))) + 'module + 'importer + blocks-min-x)) + (x9002 + (input))) + (x9003 + x9002))) + (g8862 + (letrec ((x9005 + ((lambda (j7354 + k7355 + f7356) + (lambda (g7353) + (real?/c + j7354 + k7355 + (f7356 + (BSET/C + j7354 + k7355 + g7353))))) + 'module + 'importer + blocks-max-y)) + (x9004 + (input))) + (x9005 + x9004))) + (g8863 + (letrec ((x9007 + ((lambda (j7358 + k7359 + f7360) + (lambda (g7357) + (BSET/C + j7358 + k7359 + (f7360 + (BSET/C + j7358 + k7359 + g7357))))) + 'module + 'importer + eliminate-full-rows)) + (x9006 + (input))) + (x9007 + x9006))) + (g8864 + (letrec ((x9019 + ((lambda (j7364 + k7365 + f7366) + (lambda (g7361 + g7362 + g7363) + (TETRA/C + j7364 + k7365 + (f7366 + (integer?/c + j7364 + k7365 + g7361) + (integer?/c + j7364 + k7365 + g7362) + (TETRA/C + j7364 + k7365 + g7363))))) + 'module + 'importer + tetra-move)) + (x9018 + (input)) + (x9017 + (input)) + (x9008 + (letrec ((x9009 + (letrec ((x9012 + (letrec ((x9013 + (letrec ((x9016 + (input)) + (x9014 + (letrec ((x9015 + (input))) + (cons + x9015 + '())))) + (cons + x9016 + x9014)))) + (cons + 'posn + x9013))) + (x9010 + (letrec ((x9011 + (input))) + (cons + x9011 + '())))) + (cons + x9012 + x9010)))) + (cons + 'tetra + x9009)))) + (x9019 + x9018 + x9017 + x9008))) + (g8865 + (letrec ((x9029 + ((lambda (j7368 + k7369 + f7370) + (lambda (g7367) + (TETRA/C + j7368 + k7369 + (f7370 + (TETRA/C + j7368 + k7369 + g7367))))) + 'module + 'importer + tetra-rotate-ccw)) + (x9020 + (letrec ((x9021 + (letrec ((x9024 + (letrec ((x9025 + (letrec ((x9028 + (input)) + (x9026 + (letrec ((x9027 + (input))) + (cons + x9027 + '())))) + (cons + x9028 + x9026)))) + (cons + 'posn + x9025))) + (x9022 + (letrec ((x9023 + (input))) + (cons + x9023 + '())))) + (cons + x9024 + x9022)))) + (cons + 'tetra + x9021)))) + (x9029 + x9020))) + (g8866 + (letrec ((x9039 + ((lambda (j7372 + k7373 + f7374) + (lambda (g7371) + (TETRA/C + j7372 + k7373 + (f7374 + (TETRA/C + j7372 + k7373 + g7371))))) + 'module + 'importer + tetra-rotate-cw)) + (x9030 + (letrec ((x9031 + (letrec ((x9034 + (letrec ((x9035 + (letrec ((x9038 + (input)) + (x9036 + (letrec ((x9037 + (input))) + (cons + x9037 + '())))) + (cons + x9038 + x9036)))) + (cons + 'posn + x9035))) + (x9032 + (letrec ((x9033 + (input))) + (cons + x9033 + '())))) + (cons + x9034 + x9032)))) + (cons + 'tetra + x9031)))) + (x9039 + x9030))) + (g8867 + (letrec ((x9050 + ((lambda (j7377 + k7378 + f7379) + (lambda (g7375 + g7376) + (boolean?/c + j7377 + k7378 + (f7379 + (TETRA/C + j7377 + k7378 + g7375) + (BSET/C + j7377 + k7378 + g7376))))) + 'module + 'importer + tetra-overlaps-blocks?)) + (x9041 + (letrec ((x9042 + (letrec ((x9045 + (letrec ((x9046 + (letrec ((x9049 + (input)) + (x9047 + (letrec ((x9048 + (input))) + (cons + x9048 + '())))) + (cons + x9049 + x9047)))) + (cons + 'posn + x9046))) + (x9043 + (letrec ((x9044 + (input))) + (cons + x9044 + '())))) + (cons + x9045 + x9043)))) + (cons + 'tetra + x9042))) + (x9040 + (input))) + (x9050 + x9041 + x9040))) + (g8868 + (letrec ((x9062 + ((lambda (j7391 + k7392 + f7393) + (lambda (g7380 + g7381 + g7382 + g7383 + g7384 + g7385 + g7386 + g7387 + g7388 + g7389 + g7390) + (TETRA/C + j7391 + k7392 + (f7393 + (COLOR/C + j7391 + k7392 + g7380) + (real?/c + j7391 + k7392 + g7381) + (real?/c + j7391 + k7392 + g7382) + (integer?/c + j7391 + k7392 + g7383) + (integer?/c + j7391 + k7392 + g7384) + (integer?/c + j7391 + k7392 + g7385) + (integer?/c + j7391 + k7392 + g7386) + (integer?/c + j7391 + k7392 + g7387) + (integer?/c + j7391 + k7392 + g7388) + (integer?/c + j7391 + k7392 + g7389) + (integer?/c + j7391 + k7392 + g7390))))) + 'module + 'importer + build-tetra-blocks)) + (x9061 + (input)) + (x9060 + (input)) + (x9059 + (input)) + (x9058 + (input)) + (x9057 + (input)) + (x9056 + (input)) + (x9055 + (input)) + (x9054 + (input)) + (x9053 + (input)) + (x9052 + (input)) + (x9051 + (input))) + (x9062 + x9061 + x9060 + x9059 + x9058 + x9057 + x9056 + x9055 + x9054 + x9053 + x9052 + x9051))) + (g8869 + (letrec ((x9073 + ((lambda (j7396 + k7397 + f7398) + (lambda (g7394 + g7395) + (TETRA/C + j7396 + k7397 + (f7398 + (TETRA/C + j7396 + k7397 + g7394) + (COLOR/C + j7396 + k7397 + g7395))))) + 'module + 'importer + tetra-change-color)) + (x9064 + (letrec ((x9065 + (letrec ((x9068 + (letrec ((x9069 + (letrec ((x9072 + (input)) + (x9070 + (letrec ((x9071 + (input))) + (cons + x9071 + '())))) + (cons + x9072 + x9070)))) + (cons + 'posn + x9069))) + (x9066 + (letrec ((x9067 + (input))) + (cons + x9067 + '())))) + (cons + x9068 + x9066)))) + (cons + 'tetra + x9065))) + (x9063 + (input))) + (x9073 + x9064 + x9063))) + (g8870 + (letrec ((x9088 + ((lambda (j7401 + k7402 + f7403) + (lambda (g7399 + g7400) + (WORLD/C + j7401 + k7402 + (f7403 + (WORLD/C + j7401 + k7402 + g7399) + (string?/c + j7401 + k7402 + g7400))))) + 'module + 'importer + world-key-move)) + (x9075 + (letrec ((x9076 + (letrec ((x9079 + (letrec ((x9080 + (letrec ((x9083 + (letrec ((x9084 + (letrec ((x9087 + (input)) + (x9085 + (letrec ((x9086 + (input))) + (cons + x9086 + '())))) + (cons + x9087 + x9085)))) + (cons + 'posn + x9084))) + (x9081 + (letrec ((x9082 + (input))) + (cons + x9082 + '())))) + (cons + x9083 + x9081)))) + (cons + 'tetra + x9080))) + (x9077 + (letrec ((x9078 + (input))) + (cons + x9078 + '())))) + (cons + x9079 + x9077)))) + (cons + 'world + x9076))) + (x9074 + (input))) + (x9088 + x9075 + x9074))) + (g8871 + (letrec ((x9103 + ((lambda (j7406 + k7407 + f7408) + (lambda (g7404 + g7405) + (WORLD/C + j7406 + k7407 + (f7408 + (WORLD/C + j7406 + k7407 + g7404) + ((and/c + cons?/c + (listof + TETRA/C)) + j7406 + k7407 + g7405))))) + 'module + 'importer + next-world)) + (x9090 + (letrec ((x9091 + (letrec ((x9094 + (letrec ((x9095 + (letrec ((x9098 + (letrec ((x9099 + (letrec ((x9102 + (input)) + (x9100 + (letrec ((x9101 + (input))) + (cons + x9101 + '())))) + (cons + x9102 + x9100)))) + (cons + 'posn + x9099))) + (x9096 + (letrec ((x9097 + (input))) + (cons + x9097 + '())))) + (cons + x9098 + x9096)))) + (cons + 'tetra + x9095))) + (x9092 + (letrec ((x9093 + (input))) + (cons + x9093 + '())))) + (cons + x9094 + x9092)))) + (cons + 'world + x9091))) + (x9089 + (input))) + (x9103 + x9090 + x9089))) + (g8872 + (letrec ((x9117 + ((lambda (j7410 + k7411 + f7412) + (lambda (g7409) + (BSET/C + j7410 + k7411 + (f7412 + (WORLD/C + j7410 + k7411 + g7409))))) + 'module + 'importer + ghost-blocks)) + (x9104 + (letrec ((x9105 + (letrec ((x9108 + (letrec ((x9109 + (letrec ((x9112 + (letrec ((x9113 + (letrec ((x9116 + (input)) + (x9114 + (letrec ((x9115 + (input))) + (cons + x9115 + '())))) + (cons + x9116 + x9114)))) + (cons + 'posn + x9113))) + (x9110 + (letrec ((x9111 + (input))) + (cons + x9111 + '())))) + (cons + x9112 + x9110)))) + (cons + 'tetra + x9109))) + (x9106 + (letrec ((x9107 + (input))) + (cons + x9107 + '())))) + (cons + x9108 + x9106)))) + (cons + 'world + x9105)))) + (x9117 + x9104))) + (g8873 + (letrec ((x9119 + ((lambda (j7414 + k7415 + f7416) + (lambda (g7413) + (boolean?/c + j7414 + k7415 + (f7416 + (any/c + j7414 + k7415 + g7413))))) + 'module + 'importer + image?)) + (x9118 + (input))) + (x9119 + x9118))) + (g8874 + (letrec ((x9122 + ((lambda (j7419 + k7420 + f7421) + (lambda (g7417 + g7418) + (image? + j7419 + k7420 + (f7421 + (image? + j7419 + k7420 + g7417) + (image? + j7419 + k7420 + g7418))))) + 'module + 'importer + overlay)) + (x9121 + (input)) + (x9120 + (input))) + (x9122 + x9121 + x9120))) + (g8875 + (letrec ((x9126 + ((lambda (j7425 + k7426 + f7427) + (lambda (g7422 + g7423 + g7424) + (image? + j7425 + k7426 + (f7427 + (real?/c + j7425 + k7426 + g7422) + (real?/c + j7425 + k7426 + g7423) + (string?/c + j7425 + k7426 + g7424))))) + 'module + 'importer + circle)) + (x9125 + (input)) + (x9124 + (input)) + (x9123 + (input))) + (x9126 + x9125 + x9124 + x9123))) + (g8876 + (letrec ((x9131 + ((lambda (j7432 + k7433 + f7434) + (lambda (g7428 + g7429 + g7430 + g7431) + (image? + j7432 + k7433 + (f7434 + (real?/c + j7432 + k7433 + g7428) + (real?/c + j7432 + k7433 + g7429) + (COLOR/C + j7432 + k7433 + g7430) + (COLOR/C + j7432 + k7433 + g7431))))) + 'module + 'importer + rectangle)) + (x9130 + (input)) + (x9129 + (input)) + (x9128 + (input)) + (x9127 + (input))) + (x9131 + x9130 + x9129 + x9128 + x9127))) + (g8877 + (letrec ((x9136 + ((lambda (j7439 + k7440 + f7441) + (lambda (g7435 + g7436 + g7437 + g7438) + (image/c + j7439 + k7440 + (f7441 + (image/c + j7439 + k7440 + g7435) + (real?/c + j7439 + k7440 + g7436) + (real?/c + j7439 + k7440 + g7437) + (image/c + j7439 + k7440 + g7438))))) + 'module + 'importer + place-image)) + (x9135 + (input)) + (x9134 + (input)) + (x9133 + (input)) + (x9132 + (input))) + (x9136 + x9135 + x9134 + x9133 + x9132))) + (g8878 + (letrec ((x9139 + ((lambda (j7444 + k7445 + f7446) + (lambda (g7442 + g7443) + (image? + j7444 + k7445 + (f7446 + (real?/c + j7444 + k7445 + g7442) + (real?/c + j7444 + k7445 + g7443))))) + 'module + 'importer + empty-scene)) + (x9138 + (input)) + (x9137 + (input))) + (x9139 + x9138 + x9137))) + (g8879 + (letrec ((x9141 + ((lambda (j7448 + k7449 + f7450) + (lambda (g7447) + (TETRA/C + j7448 + k7449 + (f7450 + ((and/c + cons?/c + (listof + TETRA/C)) + j7448 + k7449 + g7447))))) + 'module + 'importer + list-pick-random)) + (x9140 + (input))) + (x9141 + x9140))) + (g8880 + (integer?/c + 'module + 'importer + neg-1)) + (g8881 + (letrec ((x9155 + ((lambda (j7452 + k7453 + f7454) + (lambda (g7451) + (image/c + j7452 + k7453 + (f7454 + (WORLD/C + j7452 + k7453 + g7451))))) + 'module + 'importer + world->image)) + (x9142 + (letrec ((x9143 + (letrec ((x9146 + (letrec ((x9147 + (letrec ((x9150 + (letrec ((x9151 + (letrec ((x9154 + (input)) + (x9152 + (letrec ((x9153 + (input))) + (cons + x9153 + '())))) + (cons + x9154 + x9152)))) + (cons + 'posn + x9151))) + (x9148 + (letrec ((x9149 + (input))) + (cons + x9149 + '())))) + (cons + x9150 + x9148)))) + (cons + 'tetra + x9147))) + (x9144 + (letrec ((x9145 + (input))) + (cons + x9145 + '())))) + (cons + x9146 + x9144)))) + (cons + 'world + x9143)))) + (x9155 + x9142))) + (g8882 + (letrec ((x9157 + ((lambda (j7456 + k7457 + f7458) + (lambda (g7455) + (image/c + j7456 + k7457 + (f7458 + (BSET/C + j7456 + k7457 + g7455))))) + 'module + 'importer + blocks->image)) + (x9156 + (input))) + (x9157 + x9156))) + (g8883 + (letrec ((x9165 + ((lambda (j7460 + k7461 + f7462) + (lambda (g7459) + (image/c + j7460 + k7461 + (f7462 + (BLOCK/C + j7460 + k7461 + g7459))))) + 'module + 'importer + block->image)) + (x9158 + (letrec ((x9159 + (letrec ((x9164 + (input)) + (x9160 + (letrec ((x9163 + (input)) + (x9161 + (letrec ((x9162 + (input))) + (cons + x9162 + '())))) + (cons + x9163 + x9161)))) + (cons + x9164 + x9160)))) + (cons + 'block + x9159)))) + (x9165 + x9158))) + (g8884 + (letrec ((x9174 + ((lambda (j7465 + k7466 + f7467) + (lambda (g7463 + g7464) + (image/c + j7465 + k7466 + (f7467 + (BLOCK/C + j7465 + k7466 + g7463) + (image/c + j7465 + k7466 + g7464))))) + 'module + 'importer + place-block)) + (x9167 + (letrec ((x9168 + (letrec ((x9173 + (input)) + (x9169 + (letrec ((x9172 + (input)) + (x9170 + (letrec ((x9171 + (input))) + (cons + x9171 + '())))) + (cons + x9172 + x9170)))) + (cons + x9173 + x9169)))) + (cons + 'block + x9168))) + (x9166 + (input))) + (x9174 + x9167 + x9166))) + (g8885 + (letrec ((x9176 + ((lambda (j7469 + k7470 + f7471) + (lambda (g7468) + (WORLD/C + j7469 + k7470 + (f7471 + ((and/c + cons?/c + (listof + TETRA/C)) + j7469 + k7470 + g7468))))) + 'module + 'importer + world0)) + (x9175 + (input))) + (x9176 + x9175)))) + g8885))) + g8832))) + g8831)))) + g8773)))) + g8467)))) + g8446)))) + g8425)))) + g8394))) + g8393)))) + g7506))) + g7505)) diff --git a/analyses/simpleactor/benchmarks-out/games_zombie.rkt b/analyses/simpleactor/benchmarks-out/games_zombie.rkt index dabf5a4c..f62fd585 100644 --- a/analyses/simpleactor/benchmarks-out/games_zombie.rkt +++ b/analyses/simpleactor/benchmarks-out/games_zombie.rkt @@ -1,436 +1,5028 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7453 #t)) g7453))) + (meta (lambda (v) (letrec ((g7454 v)) g7454))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7455 + (letrec ((g7456 + (letrec ((x-e7457 lst)) + (match + x-e7457 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7458 (eq? v v1))) + (if x-cnd7458 #t (member v vs))))))))) + g7456))) + g7455))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (struct image ()) - (define (empty-scene w h) (image)) - (define (place-image i₁ r c i₂) (image)) - (define (circle r m c) (image)) - (define (min x y) (if (<= x y) x y)) - (define (max x y) (if (>= x y) x y)) - (define (abs x) (if (>= x 0) x (- 0 x))) - (define (sqr x) (* x x)) - (define WIDTH 400) - (define HEIGHT 400) - (define MT-SCENE (empty-scene WIDTH HEIGHT)) - (define PLAYER-SPEED 4) - (define ZOMBIE-SPEED 2) - (define ZOMBIE-RADIUS 20) - (define PLAYER-RADIUS 20) - (define PLAYER-IMG (circle PLAYER-RADIUS solid green)) - (define posn/c - (->d - (one-of/c 'x 'y 'posn 'move-toward/speed 'draw-on/image 'dist) - (lambda (msg) - (cond - ((equal? msg 'x) - (lambda (j3983 k3984 f3985) - (lambda () (real? j3983 k3984 (f3985))))) - ((equal? msg 'y) - (lambda (j3986 k3987 f3988) - (lambda () (real? j3986 k3987 (f3988))))) - ((equal? msg 'posn) - (lambda (j3989 k3990 f3991) - (lambda () (posn/c j3989 k3990 (f3991))))) - ((equal? msg 'move-toward/speed) - (lambda (j3994 k3995 f3996) - (lambda (g3992 g3993) - (posn/c - j3994 - k3995 - (f3996 - (posn/c j3994 k3995 g3992) - (real? j3994 k3995 g3993)))))) - ((equal? msg 'draw-on/image) - (lambda (j3999 k4000 f4001) - (lambda (g3997 g3998) - (image? - j3999 - k4000 - (f4001 - (image? j3999 k4000 g3997) - (image? j3999 k4000 g3998)))))) - ((equal? msg 'dist) - (lambda (j4003 k4004 f4005) - (lambda (g4002) - (real? j4003 k4004 (f4005 (posn/c j4003 k4004 g4002)))))) - (else error))))) - (define player/c - (->d - (one-of/c 'posn 'move-toward 'draw-on) - (lambda (msg) - (cond - ((equal? msg 'posn) - (lambda (j4006 k4007 f4008) - (lambda () (posn/c j4006 k4007 (f4008))))) - ((equal? msg 'move-toward) - (lambda (j4010 k4011 f4012) - (lambda (g4009) - (player/c j4010 k4011 (f4012 (posn/c j4010 k4011 g4009)))))) - ((equal? msg 'draw-on) - (lambda (j4014 k4015 f4016) - (lambda (g4013) - (image? j4014 k4015 (f4016 (image? j4014 k4015 g4013)))))) - (else error))))) - (define zombie/c - (->d - (one-of/c 'posn 'draw-on/color 'touching? 'move-toward) - (lambda (msg) - (cond - ((equal? msg 'posn) - (lambda (j4017 k4018 f4019) - (lambda () (posn/c j4017 k4018 (f4019))))) - ((equal? msg 'draw-on/color) - (lambda (j4022 k4023 f4024) - (lambda (g4020 g4021) - (image? - j4022 - k4023 - (f4024 - (string? j4022 k4023 g4020) - (image? j4022 k4023 g4021)))))) - ((equal? msg 'touching?) - (lambda (j4026 k4027 f4028) - (lambda (g4025) - (boolean? j4026 k4027 (f4028 (posn/c j4026 k4027 g4025)))))) - ((equal? msg 'move-toward) - (lambda (j4030 k4031 f4032) - (lambda (g4029) - (zombie/c j4030 k4031 (f4032 (posn/c j4030 k4031 g4029)))))) - (else error))))) - (define horde/c - (->d - (one-of/c 'dead 'undead 'draw-on 'touching? 'move-toward 'eat-brains) - (lambda (msg) - (cond - ((equal? msg 'dead) - (lambda (j4033 k4034 f4035) - (lambda () (zombies/c j4033 k4034 (f4035))))) - ((equal? msg 'undead) - (lambda (j4036 k4037 f4038) - (lambda () (zombies/c j4036 k4037 (f4038))))) - ((equal? msg 'draw-on) - (lambda (j4040 k4041 f4042) - (lambda (g4039) - (image? j4040 k4041 (f4042 (image? j4040 k4041 g4039)))))) - ((equal? msg 'touching?) - (lambda (j4044 k4045 f4046) - (lambda (g4043) - (boolean? j4044 k4045 (f4046 (posn/c j4044 k4045 g4043)))))) - ((equal? msg 'move-toward) - (lambda (j4048 k4049 f4050) - (lambda (g4047) - (horde/c j4048 k4049 (f4050 (posn/c j4048 k4049 g4047)))))) - ((equal? msg 'eat-brains) - (lambda (j4051 k4052 f4053) - (lambda () (horde/c j4051 k4052 (f4053))))) - (else error))))) - (define zombies/c - (->d - (one-of/c 'move-toward 'draw-on/color 'touching? 'kill-all) - (lambda (msg) - (cond - ((equal? msg 'move-toward) - (lambda (j4055 k4056 f4057) - (lambda (g4054) - (zombies/c j4055 k4056 (f4057 (posn/c j4055 k4056 g4054)))))) - ((equal? msg 'draw-on/color) - (lambda (j4060 k4061 f4062) - (lambda (g4058 g4059) - (image? - j4060 - k4061 - (f4062 - (string? j4060 k4061 g4058) - (image? j4060 k4061 g4059)))))) - ((equal? msg 'touching?) - (lambda (j4064 k4065 f4066) - (lambda (g4063) - (boolean? j4064 k4065 (f4066 (posn/c j4064 k4065 g4063)))))) - ((equal? msg 'kill-all) - (lambda (j4068 k4069 f4070) - (lambda (g4067) - (horde/c j4068 k4069 (f4070 (zombies/c j4068 k4069 g4067)))))) - (else error))))) - (define world/c - (->d - (one-of/c 'on-mouse 'on-tick 'to-draw 'stop-when) - (lambda (msg) - (cond - ((equal? msg 'on-mouse) - (lambda (j4074 k4075 f4076) - (lambda (g4071 g4072 g4073) - (world/c - j4074 - k4075 - (f4076 - (real? j4074 k4075 g4071) - (real? j4074 k4075 g4072) - (string? j4074 k4075 g4073)))))) - ((equal? msg 'on-tick) - (lambda (j4077 k4078 f4079) - (lambda () (world/c j4077 k4078 (f4079))))) - ((equal? msg 'to-draw) - (lambda (j4080 k4081 f4082) - (lambda () (image? j4080 k4081 (f4082))))) - ((equal? msg 'stop-when) - (lambda (j4083 k4084 f4085) - (lambda () (boolean? j4083 k4084 (f4085))))) - (else error))))) - (define (new-world player mouse zombies) - (λ (msg) - (cond - ((equal? msg 'on-mouse) - (λ (x y me) - (new-world - player - (if (equal? me leave) ((player 'posn)) (new-posn x y)) - zombies))) - ((equal? msg 'on-tick) - (λ () - (new-world - ((player 'move-toward) mouse) - mouse - ((((zombies 'eat-brains)) 'move-toward) ((player 'posn)))))) - ((equal? msg 'to-draw) - (λ () ((player 'draw-on) ((zombies 'draw-on) MT-SCENE)))) - ((equal? msg 'stop-when) - (λ () ((zombies 'touching?) ((player 'posn))))) - (else unknown message)))) - (define (new-player p) - (λ (msg) - (cond - ((equal? msg 'posn) (λ () p)) - ((equal? msg 'move-toward) - (λ (q) (new-player ((p 'move-toward/speed) q PLAYER-SPEED)))) - ((equal? msg 'draw-on) (λ (scn) ((p 'draw-on/image) PLAYER-IMG scn))) - (else unknown message)))) - (define (new-horde undead dead) - (λ (msg) - (cond - ((equal? msg 'dead) (λ () dead)) - ((equal? msg 'undead) (λ () undead)) - ((equal? msg 'draw-on) - (λ (scn) - ((undead 'draw-on/color) - yellow - ((dead 'draw-on/color) black scn)))) - ((equal? msg 'touching?) - (λ (p) (or ((undead 'touching?) p) ((dead 'touching?) p)))) - ((equal? msg 'move-toward) - (λ (p) (new-horde ((undead 'move-toward) p) dead))) - ((equal? msg 'eat-brains) (λ () ((undead 'kill-all) dead))) - (else unknown message)))) - (define (new-cons-zombies z r) - (λ (msg) - (cond - ((equal? msg 'move-toward) - (λ (p) (new-cons-zombies ((z 'move-toward) p) ((r 'move-toward) p)))) - ((equal? msg 'draw-on/color) - (λ (c s) ((z 'draw-on/color) c ((r 'draw-on/color) c s)))) - ((equal? msg 'touching?) - (λ (p) (or ((z 'touching?) p) ((r 'touching?) p)))) - ((equal? msg 'kill-all) - (λ (dead) - (cond - ((or ((r 'touching?) ((z 'posn))) ((dead 'touching?) ((z 'posn)))) - ((r 'kill-all) (new-cons-zombies z dead))) - (else - (let ((res ((r 'kill-all) dead))) - (new-horde - (new-cons-zombies z ((res 'undead))) - ((res 'dead)))))))) - (else unknown message)))) - (define (new-mt-zombies) - (λ (msg) - (cond - ((equal? msg 'move-toward) (λ (p) (new-mt-zombies))) - ((equal? msg 'draw-on/color) (λ (c s) s)) - ((equal? msg 'touching?) (λ (p) #f)) - ((equal? msg 'kill-all) (λ (dead) (new-horde (new-mt-zombies) dead))) - (else unknown message)))) - (define (new-zombie p) - (λ (msg) - (cond - ((equal? msg 'posn) (λ () p)) - ((equal? msg 'draw-on/color) - (λ (c s) ((p 'draw-on/image) (circle ZOMBIE-RADIUS solid c) s))) - ((equal? msg 'touching?) (λ (q) (<= ((p 'dist) q) ZOMBIE-RADIUS))) - ((equal? msg 'move-toward) - (λ (q) (new-zombie ((p 'move-toward/speed) q ZOMBIE-SPEED)))) - (else unknown message)))) - (define (new-posn x y) - (letrec ((this - (λ (msg) - (cond - ((equal? msg 'x) (λ () x)) - ((equal? msg 'y) (λ () y)) - ((equal? msg 'posn) (λ () this)) - ((equal? msg 'move-toward/speed) - (λ (p speed) - (let* ((δx (- ((p 'x)) x)) - (δy (- ((p 'y)) y)) - (move-distance - (min speed (max (abs δx) (abs δy))))) - (cond - ((< (abs δx) (abs δy)) - ((this 'move) - 0 - (if (positive? δy) - move-distance - (- 0 move-distance)))) - (else - ((this 'move) - (if (positive? δx) - move-distance - (- 0 move-distance)) - 0)))))) - ((equal? msg 'move) - (λ (δx δy) (new-posn (+ x δx) (+ y δy)))) - ((equal? msg 'draw-on/image) - (λ (img scn) (place-image img x y scn))) - ((equal? msg 'dist) - (λ (p) - (sqrt (+ (sqr (- ((p 'y)) y)) (sqr (- ((p 'x)) x)))))) - (else unknown message))))) - this)) - (define w0 - (new-world - (new-player (new-posn 0 0)) - (new-posn 0 0) - (new-horde - (new-cons-zombies - (new-zombie (new-posn 100 300)) - (new-cons-zombies (new-zombie (new-posn 100 200)) (new-mt-zombies))) - (new-cons-zombies (new-zombie (new-posn 200 200)) (new-mt-zombies))))) - (begin - ((((lambda (j4087 k4088 f4089) - (lambda (g4086) - (boolean? j4087 k4088 (f4089 (any/c j4087 k4088 g4086))))) - 'module - 'importer - image?) - (input)) - (((lambda (j4092 k4093 f4094) - (lambda (g4090 g4091) - (image? - j4092 - k4093 - (f4094 (real? j4092 k4093 g4090) (real? j4092 k4093 g4091))))) - 'module - 'importer - empty-scene) - (input) - (input)) - (((lambda (j4099 k4100 f4101) - (lambda (g4095 g4096 g4097 g4098) - (image? - j4099 - k4100 - (f4101 - (image? j4099 k4100 g4095) - (real? j4099 k4100 g4096) - (real? j4099 k4100 g4097) - (image? j4099 k4100 g4098))))) - 'module - 'importer - place-image) - (input) - (input) - (input) - (input)) - (((lambda (j4105 k4106 f4107) - (lambda (g4102 g4103 g4104) - (image? - j4105 - k4106 - (f4107 - (real? j4105 k4106 g4102) - (string? j4105 k4106 g4103) - (string? j4105 k4106 g4104))))) - 'module - 'importer - circle) - (input) - (input) - (input)) - (((lambda (j4111 k4112 f4113) - (lambda (g4108 g4109 g4110) - (world/c - j4111 - k4112 - (f4113 - (player/c j4111 k4112 g4108) - (posn/c j4111 k4112 g4109) - (horde/c j4111 k4112 g4110))))) - 'module - 'importer - new-world) - (input) - (input) - (input)) - (((lambda (j4115 k4116 f4117) - (lambda (g4114) - (player/c j4115 k4116 (f4117 (posn/c j4115 k4116 g4114))))) - 'module - 'importer - new-player) - (input)) - (((lambda (j4120 k4121 f4122) - (lambda (g4118 g4119) - (horde/c - j4120 - k4121 - (f4122 - (zombies/c j4120 k4121 g4118) - (zombies/c j4120 k4121 g4119))))) - 'module - 'importer - new-horde) - (input) - (input)) - (((lambda (j4125 k4126 f4127) - (lambda (g4123 g4124) - (zombies/c - j4125 - k4126 - (f4127 - (zombie/c j4125 k4126 g4123) - (zombies/c j4125 k4126 g4124))))) - 'module - 'importer - new-cons-zombies) - (input) - (input)) - ((lambda (j4128 k4129 f4130) - (lambda () (zombies/c j4128 k4129 (f4130)))) - 'module - 'importer - new-mt-zombies) - (((lambda (j4132 k4133 f4134) - (lambda (g4131) - (zombie/c j4132 k4133 (f4134 (posn/c j4132 k4133 g4131))))) - 'module - 'importer - new-zombie) - (input)) - (((lambda (j4137 k4138 f4139) - (lambda (g4135 g4136) - (posn/c - j4137 - k4138 - (f4139 (real? j4137 k4138 g4135) (real? j4137 k4138 g4136))))) - 'module - 'importer - new-posn) - (input) - (input)) - (world/c 'module 'importer w0))))) + (actor? + (lambda (k j) + (letrec ((g7459 (lambda (v) (letrec ((g7460 v)) g7460)))) g7459))) + (nonzero? + (lambda (v) + (letrec ((g7461 (letrec ((x7462 (= v 0))) (not x7462)))) g7461)))) + (letrec ((g7463 + (letrec ((g7464 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7465 + (letrec ((x-cnd7466 (real? g7162))) + (if x-cnd7466 + g7162 + (blame g7160 'real?))))) + g7465))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7467 + (letrec ((x-cnd7468 + (boolean? g7165))) + (if x-cnd7468 + g7165 + (blame g7163 'boolean?))))) + g7467))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7469 + (letrec ((x-cnd7470 + (number? g7168))) + (if x-cnd7470 + g7168 + (blame g7166 'number?))))) + g7469))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7471 + (letrec ((x-cnd7472 + ((lambda (v) #t) g7171))) + (if x-cnd7472 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7471))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7473 + (letrec ((x-cnd7474 + ((lambda (v) #t) g7174))) + (if x-cnd7474 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7473))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7475 + (letrec ((x-cnd7476 (pair? g7177))) + (if x-cnd7476 + g7177 + (blame g7175 'pair?))))) + g7475))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7477 + (letrec ((x-cnd7478 (pair? g7180))) + (if x-cnd7478 + g7180 + (blame g7178 'pair?))))) + g7477))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7479 + (letrec ((x-cnd7480 + (integer? g7183))) + (if x-cnd7480 + g7183 + (blame g7181 'integer?))))) + g7479))) + (and/c + (lambda (c1 c2) + (letrec ((g7481 + (lambda (k j v) + (letrec ((g7482 + (letrec ((x-cnd7483 + (c1 k j v))) + (if x-cnd7483 + (c2 k j v) + #f)))) + g7482)))) + g7481))) + (list-of + (lambda (contract) + (letrec ((g7484 + (lambda (k j v) + (letrec ((g7485 + (letrec ((x-cnd7486 + (null? v))) + (if x-cnd7486 + '() + (letrec ((x7490 + (letrec ((x7491 + (car + v))) + (contract + k + j + x7491))) + (x7487 + (letrec ((x7489 + (list-of + contract)) + (x7488 + (cdr + v))) + (x7489 + k + j + x7488)))) + (cons + x7490 + x7487)))))) + g7485)))) + g7484))) + (any? (lambda (v) (letrec ((g7492 #t)) g7492))) + (nonzero? + (lambda (v) + (letrec ((g7493 + (letrec ((x7494 (= v 0))) + (not x7494)))) + g7493))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7495 + (letrec ((x-cnd7496 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7496 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7495))) + (meta (lambda (v) (letrec ((g7497 v)) g7497))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7498 #t)) g7498))) + (cdddr + (lambda (x) + (letrec ((g7499 + (letrec ((x7500 + (letrec ((x7501 (cdr x))) + (cdr x7501)))) + (cdr x7500)))) + g7499))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7502 + (letrec ((x7505 (procedure? f))) + (assert x7505))) + (g7503 + (letrec ((x7506 (list? l))) + (assert x7506))) + (g7504 + (letrec ((x-cnd7507 (null? l))) + (if x-cnd7507 + '() + (letrec ((x7510 + (letrec ((x7511 + (car l))) + (f x7511))) + (x7508 + (letrec ((x7509 + (cdr l))) + (map f x7509)))) + (cons x7510 x7508)))))) + g7504))) + (cdar + (lambda (x) + (letrec ((g7512 + (letrec ((x7513 (car x))) + (cdr x7513)))) + g7512))) + (cadadr + (lambda (x) + (letrec ((g7514 + (letrec ((x7515 + (letrec ((x7516 + (letrec ((x7517 + (cdr + x))) + (car + x7517)))) + (cdr x7516)))) + (car x7515)))) + g7514))) + (cdadar + (lambda (x) + (letrec ((g7518 + (letrec ((x7519 + (letrec ((x7520 + (letrec ((x7521 + (car + x))) + (cdr + x7521)))) + (car x7520)))) + (cdr x7519)))) + g7518))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7522 + (letrec ((x7525 + (string? filename))) + (assert x7525))) + (g7523 + (letrec ((x7526 (procedure? proc))) + (assert x7526))) + (g7524 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7527 + (close-output-port + output-port)) + (g7528 res)) + g7528)))) + g7524))) + (caddr + (lambda (x) + (letrec ((g7529 + (letrec ((x7530 + (letrec ((x7531 (cdr x))) + (cdr x7531)))) + (car x7530)))) + g7529))) + (cdaadr + (lambda (x) + (letrec ((g7532 + (letrec ((x7533 + (letrec ((x7534 + (letrec ((x7535 + (cdr + x))) + (car + x7535)))) + (car x7534)))) + (cdr x7533)))) + g7532))) + (assq + (lambda (k l) + (letrec ((g7536 + (letrec ((x7538 (list? l))) + (assert x7538))) + (g7537 + (letrec ((x-cnd7539 (null? l))) + (if x-cnd7539 + #f + (letrec ((x-cnd7540 + (letrec ((x7541 + (caar l))) + (eq? x7541 k)))) + (if x-cnd7540 + (car l) + (letrec ((x7542 (cdr l))) + (assq k x7542)))))))) + g7537))) + (even? + (lambda (x) + (letrec ((g7543 + (letrec ((x7544 (modulo x 2))) + (= 0 x7544)))) + g7543))) + (list->string + (lambda (l) + (letrec ((g7545 + (letrec ((x7547 (list? l))) + (assert x7547))) + (g7546 + (letrec ((x-cnd7548 (null? l))) + (if x-cnd7548 + "" + (letrec ((x7551 + (letrec ((x7552 + (car l))) + (char->string + x7552))) + (x7549 + (letrec ((x7550 + (cdr l))) + (list->string + x7550)))) + (string-append + x7551 + x7549)))))) + g7546))) + (char<=? + (lambda (c1 c2) + (letrec ((g7553 + (letrec ((x7556 (char? c1))) + (assert x7556))) + (g7554 + (letrec ((x7557 (char? c2))) + (assert x7557))) + (g7555 + (letrec ((val7143 (char=? c x7574)))) + (if x-cnd7573 + (letrec ((x7575 #\z)) + (char-ci<=? c x7575)) + #f)))) + g7572))) + (<= + (lambda (x y) + (letrec ((g7576 + (letrec ((x7578 (number? x))) + (assert x7578))) + (g7577 + (letrec ((val7144 (< x y))) + (letrec ((g7579 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7580 + (if val7145 + val7145 + #f))) + g7580))))) + g7579)))) + g7577))) + (char-whitespace? + (lambda (c) + (letrec ((g7581 + (letrec ((val7146 + (letrec ((x7582 + (char->integer + c))) + (= x7582 9)))) + (letrec ((g7583 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7584 + (char->integer + c))) + (= + x7584 + 10)))) + (letrec ((g7585 + (if val7147 + val7147 + (letrec ((x7586 + (char->integer + c))) + (= + x7586 + 32))))) + g7585))))) + g7583)))) + g7581))) + (cddar + (lambda (x) + (letrec ((g7587 + (letrec ((x7588 + (letrec ((x7589 (car x))) + (cdr x7589)))) + (cdr x7588)))) + g7587))) + (positive? + (lambda (x) + (letrec ((g7590 + (letrec ((x7592 (number? x))) + (assert x7592))) + (g7591 (> x 0))) + g7591))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7593 #f)) g7593))) + (cddr + (lambda (x) + (letrec ((g7594 + (letrec ((x7595 (cdr x))) + (cdr x7595)))) + g7594))) + (truncate + (lambda (x) + (letrec ((g7596 + (letrec ((x7598 (number? x))) + (assert x7598))) + (g7597 + (letrec ((x-cnd7599 (< x 0))) + (if x-cnd7599 + (ceiling x) + (floor x))))) + g7597))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7600 + (letrec ((val7148 (eq? a b))) + (letrec ((g7601 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7603 + (null? + a)) + (x7602 + (null? + b))) + (and x7603 + x7602)))) + (letrec ((g7604 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7607 + (string? + a)) + (x7606 + (string? + b)) + (x7605 + (string=? + a + b))) + (and x7607 + x7606 + x7605)))) + (letrec ((g7608 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7616 + (pair? + a)) + (x7615 + (pair? + b)) + (x7612 + (letrec ((x7614 + (car + a)) + (x7613 + (car + b))) + (equal? + x7614 + x7613))) + (x7609 + (letrec ((x7611 + (cdr + a)) + (x7610 + (cdr + b))) + (equal? + x7611 + x7610)))) + (and x7616 + x7615 + x7612 + x7609)))) + (letrec ((g7617 + (if val7151 + val7151 + (letrec ((x7636 + (vector? + a)) + (x7635 + (vector? + b)) + (x7618 + (letrec ((x7632 + (letrec ((x7633 + (letrec ((x7634 + (vector-length + a))) + (n + x7634)))) + (x7633))) + (x7619 + (letrec ((x7630 + (letrec ((x7631 + (vector-length + b))) + (= + x7631 + n))) + (x7620 + (letrec ((loop + (lambda (i) + (letrec ((g7621 + (letrec ((x7628 + (= + i + n)) + (x7622 + (letrec ((x7625 + (letrec ((x7627 + (vector-ref + a + i)) + (x7626 + (vector-ref + b + i))) + (equal? + x7627 + x7626))) + (x7623 + (letrec ((x7624 + (+ + i + 1))) + (loop + x7624)))) + (and x7625 + x7623)))) + (or x7628 + x7622)))) + g7621)))) + (letrec ((g7629 + (loop + 0))) + g7629)))) + (and x7630 + x7620)))) + (let x7632 x7619)))) + (and x7636 + x7635 + x7618))))) + g7617))))) + g7608))))) + g7604))))) + g7601)))) + g7600))) + (cdaaar + (lambda (x) + (letrec ((g7637 + (letrec ((x7638 + (letrec ((x7639 + (letrec ((x7640 + (car + x))) + (car + x7640)))) + (car x7639)))) + (cdr x7638)))) + g7637))) + (caaddr + (lambda (x) + (letrec ((g7641 + (letrec ((x7642 + (letrec ((x7643 + (letrec ((x7644 + (cdr + x))) + (cdr + x7644)))) + (car x7643)))) + (car x7642)))) + g7641))) + (eqv? + (lambda (x y) + (letrec ((g7645 (eq? x y))) g7645))) + (>= + (lambda (x y) + (letrec ((g7646 + (letrec ((x7648 (number? x))) + (assert x7648))) + (g7647 + (letrec ((val7152 (> x y))) + (letrec ((g7649 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7650 + (if val7153 + val7153 + #f))) + g7650))))) + g7649)))) + g7647))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7651 + (letrec ((x7654 + (string? filename))) + (assert x7654))) + (g7652 + (letrec ((x7655 (procedure? proc))) + (assert x7655))) + (g7653 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7656 + (close-input-port + input-port)) + (g7657 res)) + g7657)))) + g7653))) + (ref + (lambda (x) + (letrec ((g7658 (cons x '()))) g7658))) + (char>=? + (lambda (c1 c2) + (letrec ((g7659 + (letrec ((x7662 (char? c1))) + (assert x7662))) + (g7660 + (letrec ((x7663 (char? c2))) + (assert x7663))) + (g7661 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7664 + (if val7154 + val7154 + (char=? c1 c2)))) + g7664)))) + g7661))) + (cdaar + (lambda (x) + (letrec ((g7665 + (letrec ((x7666 + (letrec ((x7667 (car x))) + (car x7667)))) + (cdr x7666)))) + g7665))) + (cdaddr + (lambda (x) + (letrec ((g7668 + (letrec ((x7669 + (letrec ((x7670 + (letrec ((x7671 + (cdr + x))) + (cdr + x7671)))) + (car x7670)))) + (cdr x7669)))) + g7668))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7672 + (letrec ((x7673 + (letrec ((x7674 (car x))) + (cdr x7674)))) + (car x7673)))) + g7672))) + (caadr + (lambda (x) + (letrec ((g7675 + (letrec ((x7676 + (letrec ((x7677 (cdr x))) + (car x7677)))) + (car x7676)))) + g7675))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7678 + (letrec ((x7681 (char? c1))) + (assert x7681))) + (g7679 + (letrec ((x7682 (char? c2))) + (assert x7682))) + (g7680 + (letrec ((x7683 + (char-ci<=? c1 c2))) + (not x7683)))) + g7680))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7684 + (letrec ((x7685 + (letrec ((x7686 + (letrec ((x7687 + (car + x))) + (car + x7687)))) + (car x7686)))) + (car x7685)))) + g7684))) + (negative? + (lambda (x) + (letrec ((g7688 + (letrec ((x7690 (number? x))) + (assert x7690))) + (g7689 (< x 0))) + g7689))) + (memv + (lambda (e l) + (letrec ((g7691 (memq e l))) g7691))) + (caaar + (lambda (x) + (letrec ((g7692 + (letrec ((x7693 + (letrec ((x7694 (car x))) + (car x7694)))) + (car x7693)))) + g7692))) + (debug + (lambda (e) (letrec ((g7695 '())) g7695))) + (reverse + (lambda (l) + (letrec ((g7696 + (letrec ((x7698 (list? l))) + (assert x7698))) + (g7697 + (letrec ((x-cnd7699 (null? l))) + (if x-cnd7699 + '() + (letrec ((x7702 + (letrec ((x7703 + (cdr l))) + (reverse x7703))) + (x7700 + (letrec ((x7701 + (car l))) + (list x7701)))) + (append x7702 x7700)))))) + g7697))) + (caaadr + (lambda (x) + (letrec ((g7704 + (letrec ((x7705 + (letrec ((x7706 + (letrec ((x7707 + (cdr + x))) + (car + x7707)))) + (car x7706)))) + (car x7705)))) + g7704))) + (cddadr + (lambda (x) + (letrec ((g7708 + (letrec ((x7709 + (letrec ((x7710 + (letrec ((x7711 + (cdr + x))) + (car + x7711)))) + (cdr x7710)))) + (cdr x7709)))) + g7708))) + (odd? + (lambda (x) + (letrec ((g7712 + (letrec ((x7714 (number? x))) + (assert x7714))) + (g7713 + (letrec ((x7715 (modulo x 2))) + (= 1 x7715)))) + g7713))) + (caadar + (lambda (x) + (letrec ((g7716 + (letrec ((x7717 + (letrec ((x7718 + (letrec ((x7719 + (car + x))) + (cdr + x7719)))) + (car x7718)))) + (car x7717)))) + g7716))) + (apply + (lambda (proc args) + (letrec ((g7720 + (letrec ((x7723 (procedure? proc))) + (assert x7723))) + (g7721 + (letrec ((x7724 (list? args))) + (assert x7724))) + (g7722 + (if cnd + (letrec ((g7725 (proc))) g7725) + (if cnd + (letrec ((g7726 + (letrec ((x7727 + (car + args))) + (proc x7727)))) + g7726) + (if cnd + (letrec ((g7728 + (letrec ((x7730 + (car + args)) + (x7729 + (cadr + args))) + (proc + x7730 + x7729)))) + g7728) + (if cnd + (letrec ((g7731 + (letrec ((x7734 + (car + args)) + (x7733 + (cadr + args)) + (x7732 + (caddr + args))) + (proc + x7734 + x7733 + x7732)))) + g7731) + (if cnd + (letrec ((g7735 + (letrec ((x7739 + (car + args)) + (x7738 + (cadr + args)) + (x7737 + (caddr + args)) + (x7736 + (cadddr + args))) + (proc + x7739 + x7738 + x7737 + x7736)))) + g7735) + (if cnd + (letrec ((g7740 + (letrec ((x7746 + (car + args)) + (x7745 + (cadr + args)) + (x7744 + (caddr + args)) + (x7743 + (cadddr + args)) + (x7741 + (letrec ((x7742 + (cddddr + args))) + (car + x7742)))) + (proc + x7746 + x7745 + x7744 + x7743 + x7741)))) + g7740) + (if cnd + (letrec ((g7747 + (letrec ((x7755 + (car + args)) + (x7754 + (cadr + args)) + (x7753 + (caddr + args)) + (x7752 + (cadddr + args)) + (x7750 + (letrec ((x7751 + (cddddr + args))) + (car + x7751))) + (x7748 + (letrec ((x7749 + (cddddr + args))) + (cadr + x7749)))) + (proc + x7755 + x7754 + x7753 + x7752 + x7750 + x7748)))) + g7747) + (if cnd + (letrec ((g7756 + (letrec ((x7766 + (car + args)) + (x7765 + (cadr + args)) + (x7764 + (caddr + args)) + (x7763 + (cadddr + args)) + (x7761 + (letrec ((x7762 + (cddddr + args))) + (car + x7762))) + (x7759 + (letrec ((x7760 + (cddddr + args))) + (cadr + x7760))) + (x7757 + (letrec ((x7758 + (cddddr + args))) + (caddr + x7758)))) + (proc + x7766 + x7765 + x7764 + x7763 + x7761 + x7759 + x7757)))) + g7756) + (letrec ((g7767 + (error + "Unsupported call."))) + g7767))))))))))) + g7722))) + (member + (lambda (e l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + #f + (letrec ((x-cnd7772 + (letrec ((x7773 + (car l))) + (equal? x7773 e)))) + (if x-cnd7772 + l + (letrec ((x7774 (cdr l))) + (member e x7774)))))))) + g7769))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7775 + (letrec ((x7776 + (letrec ((x7777 + (letrec ((x7778 + (cdr + x))) + (cdr + x7778)))) + (cdr x7777)))) + (cdr x7776)))) + g7775))) + (cadddr + (lambda (x) + (letrec ((g7779 + (letrec ((x7780 + (letrec ((x7781 + (letrec ((x7782 + (cdr + x))) + (cdr + x7782)))) + (cdr x7781)))) + (car x7780)))) + g7779))) + (int-top + (lambda () + (letrec ((g7783 (random 42))) g7783))) + (zero? + (lambda (x) + (letrec ((g7784 + (letrec ((x7786 (number? x))) + (assert x7786))) + (g7785 (= x 0))) + g7785))) + (string>=? + (lambda (s1 s2) + (letrec ((g7787 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7788 + (if val7155 + val7155 + (string=? s1 s2)))) + g7788)))) + g7787))) + (cadr + (lambda (x) + (letrec ((g7789 + (letrec ((x7790 (cdr x))) + (car x7790)))) + g7789))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7791 + (letrec ((val7156 + (letrec ((x7794 + (pair? l)) + (x7792 + (letrec ((x7793 + (cdr + l))) + (list? + x7793)))) + (and x7794 x7792)))) + (letrec ((g7795 + (if val7156 + val7156 + (null? l)))) + g7795)))) + g7791))) + (cddaar + (lambda (x) + (letrec ((g7796 + (letrec ((x7797 + (letrec ((x7798 + (letrec ((x7799 + (car + x))) + (car + x7799)))) + (cdr x7798)))) + (cdr x7797)))) + g7796))) + (char-numeric? + (lambda (c) + (letrec ((g7800 + (letrec ((x-cnd7801 + (letrec ((x7802 #\0)) + (char<=? x7802 c)))) + (if x-cnd7801 + (letrec ((x7803 #\9)) + (char<=? c x7803)) + #f)))) + g7800))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7804 + (letrec ((x7806 (list? l))) + (assert x7806))) + (g7805 + (letrec ((x-cnd7807 (null? l))) + (if x-cnd7807 + #f + (letrec ((x-cnd7808 + (letrec ((x7809 + (caar l))) + (eqv? x7809 k)))) + (if x-cnd7808 + (car l) + (letrec ((x7810 (cdr l))) + (assq k x7810)))))))) + g7805))) + (not + (lambda (x) + (letrec ((g7811 (if x #f #t))) g7811))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7812 (append l1 l2))) g7812))) + (memq + (lambda (e l) + (letrec ((g7813 + (letrec ((x7815 (list? l))) + (assert x7815))) + (g7814 + (letrec ((x-cnd7816 (null? l))) + (if x-cnd7816 + #f + (letrec ((x-cnd7817 + (letrec ((x7818 + (car l))) + (eq? x7818 e)))) + (if x-cnd7817 + l + (letrec ((x7819 (cdr l))) + (memq e x7819)))))))) + g7814))) + (cadaar + (lambda (x) + (letrec ((g7820 + (letrec ((x7821 + (letrec ((x7822 + (letrec ((x7823 + (car + x))) + (car + x7823)))) + (cdr x7822)))) + (car x7821)))) + g7820))) + (length + (lambda (l) + (letrec ((g7824 + (letrec ((x7826 (list? l))) + (assert x7826))) + (g7825 + (letrec ((rec + (lambda (l) + (letrec ((g7827 + (letrec ((x-cnd7828 + (null? + l))) + (if x-cnd7828 + 0 + (letrec ((x7829 + (letrec ((x7830 + (cdr + l))) + (rec + x7830)))) + (+ + 1 + x7829)))))) + g7827)))) + (letrec ((g7831 (rec l))) + g7831)))) + g7825))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7832 + (letrec ((x7835 (char? c1))) + (assert x7835))) + (g7833 + (letrec ((x7836 (char? c2))) + (assert x7836))) + (g7834 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7838 + (letrec ((x7839 (string<=? s1 s2))) + (not x7839)))) + g7838))) + (cdadr + (lambda (x) + (letrec ((g7840 + (letrec ((x7841 + (letrec ((x7842 (cdr x))) + (car x7842)))) + (cdr x7841)))) + g7840))) + (assoc + (lambda (k l) + (letrec ((g7843 + (letrec ((x7845 (list? l))) + (assert x7845))) + (g7844 + (letrec ((x-cnd7846 (null? l))) + (if x-cnd7846 + #f + (letrec ((x-cnd7847 + (letrec ((x7848 + (caar l))) + (equal? x7848 k)))) + (if x-cnd7847 + (car l) + (letrec ((x7849 (cdr l))) + (assoc k x7849)))))))) + g7844))) + (caar + (lambda (x) + (letrec ((g7850 + (letrec ((x7851 (car x))) + (car x7851)))) + g7850))) + (char>? + (lambda (c1 c2) + (letrec ((g7852 + (letrec ((x7855 (char? c1))) + (assert x7855))) + (g7853 + (letrec ((x7856 (char? c2))) + (assert x7856))) + (g7854 + (letrec ((x7857 (char<=? c1 c2))) + (not x7857)))) + g7854))) + (string<=? + (lambda (s1 s2) + (letrec ((g7858 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7875 + (letrec ((x7878 (char? c1))) + (assert x7878))) + (g7876 + (letrec ((x7879 (char? c2))) + (assert x7879))) + (g7877 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7880 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7880)))) + g7877))) + (caddar + (lambda (x) + (letrec ((g7881 + (letrec ((x7882 + (letrec ((x7883 + (letrec ((x7884 + (car + x))) + (cdr + x7884)))) + (cdr x7883)))) + (car x7882)))) + g7881))) + (newline + (lambda () (letrec ((g7885 #f)) g7885))) + (lcm + (lambda (m n) + (letrec ((g7886 + (letrec ((x7888 + (letrec ((x7889 (* m n))) + (abs x7889))) + (x7887 (gcd m n))) + (/ x7888 x7887)))) + g7886))) + (deref car) + (> + (lambda (x y) + (letrec ((g7890 + (letrec ((x7892 (number? x))) + (assert x7892))) + (g7891 + (letrec ((x7893 (<= x y))) + (not x7893)))) + g7891))) + (list-ref + (lambda (l index) + (letrec ((g7894 + (letrec ((x7898 (list? l))) + (assert x7898))) + (g7895 + (letrec ((x7899 (number? index))) + (assert x7899))) + (g7896 + (letrec ((x7900 + (letrec ((x7901 + (length l))) + (< index x7901)))) + (assert x7900))) + (g7897 + (letrec ((x-cnd7902 (= index 0))) + (if x-cnd7902 + (car l) + (letrec ((x7904 (cdr l)) + (x7903 (- index 1))) + (list-ref x7904 x7903)))))) + g7897))) + (gcd + (lambda (a b) + (letrec ((g7905 + (letrec ((x-cnd7906 (= b 0))) + (if x-cnd7906 + a + (letrec ((x7907 (modulo a b))) + (gcd b x7907)))))) + g7905))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7908 + (letrec ((x-cnd7909 (real? g7162))) + (if x-cnd7909 + g7162 + (blame g7160 'real?))))) + g7908))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7910 + (letrec ((x-cnd7911 + (boolean? g7165))) + (if x-cnd7911 + g7165 + (blame g7163 'boolean?))))) + g7910))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7912 + (letrec ((x-cnd7913 + (number? g7168))) + (if x-cnd7913 + g7168 + (blame g7166 'number?))))) + g7912))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7914 + (letrec ((x-cnd7915 + ((lambda (v) #t) g7171))) + (if x-cnd7915 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7914))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7916 + (letrec ((x-cnd7917 + ((lambda (v) #t) g7174))) + (if x-cnd7917 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7916))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7918 + (letrec ((x-cnd7919 (pair? g7177))) + (if x-cnd7919 + g7177 + (blame g7175 'pair?))))) + g7918))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7920 + (letrec ((x-cnd7921 (pair? g7180))) + (if x-cnd7921 + g7180 + (blame g7178 'pair?))))) + g7920))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7922 + (letrec ((x-cnd7923 + (integer? g7183))) + (if x-cnd7923 + g7183 + (blame g7181 'integer?))))) + g7922))) + (and/c + (lambda (c1 c2) + (letrec ((g7924 + (lambda (k j v) + (letrec ((g7925 + (letrec ((x-cnd7926 + (c1 k j v))) + (if x-cnd7926 + (c2 k j v) + #f)))) + g7925)))) + g7924))) + (list-of + (lambda (contract) + (letrec ((g7927 + (lambda (k j v) + (letrec ((g7928 + (letrec ((x-cnd7929 + (null? v))) + (if x-cnd7929 + '() + (letrec ((x7933 + (letrec ((x7934 + (car + v))) + (contract + k + j + x7934))) + (x7930 + (letrec ((x7932 + (list-of + contract)) + (x7931 + (cdr + v))) + (x7932 + k + j + x7931)))) + (cons + x7933 + x7930)))))) + g7928)))) + g7927))) + (any? (lambda (v) (letrec ((g7935 #t)) g7935))) + (nonzero? + (lambda (v) + (letrec ((g7936 + (letrec ((x7937 (= v 0))) + (not x7937)))) + g7936))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7938 + (letrec ((x-cnd7939 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7939 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7938))) + (meta (lambda (v) (letrec ((g7940 v)) g7940))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7941 #t)) g7941))) + (cdddr + (lambda (x) + (letrec ((g7942 + (letrec ((x7943 + (letrec ((x7944 (cdr x))) + (cdr x7944)))) + (cdr x7943)))) + g7942))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7945 + (letrec ((x7948 (procedure? f))) + (assert x7948))) + (g7946 + (letrec ((x7949 (list? l))) + (assert x7949))) + (g7947 + (letrec ((x-cnd7950 (null? l))) + (if x-cnd7950 + '() + (letrec ((x7953 + (letrec ((x7954 + (car l))) + (f x7954))) + (x7951 + (letrec ((x7952 + (cdr l))) + (map f x7952)))) + (cons x7953 x7951)))))) + g7947))) + (cdar + (lambda (x) + (letrec ((g7955 + (letrec ((x7956 (car x))) + (cdr x7956)))) + g7955))) + (cadadr + (lambda (x) + (letrec ((g7957 + (letrec ((x7958 + (letrec ((x7959 + (letrec ((x7960 + (cdr + x))) + (car + x7960)))) + (cdr x7959)))) + (car x7958)))) + g7957))) + (cdadar + (lambda (x) + (letrec ((g7961 + (letrec ((x7962 + (letrec ((x7963 + (letrec ((x7964 + (car + x))) + (cdr + x7964)))) + (car x7963)))) + (cdr x7962)))) + g7961))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7965 + (letrec ((x7968 + (string? filename))) + (assert x7968))) + (g7966 + (letrec ((x7969 (procedure? proc))) + (assert x7969))) + (g7967 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7970 + (close-output-port + output-port)) + (g7971 res)) + g7971)))) + g7967))) + (caddr + (lambda (x) + (letrec ((g7972 + (letrec ((x7973 + (letrec ((x7974 (cdr x))) + (cdr x7974)))) + (car x7973)))) + g7972))) + (cdaadr + (lambda (x) + (letrec ((g7975 + (letrec ((x7976 + (letrec ((x7977 + (letrec ((x7978 + (cdr + x))) + (car + x7978)))) + (car x7977)))) + (cdr x7976)))) + g7975))) + (assq + (lambda (k l) + (letrec ((g7979 + (letrec ((x7981 (list? l))) + (assert x7981))) + (g7980 + (letrec ((x-cnd7982 (null? l))) + (if x-cnd7982 + #f + (letrec ((x-cnd7983 + (letrec ((x7984 + (caar l))) + (eq? x7984 k)))) + (if x-cnd7983 + (car l) + (letrec ((x7985 (cdr l))) + (assq k x7985)))))))) + g7980))) + (even? + (lambda (x) + (letrec ((g7986 + (letrec ((x7987 (modulo x 2))) + (= 0 x7987)))) + g7986))) + (list->string + (lambda (l) + (letrec ((g7988 + (letrec ((x7990 (list? l))) + (assert x7990))) + (g7989 + (letrec ((x-cnd7991 (null? l))) + (if x-cnd7991 + "" + (letrec ((x7994 + (letrec ((x7995 + (car l))) + (char->string + x7995))) + (x7992 + (letrec ((x7993 + (cdr l))) + (list->string + x7993)))) + (string-append + x7994 + x7992)))))) + g7989))) + (char<=? + (lambda (c1 c2) + (letrec ((g7996 + (letrec ((x7999 (char? c1))) + (assert x7999))) + (g7997 + (letrec ((x8000 (char? c2))) + (assert x8000))) + (g7998 + (letrec ((val7143 (char=? c x8017)))) + (if x-cnd8016 + (letrec ((x8018 #\z)) + (char-ci<=? c x8018)) + #f)))) + g8015))) + (<= + (lambda (x y) + (letrec ((g8019 + (letrec ((x8021 (number? x))) + (assert x8021))) + (g8020 + (letrec ((val7144 (< x y))) + (letrec ((g8022 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g8023 + (if val7145 + val7145 + #f))) + g8023))))) + g8022)))) + g8020))) + (char-whitespace? + (lambda (c) + (letrec ((g8024 + (letrec ((val7146 + (letrec ((x8025 + (char->integer + c))) + (= x8025 9)))) + (letrec ((g8026 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x8027 + (char->integer + c))) + (= + x8027 + 10)))) + (letrec ((g8028 + (if val7147 + val7147 + (letrec ((x8029 + (char->integer + c))) + (= + x8029 + 32))))) + g8028))))) + g8026)))) + g8024))) + (cddar + (lambda (x) + (letrec ((g8030 + (letrec ((x8031 + (letrec ((x8032 (car x))) + (cdr x8032)))) + (cdr x8031)))) + g8030))) + (positive? + (lambda (x) + (letrec ((g8033 + (letrec ((x8035 (number? x))) + (assert x8035))) + (g8034 (> x 0))) + g8034))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g8036 #f)) g8036))) + (cddr + (lambda (x) + (letrec ((g8037 + (letrec ((x8038 (cdr x))) + (cdr x8038)))) + g8037))) + (truncate + (lambda (x) + (letrec ((g8039 + (letrec ((x8041 (number? x))) + (assert x8041))) + (g8040 + (letrec ((x-cnd8042 (< x 0))) + (if x-cnd8042 + (ceiling x) + (floor x))))) + g8040))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g8043 + (letrec ((val7148 (eq? a b))) + (letrec ((g8044 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x8046 + (null? + a)) + (x8045 + (null? + b))) + (and x8046 + x8045)))) + (letrec ((g8047 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x8050 + (string? + a)) + (x8049 + (string? + b)) + (x8048 + (string=? + a + b))) + (and x8050 + x8049 + x8048)))) + (letrec ((g8051 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x8059 + (pair? + a)) + (x8058 + (pair? + b)) + (x8055 + (letrec ((x8057 + (car + a)) + (x8056 + (car + b))) + (equal? + x8057 + x8056))) + (x8052 + (letrec ((x8054 + (cdr + a)) + (x8053 + (cdr + b))) + (equal? + x8054 + x8053)))) + (and x8059 + x8058 + x8055 + x8052)))) + (letrec ((g8060 + (if val7151 + val7151 + (letrec ((x8079 + (vector? + a)) + (x8078 + (vector? + b)) + (x8061 + (letrec ((x8075 + (letrec ((x8076 + (letrec ((x8077 + (vector-length + a))) + (n + x8077)))) + (x8076))) + (x8062 + (letrec ((x8073 + (letrec ((x8074 + (vector-length + b))) + (= + x8074 + n))) + (x8063 + (letrec ((loop + (lambda (i) + (letrec ((g8064 + (letrec ((x8071 + (= + i + n)) + (x8065 + (letrec ((x8068 + (letrec ((x8070 + (vector-ref + a + i)) + (x8069 + (vector-ref + b + i))) + (equal? + x8070 + x8069))) + (x8066 + (letrec ((x8067 + (+ + i + 1))) + (loop + x8067)))) + (and x8068 + x8066)))) + (or x8071 + x8065)))) + g8064)))) + (letrec ((g8072 + (loop + 0))) + g8072)))) + (and x8073 + x8063)))) + (let x8075 x8062)))) + (and x8079 + x8078 + x8061))))) + g8060))))) + g8051))))) + g8047))))) + g8044)))) + g8043))) + (cdaaar + (lambda (x) + (letrec ((g8080 + (letrec ((x8081 + (letrec ((x8082 + (letrec ((x8083 + (car + x))) + (car + x8083)))) + (car x8082)))) + (cdr x8081)))) + g8080))) + (caaddr + (lambda (x) + (letrec ((g8084 + (letrec ((x8085 + (letrec ((x8086 + (letrec ((x8087 + (cdr + x))) + (cdr + x8087)))) + (car x8086)))) + (car x8085)))) + g8084))) + (eqv? + (lambda (x y) + (letrec ((g8088 (eq? x y))) g8088))) + (>= + (lambda (x y) + (letrec ((g8089 + (letrec ((x8091 (number? x))) + (assert x8091))) + (g8090 + (letrec ((val7152 (> x y))) + (letrec ((g8092 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g8093 + (if val7153 + val7153 + #f))) + g8093))))) + g8092)))) + g8090))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g8094 + (letrec ((x8097 + (string? filename))) + (assert x8097))) + (g8095 + (letrec ((x8098 (procedure? proc))) + (assert x8098))) + (g8096 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g8099 + (close-input-port + input-port)) + (g8100 res)) + g8100)))) + g8096))) + (ref + (lambda (x) + (letrec ((g8101 (cons x '()))) g8101))) + (char>=? + (lambda (c1 c2) + (letrec ((g8102 + (letrec ((x8105 (char? c1))) + (assert x8105))) + (g8103 + (letrec ((x8106 (char? c2))) + (assert x8106))) + (g8104 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g8107 + (if val7154 + val7154 + (char=? c1 c2)))) + g8107)))) + g8104))) + (cdaar + (lambda (x) + (letrec ((g8108 + (letrec ((x8109 + (letrec ((x8110 (car x))) + (car x8110)))) + (cdr x8109)))) + g8108))) + (cdaddr + (lambda (x) + (letrec ((g8111 + (letrec ((x8112 + (letrec ((x8113 + (letrec ((x8114 + (cdr + x))) + (cdr + x8114)))) + (car x8113)))) + (cdr x8112)))) + g8111))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g8115 + (letrec ((x8116 + (letrec ((x8117 (car x))) + (cdr x8117)))) + (car x8116)))) + g8115))) + (caadr + (lambda (x) + (letrec ((g8118 + (letrec ((x8119 + (letrec ((x8120 (cdr x))) + (car x8120)))) + (car x8119)))) + g8118))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g8121 + (letrec ((x8124 (char? c1))) + (assert x8124))) + (g8122 + (letrec ((x8125 (char? c2))) + (assert x8125))) + (g8123 + (letrec ((x8126 + (char-ci<=? c1 c2))) + (not x8126)))) + g8123))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g8127 + (letrec ((x8128 + (letrec ((x8129 + (letrec ((x8130 + (car + x))) + (car + x8130)))) + (car x8129)))) + (car x8128)))) + g8127))) + (negative? + (lambda (x) + (letrec ((g8131 + (letrec ((x8133 (number? x))) + (assert x8133))) + (g8132 (< x 0))) + g8132))) + (memv + (lambda (e l) + (letrec ((g8134 (memq e l))) g8134))) + (caaar + (lambda (x) + (letrec ((g8135 + (letrec ((x8136 + (letrec ((x8137 (car x))) + (car x8137)))) + (car x8136)))) + g8135))) + (debug + (lambda (e) (letrec ((g8138 '())) g8138))) + (reverse + (lambda (l) + (letrec ((g8139 + (letrec ((x8141 (list? l))) + (assert x8141))) + (g8140 + (letrec ((x-cnd8142 (null? l))) + (if x-cnd8142 + '() + (letrec ((x8145 + (letrec ((x8146 + (cdr l))) + (reverse x8146))) + (x8143 + (letrec ((x8144 + (car l))) + (list x8144)))) + (append x8145 x8143)))))) + g8140))) + (caaadr + (lambda (x) + (letrec ((g8147 + (letrec ((x8148 + (letrec ((x8149 + (letrec ((x8150 + (cdr + x))) + (car + x8150)))) + (car x8149)))) + (car x8148)))) + g8147))) + (cddadr + (lambda (x) + (letrec ((g8151 + (letrec ((x8152 + (letrec ((x8153 + (letrec ((x8154 + (cdr + x))) + (car + x8154)))) + (cdr x8153)))) + (cdr x8152)))) + g8151))) + (odd? + (lambda (x) + (letrec ((g8155 + (letrec ((x8157 (number? x))) + (assert x8157))) + (g8156 + (letrec ((x8158 (modulo x 2))) + (= 1 x8158)))) + g8156))) + (caadar + (lambda (x) + (letrec ((g8159 + (letrec ((x8160 + (letrec ((x8161 + (letrec ((x8162 + (car + x))) + (cdr + x8162)))) + (car x8161)))) + (car x8160)))) + g8159))) + (apply + (lambda (proc args) + (letrec ((g8163 + (letrec ((x8166 (procedure? proc))) + (assert x8166))) + (g8164 + (letrec ((x8167 (list? args))) + (assert x8167))) + (g8165 + (if cnd + (letrec ((g8168 (proc))) g8168) + (if cnd + (letrec ((g8169 + (letrec ((x8170 + (car + args))) + (proc x8170)))) + g8169) + (if cnd + (letrec ((g8171 + (letrec ((x8173 + (car + args)) + (x8172 + (cadr + args))) + (proc + x8173 + x8172)))) + g8171) + (if cnd + (letrec ((g8174 + (letrec ((x8177 + (car + args)) + (x8176 + (cadr + args)) + (x8175 + (caddr + args))) + (proc + x8177 + x8176 + x8175)))) + g8174) + (if cnd + (letrec ((g8178 + (letrec ((x8182 + (car + args)) + (x8181 + (cadr + args)) + (x8180 + (caddr + args)) + (x8179 + (cadddr + args))) + (proc + x8182 + x8181 + x8180 + x8179)))) + g8178) + (if cnd + (letrec ((g8183 + (letrec ((x8189 + (car + args)) + (x8188 + (cadr + args)) + (x8187 + (caddr + args)) + (x8186 + (cadddr + args)) + (x8184 + (letrec ((x8185 + (cddddr + args))) + (car + x8185)))) + (proc + x8189 + x8188 + x8187 + x8186 + x8184)))) + g8183) + (if cnd + (letrec ((g8190 + (letrec ((x8198 + (car + args)) + (x8197 + (cadr + args)) + (x8196 + (caddr + args)) + (x8195 + (cadddr + args)) + (x8193 + (letrec ((x8194 + (cddddr + args))) + (car + x8194))) + (x8191 + (letrec ((x8192 + (cddddr + args))) + (cadr + x8192)))) + (proc + x8198 + x8197 + x8196 + x8195 + x8193 + x8191)))) + g8190) + (if cnd + (letrec ((g8199 + (letrec ((x8209 + (car + args)) + (x8208 + (cadr + args)) + (x8207 + (caddr + args)) + (x8206 + (cadddr + args)) + (x8204 + (letrec ((x8205 + (cddddr + args))) + (car + x8205))) + (x8202 + (letrec ((x8203 + (cddddr + args))) + (cadr + x8203))) + (x8200 + (letrec ((x8201 + (cddddr + args))) + (caddr + x8201)))) + (proc + x8209 + x8208 + x8207 + x8206 + x8204 + x8202 + x8200)))) + g8199) + (letrec ((g8210 + (error + "Unsupported call."))) + g8210))))))))))) + g8165))) + (member + (lambda (e l) + (letrec ((g8211 + (letrec ((x8213 (list? l))) + (assert x8213))) + (g8212 + (letrec ((x-cnd8214 (null? l))) + (if x-cnd8214 + #f + (letrec ((x-cnd8215 + (letrec ((x8216 + (car l))) + (equal? x8216 e)))) + (if x-cnd8215 + l + (letrec ((x8217 (cdr l))) + (member e x8217)))))))) + g8212))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8218 + (letrec ((x8219 + (letrec ((x8220 + (letrec ((x8221 + (cdr + x))) + (cdr + x8221)))) + (cdr x8220)))) + (cdr x8219)))) + g8218))) + (cadddr + (lambda (x) + (letrec ((g8222 + (letrec ((x8223 + (letrec ((x8224 + (letrec ((x8225 + (cdr + x))) + (cdr + x8225)))) + (cdr x8224)))) + (car x8223)))) + g8222))) + (int-top + (lambda () + (letrec ((g8226 (random 42))) g8226))) + (zero? + (lambda (x) + (letrec ((g8227 + (letrec ((x8229 (number? x))) + (assert x8229))) + (g8228 (= x 0))) + g8228))) + (string>=? + (lambda (s1 s2) + (letrec ((g8230 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8231 + (if val7155 + val7155 + (string=? s1 s2)))) + g8231)))) + g8230))) + (cadr + (lambda (x) + (letrec ((g8232 + (letrec ((x8233 (cdr x))) + (car x8233)))) + g8232))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8234 + (letrec ((val7156 + (letrec ((x8237 + (pair? l)) + (x8235 + (letrec ((x8236 + (cdr + l))) + (list? + x8236)))) + (and x8237 x8235)))) + (letrec ((g8238 + (if val7156 + val7156 + (null? l)))) + g8238)))) + g8234))) + (cddaar + (lambda (x) + (letrec ((g8239 + (letrec ((x8240 + (letrec ((x8241 + (letrec ((x8242 + (car + x))) + (car + x8242)))) + (cdr x8241)))) + (cdr x8240)))) + g8239))) + (char-numeric? + (lambda (c) + (letrec ((g8243 + (letrec ((x-cnd8244 + (letrec ((x8245 #\0)) + (char<=? x8245 c)))) + (if x-cnd8244 + (letrec ((x8246 #\9)) + (char<=? c x8246)) + #f)))) + g8243))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8247 + (letrec ((x8249 (list? l))) + (assert x8249))) + (g8248 + (letrec ((x-cnd8250 (null? l))) + (if x-cnd8250 + #f + (letrec ((x-cnd8251 + (letrec ((x8252 + (caar l))) + (eqv? x8252 k)))) + (if x-cnd8251 + (car l) + (letrec ((x8253 (cdr l))) + (assq k x8253)))))))) + g8248))) + (not + (lambda (x) + (letrec ((g8254 (if x #f #t))) g8254))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8255 (append l1 l2))) g8255))) + (memq + (lambda (e l) + (letrec ((g8256 + (letrec ((x8258 (list? l))) + (assert x8258))) + (g8257 + (letrec ((x-cnd8259 (null? l))) + (if x-cnd8259 + #f + (letrec ((x-cnd8260 + (letrec ((x8261 + (car l))) + (eq? x8261 e)))) + (if x-cnd8260 + l + (letrec ((x8262 (cdr l))) + (memq e x8262)))))))) + g8257))) + (cadaar + (lambda (x) + (letrec ((g8263 + (letrec ((x8264 + (letrec ((x8265 + (letrec ((x8266 + (car + x))) + (car + x8266)))) + (cdr x8265)))) + (car x8264)))) + g8263))) + (length + (lambda (l) + (letrec ((g8267 + (letrec ((x8269 (list? l))) + (assert x8269))) + (g8268 + (letrec ((rec + (lambda (l) + (letrec ((g8270 + (letrec ((x-cnd8271 + (null? + l))) + (if x-cnd8271 + 0 + (letrec ((x8272 + (letrec ((x8273 + (cdr + l))) + (rec + x8273)))) + (+ + 1 + x8272)))))) + g8270)))) + (letrec ((g8274 (rec l))) + g8274)))) + g8268))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8275 + (letrec ((x8278 (char? c1))) + (assert x8278))) + (g8276 + (letrec ((x8279 (char? c2))) + (assert x8279))) + (g8277 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8281 + (letrec ((x8282 (string<=? s1 s2))) + (not x8282)))) + g8281))) + (cdadr + (lambda (x) + (letrec ((g8283 + (letrec ((x8284 + (letrec ((x8285 (cdr x))) + (car x8285)))) + (cdr x8284)))) + g8283))) + (assoc + (lambda (k l) + (letrec ((g8286 + (letrec ((x8288 (list? l))) + (assert x8288))) + (g8287 + (letrec ((x-cnd8289 (null? l))) + (if x-cnd8289 + #f + (letrec ((x-cnd8290 + (letrec ((x8291 + (caar l))) + (equal? x8291 k)))) + (if x-cnd8290 + (car l) + (letrec ((x8292 (cdr l))) + (assoc k x8292)))))))) + g8287))) + (caar + (lambda (x) + (letrec ((g8293 + (letrec ((x8294 (car x))) + (car x8294)))) + g8293))) + (char>? + (lambda (c1 c2) + (letrec ((g8295 + (letrec ((x8298 (char? c1))) + (assert x8298))) + (g8296 + (letrec ((x8299 (char? c2))) + (assert x8299))) + (g8297 + (letrec ((x8300 (char<=? c1 c2))) + (not x8300)))) + g8297))) + (string<=? + (lambda (s1 s2) + (letrec ((g8301 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8318 + (letrec ((x8321 (char? c1))) + (assert x8321))) + (g8319 + (letrec ((x8322 (char? c2))) + (assert x8322))) + (g8320 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8323 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8323)))) + g8320))) + (caddar + (lambda (x) + (letrec ((g8324 + (letrec ((x8325 + (letrec ((x8326 + (letrec ((x8327 + (car + x))) + (cdr + x8327)))) + (cdr x8326)))) + (car x8325)))) + g8324))) + (newline + (lambda () (letrec ((g8328 #f)) g8328))) + (lcm + (lambda (m n) + (letrec ((g8329 + (letrec ((x8331 + (letrec ((x8332 (* m n))) + (abs x8332))) + (x8330 (gcd m n))) + (/ x8331 x8330)))) + g8329))) + (deref car) + (> + (lambda (x y) + (letrec ((g8333 + (letrec ((x8335 (number? x))) + (assert x8335))) + (g8334 + (letrec ((x8336 (<= x y))) + (not x8336)))) + g8334))) + (list-ref + (lambda (l index) + (letrec ((g8337 + (letrec ((x8341 (list? l))) + (assert x8341))) + (g8338 + (letrec ((x8342 (number? index))) + (assert x8342))) + (g8339 + (letrec ((x8343 + (letrec ((x8344 + (length l))) + (< index x8344)))) + (assert x8343))) + (g8340 + (letrec ((x-cnd8345 (= index 0))) + (if x-cnd8345 + (car l) + (letrec ((x8347 (cdr l)) + (x8346 (- index 1))) + (list-ref x8347 x8346)))))) + g8340))) + (gcd + (lambda (a b) + (letrec ((g8348 + (letrec ((x-cnd8349 (= b 0))) + (if x-cnd8349 + a + (letrec ((x8350 (modulo a b))) + (gcd b x8350)))))) + g8348)))) + (letrec ((g8351 + (letrec ((g8352 + (letrec ((image + (lambda () + (letrec ((g8353 + (cons + 'image + '()))) + g8353))) + (image? + (lambda (image7452) + (letrec ((g8354 + (letrec ((x8355 + (car + image7452))) + (eq? + x8355 + 'image)))) + g8354))) + (image + (lambda () + (letrec ((g8356 + (cons + 'image + '()))) + g8356))) + (image? + (lambda (image7452) + (letrec ((g8357 + (letrec ((x8358 + (car + image7452))) + (eq? + x8358 + 'image)))) + g8357))) + (empty-scene + (lambda (w h) + (letrec ((g8359 + (image))) + g8359))) + (place-image + (lambda (i₁ r c i₂) + (letrec ((g8360 + (image))) + g8360))) + (circle + (lambda (r m c) + (letrec ((g8361 + (image))) + g8361))) + (min + (lambda (x y) + (letrec ((g8362 + (letrec ((x-cnd8363 + (<= + x + y))) + (if x-cnd8363 + x + y)))) + g8362))) + (max + (lambda (x y) + (letrec ((g8364 + (letrec ((x-cnd8365 + (>= + x + y))) + (if x-cnd8365 + x + y)))) + g8364))) + (abs + (lambda (x) + (letrec ((g8366 + (letrec ((x-cnd8367 + (>= + x + 0))) + (if x-cnd8367 + x + (- + 0 + x))))) + g8366))) + (sqr + (lambda (x) + (letrec ((g8368 + (* x x))) + g8368))) + (WIDTH 400) + (HEIGHT 400) + (MT-SCENE + (empty-scene + WIDTH + HEIGHT)) + (PLAYER-SPEED 4) + (ZOMBIE-SPEED 2) + (ZOMBIE-RADIUS 20) + (PLAYER-RADIUS 20) + (PLAYER-IMG + (circle + PLAYER-RADIUS + "solid" + "green")) + (posn/c + (lambda (j7230 + k7231 + f7232) + (letrec ((g8369 + (lambda (g7229) + (letrec ((g8370 + (letrec ((x7233 + ((lambda (g7237 + g7238 + g7239) + (if ((lambda (v7236) + (if (eq? + 'x + v7236) + #t + (if (eq? + 'y + v7236) + #t + (if (eq? + 'posn + v7236) + #t + (if (eq? + 'move-toward/speed + v7236) + #t + (if (eq? + 'draw-on/image + v7236) + #t + (eq? + 'dist + v7236))))))) + g7239) + g7239 + (blame + g7237 + '(lambda (v7236) + (if (eq? + 'x + v7236) + #t + (if (eq? + 'y + v7236) + #t + (if (eq? + 'posn + v7236) + #t + (if (eq? + 'move-toward/speed + v7236) + #t + (if (eq? + 'draw-on/image + v7236) + #t + (eq? + 'dist + v7236)))))))))) + j7230 + k7231 + g7229))) + (letrec ((g8371 + (letrec ((x8373 + ((lambda (msg) + (if cnd + (begin + (lambda (j7240 + k7241 + f7242) + (lambda () + (real? + j7240 + k7241 + (f7242))))) + (if cnd + (begin + (lambda (j7243 + k7244 + f7245) + (lambda () + (real? + j7243 + k7244 + (f7245))))) + (if cnd + (begin + (lambda (j7246 + k7247 + f7248) + (lambda () + (posn/c + j7246 + k7247 + (f7248))))) + (if cnd + (begin + (lambda (j7251 + k7252 + f7253) + (lambda (g7249 + g7250) + (posn/c + j7251 + k7252 + (f7253 + (posn/c + j7251 + k7252 + g7249) + (real? + j7251 + k7252 + g7250)))))) + (if cnd + (begin + (lambda (j7256 + k7257 + f7258) + (lambda (g7254 + g7255) + (image? + j7256 + k7257 + (f7258 + (image? + j7256 + k7257 + g7254) + (image? + j7256 + k7257 + g7255)))))) + (if cnd + (begin + (lambda (j7260 + k7261 + f7262) + (lambda (g7259) + (real? + j7260 + k7261 + (f7262 + (posn/c + j7260 + k7261 + g7259)))))) + (begin + "error")))))))) + x7233)) + (x8372 + (f7232 + x7233))) + (x8373 + j7230 + k7231 + x8372)))) + g8371)))) + g8370)))) + g8369))) + (player/c + (lambda (j7264 + k7265 + f7266) + (letrec ((g8374 + (lambda (g7263) + (letrec ((g8375 + (letrec ((x7267 + ((lambda (g7271 + g7272 + g7273) + (if ((lambda (v7270) + (if (eq? + 'posn + v7270) + #t + (if (eq? + 'move-toward + v7270) + #t + (eq? + 'draw-on + v7270)))) + g7273) + g7273 + (blame + g7271 + '(lambda (v7270) + (if (eq? + 'posn + v7270) + #t + (if (eq? + 'move-toward + v7270) + #t + (eq? + 'draw-on + v7270))))))) + j7264 + k7265 + g7263))) + (letrec ((g8376 + (letrec ((x8378 + ((lambda (msg) + (if cnd + (begin + (lambda (j7274 + k7275 + f7276) + (lambda () + (posn/c + j7274 + k7275 + (f7276))))) + (if cnd + (begin + (lambda (j7278 + k7279 + f7280) + (lambda (g7277) + (player/c + j7278 + k7279 + (f7280 + (posn/c + j7278 + k7279 + g7277)))))) + (if cnd + (begin + (lambda (j7282 + k7283 + f7284) + (lambda (g7281) + (image? + j7282 + k7283 + (f7284 + (image? + j7282 + k7283 + g7281)))))) + (begin + "error"))))) + x7267)) + (x8377 + (f7266 + x7267))) + (x8378 + j7264 + k7265 + x8377)))) + g8376)))) + g8375)))) + g8374))) + (zombie/c + (lambda (j7286 + k7287 + f7288) + (letrec ((g8379 + (lambda (g7285) + (letrec ((g8380 + (letrec ((x7289 + ((lambda (g7293 + g7294 + g7295) + (if ((lambda (v7292) + (if (eq? + 'posn + v7292) + #t + (if (eq? + 'draw-on/color + v7292) + #t + (if (eq? + 'touching? + v7292) + #t + (eq? + 'move-toward + v7292))))) + g7295) + g7295 + (blame + g7293 + '(lambda (v7292) + (if (eq? + 'posn + v7292) + #t + (if (eq? + 'draw-on/color + v7292) + #t + (if (eq? + 'touching? + v7292) + #t + (eq? + 'move-toward + v7292)))))))) + j7286 + k7287 + g7285))) + (letrec ((g8381 + (letrec ((x8383 + ((lambda (msg) + (if cnd + (begin + (lambda (j7296 + k7297 + f7298) + (lambda () + (posn/c + j7296 + k7297 + (f7298))))) + (if cnd + (begin + (lambda (j7301 + k7302 + f7303) + (lambda (g7299 + g7300) + (image? + j7301 + k7302 + (f7303 + (string? + j7301 + k7302 + g7299) + (image? + j7301 + k7302 + g7300)))))) + (if cnd + (begin + (lambda (j7305 + k7306 + f7307) + (lambda (g7304) + (boolean? + j7305 + k7306 + (f7307 + (posn/c + j7305 + k7306 + g7304)))))) + (if cnd + (begin + (lambda (j7309 + k7310 + f7311) + (lambda (g7308) + (zombie/c + j7309 + k7310 + (f7311 + (posn/c + j7309 + k7310 + g7308)))))) + (begin + "error")))))) + x7289)) + (x8382 + (f7288 + x7289))) + (x8383 + j7286 + k7287 + x8382)))) + g8381)))) + g8380)))) + g8379))) + (horde/c + (lambda (j7313 + k7314 + f7315) + (letrec ((g8384 + (lambda (g7312) + (letrec ((g8385 + (letrec ((x7316 + ((lambda (g7320 + g7321 + g7322) + (if ((lambda (v7319) + (if (eq? + 'dead + v7319) + #t + (if (eq? + 'undead + v7319) + #t + (if (eq? + 'draw-on + v7319) + #t + (if (eq? + 'touching? + v7319) + #t + (if (eq? + 'move-toward + v7319) + #t + (eq? + 'eat-brains + v7319))))))) + g7322) + g7322 + (blame + g7320 + '(lambda (v7319) + (if (eq? + 'dead + v7319) + #t + (if (eq? + 'undead + v7319) + #t + (if (eq? + 'draw-on + v7319) + #t + (if (eq? + 'touching? + v7319) + #t + (if (eq? + 'move-toward + v7319) + #t + (eq? + 'eat-brains + v7319)))))))))) + j7313 + k7314 + g7312))) + (letrec ((g8386 + (letrec ((x8388 + ((lambda (msg) + (if cnd + (begin + (lambda (j7323 + k7324 + f7325) + (lambda () + (zombies/c + j7323 + k7324 + (f7325))))) + (if cnd + (begin + (lambda (j7326 + k7327 + f7328) + (lambda () + (zombies/c + j7326 + k7327 + (f7328))))) + (if cnd + (begin + (lambda (j7330 + k7331 + f7332) + (lambda (g7329) + (image? + j7330 + k7331 + (f7332 + (image? + j7330 + k7331 + g7329)))))) + (if cnd + (begin + (lambda (j7334 + k7335 + f7336) + (lambda (g7333) + (boolean? + j7334 + k7335 + (f7336 + (posn/c + j7334 + k7335 + g7333)))))) + (if cnd + (begin + (lambda (j7338 + k7339 + f7340) + (lambda (g7337) + (horde/c + j7338 + k7339 + (f7340 + (posn/c + j7338 + k7339 + g7337)))))) + (if cnd + (begin + (lambda (j7341 + k7342 + f7343) + (lambda () + (horde/c + j7341 + k7342 + (f7343))))) + (begin + "error")))))))) + x7316)) + (x8387 + (f7315 + x7316))) + (x8388 + j7313 + k7314 + x8387)))) + g8386)))) + g8385)))) + g8384))) + (zombies/c + (lambda (j7345 + k7346 + f7347) + (letrec ((g8389 + (lambda (g7344) + (letrec ((g8390 + (letrec ((x7348 + ((lambda (g7352 + g7353 + g7354) + (if ((lambda (v7351) + (if (eq? + 'move-toward + v7351) + #t + (if (eq? + 'draw-on/color + v7351) + #t + (if (eq? + 'touching? + v7351) + #t + (eq? + 'kill-all + v7351))))) + g7354) + g7354 + (blame + g7352 + '(lambda (v7351) + (if (eq? + 'move-toward + v7351) + #t + (if (eq? + 'draw-on/color + v7351) + #t + (if (eq? + 'touching? + v7351) + #t + (eq? + 'kill-all + v7351)))))))) + j7345 + k7346 + g7344))) + (letrec ((g8391 + (letrec ((x8393 + ((lambda (msg) + (if cnd + (begin + (lambda (j7356 + k7357 + f7358) + (lambda (g7355) + (zombies/c + j7356 + k7357 + (f7358 + (posn/c + j7356 + k7357 + g7355)))))) + (if cnd + (begin + (lambda (j7361 + k7362 + f7363) + (lambda (g7359 + g7360) + (image? + j7361 + k7362 + (f7363 + (string? + j7361 + k7362 + g7359) + (image? + j7361 + k7362 + g7360)))))) + (if cnd + (begin + (lambda (j7365 + k7366 + f7367) + (lambda (g7364) + (boolean? + j7365 + k7366 + (f7367 + (posn/c + j7365 + k7366 + g7364)))))) + (if cnd + (begin + (lambda (j7369 + k7370 + f7371) + (lambda (g7368) + (horde/c + j7369 + k7370 + (f7371 + (zombies/c + j7369 + k7370 + g7368)))))) + (begin + "error")))))) + x7348)) + (x8392 + (f7347 + x7348))) + (x8393 + j7345 + k7346 + x8392)))) + g8391)))) + g8390)))) + g8389))) + (world/c + (lambda (j7373 + k7374 + f7375) + (letrec ((g8394 + (lambda (g7372) + (letrec ((g8395 + (letrec ((x7376 + ((lambda (g7380 + g7381 + g7382) + (if ((lambda (v7379) + (if (eq? + 'on-mouse + v7379) + #t + (if (eq? + 'on-tick + v7379) + #t + (if (eq? + 'to-draw + v7379) + #t + (eq? + 'stop-when + v7379))))) + g7382) + g7382 + (blame + g7380 + '(lambda (v7379) + (if (eq? + 'on-mouse + v7379) + #t + (if (eq? + 'on-tick + v7379) + #t + (if (eq? + 'to-draw + v7379) + #t + (eq? + 'stop-when + v7379)))))))) + j7373 + k7374 + g7372))) + (letrec ((g8396 + (letrec ((x8398 + ((lambda (msg) + (if cnd + (begin + (lambda (j7386 + k7387 + f7388) + (lambda (g7383 + g7384 + g7385) + (world/c + j7386 + k7387 + (f7388 + (real? + j7386 + k7387 + g7383) + (real? + j7386 + k7387 + g7384) + (string? + j7386 + k7387 + g7385)))))) + (if cnd + (begin + (lambda (j7389 + k7390 + f7391) + (lambda () + (world/c + j7389 + k7390 + (f7391))))) + (if cnd + (begin + (lambda (j7392 + k7393 + f7394) + (lambda () + (image? + j7392 + k7393 + (f7394))))) + (if cnd + (begin + (lambda (j7395 + k7396 + f7397) + (lambda () + (boolean? + j7395 + k7396 + (f7397))))) + (begin + "error")))))) + x7376)) + (x8397 + (f7375 + x7376))) + (x8398 + j7373 + k7374 + x8397)))) + g8396)))) + g8395)))) + g8394))) + (new-world + (lambda (player + mouse + zombies) + (letrec ((g8399 + (letrec ((x8428 + (msg)) + (x8400 + (if cnd + (letrec ((g8401 + (letrec ((x8406 + (x + y + me)) + (x8402 + (letrec ((x8403 + (letrec ((x-cnd8404 + (equal? + me + "leave"))) + (if x-cnd8404 + (letrec ((x8405 + (player + 'posn))) + (x8405)) + (new-posn + x + y))))) + (new-world + player + x8403 + zombies)))) + (λ x8406 + x8402)))) + g8401) + (if cnd + (letrec ((g8407 + (letrec ((x8408 + (letrec ((x8415 + (letrec ((x8416 + (player + 'move-toward))) + (x8416 + mouse))) + (x8409 + (letrec ((x8412 + (letrec ((x8413 + (letrec ((x8414 + (zombies + 'eat-brains))) + (x8414)))) + (x8413 + 'move-toward))) + (x8410 + (letrec ((x8411 + (player + 'posn))) + (x8411)))) + (x8412 + x8410)))) + (new-world + x8415 + mouse + x8409)))) + (λ () + x8408)))) + g8407) + (if cnd + (letrec ((g8417 + (letrec ((x8418 + (letrec ((x8421 + (player + 'draw-on)) + (x8419 + (letrec ((x8420 + (zombies + 'draw-on))) + (x8420 + MT-SCENE)))) + (x8421 + x8419)))) + (λ () + x8418)))) + g8417) + (if cnd + (letrec ((g8422 + (letrec ((x8423 + (letrec ((x8426 + (zombies + 'touching?)) + (x8424 + (letrec ((x8425 + (player + 'posn))) + (x8425)))) + (x8426 + x8424)))) + (λ () + x8423)))) + g8422) + (letrec ((g8427 + "unknown message")) + g8427))))))) + (λ x8428 + x8400)))) + g8399))) + (new-player + (lambda (p) + (letrec ((g8429 + (letrec ((x8442 + (msg)) + (x8430 + (if cnd + (letrec ((g8431 + (λ () + p))) + g8431) + (if cnd + (letrec ((g8432 + (letrec ((x8436 + (q)) + (x8433 + (letrec ((x8434 + (letrec ((x8435 + (p + 'move-toward/speed))) + (x8435 + q + PLAYER-SPEED)))) + (new-player + x8434)))) + (λ x8436 + x8433)))) + g8432) + (if cnd + (letrec ((g8437 + (letrec ((x8440 + (scn)) + (x8438 + (letrec ((x8439 + (p + 'draw-on/image))) + (x8439 + PLAYER-IMG + scn)))) + (λ x8440 + x8438)))) + g8437) + (letrec ((g8441 + "unknown message")) + g8441)))))) + (λ x8442 + x8430)))) + g8429))) + (new-horde + (lambda (undead dead) + (letrec ((g8443 + (letrec ((x8469 + (msg)) + (x8444 + (if cnd + (letrec ((g8445 + (λ () + dead))) + g8445) + (if cnd + (letrec ((g8446 + (λ () + undead))) + g8446) + (if cnd + (letrec ((g8447 + (letrec ((x8452 + (scn)) + (x8448 + (letrec ((x8451 + (undead + 'draw-on/color)) + (x8449 + (letrec ((x8450 + (dead + 'draw-on/color))) + (x8450 + "black" + scn)))) + (x8451 + "yellow" + x8449)))) + (λ x8452 + x8448)))) + g8447) + (if cnd + (letrec ((g8453 + (letrec ((x8459 + (p)) + (x8454 + (letrec ((x8457 + (letrec ((x8458 + (undead + 'touching?))) + (x8458 + p))) + (x8455 + (letrec ((x8456 + (dead + 'touching?))) + (x8456 + p)))) + (or x8457 + x8455)))) + (λ x8459 + x8454)))) + g8453) + (if cnd + (letrec ((g8460 + (letrec ((x8464 + (p)) + (x8461 + (letrec ((x8462 + (letrec ((x8463 + (undead + 'move-toward))) + (x8463 + p)))) + (new-horde + x8462 + dead)))) + (λ x8464 + x8461)))) + g8460) + (if cnd + (letrec ((g8465 + (letrec ((x8466 + (letrec ((x8467 + (undead + 'kill-all))) + (x8467 + dead)))) + (λ () + x8466)))) + g8465) + (letrec ((g8468 + "unknown message")) + g8468))))))))) + (λ x8469 + x8444)))) + g8443))) + (new-cons-zombies + (lambda (z r) + (letrec ((g8470 + (letrec ((x8521 + (msg)) + (x8471 + (if cnd + (letrec ((g8472 + (letrec ((x8478 + (p)) + (x8473 + (letrec ((x8476 + (letrec ((x8477 + (z + 'move-toward))) + (x8477 + p))) + (x8474 + (letrec ((x8475 + (r + 'move-toward))) + (x8475 + p)))) + (new-cons-zombies + x8476 + x8474)))) + (λ x8478 + x8473)))) + g8472) + (if cnd + (letrec ((g8479 + (letrec ((x8484 + (c + s)) + (x8480 + (letrec ((x8483 + (z + 'draw-on/color)) + (x8481 + (letrec ((x8482 + (r + 'draw-on/color))) + (x8482 + c + s)))) + (x8483 + c + x8481)))) + (λ x8484 + x8480)))) + g8479) + (if cnd + (letrec ((g8485 + (letrec ((x8491 + (p)) + (x8486 + (letrec ((x8489 + (letrec ((x8490 + (z + 'touching?))) + (x8490 + p))) + (x8487 + (letrec ((x8488 + (r + 'touching?))) + (x8488 + p)))) + (or x8489 + x8487)))) + (λ x8491 + x8486)))) + g8485) + (if cnd + (letrec ((g8492 + (letrec ((x8519 + (dead)) + (x8493 + (letrec ((x8506 + (letrec ((x8510 + (letrec ((x8515 + (letrec ((x8518 + (r + 'touching?)) + (x8516 + (letrec ((x8517 + (z + 'posn))) + (x8517)))) + (x8518 + x8516))) + (x8511 + (letrec ((x8514 + (dead + 'touching?)) + (x8512 + (letrec ((x8513 + (z + 'posn))) + (x8513)))) + (x8514 + x8512)))) + (or x8515 + x8511))) + (x8507 + (letrec ((x8509 + (r + 'kill-all)) + (x8508 + (new-cons-zombies + z + dead))) + (x8509 + x8508)))) + (x8510 + x8507))) + (x8494 + (letrec ((x8495 + (letrec ((x8502 + (letrec ((x8503 + (letrec ((x8504 + (letrec ((x8505 + (r + 'kill-all))) + (x8505 + dead)))) + (res + x8504)))) + (x8503))) + (x8496 + (letrec ((x8499 + (letrec ((x8500 + (letrec ((x8501 + (res + 'undead))) + (x8501)))) + (new-cons-zombies + z + x8500))) + (x8497 + (letrec ((x8498 + (res + 'dead))) + (x8498)))) + (new-horde + x8499 + x8497)))) + (let x8502 x8496)))) + (else + x8495)))) + (cond + x8506 + x8494)))) + (λ x8519 + x8493)))) + g8492) + (letrec ((g8520 + "unknown message")) + g8520))))))) + (λ x8521 + x8471)))) + g8470))) + (new-mt-zombies + (lambda () + (letrec ((g8522 + (letrec ((x8536 + (msg)) + (x8523 + (if cnd + (letrec ((g8524 + (letrec ((x8526 + (p)) + (x8525 + (new-mt-zombies))) + (λ x8526 + x8525)))) + g8524) + (if cnd + (letrec ((g8527 + (letrec ((x8528 + (c + s))) + (λ x8528 + s)))) + g8527) + (if cnd + (letrec ((g8529 + (letrec ((x8530 + (p))) + (λ x8530 + #f)))) + g8529) + (if cnd + (letrec ((g8531 + (letrec ((x8534 + (dead)) + (x8532 + (letrec ((x8533 + (new-mt-zombies))) + (new-horde + x8533 + dead)))) + (λ x8534 + x8532)))) + g8531) + (letrec ((g8535 + "unknown message")) + g8535))))))) + (λ x8536 + x8523)))) + g8522))) + (new-zombie + (lambda (p) + (letrec ((g8537 + (letrec ((x8556 + (msg)) + (x8538 + (if cnd + (letrec ((g8539 + (λ () + p))) + g8539) + (if cnd + (letrec ((g8540 + (letrec ((x8544 + (c + s)) + (x8541 + (letrec ((x8543 + (p + 'draw-on/image)) + (x8542 + (circle + ZOMBIE-RADIUS + "solid" + c))) + (x8543 + x8542 + s)))) + (λ x8544 + x8541)))) + g8540) + (if cnd + (letrec ((g8545 + (letrec ((x8549 + (q)) + (x8546 + (letrec ((x8547 + (letrec ((x8548 + (p + 'dist))) + (x8548 + q)))) + (<= + x8547 + ZOMBIE-RADIUS)))) + (λ x8549 + x8546)))) + g8545) + (if cnd + (letrec ((g8550 + (letrec ((x8554 + (q)) + (x8551 + (letrec ((x8552 + (letrec ((x8553 + (p + 'move-toward/speed))) + (x8553 + q + ZOMBIE-SPEED)))) + (new-zombie + x8552)))) + (λ x8554 + x8551)))) + g8550) + (letrec ((g8555 + "unknown message")) + g8555))))))) + (λ x8556 + x8538)))) + g8537))) + (new-posn + (lambda (x y) + (letrec ((g8557 + (letrec ((this + (letrec ((x8614 + (msg)) + (x8558 + (if cnd + (letrec ((g8559 + (λ () + x))) + g8559) + (if cnd + (letrec ((g8560 + (λ () + y))) + g8560) + (if cnd + (letrec ((g8561 + (λ () + this))) + g8561) + (if cnd + (letrec ((g8562 + (letrec ((x8592 + (p + speed)) + (x8563 + (letrec ((x8578 + (letrec ((x8588 + (letrec ((x8589 + (letrec ((x8590 + (letrec ((x8591 + (p + 'x))) + (x8591)))) + (- + x8590 + x)))) + (δx + x8589))) + (x8584 + (letrec ((x8585 + (letrec ((x8586 + (letrec ((x8587 + (p + 'y))) + (x8587)))) + (- + x8586 + y)))) + (δy + x8585))) + (x8579 + (letrec ((x8580 + (letrec ((x8581 + (letrec ((x8583 + (abs + δx)) + (x8582 + (abs + δy))) + (max + x8583 + x8582)))) + (min + speed + x8581)))) + (move-distance + x8580)))) + (x8588 + x8584 + x8579))) + (x8564 + (letrec ((x8570 + (letrec ((x8575 + (letrec ((x8577 + (abs + δx)) + (x8576 + (abs + δy))) + (< + x8577 + x8576))) + (x8571 + (letrec ((x8574 + (this + 'move)) + (x8572 + (letrec ((x-cnd8573 + (positive? + δy))) + (if x-cnd8573 + move-distance + (- + 0 + move-distance))))) + (x8574 + 0 + x8572)))) + (x8575 + x8571))) + (x8565 + (letrec ((x8566 + (letrec ((x8569 + (this + 'move)) + (x8567 + (letrec ((x-cnd8568 + (positive? + δx))) + (if x-cnd8568 + move-distance + (- + 0 + move-distance))))) + (x8569 + x8567 + 0)))) + (else + x8566)))) + (cond + x8570 + x8565)))) + (let* x8578 x8564)))) + (λ x8592 + x8563)))) + g8562) + (if cnd + (letrec ((g8593 + (letrec ((x8597 + (δx + δy)) + (x8594 + (letrec ((x8596 + (+ + x + δx)) + (x8595 + (+ + y + δy))) + (new-posn + x8596 + x8595)))) + (λ x8597 + x8594)))) + g8593) + (if cnd + (letrec ((g8598 + (letrec ((x8600 + (img + scn)) + (x8599 + (place-image + img + x + y + scn))) + (λ x8600 + x8599)))) + g8598) + (if cnd + (letrec ((g8601 + (letrec ((x8612 + (p)) + (x8602 + (letrec ((x8603 + (letrec ((x8608 + (letrec ((x8609 + (letrec ((x8610 + (letrec ((x8611 + (p + 'y))) + (x8611)))) + (- + x8610 + y)))) + (sqr + x8609))) + (x8604 + (letrec ((x8605 + (letrec ((x8606 + (letrec ((x8607 + (p + 'x))) + (x8607)))) + (- + x8606 + x)))) + (sqr + x8605)))) + (+ + x8608 + x8604)))) + (sqrt + x8603)))) + (λ x8612 + x8602)))) + g8601) + (letrec ((g8613 + "unknown message")) + g8613)))))))))) + (λ x8614 + x8558)))) + (letrec ((g8615 + this)) + g8615)))) + g8557))) + (w0 + (letrec ((x8629 + (letrec ((x8630 + (new-posn + 0 + 0))) + (new-player + x8630))) + (x8628 + (new-posn 0 0)) + (x8616 + (letrec ((x8621 + (letrec ((x8626 + (letrec ((x8627 + (new-posn + 100 + 300))) + (new-zombie + x8627))) + (x8622 + (letrec ((x8624 + (letrec ((x8625 + (new-posn + 100 + 200))) + (new-zombie + x8625))) + (x8623 + (new-mt-zombies))) + (new-cons-zombies + x8624 + x8623)))) + (new-cons-zombies + x8626 + x8622))) + (x8617 + (letrec ((x8619 + (letrec ((x8620 + (new-posn + 200 + 200))) + (new-zombie + x8620))) + (x8618 + (new-mt-zombies))) + (new-cons-zombies + x8619 + x8618)))) + (new-horde + x8621 + x8617)))) + (new-world + x8629 + x8628 + x8616)))) + (letrec ((g8631 + (letrec ((g8632 + (letrec ((g8633 + (letrec ((x8646 + ((lambda (j7399 + k7400 + f7401) + (lambda (g7398) + (boolean?/c + j7399 + k7400 + (f7401 + (any/c + j7399 + k7400 + g7398))))) + 'module + 'importer + image?)) + (x8645 + (input))) + (x8646 + x8645))) + (g8634 + (letrec ((x8649 + ((lambda (j7404 + k7405 + f7406) + (lambda (g7402 + g7403) + (image? + j7404 + k7405 + (f7406 + (real?/c + j7404 + k7405 + g7402) + (real?/c + j7404 + k7405 + g7403))))) + 'module + 'importer + empty-scene)) + (x8648 + (input)) + (x8647 + (input))) + (x8649 + x8648 + x8647))) + (g8635 + (letrec ((x8654 + ((lambda (j7411 + k7412 + f7413) + (lambda (g7407 + g7408 + g7409 + g7410) + (image? + j7411 + k7412 + (f7413 + (image?/c + j7411 + k7412 + g7407) + (real?/c + j7411 + k7412 + g7408) + (real?/c + j7411 + k7412 + g7409) + (image? + j7411 + k7412 + g7410))))) + 'module + 'importer + place-image)) + (x8653 + (input)) + (x8652 + (input)) + (x8651 + (input)) + (x8650 + (input))) + (x8654 + x8653 + x8652 + x8651 + x8650))) + (g8636 + (letrec ((x8658 + ((lambda (j7417 + k7418 + f7419) + (lambda (g7414 + g7415 + g7416) + (image? + j7417 + k7418 + (f7419 + (real?/c + j7417 + k7418 + g7414) + (string?/c + j7417 + k7418 + g7415) + (string?/c + j7417 + k7418 + g7416))))) + 'module + 'importer + circle)) + (x8657 + (input)) + (x8656 + (input)) + (x8655 + (input))) + (x8658 + x8657 + x8656 + x8655))) + (g8637 + (letrec ((x8662 + ((lambda (j7423 + k7424 + f7425) + (lambda (g7420 + g7421 + g7422) + (world/c + j7423 + k7424 + (f7425 + (player/c + j7423 + k7424 + g7420) + (posn/c + j7423 + k7424 + g7421) + (horde/c + j7423 + k7424 + g7422))))) + 'module + 'importer + new-world)) + (x8661 + (input)) + (x8660 + (input)) + (x8659 + (input))) + (x8662 + x8661 + x8660 + x8659))) + (g8638 + (letrec ((x8664 + ((lambda (j7427 + k7428 + f7429) + (lambda (g7426) + (player/c + j7427 + k7428 + (f7429 + (posn/c + j7427 + k7428 + g7426))))) + 'module + 'importer + new-player)) + (x8663 + (input))) + (x8664 + x8663))) + (g8639 + (letrec ((x8667 + ((lambda (j7432 + k7433 + f7434) + (lambda (g7430 + g7431) + (horde/c + j7432 + k7433 + (f7434 + (zombies/c + j7432 + k7433 + g7430) + (zombies/c + j7432 + k7433 + g7431))))) + 'module + 'importer + new-horde)) + (x8666 + (input)) + (x8665 + (input))) + (x8667 + x8666 + x8665))) + (g8640 + (letrec ((x8670 + ((lambda (j7437 + k7438 + f7439) + (lambda (g7435 + g7436) + (zombies/c + j7437 + k7438 + (f7439 + (zombie/c + j7437 + k7438 + g7435) + (zombies/c + j7437 + k7438 + g7436))))) + 'module + 'importer + new-cons-zombies)) + (x8669 + (input)) + (x8668 + (input))) + (x8670 + x8669 + x8668))) + (g8641 + ((lambda (j7440 + k7441 + f7442) + (lambda () + (zombies/c + j7440 + k7441 + (f7442)))) + 'module + 'importer + new-mt-zombies)) + (g8642 + (letrec ((x8672 + ((lambda (j7444 + k7445 + f7446) + (lambda (g7443) + (zombie/c + j7444 + k7445 + (f7446 + (posn/c + j7444 + k7445 + g7443))))) + 'module + 'importer + new-zombie)) + (x8671 + (input))) + (x8672 + x8671))) + (g8643 + (letrec ((x8675 + ((lambda (j7449 + k7450 + f7451) + (lambda (g7447 + g7448) + (posn/c + j7449 + k7450 + (f7451 + (real?/c + j7449 + k7450 + g7447) + (real?/c + j7449 + k7450 + g7448))))) + 'module + 'importer + new-posn)) + (x8674 + (input)) + (x8673 + (input))) + (x8675 + x8674 + x8673))) + (g8644 + (world/c + 'module + 'importer + w0))) + g8644))) + g8632))) + g8631)))) + g8352))) + g8351)))) + g7464))) + g7463)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_fold-div.rkt b/analyses/simpleactor/benchmarks-out/mochi_fold-div.rkt index 8390647c..9e24a596 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_fold-div.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_fold-div.rkt @@ -1,37 +1,3150 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7238 #t)) g7238))) + (meta (lambda (v) (letrec ((g7239 v)) g7239))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7240 + (letrec ((g7241 + (letrec ((x-e7242 lst)) + (match + x-e7242 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7243 (eq? v v1))) + (if x-cnd7243 #t (member v vs))))))))) + g7241))) + g7240))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (foldl f z l) (if (empty? l) z (foldl f (f z (car l)) (cdr l)))) - (define (randpos rand) (let ((n (rand))) (if (> n 0) n (randpos rand)))) - (define (mk-list rand n) - (if (<= n 0) empty (cons (randpos rand) (mk-list rand (- n 1))))) - (define (main rand n m) (foldl / m (mk-list rand n))) - (begin - ((((lambda (j3986 k3987 f3988) - (lambda (g3983 g3984 g3985) - (real? - j3986 - k3987 - (f3988 - ((lambda (j3989 k3990 f3991) - (lambda () (integer? j3989 k3990 (f3991)))) - j3986 - k3987 - g3983) - (integer? j3986 k3987 g3984) - (integer? j3986 k3987 g3985))))) - 'module - 'importer - main) - (input) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7244 (lambda (v) (letrec ((g7245 v)) g7245)))) g7244))) + (nonzero? + (lambda (v) + (letrec ((g7246 (letrec ((x7247 (= v 0))) (not x7247)))) g7246)))) + (letrec ((g7248 + (letrec ((g7249 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7250 + (letrec ((x-cnd7251 (real? g7162))) + (if x-cnd7251 + g7162 + (blame g7160 'real?))))) + g7250))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7252 + (letrec ((x-cnd7253 + (boolean? g7165))) + (if x-cnd7253 + g7165 + (blame g7163 'boolean?))))) + g7252))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7254 + (letrec ((x-cnd7255 + (number? g7168))) + (if x-cnd7255 + g7168 + (blame g7166 'number?))))) + g7254))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7256 + (letrec ((x-cnd7257 + ((lambda (v) #t) g7171))) + (if x-cnd7257 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7256))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7258 + (letrec ((x-cnd7259 + ((lambda (v) #t) g7174))) + (if x-cnd7259 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7258))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7260 + (letrec ((x-cnd7261 (pair? g7177))) + (if x-cnd7261 + g7177 + (blame g7175 'pair?))))) + g7260))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7262 + (letrec ((x-cnd7263 (pair? g7180))) + (if x-cnd7263 + g7180 + (blame g7178 'pair?))))) + g7262))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7264 + (letrec ((x-cnd7265 + (integer? g7183))) + (if x-cnd7265 + g7183 + (blame g7181 'integer?))))) + g7264))) + (and/c + (lambda (c1 c2) + (letrec ((g7266 + (lambda (k j v) + (letrec ((g7267 + (letrec ((x-cnd7268 + (c1 k j v))) + (if x-cnd7268 + (c2 k j v) + #f)))) + g7267)))) + g7266))) + (list-of + (lambda (contract) + (letrec ((g7269 + (lambda (k j v) + (letrec ((g7270 + (letrec ((x-cnd7271 + (null? v))) + (if x-cnd7271 + '() + (letrec ((x7275 + (letrec ((x7276 + (car + v))) + (contract + k + j + x7276))) + (x7272 + (letrec ((x7274 + (list-of + contract)) + (x7273 + (cdr + v))) + (x7274 + k + j + x7273)))) + (cons + x7275 + x7272)))))) + g7270)))) + g7269))) + (any? (lambda (v) (letrec ((g7277 #t)) g7277))) + (nonzero? + (lambda (v) + (letrec ((g7278 + (letrec ((x7279 (= v 0))) + (not x7279)))) + g7278))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7280 + (letrec ((x-cnd7281 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7281 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7280))) + (meta (lambda (v) (letrec ((g7282 v)) g7282))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7283 #t)) g7283))) + (cdddr + (lambda (x) + (letrec ((g7284 + (letrec ((x7285 + (letrec ((x7286 (cdr x))) + (cdr x7286)))) + (cdr x7285)))) + g7284))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7287 + (letrec ((x7290 (procedure? f))) + (assert x7290))) + (g7288 + (letrec ((x7291 (list? l))) + (assert x7291))) + (g7289 + (letrec ((x-cnd7292 (null? l))) + (if x-cnd7292 + '() + (letrec ((x7295 + (letrec ((x7296 + (car l))) + (f x7296))) + (x7293 + (letrec ((x7294 + (cdr l))) + (map f x7294)))) + (cons x7295 x7293)))))) + g7289))) + (cdar + (lambda (x) + (letrec ((g7297 + (letrec ((x7298 (car x))) + (cdr x7298)))) + g7297))) + (cadadr + (lambda (x) + (letrec ((g7299 + (letrec ((x7300 + (letrec ((x7301 + (letrec ((x7302 + (cdr + x))) + (car + x7302)))) + (cdr x7301)))) + (car x7300)))) + g7299))) + (cdadar + (lambda (x) + (letrec ((g7303 + (letrec ((x7304 + (letrec ((x7305 + (letrec ((x7306 + (car + x))) + (cdr + x7306)))) + (car x7305)))) + (cdr x7304)))) + g7303))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7307 + (letrec ((x7310 + (string? filename))) + (assert x7310))) + (g7308 + (letrec ((x7311 (procedure? proc))) + (assert x7311))) + (g7309 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7312 + (close-output-port + output-port)) + (g7313 res)) + g7313)))) + g7309))) + (caddr + (lambda (x) + (letrec ((g7314 + (letrec ((x7315 + (letrec ((x7316 (cdr x))) + (cdr x7316)))) + (car x7315)))) + g7314))) + (cdaadr + (lambda (x) + (letrec ((g7317 + (letrec ((x7318 + (letrec ((x7319 + (letrec ((x7320 + (cdr + x))) + (car + x7320)))) + (car x7319)))) + (cdr x7318)))) + g7317))) + (assq + (lambda (k l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + #f + (letrec ((x-cnd7325 + (letrec ((x7326 + (caar l))) + (eq? x7326 k)))) + (if x-cnd7325 + (car l) + (letrec ((x7327 (cdr l))) + (assq k x7327)))))))) + g7322))) + (even? + (lambda (x) + (letrec ((g7328 + (letrec ((x7329 (modulo x 2))) + (= 0 x7329)))) + g7328))) + (list->string + (lambda (l) + (letrec ((g7330 + (letrec ((x7332 (list? l))) + (assert x7332))) + (g7331 + (letrec ((x-cnd7333 (null? l))) + (if x-cnd7333 + "" + (letrec ((x7336 + (letrec ((x7337 + (car l))) + (char->string + x7337))) + (x7334 + (letrec ((x7335 + (cdr l))) + (list->string + x7335)))) + (string-append + x7336 + x7334)))))) + g7331))) + (char<=? + (lambda (c1 c2) + (letrec ((g7338 + (letrec ((x7341 (char? c1))) + (assert x7341))) + (g7339 + (letrec ((x7342 (char? c2))) + (assert x7342))) + (g7340 + (letrec ((val7143 (char=? c x7359)))) + (if x-cnd7358 + (letrec ((x7360 #\z)) + (char-ci<=? c x7360)) + #f)))) + g7357))) + (<= + (lambda (x y) + (letrec ((g7361 + (letrec ((x7363 (number? x))) + (assert x7363))) + (g7362 + (letrec ((val7144 (< x y))) + (letrec ((g7364 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7365 + (if val7145 + val7145 + #f))) + g7365))))) + g7364)))) + g7362))) + (char-whitespace? + (lambda (c) + (letrec ((g7366 + (letrec ((val7146 + (letrec ((x7367 + (char->integer + c))) + (= x7367 9)))) + (letrec ((g7368 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7369 + (char->integer + c))) + (= + x7369 + 10)))) + (letrec ((g7370 + (if val7147 + val7147 + (letrec ((x7371 + (char->integer + c))) + (= + x7371 + 32))))) + g7370))))) + g7368)))) + g7366))) + (cddar + (lambda (x) + (letrec ((g7372 + (letrec ((x7373 + (letrec ((x7374 (car x))) + (cdr x7374)))) + (cdr x7373)))) + g7372))) + (positive? + (lambda (x) + (letrec ((g7375 + (letrec ((x7377 (number? x))) + (assert x7377))) + (g7376 (> x 0))) + g7376))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7378 #f)) g7378))) + (cddr + (lambda (x) + (letrec ((g7379 + (letrec ((x7380 (cdr x))) + (cdr x7380)))) + g7379))) + (truncate + (lambda (x) + (letrec ((g7381 + (letrec ((x7383 (number? x))) + (assert x7383))) + (g7382 + (letrec ((x-cnd7384 (< x 0))) + (if x-cnd7384 + (ceiling x) + (floor x))))) + g7382))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7385 + (letrec ((val7148 (eq? a b))) + (letrec ((g7386 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7388 + (null? + a)) + (x7387 + (null? + b))) + (and x7388 + x7387)))) + (letrec ((g7389 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7392 + (string? + a)) + (x7391 + (string? + b)) + (x7390 + (string=? + a + b))) + (and x7392 + x7391 + x7390)))) + (letrec ((g7393 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7401 + (pair? + a)) + (x7400 + (pair? + b)) + (x7397 + (letrec ((x7399 + (car + a)) + (x7398 + (car + b))) + (equal? + x7399 + x7398))) + (x7394 + (letrec ((x7396 + (cdr + a)) + (x7395 + (cdr + b))) + (equal? + x7396 + x7395)))) + (and x7401 + x7400 + x7397 + x7394)))) + (letrec ((g7402 + (if val7151 + val7151 + (letrec ((x7421 + (vector? + a)) + (x7420 + (vector? + b)) + (x7403 + (letrec ((x7417 + (letrec ((x7418 + (letrec ((x7419 + (vector-length + a))) + (n + x7419)))) + (x7418))) + (x7404 + (letrec ((x7415 + (letrec ((x7416 + (vector-length + b))) + (= + x7416 + n))) + (x7405 + (letrec ((loop + (lambda (i) + (letrec ((g7406 + (letrec ((x7413 + (= + i + n)) + (x7407 + (letrec ((x7410 + (letrec ((x7412 + (vector-ref + a + i)) + (x7411 + (vector-ref + b + i))) + (equal? + x7412 + x7411))) + (x7408 + (letrec ((x7409 + (+ + i + 1))) + (loop + x7409)))) + (and x7410 + x7408)))) + (or x7413 + x7407)))) + g7406)))) + (letrec ((g7414 + (loop + 0))) + g7414)))) + (and x7415 + x7405)))) + (let x7417 x7404)))) + (and x7421 + x7420 + x7403))))) + g7402))))) + g7393))))) + g7389))))) + g7386)))) + g7385))) + (cdaaar + (lambda (x) + (letrec ((g7422 + (letrec ((x7423 + (letrec ((x7424 + (letrec ((x7425 + (car + x))) + (car + x7425)))) + (car x7424)))) + (cdr x7423)))) + g7422))) + (caaddr + (lambda (x) + (letrec ((g7426 + (letrec ((x7427 + (letrec ((x7428 + (letrec ((x7429 + (cdr + x))) + (cdr + x7429)))) + (car x7428)))) + (car x7427)))) + g7426))) + (eqv? + (lambda (x y) + (letrec ((g7430 (eq? x y))) g7430))) + (>= + (lambda (x y) + (letrec ((g7431 + (letrec ((x7433 (number? x))) + (assert x7433))) + (g7432 + (letrec ((val7152 (> x y))) + (letrec ((g7434 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7435 + (if val7153 + val7153 + #f))) + g7435))))) + g7434)))) + g7432))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7436 + (letrec ((x7439 + (string? filename))) + (assert x7439))) + (g7437 + (letrec ((x7440 (procedure? proc))) + (assert x7440))) + (g7438 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7441 + (close-input-port + input-port)) + (g7442 res)) + g7442)))) + g7438))) + (ref + (lambda (x) + (letrec ((g7443 (cons x '()))) g7443))) + (char>=? + (lambda (c1 c2) + (letrec ((g7444 + (letrec ((x7447 (char? c1))) + (assert x7447))) + (g7445 + (letrec ((x7448 (char? c2))) + (assert x7448))) + (g7446 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7449 + (if val7154 + val7154 + (char=? c1 c2)))) + g7449)))) + g7446))) + (cdaar + (lambda (x) + (letrec ((g7450 + (letrec ((x7451 + (letrec ((x7452 (car x))) + (car x7452)))) + (cdr x7451)))) + g7450))) + (cdaddr + (lambda (x) + (letrec ((g7453 + (letrec ((x7454 + (letrec ((x7455 + (letrec ((x7456 + (cdr + x))) + (cdr + x7456)))) + (car x7455)))) + (cdr x7454)))) + g7453))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7457 + (letrec ((x7458 + (letrec ((x7459 (car x))) + (cdr x7459)))) + (car x7458)))) + g7457))) + (caadr + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 (cdr x))) + (car x7462)))) + (car x7461)))) + g7460))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7463 + (letrec ((x7466 (char? c1))) + (assert x7466))) + (g7464 + (letrec ((x7467 (char? c2))) + (assert x7467))) + (g7465 + (letrec ((x7468 + (char-ci<=? c1 c2))) + (not x7468)))) + g7465))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7469 + (letrec ((x7470 + (letrec ((x7471 + (letrec ((x7472 + (car + x))) + (car + x7472)))) + (car x7471)))) + (car x7470)))) + g7469))) + (negative? + (lambda (x) + (letrec ((g7473 + (letrec ((x7475 (number? x))) + (assert x7475))) + (g7474 (< x 0))) + g7474))) + (memv + (lambda (e l) + (letrec ((g7476 (memq e l))) g7476))) + (caaar + (lambda (x) + (letrec ((g7477 + (letrec ((x7478 + (letrec ((x7479 (car x))) + (car x7479)))) + (car x7478)))) + g7477))) + (debug + (lambda (e) (letrec ((g7480 '())) g7480))) + (reverse + (lambda (l) + (letrec ((g7481 + (letrec ((x7483 (list? l))) + (assert x7483))) + (g7482 + (letrec ((x-cnd7484 (null? l))) + (if x-cnd7484 + '() + (letrec ((x7487 + (letrec ((x7488 + (cdr l))) + (reverse x7488))) + (x7485 + (letrec ((x7486 + (car l))) + (list x7486)))) + (append x7487 x7485)))))) + g7482))) + (caaadr + (lambda (x) + (letrec ((g7489 + (letrec ((x7490 + (letrec ((x7491 + (letrec ((x7492 + (cdr + x))) + (car + x7492)))) + (car x7491)))) + (car x7490)))) + g7489))) + (cddadr + (lambda (x) + (letrec ((g7493 + (letrec ((x7494 + (letrec ((x7495 + (letrec ((x7496 + (cdr + x))) + (car + x7496)))) + (cdr x7495)))) + (cdr x7494)))) + g7493))) + (odd? + (lambda (x) + (letrec ((g7497 + (letrec ((x7499 (number? x))) + (assert x7499))) + (g7498 + (letrec ((x7500 (modulo x 2))) + (= 1 x7500)))) + g7498))) + (caadar + (lambda (x) + (letrec ((g7501 + (letrec ((x7502 + (letrec ((x7503 + (letrec ((x7504 + (car + x))) + (cdr + x7504)))) + (car x7503)))) + (car x7502)))) + g7501))) + (apply + (lambda (proc args) + (letrec ((g7505 + (letrec ((x7508 (procedure? proc))) + (assert x7508))) + (g7506 + (letrec ((x7509 (list? args))) + (assert x7509))) + (g7507 + (if cnd + (letrec ((g7510 (proc))) g7510) + (if cnd + (letrec ((g7511 + (letrec ((x7512 + (car + args))) + (proc x7512)))) + g7511) + (if cnd + (letrec ((g7513 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args))) + (proc + x7515 + x7514)))) + g7513) + (if cnd + (letrec ((g7516 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args))) + (proc + x7519 + x7518 + x7517)))) + g7516) + (if cnd + (letrec ((g7520 + (letrec ((x7524 + (car + args)) + (x7523 + (cadr + args)) + (x7522 + (caddr + args)) + (x7521 + (cadddr + args))) + (proc + x7524 + x7523 + x7522 + x7521)))) + g7520) + (if cnd + (letrec ((g7525 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526)))) + g7525) + (if cnd + (letrec ((g7532 + (letrec ((x7540 + (car + args)) + (x7539 + (cadr + args)) + (x7538 + (caddr + args)) + (x7537 + (cadddr + args)) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (car + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (cadr + x7534)))) + (proc + x7540 + x7539 + x7538 + x7537 + x7535 + x7533)))) + g7532) + (if cnd + (letrec ((g7541 + (letrec ((x7551 + (car + args)) + (x7550 + (cadr + args)) + (x7549 + (caddr + args)) + (x7548 + (cadddr + args)) + (x7546 + (letrec ((x7547 + (cddddr + args))) + (car + x7547))) + (x7544 + (letrec ((x7545 + (cddddr + args))) + (cadr + x7545))) + (x7542 + (letrec ((x7543 + (cddddr + args))) + (caddr + x7543)))) + (proc + x7551 + x7550 + x7549 + x7548 + x7546 + x7544 + x7542)))) + g7541) + (letrec ((g7552 + (error + "Unsupported call."))) + g7552))))))))))) + g7507))) + (member + (lambda (e l) + (letrec ((g7553 + (letrec ((x7555 (list? l))) + (assert x7555))) + (g7554 + (letrec ((x-cnd7556 (null? l))) + (if x-cnd7556 + #f + (letrec ((x-cnd7557 + (letrec ((x7558 + (car l))) + (equal? x7558 e)))) + (if x-cnd7557 + l + (letrec ((x7559 (cdr l))) + (member e x7559)))))))) + g7554))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7560 + (letrec ((x7561 + (letrec ((x7562 + (letrec ((x7563 + (cdr + x))) + (cdr + x7563)))) + (cdr x7562)))) + (cdr x7561)))) + g7560))) + (cadddr + (lambda (x) + (letrec ((g7564 + (letrec ((x7565 + (letrec ((x7566 + (letrec ((x7567 + (cdr + x))) + (cdr + x7567)))) + (cdr x7566)))) + (car x7565)))) + g7564))) + (int-top + (lambda () + (letrec ((g7568 (random 42))) g7568))) + (zero? + (lambda (x) + (letrec ((g7569 + (letrec ((x7571 (number? x))) + (assert x7571))) + (g7570 (= x 0))) + g7570))) + (string>=? + (lambda (s1 s2) + (letrec ((g7572 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7573 + (if val7155 + val7155 + (string=? s1 s2)))) + g7573)))) + g7572))) + (cadr + (lambda (x) + (letrec ((g7574 + (letrec ((x7575 (cdr x))) + (car x7575)))) + g7574))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7576 + (letrec ((val7156 + (letrec ((x7579 + (pair? l)) + (x7577 + (letrec ((x7578 + (cdr + l))) + (list? + x7578)))) + (and x7579 x7577)))) + (letrec ((g7580 + (if val7156 + val7156 + (null? l)))) + g7580)))) + g7576))) + (cddaar + (lambda (x) + (letrec ((g7581 + (letrec ((x7582 + (letrec ((x7583 + (letrec ((x7584 + (car + x))) + (car + x7584)))) + (cdr x7583)))) + (cdr x7582)))) + g7581))) + (char-numeric? + (lambda (c) + (letrec ((g7585 + (letrec ((x-cnd7586 + (letrec ((x7587 #\0)) + (char<=? x7587 c)))) + (if x-cnd7586 + (letrec ((x7588 #\9)) + (char<=? c x7588)) + #f)))) + g7585))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (caar l))) + (eqv? x7594 k)))) + (if x-cnd7593 + (car l) + (letrec ((x7595 (cdr l))) + (assq k x7595)))))))) + g7590))) + (not + (lambda (x) + (letrec ((g7596 (if x #f #t))) g7596))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7597 (append l1 l2))) g7597))) + (memq + (lambda (e l) + (letrec ((g7598 + (letrec ((x7600 (list? l))) + (assert x7600))) + (g7599 + (letrec ((x-cnd7601 (null? l))) + (if x-cnd7601 + #f + (letrec ((x-cnd7602 + (letrec ((x7603 + (car l))) + (eq? x7603 e)))) + (if x-cnd7602 + l + (letrec ((x7604 (cdr l))) + (memq e x7604)))))))) + g7599))) + (cadaar + (lambda (x) + (letrec ((g7605 + (letrec ((x7606 + (letrec ((x7607 + (letrec ((x7608 + (car + x))) + (car + x7608)))) + (cdr x7607)))) + (car x7606)))) + g7605))) + (length + (lambda (l) + (letrec ((g7609 + (letrec ((x7611 (list? l))) + (assert x7611))) + (g7610 + (letrec ((rec + (lambda (l) + (letrec ((g7612 + (letrec ((x-cnd7613 + (null? + l))) + (if x-cnd7613 + 0 + (letrec ((x7614 + (letrec ((x7615 + (cdr + l))) + (rec + x7615)))) + (+ + 1 + x7614)))))) + g7612)))) + (letrec ((g7616 (rec l))) + g7616)))) + g7610))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7617 + (letrec ((x7620 (char? c1))) + (assert x7620))) + (g7618 + (letrec ((x7621 (char? c2))) + (assert x7621))) + (g7619 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7623 + (letrec ((x7624 (string<=? s1 s2))) + (not x7624)))) + g7623))) + (cdadr + (lambda (x) + (letrec ((g7625 + (letrec ((x7626 + (letrec ((x7627 (cdr x))) + (car x7627)))) + (cdr x7626)))) + g7625))) + (assoc + (lambda (k l) + (letrec ((g7628 + (letrec ((x7630 (list? l))) + (assert x7630))) + (g7629 + (letrec ((x-cnd7631 (null? l))) + (if x-cnd7631 + #f + (letrec ((x-cnd7632 + (letrec ((x7633 + (caar l))) + (equal? x7633 k)))) + (if x-cnd7632 + (car l) + (letrec ((x7634 (cdr l))) + (assoc k x7634)))))))) + g7629))) + (caar + (lambda (x) + (letrec ((g7635 + (letrec ((x7636 (car x))) + (car x7636)))) + g7635))) + (char>? + (lambda (c1 c2) + (letrec ((g7637 + (letrec ((x7640 (char? c1))) + (assert x7640))) + (g7638 + (letrec ((x7641 (char? c2))) + (assert x7641))) + (g7639 + (letrec ((x7642 (char<=? c1 c2))) + (not x7642)))) + g7639))) + (string<=? + (lambda (s1 s2) + (letrec ((g7643 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7660 + (letrec ((x7663 (char? c1))) + (assert x7663))) + (g7661 + (letrec ((x7664 (char? c2))) + (assert x7664))) + (g7662 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7665 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7665)))) + g7662))) + (caddar + (lambda (x) + (letrec ((g7666 + (letrec ((x7667 + (letrec ((x7668 + (letrec ((x7669 + (car + x))) + (cdr + x7669)))) + (cdr x7668)))) + (car x7667)))) + g7666))) + (newline + (lambda () (letrec ((g7670 #f)) g7670))) + (lcm + (lambda (m n) + (letrec ((g7671 + (letrec ((x7673 + (letrec ((x7674 (* m n))) + (abs x7674))) + (x7672 (gcd m n))) + (/ x7673 x7672)))) + g7671))) + (deref car) + (> + (lambda (x y) + (letrec ((g7675 + (letrec ((x7677 (number? x))) + (assert x7677))) + (g7676 + (letrec ((x7678 (<= x y))) + (not x7678)))) + g7676))) + (list-ref + (lambda (l index) + (letrec ((g7679 + (letrec ((x7683 (list? l))) + (assert x7683))) + (g7680 + (letrec ((x7684 (number? index))) + (assert x7684))) + (g7681 + (letrec ((x7685 + (letrec ((x7686 + (length l))) + (< index x7686)))) + (assert x7685))) + (g7682 + (letrec ((x-cnd7687 (= index 0))) + (if x-cnd7687 + (car l) + (letrec ((x7689 (cdr l)) + (x7688 (- index 1))) + (list-ref x7689 x7688)))))) + g7682))) + (gcd + (lambda (a b) + (letrec ((g7690 + (letrec ((x-cnd7691 (= b 0))) + (if x-cnd7691 + a + (letrec ((x7692 (modulo a b))) + (gcd b x7692)))))) + g7690))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7693 + (letrec ((x-cnd7694 (real? g7162))) + (if x-cnd7694 + g7162 + (blame g7160 'real?))))) + g7693))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7695 + (letrec ((x-cnd7696 + (boolean? g7165))) + (if x-cnd7696 + g7165 + (blame g7163 'boolean?))))) + g7695))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7697 + (letrec ((x-cnd7698 + (number? g7168))) + (if x-cnd7698 + g7168 + (blame g7166 'number?))))) + g7697))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7699 + (letrec ((x-cnd7700 + ((lambda (v) #t) g7171))) + (if x-cnd7700 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7699))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7701 + (letrec ((x-cnd7702 + ((lambda (v) #t) g7174))) + (if x-cnd7702 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7701))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7703 + (letrec ((x-cnd7704 (pair? g7177))) + (if x-cnd7704 + g7177 + (blame g7175 'pair?))))) + g7703))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7705 + (letrec ((x-cnd7706 (pair? g7180))) + (if x-cnd7706 + g7180 + (blame g7178 'pair?))))) + g7705))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7707 + (letrec ((x-cnd7708 + (integer? g7183))) + (if x-cnd7708 + g7183 + (blame g7181 'integer?))))) + g7707))) + (and/c + (lambda (c1 c2) + (letrec ((g7709 + (lambda (k j v) + (letrec ((g7710 + (letrec ((x-cnd7711 + (c1 k j v))) + (if x-cnd7711 + (c2 k j v) + #f)))) + g7710)))) + g7709))) + (list-of + (lambda (contract) + (letrec ((g7712 + (lambda (k j v) + (letrec ((g7713 + (letrec ((x-cnd7714 + (null? v))) + (if x-cnd7714 + '() + (letrec ((x7718 + (letrec ((x7719 + (car + v))) + (contract + k + j + x7719))) + (x7715 + (letrec ((x7717 + (list-of + contract)) + (x7716 + (cdr + v))) + (x7717 + k + j + x7716)))) + (cons + x7718 + x7715)))))) + g7713)))) + g7712))) + (any? (lambda (v) (letrec ((g7720 #t)) g7720))) + (nonzero? + (lambda (v) + (letrec ((g7721 + (letrec ((x7722 (= v 0))) + (not x7722)))) + g7721))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7723 + (letrec ((x-cnd7724 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7724 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7723))) + (meta (lambda (v) (letrec ((g7725 v)) g7725))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7726 #t)) g7726))) + (cdddr + (lambda (x) + (letrec ((g7727 + (letrec ((x7728 + (letrec ((x7729 (cdr x))) + (cdr x7729)))) + (cdr x7728)))) + g7727))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7730 + (letrec ((x7733 (procedure? f))) + (assert x7733))) + (g7731 + (letrec ((x7734 (list? l))) + (assert x7734))) + (g7732 + (letrec ((x-cnd7735 (null? l))) + (if x-cnd7735 + '() + (letrec ((x7738 + (letrec ((x7739 + (car l))) + (f x7739))) + (x7736 + (letrec ((x7737 + (cdr l))) + (map f x7737)))) + (cons x7738 x7736)))))) + g7732))) + (cdar + (lambda (x) + (letrec ((g7740 + (letrec ((x7741 (car x))) + (cdr x7741)))) + g7740))) + (cadadr + (lambda (x) + (letrec ((g7742 + (letrec ((x7743 + (letrec ((x7744 + (letrec ((x7745 + (cdr + x))) + (car + x7745)))) + (cdr x7744)))) + (car x7743)))) + g7742))) + (cdadar + (lambda (x) + (letrec ((g7746 + (letrec ((x7747 + (letrec ((x7748 + (letrec ((x7749 + (car + x))) + (cdr + x7749)))) + (car x7748)))) + (cdr x7747)))) + g7746))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7750 + (letrec ((x7753 + (string? filename))) + (assert x7753))) + (g7751 + (letrec ((x7754 (procedure? proc))) + (assert x7754))) + (g7752 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7755 + (close-output-port + output-port)) + (g7756 res)) + g7756)))) + g7752))) + (caddr + (lambda (x) + (letrec ((g7757 + (letrec ((x7758 + (letrec ((x7759 (cdr x))) + (cdr x7759)))) + (car x7758)))) + g7757))) + (cdaadr + (lambda (x) + (letrec ((g7760 + (letrec ((x7761 + (letrec ((x7762 + (letrec ((x7763 + (cdr + x))) + (car + x7763)))) + (car x7762)))) + (cdr x7761)))) + g7760))) + (assq + (lambda (k l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + #f + (letrec ((x-cnd7768 + (letrec ((x7769 + (caar l))) + (eq? x7769 k)))) + (if x-cnd7768 + (car l) + (letrec ((x7770 (cdr l))) + (assq k x7770)))))))) + g7765))) + (even? + (lambda (x) + (letrec ((g7771 + (letrec ((x7772 (modulo x 2))) + (= 0 x7772)))) + g7771))) + (list->string + (lambda (l) + (letrec ((g7773 + (letrec ((x7775 (list? l))) + (assert x7775))) + (g7774 + (letrec ((x-cnd7776 (null? l))) + (if x-cnd7776 + "" + (letrec ((x7779 + (letrec ((x7780 + (car l))) + (char->string + x7780))) + (x7777 + (letrec ((x7778 + (cdr l))) + (list->string + x7778)))) + (string-append + x7779 + x7777)))))) + g7774))) + (char<=? + (lambda (c1 c2) + (letrec ((g7781 + (letrec ((x7784 (char? c1))) + (assert x7784))) + (g7782 + (letrec ((x7785 (char? c2))) + (assert x7785))) + (g7783 + (letrec ((val7143 (char=? c x7802)))) + (if x-cnd7801 + (letrec ((x7803 #\z)) + (char-ci<=? c x7803)) + #f)))) + g7800))) + (<= + (lambda (x y) + (letrec ((g7804 + (letrec ((x7806 (number? x))) + (assert x7806))) + (g7805 + (letrec ((val7144 (< x y))) + (letrec ((g7807 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7808 + (if val7145 + val7145 + #f))) + g7808))))) + g7807)))) + g7805))) + (char-whitespace? + (lambda (c) + (letrec ((g7809 + (letrec ((val7146 + (letrec ((x7810 + (char->integer + c))) + (= x7810 9)))) + (letrec ((g7811 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7812 + (char->integer + c))) + (= + x7812 + 10)))) + (letrec ((g7813 + (if val7147 + val7147 + (letrec ((x7814 + (char->integer + c))) + (= + x7814 + 32))))) + g7813))))) + g7811)))) + g7809))) + (cddar + (lambda (x) + (letrec ((g7815 + (letrec ((x7816 + (letrec ((x7817 (car x))) + (cdr x7817)))) + (cdr x7816)))) + g7815))) + (positive? + (lambda (x) + (letrec ((g7818 + (letrec ((x7820 (number? x))) + (assert x7820))) + (g7819 (> x 0))) + g7819))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7821 #f)) g7821))) + (cddr + (lambda (x) + (letrec ((g7822 + (letrec ((x7823 (cdr x))) + (cdr x7823)))) + g7822))) + (truncate + (lambda (x) + (letrec ((g7824 + (letrec ((x7826 (number? x))) + (assert x7826))) + (g7825 + (letrec ((x-cnd7827 (< x 0))) + (if x-cnd7827 + (ceiling x) + (floor x))))) + g7825))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7828 + (letrec ((val7148 (eq? a b))) + (letrec ((g7829 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7831 + (null? + a)) + (x7830 + (null? + b))) + (and x7831 + x7830)))) + (letrec ((g7832 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7835 + (string? + a)) + (x7834 + (string? + b)) + (x7833 + (string=? + a + b))) + (and x7835 + x7834 + x7833)))) + (letrec ((g7836 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7844 + (pair? + a)) + (x7843 + (pair? + b)) + (x7840 + (letrec ((x7842 + (car + a)) + (x7841 + (car + b))) + (equal? + x7842 + x7841))) + (x7837 + (letrec ((x7839 + (cdr + a)) + (x7838 + (cdr + b))) + (equal? + x7839 + x7838)))) + (and x7844 + x7843 + x7840 + x7837)))) + (letrec ((g7845 + (if val7151 + val7151 + (letrec ((x7864 + (vector? + a)) + (x7863 + (vector? + b)) + (x7846 + (letrec ((x7860 + (letrec ((x7861 + (letrec ((x7862 + (vector-length + a))) + (n + x7862)))) + (x7861))) + (x7847 + (letrec ((x7858 + (letrec ((x7859 + (vector-length + b))) + (= + x7859 + n))) + (x7848 + (letrec ((loop + (lambda (i) + (letrec ((g7849 + (letrec ((x7856 + (= + i + n)) + (x7850 + (letrec ((x7853 + (letrec ((x7855 + (vector-ref + a + i)) + (x7854 + (vector-ref + b + i))) + (equal? + x7855 + x7854))) + (x7851 + (letrec ((x7852 + (+ + i + 1))) + (loop + x7852)))) + (and x7853 + x7851)))) + (or x7856 + x7850)))) + g7849)))) + (letrec ((g7857 + (loop + 0))) + g7857)))) + (and x7858 + x7848)))) + (let x7860 x7847)))) + (and x7864 + x7863 + x7846))))) + g7845))))) + g7836))))) + g7832))))) + g7829)))) + g7828))) + (cdaaar + (lambda (x) + (letrec ((g7865 + (letrec ((x7866 + (letrec ((x7867 + (letrec ((x7868 + (car + x))) + (car + x7868)))) + (car x7867)))) + (cdr x7866)))) + g7865))) + (caaddr + (lambda (x) + (letrec ((g7869 + (letrec ((x7870 + (letrec ((x7871 + (letrec ((x7872 + (cdr + x))) + (cdr + x7872)))) + (car x7871)))) + (car x7870)))) + g7869))) + (eqv? + (lambda (x y) + (letrec ((g7873 (eq? x y))) g7873))) + (>= + (lambda (x y) + (letrec ((g7874 + (letrec ((x7876 (number? x))) + (assert x7876))) + (g7875 + (letrec ((val7152 (> x y))) + (letrec ((g7877 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7878 + (if val7153 + val7153 + #f))) + g7878))))) + g7877)))) + g7875))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7879 + (letrec ((x7882 + (string? filename))) + (assert x7882))) + (g7880 + (letrec ((x7883 (procedure? proc))) + (assert x7883))) + (g7881 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7884 + (close-input-port + input-port)) + (g7885 res)) + g7885)))) + g7881))) + (ref + (lambda (x) + (letrec ((g7886 (cons x '()))) g7886))) + (char>=? + (lambda (c1 c2) + (letrec ((g7887 + (letrec ((x7890 (char? c1))) + (assert x7890))) + (g7888 + (letrec ((x7891 (char? c2))) + (assert x7891))) + (g7889 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7892 + (if val7154 + val7154 + (char=? c1 c2)))) + g7892)))) + g7889))) + (cdaar + (lambda (x) + (letrec ((g7893 + (letrec ((x7894 + (letrec ((x7895 (car x))) + (car x7895)))) + (cdr x7894)))) + g7893))) + (cdaddr + (lambda (x) + (letrec ((g7896 + (letrec ((x7897 + (letrec ((x7898 + (letrec ((x7899 + (cdr + x))) + (cdr + x7899)))) + (car x7898)))) + (cdr x7897)))) + g7896))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7900 + (letrec ((x7901 + (letrec ((x7902 (car x))) + (cdr x7902)))) + (car x7901)))) + g7900))) + (caadr + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 (cdr x))) + (car x7905)))) + (car x7904)))) + g7903))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7906 + (letrec ((x7909 (char? c1))) + (assert x7909))) + (g7907 + (letrec ((x7910 (char? c2))) + (assert x7910))) + (g7908 + (letrec ((x7911 + (char-ci<=? c1 c2))) + (not x7911)))) + g7908))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7912 + (letrec ((x7913 + (letrec ((x7914 + (letrec ((x7915 + (car + x))) + (car + x7915)))) + (car x7914)))) + (car x7913)))) + g7912))) + (negative? + (lambda (x) + (letrec ((g7916 + (letrec ((x7918 (number? x))) + (assert x7918))) + (g7917 (< x 0))) + g7917))) + (memv + (lambda (e l) + (letrec ((g7919 (memq e l))) g7919))) + (caaar + (lambda (x) + (letrec ((g7920 + (letrec ((x7921 + (letrec ((x7922 (car x))) + (car x7922)))) + (car x7921)))) + g7920))) + (debug + (lambda (e) (letrec ((g7923 '())) g7923))) + (reverse + (lambda (l) + (letrec ((g7924 + (letrec ((x7926 (list? l))) + (assert x7926))) + (g7925 + (letrec ((x-cnd7927 (null? l))) + (if x-cnd7927 + '() + (letrec ((x7930 + (letrec ((x7931 + (cdr l))) + (reverse x7931))) + (x7928 + (letrec ((x7929 + (car l))) + (list x7929)))) + (append x7930 x7928)))))) + g7925))) + (caaadr + (lambda (x) + (letrec ((g7932 + (letrec ((x7933 + (letrec ((x7934 + (letrec ((x7935 + (cdr + x))) + (car + x7935)))) + (car x7934)))) + (car x7933)))) + g7932))) + (cddadr + (lambda (x) + (letrec ((g7936 + (letrec ((x7937 + (letrec ((x7938 + (letrec ((x7939 + (cdr + x))) + (car + x7939)))) + (cdr x7938)))) + (cdr x7937)))) + g7936))) + (odd? + (lambda (x) + (letrec ((g7940 + (letrec ((x7942 (number? x))) + (assert x7942))) + (g7941 + (letrec ((x7943 (modulo x 2))) + (= 1 x7943)))) + g7941))) + (caadar + (lambda (x) + (letrec ((g7944 + (letrec ((x7945 + (letrec ((x7946 + (letrec ((x7947 + (car + x))) + (cdr + x7947)))) + (car x7946)))) + (car x7945)))) + g7944))) + (apply + (lambda (proc args) + (letrec ((g7948 + (letrec ((x7951 (procedure? proc))) + (assert x7951))) + (g7949 + (letrec ((x7952 (list? args))) + (assert x7952))) + (g7950 + (if cnd + (letrec ((g7953 (proc))) g7953) + (if cnd + (letrec ((g7954 + (letrec ((x7955 + (car + args))) + (proc x7955)))) + g7954) + (if cnd + (letrec ((g7956 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args))) + (proc + x7958 + x7957)))) + g7956) + (if cnd + (letrec ((g7959 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args))) + (proc + x7962 + x7961 + x7960)))) + g7959) + (if cnd + (letrec ((g7963 + (letrec ((x7967 + (car + args)) + (x7966 + (cadr + args)) + (x7965 + (caddr + args)) + (x7964 + (cadddr + args))) + (proc + x7967 + x7966 + x7965 + x7964)))) + g7963) + (if cnd + (letrec ((g7968 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969)))) + g7968) + (if cnd + (letrec ((g7975 + (letrec ((x7983 + (car + args)) + (x7982 + (cadr + args)) + (x7981 + (caddr + args)) + (x7980 + (cadddr + args)) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (car + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (cadr + x7977)))) + (proc + x7983 + x7982 + x7981 + x7980 + x7978 + x7976)))) + g7975) + (if cnd + (letrec ((g7984 + (letrec ((x7994 + (car + args)) + (x7993 + (cadr + args)) + (x7992 + (caddr + args)) + (x7991 + (cadddr + args)) + (x7989 + (letrec ((x7990 + (cddddr + args))) + (car + x7990))) + (x7987 + (letrec ((x7988 + (cddddr + args))) + (cadr + x7988))) + (x7985 + (letrec ((x7986 + (cddddr + args))) + (caddr + x7986)))) + (proc + x7994 + x7993 + x7992 + x7991 + x7989 + x7987 + x7985)))) + g7984) + (letrec ((g7995 + (error + "Unsupported call."))) + g7995))))))))))) + g7950))) + (member + (lambda (e l) + (letrec ((g7996 + (letrec ((x7998 (list? l))) + (assert x7998))) + (g7997 + (letrec ((x-cnd7999 (null? l))) + (if x-cnd7999 + #f + (letrec ((x-cnd8000 + (letrec ((x8001 + (car l))) + (equal? x8001 e)))) + (if x-cnd8000 + l + (letrec ((x8002 (cdr l))) + (member e x8002)))))))) + g7997))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8003 + (letrec ((x8004 + (letrec ((x8005 + (letrec ((x8006 + (cdr + x))) + (cdr + x8006)))) + (cdr x8005)))) + (cdr x8004)))) + g8003))) + (cadddr + (lambda (x) + (letrec ((g8007 + (letrec ((x8008 + (letrec ((x8009 + (letrec ((x8010 + (cdr + x))) + (cdr + x8010)))) + (cdr x8009)))) + (car x8008)))) + g8007))) + (int-top + (lambda () + (letrec ((g8011 (random 42))) g8011))) + (zero? + (lambda (x) + (letrec ((g8012 + (letrec ((x8014 (number? x))) + (assert x8014))) + (g8013 (= x 0))) + g8013))) + (string>=? + (lambda (s1 s2) + (letrec ((g8015 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8016 + (if val7155 + val7155 + (string=? s1 s2)))) + g8016)))) + g8015))) + (cadr + (lambda (x) + (letrec ((g8017 + (letrec ((x8018 (cdr x))) + (car x8018)))) + g8017))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8019 + (letrec ((val7156 + (letrec ((x8022 + (pair? l)) + (x8020 + (letrec ((x8021 + (cdr + l))) + (list? + x8021)))) + (and x8022 x8020)))) + (letrec ((g8023 + (if val7156 + val7156 + (null? l)))) + g8023)))) + g8019))) + (cddaar + (lambda (x) + (letrec ((g8024 + (letrec ((x8025 + (letrec ((x8026 + (letrec ((x8027 + (car + x))) + (car + x8027)))) + (cdr x8026)))) + (cdr x8025)))) + g8024))) + (char-numeric? + (lambda (c) + (letrec ((g8028 + (letrec ((x-cnd8029 + (letrec ((x8030 #\0)) + (char<=? x8030 c)))) + (if x-cnd8029 + (letrec ((x8031 #\9)) + (char<=? c x8031)) + #f)))) + g8028))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (caar l))) + (eqv? x8037 k)))) + (if x-cnd8036 + (car l) + (letrec ((x8038 (cdr l))) + (assq k x8038)))))))) + g8033))) + (not + (lambda (x) + (letrec ((g8039 (if x #f #t))) g8039))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8040 (append l1 l2))) g8040))) + (memq + (lambda (e l) + (letrec ((g8041 + (letrec ((x8043 (list? l))) + (assert x8043))) + (g8042 + (letrec ((x-cnd8044 (null? l))) + (if x-cnd8044 + #f + (letrec ((x-cnd8045 + (letrec ((x8046 + (car l))) + (eq? x8046 e)))) + (if x-cnd8045 + l + (letrec ((x8047 (cdr l))) + (memq e x8047)))))))) + g8042))) + (cadaar + (lambda (x) + (letrec ((g8048 + (letrec ((x8049 + (letrec ((x8050 + (letrec ((x8051 + (car + x))) + (car + x8051)))) + (cdr x8050)))) + (car x8049)))) + g8048))) + (length + (lambda (l) + (letrec ((g8052 + (letrec ((x8054 (list? l))) + (assert x8054))) + (g8053 + (letrec ((rec + (lambda (l) + (letrec ((g8055 + (letrec ((x-cnd8056 + (null? + l))) + (if x-cnd8056 + 0 + (letrec ((x8057 + (letrec ((x8058 + (cdr + l))) + (rec + x8058)))) + (+ + 1 + x8057)))))) + g8055)))) + (letrec ((g8059 (rec l))) + g8059)))) + g8053))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8060 + (letrec ((x8063 (char? c1))) + (assert x8063))) + (g8061 + (letrec ((x8064 (char? c2))) + (assert x8064))) + (g8062 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8066 + (letrec ((x8067 (string<=? s1 s2))) + (not x8067)))) + g8066))) + (cdadr + (lambda (x) + (letrec ((g8068 + (letrec ((x8069 + (letrec ((x8070 (cdr x))) + (car x8070)))) + (cdr x8069)))) + g8068))) + (assoc + (lambda (k l) + (letrec ((g8071 + (letrec ((x8073 (list? l))) + (assert x8073))) + (g8072 + (letrec ((x-cnd8074 (null? l))) + (if x-cnd8074 + #f + (letrec ((x-cnd8075 + (letrec ((x8076 + (caar l))) + (equal? x8076 k)))) + (if x-cnd8075 + (car l) + (letrec ((x8077 (cdr l))) + (assoc k x8077)))))))) + g8072))) + (caar + (lambda (x) + (letrec ((g8078 + (letrec ((x8079 (car x))) + (car x8079)))) + g8078))) + (char>? + (lambda (c1 c2) + (letrec ((g8080 + (letrec ((x8083 (char? c1))) + (assert x8083))) + (g8081 + (letrec ((x8084 (char? c2))) + (assert x8084))) + (g8082 + (letrec ((x8085 (char<=? c1 c2))) + (not x8085)))) + g8082))) + (string<=? + (lambda (s1 s2) + (letrec ((g8086 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8103 + (letrec ((x8106 (char? c1))) + (assert x8106))) + (g8104 + (letrec ((x8107 (char? c2))) + (assert x8107))) + (g8105 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8108 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8108)))) + g8105))) + (caddar + (lambda (x) + (letrec ((g8109 + (letrec ((x8110 + (letrec ((x8111 + (letrec ((x8112 + (car + x))) + (cdr + x8112)))) + (cdr x8111)))) + (car x8110)))) + g8109))) + (newline + (lambda () (letrec ((g8113 #f)) g8113))) + (lcm + (lambda (m n) + (letrec ((g8114 + (letrec ((x8116 + (letrec ((x8117 (* m n))) + (abs x8117))) + (x8115 (gcd m n))) + (/ x8116 x8115)))) + g8114))) + (deref car) + (> + (lambda (x y) + (letrec ((g8118 + (letrec ((x8120 (number? x))) + (assert x8120))) + (g8119 + (letrec ((x8121 (<= x y))) + (not x8121)))) + g8119))) + (list-ref + (lambda (l index) + (letrec ((g8122 + (letrec ((x8126 (list? l))) + (assert x8126))) + (g8123 + (letrec ((x8127 (number? index))) + (assert x8127))) + (g8124 + (letrec ((x8128 + (letrec ((x8129 + (length l))) + (< index x8129)))) + (assert x8128))) + (g8125 + (letrec ((x-cnd8130 (= index 0))) + (if x-cnd8130 + (car l) + (letrec ((x8132 (cdr l)) + (x8131 (- index 1))) + (list-ref x8132 x8131)))))) + g8125))) + (gcd + (lambda (a b) + (letrec ((g8133 + (letrec ((x-cnd8134 (= b 0))) + (if x-cnd8134 + a + (letrec ((x8135 (modulo a b))) + (gcd b x8135)))))) + g8133)))) + (letrec ((g8136 + (letrec ((g8137 + (letrec ((foldl + (lambda (f z l) + (letrec ((g8138 + (letrec ((x-cnd8139 + (empty? + l))) + (if x-cnd8139 + z + (letrec ((x8141 + (letrec ((x8142 + (car + l))) + (f + z + x8142))) + (x8140 + (cdr + l))) + (foldl + f + x8141 + x8140)))))) + g8138))) + (randpos + (lambda (rand) + (letrec ((g8143 + (letrec ((n + (rand))) + (letrec ((g8144 + (letrec ((x-cnd8145 + (> + n + 0))) + (if x-cnd8145 + n + (randpos + rand))))) + g8144)))) + g8143))) + (mk-list + (lambda (rand n) + (letrec ((g8146 + (letrec ((x-cnd8147 + (<= + n + 0))) + (if x-cnd8147 + empty + (letrec ((x8150 + (randpos + rand)) + (x8148 + (letrec ((x8149 + (- + n + 1))) + (mk-list + rand + x8149)))) + (cons + x8150 + x8148)))))) + g8146))) + (main + (lambda (rand n m) + (letrec ((g8151 + (letrec ((x8152 + (mk-list + rand + n))) + (foldl + / + m + x8152)))) + g8151)))) + (letrec ((g8153 + (letrec ((g8154 + (letrec ((g8155 + (letrec ((x8159 + ((lambda (j7232 + k7233 + f7234) + (lambda (g7229 + g7230 + g7231) + (real?/c + j7232 + k7233 + (f7234 + ((lambda (j7235 + k7236 + f7237) + (lambda () + (integer?/c + j7235 + k7236 + (f7237)))) + j7232 + k7233 + g7229) + (integer?/c + j7232 + k7233 + g7230) + (integer?/c + j7232 + k7233 + g7231))))) + 'module + 'importer + main)) + (x8158 + (input)) + (x8157 + (input)) + (x8156 + (input))) + (x8159 + x8158 + x8157 + x8156)))) + g8155))) + g8154))) + g8153)))) + g8137))) + g8136)))) + g7249))) + g7248)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_hors.rkt b/analyses/simpleactor/benchmarks-out/mochi_hors.rkt index 75b4e8cc..5d5b5798 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_hors.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_hors.rkt @@ -1,27 +1,3125 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (c _) 'unit) - (define (b x _) (x 1)) - (define (a x y q) (if (= q 0) (begin (x 0) (y 0)) (error 'invalid))) - (define (f n x q) - (if (<= n 0) (x q) (a x (λ (p) (f (- n 1) (λ (_) (b x _)) p)) q))) - (define (s n q) (f n c q)) - (define (main n) (s n 0)) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - (any/c j3984 k3985 (f3986 (integer? j3984 k3985 g3983))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((c + (lambda (_) + (letrec ((g8133 'unit)) + g8133))) + (b + (lambda (x _) + (letrec ((g8134 (x 1))) + g8134))) + (a + (lambda (x y q) + (letrec ((g8135 + (letrec ((x-cnd8136 + (= + q + 0))) + (if x-cnd8136 + (letrec ((g8137 + (x + 0)) + (g8138 + (y + 0))) + g8138) + (error + 'invalid))))) + g8135))) + (f + (lambda (n x q) + (letrec ((g8139 + (letrec ((x-cnd8140 + (<= + n + 0))) + (if x-cnd8140 + (x q) + (letrec ((x8141 + (letrec ((x8147 + (p)) + (x8142 + (letrec ((x8146 + (- + n + 1)) + (x8143 + (letrec ((x8145 + (_)) + (x8144 + (b + x + _))) + (λ x8145 + x8144)))) + (f + x8146 + x8143 + p)))) + (λ x8147 + x8142)))) + (a + x + x8141 + q)))))) + g8139))) + (s + (lambda (n q) + (letrec ((g8148 + (f n c q))) + g8148))) + (main + (lambda (n) + (letrec ((g8149 + (s n 0))) + g8149)))) + (letrec ((g8150 + (letrec ((g8151 + (letrec ((g8152 + (letrec ((x8154 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + (any/c + j7230 + k7231 + (f7232 + (integer?/c + j7230 + k7231 + g7229))))) + 'module + 'importer + main)) + (x8153 + (input))) + (x8154 + x8153)))) + g8152))) + g8151))) + g8150)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_hrec.rkt b/analyses/simpleactor/benchmarks-out/mochi_hrec.rkt index 3352917b..9bf4d33e 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_hrec.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_hrec.rkt @@ -1,46 +1,3125 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7242 #t)) g7242))) + (meta (lambda (v) (letrec ((g7243 v)) g7243))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7244 + (letrec ((g7245 + (letrec ((x-e7246 lst)) + (match + x-e7246 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7247 (eq? v v1))) + (if x-cnd7247 #t (member v vs))))))))) + g7245))) + g7244))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (f g x) (if (>= x 0) (g x) (f (λ (x) (f g x)) (g x)))) - (define (main n) (f add1 n)) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - (integer? - j3985 - k3986 - (f3987 - ((lambda (j3989 k3990 f3991) - (lambda (g3988) - (integer? - j3989 - k3990 - (f3991 (integer? j3989 k3990 g3988))))) - j3985 - k3986 - g3983) - (integer? j3985 k3986 g3984))))) - 'module - 'importer - f) - (input) - (input)) - (((lambda (j3993 k3994 f3995) - (lambda (g3992) - ((and/c integer? (>=/c 0)) - j3993 - k3994 - (f3995 (integer? j3993 k3994 g3992))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7248 (lambda (v) (letrec ((g7249 v)) g7249)))) g7248))) + (nonzero? + (lambda (v) + (letrec ((g7250 (letrec ((x7251 (= v 0))) (not x7251)))) g7250)))) + (letrec ((g7252 + (letrec ((g7253 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7254 + (letrec ((x-cnd7255 (real? g7162))) + (if x-cnd7255 + g7162 + (blame g7160 'real?))))) + g7254))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7256 + (letrec ((x-cnd7257 + (boolean? g7165))) + (if x-cnd7257 + g7165 + (blame g7163 'boolean?))))) + g7256))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7258 + (letrec ((x-cnd7259 + (number? g7168))) + (if x-cnd7259 + g7168 + (blame g7166 'number?))))) + g7258))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7260 + (letrec ((x-cnd7261 + ((lambda (v) #t) g7171))) + (if x-cnd7261 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7260))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7262 + (letrec ((x-cnd7263 + ((lambda (v) #t) g7174))) + (if x-cnd7263 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7262))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7264 + (letrec ((x-cnd7265 (pair? g7177))) + (if x-cnd7265 + g7177 + (blame g7175 'pair?))))) + g7264))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7266 + (letrec ((x-cnd7267 (pair? g7180))) + (if x-cnd7267 + g7180 + (blame g7178 'pair?))))) + g7266))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7268 + (letrec ((x-cnd7269 + (integer? g7183))) + (if x-cnd7269 + g7183 + (blame g7181 'integer?))))) + g7268))) + (and/c + (lambda (c1 c2) + (letrec ((g7270 + (lambda (k j v) + (letrec ((g7271 + (letrec ((x-cnd7272 + (c1 k j v))) + (if x-cnd7272 + (c2 k j v) + #f)))) + g7271)))) + g7270))) + (list-of + (lambda (contract) + (letrec ((g7273 + (lambda (k j v) + (letrec ((g7274 + (letrec ((x-cnd7275 + (null? v))) + (if x-cnd7275 + '() + (letrec ((x7279 + (letrec ((x7280 + (car + v))) + (contract + k + j + x7280))) + (x7276 + (letrec ((x7278 + (list-of + contract)) + (x7277 + (cdr + v))) + (x7278 + k + j + x7277)))) + (cons + x7279 + x7276)))))) + g7274)))) + g7273))) + (any? (lambda (v) (letrec ((g7281 #t)) g7281))) + (nonzero? + (lambda (v) + (letrec ((g7282 + (letrec ((x7283 (= v 0))) + (not x7283)))) + g7282))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7284 + (letrec ((x-cnd7285 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7285 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7284))) + (meta (lambda (v) (letrec ((g7286 v)) g7286))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7287 #t)) g7287))) + (cdddr + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 + (letrec ((x7290 (cdr x))) + (cdr x7290)))) + (cdr x7289)))) + g7288))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7291 + (letrec ((x7294 (procedure? f))) + (assert x7294))) + (g7292 + (letrec ((x7295 (list? l))) + (assert x7295))) + (g7293 + (letrec ((x-cnd7296 (null? l))) + (if x-cnd7296 + '() + (letrec ((x7299 + (letrec ((x7300 + (car l))) + (f x7300))) + (x7297 + (letrec ((x7298 + (cdr l))) + (map f x7298)))) + (cons x7299 x7297)))))) + g7293))) + (cdar + (lambda (x) + (letrec ((g7301 + (letrec ((x7302 (car x))) + (cdr x7302)))) + g7301))) + (cadadr + (lambda (x) + (letrec ((g7303 + (letrec ((x7304 + (letrec ((x7305 + (letrec ((x7306 + (cdr + x))) + (car + x7306)))) + (cdr x7305)))) + (car x7304)))) + g7303))) + (cdadar + (lambda (x) + (letrec ((g7307 + (letrec ((x7308 + (letrec ((x7309 + (letrec ((x7310 + (car + x))) + (cdr + x7310)))) + (car x7309)))) + (cdr x7308)))) + g7307))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7311 + (letrec ((x7314 + (string? filename))) + (assert x7314))) + (g7312 + (letrec ((x7315 (procedure? proc))) + (assert x7315))) + (g7313 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7316 + (close-output-port + output-port)) + (g7317 res)) + g7317)))) + g7313))) + (caddr + (lambda (x) + (letrec ((g7318 + (letrec ((x7319 + (letrec ((x7320 (cdr x))) + (cdr x7320)))) + (car x7319)))) + g7318))) + (cdaadr + (lambda (x) + (letrec ((g7321 + (letrec ((x7322 + (letrec ((x7323 + (letrec ((x7324 + (cdr + x))) + (car + x7324)))) + (car x7323)))) + (cdr x7322)))) + g7321))) + (assq + (lambda (k l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + #f + (letrec ((x-cnd7329 + (letrec ((x7330 + (caar l))) + (eq? x7330 k)))) + (if x-cnd7329 + (car l) + (letrec ((x7331 (cdr l))) + (assq k x7331)))))))) + g7326))) + (even? + (lambda (x) + (letrec ((g7332 + (letrec ((x7333 (modulo x 2))) + (= 0 x7333)))) + g7332))) + (list->string + (lambda (l) + (letrec ((g7334 + (letrec ((x7336 (list? l))) + (assert x7336))) + (g7335 + (letrec ((x-cnd7337 (null? l))) + (if x-cnd7337 + "" + (letrec ((x7340 + (letrec ((x7341 + (car l))) + (char->string + x7341))) + (x7338 + (letrec ((x7339 + (cdr l))) + (list->string + x7339)))) + (string-append + x7340 + x7338)))))) + g7335))) + (char<=? + (lambda (c1 c2) + (letrec ((g7342 + (letrec ((x7345 (char? c1))) + (assert x7345))) + (g7343 + (letrec ((x7346 (char? c2))) + (assert x7346))) + (g7344 + (letrec ((val7143 (char=? c x7363)))) + (if x-cnd7362 + (letrec ((x7364 #\z)) + (char-ci<=? c x7364)) + #f)))) + g7361))) + (<= + (lambda (x y) + (letrec ((g7365 + (letrec ((x7367 (number? x))) + (assert x7367))) + (g7366 + (letrec ((val7144 (< x y))) + (letrec ((g7368 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7369 + (if val7145 + val7145 + #f))) + g7369))))) + g7368)))) + g7366))) + (char-whitespace? + (lambda (c) + (letrec ((g7370 + (letrec ((val7146 + (letrec ((x7371 + (char->integer + c))) + (= x7371 9)))) + (letrec ((g7372 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7373 + (char->integer + c))) + (= + x7373 + 10)))) + (letrec ((g7374 + (if val7147 + val7147 + (letrec ((x7375 + (char->integer + c))) + (= + x7375 + 32))))) + g7374))))) + g7372)))) + g7370))) + (cddar + (lambda (x) + (letrec ((g7376 + (letrec ((x7377 + (letrec ((x7378 (car x))) + (cdr x7378)))) + (cdr x7377)))) + g7376))) + (positive? + (lambda (x) + (letrec ((g7379 + (letrec ((x7381 (number? x))) + (assert x7381))) + (g7380 (> x 0))) + g7380))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7382 #f)) g7382))) + (cddr + (lambda (x) + (letrec ((g7383 + (letrec ((x7384 (cdr x))) + (cdr x7384)))) + g7383))) + (truncate + (lambda (x) + (letrec ((g7385 + (letrec ((x7387 (number? x))) + (assert x7387))) + (g7386 + (letrec ((x-cnd7388 (< x 0))) + (if x-cnd7388 + (ceiling x) + (floor x))))) + g7386))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7389 + (letrec ((val7148 (eq? a b))) + (letrec ((g7390 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7392 + (null? + a)) + (x7391 + (null? + b))) + (and x7392 + x7391)))) + (letrec ((g7393 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7396 + (string? + a)) + (x7395 + (string? + b)) + (x7394 + (string=? + a + b))) + (and x7396 + x7395 + x7394)))) + (letrec ((g7397 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7405 + (pair? + a)) + (x7404 + (pair? + b)) + (x7401 + (letrec ((x7403 + (car + a)) + (x7402 + (car + b))) + (equal? + x7403 + x7402))) + (x7398 + (letrec ((x7400 + (cdr + a)) + (x7399 + (cdr + b))) + (equal? + x7400 + x7399)))) + (and x7405 + x7404 + x7401 + x7398)))) + (letrec ((g7406 + (if val7151 + val7151 + (letrec ((x7425 + (vector? + a)) + (x7424 + (vector? + b)) + (x7407 + (letrec ((x7421 + (letrec ((x7422 + (letrec ((x7423 + (vector-length + a))) + (n + x7423)))) + (x7422))) + (x7408 + (letrec ((x7419 + (letrec ((x7420 + (vector-length + b))) + (= + x7420 + n))) + (x7409 + (letrec ((loop + (lambda (i) + (letrec ((g7410 + (letrec ((x7417 + (= + i + n)) + (x7411 + (letrec ((x7414 + (letrec ((x7416 + (vector-ref + a + i)) + (x7415 + (vector-ref + b + i))) + (equal? + x7416 + x7415))) + (x7412 + (letrec ((x7413 + (+ + i + 1))) + (loop + x7413)))) + (and x7414 + x7412)))) + (or x7417 + x7411)))) + g7410)))) + (letrec ((g7418 + (loop + 0))) + g7418)))) + (and x7419 + x7409)))) + (let x7421 x7408)))) + (and x7425 + x7424 + x7407))))) + g7406))))) + g7397))))) + g7393))))) + g7390)))) + g7389))) + (cdaaar + (lambda (x) + (letrec ((g7426 + (letrec ((x7427 + (letrec ((x7428 + (letrec ((x7429 + (car + x))) + (car + x7429)))) + (car x7428)))) + (cdr x7427)))) + g7426))) + (caaddr + (lambda (x) + (letrec ((g7430 + (letrec ((x7431 + (letrec ((x7432 + (letrec ((x7433 + (cdr + x))) + (cdr + x7433)))) + (car x7432)))) + (car x7431)))) + g7430))) + (eqv? + (lambda (x y) + (letrec ((g7434 (eq? x y))) g7434))) + (>= + (lambda (x y) + (letrec ((g7435 + (letrec ((x7437 (number? x))) + (assert x7437))) + (g7436 + (letrec ((val7152 (> x y))) + (letrec ((g7438 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7439 + (if val7153 + val7153 + #f))) + g7439))))) + g7438)))) + g7436))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7440 + (letrec ((x7443 + (string? filename))) + (assert x7443))) + (g7441 + (letrec ((x7444 (procedure? proc))) + (assert x7444))) + (g7442 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7445 + (close-input-port + input-port)) + (g7446 res)) + g7446)))) + g7442))) + (ref + (lambda (x) + (letrec ((g7447 (cons x '()))) g7447))) + (char>=? + (lambda (c1 c2) + (letrec ((g7448 + (letrec ((x7451 (char? c1))) + (assert x7451))) + (g7449 + (letrec ((x7452 (char? c2))) + (assert x7452))) + (g7450 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7453 + (if val7154 + val7154 + (char=? c1 c2)))) + g7453)))) + g7450))) + (cdaar + (lambda (x) + (letrec ((g7454 + (letrec ((x7455 + (letrec ((x7456 (car x))) + (car x7456)))) + (cdr x7455)))) + g7454))) + (cdaddr + (lambda (x) + (letrec ((g7457 + (letrec ((x7458 + (letrec ((x7459 + (letrec ((x7460 + (cdr + x))) + (cdr + x7460)))) + (car x7459)))) + (cdr x7458)))) + g7457))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7461 + (letrec ((x7462 + (letrec ((x7463 (car x))) + (cdr x7463)))) + (car x7462)))) + g7461))) + (caadr + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 (cdr x))) + (car x7466)))) + (car x7465)))) + g7464))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7467 + (letrec ((x7470 (char? c1))) + (assert x7470))) + (g7468 + (letrec ((x7471 (char? c2))) + (assert x7471))) + (g7469 + (letrec ((x7472 + (char-ci<=? c1 c2))) + (not x7472)))) + g7469))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7473 + (letrec ((x7474 + (letrec ((x7475 + (letrec ((x7476 + (car + x))) + (car + x7476)))) + (car x7475)))) + (car x7474)))) + g7473))) + (negative? + (lambda (x) + (letrec ((g7477 + (letrec ((x7479 (number? x))) + (assert x7479))) + (g7478 (< x 0))) + g7478))) + (memv + (lambda (e l) + (letrec ((g7480 (memq e l))) g7480))) + (caaar + (lambda (x) + (letrec ((g7481 + (letrec ((x7482 + (letrec ((x7483 (car x))) + (car x7483)))) + (car x7482)))) + g7481))) + (debug + (lambda (e) (letrec ((g7484 '())) g7484))) + (reverse + (lambda (l) + (letrec ((g7485 + (letrec ((x7487 (list? l))) + (assert x7487))) + (g7486 + (letrec ((x-cnd7488 (null? l))) + (if x-cnd7488 + '() + (letrec ((x7491 + (letrec ((x7492 + (cdr l))) + (reverse x7492))) + (x7489 + (letrec ((x7490 + (car l))) + (list x7490)))) + (append x7491 x7489)))))) + g7486))) + (caaadr + (lambda (x) + (letrec ((g7493 + (letrec ((x7494 + (letrec ((x7495 + (letrec ((x7496 + (cdr + x))) + (car + x7496)))) + (car x7495)))) + (car x7494)))) + g7493))) + (cddadr + (lambda (x) + (letrec ((g7497 + (letrec ((x7498 + (letrec ((x7499 + (letrec ((x7500 + (cdr + x))) + (car + x7500)))) + (cdr x7499)))) + (cdr x7498)))) + g7497))) + (odd? + (lambda (x) + (letrec ((g7501 + (letrec ((x7503 (number? x))) + (assert x7503))) + (g7502 + (letrec ((x7504 (modulo x 2))) + (= 1 x7504)))) + g7502))) + (caadar + (lambda (x) + (letrec ((g7505 + (letrec ((x7506 + (letrec ((x7507 + (letrec ((x7508 + (car + x))) + (cdr + x7508)))) + (car x7507)))) + (car x7506)))) + g7505))) + (apply + (lambda (proc args) + (letrec ((g7509 + (letrec ((x7512 (procedure? proc))) + (assert x7512))) + (g7510 + (letrec ((x7513 (list? args))) + (assert x7513))) + (g7511 + (if cnd + (letrec ((g7514 (proc))) g7514) + (if cnd + (letrec ((g7515 + (letrec ((x7516 + (car + args))) + (proc x7516)))) + g7515) + (if cnd + (letrec ((g7517 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args))) + (proc + x7519 + x7518)))) + g7517) + (if cnd + (letrec ((g7520 + (letrec ((x7523 + (car + args)) + (x7522 + (cadr + args)) + (x7521 + (caddr + args))) + (proc + x7523 + x7522 + x7521)))) + g7520) + (if cnd + (letrec ((g7524 + (letrec ((x7528 + (car + args)) + (x7527 + (cadr + args)) + (x7526 + (caddr + args)) + (x7525 + (cadddr + args))) + (proc + x7528 + x7527 + x7526 + x7525)))) + g7524) + (if cnd + (letrec ((g7529 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530)))) + g7529) + (if cnd + (letrec ((g7536 + (letrec ((x7544 + (car + args)) + (x7543 + (cadr + args)) + (x7542 + (caddr + args)) + (x7541 + (cadddr + args)) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (car + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (cadr + x7538)))) + (proc + x7544 + x7543 + x7542 + x7541 + x7539 + x7537)))) + g7536) + (if cnd + (letrec ((g7545 + (letrec ((x7555 + (car + args)) + (x7554 + (cadr + args)) + (x7553 + (caddr + args)) + (x7552 + (cadddr + args)) + (x7550 + (letrec ((x7551 + (cddddr + args))) + (car + x7551))) + (x7548 + (letrec ((x7549 + (cddddr + args))) + (cadr + x7549))) + (x7546 + (letrec ((x7547 + (cddddr + args))) + (caddr + x7547)))) + (proc + x7555 + x7554 + x7553 + x7552 + x7550 + x7548 + x7546)))) + g7545) + (letrec ((g7556 + (error + "Unsupported call."))) + g7556))))))))))) + g7511))) + (member + (lambda (e l) + (letrec ((g7557 + (letrec ((x7559 (list? l))) + (assert x7559))) + (g7558 + (letrec ((x-cnd7560 (null? l))) + (if x-cnd7560 + #f + (letrec ((x-cnd7561 + (letrec ((x7562 + (car l))) + (equal? x7562 e)))) + (if x-cnd7561 + l + (letrec ((x7563 (cdr l))) + (member e x7563)))))))) + g7558))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7564 + (letrec ((x7565 + (letrec ((x7566 + (letrec ((x7567 + (cdr + x))) + (cdr + x7567)))) + (cdr x7566)))) + (cdr x7565)))) + g7564))) + (cadddr + (lambda (x) + (letrec ((g7568 + (letrec ((x7569 + (letrec ((x7570 + (letrec ((x7571 + (cdr + x))) + (cdr + x7571)))) + (cdr x7570)))) + (car x7569)))) + g7568))) + (int-top + (lambda () + (letrec ((g7572 (random 42))) g7572))) + (zero? + (lambda (x) + (letrec ((g7573 + (letrec ((x7575 (number? x))) + (assert x7575))) + (g7574 (= x 0))) + g7574))) + (string>=? + (lambda (s1 s2) + (letrec ((g7576 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7577 + (if val7155 + val7155 + (string=? s1 s2)))) + g7577)))) + g7576))) + (cadr + (lambda (x) + (letrec ((g7578 + (letrec ((x7579 (cdr x))) + (car x7579)))) + g7578))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7580 + (letrec ((val7156 + (letrec ((x7583 + (pair? l)) + (x7581 + (letrec ((x7582 + (cdr + l))) + (list? + x7582)))) + (and x7583 x7581)))) + (letrec ((g7584 + (if val7156 + val7156 + (null? l)))) + g7584)))) + g7580))) + (cddaar + (lambda (x) + (letrec ((g7585 + (letrec ((x7586 + (letrec ((x7587 + (letrec ((x7588 + (car + x))) + (car + x7588)))) + (cdr x7587)))) + (cdr x7586)))) + g7585))) + (char-numeric? + (lambda (c) + (letrec ((g7589 + (letrec ((x-cnd7590 + (letrec ((x7591 #\0)) + (char<=? x7591 c)))) + (if x-cnd7590 + (letrec ((x7592 #\9)) + (char<=? c x7592)) + #f)))) + g7589))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (caar l))) + (eqv? x7598 k)))) + (if x-cnd7597 + (car l) + (letrec ((x7599 (cdr l))) + (assq k x7599)))))))) + g7594))) + (not + (lambda (x) + (letrec ((g7600 (if x #f #t))) g7600))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7601 (append l1 l2))) g7601))) + (memq + (lambda (e l) + (letrec ((g7602 + (letrec ((x7604 (list? l))) + (assert x7604))) + (g7603 + (letrec ((x-cnd7605 (null? l))) + (if x-cnd7605 + #f + (letrec ((x-cnd7606 + (letrec ((x7607 + (car l))) + (eq? x7607 e)))) + (if x-cnd7606 + l + (letrec ((x7608 (cdr l))) + (memq e x7608)))))))) + g7603))) + (cadaar + (lambda (x) + (letrec ((g7609 + (letrec ((x7610 + (letrec ((x7611 + (letrec ((x7612 + (car + x))) + (car + x7612)))) + (cdr x7611)))) + (car x7610)))) + g7609))) + (length + (lambda (l) + (letrec ((g7613 + (letrec ((x7615 (list? l))) + (assert x7615))) + (g7614 + (letrec ((rec + (lambda (l) + (letrec ((g7616 + (letrec ((x-cnd7617 + (null? + l))) + (if x-cnd7617 + 0 + (letrec ((x7618 + (letrec ((x7619 + (cdr + l))) + (rec + x7619)))) + (+ + 1 + x7618)))))) + g7616)))) + (letrec ((g7620 (rec l))) + g7620)))) + g7614))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7621 + (letrec ((x7624 (char? c1))) + (assert x7624))) + (g7622 + (letrec ((x7625 (char? c2))) + (assert x7625))) + (g7623 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7627 + (letrec ((x7628 (string<=? s1 s2))) + (not x7628)))) + g7627))) + (cdadr + (lambda (x) + (letrec ((g7629 + (letrec ((x7630 + (letrec ((x7631 (cdr x))) + (car x7631)))) + (cdr x7630)))) + g7629))) + (assoc + (lambda (k l) + (letrec ((g7632 + (letrec ((x7634 (list? l))) + (assert x7634))) + (g7633 + (letrec ((x-cnd7635 (null? l))) + (if x-cnd7635 + #f + (letrec ((x-cnd7636 + (letrec ((x7637 + (caar l))) + (equal? x7637 k)))) + (if x-cnd7636 + (car l) + (letrec ((x7638 (cdr l))) + (assoc k x7638)))))))) + g7633))) + (caar + (lambda (x) + (letrec ((g7639 + (letrec ((x7640 (car x))) + (car x7640)))) + g7639))) + (char>? + (lambda (c1 c2) + (letrec ((g7641 + (letrec ((x7644 (char? c1))) + (assert x7644))) + (g7642 + (letrec ((x7645 (char? c2))) + (assert x7645))) + (g7643 + (letrec ((x7646 (char<=? c1 c2))) + (not x7646)))) + g7643))) + (string<=? + (lambda (s1 s2) + (letrec ((g7647 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7664 + (letrec ((x7667 (char? c1))) + (assert x7667))) + (g7665 + (letrec ((x7668 (char? c2))) + (assert x7668))) + (g7666 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7669 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7669)))) + g7666))) + (caddar + (lambda (x) + (letrec ((g7670 + (letrec ((x7671 + (letrec ((x7672 + (letrec ((x7673 + (car + x))) + (cdr + x7673)))) + (cdr x7672)))) + (car x7671)))) + g7670))) + (newline + (lambda () (letrec ((g7674 #f)) g7674))) + (lcm + (lambda (m n) + (letrec ((g7675 + (letrec ((x7677 + (letrec ((x7678 (* m n))) + (abs x7678))) + (x7676 (gcd m n))) + (/ x7677 x7676)))) + g7675))) + (deref car) + (> + (lambda (x y) + (letrec ((g7679 + (letrec ((x7681 (number? x))) + (assert x7681))) + (g7680 + (letrec ((x7682 (<= x y))) + (not x7682)))) + g7680))) + (list-ref + (lambda (l index) + (letrec ((g7683 + (letrec ((x7687 (list? l))) + (assert x7687))) + (g7684 + (letrec ((x7688 (number? index))) + (assert x7688))) + (g7685 + (letrec ((x7689 + (letrec ((x7690 + (length l))) + (< index x7690)))) + (assert x7689))) + (g7686 + (letrec ((x-cnd7691 (= index 0))) + (if x-cnd7691 + (car l) + (letrec ((x7693 (cdr l)) + (x7692 (- index 1))) + (list-ref x7693 x7692)))))) + g7686))) + (gcd + (lambda (a b) + (letrec ((g7694 + (letrec ((x-cnd7695 (= b 0))) + (if x-cnd7695 + a + (letrec ((x7696 (modulo a b))) + (gcd b x7696)))))) + g7694))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7697 + (letrec ((x-cnd7698 (real? g7162))) + (if x-cnd7698 + g7162 + (blame g7160 'real?))))) + g7697))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7699 + (letrec ((x-cnd7700 + (boolean? g7165))) + (if x-cnd7700 + g7165 + (blame g7163 'boolean?))))) + g7699))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7701 + (letrec ((x-cnd7702 + (number? g7168))) + (if x-cnd7702 + g7168 + (blame g7166 'number?))))) + g7701))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7703 + (letrec ((x-cnd7704 + ((lambda (v) #t) g7171))) + (if x-cnd7704 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7703))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7705 + (letrec ((x-cnd7706 + ((lambda (v) #t) g7174))) + (if x-cnd7706 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7705))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7707 + (letrec ((x-cnd7708 (pair? g7177))) + (if x-cnd7708 + g7177 + (blame g7175 'pair?))))) + g7707))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7709 + (letrec ((x-cnd7710 (pair? g7180))) + (if x-cnd7710 + g7180 + (blame g7178 'pair?))))) + g7709))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7711 + (letrec ((x-cnd7712 + (integer? g7183))) + (if x-cnd7712 + g7183 + (blame g7181 'integer?))))) + g7711))) + (and/c + (lambda (c1 c2) + (letrec ((g7713 + (lambda (k j v) + (letrec ((g7714 + (letrec ((x-cnd7715 + (c1 k j v))) + (if x-cnd7715 + (c2 k j v) + #f)))) + g7714)))) + g7713))) + (list-of + (lambda (contract) + (letrec ((g7716 + (lambda (k j v) + (letrec ((g7717 + (letrec ((x-cnd7718 + (null? v))) + (if x-cnd7718 + '() + (letrec ((x7722 + (letrec ((x7723 + (car + v))) + (contract + k + j + x7723))) + (x7719 + (letrec ((x7721 + (list-of + contract)) + (x7720 + (cdr + v))) + (x7721 + k + j + x7720)))) + (cons + x7722 + x7719)))))) + g7717)))) + g7716))) + (any? (lambda (v) (letrec ((g7724 #t)) g7724))) + (nonzero? + (lambda (v) + (letrec ((g7725 + (letrec ((x7726 (= v 0))) + (not x7726)))) + g7725))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7727 + (letrec ((x-cnd7728 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7728 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7727))) + (meta (lambda (v) (letrec ((g7729 v)) g7729))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7730 #t)) g7730))) + (cdddr + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 + (letrec ((x7733 (cdr x))) + (cdr x7733)))) + (cdr x7732)))) + g7731))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7734 + (letrec ((x7737 (procedure? f))) + (assert x7737))) + (g7735 + (letrec ((x7738 (list? l))) + (assert x7738))) + (g7736 + (letrec ((x-cnd7739 (null? l))) + (if x-cnd7739 + '() + (letrec ((x7742 + (letrec ((x7743 + (car l))) + (f x7743))) + (x7740 + (letrec ((x7741 + (cdr l))) + (map f x7741)))) + (cons x7742 x7740)))))) + g7736))) + (cdar + (lambda (x) + (letrec ((g7744 + (letrec ((x7745 (car x))) + (cdr x7745)))) + g7744))) + (cadadr + (lambda (x) + (letrec ((g7746 + (letrec ((x7747 + (letrec ((x7748 + (letrec ((x7749 + (cdr + x))) + (car + x7749)))) + (cdr x7748)))) + (car x7747)))) + g7746))) + (cdadar + (lambda (x) + (letrec ((g7750 + (letrec ((x7751 + (letrec ((x7752 + (letrec ((x7753 + (car + x))) + (cdr + x7753)))) + (car x7752)))) + (cdr x7751)))) + g7750))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7754 + (letrec ((x7757 + (string? filename))) + (assert x7757))) + (g7755 + (letrec ((x7758 (procedure? proc))) + (assert x7758))) + (g7756 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7759 + (close-output-port + output-port)) + (g7760 res)) + g7760)))) + g7756))) + (caddr + (lambda (x) + (letrec ((g7761 + (letrec ((x7762 + (letrec ((x7763 (cdr x))) + (cdr x7763)))) + (car x7762)))) + g7761))) + (cdaadr + (lambda (x) + (letrec ((g7764 + (letrec ((x7765 + (letrec ((x7766 + (letrec ((x7767 + (cdr + x))) + (car + x7767)))) + (car x7766)))) + (cdr x7765)))) + g7764))) + (assq + (lambda (k l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + #f + (letrec ((x-cnd7772 + (letrec ((x7773 + (caar l))) + (eq? x7773 k)))) + (if x-cnd7772 + (car l) + (letrec ((x7774 (cdr l))) + (assq k x7774)))))))) + g7769))) + (even? + (lambda (x) + (letrec ((g7775 + (letrec ((x7776 (modulo x 2))) + (= 0 x7776)))) + g7775))) + (list->string + (lambda (l) + (letrec ((g7777 + (letrec ((x7779 (list? l))) + (assert x7779))) + (g7778 + (letrec ((x-cnd7780 (null? l))) + (if x-cnd7780 + "" + (letrec ((x7783 + (letrec ((x7784 + (car l))) + (char->string + x7784))) + (x7781 + (letrec ((x7782 + (cdr l))) + (list->string + x7782)))) + (string-append + x7783 + x7781)))))) + g7778))) + (char<=? + (lambda (c1 c2) + (letrec ((g7785 + (letrec ((x7788 (char? c1))) + (assert x7788))) + (g7786 + (letrec ((x7789 (char? c2))) + (assert x7789))) + (g7787 + (letrec ((val7143 (char=? c x7806)))) + (if x-cnd7805 + (letrec ((x7807 #\z)) + (char-ci<=? c x7807)) + #f)))) + g7804))) + (<= + (lambda (x y) + (letrec ((g7808 + (letrec ((x7810 (number? x))) + (assert x7810))) + (g7809 + (letrec ((val7144 (< x y))) + (letrec ((g7811 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7812 + (if val7145 + val7145 + #f))) + g7812))))) + g7811)))) + g7809))) + (char-whitespace? + (lambda (c) + (letrec ((g7813 + (letrec ((val7146 + (letrec ((x7814 + (char->integer + c))) + (= x7814 9)))) + (letrec ((g7815 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7816 + (char->integer + c))) + (= + x7816 + 10)))) + (letrec ((g7817 + (if val7147 + val7147 + (letrec ((x7818 + (char->integer + c))) + (= + x7818 + 32))))) + g7817))))) + g7815)))) + g7813))) + (cddar + (lambda (x) + (letrec ((g7819 + (letrec ((x7820 + (letrec ((x7821 (car x))) + (cdr x7821)))) + (cdr x7820)))) + g7819))) + (positive? + (lambda (x) + (letrec ((g7822 + (letrec ((x7824 (number? x))) + (assert x7824))) + (g7823 (> x 0))) + g7823))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7825 #f)) g7825))) + (cddr + (lambda (x) + (letrec ((g7826 + (letrec ((x7827 (cdr x))) + (cdr x7827)))) + g7826))) + (truncate + (lambda (x) + (letrec ((g7828 + (letrec ((x7830 (number? x))) + (assert x7830))) + (g7829 + (letrec ((x-cnd7831 (< x 0))) + (if x-cnd7831 + (ceiling x) + (floor x))))) + g7829))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7832 + (letrec ((val7148 (eq? a b))) + (letrec ((g7833 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7835 + (null? + a)) + (x7834 + (null? + b))) + (and x7835 + x7834)))) + (letrec ((g7836 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7839 + (string? + a)) + (x7838 + (string? + b)) + (x7837 + (string=? + a + b))) + (and x7839 + x7838 + x7837)))) + (letrec ((g7840 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7848 + (pair? + a)) + (x7847 + (pair? + b)) + (x7844 + (letrec ((x7846 + (car + a)) + (x7845 + (car + b))) + (equal? + x7846 + x7845))) + (x7841 + (letrec ((x7843 + (cdr + a)) + (x7842 + (cdr + b))) + (equal? + x7843 + x7842)))) + (and x7848 + x7847 + x7844 + x7841)))) + (letrec ((g7849 + (if val7151 + val7151 + (letrec ((x7868 + (vector? + a)) + (x7867 + (vector? + b)) + (x7850 + (letrec ((x7864 + (letrec ((x7865 + (letrec ((x7866 + (vector-length + a))) + (n + x7866)))) + (x7865))) + (x7851 + (letrec ((x7862 + (letrec ((x7863 + (vector-length + b))) + (= + x7863 + n))) + (x7852 + (letrec ((loop + (lambda (i) + (letrec ((g7853 + (letrec ((x7860 + (= + i + n)) + (x7854 + (letrec ((x7857 + (letrec ((x7859 + (vector-ref + a + i)) + (x7858 + (vector-ref + b + i))) + (equal? + x7859 + x7858))) + (x7855 + (letrec ((x7856 + (+ + i + 1))) + (loop + x7856)))) + (and x7857 + x7855)))) + (or x7860 + x7854)))) + g7853)))) + (letrec ((g7861 + (loop + 0))) + g7861)))) + (and x7862 + x7852)))) + (let x7864 x7851)))) + (and x7868 + x7867 + x7850))))) + g7849))))) + g7840))))) + g7836))))) + g7833)))) + g7832))) + (cdaaar + (lambda (x) + (letrec ((g7869 + (letrec ((x7870 + (letrec ((x7871 + (letrec ((x7872 + (car + x))) + (car + x7872)))) + (car x7871)))) + (cdr x7870)))) + g7869))) + (caaddr + (lambda (x) + (letrec ((g7873 + (letrec ((x7874 + (letrec ((x7875 + (letrec ((x7876 + (cdr + x))) + (cdr + x7876)))) + (car x7875)))) + (car x7874)))) + g7873))) + (eqv? + (lambda (x y) + (letrec ((g7877 (eq? x y))) g7877))) + (>= + (lambda (x y) + (letrec ((g7878 + (letrec ((x7880 (number? x))) + (assert x7880))) + (g7879 + (letrec ((val7152 (> x y))) + (letrec ((g7881 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7882 + (if val7153 + val7153 + #f))) + g7882))))) + g7881)))) + g7879))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7883 + (letrec ((x7886 + (string? filename))) + (assert x7886))) + (g7884 + (letrec ((x7887 (procedure? proc))) + (assert x7887))) + (g7885 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7888 + (close-input-port + input-port)) + (g7889 res)) + g7889)))) + g7885))) + (ref + (lambda (x) + (letrec ((g7890 (cons x '()))) g7890))) + (char>=? + (lambda (c1 c2) + (letrec ((g7891 + (letrec ((x7894 (char? c1))) + (assert x7894))) + (g7892 + (letrec ((x7895 (char? c2))) + (assert x7895))) + (g7893 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7896 + (if val7154 + val7154 + (char=? c1 c2)))) + g7896)))) + g7893))) + (cdaar + (lambda (x) + (letrec ((g7897 + (letrec ((x7898 + (letrec ((x7899 (car x))) + (car x7899)))) + (cdr x7898)))) + g7897))) + (cdaddr + (lambda (x) + (letrec ((g7900 + (letrec ((x7901 + (letrec ((x7902 + (letrec ((x7903 + (cdr + x))) + (cdr + x7903)))) + (car x7902)))) + (cdr x7901)))) + g7900))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7904 + (letrec ((x7905 + (letrec ((x7906 (car x))) + (cdr x7906)))) + (car x7905)))) + g7904))) + (caadr + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 (cdr x))) + (car x7909)))) + (car x7908)))) + g7907))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7910 + (letrec ((x7913 (char? c1))) + (assert x7913))) + (g7911 + (letrec ((x7914 (char? c2))) + (assert x7914))) + (g7912 + (letrec ((x7915 + (char-ci<=? c1 c2))) + (not x7915)))) + g7912))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7916 + (letrec ((x7917 + (letrec ((x7918 + (letrec ((x7919 + (car + x))) + (car + x7919)))) + (car x7918)))) + (car x7917)))) + g7916))) + (negative? + (lambda (x) + (letrec ((g7920 + (letrec ((x7922 (number? x))) + (assert x7922))) + (g7921 (< x 0))) + g7921))) + (memv + (lambda (e l) + (letrec ((g7923 (memq e l))) g7923))) + (caaar + (lambda (x) + (letrec ((g7924 + (letrec ((x7925 + (letrec ((x7926 (car x))) + (car x7926)))) + (car x7925)))) + g7924))) + (debug + (lambda (e) (letrec ((g7927 '())) g7927))) + (reverse + (lambda (l) + (letrec ((g7928 + (letrec ((x7930 (list? l))) + (assert x7930))) + (g7929 + (letrec ((x-cnd7931 (null? l))) + (if x-cnd7931 + '() + (letrec ((x7934 + (letrec ((x7935 + (cdr l))) + (reverse x7935))) + (x7932 + (letrec ((x7933 + (car l))) + (list x7933)))) + (append x7934 x7932)))))) + g7929))) + (caaadr + (lambda (x) + (letrec ((g7936 + (letrec ((x7937 + (letrec ((x7938 + (letrec ((x7939 + (cdr + x))) + (car + x7939)))) + (car x7938)))) + (car x7937)))) + g7936))) + (cddadr + (lambda (x) + (letrec ((g7940 + (letrec ((x7941 + (letrec ((x7942 + (letrec ((x7943 + (cdr + x))) + (car + x7943)))) + (cdr x7942)))) + (cdr x7941)))) + g7940))) + (odd? + (lambda (x) + (letrec ((g7944 + (letrec ((x7946 (number? x))) + (assert x7946))) + (g7945 + (letrec ((x7947 (modulo x 2))) + (= 1 x7947)))) + g7945))) + (caadar + (lambda (x) + (letrec ((g7948 + (letrec ((x7949 + (letrec ((x7950 + (letrec ((x7951 + (car + x))) + (cdr + x7951)))) + (car x7950)))) + (car x7949)))) + g7948))) + (apply + (lambda (proc args) + (letrec ((g7952 + (letrec ((x7955 (procedure? proc))) + (assert x7955))) + (g7953 + (letrec ((x7956 (list? args))) + (assert x7956))) + (g7954 + (if cnd + (letrec ((g7957 (proc))) g7957) + (if cnd + (letrec ((g7958 + (letrec ((x7959 + (car + args))) + (proc x7959)))) + g7958) + (if cnd + (letrec ((g7960 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args))) + (proc + x7962 + x7961)))) + g7960) + (if cnd + (letrec ((g7963 + (letrec ((x7966 + (car + args)) + (x7965 + (cadr + args)) + (x7964 + (caddr + args))) + (proc + x7966 + x7965 + x7964)))) + g7963) + (if cnd + (letrec ((g7967 + (letrec ((x7971 + (car + args)) + (x7970 + (cadr + args)) + (x7969 + (caddr + args)) + (x7968 + (cadddr + args))) + (proc + x7971 + x7970 + x7969 + x7968)))) + g7967) + (if cnd + (letrec ((g7972 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973)))) + g7972) + (if cnd + (letrec ((g7979 + (letrec ((x7987 + (car + args)) + (x7986 + (cadr + args)) + (x7985 + (caddr + args)) + (x7984 + (cadddr + args)) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (car + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (cadr + x7981)))) + (proc + x7987 + x7986 + x7985 + x7984 + x7982 + x7980)))) + g7979) + (if cnd + (letrec ((g7988 + (letrec ((x7998 + (car + args)) + (x7997 + (cadr + args)) + (x7996 + (caddr + args)) + (x7995 + (cadddr + args)) + (x7993 + (letrec ((x7994 + (cddddr + args))) + (car + x7994))) + (x7991 + (letrec ((x7992 + (cddddr + args))) + (cadr + x7992))) + (x7989 + (letrec ((x7990 + (cddddr + args))) + (caddr + x7990)))) + (proc + x7998 + x7997 + x7996 + x7995 + x7993 + x7991 + x7989)))) + g7988) + (letrec ((g7999 + (error + "Unsupported call."))) + g7999))))))))))) + g7954))) + (member + (lambda (e l) + (letrec ((g8000 + (letrec ((x8002 (list? l))) + (assert x8002))) + (g8001 + (letrec ((x-cnd8003 (null? l))) + (if x-cnd8003 + #f + (letrec ((x-cnd8004 + (letrec ((x8005 + (car l))) + (equal? x8005 e)))) + (if x-cnd8004 + l + (letrec ((x8006 (cdr l))) + (member e x8006)))))))) + g8001))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8007 + (letrec ((x8008 + (letrec ((x8009 + (letrec ((x8010 + (cdr + x))) + (cdr + x8010)))) + (cdr x8009)))) + (cdr x8008)))) + g8007))) + (cadddr + (lambda (x) + (letrec ((g8011 + (letrec ((x8012 + (letrec ((x8013 + (letrec ((x8014 + (cdr + x))) + (cdr + x8014)))) + (cdr x8013)))) + (car x8012)))) + g8011))) + (int-top + (lambda () + (letrec ((g8015 (random 42))) g8015))) + (zero? + (lambda (x) + (letrec ((g8016 + (letrec ((x8018 (number? x))) + (assert x8018))) + (g8017 (= x 0))) + g8017))) + (string>=? + (lambda (s1 s2) + (letrec ((g8019 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8020 + (if val7155 + val7155 + (string=? s1 s2)))) + g8020)))) + g8019))) + (cadr + (lambda (x) + (letrec ((g8021 + (letrec ((x8022 (cdr x))) + (car x8022)))) + g8021))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8023 + (letrec ((val7156 + (letrec ((x8026 + (pair? l)) + (x8024 + (letrec ((x8025 + (cdr + l))) + (list? + x8025)))) + (and x8026 x8024)))) + (letrec ((g8027 + (if val7156 + val7156 + (null? l)))) + g8027)))) + g8023))) + (cddaar + (lambda (x) + (letrec ((g8028 + (letrec ((x8029 + (letrec ((x8030 + (letrec ((x8031 + (car + x))) + (car + x8031)))) + (cdr x8030)))) + (cdr x8029)))) + g8028))) + (char-numeric? + (lambda (c) + (letrec ((g8032 + (letrec ((x-cnd8033 + (letrec ((x8034 #\0)) + (char<=? x8034 c)))) + (if x-cnd8033 + (letrec ((x8035 #\9)) + (char<=? c x8035)) + #f)))) + g8032))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (caar l))) + (eqv? x8041 k)))) + (if x-cnd8040 + (car l) + (letrec ((x8042 (cdr l))) + (assq k x8042)))))))) + g8037))) + (not + (lambda (x) + (letrec ((g8043 (if x #f #t))) g8043))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8044 (append l1 l2))) g8044))) + (memq + (lambda (e l) + (letrec ((g8045 + (letrec ((x8047 (list? l))) + (assert x8047))) + (g8046 + (letrec ((x-cnd8048 (null? l))) + (if x-cnd8048 + #f + (letrec ((x-cnd8049 + (letrec ((x8050 + (car l))) + (eq? x8050 e)))) + (if x-cnd8049 + l + (letrec ((x8051 (cdr l))) + (memq e x8051)))))))) + g8046))) + (cadaar + (lambda (x) + (letrec ((g8052 + (letrec ((x8053 + (letrec ((x8054 + (letrec ((x8055 + (car + x))) + (car + x8055)))) + (cdr x8054)))) + (car x8053)))) + g8052))) + (length + (lambda (l) + (letrec ((g8056 + (letrec ((x8058 (list? l))) + (assert x8058))) + (g8057 + (letrec ((rec + (lambda (l) + (letrec ((g8059 + (letrec ((x-cnd8060 + (null? + l))) + (if x-cnd8060 + 0 + (letrec ((x8061 + (letrec ((x8062 + (cdr + l))) + (rec + x8062)))) + (+ + 1 + x8061)))))) + g8059)))) + (letrec ((g8063 (rec l))) + g8063)))) + g8057))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8064 + (letrec ((x8067 (char? c1))) + (assert x8067))) + (g8065 + (letrec ((x8068 (char? c2))) + (assert x8068))) + (g8066 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8070 + (letrec ((x8071 (string<=? s1 s2))) + (not x8071)))) + g8070))) + (cdadr + (lambda (x) + (letrec ((g8072 + (letrec ((x8073 + (letrec ((x8074 (cdr x))) + (car x8074)))) + (cdr x8073)))) + g8072))) + (assoc + (lambda (k l) + (letrec ((g8075 + (letrec ((x8077 (list? l))) + (assert x8077))) + (g8076 + (letrec ((x-cnd8078 (null? l))) + (if x-cnd8078 + #f + (letrec ((x-cnd8079 + (letrec ((x8080 + (caar l))) + (equal? x8080 k)))) + (if x-cnd8079 + (car l) + (letrec ((x8081 (cdr l))) + (assoc k x8081)))))))) + g8076))) + (caar + (lambda (x) + (letrec ((g8082 + (letrec ((x8083 (car x))) + (car x8083)))) + g8082))) + (char>? + (lambda (c1 c2) + (letrec ((g8084 + (letrec ((x8087 (char? c1))) + (assert x8087))) + (g8085 + (letrec ((x8088 (char? c2))) + (assert x8088))) + (g8086 + (letrec ((x8089 (char<=? c1 c2))) + (not x8089)))) + g8086))) + (string<=? + (lambda (s1 s2) + (letrec ((g8090 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8107 + (letrec ((x8110 (char? c1))) + (assert x8110))) + (g8108 + (letrec ((x8111 (char? c2))) + (assert x8111))) + (g8109 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8112 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8112)))) + g8109))) + (caddar + (lambda (x) + (letrec ((g8113 + (letrec ((x8114 + (letrec ((x8115 + (letrec ((x8116 + (car + x))) + (cdr + x8116)))) + (cdr x8115)))) + (car x8114)))) + g8113))) + (newline + (lambda () (letrec ((g8117 #f)) g8117))) + (lcm + (lambda (m n) + (letrec ((g8118 + (letrec ((x8120 + (letrec ((x8121 (* m n))) + (abs x8121))) + (x8119 (gcd m n))) + (/ x8120 x8119)))) + g8118))) + (deref car) + (> + (lambda (x y) + (letrec ((g8122 + (letrec ((x8124 (number? x))) + (assert x8124))) + (g8123 + (letrec ((x8125 (<= x y))) + (not x8125)))) + g8123))) + (list-ref + (lambda (l index) + (letrec ((g8126 + (letrec ((x8130 (list? l))) + (assert x8130))) + (g8127 + (letrec ((x8131 (number? index))) + (assert x8131))) + (g8128 + (letrec ((x8132 + (letrec ((x8133 + (length l))) + (< index x8133)))) + (assert x8132))) + (g8129 + (letrec ((x-cnd8134 (= index 0))) + (if x-cnd8134 + (car l) + (letrec ((x8136 (cdr l)) + (x8135 (- index 1))) + (list-ref x8136 x8135)))))) + g8129))) + (gcd + (lambda (a b) + (letrec ((g8137 + (letrec ((x-cnd8138 (= b 0))) + (if x-cnd8138 + a + (letrec ((x8139 (modulo a b))) + (gcd b x8139)))))) + g8137)))) + (letrec ((g8140 + (letrec ((g8141 + (letrec ((f + (lambda (g x) + (letrec ((g8142 + (letrec ((x-cnd8143 + (>= + x + 0))) + (if x-cnd8143 + (g x) + (letrec ((x8145 + (letrec ((x8147 + (x)) + (x8146 + (f + g + x))) + (λ x8147 + x8146))) + (x8144 + (g + x))) + (f + x8145 + x8144)))))) + g8142))) + (main + (lambda (n) + (letrec ((g8148 + (f add1 n))) + g8148)))) + (letrec ((g8149 + (letrec ((g8150 + (letrec ((g8151 + (letrec ((x8155 + ((lambda (j7231 + k7232 + f7233) + (lambda (g7229 + g7230) + (integer? + j7231 + k7232 + (f7233 + ((lambda (j7235 + k7236 + f7237) + (lambda (g7234) + (integer? + j7235 + k7236 + (f7237 + (integer? + j7235 + k7236 + g7234))))) + j7231 + k7232 + g7229) + (integer? + j7231 + k7232 + g7230))))) + 'module + 'importer + f)) + (x8154 + (input)) + (x8153 + (input))) + (x8155 + x8154 + x8153))) + (g8152 + (letrec ((x8157 + ((lambda (j7239 + k7240 + f7241) + (lambda (g7238) + ((and/c + integer? + (>=/c + 0)) + j7239 + k7240 + (f7241 + (integer? + j7239 + k7240 + g7238))))) + 'module + 'importer + main)) + (x8156 + (input))) + (x8157 + x8156)))) + g8152))) + g8150))) + g8149)))) + g8141))) + g8140)))) + g7253))) + g7252)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_l-zipunzip.rkt b/analyses/simpleactor/benchmarks-out/mochi_l-zipunzip.rkt index 7bd8c308..3294a50e 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_l-zipunzip.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_l-zipunzip.rkt @@ -1,55 +1,3190 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7247 #t)) g7247))) + (meta (lambda (v) (letrec ((g7248 v)) g7248))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7249 + (letrec ((g7250 + (letrec ((x-e7251 lst)) + (match + x-e7251 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7252 (eq? v v1))) + (if x-cnd7252 #t (member v vs))))))))) + g7250))) + g7249))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (f g) (λ (x y) (g (+ x 1) (+ y 1)))) - (define (unzip x k) (if (= x 0) (k 0 0) (unzip (- x 1) (f k)))) - (define (zip x y) - (if (= x 0) - (if (= y 0) 0 'fail) - (if (= y 0) 'fail (+ 1 (zip (- x 1) (- y 1)))))) - (define (main n) (unzip n zip)) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((lambda (j3989 k3990 f3991) - (lambda (g3987 g3988) - (integer? - j3989 - k3990 - (f3991 - (integer? j3989 k3990 g3987) - (integer? j3989 k3990 g3988))))) - j3984 - k3985 - (f3986 - ((lambda (j3994 k3995 f3996) - (lambda (g3992 g3993) - (integer? - j3994 - k3995 - (f3996 - (integer? j3994 k3995 g3992) - (integer? j3994 k3995 g3993))))) - j3984 - k3985 - g3983))))) - 'module - 'importer - f) - (input)) - (((lambda (j3998 k3999 f4000) - (lambda (g3997) - (integer? j3998 k3999 (f4000 (integer? j3998 k3999 g3997))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7253 (lambda (v) (letrec ((g7254 v)) g7254)))) g7253))) + (nonzero? + (lambda (v) + (letrec ((g7255 (letrec ((x7256 (= v 0))) (not x7256)))) g7255)))) + (letrec ((g7257 + (letrec ((g7258 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7259 + (letrec ((x-cnd7260 (real? g7162))) + (if x-cnd7260 + g7162 + (blame g7160 'real?))))) + g7259))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7261 + (letrec ((x-cnd7262 + (boolean? g7165))) + (if x-cnd7262 + g7165 + (blame g7163 'boolean?))))) + g7261))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7263 + (letrec ((x-cnd7264 + (number? g7168))) + (if x-cnd7264 + g7168 + (blame g7166 'number?))))) + g7263))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7265 + (letrec ((x-cnd7266 + ((lambda (v) #t) g7171))) + (if x-cnd7266 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7265))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7267 + (letrec ((x-cnd7268 + ((lambda (v) #t) g7174))) + (if x-cnd7268 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7267))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7269 + (letrec ((x-cnd7270 (pair? g7177))) + (if x-cnd7270 + g7177 + (blame g7175 'pair?))))) + g7269))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7271 + (letrec ((x-cnd7272 (pair? g7180))) + (if x-cnd7272 + g7180 + (blame g7178 'pair?))))) + g7271))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7273 + (letrec ((x-cnd7274 + (integer? g7183))) + (if x-cnd7274 + g7183 + (blame g7181 'integer?))))) + g7273))) + (and/c + (lambda (c1 c2) + (letrec ((g7275 + (lambda (k j v) + (letrec ((g7276 + (letrec ((x-cnd7277 + (c1 k j v))) + (if x-cnd7277 + (c2 k j v) + #f)))) + g7276)))) + g7275))) + (list-of + (lambda (contract) + (letrec ((g7278 + (lambda (k j v) + (letrec ((g7279 + (letrec ((x-cnd7280 + (null? v))) + (if x-cnd7280 + '() + (letrec ((x7284 + (letrec ((x7285 + (car + v))) + (contract + k + j + x7285))) + (x7281 + (letrec ((x7283 + (list-of + contract)) + (x7282 + (cdr + v))) + (x7283 + k + j + x7282)))) + (cons + x7284 + x7281)))))) + g7279)))) + g7278))) + (any? (lambda (v) (letrec ((g7286 #t)) g7286))) + (nonzero? + (lambda (v) + (letrec ((g7287 + (letrec ((x7288 (= v 0))) + (not x7288)))) + g7287))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7289 + (letrec ((x-cnd7290 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7290 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7289))) + (meta (lambda (v) (letrec ((g7291 v)) g7291))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7292 #t)) g7292))) + (cdddr + (lambda (x) + (letrec ((g7293 + (letrec ((x7294 + (letrec ((x7295 (cdr x))) + (cdr x7295)))) + (cdr x7294)))) + g7293))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7296 + (letrec ((x7299 (procedure? f))) + (assert x7299))) + (g7297 + (letrec ((x7300 (list? l))) + (assert x7300))) + (g7298 + (letrec ((x-cnd7301 (null? l))) + (if x-cnd7301 + '() + (letrec ((x7304 + (letrec ((x7305 + (car l))) + (f x7305))) + (x7302 + (letrec ((x7303 + (cdr l))) + (map f x7303)))) + (cons x7304 x7302)))))) + g7298))) + (cdar + (lambda (x) + (letrec ((g7306 + (letrec ((x7307 (car x))) + (cdr x7307)))) + g7306))) + (cadadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (cdr x7310)))) + (car x7309)))) + g7308))) + (cdadar + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (car + x))) + (cdr + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7316 + (letrec ((x7319 + (string? filename))) + (assert x7319))) + (g7317 + (letrec ((x7320 (procedure? proc))) + (assert x7320))) + (g7318 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7321 + (close-output-port + output-port)) + (g7322 res)) + g7322)))) + g7318))) + (caddr + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 + (letrec ((x7325 (cdr x))) + (cdr x7325)))) + (car x7324)))) + g7323))) + (cdaadr + (lambda (x) + (letrec ((g7326 + (letrec ((x7327 + (letrec ((x7328 + (letrec ((x7329 + (cdr + x))) + (car + x7329)))) + (car x7328)))) + (cdr x7327)))) + g7326))) + (assq + (lambda (k l) + (letrec ((g7330 + (letrec ((x7332 (list? l))) + (assert x7332))) + (g7331 + (letrec ((x-cnd7333 (null? l))) + (if x-cnd7333 + #f + (letrec ((x-cnd7334 + (letrec ((x7335 + (caar l))) + (eq? x7335 k)))) + (if x-cnd7334 + (car l) + (letrec ((x7336 (cdr l))) + (assq k x7336)))))))) + g7331))) + (even? + (lambda (x) + (letrec ((g7337 + (letrec ((x7338 (modulo x 2))) + (= 0 x7338)))) + g7337))) + (list->string + (lambda (l) + (letrec ((g7339 + (letrec ((x7341 (list? l))) + (assert x7341))) + (g7340 + (letrec ((x-cnd7342 (null? l))) + (if x-cnd7342 + "" + (letrec ((x7345 + (letrec ((x7346 + (car l))) + (char->string + x7346))) + (x7343 + (letrec ((x7344 + (cdr l))) + (list->string + x7344)))) + (string-append + x7345 + x7343)))))) + g7340))) + (char<=? + (lambda (c1 c2) + (letrec ((g7347 + (letrec ((x7350 (char? c1))) + (assert x7350))) + (g7348 + (letrec ((x7351 (char? c2))) + (assert x7351))) + (g7349 + (letrec ((val7143 (char=? c x7368)))) + (if x-cnd7367 + (letrec ((x7369 #\z)) + (char-ci<=? c x7369)) + #f)))) + g7366))) + (<= + (lambda (x y) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 + (letrec ((val7144 (< x y))) + (letrec ((g7373 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7374 + (if val7145 + val7145 + #f))) + g7374))))) + g7373)))) + g7371))) + (char-whitespace? + (lambda (c) + (letrec ((g7375 + (letrec ((val7146 + (letrec ((x7376 + (char->integer + c))) + (= x7376 9)))) + (letrec ((g7377 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7378 + (char->integer + c))) + (= + x7378 + 10)))) + (letrec ((g7379 + (if val7147 + val7147 + (letrec ((x7380 + (char->integer + c))) + (= + x7380 + 32))))) + g7379))))) + g7377)))) + g7375))) + (cddar + (lambda (x) + (letrec ((g7381 + (letrec ((x7382 + (letrec ((x7383 (car x))) + (cdr x7383)))) + (cdr x7382)))) + g7381))) + (positive? + (lambda (x) + (letrec ((g7384 + (letrec ((x7386 (number? x))) + (assert x7386))) + (g7385 (> x 0))) + g7385))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7387 #f)) g7387))) + (cddr + (lambda (x) + (letrec ((g7388 + (letrec ((x7389 (cdr x))) + (cdr x7389)))) + g7388))) + (truncate + (lambda (x) + (letrec ((g7390 + (letrec ((x7392 (number? x))) + (assert x7392))) + (g7391 + (letrec ((x-cnd7393 (< x 0))) + (if x-cnd7393 + (ceiling x) + (floor x))))) + g7391))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7394 + (letrec ((val7148 (eq? a b))) + (letrec ((g7395 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7397 + (null? + a)) + (x7396 + (null? + b))) + (and x7397 + x7396)))) + (letrec ((g7398 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7401 + (string? + a)) + (x7400 + (string? + b)) + (x7399 + (string=? + a + b))) + (and x7401 + x7400 + x7399)))) + (letrec ((g7402 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7410 + (pair? + a)) + (x7409 + (pair? + b)) + (x7406 + (letrec ((x7408 + (car + a)) + (x7407 + (car + b))) + (equal? + x7408 + x7407))) + (x7403 + (letrec ((x7405 + (cdr + a)) + (x7404 + (cdr + b))) + (equal? + x7405 + x7404)))) + (and x7410 + x7409 + x7406 + x7403)))) + (letrec ((g7411 + (if val7151 + val7151 + (letrec ((x7430 + (vector? + a)) + (x7429 + (vector? + b)) + (x7412 + (letrec ((x7426 + (letrec ((x7427 + (letrec ((x7428 + (vector-length + a))) + (n + x7428)))) + (x7427))) + (x7413 + (letrec ((x7424 + (letrec ((x7425 + (vector-length + b))) + (= + x7425 + n))) + (x7414 + (letrec ((loop + (lambda (i) + (letrec ((g7415 + (letrec ((x7422 + (= + i + n)) + (x7416 + (letrec ((x7419 + (letrec ((x7421 + (vector-ref + a + i)) + (x7420 + (vector-ref + b + i))) + (equal? + x7421 + x7420))) + (x7417 + (letrec ((x7418 + (+ + i + 1))) + (loop + x7418)))) + (and x7419 + x7417)))) + (or x7422 + x7416)))) + g7415)))) + (letrec ((g7423 + (loop + 0))) + g7423)))) + (and x7424 + x7414)))) + (let x7426 x7413)))) + (and x7430 + x7429 + x7412))))) + g7411))))) + g7402))))) + g7398))))) + g7395)))) + g7394))) + (cdaaar + (lambda (x) + (letrec ((g7431 + (letrec ((x7432 + (letrec ((x7433 + (letrec ((x7434 + (car + x))) + (car + x7434)))) + (car x7433)))) + (cdr x7432)))) + g7431))) + (caaddr + (lambda (x) + (letrec ((g7435 + (letrec ((x7436 + (letrec ((x7437 + (letrec ((x7438 + (cdr + x))) + (cdr + x7438)))) + (car x7437)))) + (car x7436)))) + g7435))) + (eqv? + (lambda (x y) + (letrec ((g7439 (eq? x y))) g7439))) + (>= + (lambda (x y) + (letrec ((g7440 + (letrec ((x7442 (number? x))) + (assert x7442))) + (g7441 + (letrec ((val7152 (> x y))) + (letrec ((g7443 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7444 + (if val7153 + val7153 + #f))) + g7444))))) + g7443)))) + g7441))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7445 + (letrec ((x7448 + (string? filename))) + (assert x7448))) + (g7446 + (letrec ((x7449 (procedure? proc))) + (assert x7449))) + (g7447 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7450 + (close-input-port + input-port)) + (g7451 res)) + g7451)))) + g7447))) + (ref + (lambda (x) + (letrec ((g7452 (cons x '()))) g7452))) + (char>=? + (lambda (c1 c2) + (letrec ((g7453 + (letrec ((x7456 (char? c1))) + (assert x7456))) + (g7454 + (letrec ((x7457 (char? c2))) + (assert x7457))) + (g7455 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7458 + (if val7154 + val7154 + (char=? c1 c2)))) + g7458)))) + g7455))) + (cdaar + (lambda (x) + (letrec ((g7459 + (letrec ((x7460 + (letrec ((x7461 (car x))) + (car x7461)))) + (cdr x7460)))) + g7459))) + (cdaddr + (lambda (x) + (letrec ((g7462 + (letrec ((x7463 + (letrec ((x7464 + (letrec ((x7465 + (cdr + x))) + (cdr + x7465)))) + (car x7464)))) + (cdr x7463)))) + g7462))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7466 + (letrec ((x7467 + (letrec ((x7468 (car x))) + (cdr x7468)))) + (car x7467)))) + g7466))) + (caadr + (lambda (x) + (letrec ((g7469 + (letrec ((x7470 + (letrec ((x7471 (cdr x))) + (car x7471)))) + (car x7470)))) + g7469))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7472 + (letrec ((x7475 (char? c1))) + (assert x7475))) + (g7473 + (letrec ((x7476 (char? c2))) + (assert x7476))) + (g7474 + (letrec ((x7477 + (char-ci<=? c1 c2))) + (not x7477)))) + g7474))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7478 + (letrec ((x7479 + (letrec ((x7480 + (letrec ((x7481 + (car + x))) + (car + x7481)))) + (car x7480)))) + (car x7479)))) + g7478))) + (negative? + (lambda (x) + (letrec ((g7482 + (letrec ((x7484 (number? x))) + (assert x7484))) + (g7483 (< x 0))) + g7483))) + (memv + (lambda (e l) + (letrec ((g7485 (memq e l))) g7485))) + (caaar + (lambda (x) + (letrec ((g7486 + (letrec ((x7487 + (letrec ((x7488 (car x))) + (car x7488)))) + (car x7487)))) + g7486))) + (debug + (lambda (e) (letrec ((g7489 '())) g7489))) + (reverse + (lambda (l) + (letrec ((g7490 + (letrec ((x7492 (list? l))) + (assert x7492))) + (g7491 + (letrec ((x-cnd7493 (null? l))) + (if x-cnd7493 + '() + (letrec ((x7496 + (letrec ((x7497 + (cdr l))) + (reverse x7497))) + (x7494 + (letrec ((x7495 + (car l))) + (list x7495)))) + (append x7496 x7494)))))) + g7491))) + (caaadr + (lambda (x) + (letrec ((g7498 + (letrec ((x7499 + (letrec ((x7500 + (letrec ((x7501 + (cdr + x))) + (car + x7501)))) + (car x7500)))) + (car x7499)))) + g7498))) + (cddadr + (lambda (x) + (letrec ((g7502 + (letrec ((x7503 + (letrec ((x7504 + (letrec ((x7505 + (cdr + x))) + (car + x7505)))) + (cdr x7504)))) + (cdr x7503)))) + g7502))) + (odd? + (lambda (x) + (letrec ((g7506 + (letrec ((x7508 (number? x))) + (assert x7508))) + (g7507 + (letrec ((x7509 (modulo x 2))) + (= 1 x7509)))) + g7507))) + (caadar + (lambda (x) + (letrec ((g7510 + (letrec ((x7511 + (letrec ((x7512 + (letrec ((x7513 + (car + x))) + (cdr + x7513)))) + (car x7512)))) + (car x7511)))) + g7510))) + (apply + (lambda (proc args) + (letrec ((g7514 + (letrec ((x7517 (procedure? proc))) + (assert x7517))) + (g7515 + (letrec ((x7518 (list? args))) + (assert x7518))) + (g7516 + (if cnd + (letrec ((g7519 (proc))) g7519) + (if cnd + (letrec ((g7520 + (letrec ((x7521 + (car + args))) + (proc x7521)))) + g7520) + (if cnd + (letrec ((g7522 + (letrec ((x7524 + (car + args)) + (x7523 + (cadr + args))) + (proc + x7524 + x7523)))) + g7522) + (if cnd + (letrec ((g7525 + (letrec ((x7528 + (car + args)) + (x7527 + (cadr + args)) + (x7526 + (caddr + args))) + (proc + x7528 + x7527 + x7526)))) + g7525) + (if cnd + (letrec ((g7529 + (letrec ((x7533 + (car + args)) + (x7532 + (cadr + args)) + (x7531 + (caddr + args)) + (x7530 + (cadddr + args))) + (proc + x7533 + x7532 + x7531 + x7530)))) + g7529) + (if cnd + (letrec ((g7534 + (letrec ((x7540 + (car + args)) + (x7539 + (cadr + args)) + (x7538 + (caddr + args)) + (x7537 + (cadddr + args)) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (car + x7536)))) + (proc + x7540 + x7539 + x7538 + x7537 + x7535)))) + g7534) + (if cnd + (letrec ((g7541 + (letrec ((x7549 + (car + args)) + (x7548 + (cadr + args)) + (x7547 + (caddr + args)) + (x7546 + (cadddr + args)) + (x7544 + (letrec ((x7545 + (cddddr + args))) + (car + x7545))) + (x7542 + (letrec ((x7543 + (cddddr + args))) + (cadr + x7543)))) + (proc + x7549 + x7548 + x7547 + x7546 + x7544 + x7542)))) + g7541) + (if cnd + (letrec ((g7550 + (letrec ((x7560 + (car + args)) + (x7559 + (cadr + args)) + (x7558 + (caddr + args)) + (x7557 + (cadddr + args)) + (x7555 + (letrec ((x7556 + (cddddr + args))) + (car + x7556))) + (x7553 + (letrec ((x7554 + (cddddr + args))) + (cadr + x7554))) + (x7551 + (letrec ((x7552 + (cddddr + args))) + (caddr + x7552)))) + (proc + x7560 + x7559 + x7558 + x7557 + x7555 + x7553 + x7551)))) + g7550) + (letrec ((g7561 + (error + "Unsupported call."))) + g7561))))))))))) + g7516))) + (member + (lambda (e l) + (letrec ((g7562 + (letrec ((x7564 (list? l))) + (assert x7564))) + (g7563 + (letrec ((x-cnd7565 (null? l))) + (if x-cnd7565 + #f + (letrec ((x-cnd7566 + (letrec ((x7567 + (car l))) + (equal? x7567 e)))) + (if x-cnd7566 + l + (letrec ((x7568 (cdr l))) + (member e x7568)))))))) + g7563))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 + (letrec ((x7571 + (letrec ((x7572 + (cdr + x))) + (cdr + x7572)))) + (cdr x7571)))) + (cdr x7570)))) + g7569))) + (cadddr + (lambda (x) + (letrec ((g7573 + (letrec ((x7574 + (letrec ((x7575 + (letrec ((x7576 + (cdr + x))) + (cdr + x7576)))) + (cdr x7575)))) + (car x7574)))) + g7573))) + (int-top + (lambda () + (letrec ((g7577 (random 42))) g7577))) + (zero? + (lambda (x) + (letrec ((g7578 + (letrec ((x7580 (number? x))) + (assert x7580))) + (g7579 (= x 0))) + g7579))) + (string>=? + (lambda (s1 s2) + (letrec ((g7581 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7582 + (if val7155 + val7155 + (string=? s1 s2)))) + g7582)))) + g7581))) + (cadr + (lambda (x) + (letrec ((g7583 + (letrec ((x7584 (cdr x))) + (car x7584)))) + g7583))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7585 + (letrec ((val7156 + (letrec ((x7588 + (pair? l)) + (x7586 + (letrec ((x7587 + (cdr + l))) + (list? + x7587)))) + (and x7588 x7586)))) + (letrec ((g7589 + (if val7156 + val7156 + (null? l)))) + g7589)))) + g7585))) + (cddaar + (lambda (x) + (letrec ((g7590 + (letrec ((x7591 + (letrec ((x7592 + (letrec ((x7593 + (car + x))) + (car + x7593)))) + (cdr x7592)))) + (cdr x7591)))) + g7590))) + (char-numeric? + (lambda (c) + (letrec ((g7594 + (letrec ((x-cnd7595 + (letrec ((x7596 #\0)) + (char<=? x7596 c)))) + (if x-cnd7595 + (letrec ((x7597 #\9)) + (char<=? c x7597)) + #f)))) + g7594))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7598 + (letrec ((x7600 (list? l))) + (assert x7600))) + (g7599 + (letrec ((x-cnd7601 (null? l))) + (if x-cnd7601 + #f + (letrec ((x-cnd7602 + (letrec ((x7603 + (caar l))) + (eqv? x7603 k)))) + (if x-cnd7602 + (car l) + (letrec ((x7604 (cdr l))) + (assq k x7604)))))))) + g7599))) + (not + (lambda (x) + (letrec ((g7605 (if x #f #t))) g7605))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7606 (append l1 l2))) g7606))) + (memq + (lambda (e l) + (letrec ((g7607 + (letrec ((x7609 (list? l))) + (assert x7609))) + (g7608 + (letrec ((x-cnd7610 (null? l))) + (if x-cnd7610 + #f + (letrec ((x-cnd7611 + (letrec ((x7612 + (car l))) + (eq? x7612 e)))) + (if x-cnd7611 + l + (letrec ((x7613 (cdr l))) + (memq e x7613)))))))) + g7608))) + (cadaar + (lambda (x) + (letrec ((g7614 + (letrec ((x7615 + (letrec ((x7616 + (letrec ((x7617 + (car + x))) + (car + x7617)))) + (cdr x7616)))) + (car x7615)))) + g7614))) + (length + (lambda (l) + (letrec ((g7618 + (letrec ((x7620 (list? l))) + (assert x7620))) + (g7619 + (letrec ((rec + (lambda (l) + (letrec ((g7621 + (letrec ((x-cnd7622 + (null? + l))) + (if x-cnd7622 + 0 + (letrec ((x7623 + (letrec ((x7624 + (cdr + l))) + (rec + x7624)))) + (+ + 1 + x7623)))))) + g7621)))) + (letrec ((g7625 (rec l))) + g7625)))) + g7619))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7626 + (letrec ((x7629 (char? c1))) + (assert x7629))) + (g7627 + (letrec ((x7630 (char? c2))) + (assert x7630))) + (g7628 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7632 + (letrec ((x7633 (string<=? s1 s2))) + (not x7633)))) + g7632))) + (cdadr + (lambda (x) + (letrec ((g7634 + (letrec ((x7635 + (letrec ((x7636 (cdr x))) + (car x7636)))) + (cdr x7635)))) + g7634))) + (assoc + (lambda (k l) + (letrec ((g7637 + (letrec ((x7639 (list? l))) + (assert x7639))) + (g7638 + (letrec ((x-cnd7640 (null? l))) + (if x-cnd7640 + #f + (letrec ((x-cnd7641 + (letrec ((x7642 + (caar l))) + (equal? x7642 k)))) + (if x-cnd7641 + (car l) + (letrec ((x7643 (cdr l))) + (assoc k x7643)))))))) + g7638))) + (caar + (lambda (x) + (letrec ((g7644 + (letrec ((x7645 (car x))) + (car x7645)))) + g7644))) + (char>? + (lambda (c1 c2) + (letrec ((g7646 + (letrec ((x7649 (char? c1))) + (assert x7649))) + (g7647 + (letrec ((x7650 (char? c2))) + (assert x7650))) + (g7648 + (letrec ((x7651 (char<=? c1 c2))) + (not x7651)))) + g7648))) + (string<=? + (lambda (s1 s2) + (letrec ((g7652 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7669 + (letrec ((x7672 (char? c1))) + (assert x7672))) + (g7670 + (letrec ((x7673 (char? c2))) + (assert x7673))) + (g7671 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7674 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7674)))) + g7671))) + (caddar + (lambda (x) + (letrec ((g7675 + (letrec ((x7676 + (letrec ((x7677 + (letrec ((x7678 + (car + x))) + (cdr + x7678)))) + (cdr x7677)))) + (car x7676)))) + g7675))) + (newline + (lambda () (letrec ((g7679 #f)) g7679))) + (lcm + (lambda (m n) + (letrec ((g7680 + (letrec ((x7682 + (letrec ((x7683 (* m n))) + (abs x7683))) + (x7681 (gcd m n))) + (/ x7682 x7681)))) + g7680))) + (deref car) + (> + (lambda (x y) + (letrec ((g7684 + (letrec ((x7686 (number? x))) + (assert x7686))) + (g7685 + (letrec ((x7687 (<= x y))) + (not x7687)))) + g7685))) + (list-ref + (lambda (l index) + (letrec ((g7688 + (letrec ((x7692 (list? l))) + (assert x7692))) + (g7689 + (letrec ((x7693 (number? index))) + (assert x7693))) + (g7690 + (letrec ((x7694 + (letrec ((x7695 + (length l))) + (< index x7695)))) + (assert x7694))) + (g7691 + (letrec ((x-cnd7696 (= index 0))) + (if x-cnd7696 + (car l) + (letrec ((x7698 (cdr l)) + (x7697 (- index 1))) + (list-ref x7698 x7697)))))) + g7691))) + (gcd + (lambda (a b) + (letrec ((g7699 + (letrec ((x-cnd7700 (= b 0))) + (if x-cnd7700 + a + (letrec ((x7701 (modulo a b))) + (gcd b x7701)))))) + g7699))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7702 + (letrec ((x-cnd7703 (real? g7162))) + (if x-cnd7703 + g7162 + (blame g7160 'real?))))) + g7702))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7704 + (letrec ((x-cnd7705 + (boolean? g7165))) + (if x-cnd7705 + g7165 + (blame g7163 'boolean?))))) + g7704))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7706 + (letrec ((x-cnd7707 + (number? g7168))) + (if x-cnd7707 + g7168 + (blame g7166 'number?))))) + g7706))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7708 + (letrec ((x-cnd7709 + ((lambda (v) #t) g7171))) + (if x-cnd7709 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7708))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7710 + (letrec ((x-cnd7711 + ((lambda (v) #t) g7174))) + (if x-cnd7711 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7710))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7712 + (letrec ((x-cnd7713 (pair? g7177))) + (if x-cnd7713 + g7177 + (blame g7175 'pair?))))) + g7712))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7714 + (letrec ((x-cnd7715 (pair? g7180))) + (if x-cnd7715 + g7180 + (blame g7178 'pair?))))) + g7714))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7716 + (letrec ((x-cnd7717 + (integer? g7183))) + (if x-cnd7717 + g7183 + (blame g7181 'integer?))))) + g7716))) + (and/c + (lambda (c1 c2) + (letrec ((g7718 + (lambda (k j v) + (letrec ((g7719 + (letrec ((x-cnd7720 + (c1 k j v))) + (if x-cnd7720 + (c2 k j v) + #f)))) + g7719)))) + g7718))) + (list-of + (lambda (contract) + (letrec ((g7721 + (lambda (k j v) + (letrec ((g7722 + (letrec ((x-cnd7723 + (null? v))) + (if x-cnd7723 + '() + (letrec ((x7727 + (letrec ((x7728 + (car + v))) + (contract + k + j + x7728))) + (x7724 + (letrec ((x7726 + (list-of + contract)) + (x7725 + (cdr + v))) + (x7726 + k + j + x7725)))) + (cons + x7727 + x7724)))))) + g7722)))) + g7721))) + (any? (lambda (v) (letrec ((g7729 #t)) g7729))) + (nonzero? + (lambda (v) + (letrec ((g7730 + (letrec ((x7731 (= v 0))) + (not x7731)))) + g7730))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7732 + (letrec ((x-cnd7733 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7733 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7732))) + (meta (lambda (v) (letrec ((g7734 v)) g7734))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7735 #t)) g7735))) + (cdddr + (lambda (x) + (letrec ((g7736 + (letrec ((x7737 + (letrec ((x7738 (cdr x))) + (cdr x7738)))) + (cdr x7737)))) + g7736))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7739 + (letrec ((x7742 (procedure? f))) + (assert x7742))) + (g7740 + (letrec ((x7743 (list? l))) + (assert x7743))) + (g7741 + (letrec ((x-cnd7744 (null? l))) + (if x-cnd7744 + '() + (letrec ((x7747 + (letrec ((x7748 + (car l))) + (f x7748))) + (x7745 + (letrec ((x7746 + (cdr l))) + (map f x7746)))) + (cons x7747 x7745)))))) + g7741))) + (cdar + (lambda (x) + (letrec ((g7749 + (letrec ((x7750 (car x))) + (cdr x7750)))) + g7749))) + (cadadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (cdr x7753)))) + (car x7752)))) + g7751))) + (cdadar + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (car + x))) + (cdr + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7759 + (letrec ((x7762 + (string? filename))) + (assert x7762))) + (g7760 + (letrec ((x7763 (procedure? proc))) + (assert x7763))) + (g7761 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7764 + (close-output-port + output-port)) + (g7765 res)) + g7765)))) + g7761))) + (caddr + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 + (letrec ((x7768 (cdr x))) + (cdr x7768)))) + (car x7767)))) + g7766))) + (cdaadr + (lambda (x) + (letrec ((g7769 + (letrec ((x7770 + (letrec ((x7771 + (letrec ((x7772 + (cdr + x))) + (car + x7772)))) + (car x7771)))) + (cdr x7770)))) + g7769))) + (assq + (lambda (k l) + (letrec ((g7773 + (letrec ((x7775 (list? l))) + (assert x7775))) + (g7774 + (letrec ((x-cnd7776 (null? l))) + (if x-cnd7776 + #f + (letrec ((x-cnd7777 + (letrec ((x7778 + (caar l))) + (eq? x7778 k)))) + (if x-cnd7777 + (car l) + (letrec ((x7779 (cdr l))) + (assq k x7779)))))))) + g7774))) + (even? + (lambda (x) + (letrec ((g7780 + (letrec ((x7781 (modulo x 2))) + (= 0 x7781)))) + g7780))) + (list->string + (lambda (l) + (letrec ((g7782 + (letrec ((x7784 (list? l))) + (assert x7784))) + (g7783 + (letrec ((x-cnd7785 (null? l))) + (if x-cnd7785 + "" + (letrec ((x7788 + (letrec ((x7789 + (car l))) + (char->string + x7789))) + (x7786 + (letrec ((x7787 + (cdr l))) + (list->string + x7787)))) + (string-append + x7788 + x7786)))))) + g7783))) + (char<=? + (lambda (c1 c2) + (letrec ((g7790 + (letrec ((x7793 (char? c1))) + (assert x7793))) + (g7791 + (letrec ((x7794 (char? c2))) + (assert x7794))) + (g7792 + (letrec ((val7143 (char=? c x7811)))) + (if x-cnd7810 + (letrec ((x7812 #\z)) + (char-ci<=? c x7812)) + #f)))) + g7809))) + (<= + (lambda (x y) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 + (letrec ((val7144 (< x y))) + (letrec ((g7816 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7817 + (if val7145 + val7145 + #f))) + g7817))))) + g7816)))) + g7814))) + (char-whitespace? + (lambda (c) + (letrec ((g7818 + (letrec ((val7146 + (letrec ((x7819 + (char->integer + c))) + (= x7819 9)))) + (letrec ((g7820 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7821 + (char->integer + c))) + (= + x7821 + 10)))) + (letrec ((g7822 + (if val7147 + val7147 + (letrec ((x7823 + (char->integer + c))) + (= + x7823 + 32))))) + g7822))))) + g7820)))) + g7818))) + (cddar + (lambda (x) + (letrec ((g7824 + (letrec ((x7825 + (letrec ((x7826 (car x))) + (cdr x7826)))) + (cdr x7825)))) + g7824))) + (positive? + (lambda (x) + (letrec ((g7827 + (letrec ((x7829 (number? x))) + (assert x7829))) + (g7828 (> x 0))) + g7828))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7830 #f)) g7830))) + (cddr + (lambda (x) + (letrec ((g7831 + (letrec ((x7832 (cdr x))) + (cdr x7832)))) + g7831))) + (truncate + (lambda (x) + (letrec ((g7833 + (letrec ((x7835 (number? x))) + (assert x7835))) + (g7834 + (letrec ((x-cnd7836 (< x 0))) + (if x-cnd7836 + (ceiling x) + (floor x))))) + g7834))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7837 + (letrec ((val7148 (eq? a b))) + (letrec ((g7838 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7840 + (null? + a)) + (x7839 + (null? + b))) + (and x7840 + x7839)))) + (letrec ((g7841 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7844 + (string? + a)) + (x7843 + (string? + b)) + (x7842 + (string=? + a + b))) + (and x7844 + x7843 + x7842)))) + (letrec ((g7845 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7853 + (pair? + a)) + (x7852 + (pair? + b)) + (x7849 + (letrec ((x7851 + (car + a)) + (x7850 + (car + b))) + (equal? + x7851 + x7850))) + (x7846 + (letrec ((x7848 + (cdr + a)) + (x7847 + (cdr + b))) + (equal? + x7848 + x7847)))) + (and x7853 + x7852 + x7849 + x7846)))) + (letrec ((g7854 + (if val7151 + val7151 + (letrec ((x7873 + (vector? + a)) + (x7872 + (vector? + b)) + (x7855 + (letrec ((x7869 + (letrec ((x7870 + (letrec ((x7871 + (vector-length + a))) + (n + x7871)))) + (x7870))) + (x7856 + (letrec ((x7867 + (letrec ((x7868 + (vector-length + b))) + (= + x7868 + n))) + (x7857 + (letrec ((loop + (lambda (i) + (letrec ((g7858 + (letrec ((x7865 + (= + i + n)) + (x7859 + (letrec ((x7862 + (letrec ((x7864 + (vector-ref + a + i)) + (x7863 + (vector-ref + b + i))) + (equal? + x7864 + x7863))) + (x7860 + (letrec ((x7861 + (+ + i + 1))) + (loop + x7861)))) + (and x7862 + x7860)))) + (or x7865 + x7859)))) + g7858)))) + (letrec ((g7866 + (loop + 0))) + g7866)))) + (and x7867 + x7857)))) + (let x7869 x7856)))) + (and x7873 + x7872 + x7855))))) + g7854))))) + g7845))))) + g7841))))) + g7838)))) + g7837))) + (cdaaar + (lambda (x) + (letrec ((g7874 + (letrec ((x7875 + (letrec ((x7876 + (letrec ((x7877 + (car + x))) + (car + x7877)))) + (car x7876)))) + (cdr x7875)))) + g7874))) + (caaddr + (lambda (x) + (letrec ((g7878 + (letrec ((x7879 + (letrec ((x7880 + (letrec ((x7881 + (cdr + x))) + (cdr + x7881)))) + (car x7880)))) + (car x7879)))) + g7878))) + (eqv? + (lambda (x y) + (letrec ((g7882 (eq? x y))) g7882))) + (>= + (lambda (x y) + (letrec ((g7883 + (letrec ((x7885 (number? x))) + (assert x7885))) + (g7884 + (letrec ((val7152 (> x y))) + (letrec ((g7886 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7887 + (if val7153 + val7153 + #f))) + g7887))))) + g7886)))) + g7884))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7888 + (letrec ((x7891 + (string? filename))) + (assert x7891))) + (g7889 + (letrec ((x7892 (procedure? proc))) + (assert x7892))) + (g7890 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7893 + (close-input-port + input-port)) + (g7894 res)) + g7894)))) + g7890))) + (ref + (lambda (x) + (letrec ((g7895 (cons x '()))) g7895))) + (char>=? + (lambda (c1 c2) + (letrec ((g7896 + (letrec ((x7899 (char? c1))) + (assert x7899))) + (g7897 + (letrec ((x7900 (char? c2))) + (assert x7900))) + (g7898 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7901 + (if val7154 + val7154 + (char=? c1 c2)))) + g7901)))) + g7898))) + (cdaar + (lambda (x) + (letrec ((g7902 + (letrec ((x7903 + (letrec ((x7904 (car x))) + (car x7904)))) + (cdr x7903)))) + g7902))) + (cdaddr + (lambda (x) + (letrec ((g7905 + (letrec ((x7906 + (letrec ((x7907 + (letrec ((x7908 + (cdr + x))) + (cdr + x7908)))) + (car x7907)))) + (cdr x7906)))) + g7905))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7909 + (letrec ((x7910 + (letrec ((x7911 (car x))) + (cdr x7911)))) + (car x7910)))) + g7909))) + (caadr + (lambda (x) + (letrec ((g7912 + (letrec ((x7913 + (letrec ((x7914 (cdr x))) + (car x7914)))) + (car x7913)))) + g7912))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7915 + (letrec ((x7918 (char? c1))) + (assert x7918))) + (g7916 + (letrec ((x7919 (char? c2))) + (assert x7919))) + (g7917 + (letrec ((x7920 + (char-ci<=? c1 c2))) + (not x7920)))) + g7917))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7921 + (letrec ((x7922 + (letrec ((x7923 + (letrec ((x7924 + (car + x))) + (car + x7924)))) + (car x7923)))) + (car x7922)))) + g7921))) + (negative? + (lambda (x) + (letrec ((g7925 + (letrec ((x7927 (number? x))) + (assert x7927))) + (g7926 (< x 0))) + g7926))) + (memv + (lambda (e l) + (letrec ((g7928 (memq e l))) g7928))) + (caaar + (lambda (x) + (letrec ((g7929 + (letrec ((x7930 + (letrec ((x7931 (car x))) + (car x7931)))) + (car x7930)))) + g7929))) + (debug + (lambda (e) (letrec ((g7932 '())) g7932))) + (reverse + (lambda (l) + (letrec ((g7933 + (letrec ((x7935 (list? l))) + (assert x7935))) + (g7934 + (letrec ((x-cnd7936 (null? l))) + (if x-cnd7936 + '() + (letrec ((x7939 + (letrec ((x7940 + (cdr l))) + (reverse x7940))) + (x7937 + (letrec ((x7938 + (car l))) + (list x7938)))) + (append x7939 x7937)))))) + g7934))) + (caaadr + (lambda (x) + (letrec ((g7941 + (letrec ((x7942 + (letrec ((x7943 + (letrec ((x7944 + (cdr + x))) + (car + x7944)))) + (car x7943)))) + (car x7942)))) + g7941))) + (cddadr + (lambda (x) + (letrec ((g7945 + (letrec ((x7946 + (letrec ((x7947 + (letrec ((x7948 + (cdr + x))) + (car + x7948)))) + (cdr x7947)))) + (cdr x7946)))) + g7945))) + (odd? + (lambda (x) + (letrec ((g7949 + (letrec ((x7951 (number? x))) + (assert x7951))) + (g7950 + (letrec ((x7952 (modulo x 2))) + (= 1 x7952)))) + g7950))) + (caadar + (lambda (x) + (letrec ((g7953 + (letrec ((x7954 + (letrec ((x7955 + (letrec ((x7956 + (car + x))) + (cdr + x7956)))) + (car x7955)))) + (car x7954)))) + g7953))) + (apply + (lambda (proc args) + (letrec ((g7957 + (letrec ((x7960 (procedure? proc))) + (assert x7960))) + (g7958 + (letrec ((x7961 (list? args))) + (assert x7961))) + (g7959 + (if cnd + (letrec ((g7962 (proc))) g7962) + (if cnd + (letrec ((g7963 + (letrec ((x7964 + (car + args))) + (proc x7964)))) + g7963) + (if cnd + (letrec ((g7965 + (letrec ((x7967 + (car + args)) + (x7966 + (cadr + args))) + (proc + x7967 + x7966)))) + g7965) + (if cnd + (letrec ((g7968 + (letrec ((x7971 + (car + args)) + (x7970 + (cadr + args)) + (x7969 + (caddr + args))) + (proc + x7971 + x7970 + x7969)))) + g7968) + (if cnd + (letrec ((g7972 + (letrec ((x7976 + (car + args)) + (x7975 + (cadr + args)) + (x7974 + (caddr + args)) + (x7973 + (cadddr + args))) + (proc + x7976 + x7975 + x7974 + x7973)))) + g7972) + (if cnd + (letrec ((g7977 + (letrec ((x7983 + (car + args)) + (x7982 + (cadr + args)) + (x7981 + (caddr + args)) + (x7980 + (cadddr + args)) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (car + x7979)))) + (proc + x7983 + x7982 + x7981 + x7980 + x7978)))) + g7977) + (if cnd + (letrec ((g7984 + (letrec ((x7992 + (car + args)) + (x7991 + (cadr + args)) + (x7990 + (caddr + args)) + (x7989 + (cadddr + args)) + (x7987 + (letrec ((x7988 + (cddddr + args))) + (car + x7988))) + (x7985 + (letrec ((x7986 + (cddddr + args))) + (cadr + x7986)))) + (proc + x7992 + x7991 + x7990 + x7989 + x7987 + x7985)))) + g7984) + (if cnd + (letrec ((g7993 + (letrec ((x8003 + (car + args)) + (x8002 + (cadr + args)) + (x8001 + (caddr + args)) + (x8000 + (cadddr + args)) + (x7998 + (letrec ((x7999 + (cddddr + args))) + (car + x7999))) + (x7996 + (letrec ((x7997 + (cddddr + args))) + (cadr + x7997))) + (x7994 + (letrec ((x7995 + (cddddr + args))) + (caddr + x7995)))) + (proc + x8003 + x8002 + x8001 + x8000 + x7998 + x7996 + x7994)))) + g7993) + (letrec ((g8004 + (error + "Unsupported call."))) + g8004))))))))))) + g7959))) + (member + (lambda (e l) + (letrec ((g8005 + (letrec ((x8007 (list? l))) + (assert x8007))) + (g8006 + (letrec ((x-cnd8008 (null? l))) + (if x-cnd8008 + #f + (letrec ((x-cnd8009 + (letrec ((x8010 + (car l))) + (equal? x8010 e)))) + (if x-cnd8009 + l + (letrec ((x8011 (cdr l))) + (member e x8011)))))))) + g8006))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 + (letrec ((x8014 + (letrec ((x8015 + (cdr + x))) + (cdr + x8015)))) + (cdr x8014)))) + (cdr x8013)))) + g8012))) + (cadddr + (lambda (x) + (letrec ((g8016 + (letrec ((x8017 + (letrec ((x8018 + (letrec ((x8019 + (cdr + x))) + (cdr + x8019)))) + (cdr x8018)))) + (car x8017)))) + g8016))) + (int-top + (lambda () + (letrec ((g8020 (random 42))) g8020))) + (zero? + (lambda (x) + (letrec ((g8021 + (letrec ((x8023 (number? x))) + (assert x8023))) + (g8022 (= x 0))) + g8022))) + (string>=? + (lambda (s1 s2) + (letrec ((g8024 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8025 + (if val7155 + val7155 + (string=? s1 s2)))) + g8025)))) + g8024))) + (cadr + (lambda (x) + (letrec ((g8026 + (letrec ((x8027 (cdr x))) + (car x8027)))) + g8026))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8028 + (letrec ((val7156 + (letrec ((x8031 + (pair? l)) + (x8029 + (letrec ((x8030 + (cdr + l))) + (list? + x8030)))) + (and x8031 x8029)))) + (letrec ((g8032 + (if val7156 + val7156 + (null? l)))) + g8032)))) + g8028))) + (cddaar + (lambda (x) + (letrec ((g8033 + (letrec ((x8034 + (letrec ((x8035 + (letrec ((x8036 + (car + x))) + (car + x8036)))) + (cdr x8035)))) + (cdr x8034)))) + g8033))) + (char-numeric? + (lambda (c) + (letrec ((g8037 + (letrec ((x-cnd8038 + (letrec ((x8039 #\0)) + (char<=? x8039 c)))) + (if x-cnd8038 + (letrec ((x8040 #\9)) + (char<=? c x8040)) + #f)))) + g8037))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8041 + (letrec ((x8043 (list? l))) + (assert x8043))) + (g8042 + (letrec ((x-cnd8044 (null? l))) + (if x-cnd8044 + #f + (letrec ((x-cnd8045 + (letrec ((x8046 + (caar l))) + (eqv? x8046 k)))) + (if x-cnd8045 + (car l) + (letrec ((x8047 (cdr l))) + (assq k x8047)))))))) + g8042))) + (not + (lambda (x) + (letrec ((g8048 (if x #f #t))) g8048))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8049 (append l1 l2))) g8049))) + (memq + (lambda (e l) + (letrec ((g8050 + (letrec ((x8052 (list? l))) + (assert x8052))) + (g8051 + (letrec ((x-cnd8053 (null? l))) + (if x-cnd8053 + #f + (letrec ((x-cnd8054 + (letrec ((x8055 + (car l))) + (eq? x8055 e)))) + (if x-cnd8054 + l + (letrec ((x8056 (cdr l))) + (memq e x8056)))))))) + g8051))) + (cadaar + (lambda (x) + (letrec ((g8057 + (letrec ((x8058 + (letrec ((x8059 + (letrec ((x8060 + (car + x))) + (car + x8060)))) + (cdr x8059)))) + (car x8058)))) + g8057))) + (length + (lambda (l) + (letrec ((g8061 + (letrec ((x8063 (list? l))) + (assert x8063))) + (g8062 + (letrec ((rec + (lambda (l) + (letrec ((g8064 + (letrec ((x-cnd8065 + (null? + l))) + (if x-cnd8065 + 0 + (letrec ((x8066 + (letrec ((x8067 + (cdr + l))) + (rec + x8067)))) + (+ + 1 + x8066)))))) + g8064)))) + (letrec ((g8068 (rec l))) + g8068)))) + g8062))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8069 + (letrec ((x8072 (char? c1))) + (assert x8072))) + (g8070 + (letrec ((x8073 (char? c2))) + (assert x8073))) + (g8071 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8075 + (letrec ((x8076 (string<=? s1 s2))) + (not x8076)))) + g8075))) + (cdadr + (lambda (x) + (letrec ((g8077 + (letrec ((x8078 + (letrec ((x8079 (cdr x))) + (car x8079)))) + (cdr x8078)))) + g8077))) + (assoc + (lambda (k l) + (letrec ((g8080 + (letrec ((x8082 (list? l))) + (assert x8082))) + (g8081 + (letrec ((x-cnd8083 (null? l))) + (if x-cnd8083 + #f + (letrec ((x-cnd8084 + (letrec ((x8085 + (caar l))) + (equal? x8085 k)))) + (if x-cnd8084 + (car l) + (letrec ((x8086 (cdr l))) + (assoc k x8086)))))))) + g8081))) + (caar + (lambda (x) + (letrec ((g8087 + (letrec ((x8088 (car x))) + (car x8088)))) + g8087))) + (char>? + (lambda (c1 c2) + (letrec ((g8089 + (letrec ((x8092 (char? c1))) + (assert x8092))) + (g8090 + (letrec ((x8093 (char? c2))) + (assert x8093))) + (g8091 + (letrec ((x8094 (char<=? c1 c2))) + (not x8094)))) + g8091))) + (string<=? + (lambda (s1 s2) + (letrec ((g8095 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8112 + (letrec ((x8115 (char? c1))) + (assert x8115))) + (g8113 + (letrec ((x8116 (char? c2))) + (assert x8116))) + (g8114 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8117 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8117)))) + g8114))) + (caddar + (lambda (x) + (letrec ((g8118 + (letrec ((x8119 + (letrec ((x8120 + (letrec ((x8121 + (car + x))) + (cdr + x8121)))) + (cdr x8120)))) + (car x8119)))) + g8118))) + (newline + (lambda () (letrec ((g8122 #f)) g8122))) + (lcm + (lambda (m n) + (letrec ((g8123 + (letrec ((x8125 + (letrec ((x8126 (* m n))) + (abs x8126))) + (x8124 (gcd m n))) + (/ x8125 x8124)))) + g8123))) + (deref car) + (> + (lambda (x y) + (letrec ((g8127 + (letrec ((x8129 (number? x))) + (assert x8129))) + (g8128 + (letrec ((x8130 (<= x y))) + (not x8130)))) + g8128))) + (list-ref + (lambda (l index) + (letrec ((g8131 + (letrec ((x8135 (list? l))) + (assert x8135))) + (g8132 + (letrec ((x8136 (number? index))) + (assert x8136))) + (g8133 + (letrec ((x8137 + (letrec ((x8138 + (length l))) + (< index x8138)))) + (assert x8137))) + (g8134 + (letrec ((x-cnd8139 (= index 0))) + (if x-cnd8139 + (car l) + (letrec ((x8141 (cdr l)) + (x8140 (- index 1))) + (list-ref x8141 x8140)))))) + g8134))) + (gcd + (lambda (a b) + (letrec ((g8142 + (letrec ((x-cnd8143 (= b 0))) + (if x-cnd8143 + a + (letrec ((x8144 (modulo a b))) + (gcd b x8144)))))) + g8142)))) + (letrec ((g8145 + (letrec ((g8146 + (letrec ((f + (lambda (g) + (letrec ((g8147 + (letrec ((x8151 + (x + y)) + (x8148 + (letrec ((x8150 + (+ + x + 1)) + (x8149 + (+ + y + 1))) + (g + x8150 + x8149)))) + (λ x8151 + x8148)))) + g8147))) + (unzip + (lambda (x k) + (letrec ((g8152 + (letrec ((x-cnd8153 + (= + x + 0))) + (if x-cnd8153 + (k 0 0) + (letrec ((x8155 + (- + x + 1)) + (x8154 + (f + k))) + (unzip + x8155 + x8154)))))) + g8152))) + (zip + (lambda (x y) + (letrec ((g8156 + (letrec ((x-cnd8157 + (= + x + 0))) + (if x-cnd8157 + (letrec ((x-cnd8158 + (= + y + 0))) + (if x-cnd8158 + 0 + 'fail)) + (letrec ((x-cnd8159 + (= + y + 0))) + (if x-cnd8159 + 'fail + (letrec ((x8160 + (letrec ((x8162 + (- + x + 1)) + (x8161 + (- + y + 1))) + (zip + x8162 + x8161)))) + (+ + 1 + x8160)))))))) + g8156))) + (main + (lambda (n) + (letrec ((g8163 + (unzip + n + zip))) + g8163)))) + (letrec ((g8164 + (letrec ((g8165 + (letrec ((g8166 + (letrec ((x8169 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + ((lambda (j7235 + k7236 + f7237) + (lambda (g7233 + g7234) + (integer?/c + j7235 + k7236 + (f7237 + (integer?/c + j7235 + k7236 + g7233) + (integer?/c + j7235 + k7236 + g7234))))) + j7230 + k7231 + (f7232 + ((lambda (j7240 + k7241 + f7242) + (lambda (g7238 + g7239) + (integer?/c + j7240 + k7241 + (f7242 + (integer?/c + j7240 + k7241 + g7238) + (integer?/c + j7240 + k7241 + g7239))))) + j7230 + k7231 + g7229))))) + 'module + 'importer + f)) + (x8168 + (input))) + (x8169 + x8168))) + (g8167 + (letrec ((x8171 + ((lambda (j7244 + k7245 + f7246) + (lambda (g7243) + (integer?/c + j7244 + k7245 + (f7246 + (integer?/c + j7244 + k7245 + g7243))))) + 'module + 'importer + main)) + (x8170 + (input))) + (x8171 + x8170)))) + g8167))) + g8165))) + g8164)))) + g8146))) + g8145)))) + g7258))) + g7257)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_map-foldr.rkt b/analyses/simpleactor/benchmarks-out/mochi_map-foldr.rkt index f2678a1f..25ed3e07 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_map-foldr.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_map-foldr.rkt @@ -1,59 +1,3171 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7249 #t)) g7249))) + (meta (lambda (v) (letrec ((g7250 v)) g7250))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7251 + (letrec ((g7252 + (letrec ((x-e7253 lst)) + (match + x-e7253 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7254 (eq? v v1))) + (if x-cnd7254 #t (member v vs))))))))) + g7252))) + g7251))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (foldr f z xs) - (if (empty? xs) z (f (car xs) (foldr f z (cdr xs))))) - (define (map f xs) (foldr (λ (x ys) (cons (f x) ys)) empty xs)) - (begin - ((((lambda (j3986 k3987 f3988) - (lambda (g3983 g3984 g3985) - (any/c - j3986 - k3987 - (f3988 - ((lambda (j3991 k3992 f3993) - (lambda (g3989 g3990) - (any/c - j3991 - k3992 - (f3993 - (any/c j3991 k3992 g3989) - (any/c j3991 k3992 g3990))))) - j3986 - k3987 - g3983) - (any/c j3986 k3987 g3984) - ((listof any/c) j3986 k3987 g3985))))) - 'module - 'importer - foldr) - (input) - (input) - (input)) - (((lambda (j3996 k3997 f3998) - (lambda (g3994 g3995) - ((listof any/c) - j3996 - k3997 - (f3998 - ((lambda (j4000 k4001 f4002) - (lambda (g3999) - (any/c j4000 k4001 (f4002 (any/c j4000 k4001 g3999))))) - j3996 - k3997 - g3994) - ((listof any/c) j3996 k3997 g3995))))) - 'module - 'importer - map) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7255 (lambda (v) (letrec ((g7256 v)) g7256)))) g7255))) + (nonzero? + (lambda (v) + (letrec ((g7257 (letrec ((x7258 (= v 0))) (not x7258)))) g7257)))) + (letrec ((g7259 + (letrec ((g7260 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7261 + (letrec ((x-cnd7262 (real? g7162))) + (if x-cnd7262 + g7162 + (blame g7160 'real?))))) + g7261))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7263 + (letrec ((x-cnd7264 + (boolean? g7165))) + (if x-cnd7264 + g7165 + (blame g7163 'boolean?))))) + g7263))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7265 + (letrec ((x-cnd7266 + (number? g7168))) + (if x-cnd7266 + g7168 + (blame g7166 'number?))))) + g7265))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7267 + (letrec ((x-cnd7268 + ((lambda (v) #t) g7171))) + (if x-cnd7268 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7267))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7269 + (letrec ((x-cnd7270 + ((lambda (v) #t) g7174))) + (if x-cnd7270 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7269))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7271 + (letrec ((x-cnd7272 (pair? g7177))) + (if x-cnd7272 + g7177 + (blame g7175 'pair?))))) + g7271))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7273 + (letrec ((x-cnd7274 (pair? g7180))) + (if x-cnd7274 + g7180 + (blame g7178 'pair?))))) + g7273))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7275 + (letrec ((x-cnd7276 + (integer? g7183))) + (if x-cnd7276 + g7183 + (blame g7181 'integer?))))) + g7275))) + (and/c + (lambda (c1 c2) + (letrec ((g7277 + (lambda (k j v) + (letrec ((g7278 + (letrec ((x-cnd7279 + (c1 k j v))) + (if x-cnd7279 + (c2 k j v) + #f)))) + g7278)))) + g7277))) + (list-of + (lambda (contract) + (letrec ((g7280 + (lambda (k j v) + (letrec ((g7281 + (letrec ((x-cnd7282 + (null? v))) + (if x-cnd7282 + '() + (letrec ((x7286 + (letrec ((x7287 + (car + v))) + (contract + k + j + x7287))) + (x7283 + (letrec ((x7285 + (list-of + contract)) + (x7284 + (cdr + v))) + (x7285 + k + j + x7284)))) + (cons + x7286 + x7283)))))) + g7281)))) + g7280))) + (any? (lambda (v) (letrec ((g7288 #t)) g7288))) + (nonzero? + (lambda (v) + (letrec ((g7289 + (letrec ((x7290 (= v 0))) + (not x7290)))) + g7289))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7291 + (letrec ((x-cnd7292 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7292 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7291))) + (meta (lambda (v) (letrec ((g7293 v)) g7293))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7294 #t)) g7294))) + (cdddr + (lambda (x) + (letrec ((g7295 + (letrec ((x7296 + (letrec ((x7297 (cdr x))) + (cdr x7297)))) + (cdr x7296)))) + g7295))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7298 + (letrec ((x7301 (procedure? f))) + (assert x7301))) + (g7299 + (letrec ((x7302 (list? l))) + (assert x7302))) + (g7300 + (letrec ((x-cnd7303 (null? l))) + (if x-cnd7303 + '() + (letrec ((x7306 + (letrec ((x7307 + (car l))) + (f x7307))) + (x7304 + (letrec ((x7305 + (cdr l))) + (map f x7305)))) + (cons x7306 x7304)))))) + g7300))) + (cdar + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 (car x))) + (cdr x7309)))) + g7308))) + (cadadr + (lambda (x) + (letrec ((g7310 + (letrec ((x7311 + (letrec ((x7312 + (letrec ((x7313 + (cdr + x))) + (car + x7313)))) + (cdr x7312)))) + (car x7311)))) + g7310))) + (cdadar + (lambda (x) + (letrec ((g7314 + (letrec ((x7315 + (letrec ((x7316 + (letrec ((x7317 + (car + x))) + (cdr + x7317)))) + (car x7316)))) + (cdr x7315)))) + g7314))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7318 + (letrec ((x7321 + (string? filename))) + (assert x7321))) + (g7319 + (letrec ((x7322 (procedure? proc))) + (assert x7322))) + (g7320 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7323 + (close-output-port + output-port)) + (g7324 res)) + g7324)))) + g7320))) + (caddr + (lambda (x) + (letrec ((g7325 + (letrec ((x7326 + (letrec ((x7327 (cdr x))) + (cdr x7327)))) + (car x7326)))) + g7325))) + (cdaadr + (lambda (x) + (letrec ((g7328 + (letrec ((x7329 + (letrec ((x7330 + (letrec ((x7331 + (cdr + x))) + (car + x7331)))) + (car x7330)))) + (cdr x7329)))) + g7328))) + (assq + (lambda (k l) + (letrec ((g7332 + (letrec ((x7334 (list? l))) + (assert x7334))) + (g7333 + (letrec ((x-cnd7335 (null? l))) + (if x-cnd7335 + #f + (letrec ((x-cnd7336 + (letrec ((x7337 + (caar l))) + (eq? x7337 k)))) + (if x-cnd7336 + (car l) + (letrec ((x7338 (cdr l))) + (assq k x7338)))))))) + g7333))) + (even? + (lambda (x) + (letrec ((g7339 + (letrec ((x7340 (modulo x 2))) + (= 0 x7340)))) + g7339))) + (list->string + (lambda (l) + (letrec ((g7341 + (letrec ((x7343 (list? l))) + (assert x7343))) + (g7342 + (letrec ((x-cnd7344 (null? l))) + (if x-cnd7344 + "" + (letrec ((x7347 + (letrec ((x7348 + (car l))) + (char->string + x7348))) + (x7345 + (letrec ((x7346 + (cdr l))) + (list->string + x7346)))) + (string-append + x7347 + x7345)))))) + g7342))) + (char<=? + (lambda (c1 c2) + (letrec ((g7349 + (letrec ((x7352 (char? c1))) + (assert x7352))) + (g7350 + (letrec ((x7353 (char? c2))) + (assert x7353))) + (g7351 + (letrec ((val7143 (char=? c x7370)))) + (if x-cnd7369 + (letrec ((x7371 #\z)) + (char-ci<=? c x7371)) + #f)))) + g7368))) + (<= + (lambda (x y) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((val7144 (< x y))) + (letrec ((g7375 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7376 + (if val7145 + val7145 + #f))) + g7376))))) + g7375)))) + g7373))) + (char-whitespace? + (lambda (c) + (letrec ((g7377 + (letrec ((val7146 + (letrec ((x7378 + (char->integer + c))) + (= x7378 9)))) + (letrec ((g7379 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7380 + (char->integer + c))) + (= + x7380 + 10)))) + (letrec ((g7381 + (if val7147 + val7147 + (letrec ((x7382 + (char->integer + c))) + (= + x7382 + 32))))) + g7381))))) + g7379)))) + g7377))) + (cddar + (lambda (x) + (letrec ((g7383 + (letrec ((x7384 + (letrec ((x7385 (car x))) + (cdr x7385)))) + (cdr x7384)))) + g7383))) + (positive? + (lambda (x) + (letrec ((g7386 + (letrec ((x7388 (number? x))) + (assert x7388))) + (g7387 (> x 0))) + g7387))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7389 #f)) g7389))) + (cddr + (lambda (x) + (letrec ((g7390 + (letrec ((x7391 (cdr x))) + (cdr x7391)))) + g7390))) + (truncate + (lambda (x) + (letrec ((g7392 + (letrec ((x7394 (number? x))) + (assert x7394))) + (g7393 + (letrec ((x-cnd7395 (< x 0))) + (if x-cnd7395 + (ceiling x) + (floor x))))) + g7393))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7396 + (letrec ((val7148 (eq? a b))) + (letrec ((g7397 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7399 + (null? + a)) + (x7398 + (null? + b))) + (and x7399 + x7398)))) + (letrec ((g7400 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7403 + (string? + a)) + (x7402 + (string? + b)) + (x7401 + (string=? + a + b))) + (and x7403 + x7402 + x7401)))) + (letrec ((g7404 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7412 + (pair? + a)) + (x7411 + (pair? + b)) + (x7408 + (letrec ((x7410 + (car + a)) + (x7409 + (car + b))) + (equal? + x7410 + x7409))) + (x7405 + (letrec ((x7407 + (cdr + a)) + (x7406 + (cdr + b))) + (equal? + x7407 + x7406)))) + (and x7412 + x7411 + x7408 + x7405)))) + (letrec ((g7413 + (if val7151 + val7151 + (letrec ((x7432 + (vector? + a)) + (x7431 + (vector? + b)) + (x7414 + (letrec ((x7428 + (letrec ((x7429 + (letrec ((x7430 + (vector-length + a))) + (n + x7430)))) + (x7429))) + (x7415 + (letrec ((x7426 + (letrec ((x7427 + (vector-length + b))) + (= + x7427 + n))) + (x7416 + (letrec ((loop + (lambda (i) + (letrec ((g7417 + (letrec ((x7424 + (= + i + n)) + (x7418 + (letrec ((x7421 + (letrec ((x7423 + (vector-ref + a + i)) + (x7422 + (vector-ref + b + i))) + (equal? + x7423 + x7422))) + (x7419 + (letrec ((x7420 + (+ + i + 1))) + (loop + x7420)))) + (and x7421 + x7419)))) + (or x7424 + x7418)))) + g7417)))) + (letrec ((g7425 + (loop + 0))) + g7425)))) + (and x7426 + x7416)))) + (let x7428 x7415)))) + (and x7432 + x7431 + x7414))))) + g7413))))) + g7404))))) + g7400))))) + g7397)))) + g7396))) + (cdaaar + (lambda (x) + (letrec ((g7433 + (letrec ((x7434 + (letrec ((x7435 + (letrec ((x7436 + (car + x))) + (car + x7436)))) + (car x7435)))) + (cdr x7434)))) + g7433))) + (caaddr + (lambda (x) + (letrec ((g7437 + (letrec ((x7438 + (letrec ((x7439 + (letrec ((x7440 + (cdr + x))) + (cdr + x7440)))) + (car x7439)))) + (car x7438)))) + g7437))) + (eqv? + (lambda (x y) + (letrec ((g7441 (eq? x y))) g7441))) + (>= + (lambda (x y) + (letrec ((g7442 + (letrec ((x7444 (number? x))) + (assert x7444))) + (g7443 + (letrec ((val7152 (> x y))) + (letrec ((g7445 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7446 + (if val7153 + val7153 + #f))) + g7446))))) + g7445)))) + g7443))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7447 + (letrec ((x7450 + (string? filename))) + (assert x7450))) + (g7448 + (letrec ((x7451 (procedure? proc))) + (assert x7451))) + (g7449 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7452 + (close-input-port + input-port)) + (g7453 res)) + g7453)))) + g7449))) + (ref + (lambda (x) + (letrec ((g7454 (cons x '()))) g7454))) + (char>=? + (lambda (c1 c2) + (letrec ((g7455 + (letrec ((x7458 (char? c1))) + (assert x7458))) + (g7456 + (letrec ((x7459 (char? c2))) + (assert x7459))) + (g7457 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7460 + (if val7154 + val7154 + (char=? c1 c2)))) + g7460)))) + g7457))) + (cdaar + (lambda (x) + (letrec ((g7461 + (letrec ((x7462 + (letrec ((x7463 (car x))) + (car x7463)))) + (cdr x7462)))) + g7461))) + (cdaddr + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (cdr + x))) + (cdr + x7467)))) + (car x7466)))) + (cdr x7465)))) + g7464))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (cdr x7470)))) + (car x7469)))) + g7468))) + (caadr + (lambda (x) + (letrec ((g7471 + (letrec ((x7472 + (letrec ((x7473 (cdr x))) + (car x7473)))) + (car x7472)))) + g7471))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7474 + (letrec ((x7477 (char? c1))) + (assert x7477))) + (g7475 + (letrec ((x7478 (char? c2))) + (assert x7478))) + (g7476 + (letrec ((x7479 + (char-ci<=? c1 c2))) + (not x7479)))) + g7476))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (car + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (negative? + (lambda (x) + (letrec ((g7484 + (letrec ((x7486 (number? x))) + (assert x7486))) + (g7485 (< x 0))) + g7485))) + (memv + (lambda (e l) + (letrec ((g7487 (memq e l))) g7487))) + (caaar + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 (car x))) + (car x7490)))) + (car x7489)))) + g7488))) + (debug + (lambda (e) (letrec ((g7491 '())) g7491))) + (reverse + (lambda (l) + (letrec ((g7492 + (letrec ((x7494 (list? l))) + (assert x7494))) + (g7493 + (letrec ((x-cnd7495 (null? l))) + (if x-cnd7495 + '() + (letrec ((x7498 + (letrec ((x7499 + (cdr l))) + (reverse x7499))) + (x7496 + (letrec ((x7497 + (car l))) + (list x7497)))) + (append x7498 x7496)))))) + g7493))) + (caaadr + (lambda (x) + (letrec ((g7500 + (letrec ((x7501 + (letrec ((x7502 + (letrec ((x7503 + (cdr + x))) + (car + x7503)))) + (car x7502)))) + (car x7501)))) + g7500))) + (cddadr + (lambda (x) + (letrec ((g7504 + (letrec ((x7505 + (letrec ((x7506 + (letrec ((x7507 + (cdr + x))) + (car + x7507)))) + (cdr x7506)))) + (cdr x7505)))) + g7504))) + (odd? + (lambda (x) + (letrec ((g7508 + (letrec ((x7510 (number? x))) + (assert x7510))) + (g7509 + (letrec ((x7511 (modulo x 2))) + (= 1 x7511)))) + g7509))) + (caadar + (lambda (x) + (letrec ((g7512 + (letrec ((x7513 + (letrec ((x7514 + (letrec ((x7515 + (car + x))) + (cdr + x7515)))) + (car x7514)))) + (car x7513)))) + g7512))) + (apply + (lambda (proc args) + (letrec ((g7516 + (letrec ((x7519 (procedure? proc))) + (assert x7519))) + (g7517 + (letrec ((x7520 (list? args))) + (assert x7520))) + (g7518 + (if cnd + (letrec ((g7521 (proc))) g7521) + (if cnd + (letrec ((g7522 + (letrec ((x7523 + (car + args))) + (proc x7523)))) + g7522) + (if cnd + (letrec ((g7524 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args))) + (proc + x7526 + x7525)))) + g7524) + (if cnd + (letrec ((g7527 + (letrec ((x7530 + (car + args)) + (x7529 + (cadr + args)) + (x7528 + (caddr + args))) + (proc + x7530 + x7529 + x7528)))) + g7527) + (if cnd + (letrec ((g7531 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args))) + (proc + x7535 + x7534 + x7533 + x7532)))) + g7531) + (if cnd + (letrec ((g7536 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537)))) + g7536) + (if cnd + (letrec ((g7543 + (letrec ((x7551 + (car + args)) + (x7550 + (cadr + args)) + (x7549 + (caddr + args)) + (x7548 + (cadddr + args)) + (x7546 + (letrec ((x7547 + (cddddr + args))) + (car + x7547))) + (x7544 + (letrec ((x7545 + (cddddr + args))) + (cadr + x7545)))) + (proc + x7551 + x7550 + x7549 + x7548 + x7546 + x7544)))) + g7543) + (if cnd + (letrec ((g7552 + (letrec ((x7562 + (car + args)) + (x7561 + (cadr + args)) + (x7560 + (caddr + args)) + (x7559 + (cadddr + args)) + (x7557 + (letrec ((x7558 + (cddddr + args))) + (car + x7558))) + (x7555 + (letrec ((x7556 + (cddddr + args))) + (cadr + x7556))) + (x7553 + (letrec ((x7554 + (cddddr + args))) + (caddr + x7554)))) + (proc + x7562 + x7561 + x7560 + x7559 + x7557 + x7555 + x7553)))) + g7552) + (letrec ((g7563 + (error + "Unsupported call."))) + g7563))))))))))) + g7518))) + (member + (lambda (e l) + (letrec ((g7564 + (letrec ((x7566 (list? l))) + (assert x7566))) + (g7565 + (letrec ((x-cnd7567 (null? l))) + (if x-cnd7567 + #f + (letrec ((x-cnd7568 + (letrec ((x7569 + (car l))) + (equal? x7569 e)))) + (if x-cnd7568 + l + (letrec ((x7570 (cdr l))) + (member e x7570)))))))) + g7565))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7571 + (letrec ((x7572 + (letrec ((x7573 + (letrec ((x7574 + (cdr + x))) + (cdr + x7574)))) + (cdr x7573)))) + (cdr x7572)))) + g7571))) + (cadddr + (lambda (x) + (letrec ((g7575 + (letrec ((x7576 + (letrec ((x7577 + (letrec ((x7578 + (cdr + x))) + (cdr + x7578)))) + (cdr x7577)))) + (car x7576)))) + g7575))) + (int-top + (lambda () + (letrec ((g7579 (random 42))) g7579))) + (zero? + (lambda (x) + (letrec ((g7580 + (letrec ((x7582 (number? x))) + (assert x7582))) + (g7581 (= x 0))) + g7581))) + (string>=? + (lambda (s1 s2) + (letrec ((g7583 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7584 + (if val7155 + val7155 + (string=? s1 s2)))) + g7584)))) + g7583))) + (cadr + (lambda (x) + (letrec ((g7585 + (letrec ((x7586 (cdr x))) + (car x7586)))) + g7585))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7587 + (letrec ((val7156 + (letrec ((x7590 + (pair? l)) + (x7588 + (letrec ((x7589 + (cdr + l))) + (list? + x7589)))) + (and x7590 x7588)))) + (letrec ((g7591 + (if val7156 + val7156 + (null? l)))) + g7591)))) + g7587))) + (cddaar + (lambda (x) + (letrec ((g7592 + (letrec ((x7593 + (letrec ((x7594 + (letrec ((x7595 + (car + x))) + (car + x7595)))) + (cdr x7594)))) + (cdr x7593)))) + g7592))) + (char-numeric? + (lambda (c) + (letrec ((g7596 + (letrec ((x-cnd7597 + (letrec ((x7598 #\0)) + (char<=? x7598 c)))) + (if x-cnd7597 + (letrec ((x7599 #\9)) + (char<=? c x7599)) + #f)))) + g7596))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((x-cnd7603 (null? l))) + (if x-cnd7603 + #f + (letrec ((x-cnd7604 + (letrec ((x7605 + (caar l))) + (eqv? x7605 k)))) + (if x-cnd7604 + (car l) + (letrec ((x7606 (cdr l))) + (assq k x7606)))))))) + g7601))) + (not + (lambda (x) + (letrec ((g7607 (if x #f #t))) g7607))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7608 (append l1 l2))) g7608))) + (memq + (lambda (e l) + (letrec ((g7609 + (letrec ((x7611 (list? l))) + (assert x7611))) + (g7610 + (letrec ((x-cnd7612 (null? l))) + (if x-cnd7612 + #f + (letrec ((x-cnd7613 + (letrec ((x7614 + (car l))) + (eq? x7614 e)))) + (if x-cnd7613 + l + (letrec ((x7615 (cdr l))) + (memq e x7615)))))))) + g7610))) + (cadaar + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 + (letrec ((x7619 + (car + x))) + (car + x7619)))) + (cdr x7618)))) + (car x7617)))) + g7616))) + (length + (lambda (l) + (letrec ((g7620 + (letrec ((x7622 (list? l))) + (assert x7622))) + (g7621 + (letrec ((rec + (lambda (l) + (letrec ((g7623 + (letrec ((x-cnd7624 + (null? + l))) + (if x-cnd7624 + 0 + (letrec ((x7625 + (letrec ((x7626 + (cdr + l))) + (rec + x7626)))) + (+ + 1 + x7625)))))) + g7623)))) + (letrec ((g7627 (rec l))) + g7627)))) + g7621))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((x7635 (string<=? s1 s2))) + (not x7635)))) + g7634))) + (cdadr + (lambda (x) + (letrec ((g7636 + (letrec ((x7637 + (letrec ((x7638 (cdr x))) + (car x7638)))) + (cdr x7637)))) + g7636))) + (assoc + (lambda (k l) + (letrec ((g7639 + (letrec ((x7641 (list? l))) + (assert x7641))) + (g7640 + (letrec ((x-cnd7642 (null? l))) + (if x-cnd7642 + #f + (letrec ((x-cnd7643 + (letrec ((x7644 + (caar l))) + (equal? x7644 k)))) + (if x-cnd7643 + (car l) + (letrec ((x7645 (cdr l))) + (assoc k x7645)))))))) + g7640))) + (caar + (lambda (x) + (letrec ((g7646 + (letrec ((x7647 (car x))) + (car x7647)))) + g7646))) + (char>? + (lambda (c1 c2) + (letrec ((g7648 + (letrec ((x7651 (char? c1))) + (assert x7651))) + (g7649 + (letrec ((x7652 (char? c2))) + (assert x7652))) + (g7650 + (letrec ((x7653 (char<=? c1 c2))) + (not x7653)))) + g7650))) + (string<=? + (lambda (s1 s2) + (letrec ((g7654 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7671 + (letrec ((x7674 (char? c1))) + (assert x7674))) + (g7672 + (letrec ((x7675 (char? c2))) + (assert x7675))) + (g7673 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7676 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7676)))) + g7673))) + (caddar + (lambda (x) + (letrec ((g7677 + (letrec ((x7678 + (letrec ((x7679 + (letrec ((x7680 + (car + x))) + (cdr + x7680)))) + (cdr x7679)))) + (car x7678)))) + g7677))) + (newline + (lambda () (letrec ((g7681 #f)) g7681))) + (lcm + (lambda (m n) + (letrec ((g7682 + (letrec ((x7684 + (letrec ((x7685 (* m n))) + (abs x7685))) + (x7683 (gcd m n))) + (/ x7684 x7683)))) + g7682))) + (deref car) + (> + (lambda (x y) + (letrec ((g7686 + (letrec ((x7688 (number? x))) + (assert x7688))) + (g7687 + (letrec ((x7689 (<= x y))) + (not x7689)))) + g7687))) + (list-ref + (lambda (l index) + (letrec ((g7690 + (letrec ((x7694 (list? l))) + (assert x7694))) + (g7691 + (letrec ((x7695 (number? index))) + (assert x7695))) + (g7692 + (letrec ((x7696 + (letrec ((x7697 + (length l))) + (< index x7697)))) + (assert x7696))) + (g7693 + (letrec ((x-cnd7698 (= index 0))) + (if x-cnd7698 + (car l) + (letrec ((x7700 (cdr l)) + (x7699 (- index 1))) + (list-ref x7700 x7699)))))) + g7693))) + (gcd + (lambda (a b) + (letrec ((g7701 + (letrec ((x-cnd7702 (= b 0))) + (if x-cnd7702 + a + (letrec ((x7703 (modulo a b))) + (gcd b x7703)))))) + g7701))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7704 + (letrec ((x-cnd7705 (real? g7162))) + (if x-cnd7705 + g7162 + (blame g7160 'real?))))) + g7704))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7706 + (letrec ((x-cnd7707 + (boolean? g7165))) + (if x-cnd7707 + g7165 + (blame g7163 'boolean?))))) + g7706))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7708 + (letrec ((x-cnd7709 + (number? g7168))) + (if x-cnd7709 + g7168 + (blame g7166 'number?))))) + g7708))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7710 + (letrec ((x-cnd7711 + ((lambda (v) #t) g7171))) + (if x-cnd7711 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7710))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7712 + (letrec ((x-cnd7713 + ((lambda (v) #t) g7174))) + (if x-cnd7713 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7712))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7714 + (letrec ((x-cnd7715 (pair? g7177))) + (if x-cnd7715 + g7177 + (blame g7175 'pair?))))) + g7714))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7716 + (letrec ((x-cnd7717 (pair? g7180))) + (if x-cnd7717 + g7180 + (blame g7178 'pair?))))) + g7716))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7718 + (letrec ((x-cnd7719 + (integer? g7183))) + (if x-cnd7719 + g7183 + (blame g7181 'integer?))))) + g7718))) + (and/c + (lambda (c1 c2) + (letrec ((g7720 + (lambda (k j v) + (letrec ((g7721 + (letrec ((x-cnd7722 + (c1 k j v))) + (if x-cnd7722 + (c2 k j v) + #f)))) + g7721)))) + g7720))) + (list-of + (lambda (contract) + (letrec ((g7723 + (lambda (k j v) + (letrec ((g7724 + (letrec ((x-cnd7725 + (null? v))) + (if x-cnd7725 + '() + (letrec ((x7729 + (letrec ((x7730 + (car + v))) + (contract + k + j + x7730))) + (x7726 + (letrec ((x7728 + (list-of + contract)) + (x7727 + (cdr + v))) + (x7728 + k + j + x7727)))) + (cons + x7729 + x7726)))))) + g7724)))) + g7723))) + (any? (lambda (v) (letrec ((g7731 #t)) g7731))) + (nonzero? + (lambda (v) + (letrec ((g7732 + (letrec ((x7733 (= v 0))) + (not x7733)))) + g7732))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7734 + (letrec ((x-cnd7735 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7735 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7734))) + (meta (lambda (v) (letrec ((g7736 v)) g7736))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7737 #t)) g7737))) + (cdddr + (lambda (x) + (letrec ((g7738 + (letrec ((x7739 + (letrec ((x7740 (cdr x))) + (cdr x7740)))) + (cdr x7739)))) + g7738))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7741 + (letrec ((x7744 (procedure? f))) + (assert x7744))) + (g7742 + (letrec ((x7745 (list? l))) + (assert x7745))) + (g7743 + (letrec ((x-cnd7746 (null? l))) + (if x-cnd7746 + '() + (letrec ((x7749 + (letrec ((x7750 + (car l))) + (f x7750))) + (x7747 + (letrec ((x7748 + (cdr l))) + (map f x7748)))) + (cons x7749 x7747)))))) + g7743))) + (cdar + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 (car x))) + (cdr x7752)))) + g7751))) + (cadadr + (lambda (x) + (letrec ((g7753 + (letrec ((x7754 + (letrec ((x7755 + (letrec ((x7756 + (cdr + x))) + (car + x7756)))) + (cdr x7755)))) + (car x7754)))) + g7753))) + (cdadar + (lambda (x) + (letrec ((g7757 + (letrec ((x7758 + (letrec ((x7759 + (letrec ((x7760 + (car + x))) + (cdr + x7760)))) + (car x7759)))) + (cdr x7758)))) + g7757))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7761 + (letrec ((x7764 + (string? filename))) + (assert x7764))) + (g7762 + (letrec ((x7765 (procedure? proc))) + (assert x7765))) + (g7763 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7766 + (close-output-port + output-port)) + (g7767 res)) + g7767)))) + g7763))) + (caddr + (lambda (x) + (letrec ((g7768 + (letrec ((x7769 + (letrec ((x7770 (cdr x))) + (cdr x7770)))) + (car x7769)))) + g7768))) + (cdaadr + (lambda (x) + (letrec ((g7771 + (letrec ((x7772 + (letrec ((x7773 + (letrec ((x7774 + (cdr + x))) + (car + x7774)))) + (car x7773)))) + (cdr x7772)))) + g7771))) + (assq + (lambda (k l) + (letrec ((g7775 + (letrec ((x7777 (list? l))) + (assert x7777))) + (g7776 + (letrec ((x-cnd7778 (null? l))) + (if x-cnd7778 + #f + (letrec ((x-cnd7779 + (letrec ((x7780 + (caar l))) + (eq? x7780 k)))) + (if x-cnd7779 + (car l) + (letrec ((x7781 (cdr l))) + (assq k x7781)))))))) + g7776))) + (even? + (lambda (x) + (letrec ((g7782 + (letrec ((x7783 (modulo x 2))) + (= 0 x7783)))) + g7782))) + (list->string + (lambda (l) + (letrec ((g7784 + (letrec ((x7786 (list? l))) + (assert x7786))) + (g7785 + (letrec ((x-cnd7787 (null? l))) + (if x-cnd7787 + "" + (letrec ((x7790 + (letrec ((x7791 + (car l))) + (char->string + x7791))) + (x7788 + (letrec ((x7789 + (cdr l))) + (list->string + x7789)))) + (string-append + x7790 + x7788)))))) + g7785))) + (char<=? + (lambda (c1 c2) + (letrec ((g7792 + (letrec ((x7795 (char? c1))) + (assert x7795))) + (g7793 + (letrec ((x7796 (char? c2))) + (assert x7796))) + (g7794 + (letrec ((val7143 (char=? c x7813)))) + (if x-cnd7812 + (letrec ((x7814 #\z)) + (char-ci<=? c x7814)) + #f)))) + g7811))) + (<= + (lambda (x y) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((val7144 (< x y))) + (letrec ((g7818 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7819 + (if val7145 + val7145 + #f))) + g7819))))) + g7818)))) + g7816))) + (char-whitespace? + (lambda (c) + (letrec ((g7820 + (letrec ((val7146 + (letrec ((x7821 + (char->integer + c))) + (= x7821 9)))) + (letrec ((g7822 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7823 + (char->integer + c))) + (= + x7823 + 10)))) + (letrec ((g7824 + (if val7147 + val7147 + (letrec ((x7825 + (char->integer + c))) + (= + x7825 + 32))))) + g7824))))) + g7822)))) + g7820))) + (cddar + (lambda (x) + (letrec ((g7826 + (letrec ((x7827 + (letrec ((x7828 (car x))) + (cdr x7828)))) + (cdr x7827)))) + g7826))) + (positive? + (lambda (x) + (letrec ((g7829 + (letrec ((x7831 (number? x))) + (assert x7831))) + (g7830 (> x 0))) + g7830))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7832 #f)) g7832))) + (cddr + (lambda (x) + (letrec ((g7833 + (letrec ((x7834 (cdr x))) + (cdr x7834)))) + g7833))) + (truncate + (lambda (x) + (letrec ((g7835 + (letrec ((x7837 (number? x))) + (assert x7837))) + (g7836 + (letrec ((x-cnd7838 (< x 0))) + (if x-cnd7838 + (ceiling x) + (floor x))))) + g7836))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7839 + (letrec ((val7148 (eq? a b))) + (letrec ((g7840 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7842 + (null? + a)) + (x7841 + (null? + b))) + (and x7842 + x7841)))) + (letrec ((g7843 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7846 + (string? + a)) + (x7845 + (string? + b)) + (x7844 + (string=? + a + b))) + (and x7846 + x7845 + x7844)))) + (letrec ((g7847 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7855 + (pair? + a)) + (x7854 + (pair? + b)) + (x7851 + (letrec ((x7853 + (car + a)) + (x7852 + (car + b))) + (equal? + x7853 + x7852))) + (x7848 + (letrec ((x7850 + (cdr + a)) + (x7849 + (cdr + b))) + (equal? + x7850 + x7849)))) + (and x7855 + x7854 + x7851 + x7848)))) + (letrec ((g7856 + (if val7151 + val7151 + (letrec ((x7875 + (vector? + a)) + (x7874 + (vector? + b)) + (x7857 + (letrec ((x7871 + (letrec ((x7872 + (letrec ((x7873 + (vector-length + a))) + (n + x7873)))) + (x7872))) + (x7858 + (letrec ((x7869 + (letrec ((x7870 + (vector-length + b))) + (= + x7870 + n))) + (x7859 + (letrec ((loop + (lambda (i) + (letrec ((g7860 + (letrec ((x7867 + (= + i + n)) + (x7861 + (letrec ((x7864 + (letrec ((x7866 + (vector-ref + a + i)) + (x7865 + (vector-ref + b + i))) + (equal? + x7866 + x7865))) + (x7862 + (letrec ((x7863 + (+ + i + 1))) + (loop + x7863)))) + (and x7864 + x7862)))) + (or x7867 + x7861)))) + g7860)))) + (letrec ((g7868 + (loop + 0))) + g7868)))) + (and x7869 + x7859)))) + (let x7871 x7858)))) + (and x7875 + x7874 + x7857))))) + g7856))))) + g7847))))) + g7843))))) + g7840)))) + g7839))) + (cdaaar + (lambda (x) + (letrec ((g7876 + (letrec ((x7877 + (letrec ((x7878 + (letrec ((x7879 + (car + x))) + (car + x7879)))) + (car x7878)))) + (cdr x7877)))) + g7876))) + (caaddr + (lambda (x) + (letrec ((g7880 + (letrec ((x7881 + (letrec ((x7882 + (letrec ((x7883 + (cdr + x))) + (cdr + x7883)))) + (car x7882)))) + (car x7881)))) + g7880))) + (eqv? + (lambda (x y) + (letrec ((g7884 (eq? x y))) g7884))) + (>= + (lambda (x y) + (letrec ((g7885 + (letrec ((x7887 (number? x))) + (assert x7887))) + (g7886 + (letrec ((val7152 (> x y))) + (letrec ((g7888 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7889 + (if val7153 + val7153 + #f))) + g7889))))) + g7888)))) + g7886))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7890 + (letrec ((x7893 + (string? filename))) + (assert x7893))) + (g7891 + (letrec ((x7894 (procedure? proc))) + (assert x7894))) + (g7892 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7895 + (close-input-port + input-port)) + (g7896 res)) + g7896)))) + g7892))) + (ref + (lambda (x) + (letrec ((g7897 (cons x '()))) g7897))) + (char>=? + (lambda (c1 c2) + (letrec ((g7898 + (letrec ((x7901 (char? c1))) + (assert x7901))) + (g7899 + (letrec ((x7902 (char? c2))) + (assert x7902))) + (g7900 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7903 + (if val7154 + val7154 + (char=? c1 c2)))) + g7903)))) + g7900))) + (cdaar + (lambda (x) + (letrec ((g7904 + (letrec ((x7905 + (letrec ((x7906 (car x))) + (car x7906)))) + (cdr x7905)))) + g7904))) + (cdaddr + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (cdr + x))) + (cdr + x7910)))) + (car x7909)))) + (cdr x7908)))) + g7907))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (cdr x7913)))) + (car x7912)))) + g7911))) + (caadr + (lambda (x) + (letrec ((g7914 + (letrec ((x7915 + (letrec ((x7916 (cdr x))) + (car x7916)))) + (car x7915)))) + g7914))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7917 + (letrec ((x7920 (char? c1))) + (assert x7920))) + (g7918 + (letrec ((x7921 (char? c2))) + (assert x7921))) + (g7919 + (letrec ((x7922 + (char-ci<=? c1 c2))) + (not x7922)))) + g7919))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (car + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (negative? + (lambda (x) + (letrec ((g7927 + (letrec ((x7929 (number? x))) + (assert x7929))) + (g7928 (< x 0))) + g7928))) + (memv + (lambda (e l) + (letrec ((g7930 (memq e l))) g7930))) + (caaar + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 (car x))) + (car x7933)))) + (car x7932)))) + g7931))) + (debug + (lambda (e) (letrec ((g7934 '())) g7934))) + (reverse + (lambda (l) + (letrec ((g7935 + (letrec ((x7937 (list? l))) + (assert x7937))) + (g7936 + (letrec ((x-cnd7938 (null? l))) + (if x-cnd7938 + '() + (letrec ((x7941 + (letrec ((x7942 + (cdr l))) + (reverse x7942))) + (x7939 + (letrec ((x7940 + (car l))) + (list x7940)))) + (append x7941 x7939)))))) + g7936))) + (caaadr + (lambda (x) + (letrec ((g7943 + (letrec ((x7944 + (letrec ((x7945 + (letrec ((x7946 + (cdr + x))) + (car + x7946)))) + (car x7945)))) + (car x7944)))) + g7943))) + (cddadr + (lambda (x) + (letrec ((g7947 + (letrec ((x7948 + (letrec ((x7949 + (letrec ((x7950 + (cdr + x))) + (car + x7950)))) + (cdr x7949)))) + (cdr x7948)))) + g7947))) + (odd? + (lambda (x) + (letrec ((g7951 + (letrec ((x7953 (number? x))) + (assert x7953))) + (g7952 + (letrec ((x7954 (modulo x 2))) + (= 1 x7954)))) + g7952))) + (caadar + (lambda (x) + (letrec ((g7955 + (letrec ((x7956 + (letrec ((x7957 + (letrec ((x7958 + (car + x))) + (cdr + x7958)))) + (car x7957)))) + (car x7956)))) + g7955))) + (apply + (lambda (proc args) + (letrec ((g7959 + (letrec ((x7962 (procedure? proc))) + (assert x7962))) + (g7960 + (letrec ((x7963 (list? args))) + (assert x7963))) + (g7961 + (if cnd + (letrec ((g7964 (proc))) g7964) + (if cnd + (letrec ((g7965 + (letrec ((x7966 + (car + args))) + (proc x7966)))) + g7965) + (if cnd + (letrec ((g7967 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args))) + (proc + x7969 + x7968)))) + g7967) + (if cnd + (letrec ((g7970 + (letrec ((x7973 + (car + args)) + (x7972 + (cadr + args)) + (x7971 + (caddr + args))) + (proc + x7973 + x7972 + x7971)))) + g7970) + (if cnd + (letrec ((g7974 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args))) + (proc + x7978 + x7977 + x7976 + x7975)))) + g7974) + (if cnd + (letrec ((g7979 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980)))) + g7979) + (if cnd + (letrec ((g7986 + (letrec ((x7994 + (car + args)) + (x7993 + (cadr + args)) + (x7992 + (caddr + args)) + (x7991 + (cadddr + args)) + (x7989 + (letrec ((x7990 + (cddddr + args))) + (car + x7990))) + (x7987 + (letrec ((x7988 + (cddddr + args))) + (cadr + x7988)))) + (proc + x7994 + x7993 + x7992 + x7991 + x7989 + x7987)))) + g7986) + (if cnd + (letrec ((g7995 + (letrec ((x8005 + (car + args)) + (x8004 + (cadr + args)) + (x8003 + (caddr + args)) + (x8002 + (cadddr + args)) + (x8000 + (letrec ((x8001 + (cddddr + args))) + (car + x8001))) + (x7998 + (letrec ((x7999 + (cddddr + args))) + (cadr + x7999))) + (x7996 + (letrec ((x7997 + (cddddr + args))) + (caddr + x7997)))) + (proc + x8005 + x8004 + x8003 + x8002 + x8000 + x7998 + x7996)))) + g7995) + (letrec ((g8006 + (error + "Unsupported call."))) + g8006))))))))))) + g7961))) + (member + (lambda (e l) + (letrec ((g8007 + (letrec ((x8009 (list? l))) + (assert x8009))) + (g8008 + (letrec ((x-cnd8010 (null? l))) + (if x-cnd8010 + #f + (letrec ((x-cnd8011 + (letrec ((x8012 + (car l))) + (equal? x8012 e)))) + (if x-cnd8011 + l + (letrec ((x8013 (cdr l))) + (member e x8013)))))))) + g8008))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8014 + (letrec ((x8015 + (letrec ((x8016 + (letrec ((x8017 + (cdr + x))) + (cdr + x8017)))) + (cdr x8016)))) + (cdr x8015)))) + g8014))) + (cadddr + (lambda (x) + (letrec ((g8018 + (letrec ((x8019 + (letrec ((x8020 + (letrec ((x8021 + (cdr + x))) + (cdr + x8021)))) + (cdr x8020)))) + (car x8019)))) + g8018))) + (int-top + (lambda () + (letrec ((g8022 (random 42))) g8022))) + (zero? + (lambda (x) + (letrec ((g8023 + (letrec ((x8025 (number? x))) + (assert x8025))) + (g8024 (= x 0))) + g8024))) + (string>=? + (lambda (s1 s2) + (letrec ((g8026 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8027 + (if val7155 + val7155 + (string=? s1 s2)))) + g8027)))) + g8026))) + (cadr + (lambda (x) + (letrec ((g8028 + (letrec ((x8029 (cdr x))) + (car x8029)))) + g8028))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8030 + (letrec ((val7156 + (letrec ((x8033 + (pair? l)) + (x8031 + (letrec ((x8032 + (cdr + l))) + (list? + x8032)))) + (and x8033 x8031)))) + (letrec ((g8034 + (if val7156 + val7156 + (null? l)))) + g8034)))) + g8030))) + (cddaar + (lambda (x) + (letrec ((g8035 + (letrec ((x8036 + (letrec ((x8037 + (letrec ((x8038 + (car + x))) + (car + x8038)))) + (cdr x8037)))) + (cdr x8036)))) + g8035))) + (char-numeric? + (lambda (c) + (letrec ((g8039 + (letrec ((x-cnd8040 + (letrec ((x8041 #\0)) + (char<=? x8041 c)))) + (if x-cnd8040 + (letrec ((x8042 #\9)) + (char<=? c x8042)) + #f)))) + g8039))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((x-cnd8046 (null? l))) + (if x-cnd8046 + #f + (letrec ((x-cnd8047 + (letrec ((x8048 + (caar l))) + (eqv? x8048 k)))) + (if x-cnd8047 + (car l) + (letrec ((x8049 (cdr l))) + (assq k x8049)))))))) + g8044))) + (not + (lambda (x) + (letrec ((g8050 (if x #f #t))) g8050))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8051 (append l1 l2))) g8051))) + (memq + (lambda (e l) + (letrec ((g8052 + (letrec ((x8054 (list? l))) + (assert x8054))) + (g8053 + (letrec ((x-cnd8055 (null? l))) + (if x-cnd8055 + #f + (letrec ((x-cnd8056 + (letrec ((x8057 + (car l))) + (eq? x8057 e)))) + (if x-cnd8056 + l + (letrec ((x8058 (cdr l))) + (memq e x8058)))))))) + g8053))) + (cadaar + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 + (letrec ((x8062 + (car + x))) + (car + x8062)))) + (cdr x8061)))) + (car x8060)))) + g8059))) + (length + (lambda (l) + (letrec ((g8063 + (letrec ((x8065 (list? l))) + (assert x8065))) + (g8064 + (letrec ((rec + (lambda (l) + (letrec ((g8066 + (letrec ((x-cnd8067 + (null? + l))) + (if x-cnd8067 + 0 + (letrec ((x8068 + (letrec ((x8069 + (cdr + l))) + (rec + x8069)))) + (+ + 1 + x8068)))))) + g8066)))) + (letrec ((g8070 (rec l))) + g8070)))) + g8064))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((x8078 (string<=? s1 s2))) + (not x8078)))) + g8077))) + (cdadr + (lambda (x) + (letrec ((g8079 + (letrec ((x8080 + (letrec ((x8081 (cdr x))) + (car x8081)))) + (cdr x8080)))) + g8079))) + (assoc + (lambda (k l) + (letrec ((g8082 + (letrec ((x8084 (list? l))) + (assert x8084))) + (g8083 + (letrec ((x-cnd8085 (null? l))) + (if x-cnd8085 + #f + (letrec ((x-cnd8086 + (letrec ((x8087 + (caar l))) + (equal? x8087 k)))) + (if x-cnd8086 + (car l) + (letrec ((x8088 (cdr l))) + (assoc k x8088)))))))) + g8083))) + (caar + (lambda (x) + (letrec ((g8089 + (letrec ((x8090 (car x))) + (car x8090)))) + g8089))) + (char>? + (lambda (c1 c2) + (letrec ((g8091 + (letrec ((x8094 (char? c1))) + (assert x8094))) + (g8092 + (letrec ((x8095 (char? c2))) + (assert x8095))) + (g8093 + (letrec ((x8096 (char<=? c1 c2))) + (not x8096)))) + g8093))) + (string<=? + (lambda (s1 s2) + (letrec ((g8097 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8114 + (letrec ((x8117 (char? c1))) + (assert x8117))) + (g8115 + (letrec ((x8118 (char? c2))) + (assert x8118))) + (g8116 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8119 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8119)))) + g8116))) + (caddar + (lambda (x) + (letrec ((g8120 + (letrec ((x8121 + (letrec ((x8122 + (letrec ((x8123 + (car + x))) + (cdr + x8123)))) + (cdr x8122)))) + (car x8121)))) + g8120))) + (newline + (lambda () (letrec ((g8124 #f)) g8124))) + (lcm + (lambda (m n) + (letrec ((g8125 + (letrec ((x8127 + (letrec ((x8128 (* m n))) + (abs x8128))) + (x8126 (gcd m n))) + (/ x8127 x8126)))) + g8125))) + (deref car) + (> + (lambda (x y) + (letrec ((g8129 + (letrec ((x8131 (number? x))) + (assert x8131))) + (g8130 + (letrec ((x8132 (<= x y))) + (not x8132)))) + g8130))) + (list-ref + (lambda (l index) + (letrec ((g8133 + (letrec ((x8137 (list? l))) + (assert x8137))) + (g8134 + (letrec ((x8138 (number? index))) + (assert x8138))) + (g8135 + (letrec ((x8139 + (letrec ((x8140 + (length l))) + (< index x8140)))) + (assert x8139))) + (g8136 + (letrec ((x-cnd8141 (= index 0))) + (if x-cnd8141 + (car l) + (letrec ((x8143 (cdr l)) + (x8142 (- index 1))) + (list-ref x8143 x8142)))))) + g8136))) + (gcd + (lambda (a b) + (letrec ((g8144 + (letrec ((x-cnd8145 (= b 0))) + (if x-cnd8145 + a + (letrec ((x8146 (modulo a b))) + (gcd b x8146)))))) + g8144)))) + (letrec ((g8147 + (letrec ((g8148 + (letrec ((foldr + (lambda (f z xs) + (letrec ((g8149 + (letrec ((x-cnd8150 + (empty? + xs))) + (if x-cnd8150 + z + (letrec ((x8153 + (car + xs)) + (x8151 + (letrec ((x8152 + (cdr + xs))) + (foldr + f + z + x8152)))) + (f + x8153 + x8151)))))) + g8149))) + (map + (lambda (f xs) + (letrec ((g8154 + (letrec ((x8155 + (letrec ((x8158 + (x + ys)) + (x8156 + (letrec ((x8157 + (f + x))) + (cons + x8157 + ys)))) + (λ x8158 + x8156)))) + (foldr + x8155 + empty + xs)))) + g8154)))) + (letrec ((g8159 + (letrec ((g8160 + (letrec ((g8161 + (letrec ((x8166 + ((lambda (j7232 + k7233 + f7234) + (lambda (g7229 + g7230 + g7231) + (any/c + j7232 + k7233 + (f7234 + ((lambda (j7237 + k7238 + f7239) + (lambda (g7235 + g7236) + (any/c + j7237 + k7238 + (f7239 + (any/c + j7237 + k7238 + g7235) + (any/c + j7237 + k7238 + g7236))))) + j7232 + k7233 + g7229) + (any/c + j7232 + k7233 + g7230) + ((listof + any/c) + j7232 + k7233 + g7231))))) + 'module + 'importer + foldr)) + (x8165 + (input)) + (x8164 + (input)) + (x8163 + (input))) + (x8166 + x8165 + x8164 + x8163))) + (g8162 + (letrec ((x8169 + ((lambda (j7242 + k7243 + f7244) + (lambda (g7240 + g7241) + ((listof + any/c) + j7242 + k7243 + (f7244 + ((lambda (j7246 + k7247 + f7248) + (lambda (g7245) + (any/c + j7246 + k7247 + (f7248 + (any/c + j7246 + k7247 + g7245))))) + j7242 + k7243 + g7240) + ((listof + any/c) + j7242 + k7243 + g7241))))) + 'module + 'importer + map)) + (x8168 + (input)) + (x8167 + (input))) + (x8169 + x8168 + x8167)))) + g8162))) + g8160))) + g8159)))) + g8148))) + g8147)))) + g7260))) + g7259)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_mappend.rkt b/analyses/simpleactor/benchmarks-out/mochi_mappend.rkt index ef72d2a2..0d65ab51 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_mappend.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_mappend.rkt @@ -1,51 +1,3153 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7243 #t)) g7243))) + (meta (lambda (v) (letrec ((g7244 v)) g7244))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7245 + (letrec ((g7246 + (letrec ((x-e7247 lst)) + (match + x-e7247 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7248 (eq? v v1))) + (if x-cnd7248 #t (member v vs))))))))) + g7246))) + g7245))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (mappend xs ys) - (if (empty? xs) ys (cons (car xs) (mappend (cdr xs) ys)))) - (define (map-append f xs) - (if (empty? xs) empty (mappend (f (car xs)) (map-append f (cdr xs))))) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - ((listof any/c) - j3985 - k3986 - (f3987 - ((lambda (j3989 k3990 f3991) - (lambda (g3988) - ((listof any/c) - j3989 - k3990 - (f3991 (any/c j3989 k3990 g3988))))) - j3985 - k3986 - g3983) - ((listof any/c) j3985 k3986 g3984))))) - 'module - 'importer - map-append) - (input) - (input)) - (((lambda (j3994 k3995 f3996) - (lambda (g3992 g3993) - ((listof any/c) - j3994 - k3995 - (f3996 - ((listof any/c) j3994 k3995 g3992) - ((listof any/c) j3994 k3995 g3993))))) - 'module - 'importer - mappend) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7249 (lambda (v) (letrec ((g7250 v)) g7250)))) g7249))) + (nonzero? + (lambda (v) + (letrec ((g7251 (letrec ((x7252 (= v 0))) (not x7252)))) g7251)))) + (letrec ((g7253 + (letrec ((g7254 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7255 + (letrec ((x-cnd7256 (real? g7162))) + (if x-cnd7256 + g7162 + (blame g7160 'real?))))) + g7255))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7257 + (letrec ((x-cnd7258 + (boolean? g7165))) + (if x-cnd7258 + g7165 + (blame g7163 'boolean?))))) + g7257))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7259 + (letrec ((x-cnd7260 + (number? g7168))) + (if x-cnd7260 + g7168 + (blame g7166 'number?))))) + g7259))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7261 + (letrec ((x-cnd7262 + ((lambda (v) #t) g7171))) + (if x-cnd7262 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7261))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7263 + (letrec ((x-cnd7264 + ((lambda (v) #t) g7174))) + (if x-cnd7264 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7263))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7265 + (letrec ((x-cnd7266 (pair? g7177))) + (if x-cnd7266 + g7177 + (blame g7175 'pair?))))) + g7265))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7267 + (letrec ((x-cnd7268 (pair? g7180))) + (if x-cnd7268 + g7180 + (blame g7178 'pair?))))) + g7267))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7269 + (letrec ((x-cnd7270 + (integer? g7183))) + (if x-cnd7270 + g7183 + (blame g7181 'integer?))))) + g7269))) + (and/c + (lambda (c1 c2) + (letrec ((g7271 + (lambda (k j v) + (letrec ((g7272 + (letrec ((x-cnd7273 + (c1 k j v))) + (if x-cnd7273 + (c2 k j v) + #f)))) + g7272)))) + g7271))) + (list-of + (lambda (contract) + (letrec ((g7274 + (lambda (k j v) + (letrec ((g7275 + (letrec ((x-cnd7276 + (null? v))) + (if x-cnd7276 + '() + (letrec ((x7280 + (letrec ((x7281 + (car + v))) + (contract + k + j + x7281))) + (x7277 + (letrec ((x7279 + (list-of + contract)) + (x7278 + (cdr + v))) + (x7279 + k + j + x7278)))) + (cons + x7280 + x7277)))))) + g7275)))) + g7274))) + (any? (lambda (v) (letrec ((g7282 #t)) g7282))) + (nonzero? + (lambda (v) + (letrec ((g7283 + (letrec ((x7284 (= v 0))) + (not x7284)))) + g7283))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7285 + (letrec ((x-cnd7286 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7286 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7285))) + (meta (lambda (v) (letrec ((g7287 v)) g7287))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7288 #t)) g7288))) + (cdddr + (lambda (x) + (letrec ((g7289 + (letrec ((x7290 + (letrec ((x7291 (cdr x))) + (cdr x7291)))) + (cdr x7290)))) + g7289))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7292 + (letrec ((x7295 (procedure? f))) + (assert x7295))) + (g7293 + (letrec ((x7296 (list? l))) + (assert x7296))) + (g7294 + (letrec ((x-cnd7297 (null? l))) + (if x-cnd7297 + '() + (letrec ((x7300 + (letrec ((x7301 + (car l))) + (f x7301))) + (x7298 + (letrec ((x7299 + (cdr l))) + (map f x7299)))) + (cons x7300 x7298)))))) + g7294))) + (cdar + (lambda (x) + (letrec ((g7302 + (letrec ((x7303 (car x))) + (cdr x7303)))) + g7302))) + (cadadr + (lambda (x) + (letrec ((g7304 + (letrec ((x7305 + (letrec ((x7306 + (letrec ((x7307 + (cdr + x))) + (car + x7307)))) + (cdr x7306)))) + (car x7305)))) + g7304))) + (cdadar + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (car + x))) + (cdr + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7312 + (letrec ((x7315 + (string? filename))) + (assert x7315))) + (g7313 + (letrec ((x7316 (procedure? proc))) + (assert x7316))) + (g7314 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7317 + (close-output-port + output-port)) + (g7318 res)) + g7318)))) + g7314))) + (caddr + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 + (letrec ((x7321 (cdr x))) + (cdr x7321)))) + (car x7320)))) + g7319))) + (cdaadr + (lambda (x) + (letrec ((g7322 + (letrec ((x7323 + (letrec ((x7324 + (letrec ((x7325 + (cdr + x))) + (car + x7325)))) + (car x7324)))) + (cdr x7323)))) + g7322))) + (assq + (lambda (k l) + (letrec ((g7326 + (letrec ((x7328 (list? l))) + (assert x7328))) + (g7327 + (letrec ((x-cnd7329 (null? l))) + (if x-cnd7329 + #f + (letrec ((x-cnd7330 + (letrec ((x7331 + (caar l))) + (eq? x7331 k)))) + (if x-cnd7330 + (car l) + (letrec ((x7332 (cdr l))) + (assq k x7332)))))))) + g7327))) + (even? + (lambda (x) + (letrec ((g7333 + (letrec ((x7334 (modulo x 2))) + (= 0 x7334)))) + g7333))) + (list->string + (lambda (l) + (letrec ((g7335 + (letrec ((x7337 (list? l))) + (assert x7337))) + (g7336 + (letrec ((x-cnd7338 (null? l))) + (if x-cnd7338 + "" + (letrec ((x7341 + (letrec ((x7342 + (car l))) + (char->string + x7342))) + (x7339 + (letrec ((x7340 + (cdr l))) + (list->string + x7340)))) + (string-append + x7341 + x7339)))))) + g7336))) + (char<=? + (lambda (c1 c2) + (letrec ((g7343 + (letrec ((x7346 (char? c1))) + (assert x7346))) + (g7344 + (letrec ((x7347 (char? c2))) + (assert x7347))) + (g7345 + (letrec ((val7143 (char=? c x7364)))) + (if x-cnd7363 + (letrec ((x7365 #\z)) + (char-ci<=? c x7365)) + #f)))) + g7362))) + (<= + (lambda (x y) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 + (letrec ((val7144 (< x y))) + (letrec ((g7369 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7370 + (if val7145 + val7145 + #f))) + g7370))))) + g7369)))) + g7367))) + (char-whitespace? + (lambda (c) + (letrec ((g7371 + (letrec ((val7146 + (letrec ((x7372 + (char->integer + c))) + (= x7372 9)))) + (letrec ((g7373 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7374 + (char->integer + c))) + (= + x7374 + 10)))) + (letrec ((g7375 + (if val7147 + val7147 + (letrec ((x7376 + (char->integer + c))) + (= + x7376 + 32))))) + g7375))))) + g7373)))) + g7371))) + (cddar + (lambda (x) + (letrec ((g7377 + (letrec ((x7378 + (letrec ((x7379 (car x))) + (cdr x7379)))) + (cdr x7378)))) + g7377))) + (positive? + (lambda (x) + (letrec ((g7380 + (letrec ((x7382 (number? x))) + (assert x7382))) + (g7381 (> x 0))) + g7381))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7383 #f)) g7383))) + (cddr + (lambda (x) + (letrec ((g7384 + (letrec ((x7385 (cdr x))) + (cdr x7385)))) + g7384))) + (truncate + (lambda (x) + (letrec ((g7386 + (letrec ((x7388 (number? x))) + (assert x7388))) + (g7387 + (letrec ((x-cnd7389 (< x 0))) + (if x-cnd7389 + (ceiling x) + (floor x))))) + g7387))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7390 + (letrec ((val7148 (eq? a b))) + (letrec ((g7391 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7393 + (null? + a)) + (x7392 + (null? + b))) + (and x7393 + x7392)))) + (letrec ((g7394 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7397 + (string? + a)) + (x7396 + (string? + b)) + (x7395 + (string=? + a + b))) + (and x7397 + x7396 + x7395)))) + (letrec ((g7398 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7406 + (pair? + a)) + (x7405 + (pair? + b)) + (x7402 + (letrec ((x7404 + (car + a)) + (x7403 + (car + b))) + (equal? + x7404 + x7403))) + (x7399 + (letrec ((x7401 + (cdr + a)) + (x7400 + (cdr + b))) + (equal? + x7401 + x7400)))) + (and x7406 + x7405 + x7402 + x7399)))) + (letrec ((g7407 + (if val7151 + val7151 + (letrec ((x7426 + (vector? + a)) + (x7425 + (vector? + b)) + (x7408 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (vector-length + a))) + (n + x7424)))) + (x7423))) + (x7409 + (letrec ((x7420 + (letrec ((x7421 + (vector-length + b))) + (= + x7421 + n))) + (x7410 + (letrec ((loop + (lambda (i) + (letrec ((g7411 + (letrec ((x7418 + (= + i + n)) + (x7412 + (letrec ((x7415 + (letrec ((x7417 + (vector-ref + a + i)) + (x7416 + (vector-ref + b + i))) + (equal? + x7417 + x7416))) + (x7413 + (letrec ((x7414 + (+ + i + 1))) + (loop + x7414)))) + (and x7415 + x7413)))) + (or x7418 + x7412)))) + g7411)))) + (letrec ((g7419 + (loop + 0))) + g7419)))) + (and x7420 + x7410)))) + (let x7422 x7409)))) + (and x7426 + x7425 + x7408))))) + g7407))))) + g7398))))) + g7394))))) + g7391)))) + g7390))) + (cdaaar + (lambda (x) + (letrec ((g7427 + (letrec ((x7428 + (letrec ((x7429 + (letrec ((x7430 + (car + x))) + (car + x7430)))) + (car x7429)))) + (cdr x7428)))) + g7427))) + (caaddr + (lambda (x) + (letrec ((g7431 + (letrec ((x7432 + (letrec ((x7433 + (letrec ((x7434 + (cdr + x))) + (cdr + x7434)))) + (car x7433)))) + (car x7432)))) + g7431))) + (eqv? + (lambda (x y) + (letrec ((g7435 (eq? x y))) g7435))) + (>= + (lambda (x y) + (letrec ((g7436 + (letrec ((x7438 (number? x))) + (assert x7438))) + (g7437 + (letrec ((val7152 (> x y))) + (letrec ((g7439 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7440 + (if val7153 + val7153 + #f))) + g7440))))) + g7439)))) + g7437))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7441 + (letrec ((x7444 + (string? filename))) + (assert x7444))) + (g7442 + (letrec ((x7445 (procedure? proc))) + (assert x7445))) + (g7443 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7446 + (close-input-port + input-port)) + (g7447 res)) + g7447)))) + g7443))) + (ref + (lambda (x) + (letrec ((g7448 (cons x '()))) g7448))) + (char>=? + (lambda (c1 c2) + (letrec ((g7449 + (letrec ((x7452 (char? c1))) + (assert x7452))) + (g7450 + (letrec ((x7453 (char? c2))) + (assert x7453))) + (g7451 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7454 + (if val7154 + val7154 + (char=? c1 c2)))) + g7454)))) + g7451))) + (cdaar + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (car x))) + (car x7457)))) + (cdr x7456)))) + g7455))) + (cdaddr + (lambda (x) + (letrec ((g7458 + (letrec ((x7459 + (letrec ((x7460 + (letrec ((x7461 + (cdr + x))) + (cdr + x7461)))) + (car x7460)))) + (cdr x7459)))) + g7458))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7462 + (letrec ((x7463 + (letrec ((x7464 (car x))) + (cdr x7464)))) + (car x7463)))) + g7462))) + (caadr + (lambda (x) + (letrec ((g7465 + (letrec ((x7466 + (letrec ((x7467 (cdr x))) + (car x7467)))) + (car x7466)))) + g7465))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7468 + (letrec ((x7471 (char? c1))) + (assert x7471))) + (g7469 + (letrec ((x7472 (char? c2))) + (assert x7472))) + (g7470 + (letrec ((x7473 + (char-ci<=? c1 c2))) + (not x7473)))) + g7470))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7474 + (letrec ((x7475 + (letrec ((x7476 + (letrec ((x7477 + (car + x))) + (car + x7477)))) + (car x7476)))) + (car x7475)))) + g7474))) + (negative? + (lambda (x) + (letrec ((g7478 + (letrec ((x7480 (number? x))) + (assert x7480))) + (g7479 (< x 0))) + g7479))) + (memv + (lambda (e l) + (letrec ((g7481 (memq e l))) g7481))) + (caaar + (lambda (x) + (letrec ((g7482 + (letrec ((x7483 + (letrec ((x7484 (car x))) + (car x7484)))) + (car x7483)))) + g7482))) + (debug + (lambda (e) (letrec ((g7485 '())) g7485))) + (reverse + (lambda (l) + (letrec ((g7486 + (letrec ((x7488 (list? l))) + (assert x7488))) + (g7487 + (letrec ((x-cnd7489 (null? l))) + (if x-cnd7489 + '() + (letrec ((x7492 + (letrec ((x7493 + (cdr l))) + (reverse x7493))) + (x7490 + (letrec ((x7491 + (car l))) + (list x7491)))) + (append x7492 x7490)))))) + g7487))) + (caaadr + (lambda (x) + (letrec ((g7494 + (letrec ((x7495 + (letrec ((x7496 + (letrec ((x7497 + (cdr + x))) + (car + x7497)))) + (car x7496)))) + (car x7495)))) + g7494))) + (cddadr + (lambda (x) + (letrec ((g7498 + (letrec ((x7499 + (letrec ((x7500 + (letrec ((x7501 + (cdr + x))) + (car + x7501)))) + (cdr x7500)))) + (cdr x7499)))) + g7498))) + (odd? + (lambda (x) + (letrec ((g7502 + (letrec ((x7504 (number? x))) + (assert x7504))) + (g7503 + (letrec ((x7505 (modulo x 2))) + (= 1 x7505)))) + g7503))) + (caadar + (lambda (x) + (letrec ((g7506 + (letrec ((x7507 + (letrec ((x7508 + (letrec ((x7509 + (car + x))) + (cdr + x7509)))) + (car x7508)))) + (car x7507)))) + g7506))) + (apply + (lambda (proc args) + (letrec ((g7510 + (letrec ((x7513 (procedure? proc))) + (assert x7513))) + (g7511 + (letrec ((x7514 (list? args))) + (assert x7514))) + (g7512 + (if cnd + (letrec ((g7515 (proc))) g7515) + (if cnd + (letrec ((g7516 + (letrec ((x7517 + (car + args))) + (proc x7517)))) + g7516) + (if cnd + (letrec ((g7518 + (letrec ((x7520 + (car + args)) + (x7519 + (cadr + args))) + (proc + x7520 + x7519)))) + g7518) + (if cnd + (letrec ((g7521 + (letrec ((x7524 + (car + args)) + (x7523 + (cadr + args)) + (x7522 + (caddr + args))) + (proc + x7524 + x7523 + x7522)))) + g7521) + (if cnd + (letrec ((g7525 + (letrec ((x7529 + (car + args)) + (x7528 + (cadr + args)) + (x7527 + (caddr + args)) + (x7526 + (cadddr + args))) + (proc + x7529 + x7528 + x7527 + x7526)))) + g7525) + (if cnd + (letrec ((g7530 + (letrec ((x7536 + (car + args)) + (x7535 + (cadr + args)) + (x7534 + (caddr + args)) + (x7533 + (cadddr + args)) + (x7531 + (letrec ((x7532 + (cddddr + args))) + (car + x7532)))) + (proc + x7536 + x7535 + x7534 + x7533 + x7531)))) + g7530) + (if cnd + (letrec ((g7537 + (letrec ((x7545 + (car + args)) + (x7544 + (cadr + args)) + (x7543 + (caddr + args)) + (x7542 + (cadddr + args)) + (x7540 + (letrec ((x7541 + (cddddr + args))) + (car + x7541))) + (x7538 + (letrec ((x7539 + (cddddr + args))) + (cadr + x7539)))) + (proc + x7545 + x7544 + x7543 + x7542 + x7540 + x7538)))) + g7537) + (if cnd + (letrec ((g7546 + (letrec ((x7556 + (car + args)) + (x7555 + (cadr + args)) + (x7554 + (caddr + args)) + (x7553 + (cadddr + args)) + (x7551 + (letrec ((x7552 + (cddddr + args))) + (car + x7552))) + (x7549 + (letrec ((x7550 + (cddddr + args))) + (cadr + x7550))) + (x7547 + (letrec ((x7548 + (cddddr + args))) + (caddr + x7548)))) + (proc + x7556 + x7555 + x7554 + x7553 + x7551 + x7549 + x7547)))) + g7546) + (letrec ((g7557 + (error + "Unsupported call."))) + g7557))))))))))) + g7512))) + (member + (lambda (e l) + (letrec ((g7558 + (letrec ((x7560 (list? l))) + (assert x7560))) + (g7559 + (letrec ((x-cnd7561 (null? l))) + (if x-cnd7561 + #f + (letrec ((x-cnd7562 + (letrec ((x7563 + (car l))) + (equal? x7563 e)))) + (if x-cnd7562 + l + (letrec ((x7564 (cdr l))) + (member e x7564)))))))) + g7559))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 + (letrec ((x7567 + (letrec ((x7568 + (cdr + x))) + (cdr + x7568)))) + (cdr x7567)))) + (cdr x7566)))) + g7565))) + (cadddr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 + (letrec ((x7571 + (letrec ((x7572 + (cdr + x))) + (cdr + x7572)))) + (cdr x7571)))) + (car x7570)))) + g7569))) + (int-top + (lambda () + (letrec ((g7573 (random 42))) g7573))) + (zero? + (lambda (x) + (letrec ((g7574 + (letrec ((x7576 (number? x))) + (assert x7576))) + (g7575 (= x 0))) + g7575))) + (string>=? + (lambda (s1 s2) + (letrec ((g7577 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7578 + (if val7155 + val7155 + (string=? s1 s2)))) + g7578)))) + g7577))) + (cadr + (lambda (x) + (letrec ((g7579 + (letrec ((x7580 (cdr x))) + (car x7580)))) + g7579))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7581 + (letrec ((val7156 + (letrec ((x7584 + (pair? l)) + (x7582 + (letrec ((x7583 + (cdr + l))) + (list? + x7583)))) + (and x7584 x7582)))) + (letrec ((g7585 + (if val7156 + val7156 + (null? l)))) + g7585)))) + g7581))) + (cddaar + (lambda (x) + (letrec ((g7586 + (letrec ((x7587 + (letrec ((x7588 + (letrec ((x7589 + (car + x))) + (car + x7589)))) + (cdr x7588)))) + (cdr x7587)))) + g7586))) + (char-numeric? + (lambda (c) + (letrec ((g7590 + (letrec ((x-cnd7591 + (letrec ((x7592 #\0)) + (char<=? x7592 c)))) + (if x-cnd7591 + (letrec ((x7593 #\9)) + (char<=? c x7593)) + #f)))) + g7590))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7594 + (letrec ((x7596 (list? l))) + (assert x7596))) + (g7595 + (letrec ((x-cnd7597 (null? l))) + (if x-cnd7597 + #f + (letrec ((x-cnd7598 + (letrec ((x7599 + (caar l))) + (eqv? x7599 k)))) + (if x-cnd7598 + (car l) + (letrec ((x7600 (cdr l))) + (assq k x7600)))))))) + g7595))) + (not + (lambda (x) + (letrec ((g7601 (if x #f #t))) g7601))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7602 (append l1 l2))) g7602))) + (memq + (lambda (e l) + (letrec ((g7603 + (letrec ((x7605 (list? l))) + (assert x7605))) + (g7604 + (letrec ((x-cnd7606 (null? l))) + (if x-cnd7606 + #f + (letrec ((x-cnd7607 + (letrec ((x7608 + (car l))) + (eq? x7608 e)))) + (if x-cnd7607 + l + (letrec ((x7609 (cdr l))) + (memq e x7609)))))))) + g7604))) + (cadaar + (lambda (x) + (letrec ((g7610 + (letrec ((x7611 + (letrec ((x7612 + (letrec ((x7613 + (car + x))) + (car + x7613)))) + (cdr x7612)))) + (car x7611)))) + g7610))) + (length + (lambda (l) + (letrec ((g7614 + (letrec ((x7616 (list? l))) + (assert x7616))) + (g7615 + (letrec ((rec + (lambda (l) + (letrec ((g7617 + (letrec ((x-cnd7618 + (null? + l))) + (if x-cnd7618 + 0 + (letrec ((x7619 + (letrec ((x7620 + (cdr + l))) + (rec + x7620)))) + (+ + 1 + x7619)))))) + g7617)))) + (letrec ((g7621 (rec l))) + g7621)))) + g7615))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7622 + (letrec ((x7625 (char? c1))) + (assert x7625))) + (g7623 + (letrec ((x7626 (char? c2))) + (assert x7626))) + (g7624 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7628 + (letrec ((x7629 (string<=? s1 s2))) + (not x7629)))) + g7628))) + (cdadr + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 + (letrec ((x7632 (cdr x))) + (car x7632)))) + (cdr x7631)))) + g7630))) + (assoc + (lambda (k l) + (letrec ((g7633 + (letrec ((x7635 (list? l))) + (assert x7635))) + (g7634 + (letrec ((x-cnd7636 (null? l))) + (if x-cnd7636 + #f + (letrec ((x-cnd7637 + (letrec ((x7638 + (caar l))) + (equal? x7638 k)))) + (if x-cnd7637 + (car l) + (letrec ((x7639 (cdr l))) + (assoc k x7639)))))))) + g7634))) + (caar + (lambda (x) + (letrec ((g7640 + (letrec ((x7641 (car x))) + (car x7641)))) + g7640))) + (char>? + (lambda (c1 c2) + (letrec ((g7642 + (letrec ((x7645 (char? c1))) + (assert x7645))) + (g7643 + (letrec ((x7646 (char? c2))) + (assert x7646))) + (g7644 + (letrec ((x7647 (char<=? c1 c2))) + (not x7647)))) + g7644))) + (string<=? + (lambda (s1 s2) + (letrec ((g7648 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7665 + (letrec ((x7668 (char? c1))) + (assert x7668))) + (g7666 + (letrec ((x7669 (char? c2))) + (assert x7669))) + (g7667 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7670 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7670)))) + g7667))) + (caddar + (lambda (x) + (letrec ((g7671 + (letrec ((x7672 + (letrec ((x7673 + (letrec ((x7674 + (car + x))) + (cdr + x7674)))) + (cdr x7673)))) + (car x7672)))) + g7671))) + (newline + (lambda () (letrec ((g7675 #f)) g7675))) + (lcm + (lambda (m n) + (letrec ((g7676 + (letrec ((x7678 + (letrec ((x7679 (* m n))) + (abs x7679))) + (x7677 (gcd m n))) + (/ x7678 x7677)))) + g7676))) + (deref car) + (> + (lambda (x y) + (letrec ((g7680 + (letrec ((x7682 (number? x))) + (assert x7682))) + (g7681 + (letrec ((x7683 (<= x y))) + (not x7683)))) + g7681))) + (list-ref + (lambda (l index) + (letrec ((g7684 + (letrec ((x7688 (list? l))) + (assert x7688))) + (g7685 + (letrec ((x7689 (number? index))) + (assert x7689))) + (g7686 + (letrec ((x7690 + (letrec ((x7691 + (length l))) + (< index x7691)))) + (assert x7690))) + (g7687 + (letrec ((x-cnd7692 (= index 0))) + (if x-cnd7692 + (car l) + (letrec ((x7694 (cdr l)) + (x7693 (- index 1))) + (list-ref x7694 x7693)))))) + g7687))) + (gcd + (lambda (a b) + (letrec ((g7695 + (letrec ((x-cnd7696 (= b 0))) + (if x-cnd7696 + a + (letrec ((x7697 (modulo a b))) + (gcd b x7697)))))) + g7695))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7698 + (letrec ((x-cnd7699 (real? g7162))) + (if x-cnd7699 + g7162 + (blame g7160 'real?))))) + g7698))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7700 + (letrec ((x-cnd7701 + (boolean? g7165))) + (if x-cnd7701 + g7165 + (blame g7163 'boolean?))))) + g7700))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7702 + (letrec ((x-cnd7703 + (number? g7168))) + (if x-cnd7703 + g7168 + (blame g7166 'number?))))) + g7702))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7704 + (letrec ((x-cnd7705 + ((lambda (v) #t) g7171))) + (if x-cnd7705 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7704))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7706 + (letrec ((x-cnd7707 + ((lambda (v) #t) g7174))) + (if x-cnd7707 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7706))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7708 + (letrec ((x-cnd7709 (pair? g7177))) + (if x-cnd7709 + g7177 + (blame g7175 'pair?))))) + g7708))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7710 + (letrec ((x-cnd7711 (pair? g7180))) + (if x-cnd7711 + g7180 + (blame g7178 'pair?))))) + g7710))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7712 + (letrec ((x-cnd7713 + (integer? g7183))) + (if x-cnd7713 + g7183 + (blame g7181 'integer?))))) + g7712))) + (and/c + (lambda (c1 c2) + (letrec ((g7714 + (lambda (k j v) + (letrec ((g7715 + (letrec ((x-cnd7716 + (c1 k j v))) + (if x-cnd7716 + (c2 k j v) + #f)))) + g7715)))) + g7714))) + (list-of + (lambda (contract) + (letrec ((g7717 + (lambda (k j v) + (letrec ((g7718 + (letrec ((x-cnd7719 + (null? v))) + (if x-cnd7719 + '() + (letrec ((x7723 + (letrec ((x7724 + (car + v))) + (contract + k + j + x7724))) + (x7720 + (letrec ((x7722 + (list-of + contract)) + (x7721 + (cdr + v))) + (x7722 + k + j + x7721)))) + (cons + x7723 + x7720)))))) + g7718)))) + g7717))) + (any? (lambda (v) (letrec ((g7725 #t)) g7725))) + (nonzero? + (lambda (v) + (letrec ((g7726 + (letrec ((x7727 (= v 0))) + (not x7727)))) + g7726))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7728 + (letrec ((x-cnd7729 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7729 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7728))) + (meta (lambda (v) (letrec ((g7730 v)) g7730))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7731 #t)) g7731))) + (cdddr + (lambda (x) + (letrec ((g7732 + (letrec ((x7733 + (letrec ((x7734 (cdr x))) + (cdr x7734)))) + (cdr x7733)))) + g7732))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7735 + (letrec ((x7738 (procedure? f))) + (assert x7738))) + (g7736 + (letrec ((x7739 (list? l))) + (assert x7739))) + (g7737 + (letrec ((x-cnd7740 (null? l))) + (if x-cnd7740 + '() + (letrec ((x7743 + (letrec ((x7744 + (car l))) + (f x7744))) + (x7741 + (letrec ((x7742 + (cdr l))) + (map f x7742)))) + (cons x7743 x7741)))))) + g7737))) + (cdar + (lambda (x) + (letrec ((g7745 + (letrec ((x7746 (car x))) + (cdr x7746)))) + g7745))) + (cadadr + (lambda (x) + (letrec ((g7747 + (letrec ((x7748 + (letrec ((x7749 + (letrec ((x7750 + (cdr + x))) + (car + x7750)))) + (cdr x7749)))) + (car x7748)))) + g7747))) + (cdadar + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (car + x))) + (cdr + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7755 + (letrec ((x7758 + (string? filename))) + (assert x7758))) + (g7756 + (letrec ((x7759 (procedure? proc))) + (assert x7759))) + (g7757 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7760 + (close-output-port + output-port)) + (g7761 res)) + g7761)))) + g7757))) + (caddr + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 + (letrec ((x7764 (cdr x))) + (cdr x7764)))) + (car x7763)))) + g7762))) + (cdaadr + (lambda (x) + (letrec ((g7765 + (letrec ((x7766 + (letrec ((x7767 + (letrec ((x7768 + (cdr + x))) + (car + x7768)))) + (car x7767)))) + (cdr x7766)))) + g7765))) + (assq + (lambda (k l) + (letrec ((g7769 + (letrec ((x7771 (list? l))) + (assert x7771))) + (g7770 + (letrec ((x-cnd7772 (null? l))) + (if x-cnd7772 + #f + (letrec ((x-cnd7773 + (letrec ((x7774 + (caar l))) + (eq? x7774 k)))) + (if x-cnd7773 + (car l) + (letrec ((x7775 (cdr l))) + (assq k x7775)))))))) + g7770))) + (even? + (lambda (x) + (letrec ((g7776 + (letrec ((x7777 (modulo x 2))) + (= 0 x7777)))) + g7776))) + (list->string + (lambda (l) + (letrec ((g7778 + (letrec ((x7780 (list? l))) + (assert x7780))) + (g7779 + (letrec ((x-cnd7781 (null? l))) + (if x-cnd7781 + "" + (letrec ((x7784 + (letrec ((x7785 + (car l))) + (char->string + x7785))) + (x7782 + (letrec ((x7783 + (cdr l))) + (list->string + x7783)))) + (string-append + x7784 + x7782)))))) + g7779))) + (char<=? + (lambda (c1 c2) + (letrec ((g7786 + (letrec ((x7789 (char? c1))) + (assert x7789))) + (g7787 + (letrec ((x7790 (char? c2))) + (assert x7790))) + (g7788 + (letrec ((val7143 (char=? c x7807)))) + (if x-cnd7806 + (letrec ((x7808 #\z)) + (char-ci<=? c x7808)) + #f)))) + g7805))) + (<= + (lambda (x y) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 + (letrec ((val7144 (< x y))) + (letrec ((g7812 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7813 + (if val7145 + val7145 + #f))) + g7813))))) + g7812)))) + g7810))) + (char-whitespace? + (lambda (c) + (letrec ((g7814 + (letrec ((val7146 + (letrec ((x7815 + (char->integer + c))) + (= x7815 9)))) + (letrec ((g7816 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7817 + (char->integer + c))) + (= + x7817 + 10)))) + (letrec ((g7818 + (if val7147 + val7147 + (letrec ((x7819 + (char->integer + c))) + (= + x7819 + 32))))) + g7818))))) + g7816)))) + g7814))) + (cddar + (lambda (x) + (letrec ((g7820 + (letrec ((x7821 + (letrec ((x7822 (car x))) + (cdr x7822)))) + (cdr x7821)))) + g7820))) + (positive? + (lambda (x) + (letrec ((g7823 + (letrec ((x7825 (number? x))) + (assert x7825))) + (g7824 (> x 0))) + g7824))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7826 #f)) g7826))) + (cddr + (lambda (x) + (letrec ((g7827 + (letrec ((x7828 (cdr x))) + (cdr x7828)))) + g7827))) + (truncate + (lambda (x) + (letrec ((g7829 + (letrec ((x7831 (number? x))) + (assert x7831))) + (g7830 + (letrec ((x-cnd7832 (< x 0))) + (if x-cnd7832 + (ceiling x) + (floor x))))) + g7830))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7833 + (letrec ((val7148 (eq? a b))) + (letrec ((g7834 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7836 + (null? + a)) + (x7835 + (null? + b))) + (and x7836 + x7835)))) + (letrec ((g7837 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7840 + (string? + a)) + (x7839 + (string? + b)) + (x7838 + (string=? + a + b))) + (and x7840 + x7839 + x7838)))) + (letrec ((g7841 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7849 + (pair? + a)) + (x7848 + (pair? + b)) + (x7845 + (letrec ((x7847 + (car + a)) + (x7846 + (car + b))) + (equal? + x7847 + x7846))) + (x7842 + (letrec ((x7844 + (cdr + a)) + (x7843 + (cdr + b))) + (equal? + x7844 + x7843)))) + (and x7849 + x7848 + x7845 + x7842)))) + (letrec ((g7850 + (if val7151 + val7151 + (letrec ((x7869 + (vector? + a)) + (x7868 + (vector? + b)) + (x7851 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (vector-length + a))) + (n + x7867)))) + (x7866))) + (x7852 + (letrec ((x7863 + (letrec ((x7864 + (vector-length + b))) + (= + x7864 + n))) + (x7853 + (letrec ((loop + (lambda (i) + (letrec ((g7854 + (letrec ((x7861 + (= + i + n)) + (x7855 + (letrec ((x7858 + (letrec ((x7860 + (vector-ref + a + i)) + (x7859 + (vector-ref + b + i))) + (equal? + x7860 + x7859))) + (x7856 + (letrec ((x7857 + (+ + i + 1))) + (loop + x7857)))) + (and x7858 + x7856)))) + (or x7861 + x7855)))) + g7854)))) + (letrec ((g7862 + (loop + 0))) + g7862)))) + (and x7863 + x7853)))) + (let x7865 x7852)))) + (and x7869 + x7868 + x7851))))) + g7850))))) + g7841))))) + g7837))))) + g7834)))) + g7833))) + (cdaaar + (lambda (x) + (letrec ((g7870 + (letrec ((x7871 + (letrec ((x7872 + (letrec ((x7873 + (car + x))) + (car + x7873)))) + (car x7872)))) + (cdr x7871)))) + g7870))) + (caaddr + (lambda (x) + (letrec ((g7874 + (letrec ((x7875 + (letrec ((x7876 + (letrec ((x7877 + (cdr + x))) + (cdr + x7877)))) + (car x7876)))) + (car x7875)))) + g7874))) + (eqv? + (lambda (x y) + (letrec ((g7878 (eq? x y))) g7878))) + (>= + (lambda (x y) + (letrec ((g7879 + (letrec ((x7881 (number? x))) + (assert x7881))) + (g7880 + (letrec ((val7152 (> x y))) + (letrec ((g7882 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7883 + (if val7153 + val7153 + #f))) + g7883))))) + g7882)))) + g7880))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7884 + (letrec ((x7887 + (string? filename))) + (assert x7887))) + (g7885 + (letrec ((x7888 (procedure? proc))) + (assert x7888))) + (g7886 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7889 + (close-input-port + input-port)) + (g7890 res)) + g7890)))) + g7886))) + (ref + (lambda (x) + (letrec ((g7891 (cons x '()))) g7891))) + (char>=? + (lambda (c1 c2) + (letrec ((g7892 + (letrec ((x7895 (char? c1))) + (assert x7895))) + (g7893 + (letrec ((x7896 (char? c2))) + (assert x7896))) + (g7894 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7897 + (if val7154 + val7154 + (char=? c1 c2)))) + g7897)))) + g7894))) + (cdaar + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (car x))) + (car x7900)))) + (cdr x7899)))) + g7898))) + (cdaddr + (lambda (x) + (letrec ((g7901 + (letrec ((x7902 + (letrec ((x7903 + (letrec ((x7904 + (cdr + x))) + (cdr + x7904)))) + (car x7903)))) + (cdr x7902)))) + g7901))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7905 + (letrec ((x7906 + (letrec ((x7907 (car x))) + (cdr x7907)))) + (car x7906)))) + g7905))) + (caadr + (lambda (x) + (letrec ((g7908 + (letrec ((x7909 + (letrec ((x7910 (cdr x))) + (car x7910)))) + (car x7909)))) + g7908))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7911 + (letrec ((x7914 (char? c1))) + (assert x7914))) + (g7912 + (letrec ((x7915 (char? c2))) + (assert x7915))) + (g7913 + (letrec ((x7916 + (char-ci<=? c1 c2))) + (not x7916)))) + g7913))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7917 + (letrec ((x7918 + (letrec ((x7919 + (letrec ((x7920 + (car + x))) + (car + x7920)))) + (car x7919)))) + (car x7918)))) + g7917))) + (negative? + (lambda (x) + (letrec ((g7921 + (letrec ((x7923 (number? x))) + (assert x7923))) + (g7922 (< x 0))) + g7922))) + (memv + (lambda (e l) + (letrec ((g7924 (memq e l))) g7924))) + (caaar + (lambda (x) + (letrec ((g7925 + (letrec ((x7926 + (letrec ((x7927 (car x))) + (car x7927)))) + (car x7926)))) + g7925))) + (debug + (lambda (e) (letrec ((g7928 '())) g7928))) + (reverse + (lambda (l) + (letrec ((g7929 + (letrec ((x7931 (list? l))) + (assert x7931))) + (g7930 + (letrec ((x-cnd7932 (null? l))) + (if x-cnd7932 + '() + (letrec ((x7935 + (letrec ((x7936 + (cdr l))) + (reverse x7936))) + (x7933 + (letrec ((x7934 + (car l))) + (list x7934)))) + (append x7935 x7933)))))) + g7930))) + (caaadr + (lambda (x) + (letrec ((g7937 + (letrec ((x7938 + (letrec ((x7939 + (letrec ((x7940 + (cdr + x))) + (car + x7940)))) + (car x7939)))) + (car x7938)))) + g7937))) + (cddadr + (lambda (x) + (letrec ((g7941 + (letrec ((x7942 + (letrec ((x7943 + (letrec ((x7944 + (cdr + x))) + (car + x7944)))) + (cdr x7943)))) + (cdr x7942)))) + g7941))) + (odd? + (lambda (x) + (letrec ((g7945 + (letrec ((x7947 (number? x))) + (assert x7947))) + (g7946 + (letrec ((x7948 (modulo x 2))) + (= 1 x7948)))) + g7946))) + (caadar + (lambda (x) + (letrec ((g7949 + (letrec ((x7950 + (letrec ((x7951 + (letrec ((x7952 + (car + x))) + (cdr + x7952)))) + (car x7951)))) + (car x7950)))) + g7949))) + (apply + (lambda (proc args) + (letrec ((g7953 + (letrec ((x7956 (procedure? proc))) + (assert x7956))) + (g7954 + (letrec ((x7957 (list? args))) + (assert x7957))) + (g7955 + (if cnd + (letrec ((g7958 (proc))) g7958) + (if cnd + (letrec ((g7959 + (letrec ((x7960 + (car + args))) + (proc x7960)))) + g7959) + (if cnd + (letrec ((g7961 + (letrec ((x7963 + (car + args)) + (x7962 + (cadr + args))) + (proc + x7963 + x7962)))) + g7961) + (if cnd + (letrec ((g7964 + (letrec ((x7967 + (car + args)) + (x7966 + (cadr + args)) + (x7965 + (caddr + args))) + (proc + x7967 + x7966 + x7965)))) + g7964) + (if cnd + (letrec ((g7968 + (letrec ((x7972 + (car + args)) + (x7971 + (cadr + args)) + (x7970 + (caddr + args)) + (x7969 + (cadddr + args))) + (proc + x7972 + x7971 + x7970 + x7969)))) + g7968) + (if cnd + (letrec ((g7973 + (letrec ((x7979 + (car + args)) + (x7978 + (cadr + args)) + (x7977 + (caddr + args)) + (x7976 + (cadddr + args)) + (x7974 + (letrec ((x7975 + (cddddr + args))) + (car + x7975)))) + (proc + x7979 + x7978 + x7977 + x7976 + x7974)))) + g7973) + (if cnd + (letrec ((g7980 + (letrec ((x7988 + (car + args)) + (x7987 + (cadr + args)) + (x7986 + (caddr + args)) + (x7985 + (cadddr + args)) + (x7983 + (letrec ((x7984 + (cddddr + args))) + (car + x7984))) + (x7981 + (letrec ((x7982 + (cddddr + args))) + (cadr + x7982)))) + (proc + x7988 + x7987 + x7986 + x7985 + x7983 + x7981)))) + g7980) + (if cnd + (letrec ((g7989 + (letrec ((x7999 + (car + args)) + (x7998 + (cadr + args)) + (x7997 + (caddr + args)) + (x7996 + (cadddr + args)) + (x7994 + (letrec ((x7995 + (cddddr + args))) + (car + x7995))) + (x7992 + (letrec ((x7993 + (cddddr + args))) + (cadr + x7993))) + (x7990 + (letrec ((x7991 + (cddddr + args))) + (caddr + x7991)))) + (proc + x7999 + x7998 + x7997 + x7996 + x7994 + x7992 + x7990)))) + g7989) + (letrec ((g8000 + (error + "Unsupported call."))) + g8000))))))))))) + g7955))) + (member + (lambda (e l) + (letrec ((g8001 + (letrec ((x8003 (list? l))) + (assert x8003))) + (g8002 + (letrec ((x-cnd8004 (null? l))) + (if x-cnd8004 + #f + (letrec ((x-cnd8005 + (letrec ((x8006 + (car l))) + (equal? x8006 e)))) + (if x-cnd8005 + l + (letrec ((x8007 (cdr l))) + (member e x8007)))))))) + g8002))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 + (letrec ((x8010 + (letrec ((x8011 + (cdr + x))) + (cdr + x8011)))) + (cdr x8010)))) + (cdr x8009)))) + g8008))) + (cadddr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 + (letrec ((x8014 + (letrec ((x8015 + (cdr + x))) + (cdr + x8015)))) + (cdr x8014)))) + (car x8013)))) + g8012))) + (int-top + (lambda () + (letrec ((g8016 (random 42))) g8016))) + (zero? + (lambda (x) + (letrec ((g8017 + (letrec ((x8019 (number? x))) + (assert x8019))) + (g8018 (= x 0))) + g8018))) + (string>=? + (lambda (s1 s2) + (letrec ((g8020 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8021 + (if val7155 + val7155 + (string=? s1 s2)))) + g8021)))) + g8020))) + (cadr + (lambda (x) + (letrec ((g8022 + (letrec ((x8023 (cdr x))) + (car x8023)))) + g8022))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8024 + (letrec ((val7156 + (letrec ((x8027 + (pair? l)) + (x8025 + (letrec ((x8026 + (cdr + l))) + (list? + x8026)))) + (and x8027 x8025)))) + (letrec ((g8028 + (if val7156 + val7156 + (null? l)))) + g8028)))) + g8024))) + (cddaar + (lambda (x) + (letrec ((g8029 + (letrec ((x8030 + (letrec ((x8031 + (letrec ((x8032 + (car + x))) + (car + x8032)))) + (cdr x8031)))) + (cdr x8030)))) + g8029))) + (char-numeric? + (lambda (c) + (letrec ((g8033 + (letrec ((x-cnd8034 + (letrec ((x8035 #\0)) + (char<=? x8035 c)))) + (if x-cnd8034 + (letrec ((x8036 #\9)) + (char<=? c x8036)) + #f)))) + g8033))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8037 + (letrec ((x8039 (list? l))) + (assert x8039))) + (g8038 + (letrec ((x-cnd8040 (null? l))) + (if x-cnd8040 + #f + (letrec ((x-cnd8041 + (letrec ((x8042 + (caar l))) + (eqv? x8042 k)))) + (if x-cnd8041 + (car l) + (letrec ((x8043 (cdr l))) + (assq k x8043)))))))) + g8038))) + (not + (lambda (x) + (letrec ((g8044 (if x #f #t))) g8044))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8045 (append l1 l2))) g8045))) + (memq + (lambda (e l) + (letrec ((g8046 + (letrec ((x8048 (list? l))) + (assert x8048))) + (g8047 + (letrec ((x-cnd8049 (null? l))) + (if x-cnd8049 + #f + (letrec ((x-cnd8050 + (letrec ((x8051 + (car l))) + (eq? x8051 e)))) + (if x-cnd8050 + l + (letrec ((x8052 (cdr l))) + (memq e x8052)))))))) + g8047))) + (cadaar + (lambda (x) + (letrec ((g8053 + (letrec ((x8054 + (letrec ((x8055 + (letrec ((x8056 + (car + x))) + (car + x8056)))) + (cdr x8055)))) + (car x8054)))) + g8053))) + (length + (lambda (l) + (letrec ((g8057 + (letrec ((x8059 (list? l))) + (assert x8059))) + (g8058 + (letrec ((rec + (lambda (l) + (letrec ((g8060 + (letrec ((x-cnd8061 + (null? + l))) + (if x-cnd8061 + 0 + (letrec ((x8062 + (letrec ((x8063 + (cdr + l))) + (rec + x8063)))) + (+ + 1 + x8062)))))) + g8060)))) + (letrec ((g8064 (rec l))) + g8064)))) + g8058))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8065 + (letrec ((x8068 (char? c1))) + (assert x8068))) + (g8066 + (letrec ((x8069 (char? c2))) + (assert x8069))) + (g8067 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8071 + (letrec ((x8072 (string<=? s1 s2))) + (not x8072)))) + g8071))) + (cdadr + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 + (letrec ((x8075 (cdr x))) + (car x8075)))) + (cdr x8074)))) + g8073))) + (assoc + (lambda (k l) + (letrec ((g8076 + (letrec ((x8078 (list? l))) + (assert x8078))) + (g8077 + (letrec ((x-cnd8079 (null? l))) + (if x-cnd8079 + #f + (letrec ((x-cnd8080 + (letrec ((x8081 + (caar l))) + (equal? x8081 k)))) + (if x-cnd8080 + (car l) + (letrec ((x8082 (cdr l))) + (assoc k x8082)))))))) + g8077))) + (caar + (lambda (x) + (letrec ((g8083 + (letrec ((x8084 (car x))) + (car x8084)))) + g8083))) + (char>? + (lambda (c1 c2) + (letrec ((g8085 + (letrec ((x8088 (char? c1))) + (assert x8088))) + (g8086 + (letrec ((x8089 (char? c2))) + (assert x8089))) + (g8087 + (letrec ((x8090 (char<=? c1 c2))) + (not x8090)))) + g8087))) + (string<=? + (lambda (s1 s2) + (letrec ((g8091 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8108 + (letrec ((x8111 (char? c1))) + (assert x8111))) + (g8109 + (letrec ((x8112 (char? c2))) + (assert x8112))) + (g8110 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8113 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8113)))) + g8110))) + (caddar + (lambda (x) + (letrec ((g8114 + (letrec ((x8115 + (letrec ((x8116 + (letrec ((x8117 + (car + x))) + (cdr + x8117)))) + (cdr x8116)))) + (car x8115)))) + g8114))) + (newline + (lambda () (letrec ((g8118 #f)) g8118))) + (lcm + (lambda (m n) + (letrec ((g8119 + (letrec ((x8121 + (letrec ((x8122 (* m n))) + (abs x8122))) + (x8120 (gcd m n))) + (/ x8121 x8120)))) + g8119))) + (deref car) + (> + (lambda (x y) + (letrec ((g8123 + (letrec ((x8125 (number? x))) + (assert x8125))) + (g8124 + (letrec ((x8126 (<= x y))) + (not x8126)))) + g8124))) + (list-ref + (lambda (l index) + (letrec ((g8127 + (letrec ((x8131 (list? l))) + (assert x8131))) + (g8128 + (letrec ((x8132 (number? index))) + (assert x8132))) + (g8129 + (letrec ((x8133 + (letrec ((x8134 + (length l))) + (< index x8134)))) + (assert x8133))) + (g8130 + (letrec ((x-cnd8135 (= index 0))) + (if x-cnd8135 + (car l) + (letrec ((x8137 (cdr l)) + (x8136 (- index 1))) + (list-ref x8137 x8136)))))) + g8130))) + (gcd + (lambda (a b) + (letrec ((g8138 + (letrec ((x-cnd8139 (= b 0))) + (if x-cnd8139 + a + (letrec ((x8140 (modulo a b))) + (gcd b x8140)))))) + g8138)))) + (letrec ((g8141 + (letrec ((g8142 + (letrec ((mappend + (lambda (xs ys) + (letrec ((g8143 + (letrec ((x-cnd8144 + (empty? + xs))) + (if x-cnd8144 + ys + (letrec ((x8147 + (car + xs)) + (x8145 + (letrec ((x8146 + (cdr + xs))) + (mappend + x8146 + ys)))) + (cons + x8147 + x8145)))))) + g8143))) + (map-append + (lambda (f xs) + (letrec ((g8148 + (letrec ((x-cnd8149 + (empty? + xs))) + (if x-cnd8149 + empty + (letrec ((x8152 + (letrec ((x8153 + (car + xs))) + (f + x8153))) + (x8150 + (letrec ((x8151 + (cdr + xs))) + (map-append + f + x8151)))) + (mappend + x8152 + x8150)))))) + g8148)))) + (letrec ((g8154 + (letrec ((g8155 + (letrec ((g8156 + (letrec ((x8160 + ((lambda (j7231 + k7232 + f7233) + (lambda (g7229 + g7230) + ((listof + any/c) + j7231 + k7232 + (f7233 + ((lambda (j7235 + k7236 + f7237) + (lambda (g7234) + ((listof + any/c) + j7235 + k7236 + (f7237 + (any/c + j7235 + k7236 + g7234))))) + j7231 + k7232 + g7229) + ((listof + any/c) + j7231 + k7232 + g7230))))) + 'module + 'importer + map-append)) + (x8159 + (input)) + (x8158 + (input))) + (x8160 + x8159 + x8158))) + (g8157 + (letrec ((x8163 + ((lambda (j7240 + k7241 + f7242) + (lambda (g7238 + g7239) + ((listof + any/c) + j7240 + k7241 + (f7242 + ((listof + any/c) + j7240 + k7241 + g7238) + ((listof + any/c) + j7240 + k7241 + g7239))))) + 'module + 'importer + mappend)) + (x8162 + (input)) + (x8161 + (input))) + (x8163 + x8162 + x8161)))) + g8157))) + g8155))) + g8154)))) + g8142))) + g8141)))) + g7254))) + g7253)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_mem.rkt b/analyses/simpleactor/benchmarks-out/mochi_mem.rkt index 96e49c34..2a07dce4 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_mem.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_mem.rkt @@ -1,39 +1,3164 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7246 #t)) g7246))) + (meta (lambda (v) (letrec ((g7247 v)) g7247))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7248 + (letrec ((g7249 + (letrec ((x-e7250 lst)) + (match + x-e7250 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7251 (eq? v v1))) + (if x-cnd7251 #t (member v vs))))))))) + g7249))) + g7248))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (mk-list n x) (if (< n 0) empty (cons x (mk-list (- n 1) x)))) - (define (mem x xs) - (if (empty? xs) #f (or (= x (car xs)) (mem x (cdr xs))))) - (begin - (((->d - integer? - integer? - (lambda (_ x) - (and/c - (listof integer?) - (lambda (l) (or (empty? l) (member x l)))))) - 'module - 'importer - mk-list) - (((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - (boolean? - j3985 - k3986 - (f3987 - (integer? j3985 k3986 g3983) - ((listof integer?) j3985 k3986 g3984))))) - 'module - 'importer - mem) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7252 (lambda (v) (letrec ((g7253 v)) g7253)))) g7252))) + (nonzero? + (lambda (v) + (letrec ((g7254 (letrec ((x7255 (= v 0))) (not x7255)))) g7254)))) + (letrec ((g7256 + (letrec ((g7257 + (letrec ((real/c + (lambda (g7162 g7163 g7164) + (letrec ((g7258 + (letrec ((x-cnd7259 (real? g7164))) + (if x-cnd7259 + g7164 + (blame g7162 'real?))))) + g7258))) + (boolean?/c + (lambda (g7165 g7166 g7167) + (letrec ((g7260 + (letrec ((x-cnd7261 + (boolean? g7167))) + (if x-cnd7261 + g7167 + (blame g7165 'boolean?))))) + g7260))) + (number?/c + (lambda (g7168 g7169 g7170) + (letrec ((g7262 + (letrec ((x-cnd7263 + (number? g7170))) + (if x-cnd7263 + g7170 + (blame g7168 'number?))))) + g7262))) + (any/c + (lambda (g7171 g7172 g7173) + (letrec ((g7264 + (letrec ((x-cnd7265 + ((lambda (v) #t) g7173))) + (if x-cnd7265 + g7173 + (blame + g7171 + '(lambda (v) #t)))))) + g7264))) + (any?/c + (lambda (g7174 g7175 g7176) + (letrec ((g7266 + (letrec ((x-cnd7267 + ((lambda (v) #t) g7176))) + (if x-cnd7267 + g7176 + (blame + g7174 + '(lambda (v) #t)))))) + g7266))) + (image? any/c) + (cons?/c + (lambda (g7177 g7178 g7179) + (letrec ((g7268 + (letrec ((x-cnd7269 (pair? g7179))) + (if x-cnd7269 + g7179 + (blame g7177 'pair?))))) + g7268))) + (pair?/c + (lambda (g7180 g7181 g7182) + (letrec ((g7270 + (letrec ((x-cnd7271 (pair? g7182))) + (if x-cnd7271 + g7182 + (blame g7180 'pair?))))) + g7270))) + (integer? + (lambda (g7183 g7184 g7185) + (letrec ((g7272 + (letrec ((x-cnd7273 + (integer? g7185))) + (if x-cnd7273 + g7185 + (blame g7183 'integer?))))) + g7272))) + (and/c + (lambda (c1 c2) + (letrec ((g7274 + (lambda (k j v) + (letrec ((g7275 + (letrec ((x-cnd7276 + (c1 k j v))) + (if x-cnd7276 + (c2 k j v) + #f)))) + g7275)))) + g7274))) + (list-of + (lambda (contract) + (letrec ((g7277 + (lambda (k j v) + (letrec ((g7278 + (letrec ((x-cnd7279 + (null? v))) + (if x-cnd7279 + '() + (letrec ((x7283 + (letrec ((x7284 + (car + v))) + (contract + k + j + x7284))) + (x7280 + (letrec ((x7282 + (list-of + contract)) + (x7281 + (cdr + v))) + (x7282 + k + j + x7281)))) + (cons + x7283 + x7280)))))) + g7278)))) + g7277))) + (any? (lambda (v) (letrec ((g7285 #t)) g7285))) + (nonzero? + (lambda (v) + (letrec ((g7286 + (letrec ((x7287 (= v 0))) + (not x7287)))) + g7286))) + (nonzero?/c + (lambda (g7186 g7187 g7188) + (letrec ((g7288 + (letrec ((x-cnd7289 + ((lambda (v) + (not (= v 0))) + g7188))) + (if x-cnd7289 + g7188 + (blame + g7186 + '(lambda (v) + (not (= v 0)))))))) + g7288))) + (meta (lambda (v) (letrec ((g7290 v)) g7290))) + (orig-+ +) + (+ + ((lambda (j7191 k7192 f7193) + (lambda (g7189 g7190) + (number?/c + j7191 + k7192 + (f7193 + (number?/c j7191 k7192 g7189) + (number?/c j7191 k7192 g7190))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7196 k7197 f7198) + (lambda (g7194 g7195) + (number?/c + j7196 + k7197 + (f7198 + (number?/c j7196 k7197 g7194) + (number?/c j7196 k7197 g7195))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7201 k7202 f7203) + (lambda (g7199 g7200) + (number?/c + j7201 + k7202 + (f7203 + (number?/c j7201 k7202 g7199) + (number?/c j7201 k7202 g7200))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7206 k7207 f7208) + (lambda (g7204 g7205) + (number?/c + j7206 + k7207 + (f7208 + (number?/c j7206 k7207 g7204) + (number?/c j7206 k7207 g7205))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7210 k7211 f7212) + (lambda (g7209) + (any/c + j7210 + k7211 + (f7212 (pair?/c j7210 k7211 g7209))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7214 k7215 f7216) + (lambda (g7213) + (any/c + j7214 + k7215 + (f7216 (pair?/c j7214 k7215 g7213))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7219 k7220 f7221) + (lambda (g7217 g7218) + (pair?/c + j7219 + k7220 + (f7221 + (any/c j7219 k7220 g7217) + (any/c j7219 k7220 g7218))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7223 k7224 f7225) + (lambda (g7222) + (integer?/c + j7223 + k7224 + (f7225 (vector?/c j7223 k7224 g7222))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7228 k7229 f7230) + (lambda (g7226 g7227) + (any/c + j7228 + k7229 + (f7230 + (vector?/c j7228 k7229 g7226) + (integer?/c j7228 k7229 g7227))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7291 #t)) g7291))) + (cdddr + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 + (letrec ((x7294 (cdr x))) + (cdr x7294)))) + (cdr x7293)))) + g7292))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7295 + (letrec ((x7298 (procedure? f))) + (assert x7298))) + (g7296 + (letrec ((x7299 (list? l))) + (assert x7299))) + (g7297 + (letrec ((x-cnd7300 (null? l))) + (if x-cnd7300 + '() + (letrec ((x7303 + (letrec ((x7304 + (car l))) + (f x7304))) + (x7301 + (letrec ((x7302 + (cdr l))) + (map f x7302)))) + (cons x7303 x7301)))))) + g7297))) + (cdar + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 (car x))) + (cdr x7306)))) + g7305))) + (cadadr + (lambda (x) + (letrec ((g7307 + (letrec ((x7308 + (letrec ((x7309 + (letrec ((x7310 + (cdr + x))) + (car + x7310)))) + (cdr x7309)))) + (car x7308)))) + g7307))) + (cdadar + (lambda (x) + (letrec ((g7311 + (letrec ((x7312 + (letrec ((x7313 + (letrec ((x7314 + (car + x))) + (cdr + x7314)))) + (car x7313)))) + (cdr x7312)))) + g7311))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7315 + (letrec ((x7318 + (string? filename))) + (assert x7318))) + (g7316 + (letrec ((x7319 (procedure? proc))) + (assert x7319))) + (g7317 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7320 + (close-output-port + output-port)) + (g7321 res)) + g7321)))) + g7317))) + (caddr + (lambda (x) + (letrec ((g7322 + (letrec ((x7323 + (letrec ((x7324 (cdr x))) + (cdr x7324)))) + (car x7323)))) + g7322))) + (cdaadr + (lambda (x) + (letrec ((g7325 + (letrec ((x7326 + (letrec ((x7327 + (letrec ((x7328 + (cdr + x))) + (car + x7328)))) + (car x7327)))) + (cdr x7326)))) + g7325))) + (assq + (lambda (k l) + (letrec ((g7329 + (letrec ((x7331 (list? l))) + (assert x7331))) + (g7330 + (letrec ((x-cnd7332 (null? l))) + (if x-cnd7332 + #f + (letrec ((x-cnd7333 + (letrec ((x7334 + (caar l))) + (eq? x7334 k)))) + (if x-cnd7333 + (car l) + (letrec ((x7335 (cdr l))) + (assq k x7335)))))))) + g7330))) + (even? + (lambda (x) + (letrec ((g7336 + (letrec ((x7337 (modulo x 2))) + (= 0 x7337)))) + g7336))) + (list->string + (lambda (l) + (letrec ((g7338 + (letrec ((x7340 (list? l))) + (assert x7340))) + (g7339 + (letrec ((x-cnd7341 (null? l))) + (if x-cnd7341 + "" + (letrec ((x7344 + (letrec ((x7345 + (car l))) + (char->string + x7345))) + (x7342 + (letrec ((x7343 + (cdr l))) + (list->string + x7343)))) + (string-append + x7344 + x7342)))))) + g7339))) + (char<=? + (lambda (c1 c2) + (letrec ((g7346 + (letrec ((x7349 (char? c1))) + (assert x7349))) + (g7347 + (letrec ((x7350 (char? c2))) + (assert x7350))) + (g7348 + (letrec ((val7143 (char=? c x7367)))) + (if x-cnd7366 + (letrec ((x7368 #\z)) + (char-ci<=? c x7368)) + #f)))) + g7365))) + (<= + (lambda (x y) + (letrec ((g7369 + (letrec ((x7371 (number? x))) + (assert x7371))) + (g7370 + (letrec ((val7144 (< x y))) + (letrec ((g7372 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7373 + (if val7145 + val7145 + #f))) + g7373))))) + g7372)))) + g7370))) + (char-whitespace? + (lambda (c) + (letrec ((g7374 + (letrec ((val7146 + (letrec ((x7375 + (char->integer + c))) + (= x7375 9)))) + (letrec ((g7376 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7377 + (char->integer + c))) + (= + x7377 + 10)))) + (letrec ((g7378 + (if val7147 + val7147 + (letrec ((x7379 + (char->integer + c))) + (= + x7379 + 32))))) + g7378))))) + g7376)))) + g7374))) + (cddar + (lambda (x) + (letrec ((g7380 + (letrec ((x7381 + (letrec ((x7382 (car x))) + (cdr x7382)))) + (cdr x7381)))) + g7380))) + (positive? + (lambda (x) + (letrec ((g7383 + (letrec ((x7385 (number? x))) + (assert x7385))) + (g7384 (> x 0))) + g7384))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7386 #f)) g7386))) + (cddr + (lambda (x) + (letrec ((g7387 + (letrec ((x7388 (cdr x))) + (cdr x7388)))) + g7387))) + (truncate + (lambda (x) + (letrec ((g7389 + (letrec ((x7391 (number? x))) + (assert x7391))) + (g7390 + (letrec ((x-cnd7392 (< x 0))) + (if x-cnd7392 + (ceiling x) + (floor x))))) + g7390))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7393 + (letrec ((val7148 (eq? a b))) + (letrec ((g7394 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7396 + (null? + a)) + (x7395 + (null? + b))) + (and x7396 + x7395)))) + (letrec ((g7397 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7400 + (string? + a)) + (x7399 + (string? + b)) + (x7398 + (string=? + a + b))) + (and x7400 + x7399 + x7398)))) + (letrec ((g7401 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7409 + (pair? + a)) + (x7408 + (pair? + b)) + (x7405 + (letrec ((x7407 + (car + a)) + (x7406 + (car + b))) + (equal? + x7407 + x7406))) + (x7402 + (letrec ((x7404 + (cdr + a)) + (x7403 + (cdr + b))) + (equal? + x7404 + x7403)))) + (and x7409 + x7408 + x7405 + x7402)))) + (letrec ((g7410 + (if val7151 + val7151 + (letrec ((x7429 + (vector? + a)) + (x7428 + (vector? + b)) + (x7411 + (letrec ((x7425 + (letrec ((x7426 + (letrec ((x7427 + (vector-length + a))) + (n + x7427)))) + (x7426))) + (x7412 + (letrec ((x7423 + (letrec ((x7424 + (vector-length + b))) + (= + x7424 + n))) + (x7413 + (letrec ((loop + (lambda (i) + (letrec ((g7414 + (letrec ((x7421 + (= + i + n)) + (x7415 + (letrec ((x7418 + (letrec ((x7420 + (vector-ref + a + i)) + (x7419 + (vector-ref + b + i))) + (equal? + x7420 + x7419))) + (x7416 + (letrec ((x7417 + (+ + i + 1))) + (loop + x7417)))) + (and x7418 + x7416)))) + (or x7421 + x7415)))) + g7414)))) + (letrec ((g7422 + (loop + 0))) + g7422)))) + (and x7423 + x7413)))) + (let x7425 x7412)))) + (and x7429 + x7428 + x7411))))) + g7410))))) + g7401))))) + g7397))))) + g7394)))) + g7393))) + (cdaaar + (lambda (x) + (letrec ((g7430 + (letrec ((x7431 + (letrec ((x7432 + (letrec ((x7433 + (car + x))) + (car + x7433)))) + (car x7432)))) + (cdr x7431)))) + g7430))) + (caaddr + (lambda (x) + (letrec ((g7434 + (letrec ((x7435 + (letrec ((x7436 + (letrec ((x7437 + (cdr + x))) + (cdr + x7437)))) + (car x7436)))) + (car x7435)))) + g7434))) + (eqv? + (lambda (x y) + (letrec ((g7438 (eq? x y))) g7438))) + (>= + (lambda (x y) + (letrec ((g7439 + (letrec ((x7441 (number? x))) + (assert x7441))) + (g7440 + (letrec ((val7152 (> x y))) + (letrec ((g7442 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7443 + (if val7153 + val7153 + #f))) + g7443))))) + g7442)))) + g7440))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7444 + (letrec ((x7447 + (string? filename))) + (assert x7447))) + (g7445 + (letrec ((x7448 (procedure? proc))) + (assert x7448))) + (g7446 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7449 + (close-input-port + input-port)) + (g7450 res)) + g7450)))) + g7446))) + (ref + (lambda (x) + (letrec ((g7451 (cons x '()))) g7451))) + (char>=? + (lambda (c1 c2) + (letrec ((g7452 + (letrec ((x7455 (char? c1))) + (assert x7455))) + (g7453 + (letrec ((x7456 (char? c2))) + (assert x7456))) + (g7454 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7457 + (if val7154 + val7154 + (char=? c1 c2)))) + g7457)))) + g7454))) + (cdaar + (lambda (x) + (letrec ((g7458 + (letrec ((x7459 + (letrec ((x7460 (car x))) + (car x7460)))) + (cdr x7459)))) + g7458))) + (cdaddr + (lambda (x) + (letrec ((g7461 + (letrec ((x7462 + (letrec ((x7463 + (letrec ((x7464 + (cdr + x))) + (cdr + x7464)))) + (car x7463)))) + (cdr x7462)))) + g7461))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7465 + (letrec ((x7466 + (letrec ((x7467 (car x))) + (cdr x7467)))) + (car x7466)))) + g7465))) + (caadr + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (cdr x))) + (car x7470)))) + (car x7469)))) + g7468))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7471 + (letrec ((x7474 (char? c1))) + (assert x7474))) + (g7472 + (letrec ((x7475 (char? c2))) + (assert x7475))) + (g7473 + (letrec ((x7476 + (char-ci<=? c1 c2))) + (not x7476)))) + g7473))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7477 + (letrec ((x7478 + (letrec ((x7479 + (letrec ((x7480 + (car + x))) + (car + x7480)))) + (car x7479)))) + (car x7478)))) + g7477))) + (negative? + (lambda (x) + (letrec ((g7481 + (letrec ((x7483 (number? x))) + (assert x7483))) + (g7482 (< x 0))) + g7482))) + (memv + (lambda (e l) + (letrec ((g7484 (memq e l))) g7484))) + (caaar + (lambda (x) + (letrec ((g7485 + (letrec ((x7486 + (letrec ((x7487 (car x))) + (car x7487)))) + (car x7486)))) + g7485))) + (debug + (lambda (e) (letrec ((g7488 '())) g7488))) + (reverse + (lambda (l) + (letrec ((g7489 + (letrec ((x7491 (list? l))) + (assert x7491))) + (g7490 + (letrec ((x-cnd7492 (null? l))) + (if x-cnd7492 + '() + (letrec ((x7495 + (letrec ((x7496 + (cdr l))) + (reverse x7496))) + (x7493 + (letrec ((x7494 + (car l))) + (list x7494)))) + (append x7495 x7493)))))) + g7490))) + (caaadr + (lambda (x) + (letrec ((g7497 + (letrec ((x7498 + (letrec ((x7499 + (letrec ((x7500 + (cdr + x))) + (car + x7500)))) + (car x7499)))) + (car x7498)))) + g7497))) + (cddadr + (lambda (x) + (letrec ((g7501 + (letrec ((x7502 + (letrec ((x7503 + (letrec ((x7504 + (cdr + x))) + (car + x7504)))) + (cdr x7503)))) + (cdr x7502)))) + g7501))) + (odd? + (lambda (x) + (letrec ((g7505 + (letrec ((x7507 (number? x))) + (assert x7507))) + (g7506 + (letrec ((x7508 (modulo x 2))) + (= 1 x7508)))) + g7506))) + (caadar + (lambda (x) + (letrec ((g7509 + (letrec ((x7510 + (letrec ((x7511 + (letrec ((x7512 + (car + x))) + (cdr + x7512)))) + (car x7511)))) + (car x7510)))) + g7509))) + (apply + (lambda (proc args) + (letrec ((g7513 + (letrec ((x7516 (procedure? proc))) + (assert x7516))) + (g7514 + (letrec ((x7517 (list? args))) + (assert x7517))) + (g7515 + (if cnd + (letrec ((g7518 (proc))) g7518) + (if cnd + (letrec ((g7519 + (letrec ((x7520 + (car + args))) + (proc x7520)))) + g7519) + (if cnd + (letrec ((g7521 + (letrec ((x7523 + (car + args)) + (x7522 + (cadr + args))) + (proc + x7523 + x7522)))) + g7521) + (if cnd + (letrec ((g7524 + (letrec ((x7527 + (car + args)) + (x7526 + (cadr + args)) + (x7525 + (caddr + args))) + (proc + x7527 + x7526 + x7525)))) + g7524) + (if cnd + (letrec ((g7528 + (letrec ((x7532 + (car + args)) + (x7531 + (cadr + args)) + (x7530 + (caddr + args)) + (x7529 + (cadddr + args))) + (proc + x7532 + x7531 + x7530 + x7529)))) + g7528) + (if cnd + (letrec ((g7533 + (letrec ((x7539 + (car + args)) + (x7538 + (cadr + args)) + (x7537 + (caddr + args)) + (x7536 + (cadddr + args)) + (x7534 + (letrec ((x7535 + (cddddr + args))) + (car + x7535)))) + (proc + x7539 + x7538 + x7537 + x7536 + x7534)))) + g7533) + (if cnd + (letrec ((g7540 + (letrec ((x7548 + (car + args)) + (x7547 + (cadr + args)) + (x7546 + (caddr + args)) + (x7545 + (cadddr + args)) + (x7543 + (letrec ((x7544 + (cddddr + args))) + (car + x7544))) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (cadr + x7542)))) + (proc + x7548 + x7547 + x7546 + x7545 + x7543 + x7541)))) + g7540) + (if cnd + (letrec ((g7549 + (letrec ((x7559 + (car + args)) + (x7558 + (cadr + args)) + (x7557 + (caddr + args)) + (x7556 + (cadddr + args)) + (x7554 + (letrec ((x7555 + (cddddr + args))) + (car + x7555))) + (x7552 + (letrec ((x7553 + (cddddr + args))) + (cadr + x7553))) + (x7550 + (letrec ((x7551 + (cddddr + args))) + (caddr + x7551)))) + (proc + x7559 + x7558 + x7557 + x7556 + x7554 + x7552 + x7550)))) + g7549) + (letrec ((g7560 + (error + "Unsupported call."))) + g7560))))))))))) + g7515))) + (member + (lambda (e l) + (letrec ((g7561 + (letrec ((x7563 (list? l))) + (assert x7563))) + (g7562 + (letrec ((x-cnd7564 (null? l))) + (if x-cnd7564 + #f + (letrec ((x-cnd7565 + (letrec ((x7566 + (car l))) + (equal? x7566 e)))) + (if x-cnd7565 + l + (letrec ((x7567 (cdr l))) + (member e x7567)))))))) + g7562))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7568 + (letrec ((x7569 + (letrec ((x7570 + (letrec ((x7571 + (cdr + x))) + (cdr + x7571)))) + (cdr x7570)))) + (cdr x7569)))) + g7568))) + (cadddr + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (cdr + x))) + (cdr + x7575)))) + (cdr x7574)))) + (car x7573)))) + g7572))) + (int-top + (lambda () + (letrec ((g7576 (random 42))) g7576))) + (zero? + (lambda (x) + (letrec ((g7577 + (letrec ((x7579 (number? x))) + (assert x7579))) + (g7578 (= x 0))) + g7578))) + (string>=? + (lambda (s1 s2) + (letrec ((g7580 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7581 + (if val7155 + val7155 + (string=? s1 s2)))) + g7581)))) + g7580))) + (cadr + (lambda (x) + (letrec ((g7582 + (letrec ((x7583 (cdr x))) + (car x7583)))) + g7582))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7584 + (letrec ((val7156 + (letrec ((x7587 + (pair? l)) + (x7585 + (letrec ((x7586 + (cdr + l))) + (list? + x7586)))) + (and x7587 x7585)))) + (letrec ((g7588 + (if val7156 + val7156 + (null? l)))) + g7588)))) + g7584))) + (cddaar + (lambda (x) + (letrec ((g7589 + (letrec ((x7590 + (letrec ((x7591 + (letrec ((x7592 + (car + x))) + (car + x7592)))) + (cdr x7591)))) + (cdr x7590)))) + g7589))) + (char-numeric? + (lambda (c) + (letrec ((g7593 + (letrec ((x-cnd7594 + (letrec ((x7595 #\0)) + (char<=? x7595 c)))) + (if x-cnd7594 + (letrec ((x7596 #\9)) + (char<=? c x7596)) + #f)))) + g7593))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7597 + (letrec ((x7599 (list? l))) + (assert x7599))) + (g7598 + (letrec ((x-cnd7600 (null? l))) + (if x-cnd7600 + #f + (letrec ((x-cnd7601 + (letrec ((x7602 + (caar l))) + (eqv? x7602 k)))) + (if x-cnd7601 + (car l) + (letrec ((x7603 (cdr l))) + (assq k x7603)))))))) + g7598))) + (not + (lambda (x) + (letrec ((g7604 (if x #f #t))) g7604))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7605 (append l1 l2))) g7605))) + (memq + (lambda (e l) + (letrec ((g7606 + (letrec ((x7608 (list? l))) + (assert x7608))) + (g7607 + (letrec ((x-cnd7609 (null? l))) + (if x-cnd7609 + #f + (letrec ((x-cnd7610 + (letrec ((x7611 + (car l))) + (eq? x7611 e)))) + (if x-cnd7610 + l + (letrec ((x7612 (cdr l))) + (memq e x7612)))))))) + g7607))) + (cadaar + (lambda (x) + (letrec ((g7613 + (letrec ((x7614 + (letrec ((x7615 + (letrec ((x7616 + (car + x))) + (car + x7616)))) + (cdr x7615)))) + (car x7614)))) + g7613))) + (length + (lambda (l) + (letrec ((g7617 + (letrec ((x7619 (list? l))) + (assert x7619))) + (g7618 + (letrec ((rec + (lambda (l) + (letrec ((g7620 + (letrec ((x-cnd7621 + (null? + l))) + (if x-cnd7621 + 0 + (letrec ((x7622 + (letrec ((x7623 + (cdr + l))) + (rec + x7623)))) + (+ + 1 + x7622)))))) + g7620)))) + (letrec ((g7624 (rec l))) + g7624)))) + g7618))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7625 + (letrec ((x7628 (char? c1))) + (assert x7628))) + (g7626 + (letrec ((x7629 (char? c2))) + (assert x7629))) + (g7627 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7631 + (letrec ((x7632 (string<=? s1 s2))) + (not x7632)))) + g7631))) + (cdadr + (lambda (x) + (letrec ((g7633 + (letrec ((x7634 + (letrec ((x7635 (cdr x))) + (car x7635)))) + (cdr x7634)))) + g7633))) + (assoc + (lambda (k l) + (letrec ((g7636 + (letrec ((x7638 (list? l))) + (assert x7638))) + (g7637 + (letrec ((x-cnd7639 (null? l))) + (if x-cnd7639 + #f + (letrec ((x-cnd7640 + (letrec ((x7641 + (caar l))) + (equal? x7641 k)))) + (if x-cnd7640 + (car l) + (letrec ((x7642 (cdr l))) + (assoc k x7642)))))))) + g7637))) + (caar + (lambda (x) + (letrec ((g7643 + (letrec ((x7644 (car x))) + (car x7644)))) + g7643))) + (char>? + (lambda (c1 c2) + (letrec ((g7645 + (letrec ((x7648 (char? c1))) + (assert x7648))) + (g7646 + (letrec ((x7649 (char? c2))) + (assert x7649))) + (g7647 + (letrec ((x7650 (char<=? c1 c2))) + (not x7650)))) + g7647))) + (string<=? + (lambda (s1 s2) + (letrec ((g7651 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7668 + (letrec ((x7671 (char? c1))) + (assert x7671))) + (g7669 + (letrec ((x7672 (char? c2))) + (assert x7672))) + (g7670 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7673 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7673)))) + g7670))) + (caddar + (lambda (x) + (letrec ((g7674 + (letrec ((x7675 + (letrec ((x7676 + (letrec ((x7677 + (car + x))) + (cdr + x7677)))) + (cdr x7676)))) + (car x7675)))) + g7674))) + (newline + (lambda () (letrec ((g7678 #f)) g7678))) + (lcm + (lambda (m n) + (letrec ((g7679 + (letrec ((x7681 + (letrec ((x7682 (* m n))) + (abs x7682))) + (x7680 (gcd m n))) + (/ x7681 x7680)))) + g7679))) + (deref car) + (> + (lambda (x y) + (letrec ((g7683 + (letrec ((x7685 (number? x))) + (assert x7685))) + (g7684 + (letrec ((x7686 (<= x y))) + (not x7686)))) + g7684))) + (list-ref + (lambda (l index) + (letrec ((g7687 + (letrec ((x7691 (list? l))) + (assert x7691))) + (g7688 + (letrec ((x7692 (number? index))) + (assert x7692))) + (g7689 + (letrec ((x7693 + (letrec ((x7694 + (length l))) + (< index x7694)))) + (assert x7693))) + (g7690 + (letrec ((x-cnd7695 (= index 0))) + (if x-cnd7695 + (car l) + (letrec ((x7697 (cdr l)) + (x7696 (- index 1))) + (list-ref x7697 x7696)))))) + g7690))) + (gcd + (lambda (a b) + (letrec ((g7698 + (letrec ((x-cnd7699 (= b 0))) + (if x-cnd7699 + a + (letrec ((x7700 (modulo a b))) + (gcd b x7700)))))) + g7698))) + (real/c + (lambda (g7162 g7163 g7164) + (letrec ((g7701 + (letrec ((x-cnd7702 (real? g7164))) + (if x-cnd7702 + g7164 + (blame g7162 'real?))))) + g7701))) + (boolean?/c + (lambda (g7165 g7166 g7167) + (letrec ((g7703 + (letrec ((x-cnd7704 + (boolean? g7167))) + (if x-cnd7704 + g7167 + (blame g7165 'boolean?))))) + g7703))) + (number?/c + (lambda (g7168 g7169 g7170) + (letrec ((g7705 + (letrec ((x-cnd7706 + (number? g7170))) + (if x-cnd7706 + g7170 + (blame g7168 'number?))))) + g7705))) + (any/c + (lambda (g7171 g7172 g7173) + (letrec ((g7707 + (letrec ((x-cnd7708 + ((lambda (v) #t) g7173))) + (if x-cnd7708 + g7173 + (blame + g7171 + '(lambda (v) #t)))))) + g7707))) + (any?/c + (lambda (g7174 g7175 g7176) + (letrec ((g7709 + (letrec ((x-cnd7710 + ((lambda (v) #t) g7176))) + (if x-cnd7710 + g7176 + (blame + g7174 + '(lambda (v) #t)))))) + g7709))) + (image? any/c) + (cons?/c + (lambda (g7177 g7178 g7179) + (letrec ((g7711 + (letrec ((x-cnd7712 (pair? g7179))) + (if x-cnd7712 + g7179 + (blame g7177 'pair?))))) + g7711))) + (pair?/c + (lambda (g7180 g7181 g7182) + (letrec ((g7713 + (letrec ((x-cnd7714 (pair? g7182))) + (if x-cnd7714 + g7182 + (blame g7180 'pair?))))) + g7713))) + (integer? + (lambda (g7183 g7184 g7185) + (letrec ((g7715 + (letrec ((x-cnd7716 + (integer? g7185))) + (if x-cnd7716 + g7185 + (blame g7183 'integer?))))) + g7715))) + (and/c + (lambda (c1 c2) + (letrec ((g7717 + (lambda (k j v) + (letrec ((g7718 + (letrec ((x-cnd7719 + (c1 k j v))) + (if x-cnd7719 + (c2 k j v) + #f)))) + g7718)))) + g7717))) + (list-of + (lambda (contract) + (letrec ((g7720 + (lambda (k j v) + (letrec ((g7721 + (letrec ((x-cnd7722 + (null? v))) + (if x-cnd7722 + '() + (letrec ((x7726 + (letrec ((x7727 + (car + v))) + (contract + k + j + x7727))) + (x7723 + (letrec ((x7725 + (list-of + contract)) + (x7724 + (cdr + v))) + (x7725 + k + j + x7724)))) + (cons + x7726 + x7723)))))) + g7721)))) + g7720))) + (any? (lambda (v) (letrec ((g7728 #t)) g7728))) + (nonzero? + (lambda (v) + (letrec ((g7729 + (letrec ((x7730 (= v 0))) + (not x7730)))) + g7729))) + (nonzero?/c + (lambda (g7186 g7187 g7188) + (letrec ((g7731 + (letrec ((x-cnd7732 + ((lambda (v) + (not (= v 0))) + g7188))) + (if x-cnd7732 + g7188 + (blame + g7186 + '(lambda (v) + (not (= v 0)))))))) + g7731))) + (meta (lambda (v) (letrec ((g7733 v)) g7733))) + (orig-+ +) + (+ + ((lambda (j7191 k7192 f7193) + (lambda (g7189 g7190) + (number?/c + j7191 + k7192 + (f7193 + (number?/c j7191 k7192 g7189) + (number?/c j7191 k7192 g7190))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7196 k7197 f7198) + (lambda (g7194 g7195) + (number?/c + j7196 + k7197 + (f7198 + (number?/c j7196 k7197 g7194) + (number?/c j7196 k7197 g7195))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7201 k7202 f7203) + (lambda (g7199 g7200) + (number?/c + j7201 + k7202 + (f7203 + (number?/c j7201 k7202 g7199) + (number?/c j7201 k7202 g7200))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7206 k7207 f7208) + (lambda (g7204 g7205) + (number?/c + j7206 + k7207 + (f7208 + (number?/c j7206 k7207 g7204) + (number?/c j7206 k7207 g7205))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7210 k7211 f7212) + (lambda (g7209) + (any/c + j7210 + k7211 + (f7212 (pair?/c j7210 k7211 g7209))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7214 k7215 f7216) + (lambda (g7213) + (any/c + j7214 + k7215 + (f7216 (pair?/c j7214 k7215 g7213))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7219 k7220 f7221) + (lambda (g7217 g7218) + (pair?/c + j7219 + k7220 + (f7221 + (any/c j7219 k7220 g7217) + (any/c j7219 k7220 g7218))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7223 k7224 f7225) + (lambda (g7222) + (integer?/c + j7223 + k7224 + (f7225 (vector?/c j7223 k7224 g7222))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7228 k7229 f7230) + (lambda (g7226 g7227) + (any/c + j7228 + k7229 + (f7230 + (vector?/c j7228 k7229 g7226) + (integer?/c j7228 k7229 g7227))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7734 #t)) g7734))) + (cdddr + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 + (letrec ((x7737 (cdr x))) + (cdr x7737)))) + (cdr x7736)))) + g7735))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7738 + (letrec ((x7741 (procedure? f))) + (assert x7741))) + (g7739 + (letrec ((x7742 (list? l))) + (assert x7742))) + (g7740 + (letrec ((x-cnd7743 (null? l))) + (if x-cnd7743 + '() + (letrec ((x7746 + (letrec ((x7747 + (car l))) + (f x7747))) + (x7744 + (letrec ((x7745 + (cdr l))) + (map f x7745)))) + (cons x7746 x7744)))))) + g7740))) + (cdar + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 (car x))) + (cdr x7749)))) + g7748))) + (cadadr + (lambda (x) + (letrec ((g7750 + (letrec ((x7751 + (letrec ((x7752 + (letrec ((x7753 + (cdr + x))) + (car + x7753)))) + (cdr x7752)))) + (car x7751)))) + g7750))) + (cdadar + (lambda (x) + (letrec ((g7754 + (letrec ((x7755 + (letrec ((x7756 + (letrec ((x7757 + (car + x))) + (cdr + x7757)))) + (car x7756)))) + (cdr x7755)))) + g7754))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7758 + (letrec ((x7761 + (string? filename))) + (assert x7761))) + (g7759 + (letrec ((x7762 (procedure? proc))) + (assert x7762))) + (g7760 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7763 + (close-output-port + output-port)) + (g7764 res)) + g7764)))) + g7760))) + (caddr + (lambda (x) + (letrec ((g7765 + (letrec ((x7766 + (letrec ((x7767 (cdr x))) + (cdr x7767)))) + (car x7766)))) + g7765))) + (cdaadr + (lambda (x) + (letrec ((g7768 + (letrec ((x7769 + (letrec ((x7770 + (letrec ((x7771 + (cdr + x))) + (car + x7771)))) + (car x7770)))) + (cdr x7769)))) + g7768))) + (assq + (lambda (k l) + (letrec ((g7772 + (letrec ((x7774 (list? l))) + (assert x7774))) + (g7773 + (letrec ((x-cnd7775 (null? l))) + (if x-cnd7775 + #f + (letrec ((x-cnd7776 + (letrec ((x7777 + (caar l))) + (eq? x7777 k)))) + (if x-cnd7776 + (car l) + (letrec ((x7778 (cdr l))) + (assq k x7778)))))))) + g7773))) + (even? + (lambda (x) + (letrec ((g7779 + (letrec ((x7780 (modulo x 2))) + (= 0 x7780)))) + g7779))) + (list->string + (lambda (l) + (letrec ((g7781 + (letrec ((x7783 (list? l))) + (assert x7783))) + (g7782 + (letrec ((x-cnd7784 (null? l))) + (if x-cnd7784 + "" + (letrec ((x7787 + (letrec ((x7788 + (car l))) + (char->string + x7788))) + (x7785 + (letrec ((x7786 + (cdr l))) + (list->string + x7786)))) + (string-append + x7787 + x7785)))))) + g7782))) + (char<=? + (lambda (c1 c2) + (letrec ((g7789 + (letrec ((x7792 (char? c1))) + (assert x7792))) + (g7790 + (letrec ((x7793 (char? c2))) + (assert x7793))) + (g7791 + (letrec ((val7143 (char=? c x7810)))) + (if x-cnd7809 + (letrec ((x7811 #\z)) + (char-ci<=? c x7811)) + #f)))) + g7808))) + (<= + (lambda (x y) + (letrec ((g7812 + (letrec ((x7814 (number? x))) + (assert x7814))) + (g7813 + (letrec ((val7144 (< x y))) + (letrec ((g7815 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7816 + (if val7145 + val7145 + #f))) + g7816))))) + g7815)))) + g7813))) + (char-whitespace? + (lambda (c) + (letrec ((g7817 + (letrec ((val7146 + (letrec ((x7818 + (char->integer + c))) + (= x7818 9)))) + (letrec ((g7819 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7820 + (char->integer + c))) + (= + x7820 + 10)))) + (letrec ((g7821 + (if val7147 + val7147 + (letrec ((x7822 + (char->integer + c))) + (= + x7822 + 32))))) + g7821))))) + g7819)))) + g7817))) + (cddar + (lambda (x) + (letrec ((g7823 + (letrec ((x7824 + (letrec ((x7825 (car x))) + (cdr x7825)))) + (cdr x7824)))) + g7823))) + (positive? + (lambda (x) + (letrec ((g7826 + (letrec ((x7828 (number? x))) + (assert x7828))) + (g7827 (> x 0))) + g7827))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7829 #f)) g7829))) + (cddr + (lambda (x) + (letrec ((g7830 + (letrec ((x7831 (cdr x))) + (cdr x7831)))) + g7830))) + (truncate + (lambda (x) + (letrec ((g7832 + (letrec ((x7834 (number? x))) + (assert x7834))) + (g7833 + (letrec ((x-cnd7835 (< x 0))) + (if x-cnd7835 + (ceiling x) + (floor x))))) + g7833))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7836 + (letrec ((val7148 (eq? a b))) + (letrec ((g7837 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7839 + (null? + a)) + (x7838 + (null? + b))) + (and x7839 + x7838)))) + (letrec ((g7840 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7843 + (string? + a)) + (x7842 + (string? + b)) + (x7841 + (string=? + a + b))) + (and x7843 + x7842 + x7841)))) + (letrec ((g7844 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7852 + (pair? + a)) + (x7851 + (pair? + b)) + (x7848 + (letrec ((x7850 + (car + a)) + (x7849 + (car + b))) + (equal? + x7850 + x7849))) + (x7845 + (letrec ((x7847 + (cdr + a)) + (x7846 + (cdr + b))) + (equal? + x7847 + x7846)))) + (and x7852 + x7851 + x7848 + x7845)))) + (letrec ((g7853 + (if val7151 + val7151 + (letrec ((x7872 + (vector? + a)) + (x7871 + (vector? + b)) + (x7854 + (letrec ((x7868 + (letrec ((x7869 + (letrec ((x7870 + (vector-length + a))) + (n + x7870)))) + (x7869))) + (x7855 + (letrec ((x7866 + (letrec ((x7867 + (vector-length + b))) + (= + x7867 + n))) + (x7856 + (letrec ((loop + (lambda (i) + (letrec ((g7857 + (letrec ((x7864 + (= + i + n)) + (x7858 + (letrec ((x7861 + (letrec ((x7863 + (vector-ref + a + i)) + (x7862 + (vector-ref + b + i))) + (equal? + x7863 + x7862))) + (x7859 + (letrec ((x7860 + (+ + i + 1))) + (loop + x7860)))) + (and x7861 + x7859)))) + (or x7864 + x7858)))) + g7857)))) + (letrec ((g7865 + (loop + 0))) + g7865)))) + (and x7866 + x7856)))) + (let x7868 x7855)))) + (and x7872 + x7871 + x7854))))) + g7853))))) + g7844))))) + g7840))))) + g7837)))) + g7836))) + (cdaaar + (lambda (x) + (letrec ((g7873 + (letrec ((x7874 + (letrec ((x7875 + (letrec ((x7876 + (car + x))) + (car + x7876)))) + (car x7875)))) + (cdr x7874)))) + g7873))) + (caaddr + (lambda (x) + (letrec ((g7877 + (letrec ((x7878 + (letrec ((x7879 + (letrec ((x7880 + (cdr + x))) + (cdr + x7880)))) + (car x7879)))) + (car x7878)))) + g7877))) + (eqv? + (lambda (x y) + (letrec ((g7881 (eq? x y))) g7881))) + (>= + (lambda (x y) + (letrec ((g7882 + (letrec ((x7884 (number? x))) + (assert x7884))) + (g7883 + (letrec ((val7152 (> x y))) + (letrec ((g7885 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7886 + (if val7153 + val7153 + #f))) + g7886))))) + g7885)))) + g7883))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7887 + (letrec ((x7890 + (string? filename))) + (assert x7890))) + (g7888 + (letrec ((x7891 (procedure? proc))) + (assert x7891))) + (g7889 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7892 + (close-input-port + input-port)) + (g7893 res)) + g7893)))) + g7889))) + (ref + (lambda (x) + (letrec ((g7894 (cons x '()))) g7894))) + (char>=? + (lambda (c1 c2) + (letrec ((g7895 + (letrec ((x7898 (char? c1))) + (assert x7898))) + (g7896 + (letrec ((x7899 (char? c2))) + (assert x7899))) + (g7897 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7900 + (if val7154 + val7154 + (char=? c1 c2)))) + g7900)))) + g7897))) + (cdaar + (lambda (x) + (letrec ((g7901 + (letrec ((x7902 + (letrec ((x7903 (car x))) + (car x7903)))) + (cdr x7902)))) + g7901))) + (cdaddr + (lambda (x) + (letrec ((g7904 + (letrec ((x7905 + (letrec ((x7906 + (letrec ((x7907 + (cdr + x))) + (cdr + x7907)))) + (car x7906)))) + (cdr x7905)))) + g7904))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7908 + (letrec ((x7909 + (letrec ((x7910 (car x))) + (cdr x7910)))) + (car x7909)))) + g7908))) + (caadr + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (cdr x))) + (car x7913)))) + (car x7912)))) + g7911))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7914 + (letrec ((x7917 (char? c1))) + (assert x7917))) + (g7915 + (letrec ((x7918 (char? c2))) + (assert x7918))) + (g7916 + (letrec ((x7919 + (char-ci<=? c1 c2))) + (not x7919)))) + g7916))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7920 + (letrec ((x7921 + (letrec ((x7922 + (letrec ((x7923 + (car + x))) + (car + x7923)))) + (car x7922)))) + (car x7921)))) + g7920))) + (negative? + (lambda (x) + (letrec ((g7924 + (letrec ((x7926 (number? x))) + (assert x7926))) + (g7925 (< x 0))) + g7925))) + (memv + (lambda (e l) + (letrec ((g7927 (memq e l))) g7927))) + (caaar + (lambda (x) + (letrec ((g7928 + (letrec ((x7929 + (letrec ((x7930 (car x))) + (car x7930)))) + (car x7929)))) + g7928))) + (debug + (lambda (e) (letrec ((g7931 '())) g7931))) + (reverse + (lambda (l) + (letrec ((g7932 + (letrec ((x7934 (list? l))) + (assert x7934))) + (g7933 + (letrec ((x-cnd7935 (null? l))) + (if x-cnd7935 + '() + (letrec ((x7938 + (letrec ((x7939 + (cdr l))) + (reverse x7939))) + (x7936 + (letrec ((x7937 + (car l))) + (list x7937)))) + (append x7938 x7936)))))) + g7933))) + (caaadr + (lambda (x) + (letrec ((g7940 + (letrec ((x7941 + (letrec ((x7942 + (letrec ((x7943 + (cdr + x))) + (car + x7943)))) + (car x7942)))) + (car x7941)))) + g7940))) + (cddadr + (lambda (x) + (letrec ((g7944 + (letrec ((x7945 + (letrec ((x7946 + (letrec ((x7947 + (cdr + x))) + (car + x7947)))) + (cdr x7946)))) + (cdr x7945)))) + g7944))) + (odd? + (lambda (x) + (letrec ((g7948 + (letrec ((x7950 (number? x))) + (assert x7950))) + (g7949 + (letrec ((x7951 (modulo x 2))) + (= 1 x7951)))) + g7949))) + (caadar + (lambda (x) + (letrec ((g7952 + (letrec ((x7953 + (letrec ((x7954 + (letrec ((x7955 + (car + x))) + (cdr + x7955)))) + (car x7954)))) + (car x7953)))) + g7952))) + (apply + (lambda (proc args) + (letrec ((g7956 + (letrec ((x7959 (procedure? proc))) + (assert x7959))) + (g7957 + (letrec ((x7960 (list? args))) + (assert x7960))) + (g7958 + (if cnd + (letrec ((g7961 (proc))) g7961) + (if cnd + (letrec ((g7962 + (letrec ((x7963 + (car + args))) + (proc x7963)))) + g7962) + (if cnd + (letrec ((g7964 + (letrec ((x7966 + (car + args)) + (x7965 + (cadr + args))) + (proc + x7966 + x7965)))) + g7964) + (if cnd + (letrec ((g7967 + (letrec ((x7970 + (car + args)) + (x7969 + (cadr + args)) + (x7968 + (caddr + args))) + (proc + x7970 + x7969 + x7968)))) + g7967) + (if cnd + (letrec ((g7971 + (letrec ((x7975 + (car + args)) + (x7974 + (cadr + args)) + (x7973 + (caddr + args)) + (x7972 + (cadddr + args))) + (proc + x7975 + x7974 + x7973 + x7972)))) + g7971) + (if cnd + (letrec ((g7976 + (letrec ((x7982 + (car + args)) + (x7981 + (cadr + args)) + (x7980 + (caddr + args)) + (x7979 + (cadddr + args)) + (x7977 + (letrec ((x7978 + (cddddr + args))) + (car + x7978)))) + (proc + x7982 + x7981 + x7980 + x7979 + x7977)))) + g7976) + (if cnd + (letrec ((g7983 + (letrec ((x7991 + (car + args)) + (x7990 + (cadr + args)) + (x7989 + (caddr + args)) + (x7988 + (cadddr + args)) + (x7986 + (letrec ((x7987 + (cddddr + args))) + (car + x7987))) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (cadr + x7985)))) + (proc + x7991 + x7990 + x7989 + x7988 + x7986 + x7984)))) + g7983) + (if cnd + (letrec ((g7992 + (letrec ((x8002 + (car + args)) + (x8001 + (cadr + args)) + (x8000 + (caddr + args)) + (x7999 + (cadddr + args)) + (x7997 + (letrec ((x7998 + (cddddr + args))) + (car + x7998))) + (x7995 + (letrec ((x7996 + (cddddr + args))) + (cadr + x7996))) + (x7993 + (letrec ((x7994 + (cddddr + args))) + (caddr + x7994)))) + (proc + x8002 + x8001 + x8000 + x7999 + x7997 + x7995 + x7993)))) + g7992) + (letrec ((g8003 + (error + "Unsupported call."))) + g8003))))))))))) + g7958))) + (member + (lambda (e l) + (letrec ((g8004 + (letrec ((x8006 (list? l))) + (assert x8006))) + (g8005 + (letrec ((x-cnd8007 (null? l))) + (if x-cnd8007 + #f + (letrec ((x-cnd8008 + (letrec ((x8009 + (car l))) + (equal? x8009 e)))) + (if x-cnd8008 + l + (letrec ((x8010 (cdr l))) + (member e x8010)))))))) + g8005))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8011 + (letrec ((x8012 + (letrec ((x8013 + (letrec ((x8014 + (cdr + x))) + (cdr + x8014)))) + (cdr x8013)))) + (cdr x8012)))) + g8011))) + (cadddr + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (cdr + x))) + (cdr + x8018)))) + (cdr x8017)))) + (car x8016)))) + g8015))) + (int-top + (lambda () + (letrec ((g8019 (random 42))) g8019))) + (zero? + (lambda (x) + (letrec ((g8020 + (letrec ((x8022 (number? x))) + (assert x8022))) + (g8021 (= x 0))) + g8021))) + (string>=? + (lambda (s1 s2) + (letrec ((g8023 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8024 + (if val7155 + val7155 + (string=? s1 s2)))) + g8024)))) + g8023))) + (cadr + (lambda (x) + (letrec ((g8025 + (letrec ((x8026 (cdr x))) + (car x8026)))) + g8025))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8027 + (letrec ((val7156 + (letrec ((x8030 + (pair? l)) + (x8028 + (letrec ((x8029 + (cdr + l))) + (list? + x8029)))) + (and x8030 x8028)))) + (letrec ((g8031 + (if val7156 + val7156 + (null? l)))) + g8031)))) + g8027))) + (cddaar + (lambda (x) + (letrec ((g8032 + (letrec ((x8033 + (letrec ((x8034 + (letrec ((x8035 + (car + x))) + (car + x8035)))) + (cdr x8034)))) + (cdr x8033)))) + g8032))) + (char-numeric? + (lambda (c) + (letrec ((g8036 + (letrec ((x-cnd8037 + (letrec ((x8038 #\0)) + (char<=? x8038 c)))) + (if x-cnd8037 + (letrec ((x8039 #\9)) + (char<=? c x8039)) + #f)))) + g8036))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8040 + (letrec ((x8042 (list? l))) + (assert x8042))) + (g8041 + (letrec ((x-cnd8043 (null? l))) + (if x-cnd8043 + #f + (letrec ((x-cnd8044 + (letrec ((x8045 + (caar l))) + (eqv? x8045 k)))) + (if x-cnd8044 + (car l) + (letrec ((x8046 (cdr l))) + (assq k x8046)))))))) + g8041))) + (not + (lambda (x) + (letrec ((g8047 (if x #f #t))) g8047))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8048 (append l1 l2))) g8048))) + (memq + (lambda (e l) + (letrec ((g8049 + (letrec ((x8051 (list? l))) + (assert x8051))) + (g8050 + (letrec ((x-cnd8052 (null? l))) + (if x-cnd8052 + #f + (letrec ((x-cnd8053 + (letrec ((x8054 + (car l))) + (eq? x8054 e)))) + (if x-cnd8053 + l + (letrec ((x8055 (cdr l))) + (memq e x8055)))))))) + g8050))) + (cadaar + (lambda (x) + (letrec ((g8056 + (letrec ((x8057 + (letrec ((x8058 + (letrec ((x8059 + (car + x))) + (car + x8059)))) + (cdr x8058)))) + (car x8057)))) + g8056))) + (length + (lambda (l) + (letrec ((g8060 + (letrec ((x8062 (list? l))) + (assert x8062))) + (g8061 + (letrec ((rec + (lambda (l) + (letrec ((g8063 + (letrec ((x-cnd8064 + (null? + l))) + (if x-cnd8064 + 0 + (letrec ((x8065 + (letrec ((x8066 + (cdr + l))) + (rec + x8066)))) + (+ + 1 + x8065)))))) + g8063)))) + (letrec ((g8067 (rec l))) + g8067)))) + g8061))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8068 + (letrec ((x8071 (char? c1))) + (assert x8071))) + (g8069 + (letrec ((x8072 (char? c2))) + (assert x8072))) + (g8070 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8074 + (letrec ((x8075 (string<=? s1 s2))) + (not x8075)))) + g8074))) + (cdadr + (lambda (x) + (letrec ((g8076 + (letrec ((x8077 + (letrec ((x8078 (cdr x))) + (car x8078)))) + (cdr x8077)))) + g8076))) + (assoc + (lambda (k l) + (letrec ((g8079 + (letrec ((x8081 (list? l))) + (assert x8081))) + (g8080 + (letrec ((x-cnd8082 (null? l))) + (if x-cnd8082 + #f + (letrec ((x-cnd8083 + (letrec ((x8084 + (caar l))) + (equal? x8084 k)))) + (if x-cnd8083 + (car l) + (letrec ((x8085 (cdr l))) + (assoc k x8085)))))))) + g8080))) + (caar + (lambda (x) + (letrec ((g8086 + (letrec ((x8087 (car x))) + (car x8087)))) + g8086))) + (char>? + (lambda (c1 c2) + (letrec ((g8088 + (letrec ((x8091 (char? c1))) + (assert x8091))) + (g8089 + (letrec ((x8092 (char? c2))) + (assert x8092))) + (g8090 + (letrec ((x8093 (char<=? c1 c2))) + (not x8093)))) + g8090))) + (string<=? + (lambda (s1 s2) + (letrec ((g8094 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8111 + (letrec ((x8114 (char? c1))) + (assert x8114))) + (g8112 + (letrec ((x8115 (char? c2))) + (assert x8115))) + (g8113 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8116 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8116)))) + g8113))) + (caddar + (lambda (x) + (letrec ((g8117 + (letrec ((x8118 + (letrec ((x8119 + (letrec ((x8120 + (car + x))) + (cdr + x8120)))) + (cdr x8119)))) + (car x8118)))) + g8117))) + (newline + (lambda () (letrec ((g8121 #f)) g8121))) + (lcm + (lambda (m n) + (letrec ((g8122 + (letrec ((x8124 + (letrec ((x8125 (* m n))) + (abs x8125))) + (x8123 (gcd m n))) + (/ x8124 x8123)))) + g8122))) + (deref car) + (> + (lambda (x y) + (letrec ((g8126 + (letrec ((x8128 (number? x))) + (assert x8128))) + (g8127 + (letrec ((x8129 (<= x y))) + (not x8129)))) + g8127))) + (list-ref + (lambda (l index) + (letrec ((g8130 + (letrec ((x8134 (list? l))) + (assert x8134))) + (g8131 + (letrec ((x8135 (number? index))) + (assert x8135))) + (g8132 + (letrec ((x8136 + (letrec ((x8137 + (length l))) + (< index x8137)))) + (assert x8136))) + (g8133 + (letrec ((x-cnd8138 (= index 0))) + (if x-cnd8138 + (car l) + (letrec ((x8140 (cdr l)) + (x8139 (- index 1))) + (list-ref x8140 x8139)))))) + g8133))) + (gcd + (lambda (a b) + (letrec ((g8141 + (letrec ((x-cnd8142 (= b 0))) + (if x-cnd8142 + a + (letrec ((x8143 (modulo a b))) + (gcd b x8143)))))) + g8141)))) + (letrec ((g8144 + (letrec ((g8145 + (letrec ((mk-list + (lambda (n x) + (letrec ((g8146 + (letrec ((x-cnd8147 + (< + n + 0))) + (if x-cnd8147 + empty + (letrec ((x8148 + (letrec ((x8149 + (- + n + 1))) + (mk-list + x8149 + x)))) + (cons + x + x8148)))))) + g8146))) + (mem + (lambda (x xs) + (letrec ((g8150 + (letrec ((x-cnd8151 + (empty? + xs))) + (if x-cnd8151 + #f + (letrec ((val7160 + (letrec ((x8152 + (car + xs))) + (= + x + x8152)))) + (letrec ((g8153 + (if val7160 + val7160 + (letrec ((x8154 + (cdr + xs))) + (mem + x + x8154))))) + g8153)))))) + g8150)))) + (letrec ((g8155 + (letrec ((g8156 + (letrec ((g8157 + ((lambda (j7233 + k7234 + f7235) + (lambda (g7231 + g7232) + (letrec ((x7236 + (integer?/c + j7233 + k7234 + g7231)) + (x7237 + (integer?/c + j7233 + k7234 + g7232))) + (((lambda (_ + x) + (and/c + (listof + integer?/c) + (lambda (g7238 + g7239 + g7240) + (if ((lambda (l) + (letrec ((val7161 + (empty? + l))) + (if val7161 + val7161 + (member + x + l)))) + g7240) + g7240 + (blame + g7238 + '(lambda (l) + (letrec ((val7161 + (empty? + l))) + (if val7161 + val7161 + (member + x + l))))))))) + x7236 + x7237) + j7233 + k7234 + (f7235 + x7236 + x7237))))) + 'module + 'importer + mk-list)) + (g8158 + (letrec ((x8161 + ((lambda (j7243 + k7244 + f7245) + (lambda (g7241 + g7242) + (boolean?/c + j7243 + k7244 + (f7245 + (integer?/c + j7243 + k7244 + g7241) + ((listof + integer?/c) + j7243 + k7244 + g7242))))) + 'module + 'importer + mem)) + (x8160 + (input)) + (x8159 + (input))) + (x8161 + x8160 + x8159)))) + g8158))) + g8156))) + g8155)))) + g8145))) + g8144)))) + g7257))) + g7256)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_mult.rkt b/analyses/simpleactor/benchmarks-out/mochi_mult.rkt index 0e5a9b68..1478af7b 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_mult.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_mult.rkt @@ -1,32 +1,3120 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7240 #t)) g7240))) + (meta (lambda (v) (letrec ((g7241 v)) g7241))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7242 + (letrec ((g7243 + (letrec ((x-e7244 lst)) + (match + x-e7244 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7245 (eq? v v1))) + (if x-cnd7245 #t (member v vs))))))))) + g7243))) + g7242))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (mult n m) (if (or (<= n 0) (<= m 0)) 0 (+ n (mult n (- m 1))))) - (define (sqr n) (mult n n)) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - ((and/c integer? (>=/c 0)) - j3985 - k3986 - (f3987 - (integer? j3985 k3986 g3983) - (integer? j3985 k3986 g3984))))) - 'module - 'importer - mult) - (input) - (input)) - ((->d integer? (lambda (n) (and/c integer? (>=/c n)))) - 'module - 'importer - sqr))))) + (actor? + (lambda (k j) + (letrec ((g7246 (lambda (v) (letrec ((g7247 v)) g7247)))) g7246))) + (nonzero? + (lambda (v) + (letrec ((g7248 (letrec ((x7249 (= v 0))) (not x7249)))) g7248)))) + (letrec ((g7250 + (letrec ((g7251 + (letrec ((real/c + (lambda (g7161 g7162 g7163) + (letrec ((g7252 + (letrec ((x-cnd7253 (real? g7163))) + (if x-cnd7253 + g7163 + (blame g7161 'real?))))) + g7252))) + (boolean?/c + (lambda (g7164 g7165 g7166) + (letrec ((g7254 + (letrec ((x-cnd7255 + (boolean? g7166))) + (if x-cnd7255 + g7166 + (blame g7164 'boolean?))))) + g7254))) + (number?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7256 + (letrec ((x-cnd7257 + (number? g7169))) + (if x-cnd7257 + g7169 + (blame g7167 'number?))))) + g7256))) + (any/c + (lambda (g7170 g7171 g7172) + (letrec ((g7258 + (letrec ((x-cnd7259 + ((lambda (v) #t) g7172))) + (if x-cnd7259 + g7172 + (blame + g7170 + '(lambda (v) #t)))))) + g7258))) + (any?/c + (lambda (g7173 g7174 g7175) + (letrec ((g7260 + (letrec ((x-cnd7261 + ((lambda (v) #t) g7175))) + (if x-cnd7261 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7260))) + (image? any/c) + (cons?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7262 + (letrec ((x-cnd7263 (pair? g7178))) + (if x-cnd7263 + g7178 + (blame g7176 'pair?))))) + g7262))) + (pair?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7264 + (letrec ((x-cnd7265 (pair? g7181))) + (if x-cnd7265 + g7181 + (blame g7179 'pair?))))) + g7264))) + (integer? + (lambda (g7182 g7183 g7184) + (letrec ((g7266 + (letrec ((x-cnd7267 + (integer? g7184))) + (if x-cnd7267 + g7184 + (blame g7182 'integer?))))) + g7266))) + (and/c + (lambda (c1 c2) + (letrec ((g7268 + (lambda (k j v) + (letrec ((g7269 + (letrec ((x-cnd7270 + (c1 k j v))) + (if x-cnd7270 + (c2 k j v) + #f)))) + g7269)))) + g7268))) + (list-of + (lambda (contract) + (letrec ((g7271 + (lambda (k j v) + (letrec ((g7272 + (letrec ((x-cnd7273 + (null? v))) + (if x-cnd7273 + '() + (letrec ((x7277 + (letrec ((x7278 + (car + v))) + (contract + k + j + x7278))) + (x7274 + (letrec ((x7276 + (list-of + contract)) + (x7275 + (cdr + v))) + (x7276 + k + j + x7275)))) + (cons + x7277 + x7274)))))) + g7272)))) + g7271))) + (any? (lambda (v) (letrec ((g7279 #t)) g7279))) + (nonzero? + (lambda (v) + (letrec ((g7280 + (letrec ((x7281 (= v 0))) + (not x7281)))) + g7280))) + (nonzero?/c + (lambda (g7185 g7186 g7187) + (letrec ((g7282 + (letrec ((x-cnd7283 + ((lambda (v) + (not (= v 0))) + g7187))) + (if x-cnd7283 + g7187 + (blame + g7185 + '(lambda (v) + (not (= v 0)))))))) + g7282))) + (meta (lambda (v) (letrec ((g7284 v)) g7284))) + (orig-+ +) + (+ + ((lambda (j7190 k7191 f7192) + (lambda (g7188 g7189) + (number?/c + j7190 + k7191 + (f7192 + (number?/c j7190 k7191 g7188) + (number?/c j7190 k7191 g7189))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7195 k7196 f7197) + (lambda (g7193 g7194) + (number?/c + j7195 + k7196 + (f7197 + (number?/c j7195 k7196 g7193) + (number?/c j7195 k7196 g7194))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7200 k7201 f7202) + (lambda (g7198 g7199) + (number?/c + j7200 + k7201 + (f7202 + (number?/c j7200 k7201 g7198) + (number?/c j7200 k7201 g7199))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7205 k7206 f7207) + (lambda (g7203 g7204) + (number?/c + j7205 + k7206 + (f7207 + (number?/c j7205 k7206 g7203) + (number?/c j7205 k7206 g7204))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7209 k7210 f7211) + (lambda (g7208) + (any/c + j7209 + k7210 + (f7211 (pair?/c j7209 k7210 g7208))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7213 k7214 f7215) + (lambda (g7212) + (any/c + j7213 + k7214 + (f7215 (pair?/c j7213 k7214 g7212))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7218 k7219 f7220) + (lambda (g7216 g7217) + (pair?/c + j7218 + k7219 + (f7220 + (any/c j7218 k7219 g7216) + (any/c j7218 k7219 g7217))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7222 k7223 f7224) + (lambda (g7221) + (integer?/c + j7222 + k7223 + (f7224 (vector?/c j7222 k7223 g7221))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7227 k7228 f7229) + (lambda (g7225 g7226) + (any/c + j7227 + k7228 + (f7229 + (vector?/c j7227 k7228 g7225) + (integer?/c j7227 k7228 g7226))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7285 #t)) g7285))) + (cdddr + (lambda (x) + (letrec ((g7286 + (letrec ((x7287 + (letrec ((x7288 (cdr x))) + (cdr x7288)))) + (cdr x7287)))) + g7286))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7289 + (letrec ((x7292 (procedure? f))) + (assert x7292))) + (g7290 + (letrec ((x7293 (list? l))) + (assert x7293))) + (g7291 + (letrec ((x-cnd7294 (null? l))) + (if x-cnd7294 + '() + (letrec ((x7297 + (letrec ((x7298 + (car l))) + (f x7298))) + (x7295 + (letrec ((x7296 + (cdr l))) + (map f x7296)))) + (cons x7297 x7295)))))) + g7291))) + (cdar + (lambda (x) + (letrec ((g7299 + (letrec ((x7300 (car x))) + (cdr x7300)))) + g7299))) + (cadadr + (lambda (x) + (letrec ((g7301 + (letrec ((x7302 + (letrec ((x7303 + (letrec ((x7304 + (cdr + x))) + (car + x7304)))) + (cdr x7303)))) + (car x7302)))) + g7301))) + (cdadar + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 + (letrec ((x7308 + (car + x))) + (cdr + x7308)))) + (car x7307)))) + (cdr x7306)))) + g7305))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7309 + (letrec ((x7312 + (string? filename))) + (assert x7312))) + (g7310 + (letrec ((x7313 (procedure? proc))) + (assert x7313))) + (g7311 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7314 + (close-output-port + output-port)) + (g7315 res)) + g7315)))) + g7311))) + (caddr + (lambda (x) + (letrec ((g7316 + (letrec ((x7317 + (letrec ((x7318 (cdr x))) + (cdr x7318)))) + (car x7317)))) + g7316))) + (cdaadr + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 + (letrec ((x7321 + (letrec ((x7322 + (cdr + x))) + (car + x7322)))) + (car x7321)))) + (cdr x7320)))) + g7319))) + (assq + (lambda (k l) + (letrec ((g7323 + (letrec ((x7325 (list? l))) + (assert x7325))) + (g7324 + (letrec ((x-cnd7326 (null? l))) + (if x-cnd7326 + #f + (letrec ((x-cnd7327 + (letrec ((x7328 + (caar l))) + (eq? x7328 k)))) + (if x-cnd7327 + (car l) + (letrec ((x7329 (cdr l))) + (assq k x7329)))))))) + g7324))) + (even? + (lambda (x) + (letrec ((g7330 + (letrec ((x7331 (modulo x 2))) + (= 0 x7331)))) + g7330))) + (list->string + (lambda (l) + (letrec ((g7332 + (letrec ((x7334 (list? l))) + (assert x7334))) + (g7333 + (letrec ((x-cnd7335 (null? l))) + (if x-cnd7335 + "" + (letrec ((x7338 + (letrec ((x7339 + (car l))) + (char->string + x7339))) + (x7336 + (letrec ((x7337 + (cdr l))) + (list->string + x7337)))) + (string-append + x7338 + x7336)))))) + g7333))) + (char<=? + (lambda (c1 c2) + (letrec ((g7340 + (letrec ((x7343 (char? c1))) + (assert x7343))) + (g7341 + (letrec ((x7344 (char? c2))) + (assert x7344))) + (g7342 + (letrec ((val7143 (char=? c x7361)))) + (if x-cnd7360 + (letrec ((x7362 #\z)) + (char-ci<=? c x7362)) + #f)))) + g7359))) + (<= + (lambda (x y) + (letrec ((g7363 + (letrec ((x7365 (number? x))) + (assert x7365))) + (g7364 + (letrec ((val7144 (< x y))) + (letrec ((g7366 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7367 + (if val7145 + val7145 + #f))) + g7367))))) + g7366)))) + g7364))) + (char-whitespace? + (lambda (c) + (letrec ((g7368 + (letrec ((val7146 + (letrec ((x7369 + (char->integer + c))) + (= x7369 9)))) + (letrec ((g7370 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7371 + (char->integer + c))) + (= + x7371 + 10)))) + (letrec ((g7372 + (if val7147 + val7147 + (letrec ((x7373 + (char->integer + c))) + (= + x7373 + 32))))) + g7372))))) + g7370)))) + g7368))) + (cddar + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 + (letrec ((x7376 (car x))) + (cdr x7376)))) + (cdr x7375)))) + g7374))) + (positive? + (lambda (x) + (letrec ((g7377 + (letrec ((x7379 (number? x))) + (assert x7379))) + (g7378 (> x 0))) + g7378))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7380 #f)) g7380))) + (cddr + (lambda (x) + (letrec ((g7381 + (letrec ((x7382 (cdr x))) + (cdr x7382)))) + g7381))) + (truncate + (lambda (x) + (letrec ((g7383 + (letrec ((x7385 (number? x))) + (assert x7385))) + (g7384 + (letrec ((x-cnd7386 (< x 0))) + (if x-cnd7386 + (ceiling x) + (floor x))))) + g7384))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7387 + (letrec ((val7148 (eq? a b))) + (letrec ((g7388 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7390 + (null? + a)) + (x7389 + (null? + b))) + (and x7390 + x7389)))) + (letrec ((g7391 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7394 + (string? + a)) + (x7393 + (string? + b)) + (x7392 + (string=? + a + b))) + (and x7394 + x7393 + x7392)))) + (letrec ((g7395 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7403 + (pair? + a)) + (x7402 + (pair? + b)) + (x7399 + (letrec ((x7401 + (car + a)) + (x7400 + (car + b))) + (equal? + x7401 + x7400))) + (x7396 + (letrec ((x7398 + (cdr + a)) + (x7397 + (cdr + b))) + (equal? + x7398 + x7397)))) + (and x7403 + x7402 + x7399 + x7396)))) + (letrec ((g7404 + (if val7151 + val7151 + (letrec ((x7423 + (vector? + a)) + (x7422 + (vector? + b)) + (x7405 + (letrec ((x7419 + (letrec ((x7420 + (letrec ((x7421 + (vector-length + a))) + (n + x7421)))) + (x7420))) + (x7406 + (letrec ((x7417 + (letrec ((x7418 + (vector-length + b))) + (= + x7418 + n))) + (x7407 + (letrec ((loop + (lambda (i) + (letrec ((g7408 + (letrec ((x7415 + (= + i + n)) + (x7409 + (letrec ((x7412 + (letrec ((x7414 + (vector-ref + a + i)) + (x7413 + (vector-ref + b + i))) + (equal? + x7414 + x7413))) + (x7410 + (letrec ((x7411 + (+ + i + 1))) + (loop + x7411)))) + (and x7412 + x7410)))) + (or x7415 + x7409)))) + g7408)))) + (letrec ((g7416 + (loop + 0))) + g7416)))) + (and x7417 + x7407)))) + (let x7419 x7406)))) + (and x7423 + x7422 + x7405))))) + g7404))))) + g7395))))) + g7391))))) + g7388)))) + g7387))) + (cdaaar + (lambda (x) + (letrec ((g7424 + (letrec ((x7425 + (letrec ((x7426 + (letrec ((x7427 + (car + x))) + (car + x7427)))) + (car x7426)))) + (cdr x7425)))) + g7424))) + (caaddr + (lambda (x) + (letrec ((g7428 + (letrec ((x7429 + (letrec ((x7430 + (letrec ((x7431 + (cdr + x))) + (cdr + x7431)))) + (car x7430)))) + (car x7429)))) + g7428))) + (eqv? + (lambda (x y) + (letrec ((g7432 (eq? x y))) g7432))) + (>= + (lambda (x y) + (letrec ((g7433 + (letrec ((x7435 (number? x))) + (assert x7435))) + (g7434 + (letrec ((val7152 (> x y))) + (letrec ((g7436 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7437 + (if val7153 + val7153 + #f))) + g7437))))) + g7436)))) + g7434))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7438 + (letrec ((x7441 + (string? filename))) + (assert x7441))) + (g7439 + (letrec ((x7442 (procedure? proc))) + (assert x7442))) + (g7440 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7443 + (close-input-port + input-port)) + (g7444 res)) + g7444)))) + g7440))) + (ref + (lambda (x) + (letrec ((g7445 (cons x '()))) g7445))) + (char>=? + (lambda (c1 c2) + (letrec ((g7446 + (letrec ((x7449 (char? c1))) + (assert x7449))) + (g7447 + (letrec ((x7450 (char? c2))) + (assert x7450))) + (g7448 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7451 + (if val7154 + val7154 + (char=? c1 c2)))) + g7451)))) + g7448))) + (cdaar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (car x7454)))) + (cdr x7453)))) + g7452))) + (cdaddr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 + (letrec ((x7458 + (cdr + x))) + (cdr + x7458)))) + (car x7457)))) + (cdr x7456)))) + g7455))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7459 + (letrec ((x7460 + (letrec ((x7461 (car x))) + (cdr x7461)))) + (car x7460)))) + g7459))) + (caadr + (lambda (x) + (letrec ((g7462 + (letrec ((x7463 + (letrec ((x7464 (cdr x))) + (car x7464)))) + (car x7463)))) + g7462))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7465 + (letrec ((x7468 (char? c1))) + (assert x7468))) + (g7466 + (letrec ((x7469 (char? c2))) + (assert x7469))) + (g7467 + (letrec ((x7470 + (char-ci<=? c1 c2))) + (not x7470)))) + g7467))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7471 + (letrec ((x7472 + (letrec ((x7473 + (letrec ((x7474 + (car + x))) + (car + x7474)))) + (car x7473)))) + (car x7472)))) + g7471))) + (negative? + (lambda (x) + (letrec ((g7475 + (letrec ((x7477 (number? x))) + (assert x7477))) + (g7476 (< x 0))) + g7476))) + (memv + (lambda (e l) + (letrec ((g7478 (memq e l))) g7478))) + (caaar + (lambda (x) + (letrec ((g7479 + (letrec ((x7480 + (letrec ((x7481 (car x))) + (car x7481)))) + (car x7480)))) + g7479))) + (debug + (lambda (e) (letrec ((g7482 '())) g7482))) + (reverse + (lambda (l) + (letrec ((g7483 + (letrec ((x7485 (list? l))) + (assert x7485))) + (g7484 + (letrec ((x-cnd7486 (null? l))) + (if x-cnd7486 + '() + (letrec ((x7489 + (letrec ((x7490 + (cdr l))) + (reverse x7490))) + (x7487 + (letrec ((x7488 + (car l))) + (list x7488)))) + (append x7489 x7487)))))) + g7484))) + (caaadr + (lambda (x) + (letrec ((g7491 + (letrec ((x7492 + (letrec ((x7493 + (letrec ((x7494 + (cdr + x))) + (car + x7494)))) + (car x7493)))) + (car x7492)))) + g7491))) + (cddadr + (lambda (x) + (letrec ((g7495 + (letrec ((x7496 + (letrec ((x7497 + (letrec ((x7498 + (cdr + x))) + (car + x7498)))) + (cdr x7497)))) + (cdr x7496)))) + g7495))) + (odd? + (lambda (x) + (letrec ((g7499 + (letrec ((x7501 (number? x))) + (assert x7501))) + (g7500 + (letrec ((x7502 (modulo x 2))) + (= 1 x7502)))) + g7500))) + (caadar + (lambda (x) + (letrec ((g7503 + (letrec ((x7504 + (letrec ((x7505 + (letrec ((x7506 + (car + x))) + (cdr + x7506)))) + (car x7505)))) + (car x7504)))) + g7503))) + (apply + (lambda (proc args) + (letrec ((g7507 + (letrec ((x7510 (procedure? proc))) + (assert x7510))) + (g7508 + (letrec ((x7511 (list? args))) + (assert x7511))) + (g7509 + (if cnd + (letrec ((g7512 (proc))) g7512) + (if cnd + (letrec ((g7513 + (letrec ((x7514 + (car + args))) + (proc x7514)))) + g7513) + (if cnd + (letrec ((g7515 + (letrec ((x7517 + (car + args)) + (x7516 + (cadr + args))) + (proc + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7518 + (letrec ((x7521 + (car + args)) + (x7520 + (cadr + args)) + (x7519 + (caddr + args))) + (proc + x7521 + x7520 + x7519)))) + g7518) + (if cnd + (letrec ((g7522 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args))) + (proc + x7526 + x7525 + x7524 + x7523)))) + g7522) + (if cnd + (letrec ((g7527 + (letrec ((x7533 + (car + args)) + (x7532 + (cadr + args)) + (x7531 + (caddr + args)) + (x7530 + (cadddr + args)) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (car + x7529)))) + (proc + x7533 + x7532 + x7531 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7534 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535)))) + g7534) + (if cnd + (letrec ((g7543 + (letrec ((x7553 + (car + args)) + (x7552 + (cadr + args)) + (x7551 + (caddr + args)) + (x7550 + (cadddr + args)) + (x7548 + (letrec ((x7549 + (cddddr + args))) + (car + x7549))) + (x7546 + (letrec ((x7547 + (cddddr + args))) + (cadr + x7547))) + (x7544 + (letrec ((x7545 + (cddddr + args))) + (caddr + x7545)))) + (proc + x7553 + x7552 + x7551 + x7550 + x7548 + x7546 + x7544)))) + g7543) + (letrec ((g7554 + (error + "Unsupported call."))) + g7554))))))))))) + g7509))) + (member + (lambda (e l) + (letrec ((g7555 + (letrec ((x7557 (list? l))) + (assert x7557))) + (g7556 + (letrec ((x-cnd7558 (null? l))) + (if x-cnd7558 + #f + (letrec ((x-cnd7559 + (letrec ((x7560 + (car l))) + (equal? x7560 e)))) + (if x-cnd7559 + l + (letrec ((x7561 (cdr l))) + (member e x7561)))))))) + g7556))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7562 + (letrec ((x7563 + (letrec ((x7564 + (letrec ((x7565 + (cdr + x))) + (cdr + x7565)))) + (cdr x7564)))) + (cdr x7563)))) + g7562))) + (cadddr + (lambda (x) + (letrec ((g7566 + (letrec ((x7567 + (letrec ((x7568 + (letrec ((x7569 + (cdr + x))) + (cdr + x7569)))) + (cdr x7568)))) + (car x7567)))) + g7566))) + (int-top + (lambda () + (letrec ((g7570 (random 42))) g7570))) + (zero? + (lambda (x) + (letrec ((g7571 + (letrec ((x7573 (number? x))) + (assert x7573))) + (g7572 (= x 0))) + g7572))) + (string>=? + (lambda (s1 s2) + (letrec ((g7574 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7575 + (if val7155 + val7155 + (string=? s1 s2)))) + g7575)))) + g7574))) + (cadr + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 (cdr x))) + (car x7577)))) + g7576))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7578 + (letrec ((val7156 + (letrec ((x7581 + (pair? l)) + (x7579 + (letrec ((x7580 + (cdr + l))) + (list? + x7580)))) + (and x7581 x7579)))) + (letrec ((g7582 + (if val7156 + val7156 + (null? l)))) + g7582)))) + g7578))) + (cddaar + (lambda (x) + (letrec ((g7583 + (letrec ((x7584 + (letrec ((x7585 + (letrec ((x7586 + (car + x))) + (car + x7586)))) + (cdr x7585)))) + (cdr x7584)))) + g7583))) + (char-numeric? + (lambda (c) + (letrec ((g7587 + (letrec ((x-cnd7588 + (letrec ((x7589 #\0)) + (char<=? x7589 c)))) + (if x-cnd7588 + (letrec ((x7590 #\9)) + (char<=? c x7590)) + #f)))) + g7587))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7591 + (letrec ((x7593 (list? l))) + (assert x7593))) + (g7592 + (letrec ((x-cnd7594 (null? l))) + (if x-cnd7594 + #f + (letrec ((x-cnd7595 + (letrec ((x7596 + (caar l))) + (eqv? x7596 k)))) + (if x-cnd7595 + (car l) + (letrec ((x7597 (cdr l))) + (assq k x7597)))))))) + g7592))) + (not + (lambda (x) + (letrec ((g7598 (if x #f #t))) g7598))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7599 (append l1 l2))) g7599))) + (memq + (lambda (e l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((x-cnd7603 (null? l))) + (if x-cnd7603 + #f + (letrec ((x-cnd7604 + (letrec ((x7605 + (car l))) + (eq? x7605 e)))) + (if x-cnd7604 + l + (letrec ((x7606 (cdr l))) + (memq e x7606)))))))) + g7601))) + (cadaar + (lambda (x) + (letrec ((g7607 + (letrec ((x7608 + (letrec ((x7609 + (letrec ((x7610 + (car + x))) + (car + x7610)))) + (cdr x7609)))) + (car x7608)))) + g7607))) + (length + (lambda (l) + (letrec ((g7611 + (letrec ((x7613 (list? l))) + (assert x7613))) + (g7612 + (letrec ((rec + (lambda (l) + (letrec ((g7614 + (letrec ((x-cnd7615 + (null? + l))) + (if x-cnd7615 + 0 + (letrec ((x7616 + (letrec ((x7617 + (cdr + l))) + (rec + x7617)))) + (+ + 1 + x7616)))))) + g7614)))) + (letrec ((g7618 (rec l))) + g7618)))) + g7612))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7619 + (letrec ((x7622 (char? c1))) + (assert x7622))) + (g7620 + (letrec ((x7623 (char? c2))) + (assert x7623))) + (g7621 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7625 + (letrec ((x7626 (string<=? s1 s2))) + (not x7626)))) + g7625))) + (cdadr + (lambda (x) + (letrec ((g7627 + (letrec ((x7628 + (letrec ((x7629 (cdr x))) + (car x7629)))) + (cdr x7628)))) + g7627))) + (assoc + (lambda (k l) + (letrec ((g7630 + (letrec ((x7632 (list? l))) + (assert x7632))) + (g7631 + (letrec ((x-cnd7633 (null? l))) + (if x-cnd7633 + #f + (letrec ((x-cnd7634 + (letrec ((x7635 + (caar l))) + (equal? x7635 k)))) + (if x-cnd7634 + (car l) + (letrec ((x7636 (cdr l))) + (assoc k x7636)))))))) + g7631))) + (caar + (lambda (x) + (letrec ((g7637 + (letrec ((x7638 (car x))) + (car x7638)))) + g7637))) + (char>? + (lambda (c1 c2) + (letrec ((g7639 + (letrec ((x7642 (char? c1))) + (assert x7642))) + (g7640 + (letrec ((x7643 (char? c2))) + (assert x7643))) + (g7641 + (letrec ((x7644 (char<=? c1 c2))) + (not x7644)))) + g7641))) + (string<=? + (lambda (s1 s2) + (letrec ((g7645 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7662 + (letrec ((x7665 (char? c1))) + (assert x7665))) + (g7663 + (letrec ((x7666 (char? c2))) + (assert x7666))) + (g7664 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7667 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7667)))) + g7664))) + (caddar + (lambda (x) + (letrec ((g7668 + (letrec ((x7669 + (letrec ((x7670 + (letrec ((x7671 + (car + x))) + (cdr + x7671)))) + (cdr x7670)))) + (car x7669)))) + g7668))) + (newline + (lambda () (letrec ((g7672 #f)) g7672))) + (lcm + (lambda (m n) + (letrec ((g7673 + (letrec ((x7675 + (letrec ((x7676 (* m n))) + (abs x7676))) + (x7674 (gcd m n))) + (/ x7675 x7674)))) + g7673))) + (deref car) + (> + (lambda (x y) + (letrec ((g7677 + (letrec ((x7679 (number? x))) + (assert x7679))) + (g7678 + (letrec ((x7680 (<= x y))) + (not x7680)))) + g7678))) + (list-ref + (lambda (l index) + (letrec ((g7681 + (letrec ((x7685 (list? l))) + (assert x7685))) + (g7682 + (letrec ((x7686 (number? index))) + (assert x7686))) + (g7683 + (letrec ((x7687 + (letrec ((x7688 + (length l))) + (< index x7688)))) + (assert x7687))) + (g7684 + (letrec ((x-cnd7689 (= index 0))) + (if x-cnd7689 + (car l) + (letrec ((x7691 (cdr l)) + (x7690 (- index 1))) + (list-ref x7691 x7690)))))) + g7684))) + (gcd + (lambda (a b) + (letrec ((g7692 + (letrec ((x-cnd7693 (= b 0))) + (if x-cnd7693 + a + (letrec ((x7694 (modulo a b))) + (gcd b x7694)))))) + g7692))) + (real/c + (lambda (g7161 g7162 g7163) + (letrec ((g7695 + (letrec ((x-cnd7696 (real? g7163))) + (if x-cnd7696 + g7163 + (blame g7161 'real?))))) + g7695))) + (boolean?/c + (lambda (g7164 g7165 g7166) + (letrec ((g7697 + (letrec ((x-cnd7698 + (boolean? g7166))) + (if x-cnd7698 + g7166 + (blame g7164 'boolean?))))) + g7697))) + (number?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7699 + (letrec ((x-cnd7700 + (number? g7169))) + (if x-cnd7700 + g7169 + (blame g7167 'number?))))) + g7699))) + (any/c + (lambda (g7170 g7171 g7172) + (letrec ((g7701 + (letrec ((x-cnd7702 + ((lambda (v) #t) g7172))) + (if x-cnd7702 + g7172 + (blame + g7170 + '(lambda (v) #t)))))) + g7701))) + (any?/c + (lambda (g7173 g7174 g7175) + (letrec ((g7703 + (letrec ((x-cnd7704 + ((lambda (v) #t) g7175))) + (if x-cnd7704 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7703))) + (image? any/c) + (cons?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7705 + (letrec ((x-cnd7706 (pair? g7178))) + (if x-cnd7706 + g7178 + (blame g7176 'pair?))))) + g7705))) + (pair?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7707 + (letrec ((x-cnd7708 (pair? g7181))) + (if x-cnd7708 + g7181 + (blame g7179 'pair?))))) + g7707))) + (integer? + (lambda (g7182 g7183 g7184) + (letrec ((g7709 + (letrec ((x-cnd7710 + (integer? g7184))) + (if x-cnd7710 + g7184 + (blame g7182 'integer?))))) + g7709))) + (and/c + (lambda (c1 c2) + (letrec ((g7711 + (lambda (k j v) + (letrec ((g7712 + (letrec ((x-cnd7713 + (c1 k j v))) + (if x-cnd7713 + (c2 k j v) + #f)))) + g7712)))) + g7711))) + (list-of + (lambda (contract) + (letrec ((g7714 + (lambda (k j v) + (letrec ((g7715 + (letrec ((x-cnd7716 + (null? v))) + (if x-cnd7716 + '() + (letrec ((x7720 + (letrec ((x7721 + (car + v))) + (contract + k + j + x7721))) + (x7717 + (letrec ((x7719 + (list-of + contract)) + (x7718 + (cdr + v))) + (x7719 + k + j + x7718)))) + (cons + x7720 + x7717)))))) + g7715)))) + g7714))) + (any? (lambda (v) (letrec ((g7722 #t)) g7722))) + (nonzero? + (lambda (v) + (letrec ((g7723 + (letrec ((x7724 (= v 0))) + (not x7724)))) + g7723))) + (nonzero?/c + (lambda (g7185 g7186 g7187) + (letrec ((g7725 + (letrec ((x-cnd7726 + ((lambda (v) + (not (= v 0))) + g7187))) + (if x-cnd7726 + g7187 + (blame + g7185 + '(lambda (v) + (not (= v 0)))))))) + g7725))) + (meta (lambda (v) (letrec ((g7727 v)) g7727))) + (orig-+ +) + (+ + ((lambda (j7190 k7191 f7192) + (lambda (g7188 g7189) + (number?/c + j7190 + k7191 + (f7192 + (number?/c j7190 k7191 g7188) + (number?/c j7190 k7191 g7189))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7195 k7196 f7197) + (lambda (g7193 g7194) + (number?/c + j7195 + k7196 + (f7197 + (number?/c j7195 k7196 g7193) + (number?/c j7195 k7196 g7194))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7200 k7201 f7202) + (lambda (g7198 g7199) + (number?/c + j7200 + k7201 + (f7202 + (number?/c j7200 k7201 g7198) + (number?/c j7200 k7201 g7199))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7205 k7206 f7207) + (lambda (g7203 g7204) + (number?/c + j7205 + k7206 + (f7207 + (number?/c j7205 k7206 g7203) + (number?/c j7205 k7206 g7204))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7209 k7210 f7211) + (lambda (g7208) + (any/c + j7209 + k7210 + (f7211 (pair?/c j7209 k7210 g7208))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7213 k7214 f7215) + (lambda (g7212) + (any/c + j7213 + k7214 + (f7215 (pair?/c j7213 k7214 g7212))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7218 k7219 f7220) + (lambda (g7216 g7217) + (pair?/c + j7218 + k7219 + (f7220 + (any/c j7218 k7219 g7216) + (any/c j7218 k7219 g7217))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7222 k7223 f7224) + (lambda (g7221) + (integer?/c + j7222 + k7223 + (f7224 (vector?/c j7222 k7223 g7221))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7227 k7228 f7229) + (lambda (g7225 g7226) + (any/c + j7227 + k7228 + (f7229 + (vector?/c j7227 k7228 g7225) + (integer?/c j7227 k7228 g7226))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7728 #t)) g7728))) + (cdddr + (lambda (x) + (letrec ((g7729 + (letrec ((x7730 + (letrec ((x7731 (cdr x))) + (cdr x7731)))) + (cdr x7730)))) + g7729))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7732 + (letrec ((x7735 (procedure? f))) + (assert x7735))) + (g7733 + (letrec ((x7736 (list? l))) + (assert x7736))) + (g7734 + (letrec ((x-cnd7737 (null? l))) + (if x-cnd7737 + '() + (letrec ((x7740 + (letrec ((x7741 + (car l))) + (f x7741))) + (x7738 + (letrec ((x7739 + (cdr l))) + (map f x7739)))) + (cons x7740 x7738)))))) + g7734))) + (cdar + (lambda (x) + (letrec ((g7742 + (letrec ((x7743 (car x))) + (cdr x7743)))) + g7742))) + (cadadr + (lambda (x) + (letrec ((g7744 + (letrec ((x7745 + (letrec ((x7746 + (letrec ((x7747 + (cdr + x))) + (car + x7747)))) + (cdr x7746)))) + (car x7745)))) + g7744))) + (cdadar + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 + (letrec ((x7751 + (car + x))) + (cdr + x7751)))) + (car x7750)))) + (cdr x7749)))) + g7748))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7752 + (letrec ((x7755 + (string? filename))) + (assert x7755))) + (g7753 + (letrec ((x7756 (procedure? proc))) + (assert x7756))) + (g7754 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7757 + (close-output-port + output-port)) + (g7758 res)) + g7758)))) + g7754))) + (caddr + (lambda (x) + (letrec ((g7759 + (letrec ((x7760 + (letrec ((x7761 (cdr x))) + (cdr x7761)))) + (car x7760)))) + g7759))) + (cdaadr + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 + (letrec ((x7764 + (letrec ((x7765 + (cdr + x))) + (car + x7765)))) + (car x7764)))) + (cdr x7763)))) + g7762))) + (assq + (lambda (k l) + (letrec ((g7766 + (letrec ((x7768 (list? l))) + (assert x7768))) + (g7767 + (letrec ((x-cnd7769 (null? l))) + (if x-cnd7769 + #f + (letrec ((x-cnd7770 + (letrec ((x7771 + (caar l))) + (eq? x7771 k)))) + (if x-cnd7770 + (car l) + (letrec ((x7772 (cdr l))) + (assq k x7772)))))))) + g7767))) + (even? + (lambda (x) + (letrec ((g7773 + (letrec ((x7774 (modulo x 2))) + (= 0 x7774)))) + g7773))) + (list->string + (lambda (l) + (letrec ((g7775 + (letrec ((x7777 (list? l))) + (assert x7777))) + (g7776 + (letrec ((x-cnd7778 (null? l))) + (if x-cnd7778 + "" + (letrec ((x7781 + (letrec ((x7782 + (car l))) + (char->string + x7782))) + (x7779 + (letrec ((x7780 + (cdr l))) + (list->string + x7780)))) + (string-append + x7781 + x7779)))))) + g7776))) + (char<=? + (lambda (c1 c2) + (letrec ((g7783 + (letrec ((x7786 (char? c1))) + (assert x7786))) + (g7784 + (letrec ((x7787 (char? c2))) + (assert x7787))) + (g7785 + (letrec ((val7143 (char=? c x7804)))) + (if x-cnd7803 + (letrec ((x7805 #\z)) + (char-ci<=? c x7805)) + #f)))) + g7802))) + (<= + (lambda (x y) + (letrec ((g7806 + (letrec ((x7808 (number? x))) + (assert x7808))) + (g7807 + (letrec ((val7144 (< x y))) + (letrec ((g7809 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7810 + (if val7145 + val7145 + #f))) + g7810))))) + g7809)))) + g7807))) + (char-whitespace? + (lambda (c) + (letrec ((g7811 + (letrec ((val7146 + (letrec ((x7812 + (char->integer + c))) + (= x7812 9)))) + (letrec ((g7813 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7814 + (char->integer + c))) + (= + x7814 + 10)))) + (letrec ((g7815 + (if val7147 + val7147 + (letrec ((x7816 + (char->integer + c))) + (= + x7816 + 32))))) + g7815))))) + g7813)))) + g7811))) + (cddar + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 + (letrec ((x7819 (car x))) + (cdr x7819)))) + (cdr x7818)))) + g7817))) + (positive? + (lambda (x) + (letrec ((g7820 + (letrec ((x7822 (number? x))) + (assert x7822))) + (g7821 (> x 0))) + g7821))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7823 #f)) g7823))) + (cddr + (lambda (x) + (letrec ((g7824 + (letrec ((x7825 (cdr x))) + (cdr x7825)))) + g7824))) + (truncate + (lambda (x) + (letrec ((g7826 + (letrec ((x7828 (number? x))) + (assert x7828))) + (g7827 + (letrec ((x-cnd7829 (< x 0))) + (if x-cnd7829 + (ceiling x) + (floor x))))) + g7827))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7830 + (letrec ((val7148 (eq? a b))) + (letrec ((g7831 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7833 + (null? + a)) + (x7832 + (null? + b))) + (and x7833 + x7832)))) + (letrec ((g7834 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7837 + (string? + a)) + (x7836 + (string? + b)) + (x7835 + (string=? + a + b))) + (and x7837 + x7836 + x7835)))) + (letrec ((g7838 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7846 + (pair? + a)) + (x7845 + (pair? + b)) + (x7842 + (letrec ((x7844 + (car + a)) + (x7843 + (car + b))) + (equal? + x7844 + x7843))) + (x7839 + (letrec ((x7841 + (cdr + a)) + (x7840 + (cdr + b))) + (equal? + x7841 + x7840)))) + (and x7846 + x7845 + x7842 + x7839)))) + (letrec ((g7847 + (if val7151 + val7151 + (letrec ((x7866 + (vector? + a)) + (x7865 + (vector? + b)) + (x7848 + (letrec ((x7862 + (letrec ((x7863 + (letrec ((x7864 + (vector-length + a))) + (n + x7864)))) + (x7863))) + (x7849 + (letrec ((x7860 + (letrec ((x7861 + (vector-length + b))) + (= + x7861 + n))) + (x7850 + (letrec ((loop + (lambda (i) + (letrec ((g7851 + (letrec ((x7858 + (= + i + n)) + (x7852 + (letrec ((x7855 + (letrec ((x7857 + (vector-ref + a + i)) + (x7856 + (vector-ref + b + i))) + (equal? + x7857 + x7856))) + (x7853 + (letrec ((x7854 + (+ + i + 1))) + (loop + x7854)))) + (and x7855 + x7853)))) + (or x7858 + x7852)))) + g7851)))) + (letrec ((g7859 + (loop + 0))) + g7859)))) + (and x7860 + x7850)))) + (let x7862 x7849)))) + (and x7866 + x7865 + x7848))))) + g7847))))) + g7838))))) + g7834))))) + g7831)))) + g7830))) + (cdaaar + (lambda (x) + (letrec ((g7867 + (letrec ((x7868 + (letrec ((x7869 + (letrec ((x7870 + (car + x))) + (car + x7870)))) + (car x7869)))) + (cdr x7868)))) + g7867))) + (caaddr + (lambda (x) + (letrec ((g7871 + (letrec ((x7872 + (letrec ((x7873 + (letrec ((x7874 + (cdr + x))) + (cdr + x7874)))) + (car x7873)))) + (car x7872)))) + g7871))) + (eqv? + (lambda (x y) + (letrec ((g7875 (eq? x y))) g7875))) + (>= + (lambda (x y) + (letrec ((g7876 + (letrec ((x7878 (number? x))) + (assert x7878))) + (g7877 + (letrec ((val7152 (> x y))) + (letrec ((g7879 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7880 + (if val7153 + val7153 + #f))) + g7880))))) + g7879)))) + g7877))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7881 + (letrec ((x7884 + (string? filename))) + (assert x7884))) + (g7882 + (letrec ((x7885 (procedure? proc))) + (assert x7885))) + (g7883 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7886 + (close-input-port + input-port)) + (g7887 res)) + g7887)))) + g7883))) + (ref + (lambda (x) + (letrec ((g7888 (cons x '()))) g7888))) + (char>=? + (lambda (c1 c2) + (letrec ((g7889 + (letrec ((x7892 (char? c1))) + (assert x7892))) + (g7890 + (letrec ((x7893 (char? c2))) + (assert x7893))) + (g7891 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7894 + (if val7154 + val7154 + (char=? c1 c2)))) + g7894)))) + g7891))) + (cdaar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (car x7897)))) + (cdr x7896)))) + g7895))) + (cdaddr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 + (letrec ((x7901 + (cdr + x))) + (cdr + x7901)))) + (car x7900)))) + (cdr x7899)))) + g7898))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7902 + (letrec ((x7903 + (letrec ((x7904 (car x))) + (cdr x7904)))) + (car x7903)))) + g7902))) + (caadr + (lambda (x) + (letrec ((g7905 + (letrec ((x7906 + (letrec ((x7907 (cdr x))) + (car x7907)))) + (car x7906)))) + g7905))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7908 + (letrec ((x7911 (char? c1))) + (assert x7911))) + (g7909 + (letrec ((x7912 (char? c2))) + (assert x7912))) + (g7910 + (letrec ((x7913 + (char-ci<=? c1 c2))) + (not x7913)))) + g7910))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7914 + (letrec ((x7915 + (letrec ((x7916 + (letrec ((x7917 + (car + x))) + (car + x7917)))) + (car x7916)))) + (car x7915)))) + g7914))) + (negative? + (lambda (x) + (letrec ((g7918 + (letrec ((x7920 (number? x))) + (assert x7920))) + (g7919 (< x 0))) + g7919))) + (memv + (lambda (e l) + (letrec ((g7921 (memq e l))) g7921))) + (caaar + (lambda (x) + (letrec ((g7922 + (letrec ((x7923 + (letrec ((x7924 (car x))) + (car x7924)))) + (car x7923)))) + g7922))) + (debug + (lambda (e) (letrec ((g7925 '())) g7925))) + (reverse + (lambda (l) + (letrec ((g7926 + (letrec ((x7928 (list? l))) + (assert x7928))) + (g7927 + (letrec ((x-cnd7929 (null? l))) + (if x-cnd7929 + '() + (letrec ((x7932 + (letrec ((x7933 + (cdr l))) + (reverse x7933))) + (x7930 + (letrec ((x7931 + (car l))) + (list x7931)))) + (append x7932 x7930)))))) + g7927))) + (caaadr + (lambda (x) + (letrec ((g7934 + (letrec ((x7935 + (letrec ((x7936 + (letrec ((x7937 + (cdr + x))) + (car + x7937)))) + (car x7936)))) + (car x7935)))) + g7934))) + (cddadr + (lambda (x) + (letrec ((g7938 + (letrec ((x7939 + (letrec ((x7940 + (letrec ((x7941 + (cdr + x))) + (car + x7941)))) + (cdr x7940)))) + (cdr x7939)))) + g7938))) + (odd? + (lambda (x) + (letrec ((g7942 + (letrec ((x7944 (number? x))) + (assert x7944))) + (g7943 + (letrec ((x7945 (modulo x 2))) + (= 1 x7945)))) + g7943))) + (caadar + (lambda (x) + (letrec ((g7946 + (letrec ((x7947 + (letrec ((x7948 + (letrec ((x7949 + (car + x))) + (cdr + x7949)))) + (car x7948)))) + (car x7947)))) + g7946))) + (apply + (lambda (proc args) + (letrec ((g7950 + (letrec ((x7953 (procedure? proc))) + (assert x7953))) + (g7951 + (letrec ((x7954 (list? args))) + (assert x7954))) + (g7952 + (if cnd + (letrec ((g7955 (proc))) g7955) + (if cnd + (letrec ((g7956 + (letrec ((x7957 + (car + args))) + (proc x7957)))) + g7956) + (if cnd + (letrec ((g7958 + (letrec ((x7960 + (car + args)) + (x7959 + (cadr + args))) + (proc + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7961 + (letrec ((x7964 + (car + args)) + (x7963 + (cadr + args)) + (x7962 + (caddr + args))) + (proc + x7964 + x7963 + x7962)))) + g7961) + (if cnd + (letrec ((g7965 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args))) + (proc + x7969 + x7968 + x7967 + x7966)))) + g7965) + (if cnd + (letrec ((g7970 + (letrec ((x7976 + (car + args)) + (x7975 + (cadr + args)) + (x7974 + (caddr + args)) + (x7973 + (cadddr + args)) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (car + x7972)))) + (proc + x7976 + x7975 + x7974 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7977 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978)))) + g7977) + (if cnd + (letrec ((g7986 + (letrec ((x7996 + (car + args)) + (x7995 + (cadr + args)) + (x7994 + (caddr + args)) + (x7993 + (cadddr + args)) + (x7991 + (letrec ((x7992 + (cddddr + args))) + (car + x7992))) + (x7989 + (letrec ((x7990 + (cddddr + args))) + (cadr + x7990))) + (x7987 + (letrec ((x7988 + (cddddr + args))) + (caddr + x7988)))) + (proc + x7996 + x7995 + x7994 + x7993 + x7991 + x7989 + x7987)))) + g7986) + (letrec ((g7997 + (error + "Unsupported call."))) + g7997))))))))))) + g7952))) + (member + (lambda (e l) + (letrec ((g7998 + (letrec ((x8000 (list? l))) + (assert x8000))) + (g7999 + (letrec ((x-cnd8001 (null? l))) + (if x-cnd8001 + #f + (letrec ((x-cnd8002 + (letrec ((x8003 + (car l))) + (equal? x8003 e)))) + (if x-cnd8002 + l + (letrec ((x8004 (cdr l))) + (member e x8004)))))))) + g7999))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8005 + (letrec ((x8006 + (letrec ((x8007 + (letrec ((x8008 + (cdr + x))) + (cdr + x8008)))) + (cdr x8007)))) + (cdr x8006)))) + g8005))) + (cadddr + (lambda (x) + (letrec ((g8009 + (letrec ((x8010 + (letrec ((x8011 + (letrec ((x8012 + (cdr + x))) + (cdr + x8012)))) + (cdr x8011)))) + (car x8010)))) + g8009))) + (int-top + (lambda () + (letrec ((g8013 (random 42))) g8013))) + (zero? + (lambda (x) + (letrec ((g8014 + (letrec ((x8016 (number? x))) + (assert x8016))) + (g8015 (= x 0))) + g8015))) + (string>=? + (lambda (s1 s2) + (letrec ((g8017 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8018 + (if val7155 + val7155 + (string=? s1 s2)))) + g8018)))) + g8017))) + (cadr + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 (cdr x))) + (car x8020)))) + g8019))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8021 + (letrec ((val7156 + (letrec ((x8024 + (pair? l)) + (x8022 + (letrec ((x8023 + (cdr + l))) + (list? + x8023)))) + (and x8024 x8022)))) + (letrec ((g8025 + (if val7156 + val7156 + (null? l)))) + g8025)))) + g8021))) + (cddaar + (lambda (x) + (letrec ((g8026 + (letrec ((x8027 + (letrec ((x8028 + (letrec ((x8029 + (car + x))) + (car + x8029)))) + (cdr x8028)))) + (cdr x8027)))) + g8026))) + (char-numeric? + (lambda (c) + (letrec ((g8030 + (letrec ((x-cnd8031 + (letrec ((x8032 #\0)) + (char<=? x8032 c)))) + (if x-cnd8031 + (letrec ((x8033 #\9)) + (char<=? c x8033)) + #f)))) + g8030))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8034 + (letrec ((x8036 (list? l))) + (assert x8036))) + (g8035 + (letrec ((x-cnd8037 (null? l))) + (if x-cnd8037 + #f + (letrec ((x-cnd8038 + (letrec ((x8039 + (caar l))) + (eqv? x8039 k)))) + (if x-cnd8038 + (car l) + (letrec ((x8040 (cdr l))) + (assq k x8040)))))))) + g8035))) + (not + (lambda (x) + (letrec ((g8041 (if x #f #t))) g8041))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8042 (append l1 l2))) g8042))) + (memq + (lambda (e l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((x-cnd8046 (null? l))) + (if x-cnd8046 + #f + (letrec ((x-cnd8047 + (letrec ((x8048 + (car l))) + (eq? x8048 e)))) + (if x-cnd8047 + l + (letrec ((x8049 (cdr l))) + (memq e x8049)))))))) + g8044))) + (cadaar + (lambda (x) + (letrec ((g8050 + (letrec ((x8051 + (letrec ((x8052 + (letrec ((x8053 + (car + x))) + (car + x8053)))) + (cdr x8052)))) + (car x8051)))) + g8050))) + (length + (lambda (l) + (letrec ((g8054 + (letrec ((x8056 (list? l))) + (assert x8056))) + (g8055 + (letrec ((rec + (lambda (l) + (letrec ((g8057 + (letrec ((x-cnd8058 + (null? + l))) + (if x-cnd8058 + 0 + (letrec ((x8059 + (letrec ((x8060 + (cdr + l))) + (rec + x8060)))) + (+ + 1 + x8059)))))) + g8057)))) + (letrec ((g8061 (rec l))) + g8061)))) + g8055))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8062 + (letrec ((x8065 (char? c1))) + (assert x8065))) + (g8063 + (letrec ((x8066 (char? c2))) + (assert x8066))) + (g8064 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8068 + (letrec ((x8069 (string<=? s1 s2))) + (not x8069)))) + g8068))) + (cdadr + (lambda (x) + (letrec ((g8070 + (letrec ((x8071 + (letrec ((x8072 (cdr x))) + (car x8072)))) + (cdr x8071)))) + g8070))) + (assoc + (lambda (k l) + (letrec ((g8073 + (letrec ((x8075 (list? l))) + (assert x8075))) + (g8074 + (letrec ((x-cnd8076 (null? l))) + (if x-cnd8076 + #f + (letrec ((x-cnd8077 + (letrec ((x8078 + (caar l))) + (equal? x8078 k)))) + (if x-cnd8077 + (car l) + (letrec ((x8079 (cdr l))) + (assoc k x8079)))))))) + g8074))) + (caar + (lambda (x) + (letrec ((g8080 + (letrec ((x8081 (car x))) + (car x8081)))) + g8080))) + (char>? + (lambda (c1 c2) + (letrec ((g8082 + (letrec ((x8085 (char? c1))) + (assert x8085))) + (g8083 + (letrec ((x8086 (char? c2))) + (assert x8086))) + (g8084 + (letrec ((x8087 (char<=? c1 c2))) + (not x8087)))) + g8084))) + (string<=? + (lambda (s1 s2) + (letrec ((g8088 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8105 + (letrec ((x8108 (char? c1))) + (assert x8108))) + (g8106 + (letrec ((x8109 (char? c2))) + (assert x8109))) + (g8107 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8110 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8110)))) + g8107))) + (caddar + (lambda (x) + (letrec ((g8111 + (letrec ((x8112 + (letrec ((x8113 + (letrec ((x8114 + (car + x))) + (cdr + x8114)))) + (cdr x8113)))) + (car x8112)))) + g8111))) + (newline + (lambda () (letrec ((g8115 #f)) g8115))) + (lcm + (lambda (m n) + (letrec ((g8116 + (letrec ((x8118 + (letrec ((x8119 (* m n))) + (abs x8119))) + (x8117 (gcd m n))) + (/ x8118 x8117)))) + g8116))) + (deref car) + (> + (lambda (x y) + (letrec ((g8120 + (letrec ((x8122 (number? x))) + (assert x8122))) + (g8121 + (letrec ((x8123 (<= x y))) + (not x8123)))) + g8121))) + (list-ref + (lambda (l index) + (letrec ((g8124 + (letrec ((x8128 (list? l))) + (assert x8128))) + (g8125 + (letrec ((x8129 (number? index))) + (assert x8129))) + (g8126 + (letrec ((x8130 + (letrec ((x8131 + (length l))) + (< index x8131)))) + (assert x8130))) + (g8127 + (letrec ((x-cnd8132 (= index 0))) + (if x-cnd8132 + (car l) + (letrec ((x8134 (cdr l)) + (x8133 (- index 1))) + (list-ref x8134 x8133)))))) + g8127))) + (gcd + (lambda (a b) + (letrec ((g8135 + (letrec ((x-cnd8136 (= b 0))) + (if x-cnd8136 + a + (letrec ((x8137 (modulo a b))) + (gcd b x8137)))))) + g8135)))) + (letrec ((g8138 + (letrec ((g8139 + (letrec ((mult + (lambda (n m) + (letrec ((g8140 + (letrec ((x-cnd8141 + (letrec ((val7160 + (<= + n + 0))) + (letrec ((g8142 + (if val7160 + val7160 + (<= + m + 0)))) + g8142)))) + (if x-cnd8141 + 0 + (letrec ((x8143 + (letrec ((x8144 + (- + m + 1))) + (mult + n + x8144)))) + (+ + n + x8143)))))) + g8140))) + (sqr + (lambda (n) + (letrec ((g8145 + (mult n n))) + g8145)))) + (letrec ((g8146 + (letrec ((g8147 + (letrec ((g8148 + (letrec ((x8152 + ((lambda (j7232 + k7233 + f7234) + (lambda (g7230 + g7231) + ((and/c + integer?/c + (>=/c + 0)) + j7232 + k7233 + (f7234 + (integer?/c + j7232 + k7233 + g7230) + (integer?/c + j7232 + k7233 + g7231))))) + 'module + 'importer + mult)) + (x8151 + (input)) + (x8150 + (input))) + (x8152 + x8151 + x8150))) + (g8149 + ((lambda (j7236 + k7237 + f7238) + (lambda (g7235) + (letrec ((x7239 + (integer?/c + j7236 + k7237 + g7235))) + (((lambda (n) + (and/c + integer?/c + (>=/c + n))) + x7239) + j7236 + k7237 + (f7238 + x7239))))) + 'module + 'importer + sqr))) + g8149))) + g8147))) + g8146)))) + g8139))) + g8138)))) + g7251))) + g7250)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_neg.rkt b/analyses/simpleactor/benchmarks-out/mochi_neg.rkt index 85a1ca61..646a8cda 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_neg.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_neg.rkt @@ -1,27 +1,3107 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (g x) (λ (_) x)) - (define (twice f x y) ((f (f x)) y)) - (define (neg x) (λ (_) (- 0 (x #f)))) - (define (main n) (if (>= n 0) (twice neg (g n) 'unit) 42)) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((and/c integer? (>=/c 0)) - j3984 - k3985 - (f3986 (integer? j3984 k3985 g3983))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((g + (lambda (x) + (letrec ((g8133 + (letrec ((x8134 + (_))) + (λ x8134 + x)))) + g8133))) + (twice + (lambda (f x y) + (letrec ((g8135 + (letrec ((x8136 + (letrec ((x8137 + (f + x))) + (f + x8137)))) + (x8136 + y)))) + g8135))) + (neg + (lambda (x) + (letrec ((g8138 + (letrec ((x8141 + (_)) + (x8139 + (letrec ((x8140 + (x + #f))) + (- + 0 + x8140)))) + (λ x8141 + x8139)))) + g8138))) + (main + (lambda (n) + (letrec ((g8142 + (letrec ((x-cnd8143 + (>= + n + 0))) + (if x-cnd8143 + (letrec ((x8144 + (g + n))) + (twice + neg + x8144 + 'unit)) + 42)))) + g8142)))) + (letrec ((g8145 + (letrec ((g8146 + (letrec ((g8147 + (letrec ((x8149 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + ((and/c + integer?/c + (>=/c + 0)) + j7230 + k7231 + (f7232 + (integer?/c + j7230 + k7231 + g7229))))) + 'module + 'importer + main)) + (x8148 + (input))) + (x8149 + x8148)))) + g8147))) + g8146))) + g8145)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_nth0.rkt b/analyses/simpleactor/benchmarks-out/mochi_nth0.rkt index 2ffe2642..b5890d8f 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_nth0.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_nth0.rkt @@ -1,23 +1,3109 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (nth n xs) (if (= n 0) (car xs) (nth (- n 1) (cdr xs)))) - (define (mk-list n) (if (< n 0) empty (cons n (mk-list (- n 1))))) - (define (main n) (let ((xs (mk-list n))) (if (empty? xs) 0 (nth 0 xs)))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - (integer? j3984 k3985 (f3986 (integer? j3984 k3985 g3983))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((nth + (lambda (n xs) + (letrec ((g8133 + (letrec ((x-cnd8134 + (= + n + 0))) + (if x-cnd8134 + (car xs) + (letrec ((x8136 + (- + n + 1)) + (x8135 + (cdr + xs))) + (nth + x8136 + x8135)))))) + g8133))) + (mk-list + (lambda (n) + (letrec ((g8137 + (letrec ((x-cnd8138 + (< + n + 0))) + (if x-cnd8138 + empty + (letrec ((x8139 + (letrec ((x8140 + (- + n + 1))) + (mk-list + x8140)))) + (cons + n + x8139)))))) + g8137))) + (main + (lambda (n) + (letrec ((g8141 + (letrec ((xs + (mk-list + n))) + (letrec ((g8142 + (letrec ((x-cnd8143 + (empty? + xs))) + (if x-cnd8143 + 0 + (nth + 0 + xs))))) + g8142)))) + g8141)))) + (letrec ((g8144 + (letrec ((g8145 + (letrec ((g8146 + (letrec ((x8148 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + (integer?/c + j7230 + k7231 + (f7232 + (integer?/c + j7230 + k7231 + g7229))))) + 'module + 'importer + main)) + (x8147 + (input))) + (x8148 + x8147)))) + g8146))) + g8145))) + g8144)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_r-file.rkt b/analyses/simpleactor/benchmarks-out/mochi_r-file.rkt index 1abd5874..4ed5eb3d 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_r-file.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_r-file.rkt @@ -1,40 +1,3225 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7240 #t)) g7240))) + (meta (lambda (v) (letrec ((g7241 v)) g7241))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7242 + (letrec ((g7243 + (letrec ((x-e7244 lst)) + (match + x-e7244 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7245 (eq? v v1))) + (if x-cnd7245 #t (member v vs))))))))) + g7243))) + g7242))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define STATE/C (one-of/c 'init 'opened 'closed 'ignore)) - (define (loop) (loop)) - (define (readit st) (if (equal? 'opened st) 'opened 'ignore)) - (define (read_ x st) (if x (readit st) st)) - (define (closeit st) - (cond - ((equal? 'opened st) 'closed) - ((equal? 'ignore st) 'ignore) - (else (loop) 0))) - (define (close_ x st) (if x (closeit st) st)) - (define (f x y st) (close_ y (close_ x st)) (f x y (read_ y (read_ x st)))) - (define (next st) (if (equal? 'init st) 'opened 'ignore)) - (define (g b3 x st) (if (> b3 0) (f x #t (next st)) (f x #f st))) - (define (main b2 b3) (if (> b2 0) (g b3 #t 'opened) (g b3 #f 'init)) 'unit) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - (any/c - j3985 - k3986 - (f3987 - (integer? j3985 k3986 g3983) - (integer? j3985 k3986 g3984))))) - 'module - 'importer - main) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7246 (lambda (v) (letrec ((g7247 v)) g7247)))) g7246))) + (nonzero? + (lambda (v) + (letrec ((g7248 (letrec ((x7249 (= v 0))) (not x7249)))) g7248)))) + (letrec ((g7250 + (letrec ((g7251 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7252 + (letrec ((x-cnd7253 (real? g7162))) + (if x-cnd7253 + g7162 + (blame g7160 'real?))))) + g7252))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7254 + (letrec ((x-cnd7255 + (boolean? g7165))) + (if x-cnd7255 + g7165 + (blame g7163 'boolean?))))) + g7254))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7256 + (letrec ((x-cnd7257 + (number? g7168))) + (if x-cnd7257 + g7168 + (blame g7166 'number?))))) + g7256))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7258 + (letrec ((x-cnd7259 + ((lambda (v) #t) g7171))) + (if x-cnd7259 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7258))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7260 + (letrec ((x-cnd7261 + ((lambda (v) #t) g7174))) + (if x-cnd7261 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7260))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7262 + (letrec ((x-cnd7263 (pair? g7177))) + (if x-cnd7263 + g7177 + (blame g7175 'pair?))))) + g7262))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7264 + (letrec ((x-cnd7265 (pair? g7180))) + (if x-cnd7265 + g7180 + (blame g7178 'pair?))))) + g7264))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7266 + (letrec ((x-cnd7267 + (integer? g7183))) + (if x-cnd7267 + g7183 + (blame g7181 'integer?))))) + g7266))) + (and/c + (lambda (c1 c2) + (letrec ((g7268 + (lambda (k j v) + (letrec ((g7269 + (letrec ((x-cnd7270 + (c1 k j v))) + (if x-cnd7270 + (c2 k j v) + #f)))) + g7269)))) + g7268))) + (list-of + (lambda (contract) + (letrec ((g7271 + (lambda (k j v) + (letrec ((g7272 + (letrec ((x-cnd7273 + (null? v))) + (if x-cnd7273 + '() + (letrec ((x7277 + (letrec ((x7278 + (car + v))) + (contract + k + j + x7278))) + (x7274 + (letrec ((x7276 + (list-of + contract)) + (x7275 + (cdr + v))) + (x7276 + k + j + x7275)))) + (cons + x7277 + x7274)))))) + g7272)))) + g7271))) + (any? (lambda (v) (letrec ((g7279 #t)) g7279))) + (nonzero? + (lambda (v) + (letrec ((g7280 + (letrec ((x7281 (= v 0))) + (not x7281)))) + g7280))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7282 + (letrec ((x-cnd7283 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7283 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7282))) + (meta (lambda (v) (letrec ((g7284 v)) g7284))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7285 #t)) g7285))) + (cdddr + (lambda (x) + (letrec ((g7286 + (letrec ((x7287 + (letrec ((x7288 (cdr x))) + (cdr x7288)))) + (cdr x7287)))) + g7286))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7289 + (letrec ((x7292 (procedure? f))) + (assert x7292))) + (g7290 + (letrec ((x7293 (list? l))) + (assert x7293))) + (g7291 + (letrec ((x-cnd7294 (null? l))) + (if x-cnd7294 + '() + (letrec ((x7297 + (letrec ((x7298 + (car l))) + (f x7298))) + (x7295 + (letrec ((x7296 + (cdr l))) + (map f x7296)))) + (cons x7297 x7295)))))) + g7291))) + (cdar + (lambda (x) + (letrec ((g7299 + (letrec ((x7300 (car x))) + (cdr x7300)))) + g7299))) + (cadadr + (lambda (x) + (letrec ((g7301 + (letrec ((x7302 + (letrec ((x7303 + (letrec ((x7304 + (cdr + x))) + (car + x7304)))) + (cdr x7303)))) + (car x7302)))) + g7301))) + (cdadar + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 + (letrec ((x7308 + (car + x))) + (cdr + x7308)))) + (car x7307)))) + (cdr x7306)))) + g7305))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7309 + (letrec ((x7312 + (string? filename))) + (assert x7312))) + (g7310 + (letrec ((x7313 (procedure? proc))) + (assert x7313))) + (g7311 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7314 + (close-output-port + output-port)) + (g7315 res)) + g7315)))) + g7311))) + (caddr + (lambda (x) + (letrec ((g7316 + (letrec ((x7317 + (letrec ((x7318 (cdr x))) + (cdr x7318)))) + (car x7317)))) + g7316))) + (cdaadr + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 + (letrec ((x7321 + (letrec ((x7322 + (cdr + x))) + (car + x7322)))) + (car x7321)))) + (cdr x7320)))) + g7319))) + (assq + (lambda (k l) + (letrec ((g7323 + (letrec ((x7325 (list? l))) + (assert x7325))) + (g7324 + (letrec ((x-cnd7326 (null? l))) + (if x-cnd7326 + #f + (letrec ((x-cnd7327 + (letrec ((x7328 + (caar l))) + (eq? x7328 k)))) + (if x-cnd7327 + (car l) + (letrec ((x7329 (cdr l))) + (assq k x7329)))))))) + g7324))) + (even? + (lambda (x) + (letrec ((g7330 + (letrec ((x7331 (modulo x 2))) + (= 0 x7331)))) + g7330))) + (list->string + (lambda (l) + (letrec ((g7332 + (letrec ((x7334 (list? l))) + (assert x7334))) + (g7333 + (letrec ((x-cnd7335 (null? l))) + (if x-cnd7335 + "" + (letrec ((x7338 + (letrec ((x7339 + (car l))) + (char->string + x7339))) + (x7336 + (letrec ((x7337 + (cdr l))) + (list->string + x7337)))) + (string-append + x7338 + x7336)))))) + g7333))) + (char<=? + (lambda (c1 c2) + (letrec ((g7340 + (letrec ((x7343 (char? c1))) + (assert x7343))) + (g7341 + (letrec ((x7344 (char? c2))) + (assert x7344))) + (g7342 + (letrec ((val7143 (char=? c x7361)))) + (if x-cnd7360 + (letrec ((x7362 #\z)) + (char-ci<=? c x7362)) + #f)))) + g7359))) + (<= + (lambda (x y) + (letrec ((g7363 + (letrec ((x7365 (number? x))) + (assert x7365))) + (g7364 + (letrec ((val7144 (< x y))) + (letrec ((g7366 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7367 + (if val7145 + val7145 + #f))) + g7367))))) + g7366)))) + g7364))) + (char-whitespace? + (lambda (c) + (letrec ((g7368 + (letrec ((val7146 + (letrec ((x7369 + (char->integer + c))) + (= x7369 9)))) + (letrec ((g7370 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7371 + (char->integer + c))) + (= + x7371 + 10)))) + (letrec ((g7372 + (if val7147 + val7147 + (letrec ((x7373 + (char->integer + c))) + (= + x7373 + 32))))) + g7372))))) + g7370)))) + g7368))) + (cddar + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 + (letrec ((x7376 (car x))) + (cdr x7376)))) + (cdr x7375)))) + g7374))) + (positive? + (lambda (x) + (letrec ((g7377 + (letrec ((x7379 (number? x))) + (assert x7379))) + (g7378 (> x 0))) + g7378))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7380 #f)) g7380))) + (cddr + (lambda (x) + (letrec ((g7381 + (letrec ((x7382 (cdr x))) + (cdr x7382)))) + g7381))) + (truncate + (lambda (x) + (letrec ((g7383 + (letrec ((x7385 (number? x))) + (assert x7385))) + (g7384 + (letrec ((x-cnd7386 (< x 0))) + (if x-cnd7386 + (ceiling x) + (floor x))))) + g7384))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7387 + (letrec ((val7148 (eq? a b))) + (letrec ((g7388 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7390 + (null? + a)) + (x7389 + (null? + b))) + (and x7390 + x7389)))) + (letrec ((g7391 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7394 + (string? + a)) + (x7393 + (string? + b)) + (x7392 + (string=? + a + b))) + (and x7394 + x7393 + x7392)))) + (letrec ((g7395 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7403 + (pair? + a)) + (x7402 + (pair? + b)) + (x7399 + (letrec ((x7401 + (car + a)) + (x7400 + (car + b))) + (equal? + x7401 + x7400))) + (x7396 + (letrec ((x7398 + (cdr + a)) + (x7397 + (cdr + b))) + (equal? + x7398 + x7397)))) + (and x7403 + x7402 + x7399 + x7396)))) + (letrec ((g7404 + (if val7151 + val7151 + (letrec ((x7423 + (vector? + a)) + (x7422 + (vector? + b)) + (x7405 + (letrec ((x7419 + (letrec ((x7420 + (letrec ((x7421 + (vector-length + a))) + (n + x7421)))) + (x7420))) + (x7406 + (letrec ((x7417 + (letrec ((x7418 + (vector-length + b))) + (= + x7418 + n))) + (x7407 + (letrec ((loop + (lambda (i) + (letrec ((g7408 + (letrec ((x7415 + (= + i + n)) + (x7409 + (letrec ((x7412 + (letrec ((x7414 + (vector-ref + a + i)) + (x7413 + (vector-ref + b + i))) + (equal? + x7414 + x7413))) + (x7410 + (letrec ((x7411 + (+ + i + 1))) + (loop + x7411)))) + (and x7412 + x7410)))) + (or x7415 + x7409)))) + g7408)))) + (letrec ((g7416 + (loop + 0))) + g7416)))) + (and x7417 + x7407)))) + (let x7419 x7406)))) + (and x7423 + x7422 + x7405))))) + g7404))))) + g7395))))) + g7391))))) + g7388)))) + g7387))) + (cdaaar + (lambda (x) + (letrec ((g7424 + (letrec ((x7425 + (letrec ((x7426 + (letrec ((x7427 + (car + x))) + (car + x7427)))) + (car x7426)))) + (cdr x7425)))) + g7424))) + (caaddr + (lambda (x) + (letrec ((g7428 + (letrec ((x7429 + (letrec ((x7430 + (letrec ((x7431 + (cdr + x))) + (cdr + x7431)))) + (car x7430)))) + (car x7429)))) + g7428))) + (eqv? + (lambda (x y) + (letrec ((g7432 (eq? x y))) g7432))) + (>= + (lambda (x y) + (letrec ((g7433 + (letrec ((x7435 (number? x))) + (assert x7435))) + (g7434 + (letrec ((val7152 (> x y))) + (letrec ((g7436 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7437 + (if val7153 + val7153 + #f))) + g7437))))) + g7436)))) + g7434))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7438 + (letrec ((x7441 + (string? filename))) + (assert x7441))) + (g7439 + (letrec ((x7442 (procedure? proc))) + (assert x7442))) + (g7440 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7443 + (close-input-port + input-port)) + (g7444 res)) + g7444)))) + g7440))) + (ref + (lambda (x) + (letrec ((g7445 (cons x '()))) g7445))) + (char>=? + (lambda (c1 c2) + (letrec ((g7446 + (letrec ((x7449 (char? c1))) + (assert x7449))) + (g7447 + (letrec ((x7450 (char? c2))) + (assert x7450))) + (g7448 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7451 + (if val7154 + val7154 + (char=? c1 c2)))) + g7451)))) + g7448))) + (cdaar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (car x7454)))) + (cdr x7453)))) + g7452))) + (cdaddr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 + (letrec ((x7458 + (cdr + x))) + (cdr + x7458)))) + (car x7457)))) + (cdr x7456)))) + g7455))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7459 + (letrec ((x7460 + (letrec ((x7461 (car x))) + (cdr x7461)))) + (car x7460)))) + g7459))) + (caadr + (lambda (x) + (letrec ((g7462 + (letrec ((x7463 + (letrec ((x7464 (cdr x))) + (car x7464)))) + (car x7463)))) + g7462))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7465 + (letrec ((x7468 (char? c1))) + (assert x7468))) + (g7466 + (letrec ((x7469 (char? c2))) + (assert x7469))) + (g7467 + (letrec ((x7470 + (char-ci<=? c1 c2))) + (not x7470)))) + g7467))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7471 + (letrec ((x7472 + (letrec ((x7473 + (letrec ((x7474 + (car + x))) + (car + x7474)))) + (car x7473)))) + (car x7472)))) + g7471))) + (negative? + (lambda (x) + (letrec ((g7475 + (letrec ((x7477 (number? x))) + (assert x7477))) + (g7476 (< x 0))) + g7476))) + (memv + (lambda (e l) + (letrec ((g7478 (memq e l))) g7478))) + (caaar + (lambda (x) + (letrec ((g7479 + (letrec ((x7480 + (letrec ((x7481 (car x))) + (car x7481)))) + (car x7480)))) + g7479))) + (debug + (lambda (e) (letrec ((g7482 '())) g7482))) + (reverse + (lambda (l) + (letrec ((g7483 + (letrec ((x7485 (list? l))) + (assert x7485))) + (g7484 + (letrec ((x-cnd7486 (null? l))) + (if x-cnd7486 + '() + (letrec ((x7489 + (letrec ((x7490 + (cdr l))) + (reverse x7490))) + (x7487 + (letrec ((x7488 + (car l))) + (list x7488)))) + (append x7489 x7487)))))) + g7484))) + (caaadr + (lambda (x) + (letrec ((g7491 + (letrec ((x7492 + (letrec ((x7493 + (letrec ((x7494 + (cdr + x))) + (car + x7494)))) + (car x7493)))) + (car x7492)))) + g7491))) + (cddadr + (lambda (x) + (letrec ((g7495 + (letrec ((x7496 + (letrec ((x7497 + (letrec ((x7498 + (cdr + x))) + (car + x7498)))) + (cdr x7497)))) + (cdr x7496)))) + g7495))) + (odd? + (lambda (x) + (letrec ((g7499 + (letrec ((x7501 (number? x))) + (assert x7501))) + (g7500 + (letrec ((x7502 (modulo x 2))) + (= 1 x7502)))) + g7500))) + (caadar + (lambda (x) + (letrec ((g7503 + (letrec ((x7504 + (letrec ((x7505 + (letrec ((x7506 + (car + x))) + (cdr + x7506)))) + (car x7505)))) + (car x7504)))) + g7503))) + (apply + (lambda (proc args) + (letrec ((g7507 + (letrec ((x7510 (procedure? proc))) + (assert x7510))) + (g7508 + (letrec ((x7511 (list? args))) + (assert x7511))) + (g7509 + (if cnd + (letrec ((g7512 (proc))) g7512) + (if cnd + (letrec ((g7513 + (letrec ((x7514 + (car + args))) + (proc x7514)))) + g7513) + (if cnd + (letrec ((g7515 + (letrec ((x7517 + (car + args)) + (x7516 + (cadr + args))) + (proc + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7518 + (letrec ((x7521 + (car + args)) + (x7520 + (cadr + args)) + (x7519 + (caddr + args))) + (proc + x7521 + x7520 + x7519)))) + g7518) + (if cnd + (letrec ((g7522 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args))) + (proc + x7526 + x7525 + x7524 + x7523)))) + g7522) + (if cnd + (letrec ((g7527 + (letrec ((x7533 + (car + args)) + (x7532 + (cadr + args)) + (x7531 + (caddr + args)) + (x7530 + (cadddr + args)) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (car + x7529)))) + (proc + x7533 + x7532 + x7531 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7534 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535)))) + g7534) + (if cnd + (letrec ((g7543 + (letrec ((x7553 + (car + args)) + (x7552 + (cadr + args)) + (x7551 + (caddr + args)) + (x7550 + (cadddr + args)) + (x7548 + (letrec ((x7549 + (cddddr + args))) + (car + x7549))) + (x7546 + (letrec ((x7547 + (cddddr + args))) + (cadr + x7547))) + (x7544 + (letrec ((x7545 + (cddddr + args))) + (caddr + x7545)))) + (proc + x7553 + x7552 + x7551 + x7550 + x7548 + x7546 + x7544)))) + g7543) + (letrec ((g7554 + (error + "Unsupported call."))) + g7554))))))))))) + g7509))) + (member + (lambda (e l) + (letrec ((g7555 + (letrec ((x7557 (list? l))) + (assert x7557))) + (g7556 + (letrec ((x-cnd7558 (null? l))) + (if x-cnd7558 + #f + (letrec ((x-cnd7559 + (letrec ((x7560 + (car l))) + (equal? x7560 e)))) + (if x-cnd7559 + l + (letrec ((x7561 (cdr l))) + (member e x7561)))))))) + g7556))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7562 + (letrec ((x7563 + (letrec ((x7564 + (letrec ((x7565 + (cdr + x))) + (cdr + x7565)))) + (cdr x7564)))) + (cdr x7563)))) + g7562))) + (cadddr + (lambda (x) + (letrec ((g7566 + (letrec ((x7567 + (letrec ((x7568 + (letrec ((x7569 + (cdr + x))) + (cdr + x7569)))) + (cdr x7568)))) + (car x7567)))) + g7566))) + (int-top + (lambda () + (letrec ((g7570 (random 42))) g7570))) + (zero? + (lambda (x) + (letrec ((g7571 + (letrec ((x7573 (number? x))) + (assert x7573))) + (g7572 (= x 0))) + g7572))) + (string>=? + (lambda (s1 s2) + (letrec ((g7574 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7575 + (if val7155 + val7155 + (string=? s1 s2)))) + g7575)))) + g7574))) + (cadr + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 (cdr x))) + (car x7577)))) + g7576))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7578 + (letrec ((val7156 + (letrec ((x7581 + (pair? l)) + (x7579 + (letrec ((x7580 + (cdr + l))) + (list? + x7580)))) + (and x7581 x7579)))) + (letrec ((g7582 + (if val7156 + val7156 + (null? l)))) + g7582)))) + g7578))) + (cddaar + (lambda (x) + (letrec ((g7583 + (letrec ((x7584 + (letrec ((x7585 + (letrec ((x7586 + (car + x))) + (car + x7586)))) + (cdr x7585)))) + (cdr x7584)))) + g7583))) + (char-numeric? + (lambda (c) + (letrec ((g7587 + (letrec ((x-cnd7588 + (letrec ((x7589 #\0)) + (char<=? x7589 c)))) + (if x-cnd7588 + (letrec ((x7590 #\9)) + (char<=? c x7590)) + #f)))) + g7587))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7591 + (letrec ((x7593 (list? l))) + (assert x7593))) + (g7592 + (letrec ((x-cnd7594 (null? l))) + (if x-cnd7594 + #f + (letrec ((x-cnd7595 + (letrec ((x7596 + (caar l))) + (eqv? x7596 k)))) + (if x-cnd7595 + (car l) + (letrec ((x7597 (cdr l))) + (assq k x7597)))))))) + g7592))) + (not + (lambda (x) + (letrec ((g7598 (if x #f #t))) g7598))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7599 (append l1 l2))) g7599))) + (memq + (lambda (e l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((x-cnd7603 (null? l))) + (if x-cnd7603 + #f + (letrec ((x-cnd7604 + (letrec ((x7605 + (car l))) + (eq? x7605 e)))) + (if x-cnd7604 + l + (letrec ((x7606 (cdr l))) + (memq e x7606)))))))) + g7601))) + (cadaar + (lambda (x) + (letrec ((g7607 + (letrec ((x7608 + (letrec ((x7609 + (letrec ((x7610 + (car + x))) + (car + x7610)))) + (cdr x7609)))) + (car x7608)))) + g7607))) + (length + (lambda (l) + (letrec ((g7611 + (letrec ((x7613 (list? l))) + (assert x7613))) + (g7612 + (letrec ((rec + (lambda (l) + (letrec ((g7614 + (letrec ((x-cnd7615 + (null? + l))) + (if x-cnd7615 + 0 + (letrec ((x7616 + (letrec ((x7617 + (cdr + l))) + (rec + x7617)))) + (+ + 1 + x7616)))))) + g7614)))) + (letrec ((g7618 (rec l))) + g7618)))) + g7612))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7619 + (letrec ((x7622 (char? c1))) + (assert x7622))) + (g7620 + (letrec ((x7623 (char? c2))) + (assert x7623))) + (g7621 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7625 + (letrec ((x7626 (string<=? s1 s2))) + (not x7626)))) + g7625))) + (cdadr + (lambda (x) + (letrec ((g7627 + (letrec ((x7628 + (letrec ((x7629 (cdr x))) + (car x7629)))) + (cdr x7628)))) + g7627))) + (assoc + (lambda (k l) + (letrec ((g7630 + (letrec ((x7632 (list? l))) + (assert x7632))) + (g7631 + (letrec ((x-cnd7633 (null? l))) + (if x-cnd7633 + #f + (letrec ((x-cnd7634 + (letrec ((x7635 + (caar l))) + (equal? x7635 k)))) + (if x-cnd7634 + (car l) + (letrec ((x7636 (cdr l))) + (assoc k x7636)))))))) + g7631))) + (caar + (lambda (x) + (letrec ((g7637 + (letrec ((x7638 (car x))) + (car x7638)))) + g7637))) + (char>? + (lambda (c1 c2) + (letrec ((g7639 + (letrec ((x7642 (char? c1))) + (assert x7642))) + (g7640 + (letrec ((x7643 (char? c2))) + (assert x7643))) + (g7641 + (letrec ((x7644 (char<=? c1 c2))) + (not x7644)))) + g7641))) + (string<=? + (lambda (s1 s2) + (letrec ((g7645 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7662 + (letrec ((x7665 (char? c1))) + (assert x7665))) + (g7663 + (letrec ((x7666 (char? c2))) + (assert x7666))) + (g7664 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7667 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7667)))) + g7664))) + (caddar + (lambda (x) + (letrec ((g7668 + (letrec ((x7669 + (letrec ((x7670 + (letrec ((x7671 + (car + x))) + (cdr + x7671)))) + (cdr x7670)))) + (car x7669)))) + g7668))) + (newline + (lambda () (letrec ((g7672 #f)) g7672))) + (lcm + (lambda (m n) + (letrec ((g7673 + (letrec ((x7675 + (letrec ((x7676 (* m n))) + (abs x7676))) + (x7674 (gcd m n))) + (/ x7675 x7674)))) + g7673))) + (deref car) + (> + (lambda (x y) + (letrec ((g7677 + (letrec ((x7679 (number? x))) + (assert x7679))) + (g7678 + (letrec ((x7680 (<= x y))) + (not x7680)))) + g7678))) + (list-ref + (lambda (l index) + (letrec ((g7681 + (letrec ((x7685 (list? l))) + (assert x7685))) + (g7682 + (letrec ((x7686 (number? index))) + (assert x7686))) + (g7683 + (letrec ((x7687 + (letrec ((x7688 + (length l))) + (< index x7688)))) + (assert x7687))) + (g7684 + (letrec ((x-cnd7689 (= index 0))) + (if x-cnd7689 + (car l) + (letrec ((x7691 (cdr l)) + (x7690 (- index 1))) + (list-ref x7691 x7690)))))) + g7684))) + (gcd + (lambda (a b) + (letrec ((g7692 + (letrec ((x-cnd7693 (= b 0))) + (if x-cnd7693 + a + (letrec ((x7694 (modulo a b))) + (gcd b x7694)))))) + g7692))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7695 + (letrec ((x-cnd7696 (real? g7162))) + (if x-cnd7696 + g7162 + (blame g7160 'real?))))) + g7695))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7697 + (letrec ((x-cnd7698 + (boolean? g7165))) + (if x-cnd7698 + g7165 + (blame g7163 'boolean?))))) + g7697))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7699 + (letrec ((x-cnd7700 + (number? g7168))) + (if x-cnd7700 + g7168 + (blame g7166 'number?))))) + g7699))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7701 + (letrec ((x-cnd7702 + ((lambda (v) #t) g7171))) + (if x-cnd7702 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7701))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7703 + (letrec ((x-cnd7704 + ((lambda (v) #t) g7174))) + (if x-cnd7704 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7703))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7705 + (letrec ((x-cnd7706 (pair? g7177))) + (if x-cnd7706 + g7177 + (blame g7175 'pair?))))) + g7705))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7707 + (letrec ((x-cnd7708 (pair? g7180))) + (if x-cnd7708 + g7180 + (blame g7178 'pair?))))) + g7707))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7709 + (letrec ((x-cnd7710 + (integer? g7183))) + (if x-cnd7710 + g7183 + (blame g7181 'integer?))))) + g7709))) + (and/c + (lambda (c1 c2) + (letrec ((g7711 + (lambda (k j v) + (letrec ((g7712 + (letrec ((x-cnd7713 + (c1 k j v))) + (if x-cnd7713 + (c2 k j v) + #f)))) + g7712)))) + g7711))) + (list-of + (lambda (contract) + (letrec ((g7714 + (lambda (k j v) + (letrec ((g7715 + (letrec ((x-cnd7716 + (null? v))) + (if x-cnd7716 + '() + (letrec ((x7720 + (letrec ((x7721 + (car + v))) + (contract + k + j + x7721))) + (x7717 + (letrec ((x7719 + (list-of + contract)) + (x7718 + (cdr + v))) + (x7719 + k + j + x7718)))) + (cons + x7720 + x7717)))))) + g7715)))) + g7714))) + (any? (lambda (v) (letrec ((g7722 #t)) g7722))) + (nonzero? + (lambda (v) + (letrec ((g7723 + (letrec ((x7724 (= v 0))) + (not x7724)))) + g7723))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7725 + (letrec ((x-cnd7726 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7726 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7725))) + (meta (lambda (v) (letrec ((g7727 v)) g7727))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7728 #t)) g7728))) + (cdddr + (lambda (x) + (letrec ((g7729 + (letrec ((x7730 + (letrec ((x7731 (cdr x))) + (cdr x7731)))) + (cdr x7730)))) + g7729))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7732 + (letrec ((x7735 (procedure? f))) + (assert x7735))) + (g7733 + (letrec ((x7736 (list? l))) + (assert x7736))) + (g7734 + (letrec ((x-cnd7737 (null? l))) + (if x-cnd7737 + '() + (letrec ((x7740 + (letrec ((x7741 + (car l))) + (f x7741))) + (x7738 + (letrec ((x7739 + (cdr l))) + (map f x7739)))) + (cons x7740 x7738)))))) + g7734))) + (cdar + (lambda (x) + (letrec ((g7742 + (letrec ((x7743 (car x))) + (cdr x7743)))) + g7742))) + (cadadr + (lambda (x) + (letrec ((g7744 + (letrec ((x7745 + (letrec ((x7746 + (letrec ((x7747 + (cdr + x))) + (car + x7747)))) + (cdr x7746)))) + (car x7745)))) + g7744))) + (cdadar + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 + (letrec ((x7751 + (car + x))) + (cdr + x7751)))) + (car x7750)))) + (cdr x7749)))) + g7748))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7752 + (letrec ((x7755 + (string? filename))) + (assert x7755))) + (g7753 + (letrec ((x7756 (procedure? proc))) + (assert x7756))) + (g7754 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7757 + (close-output-port + output-port)) + (g7758 res)) + g7758)))) + g7754))) + (caddr + (lambda (x) + (letrec ((g7759 + (letrec ((x7760 + (letrec ((x7761 (cdr x))) + (cdr x7761)))) + (car x7760)))) + g7759))) + (cdaadr + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 + (letrec ((x7764 + (letrec ((x7765 + (cdr + x))) + (car + x7765)))) + (car x7764)))) + (cdr x7763)))) + g7762))) + (assq + (lambda (k l) + (letrec ((g7766 + (letrec ((x7768 (list? l))) + (assert x7768))) + (g7767 + (letrec ((x-cnd7769 (null? l))) + (if x-cnd7769 + #f + (letrec ((x-cnd7770 + (letrec ((x7771 + (caar l))) + (eq? x7771 k)))) + (if x-cnd7770 + (car l) + (letrec ((x7772 (cdr l))) + (assq k x7772)))))))) + g7767))) + (even? + (lambda (x) + (letrec ((g7773 + (letrec ((x7774 (modulo x 2))) + (= 0 x7774)))) + g7773))) + (list->string + (lambda (l) + (letrec ((g7775 + (letrec ((x7777 (list? l))) + (assert x7777))) + (g7776 + (letrec ((x-cnd7778 (null? l))) + (if x-cnd7778 + "" + (letrec ((x7781 + (letrec ((x7782 + (car l))) + (char->string + x7782))) + (x7779 + (letrec ((x7780 + (cdr l))) + (list->string + x7780)))) + (string-append + x7781 + x7779)))))) + g7776))) + (char<=? + (lambda (c1 c2) + (letrec ((g7783 + (letrec ((x7786 (char? c1))) + (assert x7786))) + (g7784 + (letrec ((x7787 (char? c2))) + (assert x7787))) + (g7785 + (letrec ((val7143 (char=? c x7804)))) + (if x-cnd7803 + (letrec ((x7805 #\z)) + (char-ci<=? c x7805)) + #f)))) + g7802))) + (<= + (lambda (x y) + (letrec ((g7806 + (letrec ((x7808 (number? x))) + (assert x7808))) + (g7807 + (letrec ((val7144 (< x y))) + (letrec ((g7809 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7810 + (if val7145 + val7145 + #f))) + g7810))))) + g7809)))) + g7807))) + (char-whitespace? + (lambda (c) + (letrec ((g7811 + (letrec ((val7146 + (letrec ((x7812 + (char->integer + c))) + (= x7812 9)))) + (letrec ((g7813 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7814 + (char->integer + c))) + (= + x7814 + 10)))) + (letrec ((g7815 + (if val7147 + val7147 + (letrec ((x7816 + (char->integer + c))) + (= + x7816 + 32))))) + g7815))))) + g7813)))) + g7811))) + (cddar + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 + (letrec ((x7819 (car x))) + (cdr x7819)))) + (cdr x7818)))) + g7817))) + (positive? + (lambda (x) + (letrec ((g7820 + (letrec ((x7822 (number? x))) + (assert x7822))) + (g7821 (> x 0))) + g7821))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7823 #f)) g7823))) + (cddr + (lambda (x) + (letrec ((g7824 + (letrec ((x7825 (cdr x))) + (cdr x7825)))) + g7824))) + (truncate + (lambda (x) + (letrec ((g7826 + (letrec ((x7828 (number? x))) + (assert x7828))) + (g7827 + (letrec ((x-cnd7829 (< x 0))) + (if x-cnd7829 + (ceiling x) + (floor x))))) + g7827))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7830 + (letrec ((val7148 (eq? a b))) + (letrec ((g7831 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7833 + (null? + a)) + (x7832 + (null? + b))) + (and x7833 + x7832)))) + (letrec ((g7834 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7837 + (string? + a)) + (x7836 + (string? + b)) + (x7835 + (string=? + a + b))) + (and x7837 + x7836 + x7835)))) + (letrec ((g7838 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7846 + (pair? + a)) + (x7845 + (pair? + b)) + (x7842 + (letrec ((x7844 + (car + a)) + (x7843 + (car + b))) + (equal? + x7844 + x7843))) + (x7839 + (letrec ((x7841 + (cdr + a)) + (x7840 + (cdr + b))) + (equal? + x7841 + x7840)))) + (and x7846 + x7845 + x7842 + x7839)))) + (letrec ((g7847 + (if val7151 + val7151 + (letrec ((x7866 + (vector? + a)) + (x7865 + (vector? + b)) + (x7848 + (letrec ((x7862 + (letrec ((x7863 + (letrec ((x7864 + (vector-length + a))) + (n + x7864)))) + (x7863))) + (x7849 + (letrec ((x7860 + (letrec ((x7861 + (vector-length + b))) + (= + x7861 + n))) + (x7850 + (letrec ((loop + (lambda (i) + (letrec ((g7851 + (letrec ((x7858 + (= + i + n)) + (x7852 + (letrec ((x7855 + (letrec ((x7857 + (vector-ref + a + i)) + (x7856 + (vector-ref + b + i))) + (equal? + x7857 + x7856))) + (x7853 + (letrec ((x7854 + (+ + i + 1))) + (loop + x7854)))) + (and x7855 + x7853)))) + (or x7858 + x7852)))) + g7851)))) + (letrec ((g7859 + (loop + 0))) + g7859)))) + (and x7860 + x7850)))) + (let x7862 x7849)))) + (and x7866 + x7865 + x7848))))) + g7847))))) + g7838))))) + g7834))))) + g7831)))) + g7830))) + (cdaaar + (lambda (x) + (letrec ((g7867 + (letrec ((x7868 + (letrec ((x7869 + (letrec ((x7870 + (car + x))) + (car + x7870)))) + (car x7869)))) + (cdr x7868)))) + g7867))) + (caaddr + (lambda (x) + (letrec ((g7871 + (letrec ((x7872 + (letrec ((x7873 + (letrec ((x7874 + (cdr + x))) + (cdr + x7874)))) + (car x7873)))) + (car x7872)))) + g7871))) + (eqv? + (lambda (x y) + (letrec ((g7875 (eq? x y))) g7875))) + (>= + (lambda (x y) + (letrec ((g7876 + (letrec ((x7878 (number? x))) + (assert x7878))) + (g7877 + (letrec ((val7152 (> x y))) + (letrec ((g7879 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7880 + (if val7153 + val7153 + #f))) + g7880))))) + g7879)))) + g7877))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7881 + (letrec ((x7884 + (string? filename))) + (assert x7884))) + (g7882 + (letrec ((x7885 (procedure? proc))) + (assert x7885))) + (g7883 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7886 + (close-input-port + input-port)) + (g7887 res)) + g7887)))) + g7883))) + (ref + (lambda (x) + (letrec ((g7888 (cons x '()))) g7888))) + (char>=? + (lambda (c1 c2) + (letrec ((g7889 + (letrec ((x7892 (char? c1))) + (assert x7892))) + (g7890 + (letrec ((x7893 (char? c2))) + (assert x7893))) + (g7891 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7894 + (if val7154 + val7154 + (char=? c1 c2)))) + g7894)))) + g7891))) + (cdaar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (car x7897)))) + (cdr x7896)))) + g7895))) + (cdaddr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 + (letrec ((x7901 + (cdr + x))) + (cdr + x7901)))) + (car x7900)))) + (cdr x7899)))) + g7898))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7902 + (letrec ((x7903 + (letrec ((x7904 (car x))) + (cdr x7904)))) + (car x7903)))) + g7902))) + (caadr + (lambda (x) + (letrec ((g7905 + (letrec ((x7906 + (letrec ((x7907 (cdr x))) + (car x7907)))) + (car x7906)))) + g7905))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7908 + (letrec ((x7911 (char? c1))) + (assert x7911))) + (g7909 + (letrec ((x7912 (char? c2))) + (assert x7912))) + (g7910 + (letrec ((x7913 + (char-ci<=? c1 c2))) + (not x7913)))) + g7910))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7914 + (letrec ((x7915 + (letrec ((x7916 + (letrec ((x7917 + (car + x))) + (car + x7917)))) + (car x7916)))) + (car x7915)))) + g7914))) + (negative? + (lambda (x) + (letrec ((g7918 + (letrec ((x7920 (number? x))) + (assert x7920))) + (g7919 (< x 0))) + g7919))) + (memv + (lambda (e l) + (letrec ((g7921 (memq e l))) g7921))) + (caaar + (lambda (x) + (letrec ((g7922 + (letrec ((x7923 + (letrec ((x7924 (car x))) + (car x7924)))) + (car x7923)))) + g7922))) + (debug + (lambda (e) (letrec ((g7925 '())) g7925))) + (reverse + (lambda (l) + (letrec ((g7926 + (letrec ((x7928 (list? l))) + (assert x7928))) + (g7927 + (letrec ((x-cnd7929 (null? l))) + (if x-cnd7929 + '() + (letrec ((x7932 + (letrec ((x7933 + (cdr l))) + (reverse x7933))) + (x7930 + (letrec ((x7931 + (car l))) + (list x7931)))) + (append x7932 x7930)))))) + g7927))) + (caaadr + (lambda (x) + (letrec ((g7934 + (letrec ((x7935 + (letrec ((x7936 + (letrec ((x7937 + (cdr + x))) + (car + x7937)))) + (car x7936)))) + (car x7935)))) + g7934))) + (cddadr + (lambda (x) + (letrec ((g7938 + (letrec ((x7939 + (letrec ((x7940 + (letrec ((x7941 + (cdr + x))) + (car + x7941)))) + (cdr x7940)))) + (cdr x7939)))) + g7938))) + (odd? + (lambda (x) + (letrec ((g7942 + (letrec ((x7944 (number? x))) + (assert x7944))) + (g7943 + (letrec ((x7945 (modulo x 2))) + (= 1 x7945)))) + g7943))) + (caadar + (lambda (x) + (letrec ((g7946 + (letrec ((x7947 + (letrec ((x7948 + (letrec ((x7949 + (car + x))) + (cdr + x7949)))) + (car x7948)))) + (car x7947)))) + g7946))) + (apply + (lambda (proc args) + (letrec ((g7950 + (letrec ((x7953 (procedure? proc))) + (assert x7953))) + (g7951 + (letrec ((x7954 (list? args))) + (assert x7954))) + (g7952 + (if cnd + (letrec ((g7955 (proc))) g7955) + (if cnd + (letrec ((g7956 + (letrec ((x7957 + (car + args))) + (proc x7957)))) + g7956) + (if cnd + (letrec ((g7958 + (letrec ((x7960 + (car + args)) + (x7959 + (cadr + args))) + (proc + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7961 + (letrec ((x7964 + (car + args)) + (x7963 + (cadr + args)) + (x7962 + (caddr + args))) + (proc + x7964 + x7963 + x7962)))) + g7961) + (if cnd + (letrec ((g7965 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args))) + (proc + x7969 + x7968 + x7967 + x7966)))) + g7965) + (if cnd + (letrec ((g7970 + (letrec ((x7976 + (car + args)) + (x7975 + (cadr + args)) + (x7974 + (caddr + args)) + (x7973 + (cadddr + args)) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (car + x7972)))) + (proc + x7976 + x7975 + x7974 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7977 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978)))) + g7977) + (if cnd + (letrec ((g7986 + (letrec ((x7996 + (car + args)) + (x7995 + (cadr + args)) + (x7994 + (caddr + args)) + (x7993 + (cadddr + args)) + (x7991 + (letrec ((x7992 + (cddddr + args))) + (car + x7992))) + (x7989 + (letrec ((x7990 + (cddddr + args))) + (cadr + x7990))) + (x7987 + (letrec ((x7988 + (cddddr + args))) + (caddr + x7988)))) + (proc + x7996 + x7995 + x7994 + x7993 + x7991 + x7989 + x7987)))) + g7986) + (letrec ((g7997 + (error + "Unsupported call."))) + g7997))))))))))) + g7952))) + (member + (lambda (e l) + (letrec ((g7998 + (letrec ((x8000 (list? l))) + (assert x8000))) + (g7999 + (letrec ((x-cnd8001 (null? l))) + (if x-cnd8001 + #f + (letrec ((x-cnd8002 + (letrec ((x8003 + (car l))) + (equal? x8003 e)))) + (if x-cnd8002 + l + (letrec ((x8004 (cdr l))) + (member e x8004)))))))) + g7999))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8005 + (letrec ((x8006 + (letrec ((x8007 + (letrec ((x8008 + (cdr + x))) + (cdr + x8008)))) + (cdr x8007)))) + (cdr x8006)))) + g8005))) + (cadddr + (lambda (x) + (letrec ((g8009 + (letrec ((x8010 + (letrec ((x8011 + (letrec ((x8012 + (cdr + x))) + (cdr + x8012)))) + (cdr x8011)))) + (car x8010)))) + g8009))) + (int-top + (lambda () + (letrec ((g8013 (random 42))) g8013))) + (zero? + (lambda (x) + (letrec ((g8014 + (letrec ((x8016 (number? x))) + (assert x8016))) + (g8015 (= x 0))) + g8015))) + (string>=? + (lambda (s1 s2) + (letrec ((g8017 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8018 + (if val7155 + val7155 + (string=? s1 s2)))) + g8018)))) + g8017))) + (cadr + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 (cdr x))) + (car x8020)))) + g8019))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8021 + (letrec ((val7156 + (letrec ((x8024 + (pair? l)) + (x8022 + (letrec ((x8023 + (cdr + l))) + (list? + x8023)))) + (and x8024 x8022)))) + (letrec ((g8025 + (if val7156 + val7156 + (null? l)))) + g8025)))) + g8021))) + (cddaar + (lambda (x) + (letrec ((g8026 + (letrec ((x8027 + (letrec ((x8028 + (letrec ((x8029 + (car + x))) + (car + x8029)))) + (cdr x8028)))) + (cdr x8027)))) + g8026))) + (char-numeric? + (lambda (c) + (letrec ((g8030 + (letrec ((x-cnd8031 + (letrec ((x8032 #\0)) + (char<=? x8032 c)))) + (if x-cnd8031 + (letrec ((x8033 #\9)) + (char<=? c x8033)) + #f)))) + g8030))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8034 + (letrec ((x8036 (list? l))) + (assert x8036))) + (g8035 + (letrec ((x-cnd8037 (null? l))) + (if x-cnd8037 + #f + (letrec ((x-cnd8038 + (letrec ((x8039 + (caar l))) + (eqv? x8039 k)))) + (if x-cnd8038 + (car l) + (letrec ((x8040 (cdr l))) + (assq k x8040)))))))) + g8035))) + (not + (lambda (x) + (letrec ((g8041 (if x #f #t))) g8041))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8042 (append l1 l2))) g8042))) + (memq + (lambda (e l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((x-cnd8046 (null? l))) + (if x-cnd8046 + #f + (letrec ((x-cnd8047 + (letrec ((x8048 + (car l))) + (eq? x8048 e)))) + (if x-cnd8047 + l + (letrec ((x8049 (cdr l))) + (memq e x8049)))))))) + g8044))) + (cadaar + (lambda (x) + (letrec ((g8050 + (letrec ((x8051 + (letrec ((x8052 + (letrec ((x8053 + (car + x))) + (car + x8053)))) + (cdr x8052)))) + (car x8051)))) + g8050))) + (length + (lambda (l) + (letrec ((g8054 + (letrec ((x8056 (list? l))) + (assert x8056))) + (g8055 + (letrec ((rec + (lambda (l) + (letrec ((g8057 + (letrec ((x-cnd8058 + (null? + l))) + (if x-cnd8058 + 0 + (letrec ((x8059 + (letrec ((x8060 + (cdr + l))) + (rec + x8060)))) + (+ + 1 + x8059)))))) + g8057)))) + (letrec ((g8061 (rec l))) + g8061)))) + g8055))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8062 + (letrec ((x8065 (char? c1))) + (assert x8065))) + (g8063 + (letrec ((x8066 (char? c2))) + (assert x8066))) + (g8064 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8068 + (letrec ((x8069 (string<=? s1 s2))) + (not x8069)))) + g8068))) + (cdadr + (lambda (x) + (letrec ((g8070 + (letrec ((x8071 + (letrec ((x8072 (cdr x))) + (car x8072)))) + (cdr x8071)))) + g8070))) + (assoc + (lambda (k l) + (letrec ((g8073 + (letrec ((x8075 (list? l))) + (assert x8075))) + (g8074 + (letrec ((x-cnd8076 (null? l))) + (if x-cnd8076 + #f + (letrec ((x-cnd8077 + (letrec ((x8078 + (caar l))) + (equal? x8078 k)))) + (if x-cnd8077 + (car l) + (letrec ((x8079 (cdr l))) + (assoc k x8079)))))))) + g8074))) + (caar + (lambda (x) + (letrec ((g8080 + (letrec ((x8081 (car x))) + (car x8081)))) + g8080))) + (char>? + (lambda (c1 c2) + (letrec ((g8082 + (letrec ((x8085 (char? c1))) + (assert x8085))) + (g8083 + (letrec ((x8086 (char? c2))) + (assert x8086))) + (g8084 + (letrec ((x8087 (char<=? c1 c2))) + (not x8087)))) + g8084))) + (string<=? + (lambda (s1 s2) + (letrec ((g8088 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8105 + (letrec ((x8108 (char? c1))) + (assert x8108))) + (g8106 + (letrec ((x8109 (char? c2))) + (assert x8109))) + (g8107 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8110 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8110)))) + g8107))) + (caddar + (lambda (x) + (letrec ((g8111 + (letrec ((x8112 + (letrec ((x8113 + (letrec ((x8114 + (car + x))) + (cdr + x8114)))) + (cdr x8113)))) + (car x8112)))) + g8111))) + (newline + (lambda () (letrec ((g8115 #f)) g8115))) + (lcm + (lambda (m n) + (letrec ((g8116 + (letrec ((x8118 + (letrec ((x8119 (* m n))) + (abs x8119))) + (x8117 (gcd m n))) + (/ x8118 x8117)))) + g8116))) + (deref car) + (> + (lambda (x y) + (letrec ((g8120 + (letrec ((x8122 (number? x))) + (assert x8122))) + (g8121 + (letrec ((x8123 (<= x y))) + (not x8123)))) + g8121))) + (list-ref + (lambda (l index) + (letrec ((g8124 + (letrec ((x8128 (list? l))) + (assert x8128))) + (g8125 + (letrec ((x8129 (number? index))) + (assert x8129))) + (g8126 + (letrec ((x8130 + (letrec ((x8131 + (length l))) + (< index x8131)))) + (assert x8130))) + (g8127 + (letrec ((x-cnd8132 (= index 0))) + (if x-cnd8132 + (car l) + (letrec ((x8134 (cdr l)) + (x8133 (- index 1))) + (list-ref x8134 x8133)))))) + g8127))) + (gcd + (lambda (a b) + (letrec ((g8135 + (letrec ((x-cnd8136 (= b 0))) + (if x-cnd8136 + a + (letrec ((x8137 (modulo a b))) + (gcd b x8137)))))) + g8135)))) + (letrec ((g8138 + (letrec ((g8139 + (letrec ((STATE/C + (lambda (g7232 + g7233 + g7234) + (letrec ((g8140 + (letrec ((x-cnd8141 + ((lambda (v7231) + (if (eq? + 'init + v7231) + #t + (if (eq? + 'opened + v7231) + #t + (if (eq? + 'closed + v7231) + #t + (eq? + 'ignore + v7231))))) + g7234))) + (if x-cnd8141 + g7234 + (blame + g7232 + '(lambda (v7231) + (if (eq? + 'init + v7231) + #t + (if (eq? + 'opened + v7231) + #t + (if (eq? + 'closed + v7231) + #t + (eq? + 'ignore + v7231)))))))))) + g8140))) + (loop + (lambda () + (letrec ((g8142 + (loop))) + g8142))) + (readit + (lambda (st) + (letrec ((g8143 + (letrec ((x-cnd8144 + (equal? + 'opened + st))) + (if x-cnd8144 + 'opened + 'ignore)))) + g8143))) + (read_ + (lambda (x st) + (letrec ((g8145 + (if x + (readit st) + st))) + g8145))) + (closeit + (lambda (st) + (letrec ((g8146 + (if cnd + (letrec ((g8147 + 'closed)) + g8147) + (if cnd + (letrec ((g8148 + 'ignore)) + g8148) + (letrec ((g8149 + (loop)) + (g8150 + 0)) + g8150))))) + g8146))) + (close_ + (lambda (x st) + (letrec ((g8151 + (if x + (closeit + st) + st))) + g8151))) + (f + (lambda (x y st) + (letrec ((g8152 + (letrec ((x8154 + (close_ + x + st))) + (close_ + y + x8154))) + (g8153 + (letrec ((x8155 + (letrec ((x8156 + (read_ + x + st))) + (read_ + y + x8156)))) + (f + x + y + x8155)))) + g8153))) + (next + (lambda (st) + (letrec ((g8157 + (letrec ((x-cnd8158 + (equal? + 'init + st))) + (if x-cnd8158 + 'opened + 'ignore)))) + g8157))) + (g + (lambda (b3 x st) + (letrec ((g8159 + (letrec ((x-cnd8160 + (> + b3 + 0))) + (if x-cnd8160 + (letrec ((x8161 + (next + st))) + (f + x + #t + x8161)) + (f + x + #f + st))))) + g8159))) + (main + (lambda (b2 b3) + (letrec ((g8162 + (letrec ((x-cnd8164 + (> + b2 + 0))) + (if x-cnd8164 + (g + b3 + #t + 'opened) + (g + b3 + #f + 'init)))) + (g8163 'unit)) + g8163)))) + (letrec ((g8165 + (letrec ((g8166 + (letrec ((g8167 + (letrec ((x8170 + ((lambda (j7237 + k7238 + f7239) + (lambda (g7235 + g7236) + (any/c + j7237 + k7238 + (f7239 + (integer?/c + j7237 + k7238 + g7235) + (integer?/c + j7237 + k7238 + g7236))))) + 'module + 'importer + main)) + (x8169 + (input)) + (x8168 + (input))) + (x8170 + x8169 + x8168)))) + g8167))) + g8166))) + g8165)))) + g8139))) + g8138)))) + g7251))) + g7250)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_r-lock.rkt b/analyses/simpleactor/benchmarks-out/mochi_r-lock.rkt index f1480a75..6e00a767 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_r-lock.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_r-lock.rkt @@ -1,25 +1,3108 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7239 #t)) g7239))) + (meta (lambda (v) (letrec ((g7240 v)) g7240))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7241 + (letrec ((g7242 + (letrec ((x-e7243 lst)) + (match + x-e7243 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7244 (eq? v v1))) + (if x-cnd7244 #t (member v vs))))))))) + g7242))) + g7241))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (lock st) 1) - (define (unlock st) 0) - (define (f n st) (if (> n 0) (lock st) st)) - (define (g n st) (if (> n 0) (unlock st) st)) - (define (main n) (g n (f n 0))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((one-of/c 0) j3984 k3985 (f3986 (integer? j3984 k3985 g3983))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7245 (lambda (v) (letrec ((g7246 v)) g7246)))) g7245))) + (nonzero? + (lambda (v) + (letrec ((g7247 (letrec ((x7248 (= v 0))) (not x7248)))) g7247)))) + (letrec ((g7249 + (letrec ((g7250 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7251 + (letrec ((x-cnd7252 (real? g7162))) + (if x-cnd7252 + g7162 + (blame g7160 'real?))))) + g7251))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7253 + (letrec ((x-cnd7254 + (boolean? g7165))) + (if x-cnd7254 + g7165 + (blame g7163 'boolean?))))) + g7253))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7255 + (letrec ((x-cnd7256 + (number? g7168))) + (if x-cnd7256 + g7168 + (blame g7166 'number?))))) + g7255))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7257 + (letrec ((x-cnd7258 + ((lambda (v) #t) g7171))) + (if x-cnd7258 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7257))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7259 + (letrec ((x-cnd7260 + ((lambda (v) #t) g7174))) + (if x-cnd7260 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7259))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7261 + (letrec ((x-cnd7262 (pair? g7177))) + (if x-cnd7262 + g7177 + (blame g7175 'pair?))))) + g7261))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7263 + (letrec ((x-cnd7264 (pair? g7180))) + (if x-cnd7264 + g7180 + (blame g7178 'pair?))))) + g7263))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7265 + (letrec ((x-cnd7266 + (integer? g7183))) + (if x-cnd7266 + g7183 + (blame g7181 'integer?))))) + g7265))) + (and/c + (lambda (c1 c2) + (letrec ((g7267 + (lambda (k j v) + (letrec ((g7268 + (letrec ((x-cnd7269 + (c1 k j v))) + (if x-cnd7269 + (c2 k j v) + #f)))) + g7268)))) + g7267))) + (list-of + (lambda (contract) + (letrec ((g7270 + (lambda (k j v) + (letrec ((g7271 + (letrec ((x-cnd7272 + (null? v))) + (if x-cnd7272 + '() + (letrec ((x7276 + (letrec ((x7277 + (car + v))) + (contract + k + j + x7277))) + (x7273 + (letrec ((x7275 + (list-of + contract)) + (x7274 + (cdr + v))) + (x7275 + k + j + x7274)))) + (cons + x7276 + x7273)))))) + g7271)))) + g7270))) + (any? (lambda (v) (letrec ((g7278 #t)) g7278))) + (nonzero? + (lambda (v) + (letrec ((g7279 + (letrec ((x7280 (= v 0))) + (not x7280)))) + g7279))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7281 + (letrec ((x-cnd7282 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7282 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7281))) + (meta (lambda (v) (letrec ((g7283 v)) g7283))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7284 #t)) g7284))) + (cdddr + (lambda (x) + (letrec ((g7285 + (letrec ((x7286 + (letrec ((x7287 (cdr x))) + (cdr x7287)))) + (cdr x7286)))) + g7285))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7288 + (letrec ((x7291 (procedure? f))) + (assert x7291))) + (g7289 + (letrec ((x7292 (list? l))) + (assert x7292))) + (g7290 + (letrec ((x-cnd7293 (null? l))) + (if x-cnd7293 + '() + (letrec ((x7296 + (letrec ((x7297 + (car l))) + (f x7297))) + (x7294 + (letrec ((x7295 + (cdr l))) + (map f x7295)))) + (cons x7296 x7294)))))) + g7290))) + (cdar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 (car x))) + (cdr x7299)))) + g7298))) + (cadadr + (lambda (x) + (letrec ((g7300 + (letrec ((x7301 + (letrec ((x7302 + (letrec ((x7303 + (cdr + x))) + (car + x7303)))) + (cdr x7302)))) + (car x7301)))) + g7300))) + (cdadar + (lambda (x) + (letrec ((g7304 + (letrec ((x7305 + (letrec ((x7306 + (letrec ((x7307 + (car + x))) + (cdr + x7307)))) + (car x7306)))) + (cdr x7305)))) + g7304))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7308 + (letrec ((x7311 + (string? filename))) + (assert x7311))) + (g7309 + (letrec ((x7312 (procedure? proc))) + (assert x7312))) + (g7310 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7313 + (close-output-port + output-port)) + (g7314 res)) + g7314)))) + g7310))) + (caddr + (lambda (x) + (letrec ((g7315 + (letrec ((x7316 + (letrec ((x7317 (cdr x))) + (cdr x7317)))) + (car x7316)))) + g7315))) + (cdaadr + (lambda (x) + (letrec ((g7318 + (letrec ((x7319 + (letrec ((x7320 + (letrec ((x7321 + (cdr + x))) + (car + x7321)))) + (car x7320)))) + (cdr x7319)))) + g7318))) + (assq + (lambda (k l) + (letrec ((g7322 + (letrec ((x7324 (list? l))) + (assert x7324))) + (g7323 + (letrec ((x-cnd7325 (null? l))) + (if x-cnd7325 + #f + (letrec ((x-cnd7326 + (letrec ((x7327 + (caar l))) + (eq? x7327 k)))) + (if x-cnd7326 + (car l) + (letrec ((x7328 (cdr l))) + (assq k x7328)))))))) + g7323))) + (even? + (lambda (x) + (letrec ((g7329 + (letrec ((x7330 (modulo x 2))) + (= 0 x7330)))) + g7329))) + (list->string + (lambda (l) + (letrec ((g7331 + (letrec ((x7333 (list? l))) + (assert x7333))) + (g7332 + (letrec ((x-cnd7334 (null? l))) + (if x-cnd7334 + "" + (letrec ((x7337 + (letrec ((x7338 + (car l))) + (char->string + x7338))) + (x7335 + (letrec ((x7336 + (cdr l))) + (list->string + x7336)))) + (string-append + x7337 + x7335)))))) + g7332))) + (char<=? + (lambda (c1 c2) + (letrec ((g7339 + (letrec ((x7342 (char? c1))) + (assert x7342))) + (g7340 + (letrec ((x7343 (char? c2))) + (assert x7343))) + (g7341 + (letrec ((val7143 (char=? c x7360)))) + (if x-cnd7359 + (letrec ((x7361 #\z)) + (char-ci<=? c x7361)) + #f)))) + g7358))) + (<= + (lambda (x y) + (letrec ((g7362 + (letrec ((x7364 (number? x))) + (assert x7364))) + (g7363 + (letrec ((val7144 (< x y))) + (letrec ((g7365 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7366 + (if val7145 + val7145 + #f))) + g7366))))) + g7365)))) + g7363))) + (char-whitespace? + (lambda (c) + (letrec ((g7367 + (letrec ((val7146 + (letrec ((x7368 + (char->integer + c))) + (= x7368 9)))) + (letrec ((g7369 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7370 + (char->integer + c))) + (= + x7370 + 10)))) + (letrec ((g7371 + (if val7147 + val7147 + (letrec ((x7372 + (char->integer + c))) + (= + x7372 + 32))))) + g7371))))) + g7369)))) + g7367))) + (cddar + (lambda (x) + (letrec ((g7373 + (letrec ((x7374 + (letrec ((x7375 (car x))) + (cdr x7375)))) + (cdr x7374)))) + g7373))) + (positive? + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 (> x 0))) + g7377))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7379 #f)) g7379))) + (cddr + (lambda (x) + (letrec ((g7380 + (letrec ((x7381 (cdr x))) + (cdr x7381)))) + g7380))) + (truncate + (lambda (x) + (letrec ((g7382 + (letrec ((x7384 (number? x))) + (assert x7384))) + (g7383 + (letrec ((x-cnd7385 (< x 0))) + (if x-cnd7385 + (ceiling x) + (floor x))))) + g7383))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7386 + (letrec ((val7148 (eq? a b))) + (letrec ((g7387 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7389 + (null? + a)) + (x7388 + (null? + b))) + (and x7389 + x7388)))) + (letrec ((g7390 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7393 + (string? + a)) + (x7392 + (string? + b)) + (x7391 + (string=? + a + b))) + (and x7393 + x7392 + x7391)))) + (letrec ((g7394 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7402 + (pair? + a)) + (x7401 + (pair? + b)) + (x7398 + (letrec ((x7400 + (car + a)) + (x7399 + (car + b))) + (equal? + x7400 + x7399))) + (x7395 + (letrec ((x7397 + (cdr + a)) + (x7396 + (cdr + b))) + (equal? + x7397 + x7396)))) + (and x7402 + x7401 + x7398 + x7395)))) + (letrec ((g7403 + (if val7151 + val7151 + (letrec ((x7422 + (vector? + a)) + (x7421 + (vector? + b)) + (x7404 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (vector-length + a))) + (n + x7420)))) + (x7419))) + (x7405 + (letrec ((x7416 + (letrec ((x7417 + (vector-length + b))) + (= + x7417 + n))) + (x7406 + (letrec ((loop + (lambda (i) + (letrec ((g7407 + (letrec ((x7414 + (= + i + n)) + (x7408 + (letrec ((x7411 + (letrec ((x7413 + (vector-ref + a + i)) + (x7412 + (vector-ref + b + i))) + (equal? + x7413 + x7412))) + (x7409 + (letrec ((x7410 + (+ + i + 1))) + (loop + x7410)))) + (and x7411 + x7409)))) + (or x7414 + x7408)))) + g7407)))) + (letrec ((g7415 + (loop + 0))) + g7415)))) + (and x7416 + x7406)))) + (let x7418 x7405)))) + (and x7422 + x7421 + x7404))))) + g7403))))) + g7394))))) + g7390))))) + g7387)))) + g7386))) + (cdaaar + (lambda (x) + (letrec ((g7423 + (letrec ((x7424 + (letrec ((x7425 + (letrec ((x7426 + (car + x))) + (car + x7426)))) + (car x7425)))) + (cdr x7424)))) + g7423))) + (caaddr + (lambda (x) + (letrec ((g7427 + (letrec ((x7428 + (letrec ((x7429 + (letrec ((x7430 + (cdr + x))) + (cdr + x7430)))) + (car x7429)))) + (car x7428)))) + g7427))) + (eqv? + (lambda (x y) + (letrec ((g7431 (eq? x y))) g7431))) + (>= + (lambda (x y) + (letrec ((g7432 + (letrec ((x7434 (number? x))) + (assert x7434))) + (g7433 + (letrec ((val7152 (> x y))) + (letrec ((g7435 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7436 + (if val7153 + val7153 + #f))) + g7436))))) + g7435)))) + g7433))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7437 + (letrec ((x7440 + (string? filename))) + (assert x7440))) + (g7438 + (letrec ((x7441 (procedure? proc))) + (assert x7441))) + (g7439 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7442 + (close-input-port + input-port)) + (g7443 res)) + g7443)))) + g7439))) + (ref + (lambda (x) + (letrec ((g7444 (cons x '()))) g7444))) + (char>=? + (lambda (c1 c2) + (letrec ((g7445 + (letrec ((x7448 (char? c1))) + (assert x7448))) + (g7446 + (letrec ((x7449 (char? c2))) + (assert x7449))) + (g7447 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7450 + (if val7154 + val7154 + (char=? c1 c2)))) + g7450)))) + g7447))) + (cdaar + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (car x))) + (car x7453)))) + (cdr x7452)))) + g7451))) + (cdaddr + (lambda (x) + (letrec ((g7454 + (letrec ((x7455 + (letrec ((x7456 + (letrec ((x7457 + (cdr + x))) + (cdr + x7457)))) + (car x7456)))) + (cdr x7455)))) + g7454))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7458 + (letrec ((x7459 + (letrec ((x7460 (car x))) + (cdr x7460)))) + (car x7459)))) + g7458))) + (caadr + (lambda (x) + (letrec ((g7461 + (letrec ((x7462 + (letrec ((x7463 (cdr x))) + (car x7463)))) + (car x7462)))) + g7461))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7464 + (letrec ((x7467 (char? c1))) + (assert x7467))) + (g7465 + (letrec ((x7468 (char? c2))) + (assert x7468))) + (g7466 + (letrec ((x7469 + (char-ci<=? c1 c2))) + (not x7469)))) + g7466))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7470 + (letrec ((x7471 + (letrec ((x7472 + (letrec ((x7473 + (car + x))) + (car + x7473)))) + (car x7472)))) + (car x7471)))) + g7470))) + (negative? + (lambda (x) + (letrec ((g7474 + (letrec ((x7476 (number? x))) + (assert x7476))) + (g7475 (< x 0))) + g7475))) + (memv + (lambda (e l) + (letrec ((g7477 (memq e l))) g7477))) + (caaar + (lambda (x) + (letrec ((g7478 + (letrec ((x7479 + (letrec ((x7480 (car x))) + (car x7480)))) + (car x7479)))) + g7478))) + (debug + (lambda (e) (letrec ((g7481 '())) g7481))) + (reverse + (lambda (l) + (letrec ((g7482 + (letrec ((x7484 (list? l))) + (assert x7484))) + (g7483 + (letrec ((x-cnd7485 (null? l))) + (if x-cnd7485 + '() + (letrec ((x7488 + (letrec ((x7489 + (cdr l))) + (reverse x7489))) + (x7486 + (letrec ((x7487 + (car l))) + (list x7487)))) + (append x7488 x7486)))))) + g7483))) + (caaadr + (lambda (x) + (letrec ((g7490 + (letrec ((x7491 + (letrec ((x7492 + (letrec ((x7493 + (cdr + x))) + (car + x7493)))) + (car x7492)))) + (car x7491)))) + g7490))) + (cddadr + (lambda (x) + (letrec ((g7494 + (letrec ((x7495 + (letrec ((x7496 + (letrec ((x7497 + (cdr + x))) + (car + x7497)))) + (cdr x7496)))) + (cdr x7495)))) + g7494))) + (odd? + (lambda (x) + (letrec ((g7498 + (letrec ((x7500 (number? x))) + (assert x7500))) + (g7499 + (letrec ((x7501 (modulo x 2))) + (= 1 x7501)))) + g7499))) + (caadar + (lambda (x) + (letrec ((g7502 + (letrec ((x7503 + (letrec ((x7504 + (letrec ((x7505 + (car + x))) + (cdr + x7505)))) + (car x7504)))) + (car x7503)))) + g7502))) + (apply + (lambda (proc args) + (letrec ((g7506 + (letrec ((x7509 (procedure? proc))) + (assert x7509))) + (g7507 + (letrec ((x7510 (list? args))) + (assert x7510))) + (g7508 + (if cnd + (letrec ((g7511 (proc))) g7511) + (if cnd + (letrec ((g7512 + (letrec ((x7513 + (car + args))) + (proc x7513)))) + g7512) + (if cnd + (letrec ((g7514 + (letrec ((x7516 + (car + args)) + (x7515 + (cadr + args))) + (proc + x7516 + x7515)))) + g7514) + (if cnd + (letrec ((g7517 + (letrec ((x7520 + (car + args)) + (x7519 + (cadr + args)) + (x7518 + (caddr + args))) + (proc + x7520 + x7519 + x7518)))) + g7517) + (if cnd + (letrec ((g7521 + (letrec ((x7525 + (car + args)) + (x7524 + (cadr + args)) + (x7523 + (caddr + args)) + (x7522 + (cadddr + args))) + (proc + x7525 + x7524 + x7523 + x7522)))) + g7521) + (if cnd + (letrec ((g7526 + (letrec ((x7532 + (car + args)) + (x7531 + (cadr + args)) + (x7530 + (caddr + args)) + (x7529 + (cadddr + args)) + (x7527 + (letrec ((x7528 + (cddddr + args))) + (car + x7528)))) + (proc + x7532 + x7531 + x7530 + x7529 + x7527)))) + g7526) + (if cnd + (letrec ((g7533 + (letrec ((x7541 + (car + args)) + (x7540 + (cadr + args)) + (x7539 + (caddr + args)) + (x7538 + (cadddr + args)) + (x7536 + (letrec ((x7537 + (cddddr + args))) + (car + x7537))) + (x7534 + (letrec ((x7535 + (cddddr + args))) + (cadr + x7535)))) + (proc + x7541 + x7540 + x7539 + x7538 + x7536 + x7534)))) + g7533) + (if cnd + (letrec ((g7542 + (letrec ((x7552 + (car + args)) + (x7551 + (cadr + args)) + (x7550 + (caddr + args)) + (x7549 + (cadddr + args)) + (x7547 + (letrec ((x7548 + (cddddr + args))) + (car + x7548))) + (x7545 + (letrec ((x7546 + (cddddr + args))) + (cadr + x7546))) + (x7543 + (letrec ((x7544 + (cddddr + args))) + (caddr + x7544)))) + (proc + x7552 + x7551 + x7550 + x7549 + x7547 + x7545 + x7543)))) + g7542) + (letrec ((g7553 + (error + "Unsupported call."))) + g7553))))))))))) + g7508))) + (member + (lambda (e l) + (letrec ((g7554 + (letrec ((x7556 (list? l))) + (assert x7556))) + (g7555 + (letrec ((x-cnd7557 (null? l))) + (if x-cnd7557 + #f + (letrec ((x-cnd7558 + (letrec ((x7559 + (car l))) + (equal? x7559 e)))) + (if x-cnd7558 + l + (letrec ((x7560 (cdr l))) + (member e x7560)))))))) + g7555))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7561 + (letrec ((x7562 + (letrec ((x7563 + (letrec ((x7564 + (cdr + x))) + (cdr + x7564)))) + (cdr x7563)))) + (cdr x7562)))) + g7561))) + (cadddr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 + (letrec ((x7567 + (letrec ((x7568 + (cdr + x))) + (cdr + x7568)))) + (cdr x7567)))) + (car x7566)))) + g7565))) + (int-top + (lambda () + (letrec ((g7569 (random 42))) g7569))) + (zero? + (lambda (x) + (letrec ((g7570 + (letrec ((x7572 (number? x))) + (assert x7572))) + (g7571 (= x 0))) + g7571))) + (string>=? + (lambda (s1 s2) + (letrec ((g7573 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7574 + (if val7155 + val7155 + (string=? s1 s2)))) + g7574)))) + g7573))) + (cadr + (lambda (x) + (letrec ((g7575 + (letrec ((x7576 (cdr x))) + (car x7576)))) + g7575))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7577 + (letrec ((val7156 + (letrec ((x7580 + (pair? l)) + (x7578 + (letrec ((x7579 + (cdr + l))) + (list? + x7579)))) + (and x7580 x7578)))) + (letrec ((g7581 + (if val7156 + val7156 + (null? l)))) + g7581)))) + g7577))) + (cddaar + (lambda (x) + (letrec ((g7582 + (letrec ((x7583 + (letrec ((x7584 + (letrec ((x7585 + (car + x))) + (car + x7585)))) + (cdr x7584)))) + (cdr x7583)))) + g7582))) + (char-numeric? + (lambda (c) + (letrec ((g7586 + (letrec ((x-cnd7587 + (letrec ((x7588 #\0)) + (char<=? x7588 c)))) + (if x-cnd7587 + (letrec ((x7589 #\9)) + (char<=? c x7589)) + #f)))) + g7586))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7590 + (letrec ((x7592 (list? l))) + (assert x7592))) + (g7591 + (letrec ((x-cnd7593 (null? l))) + (if x-cnd7593 + #f + (letrec ((x-cnd7594 + (letrec ((x7595 + (caar l))) + (eqv? x7595 k)))) + (if x-cnd7594 + (car l) + (letrec ((x7596 (cdr l))) + (assq k x7596)))))))) + g7591))) + (not + (lambda (x) + (letrec ((g7597 (if x #f #t))) g7597))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7598 (append l1 l2))) g7598))) + (memq + (lambda (e l) + (letrec ((g7599 + (letrec ((x7601 (list? l))) + (assert x7601))) + (g7600 + (letrec ((x-cnd7602 (null? l))) + (if x-cnd7602 + #f + (letrec ((x-cnd7603 + (letrec ((x7604 + (car l))) + (eq? x7604 e)))) + (if x-cnd7603 + l + (letrec ((x7605 (cdr l))) + (memq e x7605)))))))) + g7600))) + (cadaar + (lambda (x) + (letrec ((g7606 + (letrec ((x7607 + (letrec ((x7608 + (letrec ((x7609 + (car + x))) + (car + x7609)))) + (cdr x7608)))) + (car x7607)))) + g7606))) + (length + (lambda (l) + (letrec ((g7610 + (letrec ((x7612 (list? l))) + (assert x7612))) + (g7611 + (letrec ((rec + (lambda (l) + (letrec ((g7613 + (letrec ((x-cnd7614 + (null? + l))) + (if x-cnd7614 + 0 + (letrec ((x7615 + (letrec ((x7616 + (cdr + l))) + (rec + x7616)))) + (+ + 1 + x7615)))))) + g7613)))) + (letrec ((g7617 (rec l))) + g7617)))) + g7611))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7618 + (letrec ((x7621 (char? c1))) + (assert x7621))) + (g7619 + (letrec ((x7622 (char? c2))) + (assert x7622))) + (g7620 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7624 + (letrec ((x7625 (string<=? s1 s2))) + (not x7625)))) + g7624))) + (cdadr + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 + (letrec ((x7628 (cdr x))) + (car x7628)))) + (cdr x7627)))) + g7626))) + (assoc + (lambda (k l) + (letrec ((g7629 + (letrec ((x7631 (list? l))) + (assert x7631))) + (g7630 + (letrec ((x-cnd7632 (null? l))) + (if x-cnd7632 + #f + (letrec ((x-cnd7633 + (letrec ((x7634 + (caar l))) + (equal? x7634 k)))) + (if x-cnd7633 + (car l) + (letrec ((x7635 (cdr l))) + (assoc k x7635)))))))) + g7630))) + (caar + (lambda (x) + (letrec ((g7636 + (letrec ((x7637 (car x))) + (car x7637)))) + g7636))) + (char>? + (lambda (c1 c2) + (letrec ((g7638 + (letrec ((x7641 (char? c1))) + (assert x7641))) + (g7639 + (letrec ((x7642 (char? c2))) + (assert x7642))) + (g7640 + (letrec ((x7643 (char<=? c1 c2))) + (not x7643)))) + g7640))) + (string<=? + (lambda (s1 s2) + (letrec ((g7644 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7661 + (letrec ((x7664 (char? c1))) + (assert x7664))) + (g7662 + (letrec ((x7665 (char? c2))) + (assert x7665))) + (g7663 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7666 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7666)))) + g7663))) + (caddar + (lambda (x) + (letrec ((g7667 + (letrec ((x7668 + (letrec ((x7669 + (letrec ((x7670 + (car + x))) + (cdr + x7670)))) + (cdr x7669)))) + (car x7668)))) + g7667))) + (newline + (lambda () (letrec ((g7671 #f)) g7671))) + (lcm + (lambda (m n) + (letrec ((g7672 + (letrec ((x7674 + (letrec ((x7675 (* m n))) + (abs x7675))) + (x7673 (gcd m n))) + (/ x7674 x7673)))) + g7672))) + (deref car) + (> + (lambda (x y) + (letrec ((g7676 + (letrec ((x7678 (number? x))) + (assert x7678))) + (g7677 + (letrec ((x7679 (<= x y))) + (not x7679)))) + g7677))) + (list-ref + (lambda (l index) + (letrec ((g7680 + (letrec ((x7684 (list? l))) + (assert x7684))) + (g7681 + (letrec ((x7685 (number? index))) + (assert x7685))) + (g7682 + (letrec ((x7686 + (letrec ((x7687 + (length l))) + (< index x7687)))) + (assert x7686))) + (g7683 + (letrec ((x-cnd7688 (= index 0))) + (if x-cnd7688 + (car l) + (letrec ((x7690 (cdr l)) + (x7689 (- index 1))) + (list-ref x7690 x7689)))))) + g7683))) + (gcd + (lambda (a b) + (letrec ((g7691 + (letrec ((x-cnd7692 (= b 0))) + (if x-cnd7692 + a + (letrec ((x7693 (modulo a b))) + (gcd b x7693)))))) + g7691))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7694 + (letrec ((x-cnd7695 (real? g7162))) + (if x-cnd7695 + g7162 + (blame g7160 'real?))))) + g7694))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7696 + (letrec ((x-cnd7697 + (boolean? g7165))) + (if x-cnd7697 + g7165 + (blame g7163 'boolean?))))) + g7696))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7698 + (letrec ((x-cnd7699 + (number? g7168))) + (if x-cnd7699 + g7168 + (blame g7166 'number?))))) + g7698))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7700 + (letrec ((x-cnd7701 + ((lambda (v) #t) g7171))) + (if x-cnd7701 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7700))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7702 + (letrec ((x-cnd7703 + ((lambda (v) #t) g7174))) + (if x-cnd7703 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7702))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7704 + (letrec ((x-cnd7705 (pair? g7177))) + (if x-cnd7705 + g7177 + (blame g7175 'pair?))))) + g7704))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7706 + (letrec ((x-cnd7707 (pair? g7180))) + (if x-cnd7707 + g7180 + (blame g7178 'pair?))))) + g7706))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7708 + (letrec ((x-cnd7709 + (integer? g7183))) + (if x-cnd7709 + g7183 + (blame g7181 'integer?))))) + g7708))) + (and/c + (lambda (c1 c2) + (letrec ((g7710 + (lambda (k j v) + (letrec ((g7711 + (letrec ((x-cnd7712 + (c1 k j v))) + (if x-cnd7712 + (c2 k j v) + #f)))) + g7711)))) + g7710))) + (list-of + (lambda (contract) + (letrec ((g7713 + (lambda (k j v) + (letrec ((g7714 + (letrec ((x-cnd7715 + (null? v))) + (if x-cnd7715 + '() + (letrec ((x7719 + (letrec ((x7720 + (car + v))) + (contract + k + j + x7720))) + (x7716 + (letrec ((x7718 + (list-of + contract)) + (x7717 + (cdr + v))) + (x7718 + k + j + x7717)))) + (cons + x7719 + x7716)))))) + g7714)))) + g7713))) + (any? (lambda (v) (letrec ((g7721 #t)) g7721))) + (nonzero? + (lambda (v) + (letrec ((g7722 + (letrec ((x7723 (= v 0))) + (not x7723)))) + g7722))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7724 + (letrec ((x-cnd7725 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7725 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7724))) + (meta (lambda (v) (letrec ((g7726 v)) g7726))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7727 #t)) g7727))) + (cdddr + (lambda (x) + (letrec ((g7728 + (letrec ((x7729 + (letrec ((x7730 (cdr x))) + (cdr x7730)))) + (cdr x7729)))) + g7728))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7731 + (letrec ((x7734 (procedure? f))) + (assert x7734))) + (g7732 + (letrec ((x7735 (list? l))) + (assert x7735))) + (g7733 + (letrec ((x-cnd7736 (null? l))) + (if x-cnd7736 + '() + (letrec ((x7739 + (letrec ((x7740 + (car l))) + (f x7740))) + (x7737 + (letrec ((x7738 + (cdr l))) + (map f x7738)))) + (cons x7739 x7737)))))) + g7733))) + (cdar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 (car x))) + (cdr x7742)))) + g7741))) + (cadadr + (lambda (x) + (letrec ((g7743 + (letrec ((x7744 + (letrec ((x7745 + (letrec ((x7746 + (cdr + x))) + (car + x7746)))) + (cdr x7745)))) + (car x7744)))) + g7743))) + (cdadar + (lambda (x) + (letrec ((g7747 + (letrec ((x7748 + (letrec ((x7749 + (letrec ((x7750 + (car + x))) + (cdr + x7750)))) + (car x7749)))) + (cdr x7748)))) + g7747))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7751 + (letrec ((x7754 + (string? filename))) + (assert x7754))) + (g7752 + (letrec ((x7755 (procedure? proc))) + (assert x7755))) + (g7753 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7756 + (close-output-port + output-port)) + (g7757 res)) + g7757)))) + g7753))) + (caddr + (lambda (x) + (letrec ((g7758 + (letrec ((x7759 + (letrec ((x7760 (cdr x))) + (cdr x7760)))) + (car x7759)))) + g7758))) + (cdaadr + (lambda (x) + (letrec ((g7761 + (letrec ((x7762 + (letrec ((x7763 + (letrec ((x7764 + (cdr + x))) + (car + x7764)))) + (car x7763)))) + (cdr x7762)))) + g7761))) + (assq + (lambda (k l) + (letrec ((g7765 + (letrec ((x7767 (list? l))) + (assert x7767))) + (g7766 + (letrec ((x-cnd7768 (null? l))) + (if x-cnd7768 + #f + (letrec ((x-cnd7769 + (letrec ((x7770 + (caar l))) + (eq? x7770 k)))) + (if x-cnd7769 + (car l) + (letrec ((x7771 (cdr l))) + (assq k x7771)))))))) + g7766))) + (even? + (lambda (x) + (letrec ((g7772 + (letrec ((x7773 (modulo x 2))) + (= 0 x7773)))) + g7772))) + (list->string + (lambda (l) + (letrec ((g7774 + (letrec ((x7776 (list? l))) + (assert x7776))) + (g7775 + (letrec ((x-cnd7777 (null? l))) + (if x-cnd7777 + "" + (letrec ((x7780 + (letrec ((x7781 + (car l))) + (char->string + x7781))) + (x7778 + (letrec ((x7779 + (cdr l))) + (list->string + x7779)))) + (string-append + x7780 + x7778)))))) + g7775))) + (char<=? + (lambda (c1 c2) + (letrec ((g7782 + (letrec ((x7785 (char? c1))) + (assert x7785))) + (g7783 + (letrec ((x7786 (char? c2))) + (assert x7786))) + (g7784 + (letrec ((val7143 (char=? c x7803)))) + (if x-cnd7802 + (letrec ((x7804 #\z)) + (char-ci<=? c x7804)) + #f)))) + g7801))) + (<= + (lambda (x y) + (letrec ((g7805 + (letrec ((x7807 (number? x))) + (assert x7807))) + (g7806 + (letrec ((val7144 (< x y))) + (letrec ((g7808 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7809 + (if val7145 + val7145 + #f))) + g7809))))) + g7808)))) + g7806))) + (char-whitespace? + (lambda (c) + (letrec ((g7810 + (letrec ((val7146 + (letrec ((x7811 + (char->integer + c))) + (= x7811 9)))) + (letrec ((g7812 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7813 + (char->integer + c))) + (= + x7813 + 10)))) + (letrec ((g7814 + (if val7147 + val7147 + (letrec ((x7815 + (char->integer + c))) + (= + x7815 + 32))))) + g7814))))) + g7812)))) + g7810))) + (cddar + (lambda (x) + (letrec ((g7816 + (letrec ((x7817 + (letrec ((x7818 (car x))) + (cdr x7818)))) + (cdr x7817)))) + g7816))) + (positive? + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 (> x 0))) + g7820))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7822 #f)) g7822))) + (cddr + (lambda (x) + (letrec ((g7823 + (letrec ((x7824 (cdr x))) + (cdr x7824)))) + g7823))) + (truncate + (lambda (x) + (letrec ((g7825 + (letrec ((x7827 (number? x))) + (assert x7827))) + (g7826 + (letrec ((x-cnd7828 (< x 0))) + (if x-cnd7828 + (ceiling x) + (floor x))))) + g7826))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7829 + (letrec ((val7148 (eq? a b))) + (letrec ((g7830 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7832 + (null? + a)) + (x7831 + (null? + b))) + (and x7832 + x7831)))) + (letrec ((g7833 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7836 + (string? + a)) + (x7835 + (string? + b)) + (x7834 + (string=? + a + b))) + (and x7836 + x7835 + x7834)))) + (letrec ((g7837 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7845 + (pair? + a)) + (x7844 + (pair? + b)) + (x7841 + (letrec ((x7843 + (car + a)) + (x7842 + (car + b))) + (equal? + x7843 + x7842))) + (x7838 + (letrec ((x7840 + (cdr + a)) + (x7839 + (cdr + b))) + (equal? + x7840 + x7839)))) + (and x7845 + x7844 + x7841 + x7838)))) + (letrec ((g7846 + (if val7151 + val7151 + (letrec ((x7865 + (vector? + a)) + (x7864 + (vector? + b)) + (x7847 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (vector-length + a))) + (n + x7863)))) + (x7862))) + (x7848 + (letrec ((x7859 + (letrec ((x7860 + (vector-length + b))) + (= + x7860 + n))) + (x7849 + (letrec ((loop + (lambda (i) + (letrec ((g7850 + (letrec ((x7857 + (= + i + n)) + (x7851 + (letrec ((x7854 + (letrec ((x7856 + (vector-ref + a + i)) + (x7855 + (vector-ref + b + i))) + (equal? + x7856 + x7855))) + (x7852 + (letrec ((x7853 + (+ + i + 1))) + (loop + x7853)))) + (and x7854 + x7852)))) + (or x7857 + x7851)))) + g7850)))) + (letrec ((g7858 + (loop + 0))) + g7858)))) + (and x7859 + x7849)))) + (let x7861 x7848)))) + (and x7865 + x7864 + x7847))))) + g7846))))) + g7837))))) + g7833))))) + g7830)))) + g7829))) + (cdaaar + (lambda (x) + (letrec ((g7866 + (letrec ((x7867 + (letrec ((x7868 + (letrec ((x7869 + (car + x))) + (car + x7869)))) + (car x7868)))) + (cdr x7867)))) + g7866))) + (caaddr + (lambda (x) + (letrec ((g7870 + (letrec ((x7871 + (letrec ((x7872 + (letrec ((x7873 + (cdr + x))) + (cdr + x7873)))) + (car x7872)))) + (car x7871)))) + g7870))) + (eqv? + (lambda (x y) + (letrec ((g7874 (eq? x y))) g7874))) + (>= + (lambda (x y) + (letrec ((g7875 + (letrec ((x7877 (number? x))) + (assert x7877))) + (g7876 + (letrec ((val7152 (> x y))) + (letrec ((g7878 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7879 + (if val7153 + val7153 + #f))) + g7879))))) + g7878)))) + g7876))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7880 + (letrec ((x7883 + (string? filename))) + (assert x7883))) + (g7881 + (letrec ((x7884 (procedure? proc))) + (assert x7884))) + (g7882 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7885 + (close-input-port + input-port)) + (g7886 res)) + g7886)))) + g7882))) + (ref + (lambda (x) + (letrec ((g7887 (cons x '()))) g7887))) + (char>=? + (lambda (c1 c2) + (letrec ((g7888 + (letrec ((x7891 (char? c1))) + (assert x7891))) + (g7889 + (letrec ((x7892 (char? c2))) + (assert x7892))) + (g7890 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7893 + (if val7154 + val7154 + (char=? c1 c2)))) + g7893)))) + g7890))) + (cdaar + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (car x))) + (car x7896)))) + (cdr x7895)))) + g7894))) + (cdaddr + (lambda (x) + (letrec ((g7897 + (letrec ((x7898 + (letrec ((x7899 + (letrec ((x7900 + (cdr + x))) + (cdr + x7900)))) + (car x7899)))) + (cdr x7898)))) + g7897))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7901 + (letrec ((x7902 + (letrec ((x7903 (car x))) + (cdr x7903)))) + (car x7902)))) + g7901))) + (caadr + (lambda (x) + (letrec ((g7904 + (letrec ((x7905 + (letrec ((x7906 (cdr x))) + (car x7906)))) + (car x7905)))) + g7904))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7907 + (letrec ((x7910 (char? c1))) + (assert x7910))) + (g7908 + (letrec ((x7911 (char? c2))) + (assert x7911))) + (g7909 + (letrec ((x7912 + (char-ci<=? c1 c2))) + (not x7912)))) + g7909))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7913 + (letrec ((x7914 + (letrec ((x7915 + (letrec ((x7916 + (car + x))) + (car + x7916)))) + (car x7915)))) + (car x7914)))) + g7913))) + (negative? + (lambda (x) + (letrec ((g7917 + (letrec ((x7919 (number? x))) + (assert x7919))) + (g7918 (< x 0))) + g7918))) + (memv + (lambda (e l) + (letrec ((g7920 (memq e l))) g7920))) + (caaar + (lambda (x) + (letrec ((g7921 + (letrec ((x7922 + (letrec ((x7923 (car x))) + (car x7923)))) + (car x7922)))) + g7921))) + (debug + (lambda (e) (letrec ((g7924 '())) g7924))) + (reverse + (lambda (l) + (letrec ((g7925 + (letrec ((x7927 (list? l))) + (assert x7927))) + (g7926 + (letrec ((x-cnd7928 (null? l))) + (if x-cnd7928 + '() + (letrec ((x7931 + (letrec ((x7932 + (cdr l))) + (reverse x7932))) + (x7929 + (letrec ((x7930 + (car l))) + (list x7930)))) + (append x7931 x7929)))))) + g7926))) + (caaadr + (lambda (x) + (letrec ((g7933 + (letrec ((x7934 + (letrec ((x7935 + (letrec ((x7936 + (cdr + x))) + (car + x7936)))) + (car x7935)))) + (car x7934)))) + g7933))) + (cddadr + (lambda (x) + (letrec ((g7937 + (letrec ((x7938 + (letrec ((x7939 + (letrec ((x7940 + (cdr + x))) + (car + x7940)))) + (cdr x7939)))) + (cdr x7938)))) + g7937))) + (odd? + (lambda (x) + (letrec ((g7941 + (letrec ((x7943 (number? x))) + (assert x7943))) + (g7942 + (letrec ((x7944 (modulo x 2))) + (= 1 x7944)))) + g7942))) + (caadar + (lambda (x) + (letrec ((g7945 + (letrec ((x7946 + (letrec ((x7947 + (letrec ((x7948 + (car + x))) + (cdr + x7948)))) + (car x7947)))) + (car x7946)))) + g7945))) + (apply + (lambda (proc args) + (letrec ((g7949 + (letrec ((x7952 (procedure? proc))) + (assert x7952))) + (g7950 + (letrec ((x7953 (list? args))) + (assert x7953))) + (g7951 + (if cnd + (letrec ((g7954 (proc))) g7954) + (if cnd + (letrec ((g7955 + (letrec ((x7956 + (car + args))) + (proc x7956)))) + g7955) + (if cnd + (letrec ((g7957 + (letrec ((x7959 + (car + args)) + (x7958 + (cadr + args))) + (proc + x7959 + x7958)))) + g7957) + (if cnd + (letrec ((g7960 + (letrec ((x7963 + (car + args)) + (x7962 + (cadr + args)) + (x7961 + (caddr + args))) + (proc + x7963 + x7962 + x7961)))) + g7960) + (if cnd + (letrec ((g7964 + (letrec ((x7968 + (car + args)) + (x7967 + (cadr + args)) + (x7966 + (caddr + args)) + (x7965 + (cadddr + args))) + (proc + x7968 + x7967 + x7966 + x7965)))) + g7964) + (if cnd + (letrec ((g7969 + (letrec ((x7975 + (car + args)) + (x7974 + (cadr + args)) + (x7973 + (caddr + args)) + (x7972 + (cadddr + args)) + (x7970 + (letrec ((x7971 + (cddddr + args))) + (car + x7971)))) + (proc + x7975 + x7974 + x7973 + x7972 + x7970)))) + g7969) + (if cnd + (letrec ((g7976 + (letrec ((x7984 + (car + args)) + (x7983 + (cadr + args)) + (x7982 + (caddr + args)) + (x7981 + (cadddr + args)) + (x7979 + (letrec ((x7980 + (cddddr + args))) + (car + x7980))) + (x7977 + (letrec ((x7978 + (cddddr + args))) + (cadr + x7978)))) + (proc + x7984 + x7983 + x7982 + x7981 + x7979 + x7977)))) + g7976) + (if cnd + (letrec ((g7985 + (letrec ((x7995 + (car + args)) + (x7994 + (cadr + args)) + (x7993 + (caddr + args)) + (x7992 + (cadddr + args)) + (x7990 + (letrec ((x7991 + (cddddr + args))) + (car + x7991))) + (x7988 + (letrec ((x7989 + (cddddr + args))) + (cadr + x7989))) + (x7986 + (letrec ((x7987 + (cddddr + args))) + (caddr + x7987)))) + (proc + x7995 + x7994 + x7993 + x7992 + x7990 + x7988 + x7986)))) + g7985) + (letrec ((g7996 + (error + "Unsupported call."))) + g7996))))))))))) + g7951))) + (member + (lambda (e l) + (letrec ((g7997 + (letrec ((x7999 (list? l))) + (assert x7999))) + (g7998 + (letrec ((x-cnd8000 (null? l))) + (if x-cnd8000 + #f + (letrec ((x-cnd8001 + (letrec ((x8002 + (car l))) + (equal? x8002 e)))) + (if x-cnd8001 + l + (letrec ((x8003 (cdr l))) + (member e x8003)))))))) + g7998))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8004 + (letrec ((x8005 + (letrec ((x8006 + (letrec ((x8007 + (cdr + x))) + (cdr + x8007)))) + (cdr x8006)))) + (cdr x8005)))) + g8004))) + (cadddr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 + (letrec ((x8010 + (letrec ((x8011 + (cdr + x))) + (cdr + x8011)))) + (cdr x8010)))) + (car x8009)))) + g8008))) + (int-top + (lambda () + (letrec ((g8012 (random 42))) g8012))) + (zero? + (lambda (x) + (letrec ((g8013 + (letrec ((x8015 (number? x))) + (assert x8015))) + (g8014 (= x 0))) + g8014))) + (string>=? + (lambda (s1 s2) + (letrec ((g8016 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8017 + (if val7155 + val7155 + (string=? s1 s2)))) + g8017)))) + g8016))) + (cadr + (lambda (x) + (letrec ((g8018 + (letrec ((x8019 (cdr x))) + (car x8019)))) + g8018))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8020 + (letrec ((val7156 + (letrec ((x8023 + (pair? l)) + (x8021 + (letrec ((x8022 + (cdr + l))) + (list? + x8022)))) + (and x8023 x8021)))) + (letrec ((g8024 + (if val7156 + val7156 + (null? l)))) + g8024)))) + g8020))) + (cddaar + (lambda (x) + (letrec ((g8025 + (letrec ((x8026 + (letrec ((x8027 + (letrec ((x8028 + (car + x))) + (car + x8028)))) + (cdr x8027)))) + (cdr x8026)))) + g8025))) + (char-numeric? + (lambda (c) + (letrec ((g8029 + (letrec ((x-cnd8030 + (letrec ((x8031 #\0)) + (char<=? x8031 c)))) + (if x-cnd8030 + (letrec ((x8032 #\9)) + (char<=? c x8032)) + #f)))) + g8029))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8033 + (letrec ((x8035 (list? l))) + (assert x8035))) + (g8034 + (letrec ((x-cnd8036 (null? l))) + (if x-cnd8036 + #f + (letrec ((x-cnd8037 + (letrec ((x8038 + (caar l))) + (eqv? x8038 k)))) + (if x-cnd8037 + (car l) + (letrec ((x8039 (cdr l))) + (assq k x8039)))))))) + g8034))) + (not + (lambda (x) + (letrec ((g8040 (if x #f #t))) g8040))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8041 (append l1 l2))) g8041))) + (memq + (lambda (e l) + (letrec ((g8042 + (letrec ((x8044 (list? l))) + (assert x8044))) + (g8043 + (letrec ((x-cnd8045 (null? l))) + (if x-cnd8045 + #f + (letrec ((x-cnd8046 + (letrec ((x8047 + (car l))) + (eq? x8047 e)))) + (if x-cnd8046 + l + (letrec ((x8048 (cdr l))) + (memq e x8048)))))))) + g8043))) + (cadaar + (lambda (x) + (letrec ((g8049 + (letrec ((x8050 + (letrec ((x8051 + (letrec ((x8052 + (car + x))) + (car + x8052)))) + (cdr x8051)))) + (car x8050)))) + g8049))) + (length + (lambda (l) + (letrec ((g8053 + (letrec ((x8055 (list? l))) + (assert x8055))) + (g8054 + (letrec ((rec + (lambda (l) + (letrec ((g8056 + (letrec ((x-cnd8057 + (null? + l))) + (if x-cnd8057 + 0 + (letrec ((x8058 + (letrec ((x8059 + (cdr + l))) + (rec + x8059)))) + (+ + 1 + x8058)))))) + g8056)))) + (letrec ((g8060 (rec l))) + g8060)))) + g8054))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8061 + (letrec ((x8064 (char? c1))) + (assert x8064))) + (g8062 + (letrec ((x8065 (char? c2))) + (assert x8065))) + (g8063 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8067 + (letrec ((x8068 (string<=? s1 s2))) + (not x8068)))) + g8067))) + (cdadr + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 + (letrec ((x8071 (cdr x))) + (car x8071)))) + (cdr x8070)))) + g8069))) + (assoc + (lambda (k l) + (letrec ((g8072 + (letrec ((x8074 (list? l))) + (assert x8074))) + (g8073 + (letrec ((x-cnd8075 (null? l))) + (if x-cnd8075 + #f + (letrec ((x-cnd8076 + (letrec ((x8077 + (caar l))) + (equal? x8077 k)))) + (if x-cnd8076 + (car l) + (letrec ((x8078 (cdr l))) + (assoc k x8078)))))))) + g8073))) + (caar + (lambda (x) + (letrec ((g8079 + (letrec ((x8080 (car x))) + (car x8080)))) + g8079))) + (char>? + (lambda (c1 c2) + (letrec ((g8081 + (letrec ((x8084 (char? c1))) + (assert x8084))) + (g8082 + (letrec ((x8085 (char? c2))) + (assert x8085))) + (g8083 + (letrec ((x8086 (char<=? c1 c2))) + (not x8086)))) + g8083))) + (string<=? + (lambda (s1 s2) + (letrec ((g8087 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8104 + (letrec ((x8107 (char? c1))) + (assert x8107))) + (g8105 + (letrec ((x8108 (char? c2))) + (assert x8108))) + (g8106 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8109 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8109)))) + g8106))) + (caddar + (lambda (x) + (letrec ((g8110 + (letrec ((x8111 + (letrec ((x8112 + (letrec ((x8113 + (car + x))) + (cdr + x8113)))) + (cdr x8112)))) + (car x8111)))) + g8110))) + (newline + (lambda () (letrec ((g8114 #f)) g8114))) + (lcm + (lambda (m n) + (letrec ((g8115 + (letrec ((x8117 + (letrec ((x8118 (* m n))) + (abs x8118))) + (x8116 (gcd m n))) + (/ x8117 x8116)))) + g8115))) + (deref car) + (> + (lambda (x y) + (letrec ((g8119 + (letrec ((x8121 (number? x))) + (assert x8121))) + (g8120 + (letrec ((x8122 (<= x y))) + (not x8122)))) + g8120))) + (list-ref + (lambda (l index) + (letrec ((g8123 + (letrec ((x8127 (list? l))) + (assert x8127))) + (g8124 + (letrec ((x8128 (number? index))) + (assert x8128))) + (g8125 + (letrec ((x8129 + (letrec ((x8130 + (length l))) + (< index x8130)))) + (assert x8129))) + (g8126 + (letrec ((x-cnd8131 (= index 0))) + (if x-cnd8131 + (car l) + (letrec ((x8133 (cdr l)) + (x8132 (- index 1))) + (list-ref x8133 x8132)))))) + g8126))) + (gcd + (lambda (a b) + (letrec ((g8134 + (letrec ((x-cnd8135 (= b 0))) + (if x-cnd8135 + a + (letrec ((x8136 (modulo a b))) + (gcd b x8136)))))) + g8134)))) + (letrec ((g8137 + (letrec ((g8138 + (letrec ((lock + (lambda (st) + (letrec ((g8139 1)) + g8139))) + (unlock + (lambda (st) + (letrec ((g8140 0)) + g8140))) + (f + (lambda (n st) + (letrec ((g8141 + (letrec ((x-cnd8142 + (> + n + 0))) + (if x-cnd8142 + (lock st) + st)))) + g8141))) + (g + (lambda (n st) + (letrec ((g8143 + (letrec ((x-cnd8144 + (> + n + 0))) + (if x-cnd8144 + (unlock + st) + st)))) + g8143))) + (main + (lambda (n) + (letrec ((g8145 + (letrec ((x8146 + (f + n + 0))) + (g + n + x8146)))) + g8145)))) + (letrec ((g8147 + (letrec ((g8148 + (letrec ((g8149 + (letrec ((x8151 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + ((lambda (g7236 + g7237 + g7238) + (if ((lambda (v7235) + (eq? + 0 + v7235)) + g7238) + g7238 + (blame + g7236 + '(lambda (v7235) + (eq? + 0 + v7235))))) + j7230 + k7231 + (f7232 + (integer?/c + j7230 + k7231 + g7229))))) + 'module + 'importer + main)) + (x8150 + (input))) + (x8151 + x8150)))) + g8149))) + g8148))) + g8147)))) + g8138))) + g8137)))) + g7250))) + g7249)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_reverse.rkt b/analyses/simpleactor/benchmarks-out/mochi_reverse.rkt index 678e61d4..4eec6410 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_reverse.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_reverse.rkt @@ -1,26 +1,3118 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (main len) - (let ((xs (mk-list len))) - (if (not (= len 0)) (car (reverse xs empty)) 0))) - (define (reverse l ac) - (if (empty? l) ac (reverse (cdr l) (cons (car l) ac)))) - (define (mk-list n) (if (= n 0) empty (cons n (mk-list (- n 1))))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - (integer? j3984 k3985 (f3986 (integer? j3984 k3985 g3983))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((main + (lambda (len) + (letrec ((g8133 + (letrec ((xs + (mk-list + len))) + (letrec ((g8134 + (letrec ((x-cnd8135 + (letrec ((x8136 + (= + len + 0))) + (not + x8136)))) + (if x-cnd8135 + (letrec ((x8137 + (reverse + xs + empty))) + (car + x8137)) + 0)))) + g8134)))) + g8133))) + (reverse + (lambda (l ac) + (letrec ((g8138 + (letrec ((x-cnd8139 + (empty? + l))) + (if x-cnd8139 + ac + (letrec ((x8142 + (cdr + l)) + (x8140 + (letrec ((x8141 + (car + l))) + (cons + x8141 + ac)))) + (reverse + x8142 + x8140)))))) + g8138))) + (mk-list + (lambda (n) + (letrec ((g8143 + (letrec ((x-cnd8144 + (= + n + 0))) + (if x-cnd8144 + empty + (letrec ((x8145 + (letrec ((x8146 + (- + n + 1))) + (mk-list + x8146)))) + (cons + n + x8145)))))) + g8143)))) + (letrec ((g8147 + (letrec ((g8148 + (letrec ((g8149 + (letrec ((x8151 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + (integer?/c + j7230 + k7231 + (f7232 + (integer?/c + j7230 + k7231 + g7229))))) + 'module + 'importer + main)) + (x8150 + (input))) + (x8151 + x8150)))) + g8149))) + g8148))) + g8147)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_sum.rkt b/analyses/simpleactor/benchmarks-out/mochi_sum.rkt index 243d47c6..3844c500 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_sum.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_sum.rkt @@ -1,18 +1,3074 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7234 #t)) g7234))) + (meta (lambda (v) (letrec ((g7235 v)) g7235))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7236 + (letrec ((g7237 + (letrec ((x-e7238 lst)) + (match + x-e7238 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7239 (eq? v v1))) + (if x-cnd7239 #t (member v vs))))))))) + g7237))) + g7236))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (sum n) (if (<= n 0) 0 (+ n (sum (- n 1))))) - (begin - (((->d integer? (lambda (n) (and/c integer? (>=/c n)))) - 'module - 'importer - sum))))) + (actor? + (lambda (k j) + (letrec ((g7240 (lambda (v) (letrec ((g7241 v)) g7241)))) g7240))) + (nonzero? + (lambda (v) + (letrec ((g7242 (letrec ((x7243 (= v 0))) (not x7243)))) g7242)))) + (letrec ((g7244 + (letrec ((g7245 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7246 + (letrec ((x-cnd7247 (real? g7162))) + (if x-cnd7247 + g7162 + (blame g7160 'real?))))) + g7246))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7248 + (letrec ((x-cnd7249 + (boolean? g7165))) + (if x-cnd7249 + g7165 + (blame g7163 'boolean?))))) + g7248))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7250 + (letrec ((x-cnd7251 + (number? g7168))) + (if x-cnd7251 + g7168 + (blame g7166 'number?))))) + g7250))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7252 + (letrec ((x-cnd7253 + ((lambda (v) #t) g7171))) + (if x-cnd7253 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7252))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7254 + (letrec ((x-cnd7255 + ((lambda (v) #t) g7174))) + (if x-cnd7255 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7254))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7256 + (letrec ((x-cnd7257 (pair? g7177))) + (if x-cnd7257 + g7177 + (blame g7175 'pair?))))) + g7256))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7258 + (letrec ((x-cnd7259 (pair? g7180))) + (if x-cnd7259 + g7180 + (blame g7178 'pair?))))) + g7258))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7260 + (letrec ((x-cnd7261 + (integer? g7183))) + (if x-cnd7261 + g7183 + (blame g7181 'integer?))))) + g7260))) + (and/c + (lambda (c1 c2) + (letrec ((g7262 + (lambda (k j v) + (letrec ((g7263 + (letrec ((x-cnd7264 + (c1 k j v))) + (if x-cnd7264 + (c2 k j v) + #f)))) + g7263)))) + g7262))) + (list-of + (lambda (contract) + (letrec ((g7265 + (lambda (k j v) + (letrec ((g7266 + (letrec ((x-cnd7267 + (null? v))) + (if x-cnd7267 + '() + (letrec ((x7271 + (letrec ((x7272 + (car + v))) + (contract + k + j + x7272))) + (x7268 + (letrec ((x7270 + (list-of + contract)) + (x7269 + (cdr + v))) + (x7270 + k + j + x7269)))) + (cons + x7271 + x7268)))))) + g7266)))) + g7265))) + (any? (lambda (v) (letrec ((g7273 #t)) g7273))) + (nonzero? + (lambda (v) + (letrec ((g7274 + (letrec ((x7275 (= v 0))) + (not x7275)))) + g7274))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7276 + (letrec ((x-cnd7277 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7277 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7276))) + (meta (lambda (v) (letrec ((g7278 v)) g7278))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7279 #t)) g7279))) + (cdddr + (lambda (x) + (letrec ((g7280 + (letrec ((x7281 + (letrec ((x7282 (cdr x))) + (cdr x7282)))) + (cdr x7281)))) + g7280))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7283 + (letrec ((x7286 (procedure? f))) + (assert x7286))) + (g7284 + (letrec ((x7287 (list? l))) + (assert x7287))) + (g7285 + (letrec ((x-cnd7288 (null? l))) + (if x-cnd7288 + '() + (letrec ((x7291 + (letrec ((x7292 + (car l))) + (f x7292))) + (x7289 + (letrec ((x7290 + (cdr l))) + (map f x7290)))) + (cons x7291 x7289)))))) + g7285))) + (cdar + (lambda (x) + (letrec ((g7293 + (letrec ((x7294 (car x))) + (cdr x7294)))) + g7293))) + (cadadr + (lambda (x) + (letrec ((g7295 + (letrec ((x7296 + (letrec ((x7297 + (letrec ((x7298 + (cdr + x))) + (car + x7298)))) + (cdr x7297)))) + (car x7296)))) + g7295))) + (cdadar + (lambda (x) + (letrec ((g7299 + (letrec ((x7300 + (letrec ((x7301 + (letrec ((x7302 + (car + x))) + (cdr + x7302)))) + (car x7301)))) + (cdr x7300)))) + g7299))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7303 + (letrec ((x7306 + (string? filename))) + (assert x7306))) + (g7304 + (letrec ((x7307 (procedure? proc))) + (assert x7307))) + (g7305 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7308 + (close-output-port + output-port)) + (g7309 res)) + g7309)))) + g7305))) + (caddr + (lambda (x) + (letrec ((g7310 + (letrec ((x7311 + (letrec ((x7312 (cdr x))) + (cdr x7312)))) + (car x7311)))) + g7310))) + (cdaadr + (lambda (x) + (letrec ((g7313 + (letrec ((x7314 + (letrec ((x7315 + (letrec ((x7316 + (cdr + x))) + (car + x7316)))) + (car x7315)))) + (cdr x7314)))) + g7313))) + (assq + (lambda (k l) + (letrec ((g7317 + (letrec ((x7319 (list? l))) + (assert x7319))) + (g7318 + (letrec ((x-cnd7320 (null? l))) + (if x-cnd7320 + #f + (letrec ((x-cnd7321 + (letrec ((x7322 + (caar l))) + (eq? x7322 k)))) + (if x-cnd7321 + (car l) + (letrec ((x7323 (cdr l))) + (assq k x7323)))))))) + g7318))) + (even? + (lambda (x) + (letrec ((g7324 + (letrec ((x7325 (modulo x 2))) + (= 0 x7325)))) + g7324))) + (list->string + (lambda (l) + (letrec ((g7326 + (letrec ((x7328 (list? l))) + (assert x7328))) + (g7327 + (letrec ((x-cnd7329 (null? l))) + (if x-cnd7329 + "" + (letrec ((x7332 + (letrec ((x7333 + (car l))) + (char->string + x7333))) + (x7330 + (letrec ((x7331 + (cdr l))) + (list->string + x7331)))) + (string-append + x7332 + x7330)))))) + g7327))) + (char<=? + (lambda (c1 c2) + (letrec ((g7334 + (letrec ((x7337 (char? c1))) + (assert x7337))) + (g7335 + (letrec ((x7338 (char? c2))) + (assert x7338))) + (g7336 + (letrec ((val7143 (char=? c x7355)))) + (if x-cnd7354 + (letrec ((x7356 #\z)) + (char-ci<=? c x7356)) + #f)))) + g7353))) + (<= + (lambda (x y) + (letrec ((g7357 + (letrec ((x7359 (number? x))) + (assert x7359))) + (g7358 + (letrec ((val7144 (< x y))) + (letrec ((g7360 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7361 + (if val7145 + val7145 + #f))) + g7361))))) + g7360)))) + g7358))) + (char-whitespace? + (lambda (c) + (letrec ((g7362 + (letrec ((val7146 + (letrec ((x7363 + (char->integer + c))) + (= x7363 9)))) + (letrec ((g7364 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7365 + (char->integer + c))) + (= + x7365 + 10)))) + (letrec ((g7366 + (if val7147 + val7147 + (letrec ((x7367 + (char->integer + c))) + (= + x7367 + 32))))) + g7366))))) + g7364)))) + g7362))) + (cddar + (lambda (x) + (letrec ((g7368 + (letrec ((x7369 + (letrec ((x7370 (car x))) + (cdr x7370)))) + (cdr x7369)))) + g7368))) + (positive? + (lambda (x) + (letrec ((g7371 + (letrec ((x7373 (number? x))) + (assert x7373))) + (g7372 (> x 0))) + g7372))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7374 #f)) g7374))) + (cddr + (lambda (x) + (letrec ((g7375 + (letrec ((x7376 (cdr x))) + (cdr x7376)))) + g7375))) + (truncate + (lambda (x) + (letrec ((g7377 + (letrec ((x7379 (number? x))) + (assert x7379))) + (g7378 + (letrec ((x-cnd7380 (< x 0))) + (if x-cnd7380 + (ceiling x) + (floor x))))) + g7378))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7381 + (letrec ((val7148 (eq? a b))) + (letrec ((g7382 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7384 + (null? + a)) + (x7383 + (null? + b))) + (and x7384 + x7383)))) + (letrec ((g7385 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7388 + (string? + a)) + (x7387 + (string? + b)) + (x7386 + (string=? + a + b))) + (and x7388 + x7387 + x7386)))) + (letrec ((g7389 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7397 + (pair? + a)) + (x7396 + (pair? + b)) + (x7393 + (letrec ((x7395 + (car + a)) + (x7394 + (car + b))) + (equal? + x7395 + x7394))) + (x7390 + (letrec ((x7392 + (cdr + a)) + (x7391 + (cdr + b))) + (equal? + x7392 + x7391)))) + (and x7397 + x7396 + x7393 + x7390)))) + (letrec ((g7398 + (if val7151 + val7151 + (letrec ((x7417 + (vector? + a)) + (x7416 + (vector? + b)) + (x7399 + (letrec ((x7413 + (letrec ((x7414 + (letrec ((x7415 + (vector-length + a))) + (n + x7415)))) + (x7414))) + (x7400 + (letrec ((x7411 + (letrec ((x7412 + (vector-length + b))) + (= + x7412 + n))) + (x7401 + (letrec ((loop + (lambda (i) + (letrec ((g7402 + (letrec ((x7409 + (= + i + n)) + (x7403 + (letrec ((x7406 + (letrec ((x7408 + (vector-ref + a + i)) + (x7407 + (vector-ref + b + i))) + (equal? + x7408 + x7407))) + (x7404 + (letrec ((x7405 + (+ + i + 1))) + (loop + x7405)))) + (and x7406 + x7404)))) + (or x7409 + x7403)))) + g7402)))) + (letrec ((g7410 + (loop + 0))) + g7410)))) + (and x7411 + x7401)))) + (let x7413 x7400)))) + (and x7417 + x7416 + x7399))))) + g7398))))) + g7389))))) + g7385))))) + g7382)))) + g7381))) + (cdaaar + (lambda (x) + (letrec ((g7418 + (letrec ((x7419 + (letrec ((x7420 + (letrec ((x7421 + (car + x))) + (car + x7421)))) + (car x7420)))) + (cdr x7419)))) + g7418))) + (caaddr + (lambda (x) + (letrec ((g7422 + (letrec ((x7423 + (letrec ((x7424 + (letrec ((x7425 + (cdr + x))) + (cdr + x7425)))) + (car x7424)))) + (car x7423)))) + g7422))) + (eqv? + (lambda (x y) + (letrec ((g7426 (eq? x y))) g7426))) + (>= + (lambda (x y) + (letrec ((g7427 + (letrec ((x7429 (number? x))) + (assert x7429))) + (g7428 + (letrec ((val7152 (> x y))) + (letrec ((g7430 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7431 + (if val7153 + val7153 + #f))) + g7431))))) + g7430)))) + g7428))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7432 + (letrec ((x7435 + (string? filename))) + (assert x7435))) + (g7433 + (letrec ((x7436 (procedure? proc))) + (assert x7436))) + (g7434 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7437 + (close-input-port + input-port)) + (g7438 res)) + g7438)))) + g7434))) + (ref + (lambda (x) + (letrec ((g7439 (cons x '()))) g7439))) + (char>=? + (lambda (c1 c2) + (letrec ((g7440 + (letrec ((x7443 (char? c1))) + (assert x7443))) + (g7441 + (letrec ((x7444 (char? c2))) + (assert x7444))) + (g7442 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7445 + (if val7154 + val7154 + (char=? c1 c2)))) + g7445)))) + g7442))) + (cdaar + (lambda (x) + (letrec ((g7446 + (letrec ((x7447 + (letrec ((x7448 (car x))) + (car x7448)))) + (cdr x7447)))) + g7446))) + (cdaddr + (lambda (x) + (letrec ((g7449 + (letrec ((x7450 + (letrec ((x7451 + (letrec ((x7452 + (cdr + x))) + (cdr + x7452)))) + (car x7451)))) + (cdr x7450)))) + g7449))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7453 + (letrec ((x7454 + (letrec ((x7455 (car x))) + (cdr x7455)))) + (car x7454)))) + g7453))) + (caadr + (lambda (x) + (letrec ((g7456 + (letrec ((x7457 + (letrec ((x7458 (cdr x))) + (car x7458)))) + (car x7457)))) + g7456))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7459 + (letrec ((x7462 (char? c1))) + (assert x7462))) + (g7460 + (letrec ((x7463 (char? c2))) + (assert x7463))) + (g7461 + (letrec ((x7464 + (char-ci<=? c1 c2))) + (not x7464)))) + g7461))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7465 + (letrec ((x7466 + (letrec ((x7467 + (letrec ((x7468 + (car + x))) + (car + x7468)))) + (car x7467)))) + (car x7466)))) + g7465))) + (negative? + (lambda (x) + (letrec ((g7469 + (letrec ((x7471 (number? x))) + (assert x7471))) + (g7470 (< x 0))) + g7470))) + (memv + (lambda (e l) + (letrec ((g7472 (memq e l))) g7472))) + (caaar + (lambda (x) + (letrec ((g7473 + (letrec ((x7474 + (letrec ((x7475 (car x))) + (car x7475)))) + (car x7474)))) + g7473))) + (debug + (lambda (e) (letrec ((g7476 '())) g7476))) + (reverse + (lambda (l) + (letrec ((g7477 + (letrec ((x7479 (list? l))) + (assert x7479))) + (g7478 + (letrec ((x-cnd7480 (null? l))) + (if x-cnd7480 + '() + (letrec ((x7483 + (letrec ((x7484 + (cdr l))) + (reverse x7484))) + (x7481 + (letrec ((x7482 + (car l))) + (list x7482)))) + (append x7483 x7481)))))) + g7478))) + (caaadr + (lambda (x) + (letrec ((g7485 + (letrec ((x7486 + (letrec ((x7487 + (letrec ((x7488 + (cdr + x))) + (car + x7488)))) + (car x7487)))) + (car x7486)))) + g7485))) + (cddadr + (lambda (x) + (letrec ((g7489 + (letrec ((x7490 + (letrec ((x7491 + (letrec ((x7492 + (cdr + x))) + (car + x7492)))) + (cdr x7491)))) + (cdr x7490)))) + g7489))) + (odd? + (lambda (x) + (letrec ((g7493 + (letrec ((x7495 (number? x))) + (assert x7495))) + (g7494 + (letrec ((x7496 (modulo x 2))) + (= 1 x7496)))) + g7494))) + (caadar + (lambda (x) + (letrec ((g7497 + (letrec ((x7498 + (letrec ((x7499 + (letrec ((x7500 + (car + x))) + (cdr + x7500)))) + (car x7499)))) + (car x7498)))) + g7497))) + (apply + (lambda (proc args) + (letrec ((g7501 + (letrec ((x7504 (procedure? proc))) + (assert x7504))) + (g7502 + (letrec ((x7505 (list? args))) + (assert x7505))) + (g7503 + (if cnd + (letrec ((g7506 (proc))) g7506) + (if cnd + (letrec ((g7507 + (letrec ((x7508 + (car + args))) + (proc x7508)))) + g7507) + (if cnd + (letrec ((g7509 + (letrec ((x7511 + (car + args)) + (x7510 + (cadr + args))) + (proc + x7511 + x7510)))) + g7509) + (if cnd + (letrec ((g7512 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args))) + (proc + x7515 + x7514 + x7513)))) + g7512) + (if cnd + (letrec ((g7516 + (letrec ((x7520 + (car + args)) + (x7519 + (cadr + args)) + (x7518 + (caddr + args)) + (x7517 + (cadddr + args))) + (proc + x7520 + x7519 + x7518 + x7517)))) + g7516) + (if cnd + (letrec ((g7521 + (letrec ((x7527 + (car + args)) + (x7526 + (cadr + args)) + (x7525 + (caddr + args)) + (x7524 + (cadddr + args)) + (x7522 + (letrec ((x7523 + (cddddr + args))) + (car + x7523)))) + (proc + x7527 + x7526 + x7525 + x7524 + x7522)))) + g7521) + (if cnd + (letrec ((g7528 + (letrec ((x7536 + (car + args)) + (x7535 + (cadr + args)) + (x7534 + (caddr + args)) + (x7533 + (cadddr + args)) + (x7531 + (letrec ((x7532 + (cddddr + args))) + (car + x7532))) + (x7529 + (letrec ((x7530 + (cddddr + args))) + (cadr + x7530)))) + (proc + x7536 + x7535 + x7534 + x7533 + x7531 + x7529)))) + g7528) + (if cnd + (letrec ((g7537 + (letrec ((x7547 + (car + args)) + (x7546 + (cadr + args)) + (x7545 + (caddr + args)) + (x7544 + (cadddr + args)) + (x7542 + (letrec ((x7543 + (cddddr + args))) + (car + x7543))) + (x7540 + (letrec ((x7541 + (cddddr + args))) + (cadr + x7541))) + (x7538 + (letrec ((x7539 + (cddddr + args))) + (caddr + x7539)))) + (proc + x7547 + x7546 + x7545 + x7544 + x7542 + x7540 + x7538)))) + g7537) + (letrec ((g7548 + (error + "Unsupported call."))) + g7548))))))))))) + g7503))) + (member + (lambda (e l) + (letrec ((g7549 + (letrec ((x7551 (list? l))) + (assert x7551))) + (g7550 + (letrec ((x-cnd7552 (null? l))) + (if x-cnd7552 + #f + (letrec ((x-cnd7553 + (letrec ((x7554 + (car l))) + (equal? x7554 e)))) + (if x-cnd7553 + l + (letrec ((x7555 (cdr l))) + (member e x7555)))))))) + g7550))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7556 + (letrec ((x7557 + (letrec ((x7558 + (letrec ((x7559 + (cdr + x))) + (cdr + x7559)))) + (cdr x7558)))) + (cdr x7557)))) + g7556))) + (cadddr + (lambda (x) + (letrec ((g7560 + (letrec ((x7561 + (letrec ((x7562 + (letrec ((x7563 + (cdr + x))) + (cdr + x7563)))) + (cdr x7562)))) + (car x7561)))) + g7560))) + (int-top + (lambda () + (letrec ((g7564 (random 42))) g7564))) + (zero? + (lambda (x) + (letrec ((g7565 + (letrec ((x7567 (number? x))) + (assert x7567))) + (g7566 (= x 0))) + g7566))) + (string>=? + (lambda (s1 s2) + (letrec ((g7568 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7569 + (if val7155 + val7155 + (string=? s1 s2)))) + g7569)))) + g7568))) + (cadr + (lambda (x) + (letrec ((g7570 + (letrec ((x7571 (cdr x))) + (car x7571)))) + g7570))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7572 + (letrec ((val7156 + (letrec ((x7575 + (pair? l)) + (x7573 + (letrec ((x7574 + (cdr + l))) + (list? + x7574)))) + (and x7575 x7573)))) + (letrec ((g7576 + (if val7156 + val7156 + (null? l)))) + g7576)))) + g7572))) + (cddaar + (lambda (x) + (letrec ((g7577 + (letrec ((x7578 + (letrec ((x7579 + (letrec ((x7580 + (car + x))) + (car + x7580)))) + (cdr x7579)))) + (cdr x7578)))) + g7577))) + (char-numeric? + (lambda (c) + (letrec ((g7581 + (letrec ((x-cnd7582 + (letrec ((x7583 #\0)) + (char<=? x7583 c)))) + (if x-cnd7582 + (letrec ((x7584 #\9)) + (char<=? c x7584)) + #f)))) + g7581))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7585 + (letrec ((x7587 (list? l))) + (assert x7587))) + (g7586 + (letrec ((x-cnd7588 (null? l))) + (if x-cnd7588 + #f + (letrec ((x-cnd7589 + (letrec ((x7590 + (caar l))) + (eqv? x7590 k)))) + (if x-cnd7589 + (car l) + (letrec ((x7591 (cdr l))) + (assq k x7591)))))))) + g7586))) + (not + (lambda (x) + (letrec ((g7592 (if x #f #t))) g7592))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7593 (append l1 l2))) g7593))) + (memq + (lambda (e l) + (letrec ((g7594 + (letrec ((x7596 (list? l))) + (assert x7596))) + (g7595 + (letrec ((x-cnd7597 (null? l))) + (if x-cnd7597 + #f + (letrec ((x-cnd7598 + (letrec ((x7599 + (car l))) + (eq? x7599 e)))) + (if x-cnd7598 + l + (letrec ((x7600 (cdr l))) + (memq e x7600)))))))) + g7595))) + (cadaar + (lambda (x) + (letrec ((g7601 + (letrec ((x7602 + (letrec ((x7603 + (letrec ((x7604 + (car + x))) + (car + x7604)))) + (cdr x7603)))) + (car x7602)))) + g7601))) + (length + (lambda (l) + (letrec ((g7605 + (letrec ((x7607 (list? l))) + (assert x7607))) + (g7606 + (letrec ((rec + (lambda (l) + (letrec ((g7608 + (letrec ((x-cnd7609 + (null? + l))) + (if x-cnd7609 + 0 + (letrec ((x7610 + (letrec ((x7611 + (cdr + l))) + (rec + x7611)))) + (+ + 1 + x7610)))))) + g7608)))) + (letrec ((g7612 (rec l))) + g7612)))) + g7606))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7613 + (letrec ((x7616 (char? c1))) + (assert x7616))) + (g7614 + (letrec ((x7617 (char? c2))) + (assert x7617))) + (g7615 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7619 + (letrec ((x7620 (string<=? s1 s2))) + (not x7620)))) + g7619))) + (cdadr + (lambda (x) + (letrec ((g7621 + (letrec ((x7622 + (letrec ((x7623 (cdr x))) + (car x7623)))) + (cdr x7622)))) + g7621))) + (assoc + (lambda (k l) + (letrec ((g7624 + (letrec ((x7626 (list? l))) + (assert x7626))) + (g7625 + (letrec ((x-cnd7627 (null? l))) + (if x-cnd7627 + #f + (letrec ((x-cnd7628 + (letrec ((x7629 + (caar l))) + (equal? x7629 k)))) + (if x-cnd7628 + (car l) + (letrec ((x7630 (cdr l))) + (assoc k x7630)))))))) + g7625))) + (caar + (lambda (x) + (letrec ((g7631 + (letrec ((x7632 (car x))) + (car x7632)))) + g7631))) + (char>? + (lambda (c1 c2) + (letrec ((g7633 + (letrec ((x7636 (char? c1))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char? c2))) + (assert x7637))) + (g7635 + (letrec ((x7638 (char<=? c1 c2))) + (not x7638)))) + g7635))) + (string<=? + (lambda (s1 s2) + (letrec ((g7639 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7656 + (letrec ((x7659 (char? c1))) + (assert x7659))) + (g7657 + (letrec ((x7660 (char? c2))) + (assert x7660))) + (g7658 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7661 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7661)))) + g7658))) + (caddar + (lambda (x) + (letrec ((g7662 + (letrec ((x7663 + (letrec ((x7664 + (letrec ((x7665 + (car + x))) + (cdr + x7665)))) + (cdr x7664)))) + (car x7663)))) + g7662))) + (newline + (lambda () (letrec ((g7666 #f)) g7666))) + (lcm + (lambda (m n) + (letrec ((g7667 + (letrec ((x7669 + (letrec ((x7670 (* m n))) + (abs x7670))) + (x7668 (gcd m n))) + (/ x7669 x7668)))) + g7667))) + (deref car) + (> + (lambda (x y) + (letrec ((g7671 + (letrec ((x7673 (number? x))) + (assert x7673))) + (g7672 + (letrec ((x7674 (<= x y))) + (not x7674)))) + g7672))) + (list-ref + (lambda (l index) + (letrec ((g7675 + (letrec ((x7679 (list? l))) + (assert x7679))) + (g7676 + (letrec ((x7680 (number? index))) + (assert x7680))) + (g7677 + (letrec ((x7681 + (letrec ((x7682 + (length l))) + (< index x7682)))) + (assert x7681))) + (g7678 + (letrec ((x-cnd7683 (= index 0))) + (if x-cnd7683 + (car l) + (letrec ((x7685 (cdr l)) + (x7684 (- index 1))) + (list-ref x7685 x7684)))))) + g7678))) + (gcd + (lambda (a b) + (letrec ((g7686 + (letrec ((x-cnd7687 (= b 0))) + (if x-cnd7687 + a + (letrec ((x7688 (modulo a b))) + (gcd b x7688)))))) + g7686))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7689 + (letrec ((x-cnd7690 (real? g7162))) + (if x-cnd7690 + g7162 + (blame g7160 'real?))))) + g7689))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7691 + (letrec ((x-cnd7692 + (boolean? g7165))) + (if x-cnd7692 + g7165 + (blame g7163 'boolean?))))) + g7691))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7693 + (letrec ((x-cnd7694 + (number? g7168))) + (if x-cnd7694 + g7168 + (blame g7166 'number?))))) + g7693))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7695 + (letrec ((x-cnd7696 + ((lambda (v) #t) g7171))) + (if x-cnd7696 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7695))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7697 + (letrec ((x-cnd7698 + ((lambda (v) #t) g7174))) + (if x-cnd7698 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7697))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7699 + (letrec ((x-cnd7700 (pair? g7177))) + (if x-cnd7700 + g7177 + (blame g7175 'pair?))))) + g7699))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7701 + (letrec ((x-cnd7702 (pair? g7180))) + (if x-cnd7702 + g7180 + (blame g7178 'pair?))))) + g7701))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7703 + (letrec ((x-cnd7704 + (integer? g7183))) + (if x-cnd7704 + g7183 + (blame g7181 'integer?))))) + g7703))) + (and/c + (lambda (c1 c2) + (letrec ((g7705 + (lambda (k j v) + (letrec ((g7706 + (letrec ((x-cnd7707 + (c1 k j v))) + (if x-cnd7707 + (c2 k j v) + #f)))) + g7706)))) + g7705))) + (list-of + (lambda (contract) + (letrec ((g7708 + (lambda (k j v) + (letrec ((g7709 + (letrec ((x-cnd7710 + (null? v))) + (if x-cnd7710 + '() + (letrec ((x7714 + (letrec ((x7715 + (car + v))) + (contract + k + j + x7715))) + (x7711 + (letrec ((x7713 + (list-of + contract)) + (x7712 + (cdr + v))) + (x7713 + k + j + x7712)))) + (cons + x7714 + x7711)))))) + g7709)))) + g7708))) + (any? (lambda (v) (letrec ((g7716 #t)) g7716))) + (nonzero? + (lambda (v) + (letrec ((g7717 + (letrec ((x7718 (= v 0))) + (not x7718)))) + g7717))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7719 + (letrec ((x-cnd7720 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7720 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7719))) + (meta (lambda (v) (letrec ((g7721 v)) g7721))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7722 #t)) g7722))) + (cdddr + (lambda (x) + (letrec ((g7723 + (letrec ((x7724 + (letrec ((x7725 (cdr x))) + (cdr x7725)))) + (cdr x7724)))) + g7723))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7726 + (letrec ((x7729 (procedure? f))) + (assert x7729))) + (g7727 + (letrec ((x7730 (list? l))) + (assert x7730))) + (g7728 + (letrec ((x-cnd7731 (null? l))) + (if x-cnd7731 + '() + (letrec ((x7734 + (letrec ((x7735 + (car l))) + (f x7735))) + (x7732 + (letrec ((x7733 + (cdr l))) + (map f x7733)))) + (cons x7734 x7732)))))) + g7728))) + (cdar + (lambda (x) + (letrec ((g7736 + (letrec ((x7737 (car x))) + (cdr x7737)))) + g7736))) + (cadadr + (lambda (x) + (letrec ((g7738 + (letrec ((x7739 + (letrec ((x7740 + (letrec ((x7741 + (cdr + x))) + (car + x7741)))) + (cdr x7740)))) + (car x7739)))) + g7738))) + (cdadar + (lambda (x) + (letrec ((g7742 + (letrec ((x7743 + (letrec ((x7744 + (letrec ((x7745 + (car + x))) + (cdr + x7745)))) + (car x7744)))) + (cdr x7743)))) + g7742))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7746 + (letrec ((x7749 + (string? filename))) + (assert x7749))) + (g7747 + (letrec ((x7750 (procedure? proc))) + (assert x7750))) + (g7748 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7751 + (close-output-port + output-port)) + (g7752 res)) + g7752)))) + g7748))) + (caddr + (lambda (x) + (letrec ((g7753 + (letrec ((x7754 + (letrec ((x7755 (cdr x))) + (cdr x7755)))) + (car x7754)))) + g7753))) + (cdaadr + (lambda (x) + (letrec ((g7756 + (letrec ((x7757 + (letrec ((x7758 + (letrec ((x7759 + (cdr + x))) + (car + x7759)))) + (car x7758)))) + (cdr x7757)))) + g7756))) + (assq + (lambda (k l) + (letrec ((g7760 + (letrec ((x7762 (list? l))) + (assert x7762))) + (g7761 + (letrec ((x-cnd7763 (null? l))) + (if x-cnd7763 + #f + (letrec ((x-cnd7764 + (letrec ((x7765 + (caar l))) + (eq? x7765 k)))) + (if x-cnd7764 + (car l) + (letrec ((x7766 (cdr l))) + (assq k x7766)))))))) + g7761))) + (even? + (lambda (x) + (letrec ((g7767 + (letrec ((x7768 (modulo x 2))) + (= 0 x7768)))) + g7767))) + (list->string + (lambda (l) + (letrec ((g7769 + (letrec ((x7771 (list? l))) + (assert x7771))) + (g7770 + (letrec ((x-cnd7772 (null? l))) + (if x-cnd7772 + "" + (letrec ((x7775 + (letrec ((x7776 + (car l))) + (char->string + x7776))) + (x7773 + (letrec ((x7774 + (cdr l))) + (list->string + x7774)))) + (string-append + x7775 + x7773)))))) + g7770))) + (char<=? + (lambda (c1 c2) + (letrec ((g7777 + (letrec ((x7780 (char? c1))) + (assert x7780))) + (g7778 + (letrec ((x7781 (char? c2))) + (assert x7781))) + (g7779 + (letrec ((val7143 (char=? c x7798)))) + (if x-cnd7797 + (letrec ((x7799 #\z)) + (char-ci<=? c x7799)) + #f)))) + g7796))) + (<= + (lambda (x y) + (letrec ((g7800 + (letrec ((x7802 (number? x))) + (assert x7802))) + (g7801 + (letrec ((val7144 (< x y))) + (letrec ((g7803 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7804 + (if val7145 + val7145 + #f))) + g7804))))) + g7803)))) + g7801))) + (char-whitespace? + (lambda (c) + (letrec ((g7805 + (letrec ((val7146 + (letrec ((x7806 + (char->integer + c))) + (= x7806 9)))) + (letrec ((g7807 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7808 + (char->integer + c))) + (= + x7808 + 10)))) + (letrec ((g7809 + (if val7147 + val7147 + (letrec ((x7810 + (char->integer + c))) + (= + x7810 + 32))))) + g7809))))) + g7807)))) + g7805))) + (cddar + (lambda (x) + (letrec ((g7811 + (letrec ((x7812 + (letrec ((x7813 (car x))) + (cdr x7813)))) + (cdr x7812)))) + g7811))) + (positive? + (lambda (x) + (letrec ((g7814 + (letrec ((x7816 (number? x))) + (assert x7816))) + (g7815 (> x 0))) + g7815))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7817 #f)) g7817))) + (cddr + (lambda (x) + (letrec ((g7818 + (letrec ((x7819 (cdr x))) + (cdr x7819)))) + g7818))) + (truncate + (lambda (x) + (letrec ((g7820 + (letrec ((x7822 (number? x))) + (assert x7822))) + (g7821 + (letrec ((x-cnd7823 (< x 0))) + (if x-cnd7823 + (ceiling x) + (floor x))))) + g7821))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7824 + (letrec ((val7148 (eq? a b))) + (letrec ((g7825 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7827 + (null? + a)) + (x7826 + (null? + b))) + (and x7827 + x7826)))) + (letrec ((g7828 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7831 + (string? + a)) + (x7830 + (string? + b)) + (x7829 + (string=? + a + b))) + (and x7831 + x7830 + x7829)))) + (letrec ((g7832 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7840 + (pair? + a)) + (x7839 + (pair? + b)) + (x7836 + (letrec ((x7838 + (car + a)) + (x7837 + (car + b))) + (equal? + x7838 + x7837))) + (x7833 + (letrec ((x7835 + (cdr + a)) + (x7834 + (cdr + b))) + (equal? + x7835 + x7834)))) + (and x7840 + x7839 + x7836 + x7833)))) + (letrec ((g7841 + (if val7151 + val7151 + (letrec ((x7860 + (vector? + a)) + (x7859 + (vector? + b)) + (x7842 + (letrec ((x7856 + (letrec ((x7857 + (letrec ((x7858 + (vector-length + a))) + (n + x7858)))) + (x7857))) + (x7843 + (letrec ((x7854 + (letrec ((x7855 + (vector-length + b))) + (= + x7855 + n))) + (x7844 + (letrec ((loop + (lambda (i) + (letrec ((g7845 + (letrec ((x7852 + (= + i + n)) + (x7846 + (letrec ((x7849 + (letrec ((x7851 + (vector-ref + a + i)) + (x7850 + (vector-ref + b + i))) + (equal? + x7851 + x7850))) + (x7847 + (letrec ((x7848 + (+ + i + 1))) + (loop + x7848)))) + (and x7849 + x7847)))) + (or x7852 + x7846)))) + g7845)))) + (letrec ((g7853 + (loop + 0))) + g7853)))) + (and x7854 + x7844)))) + (let x7856 x7843)))) + (and x7860 + x7859 + x7842))))) + g7841))))) + g7832))))) + g7828))))) + g7825)))) + g7824))) + (cdaaar + (lambda (x) + (letrec ((g7861 + (letrec ((x7862 + (letrec ((x7863 + (letrec ((x7864 + (car + x))) + (car + x7864)))) + (car x7863)))) + (cdr x7862)))) + g7861))) + (caaddr + (lambda (x) + (letrec ((g7865 + (letrec ((x7866 + (letrec ((x7867 + (letrec ((x7868 + (cdr + x))) + (cdr + x7868)))) + (car x7867)))) + (car x7866)))) + g7865))) + (eqv? + (lambda (x y) + (letrec ((g7869 (eq? x y))) g7869))) + (>= + (lambda (x y) + (letrec ((g7870 + (letrec ((x7872 (number? x))) + (assert x7872))) + (g7871 + (letrec ((val7152 (> x y))) + (letrec ((g7873 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7874 + (if val7153 + val7153 + #f))) + g7874))))) + g7873)))) + g7871))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7875 + (letrec ((x7878 + (string? filename))) + (assert x7878))) + (g7876 + (letrec ((x7879 (procedure? proc))) + (assert x7879))) + (g7877 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7880 + (close-input-port + input-port)) + (g7881 res)) + g7881)))) + g7877))) + (ref + (lambda (x) + (letrec ((g7882 (cons x '()))) g7882))) + (char>=? + (lambda (c1 c2) + (letrec ((g7883 + (letrec ((x7886 (char? c1))) + (assert x7886))) + (g7884 + (letrec ((x7887 (char? c2))) + (assert x7887))) + (g7885 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7888 + (if val7154 + val7154 + (char=? c1 c2)))) + g7888)))) + g7885))) + (cdaar + (lambda (x) + (letrec ((g7889 + (letrec ((x7890 + (letrec ((x7891 (car x))) + (car x7891)))) + (cdr x7890)))) + g7889))) + (cdaddr + (lambda (x) + (letrec ((g7892 + (letrec ((x7893 + (letrec ((x7894 + (letrec ((x7895 + (cdr + x))) + (cdr + x7895)))) + (car x7894)))) + (cdr x7893)))) + g7892))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7896 + (letrec ((x7897 + (letrec ((x7898 (car x))) + (cdr x7898)))) + (car x7897)))) + g7896))) + (caadr + (lambda (x) + (letrec ((g7899 + (letrec ((x7900 + (letrec ((x7901 (cdr x))) + (car x7901)))) + (car x7900)))) + g7899))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7902 + (letrec ((x7905 (char? c1))) + (assert x7905))) + (g7903 + (letrec ((x7906 (char? c2))) + (assert x7906))) + (g7904 + (letrec ((x7907 + (char-ci<=? c1 c2))) + (not x7907)))) + g7904))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7908 + (letrec ((x7909 + (letrec ((x7910 + (letrec ((x7911 + (car + x))) + (car + x7911)))) + (car x7910)))) + (car x7909)))) + g7908))) + (negative? + (lambda (x) + (letrec ((g7912 + (letrec ((x7914 (number? x))) + (assert x7914))) + (g7913 (< x 0))) + g7913))) + (memv + (lambda (e l) + (letrec ((g7915 (memq e l))) g7915))) + (caaar + (lambda (x) + (letrec ((g7916 + (letrec ((x7917 + (letrec ((x7918 (car x))) + (car x7918)))) + (car x7917)))) + g7916))) + (debug + (lambda (e) (letrec ((g7919 '())) g7919))) + (reverse + (lambda (l) + (letrec ((g7920 + (letrec ((x7922 (list? l))) + (assert x7922))) + (g7921 + (letrec ((x-cnd7923 (null? l))) + (if x-cnd7923 + '() + (letrec ((x7926 + (letrec ((x7927 + (cdr l))) + (reverse x7927))) + (x7924 + (letrec ((x7925 + (car l))) + (list x7925)))) + (append x7926 x7924)))))) + g7921))) + (caaadr + (lambda (x) + (letrec ((g7928 + (letrec ((x7929 + (letrec ((x7930 + (letrec ((x7931 + (cdr + x))) + (car + x7931)))) + (car x7930)))) + (car x7929)))) + g7928))) + (cddadr + (lambda (x) + (letrec ((g7932 + (letrec ((x7933 + (letrec ((x7934 + (letrec ((x7935 + (cdr + x))) + (car + x7935)))) + (cdr x7934)))) + (cdr x7933)))) + g7932))) + (odd? + (lambda (x) + (letrec ((g7936 + (letrec ((x7938 (number? x))) + (assert x7938))) + (g7937 + (letrec ((x7939 (modulo x 2))) + (= 1 x7939)))) + g7937))) + (caadar + (lambda (x) + (letrec ((g7940 + (letrec ((x7941 + (letrec ((x7942 + (letrec ((x7943 + (car + x))) + (cdr + x7943)))) + (car x7942)))) + (car x7941)))) + g7940))) + (apply + (lambda (proc args) + (letrec ((g7944 + (letrec ((x7947 (procedure? proc))) + (assert x7947))) + (g7945 + (letrec ((x7948 (list? args))) + (assert x7948))) + (g7946 + (if cnd + (letrec ((g7949 (proc))) g7949) + (if cnd + (letrec ((g7950 + (letrec ((x7951 + (car + args))) + (proc x7951)))) + g7950) + (if cnd + (letrec ((g7952 + (letrec ((x7954 + (car + args)) + (x7953 + (cadr + args))) + (proc + x7954 + x7953)))) + g7952) + (if cnd + (letrec ((g7955 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args))) + (proc + x7958 + x7957 + x7956)))) + g7955) + (if cnd + (letrec ((g7959 + (letrec ((x7963 + (car + args)) + (x7962 + (cadr + args)) + (x7961 + (caddr + args)) + (x7960 + (cadddr + args))) + (proc + x7963 + x7962 + x7961 + x7960)))) + g7959) + (if cnd + (letrec ((g7964 + (letrec ((x7970 + (car + args)) + (x7969 + (cadr + args)) + (x7968 + (caddr + args)) + (x7967 + (cadddr + args)) + (x7965 + (letrec ((x7966 + (cddddr + args))) + (car + x7966)))) + (proc + x7970 + x7969 + x7968 + x7967 + x7965)))) + g7964) + (if cnd + (letrec ((g7971 + (letrec ((x7979 + (car + args)) + (x7978 + (cadr + args)) + (x7977 + (caddr + args)) + (x7976 + (cadddr + args)) + (x7974 + (letrec ((x7975 + (cddddr + args))) + (car + x7975))) + (x7972 + (letrec ((x7973 + (cddddr + args))) + (cadr + x7973)))) + (proc + x7979 + x7978 + x7977 + x7976 + x7974 + x7972)))) + g7971) + (if cnd + (letrec ((g7980 + (letrec ((x7990 + (car + args)) + (x7989 + (cadr + args)) + (x7988 + (caddr + args)) + (x7987 + (cadddr + args)) + (x7985 + (letrec ((x7986 + (cddddr + args))) + (car + x7986))) + (x7983 + (letrec ((x7984 + (cddddr + args))) + (cadr + x7984))) + (x7981 + (letrec ((x7982 + (cddddr + args))) + (caddr + x7982)))) + (proc + x7990 + x7989 + x7988 + x7987 + x7985 + x7983 + x7981)))) + g7980) + (letrec ((g7991 + (error + "Unsupported call."))) + g7991))))))))))) + g7946))) + (member + (lambda (e l) + (letrec ((g7992 + (letrec ((x7994 (list? l))) + (assert x7994))) + (g7993 + (letrec ((x-cnd7995 (null? l))) + (if x-cnd7995 + #f + (letrec ((x-cnd7996 + (letrec ((x7997 + (car l))) + (equal? x7997 e)))) + (if x-cnd7996 + l + (letrec ((x7998 (cdr l))) + (member e x7998)))))))) + g7993))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7999 + (letrec ((x8000 + (letrec ((x8001 + (letrec ((x8002 + (cdr + x))) + (cdr + x8002)))) + (cdr x8001)))) + (cdr x8000)))) + g7999))) + (cadddr + (lambda (x) + (letrec ((g8003 + (letrec ((x8004 + (letrec ((x8005 + (letrec ((x8006 + (cdr + x))) + (cdr + x8006)))) + (cdr x8005)))) + (car x8004)))) + g8003))) + (int-top + (lambda () + (letrec ((g8007 (random 42))) g8007))) + (zero? + (lambda (x) + (letrec ((g8008 + (letrec ((x8010 (number? x))) + (assert x8010))) + (g8009 (= x 0))) + g8009))) + (string>=? + (lambda (s1 s2) + (letrec ((g8011 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8012 + (if val7155 + val7155 + (string=? s1 s2)))) + g8012)))) + g8011))) + (cadr + (lambda (x) + (letrec ((g8013 + (letrec ((x8014 (cdr x))) + (car x8014)))) + g8013))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8015 + (letrec ((val7156 + (letrec ((x8018 + (pair? l)) + (x8016 + (letrec ((x8017 + (cdr + l))) + (list? + x8017)))) + (and x8018 x8016)))) + (letrec ((g8019 + (if val7156 + val7156 + (null? l)))) + g8019)))) + g8015))) + (cddaar + (lambda (x) + (letrec ((g8020 + (letrec ((x8021 + (letrec ((x8022 + (letrec ((x8023 + (car + x))) + (car + x8023)))) + (cdr x8022)))) + (cdr x8021)))) + g8020))) + (char-numeric? + (lambda (c) + (letrec ((g8024 + (letrec ((x-cnd8025 + (letrec ((x8026 #\0)) + (char<=? x8026 c)))) + (if x-cnd8025 + (letrec ((x8027 #\9)) + (char<=? c x8027)) + #f)))) + g8024))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8028 + (letrec ((x8030 (list? l))) + (assert x8030))) + (g8029 + (letrec ((x-cnd8031 (null? l))) + (if x-cnd8031 + #f + (letrec ((x-cnd8032 + (letrec ((x8033 + (caar l))) + (eqv? x8033 k)))) + (if x-cnd8032 + (car l) + (letrec ((x8034 (cdr l))) + (assq k x8034)))))))) + g8029))) + (not + (lambda (x) + (letrec ((g8035 (if x #f #t))) g8035))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8036 (append l1 l2))) g8036))) + (memq + (lambda (e l) + (letrec ((g8037 + (letrec ((x8039 (list? l))) + (assert x8039))) + (g8038 + (letrec ((x-cnd8040 (null? l))) + (if x-cnd8040 + #f + (letrec ((x-cnd8041 + (letrec ((x8042 + (car l))) + (eq? x8042 e)))) + (if x-cnd8041 + l + (letrec ((x8043 (cdr l))) + (memq e x8043)))))))) + g8038))) + (cadaar + (lambda (x) + (letrec ((g8044 + (letrec ((x8045 + (letrec ((x8046 + (letrec ((x8047 + (car + x))) + (car + x8047)))) + (cdr x8046)))) + (car x8045)))) + g8044))) + (length + (lambda (l) + (letrec ((g8048 + (letrec ((x8050 (list? l))) + (assert x8050))) + (g8049 + (letrec ((rec + (lambda (l) + (letrec ((g8051 + (letrec ((x-cnd8052 + (null? + l))) + (if x-cnd8052 + 0 + (letrec ((x8053 + (letrec ((x8054 + (cdr + l))) + (rec + x8054)))) + (+ + 1 + x8053)))))) + g8051)))) + (letrec ((g8055 (rec l))) + g8055)))) + g8049))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8056 + (letrec ((x8059 (char? c1))) + (assert x8059))) + (g8057 + (letrec ((x8060 (char? c2))) + (assert x8060))) + (g8058 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8062 + (letrec ((x8063 (string<=? s1 s2))) + (not x8063)))) + g8062))) + (cdadr + (lambda (x) + (letrec ((g8064 + (letrec ((x8065 + (letrec ((x8066 (cdr x))) + (car x8066)))) + (cdr x8065)))) + g8064))) + (assoc + (lambda (k l) + (letrec ((g8067 + (letrec ((x8069 (list? l))) + (assert x8069))) + (g8068 + (letrec ((x-cnd8070 (null? l))) + (if x-cnd8070 + #f + (letrec ((x-cnd8071 + (letrec ((x8072 + (caar l))) + (equal? x8072 k)))) + (if x-cnd8071 + (car l) + (letrec ((x8073 (cdr l))) + (assoc k x8073)))))))) + g8068))) + (caar + (lambda (x) + (letrec ((g8074 + (letrec ((x8075 (car x))) + (car x8075)))) + g8074))) + (char>? + (lambda (c1 c2) + (letrec ((g8076 + (letrec ((x8079 (char? c1))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char? c2))) + (assert x8080))) + (g8078 + (letrec ((x8081 (char<=? c1 c2))) + (not x8081)))) + g8078))) + (string<=? + (lambda (s1 s2) + (letrec ((g8082 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8099 + (letrec ((x8102 (char? c1))) + (assert x8102))) + (g8100 + (letrec ((x8103 (char? c2))) + (assert x8103))) + (g8101 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8104 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8104)))) + g8101))) + (caddar + (lambda (x) + (letrec ((g8105 + (letrec ((x8106 + (letrec ((x8107 + (letrec ((x8108 + (car + x))) + (cdr + x8108)))) + (cdr x8107)))) + (car x8106)))) + g8105))) + (newline + (lambda () (letrec ((g8109 #f)) g8109))) + (lcm + (lambda (m n) + (letrec ((g8110 + (letrec ((x8112 + (letrec ((x8113 (* m n))) + (abs x8113))) + (x8111 (gcd m n))) + (/ x8112 x8111)))) + g8110))) + (deref car) + (> + (lambda (x y) + (letrec ((g8114 + (letrec ((x8116 (number? x))) + (assert x8116))) + (g8115 + (letrec ((x8117 (<= x y))) + (not x8117)))) + g8115))) + (list-ref + (lambda (l index) + (letrec ((g8118 + (letrec ((x8122 (list? l))) + (assert x8122))) + (g8119 + (letrec ((x8123 (number? index))) + (assert x8123))) + (g8120 + (letrec ((x8124 + (letrec ((x8125 + (length l))) + (< index x8125)))) + (assert x8124))) + (g8121 + (letrec ((x-cnd8126 (= index 0))) + (if x-cnd8126 + (car l) + (letrec ((x8128 (cdr l)) + (x8127 (- index 1))) + (list-ref x8128 x8127)))))) + g8121))) + (gcd + (lambda (a b) + (letrec ((g8129 + (letrec ((x-cnd8130 (= b 0))) + (if x-cnd8130 + a + (letrec ((x8131 (modulo a b))) + (gcd b x8131)))))) + g8129)))) + (letrec ((g8132 + (letrec ((g8133 + (letrec ((sum + (lambda (n) + (letrec ((g8134 + (letrec ((x-cnd8135 + (<= + n + 0))) + (if x-cnd8135 + 0 + (letrec ((x8136 + (letrec ((x8137 + (- + n + 1))) + (sum + x8137)))) + (+ + n + x8136)))))) + g8134)))) + (letrec ((g8138 + (letrec ((g8139 + (letrec ((g8140 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + (letrec ((x7233 + (integer?/c + j7230 + k7231 + g7229))) + (((lambda (n) + (and/c + integer?/c + (>=/c + n))) + x7233) + j7230 + k7231 + (f7232 + x7233))))) + 'module + 'importer + sum))) + g8140))) + g8139))) + g8138)))) + g8133))) + g8132)))) + g7245))) + g7244)) diff --git a/analyses/simpleactor/benchmarks-out/mochi_zip.rkt b/analyses/simpleactor/benchmarks-out/mochi_zip.rkt index 4eb4f978..01ef5a4d 100644 --- a/analyses/simpleactor/benchmarks-out/mochi_zip.rkt +++ b/analyses/simpleactor/benchmarks-out/mochi_zip.rkt @@ -1,41 +1,3146 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7237 #t)) g7237))) + (meta (lambda (v) (letrec ((g7238 v)) g7238))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((x-e7241 lst)) + (match + x-e7241 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7242 (eq? v v1))) + (if x-cnd7242 #t (member v vs))))))))) + g7240))) + g7239))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (zip xs ys) - (cond - ((and (empty? xs) (empty? ys)) empty) - ((and (cons? xs) (cons? ys)) - (cons (cons (car xs) (car ys)) (zip (cdr xs) (cdr ys)))) - (else 'fail))) - (define (mk-list n) (if (< n 0) empty (cons n (mk-list (- n 1))))) - (define (main n) (let ((xs (mk-list n))) (zip xs xs))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((listof integer?) - j3984 - k3985 - (f3986 (integer? j3984 k3985 g3983))))) - 'module - 'importer - mk-list) - (input)) - (((lambda (j3988 k3989 f3990) - (lambda (g3987) - ((listof (cons/c integer? integer?)) - j3988 - k3989 - (f3990 (integer? j3988 k3989 g3987))))) - 'module - 'importer - main) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7243 (lambda (v) (letrec ((g7244 v)) g7244)))) g7243))) + (nonzero? + (lambda (v) + (letrec ((g7245 (letrec ((x7246 (= v 0))) (not x7246)))) g7245)))) + (letrec ((g7247 + (letrec ((g7248 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7249 + (letrec ((x-cnd7250 (real? g7162))) + (if x-cnd7250 + g7162 + (blame g7160 'real?))))) + g7249))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7251 + (letrec ((x-cnd7252 + (boolean? g7165))) + (if x-cnd7252 + g7165 + (blame g7163 'boolean?))))) + g7251))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7253 + (letrec ((x-cnd7254 + (number? g7168))) + (if x-cnd7254 + g7168 + (blame g7166 'number?))))) + g7253))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7255 + (letrec ((x-cnd7256 + ((lambda (v) #t) g7171))) + (if x-cnd7256 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7255))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7257 + (letrec ((x-cnd7258 + ((lambda (v) #t) g7174))) + (if x-cnd7258 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7257))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7259 + (letrec ((x-cnd7260 (pair? g7177))) + (if x-cnd7260 + g7177 + (blame g7175 'pair?))))) + g7259))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7261 + (letrec ((x-cnd7262 (pair? g7180))) + (if x-cnd7262 + g7180 + (blame g7178 'pair?))))) + g7261))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7263 + (letrec ((x-cnd7264 + (integer? g7183))) + (if x-cnd7264 + g7183 + (blame g7181 'integer?))))) + g7263))) + (and/c + (lambda (c1 c2) + (letrec ((g7265 + (lambda (k j v) + (letrec ((g7266 + (letrec ((x-cnd7267 + (c1 k j v))) + (if x-cnd7267 + (c2 k j v) + #f)))) + g7266)))) + g7265))) + (list-of + (lambda (contract) + (letrec ((g7268 + (lambda (k j v) + (letrec ((g7269 + (letrec ((x-cnd7270 + (null? v))) + (if x-cnd7270 + '() + (letrec ((x7274 + (letrec ((x7275 + (car + v))) + (contract + k + j + x7275))) + (x7271 + (letrec ((x7273 + (list-of + contract)) + (x7272 + (cdr + v))) + (x7273 + k + j + x7272)))) + (cons + x7274 + x7271)))))) + g7269)))) + g7268))) + (any? (lambda (v) (letrec ((g7276 #t)) g7276))) + (nonzero? + (lambda (v) + (letrec ((g7277 + (letrec ((x7278 (= v 0))) + (not x7278)))) + g7277))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7279 + (letrec ((x-cnd7280 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7280 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7279))) + (meta (lambda (v) (letrec ((g7281 v)) g7281))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7282 #t)) g7282))) + (cdddr + (lambda (x) + (letrec ((g7283 + (letrec ((x7284 + (letrec ((x7285 (cdr x))) + (cdr x7285)))) + (cdr x7284)))) + g7283))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7286 + (letrec ((x7289 (procedure? f))) + (assert x7289))) + (g7287 + (letrec ((x7290 (list? l))) + (assert x7290))) + (g7288 + (letrec ((x-cnd7291 (null? l))) + (if x-cnd7291 + '() + (letrec ((x7294 + (letrec ((x7295 + (car l))) + (f x7295))) + (x7292 + (letrec ((x7293 + (cdr l))) + (map f x7293)))) + (cons x7294 x7292)))))) + g7288))) + (cdar + (lambda (x) + (letrec ((g7296 + (letrec ((x7297 (car x))) + (cdr x7297)))) + g7296))) + (cadadr + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (cdr + x))) + (car + x7301)))) + (cdr x7300)))) + (car x7299)))) + g7298))) + (cdadar + (lambda (x) + (letrec ((g7302 + (letrec ((x7303 + (letrec ((x7304 + (letrec ((x7305 + (car + x))) + (cdr + x7305)))) + (car x7304)))) + (cdr x7303)))) + g7302))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7306 + (letrec ((x7309 + (string? filename))) + (assert x7309))) + (g7307 + (letrec ((x7310 (procedure? proc))) + (assert x7310))) + (g7308 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7311 + (close-output-port + output-port)) + (g7312 res)) + g7312)))) + g7308))) + (caddr + (lambda (x) + (letrec ((g7313 + (letrec ((x7314 + (letrec ((x7315 (cdr x))) + (cdr x7315)))) + (car x7314)))) + g7313))) + (cdaadr + (lambda (x) + (letrec ((g7316 + (letrec ((x7317 + (letrec ((x7318 + (letrec ((x7319 + (cdr + x))) + (car + x7319)))) + (car x7318)))) + (cdr x7317)))) + g7316))) + (assq + (lambda (k l) + (letrec ((g7320 + (letrec ((x7322 (list? l))) + (assert x7322))) + (g7321 + (letrec ((x-cnd7323 (null? l))) + (if x-cnd7323 + #f + (letrec ((x-cnd7324 + (letrec ((x7325 + (caar l))) + (eq? x7325 k)))) + (if x-cnd7324 + (car l) + (letrec ((x7326 (cdr l))) + (assq k x7326)))))))) + g7321))) + (even? + (lambda (x) + (letrec ((g7327 + (letrec ((x7328 (modulo x 2))) + (= 0 x7328)))) + g7327))) + (list->string + (lambda (l) + (letrec ((g7329 + (letrec ((x7331 (list? l))) + (assert x7331))) + (g7330 + (letrec ((x-cnd7332 (null? l))) + (if x-cnd7332 + "" + (letrec ((x7335 + (letrec ((x7336 + (car l))) + (char->string + x7336))) + (x7333 + (letrec ((x7334 + (cdr l))) + (list->string + x7334)))) + (string-append + x7335 + x7333)))))) + g7330))) + (char<=? + (lambda (c1 c2) + (letrec ((g7337 + (letrec ((x7340 (char? c1))) + (assert x7340))) + (g7338 + (letrec ((x7341 (char? c2))) + (assert x7341))) + (g7339 + (letrec ((val7143 (char=? c x7358)))) + (if x-cnd7357 + (letrec ((x7359 #\z)) + (char-ci<=? c x7359)) + #f)))) + g7356))) + (<= + (lambda (x y) + (letrec ((g7360 + (letrec ((x7362 (number? x))) + (assert x7362))) + (g7361 + (letrec ((val7144 (< x y))) + (letrec ((g7363 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7364 + (if val7145 + val7145 + #f))) + g7364))))) + g7363)))) + g7361))) + (char-whitespace? + (lambda (c) + (letrec ((g7365 + (letrec ((val7146 + (letrec ((x7366 + (char->integer + c))) + (= x7366 9)))) + (letrec ((g7367 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7368 + (char->integer + c))) + (= + x7368 + 10)))) + (letrec ((g7369 + (if val7147 + val7147 + (letrec ((x7370 + (char->integer + c))) + (= + x7370 + 32))))) + g7369))))) + g7367)))) + g7365))) + (cddar + (lambda (x) + (letrec ((g7371 + (letrec ((x7372 + (letrec ((x7373 (car x))) + (cdr x7373)))) + (cdr x7372)))) + g7371))) + (positive? + (lambda (x) + (letrec ((g7374 + (letrec ((x7376 (number? x))) + (assert x7376))) + (g7375 (> x 0))) + g7375))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7377 #f)) g7377))) + (cddr + (lambda (x) + (letrec ((g7378 + (letrec ((x7379 (cdr x))) + (cdr x7379)))) + g7378))) + (truncate + (lambda (x) + (letrec ((g7380 + (letrec ((x7382 (number? x))) + (assert x7382))) + (g7381 + (letrec ((x-cnd7383 (< x 0))) + (if x-cnd7383 + (ceiling x) + (floor x))))) + g7381))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7384 + (letrec ((val7148 (eq? a b))) + (letrec ((g7385 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7387 + (null? + a)) + (x7386 + (null? + b))) + (and x7387 + x7386)))) + (letrec ((g7388 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7391 + (string? + a)) + (x7390 + (string? + b)) + (x7389 + (string=? + a + b))) + (and x7391 + x7390 + x7389)))) + (letrec ((g7392 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7400 + (pair? + a)) + (x7399 + (pair? + b)) + (x7396 + (letrec ((x7398 + (car + a)) + (x7397 + (car + b))) + (equal? + x7398 + x7397))) + (x7393 + (letrec ((x7395 + (cdr + a)) + (x7394 + (cdr + b))) + (equal? + x7395 + x7394)))) + (and x7400 + x7399 + x7396 + x7393)))) + (letrec ((g7401 + (if val7151 + val7151 + (letrec ((x7420 + (vector? + a)) + (x7419 + (vector? + b)) + (x7402 + (letrec ((x7416 + (letrec ((x7417 + (letrec ((x7418 + (vector-length + a))) + (n + x7418)))) + (x7417))) + (x7403 + (letrec ((x7414 + (letrec ((x7415 + (vector-length + b))) + (= + x7415 + n))) + (x7404 + (letrec ((loop + (lambda (i) + (letrec ((g7405 + (letrec ((x7412 + (= + i + n)) + (x7406 + (letrec ((x7409 + (letrec ((x7411 + (vector-ref + a + i)) + (x7410 + (vector-ref + b + i))) + (equal? + x7411 + x7410))) + (x7407 + (letrec ((x7408 + (+ + i + 1))) + (loop + x7408)))) + (and x7409 + x7407)))) + (or x7412 + x7406)))) + g7405)))) + (letrec ((g7413 + (loop + 0))) + g7413)))) + (and x7414 + x7404)))) + (let x7416 x7403)))) + (and x7420 + x7419 + x7402))))) + g7401))))) + g7392))))) + g7388))))) + g7385)))) + g7384))) + (cdaaar + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (car + x))) + (car + x7424)))) + (car x7423)))) + (cdr x7422)))) + g7421))) + (caaddr + (lambda (x) + (letrec ((g7425 + (letrec ((x7426 + (letrec ((x7427 + (letrec ((x7428 + (cdr + x))) + (cdr + x7428)))) + (car x7427)))) + (car x7426)))) + g7425))) + (eqv? + (lambda (x y) + (letrec ((g7429 (eq? x y))) g7429))) + (>= + (lambda (x y) + (letrec ((g7430 + (letrec ((x7432 (number? x))) + (assert x7432))) + (g7431 + (letrec ((val7152 (> x y))) + (letrec ((g7433 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7434 + (if val7153 + val7153 + #f))) + g7434))))) + g7433)))) + g7431))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7435 + (letrec ((x7438 + (string? filename))) + (assert x7438))) + (g7436 + (letrec ((x7439 (procedure? proc))) + (assert x7439))) + (g7437 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7440 + (close-input-port + input-port)) + (g7441 res)) + g7441)))) + g7437))) + (ref + (lambda (x) + (letrec ((g7442 (cons x '()))) g7442))) + (char>=? + (lambda (c1 c2) + (letrec ((g7443 + (letrec ((x7446 (char? c1))) + (assert x7446))) + (g7444 + (letrec ((x7447 (char? c2))) + (assert x7447))) + (g7445 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7448 + (if val7154 + val7154 + (char=? c1 c2)))) + g7448)))) + g7445))) + (cdaar + (lambda (x) + (letrec ((g7449 + (letrec ((x7450 + (letrec ((x7451 (car x))) + (car x7451)))) + (cdr x7450)))) + g7449))) + (cdaddr + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 + (letrec ((x7455 + (cdr + x))) + (cdr + x7455)))) + (car x7454)))) + (cdr x7453)))) + g7452))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7456 + (letrec ((x7457 + (letrec ((x7458 (car x))) + (cdr x7458)))) + (car x7457)))) + g7456))) + (caadr + (lambda (x) + (letrec ((g7459 + (letrec ((x7460 + (letrec ((x7461 (cdr x))) + (car x7461)))) + (car x7460)))) + g7459))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7462 + (letrec ((x7465 (char? c1))) + (assert x7465))) + (g7463 + (letrec ((x7466 (char? c2))) + (assert x7466))) + (g7464 + (letrec ((x7467 + (char-ci<=? c1 c2))) + (not x7467)))) + g7464))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 + (letrec ((x7471 + (car + x))) + (car + x7471)))) + (car x7470)))) + (car x7469)))) + g7468))) + (negative? + (lambda (x) + (letrec ((g7472 + (letrec ((x7474 (number? x))) + (assert x7474))) + (g7473 (< x 0))) + g7473))) + (memv + (lambda (e l) + (letrec ((g7475 (memq e l))) g7475))) + (caaar + (lambda (x) + (letrec ((g7476 + (letrec ((x7477 + (letrec ((x7478 (car x))) + (car x7478)))) + (car x7477)))) + g7476))) + (debug + (lambda (e) (letrec ((g7479 '())) g7479))) + (reverse + (lambda (l) + (letrec ((g7480 + (letrec ((x7482 (list? l))) + (assert x7482))) + (g7481 + (letrec ((x-cnd7483 (null? l))) + (if x-cnd7483 + '() + (letrec ((x7486 + (letrec ((x7487 + (cdr l))) + (reverse x7487))) + (x7484 + (letrec ((x7485 + (car l))) + (list x7485)))) + (append x7486 x7484)))))) + g7481))) + (caaadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (car x7490)))) + (car x7489)))) + g7488))) + (cddadr + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (cdr + x))) + (car + x7495)))) + (cdr x7494)))) + (cdr x7493)))) + g7492))) + (odd? + (lambda (x) + (letrec ((g7496 + (letrec ((x7498 (number? x))) + (assert x7498))) + (g7497 + (letrec ((x7499 (modulo x 2))) + (= 1 x7499)))) + g7497))) + (caadar + (lambda (x) + (letrec ((g7500 + (letrec ((x7501 + (letrec ((x7502 + (letrec ((x7503 + (car + x))) + (cdr + x7503)))) + (car x7502)))) + (car x7501)))) + g7500))) + (apply + (lambda (proc args) + (letrec ((g7504 + (letrec ((x7507 (procedure? proc))) + (assert x7507))) + (g7505 + (letrec ((x7508 (list? args))) + (assert x7508))) + (g7506 + (if cnd + (letrec ((g7509 (proc))) g7509) + (if cnd + (letrec ((g7510 + (letrec ((x7511 + (car + args))) + (proc x7511)))) + g7510) + (if cnd + (letrec ((g7512 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args))) + (proc + x7514 + x7513)))) + g7512) + (if cnd + (letrec ((g7515 + (letrec ((x7518 + (car + args)) + (x7517 + (cadr + args)) + (x7516 + (caddr + args))) + (proc + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7519 + (letrec ((x7523 + (car + args)) + (x7522 + (cadr + args)) + (x7521 + (caddr + args)) + (x7520 + (cadddr + args))) + (proc + x7523 + x7522 + x7521 + x7520)))) + g7519) + (if cnd + (letrec ((g7524 + (letrec ((x7530 + (car + args)) + (x7529 + (cadr + args)) + (x7528 + (caddr + args)) + (x7527 + (cadddr + args)) + (x7525 + (letrec ((x7526 + (cddddr + args))) + (car + x7526)))) + (proc + x7530 + x7529 + x7528 + x7527 + x7525)))) + g7524) + (if cnd + (letrec ((g7531 + (letrec ((x7539 + (car + args)) + (x7538 + (cadr + args)) + (x7537 + (caddr + args)) + (x7536 + (cadddr + args)) + (x7534 + (letrec ((x7535 + (cddddr + args))) + (car + x7535))) + (x7532 + (letrec ((x7533 + (cddddr + args))) + (cadr + x7533)))) + (proc + x7539 + x7538 + x7537 + x7536 + x7534 + x7532)))) + g7531) + (if cnd + (letrec ((g7540 + (letrec ((x7550 + (car + args)) + (x7549 + (cadr + args)) + (x7548 + (caddr + args)) + (x7547 + (cadddr + args)) + (x7545 + (letrec ((x7546 + (cddddr + args))) + (car + x7546))) + (x7543 + (letrec ((x7544 + (cddddr + args))) + (cadr + x7544))) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (caddr + x7542)))) + (proc + x7550 + x7549 + x7548 + x7547 + x7545 + x7543 + x7541)))) + g7540) + (letrec ((g7551 + (error + "Unsupported call."))) + g7551))))))))))) + g7506))) + (member + (lambda (e l) + (letrec ((g7552 + (letrec ((x7554 (list? l))) + (assert x7554))) + (g7553 + (letrec ((x-cnd7555 (null? l))) + (if x-cnd7555 + #f + (letrec ((x-cnd7556 + (letrec ((x7557 + (car l))) + (equal? x7557 e)))) + (if x-cnd7556 + l + (letrec ((x7558 (cdr l))) + (member e x7558)))))))) + g7553))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (cdr x7560)))) + g7559))) + (cadddr + (lambda (x) + (letrec ((g7563 + (letrec ((x7564 + (letrec ((x7565 + (letrec ((x7566 + (cdr + x))) + (cdr + x7566)))) + (cdr x7565)))) + (car x7564)))) + g7563))) + (int-top + (lambda () + (letrec ((g7567 (random 42))) g7567))) + (zero? + (lambda (x) + (letrec ((g7568 + (letrec ((x7570 (number? x))) + (assert x7570))) + (g7569 (= x 0))) + g7569))) + (string>=? + (lambda (s1 s2) + (letrec ((g7571 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7572 + (if val7155 + val7155 + (string=? s1 s2)))) + g7572)))) + g7571))) + (cadr + (lambda (x) + (letrec ((g7573 + (letrec ((x7574 (cdr x))) + (car x7574)))) + g7573))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7575 + (letrec ((val7156 + (letrec ((x7578 + (pair? l)) + (x7576 + (letrec ((x7577 + (cdr + l))) + (list? + x7577)))) + (and x7578 x7576)))) + (letrec ((g7579 + (if val7156 + val7156 + (null? l)))) + g7579)))) + g7575))) + (cddaar + (lambda (x) + (letrec ((g7580 + (letrec ((x7581 + (letrec ((x7582 + (letrec ((x7583 + (car + x))) + (car + x7583)))) + (cdr x7582)))) + (cdr x7581)))) + g7580))) + (char-numeric? + (lambda (c) + (letrec ((g7584 + (letrec ((x-cnd7585 + (letrec ((x7586 #\0)) + (char<=? x7586 c)))) + (if x-cnd7585 + (letrec ((x7587 #\9)) + (char<=? c x7587)) + #f)))) + g7584))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7588 + (letrec ((x7590 (list? l))) + (assert x7590))) + (g7589 + (letrec ((x-cnd7591 (null? l))) + (if x-cnd7591 + #f + (letrec ((x-cnd7592 + (letrec ((x7593 + (caar l))) + (eqv? x7593 k)))) + (if x-cnd7592 + (car l) + (letrec ((x7594 (cdr l))) + (assq k x7594)))))))) + g7589))) + (not + (lambda (x) + (letrec ((g7595 (if x #f #t))) g7595))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7596 (append l1 l2))) g7596))) + (memq + (lambda (e l) + (letrec ((g7597 + (letrec ((x7599 (list? l))) + (assert x7599))) + (g7598 + (letrec ((x-cnd7600 (null? l))) + (if x-cnd7600 + #f + (letrec ((x-cnd7601 + (letrec ((x7602 + (car l))) + (eq? x7602 e)))) + (if x-cnd7601 + l + (letrec ((x7603 (cdr l))) + (memq e x7603)))))))) + g7598))) + (cadaar + (lambda (x) + (letrec ((g7604 + (letrec ((x7605 + (letrec ((x7606 + (letrec ((x7607 + (car + x))) + (car + x7607)))) + (cdr x7606)))) + (car x7605)))) + g7604))) + (length + (lambda (l) + (letrec ((g7608 + (letrec ((x7610 (list? l))) + (assert x7610))) + (g7609 + (letrec ((rec + (lambda (l) + (letrec ((g7611 + (letrec ((x-cnd7612 + (null? + l))) + (if x-cnd7612 + 0 + (letrec ((x7613 + (letrec ((x7614 + (cdr + l))) + (rec + x7614)))) + (+ + 1 + x7613)))))) + g7611)))) + (letrec ((g7615 (rec l))) + g7615)))) + g7609))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7616 + (letrec ((x7619 (char? c1))) + (assert x7619))) + (g7617 + (letrec ((x7620 (char? c2))) + (assert x7620))) + (g7618 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7622 + (letrec ((x7623 (string<=? s1 s2))) + (not x7623)))) + g7622))) + (cdadr + (lambda (x) + (letrec ((g7624 + (letrec ((x7625 + (letrec ((x7626 (cdr x))) + (car x7626)))) + (cdr x7625)))) + g7624))) + (assoc + (lambda (k l) + (letrec ((g7627 + (letrec ((x7629 (list? l))) + (assert x7629))) + (g7628 + (letrec ((x-cnd7630 (null? l))) + (if x-cnd7630 + #f + (letrec ((x-cnd7631 + (letrec ((x7632 + (caar l))) + (equal? x7632 k)))) + (if x-cnd7631 + (car l) + (letrec ((x7633 (cdr l))) + (assoc k x7633)))))))) + g7628))) + (caar + (lambda (x) + (letrec ((g7634 + (letrec ((x7635 (car x))) + (car x7635)))) + g7634))) + (char>? + (lambda (c1 c2) + (letrec ((g7636 + (letrec ((x7639 (char? c1))) + (assert x7639))) + (g7637 + (letrec ((x7640 (char? c2))) + (assert x7640))) + (g7638 + (letrec ((x7641 (char<=? c1 c2))) + (not x7641)))) + g7638))) + (string<=? + (lambda (s1 s2) + (letrec ((g7642 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7659 + (letrec ((x7662 (char? c1))) + (assert x7662))) + (g7660 + (letrec ((x7663 (char? c2))) + (assert x7663))) + (g7661 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7664 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7664)))) + g7661))) + (caddar + (lambda (x) + (letrec ((g7665 + (letrec ((x7666 + (letrec ((x7667 + (letrec ((x7668 + (car + x))) + (cdr + x7668)))) + (cdr x7667)))) + (car x7666)))) + g7665))) + (newline + (lambda () (letrec ((g7669 #f)) g7669))) + (lcm + (lambda (m n) + (letrec ((g7670 + (letrec ((x7672 + (letrec ((x7673 (* m n))) + (abs x7673))) + (x7671 (gcd m n))) + (/ x7672 x7671)))) + g7670))) + (deref car) + (> + (lambda (x y) + (letrec ((g7674 + (letrec ((x7676 (number? x))) + (assert x7676))) + (g7675 + (letrec ((x7677 (<= x y))) + (not x7677)))) + g7675))) + (list-ref + (lambda (l index) + (letrec ((g7678 + (letrec ((x7682 (list? l))) + (assert x7682))) + (g7679 + (letrec ((x7683 (number? index))) + (assert x7683))) + (g7680 + (letrec ((x7684 + (letrec ((x7685 + (length l))) + (< index x7685)))) + (assert x7684))) + (g7681 + (letrec ((x-cnd7686 (= index 0))) + (if x-cnd7686 + (car l) + (letrec ((x7688 (cdr l)) + (x7687 (- index 1))) + (list-ref x7688 x7687)))))) + g7681))) + (gcd + (lambda (a b) + (letrec ((g7689 + (letrec ((x-cnd7690 (= b 0))) + (if x-cnd7690 + a + (letrec ((x7691 (modulo a b))) + (gcd b x7691)))))) + g7689))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7692 + (letrec ((x-cnd7693 (real? g7162))) + (if x-cnd7693 + g7162 + (blame g7160 'real?))))) + g7692))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7694 + (letrec ((x-cnd7695 + (boolean? g7165))) + (if x-cnd7695 + g7165 + (blame g7163 'boolean?))))) + g7694))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7696 + (letrec ((x-cnd7697 + (number? g7168))) + (if x-cnd7697 + g7168 + (blame g7166 'number?))))) + g7696))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7698 + (letrec ((x-cnd7699 + ((lambda (v) #t) g7171))) + (if x-cnd7699 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7698))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7700 + (letrec ((x-cnd7701 + ((lambda (v) #t) g7174))) + (if x-cnd7701 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7700))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7702 + (letrec ((x-cnd7703 (pair? g7177))) + (if x-cnd7703 + g7177 + (blame g7175 'pair?))))) + g7702))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7704 + (letrec ((x-cnd7705 (pair? g7180))) + (if x-cnd7705 + g7180 + (blame g7178 'pair?))))) + g7704))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7706 + (letrec ((x-cnd7707 + (integer? g7183))) + (if x-cnd7707 + g7183 + (blame g7181 'integer?))))) + g7706))) + (and/c + (lambda (c1 c2) + (letrec ((g7708 + (lambda (k j v) + (letrec ((g7709 + (letrec ((x-cnd7710 + (c1 k j v))) + (if x-cnd7710 + (c2 k j v) + #f)))) + g7709)))) + g7708))) + (list-of + (lambda (contract) + (letrec ((g7711 + (lambda (k j v) + (letrec ((g7712 + (letrec ((x-cnd7713 + (null? v))) + (if x-cnd7713 + '() + (letrec ((x7717 + (letrec ((x7718 + (car + v))) + (contract + k + j + x7718))) + (x7714 + (letrec ((x7716 + (list-of + contract)) + (x7715 + (cdr + v))) + (x7716 + k + j + x7715)))) + (cons + x7717 + x7714)))))) + g7712)))) + g7711))) + (any? (lambda (v) (letrec ((g7719 #t)) g7719))) + (nonzero? + (lambda (v) + (letrec ((g7720 + (letrec ((x7721 (= v 0))) + (not x7721)))) + g7720))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7722 + (letrec ((x-cnd7723 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7723 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7722))) + (meta (lambda (v) (letrec ((g7724 v)) g7724))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7725 #t)) g7725))) + (cdddr + (lambda (x) + (letrec ((g7726 + (letrec ((x7727 + (letrec ((x7728 (cdr x))) + (cdr x7728)))) + (cdr x7727)))) + g7726))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7729 + (letrec ((x7732 (procedure? f))) + (assert x7732))) + (g7730 + (letrec ((x7733 (list? l))) + (assert x7733))) + (g7731 + (letrec ((x-cnd7734 (null? l))) + (if x-cnd7734 + '() + (letrec ((x7737 + (letrec ((x7738 + (car l))) + (f x7738))) + (x7735 + (letrec ((x7736 + (cdr l))) + (map f x7736)))) + (cons x7737 x7735)))))) + g7731))) + (cdar + (lambda (x) + (letrec ((g7739 + (letrec ((x7740 (car x))) + (cdr x7740)))) + g7739))) + (cadadr + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (cdr + x))) + (car + x7744)))) + (cdr x7743)))) + (car x7742)))) + g7741))) + (cdadar + (lambda (x) + (letrec ((g7745 + (letrec ((x7746 + (letrec ((x7747 + (letrec ((x7748 + (car + x))) + (cdr + x7748)))) + (car x7747)))) + (cdr x7746)))) + g7745))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7749 + (letrec ((x7752 + (string? filename))) + (assert x7752))) + (g7750 + (letrec ((x7753 (procedure? proc))) + (assert x7753))) + (g7751 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7754 + (close-output-port + output-port)) + (g7755 res)) + g7755)))) + g7751))) + (caddr + (lambda (x) + (letrec ((g7756 + (letrec ((x7757 + (letrec ((x7758 (cdr x))) + (cdr x7758)))) + (car x7757)))) + g7756))) + (cdaadr + (lambda (x) + (letrec ((g7759 + (letrec ((x7760 + (letrec ((x7761 + (letrec ((x7762 + (cdr + x))) + (car + x7762)))) + (car x7761)))) + (cdr x7760)))) + g7759))) + (assq + (lambda (k l) + (letrec ((g7763 + (letrec ((x7765 (list? l))) + (assert x7765))) + (g7764 + (letrec ((x-cnd7766 (null? l))) + (if x-cnd7766 + #f + (letrec ((x-cnd7767 + (letrec ((x7768 + (caar l))) + (eq? x7768 k)))) + (if x-cnd7767 + (car l) + (letrec ((x7769 (cdr l))) + (assq k x7769)))))))) + g7764))) + (even? + (lambda (x) + (letrec ((g7770 + (letrec ((x7771 (modulo x 2))) + (= 0 x7771)))) + g7770))) + (list->string + (lambda (l) + (letrec ((g7772 + (letrec ((x7774 (list? l))) + (assert x7774))) + (g7773 + (letrec ((x-cnd7775 (null? l))) + (if x-cnd7775 + "" + (letrec ((x7778 + (letrec ((x7779 + (car l))) + (char->string + x7779))) + (x7776 + (letrec ((x7777 + (cdr l))) + (list->string + x7777)))) + (string-append + x7778 + x7776)))))) + g7773))) + (char<=? + (lambda (c1 c2) + (letrec ((g7780 + (letrec ((x7783 (char? c1))) + (assert x7783))) + (g7781 + (letrec ((x7784 (char? c2))) + (assert x7784))) + (g7782 + (letrec ((val7143 (char=? c x7801)))) + (if x-cnd7800 + (letrec ((x7802 #\z)) + (char-ci<=? c x7802)) + #f)))) + g7799))) + (<= + (lambda (x y) + (letrec ((g7803 + (letrec ((x7805 (number? x))) + (assert x7805))) + (g7804 + (letrec ((val7144 (< x y))) + (letrec ((g7806 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7807 + (if val7145 + val7145 + #f))) + g7807))))) + g7806)))) + g7804))) + (char-whitespace? + (lambda (c) + (letrec ((g7808 + (letrec ((val7146 + (letrec ((x7809 + (char->integer + c))) + (= x7809 9)))) + (letrec ((g7810 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7811 + (char->integer + c))) + (= + x7811 + 10)))) + (letrec ((g7812 + (if val7147 + val7147 + (letrec ((x7813 + (char->integer + c))) + (= + x7813 + 32))))) + g7812))))) + g7810)))) + g7808))) + (cddar + (lambda (x) + (letrec ((g7814 + (letrec ((x7815 + (letrec ((x7816 (car x))) + (cdr x7816)))) + (cdr x7815)))) + g7814))) + (positive? + (lambda (x) + (letrec ((g7817 + (letrec ((x7819 (number? x))) + (assert x7819))) + (g7818 (> x 0))) + g7818))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7820 #f)) g7820))) + (cddr + (lambda (x) + (letrec ((g7821 + (letrec ((x7822 (cdr x))) + (cdr x7822)))) + g7821))) + (truncate + (lambda (x) + (letrec ((g7823 + (letrec ((x7825 (number? x))) + (assert x7825))) + (g7824 + (letrec ((x-cnd7826 (< x 0))) + (if x-cnd7826 + (ceiling x) + (floor x))))) + g7824))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7827 + (letrec ((val7148 (eq? a b))) + (letrec ((g7828 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7830 + (null? + a)) + (x7829 + (null? + b))) + (and x7830 + x7829)))) + (letrec ((g7831 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7834 + (string? + a)) + (x7833 + (string? + b)) + (x7832 + (string=? + a + b))) + (and x7834 + x7833 + x7832)))) + (letrec ((g7835 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7843 + (pair? + a)) + (x7842 + (pair? + b)) + (x7839 + (letrec ((x7841 + (car + a)) + (x7840 + (car + b))) + (equal? + x7841 + x7840))) + (x7836 + (letrec ((x7838 + (cdr + a)) + (x7837 + (cdr + b))) + (equal? + x7838 + x7837)))) + (and x7843 + x7842 + x7839 + x7836)))) + (letrec ((g7844 + (if val7151 + val7151 + (letrec ((x7863 + (vector? + a)) + (x7862 + (vector? + b)) + (x7845 + (letrec ((x7859 + (letrec ((x7860 + (letrec ((x7861 + (vector-length + a))) + (n + x7861)))) + (x7860))) + (x7846 + (letrec ((x7857 + (letrec ((x7858 + (vector-length + b))) + (= + x7858 + n))) + (x7847 + (letrec ((loop + (lambda (i) + (letrec ((g7848 + (letrec ((x7855 + (= + i + n)) + (x7849 + (letrec ((x7852 + (letrec ((x7854 + (vector-ref + a + i)) + (x7853 + (vector-ref + b + i))) + (equal? + x7854 + x7853))) + (x7850 + (letrec ((x7851 + (+ + i + 1))) + (loop + x7851)))) + (and x7852 + x7850)))) + (or x7855 + x7849)))) + g7848)))) + (letrec ((g7856 + (loop + 0))) + g7856)))) + (and x7857 + x7847)))) + (let x7859 x7846)))) + (and x7863 + x7862 + x7845))))) + g7844))))) + g7835))))) + g7831))))) + g7828)))) + g7827))) + (cdaaar + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (car + x))) + (car + x7867)))) + (car x7866)))) + (cdr x7865)))) + g7864))) + (caaddr + (lambda (x) + (letrec ((g7868 + (letrec ((x7869 + (letrec ((x7870 + (letrec ((x7871 + (cdr + x))) + (cdr + x7871)))) + (car x7870)))) + (car x7869)))) + g7868))) + (eqv? + (lambda (x y) + (letrec ((g7872 (eq? x y))) g7872))) + (>= + (lambda (x y) + (letrec ((g7873 + (letrec ((x7875 (number? x))) + (assert x7875))) + (g7874 + (letrec ((val7152 (> x y))) + (letrec ((g7876 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7877 + (if val7153 + val7153 + #f))) + g7877))))) + g7876)))) + g7874))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7878 + (letrec ((x7881 + (string? filename))) + (assert x7881))) + (g7879 + (letrec ((x7882 (procedure? proc))) + (assert x7882))) + (g7880 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7883 + (close-input-port + input-port)) + (g7884 res)) + g7884)))) + g7880))) + (ref + (lambda (x) + (letrec ((g7885 (cons x '()))) g7885))) + (char>=? + (lambda (c1 c2) + (letrec ((g7886 + (letrec ((x7889 (char? c1))) + (assert x7889))) + (g7887 + (letrec ((x7890 (char? c2))) + (assert x7890))) + (g7888 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7891 + (if val7154 + val7154 + (char=? c1 c2)))) + g7891)))) + g7888))) + (cdaar + (lambda (x) + (letrec ((g7892 + (letrec ((x7893 + (letrec ((x7894 (car x))) + (car x7894)))) + (cdr x7893)))) + g7892))) + (cdaddr + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 + (letrec ((x7898 + (cdr + x))) + (cdr + x7898)))) + (car x7897)))) + (cdr x7896)))) + g7895))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7899 + (letrec ((x7900 + (letrec ((x7901 (car x))) + (cdr x7901)))) + (car x7900)))) + g7899))) + (caadr + (lambda (x) + (letrec ((g7902 + (letrec ((x7903 + (letrec ((x7904 (cdr x))) + (car x7904)))) + (car x7903)))) + g7902))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7905 + (letrec ((x7908 (char? c1))) + (assert x7908))) + (g7906 + (letrec ((x7909 (char? c2))) + (assert x7909))) + (g7907 + (letrec ((x7910 + (char-ci<=? c1 c2))) + (not x7910)))) + g7907))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 + (letrec ((x7914 + (car + x))) + (car + x7914)))) + (car x7913)))) + (car x7912)))) + g7911))) + (negative? + (lambda (x) + (letrec ((g7915 + (letrec ((x7917 (number? x))) + (assert x7917))) + (g7916 (< x 0))) + g7916))) + (memv + (lambda (e l) + (letrec ((g7918 (memq e l))) g7918))) + (caaar + (lambda (x) + (letrec ((g7919 + (letrec ((x7920 + (letrec ((x7921 (car x))) + (car x7921)))) + (car x7920)))) + g7919))) + (debug + (lambda (e) (letrec ((g7922 '())) g7922))) + (reverse + (lambda (l) + (letrec ((g7923 + (letrec ((x7925 (list? l))) + (assert x7925))) + (g7924 + (letrec ((x-cnd7926 (null? l))) + (if x-cnd7926 + '() + (letrec ((x7929 + (letrec ((x7930 + (cdr l))) + (reverse x7930))) + (x7927 + (letrec ((x7928 + (car l))) + (list x7928)))) + (append x7929 x7927)))))) + g7924))) + (caaadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (car x7933)))) + (car x7932)))) + g7931))) + (cddadr + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (cdr + x))) + (car + x7938)))) + (cdr x7937)))) + (cdr x7936)))) + g7935))) + (odd? + (lambda (x) + (letrec ((g7939 + (letrec ((x7941 (number? x))) + (assert x7941))) + (g7940 + (letrec ((x7942 (modulo x 2))) + (= 1 x7942)))) + g7940))) + (caadar + (lambda (x) + (letrec ((g7943 + (letrec ((x7944 + (letrec ((x7945 + (letrec ((x7946 + (car + x))) + (cdr + x7946)))) + (car x7945)))) + (car x7944)))) + g7943))) + (apply + (lambda (proc args) + (letrec ((g7947 + (letrec ((x7950 (procedure? proc))) + (assert x7950))) + (g7948 + (letrec ((x7951 (list? args))) + (assert x7951))) + (g7949 + (if cnd + (letrec ((g7952 (proc))) g7952) + (if cnd + (letrec ((g7953 + (letrec ((x7954 + (car + args))) + (proc x7954)))) + g7953) + (if cnd + (letrec ((g7955 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args))) + (proc + x7957 + x7956)))) + g7955) + (if cnd + (letrec ((g7958 + (letrec ((x7961 + (car + args)) + (x7960 + (cadr + args)) + (x7959 + (caddr + args))) + (proc + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7962 + (letrec ((x7966 + (car + args)) + (x7965 + (cadr + args)) + (x7964 + (caddr + args)) + (x7963 + (cadddr + args))) + (proc + x7966 + x7965 + x7964 + x7963)))) + g7962) + (if cnd + (letrec ((g7967 + (letrec ((x7973 + (car + args)) + (x7972 + (cadr + args)) + (x7971 + (caddr + args)) + (x7970 + (cadddr + args)) + (x7968 + (letrec ((x7969 + (cddddr + args))) + (car + x7969)))) + (proc + x7973 + x7972 + x7971 + x7970 + x7968)))) + g7967) + (if cnd + (letrec ((g7974 + (letrec ((x7982 + (car + args)) + (x7981 + (cadr + args)) + (x7980 + (caddr + args)) + (x7979 + (cadddr + args)) + (x7977 + (letrec ((x7978 + (cddddr + args))) + (car + x7978))) + (x7975 + (letrec ((x7976 + (cddddr + args))) + (cadr + x7976)))) + (proc + x7982 + x7981 + x7980 + x7979 + x7977 + x7975)))) + g7974) + (if cnd + (letrec ((g7983 + (letrec ((x7993 + (car + args)) + (x7992 + (cadr + args)) + (x7991 + (caddr + args)) + (x7990 + (cadddr + args)) + (x7988 + (letrec ((x7989 + (cddddr + args))) + (car + x7989))) + (x7986 + (letrec ((x7987 + (cddddr + args))) + (cadr + x7987))) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (caddr + x7985)))) + (proc + x7993 + x7992 + x7991 + x7990 + x7988 + x7986 + x7984)))) + g7983) + (letrec ((g7994 + (error + "Unsupported call."))) + g7994))))))))))) + g7949))) + (member + (lambda (e l) + (letrec ((g7995 + (letrec ((x7997 (list? l))) + (assert x7997))) + (g7996 + (letrec ((x-cnd7998 (null? l))) + (if x-cnd7998 + #f + (letrec ((x-cnd7999 + (letrec ((x8000 + (car l))) + (equal? x8000 e)))) + (if x-cnd7999 + l + (letrec ((x8001 (cdr l))) + (member e x8001)))))))) + g7996))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (cdr x8003)))) + g8002))) + (cadddr + (lambda (x) + (letrec ((g8006 + (letrec ((x8007 + (letrec ((x8008 + (letrec ((x8009 + (cdr + x))) + (cdr + x8009)))) + (cdr x8008)))) + (car x8007)))) + g8006))) + (int-top + (lambda () + (letrec ((g8010 (random 42))) g8010))) + (zero? + (lambda (x) + (letrec ((g8011 + (letrec ((x8013 (number? x))) + (assert x8013))) + (g8012 (= x 0))) + g8012))) + (string>=? + (lambda (s1 s2) + (letrec ((g8014 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8015 + (if val7155 + val7155 + (string=? s1 s2)))) + g8015)))) + g8014))) + (cadr + (lambda (x) + (letrec ((g8016 + (letrec ((x8017 (cdr x))) + (car x8017)))) + g8016))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8018 + (letrec ((val7156 + (letrec ((x8021 + (pair? l)) + (x8019 + (letrec ((x8020 + (cdr + l))) + (list? + x8020)))) + (and x8021 x8019)))) + (letrec ((g8022 + (if val7156 + val7156 + (null? l)))) + g8022)))) + g8018))) + (cddaar + (lambda (x) + (letrec ((g8023 + (letrec ((x8024 + (letrec ((x8025 + (letrec ((x8026 + (car + x))) + (car + x8026)))) + (cdr x8025)))) + (cdr x8024)))) + g8023))) + (char-numeric? + (lambda (c) + (letrec ((g8027 + (letrec ((x-cnd8028 + (letrec ((x8029 #\0)) + (char<=? x8029 c)))) + (if x-cnd8028 + (letrec ((x8030 #\9)) + (char<=? c x8030)) + #f)))) + g8027))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8031 + (letrec ((x8033 (list? l))) + (assert x8033))) + (g8032 + (letrec ((x-cnd8034 (null? l))) + (if x-cnd8034 + #f + (letrec ((x-cnd8035 + (letrec ((x8036 + (caar l))) + (eqv? x8036 k)))) + (if x-cnd8035 + (car l) + (letrec ((x8037 (cdr l))) + (assq k x8037)))))))) + g8032))) + (not + (lambda (x) + (letrec ((g8038 (if x #f #t))) g8038))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8039 (append l1 l2))) g8039))) + (memq + (lambda (e l) + (letrec ((g8040 + (letrec ((x8042 (list? l))) + (assert x8042))) + (g8041 + (letrec ((x-cnd8043 (null? l))) + (if x-cnd8043 + #f + (letrec ((x-cnd8044 + (letrec ((x8045 + (car l))) + (eq? x8045 e)))) + (if x-cnd8044 + l + (letrec ((x8046 (cdr l))) + (memq e x8046)))))))) + g8041))) + (cadaar + (lambda (x) + (letrec ((g8047 + (letrec ((x8048 + (letrec ((x8049 + (letrec ((x8050 + (car + x))) + (car + x8050)))) + (cdr x8049)))) + (car x8048)))) + g8047))) + (length + (lambda (l) + (letrec ((g8051 + (letrec ((x8053 (list? l))) + (assert x8053))) + (g8052 + (letrec ((rec + (lambda (l) + (letrec ((g8054 + (letrec ((x-cnd8055 + (null? + l))) + (if x-cnd8055 + 0 + (letrec ((x8056 + (letrec ((x8057 + (cdr + l))) + (rec + x8057)))) + (+ + 1 + x8056)))))) + g8054)))) + (letrec ((g8058 (rec l))) + g8058)))) + g8052))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8059 + (letrec ((x8062 (char? c1))) + (assert x8062))) + (g8060 + (letrec ((x8063 (char? c2))) + (assert x8063))) + (g8061 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8065 + (letrec ((x8066 (string<=? s1 s2))) + (not x8066)))) + g8065))) + (cdadr + (lambda (x) + (letrec ((g8067 + (letrec ((x8068 + (letrec ((x8069 (cdr x))) + (car x8069)))) + (cdr x8068)))) + g8067))) + (assoc + (lambda (k l) + (letrec ((g8070 + (letrec ((x8072 (list? l))) + (assert x8072))) + (g8071 + (letrec ((x-cnd8073 (null? l))) + (if x-cnd8073 + #f + (letrec ((x-cnd8074 + (letrec ((x8075 + (caar l))) + (equal? x8075 k)))) + (if x-cnd8074 + (car l) + (letrec ((x8076 (cdr l))) + (assoc k x8076)))))))) + g8071))) + (caar + (lambda (x) + (letrec ((g8077 + (letrec ((x8078 (car x))) + (car x8078)))) + g8077))) + (char>? + (lambda (c1 c2) + (letrec ((g8079 + (letrec ((x8082 (char? c1))) + (assert x8082))) + (g8080 + (letrec ((x8083 (char? c2))) + (assert x8083))) + (g8081 + (letrec ((x8084 (char<=? c1 c2))) + (not x8084)))) + g8081))) + (string<=? + (lambda (s1 s2) + (letrec ((g8085 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8102 + (letrec ((x8105 (char? c1))) + (assert x8105))) + (g8103 + (letrec ((x8106 (char? c2))) + (assert x8106))) + (g8104 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8107 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8107)))) + g8104))) + (caddar + (lambda (x) + (letrec ((g8108 + (letrec ((x8109 + (letrec ((x8110 + (letrec ((x8111 + (car + x))) + (cdr + x8111)))) + (cdr x8110)))) + (car x8109)))) + g8108))) + (newline + (lambda () (letrec ((g8112 #f)) g8112))) + (lcm + (lambda (m n) + (letrec ((g8113 + (letrec ((x8115 + (letrec ((x8116 (* m n))) + (abs x8116))) + (x8114 (gcd m n))) + (/ x8115 x8114)))) + g8113))) + (deref car) + (> + (lambda (x y) + (letrec ((g8117 + (letrec ((x8119 (number? x))) + (assert x8119))) + (g8118 + (letrec ((x8120 (<= x y))) + (not x8120)))) + g8118))) + (list-ref + (lambda (l index) + (letrec ((g8121 + (letrec ((x8125 (list? l))) + (assert x8125))) + (g8122 + (letrec ((x8126 (number? index))) + (assert x8126))) + (g8123 + (letrec ((x8127 + (letrec ((x8128 + (length l))) + (< index x8128)))) + (assert x8127))) + (g8124 + (letrec ((x-cnd8129 (= index 0))) + (if x-cnd8129 + (car l) + (letrec ((x8131 (cdr l)) + (x8130 (- index 1))) + (list-ref x8131 x8130)))))) + g8124))) + (gcd + (lambda (a b) + (letrec ((g8132 + (letrec ((x-cnd8133 (= b 0))) + (if x-cnd8133 + a + (letrec ((x8134 (modulo a b))) + (gcd b x8134)))))) + g8132)))) + (letrec ((g8135 + (letrec ((g8136 + (letrec ((zip + (lambda (xs ys) + (letrec ((g8137 + (if cnd + (letrec ((g8138 + empty)) + g8138) + (if cnd + (letrec ((g8139 + (letrec ((x8143 + (letrec ((x8145 + (car + xs)) + (x8144 + (car + ys))) + (cons + x8145 + x8144))) + (x8140 + (letrec ((x8142 + (cdr + xs)) + (x8141 + (cdr + ys))) + (zip + x8142 + x8141)))) + (cons + x8143 + x8140)))) + g8139) + (letrec ((g8146 + 'fail)) + g8146))))) + g8137))) + (mk-list + (lambda (n) + (letrec ((g8147 + (letrec ((x-cnd8148 + (< + n + 0))) + (if x-cnd8148 + empty + (letrec ((x8149 + (letrec ((x8150 + (- + n + 1))) + (mk-list + x8150)))) + (cons + n + x8149)))))) + g8147))) + (main + (lambda (n) + (letrec ((g8151 + (letrec ((xs + (mk-list + n))) + (letrec ((g8152 + (zip + xs + xs))) + g8152)))) + g8151)))) + (letrec ((g8153 + (letrec ((g8154 + (letrec ((g8155 + (letrec ((x8158 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + ((listof + integer?/c) + j7230 + k7231 + (f7232 + (integer?/c + j7230 + k7231 + g7229))))) + 'module + 'importer + mk-list)) + (x8157 + (input))) + (x8158 + x8157))) + (g8156 + (letrec ((x8160 + ((lambda (j7234 + k7235 + f7236) + (lambda (g7233) + ((listof + (cons/c + integer?/c + integer?/c)) + j7234 + k7235 + (f7236 + (integer?/c + j7234 + k7235 + g7233))))) + 'module + 'importer + main)) + (x8159 + (input))) + (x8160 + x8159)))) + g8156))) + g8154))) + g8153)))) + g8136))) + g8135)))) + g7248))) + g7247)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_blur.rkt b/analyses/simpleactor/benchmarks-out/sergey_blur.rkt index ed32c16b..3f53105c 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_blur.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_blur.rkt @@ -1,22 +1,3080 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define id (λ (x) x)) - (define blur (λ (y) y)) - (define lp - (λ (a) - (λ (n) - (if (zero? n) - (id a) - (let* ((r ((blur id) #t)) (s ((blur id) #f))) - (not (((blur lp) s) (sub1 n)))))))) - ((lp #f) 2))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (letrec ((id + (letrec ((x8129 (x))) + (λ x8129 x))) + (blur + (letrec ((x8130 (y))) + (λ x8130 y))) + (lp + (letrec ((x8142 (a)) + (x8131 + (letrec ((x8141 + (n)) + (x8132 + (letrec ((x-cnd8133 + (zero? + n))) + (if x-cnd8133 + (id + a) + (letrec ((r + (letrec ((x8134 + (blur + id))) + (x8134 + #t))) + (s + (letrec ((x8135 + (blur + id))) + (x8135 + #f)))) + (letrec ((g8136 + (letrec ((x8137 + (letrec ((x8139 + (letrec ((x8140 + (blur + lp))) + (x8140 + s))) + (x8138 + (sub1 + n))) + (x8139 + x8138)))) + (not + x8137)))) + g8136)))))) + (λ x8141 + x8132)))) + (λ x8142 x8131)))) + (letrec ((g8143 + (letrec ((x8144 + (lp #f))) + (x8144 2)))) + g8143)))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_eta.rkt b/analyses/simpleactor/benchmarks-out/sergey_eta.rkt index 0b0c6199..4c21c21d 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_eta.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_eta.rkt @@ -1,16 +1,3057 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (do-something) 10) - (define (id y) (do-something) y) - ((id (λ (a) a)) #t) - ((id (λ (b) b)) #f))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (letrec ((do-something + (lambda () + (letrec ((g8129 10)) + g8129))) + (id + (lambda (y) + (letrec ((g8130 + (do-something)) + (g8131 y)) + g8131)))) + (letrec ((g8132 + (letrec ((x8134 + (letrec ((x8135 + (letrec ((x8136 + (a))) + (λ x8136 + a)))) + (id + x8135)))) + (x8134 #t))) + (g8133 + (letrec ((x8137 + (letrec ((x8138 + (letrec ((x8139 + (b))) + (λ x8139 + b)))) + (id + x8138)))) + (x8137 #f)))) + g8133)))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_kcfa2.rkt b/analyses/simpleactor/benchmarks-out/sergey_kcfa2.rkt index 0d3533cf..83a85d41 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_kcfa2.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_kcfa2.rkt @@ -1,16 +1,3085 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - ((λ (f1) (let ((a (f1 #t))) (f1 #f))) - (λ (x1) - ((λ (f2) (let ((b (f2 #t))) (let ((c (f2 #f))) (f2 #t)))) - (λ (x2) ((λ (z) (z x1 x2)) (λ (y1 y2) y1)))))))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (letrec ((x8145 + (letrec ((x8148 (f1)) + (x8146 + (letrec ((a + (f1 + #t))) + (letrec ((g8147 + (f1 + #f))) + g8147)))) + (λ x8148 x8146))) + (x8129 + (letrec ((x8144 (x1)) + (x8130 + (letrec ((x8139 + (letrec ((x8143 + (f2)) + (x8140 + (letrec ((b + (f2 + #t))) + (letrec ((g8141 + (letrec ((c + (f2 + #f))) + (letrec ((g8142 + (f2 + #t))) + g8142)))) + g8141)))) + (λ x8143 + x8140))) + (x8131 + (letrec ((x8138 + (x2)) + (x8132 + (letrec ((x8135 + (letrec ((x8137 + (z)) + (x8136 + (z + x1 + x2))) + (λ x8137 + x8136))) + (x8133 + (letrec ((x8134 + (y1 + y2))) + (λ x8134 + y1)))) + (x8135 + x8133)))) + (λ x8138 + x8132)))) + (x8139 + x8131)))) + (λ x8144 x8130)))) + (x8145 x8129)))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_kcfa3.rkt b/analyses/simpleactor/benchmarks-out/sergey_kcfa3.rkt index 46f8edfe..1fc3ca16 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_kcfa3.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_kcfa3.rkt @@ -1,18 +1,3103 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - ((λ (f1) (let ((a (f1 #t))) (f1 #f))) - (λ (x1) - ((λ (f2) (let ((b (f2 #t))) (f2 #f))) - (λ (x2) - ((λ (f3) (let ((c (f3 #t))) (f3 #f))) - (λ (x3) ((λ (z) (z x1 x2 x3)) (λ (y1 y2 y3) y1)))))))))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (letrec ((x8151 + (letrec ((x8154 (f1)) + (x8152 + (letrec ((a + (f1 + #t))) + (letrec ((g8153 + (f1 + #f))) + g8153)))) + (λ x8154 x8152))) + (x8129 + (letrec ((x8150 (x1)) + (x8130 + (letrec ((x8146 + (letrec ((x8149 + (f2)) + (x8147 + (letrec ((b + (f2 + #t))) + (letrec ((g8148 + (f2 + #f))) + g8148)))) + (λ x8149 + x8147))) + (x8131 + (letrec ((x8145 + (x2)) + (x8132 + (letrec ((x8141 + (letrec ((x8144 + (f3)) + (x8142 + (letrec ((c + (f3 + #t))) + (letrec ((g8143 + (f3 + #f))) + g8143)))) + (λ x8144 + x8142))) + (x8133 + (letrec ((x8140 + (x3)) + (x8134 + (letrec ((x8137 + (letrec ((x8139 + (z)) + (x8138 + (z + x1 + x2 + x3))) + (λ x8139 + x8138))) + (x8135 + (letrec ((x8136 + (y1 + y2 + y3))) + (λ x8136 + y1)))) + (x8137 + x8135)))) + (λ x8140 + x8134)))) + (x8141 + x8133)))) + (λ x8145 + x8132)))) + (x8146 + x8131)))) + (λ x8150 x8130)))) + (x8151 x8129)))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_loop2.rkt b/analyses/simpleactor/benchmarks-out/sergey_loop2.rkt index 741ca54f..2e70b529 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_loop2.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_loop2.rkt @@ -1,30 +1,3109 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (let ((lp1 2000)) - (let ((a - (set! lp1 - (λ (i x) - (let ((a (= 0 i))) - (if a - x - (let ((lp2 1000)) - (let ((b - (set! lp2 - (λ (j f y) - (let ((b (= 0 j))) - (if b - (lp1 (- i 1) y) - (let (($tmp$3 (f y))) - (lp2 (- j 1) f $tmp$3)))))))) - (lp2 10 (λ (n) (+ n i)) x))))))))) - (lp1 10 0))))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (letrec ((lp1 2000)) + (letrec ((g8129 + (letrec ((a + (letrec ((x8130 + (letrec ((x8145 + (i + x)) + (x8131 + (letrec ((a + (= + 0 + i))) + (letrec ((g8132 + (if a + x + (letrec ((lp2 + 1000)) + (letrec ((g8133 + (letrec ((b + (letrec ((x8134 + (letrec ((x8140 + (j + f + y)) + (x8135 + (letrec ((b + (= + 0 + j))) + (letrec ((g8136 + (if b + (letrec ((x8137 + (- + i + 1))) + (lp1 + x8137 + y)) + (letrec (($tmp$3 + (f + y))) + (letrec ((g8138 + (letrec ((x8139 + (- + j + 1))) + (lp2 + x8139 + f + $tmp$3)))) + g8138))))) + g8136)))) + (λ x8140 + x8135)))) + (set! lp2 + x8134)))) + (letrec ((g8141 + (letrec ((x8142 + (letrec ((x8144 + (n)) + (x8143 + (+ + n + i))) + (λ x8144 + x8143)))) + (lp2 + 10 + x8142 + x)))) + g8141)))) + g8133))))) + g8132)))) + (λ x8145 + x8131)))) + (set! lp1 + x8130)))) + (letrec ((g8146 + (lp1 + 10 + 0))) + g8146)))) + g8129)))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_mj09.rkt b/analyses/simpleactor/benchmarks-out/sergey_mj09.rkt index 96d675bc..5260c379 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_mj09.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_mj09.rkt @@ -1,18 +1,3068 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (let ((h - (λ (b) - (let ((g (λ (z) z))) - (let ((f (λ (k) (if b (k 1) (k 2))))) - (let ((y (f (λ (x) x)))) (g y))))))) - (let* ((x (h #t)) (y (h #f))) y)))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (letrec ((h + (letrec ((x8138 (b)) + (x8129 + (letrec ((g + (letrec ((x8130 + (z))) + (λ x8130 + z)))) + (letrec ((g8131 + (letrec ((f + (letrec ((x8133 + (k)) + (x8132 + (if b + (k + 1) + (k + 2)))) + (λ x8133 + x8132)))) + (letrec ((g8134 + (letrec ((y + (letrec ((x8135 + (letrec ((x8136 + (x))) + (λ x8136 + x)))) + (f + x8135)))) + (letrec ((g8137 + (g + y))) + g8137)))) + g8134)))) + g8131)))) + (λ x8138 x8129)))) + (letrec ((g8139 + (letrec ((x (h #t)) + (y (h #f))) + (letrec ((g8140 y)) + g8140)))) + g8139)))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/sergey_sat.rkt b/analyses/simpleactor/benchmarks-out/sergey_sat.rkt index 519096b4..a1083c53 100644 --- a/analyses/simpleactor/benchmarks-out/sergey_sat.rkt +++ b/analyses/simpleactor/benchmarks-out/sergey_sat.rkt @@ -1,46 +1,3199 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7230 #t)) g7230))) + (meta (lambda (v) (letrec ((g7231 v)) g7231))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7232 + (letrec ((g7233 + (letrec ((x-e7234 lst)) + (match + x-e7234 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7235 (eq? v v1))) + (if x-cnd7235 #t (member v vs))))))))) + g7233))) + g7232))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define phi - (λ (x1) - (λ (x2) - (λ (x3) - (λ (x4) - (λ (x5) - (λ (x6) - (λ (x7) - (and (or x1 x2) - (or x1 (not x2) (not x3)) - (or x3 x4) - (or (not x4) x1) - (or (not x2) (not x3)) - (or x4 x2)))))))))) - (define try (λ (f) (or (f #t) (f #f)))) - (define sat-solve-7 - (λ (p) - (try - (λ (n1) - (try - (λ (n2) - (try - (λ (n3) - (try - (λ (n4) - (try - (λ (n5) - (try - (λ (n6) - (try - (λ (n7) - (((((((p n1) n2) n3) n4) n5) n6) - n7))))))))))))))))) - (sat-solve-7 phi))) + (actor? + (lambda (k j) + (letrec ((g7236 (lambda (v) (letrec ((g7237 v)) g7237)))) g7236))) + (nonzero? + (lambda (v) + (letrec ((g7238 (letrec ((x7239 (= v 0))) (not x7239)))) g7238)))) + (letrec ((g7240 + (letrec ((g7241 + (letrec ((real/c + (lambda (g7161 g7162 g7163) + (letrec ((g7242 + (letrec ((x-cnd7243 (real? g7163))) + (if x-cnd7243 + g7163 + (blame g7161 'real?))))) + g7242))) + (boolean?/c + (lambda (g7164 g7165 g7166) + (letrec ((g7244 + (letrec ((x-cnd7245 + (boolean? g7166))) + (if x-cnd7245 + g7166 + (blame g7164 'boolean?))))) + g7244))) + (number?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7246 + (letrec ((x-cnd7247 + (number? g7169))) + (if x-cnd7247 + g7169 + (blame g7167 'number?))))) + g7246))) + (any/c + (lambda (g7170 g7171 g7172) + (letrec ((g7248 + (letrec ((x-cnd7249 + ((lambda (v) #t) g7172))) + (if x-cnd7249 + g7172 + (blame + g7170 + '(lambda (v) #t)))))) + g7248))) + (any?/c + (lambda (g7173 g7174 g7175) + (letrec ((g7250 + (letrec ((x-cnd7251 + ((lambda (v) #t) g7175))) + (if x-cnd7251 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7250))) + (image? any/c) + (cons?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7252 + (letrec ((x-cnd7253 (pair? g7178))) + (if x-cnd7253 + g7178 + (blame g7176 'pair?))))) + g7252))) + (pair?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7254 + (letrec ((x-cnd7255 (pair? g7181))) + (if x-cnd7255 + g7181 + (blame g7179 'pair?))))) + g7254))) + (integer? + (lambda (g7182 g7183 g7184) + (letrec ((g7256 + (letrec ((x-cnd7257 + (integer? g7184))) + (if x-cnd7257 + g7184 + (blame g7182 'integer?))))) + g7256))) + (and/c + (lambda (c1 c2) + (letrec ((g7258 + (lambda (k j v) + (letrec ((g7259 + (letrec ((x-cnd7260 + (c1 k j v))) + (if x-cnd7260 + (c2 k j v) + #f)))) + g7259)))) + g7258))) + (list-of + (lambda (contract) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (null? v))) + (if x-cnd7263 + '() + (letrec ((x7267 + (letrec ((x7268 + (car + v))) + (contract + k + j + x7268))) + (x7264 + (letrec ((x7266 + (list-of + contract)) + (x7265 + (cdr + v))) + (x7266 + k + j + x7265)))) + (cons + x7267 + x7264)))))) + g7262)))) + g7261))) + (any? (lambda (v) (letrec ((g7269 #t)) g7269))) + (nonzero? + (lambda (v) + (letrec ((g7270 + (letrec ((x7271 (= v 0))) + (not x7271)))) + g7270))) + (nonzero?/c + (lambda (g7185 g7186 g7187) + (letrec ((g7272 + (letrec ((x-cnd7273 + ((lambda (v) + (not (= v 0))) + g7187))) + (if x-cnd7273 + g7187 + (blame + g7185 + '(lambda (v) + (not (= v 0)))))))) + g7272))) + (meta (lambda (v) (letrec ((g7274 v)) g7274))) + (orig-+ +) + (+ + ((lambda (j7190 k7191 f7192) + (lambda (g7188 g7189) + (number?/c + j7190 + k7191 + (f7192 + (number?/c j7190 k7191 g7188) + (number?/c j7190 k7191 g7189))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7195 k7196 f7197) + (lambda (g7193 g7194) + (number?/c + j7195 + k7196 + (f7197 + (number?/c j7195 k7196 g7193) + (number?/c j7195 k7196 g7194))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7200 k7201 f7202) + (lambda (g7198 g7199) + (number?/c + j7200 + k7201 + (f7202 + (number?/c j7200 k7201 g7198) + (number?/c j7200 k7201 g7199))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7205 k7206 f7207) + (lambda (g7203 g7204) + (number?/c + j7205 + k7206 + (f7207 + (number?/c j7205 k7206 g7203) + (number?/c j7205 k7206 g7204))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7209 k7210 f7211) + (lambda (g7208) + (any/c + j7209 + k7210 + (f7211 (pair?/c j7209 k7210 g7208))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7213 k7214 f7215) + (lambda (g7212) + (any/c + j7213 + k7214 + (f7215 (pair?/c j7213 k7214 g7212))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7218 k7219 f7220) + (lambda (g7216 g7217) + (pair?/c + j7218 + k7219 + (f7220 + (any/c j7218 k7219 g7216) + (any/c j7218 k7219 g7217))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7222 k7223 f7224) + (lambda (g7221) + (integer?/c + j7222 + k7223 + (f7224 (vector?/c j7222 k7223 g7221))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7227 k7228 f7229) + (lambda (g7225 g7226) + (any/c + j7227 + k7228 + (f7229 + (vector?/c j7227 k7228 g7225) + (integer?/c j7227 k7228 g7226))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7275 #t)) g7275))) + (cdddr + (lambda (x) + (letrec ((g7276 + (letrec ((x7277 + (letrec ((x7278 (cdr x))) + (cdr x7278)))) + (cdr x7277)))) + g7276))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7279 + (letrec ((x7282 (procedure? f))) + (assert x7282))) + (g7280 + (letrec ((x7283 (list? l))) + (assert x7283))) + (g7281 + (letrec ((x-cnd7284 (null? l))) + (if x-cnd7284 + '() + (letrec ((x7287 + (letrec ((x7288 + (car l))) + (f x7288))) + (x7285 + (letrec ((x7286 + (cdr l))) + (map f x7286)))) + (cons x7287 x7285)))))) + g7281))) + (cdar + (lambda (x) + (letrec ((g7289 + (letrec ((x7290 (car x))) + (cdr x7290)))) + g7289))) + (cadadr + (lambda (x) + (letrec ((g7291 + (letrec ((x7292 + (letrec ((x7293 + (letrec ((x7294 + (cdr + x))) + (car + x7294)))) + (cdr x7293)))) + (car x7292)))) + g7291))) + (cdadar + (lambda (x) + (letrec ((g7295 + (letrec ((x7296 + (letrec ((x7297 + (letrec ((x7298 + (car + x))) + (cdr + x7298)))) + (car x7297)))) + (cdr x7296)))) + g7295))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7299 + (letrec ((x7302 + (string? filename))) + (assert x7302))) + (g7300 + (letrec ((x7303 (procedure? proc))) + (assert x7303))) + (g7301 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7304 + (close-output-port + output-port)) + (g7305 res)) + g7305)))) + g7301))) + (caddr + (lambda (x) + (letrec ((g7306 + (letrec ((x7307 + (letrec ((x7308 (cdr x))) + (cdr x7308)))) + (car x7307)))) + g7306))) + (cdaadr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 + (letrec ((x7312 + (cdr + x))) + (car + x7312)))) + (car x7311)))) + (cdr x7310)))) + g7309))) + (assq + (lambda (k l) + (letrec ((g7313 + (letrec ((x7315 (list? l))) + (assert x7315))) + (g7314 + (letrec ((x-cnd7316 (null? l))) + (if x-cnd7316 + #f + (letrec ((x-cnd7317 + (letrec ((x7318 + (caar l))) + (eq? x7318 k)))) + (if x-cnd7317 + (car l) + (letrec ((x7319 (cdr l))) + (assq k x7319)))))))) + g7314))) + (even? + (lambda (x) + (letrec ((g7320 + (letrec ((x7321 (modulo x 2))) + (= 0 x7321)))) + g7320))) + (list->string + (lambda (l) + (letrec ((g7322 + (letrec ((x7324 (list? l))) + (assert x7324))) + (g7323 + (letrec ((x-cnd7325 (null? l))) + (if x-cnd7325 + "" + (letrec ((x7328 + (letrec ((x7329 + (car l))) + (char->string + x7329))) + (x7326 + (letrec ((x7327 + (cdr l))) + (list->string + x7327)))) + (string-append + x7328 + x7326)))))) + g7323))) + (char<=? + (lambda (c1 c2) + (letrec ((g7330 + (letrec ((x7333 (char? c1))) + (assert x7333))) + (g7331 + (letrec ((x7334 (char? c2))) + (assert x7334))) + (g7332 + (letrec ((val7143 (char=? c x7351)))) + (if x-cnd7350 + (letrec ((x7352 #\z)) + (char-ci<=? c x7352)) + #f)))) + g7349))) + (<= + (lambda (x y) + (letrec ((g7353 + (letrec ((x7355 (number? x))) + (assert x7355))) + (g7354 + (letrec ((val7144 (< x y))) + (letrec ((g7356 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7357 + (if val7145 + val7145 + #f))) + g7357))))) + g7356)))) + g7354))) + (char-whitespace? + (lambda (c) + (letrec ((g7358 + (letrec ((val7146 + (letrec ((x7359 + (char->integer + c))) + (= x7359 9)))) + (letrec ((g7360 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7361 + (char->integer + c))) + (= + x7361 + 10)))) + (letrec ((g7362 + (if val7147 + val7147 + (letrec ((x7363 + (char->integer + c))) + (= + x7363 + 32))))) + g7362))))) + g7360)))) + g7358))) + (cddar + (lambda (x) + (letrec ((g7364 + (letrec ((x7365 + (letrec ((x7366 (car x))) + (cdr x7366)))) + (cdr x7365)))) + g7364))) + (positive? + (lambda (x) + (letrec ((g7367 + (letrec ((x7369 (number? x))) + (assert x7369))) + (g7368 (> x 0))) + g7368))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7370 #f)) g7370))) + (cddr + (lambda (x) + (letrec ((g7371 + (letrec ((x7372 (cdr x))) + (cdr x7372)))) + g7371))) + (truncate + (lambda (x) + (letrec ((g7373 + (letrec ((x7375 (number? x))) + (assert x7375))) + (g7374 + (letrec ((x-cnd7376 (< x 0))) + (if x-cnd7376 + (ceiling x) + (floor x))))) + g7374))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7377 + (letrec ((val7148 (eq? a b))) + (letrec ((g7378 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7380 + (null? + a)) + (x7379 + (null? + b))) + (and x7380 + x7379)))) + (letrec ((g7381 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7384 + (string? + a)) + (x7383 + (string? + b)) + (x7382 + (string=? + a + b))) + (and x7384 + x7383 + x7382)))) + (letrec ((g7385 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7393 + (pair? + a)) + (x7392 + (pair? + b)) + (x7389 + (letrec ((x7391 + (car + a)) + (x7390 + (car + b))) + (equal? + x7391 + x7390))) + (x7386 + (letrec ((x7388 + (cdr + a)) + (x7387 + (cdr + b))) + (equal? + x7388 + x7387)))) + (and x7393 + x7392 + x7389 + x7386)))) + (letrec ((g7394 + (if val7151 + val7151 + (letrec ((x7413 + (vector? + a)) + (x7412 + (vector? + b)) + (x7395 + (letrec ((x7409 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + a))) + (n + x7411)))) + (x7410))) + (x7396 + (letrec ((x7407 + (letrec ((x7408 + (vector-length + b))) + (= + x7408 + n))) + (x7397 + (letrec ((loop + (lambda (i) + (letrec ((g7398 + (letrec ((x7405 + (= + i + n)) + (x7399 + (letrec ((x7402 + (letrec ((x7404 + (vector-ref + a + i)) + (x7403 + (vector-ref + b + i))) + (equal? + x7404 + x7403))) + (x7400 + (letrec ((x7401 + (+ + i + 1))) + (loop + x7401)))) + (and x7402 + x7400)))) + (or x7405 + x7399)))) + g7398)))) + (letrec ((g7406 + (loop + 0))) + g7406)))) + (and x7407 + x7397)))) + (let x7409 x7396)))) + (and x7413 + x7412 + x7395))))) + g7394))))) + g7385))))) + g7381))))) + g7378)))) + g7377))) + (cdaaar + (lambda (x) + (letrec ((g7414 + (letrec ((x7415 + (letrec ((x7416 + (letrec ((x7417 + (car + x))) + (car + x7417)))) + (car x7416)))) + (cdr x7415)))) + g7414))) + (caaddr + (lambda (x) + (letrec ((g7418 + (letrec ((x7419 + (letrec ((x7420 + (letrec ((x7421 + (cdr + x))) + (cdr + x7421)))) + (car x7420)))) + (car x7419)))) + g7418))) + (eqv? + (lambda (x y) + (letrec ((g7422 (eq? x y))) g7422))) + (>= + (lambda (x y) + (letrec ((g7423 + (letrec ((x7425 (number? x))) + (assert x7425))) + (g7424 + (letrec ((val7152 (> x y))) + (letrec ((g7426 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7427 + (if val7153 + val7153 + #f))) + g7427))))) + g7426)))) + g7424))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7428 + (letrec ((x7431 + (string? filename))) + (assert x7431))) + (g7429 + (letrec ((x7432 (procedure? proc))) + (assert x7432))) + (g7430 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7433 + (close-input-port + input-port)) + (g7434 res)) + g7434)))) + g7430))) + (ref + (lambda (x) + (letrec ((g7435 (cons x '()))) g7435))) + (char>=? + (lambda (c1 c2) + (letrec ((g7436 + (letrec ((x7439 (char? c1))) + (assert x7439))) + (g7437 + (letrec ((x7440 (char? c2))) + (assert x7440))) + (g7438 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7441 + (if val7154 + val7154 + (char=? c1 c2)))) + g7441)))) + g7438))) + (cdaar + (lambda (x) + (letrec ((g7442 + (letrec ((x7443 + (letrec ((x7444 (car x))) + (car x7444)))) + (cdr x7443)))) + g7442))) + (cdaddr + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 + (letrec ((x7448 + (cdr + x))) + (cdr + x7448)))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7449 + (letrec ((x7450 + (letrec ((x7451 (car x))) + (cdr x7451)))) + (car x7450)))) + g7449))) + (caadr + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (cdr x))) + (car x7454)))) + (car x7453)))) + g7452))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7455 + (letrec ((x7458 (char? c1))) + (assert x7458))) + (g7456 + (letrec ((x7459 (char? c2))) + (assert x7459))) + (g7457 + (letrec ((x7460 + (char-ci<=? c1 c2))) + (not x7460)))) + g7457))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7461 + (letrec ((x7462 + (letrec ((x7463 + (letrec ((x7464 + (car + x))) + (car + x7464)))) + (car x7463)))) + (car x7462)))) + g7461))) + (negative? + (lambda (x) + (letrec ((g7465 + (letrec ((x7467 (number? x))) + (assert x7467))) + (g7466 (< x 0))) + g7466))) + (memv + (lambda (e l) + (letrec ((g7468 (memq e l))) g7468))) + (caaar + (lambda (x) + (letrec ((g7469 + (letrec ((x7470 + (letrec ((x7471 (car x))) + (car x7471)))) + (car x7470)))) + g7469))) + (debug + (lambda (e) (letrec ((g7472 '())) g7472))) + (reverse + (lambda (l) + (letrec ((g7473 + (letrec ((x7475 (list? l))) + (assert x7475))) + (g7474 + (letrec ((x-cnd7476 (null? l))) + (if x-cnd7476 + '() + (letrec ((x7479 + (letrec ((x7480 + (cdr l))) + (reverse x7480))) + (x7477 + (letrec ((x7478 + (car l))) + (list x7478)))) + (append x7479 x7477)))))) + g7474))) + (caaadr + (lambda (x) + (letrec ((g7481 + (letrec ((x7482 + (letrec ((x7483 + (letrec ((x7484 + (cdr + x))) + (car + x7484)))) + (car x7483)))) + (car x7482)))) + g7481))) + (cddadr + (lambda (x) + (letrec ((g7485 + (letrec ((x7486 + (letrec ((x7487 + (letrec ((x7488 + (cdr + x))) + (car + x7488)))) + (cdr x7487)))) + (cdr x7486)))) + g7485))) + (odd? + (lambda (x) + (letrec ((g7489 + (letrec ((x7491 (number? x))) + (assert x7491))) + (g7490 + (letrec ((x7492 (modulo x 2))) + (= 1 x7492)))) + g7490))) + (caadar + (lambda (x) + (letrec ((g7493 + (letrec ((x7494 + (letrec ((x7495 + (letrec ((x7496 + (car + x))) + (cdr + x7496)))) + (car x7495)))) + (car x7494)))) + g7493))) + (apply + (lambda (proc args) + (letrec ((g7497 + (letrec ((x7500 (procedure? proc))) + (assert x7500))) + (g7498 + (letrec ((x7501 (list? args))) + (assert x7501))) + (g7499 + (if cnd + (letrec ((g7502 (proc))) g7502) + (if cnd + (letrec ((g7503 + (letrec ((x7504 + (car + args))) + (proc x7504)))) + g7503) + (if cnd + (letrec ((g7505 + (letrec ((x7507 + (car + args)) + (x7506 + (cadr + args))) + (proc + x7507 + x7506)))) + g7505) + (if cnd + (letrec ((g7508 + (letrec ((x7511 + (car + args)) + (x7510 + (cadr + args)) + (x7509 + (caddr + args))) + (proc + x7511 + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7512 + (letrec ((x7516 + (car + args)) + (x7515 + (cadr + args)) + (x7514 + (caddr + args)) + (x7513 + (cadddr + args))) + (proc + x7516 + x7515 + x7514 + x7513)))) + g7512) + (if cnd + (letrec ((g7517 + (letrec ((x7523 + (car + args)) + (x7522 + (cadr + args)) + (x7521 + (caddr + args)) + (x7520 + (cadddr + args)) + (x7518 + (letrec ((x7519 + (cddddr + args))) + (car + x7519)))) + (proc + x7523 + x7522 + x7521 + x7520 + x7518)))) + g7517) + (if cnd + (letrec ((g7524 + (letrec ((x7532 + (car + args)) + (x7531 + (cadr + args)) + (x7530 + (caddr + args)) + (x7529 + (cadddr + args)) + (x7527 + (letrec ((x7528 + (cddddr + args))) + (car + x7528))) + (x7525 + (letrec ((x7526 + (cddddr + args))) + (cadr + x7526)))) + (proc + x7532 + x7531 + x7530 + x7529 + x7527 + x7525)))) + g7524) + (if cnd + (letrec ((g7533 + (letrec ((x7543 + (car + args)) + (x7542 + (cadr + args)) + (x7541 + (caddr + args)) + (x7540 + (cadddr + args)) + (x7538 + (letrec ((x7539 + (cddddr + args))) + (car + x7539))) + (x7536 + (letrec ((x7537 + (cddddr + args))) + (cadr + x7537))) + (x7534 + (letrec ((x7535 + (cddddr + args))) + (caddr + x7535)))) + (proc + x7543 + x7542 + x7541 + x7540 + x7538 + x7536 + x7534)))) + g7533) + (letrec ((g7544 + (error + "Unsupported call."))) + g7544))))))))))) + g7499))) + (member + (lambda (e l) + (letrec ((g7545 + (letrec ((x7547 (list? l))) + (assert x7547))) + (g7546 + (letrec ((x-cnd7548 (null? l))) + (if x-cnd7548 + #f + (letrec ((x-cnd7549 + (letrec ((x7550 + (car l))) + (equal? x7550 e)))) + (if x-cnd7549 + l + (letrec ((x7551 (cdr l))) + (member e x7551)))))))) + g7546))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7552 + (letrec ((x7553 + (letrec ((x7554 + (letrec ((x7555 + (cdr + x))) + (cdr + x7555)))) + (cdr x7554)))) + (cdr x7553)))) + g7552))) + (cadddr + (lambda (x) + (letrec ((g7556 + (letrec ((x7557 + (letrec ((x7558 + (letrec ((x7559 + (cdr + x))) + (cdr + x7559)))) + (cdr x7558)))) + (car x7557)))) + g7556))) + (int-top + (lambda () + (letrec ((g7560 (random 42))) g7560))) + (zero? + (lambda (x) + (letrec ((g7561 + (letrec ((x7563 (number? x))) + (assert x7563))) + (g7562 (= x 0))) + g7562))) + (string>=? + (lambda (s1 s2) + (letrec ((g7564 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7565 + (if val7155 + val7155 + (string=? s1 s2)))) + g7565)))) + g7564))) + (cadr + (lambda (x) + (letrec ((g7566 + (letrec ((x7567 (cdr x))) + (car x7567)))) + g7566))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7568 + (letrec ((val7156 + (letrec ((x7571 + (pair? l)) + (x7569 + (letrec ((x7570 + (cdr + l))) + (list? + x7570)))) + (and x7571 x7569)))) + (letrec ((g7572 + (if val7156 + val7156 + (null? l)))) + g7572)))) + g7568))) + (cddaar + (lambda (x) + (letrec ((g7573 + (letrec ((x7574 + (letrec ((x7575 + (letrec ((x7576 + (car + x))) + (car + x7576)))) + (cdr x7575)))) + (cdr x7574)))) + g7573))) + (char-numeric? + (lambda (c) + (letrec ((g7577 + (letrec ((x-cnd7578 + (letrec ((x7579 #\0)) + (char<=? x7579 c)))) + (if x-cnd7578 + (letrec ((x7580 #\9)) + (char<=? c x7580)) + #f)))) + g7577))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7581 + (letrec ((x7583 (list? l))) + (assert x7583))) + (g7582 + (letrec ((x-cnd7584 (null? l))) + (if x-cnd7584 + #f + (letrec ((x-cnd7585 + (letrec ((x7586 + (caar l))) + (eqv? x7586 k)))) + (if x-cnd7585 + (car l) + (letrec ((x7587 (cdr l))) + (assq k x7587)))))))) + g7582))) + (not + (lambda (x) + (letrec ((g7588 (if x #f #t))) g7588))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7589 (append l1 l2))) g7589))) + (memq + (lambda (e l) + (letrec ((g7590 + (letrec ((x7592 (list? l))) + (assert x7592))) + (g7591 + (letrec ((x-cnd7593 (null? l))) + (if x-cnd7593 + #f + (letrec ((x-cnd7594 + (letrec ((x7595 + (car l))) + (eq? x7595 e)))) + (if x-cnd7594 + l + (letrec ((x7596 (cdr l))) + (memq e x7596)))))))) + g7591))) + (cadaar + (lambda (x) + (letrec ((g7597 + (letrec ((x7598 + (letrec ((x7599 + (letrec ((x7600 + (car + x))) + (car + x7600)))) + (cdr x7599)))) + (car x7598)))) + g7597))) + (length + (lambda (l) + (letrec ((g7601 + (letrec ((x7603 (list? l))) + (assert x7603))) + (g7602 + (letrec ((rec + (lambda (l) + (letrec ((g7604 + (letrec ((x-cnd7605 + (null? + l))) + (if x-cnd7605 + 0 + (letrec ((x7606 + (letrec ((x7607 + (cdr + l))) + (rec + x7607)))) + (+ + 1 + x7606)))))) + g7604)))) + (letrec ((g7608 (rec l))) + g7608)))) + g7602))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7609 + (letrec ((x7612 (char? c1))) + (assert x7612))) + (g7610 + (letrec ((x7613 (char? c2))) + (assert x7613))) + (g7611 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7615 + (letrec ((x7616 (string<=? s1 s2))) + (not x7616)))) + g7615))) + (cdadr + (lambda (x) + (letrec ((g7617 + (letrec ((x7618 + (letrec ((x7619 (cdr x))) + (car x7619)))) + (cdr x7618)))) + g7617))) + (assoc + (lambda (k l) + (letrec ((g7620 + (letrec ((x7622 (list? l))) + (assert x7622))) + (g7621 + (letrec ((x-cnd7623 (null? l))) + (if x-cnd7623 + #f + (letrec ((x-cnd7624 + (letrec ((x7625 + (caar l))) + (equal? x7625 k)))) + (if x-cnd7624 + (car l) + (letrec ((x7626 (cdr l))) + (assoc k x7626)))))))) + g7621))) + (caar + (lambda (x) + (letrec ((g7627 + (letrec ((x7628 (car x))) + (car x7628)))) + g7627))) + (char>? + (lambda (c1 c2) + (letrec ((g7629 + (letrec ((x7632 (char? c1))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char? c2))) + (assert x7633))) + (g7631 + (letrec ((x7634 (char<=? c1 c2))) + (not x7634)))) + g7631))) + (string<=? + (lambda (s1 s2) + (letrec ((g7635 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7652 + (letrec ((x7655 (char? c1))) + (assert x7655))) + (g7653 + (letrec ((x7656 (char? c2))) + (assert x7656))) + (g7654 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7657 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7657)))) + g7654))) + (caddar + (lambda (x) + (letrec ((g7658 + (letrec ((x7659 + (letrec ((x7660 + (letrec ((x7661 + (car + x))) + (cdr + x7661)))) + (cdr x7660)))) + (car x7659)))) + g7658))) + (newline + (lambda () (letrec ((g7662 #f)) g7662))) + (lcm + (lambda (m n) + (letrec ((g7663 + (letrec ((x7665 + (letrec ((x7666 (* m n))) + (abs x7666))) + (x7664 (gcd m n))) + (/ x7665 x7664)))) + g7663))) + (deref car) + (> + (lambda (x y) + (letrec ((g7667 + (letrec ((x7669 (number? x))) + (assert x7669))) + (g7668 + (letrec ((x7670 (<= x y))) + (not x7670)))) + g7668))) + (list-ref + (lambda (l index) + (letrec ((g7671 + (letrec ((x7675 (list? l))) + (assert x7675))) + (g7672 + (letrec ((x7676 (number? index))) + (assert x7676))) + (g7673 + (letrec ((x7677 + (letrec ((x7678 + (length l))) + (< index x7678)))) + (assert x7677))) + (g7674 + (letrec ((x-cnd7679 (= index 0))) + (if x-cnd7679 + (car l) + (letrec ((x7681 (cdr l)) + (x7680 (- index 1))) + (list-ref x7681 x7680)))))) + g7674))) + (gcd + (lambda (a b) + (letrec ((g7682 + (letrec ((x-cnd7683 (= b 0))) + (if x-cnd7683 + a + (letrec ((x7684 (modulo a b))) + (gcd b x7684)))))) + g7682))) + (real/c + (lambda (g7161 g7162 g7163) + (letrec ((g7685 + (letrec ((x-cnd7686 (real? g7163))) + (if x-cnd7686 + g7163 + (blame g7161 'real?))))) + g7685))) + (boolean?/c + (lambda (g7164 g7165 g7166) + (letrec ((g7687 + (letrec ((x-cnd7688 + (boolean? g7166))) + (if x-cnd7688 + g7166 + (blame g7164 'boolean?))))) + g7687))) + (number?/c + (lambda (g7167 g7168 g7169) + (letrec ((g7689 + (letrec ((x-cnd7690 + (number? g7169))) + (if x-cnd7690 + g7169 + (blame g7167 'number?))))) + g7689))) + (any/c + (lambda (g7170 g7171 g7172) + (letrec ((g7691 + (letrec ((x-cnd7692 + ((lambda (v) #t) g7172))) + (if x-cnd7692 + g7172 + (blame + g7170 + '(lambda (v) #t)))))) + g7691))) + (any?/c + (lambda (g7173 g7174 g7175) + (letrec ((g7693 + (letrec ((x-cnd7694 + ((lambda (v) #t) g7175))) + (if x-cnd7694 + g7175 + (blame + g7173 + '(lambda (v) #t)))))) + g7693))) + (image? any/c) + (cons?/c + (lambda (g7176 g7177 g7178) + (letrec ((g7695 + (letrec ((x-cnd7696 (pair? g7178))) + (if x-cnd7696 + g7178 + (blame g7176 'pair?))))) + g7695))) + (pair?/c + (lambda (g7179 g7180 g7181) + (letrec ((g7697 + (letrec ((x-cnd7698 (pair? g7181))) + (if x-cnd7698 + g7181 + (blame g7179 'pair?))))) + g7697))) + (integer? + (lambda (g7182 g7183 g7184) + (letrec ((g7699 + (letrec ((x-cnd7700 + (integer? g7184))) + (if x-cnd7700 + g7184 + (blame g7182 'integer?))))) + g7699))) + (and/c + (lambda (c1 c2) + (letrec ((g7701 + (lambda (k j v) + (letrec ((g7702 + (letrec ((x-cnd7703 + (c1 k j v))) + (if x-cnd7703 + (c2 k j v) + #f)))) + g7702)))) + g7701))) + (list-of + (lambda (contract) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (null? v))) + (if x-cnd7706 + '() + (letrec ((x7710 + (letrec ((x7711 + (car + v))) + (contract + k + j + x7711))) + (x7707 + (letrec ((x7709 + (list-of + contract)) + (x7708 + (cdr + v))) + (x7709 + k + j + x7708)))) + (cons + x7710 + x7707)))))) + g7705)))) + g7704))) + (any? (lambda (v) (letrec ((g7712 #t)) g7712))) + (nonzero? + (lambda (v) + (letrec ((g7713 + (letrec ((x7714 (= v 0))) + (not x7714)))) + g7713))) + (nonzero?/c + (lambda (g7185 g7186 g7187) + (letrec ((g7715 + (letrec ((x-cnd7716 + ((lambda (v) + (not (= v 0))) + g7187))) + (if x-cnd7716 + g7187 + (blame + g7185 + '(lambda (v) + (not (= v 0)))))))) + g7715))) + (meta (lambda (v) (letrec ((g7717 v)) g7717))) + (orig-+ +) + (+ + ((lambda (j7190 k7191 f7192) + (lambda (g7188 g7189) + (number?/c + j7190 + k7191 + (f7192 + (number?/c j7190 k7191 g7188) + (number?/c j7190 k7191 g7189))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7195 k7196 f7197) + (lambda (g7193 g7194) + (number?/c + j7195 + k7196 + (f7197 + (number?/c j7195 k7196 g7193) + (number?/c j7195 k7196 g7194))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7200 k7201 f7202) + (lambda (g7198 g7199) + (number?/c + j7200 + k7201 + (f7202 + (number?/c j7200 k7201 g7198) + (number?/c j7200 k7201 g7199))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7205 k7206 f7207) + (lambda (g7203 g7204) + (number?/c + j7205 + k7206 + (f7207 + (number?/c j7205 k7206 g7203) + (number?/c j7205 k7206 g7204))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7209 k7210 f7211) + (lambda (g7208) + (any/c + j7209 + k7210 + (f7211 (pair?/c j7209 k7210 g7208))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7213 k7214 f7215) + (lambda (g7212) + (any/c + j7213 + k7214 + (f7215 (pair?/c j7213 k7214 g7212))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7218 k7219 f7220) + (lambda (g7216 g7217) + (pair?/c + j7218 + k7219 + (f7220 + (any/c j7218 k7219 g7216) + (any/c j7218 k7219 g7217))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7222 k7223 f7224) + (lambda (g7221) + (integer?/c + j7222 + k7223 + (f7224 (vector?/c j7222 k7223 g7221))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7227 k7228 f7229) + (lambda (g7225 g7226) + (any/c + j7227 + k7228 + (f7229 + (vector?/c j7227 k7228 g7225) + (integer?/c j7227 k7228 g7226))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7718 #t)) g7718))) + (cdddr + (lambda (x) + (letrec ((g7719 + (letrec ((x7720 + (letrec ((x7721 (cdr x))) + (cdr x7721)))) + (cdr x7720)))) + g7719))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7722 + (letrec ((x7725 (procedure? f))) + (assert x7725))) + (g7723 + (letrec ((x7726 (list? l))) + (assert x7726))) + (g7724 + (letrec ((x-cnd7727 (null? l))) + (if x-cnd7727 + '() + (letrec ((x7730 + (letrec ((x7731 + (car l))) + (f x7731))) + (x7728 + (letrec ((x7729 + (cdr l))) + (map f x7729)))) + (cons x7730 x7728)))))) + g7724))) + (cdar + (lambda (x) + (letrec ((g7732 + (letrec ((x7733 (car x))) + (cdr x7733)))) + g7732))) + (cadadr + (lambda (x) + (letrec ((g7734 + (letrec ((x7735 + (letrec ((x7736 + (letrec ((x7737 + (cdr + x))) + (car + x7737)))) + (cdr x7736)))) + (car x7735)))) + g7734))) + (cdadar + (lambda (x) + (letrec ((g7738 + (letrec ((x7739 + (letrec ((x7740 + (letrec ((x7741 + (car + x))) + (cdr + x7741)))) + (car x7740)))) + (cdr x7739)))) + g7738))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7742 + (letrec ((x7745 + (string? filename))) + (assert x7745))) + (g7743 + (letrec ((x7746 (procedure? proc))) + (assert x7746))) + (g7744 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7747 + (close-output-port + output-port)) + (g7748 res)) + g7748)))) + g7744))) + (caddr + (lambda (x) + (letrec ((g7749 + (letrec ((x7750 + (letrec ((x7751 (cdr x))) + (cdr x7751)))) + (car x7750)))) + g7749))) + (cdaadr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 + (letrec ((x7755 + (cdr + x))) + (car + x7755)))) + (car x7754)))) + (cdr x7753)))) + g7752))) + (assq + (lambda (k l) + (letrec ((g7756 + (letrec ((x7758 (list? l))) + (assert x7758))) + (g7757 + (letrec ((x-cnd7759 (null? l))) + (if x-cnd7759 + #f + (letrec ((x-cnd7760 + (letrec ((x7761 + (caar l))) + (eq? x7761 k)))) + (if x-cnd7760 + (car l) + (letrec ((x7762 (cdr l))) + (assq k x7762)))))))) + g7757))) + (even? + (lambda (x) + (letrec ((g7763 + (letrec ((x7764 (modulo x 2))) + (= 0 x7764)))) + g7763))) + (list->string + (lambda (l) + (letrec ((g7765 + (letrec ((x7767 (list? l))) + (assert x7767))) + (g7766 + (letrec ((x-cnd7768 (null? l))) + (if x-cnd7768 + "" + (letrec ((x7771 + (letrec ((x7772 + (car l))) + (char->string + x7772))) + (x7769 + (letrec ((x7770 + (cdr l))) + (list->string + x7770)))) + (string-append + x7771 + x7769)))))) + g7766))) + (char<=? + (lambda (c1 c2) + (letrec ((g7773 + (letrec ((x7776 (char? c1))) + (assert x7776))) + (g7774 + (letrec ((x7777 (char? c2))) + (assert x7777))) + (g7775 + (letrec ((val7143 (char=? c x7794)))) + (if x-cnd7793 + (letrec ((x7795 #\z)) + (char-ci<=? c x7795)) + #f)))) + g7792))) + (<= + (lambda (x y) + (letrec ((g7796 + (letrec ((x7798 (number? x))) + (assert x7798))) + (g7797 + (letrec ((val7144 (< x y))) + (letrec ((g7799 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7800 + (if val7145 + val7145 + #f))) + g7800))))) + g7799)))) + g7797))) + (char-whitespace? + (lambda (c) + (letrec ((g7801 + (letrec ((val7146 + (letrec ((x7802 + (char->integer + c))) + (= x7802 9)))) + (letrec ((g7803 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7804 + (char->integer + c))) + (= + x7804 + 10)))) + (letrec ((g7805 + (if val7147 + val7147 + (letrec ((x7806 + (char->integer + c))) + (= + x7806 + 32))))) + g7805))))) + g7803)))) + g7801))) + (cddar + (lambda (x) + (letrec ((g7807 + (letrec ((x7808 + (letrec ((x7809 (car x))) + (cdr x7809)))) + (cdr x7808)))) + g7807))) + (positive? + (lambda (x) + (letrec ((g7810 + (letrec ((x7812 (number? x))) + (assert x7812))) + (g7811 (> x 0))) + g7811))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7813 #f)) g7813))) + (cddr + (lambda (x) + (letrec ((g7814 + (letrec ((x7815 (cdr x))) + (cdr x7815)))) + g7814))) + (truncate + (lambda (x) + (letrec ((g7816 + (letrec ((x7818 (number? x))) + (assert x7818))) + (g7817 + (letrec ((x-cnd7819 (< x 0))) + (if x-cnd7819 + (ceiling x) + (floor x))))) + g7817))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7820 + (letrec ((val7148 (eq? a b))) + (letrec ((g7821 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7823 + (null? + a)) + (x7822 + (null? + b))) + (and x7823 + x7822)))) + (letrec ((g7824 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7827 + (string? + a)) + (x7826 + (string? + b)) + (x7825 + (string=? + a + b))) + (and x7827 + x7826 + x7825)))) + (letrec ((g7828 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7836 + (pair? + a)) + (x7835 + (pair? + b)) + (x7832 + (letrec ((x7834 + (car + a)) + (x7833 + (car + b))) + (equal? + x7834 + x7833))) + (x7829 + (letrec ((x7831 + (cdr + a)) + (x7830 + (cdr + b))) + (equal? + x7831 + x7830)))) + (and x7836 + x7835 + x7832 + x7829)))) + (letrec ((g7837 + (if val7151 + val7151 + (letrec ((x7856 + (vector? + a)) + (x7855 + (vector? + b)) + (x7838 + (letrec ((x7852 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + a))) + (n + x7854)))) + (x7853))) + (x7839 + (letrec ((x7850 + (letrec ((x7851 + (vector-length + b))) + (= + x7851 + n))) + (x7840 + (letrec ((loop + (lambda (i) + (letrec ((g7841 + (letrec ((x7848 + (= + i + n)) + (x7842 + (letrec ((x7845 + (letrec ((x7847 + (vector-ref + a + i)) + (x7846 + (vector-ref + b + i))) + (equal? + x7847 + x7846))) + (x7843 + (letrec ((x7844 + (+ + i + 1))) + (loop + x7844)))) + (and x7845 + x7843)))) + (or x7848 + x7842)))) + g7841)))) + (letrec ((g7849 + (loop + 0))) + g7849)))) + (and x7850 + x7840)))) + (let x7852 x7839)))) + (and x7856 + x7855 + x7838))))) + g7837))))) + g7828))))) + g7824))))) + g7821)))) + g7820))) + (cdaaar + (lambda (x) + (letrec ((g7857 + (letrec ((x7858 + (letrec ((x7859 + (letrec ((x7860 + (car + x))) + (car + x7860)))) + (car x7859)))) + (cdr x7858)))) + g7857))) + (caaddr + (lambda (x) + (letrec ((g7861 + (letrec ((x7862 + (letrec ((x7863 + (letrec ((x7864 + (cdr + x))) + (cdr + x7864)))) + (car x7863)))) + (car x7862)))) + g7861))) + (eqv? + (lambda (x y) + (letrec ((g7865 (eq? x y))) g7865))) + (>= + (lambda (x y) + (letrec ((g7866 + (letrec ((x7868 (number? x))) + (assert x7868))) + (g7867 + (letrec ((val7152 (> x y))) + (letrec ((g7869 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7870 + (if val7153 + val7153 + #f))) + g7870))))) + g7869)))) + g7867))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7871 + (letrec ((x7874 + (string? filename))) + (assert x7874))) + (g7872 + (letrec ((x7875 (procedure? proc))) + (assert x7875))) + (g7873 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7876 + (close-input-port + input-port)) + (g7877 res)) + g7877)))) + g7873))) + (ref + (lambda (x) + (letrec ((g7878 (cons x '()))) g7878))) + (char>=? + (lambda (c1 c2) + (letrec ((g7879 + (letrec ((x7882 (char? c1))) + (assert x7882))) + (g7880 + (letrec ((x7883 (char? c2))) + (assert x7883))) + (g7881 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7884 + (if val7154 + val7154 + (char=? c1 c2)))) + g7884)))) + g7881))) + (cdaar + (lambda (x) + (letrec ((g7885 + (letrec ((x7886 + (letrec ((x7887 (car x))) + (car x7887)))) + (cdr x7886)))) + g7885))) + (cdaddr + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 + (letrec ((x7891 + (cdr + x))) + (cdr + x7891)))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7892 + (letrec ((x7893 + (letrec ((x7894 (car x))) + (cdr x7894)))) + (car x7893)))) + g7892))) + (caadr + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (cdr x))) + (car x7897)))) + (car x7896)))) + g7895))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7898 + (letrec ((x7901 (char? c1))) + (assert x7901))) + (g7899 + (letrec ((x7902 (char? c2))) + (assert x7902))) + (g7900 + (letrec ((x7903 + (char-ci<=? c1 c2))) + (not x7903)))) + g7900))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7904 + (letrec ((x7905 + (letrec ((x7906 + (letrec ((x7907 + (car + x))) + (car + x7907)))) + (car x7906)))) + (car x7905)))) + g7904))) + (negative? + (lambda (x) + (letrec ((g7908 + (letrec ((x7910 (number? x))) + (assert x7910))) + (g7909 (< x 0))) + g7909))) + (memv + (lambda (e l) + (letrec ((g7911 (memq e l))) g7911))) + (caaar + (lambda (x) + (letrec ((g7912 + (letrec ((x7913 + (letrec ((x7914 (car x))) + (car x7914)))) + (car x7913)))) + g7912))) + (debug + (lambda (e) (letrec ((g7915 '())) g7915))) + (reverse + (lambda (l) + (letrec ((g7916 + (letrec ((x7918 (list? l))) + (assert x7918))) + (g7917 + (letrec ((x-cnd7919 (null? l))) + (if x-cnd7919 + '() + (letrec ((x7922 + (letrec ((x7923 + (cdr l))) + (reverse x7923))) + (x7920 + (letrec ((x7921 + (car l))) + (list x7921)))) + (append x7922 x7920)))))) + g7917))) + (caaadr + (lambda (x) + (letrec ((g7924 + (letrec ((x7925 + (letrec ((x7926 + (letrec ((x7927 + (cdr + x))) + (car + x7927)))) + (car x7926)))) + (car x7925)))) + g7924))) + (cddadr + (lambda (x) + (letrec ((g7928 + (letrec ((x7929 + (letrec ((x7930 + (letrec ((x7931 + (cdr + x))) + (car + x7931)))) + (cdr x7930)))) + (cdr x7929)))) + g7928))) + (odd? + (lambda (x) + (letrec ((g7932 + (letrec ((x7934 (number? x))) + (assert x7934))) + (g7933 + (letrec ((x7935 (modulo x 2))) + (= 1 x7935)))) + g7933))) + (caadar + (lambda (x) + (letrec ((g7936 + (letrec ((x7937 + (letrec ((x7938 + (letrec ((x7939 + (car + x))) + (cdr + x7939)))) + (car x7938)))) + (car x7937)))) + g7936))) + (apply + (lambda (proc args) + (letrec ((g7940 + (letrec ((x7943 (procedure? proc))) + (assert x7943))) + (g7941 + (letrec ((x7944 (list? args))) + (assert x7944))) + (g7942 + (if cnd + (letrec ((g7945 (proc))) g7945) + (if cnd + (letrec ((g7946 + (letrec ((x7947 + (car + args))) + (proc x7947)))) + g7946) + (if cnd + (letrec ((g7948 + (letrec ((x7950 + (car + args)) + (x7949 + (cadr + args))) + (proc + x7950 + x7949)))) + g7948) + (if cnd + (letrec ((g7951 + (letrec ((x7954 + (car + args)) + (x7953 + (cadr + args)) + (x7952 + (caddr + args))) + (proc + x7954 + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7955 + (letrec ((x7959 + (car + args)) + (x7958 + (cadr + args)) + (x7957 + (caddr + args)) + (x7956 + (cadddr + args))) + (proc + x7959 + x7958 + x7957 + x7956)))) + g7955) + (if cnd + (letrec ((g7960 + (letrec ((x7966 + (car + args)) + (x7965 + (cadr + args)) + (x7964 + (caddr + args)) + (x7963 + (cadddr + args)) + (x7961 + (letrec ((x7962 + (cddddr + args))) + (car + x7962)))) + (proc + x7966 + x7965 + x7964 + x7963 + x7961)))) + g7960) + (if cnd + (letrec ((g7967 + (letrec ((x7975 + (car + args)) + (x7974 + (cadr + args)) + (x7973 + (caddr + args)) + (x7972 + (cadddr + args)) + (x7970 + (letrec ((x7971 + (cddddr + args))) + (car + x7971))) + (x7968 + (letrec ((x7969 + (cddddr + args))) + (cadr + x7969)))) + (proc + x7975 + x7974 + x7973 + x7972 + x7970 + x7968)))) + g7967) + (if cnd + (letrec ((g7976 + (letrec ((x7986 + (car + args)) + (x7985 + (cadr + args)) + (x7984 + (caddr + args)) + (x7983 + (cadddr + args)) + (x7981 + (letrec ((x7982 + (cddddr + args))) + (car + x7982))) + (x7979 + (letrec ((x7980 + (cddddr + args))) + (cadr + x7980))) + (x7977 + (letrec ((x7978 + (cddddr + args))) + (caddr + x7978)))) + (proc + x7986 + x7985 + x7984 + x7983 + x7981 + x7979 + x7977)))) + g7976) + (letrec ((g7987 + (error + "Unsupported call."))) + g7987))))))))))) + g7942))) + (member + (lambda (e l) + (letrec ((g7988 + (letrec ((x7990 (list? l))) + (assert x7990))) + (g7989 + (letrec ((x-cnd7991 (null? l))) + (if x-cnd7991 + #f + (letrec ((x-cnd7992 + (letrec ((x7993 + (car l))) + (equal? x7993 e)))) + (if x-cnd7992 + l + (letrec ((x7994 (cdr l))) + (member e x7994)))))))) + g7989))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7995 + (letrec ((x7996 + (letrec ((x7997 + (letrec ((x7998 + (cdr + x))) + (cdr + x7998)))) + (cdr x7997)))) + (cdr x7996)))) + g7995))) + (cadddr + (lambda (x) + (letrec ((g7999 + (letrec ((x8000 + (letrec ((x8001 + (letrec ((x8002 + (cdr + x))) + (cdr + x8002)))) + (cdr x8001)))) + (car x8000)))) + g7999))) + (int-top + (lambda () + (letrec ((g8003 (random 42))) g8003))) + (zero? + (lambda (x) + (letrec ((g8004 + (letrec ((x8006 (number? x))) + (assert x8006))) + (g8005 (= x 0))) + g8005))) + (string>=? + (lambda (s1 s2) + (letrec ((g8007 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8008 + (if val7155 + val7155 + (string=? s1 s2)))) + g8008)))) + g8007))) + (cadr + (lambda (x) + (letrec ((g8009 + (letrec ((x8010 (cdr x))) + (car x8010)))) + g8009))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8011 + (letrec ((val7156 + (letrec ((x8014 + (pair? l)) + (x8012 + (letrec ((x8013 + (cdr + l))) + (list? + x8013)))) + (and x8014 x8012)))) + (letrec ((g8015 + (if val7156 + val7156 + (null? l)))) + g8015)))) + g8011))) + (cddaar + (lambda (x) + (letrec ((g8016 + (letrec ((x8017 + (letrec ((x8018 + (letrec ((x8019 + (car + x))) + (car + x8019)))) + (cdr x8018)))) + (cdr x8017)))) + g8016))) + (char-numeric? + (lambda (c) + (letrec ((g8020 + (letrec ((x-cnd8021 + (letrec ((x8022 #\0)) + (char<=? x8022 c)))) + (if x-cnd8021 + (letrec ((x8023 #\9)) + (char<=? c x8023)) + #f)))) + g8020))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8024 + (letrec ((x8026 (list? l))) + (assert x8026))) + (g8025 + (letrec ((x-cnd8027 (null? l))) + (if x-cnd8027 + #f + (letrec ((x-cnd8028 + (letrec ((x8029 + (caar l))) + (eqv? x8029 k)))) + (if x-cnd8028 + (car l) + (letrec ((x8030 (cdr l))) + (assq k x8030)))))))) + g8025))) + (not + (lambda (x) + (letrec ((g8031 (if x #f #t))) g8031))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8032 (append l1 l2))) g8032))) + (memq + (lambda (e l) + (letrec ((g8033 + (letrec ((x8035 (list? l))) + (assert x8035))) + (g8034 + (letrec ((x-cnd8036 (null? l))) + (if x-cnd8036 + #f + (letrec ((x-cnd8037 + (letrec ((x8038 + (car l))) + (eq? x8038 e)))) + (if x-cnd8037 + l + (letrec ((x8039 (cdr l))) + (memq e x8039)))))))) + g8034))) + (cadaar + (lambda (x) + (letrec ((g8040 + (letrec ((x8041 + (letrec ((x8042 + (letrec ((x8043 + (car + x))) + (car + x8043)))) + (cdr x8042)))) + (car x8041)))) + g8040))) + (length + (lambda (l) + (letrec ((g8044 + (letrec ((x8046 (list? l))) + (assert x8046))) + (g8045 + (letrec ((rec + (lambda (l) + (letrec ((g8047 + (letrec ((x-cnd8048 + (null? + l))) + (if x-cnd8048 + 0 + (letrec ((x8049 + (letrec ((x8050 + (cdr + l))) + (rec + x8050)))) + (+ + 1 + x8049)))))) + g8047)))) + (letrec ((g8051 (rec l))) + g8051)))) + g8045))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8052 + (letrec ((x8055 (char? c1))) + (assert x8055))) + (g8053 + (letrec ((x8056 (char? c2))) + (assert x8056))) + (g8054 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8058 + (letrec ((x8059 (string<=? s1 s2))) + (not x8059)))) + g8058))) + (cdadr + (lambda (x) + (letrec ((g8060 + (letrec ((x8061 + (letrec ((x8062 (cdr x))) + (car x8062)))) + (cdr x8061)))) + g8060))) + (assoc + (lambda (k l) + (letrec ((g8063 + (letrec ((x8065 (list? l))) + (assert x8065))) + (g8064 + (letrec ((x-cnd8066 (null? l))) + (if x-cnd8066 + #f + (letrec ((x-cnd8067 + (letrec ((x8068 + (caar l))) + (equal? x8068 k)))) + (if x-cnd8067 + (car l) + (letrec ((x8069 (cdr l))) + (assoc k x8069)))))))) + g8064))) + (caar + (lambda (x) + (letrec ((g8070 + (letrec ((x8071 (car x))) + (car x8071)))) + g8070))) + (char>? + (lambda (c1 c2) + (letrec ((g8072 + (letrec ((x8075 (char? c1))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char? c2))) + (assert x8076))) + (g8074 + (letrec ((x8077 (char<=? c1 c2))) + (not x8077)))) + g8074))) + (string<=? + (lambda (s1 s2) + (letrec ((g8078 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8095 + (letrec ((x8098 (char? c1))) + (assert x8098))) + (g8096 + (letrec ((x8099 (char? c2))) + (assert x8099))) + (g8097 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8100 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8100)))) + g8097))) + (caddar + (lambda (x) + (letrec ((g8101 + (letrec ((x8102 + (letrec ((x8103 + (letrec ((x8104 + (car + x))) + (cdr + x8104)))) + (cdr x8103)))) + (car x8102)))) + g8101))) + (newline + (lambda () (letrec ((g8105 #f)) g8105))) + (lcm + (lambda (m n) + (letrec ((g8106 + (letrec ((x8108 + (letrec ((x8109 (* m n))) + (abs x8109))) + (x8107 (gcd m n))) + (/ x8108 x8107)))) + g8106))) + (deref car) + (> + (lambda (x y) + (letrec ((g8110 + (letrec ((x8112 (number? x))) + (assert x8112))) + (g8111 + (letrec ((x8113 (<= x y))) + (not x8113)))) + g8111))) + (list-ref + (lambda (l index) + (letrec ((g8114 + (letrec ((x8118 (list? l))) + (assert x8118))) + (g8115 + (letrec ((x8119 (number? index))) + (assert x8119))) + (g8116 + (letrec ((x8120 + (letrec ((x8121 + (length l))) + (< index x8121)))) + (assert x8120))) + (g8117 + (letrec ((x-cnd8122 (= index 0))) + (if x-cnd8122 + (car l) + (letrec ((x8124 (cdr l)) + (x8123 (- index 1))) + (list-ref x8124 x8123)))))) + g8117))) + (gcd + (lambda (a b) + (letrec ((g8125 + (letrec ((x-cnd8126 (= b 0))) + (if x-cnd8126 + a + (letrec ((x8127 (modulo a b))) + (gcd b x8127)))))) + g8125)))) + (letrec ((g8128 + (letrec ((g8129 + (letrec ((phi + (letrec ((x8153 (x1)) + (x8130 + (letrec ((x8152 + (x2)) + (x8131 + (letrec ((x8151 + (x3)) + (x8132 + (letrec ((x8150 + (x4)) + (x8133 + (letrec ((x8149 + (x5)) + (x8134 + (letrec ((x8148 + (x6)) + (x8135 + (letrec ((x8147 + (x7)) + (x8136 + (letrec ((x-cnd8137 + (or x1 + x2))) + (if x-cnd8137 + (letrec ((x-cnd8138 + (letrec ((x8140 + (not + x2)) + (x8139 + (not + x3))) + (or x1 + x8140 + x8139)))) + (if x-cnd8138 + (letrec ((x-cnd8141 + (or x3 + x4))) + (if x-cnd8141 + (letrec ((x-cnd8142 + (letrec ((x8143 + (not + x4))) + (or x8143 + x1)))) + (if x-cnd8142 + (letrec ((x-cnd8144 + (letrec ((x8146 + (not + x2)) + (x8145 + (not + x3))) + (or x8146 + x8145)))) + (if x-cnd8144 + (or x4 + x2) + #f)) + #f)) + #f)) + #f)) + #f)))) + (λ x8147 + x8136)))) + (λ x8148 + x8135)))) + (λ x8149 + x8134)))) + (λ x8150 + x8133)))) + (λ x8151 + x8132)))) + (λ x8152 + x8131)))) + (λ x8153 x8130))) + (try + (letrec ((x8156 (f)) + (x8154 + (letrec ((val7160 + (f + #t))) + (letrec ((g8155 + (if val7160 + val7160 + (f + #f)))) + g8155)))) + (λ x8156 x8154))) + (sat-solve-7 + (letrec ((x8185 (p)) + (x8157 + (letrec ((x8158 + (letrec ((x8184 + (n1)) + (x8159 + (letrec ((x8160 + (letrec ((x8183 + (n2)) + (x8161 + (letrec ((x8162 + (letrec ((x8182 + (n3)) + (x8163 + (letrec ((x8164 + (letrec ((x8181 + (n4)) + (x8165 + (letrec ((x8166 + (letrec ((x8180 + (n5)) + (x8167 + (letrec ((x8168 + (letrec ((x8179 + (n6)) + (x8169 + (letrec ((x8170 + (letrec ((x8178 + (n7)) + (x8171 + (letrec ((x8172 + (letrec ((x8173 + (letrec ((x8174 + (letrec ((x8175 + (letrec ((x8176 + (letrec ((x8177 + (p + n1))) + (x8177 + n2)))) + (x8176 + n3)))) + (x8175 + n4)))) + (x8174 + n5)))) + (x8173 + n6)))) + (x8172 + n7)))) + (λ x8178 + x8171)))) + (try + x8170)))) + (λ x8179 + x8169)))) + (try + x8168)))) + (λ x8180 + x8167)))) + (try + x8166)))) + (λ x8181 + x8165)))) + (try + x8164)))) + (λ x8182 + x8163)))) + (try + x8162)))) + (λ x8183 + x8161)))) + (try + x8160)))) + (λ x8184 + x8159)))) + (try + x8158)))) + (λ x8185 x8157)))) + (letrec ((g8186 + (sat-solve-7 phi))) + g8186)))) + g8129))) + g8128)))) + g7241))) + g7240)) diff --git a/analyses/simpleactor/benchmarks-out/softy_append.rkt b/analyses/simpleactor/benchmarks-out/softy_append.rkt index a41929b0..bd446230 100644 --- a/analyses/simpleactor/benchmarks-out/softy_append.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_append.rkt @@ -1,28 +1,3085 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7234 #t)) g7234))) + (meta (lambda (v) (letrec ((g7235 v)) g7235))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7236 + (letrec ((g7237 + (letrec ((x-e7238 lst)) + (match + x-e7238 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7239 (eq? v v1))) + (if x-cnd7239 #t (member v vs))))))))) + g7237))) + g7236))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (append xs ys) - (if (empty? xs) ys (cons (car xs) (append (cdr xs) ys)))) - (begin - ((((lambda (j3985 k3986 f3987) - (lambda (g3983 g3984) - ((listof any/c) - j3985 - k3986 - (f3987 - ((listof any/c) j3985 k3986 g3983) - ((listof any/c) j3985 k3986 g3984))))) - 'module - 'importer - append) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7240 (lambda (v) (letrec ((g7241 v)) g7241)))) g7240))) + (nonzero? + (lambda (v) + (letrec ((g7242 (letrec ((x7243 (= v 0))) (not x7243)))) g7242)))) + (letrec ((g7244 + (letrec ((g7245 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7246 + (letrec ((x-cnd7247 (real? g7162))) + (if x-cnd7247 + g7162 + (blame g7160 'real?))))) + g7246))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7248 + (letrec ((x-cnd7249 + (boolean? g7165))) + (if x-cnd7249 + g7165 + (blame g7163 'boolean?))))) + g7248))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7250 + (letrec ((x-cnd7251 + (number? g7168))) + (if x-cnd7251 + g7168 + (blame g7166 'number?))))) + g7250))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7252 + (letrec ((x-cnd7253 + ((lambda (v) #t) g7171))) + (if x-cnd7253 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7252))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7254 + (letrec ((x-cnd7255 + ((lambda (v) #t) g7174))) + (if x-cnd7255 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7254))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7256 + (letrec ((x-cnd7257 (pair? g7177))) + (if x-cnd7257 + g7177 + (blame g7175 'pair?))))) + g7256))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7258 + (letrec ((x-cnd7259 (pair? g7180))) + (if x-cnd7259 + g7180 + (blame g7178 'pair?))))) + g7258))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7260 + (letrec ((x-cnd7261 + (integer? g7183))) + (if x-cnd7261 + g7183 + (blame g7181 'integer?))))) + g7260))) + (and/c + (lambda (c1 c2) + (letrec ((g7262 + (lambda (k j v) + (letrec ((g7263 + (letrec ((x-cnd7264 + (c1 k j v))) + (if x-cnd7264 + (c2 k j v) + #f)))) + g7263)))) + g7262))) + (list-of + (lambda (contract) + (letrec ((g7265 + (lambda (k j v) + (letrec ((g7266 + (letrec ((x-cnd7267 + (null? v))) + (if x-cnd7267 + '() + (letrec ((x7271 + (letrec ((x7272 + (car + v))) + (contract + k + j + x7272))) + (x7268 + (letrec ((x7270 + (list-of + contract)) + (x7269 + (cdr + v))) + (x7270 + k + j + x7269)))) + (cons + x7271 + x7268)))))) + g7266)))) + g7265))) + (any? (lambda (v) (letrec ((g7273 #t)) g7273))) + (nonzero? + (lambda (v) + (letrec ((g7274 + (letrec ((x7275 (= v 0))) + (not x7275)))) + g7274))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7276 + (letrec ((x-cnd7277 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7277 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7276))) + (meta (lambda (v) (letrec ((g7278 v)) g7278))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7279 #t)) g7279))) + (cdddr + (lambda (x) + (letrec ((g7280 + (letrec ((x7281 + (letrec ((x7282 (cdr x))) + (cdr x7282)))) + (cdr x7281)))) + g7280))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7283 + (letrec ((x7286 (procedure? f))) + (assert x7286))) + (g7284 + (letrec ((x7287 (list? l))) + (assert x7287))) + (g7285 + (letrec ((x-cnd7288 (null? l))) + (if x-cnd7288 + '() + (letrec ((x7291 + (letrec ((x7292 + (car l))) + (f x7292))) + (x7289 + (letrec ((x7290 + (cdr l))) + (map f x7290)))) + (cons x7291 x7289)))))) + g7285))) + (cdar + (lambda (x) + (letrec ((g7293 + (letrec ((x7294 (car x))) + (cdr x7294)))) + g7293))) + (cadadr + (lambda (x) + (letrec ((g7295 + (letrec ((x7296 + (letrec ((x7297 + (letrec ((x7298 + (cdr + x))) + (car + x7298)))) + (cdr x7297)))) + (car x7296)))) + g7295))) + (cdadar + (lambda (x) + (letrec ((g7299 + (letrec ((x7300 + (letrec ((x7301 + (letrec ((x7302 + (car + x))) + (cdr + x7302)))) + (car x7301)))) + (cdr x7300)))) + g7299))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7303 + (letrec ((x7306 + (string? filename))) + (assert x7306))) + (g7304 + (letrec ((x7307 (procedure? proc))) + (assert x7307))) + (g7305 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7308 + (close-output-port + output-port)) + (g7309 res)) + g7309)))) + g7305))) + (caddr + (lambda (x) + (letrec ((g7310 + (letrec ((x7311 + (letrec ((x7312 (cdr x))) + (cdr x7312)))) + (car x7311)))) + g7310))) + (cdaadr + (lambda (x) + (letrec ((g7313 + (letrec ((x7314 + (letrec ((x7315 + (letrec ((x7316 + (cdr + x))) + (car + x7316)))) + (car x7315)))) + (cdr x7314)))) + g7313))) + (assq + (lambda (k l) + (letrec ((g7317 + (letrec ((x7319 (list? l))) + (assert x7319))) + (g7318 + (letrec ((x-cnd7320 (null? l))) + (if x-cnd7320 + #f + (letrec ((x-cnd7321 + (letrec ((x7322 + (caar l))) + (eq? x7322 k)))) + (if x-cnd7321 + (car l) + (letrec ((x7323 (cdr l))) + (assq k x7323)))))))) + g7318))) + (even? + (lambda (x) + (letrec ((g7324 + (letrec ((x7325 (modulo x 2))) + (= 0 x7325)))) + g7324))) + (list->string + (lambda (l) + (letrec ((g7326 + (letrec ((x7328 (list? l))) + (assert x7328))) + (g7327 + (letrec ((x-cnd7329 (null? l))) + (if x-cnd7329 + "" + (letrec ((x7332 + (letrec ((x7333 + (car l))) + (char->string + x7333))) + (x7330 + (letrec ((x7331 + (cdr l))) + (list->string + x7331)))) + (string-append + x7332 + x7330)))))) + g7327))) + (char<=? + (lambda (c1 c2) + (letrec ((g7334 + (letrec ((x7337 (char? c1))) + (assert x7337))) + (g7335 + (letrec ((x7338 (char? c2))) + (assert x7338))) + (g7336 + (letrec ((val7143 (char=? c x7355)))) + (if x-cnd7354 + (letrec ((x7356 #\z)) + (char-ci<=? c x7356)) + #f)))) + g7353))) + (<= + (lambda (x y) + (letrec ((g7357 + (letrec ((x7359 (number? x))) + (assert x7359))) + (g7358 + (letrec ((val7144 (< x y))) + (letrec ((g7360 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7361 + (if val7145 + val7145 + #f))) + g7361))))) + g7360)))) + g7358))) + (char-whitespace? + (lambda (c) + (letrec ((g7362 + (letrec ((val7146 + (letrec ((x7363 + (char->integer + c))) + (= x7363 9)))) + (letrec ((g7364 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7365 + (char->integer + c))) + (= + x7365 + 10)))) + (letrec ((g7366 + (if val7147 + val7147 + (letrec ((x7367 + (char->integer + c))) + (= + x7367 + 32))))) + g7366))))) + g7364)))) + g7362))) + (cddar + (lambda (x) + (letrec ((g7368 + (letrec ((x7369 + (letrec ((x7370 (car x))) + (cdr x7370)))) + (cdr x7369)))) + g7368))) + (positive? + (lambda (x) + (letrec ((g7371 + (letrec ((x7373 (number? x))) + (assert x7373))) + (g7372 (> x 0))) + g7372))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7374 #f)) g7374))) + (cddr + (lambda (x) + (letrec ((g7375 + (letrec ((x7376 (cdr x))) + (cdr x7376)))) + g7375))) + (truncate + (lambda (x) + (letrec ((g7377 + (letrec ((x7379 (number? x))) + (assert x7379))) + (g7378 + (letrec ((x-cnd7380 (< x 0))) + (if x-cnd7380 + (ceiling x) + (floor x))))) + g7378))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7381 + (letrec ((val7148 (eq? a b))) + (letrec ((g7382 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7384 + (null? + a)) + (x7383 + (null? + b))) + (and x7384 + x7383)))) + (letrec ((g7385 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7388 + (string? + a)) + (x7387 + (string? + b)) + (x7386 + (string=? + a + b))) + (and x7388 + x7387 + x7386)))) + (letrec ((g7389 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7397 + (pair? + a)) + (x7396 + (pair? + b)) + (x7393 + (letrec ((x7395 + (car + a)) + (x7394 + (car + b))) + (equal? + x7395 + x7394))) + (x7390 + (letrec ((x7392 + (cdr + a)) + (x7391 + (cdr + b))) + (equal? + x7392 + x7391)))) + (and x7397 + x7396 + x7393 + x7390)))) + (letrec ((g7398 + (if val7151 + val7151 + (letrec ((x7417 + (vector? + a)) + (x7416 + (vector? + b)) + (x7399 + (letrec ((x7413 + (letrec ((x7414 + (letrec ((x7415 + (vector-length + a))) + (n + x7415)))) + (x7414))) + (x7400 + (letrec ((x7411 + (letrec ((x7412 + (vector-length + b))) + (= + x7412 + n))) + (x7401 + (letrec ((loop + (lambda (i) + (letrec ((g7402 + (letrec ((x7409 + (= + i + n)) + (x7403 + (letrec ((x7406 + (letrec ((x7408 + (vector-ref + a + i)) + (x7407 + (vector-ref + b + i))) + (equal? + x7408 + x7407))) + (x7404 + (letrec ((x7405 + (+ + i + 1))) + (loop + x7405)))) + (and x7406 + x7404)))) + (or x7409 + x7403)))) + g7402)))) + (letrec ((g7410 + (loop + 0))) + g7410)))) + (and x7411 + x7401)))) + (let x7413 x7400)))) + (and x7417 + x7416 + x7399))))) + g7398))))) + g7389))))) + g7385))))) + g7382)))) + g7381))) + (cdaaar + (lambda (x) + (letrec ((g7418 + (letrec ((x7419 + (letrec ((x7420 + (letrec ((x7421 + (car + x))) + (car + x7421)))) + (car x7420)))) + (cdr x7419)))) + g7418))) + (caaddr + (lambda (x) + (letrec ((g7422 + (letrec ((x7423 + (letrec ((x7424 + (letrec ((x7425 + (cdr + x))) + (cdr + x7425)))) + (car x7424)))) + (car x7423)))) + g7422))) + (eqv? + (lambda (x y) + (letrec ((g7426 (eq? x y))) g7426))) + (>= + (lambda (x y) + (letrec ((g7427 + (letrec ((x7429 (number? x))) + (assert x7429))) + (g7428 + (letrec ((val7152 (> x y))) + (letrec ((g7430 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7431 + (if val7153 + val7153 + #f))) + g7431))))) + g7430)))) + g7428))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7432 + (letrec ((x7435 + (string? filename))) + (assert x7435))) + (g7433 + (letrec ((x7436 (procedure? proc))) + (assert x7436))) + (g7434 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7437 + (close-input-port + input-port)) + (g7438 res)) + g7438)))) + g7434))) + (ref + (lambda (x) + (letrec ((g7439 (cons x '()))) g7439))) + (char>=? + (lambda (c1 c2) + (letrec ((g7440 + (letrec ((x7443 (char? c1))) + (assert x7443))) + (g7441 + (letrec ((x7444 (char? c2))) + (assert x7444))) + (g7442 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7445 + (if val7154 + val7154 + (char=? c1 c2)))) + g7445)))) + g7442))) + (cdaar + (lambda (x) + (letrec ((g7446 + (letrec ((x7447 + (letrec ((x7448 (car x))) + (car x7448)))) + (cdr x7447)))) + g7446))) + (cdaddr + (lambda (x) + (letrec ((g7449 + (letrec ((x7450 + (letrec ((x7451 + (letrec ((x7452 + (cdr + x))) + (cdr + x7452)))) + (car x7451)))) + (cdr x7450)))) + g7449))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7453 + (letrec ((x7454 + (letrec ((x7455 (car x))) + (cdr x7455)))) + (car x7454)))) + g7453))) + (caadr + (lambda (x) + (letrec ((g7456 + (letrec ((x7457 + (letrec ((x7458 (cdr x))) + (car x7458)))) + (car x7457)))) + g7456))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7459 + (letrec ((x7462 (char? c1))) + (assert x7462))) + (g7460 + (letrec ((x7463 (char? c2))) + (assert x7463))) + (g7461 + (letrec ((x7464 + (char-ci<=? c1 c2))) + (not x7464)))) + g7461))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7465 + (letrec ((x7466 + (letrec ((x7467 + (letrec ((x7468 + (car + x))) + (car + x7468)))) + (car x7467)))) + (car x7466)))) + g7465))) + (negative? + (lambda (x) + (letrec ((g7469 + (letrec ((x7471 (number? x))) + (assert x7471))) + (g7470 (< x 0))) + g7470))) + (memv + (lambda (e l) + (letrec ((g7472 (memq e l))) g7472))) + (caaar + (lambda (x) + (letrec ((g7473 + (letrec ((x7474 + (letrec ((x7475 (car x))) + (car x7475)))) + (car x7474)))) + g7473))) + (debug + (lambda (e) (letrec ((g7476 '())) g7476))) + (reverse + (lambda (l) + (letrec ((g7477 + (letrec ((x7479 (list? l))) + (assert x7479))) + (g7478 + (letrec ((x-cnd7480 (null? l))) + (if x-cnd7480 + '() + (letrec ((x7483 + (letrec ((x7484 + (cdr l))) + (reverse x7484))) + (x7481 + (letrec ((x7482 + (car l))) + (list x7482)))) + (append x7483 x7481)))))) + g7478))) + (caaadr + (lambda (x) + (letrec ((g7485 + (letrec ((x7486 + (letrec ((x7487 + (letrec ((x7488 + (cdr + x))) + (car + x7488)))) + (car x7487)))) + (car x7486)))) + g7485))) + (cddadr + (lambda (x) + (letrec ((g7489 + (letrec ((x7490 + (letrec ((x7491 + (letrec ((x7492 + (cdr + x))) + (car + x7492)))) + (cdr x7491)))) + (cdr x7490)))) + g7489))) + (odd? + (lambda (x) + (letrec ((g7493 + (letrec ((x7495 (number? x))) + (assert x7495))) + (g7494 + (letrec ((x7496 (modulo x 2))) + (= 1 x7496)))) + g7494))) + (caadar + (lambda (x) + (letrec ((g7497 + (letrec ((x7498 + (letrec ((x7499 + (letrec ((x7500 + (car + x))) + (cdr + x7500)))) + (car x7499)))) + (car x7498)))) + g7497))) + (apply + (lambda (proc args) + (letrec ((g7501 + (letrec ((x7504 (procedure? proc))) + (assert x7504))) + (g7502 + (letrec ((x7505 (list? args))) + (assert x7505))) + (g7503 + (if cnd + (letrec ((g7506 (proc))) g7506) + (if cnd + (letrec ((g7507 + (letrec ((x7508 + (car + args))) + (proc x7508)))) + g7507) + (if cnd + (letrec ((g7509 + (letrec ((x7511 + (car + args)) + (x7510 + (cadr + args))) + (proc + x7511 + x7510)))) + g7509) + (if cnd + (letrec ((g7512 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args))) + (proc + x7515 + x7514 + x7513)))) + g7512) + (if cnd + (letrec ((g7516 + (letrec ((x7520 + (car + args)) + (x7519 + (cadr + args)) + (x7518 + (caddr + args)) + (x7517 + (cadddr + args))) + (proc + x7520 + x7519 + x7518 + x7517)))) + g7516) + (if cnd + (letrec ((g7521 + (letrec ((x7527 + (car + args)) + (x7526 + (cadr + args)) + (x7525 + (caddr + args)) + (x7524 + (cadddr + args)) + (x7522 + (letrec ((x7523 + (cddddr + args))) + (car + x7523)))) + (proc + x7527 + x7526 + x7525 + x7524 + x7522)))) + g7521) + (if cnd + (letrec ((g7528 + (letrec ((x7536 + (car + args)) + (x7535 + (cadr + args)) + (x7534 + (caddr + args)) + (x7533 + (cadddr + args)) + (x7531 + (letrec ((x7532 + (cddddr + args))) + (car + x7532))) + (x7529 + (letrec ((x7530 + (cddddr + args))) + (cadr + x7530)))) + (proc + x7536 + x7535 + x7534 + x7533 + x7531 + x7529)))) + g7528) + (if cnd + (letrec ((g7537 + (letrec ((x7547 + (car + args)) + (x7546 + (cadr + args)) + (x7545 + (caddr + args)) + (x7544 + (cadddr + args)) + (x7542 + (letrec ((x7543 + (cddddr + args))) + (car + x7543))) + (x7540 + (letrec ((x7541 + (cddddr + args))) + (cadr + x7541))) + (x7538 + (letrec ((x7539 + (cddddr + args))) + (caddr + x7539)))) + (proc + x7547 + x7546 + x7545 + x7544 + x7542 + x7540 + x7538)))) + g7537) + (letrec ((g7548 + (error + "Unsupported call."))) + g7548))))))))))) + g7503))) + (member + (lambda (e l) + (letrec ((g7549 + (letrec ((x7551 (list? l))) + (assert x7551))) + (g7550 + (letrec ((x-cnd7552 (null? l))) + (if x-cnd7552 + #f + (letrec ((x-cnd7553 + (letrec ((x7554 + (car l))) + (equal? x7554 e)))) + (if x-cnd7553 + l + (letrec ((x7555 (cdr l))) + (member e x7555)))))))) + g7550))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7556 + (letrec ((x7557 + (letrec ((x7558 + (letrec ((x7559 + (cdr + x))) + (cdr + x7559)))) + (cdr x7558)))) + (cdr x7557)))) + g7556))) + (cadddr + (lambda (x) + (letrec ((g7560 + (letrec ((x7561 + (letrec ((x7562 + (letrec ((x7563 + (cdr + x))) + (cdr + x7563)))) + (cdr x7562)))) + (car x7561)))) + g7560))) + (int-top + (lambda () + (letrec ((g7564 (random 42))) g7564))) + (zero? + (lambda (x) + (letrec ((g7565 + (letrec ((x7567 (number? x))) + (assert x7567))) + (g7566 (= x 0))) + g7566))) + (string>=? + (lambda (s1 s2) + (letrec ((g7568 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7569 + (if val7155 + val7155 + (string=? s1 s2)))) + g7569)))) + g7568))) + (cadr + (lambda (x) + (letrec ((g7570 + (letrec ((x7571 (cdr x))) + (car x7571)))) + g7570))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7572 + (letrec ((val7156 + (letrec ((x7575 + (pair? l)) + (x7573 + (letrec ((x7574 + (cdr + l))) + (list? + x7574)))) + (and x7575 x7573)))) + (letrec ((g7576 + (if val7156 + val7156 + (null? l)))) + g7576)))) + g7572))) + (cddaar + (lambda (x) + (letrec ((g7577 + (letrec ((x7578 + (letrec ((x7579 + (letrec ((x7580 + (car + x))) + (car + x7580)))) + (cdr x7579)))) + (cdr x7578)))) + g7577))) + (char-numeric? + (lambda (c) + (letrec ((g7581 + (letrec ((x-cnd7582 + (letrec ((x7583 #\0)) + (char<=? x7583 c)))) + (if x-cnd7582 + (letrec ((x7584 #\9)) + (char<=? c x7584)) + #f)))) + g7581))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7585 + (letrec ((x7587 (list? l))) + (assert x7587))) + (g7586 + (letrec ((x-cnd7588 (null? l))) + (if x-cnd7588 + #f + (letrec ((x-cnd7589 + (letrec ((x7590 + (caar l))) + (eqv? x7590 k)))) + (if x-cnd7589 + (car l) + (letrec ((x7591 (cdr l))) + (assq k x7591)))))))) + g7586))) + (not + (lambda (x) + (letrec ((g7592 (if x #f #t))) g7592))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7593 (append l1 l2))) g7593))) + (memq + (lambda (e l) + (letrec ((g7594 + (letrec ((x7596 (list? l))) + (assert x7596))) + (g7595 + (letrec ((x-cnd7597 (null? l))) + (if x-cnd7597 + #f + (letrec ((x-cnd7598 + (letrec ((x7599 + (car l))) + (eq? x7599 e)))) + (if x-cnd7598 + l + (letrec ((x7600 (cdr l))) + (memq e x7600)))))))) + g7595))) + (cadaar + (lambda (x) + (letrec ((g7601 + (letrec ((x7602 + (letrec ((x7603 + (letrec ((x7604 + (car + x))) + (car + x7604)))) + (cdr x7603)))) + (car x7602)))) + g7601))) + (length + (lambda (l) + (letrec ((g7605 + (letrec ((x7607 (list? l))) + (assert x7607))) + (g7606 + (letrec ((rec + (lambda (l) + (letrec ((g7608 + (letrec ((x-cnd7609 + (null? + l))) + (if x-cnd7609 + 0 + (letrec ((x7610 + (letrec ((x7611 + (cdr + l))) + (rec + x7611)))) + (+ + 1 + x7610)))))) + g7608)))) + (letrec ((g7612 (rec l))) + g7612)))) + g7606))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7613 + (letrec ((x7616 (char? c1))) + (assert x7616))) + (g7614 + (letrec ((x7617 (char? c2))) + (assert x7617))) + (g7615 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7619 + (letrec ((x7620 (string<=? s1 s2))) + (not x7620)))) + g7619))) + (cdadr + (lambda (x) + (letrec ((g7621 + (letrec ((x7622 + (letrec ((x7623 (cdr x))) + (car x7623)))) + (cdr x7622)))) + g7621))) + (assoc + (lambda (k l) + (letrec ((g7624 + (letrec ((x7626 (list? l))) + (assert x7626))) + (g7625 + (letrec ((x-cnd7627 (null? l))) + (if x-cnd7627 + #f + (letrec ((x-cnd7628 + (letrec ((x7629 + (caar l))) + (equal? x7629 k)))) + (if x-cnd7628 + (car l) + (letrec ((x7630 (cdr l))) + (assoc k x7630)))))))) + g7625))) + (caar + (lambda (x) + (letrec ((g7631 + (letrec ((x7632 (car x))) + (car x7632)))) + g7631))) + (char>? + (lambda (c1 c2) + (letrec ((g7633 + (letrec ((x7636 (char? c1))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char? c2))) + (assert x7637))) + (g7635 + (letrec ((x7638 (char<=? c1 c2))) + (not x7638)))) + g7635))) + (string<=? + (lambda (s1 s2) + (letrec ((g7639 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7656 + (letrec ((x7659 (char? c1))) + (assert x7659))) + (g7657 + (letrec ((x7660 (char? c2))) + (assert x7660))) + (g7658 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7661 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7661)))) + g7658))) + (caddar + (lambda (x) + (letrec ((g7662 + (letrec ((x7663 + (letrec ((x7664 + (letrec ((x7665 + (car + x))) + (cdr + x7665)))) + (cdr x7664)))) + (car x7663)))) + g7662))) + (newline + (lambda () (letrec ((g7666 #f)) g7666))) + (lcm + (lambda (m n) + (letrec ((g7667 + (letrec ((x7669 + (letrec ((x7670 (* m n))) + (abs x7670))) + (x7668 (gcd m n))) + (/ x7669 x7668)))) + g7667))) + (deref car) + (> + (lambda (x y) + (letrec ((g7671 + (letrec ((x7673 (number? x))) + (assert x7673))) + (g7672 + (letrec ((x7674 (<= x y))) + (not x7674)))) + g7672))) + (list-ref + (lambda (l index) + (letrec ((g7675 + (letrec ((x7679 (list? l))) + (assert x7679))) + (g7676 + (letrec ((x7680 (number? index))) + (assert x7680))) + (g7677 + (letrec ((x7681 + (letrec ((x7682 + (length l))) + (< index x7682)))) + (assert x7681))) + (g7678 + (letrec ((x-cnd7683 (= index 0))) + (if x-cnd7683 + (car l) + (letrec ((x7685 (cdr l)) + (x7684 (- index 1))) + (list-ref x7685 x7684)))))) + g7678))) + (gcd + (lambda (a b) + (letrec ((g7686 + (letrec ((x-cnd7687 (= b 0))) + (if x-cnd7687 + a + (letrec ((x7688 (modulo a b))) + (gcd b x7688)))))) + g7686))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7689 + (letrec ((x-cnd7690 (real? g7162))) + (if x-cnd7690 + g7162 + (blame g7160 'real?))))) + g7689))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7691 + (letrec ((x-cnd7692 + (boolean? g7165))) + (if x-cnd7692 + g7165 + (blame g7163 'boolean?))))) + g7691))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7693 + (letrec ((x-cnd7694 + (number? g7168))) + (if x-cnd7694 + g7168 + (blame g7166 'number?))))) + g7693))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7695 + (letrec ((x-cnd7696 + ((lambda (v) #t) g7171))) + (if x-cnd7696 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7695))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7697 + (letrec ((x-cnd7698 + ((lambda (v) #t) g7174))) + (if x-cnd7698 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7697))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7699 + (letrec ((x-cnd7700 (pair? g7177))) + (if x-cnd7700 + g7177 + (blame g7175 'pair?))))) + g7699))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7701 + (letrec ((x-cnd7702 (pair? g7180))) + (if x-cnd7702 + g7180 + (blame g7178 'pair?))))) + g7701))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7703 + (letrec ((x-cnd7704 + (integer? g7183))) + (if x-cnd7704 + g7183 + (blame g7181 'integer?))))) + g7703))) + (and/c + (lambda (c1 c2) + (letrec ((g7705 + (lambda (k j v) + (letrec ((g7706 + (letrec ((x-cnd7707 + (c1 k j v))) + (if x-cnd7707 + (c2 k j v) + #f)))) + g7706)))) + g7705))) + (list-of + (lambda (contract) + (letrec ((g7708 + (lambda (k j v) + (letrec ((g7709 + (letrec ((x-cnd7710 + (null? v))) + (if x-cnd7710 + '() + (letrec ((x7714 + (letrec ((x7715 + (car + v))) + (contract + k + j + x7715))) + (x7711 + (letrec ((x7713 + (list-of + contract)) + (x7712 + (cdr + v))) + (x7713 + k + j + x7712)))) + (cons + x7714 + x7711)))))) + g7709)))) + g7708))) + (any? (lambda (v) (letrec ((g7716 #t)) g7716))) + (nonzero? + (lambda (v) + (letrec ((g7717 + (letrec ((x7718 (= v 0))) + (not x7718)))) + g7717))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7719 + (letrec ((x-cnd7720 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7720 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7719))) + (meta (lambda (v) (letrec ((g7721 v)) g7721))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7722 #t)) g7722))) + (cdddr + (lambda (x) + (letrec ((g7723 + (letrec ((x7724 + (letrec ((x7725 (cdr x))) + (cdr x7725)))) + (cdr x7724)))) + g7723))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7726 + (letrec ((x7729 (procedure? f))) + (assert x7729))) + (g7727 + (letrec ((x7730 (list? l))) + (assert x7730))) + (g7728 + (letrec ((x-cnd7731 (null? l))) + (if x-cnd7731 + '() + (letrec ((x7734 + (letrec ((x7735 + (car l))) + (f x7735))) + (x7732 + (letrec ((x7733 + (cdr l))) + (map f x7733)))) + (cons x7734 x7732)))))) + g7728))) + (cdar + (lambda (x) + (letrec ((g7736 + (letrec ((x7737 (car x))) + (cdr x7737)))) + g7736))) + (cadadr + (lambda (x) + (letrec ((g7738 + (letrec ((x7739 + (letrec ((x7740 + (letrec ((x7741 + (cdr + x))) + (car + x7741)))) + (cdr x7740)))) + (car x7739)))) + g7738))) + (cdadar + (lambda (x) + (letrec ((g7742 + (letrec ((x7743 + (letrec ((x7744 + (letrec ((x7745 + (car + x))) + (cdr + x7745)))) + (car x7744)))) + (cdr x7743)))) + g7742))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7746 + (letrec ((x7749 + (string? filename))) + (assert x7749))) + (g7747 + (letrec ((x7750 (procedure? proc))) + (assert x7750))) + (g7748 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7751 + (close-output-port + output-port)) + (g7752 res)) + g7752)))) + g7748))) + (caddr + (lambda (x) + (letrec ((g7753 + (letrec ((x7754 + (letrec ((x7755 (cdr x))) + (cdr x7755)))) + (car x7754)))) + g7753))) + (cdaadr + (lambda (x) + (letrec ((g7756 + (letrec ((x7757 + (letrec ((x7758 + (letrec ((x7759 + (cdr + x))) + (car + x7759)))) + (car x7758)))) + (cdr x7757)))) + g7756))) + (assq + (lambda (k l) + (letrec ((g7760 + (letrec ((x7762 (list? l))) + (assert x7762))) + (g7761 + (letrec ((x-cnd7763 (null? l))) + (if x-cnd7763 + #f + (letrec ((x-cnd7764 + (letrec ((x7765 + (caar l))) + (eq? x7765 k)))) + (if x-cnd7764 + (car l) + (letrec ((x7766 (cdr l))) + (assq k x7766)))))))) + g7761))) + (even? + (lambda (x) + (letrec ((g7767 + (letrec ((x7768 (modulo x 2))) + (= 0 x7768)))) + g7767))) + (list->string + (lambda (l) + (letrec ((g7769 + (letrec ((x7771 (list? l))) + (assert x7771))) + (g7770 + (letrec ((x-cnd7772 (null? l))) + (if x-cnd7772 + "" + (letrec ((x7775 + (letrec ((x7776 + (car l))) + (char->string + x7776))) + (x7773 + (letrec ((x7774 + (cdr l))) + (list->string + x7774)))) + (string-append + x7775 + x7773)))))) + g7770))) + (char<=? + (lambda (c1 c2) + (letrec ((g7777 + (letrec ((x7780 (char? c1))) + (assert x7780))) + (g7778 + (letrec ((x7781 (char? c2))) + (assert x7781))) + (g7779 + (letrec ((val7143 (char=? c x7798)))) + (if x-cnd7797 + (letrec ((x7799 #\z)) + (char-ci<=? c x7799)) + #f)))) + g7796))) + (<= + (lambda (x y) + (letrec ((g7800 + (letrec ((x7802 (number? x))) + (assert x7802))) + (g7801 + (letrec ((val7144 (< x y))) + (letrec ((g7803 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7804 + (if val7145 + val7145 + #f))) + g7804))))) + g7803)))) + g7801))) + (char-whitespace? + (lambda (c) + (letrec ((g7805 + (letrec ((val7146 + (letrec ((x7806 + (char->integer + c))) + (= x7806 9)))) + (letrec ((g7807 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7808 + (char->integer + c))) + (= + x7808 + 10)))) + (letrec ((g7809 + (if val7147 + val7147 + (letrec ((x7810 + (char->integer + c))) + (= + x7810 + 32))))) + g7809))))) + g7807)))) + g7805))) + (cddar + (lambda (x) + (letrec ((g7811 + (letrec ((x7812 + (letrec ((x7813 (car x))) + (cdr x7813)))) + (cdr x7812)))) + g7811))) + (positive? + (lambda (x) + (letrec ((g7814 + (letrec ((x7816 (number? x))) + (assert x7816))) + (g7815 (> x 0))) + g7815))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7817 #f)) g7817))) + (cddr + (lambda (x) + (letrec ((g7818 + (letrec ((x7819 (cdr x))) + (cdr x7819)))) + g7818))) + (truncate + (lambda (x) + (letrec ((g7820 + (letrec ((x7822 (number? x))) + (assert x7822))) + (g7821 + (letrec ((x-cnd7823 (< x 0))) + (if x-cnd7823 + (ceiling x) + (floor x))))) + g7821))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7824 + (letrec ((val7148 (eq? a b))) + (letrec ((g7825 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7827 + (null? + a)) + (x7826 + (null? + b))) + (and x7827 + x7826)))) + (letrec ((g7828 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7831 + (string? + a)) + (x7830 + (string? + b)) + (x7829 + (string=? + a + b))) + (and x7831 + x7830 + x7829)))) + (letrec ((g7832 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7840 + (pair? + a)) + (x7839 + (pair? + b)) + (x7836 + (letrec ((x7838 + (car + a)) + (x7837 + (car + b))) + (equal? + x7838 + x7837))) + (x7833 + (letrec ((x7835 + (cdr + a)) + (x7834 + (cdr + b))) + (equal? + x7835 + x7834)))) + (and x7840 + x7839 + x7836 + x7833)))) + (letrec ((g7841 + (if val7151 + val7151 + (letrec ((x7860 + (vector? + a)) + (x7859 + (vector? + b)) + (x7842 + (letrec ((x7856 + (letrec ((x7857 + (letrec ((x7858 + (vector-length + a))) + (n + x7858)))) + (x7857))) + (x7843 + (letrec ((x7854 + (letrec ((x7855 + (vector-length + b))) + (= + x7855 + n))) + (x7844 + (letrec ((loop + (lambda (i) + (letrec ((g7845 + (letrec ((x7852 + (= + i + n)) + (x7846 + (letrec ((x7849 + (letrec ((x7851 + (vector-ref + a + i)) + (x7850 + (vector-ref + b + i))) + (equal? + x7851 + x7850))) + (x7847 + (letrec ((x7848 + (+ + i + 1))) + (loop + x7848)))) + (and x7849 + x7847)))) + (or x7852 + x7846)))) + g7845)))) + (letrec ((g7853 + (loop + 0))) + g7853)))) + (and x7854 + x7844)))) + (let x7856 x7843)))) + (and x7860 + x7859 + x7842))))) + g7841))))) + g7832))))) + g7828))))) + g7825)))) + g7824))) + (cdaaar + (lambda (x) + (letrec ((g7861 + (letrec ((x7862 + (letrec ((x7863 + (letrec ((x7864 + (car + x))) + (car + x7864)))) + (car x7863)))) + (cdr x7862)))) + g7861))) + (caaddr + (lambda (x) + (letrec ((g7865 + (letrec ((x7866 + (letrec ((x7867 + (letrec ((x7868 + (cdr + x))) + (cdr + x7868)))) + (car x7867)))) + (car x7866)))) + g7865))) + (eqv? + (lambda (x y) + (letrec ((g7869 (eq? x y))) g7869))) + (>= + (lambda (x y) + (letrec ((g7870 + (letrec ((x7872 (number? x))) + (assert x7872))) + (g7871 + (letrec ((val7152 (> x y))) + (letrec ((g7873 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7874 + (if val7153 + val7153 + #f))) + g7874))))) + g7873)))) + g7871))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7875 + (letrec ((x7878 + (string? filename))) + (assert x7878))) + (g7876 + (letrec ((x7879 (procedure? proc))) + (assert x7879))) + (g7877 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7880 + (close-input-port + input-port)) + (g7881 res)) + g7881)))) + g7877))) + (ref + (lambda (x) + (letrec ((g7882 (cons x '()))) g7882))) + (char>=? + (lambda (c1 c2) + (letrec ((g7883 + (letrec ((x7886 (char? c1))) + (assert x7886))) + (g7884 + (letrec ((x7887 (char? c2))) + (assert x7887))) + (g7885 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7888 + (if val7154 + val7154 + (char=? c1 c2)))) + g7888)))) + g7885))) + (cdaar + (lambda (x) + (letrec ((g7889 + (letrec ((x7890 + (letrec ((x7891 (car x))) + (car x7891)))) + (cdr x7890)))) + g7889))) + (cdaddr + (lambda (x) + (letrec ((g7892 + (letrec ((x7893 + (letrec ((x7894 + (letrec ((x7895 + (cdr + x))) + (cdr + x7895)))) + (car x7894)))) + (cdr x7893)))) + g7892))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7896 + (letrec ((x7897 + (letrec ((x7898 (car x))) + (cdr x7898)))) + (car x7897)))) + g7896))) + (caadr + (lambda (x) + (letrec ((g7899 + (letrec ((x7900 + (letrec ((x7901 (cdr x))) + (car x7901)))) + (car x7900)))) + g7899))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7902 + (letrec ((x7905 (char? c1))) + (assert x7905))) + (g7903 + (letrec ((x7906 (char? c2))) + (assert x7906))) + (g7904 + (letrec ((x7907 + (char-ci<=? c1 c2))) + (not x7907)))) + g7904))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7908 + (letrec ((x7909 + (letrec ((x7910 + (letrec ((x7911 + (car + x))) + (car + x7911)))) + (car x7910)))) + (car x7909)))) + g7908))) + (negative? + (lambda (x) + (letrec ((g7912 + (letrec ((x7914 (number? x))) + (assert x7914))) + (g7913 (< x 0))) + g7913))) + (memv + (lambda (e l) + (letrec ((g7915 (memq e l))) g7915))) + (caaar + (lambda (x) + (letrec ((g7916 + (letrec ((x7917 + (letrec ((x7918 (car x))) + (car x7918)))) + (car x7917)))) + g7916))) + (debug + (lambda (e) (letrec ((g7919 '())) g7919))) + (reverse + (lambda (l) + (letrec ((g7920 + (letrec ((x7922 (list? l))) + (assert x7922))) + (g7921 + (letrec ((x-cnd7923 (null? l))) + (if x-cnd7923 + '() + (letrec ((x7926 + (letrec ((x7927 + (cdr l))) + (reverse x7927))) + (x7924 + (letrec ((x7925 + (car l))) + (list x7925)))) + (append x7926 x7924)))))) + g7921))) + (caaadr + (lambda (x) + (letrec ((g7928 + (letrec ((x7929 + (letrec ((x7930 + (letrec ((x7931 + (cdr + x))) + (car + x7931)))) + (car x7930)))) + (car x7929)))) + g7928))) + (cddadr + (lambda (x) + (letrec ((g7932 + (letrec ((x7933 + (letrec ((x7934 + (letrec ((x7935 + (cdr + x))) + (car + x7935)))) + (cdr x7934)))) + (cdr x7933)))) + g7932))) + (odd? + (lambda (x) + (letrec ((g7936 + (letrec ((x7938 (number? x))) + (assert x7938))) + (g7937 + (letrec ((x7939 (modulo x 2))) + (= 1 x7939)))) + g7937))) + (caadar + (lambda (x) + (letrec ((g7940 + (letrec ((x7941 + (letrec ((x7942 + (letrec ((x7943 + (car + x))) + (cdr + x7943)))) + (car x7942)))) + (car x7941)))) + g7940))) + (apply + (lambda (proc args) + (letrec ((g7944 + (letrec ((x7947 (procedure? proc))) + (assert x7947))) + (g7945 + (letrec ((x7948 (list? args))) + (assert x7948))) + (g7946 + (if cnd + (letrec ((g7949 (proc))) g7949) + (if cnd + (letrec ((g7950 + (letrec ((x7951 + (car + args))) + (proc x7951)))) + g7950) + (if cnd + (letrec ((g7952 + (letrec ((x7954 + (car + args)) + (x7953 + (cadr + args))) + (proc + x7954 + x7953)))) + g7952) + (if cnd + (letrec ((g7955 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args))) + (proc + x7958 + x7957 + x7956)))) + g7955) + (if cnd + (letrec ((g7959 + (letrec ((x7963 + (car + args)) + (x7962 + (cadr + args)) + (x7961 + (caddr + args)) + (x7960 + (cadddr + args))) + (proc + x7963 + x7962 + x7961 + x7960)))) + g7959) + (if cnd + (letrec ((g7964 + (letrec ((x7970 + (car + args)) + (x7969 + (cadr + args)) + (x7968 + (caddr + args)) + (x7967 + (cadddr + args)) + (x7965 + (letrec ((x7966 + (cddddr + args))) + (car + x7966)))) + (proc + x7970 + x7969 + x7968 + x7967 + x7965)))) + g7964) + (if cnd + (letrec ((g7971 + (letrec ((x7979 + (car + args)) + (x7978 + (cadr + args)) + (x7977 + (caddr + args)) + (x7976 + (cadddr + args)) + (x7974 + (letrec ((x7975 + (cddddr + args))) + (car + x7975))) + (x7972 + (letrec ((x7973 + (cddddr + args))) + (cadr + x7973)))) + (proc + x7979 + x7978 + x7977 + x7976 + x7974 + x7972)))) + g7971) + (if cnd + (letrec ((g7980 + (letrec ((x7990 + (car + args)) + (x7989 + (cadr + args)) + (x7988 + (caddr + args)) + (x7987 + (cadddr + args)) + (x7985 + (letrec ((x7986 + (cddddr + args))) + (car + x7986))) + (x7983 + (letrec ((x7984 + (cddddr + args))) + (cadr + x7984))) + (x7981 + (letrec ((x7982 + (cddddr + args))) + (caddr + x7982)))) + (proc + x7990 + x7989 + x7988 + x7987 + x7985 + x7983 + x7981)))) + g7980) + (letrec ((g7991 + (error + "Unsupported call."))) + g7991))))))))))) + g7946))) + (member + (lambda (e l) + (letrec ((g7992 + (letrec ((x7994 (list? l))) + (assert x7994))) + (g7993 + (letrec ((x-cnd7995 (null? l))) + (if x-cnd7995 + #f + (letrec ((x-cnd7996 + (letrec ((x7997 + (car l))) + (equal? x7997 e)))) + (if x-cnd7996 + l + (letrec ((x7998 (cdr l))) + (member e x7998)))))))) + g7993))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7999 + (letrec ((x8000 + (letrec ((x8001 + (letrec ((x8002 + (cdr + x))) + (cdr + x8002)))) + (cdr x8001)))) + (cdr x8000)))) + g7999))) + (cadddr + (lambda (x) + (letrec ((g8003 + (letrec ((x8004 + (letrec ((x8005 + (letrec ((x8006 + (cdr + x))) + (cdr + x8006)))) + (cdr x8005)))) + (car x8004)))) + g8003))) + (int-top + (lambda () + (letrec ((g8007 (random 42))) g8007))) + (zero? + (lambda (x) + (letrec ((g8008 + (letrec ((x8010 (number? x))) + (assert x8010))) + (g8009 (= x 0))) + g8009))) + (string>=? + (lambda (s1 s2) + (letrec ((g8011 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8012 + (if val7155 + val7155 + (string=? s1 s2)))) + g8012)))) + g8011))) + (cadr + (lambda (x) + (letrec ((g8013 + (letrec ((x8014 (cdr x))) + (car x8014)))) + g8013))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8015 + (letrec ((val7156 + (letrec ((x8018 + (pair? l)) + (x8016 + (letrec ((x8017 + (cdr + l))) + (list? + x8017)))) + (and x8018 x8016)))) + (letrec ((g8019 + (if val7156 + val7156 + (null? l)))) + g8019)))) + g8015))) + (cddaar + (lambda (x) + (letrec ((g8020 + (letrec ((x8021 + (letrec ((x8022 + (letrec ((x8023 + (car + x))) + (car + x8023)))) + (cdr x8022)))) + (cdr x8021)))) + g8020))) + (char-numeric? + (lambda (c) + (letrec ((g8024 + (letrec ((x-cnd8025 + (letrec ((x8026 #\0)) + (char<=? x8026 c)))) + (if x-cnd8025 + (letrec ((x8027 #\9)) + (char<=? c x8027)) + #f)))) + g8024))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8028 + (letrec ((x8030 (list? l))) + (assert x8030))) + (g8029 + (letrec ((x-cnd8031 (null? l))) + (if x-cnd8031 + #f + (letrec ((x-cnd8032 + (letrec ((x8033 + (caar l))) + (eqv? x8033 k)))) + (if x-cnd8032 + (car l) + (letrec ((x8034 (cdr l))) + (assq k x8034)))))))) + g8029))) + (not + (lambda (x) + (letrec ((g8035 (if x #f #t))) g8035))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8036 (append l1 l2))) g8036))) + (memq + (lambda (e l) + (letrec ((g8037 + (letrec ((x8039 (list? l))) + (assert x8039))) + (g8038 + (letrec ((x-cnd8040 (null? l))) + (if x-cnd8040 + #f + (letrec ((x-cnd8041 + (letrec ((x8042 + (car l))) + (eq? x8042 e)))) + (if x-cnd8041 + l + (letrec ((x8043 (cdr l))) + (memq e x8043)))))))) + g8038))) + (cadaar + (lambda (x) + (letrec ((g8044 + (letrec ((x8045 + (letrec ((x8046 + (letrec ((x8047 + (car + x))) + (car + x8047)))) + (cdr x8046)))) + (car x8045)))) + g8044))) + (length + (lambda (l) + (letrec ((g8048 + (letrec ((x8050 (list? l))) + (assert x8050))) + (g8049 + (letrec ((rec + (lambda (l) + (letrec ((g8051 + (letrec ((x-cnd8052 + (null? + l))) + (if x-cnd8052 + 0 + (letrec ((x8053 + (letrec ((x8054 + (cdr + l))) + (rec + x8054)))) + (+ + 1 + x8053)))))) + g8051)))) + (letrec ((g8055 (rec l))) + g8055)))) + g8049))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8056 + (letrec ((x8059 (char? c1))) + (assert x8059))) + (g8057 + (letrec ((x8060 (char? c2))) + (assert x8060))) + (g8058 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8062 + (letrec ((x8063 (string<=? s1 s2))) + (not x8063)))) + g8062))) + (cdadr + (lambda (x) + (letrec ((g8064 + (letrec ((x8065 + (letrec ((x8066 (cdr x))) + (car x8066)))) + (cdr x8065)))) + g8064))) + (assoc + (lambda (k l) + (letrec ((g8067 + (letrec ((x8069 (list? l))) + (assert x8069))) + (g8068 + (letrec ((x-cnd8070 (null? l))) + (if x-cnd8070 + #f + (letrec ((x-cnd8071 + (letrec ((x8072 + (caar l))) + (equal? x8072 k)))) + (if x-cnd8071 + (car l) + (letrec ((x8073 (cdr l))) + (assoc k x8073)))))))) + g8068))) + (caar + (lambda (x) + (letrec ((g8074 + (letrec ((x8075 (car x))) + (car x8075)))) + g8074))) + (char>? + (lambda (c1 c2) + (letrec ((g8076 + (letrec ((x8079 (char? c1))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char? c2))) + (assert x8080))) + (g8078 + (letrec ((x8081 (char<=? c1 c2))) + (not x8081)))) + g8078))) + (string<=? + (lambda (s1 s2) + (letrec ((g8082 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8099 + (letrec ((x8102 (char? c1))) + (assert x8102))) + (g8100 + (letrec ((x8103 (char? c2))) + (assert x8103))) + (g8101 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8104 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8104)))) + g8101))) + (caddar + (lambda (x) + (letrec ((g8105 + (letrec ((x8106 + (letrec ((x8107 + (letrec ((x8108 + (car + x))) + (cdr + x8108)))) + (cdr x8107)))) + (car x8106)))) + g8105))) + (newline + (lambda () (letrec ((g8109 #f)) g8109))) + (lcm + (lambda (m n) + (letrec ((g8110 + (letrec ((x8112 + (letrec ((x8113 (* m n))) + (abs x8113))) + (x8111 (gcd m n))) + (/ x8112 x8111)))) + g8110))) + (deref car) + (> + (lambda (x y) + (letrec ((g8114 + (letrec ((x8116 (number? x))) + (assert x8116))) + (g8115 + (letrec ((x8117 (<= x y))) + (not x8117)))) + g8115))) + (list-ref + (lambda (l index) + (letrec ((g8118 + (letrec ((x8122 (list? l))) + (assert x8122))) + (g8119 + (letrec ((x8123 (number? index))) + (assert x8123))) + (g8120 + (letrec ((x8124 + (letrec ((x8125 + (length l))) + (< index x8125)))) + (assert x8124))) + (g8121 + (letrec ((x-cnd8126 (= index 0))) + (if x-cnd8126 + (car l) + (letrec ((x8128 (cdr l)) + (x8127 (- index 1))) + (list-ref x8128 x8127)))))) + g8121))) + (gcd + (lambda (a b) + (letrec ((g8129 + (letrec ((x-cnd8130 (= b 0))) + (if x-cnd8130 + a + (letrec ((x8131 (modulo a b))) + (gcd b x8131)))))) + g8129)))) + (letrec ((g8132 + (letrec ((g8133 + (letrec ((append + (lambda (xs ys) + (letrec ((g8134 + (letrec ((x-cnd8135 + (empty? + xs))) + (if x-cnd8135 + ys + (letrec ((x8138 + (car + xs)) + (x8136 + (letrec ((x8137 + (cdr + xs))) + (append + x8137 + ys)))) + (cons + x8138 + x8136)))))) + g8134)))) + (letrec ((g8139 + (letrec ((g8140 + (letrec ((g8141 + (letrec ((x8144 + ((lambda (j7231 + k7232 + f7233) + (lambda (g7229 + g7230) + ((listof + any/c) + j7231 + k7232 + (f7233 + ((listof + any/c) + j7231 + k7232 + g7229) + ((listof + any/c) + j7231 + k7232 + g7230))))) + 'module + 'importer + append)) + (x8143 + (input)) + (x8142 + (input))) + (x8144 + x8143 + x8142)))) + g8141))) + g8140))) + g8139)))) + g8133))) + g8132)))) + g7245))) + g7244)) diff --git a/analyses/simpleactor/benchmarks-out/softy_cpstak.rkt b/analyses/simpleactor/benchmarks-out/softy_cpstak.rkt index 861ce4c2..faf3dbf7 100644 --- a/analyses/simpleactor/benchmarks-out/softy_cpstak.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_cpstak.rkt @@ -1,42 +1,3123 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7235 #t)) g7235))) + (meta (lambda (v) (letrec ((g7236 v)) g7236))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7237 + (letrec ((g7238 + (letrec ((x-e7239 lst)) + (match + x-e7239 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7240 (eq? v v1))) + (if x-cnd7240 #t (member v vs))))))))) + g7238))) + g7237))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (tak x y z k) - (if (not (< y x)) - (k z) - (tak - (- x 1) - y - z - (lambda (v1) - (tak - (- y 1) - z - x - (lambda (v2) (tak (- z 1) x y (lambda (v3) (tak v1 v2 v3 k))))))))) - (define (tak-main x y z) (tak x y z (λ (x) x))) - (begin - ((((lambda (j3986 k3987 f3988) - (lambda (g3983 g3984 g3985) - (integer? - j3986 - k3987 - (f3988 - (integer? j3986 k3987 g3983) - (integer? j3986 k3987 g3984) - (integer? j3986 k3987 g3985))))) - 'module - 'importer - tak-main) - (input) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7241 (lambda (v) (letrec ((g7242 v)) g7242)))) g7241))) + (nonzero? + (lambda (v) + (letrec ((g7243 (letrec ((x7244 (= v 0))) (not x7244)))) g7243)))) + (letrec ((g7245 + (letrec ((g7246 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7247 + (letrec ((x-cnd7248 (real? g7162))) + (if x-cnd7248 + g7162 + (blame g7160 'real?))))) + g7247))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7249 + (letrec ((x-cnd7250 + (boolean? g7165))) + (if x-cnd7250 + g7165 + (blame g7163 'boolean?))))) + g7249))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7251 + (letrec ((x-cnd7252 + (number? g7168))) + (if x-cnd7252 + g7168 + (blame g7166 'number?))))) + g7251))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7171))) + (if x-cnd7254 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7253))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7255 + (letrec ((x-cnd7256 + ((lambda (v) #t) g7174))) + (if x-cnd7256 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7255))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7177))) + (if x-cnd7258 + g7177 + (blame g7175 'pair?))))) + g7257))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7259 + (letrec ((x-cnd7260 (pair? g7180))) + (if x-cnd7260 + g7180 + (blame g7178 'pair?))))) + g7259))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7261 + (letrec ((x-cnd7262 + (integer? g7183))) + (if x-cnd7262 + g7183 + (blame g7181 'integer?))))) + g7261))) + (and/c + (lambda (c1 c2) + (letrec ((g7263 + (lambda (k j v) + (letrec ((g7264 + (letrec ((x-cnd7265 + (c1 k j v))) + (if x-cnd7265 + (c2 k j v) + #f)))) + g7264)))) + g7263))) + (list-of + (lambda (contract) + (letrec ((g7266 + (lambda (k j v) + (letrec ((g7267 + (letrec ((x-cnd7268 + (null? v))) + (if x-cnd7268 + '() + (letrec ((x7272 + (letrec ((x7273 + (car + v))) + (contract + k + j + x7273))) + (x7269 + (letrec ((x7271 + (list-of + contract)) + (x7270 + (cdr + v))) + (x7271 + k + j + x7270)))) + (cons + x7272 + x7269)))))) + g7267)))) + g7266))) + (any? (lambda (v) (letrec ((g7274 #t)) g7274))) + (nonzero? + (lambda (v) + (letrec ((g7275 + (letrec ((x7276 (= v 0))) + (not x7276)))) + g7275))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7277 + (letrec ((x-cnd7278 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7278 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7277))) + (meta (lambda (v) (letrec ((g7279 v)) g7279))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7280 #t)) g7280))) + (cdddr + (lambda (x) + (letrec ((g7281 + (letrec ((x7282 + (letrec ((x7283 (cdr x))) + (cdr x7283)))) + (cdr x7282)))) + g7281))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7284 + (letrec ((x7287 (procedure? f))) + (assert x7287))) + (g7285 + (letrec ((x7288 (list? l))) + (assert x7288))) + (g7286 + (letrec ((x-cnd7289 (null? l))) + (if x-cnd7289 + '() + (letrec ((x7292 + (letrec ((x7293 + (car l))) + (f x7293))) + (x7290 + (letrec ((x7291 + (cdr l))) + (map f x7291)))) + (cons x7292 x7290)))))) + g7286))) + (cdar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 (car x))) + (cdr x7295)))) + g7294))) + (cadadr + (lambda (x) + (letrec ((g7296 + (letrec ((x7297 + (letrec ((x7298 + (letrec ((x7299 + (cdr + x))) + (car + x7299)))) + (cdr x7298)))) + (car x7297)))) + g7296))) + (cdadar + (lambda (x) + (letrec ((g7300 + (letrec ((x7301 + (letrec ((x7302 + (letrec ((x7303 + (car + x))) + (cdr + x7303)))) + (car x7302)))) + (cdr x7301)))) + g7300))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7304 + (letrec ((x7307 + (string? filename))) + (assert x7307))) + (g7305 + (letrec ((x7308 (procedure? proc))) + (assert x7308))) + (g7306 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7309 + (close-output-port + output-port)) + (g7310 res)) + g7310)))) + g7306))) + (caddr + (lambda (x) + (letrec ((g7311 + (letrec ((x7312 + (letrec ((x7313 (cdr x))) + (cdr x7313)))) + (car x7312)))) + g7311))) + (cdaadr + (lambda (x) + (letrec ((g7314 + (letrec ((x7315 + (letrec ((x7316 + (letrec ((x7317 + (cdr + x))) + (car + x7317)))) + (car x7316)))) + (cdr x7315)))) + g7314))) + (assq + (lambda (k l) + (letrec ((g7318 + (letrec ((x7320 (list? l))) + (assert x7320))) + (g7319 + (letrec ((x-cnd7321 (null? l))) + (if x-cnd7321 + #f + (letrec ((x-cnd7322 + (letrec ((x7323 + (caar l))) + (eq? x7323 k)))) + (if x-cnd7322 + (car l) + (letrec ((x7324 (cdr l))) + (assq k x7324)))))))) + g7319))) + (even? + (lambda (x) + (letrec ((g7325 + (letrec ((x7326 (modulo x 2))) + (= 0 x7326)))) + g7325))) + (list->string + (lambda (l) + (letrec ((g7327 + (letrec ((x7329 (list? l))) + (assert x7329))) + (g7328 + (letrec ((x-cnd7330 (null? l))) + (if x-cnd7330 + "" + (letrec ((x7333 + (letrec ((x7334 + (car l))) + (char->string + x7334))) + (x7331 + (letrec ((x7332 + (cdr l))) + (list->string + x7332)))) + (string-append + x7333 + x7331)))))) + g7328))) + (char<=? + (lambda (c1 c2) + (letrec ((g7335 + (letrec ((x7338 (char? c1))) + (assert x7338))) + (g7336 + (letrec ((x7339 (char? c2))) + (assert x7339))) + (g7337 + (letrec ((val7143 (char=? c x7356)))) + (if x-cnd7355 + (letrec ((x7357 #\z)) + (char-ci<=? c x7357)) + #f)))) + g7354))) + (<= + (lambda (x y) + (letrec ((g7358 + (letrec ((x7360 (number? x))) + (assert x7360))) + (g7359 + (letrec ((val7144 (< x y))) + (letrec ((g7361 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7362 + (if val7145 + val7145 + #f))) + g7362))))) + g7361)))) + g7359))) + (char-whitespace? + (lambda (c) + (letrec ((g7363 + (letrec ((val7146 + (letrec ((x7364 + (char->integer + c))) + (= x7364 9)))) + (letrec ((g7365 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 10)))) + (letrec ((g7367 + (if val7147 + val7147 + (letrec ((x7368 + (char->integer + c))) + (= + x7368 + 32))))) + g7367))))) + g7365)))) + g7363))) + (cddar + (lambda (x) + (letrec ((g7369 + (letrec ((x7370 + (letrec ((x7371 (car x))) + (cdr x7371)))) + (cdr x7370)))) + g7369))) + (positive? + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 (> x 0))) + g7373))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7375 #f)) g7375))) + (cddr + (lambda (x) + (letrec ((g7376 + (letrec ((x7377 (cdr x))) + (cdr x7377)))) + g7376))) + (truncate + (lambda (x) + (letrec ((g7378 + (letrec ((x7380 (number? x))) + (assert x7380))) + (g7379 + (letrec ((x-cnd7381 (< x 0))) + (if x-cnd7381 + (ceiling x) + (floor x))))) + g7379))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7382 + (letrec ((val7148 (eq? a b))) + (letrec ((g7383 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7385 + (null? + a)) + (x7384 + (null? + b))) + (and x7385 + x7384)))) + (letrec ((g7386 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7389 + (string? + a)) + (x7388 + (string? + b)) + (x7387 + (string=? + a + b))) + (and x7389 + x7388 + x7387)))) + (letrec ((g7390 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7398 + (pair? + a)) + (x7397 + (pair? + b)) + (x7394 + (letrec ((x7396 + (car + a)) + (x7395 + (car + b))) + (equal? + x7396 + x7395))) + (x7391 + (letrec ((x7393 + (cdr + a)) + (x7392 + (cdr + b))) + (equal? + x7393 + x7392)))) + (and x7398 + x7397 + x7394 + x7391)))) + (letrec ((g7399 + (if val7151 + val7151 + (letrec ((x7418 + (vector? + a)) + (x7417 + (vector? + b)) + (x7400 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (vector-length + a))) + (n + x7416)))) + (x7415))) + (x7401 + (letrec ((x7412 + (letrec ((x7413 + (vector-length + b))) + (= + x7413 + n))) + (x7402 + (letrec ((loop + (lambda (i) + (letrec ((g7403 + (letrec ((x7410 + (= + i + n)) + (x7404 + (letrec ((x7407 + (letrec ((x7409 + (vector-ref + a + i)) + (x7408 + (vector-ref + b + i))) + (equal? + x7409 + x7408))) + (x7405 + (letrec ((x7406 + (+ + i + 1))) + (loop + x7406)))) + (and x7407 + x7405)))) + (or x7410 + x7404)))) + g7403)))) + (letrec ((g7411 + (loop + 0))) + g7411)))) + (and x7412 + x7402)))) + (let x7414 x7401)))) + (and x7418 + x7417 + x7400))))) + g7399))))) + g7390))))) + g7386))))) + g7383)))) + g7382))) + (cdaaar + (lambda (x) + (letrec ((g7419 + (letrec ((x7420 + (letrec ((x7421 + (letrec ((x7422 + (car + x))) + (car + x7422)))) + (car x7421)))) + (cdr x7420)))) + g7419))) + (caaddr + (lambda (x) + (letrec ((g7423 + (letrec ((x7424 + (letrec ((x7425 + (letrec ((x7426 + (cdr + x))) + (cdr + x7426)))) + (car x7425)))) + (car x7424)))) + g7423))) + (eqv? + (lambda (x y) + (letrec ((g7427 (eq? x y))) g7427))) + (>= + (lambda (x y) + (letrec ((g7428 + (letrec ((x7430 (number? x))) + (assert x7430))) + (g7429 + (letrec ((val7152 (> x y))) + (letrec ((g7431 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7432 + (if val7153 + val7153 + #f))) + g7432))))) + g7431)))) + g7429))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7433 + (letrec ((x7436 + (string? filename))) + (assert x7436))) + (g7434 + (letrec ((x7437 (procedure? proc))) + (assert x7437))) + (g7435 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7438 + (close-input-port + input-port)) + (g7439 res)) + g7439)))) + g7435))) + (ref + (lambda (x) + (letrec ((g7440 (cons x '()))) g7440))) + (char>=? + (lambda (c1 c2) + (letrec ((g7441 + (letrec ((x7444 (char? c1))) + (assert x7444))) + (g7442 + (letrec ((x7445 (char? c2))) + (assert x7445))) + (g7443 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7446 + (if val7154 + val7154 + (char=? c1 c2)))) + g7446)))) + g7443))) + (cdaar + (lambda (x) + (letrec ((g7447 + (letrec ((x7448 + (letrec ((x7449 (car x))) + (car x7449)))) + (cdr x7448)))) + g7447))) + (cdaddr + (lambda (x) + (letrec ((g7450 + (letrec ((x7451 + (letrec ((x7452 + (letrec ((x7453 + (cdr + x))) + (cdr + x7453)))) + (car x7452)))) + (cdr x7451)))) + g7450))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7454 + (letrec ((x7455 + (letrec ((x7456 (car x))) + (cdr x7456)))) + (car x7455)))) + g7454))) + (caadr + (lambda (x) + (letrec ((g7457 + (letrec ((x7458 + (letrec ((x7459 (cdr x))) + (car x7459)))) + (car x7458)))) + g7457))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7460 + (letrec ((x7463 (char? c1))) + (assert x7463))) + (g7461 + (letrec ((x7464 (char? c2))) + (assert x7464))) + (g7462 + (letrec ((x7465 + (char-ci<=? c1 c2))) + (not x7465)))) + g7462))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7466 + (letrec ((x7467 + (letrec ((x7468 + (letrec ((x7469 + (car + x))) + (car + x7469)))) + (car x7468)))) + (car x7467)))) + g7466))) + (negative? + (lambda (x) + (letrec ((g7470 + (letrec ((x7472 (number? x))) + (assert x7472))) + (g7471 (< x 0))) + g7471))) + (memv + (lambda (e l) + (letrec ((g7473 (memq e l))) g7473))) + (caaar + (lambda (x) + (letrec ((g7474 + (letrec ((x7475 + (letrec ((x7476 (car x))) + (car x7476)))) + (car x7475)))) + g7474))) + (debug + (lambda (e) (letrec ((g7477 '())) g7477))) + (reverse + (lambda (l) + (letrec ((g7478 + (letrec ((x7480 (list? l))) + (assert x7480))) + (g7479 + (letrec ((x-cnd7481 (null? l))) + (if x-cnd7481 + '() + (letrec ((x7484 + (letrec ((x7485 + (cdr l))) + (reverse x7485))) + (x7482 + (letrec ((x7483 + (car l))) + (list x7483)))) + (append x7484 x7482)))))) + g7479))) + (caaadr + (lambda (x) + (letrec ((g7486 + (letrec ((x7487 + (letrec ((x7488 + (letrec ((x7489 + (cdr + x))) + (car + x7489)))) + (car x7488)))) + (car x7487)))) + g7486))) + (cddadr + (lambda (x) + (letrec ((g7490 + (letrec ((x7491 + (letrec ((x7492 + (letrec ((x7493 + (cdr + x))) + (car + x7493)))) + (cdr x7492)))) + (cdr x7491)))) + g7490))) + (odd? + (lambda (x) + (letrec ((g7494 + (letrec ((x7496 (number? x))) + (assert x7496))) + (g7495 + (letrec ((x7497 (modulo x 2))) + (= 1 x7497)))) + g7495))) + (caadar + (lambda (x) + (letrec ((g7498 + (letrec ((x7499 + (letrec ((x7500 + (letrec ((x7501 + (car + x))) + (cdr + x7501)))) + (car x7500)))) + (car x7499)))) + g7498))) + (apply + (lambda (proc args) + (letrec ((g7502 + (letrec ((x7505 (procedure? proc))) + (assert x7505))) + (g7503 + (letrec ((x7506 (list? args))) + (assert x7506))) + (g7504 + (if cnd + (letrec ((g7507 (proc))) g7507) + (if cnd + (letrec ((g7508 + (letrec ((x7509 + (car + args))) + (proc x7509)))) + g7508) + (if cnd + (letrec ((g7510 + (letrec ((x7512 + (car + args)) + (x7511 + (cadr + args))) + (proc + x7512 + x7511)))) + g7510) + (if cnd + (letrec ((g7513 + (letrec ((x7516 + (car + args)) + (x7515 + (cadr + args)) + (x7514 + (caddr + args))) + (proc + x7516 + x7515 + x7514)))) + g7513) + (if cnd + (letrec ((g7517 + (letrec ((x7521 + (car + args)) + (x7520 + (cadr + args)) + (x7519 + (caddr + args)) + (x7518 + (cadddr + args))) + (proc + x7521 + x7520 + x7519 + x7518)))) + g7517) + (if cnd + (letrec ((g7522 + (letrec ((x7528 + (car + args)) + (x7527 + (cadr + args)) + (x7526 + (caddr + args)) + (x7525 + (cadddr + args)) + (x7523 + (letrec ((x7524 + (cddddr + args))) + (car + x7524)))) + (proc + x7528 + x7527 + x7526 + x7525 + x7523)))) + g7522) + (if cnd + (letrec ((g7529 + (letrec ((x7537 + (car + args)) + (x7536 + (cadr + args)) + (x7535 + (caddr + args)) + (x7534 + (cadddr + args)) + (x7532 + (letrec ((x7533 + (cddddr + args))) + (car + x7533))) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (cadr + x7531)))) + (proc + x7537 + x7536 + x7535 + x7534 + x7532 + x7530)))) + g7529) + (if cnd + (letrec ((g7538 + (letrec ((x7548 + (car + args)) + (x7547 + (cadr + args)) + (x7546 + (caddr + args)) + (x7545 + (cadddr + args)) + (x7543 + (letrec ((x7544 + (cddddr + args))) + (car + x7544))) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (cadr + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (caddr + x7540)))) + (proc + x7548 + x7547 + x7546 + x7545 + x7543 + x7541 + x7539)))) + g7538) + (letrec ((g7549 + (error + "Unsupported call."))) + g7549))))))))))) + g7504))) + (member + (lambda (e l) + (letrec ((g7550 + (letrec ((x7552 (list? l))) + (assert x7552))) + (g7551 + (letrec ((x-cnd7553 (null? l))) + (if x-cnd7553 + #f + (letrec ((x-cnd7554 + (letrec ((x7555 + (car l))) + (equal? x7555 e)))) + (if x-cnd7554 + l + (letrec ((x7556 (cdr l))) + (member e x7556)))))))) + g7551))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7557 + (letrec ((x7558 + (letrec ((x7559 + (letrec ((x7560 + (cdr + x))) + (cdr + x7560)))) + (cdr x7559)))) + (cdr x7558)))) + g7557))) + (cadddr + (lambda (x) + (letrec ((g7561 + (letrec ((x7562 + (letrec ((x7563 + (letrec ((x7564 + (cdr + x))) + (cdr + x7564)))) + (cdr x7563)))) + (car x7562)))) + g7561))) + (int-top + (lambda () + (letrec ((g7565 (random 42))) g7565))) + (zero? + (lambda (x) + (letrec ((g7566 + (letrec ((x7568 (number? x))) + (assert x7568))) + (g7567 (= x 0))) + g7567))) + (string>=? + (lambda (s1 s2) + (letrec ((g7569 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7570 + (if val7155 + val7155 + (string=? s1 s2)))) + g7570)))) + g7569))) + (cadr + (lambda (x) + (letrec ((g7571 + (letrec ((x7572 (cdr x))) + (car x7572)))) + g7571))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7573 + (letrec ((val7156 + (letrec ((x7576 + (pair? l)) + (x7574 + (letrec ((x7575 + (cdr + l))) + (list? + x7575)))) + (and x7576 x7574)))) + (letrec ((g7577 + (if val7156 + val7156 + (null? l)))) + g7577)))) + g7573))) + (cddaar + (lambda (x) + (letrec ((g7578 + (letrec ((x7579 + (letrec ((x7580 + (letrec ((x7581 + (car + x))) + (car + x7581)))) + (cdr x7580)))) + (cdr x7579)))) + g7578))) + (char-numeric? + (lambda (c) + (letrec ((g7582 + (letrec ((x-cnd7583 + (letrec ((x7584 #\0)) + (char<=? x7584 c)))) + (if x-cnd7583 + (letrec ((x7585 #\9)) + (char<=? c x7585)) + #f)))) + g7582))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7586 + (letrec ((x7588 (list? l))) + (assert x7588))) + (g7587 + (letrec ((x-cnd7589 (null? l))) + (if x-cnd7589 + #f + (letrec ((x-cnd7590 + (letrec ((x7591 + (caar l))) + (eqv? x7591 k)))) + (if x-cnd7590 + (car l) + (letrec ((x7592 (cdr l))) + (assq k x7592)))))))) + g7587))) + (not + (lambda (x) + (letrec ((g7593 (if x #f #t))) g7593))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7594 (append l1 l2))) g7594))) + (memq + (lambda (e l) + (letrec ((g7595 + (letrec ((x7597 (list? l))) + (assert x7597))) + (g7596 + (letrec ((x-cnd7598 (null? l))) + (if x-cnd7598 + #f + (letrec ((x-cnd7599 + (letrec ((x7600 + (car l))) + (eq? x7600 e)))) + (if x-cnd7599 + l + (letrec ((x7601 (cdr l))) + (memq e x7601)))))))) + g7596))) + (cadaar + (lambda (x) + (letrec ((g7602 + (letrec ((x7603 + (letrec ((x7604 + (letrec ((x7605 + (car + x))) + (car + x7605)))) + (cdr x7604)))) + (car x7603)))) + g7602))) + (length + (lambda (l) + (letrec ((g7606 + (letrec ((x7608 (list? l))) + (assert x7608))) + (g7607 + (letrec ((rec + (lambda (l) + (letrec ((g7609 + (letrec ((x-cnd7610 + (null? + l))) + (if x-cnd7610 + 0 + (letrec ((x7611 + (letrec ((x7612 + (cdr + l))) + (rec + x7612)))) + (+ + 1 + x7611)))))) + g7609)))) + (letrec ((g7613 (rec l))) + g7613)))) + g7607))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7614 + (letrec ((x7617 (char? c1))) + (assert x7617))) + (g7615 + (letrec ((x7618 (char? c2))) + (assert x7618))) + (g7616 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7620 + (letrec ((x7621 (string<=? s1 s2))) + (not x7621)))) + g7620))) + (cdadr + (lambda (x) + (letrec ((g7622 + (letrec ((x7623 + (letrec ((x7624 (cdr x))) + (car x7624)))) + (cdr x7623)))) + g7622))) + (assoc + (lambda (k l) + (letrec ((g7625 + (letrec ((x7627 (list? l))) + (assert x7627))) + (g7626 + (letrec ((x-cnd7628 (null? l))) + (if x-cnd7628 + #f + (letrec ((x-cnd7629 + (letrec ((x7630 + (caar l))) + (equal? x7630 k)))) + (if x-cnd7629 + (car l) + (letrec ((x7631 (cdr l))) + (assoc k x7631)))))))) + g7626))) + (caar + (lambda (x) + (letrec ((g7632 + (letrec ((x7633 (car x))) + (car x7633)))) + g7632))) + (char>? + (lambda (c1 c2) + (letrec ((g7634 + (letrec ((x7637 (char? c1))) + (assert x7637))) + (g7635 + (letrec ((x7638 (char? c2))) + (assert x7638))) + (g7636 + (letrec ((x7639 (char<=? c1 c2))) + (not x7639)))) + g7636))) + (string<=? + (lambda (s1 s2) + (letrec ((g7640 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7657 + (letrec ((x7660 (char? c1))) + (assert x7660))) + (g7658 + (letrec ((x7661 (char? c2))) + (assert x7661))) + (g7659 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7662 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7662)))) + g7659))) + (caddar + (lambda (x) + (letrec ((g7663 + (letrec ((x7664 + (letrec ((x7665 + (letrec ((x7666 + (car + x))) + (cdr + x7666)))) + (cdr x7665)))) + (car x7664)))) + g7663))) + (newline + (lambda () (letrec ((g7667 #f)) g7667))) + (lcm + (lambda (m n) + (letrec ((g7668 + (letrec ((x7670 + (letrec ((x7671 (* m n))) + (abs x7671))) + (x7669 (gcd m n))) + (/ x7670 x7669)))) + g7668))) + (deref car) + (> + (lambda (x y) + (letrec ((g7672 + (letrec ((x7674 (number? x))) + (assert x7674))) + (g7673 + (letrec ((x7675 (<= x y))) + (not x7675)))) + g7673))) + (list-ref + (lambda (l index) + (letrec ((g7676 + (letrec ((x7680 (list? l))) + (assert x7680))) + (g7677 + (letrec ((x7681 (number? index))) + (assert x7681))) + (g7678 + (letrec ((x7682 + (letrec ((x7683 + (length l))) + (< index x7683)))) + (assert x7682))) + (g7679 + (letrec ((x-cnd7684 (= index 0))) + (if x-cnd7684 + (car l) + (letrec ((x7686 (cdr l)) + (x7685 (- index 1))) + (list-ref x7686 x7685)))))) + g7679))) + (gcd + (lambda (a b) + (letrec ((g7687 + (letrec ((x-cnd7688 (= b 0))) + (if x-cnd7688 + a + (letrec ((x7689 (modulo a b))) + (gcd b x7689)))))) + g7687))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7690 + (letrec ((x-cnd7691 (real? g7162))) + (if x-cnd7691 + g7162 + (blame g7160 'real?))))) + g7690))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7692 + (letrec ((x-cnd7693 + (boolean? g7165))) + (if x-cnd7693 + g7165 + (blame g7163 'boolean?))))) + g7692))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7694 + (letrec ((x-cnd7695 + (number? g7168))) + (if x-cnd7695 + g7168 + (blame g7166 'number?))))) + g7694))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7171))) + (if x-cnd7697 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7696))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7698 + (letrec ((x-cnd7699 + ((lambda (v) #t) g7174))) + (if x-cnd7699 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7698))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7177))) + (if x-cnd7701 + g7177 + (blame g7175 'pair?))))) + g7700))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7702 + (letrec ((x-cnd7703 (pair? g7180))) + (if x-cnd7703 + g7180 + (blame g7178 'pair?))))) + g7702))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7704 + (letrec ((x-cnd7705 + (integer? g7183))) + (if x-cnd7705 + g7183 + (blame g7181 'integer?))))) + g7704))) + (and/c + (lambda (c1 c2) + (letrec ((g7706 + (lambda (k j v) + (letrec ((g7707 + (letrec ((x-cnd7708 + (c1 k j v))) + (if x-cnd7708 + (c2 k j v) + #f)))) + g7707)))) + g7706))) + (list-of + (lambda (contract) + (letrec ((g7709 + (lambda (k j v) + (letrec ((g7710 + (letrec ((x-cnd7711 + (null? v))) + (if x-cnd7711 + '() + (letrec ((x7715 + (letrec ((x7716 + (car + v))) + (contract + k + j + x7716))) + (x7712 + (letrec ((x7714 + (list-of + contract)) + (x7713 + (cdr + v))) + (x7714 + k + j + x7713)))) + (cons + x7715 + x7712)))))) + g7710)))) + g7709))) + (any? (lambda (v) (letrec ((g7717 #t)) g7717))) + (nonzero? + (lambda (v) + (letrec ((g7718 + (letrec ((x7719 (= v 0))) + (not x7719)))) + g7718))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7720 + (letrec ((x-cnd7721 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7721 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7720))) + (meta (lambda (v) (letrec ((g7722 v)) g7722))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7723 #t)) g7723))) + (cdddr + (lambda (x) + (letrec ((g7724 + (letrec ((x7725 + (letrec ((x7726 (cdr x))) + (cdr x7726)))) + (cdr x7725)))) + g7724))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7727 + (letrec ((x7730 (procedure? f))) + (assert x7730))) + (g7728 + (letrec ((x7731 (list? l))) + (assert x7731))) + (g7729 + (letrec ((x-cnd7732 (null? l))) + (if x-cnd7732 + '() + (letrec ((x7735 + (letrec ((x7736 + (car l))) + (f x7736))) + (x7733 + (letrec ((x7734 + (cdr l))) + (map f x7734)))) + (cons x7735 x7733)))))) + g7729))) + (cdar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 (car x))) + (cdr x7738)))) + g7737))) + (cadadr + (lambda (x) + (letrec ((g7739 + (letrec ((x7740 + (letrec ((x7741 + (letrec ((x7742 + (cdr + x))) + (car + x7742)))) + (cdr x7741)))) + (car x7740)))) + g7739))) + (cdadar + (lambda (x) + (letrec ((g7743 + (letrec ((x7744 + (letrec ((x7745 + (letrec ((x7746 + (car + x))) + (cdr + x7746)))) + (car x7745)))) + (cdr x7744)))) + g7743))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7747 + (letrec ((x7750 + (string? filename))) + (assert x7750))) + (g7748 + (letrec ((x7751 (procedure? proc))) + (assert x7751))) + (g7749 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7752 + (close-output-port + output-port)) + (g7753 res)) + g7753)))) + g7749))) + (caddr + (lambda (x) + (letrec ((g7754 + (letrec ((x7755 + (letrec ((x7756 (cdr x))) + (cdr x7756)))) + (car x7755)))) + g7754))) + (cdaadr + (lambda (x) + (letrec ((g7757 + (letrec ((x7758 + (letrec ((x7759 + (letrec ((x7760 + (cdr + x))) + (car + x7760)))) + (car x7759)))) + (cdr x7758)))) + g7757))) + (assq + (lambda (k l) + (letrec ((g7761 + (letrec ((x7763 (list? l))) + (assert x7763))) + (g7762 + (letrec ((x-cnd7764 (null? l))) + (if x-cnd7764 + #f + (letrec ((x-cnd7765 + (letrec ((x7766 + (caar l))) + (eq? x7766 k)))) + (if x-cnd7765 + (car l) + (letrec ((x7767 (cdr l))) + (assq k x7767)))))))) + g7762))) + (even? + (lambda (x) + (letrec ((g7768 + (letrec ((x7769 (modulo x 2))) + (= 0 x7769)))) + g7768))) + (list->string + (lambda (l) + (letrec ((g7770 + (letrec ((x7772 (list? l))) + (assert x7772))) + (g7771 + (letrec ((x-cnd7773 (null? l))) + (if x-cnd7773 + "" + (letrec ((x7776 + (letrec ((x7777 + (car l))) + (char->string + x7777))) + (x7774 + (letrec ((x7775 + (cdr l))) + (list->string + x7775)))) + (string-append + x7776 + x7774)))))) + g7771))) + (char<=? + (lambda (c1 c2) + (letrec ((g7778 + (letrec ((x7781 (char? c1))) + (assert x7781))) + (g7779 + (letrec ((x7782 (char? c2))) + (assert x7782))) + (g7780 + (letrec ((val7143 (char=? c x7799)))) + (if x-cnd7798 + (letrec ((x7800 #\z)) + (char-ci<=? c x7800)) + #f)))) + g7797))) + (<= + (lambda (x y) + (letrec ((g7801 + (letrec ((x7803 (number? x))) + (assert x7803))) + (g7802 + (letrec ((val7144 (< x y))) + (letrec ((g7804 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7805 + (if val7145 + val7145 + #f))) + g7805))))) + g7804)))) + g7802))) + (char-whitespace? + (lambda (c) + (letrec ((g7806 + (letrec ((val7146 + (letrec ((x7807 + (char->integer + c))) + (= x7807 9)))) + (letrec ((g7808 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 10)))) + (letrec ((g7810 + (if val7147 + val7147 + (letrec ((x7811 + (char->integer + c))) + (= + x7811 + 32))))) + g7810))))) + g7808)))) + g7806))) + (cddar + (lambda (x) + (letrec ((g7812 + (letrec ((x7813 + (letrec ((x7814 (car x))) + (cdr x7814)))) + (cdr x7813)))) + g7812))) + (positive? + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 (> x 0))) + g7816))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7818 #f)) g7818))) + (cddr + (lambda (x) + (letrec ((g7819 + (letrec ((x7820 (cdr x))) + (cdr x7820)))) + g7819))) + (truncate + (lambda (x) + (letrec ((g7821 + (letrec ((x7823 (number? x))) + (assert x7823))) + (g7822 + (letrec ((x-cnd7824 (< x 0))) + (if x-cnd7824 + (ceiling x) + (floor x))))) + g7822))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7825 + (letrec ((val7148 (eq? a b))) + (letrec ((g7826 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7828 + (null? + a)) + (x7827 + (null? + b))) + (and x7828 + x7827)))) + (letrec ((g7829 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7832 + (string? + a)) + (x7831 + (string? + b)) + (x7830 + (string=? + a + b))) + (and x7832 + x7831 + x7830)))) + (letrec ((g7833 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7841 + (pair? + a)) + (x7840 + (pair? + b)) + (x7837 + (letrec ((x7839 + (car + a)) + (x7838 + (car + b))) + (equal? + x7839 + x7838))) + (x7834 + (letrec ((x7836 + (cdr + a)) + (x7835 + (cdr + b))) + (equal? + x7836 + x7835)))) + (and x7841 + x7840 + x7837 + x7834)))) + (letrec ((g7842 + (if val7151 + val7151 + (letrec ((x7861 + (vector? + a)) + (x7860 + (vector? + b)) + (x7843 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (vector-length + a))) + (n + x7859)))) + (x7858))) + (x7844 + (letrec ((x7855 + (letrec ((x7856 + (vector-length + b))) + (= + x7856 + n))) + (x7845 + (letrec ((loop + (lambda (i) + (letrec ((g7846 + (letrec ((x7853 + (= + i + n)) + (x7847 + (letrec ((x7850 + (letrec ((x7852 + (vector-ref + a + i)) + (x7851 + (vector-ref + b + i))) + (equal? + x7852 + x7851))) + (x7848 + (letrec ((x7849 + (+ + i + 1))) + (loop + x7849)))) + (and x7850 + x7848)))) + (or x7853 + x7847)))) + g7846)))) + (letrec ((g7854 + (loop + 0))) + g7854)))) + (and x7855 + x7845)))) + (let x7857 x7844)))) + (and x7861 + x7860 + x7843))))) + g7842))))) + g7833))))) + g7829))))) + g7826)))) + g7825))) + (cdaaar + (lambda (x) + (letrec ((g7862 + (letrec ((x7863 + (letrec ((x7864 + (letrec ((x7865 + (car + x))) + (car + x7865)))) + (car x7864)))) + (cdr x7863)))) + g7862))) + (caaddr + (lambda (x) + (letrec ((g7866 + (letrec ((x7867 + (letrec ((x7868 + (letrec ((x7869 + (cdr + x))) + (cdr + x7869)))) + (car x7868)))) + (car x7867)))) + g7866))) + (eqv? + (lambda (x y) + (letrec ((g7870 (eq? x y))) g7870))) + (>= + (lambda (x y) + (letrec ((g7871 + (letrec ((x7873 (number? x))) + (assert x7873))) + (g7872 + (letrec ((val7152 (> x y))) + (letrec ((g7874 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7875 + (if val7153 + val7153 + #f))) + g7875))))) + g7874)))) + g7872))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7876 + (letrec ((x7879 + (string? filename))) + (assert x7879))) + (g7877 + (letrec ((x7880 (procedure? proc))) + (assert x7880))) + (g7878 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7881 + (close-input-port + input-port)) + (g7882 res)) + g7882)))) + g7878))) + (ref + (lambda (x) + (letrec ((g7883 (cons x '()))) g7883))) + (char>=? + (lambda (c1 c2) + (letrec ((g7884 + (letrec ((x7887 (char? c1))) + (assert x7887))) + (g7885 + (letrec ((x7888 (char? c2))) + (assert x7888))) + (g7886 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7889 + (if val7154 + val7154 + (char=? c1 c2)))) + g7889)))) + g7886))) + (cdaar + (lambda (x) + (letrec ((g7890 + (letrec ((x7891 + (letrec ((x7892 (car x))) + (car x7892)))) + (cdr x7891)))) + g7890))) + (cdaddr + (lambda (x) + (letrec ((g7893 + (letrec ((x7894 + (letrec ((x7895 + (letrec ((x7896 + (cdr + x))) + (cdr + x7896)))) + (car x7895)))) + (cdr x7894)))) + g7893))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7897 + (letrec ((x7898 + (letrec ((x7899 (car x))) + (cdr x7899)))) + (car x7898)))) + g7897))) + (caadr + (lambda (x) + (letrec ((g7900 + (letrec ((x7901 + (letrec ((x7902 (cdr x))) + (car x7902)))) + (car x7901)))) + g7900))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7903 + (letrec ((x7906 (char? c1))) + (assert x7906))) + (g7904 + (letrec ((x7907 (char? c2))) + (assert x7907))) + (g7905 + (letrec ((x7908 + (char-ci<=? c1 c2))) + (not x7908)))) + g7905))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7909 + (letrec ((x7910 + (letrec ((x7911 + (letrec ((x7912 + (car + x))) + (car + x7912)))) + (car x7911)))) + (car x7910)))) + g7909))) + (negative? + (lambda (x) + (letrec ((g7913 + (letrec ((x7915 (number? x))) + (assert x7915))) + (g7914 (< x 0))) + g7914))) + (memv + (lambda (e l) + (letrec ((g7916 (memq e l))) g7916))) + (caaar + (lambda (x) + (letrec ((g7917 + (letrec ((x7918 + (letrec ((x7919 (car x))) + (car x7919)))) + (car x7918)))) + g7917))) + (debug + (lambda (e) (letrec ((g7920 '())) g7920))) + (reverse + (lambda (l) + (letrec ((g7921 + (letrec ((x7923 (list? l))) + (assert x7923))) + (g7922 + (letrec ((x-cnd7924 (null? l))) + (if x-cnd7924 + '() + (letrec ((x7927 + (letrec ((x7928 + (cdr l))) + (reverse x7928))) + (x7925 + (letrec ((x7926 + (car l))) + (list x7926)))) + (append x7927 x7925)))))) + g7922))) + (caaadr + (lambda (x) + (letrec ((g7929 + (letrec ((x7930 + (letrec ((x7931 + (letrec ((x7932 + (cdr + x))) + (car + x7932)))) + (car x7931)))) + (car x7930)))) + g7929))) + (cddadr + (lambda (x) + (letrec ((g7933 + (letrec ((x7934 + (letrec ((x7935 + (letrec ((x7936 + (cdr + x))) + (car + x7936)))) + (cdr x7935)))) + (cdr x7934)))) + g7933))) + (odd? + (lambda (x) + (letrec ((g7937 + (letrec ((x7939 (number? x))) + (assert x7939))) + (g7938 + (letrec ((x7940 (modulo x 2))) + (= 1 x7940)))) + g7938))) + (caadar + (lambda (x) + (letrec ((g7941 + (letrec ((x7942 + (letrec ((x7943 + (letrec ((x7944 + (car + x))) + (cdr + x7944)))) + (car x7943)))) + (car x7942)))) + g7941))) + (apply + (lambda (proc args) + (letrec ((g7945 + (letrec ((x7948 (procedure? proc))) + (assert x7948))) + (g7946 + (letrec ((x7949 (list? args))) + (assert x7949))) + (g7947 + (if cnd + (letrec ((g7950 (proc))) g7950) + (if cnd + (letrec ((g7951 + (letrec ((x7952 + (car + args))) + (proc x7952)))) + g7951) + (if cnd + (letrec ((g7953 + (letrec ((x7955 + (car + args)) + (x7954 + (cadr + args))) + (proc + x7955 + x7954)))) + g7953) + (if cnd + (letrec ((g7956 + (letrec ((x7959 + (car + args)) + (x7958 + (cadr + args)) + (x7957 + (caddr + args))) + (proc + x7959 + x7958 + x7957)))) + g7956) + (if cnd + (letrec ((g7960 + (letrec ((x7964 + (car + args)) + (x7963 + (cadr + args)) + (x7962 + (caddr + args)) + (x7961 + (cadddr + args))) + (proc + x7964 + x7963 + x7962 + x7961)))) + g7960) + (if cnd + (letrec ((g7965 + (letrec ((x7971 + (car + args)) + (x7970 + (cadr + args)) + (x7969 + (caddr + args)) + (x7968 + (cadddr + args)) + (x7966 + (letrec ((x7967 + (cddddr + args))) + (car + x7967)))) + (proc + x7971 + x7970 + x7969 + x7968 + x7966)))) + g7965) + (if cnd + (letrec ((g7972 + (letrec ((x7980 + (car + args)) + (x7979 + (cadr + args)) + (x7978 + (caddr + args)) + (x7977 + (cadddr + args)) + (x7975 + (letrec ((x7976 + (cddddr + args))) + (car + x7976))) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (cadr + x7974)))) + (proc + x7980 + x7979 + x7978 + x7977 + x7975 + x7973)))) + g7972) + (if cnd + (letrec ((g7981 + (letrec ((x7991 + (car + args)) + (x7990 + (cadr + args)) + (x7989 + (caddr + args)) + (x7988 + (cadddr + args)) + (x7986 + (letrec ((x7987 + (cddddr + args))) + (car + x7987))) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (cadr + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (caddr + x7983)))) + (proc + x7991 + x7990 + x7989 + x7988 + x7986 + x7984 + x7982)))) + g7981) + (letrec ((g7992 + (error + "Unsupported call."))) + g7992))))))))))) + g7947))) + (member + (lambda (e l) + (letrec ((g7993 + (letrec ((x7995 (list? l))) + (assert x7995))) + (g7994 + (letrec ((x-cnd7996 (null? l))) + (if x-cnd7996 + #f + (letrec ((x-cnd7997 + (letrec ((x7998 + (car l))) + (equal? x7998 e)))) + (if x-cnd7997 + l + (letrec ((x7999 (cdr l))) + (member e x7999)))))))) + g7994))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8000 + (letrec ((x8001 + (letrec ((x8002 + (letrec ((x8003 + (cdr + x))) + (cdr + x8003)))) + (cdr x8002)))) + (cdr x8001)))) + g8000))) + (cadddr + (lambda (x) + (letrec ((g8004 + (letrec ((x8005 + (letrec ((x8006 + (letrec ((x8007 + (cdr + x))) + (cdr + x8007)))) + (cdr x8006)))) + (car x8005)))) + g8004))) + (int-top + (lambda () + (letrec ((g8008 (random 42))) g8008))) + (zero? + (lambda (x) + (letrec ((g8009 + (letrec ((x8011 (number? x))) + (assert x8011))) + (g8010 (= x 0))) + g8010))) + (string>=? + (lambda (s1 s2) + (letrec ((g8012 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8013 + (if val7155 + val7155 + (string=? s1 s2)))) + g8013)))) + g8012))) + (cadr + (lambda (x) + (letrec ((g8014 + (letrec ((x8015 (cdr x))) + (car x8015)))) + g8014))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8016 + (letrec ((val7156 + (letrec ((x8019 + (pair? l)) + (x8017 + (letrec ((x8018 + (cdr + l))) + (list? + x8018)))) + (and x8019 x8017)))) + (letrec ((g8020 + (if val7156 + val7156 + (null? l)))) + g8020)))) + g8016))) + (cddaar + (lambda (x) + (letrec ((g8021 + (letrec ((x8022 + (letrec ((x8023 + (letrec ((x8024 + (car + x))) + (car + x8024)))) + (cdr x8023)))) + (cdr x8022)))) + g8021))) + (char-numeric? + (lambda (c) + (letrec ((g8025 + (letrec ((x-cnd8026 + (letrec ((x8027 #\0)) + (char<=? x8027 c)))) + (if x-cnd8026 + (letrec ((x8028 #\9)) + (char<=? c x8028)) + #f)))) + g8025))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8029 + (letrec ((x8031 (list? l))) + (assert x8031))) + (g8030 + (letrec ((x-cnd8032 (null? l))) + (if x-cnd8032 + #f + (letrec ((x-cnd8033 + (letrec ((x8034 + (caar l))) + (eqv? x8034 k)))) + (if x-cnd8033 + (car l) + (letrec ((x8035 (cdr l))) + (assq k x8035)))))))) + g8030))) + (not + (lambda (x) + (letrec ((g8036 (if x #f #t))) g8036))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8037 (append l1 l2))) g8037))) + (memq + (lambda (e l) + (letrec ((g8038 + (letrec ((x8040 (list? l))) + (assert x8040))) + (g8039 + (letrec ((x-cnd8041 (null? l))) + (if x-cnd8041 + #f + (letrec ((x-cnd8042 + (letrec ((x8043 + (car l))) + (eq? x8043 e)))) + (if x-cnd8042 + l + (letrec ((x8044 (cdr l))) + (memq e x8044)))))))) + g8039))) + (cadaar + (lambda (x) + (letrec ((g8045 + (letrec ((x8046 + (letrec ((x8047 + (letrec ((x8048 + (car + x))) + (car + x8048)))) + (cdr x8047)))) + (car x8046)))) + g8045))) + (length + (lambda (l) + (letrec ((g8049 + (letrec ((x8051 (list? l))) + (assert x8051))) + (g8050 + (letrec ((rec + (lambda (l) + (letrec ((g8052 + (letrec ((x-cnd8053 + (null? + l))) + (if x-cnd8053 + 0 + (letrec ((x8054 + (letrec ((x8055 + (cdr + l))) + (rec + x8055)))) + (+ + 1 + x8054)))))) + g8052)))) + (letrec ((g8056 (rec l))) + g8056)))) + g8050))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8057 + (letrec ((x8060 (char? c1))) + (assert x8060))) + (g8058 + (letrec ((x8061 (char? c2))) + (assert x8061))) + (g8059 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8063 + (letrec ((x8064 (string<=? s1 s2))) + (not x8064)))) + g8063))) + (cdadr + (lambda (x) + (letrec ((g8065 + (letrec ((x8066 + (letrec ((x8067 (cdr x))) + (car x8067)))) + (cdr x8066)))) + g8065))) + (assoc + (lambda (k l) + (letrec ((g8068 + (letrec ((x8070 (list? l))) + (assert x8070))) + (g8069 + (letrec ((x-cnd8071 (null? l))) + (if x-cnd8071 + #f + (letrec ((x-cnd8072 + (letrec ((x8073 + (caar l))) + (equal? x8073 k)))) + (if x-cnd8072 + (car l) + (letrec ((x8074 (cdr l))) + (assoc k x8074)))))))) + g8069))) + (caar + (lambda (x) + (letrec ((g8075 + (letrec ((x8076 (car x))) + (car x8076)))) + g8075))) + (char>? + (lambda (c1 c2) + (letrec ((g8077 + (letrec ((x8080 (char? c1))) + (assert x8080))) + (g8078 + (letrec ((x8081 (char? c2))) + (assert x8081))) + (g8079 + (letrec ((x8082 (char<=? c1 c2))) + (not x8082)))) + g8079))) + (string<=? + (lambda (s1 s2) + (letrec ((g8083 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8100 + (letrec ((x8103 (char? c1))) + (assert x8103))) + (g8101 + (letrec ((x8104 (char? c2))) + (assert x8104))) + (g8102 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8105 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8105)))) + g8102))) + (caddar + (lambda (x) + (letrec ((g8106 + (letrec ((x8107 + (letrec ((x8108 + (letrec ((x8109 + (car + x))) + (cdr + x8109)))) + (cdr x8108)))) + (car x8107)))) + g8106))) + (newline + (lambda () (letrec ((g8110 #f)) g8110))) + (lcm + (lambda (m n) + (letrec ((g8111 + (letrec ((x8113 + (letrec ((x8114 (* m n))) + (abs x8114))) + (x8112 (gcd m n))) + (/ x8113 x8112)))) + g8111))) + (deref car) + (> + (lambda (x y) + (letrec ((g8115 + (letrec ((x8117 (number? x))) + (assert x8117))) + (g8116 + (letrec ((x8118 (<= x y))) + (not x8118)))) + g8116))) + (list-ref + (lambda (l index) + (letrec ((g8119 + (letrec ((x8123 (list? l))) + (assert x8123))) + (g8120 + (letrec ((x8124 (number? index))) + (assert x8124))) + (g8121 + (letrec ((x8125 + (letrec ((x8126 + (length l))) + (< index x8126)))) + (assert x8125))) + (g8122 + (letrec ((x-cnd8127 (= index 0))) + (if x-cnd8127 + (car l) + (letrec ((x8129 (cdr l)) + (x8128 (- index 1))) + (list-ref x8129 x8128)))))) + g8122))) + (gcd + (lambda (a b) + (letrec ((g8130 + (letrec ((x-cnd8131 (= b 0))) + (if x-cnd8131 + a + (letrec ((x8132 (modulo a b))) + (gcd b x8132)))))) + g8130)))) + (letrec ((g8133 + (letrec ((g8134 + (letrec ((tak + (lambda (x y z k) + (letrec ((g8135 + (letrec ((x-cnd8136 + (letrec ((x8137 + (< + y + x))) + (not + x8137)))) + (if x-cnd8136 + (k z) + (letrec ((x8138 + (- + x + 1))) + (tak + x8138 + y + z + (lambda (v1) + (tak + (- + y + 1) + z + x + (lambda (v2) + (tak + (- + z + 1) + x + y + (lambda (v3) + (tak + v1 + v2 + v3 + k)))))))))))) + g8135))) + (tak-main + (lambda (x y z) + (letrec ((g8139 + (letrec ((x8140 + (letrec ((x8141 + (x))) + (λ x8141 + x)))) + (tak + x + y + z + x8140)))) + g8139)))) + (letrec ((g8142 + (letrec ((g8143 + (letrec ((g8144 + (letrec ((x8148 + ((lambda (j7232 + k7233 + f7234) + (lambda (g7229 + g7230 + g7231) + (integer?/c + j7232 + k7233 + (f7234 + (integer?/c + j7232 + k7233 + g7229) + (integer?/c + j7232 + k7233 + g7230) + (integer?/c + j7232 + k7233 + g7231))))) + 'module + 'importer + tak-main)) + (x8147 + (input)) + (x8146 + (input)) + (x8145 + (input))) + (x8148 + x8147 + x8146 + x8145)))) + g8144))) + g8143))) + g8142)))) + g8134))) + g8133)))) + g7246))) + g7245)) diff --git a/analyses/simpleactor/benchmarks-out/softy_last-pair.rkt b/analyses/simpleactor/benchmarks-out/softy_last-pair.rkt index 8d692bb5..9000e548 100644 --- a/analyses/simpleactor/benchmarks-out/softy_last-pair.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_last-pair.rkt @@ -1,21 +1,3069 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (lastpair x) (if (pair? (cdr x)) (lastpair (cdr x)) x)) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - (pair? j3984 k3985 (f3986 (pair? j3984 k3985 g3983))))) - 'module - 'importer - lastpair) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((lastpair + (lambda (x) + (letrec ((g8133 + (letrec ((x-cnd8134 + (letrec ((x8135 + (cdr + x))) + (pair? + x8135)))) + (if x-cnd8134 + (letrec ((x8136 + (cdr + x))) + (lastpair + x8136)) + x)))) + g8133)))) + (letrec ((g8137 + (letrec ((g8138 + (letrec ((g8139 + (letrec ((x8141 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + (pair? + j7230 + k7231 + (f7232 + (pair? + j7230 + k7231 + g7229))))) + 'module + 'importer + lastpair)) + (x8140 + (input))) + (x8141 + x8140)))) + g8139))) + g8138))) + g8137)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/softy_last.rkt b/analyses/simpleactor/benchmarks-out/softy_last.rkt index 48beaedf..02d55804 100644 --- a/analyses/simpleactor/benchmarks-out/softy_last.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_last.rkt @@ -1,28 +1,3141 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (Y f) - (λ (y) - (((λ (x) (f (λ (z) ((x x) z)))) (λ (x) (f (λ (z) ((x x) z))))) y))) - (define (last l) - ((Y (λ (f) (λ (x) (if (empty? (cdr x)) (car x) (f (cdr x)))))) l)) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - (any/c - j3984 - k3985 - (f3986 ((cons/c any/c (listof any/c)) j3984 k3985 g3983))))) - 'module - 'importer - last) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((Y + (lambda (f) + (letrec ((g8133 + (letrec ((x8150 + (y)) + (x8134 + (letrec ((x8135 + (letrec ((x8143 + (letrec ((x8149 + (x)) + (x8144 + (letrec ((x8145 + (letrec ((x8148 + (z)) + (x8146 + (letrec ((x8147 + (x + x))) + (x8147 + z)))) + (λ x8148 + x8146)))) + (f + x8145)))) + (λ x8149 + x8144))) + (x8136 + (letrec ((x8142 + (x)) + (x8137 + (letrec ((x8138 + (letrec ((x8141 + (z)) + (x8139 + (letrec ((x8140 + (x + x))) + (x8140 + z)))) + (λ x8141 + x8139)))) + (f + x8138)))) + (λ x8142 + x8137)))) + (x8143 + x8136)))) + (x8135 + y)))) + (λ x8150 + x8134)))) + g8133))) + (last + (lambda (l) + (letrec ((g8151 + (letrec ((x8152 + (letrec ((x8153 + (letrec ((x8160 + (f)) + (x8154 + (letrec ((x8159 + (x)) + (x8155 + (letrec ((x-cnd8156 + (letrec ((x8157 + (cdr + x))) + (empty? + x8157)))) + (if x-cnd8156 + (car + x) + (letrec ((x8158 + (cdr + x))) + (f + x8158)))))) + (λ x8159 + x8155)))) + (λ x8160 + x8154)))) + (Y + x8153)))) + (x8152 + l)))) + g8151)))) + (letrec ((g8161 + (letrec ((g8162 + (letrec ((g8163 + (letrec ((x8165 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + (any/c + j7230 + k7231 + (f7232 + ((cons/c + any/c + (listof + any/c)) + j7230 + k7231 + g7229))))) + 'module + 'importer + last)) + (x8164 + (input))) + (x8165 + x8164)))) + g8163))) + g8162))) + g8161)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/softy_length-acc.rkt b/analyses/simpleactor/benchmarks-out/softy_length-acc.rkt index 5cf66acd..c7f1ce4c 100644 --- a/analyses/simpleactor/benchmarks-out/softy_length-acc.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_length-acc.rkt @@ -1,25 +1,3082 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (len xs) (len-acc xs 0)) - (define (len-acc xs acc) (if (empty? xs) acc (len-acc (cdr xs) (+ 1 acc)))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((and/c integer? (>=/c 0)) - j3984 - k3985 - (f3986 ((listof any/c) j3984 k3985 g3983))))) - 'module - 'importer - len) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((len + (lambda (xs) + (letrec ((g8133 + (len-acc + xs + 0))) + g8133))) + (len-acc + (lambda (xs acc) + (letrec ((g8134 + (letrec ((x-cnd8135 + (empty? + xs))) + (if x-cnd8135 + acc + (letrec ((x8137 + (cdr + xs)) + (x8136 + (+ + 1 + acc))) + (len-acc + x8137 + x8136)))))) + g8134)))) + (letrec ((g8138 + (letrec ((g8139 + (letrec ((g8140 + (letrec ((x8142 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + ((and/c + integer?/c + (>=/c + 0)) + j7230 + k7231 + (f7232 + ((listof + any/c) + j7230 + k7231 + g7229))))) + 'module + 'importer + len)) + (x8141 + (input))) + (x8142 + x8141)))) + g8140))) + g8139))) + g8138)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/softy_length.rkt b/analyses/simpleactor/benchmarks-out/softy_length.rkt index 732fe884..ff652f56 100644 --- a/analyses/simpleactor/benchmarks-out/softy_length.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_length.rkt @@ -1,24 +1,3074 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7233 #t)) g7233))) + (meta (lambda (v) (letrec ((g7234 v)) g7234))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7235 + (letrec ((g7236 + (letrec ((x-e7237 lst)) + (match + x-e7237 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7238 (eq? v v1))) + (if x-cnd7238 #t (member v vs))))))))) + g7236))) + g7235))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (len xs) (if (empty? xs) 0 (+ 1 (len (cdr xs))))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((and/c integer? (>=/c 0)) - j3984 - k3985 - (f3986 ((listof any/c) j3984 k3985 g3983))))) - 'module - 'importer - len) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7239 (lambda (v) (letrec ((g7240 v)) g7240)))) g7239))) + (nonzero? + (lambda (v) + (letrec ((g7241 (letrec ((x7242 (= v 0))) (not x7242)))) g7241)))) + (letrec ((g7243 + (letrec ((g7244 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7245 + (letrec ((x-cnd7246 (real? g7162))) + (if x-cnd7246 + g7162 + (blame g7160 'real?))))) + g7245))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7247 + (letrec ((x-cnd7248 + (boolean? g7165))) + (if x-cnd7248 + g7165 + (blame g7163 'boolean?))))) + g7247))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7249 + (letrec ((x-cnd7250 + (number? g7168))) + (if x-cnd7250 + g7168 + (blame g7166 'number?))))) + g7249))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7251 + (letrec ((x-cnd7252 + ((lambda (v) #t) g7171))) + (if x-cnd7252 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7251))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7174))) + (if x-cnd7254 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7253))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7255 + (letrec ((x-cnd7256 (pair? g7177))) + (if x-cnd7256 + g7177 + (blame g7175 'pair?))))) + g7255))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7180))) + (if x-cnd7258 + g7180 + (blame g7178 'pair?))))) + g7257))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7259 + (letrec ((x-cnd7260 + (integer? g7183))) + (if x-cnd7260 + g7183 + (blame g7181 'integer?))))) + g7259))) + (and/c + (lambda (c1 c2) + (letrec ((g7261 + (lambda (k j v) + (letrec ((g7262 + (letrec ((x-cnd7263 + (c1 k j v))) + (if x-cnd7263 + (c2 k j v) + #f)))) + g7262)))) + g7261))) + (list-of + (lambda (contract) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (null? v))) + (if x-cnd7266 + '() + (letrec ((x7270 + (letrec ((x7271 + (car + v))) + (contract + k + j + x7271))) + (x7267 + (letrec ((x7269 + (list-of + contract)) + (x7268 + (cdr + v))) + (x7269 + k + j + x7268)))) + (cons + x7270 + x7267)))))) + g7265)))) + g7264))) + (any? (lambda (v) (letrec ((g7272 #t)) g7272))) + (nonzero? + (lambda (v) + (letrec ((g7273 + (letrec ((x7274 (= v 0))) + (not x7274)))) + g7273))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7275 + (letrec ((x-cnd7276 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7276 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7275))) + (meta (lambda (v) (letrec ((g7277 v)) g7277))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7278 #t)) g7278))) + (cdddr + (lambda (x) + (letrec ((g7279 + (letrec ((x7280 + (letrec ((x7281 (cdr x))) + (cdr x7281)))) + (cdr x7280)))) + g7279))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7282 + (letrec ((x7285 (procedure? f))) + (assert x7285))) + (g7283 + (letrec ((x7286 (list? l))) + (assert x7286))) + (g7284 + (letrec ((x-cnd7287 (null? l))) + (if x-cnd7287 + '() + (letrec ((x7290 + (letrec ((x7291 + (car l))) + (f x7291))) + (x7288 + (letrec ((x7289 + (cdr l))) + (map f x7289)))) + (cons x7290 x7288)))))) + g7284))) + (cdar + (lambda (x) + (letrec ((g7292 + (letrec ((x7293 (car x))) + (cdr x7293)))) + g7292))) + (cadadr + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (cdr + x))) + (car + x7297)))) + (cdr x7296)))) + (car x7295)))) + g7294))) + (cdadar + (lambda (x) + (letrec ((g7298 + (letrec ((x7299 + (letrec ((x7300 + (letrec ((x7301 + (car + x))) + (cdr + x7301)))) + (car x7300)))) + (cdr x7299)))) + g7298))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7302 + (letrec ((x7305 + (string? filename))) + (assert x7305))) + (g7303 + (letrec ((x7306 (procedure? proc))) + (assert x7306))) + (g7304 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7307 + (close-output-port + output-port)) + (g7308 res)) + g7308)))) + g7304))) + (caddr + (lambda (x) + (letrec ((g7309 + (letrec ((x7310 + (letrec ((x7311 (cdr x))) + (cdr x7311)))) + (car x7310)))) + g7309))) + (cdaadr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 + (letrec ((x7315 + (cdr + x))) + (car + x7315)))) + (car x7314)))) + (cdr x7313)))) + g7312))) + (assq + (lambda (k l) + (letrec ((g7316 + (letrec ((x7318 (list? l))) + (assert x7318))) + (g7317 + (letrec ((x-cnd7319 (null? l))) + (if x-cnd7319 + #f + (letrec ((x-cnd7320 + (letrec ((x7321 + (caar l))) + (eq? x7321 k)))) + (if x-cnd7320 + (car l) + (letrec ((x7322 (cdr l))) + (assq k x7322)))))))) + g7317))) + (even? + (lambda (x) + (letrec ((g7323 + (letrec ((x7324 (modulo x 2))) + (= 0 x7324)))) + g7323))) + (list->string + (lambda (l) + (letrec ((g7325 + (letrec ((x7327 (list? l))) + (assert x7327))) + (g7326 + (letrec ((x-cnd7328 (null? l))) + (if x-cnd7328 + "" + (letrec ((x7331 + (letrec ((x7332 + (car l))) + (char->string + x7332))) + (x7329 + (letrec ((x7330 + (cdr l))) + (list->string + x7330)))) + (string-append + x7331 + x7329)))))) + g7326))) + (char<=? + (lambda (c1 c2) + (letrec ((g7333 + (letrec ((x7336 (char? c1))) + (assert x7336))) + (g7334 + (letrec ((x7337 (char? c2))) + (assert x7337))) + (g7335 + (letrec ((val7143 (char=? c x7354)))) + (if x-cnd7353 + (letrec ((x7355 #\z)) + (char-ci<=? c x7355)) + #f)))) + g7352))) + (<= + (lambda (x y) + (letrec ((g7356 + (letrec ((x7358 (number? x))) + (assert x7358))) + (g7357 + (letrec ((val7144 (< x y))) + (letrec ((g7359 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7360 + (if val7145 + val7145 + #f))) + g7360))))) + g7359)))) + g7357))) + (char-whitespace? + (lambda (c) + (letrec ((g7361 + (letrec ((val7146 + (letrec ((x7362 + (char->integer + c))) + (= x7362 9)))) + (letrec ((g7363 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7364 + (char->integer + c))) + (= + x7364 + 10)))) + (letrec ((g7365 + (if val7147 + val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 32))))) + g7365))))) + g7363)))) + g7361))) + (cddar + (lambda (x) + (letrec ((g7367 + (letrec ((x7368 + (letrec ((x7369 (car x))) + (cdr x7369)))) + (cdr x7368)))) + g7367))) + (positive? + (lambda (x) + (letrec ((g7370 + (letrec ((x7372 (number? x))) + (assert x7372))) + (g7371 (> x 0))) + g7371))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7373 #f)) g7373))) + (cddr + (lambda (x) + (letrec ((g7374 + (letrec ((x7375 (cdr x))) + (cdr x7375)))) + g7374))) + (truncate + (lambda (x) + (letrec ((g7376 + (letrec ((x7378 (number? x))) + (assert x7378))) + (g7377 + (letrec ((x-cnd7379 (< x 0))) + (if x-cnd7379 + (ceiling x) + (floor x))))) + g7377))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7380 + (letrec ((val7148 (eq? a b))) + (letrec ((g7381 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7383 + (null? + a)) + (x7382 + (null? + b))) + (and x7383 + x7382)))) + (letrec ((g7384 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7387 + (string? + a)) + (x7386 + (string? + b)) + (x7385 + (string=? + a + b))) + (and x7387 + x7386 + x7385)))) + (letrec ((g7388 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7396 + (pair? + a)) + (x7395 + (pair? + b)) + (x7392 + (letrec ((x7394 + (car + a)) + (x7393 + (car + b))) + (equal? + x7394 + x7393))) + (x7389 + (letrec ((x7391 + (cdr + a)) + (x7390 + (cdr + b))) + (equal? + x7391 + x7390)))) + (and x7396 + x7395 + x7392 + x7389)))) + (letrec ((g7397 + (if val7151 + val7151 + (letrec ((x7416 + (vector? + a)) + (x7415 + (vector? + b)) + (x7398 + (letrec ((x7412 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + a))) + (n + x7414)))) + (x7413))) + (x7399 + (letrec ((x7410 + (letrec ((x7411 + (vector-length + b))) + (= + x7411 + n))) + (x7400 + (letrec ((loop + (lambda (i) + (letrec ((g7401 + (letrec ((x7408 + (= + i + n)) + (x7402 + (letrec ((x7405 + (letrec ((x7407 + (vector-ref + a + i)) + (x7406 + (vector-ref + b + i))) + (equal? + x7407 + x7406))) + (x7403 + (letrec ((x7404 + (+ + i + 1))) + (loop + x7404)))) + (and x7405 + x7403)))) + (or x7408 + x7402)))) + g7401)))) + (letrec ((g7409 + (loop + 0))) + g7409)))) + (and x7410 + x7400)))) + (let x7412 x7399)))) + (and x7416 + x7415 + x7398))))) + g7397))))) + g7388))))) + g7384))))) + g7381)))) + g7380))) + (cdaaar + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (car + x))) + (car + x7420)))) + (car x7419)))) + (cdr x7418)))) + g7417))) + (caaddr + (lambda (x) + (letrec ((g7421 + (letrec ((x7422 + (letrec ((x7423 + (letrec ((x7424 + (cdr + x))) + (cdr + x7424)))) + (car x7423)))) + (car x7422)))) + g7421))) + (eqv? + (lambda (x y) + (letrec ((g7425 (eq? x y))) g7425))) + (>= + (lambda (x y) + (letrec ((g7426 + (letrec ((x7428 (number? x))) + (assert x7428))) + (g7427 + (letrec ((val7152 (> x y))) + (letrec ((g7429 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7430 + (if val7153 + val7153 + #f))) + g7430))))) + g7429)))) + g7427))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7431 + (letrec ((x7434 + (string? filename))) + (assert x7434))) + (g7432 + (letrec ((x7435 (procedure? proc))) + (assert x7435))) + (g7433 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7436 + (close-input-port + input-port)) + (g7437 res)) + g7437)))) + g7433))) + (ref + (lambda (x) + (letrec ((g7438 (cons x '()))) g7438))) + (char>=? + (lambda (c1 c2) + (letrec ((g7439 + (letrec ((x7442 (char? c1))) + (assert x7442))) + (g7440 + (letrec ((x7443 (char? c2))) + (assert x7443))) + (g7441 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7444 + (if val7154 + val7154 + (char=? c1 c2)))) + g7444)))) + g7441))) + (cdaar + (lambda (x) + (letrec ((g7445 + (letrec ((x7446 + (letrec ((x7447 (car x))) + (car x7447)))) + (cdr x7446)))) + g7445))) + (cdaddr + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 + (letrec ((x7451 + (cdr + x))) + (cdr + x7451)))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7452 + (letrec ((x7453 + (letrec ((x7454 (car x))) + (cdr x7454)))) + (car x7453)))) + g7452))) + (caadr + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (cdr x))) + (car x7457)))) + (car x7456)))) + g7455))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7458 + (letrec ((x7461 (char? c1))) + (assert x7461))) + (g7459 + (letrec ((x7462 (char? c2))) + (assert x7462))) + (g7460 + (letrec ((x7463 + (char-ci<=? c1 c2))) + (not x7463)))) + g7460))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7464 + (letrec ((x7465 + (letrec ((x7466 + (letrec ((x7467 + (car + x))) + (car + x7467)))) + (car x7466)))) + (car x7465)))) + g7464))) + (negative? + (lambda (x) + (letrec ((g7468 + (letrec ((x7470 (number? x))) + (assert x7470))) + (g7469 (< x 0))) + g7469))) + (memv + (lambda (e l) + (letrec ((g7471 (memq e l))) g7471))) + (caaar + (lambda (x) + (letrec ((g7472 + (letrec ((x7473 + (letrec ((x7474 (car x))) + (car x7474)))) + (car x7473)))) + g7472))) + (debug + (lambda (e) (letrec ((g7475 '())) g7475))) + (reverse + (lambda (l) + (letrec ((g7476 + (letrec ((x7478 (list? l))) + (assert x7478))) + (g7477 + (letrec ((x-cnd7479 (null? l))) + (if x-cnd7479 + '() + (letrec ((x7482 + (letrec ((x7483 + (cdr l))) + (reverse x7483))) + (x7480 + (letrec ((x7481 + (car l))) + (list x7481)))) + (append x7482 x7480)))))) + g7477))) + (caaadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (car x7486)))) + (car x7485)))) + g7484))) + (cddadr + (lambda (x) + (letrec ((g7488 + (letrec ((x7489 + (letrec ((x7490 + (letrec ((x7491 + (cdr + x))) + (car + x7491)))) + (cdr x7490)))) + (cdr x7489)))) + g7488))) + (odd? + (lambda (x) + (letrec ((g7492 + (letrec ((x7494 (number? x))) + (assert x7494))) + (g7493 + (letrec ((x7495 (modulo x 2))) + (= 1 x7495)))) + g7493))) + (caadar + (lambda (x) + (letrec ((g7496 + (letrec ((x7497 + (letrec ((x7498 + (letrec ((x7499 + (car + x))) + (cdr + x7499)))) + (car x7498)))) + (car x7497)))) + g7496))) + (apply + (lambda (proc args) + (letrec ((g7500 + (letrec ((x7503 (procedure? proc))) + (assert x7503))) + (g7501 + (letrec ((x7504 (list? args))) + (assert x7504))) + (g7502 + (if cnd + (letrec ((g7505 (proc))) g7505) + (if cnd + (letrec ((g7506 + (letrec ((x7507 + (car + args))) + (proc x7507)))) + g7506) + (if cnd + (letrec ((g7508 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args))) + (proc + x7510 + x7509)))) + g7508) + (if cnd + (letrec ((g7511 + (letrec ((x7514 + (car + args)) + (x7513 + (cadr + args)) + (x7512 + (caddr + args))) + (proc + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7515 + (letrec ((x7519 + (car + args)) + (x7518 + (cadr + args)) + (x7517 + (caddr + args)) + (x7516 + (cadddr + args))) + (proc + x7519 + x7518 + x7517 + x7516)))) + g7515) + (if cnd + (letrec ((g7520 + (letrec ((x7526 + (car + args)) + (x7525 + (cadr + args)) + (x7524 + (caddr + args)) + (x7523 + (cadddr + args)) + (x7521 + (letrec ((x7522 + (cddddr + args))) + (car + x7522)))) + (proc + x7526 + x7525 + x7524 + x7523 + x7521)))) + g7520) + (if cnd + (letrec ((g7527 + (letrec ((x7535 + (car + args)) + (x7534 + (cadr + args)) + (x7533 + (caddr + args)) + (x7532 + (cadddr + args)) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (car + x7531))) + (x7528 + (letrec ((x7529 + (cddddr + args))) + (cadr + x7529)))) + (proc + x7535 + x7534 + x7533 + x7532 + x7530 + x7528)))) + g7527) + (if cnd + (letrec ((g7536 + (letrec ((x7546 + (car + args)) + (x7545 + (cadr + args)) + (x7544 + (caddr + args)) + (x7543 + (cadddr + args)) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (car + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (cadr + x7540))) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (caddr + x7538)))) + (proc + x7546 + x7545 + x7544 + x7543 + x7541 + x7539 + x7537)))) + g7536) + (letrec ((g7547 + (error + "Unsupported call."))) + g7547))))))))))) + g7502))) + (member + (lambda (e l) + (letrec ((g7548 + (letrec ((x7550 (list? l))) + (assert x7550))) + (g7549 + (letrec ((x-cnd7551 (null? l))) + (if x-cnd7551 + #f + (letrec ((x-cnd7552 + (letrec ((x7553 + (car l))) + (equal? x7553 e)))) + (if x-cnd7552 + l + (letrec ((x7554 (cdr l))) + (member e x7554)))))))) + g7549))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (cdr x7556)))) + g7555))) + (cadddr + (lambda (x) + (letrec ((g7559 + (letrec ((x7560 + (letrec ((x7561 + (letrec ((x7562 + (cdr + x))) + (cdr + x7562)))) + (cdr x7561)))) + (car x7560)))) + g7559))) + (int-top + (lambda () + (letrec ((g7563 (random 42))) g7563))) + (zero? + (lambda (x) + (letrec ((g7564 + (letrec ((x7566 (number? x))) + (assert x7566))) + (g7565 (= x 0))) + g7565))) + (string>=? + (lambda (s1 s2) + (letrec ((g7567 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7568 + (if val7155 + val7155 + (string=? s1 s2)))) + g7568)))) + g7567))) + (cadr + (lambda (x) + (letrec ((g7569 + (letrec ((x7570 (cdr x))) + (car x7570)))) + g7569))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7571 + (letrec ((val7156 + (letrec ((x7574 + (pair? l)) + (x7572 + (letrec ((x7573 + (cdr + l))) + (list? + x7573)))) + (and x7574 x7572)))) + (letrec ((g7575 + (if val7156 + val7156 + (null? l)))) + g7575)))) + g7571))) + (cddaar + (lambda (x) + (letrec ((g7576 + (letrec ((x7577 + (letrec ((x7578 + (letrec ((x7579 + (car + x))) + (car + x7579)))) + (cdr x7578)))) + (cdr x7577)))) + g7576))) + (char-numeric? + (lambda (c) + (letrec ((g7580 + (letrec ((x-cnd7581 + (letrec ((x7582 #\0)) + (char<=? x7582 c)))) + (if x-cnd7581 + (letrec ((x7583 #\9)) + (char<=? c x7583)) + #f)))) + g7580))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7584 + (letrec ((x7586 (list? l))) + (assert x7586))) + (g7585 + (letrec ((x-cnd7587 (null? l))) + (if x-cnd7587 + #f + (letrec ((x-cnd7588 + (letrec ((x7589 + (caar l))) + (eqv? x7589 k)))) + (if x-cnd7588 + (car l) + (letrec ((x7590 (cdr l))) + (assq k x7590)))))))) + g7585))) + (not + (lambda (x) + (letrec ((g7591 (if x #f #t))) g7591))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7592 (append l1 l2))) g7592))) + (memq + (lambda (e l) + (letrec ((g7593 + (letrec ((x7595 (list? l))) + (assert x7595))) + (g7594 + (letrec ((x-cnd7596 (null? l))) + (if x-cnd7596 + #f + (letrec ((x-cnd7597 + (letrec ((x7598 + (car l))) + (eq? x7598 e)))) + (if x-cnd7597 + l + (letrec ((x7599 (cdr l))) + (memq e x7599)))))))) + g7594))) + (cadaar + (lambda (x) + (letrec ((g7600 + (letrec ((x7601 + (letrec ((x7602 + (letrec ((x7603 + (car + x))) + (car + x7603)))) + (cdr x7602)))) + (car x7601)))) + g7600))) + (length + (lambda (l) + (letrec ((g7604 + (letrec ((x7606 (list? l))) + (assert x7606))) + (g7605 + (letrec ((rec + (lambda (l) + (letrec ((g7607 + (letrec ((x-cnd7608 + (null? + l))) + (if x-cnd7608 + 0 + (letrec ((x7609 + (letrec ((x7610 + (cdr + l))) + (rec + x7610)))) + (+ + 1 + x7609)))))) + g7607)))) + (letrec ((g7611 (rec l))) + g7611)))) + g7605))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7612 + (letrec ((x7615 (char? c1))) + (assert x7615))) + (g7613 + (letrec ((x7616 (char? c2))) + (assert x7616))) + (g7614 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7618 + (letrec ((x7619 (string<=? s1 s2))) + (not x7619)))) + g7618))) + (cdadr + (lambda (x) + (letrec ((g7620 + (letrec ((x7621 + (letrec ((x7622 (cdr x))) + (car x7622)))) + (cdr x7621)))) + g7620))) + (assoc + (lambda (k l) + (letrec ((g7623 + (letrec ((x7625 (list? l))) + (assert x7625))) + (g7624 + (letrec ((x-cnd7626 (null? l))) + (if x-cnd7626 + #f + (letrec ((x-cnd7627 + (letrec ((x7628 + (caar l))) + (equal? x7628 k)))) + (if x-cnd7627 + (car l) + (letrec ((x7629 (cdr l))) + (assoc k x7629)))))))) + g7624))) + (caar + (lambda (x) + (letrec ((g7630 + (letrec ((x7631 (car x))) + (car x7631)))) + g7630))) + (char>? + (lambda (c1 c2) + (letrec ((g7632 + (letrec ((x7635 (char? c1))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char? c2))) + (assert x7636))) + (g7634 + (letrec ((x7637 (char<=? c1 c2))) + (not x7637)))) + g7634))) + (string<=? + (lambda (s1 s2) + (letrec ((g7638 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7655 + (letrec ((x7658 (char? c1))) + (assert x7658))) + (g7656 + (letrec ((x7659 (char? c2))) + (assert x7659))) + (g7657 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7660 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7660)))) + g7657))) + (caddar + (lambda (x) + (letrec ((g7661 + (letrec ((x7662 + (letrec ((x7663 + (letrec ((x7664 + (car + x))) + (cdr + x7664)))) + (cdr x7663)))) + (car x7662)))) + g7661))) + (newline + (lambda () (letrec ((g7665 #f)) g7665))) + (lcm + (lambda (m n) + (letrec ((g7666 + (letrec ((x7668 + (letrec ((x7669 (* m n))) + (abs x7669))) + (x7667 (gcd m n))) + (/ x7668 x7667)))) + g7666))) + (deref car) + (> + (lambda (x y) + (letrec ((g7670 + (letrec ((x7672 (number? x))) + (assert x7672))) + (g7671 + (letrec ((x7673 (<= x y))) + (not x7673)))) + g7671))) + (list-ref + (lambda (l index) + (letrec ((g7674 + (letrec ((x7678 (list? l))) + (assert x7678))) + (g7675 + (letrec ((x7679 (number? index))) + (assert x7679))) + (g7676 + (letrec ((x7680 + (letrec ((x7681 + (length l))) + (< index x7681)))) + (assert x7680))) + (g7677 + (letrec ((x-cnd7682 (= index 0))) + (if x-cnd7682 + (car l) + (letrec ((x7684 (cdr l)) + (x7683 (- index 1))) + (list-ref x7684 x7683)))))) + g7677))) + (gcd + (lambda (a b) + (letrec ((g7685 + (letrec ((x-cnd7686 (= b 0))) + (if x-cnd7686 + a + (letrec ((x7687 (modulo a b))) + (gcd b x7687)))))) + g7685))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7688 + (letrec ((x-cnd7689 (real? g7162))) + (if x-cnd7689 + g7162 + (blame g7160 'real?))))) + g7688))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7690 + (letrec ((x-cnd7691 + (boolean? g7165))) + (if x-cnd7691 + g7165 + (blame g7163 'boolean?))))) + g7690))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7692 + (letrec ((x-cnd7693 + (number? g7168))) + (if x-cnd7693 + g7168 + (blame g7166 'number?))))) + g7692))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7694 + (letrec ((x-cnd7695 + ((lambda (v) #t) g7171))) + (if x-cnd7695 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7694))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7174))) + (if x-cnd7697 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7696))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7698 + (letrec ((x-cnd7699 (pair? g7177))) + (if x-cnd7699 + g7177 + (blame g7175 'pair?))))) + g7698))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7180))) + (if x-cnd7701 + g7180 + (blame g7178 'pair?))))) + g7700))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7702 + (letrec ((x-cnd7703 + (integer? g7183))) + (if x-cnd7703 + g7183 + (blame g7181 'integer?))))) + g7702))) + (and/c + (lambda (c1 c2) + (letrec ((g7704 + (lambda (k j v) + (letrec ((g7705 + (letrec ((x-cnd7706 + (c1 k j v))) + (if x-cnd7706 + (c2 k j v) + #f)))) + g7705)))) + g7704))) + (list-of + (lambda (contract) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (null? v))) + (if x-cnd7709 + '() + (letrec ((x7713 + (letrec ((x7714 + (car + v))) + (contract + k + j + x7714))) + (x7710 + (letrec ((x7712 + (list-of + contract)) + (x7711 + (cdr + v))) + (x7712 + k + j + x7711)))) + (cons + x7713 + x7710)))))) + g7708)))) + g7707))) + (any? (lambda (v) (letrec ((g7715 #t)) g7715))) + (nonzero? + (lambda (v) + (letrec ((g7716 + (letrec ((x7717 (= v 0))) + (not x7717)))) + g7716))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7718 + (letrec ((x-cnd7719 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7719 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7718))) + (meta (lambda (v) (letrec ((g7720 v)) g7720))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7721 #t)) g7721))) + (cdddr + (lambda (x) + (letrec ((g7722 + (letrec ((x7723 + (letrec ((x7724 (cdr x))) + (cdr x7724)))) + (cdr x7723)))) + g7722))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7725 + (letrec ((x7728 (procedure? f))) + (assert x7728))) + (g7726 + (letrec ((x7729 (list? l))) + (assert x7729))) + (g7727 + (letrec ((x-cnd7730 (null? l))) + (if x-cnd7730 + '() + (letrec ((x7733 + (letrec ((x7734 + (car l))) + (f x7734))) + (x7731 + (letrec ((x7732 + (cdr l))) + (map f x7732)))) + (cons x7733 x7731)))))) + g7727))) + (cdar + (lambda (x) + (letrec ((g7735 + (letrec ((x7736 (car x))) + (cdr x7736)))) + g7735))) + (cadadr + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (cdr + x))) + (car + x7740)))) + (cdr x7739)))) + (car x7738)))) + g7737))) + (cdadar + (lambda (x) + (letrec ((g7741 + (letrec ((x7742 + (letrec ((x7743 + (letrec ((x7744 + (car + x))) + (cdr + x7744)))) + (car x7743)))) + (cdr x7742)))) + g7741))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7745 + (letrec ((x7748 + (string? filename))) + (assert x7748))) + (g7746 + (letrec ((x7749 (procedure? proc))) + (assert x7749))) + (g7747 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7750 + (close-output-port + output-port)) + (g7751 res)) + g7751)))) + g7747))) + (caddr + (lambda (x) + (letrec ((g7752 + (letrec ((x7753 + (letrec ((x7754 (cdr x))) + (cdr x7754)))) + (car x7753)))) + g7752))) + (cdaadr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 + (letrec ((x7758 + (cdr + x))) + (car + x7758)))) + (car x7757)))) + (cdr x7756)))) + g7755))) + (assq + (lambda (k l) + (letrec ((g7759 + (letrec ((x7761 (list? l))) + (assert x7761))) + (g7760 + (letrec ((x-cnd7762 (null? l))) + (if x-cnd7762 + #f + (letrec ((x-cnd7763 + (letrec ((x7764 + (caar l))) + (eq? x7764 k)))) + (if x-cnd7763 + (car l) + (letrec ((x7765 (cdr l))) + (assq k x7765)))))))) + g7760))) + (even? + (lambda (x) + (letrec ((g7766 + (letrec ((x7767 (modulo x 2))) + (= 0 x7767)))) + g7766))) + (list->string + (lambda (l) + (letrec ((g7768 + (letrec ((x7770 (list? l))) + (assert x7770))) + (g7769 + (letrec ((x-cnd7771 (null? l))) + (if x-cnd7771 + "" + (letrec ((x7774 + (letrec ((x7775 + (car l))) + (char->string + x7775))) + (x7772 + (letrec ((x7773 + (cdr l))) + (list->string + x7773)))) + (string-append + x7774 + x7772)))))) + g7769))) + (char<=? + (lambda (c1 c2) + (letrec ((g7776 + (letrec ((x7779 (char? c1))) + (assert x7779))) + (g7777 + (letrec ((x7780 (char? c2))) + (assert x7780))) + (g7778 + (letrec ((val7143 (char=? c x7797)))) + (if x-cnd7796 + (letrec ((x7798 #\z)) + (char-ci<=? c x7798)) + #f)))) + g7795))) + (<= + (lambda (x y) + (letrec ((g7799 + (letrec ((x7801 (number? x))) + (assert x7801))) + (g7800 + (letrec ((val7144 (< x y))) + (letrec ((g7802 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7803 + (if val7145 + val7145 + #f))) + g7803))))) + g7802)))) + g7800))) + (char-whitespace? + (lambda (c) + (letrec ((g7804 + (letrec ((val7146 + (letrec ((x7805 + (char->integer + c))) + (= x7805 9)))) + (letrec ((g7806 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7807 + (char->integer + c))) + (= + x7807 + 10)))) + (letrec ((g7808 + (if val7147 + val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 32))))) + g7808))))) + g7806)))) + g7804))) + (cddar + (lambda (x) + (letrec ((g7810 + (letrec ((x7811 + (letrec ((x7812 (car x))) + (cdr x7812)))) + (cdr x7811)))) + g7810))) + (positive? + (lambda (x) + (letrec ((g7813 + (letrec ((x7815 (number? x))) + (assert x7815))) + (g7814 (> x 0))) + g7814))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7816 #f)) g7816))) + (cddr + (lambda (x) + (letrec ((g7817 + (letrec ((x7818 (cdr x))) + (cdr x7818)))) + g7817))) + (truncate + (lambda (x) + (letrec ((g7819 + (letrec ((x7821 (number? x))) + (assert x7821))) + (g7820 + (letrec ((x-cnd7822 (< x 0))) + (if x-cnd7822 + (ceiling x) + (floor x))))) + g7820))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7823 + (letrec ((val7148 (eq? a b))) + (letrec ((g7824 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7826 + (null? + a)) + (x7825 + (null? + b))) + (and x7826 + x7825)))) + (letrec ((g7827 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7830 + (string? + a)) + (x7829 + (string? + b)) + (x7828 + (string=? + a + b))) + (and x7830 + x7829 + x7828)))) + (letrec ((g7831 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7839 + (pair? + a)) + (x7838 + (pair? + b)) + (x7835 + (letrec ((x7837 + (car + a)) + (x7836 + (car + b))) + (equal? + x7837 + x7836))) + (x7832 + (letrec ((x7834 + (cdr + a)) + (x7833 + (cdr + b))) + (equal? + x7834 + x7833)))) + (and x7839 + x7838 + x7835 + x7832)))) + (letrec ((g7840 + (if val7151 + val7151 + (letrec ((x7859 + (vector? + a)) + (x7858 + (vector? + b)) + (x7841 + (letrec ((x7855 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + a))) + (n + x7857)))) + (x7856))) + (x7842 + (letrec ((x7853 + (letrec ((x7854 + (vector-length + b))) + (= + x7854 + n))) + (x7843 + (letrec ((loop + (lambda (i) + (letrec ((g7844 + (letrec ((x7851 + (= + i + n)) + (x7845 + (letrec ((x7848 + (letrec ((x7850 + (vector-ref + a + i)) + (x7849 + (vector-ref + b + i))) + (equal? + x7850 + x7849))) + (x7846 + (letrec ((x7847 + (+ + i + 1))) + (loop + x7847)))) + (and x7848 + x7846)))) + (or x7851 + x7845)))) + g7844)))) + (letrec ((g7852 + (loop + 0))) + g7852)))) + (and x7853 + x7843)))) + (let x7855 x7842)))) + (and x7859 + x7858 + x7841))))) + g7840))))) + g7831))))) + g7827))))) + g7824)))) + g7823))) + (cdaaar + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (car + x))) + (car + x7863)))) + (car x7862)))) + (cdr x7861)))) + g7860))) + (caaddr + (lambda (x) + (letrec ((g7864 + (letrec ((x7865 + (letrec ((x7866 + (letrec ((x7867 + (cdr + x))) + (cdr + x7867)))) + (car x7866)))) + (car x7865)))) + g7864))) + (eqv? + (lambda (x y) + (letrec ((g7868 (eq? x y))) g7868))) + (>= + (lambda (x y) + (letrec ((g7869 + (letrec ((x7871 (number? x))) + (assert x7871))) + (g7870 + (letrec ((val7152 (> x y))) + (letrec ((g7872 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7873 + (if val7153 + val7153 + #f))) + g7873))))) + g7872)))) + g7870))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7874 + (letrec ((x7877 + (string? filename))) + (assert x7877))) + (g7875 + (letrec ((x7878 (procedure? proc))) + (assert x7878))) + (g7876 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7879 + (close-input-port + input-port)) + (g7880 res)) + g7880)))) + g7876))) + (ref + (lambda (x) + (letrec ((g7881 (cons x '()))) g7881))) + (char>=? + (lambda (c1 c2) + (letrec ((g7882 + (letrec ((x7885 (char? c1))) + (assert x7885))) + (g7883 + (letrec ((x7886 (char? c2))) + (assert x7886))) + (g7884 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7887 + (if val7154 + val7154 + (char=? c1 c2)))) + g7887)))) + g7884))) + (cdaar + (lambda (x) + (letrec ((g7888 + (letrec ((x7889 + (letrec ((x7890 (car x))) + (car x7890)))) + (cdr x7889)))) + g7888))) + (cdaddr + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 + (letrec ((x7894 + (cdr + x))) + (cdr + x7894)))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7895 + (letrec ((x7896 + (letrec ((x7897 (car x))) + (cdr x7897)))) + (car x7896)))) + g7895))) + (caadr + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (cdr x))) + (car x7900)))) + (car x7899)))) + g7898))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7901 + (letrec ((x7904 (char? c1))) + (assert x7904))) + (g7902 + (letrec ((x7905 (char? c2))) + (assert x7905))) + (g7903 + (letrec ((x7906 + (char-ci<=? c1 c2))) + (not x7906)))) + g7903))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7907 + (letrec ((x7908 + (letrec ((x7909 + (letrec ((x7910 + (car + x))) + (car + x7910)))) + (car x7909)))) + (car x7908)))) + g7907))) + (negative? + (lambda (x) + (letrec ((g7911 + (letrec ((x7913 (number? x))) + (assert x7913))) + (g7912 (< x 0))) + g7912))) + (memv + (lambda (e l) + (letrec ((g7914 (memq e l))) g7914))) + (caaar + (lambda (x) + (letrec ((g7915 + (letrec ((x7916 + (letrec ((x7917 (car x))) + (car x7917)))) + (car x7916)))) + g7915))) + (debug + (lambda (e) (letrec ((g7918 '())) g7918))) + (reverse + (lambda (l) + (letrec ((g7919 + (letrec ((x7921 (list? l))) + (assert x7921))) + (g7920 + (letrec ((x-cnd7922 (null? l))) + (if x-cnd7922 + '() + (letrec ((x7925 + (letrec ((x7926 + (cdr l))) + (reverse x7926))) + (x7923 + (letrec ((x7924 + (car l))) + (list x7924)))) + (append x7925 x7923)))))) + g7920))) + (caaadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (car x7929)))) + (car x7928)))) + g7927))) + (cddadr + (lambda (x) + (letrec ((g7931 + (letrec ((x7932 + (letrec ((x7933 + (letrec ((x7934 + (cdr + x))) + (car + x7934)))) + (cdr x7933)))) + (cdr x7932)))) + g7931))) + (odd? + (lambda (x) + (letrec ((g7935 + (letrec ((x7937 (number? x))) + (assert x7937))) + (g7936 + (letrec ((x7938 (modulo x 2))) + (= 1 x7938)))) + g7936))) + (caadar + (lambda (x) + (letrec ((g7939 + (letrec ((x7940 + (letrec ((x7941 + (letrec ((x7942 + (car + x))) + (cdr + x7942)))) + (car x7941)))) + (car x7940)))) + g7939))) + (apply + (lambda (proc args) + (letrec ((g7943 + (letrec ((x7946 (procedure? proc))) + (assert x7946))) + (g7944 + (letrec ((x7947 (list? args))) + (assert x7947))) + (g7945 + (if cnd + (letrec ((g7948 (proc))) g7948) + (if cnd + (letrec ((g7949 + (letrec ((x7950 + (car + args))) + (proc x7950)))) + g7949) + (if cnd + (letrec ((g7951 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args))) + (proc + x7953 + x7952)))) + g7951) + (if cnd + (letrec ((g7954 + (letrec ((x7957 + (car + args)) + (x7956 + (cadr + args)) + (x7955 + (caddr + args))) + (proc + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7958 + (letrec ((x7962 + (car + args)) + (x7961 + (cadr + args)) + (x7960 + (caddr + args)) + (x7959 + (cadddr + args))) + (proc + x7962 + x7961 + x7960 + x7959)))) + g7958) + (if cnd + (letrec ((g7963 + (letrec ((x7969 + (car + args)) + (x7968 + (cadr + args)) + (x7967 + (caddr + args)) + (x7966 + (cadddr + args)) + (x7964 + (letrec ((x7965 + (cddddr + args))) + (car + x7965)))) + (proc + x7969 + x7968 + x7967 + x7966 + x7964)))) + g7963) + (if cnd + (letrec ((g7970 + (letrec ((x7978 + (car + args)) + (x7977 + (cadr + args)) + (x7976 + (caddr + args)) + (x7975 + (cadddr + args)) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (car + x7974))) + (x7971 + (letrec ((x7972 + (cddddr + args))) + (cadr + x7972)))) + (proc + x7978 + x7977 + x7976 + x7975 + x7973 + x7971)))) + g7970) + (if cnd + (letrec ((g7979 + (letrec ((x7989 + (car + args)) + (x7988 + (cadr + args)) + (x7987 + (caddr + args)) + (x7986 + (cadddr + args)) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (car + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (cadr + x7983))) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (caddr + x7981)))) + (proc + x7989 + x7988 + x7987 + x7986 + x7984 + x7982 + x7980)))) + g7979) + (letrec ((g7990 + (error + "Unsupported call."))) + g7990))))))))))) + g7945))) + (member + (lambda (e l) + (letrec ((g7991 + (letrec ((x7993 (list? l))) + (assert x7993))) + (g7992 + (letrec ((x-cnd7994 (null? l))) + (if x-cnd7994 + #f + (letrec ((x-cnd7995 + (letrec ((x7996 + (car l))) + (equal? x7996 e)))) + (if x-cnd7995 + l + (letrec ((x7997 (cdr l))) + (member e x7997)))))))) + g7992))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (cdr x7999)))) + g7998))) + (cadddr + (lambda (x) + (letrec ((g8002 + (letrec ((x8003 + (letrec ((x8004 + (letrec ((x8005 + (cdr + x))) + (cdr + x8005)))) + (cdr x8004)))) + (car x8003)))) + g8002))) + (int-top + (lambda () + (letrec ((g8006 (random 42))) g8006))) + (zero? + (lambda (x) + (letrec ((g8007 + (letrec ((x8009 (number? x))) + (assert x8009))) + (g8008 (= x 0))) + g8008))) + (string>=? + (lambda (s1 s2) + (letrec ((g8010 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8011 + (if val7155 + val7155 + (string=? s1 s2)))) + g8011)))) + g8010))) + (cadr + (lambda (x) + (letrec ((g8012 + (letrec ((x8013 (cdr x))) + (car x8013)))) + g8012))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8014 + (letrec ((val7156 + (letrec ((x8017 + (pair? l)) + (x8015 + (letrec ((x8016 + (cdr + l))) + (list? + x8016)))) + (and x8017 x8015)))) + (letrec ((g8018 + (if val7156 + val7156 + (null? l)))) + g8018)))) + g8014))) + (cddaar + (lambda (x) + (letrec ((g8019 + (letrec ((x8020 + (letrec ((x8021 + (letrec ((x8022 + (car + x))) + (car + x8022)))) + (cdr x8021)))) + (cdr x8020)))) + g8019))) + (char-numeric? + (lambda (c) + (letrec ((g8023 + (letrec ((x-cnd8024 + (letrec ((x8025 #\0)) + (char<=? x8025 c)))) + (if x-cnd8024 + (letrec ((x8026 #\9)) + (char<=? c x8026)) + #f)))) + g8023))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8027 + (letrec ((x8029 (list? l))) + (assert x8029))) + (g8028 + (letrec ((x-cnd8030 (null? l))) + (if x-cnd8030 + #f + (letrec ((x-cnd8031 + (letrec ((x8032 + (caar l))) + (eqv? x8032 k)))) + (if x-cnd8031 + (car l) + (letrec ((x8033 (cdr l))) + (assq k x8033)))))))) + g8028))) + (not + (lambda (x) + (letrec ((g8034 (if x #f #t))) g8034))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8035 (append l1 l2))) g8035))) + (memq + (lambda (e l) + (letrec ((g8036 + (letrec ((x8038 (list? l))) + (assert x8038))) + (g8037 + (letrec ((x-cnd8039 (null? l))) + (if x-cnd8039 + #f + (letrec ((x-cnd8040 + (letrec ((x8041 + (car l))) + (eq? x8041 e)))) + (if x-cnd8040 + l + (letrec ((x8042 (cdr l))) + (memq e x8042)))))))) + g8037))) + (cadaar + (lambda (x) + (letrec ((g8043 + (letrec ((x8044 + (letrec ((x8045 + (letrec ((x8046 + (car + x))) + (car + x8046)))) + (cdr x8045)))) + (car x8044)))) + g8043))) + (length + (lambda (l) + (letrec ((g8047 + (letrec ((x8049 (list? l))) + (assert x8049))) + (g8048 + (letrec ((rec + (lambda (l) + (letrec ((g8050 + (letrec ((x-cnd8051 + (null? + l))) + (if x-cnd8051 + 0 + (letrec ((x8052 + (letrec ((x8053 + (cdr + l))) + (rec + x8053)))) + (+ + 1 + x8052)))))) + g8050)))) + (letrec ((g8054 (rec l))) + g8054)))) + g8048))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8055 + (letrec ((x8058 (char? c1))) + (assert x8058))) + (g8056 + (letrec ((x8059 (char? c2))) + (assert x8059))) + (g8057 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8061 + (letrec ((x8062 (string<=? s1 s2))) + (not x8062)))) + g8061))) + (cdadr + (lambda (x) + (letrec ((g8063 + (letrec ((x8064 + (letrec ((x8065 (cdr x))) + (car x8065)))) + (cdr x8064)))) + g8063))) + (assoc + (lambda (k l) + (letrec ((g8066 + (letrec ((x8068 (list? l))) + (assert x8068))) + (g8067 + (letrec ((x-cnd8069 (null? l))) + (if x-cnd8069 + #f + (letrec ((x-cnd8070 + (letrec ((x8071 + (caar l))) + (equal? x8071 k)))) + (if x-cnd8070 + (car l) + (letrec ((x8072 (cdr l))) + (assoc k x8072)))))))) + g8067))) + (caar + (lambda (x) + (letrec ((g8073 + (letrec ((x8074 (car x))) + (car x8074)))) + g8073))) + (char>? + (lambda (c1 c2) + (letrec ((g8075 + (letrec ((x8078 (char? c1))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char? c2))) + (assert x8079))) + (g8077 + (letrec ((x8080 (char<=? c1 c2))) + (not x8080)))) + g8077))) + (string<=? + (lambda (s1 s2) + (letrec ((g8081 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8098 + (letrec ((x8101 (char? c1))) + (assert x8101))) + (g8099 + (letrec ((x8102 (char? c2))) + (assert x8102))) + (g8100 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8103 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8103)))) + g8100))) + (caddar + (lambda (x) + (letrec ((g8104 + (letrec ((x8105 + (letrec ((x8106 + (letrec ((x8107 + (car + x))) + (cdr + x8107)))) + (cdr x8106)))) + (car x8105)))) + g8104))) + (newline + (lambda () (letrec ((g8108 #f)) g8108))) + (lcm + (lambda (m n) + (letrec ((g8109 + (letrec ((x8111 + (letrec ((x8112 (* m n))) + (abs x8112))) + (x8110 (gcd m n))) + (/ x8111 x8110)))) + g8109))) + (deref car) + (> + (lambda (x y) + (letrec ((g8113 + (letrec ((x8115 (number? x))) + (assert x8115))) + (g8114 + (letrec ((x8116 (<= x y))) + (not x8116)))) + g8114))) + (list-ref + (lambda (l index) + (letrec ((g8117 + (letrec ((x8121 (list? l))) + (assert x8121))) + (g8118 + (letrec ((x8122 (number? index))) + (assert x8122))) + (g8119 + (letrec ((x8123 + (letrec ((x8124 + (length l))) + (< index x8124)))) + (assert x8123))) + (g8120 + (letrec ((x-cnd8125 (= index 0))) + (if x-cnd8125 + (car l) + (letrec ((x8127 (cdr l)) + (x8126 (- index 1))) + (list-ref x8127 x8126)))))) + g8120))) + (gcd + (lambda (a b) + (letrec ((g8128 + (letrec ((x-cnd8129 (= b 0))) + (if x-cnd8129 + a + (letrec ((x8130 (modulo a b))) + (gcd b x8130)))))) + g8128)))) + (letrec ((g8131 + (letrec ((g8132 + (letrec ((len + (lambda (xs) + (letrec ((g8133 + (letrec ((x-cnd8134 + (empty? + xs))) + (if x-cnd8134 + 0 + (letrec ((x8135 + (letrec ((x8136 + (cdr + xs))) + (len + x8136)))) + (+ + 1 + x8135)))))) + g8133)))) + (letrec ((g8137 + (letrec ((g8138 + (letrec ((g8139 + (letrec ((x8141 + ((lambda (j7230 + k7231 + f7232) + (lambda (g7229) + ((and/c + integer?/c + (>=/c + 0)) + j7230 + k7231 + (f7232 + ((listof + any/c) + j7230 + k7231 + g7229))))) + 'module + 'importer + len)) + (x8140 + (input))) + (x8141 + x8140)))) + g8139))) + g8138))) + g8137)))) + g8132))) + g8131)))) + g7244))) + g7243)) diff --git a/analyses/simpleactor/benchmarks-out/softy_member.rkt b/analyses/simpleactor/benchmarks-out/softy_member.rkt index b37b5fec..e3f35438 100644 --- a/analyses/simpleactor/benchmarks-out/softy_member.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_member.rkt @@ -1,21 +1,3071 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7232 #t)) g7232))) + (meta (lambda (v) (letrec ((g7233 v)) g7233))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7234 + (letrec ((g7235 + (letrec ((x-e7236 lst)) + (match + x-e7236 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7237 (eq? v v1))) + (if x-cnd7237 #t (member v vs))))))))) + g7235))) + g7234))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (member x l) - (if (empty? l) empty (if (equal? x (car l)) l (member x (cdr l))))) - (begin - (((lambda (j3983 k3984 f3985) - (lambda () - ((any/c (listof any/c) (listof any/c)) j3983 k3984 (f3985)))) - 'module - 'importer - member))))) + (actor? + (lambda (k j) + (letrec ((g7238 (lambda (v) (letrec ((g7239 v)) g7239)))) g7238))) + (nonzero? + (lambda (v) + (letrec ((g7240 (letrec ((x7241 (= v 0))) (not x7241)))) g7240)))) + (letrec ((g7242 + (letrec ((g7243 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7244 + (letrec ((x-cnd7245 (real? g7162))) + (if x-cnd7245 + g7162 + (blame g7160 'real?))))) + g7244))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7246 + (letrec ((x-cnd7247 + (boolean? g7165))) + (if x-cnd7247 + g7165 + (blame g7163 'boolean?))))) + g7246))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7248 + (letrec ((x-cnd7249 + (number? g7168))) + (if x-cnd7249 + g7168 + (blame g7166 'number?))))) + g7248))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7250 + (letrec ((x-cnd7251 + ((lambda (v) #t) g7171))) + (if x-cnd7251 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7250))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7252 + (letrec ((x-cnd7253 + ((lambda (v) #t) g7174))) + (if x-cnd7253 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7252))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7254 + (letrec ((x-cnd7255 (pair? g7177))) + (if x-cnd7255 + g7177 + (blame g7175 'pair?))))) + g7254))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7256 + (letrec ((x-cnd7257 (pair? g7180))) + (if x-cnd7257 + g7180 + (blame g7178 'pair?))))) + g7256))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7258 + (letrec ((x-cnd7259 + (integer? g7183))) + (if x-cnd7259 + g7183 + (blame g7181 'integer?))))) + g7258))) + (and/c + (lambda (c1 c2) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (c1 k j v))) + (if x-cnd7262 + (c2 k j v) + #f)))) + g7261)))) + g7260))) + (list-of + (lambda (contract) + (letrec ((g7263 + (lambda (k j v) + (letrec ((g7264 + (letrec ((x-cnd7265 + (null? v))) + (if x-cnd7265 + '() + (letrec ((x7269 + (letrec ((x7270 + (car + v))) + (contract + k + j + x7270))) + (x7266 + (letrec ((x7268 + (list-of + contract)) + (x7267 + (cdr + v))) + (x7268 + k + j + x7267)))) + (cons + x7269 + x7266)))))) + g7264)))) + g7263))) + (any? (lambda (v) (letrec ((g7271 #t)) g7271))) + (nonzero? + (lambda (v) + (letrec ((g7272 + (letrec ((x7273 (= v 0))) + (not x7273)))) + g7272))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7274 + (letrec ((x-cnd7275 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7275 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7274))) + (meta (lambda (v) (letrec ((g7276 v)) g7276))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7277 #t)) g7277))) + (cdddr + (lambda (x) + (letrec ((g7278 + (letrec ((x7279 + (letrec ((x7280 (cdr x))) + (cdr x7280)))) + (cdr x7279)))) + g7278))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7281 + (letrec ((x7284 (procedure? f))) + (assert x7284))) + (g7282 + (letrec ((x7285 (list? l))) + (assert x7285))) + (g7283 + (letrec ((x-cnd7286 (null? l))) + (if x-cnd7286 + '() + (letrec ((x7289 + (letrec ((x7290 + (car l))) + (f x7290))) + (x7287 + (letrec ((x7288 + (cdr l))) + (map f x7288)))) + (cons x7289 x7287)))))) + g7283))) + (cdar + (lambda (x) + (letrec ((g7291 + (letrec ((x7292 (car x))) + (cdr x7292)))) + g7291))) + (cadadr + (lambda (x) + (letrec ((g7293 + (letrec ((x7294 + (letrec ((x7295 + (letrec ((x7296 + (cdr + x))) + (car + x7296)))) + (cdr x7295)))) + (car x7294)))) + g7293))) + (cdadar + (lambda (x) + (letrec ((g7297 + (letrec ((x7298 + (letrec ((x7299 + (letrec ((x7300 + (car + x))) + (cdr + x7300)))) + (car x7299)))) + (cdr x7298)))) + g7297))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7301 + (letrec ((x7304 + (string? filename))) + (assert x7304))) + (g7302 + (letrec ((x7305 (procedure? proc))) + (assert x7305))) + (g7303 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7306 + (close-output-port + output-port)) + (g7307 res)) + g7307)))) + g7303))) + (caddr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 (cdr x))) + (cdr x7310)))) + (car x7309)))) + g7308))) + (cdaadr + (lambda (x) + (letrec ((g7311 + (letrec ((x7312 + (letrec ((x7313 + (letrec ((x7314 + (cdr + x))) + (car + x7314)))) + (car x7313)))) + (cdr x7312)))) + g7311))) + (assq + (lambda (k l) + (letrec ((g7315 + (letrec ((x7317 (list? l))) + (assert x7317))) + (g7316 + (letrec ((x-cnd7318 (null? l))) + (if x-cnd7318 + #f + (letrec ((x-cnd7319 + (letrec ((x7320 + (caar l))) + (eq? x7320 k)))) + (if x-cnd7319 + (car l) + (letrec ((x7321 (cdr l))) + (assq k x7321)))))))) + g7316))) + (even? + (lambda (x) + (letrec ((g7322 + (letrec ((x7323 (modulo x 2))) + (= 0 x7323)))) + g7322))) + (list->string + (lambda (l) + (letrec ((g7324 + (letrec ((x7326 (list? l))) + (assert x7326))) + (g7325 + (letrec ((x-cnd7327 (null? l))) + (if x-cnd7327 + "" + (letrec ((x7330 + (letrec ((x7331 + (car l))) + (char->string + x7331))) + (x7328 + (letrec ((x7329 + (cdr l))) + (list->string + x7329)))) + (string-append + x7330 + x7328)))))) + g7325))) + (char<=? + (lambda (c1 c2) + (letrec ((g7332 + (letrec ((x7335 (char? c1))) + (assert x7335))) + (g7333 + (letrec ((x7336 (char? c2))) + (assert x7336))) + (g7334 + (letrec ((val7143 (char=? c x7353)))) + (if x-cnd7352 + (letrec ((x7354 #\z)) + (char-ci<=? c x7354)) + #f)))) + g7351))) + (<= + (lambda (x y) + (letrec ((g7355 + (letrec ((x7357 (number? x))) + (assert x7357))) + (g7356 + (letrec ((val7144 (< x y))) + (letrec ((g7358 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7359 + (if val7145 + val7145 + #f))) + g7359))))) + g7358)))) + g7356))) + (char-whitespace? + (lambda (c) + (letrec ((g7360 + (letrec ((val7146 + (letrec ((x7361 + (char->integer + c))) + (= x7361 9)))) + (letrec ((g7362 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7363 + (char->integer + c))) + (= + x7363 + 10)))) + (letrec ((g7364 + (if val7147 + val7147 + (letrec ((x7365 + (char->integer + c))) + (= + x7365 + 32))))) + g7364))))) + g7362)))) + g7360))) + (cddar + (lambda (x) + (letrec ((g7366 + (letrec ((x7367 + (letrec ((x7368 (car x))) + (cdr x7368)))) + (cdr x7367)))) + g7366))) + (positive? + (lambda (x) + (letrec ((g7369 + (letrec ((x7371 (number? x))) + (assert x7371))) + (g7370 (> x 0))) + g7370))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7372 #f)) g7372))) + (cddr + (lambda (x) + (letrec ((g7373 + (letrec ((x7374 (cdr x))) + (cdr x7374)))) + g7373))) + (truncate + (lambda (x) + (letrec ((g7375 + (letrec ((x7377 (number? x))) + (assert x7377))) + (g7376 + (letrec ((x-cnd7378 (< x 0))) + (if x-cnd7378 + (ceiling x) + (floor x))))) + g7376))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7379 + (letrec ((val7148 (eq? a b))) + (letrec ((g7380 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7382 + (null? + a)) + (x7381 + (null? + b))) + (and x7382 + x7381)))) + (letrec ((g7383 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7386 + (string? + a)) + (x7385 + (string? + b)) + (x7384 + (string=? + a + b))) + (and x7386 + x7385 + x7384)))) + (letrec ((g7387 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7395 + (pair? + a)) + (x7394 + (pair? + b)) + (x7391 + (letrec ((x7393 + (car + a)) + (x7392 + (car + b))) + (equal? + x7393 + x7392))) + (x7388 + (letrec ((x7390 + (cdr + a)) + (x7389 + (cdr + b))) + (equal? + x7390 + x7389)))) + (and x7395 + x7394 + x7391 + x7388)))) + (letrec ((g7396 + (if val7151 + val7151 + (letrec ((x7415 + (vector? + a)) + (x7414 + (vector? + b)) + (x7397 + (letrec ((x7411 + (letrec ((x7412 + (letrec ((x7413 + (vector-length + a))) + (n + x7413)))) + (x7412))) + (x7398 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + b))) + (= + x7410 + n))) + (x7399 + (letrec ((loop + (lambda (i) + (letrec ((g7400 + (letrec ((x7407 + (= + i + n)) + (x7401 + (letrec ((x7404 + (letrec ((x7406 + (vector-ref + a + i)) + (x7405 + (vector-ref + b + i))) + (equal? + x7406 + x7405))) + (x7402 + (letrec ((x7403 + (+ + i + 1))) + (loop + x7403)))) + (and x7404 + x7402)))) + (or x7407 + x7401)))) + g7400)))) + (letrec ((g7408 + (loop + 0))) + g7408)))) + (and x7409 + x7399)))) + (let x7411 x7398)))) + (and x7415 + x7414 + x7397))))) + g7396))))) + g7387))))) + g7383))))) + g7380)))) + g7379))) + (cdaaar + (lambda (x) + (letrec ((g7416 + (letrec ((x7417 + (letrec ((x7418 + (letrec ((x7419 + (car + x))) + (car + x7419)))) + (car x7418)))) + (cdr x7417)))) + g7416))) + (caaddr + (lambda (x) + (letrec ((g7420 + (letrec ((x7421 + (letrec ((x7422 + (letrec ((x7423 + (cdr + x))) + (cdr + x7423)))) + (car x7422)))) + (car x7421)))) + g7420))) + (eqv? + (lambda (x y) + (letrec ((g7424 (eq? x y))) g7424))) + (>= + (lambda (x y) + (letrec ((g7425 + (letrec ((x7427 (number? x))) + (assert x7427))) + (g7426 + (letrec ((val7152 (> x y))) + (letrec ((g7428 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7429 + (if val7153 + val7153 + #f))) + g7429))))) + g7428)))) + g7426))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7430 + (letrec ((x7433 + (string? filename))) + (assert x7433))) + (g7431 + (letrec ((x7434 (procedure? proc))) + (assert x7434))) + (g7432 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7435 + (close-input-port + input-port)) + (g7436 res)) + g7436)))) + g7432))) + (ref + (lambda (x) + (letrec ((g7437 (cons x '()))) g7437))) + (char>=? + (lambda (c1 c2) + (letrec ((g7438 + (letrec ((x7441 (char? c1))) + (assert x7441))) + (g7439 + (letrec ((x7442 (char? c2))) + (assert x7442))) + (g7440 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7443 + (if val7154 + val7154 + (char=? c1 c2)))) + g7443)))) + g7440))) + (cdaar + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 (car x))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (cdaddr + (lambda (x) + (letrec ((g7447 + (letrec ((x7448 + (letrec ((x7449 + (letrec ((x7450 + (cdr + x))) + (cdr + x7450)))) + (car x7449)))) + (cdr x7448)))) + g7447))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (car x))) + (cdr x7453)))) + (car x7452)))) + g7451))) + (caadr + (lambda (x) + (letrec ((g7454 + (letrec ((x7455 + (letrec ((x7456 (cdr x))) + (car x7456)))) + (car x7455)))) + g7454))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7457 + (letrec ((x7460 (char? c1))) + (assert x7460))) + (g7458 + (letrec ((x7461 (char? c2))) + (assert x7461))) + (g7459 + (letrec ((x7462 + (char-ci<=? c1 c2))) + (not x7462)))) + g7459))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7463 + (letrec ((x7464 + (letrec ((x7465 + (letrec ((x7466 + (car + x))) + (car + x7466)))) + (car x7465)))) + (car x7464)))) + g7463))) + (negative? + (lambda (x) + (letrec ((g7467 + (letrec ((x7469 (number? x))) + (assert x7469))) + (g7468 (< x 0))) + g7468))) + (memv + (lambda (e l) + (letrec ((g7470 (memq e l))) g7470))) + (caaar + (lambda (x) + (letrec ((g7471 + (letrec ((x7472 + (letrec ((x7473 (car x))) + (car x7473)))) + (car x7472)))) + g7471))) + (debug + (lambda (e) (letrec ((g7474 '())) g7474))) + (reverse + (lambda (l) + (letrec ((g7475 + (letrec ((x7477 (list? l))) + (assert x7477))) + (g7476 + (letrec ((x-cnd7478 (null? l))) + (if x-cnd7478 + '() + (letrec ((x7481 + (letrec ((x7482 + (cdr l))) + (reverse x7482))) + (x7479 + (letrec ((x7480 + (car l))) + (list x7480)))) + (append x7481 x7479)))))) + g7476))) + (caaadr + (lambda (x) + (letrec ((g7483 + (letrec ((x7484 + (letrec ((x7485 + (letrec ((x7486 + (cdr + x))) + (car + x7486)))) + (car x7485)))) + (car x7484)))) + g7483))) + (cddadr + (lambda (x) + (letrec ((g7487 + (letrec ((x7488 + (letrec ((x7489 + (letrec ((x7490 + (cdr + x))) + (car + x7490)))) + (cdr x7489)))) + (cdr x7488)))) + g7487))) + (odd? + (lambda (x) + (letrec ((g7491 + (letrec ((x7493 (number? x))) + (assert x7493))) + (g7492 + (letrec ((x7494 (modulo x 2))) + (= 1 x7494)))) + g7492))) + (caadar + (lambda (x) + (letrec ((g7495 + (letrec ((x7496 + (letrec ((x7497 + (letrec ((x7498 + (car + x))) + (cdr + x7498)))) + (car x7497)))) + (car x7496)))) + g7495))) + (apply + (lambda (proc args) + (letrec ((g7499 + (letrec ((x7502 (procedure? proc))) + (assert x7502))) + (g7500 + (letrec ((x7503 (list? args))) + (assert x7503))) + (g7501 + (if cnd + (letrec ((g7504 (proc))) g7504) + (if cnd + (letrec ((g7505 + (letrec ((x7506 + (car + args))) + (proc x7506)))) + g7505) + (if cnd + (letrec ((g7507 + (letrec ((x7509 + (car + args)) + (x7508 + (cadr + args))) + (proc + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7510 + (letrec ((x7513 + (car + args)) + (x7512 + (cadr + args)) + (x7511 + (caddr + args))) + (proc + x7513 + x7512 + x7511)))) + g7510) + (if cnd + (letrec ((g7514 + (letrec ((x7518 + (car + args)) + (x7517 + (cadr + args)) + (x7516 + (caddr + args)) + (x7515 + (cadddr + args))) + (proc + x7518 + x7517 + x7516 + x7515)))) + g7514) + (if cnd + (letrec ((g7519 + (letrec ((x7525 + (car + args)) + (x7524 + (cadr + args)) + (x7523 + (caddr + args)) + (x7522 + (cadddr + args)) + (x7520 + (letrec ((x7521 + (cddddr + args))) + (car + x7521)))) + (proc + x7525 + x7524 + x7523 + x7522 + x7520)))) + g7519) + (if cnd + (letrec ((g7526 + (letrec ((x7534 + (car + args)) + (x7533 + (cadr + args)) + (x7532 + (caddr + args)) + (x7531 + (cadddr + args)) + (x7529 + (letrec ((x7530 + (cddddr + args))) + (car + x7530))) + (x7527 + (letrec ((x7528 + (cddddr + args))) + (cadr + x7528)))) + (proc + x7534 + x7533 + x7532 + x7531 + x7529 + x7527)))) + g7526) + (if cnd + (letrec ((g7535 + (letrec ((x7545 + (car + args)) + (x7544 + (cadr + args)) + (x7543 + (caddr + args)) + (x7542 + (cadddr + args)) + (x7540 + (letrec ((x7541 + (cddddr + args))) + (car + x7541))) + (x7538 + (letrec ((x7539 + (cddddr + args))) + (cadr + x7539))) + (x7536 + (letrec ((x7537 + (cddddr + args))) + (caddr + x7537)))) + (proc + x7545 + x7544 + x7543 + x7542 + x7540 + x7538 + x7536)))) + g7535) + (letrec ((g7546 + (error + "Unsupported call."))) + g7546))))))))))) + g7501))) + (member + (lambda (e l) + (letrec ((g7547 + (letrec ((x7549 (list? l))) + (assert x7549))) + (g7548 + (letrec ((x-cnd7550 (null? l))) + (if x-cnd7550 + #f + (letrec ((x-cnd7551 + (letrec ((x7552 + (car l))) + (equal? x7552 e)))) + (if x-cnd7551 + l + (letrec ((x7553 (cdr l))) + (member e x7553)))))))) + g7548))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7554 + (letrec ((x7555 + (letrec ((x7556 + (letrec ((x7557 + (cdr + x))) + (cdr + x7557)))) + (cdr x7556)))) + (cdr x7555)))) + g7554))) + (cadddr + (lambda (x) + (letrec ((g7558 + (letrec ((x7559 + (letrec ((x7560 + (letrec ((x7561 + (cdr + x))) + (cdr + x7561)))) + (cdr x7560)))) + (car x7559)))) + g7558))) + (int-top + (lambda () + (letrec ((g7562 (random 42))) g7562))) + (zero? + (lambda (x) + (letrec ((g7563 + (letrec ((x7565 (number? x))) + (assert x7565))) + (g7564 (= x 0))) + g7564))) + (string>=? + (lambda (s1 s2) + (letrec ((g7566 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7567 + (if val7155 + val7155 + (string=? s1 s2)))) + g7567)))) + g7566))) + (cadr + (lambda (x) + (letrec ((g7568 + (letrec ((x7569 (cdr x))) + (car x7569)))) + g7568))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7570 + (letrec ((val7156 + (letrec ((x7573 + (pair? l)) + (x7571 + (letrec ((x7572 + (cdr + l))) + (list? + x7572)))) + (and x7573 x7571)))) + (letrec ((g7574 + (if val7156 + val7156 + (null? l)))) + g7574)))) + g7570))) + (cddaar + (lambda (x) + (letrec ((g7575 + (letrec ((x7576 + (letrec ((x7577 + (letrec ((x7578 + (car + x))) + (car + x7578)))) + (cdr x7577)))) + (cdr x7576)))) + g7575))) + (char-numeric? + (lambda (c) + (letrec ((g7579 + (letrec ((x-cnd7580 + (letrec ((x7581 #\0)) + (char<=? x7581 c)))) + (if x-cnd7580 + (letrec ((x7582 #\9)) + (char<=? c x7582)) + #f)))) + g7579))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7583 + (letrec ((x7585 (list? l))) + (assert x7585))) + (g7584 + (letrec ((x-cnd7586 (null? l))) + (if x-cnd7586 + #f + (letrec ((x-cnd7587 + (letrec ((x7588 + (caar l))) + (eqv? x7588 k)))) + (if x-cnd7587 + (car l) + (letrec ((x7589 (cdr l))) + (assq k x7589)))))))) + g7584))) + (not + (lambda (x) + (letrec ((g7590 (if x #f #t))) g7590))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7591 (append l1 l2))) g7591))) + (memq + (lambda (e l) + (letrec ((g7592 + (letrec ((x7594 (list? l))) + (assert x7594))) + (g7593 + (letrec ((x-cnd7595 (null? l))) + (if x-cnd7595 + #f + (letrec ((x-cnd7596 + (letrec ((x7597 + (car l))) + (eq? x7597 e)))) + (if x-cnd7596 + l + (letrec ((x7598 (cdr l))) + (memq e x7598)))))))) + g7593))) + (cadaar + (lambda (x) + (letrec ((g7599 + (letrec ((x7600 + (letrec ((x7601 + (letrec ((x7602 + (car + x))) + (car + x7602)))) + (cdr x7601)))) + (car x7600)))) + g7599))) + (length + (lambda (l) + (letrec ((g7603 + (letrec ((x7605 (list? l))) + (assert x7605))) + (g7604 + (letrec ((rec + (lambda (l) + (letrec ((g7606 + (letrec ((x-cnd7607 + (null? + l))) + (if x-cnd7607 + 0 + (letrec ((x7608 + (letrec ((x7609 + (cdr + l))) + (rec + x7609)))) + (+ + 1 + x7608)))))) + g7606)))) + (letrec ((g7610 (rec l))) + g7610)))) + g7604))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7611 + (letrec ((x7614 (char? c1))) + (assert x7614))) + (g7612 + (letrec ((x7615 (char? c2))) + (assert x7615))) + (g7613 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7617 + (letrec ((x7618 (string<=? s1 s2))) + (not x7618)))) + g7617))) + (cdadr + (lambda (x) + (letrec ((g7619 + (letrec ((x7620 + (letrec ((x7621 (cdr x))) + (car x7621)))) + (cdr x7620)))) + g7619))) + (assoc + (lambda (k l) + (letrec ((g7622 + (letrec ((x7624 (list? l))) + (assert x7624))) + (g7623 + (letrec ((x-cnd7625 (null? l))) + (if x-cnd7625 + #f + (letrec ((x-cnd7626 + (letrec ((x7627 + (caar l))) + (equal? x7627 k)))) + (if x-cnd7626 + (car l) + (letrec ((x7628 (cdr l))) + (assoc k x7628)))))))) + g7623))) + (caar + (lambda (x) + (letrec ((g7629 + (letrec ((x7630 (car x))) + (car x7630)))) + g7629))) + (char>? + (lambda (c1 c2) + (letrec ((g7631 + (letrec ((x7634 (char? c1))) + (assert x7634))) + (g7632 + (letrec ((x7635 (char? c2))) + (assert x7635))) + (g7633 + (letrec ((x7636 (char<=? c1 c2))) + (not x7636)))) + g7633))) + (string<=? + (lambda (s1 s2) + (letrec ((g7637 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7654 + (letrec ((x7657 (char? c1))) + (assert x7657))) + (g7655 + (letrec ((x7658 (char? c2))) + (assert x7658))) + (g7656 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7659 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7659)))) + g7656))) + (caddar + (lambda (x) + (letrec ((g7660 + (letrec ((x7661 + (letrec ((x7662 + (letrec ((x7663 + (car + x))) + (cdr + x7663)))) + (cdr x7662)))) + (car x7661)))) + g7660))) + (newline + (lambda () (letrec ((g7664 #f)) g7664))) + (lcm + (lambda (m n) + (letrec ((g7665 + (letrec ((x7667 + (letrec ((x7668 (* m n))) + (abs x7668))) + (x7666 (gcd m n))) + (/ x7667 x7666)))) + g7665))) + (deref car) + (> + (lambda (x y) + (letrec ((g7669 + (letrec ((x7671 (number? x))) + (assert x7671))) + (g7670 + (letrec ((x7672 (<= x y))) + (not x7672)))) + g7670))) + (list-ref + (lambda (l index) + (letrec ((g7673 + (letrec ((x7677 (list? l))) + (assert x7677))) + (g7674 + (letrec ((x7678 (number? index))) + (assert x7678))) + (g7675 + (letrec ((x7679 + (letrec ((x7680 + (length l))) + (< index x7680)))) + (assert x7679))) + (g7676 + (letrec ((x-cnd7681 (= index 0))) + (if x-cnd7681 + (car l) + (letrec ((x7683 (cdr l)) + (x7682 (- index 1))) + (list-ref x7683 x7682)))))) + g7676))) + (gcd + (lambda (a b) + (letrec ((g7684 + (letrec ((x-cnd7685 (= b 0))) + (if x-cnd7685 + a + (letrec ((x7686 (modulo a b))) + (gcd b x7686)))))) + g7684))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7687 + (letrec ((x-cnd7688 (real? g7162))) + (if x-cnd7688 + g7162 + (blame g7160 'real?))))) + g7687))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7689 + (letrec ((x-cnd7690 + (boolean? g7165))) + (if x-cnd7690 + g7165 + (blame g7163 'boolean?))))) + g7689))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7691 + (letrec ((x-cnd7692 + (number? g7168))) + (if x-cnd7692 + g7168 + (blame g7166 'number?))))) + g7691))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7693 + (letrec ((x-cnd7694 + ((lambda (v) #t) g7171))) + (if x-cnd7694 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7693))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7695 + (letrec ((x-cnd7696 + ((lambda (v) #t) g7174))) + (if x-cnd7696 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7695))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7697 + (letrec ((x-cnd7698 (pair? g7177))) + (if x-cnd7698 + g7177 + (blame g7175 'pair?))))) + g7697))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7699 + (letrec ((x-cnd7700 (pair? g7180))) + (if x-cnd7700 + g7180 + (blame g7178 'pair?))))) + g7699))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7701 + (letrec ((x-cnd7702 + (integer? g7183))) + (if x-cnd7702 + g7183 + (blame g7181 'integer?))))) + g7701))) + (and/c + (lambda (c1 c2) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (c1 k j v))) + (if x-cnd7705 + (c2 k j v) + #f)))) + g7704)))) + g7703))) + (list-of + (lambda (contract) + (letrec ((g7706 + (lambda (k j v) + (letrec ((g7707 + (letrec ((x-cnd7708 + (null? v))) + (if x-cnd7708 + '() + (letrec ((x7712 + (letrec ((x7713 + (car + v))) + (contract + k + j + x7713))) + (x7709 + (letrec ((x7711 + (list-of + contract)) + (x7710 + (cdr + v))) + (x7711 + k + j + x7710)))) + (cons + x7712 + x7709)))))) + g7707)))) + g7706))) + (any? (lambda (v) (letrec ((g7714 #t)) g7714))) + (nonzero? + (lambda (v) + (letrec ((g7715 + (letrec ((x7716 (= v 0))) + (not x7716)))) + g7715))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7717 + (letrec ((x-cnd7718 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7718 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7717))) + (meta (lambda (v) (letrec ((g7719 v)) g7719))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7720 #t)) g7720))) + (cdddr + (lambda (x) + (letrec ((g7721 + (letrec ((x7722 + (letrec ((x7723 (cdr x))) + (cdr x7723)))) + (cdr x7722)))) + g7721))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7724 + (letrec ((x7727 (procedure? f))) + (assert x7727))) + (g7725 + (letrec ((x7728 (list? l))) + (assert x7728))) + (g7726 + (letrec ((x-cnd7729 (null? l))) + (if x-cnd7729 + '() + (letrec ((x7732 + (letrec ((x7733 + (car l))) + (f x7733))) + (x7730 + (letrec ((x7731 + (cdr l))) + (map f x7731)))) + (cons x7732 x7730)))))) + g7726))) + (cdar + (lambda (x) + (letrec ((g7734 + (letrec ((x7735 (car x))) + (cdr x7735)))) + g7734))) + (cadadr + (lambda (x) + (letrec ((g7736 + (letrec ((x7737 + (letrec ((x7738 + (letrec ((x7739 + (cdr + x))) + (car + x7739)))) + (cdr x7738)))) + (car x7737)))) + g7736))) + (cdadar + (lambda (x) + (letrec ((g7740 + (letrec ((x7741 + (letrec ((x7742 + (letrec ((x7743 + (car + x))) + (cdr + x7743)))) + (car x7742)))) + (cdr x7741)))) + g7740))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7744 + (letrec ((x7747 + (string? filename))) + (assert x7747))) + (g7745 + (letrec ((x7748 (procedure? proc))) + (assert x7748))) + (g7746 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7749 + (close-output-port + output-port)) + (g7750 res)) + g7750)))) + g7746))) + (caddr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 (cdr x))) + (cdr x7753)))) + (car x7752)))) + g7751))) + (cdaadr + (lambda (x) + (letrec ((g7754 + (letrec ((x7755 + (letrec ((x7756 + (letrec ((x7757 + (cdr + x))) + (car + x7757)))) + (car x7756)))) + (cdr x7755)))) + g7754))) + (assq + (lambda (k l) + (letrec ((g7758 + (letrec ((x7760 (list? l))) + (assert x7760))) + (g7759 + (letrec ((x-cnd7761 (null? l))) + (if x-cnd7761 + #f + (letrec ((x-cnd7762 + (letrec ((x7763 + (caar l))) + (eq? x7763 k)))) + (if x-cnd7762 + (car l) + (letrec ((x7764 (cdr l))) + (assq k x7764)))))))) + g7759))) + (even? + (lambda (x) + (letrec ((g7765 + (letrec ((x7766 (modulo x 2))) + (= 0 x7766)))) + g7765))) + (list->string + (lambda (l) + (letrec ((g7767 + (letrec ((x7769 (list? l))) + (assert x7769))) + (g7768 + (letrec ((x-cnd7770 (null? l))) + (if x-cnd7770 + "" + (letrec ((x7773 + (letrec ((x7774 + (car l))) + (char->string + x7774))) + (x7771 + (letrec ((x7772 + (cdr l))) + (list->string + x7772)))) + (string-append + x7773 + x7771)))))) + g7768))) + (char<=? + (lambda (c1 c2) + (letrec ((g7775 + (letrec ((x7778 (char? c1))) + (assert x7778))) + (g7776 + (letrec ((x7779 (char? c2))) + (assert x7779))) + (g7777 + (letrec ((val7143 (char=? c x7796)))) + (if x-cnd7795 + (letrec ((x7797 #\z)) + (char-ci<=? c x7797)) + #f)))) + g7794))) + (<= + (lambda (x y) + (letrec ((g7798 + (letrec ((x7800 (number? x))) + (assert x7800))) + (g7799 + (letrec ((val7144 (< x y))) + (letrec ((g7801 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7802 + (if val7145 + val7145 + #f))) + g7802))))) + g7801)))) + g7799))) + (char-whitespace? + (lambda (c) + (letrec ((g7803 + (letrec ((val7146 + (letrec ((x7804 + (char->integer + c))) + (= x7804 9)))) + (letrec ((g7805 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7806 + (char->integer + c))) + (= + x7806 + 10)))) + (letrec ((g7807 + (if val7147 + val7147 + (letrec ((x7808 + (char->integer + c))) + (= + x7808 + 32))))) + g7807))))) + g7805)))) + g7803))) + (cddar + (lambda (x) + (letrec ((g7809 + (letrec ((x7810 + (letrec ((x7811 (car x))) + (cdr x7811)))) + (cdr x7810)))) + g7809))) + (positive? + (lambda (x) + (letrec ((g7812 + (letrec ((x7814 (number? x))) + (assert x7814))) + (g7813 (> x 0))) + g7813))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7815 #f)) g7815))) + (cddr + (lambda (x) + (letrec ((g7816 + (letrec ((x7817 (cdr x))) + (cdr x7817)))) + g7816))) + (truncate + (lambda (x) + (letrec ((g7818 + (letrec ((x7820 (number? x))) + (assert x7820))) + (g7819 + (letrec ((x-cnd7821 (< x 0))) + (if x-cnd7821 + (ceiling x) + (floor x))))) + g7819))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7822 + (letrec ((val7148 (eq? a b))) + (letrec ((g7823 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7825 + (null? + a)) + (x7824 + (null? + b))) + (and x7825 + x7824)))) + (letrec ((g7826 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7829 + (string? + a)) + (x7828 + (string? + b)) + (x7827 + (string=? + a + b))) + (and x7829 + x7828 + x7827)))) + (letrec ((g7830 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7838 + (pair? + a)) + (x7837 + (pair? + b)) + (x7834 + (letrec ((x7836 + (car + a)) + (x7835 + (car + b))) + (equal? + x7836 + x7835))) + (x7831 + (letrec ((x7833 + (cdr + a)) + (x7832 + (cdr + b))) + (equal? + x7833 + x7832)))) + (and x7838 + x7837 + x7834 + x7831)))) + (letrec ((g7839 + (if val7151 + val7151 + (letrec ((x7858 + (vector? + a)) + (x7857 + (vector? + b)) + (x7840 + (letrec ((x7854 + (letrec ((x7855 + (letrec ((x7856 + (vector-length + a))) + (n + x7856)))) + (x7855))) + (x7841 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + b))) + (= + x7853 + n))) + (x7842 + (letrec ((loop + (lambda (i) + (letrec ((g7843 + (letrec ((x7850 + (= + i + n)) + (x7844 + (letrec ((x7847 + (letrec ((x7849 + (vector-ref + a + i)) + (x7848 + (vector-ref + b + i))) + (equal? + x7849 + x7848))) + (x7845 + (letrec ((x7846 + (+ + i + 1))) + (loop + x7846)))) + (and x7847 + x7845)))) + (or x7850 + x7844)))) + g7843)))) + (letrec ((g7851 + (loop + 0))) + g7851)))) + (and x7852 + x7842)))) + (let x7854 x7841)))) + (and x7858 + x7857 + x7840))))) + g7839))))) + g7830))))) + g7826))))) + g7823)))) + g7822))) + (cdaaar + (lambda (x) + (letrec ((g7859 + (letrec ((x7860 + (letrec ((x7861 + (letrec ((x7862 + (car + x))) + (car + x7862)))) + (car x7861)))) + (cdr x7860)))) + g7859))) + (caaddr + (lambda (x) + (letrec ((g7863 + (letrec ((x7864 + (letrec ((x7865 + (letrec ((x7866 + (cdr + x))) + (cdr + x7866)))) + (car x7865)))) + (car x7864)))) + g7863))) + (eqv? + (lambda (x y) + (letrec ((g7867 (eq? x y))) g7867))) + (>= + (lambda (x y) + (letrec ((g7868 + (letrec ((x7870 (number? x))) + (assert x7870))) + (g7869 + (letrec ((val7152 (> x y))) + (letrec ((g7871 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7872 + (if val7153 + val7153 + #f))) + g7872))))) + g7871)))) + g7869))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7873 + (letrec ((x7876 + (string? filename))) + (assert x7876))) + (g7874 + (letrec ((x7877 (procedure? proc))) + (assert x7877))) + (g7875 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7878 + (close-input-port + input-port)) + (g7879 res)) + g7879)))) + g7875))) + (ref + (lambda (x) + (letrec ((g7880 (cons x '()))) g7880))) + (char>=? + (lambda (c1 c2) + (letrec ((g7881 + (letrec ((x7884 (char? c1))) + (assert x7884))) + (g7882 + (letrec ((x7885 (char? c2))) + (assert x7885))) + (g7883 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7886 + (if val7154 + val7154 + (char=? c1 c2)))) + g7886)))) + g7883))) + (cdaar + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 (car x))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (cdaddr + (lambda (x) + (letrec ((g7890 + (letrec ((x7891 + (letrec ((x7892 + (letrec ((x7893 + (cdr + x))) + (cdr + x7893)))) + (car x7892)))) + (cdr x7891)))) + g7890))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (car x))) + (cdr x7896)))) + (car x7895)))) + g7894))) + (caadr + (lambda (x) + (letrec ((g7897 + (letrec ((x7898 + (letrec ((x7899 (cdr x))) + (car x7899)))) + (car x7898)))) + g7897))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7900 + (letrec ((x7903 (char? c1))) + (assert x7903))) + (g7901 + (letrec ((x7904 (char? c2))) + (assert x7904))) + (g7902 + (letrec ((x7905 + (char-ci<=? c1 c2))) + (not x7905)))) + g7902))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7906 + (letrec ((x7907 + (letrec ((x7908 + (letrec ((x7909 + (car + x))) + (car + x7909)))) + (car x7908)))) + (car x7907)))) + g7906))) + (negative? + (lambda (x) + (letrec ((g7910 + (letrec ((x7912 (number? x))) + (assert x7912))) + (g7911 (< x 0))) + g7911))) + (memv + (lambda (e l) + (letrec ((g7913 (memq e l))) g7913))) + (caaar + (lambda (x) + (letrec ((g7914 + (letrec ((x7915 + (letrec ((x7916 (car x))) + (car x7916)))) + (car x7915)))) + g7914))) + (debug + (lambda (e) (letrec ((g7917 '())) g7917))) + (reverse + (lambda (l) + (letrec ((g7918 + (letrec ((x7920 (list? l))) + (assert x7920))) + (g7919 + (letrec ((x-cnd7921 (null? l))) + (if x-cnd7921 + '() + (letrec ((x7924 + (letrec ((x7925 + (cdr l))) + (reverse x7925))) + (x7922 + (letrec ((x7923 + (car l))) + (list x7923)))) + (append x7924 x7922)))))) + g7919))) + (caaadr + (lambda (x) + (letrec ((g7926 + (letrec ((x7927 + (letrec ((x7928 + (letrec ((x7929 + (cdr + x))) + (car + x7929)))) + (car x7928)))) + (car x7927)))) + g7926))) + (cddadr + (lambda (x) + (letrec ((g7930 + (letrec ((x7931 + (letrec ((x7932 + (letrec ((x7933 + (cdr + x))) + (car + x7933)))) + (cdr x7932)))) + (cdr x7931)))) + g7930))) + (odd? + (lambda (x) + (letrec ((g7934 + (letrec ((x7936 (number? x))) + (assert x7936))) + (g7935 + (letrec ((x7937 (modulo x 2))) + (= 1 x7937)))) + g7935))) + (caadar + (lambda (x) + (letrec ((g7938 + (letrec ((x7939 + (letrec ((x7940 + (letrec ((x7941 + (car + x))) + (cdr + x7941)))) + (car x7940)))) + (car x7939)))) + g7938))) + (apply + (lambda (proc args) + (letrec ((g7942 + (letrec ((x7945 (procedure? proc))) + (assert x7945))) + (g7943 + (letrec ((x7946 (list? args))) + (assert x7946))) + (g7944 + (if cnd + (letrec ((g7947 (proc))) g7947) + (if cnd + (letrec ((g7948 + (letrec ((x7949 + (car + args))) + (proc x7949)))) + g7948) + (if cnd + (letrec ((g7950 + (letrec ((x7952 + (car + args)) + (x7951 + (cadr + args))) + (proc + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7953 + (letrec ((x7956 + (car + args)) + (x7955 + (cadr + args)) + (x7954 + (caddr + args))) + (proc + x7956 + x7955 + x7954)))) + g7953) + (if cnd + (letrec ((g7957 + (letrec ((x7961 + (car + args)) + (x7960 + (cadr + args)) + (x7959 + (caddr + args)) + (x7958 + (cadddr + args))) + (proc + x7961 + x7960 + x7959 + x7958)))) + g7957) + (if cnd + (letrec ((g7962 + (letrec ((x7968 + (car + args)) + (x7967 + (cadr + args)) + (x7966 + (caddr + args)) + (x7965 + (cadddr + args)) + (x7963 + (letrec ((x7964 + (cddddr + args))) + (car + x7964)))) + (proc + x7968 + x7967 + x7966 + x7965 + x7963)))) + g7962) + (if cnd + (letrec ((g7969 + (letrec ((x7977 + (car + args)) + (x7976 + (cadr + args)) + (x7975 + (caddr + args)) + (x7974 + (cadddr + args)) + (x7972 + (letrec ((x7973 + (cddddr + args))) + (car + x7973))) + (x7970 + (letrec ((x7971 + (cddddr + args))) + (cadr + x7971)))) + (proc + x7977 + x7976 + x7975 + x7974 + x7972 + x7970)))) + g7969) + (if cnd + (letrec ((g7978 + (letrec ((x7988 + (car + args)) + (x7987 + (cadr + args)) + (x7986 + (caddr + args)) + (x7985 + (cadddr + args)) + (x7983 + (letrec ((x7984 + (cddddr + args))) + (car + x7984))) + (x7981 + (letrec ((x7982 + (cddddr + args))) + (cadr + x7982))) + (x7979 + (letrec ((x7980 + (cddddr + args))) + (caddr + x7980)))) + (proc + x7988 + x7987 + x7986 + x7985 + x7983 + x7981 + x7979)))) + g7978) + (letrec ((g7989 + (error + "Unsupported call."))) + g7989))))))))))) + g7944))) + (member + (lambda (e l) + (letrec ((g7990 + (letrec ((x7992 (list? l))) + (assert x7992))) + (g7991 + (letrec ((x-cnd7993 (null? l))) + (if x-cnd7993 + #f + (letrec ((x-cnd7994 + (letrec ((x7995 + (car l))) + (equal? x7995 e)))) + (if x-cnd7994 + l + (letrec ((x7996 (cdr l))) + (member e x7996)))))))) + g7991))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7997 + (letrec ((x7998 + (letrec ((x7999 + (letrec ((x8000 + (cdr + x))) + (cdr + x8000)))) + (cdr x7999)))) + (cdr x7998)))) + g7997))) + (cadddr + (lambda (x) + (letrec ((g8001 + (letrec ((x8002 + (letrec ((x8003 + (letrec ((x8004 + (cdr + x))) + (cdr + x8004)))) + (cdr x8003)))) + (car x8002)))) + g8001))) + (int-top + (lambda () + (letrec ((g8005 (random 42))) g8005))) + (zero? + (lambda (x) + (letrec ((g8006 + (letrec ((x8008 (number? x))) + (assert x8008))) + (g8007 (= x 0))) + g8007))) + (string>=? + (lambda (s1 s2) + (letrec ((g8009 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8010 + (if val7155 + val7155 + (string=? s1 s2)))) + g8010)))) + g8009))) + (cadr + (lambda (x) + (letrec ((g8011 + (letrec ((x8012 (cdr x))) + (car x8012)))) + g8011))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8013 + (letrec ((val7156 + (letrec ((x8016 + (pair? l)) + (x8014 + (letrec ((x8015 + (cdr + l))) + (list? + x8015)))) + (and x8016 x8014)))) + (letrec ((g8017 + (if val7156 + val7156 + (null? l)))) + g8017)))) + g8013))) + (cddaar + (lambda (x) + (letrec ((g8018 + (letrec ((x8019 + (letrec ((x8020 + (letrec ((x8021 + (car + x))) + (car + x8021)))) + (cdr x8020)))) + (cdr x8019)))) + g8018))) + (char-numeric? + (lambda (c) + (letrec ((g8022 + (letrec ((x-cnd8023 + (letrec ((x8024 #\0)) + (char<=? x8024 c)))) + (if x-cnd8023 + (letrec ((x8025 #\9)) + (char<=? c x8025)) + #f)))) + g8022))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8026 + (letrec ((x8028 (list? l))) + (assert x8028))) + (g8027 + (letrec ((x-cnd8029 (null? l))) + (if x-cnd8029 + #f + (letrec ((x-cnd8030 + (letrec ((x8031 + (caar l))) + (eqv? x8031 k)))) + (if x-cnd8030 + (car l) + (letrec ((x8032 (cdr l))) + (assq k x8032)))))))) + g8027))) + (not + (lambda (x) + (letrec ((g8033 (if x #f #t))) g8033))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8034 (append l1 l2))) g8034))) + (memq + (lambda (e l) + (letrec ((g8035 + (letrec ((x8037 (list? l))) + (assert x8037))) + (g8036 + (letrec ((x-cnd8038 (null? l))) + (if x-cnd8038 + #f + (letrec ((x-cnd8039 + (letrec ((x8040 + (car l))) + (eq? x8040 e)))) + (if x-cnd8039 + l + (letrec ((x8041 (cdr l))) + (memq e x8041)))))))) + g8036))) + (cadaar + (lambda (x) + (letrec ((g8042 + (letrec ((x8043 + (letrec ((x8044 + (letrec ((x8045 + (car + x))) + (car + x8045)))) + (cdr x8044)))) + (car x8043)))) + g8042))) + (length + (lambda (l) + (letrec ((g8046 + (letrec ((x8048 (list? l))) + (assert x8048))) + (g8047 + (letrec ((rec + (lambda (l) + (letrec ((g8049 + (letrec ((x-cnd8050 + (null? + l))) + (if x-cnd8050 + 0 + (letrec ((x8051 + (letrec ((x8052 + (cdr + l))) + (rec + x8052)))) + (+ + 1 + x8051)))))) + g8049)))) + (letrec ((g8053 (rec l))) + g8053)))) + g8047))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8054 + (letrec ((x8057 (char? c1))) + (assert x8057))) + (g8055 + (letrec ((x8058 (char? c2))) + (assert x8058))) + (g8056 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8060 + (letrec ((x8061 (string<=? s1 s2))) + (not x8061)))) + g8060))) + (cdadr + (lambda (x) + (letrec ((g8062 + (letrec ((x8063 + (letrec ((x8064 (cdr x))) + (car x8064)))) + (cdr x8063)))) + g8062))) + (assoc + (lambda (k l) + (letrec ((g8065 + (letrec ((x8067 (list? l))) + (assert x8067))) + (g8066 + (letrec ((x-cnd8068 (null? l))) + (if x-cnd8068 + #f + (letrec ((x-cnd8069 + (letrec ((x8070 + (caar l))) + (equal? x8070 k)))) + (if x-cnd8069 + (car l) + (letrec ((x8071 (cdr l))) + (assoc k x8071)))))))) + g8066))) + (caar + (lambda (x) + (letrec ((g8072 + (letrec ((x8073 (car x))) + (car x8073)))) + g8072))) + (char>? + (lambda (c1 c2) + (letrec ((g8074 + (letrec ((x8077 (char? c1))) + (assert x8077))) + (g8075 + (letrec ((x8078 (char? c2))) + (assert x8078))) + (g8076 + (letrec ((x8079 (char<=? c1 c2))) + (not x8079)))) + g8076))) + (string<=? + (lambda (s1 s2) + (letrec ((g8080 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8097 + (letrec ((x8100 (char? c1))) + (assert x8100))) + (g8098 + (letrec ((x8101 (char? c2))) + (assert x8101))) + (g8099 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8102 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8102)))) + g8099))) + (caddar + (lambda (x) + (letrec ((g8103 + (letrec ((x8104 + (letrec ((x8105 + (letrec ((x8106 + (car + x))) + (cdr + x8106)))) + (cdr x8105)))) + (car x8104)))) + g8103))) + (newline + (lambda () (letrec ((g8107 #f)) g8107))) + (lcm + (lambda (m n) + (letrec ((g8108 + (letrec ((x8110 + (letrec ((x8111 (* m n))) + (abs x8111))) + (x8109 (gcd m n))) + (/ x8110 x8109)))) + g8108))) + (deref car) + (> + (lambda (x y) + (letrec ((g8112 + (letrec ((x8114 (number? x))) + (assert x8114))) + (g8113 + (letrec ((x8115 (<= x y))) + (not x8115)))) + g8113))) + (list-ref + (lambda (l index) + (letrec ((g8116 + (letrec ((x8120 (list? l))) + (assert x8120))) + (g8117 + (letrec ((x8121 (number? index))) + (assert x8121))) + (g8118 + (letrec ((x8122 + (letrec ((x8123 + (length l))) + (< index x8123)))) + (assert x8122))) + (g8119 + (letrec ((x-cnd8124 (= index 0))) + (if x-cnd8124 + (car l) + (letrec ((x8126 (cdr l)) + (x8125 (- index 1))) + (list-ref x8126 x8125)))))) + g8119))) + (gcd + (lambda (a b) + (letrec ((g8127 + (letrec ((x-cnd8128 (= b 0))) + (if x-cnd8128 + a + (letrec ((x8129 (modulo a b))) + (gcd b x8129)))))) + g8127)))) + (letrec ((g8130 + (letrec ((g8131 + (letrec ((member + (lambda (x l) + (letrec ((g8132 + (letrec ((x-cnd8133 + (empty? + l))) + (if x-cnd8133 + empty + (letrec ((x-cnd8134 + (letrec ((x8135 + (car + l))) + (equal? + x + x8135)))) + (if x-cnd8134 + l + (letrec ((x8136 + (cdr + l))) + (member + x + x8136)))))))) + g8132)))) + (letrec ((g8137 + (letrec ((g8138 + (letrec ((g8139 + ((lambda (j7229 + k7230 + f7231) + (lambda () + ((any/c + (listof + any/c) + (listof + any/c)) + j7229 + k7230 + (f7231)))) + 'module + 'importer + member))) + g8139))) + g8138))) + g8137)))) + g8131))) + g8130)))) + g7243))) + g7242)) diff --git a/analyses/simpleactor/benchmarks-out/softy_recursive-div2.rkt b/analyses/simpleactor/benchmarks-out/softy_recursive-div2.rkt index 3fccb4fd..a245015a 100644 --- a/analyses/simpleactor/benchmarks-out/softy_recursive-div2.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_recursive-div2.rkt @@ -1,27 +1,3105 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7236 #t)) g7236))) + (meta (lambda (v) (letrec ((g7237 v)) g7237))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7238 + (letrec ((g7239 + (letrec ((x-e7240 lst)) + (match + x-e7240 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7241 (eq? v v1))) + (if x-cnd7241 #t (member v vs))))))))) + g7239))) + g7238))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (recursive-div2 l) - (if (empty? l) empty (cons (car l) (recursive-div2 (cdr (cdr l)))))) - (define even-list/c - (lambda () (or/c null? (cons/c any/c (cons/c any/c even-list/c))))) - (begin - ((((lambda (j3984 k3985 f3986) - (lambda (g3983) - ((listof any/c) - j3984 - k3985 - (f3986 ((even-list/c) j3984 k3985 g3983))))) - 'module - 'importer - recursive-div2) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7242 (lambda (v) (letrec ((g7243 v)) g7243)))) g7242))) + (nonzero? + (lambda (v) + (letrec ((g7244 (letrec ((x7245 (= v 0))) (not x7245)))) g7244)))) + (letrec ((g7246 + (letrec ((g7247 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7248 + (letrec ((x-cnd7249 (real? g7162))) + (if x-cnd7249 + g7162 + (blame g7160 'real?))))) + g7248))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7250 + (letrec ((x-cnd7251 + (boolean? g7165))) + (if x-cnd7251 + g7165 + (blame g7163 'boolean?))))) + g7250))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7252 + (letrec ((x-cnd7253 + (number? g7168))) + (if x-cnd7253 + g7168 + (blame g7166 'number?))))) + g7252))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7254 + (letrec ((x-cnd7255 + ((lambda (v) #t) g7171))) + (if x-cnd7255 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7254))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7256 + (letrec ((x-cnd7257 + ((lambda (v) #t) g7174))) + (if x-cnd7257 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7256))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7258 + (letrec ((x-cnd7259 (pair? g7177))) + (if x-cnd7259 + g7177 + (blame g7175 'pair?))))) + g7258))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7260 + (letrec ((x-cnd7261 (pair? g7180))) + (if x-cnd7261 + g7180 + (blame g7178 'pair?))))) + g7260))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7262 + (letrec ((x-cnd7263 + (integer? g7183))) + (if x-cnd7263 + g7183 + (blame g7181 'integer?))))) + g7262))) + (and/c + (lambda (c1 c2) + (letrec ((g7264 + (lambda (k j v) + (letrec ((g7265 + (letrec ((x-cnd7266 + (c1 k j v))) + (if x-cnd7266 + (c2 k j v) + #f)))) + g7265)))) + g7264))) + (list-of + (lambda (contract) + (letrec ((g7267 + (lambda (k j v) + (letrec ((g7268 + (letrec ((x-cnd7269 + (null? v))) + (if x-cnd7269 + '() + (letrec ((x7273 + (letrec ((x7274 + (car + v))) + (contract + k + j + x7274))) + (x7270 + (letrec ((x7272 + (list-of + contract)) + (x7271 + (cdr + v))) + (x7272 + k + j + x7271)))) + (cons + x7273 + x7270)))))) + g7268)))) + g7267))) + (any? (lambda (v) (letrec ((g7275 #t)) g7275))) + (nonzero? + (lambda (v) + (letrec ((g7276 + (letrec ((x7277 (= v 0))) + (not x7277)))) + g7276))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7278 + (letrec ((x-cnd7279 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7279 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7278))) + (meta (lambda (v) (letrec ((g7280 v)) g7280))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7281 #t)) g7281))) + (cdddr + (lambda (x) + (letrec ((g7282 + (letrec ((x7283 + (letrec ((x7284 (cdr x))) + (cdr x7284)))) + (cdr x7283)))) + g7282))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7285 + (letrec ((x7288 (procedure? f))) + (assert x7288))) + (g7286 + (letrec ((x7289 (list? l))) + (assert x7289))) + (g7287 + (letrec ((x-cnd7290 (null? l))) + (if x-cnd7290 + '() + (letrec ((x7293 + (letrec ((x7294 + (car l))) + (f x7294))) + (x7291 + (letrec ((x7292 + (cdr l))) + (map f x7292)))) + (cons x7293 x7291)))))) + g7287))) + (cdar + (lambda (x) + (letrec ((g7295 + (letrec ((x7296 (car x))) + (cdr x7296)))) + g7295))) + (cadadr + (lambda (x) + (letrec ((g7297 + (letrec ((x7298 + (letrec ((x7299 + (letrec ((x7300 + (cdr + x))) + (car + x7300)))) + (cdr x7299)))) + (car x7298)))) + g7297))) + (cdadar + (lambda (x) + (letrec ((g7301 + (letrec ((x7302 + (letrec ((x7303 + (letrec ((x7304 + (car + x))) + (cdr + x7304)))) + (car x7303)))) + (cdr x7302)))) + g7301))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7305 + (letrec ((x7308 + (string? filename))) + (assert x7308))) + (g7306 + (letrec ((x7309 (procedure? proc))) + (assert x7309))) + (g7307 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7310 + (close-output-port + output-port)) + (g7311 res)) + g7311)))) + g7307))) + (caddr + (lambda (x) + (letrec ((g7312 + (letrec ((x7313 + (letrec ((x7314 (cdr x))) + (cdr x7314)))) + (car x7313)))) + g7312))) + (cdaadr + (lambda (x) + (letrec ((g7315 + (letrec ((x7316 + (letrec ((x7317 + (letrec ((x7318 + (cdr + x))) + (car + x7318)))) + (car x7317)))) + (cdr x7316)))) + g7315))) + (assq + (lambda (k l) + (letrec ((g7319 + (letrec ((x7321 (list? l))) + (assert x7321))) + (g7320 + (letrec ((x-cnd7322 (null? l))) + (if x-cnd7322 + #f + (letrec ((x-cnd7323 + (letrec ((x7324 + (caar l))) + (eq? x7324 k)))) + (if x-cnd7323 + (car l) + (letrec ((x7325 (cdr l))) + (assq k x7325)))))))) + g7320))) + (even? + (lambda (x) + (letrec ((g7326 + (letrec ((x7327 (modulo x 2))) + (= 0 x7327)))) + g7326))) + (list->string + (lambda (l) + (letrec ((g7328 + (letrec ((x7330 (list? l))) + (assert x7330))) + (g7329 + (letrec ((x-cnd7331 (null? l))) + (if x-cnd7331 + "" + (letrec ((x7334 + (letrec ((x7335 + (car l))) + (char->string + x7335))) + (x7332 + (letrec ((x7333 + (cdr l))) + (list->string + x7333)))) + (string-append + x7334 + x7332)))))) + g7329))) + (char<=? + (lambda (c1 c2) + (letrec ((g7336 + (letrec ((x7339 (char? c1))) + (assert x7339))) + (g7337 + (letrec ((x7340 (char? c2))) + (assert x7340))) + (g7338 + (letrec ((val7143 (char=? c x7357)))) + (if x-cnd7356 + (letrec ((x7358 #\z)) + (char-ci<=? c x7358)) + #f)))) + g7355))) + (<= + (lambda (x y) + (letrec ((g7359 + (letrec ((x7361 (number? x))) + (assert x7361))) + (g7360 + (letrec ((val7144 (< x y))) + (letrec ((g7362 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7363 + (if val7145 + val7145 + #f))) + g7363))))) + g7362)))) + g7360))) + (char-whitespace? + (lambda (c) + (letrec ((g7364 + (letrec ((val7146 + (letrec ((x7365 + (char->integer + c))) + (= x7365 9)))) + (letrec ((g7366 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7367 + (char->integer + c))) + (= + x7367 + 10)))) + (letrec ((g7368 + (if val7147 + val7147 + (letrec ((x7369 + (char->integer + c))) + (= + x7369 + 32))))) + g7368))))) + g7366)))) + g7364))) + (cddar + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 + (letrec ((x7372 (car x))) + (cdr x7372)))) + (cdr x7371)))) + g7370))) + (positive? + (lambda (x) + (letrec ((g7373 + (letrec ((x7375 (number? x))) + (assert x7375))) + (g7374 (> x 0))) + g7374))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7376 #f)) g7376))) + (cddr + (lambda (x) + (letrec ((g7377 + (letrec ((x7378 (cdr x))) + (cdr x7378)))) + g7377))) + (truncate + (lambda (x) + (letrec ((g7379 + (letrec ((x7381 (number? x))) + (assert x7381))) + (g7380 + (letrec ((x-cnd7382 (< x 0))) + (if x-cnd7382 + (ceiling x) + (floor x))))) + g7380))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7383 + (letrec ((val7148 (eq? a b))) + (letrec ((g7384 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7386 + (null? + a)) + (x7385 + (null? + b))) + (and x7386 + x7385)))) + (letrec ((g7387 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7390 + (string? + a)) + (x7389 + (string? + b)) + (x7388 + (string=? + a + b))) + (and x7390 + x7389 + x7388)))) + (letrec ((g7391 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7399 + (pair? + a)) + (x7398 + (pair? + b)) + (x7395 + (letrec ((x7397 + (car + a)) + (x7396 + (car + b))) + (equal? + x7397 + x7396))) + (x7392 + (letrec ((x7394 + (cdr + a)) + (x7393 + (cdr + b))) + (equal? + x7394 + x7393)))) + (and x7399 + x7398 + x7395 + x7392)))) + (letrec ((g7400 + (if val7151 + val7151 + (letrec ((x7419 + (vector? + a)) + (x7418 + (vector? + b)) + (x7401 + (letrec ((x7415 + (letrec ((x7416 + (letrec ((x7417 + (vector-length + a))) + (n + x7417)))) + (x7416))) + (x7402 + (letrec ((x7413 + (letrec ((x7414 + (vector-length + b))) + (= + x7414 + n))) + (x7403 + (letrec ((loop + (lambda (i) + (letrec ((g7404 + (letrec ((x7411 + (= + i + n)) + (x7405 + (letrec ((x7408 + (letrec ((x7410 + (vector-ref + a + i)) + (x7409 + (vector-ref + b + i))) + (equal? + x7410 + x7409))) + (x7406 + (letrec ((x7407 + (+ + i + 1))) + (loop + x7407)))) + (and x7408 + x7406)))) + (or x7411 + x7405)))) + g7404)))) + (letrec ((g7412 + (loop + 0))) + g7412)))) + (and x7413 + x7403)))) + (let x7415 x7402)))) + (and x7419 + x7418 + x7401))))) + g7400))))) + g7391))))) + g7387))))) + g7384)))) + g7383))) + (cdaaar + (lambda (x) + (letrec ((g7420 + (letrec ((x7421 + (letrec ((x7422 + (letrec ((x7423 + (car + x))) + (car + x7423)))) + (car x7422)))) + (cdr x7421)))) + g7420))) + (caaddr + (lambda (x) + (letrec ((g7424 + (letrec ((x7425 + (letrec ((x7426 + (letrec ((x7427 + (cdr + x))) + (cdr + x7427)))) + (car x7426)))) + (car x7425)))) + g7424))) + (eqv? + (lambda (x y) + (letrec ((g7428 (eq? x y))) g7428))) + (>= + (lambda (x y) + (letrec ((g7429 + (letrec ((x7431 (number? x))) + (assert x7431))) + (g7430 + (letrec ((val7152 (> x y))) + (letrec ((g7432 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7433 + (if val7153 + val7153 + #f))) + g7433))))) + g7432)))) + g7430))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7434 + (letrec ((x7437 + (string? filename))) + (assert x7437))) + (g7435 + (letrec ((x7438 (procedure? proc))) + (assert x7438))) + (g7436 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7439 + (close-input-port + input-port)) + (g7440 res)) + g7440)))) + g7436))) + (ref + (lambda (x) + (letrec ((g7441 (cons x '()))) g7441))) + (char>=? + (lambda (c1 c2) + (letrec ((g7442 + (letrec ((x7445 (char? c1))) + (assert x7445))) + (g7443 + (letrec ((x7446 (char? c2))) + (assert x7446))) + (g7444 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7447 + (if val7154 + val7154 + (char=? c1 c2)))) + g7447)))) + g7444))) + (cdaar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (car x7450)))) + (cdr x7449)))) + g7448))) + (cdaddr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 + (letrec ((x7454 + (cdr + x))) + (cdr + x7454)))) + (car x7453)))) + (cdr x7452)))) + g7451))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7455 + (letrec ((x7456 + (letrec ((x7457 (car x))) + (cdr x7457)))) + (car x7456)))) + g7455))) + (caadr + (lambda (x) + (letrec ((g7458 + (letrec ((x7459 + (letrec ((x7460 (cdr x))) + (car x7460)))) + (car x7459)))) + g7458))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7461 + (letrec ((x7464 (char? c1))) + (assert x7464))) + (g7462 + (letrec ((x7465 (char? c2))) + (assert x7465))) + (g7463 + (letrec ((x7466 + (char-ci<=? c1 c2))) + (not x7466)))) + g7463))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7467 + (letrec ((x7468 + (letrec ((x7469 + (letrec ((x7470 + (car + x))) + (car + x7470)))) + (car x7469)))) + (car x7468)))) + g7467))) + (negative? + (lambda (x) + (letrec ((g7471 + (letrec ((x7473 (number? x))) + (assert x7473))) + (g7472 (< x 0))) + g7472))) + (memv + (lambda (e l) + (letrec ((g7474 (memq e l))) g7474))) + (caaar + (lambda (x) + (letrec ((g7475 + (letrec ((x7476 + (letrec ((x7477 (car x))) + (car x7477)))) + (car x7476)))) + g7475))) + (debug + (lambda (e) (letrec ((g7478 '())) g7478))) + (reverse + (lambda (l) + (letrec ((g7479 + (letrec ((x7481 (list? l))) + (assert x7481))) + (g7480 + (letrec ((x-cnd7482 (null? l))) + (if x-cnd7482 + '() + (letrec ((x7485 + (letrec ((x7486 + (cdr l))) + (reverse x7486))) + (x7483 + (letrec ((x7484 + (car l))) + (list x7484)))) + (append x7485 x7483)))))) + g7480))) + (caaadr + (lambda (x) + (letrec ((g7487 + (letrec ((x7488 + (letrec ((x7489 + (letrec ((x7490 + (cdr + x))) + (car + x7490)))) + (car x7489)))) + (car x7488)))) + g7487))) + (cddadr + (lambda (x) + (letrec ((g7491 + (letrec ((x7492 + (letrec ((x7493 + (letrec ((x7494 + (cdr + x))) + (car + x7494)))) + (cdr x7493)))) + (cdr x7492)))) + g7491))) + (odd? + (lambda (x) + (letrec ((g7495 + (letrec ((x7497 (number? x))) + (assert x7497))) + (g7496 + (letrec ((x7498 (modulo x 2))) + (= 1 x7498)))) + g7496))) + (caadar + (lambda (x) + (letrec ((g7499 + (letrec ((x7500 + (letrec ((x7501 + (letrec ((x7502 + (car + x))) + (cdr + x7502)))) + (car x7501)))) + (car x7500)))) + g7499))) + (apply + (lambda (proc args) + (letrec ((g7503 + (letrec ((x7506 (procedure? proc))) + (assert x7506))) + (g7504 + (letrec ((x7507 (list? args))) + (assert x7507))) + (g7505 + (if cnd + (letrec ((g7508 (proc))) g7508) + (if cnd + (letrec ((g7509 + (letrec ((x7510 + (car + args))) + (proc x7510)))) + g7509) + (if cnd + (letrec ((g7511 + (letrec ((x7513 + (car + args)) + (x7512 + (cadr + args))) + (proc + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7514 + (letrec ((x7517 + (car + args)) + (x7516 + (cadr + args)) + (x7515 + (caddr + args))) + (proc + x7517 + x7516 + x7515)))) + g7514) + (if cnd + (letrec ((g7518 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args))) + (proc + x7522 + x7521 + x7520 + x7519)))) + g7518) + (if cnd + (letrec ((g7523 + (letrec ((x7529 + (car + args)) + (x7528 + (cadr + args)) + (x7527 + (caddr + args)) + (x7526 + (cadddr + args)) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (car + x7525)))) + (proc + x7529 + x7528 + x7527 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7530 + (letrec ((x7538 + (car + args)) + (x7537 + (cadr + args)) + (x7536 + (caddr + args)) + (x7535 + (cadddr + args)) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (car + x7534))) + (x7531 + (letrec ((x7532 + (cddddr + args))) + (cadr + x7532)))) + (proc + x7538 + x7537 + x7536 + x7535 + x7533 + x7531)))) + g7530) + (if cnd + (letrec ((g7539 + (letrec ((x7549 + (car + args)) + (x7548 + (cadr + args)) + (x7547 + (caddr + args)) + (x7546 + (cadddr + args)) + (x7544 + (letrec ((x7545 + (cddddr + args))) + (car + x7545))) + (x7542 + (letrec ((x7543 + (cddddr + args))) + (cadr + x7543))) + (x7540 + (letrec ((x7541 + (cddddr + args))) + (caddr + x7541)))) + (proc + x7549 + x7548 + x7547 + x7546 + x7544 + x7542 + x7540)))) + g7539) + (letrec ((g7550 + (error + "Unsupported call."))) + g7550))))))))))) + g7505))) + (member + (lambda (e l) + (letrec ((g7551 + (letrec ((x7553 (list? l))) + (assert x7553))) + (g7552 + (letrec ((x-cnd7554 (null? l))) + (if x-cnd7554 + #f + (letrec ((x-cnd7555 + (letrec ((x7556 + (car l))) + (equal? x7556 e)))) + (if x-cnd7555 + l + (letrec ((x7557 (cdr l))) + (member e x7557)))))))) + g7552))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7558 + (letrec ((x7559 + (letrec ((x7560 + (letrec ((x7561 + (cdr + x))) + (cdr + x7561)))) + (cdr x7560)))) + (cdr x7559)))) + g7558))) + (cadddr + (lambda (x) + (letrec ((g7562 + (letrec ((x7563 + (letrec ((x7564 + (letrec ((x7565 + (cdr + x))) + (cdr + x7565)))) + (cdr x7564)))) + (car x7563)))) + g7562))) + (int-top + (lambda () + (letrec ((g7566 (random 42))) g7566))) + (zero? + (lambda (x) + (letrec ((g7567 + (letrec ((x7569 (number? x))) + (assert x7569))) + (g7568 (= x 0))) + g7568))) + (string>=? + (lambda (s1 s2) + (letrec ((g7570 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7571 + (if val7155 + val7155 + (string=? s1 s2)))) + g7571)))) + g7570))) + (cadr + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 (cdr x))) + (car x7573)))) + g7572))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7574 + (letrec ((val7156 + (letrec ((x7577 + (pair? l)) + (x7575 + (letrec ((x7576 + (cdr + l))) + (list? + x7576)))) + (and x7577 x7575)))) + (letrec ((g7578 + (if val7156 + val7156 + (null? l)))) + g7578)))) + g7574))) + (cddaar + (lambda (x) + (letrec ((g7579 + (letrec ((x7580 + (letrec ((x7581 + (letrec ((x7582 + (car + x))) + (car + x7582)))) + (cdr x7581)))) + (cdr x7580)))) + g7579))) + (char-numeric? + (lambda (c) + (letrec ((g7583 + (letrec ((x-cnd7584 + (letrec ((x7585 #\0)) + (char<=? x7585 c)))) + (if x-cnd7584 + (letrec ((x7586 #\9)) + (char<=? c x7586)) + #f)))) + g7583))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7587 + (letrec ((x7589 (list? l))) + (assert x7589))) + (g7588 + (letrec ((x-cnd7590 (null? l))) + (if x-cnd7590 + #f + (letrec ((x-cnd7591 + (letrec ((x7592 + (caar l))) + (eqv? x7592 k)))) + (if x-cnd7591 + (car l) + (letrec ((x7593 (cdr l))) + (assq k x7593)))))))) + g7588))) + (not + (lambda (x) + (letrec ((g7594 (if x #f #t))) g7594))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7595 (append l1 l2))) g7595))) + (memq + (lambda (e l) + (letrec ((g7596 + (letrec ((x7598 (list? l))) + (assert x7598))) + (g7597 + (letrec ((x-cnd7599 (null? l))) + (if x-cnd7599 + #f + (letrec ((x-cnd7600 + (letrec ((x7601 + (car l))) + (eq? x7601 e)))) + (if x-cnd7600 + l + (letrec ((x7602 (cdr l))) + (memq e x7602)))))))) + g7597))) + (cadaar + (lambda (x) + (letrec ((g7603 + (letrec ((x7604 + (letrec ((x7605 + (letrec ((x7606 + (car + x))) + (car + x7606)))) + (cdr x7605)))) + (car x7604)))) + g7603))) + (length + (lambda (l) + (letrec ((g7607 + (letrec ((x7609 (list? l))) + (assert x7609))) + (g7608 + (letrec ((rec + (lambda (l) + (letrec ((g7610 + (letrec ((x-cnd7611 + (null? + l))) + (if x-cnd7611 + 0 + (letrec ((x7612 + (letrec ((x7613 + (cdr + l))) + (rec + x7613)))) + (+ + 1 + x7612)))))) + g7610)))) + (letrec ((g7614 (rec l))) + g7614)))) + g7608))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7615 + (letrec ((x7618 (char? c1))) + (assert x7618))) + (g7616 + (letrec ((x7619 (char? c2))) + (assert x7619))) + (g7617 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7621 + (letrec ((x7622 (string<=? s1 s2))) + (not x7622)))) + g7621))) + (cdadr + (lambda (x) + (letrec ((g7623 + (letrec ((x7624 + (letrec ((x7625 (cdr x))) + (car x7625)))) + (cdr x7624)))) + g7623))) + (assoc + (lambda (k l) + (letrec ((g7626 + (letrec ((x7628 (list? l))) + (assert x7628))) + (g7627 + (letrec ((x-cnd7629 (null? l))) + (if x-cnd7629 + #f + (letrec ((x-cnd7630 + (letrec ((x7631 + (caar l))) + (equal? x7631 k)))) + (if x-cnd7630 + (car l) + (letrec ((x7632 (cdr l))) + (assoc k x7632)))))))) + g7627))) + (caar + (lambda (x) + (letrec ((g7633 + (letrec ((x7634 (car x))) + (car x7634)))) + g7633))) + (char>? + (lambda (c1 c2) + (letrec ((g7635 + (letrec ((x7638 (char? c1))) + (assert x7638))) + (g7636 + (letrec ((x7639 (char? c2))) + (assert x7639))) + (g7637 + (letrec ((x7640 (char<=? c1 c2))) + (not x7640)))) + g7637))) + (string<=? + (lambda (s1 s2) + (letrec ((g7641 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7658 + (letrec ((x7661 (char? c1))) + (assert x7661))) + (g7659 + (letrec ((x7662 (char? c2))) + (assert x7662))) + (g7660 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7663 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7663)))) + g7660))) + (caddar + (lambda (x) + (letrec ((g7664 + (letrec ((x7665 + (letrec ((x7666 + (letrec ((x7667 + (car + x))) + (cdr + x7667)))) + (cdr x7666)))) + (car x7665)))) + g7664))) + (newline + (lambda () (letrec ((g7668 #f)) g7668))) + (lcm + (lambda (m n) + (letrec ((g7669 + (letrec ((x7671 + (letrec ((x7672 (* m n))) + (abs x7672))) + (x7670 (gcd m n))) + (/ x7671 x7670)))) + g7669))) + (deref car) + (> + (lambda (x y) + (letrec ((g7673 + (letrec ((x7675 (number? x))) + (assert x7675))) + (g7674 + (letrec ((x7676 (<= x y))) + (not x7676)))) + g7674))) + (list-ref + (lambda (l index) + (letrec ((g7677 + (letrec ((x7681 (list? l))) + (assert x7681))) + (g7678 + (letrec ((x7682 (number? index))) + (assert x7682))) + (g7679 + (letrec ((x7683 + (letrec ((x7684 + (length l))) + (< index x7684)))) + (assert x7683))) + (g7680 + (letrec ((x-cnd7685 (= index 0))) + (if x-cnd7685 + (car l) + (letrec ((x7687 (cdr l)) + (x7686 (- index 1))) + (list-ref x7687 x7686)))))) + g7680))) + (gcd + (lambda (a b) + (letrec ((g7688 + (letrec ((x-cnd7689 (= b 0))) + (if x-cnd7689 + a + (letrec ((x7690 (modulo a b))) + (gcd b x7690)))))) + g7688))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7691 + (letrec ((x-cnd7692 (real? g7162))) + (if x-cnd7692 + g7162 + (blame g7160 'real?))))) + g7691))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7693 + (letrec ((x-cnd7694 + (boolean? g7165))) + (if x-cnd7694 + g7165 + (blame g7163 'boolean?))))) + g7693))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7695 + (letrec ((x-cnd7696 + (number? g7168))) + (if x-cnd7696 + g7168 + (blame g7166 'number?))))) + g7695))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7697 + (letrec ((x-cnd7698 + ((lambda (v) #t) g7171))) + (if x-cnd7698 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7697))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7699 + (letrec ((x-cnd7700 + ((lambda (v) #t) g7174))) + (if x-cnd7700 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7699))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7701 + (letrec ((x-cnd7702 (pair? g7177))) + (if x-cnd7702 + g7177 + (blame g7175 'pair?))))) + g7701))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7703 + (letrec ((x-cnd7704 (pair? g7180))) + (if x-cnd7704 + g7180 + (blame g7178 'pair?))))) + g7703))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7705 + (letrec ((x-cnd7706 + (integer? g7183))) + (if x-cnd7706 + g7183 + (blame g7181 'integer?))))) + g7705))) + (and/c + (lambda (c1 c2) + (letrec ((g7707 + (lambda (k j v) + (letrec ((g7708 + (letrec ((x-cnd7709 + (c1 k j v))) + (if x-cnd7709 + (c2 k j v) + #f)))) + g7708)))) + g7707))) + (list-of + (lambda (contract) + (letrec ((g7710 + (lambda (k j v) + (letrec ((g7711 + (letrec ((x-cnd7712 + (null? v))) + (if x-cnd7712 + '() + (letrec ((x7716 + (letrec ((x7717 + (car + v))) + (contract + k + j + x7717))) + (x7713 + (letrec ((x7715 + (list-of + contract)) + (x7714 + (cdr + v))) + (x7715 + k + j + x7714)))) + (cons + x7716 + x7713)))))) + g7711)))) + g7710))) + (any? (lambda (v) (letrec ((g7718 #t)) g7718))) + (nonzero? + (lambda (v) + (letrec ((g7719 + (letrec ((x7720 (= v 0))) + (not x7720)))) + g7719))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7721 + (letrec ((x-cnd7722 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7722 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7721))) + (meta (lambda (v) (letrec ((g7723 v)) g7723))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7724 #t)) g7724))) + (cdddr + (lambda (x) + (letrec ((g7725 + (letrec ((x7726 + (letrec ((x7727 (cdr x))) + (cdr x7727)))) + (cdr x7726)))) + g7725))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7728 + (letrec ((x7731 (procedure? f))) + (assert x7731))) + (g7729 + (letrec ((x7732 (list? l))) + (assert x7732))) + (g7730 + (letrec ((x-cnd7733 (null? l))) + (if x-cnd7733 + '() + (letrec ((x7736 + (letrec ((x7737 + (car l))) + (f x7737))) + (x7734 + (letrec ((x7735 + (cdr l))) + (map f x7735)))) + (cons x7736 x7734)))))) + g7730))) + (cdar + (lambda (x) + (letrec ((g7738 + (letrec ((x7739 (car x))) + (cdr x7739)))) + g7738))) + (cadadr + (lambda (x) + (letrec ((g7740 + (letrec ((x7741 + (letrec ((x7742 + (letrec ((x7743 + (cdr + x))) + (car + x7743)))) + (cdr x7742)))) + (car x7741)))) + g7740))) + (cdadar + (lambda (x) + (letrec ((g7744 + (letrec ((x7745 + (letrec ((x7746 + (letrec ((x7747 + (car + x))) + (cdr + x7747)))) + (car x7746)))) + (cdr x7745)))) + g7744))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7748 + (letrec ((x7751 + (string? filename))) + (assert x7751))) + (g7749 + (letrec ((x7752 (procedure? proc))) + (assert x7752))) + (g7750 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7753 + (close-output-port + output-port)) + (g7754 res)) + g7754)))) + g7750))) + (caddr + (lambda (x) + (letrec ((g7755 + (letrec ((x7756 + (letrec ((x7757 (cdr x))) + (cdr x7757)))) + (car x7756)))) + g7755))) + (cdaadr + (lambda (x) + (letrec ((g7758 + (letrec ((x7759 + (letrec ((x7760 + (letrec ((x7761 + (cdr + x))) + (car + x7761)))) + (car x7760)))) + (cdr x7759)))) + g7758))) + (assq + (lambda (k l) + (letrec ((g7762 + (letrec ((x7764 (list? l))) + (assert x7764))) + (g7763 + (letrec ((x-cnd7765 (null? l))) + (if x-cnd7765 + #f + (letrec ((x-cnd7766 + (letrec ((x7767 + (caar l))) + (eq? x7767 k)))) + (if x-cnd7766 + (car l) + (letrec ((x7768 (cdr l))) + (assq k x7768)))))))) + g7763))) + (even? + (lambda (x) + (letrec ((g7769 + (letrec ((x7770 (modulo x 2))) + (= 0 x7770)))) + g7769))) + (list->string + (lambda (l) + (letrec ((g7771 + (letrec ((x7773 (list? l))) + (assert x7773))) + (g7772 + (letrec ((x-cnd7774 (null? l))) + (if x-cnd7774 + "" + (letrec ((x7777 + (letrec ((x7778 + (car l))) + (char->string + x7778))) + (x7775 + (letrec ((x7776 + (cdr l))) + (list->string + x7776)))) + (string-append + x7777 + x7775)))))) + g7772))) + (char<=? + (lambda (c1 c2) + (letrec ((g7779 + (letrec ((x7782 (char? c1))) + (assert x7782))) + (g7780 + (letrec ((x7783 (char? c2))) + (assert x7783))) + (g7781 + (letrec ((val7143 (char=? c x7800)))) + (if x-cnd7799 + (letrec ((x7801 #\z)) + (char-ci<=? c x7801)) + #f)))) + g7798))) + (<= + (lambda (x y) + (letrec ((g7802 + (letrec ((x7804 (number? x))) + (assert x7804))) + (g7803 + (letrec ((val7144 (< x y))) + (letrec ((g7805 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7806 + (if val7145 + val7145 + #f))) + g7806))))) + g7805)))) + g7803))) + (char-whitespace? + (lambda (c) + (letrec ((g7807 + (letrec ((val7146 + (letrec ((x7808 + (char->integer + c))) + (= x7808 9)))) + (letrec ((g7809 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7810 + (char->integer + c))) + (= + x7810 + 10)))) + (letrec ((g7811 + (if val7147 + val7147 + (letrec ((x7812 + (char->integer + c))) + (= + x7812 + 32))))) + g7811))))) + g7809)))) + g7807))) + (cddar + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 + (letrec ((x7815 (car x))) + (cdr x7815)))) + (cdr x7814)))) + g7813))) + (positive? + (lambda (x) + (letrec ((g7816 + (letrec ((x7818 (number? x))) + (assert x7818))) + (g7817 (> x 0))) + g7817))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7819 #f)) g7819))) + (cddr + (lambda (x) + (letrec ((g7820 + (letrec ((x7821 (cdr x))) + (cdr x7821)))) + g7820))) + (truncate + (lambda (x) + (letrec ((g7822 + (letrec ((x7824 (number? x))) + (assert x7824))) + (g7823 + (letrec ((x-cnd7825 (< x 0))) + (if x-cnd7825 + (ceiling x) + (floor x))))) + g7823))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7826 + (letrec ((val7148 (eq? a b))) + (letrec ((g7827 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7829 + (null? + a)) + (x7828 + (null? + b))) + (and x7829 + x7828)))) + (letrec ((g7830 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7833 + (string? + a)) + (x7832 + (string? + b)) + (x7831 + (string=? + a + b))) + (and x7833 + x7832 + x7831)))) + (letrec ((g7834 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7842 + (pair? + a)) + (x7841 + (pair? + b)) + (x7838 + (letrec ((x7840 + (car + a)) + (x7839 + (car + b))) + (equal? + x7840 + x7839))) + (x7835 + (letrec ((x7837 + (cdr + a)) + (x7836 + (cdr + b))) + (equal? + x7837 + x7836)))) + (and x7842 + x7841 + x7838 + x7835)))) + (letrec ((g7843 + (if val7151 + val7151 + (letrec ((x7862 + (vector? + a)) + (x7861 + (vector? + b)) + (x7844 + (letrec ((x7858 + (letrec ((x7859 + (letrec ((x7860 + (vector-length + a))) + (n + x7860)))) + (x7859))) + (x7845 + (letrec ((x7856 + (letrec ((x7857 + (vector-length + b))) + (= + x7857 + n))) + (x7846 + (letrec ((loop + (lambda (i) + (letrec ((g7847 + (letrec ((x7854 + (= + i + n)) + (x7848 + (letrec ((x7851 + (letrec ((x7853 + (vector-ref + a + i)) + (x7852 + (vector-ref + b + i))) + (equal? + x7853 + x7852))) + (x7849 + (letrec ((x7850 + (+ + i + 1))) + (loop + x7850)))) + (and x7851 + x7849)))) + (or x7854 + x7848)))) + g7847)))) + (letrec ((g7855 + (loop + 0))) + g7855)))) + (and x7856 + x7846)))) + (let x7858 x7845)))) + (and x7862 + x7861 + x7844))))) + g7843))))) + g7834))))) + g7830))))) + g7827)))) + g7826))) + (cdaaar + (lambda (x) + (letrec ((g7863 + (letrec ((x7864 + (letrec ((x7865 + (letrec ((x7866 + (car + x))) + (car + x7866)))) + (car x7865)))) + (cdr x7864)))) + g7863))) + (caaddr + (lambda (x) + (letrec ((g7867 + (letrec ((x7868 + (letrec ((x7869 + (letrec ((x7870 + (cdr + x))) + (cdr + x7870)))) + (car x7869)))) + (car x7868)))) + g7867))) + (eqv? + (lambda (x y) + (letrec ((g7871 (eq? x y))) g7871))) + (>= + (lambda (x y) + (letrec ((g7872 + (letrec ((x7874 (number? x))) + (assert x7874))) + (g7873 + (letrec ((val7152 (> x y))) + (letrec ((g7875 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7876 + (if val7153 + val7153 + #f))) + g7876))))) + g7875)))) + g7873))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7877 + (letrec ((x7880 + (string? filename))) + (assert x7880))) + (g7878 + (letrec ((x7881 (procedure? proc))) + (assert x7881))) + (g7879 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7882 + (close-input-port + input-port)) + (g7883 res)) + g7883)))) + g7879))) + (ref + (lambda (x) + (letrec ((g7884 (cons x '()))) g7884))) + (char>=? + (lambda (c1 c2) + (letrec ((g7885 + (letrec ((x7888 (char? c1))) + (assert x7888))) + (g7886 + (letrec ((x7889 (char? c2))) + (assert x7889))) + (g7887 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7890 + (if val7154 + val7154 + (char=? c1 c2)))) + g7890)))) + g7887))) + (cdaar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (car x7893)))) + (cdr x7892)))) + g7891))) + (cdaddr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 + (letrec ((x7897 + (cdr + x))) + (cdr + x7897)))) + (car x7896)))) + (cdr x7895)))) + g7894))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7898 + (letrec ((x7899 + (letrec ((x7900 (car x))) + (cdr x7900)))) + (car x7899)))) + g7898))) + (caadr + (lambda (x) + (letrec ((g7901 + (letrec ((x7902 + (letrec ((x7903 (cdr x))) + (car x7903)))) + (car x7902)))) + g7901))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7904 + (letrec ((x7907 (char? c1))) + (assert x7907))) + (g7905 + (letrec ((x7908 (char? c2))) + (assert x7908))) + (g7906 + (letrec ((x7909 + (char-ci<=? c1 c2))) + (not x7909)))) + g7906))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7910 + (letrec ((x7911 + (letrec ((x7912 + (letrec ((x7913 + (car + x))) + (car + x7913)))) + (car x7912)))) + (car x7911)))) + g7910))) + (negative? + (lambda (x) + (letrec ((g7914 + (letrec ((x7916 (number? x))) + (assert x7916))) + (g7915 (< x 0))) + g7915))) + (memv + (lambda (e l) + (letrec ((g7917 (memq e l))) g7917))) + (caaar + (lambda (x) + (letrec ((g7918 + (letrec ((x7919 + (letrec ((x7920 (car x))) + (car x7920)))) + (car x7919)))) + g7918))) + (debug + (lambda (e) (letrec ((g7921 '())) g7921))) + (reverse + (lambda (l) + (letrec ((g7922 + (letrec ((x7924 (list? l))) + (assert x7924))) + (g7923 + (letrec ((x-cnd7925 (null? l))) + (if x-cnd7925 + '() + (letrec ((x7928 + (letrec ((x7929 + (cdr l))) + (reverse x7929))) + (x7926 + (letrec ((x7927 + (car l))) + (list x7927)))) + (append x7928 x7926)))))) + g7923))) + (caaadr + (lambda (x) + (letrec ((g7930 + (letrec ((x7931 + (letrec ((x7932 + (letrec ((x7933 + (cdr + x))) + (car + x7933)))) + (car x7932)))) + (car x7931)))) + g7930))) + (cddadr + (lambda (x) + (letrec ((g7934 + (letrec ((x7935 + (letrec ((x7936 + (letrec ((x7937 + (cdr + x))) + (car + x7937)))) + (cdr x7936)))) + (cdr x7935)))) + g7934))) + (odd? + (lambda (x) + (letrec ((g7938 + (letrec ((x7940 (number? x))) + (assert x7940))) + (g7939 + (letrec ((x7941 (modulo x 2))) + (= 1 x7941)))) + g7939))) + (caadar + (lambda (x) + (letrec ((g7942 + (letrec ((x7943 + (letrec ((x7944 + (letrec ((x7945 + (car + x))) + (cdr + x7945)))) + (car x7944)))) + (car x7943)))) + g7942))) + (apply + (lambda (proc args) + (letrec ((g7946 + (letrec ((x7949 (procedure? proc))) + (assert x7949))) + (g7947 + (letrec ((x7950 (list? args))) + (assert x7950))) + (g7948 + (if cnd + (letrec ((g7951 (proc))) g7951) + (if cnd + (letrec ((g7952 + (letrec ((x7953 + (car + args))) + (proc x7953)))) + g7952) + (if cnd + (letrec ((g7954 + (letrec ((x7956 + (car + args)) + (x7955 + (cadr + args))) + (proc + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7957 + (letrec ((x7960 + (car + args)) + (x7959 + (cadr + args)) + (x7958 + (caddr + args))) + (proc + x7960 + x7959 + x7958)))) + g7957) + (if cnd + (letrec ((g7961 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args))) + (proc + x7965 + x7964 + x7963 + x7962)))) + g7961) + (if cnd + (letrec ((g7966 + (letrec ((x7972 + (car + args)) + (x7971 + (cadr + args)) + (x7970 + (caddr + args)) + (x7969 + (cadddr + args)) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (car + x7968)))) + (proc + x7972 + x7971 + x7970 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7973 + (letrec ((x7981 + (car + args)) + (x7980 + (cadr + args)) + (x7979 + (caddr + args)) + (x7978 + (cadddr + args)) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (car + x7977))) + (x7974 + (letrec ((x7975 + (cddddr + args))) + (cadr + x7975)))) + (proc + x7981 + x7980 + x7979 + x7978 + x7976 + x7974)))) + g7973) + (if cnd + (letrec ((g7982 + (letrec ((x7992 + (car + args)) + (x7991 + (cadr + args)) + (x7990 + (caddr + args)) + (x7989 + (cadddr + args)) + (x7987 + (letrec ((x7988 + (cddddr + args))) + (car + x7988))) + (x7985 + (letrec ((x7986 + (cddddr + args))) + (cadr + x7986))) + (x7983 + (letrec ((x7984 + (cddddr + args))) + (caddr + x7984)))) + (proc + x7992 + x7991 + x7990 + x7989 + x7987 + x7985 + x7983)))) + g7982) + (letrec ((g7993 + (error + "Unsupported call."))) + g7993))))))))))) + g7948))) + (member + (lambda (e l) + (letrec ((g7994 + (letrec ((x7996 (list? l))) + (assert x7996))) + (g7995 + (letrec ((x-cnd7997 (null? l))) + (if x-cnd7997 + #f + (letrec ((x-cnd7998 + (letrec ((x7999 + (car l))) + (equal? x7999 e)))) + (if x-cnd7998 + l + (letrec ((x8000 (cdr l))) + (member e x8000)))))))) + g7995))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8001 + (letrec ((x8002 + (letrec ((x8003 + (letrec ((x8004 + (cdr + x))) + (cdr + x8004)))) + (cdr x8003)))) + (cdr x8002)))) + g8001))) + (cadddr + (lambda (x) + (letrec ((g8005 + (letrec ((x8006 + (letrec ((x8007 + (letrec ((x8008 + (cdr + x))) + (cdr + x8008)))) + (cdr x8007)))) + (car x8006)))) + g8005))) + (int-top + (lambda () + (letrec ((g8009 (random 42))) g8009))) + (zero? + (lambda (x) + (letrec ((g8010 + (letrec ((x8012 (number? x))) + (assert x8012))) + (g8011 (= x 0))) + g8011))) + (string>=? + (lambda (s1 s2) + (letrec ((g8013 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8014 + (if val7155 + val7155 + (string=? s1 s2)))) + g8014)))) + g8013))) + (cadr + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 (cdr x))) + (car x8016)))) + g8015))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8017 + (letrec ((val7156 + (letrec ((x8020 + (pair? l)) + (x8018 + (letrec ((x8019 + (cdr + l))) + (list? + x8019)))) + (and x8020 x8018)))) + (letrec ((g8021 + (if val7156 + val7156 + (null? l)))) + g8021)))) + g8017))) + (cddaar + (lambda (x) + (letrec ((g8022 + (letrec ((x8023 + (letrec ((x8024 + (letrec ((x8025 + (car + x))) + (car + x8025)))) + (cdr x8024)))) + (cdr x8023)))) + g8022))) + (char-numeric? + (lambda (c) + (letrec ((g8026 + (letrec ((x-cnd8027 + (letrec ((x8028 #\0)) + (char<=? x8028 c)))) + (if x-cnd8027 + (letrec ((x8029 #\9)) + (char<=? c x8029)) + #f)))) + g8026))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8030 + (letrec ((x8032 (list? l))) + (assert x8032))) + (g8031 + (letrec ((x-cnd8033 (null? l))) + (if x-cnd8033 + #f + (letrec ((x-cnd8034 + (letrec ((x8035 + (caar l))) + (eqv? x8035 k)))) + (if x-cnd8034 + (car l) + (letrec ((x8036 (cdr l))) + (assq k x8036)))))))) + g8031))) + (not + (lambda (x) + (letrec ((g8037 (if x #f #t))) g8037))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8038 (append l1 l2))) g8038))) + (memq + (lambda (e l) + (letrec ((g8039 + (letrec ((x8041 (list? l))) + (assert x8041))) + (g8040 + (letrec ((x-cnd8042 (null? l))) + (if x-cnd8042 + #f + (letrec ((x-cnd8043 + (letrec ((x8044 + (car l))) + (eq? x8044 e)))) + (if x-cnd8043 + l + (letrec ((x8045 (cdr l))) + (memq e x8045)))))))) + g8040))) + (cadaar + (lambda (x) + (letrec ((g8046 + (letrec ((x8047 + (letrec ((x8048 + (letrec ((x8049 + (car + x))) + (car + x8049)))) + (cdr x8048)))) + (car x8047)))) + g8046))) + (length + (lambda (l) + (letrec ((g8050 + (letrec ((x8052 (list? l))) + (assert x8052))) + (g8051 + (letrec ((rec + (lambda (l) + (letrec ((g8053 + (letrec ((x-cnd8054 + (null? + l))) + (if x-cnd8054 + 0 + (letrec ((x8055 + (letrec ((x8056 + (cdr + l))) + (rec + x8056)))) + (+ + 1 + x8055)))))) + g8053)))) + (letrec ((g8057 (rec l))) + g8057)))) + g8051))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8058 + (letrec ((x8061 (char? c1))) + (assert x8061))) + (g8059 + (letrec ((x8062 (char? c2))) + (assert x8062))) + (g8060 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8064 + (letrec ((x8065 (string<=? s1 s2))) + (not x8065)))) + g8064))) + (cdadr + (lambda (x) + (letrec ((g8066 + (letrec ((x8067 + (letrec ((x8068 (cdr x))) + (car x8068)))) + (cdr x8067)))) + g8066))) + (assoc + (lambda (k l) + (letrec ((g8069 + (letrec ((x8071 (list? l))) + (assert x8071))) + (g8070 + (letrec ((x-cnd8072 (null? l))) + (if x-cnd8072 + #f + (letrec ((x-cnd8073 + (letrec ((x8074 + (caar l))) + (equal? x8074 k)))) + (if x-cnd8073 + (car l) + (letrec ((x8075 (cdr l))) + (assoc k x8075)))))))) + g8070))) + (caar + (lambda (x) + (letrec ((g8076 + (letrec ((x8077 (car x))) + (car x8077)))) + g8076))) + (char>? + (lambda (c1 c2) + (letrec ((g8078 + (letrec ((x8081 (char? c1))) + (assert x8081))) + (g8079 + (letrec ((x8082 (char? c2))) + (assert x8082))) + (g8080 + (letrec ((x8083 (char<=? c1 c2))) + (not x8083)))) + g8080))) + (string<=? + (lambda (s1 s2) + (letrec ((g8084 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8101 + (letrec ((x8104 (char? c1))) + (assert x8104))) + (g8102 + (letrec ((x8105 (char? c2))) + (assert x8105))) + (g8103 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8106 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8106)))) + g8103))) + (caddar + (lambda (x) + (letrec ((g8107 + (letrec ((x8108 + (letrec ((x8109 + (letrec ((x8110 + (car + x))) + (cdr + x8110)))) + (cdr x8109)))) + (car x8108)))) + g8107))) + (newline + (lambda () (letrec ((g8111 #f)) g8111))) + (lcm + (lambda (m n) + (letrec ((g8112 + (letrec ((x8114 + (letrec ((x8115 (* m n))) + (abs x8115))) + (x8113 (gcd m n))) + (/ x8114 x8113)))) + g8112))) + (deref car) + (> + (lambda (x y) + (letrec ((g8116 + (letrec ((x8118 (number? x))) + (assert x8118))) + (g8117 + (letrec ((x8119 (<= x y))) + (not x8119)))) + g8117))) + (list-ref + (lambda (l index) + (letrec ((g8120 + (letrec ((x8124 (list? l))) + (assert x8124))) + (g8121 + (letrec ((x8125 (number? index))) + (assert x8125))) + (g8122 + (letrec ((x8126 + (letrec ((x8127 + (length l))) + (< index x8127)))) + (assert x8126))) + (g8123 + (letrec ((x-cnd8128 (= index 0))) + (if x-cnd8128 + (car l) + (letrec ((x8130 (cdr l)) + (x8129 (- index 1))) + (list-ref x8130 x8129)))))) + g8123))) + (gcd + (lambda (a b) + (letrec ((g8131 + (letrec ((x-cnd8132 (= b 0))) + (if x-cnd8132 + a + (letrec ((x8133 (modulo a b))) + (gcd b x8133)))))) + g8131)))) + (letrec ((g8134 + (letrec ((g8135 + (letrec ((recursive-div2 + (lambda (l) + (letrec ((g8136 + (letrec ((x-cnd8137 + (empty? + l))) + (if x-cnd8137 + empty + (letrec ((x8141 + (car + l)) + (x8138 + (letrec ((x8139 + (letrec ((x8140 + (cdr + l))) + (cdr + x8140)))) + (recursive-div2 + x8139)))) + (cons + x8141 + x8138)))))) + g8136))) + (even-list/c + (lambda (g7229 + g7230 + g7231) + (letrec ((g8142 + (letrec ((x-cnd8143 + ((lambda () + (or/c + null? + (cons/c + any/c + (cons/c + any/c + even-list/c)))) + g7231))) + (if x-cnd8143 + g7231 + (blame + g7229 + '(lambda () + (or/c + null? + (cons/c + any/c + (cons/c + any/c + even-list/c))))))))) + g8142)))) + (letrec ((g8144 + (letrec ((g8145 + (letrec ((g8146 + (letrec ((x8148 + ((lambda (j7233 + k7234 + f7235) + (lambda (g7232) + ((listof + any/c) + j7233 + k7234 + (f7235 + ((even-list/c) + j7233 + k7234 + g7232))))) + 'module + 'importer + recursive-div2)) + (x8147 + (input))) + (x8148 + x8147)))) + g8146))) + g8145))) + g8144)))) + g8135))) + g8134)))) + g7247))) + g7246)) diff --git a/analyses/simpleactor/benchmarks-out/softy_subst.rkt b/analyses/simpleactor/benchmarks-out/softy_subst.rkt index 58935e28..b20b7807 100644 --- a/analyses/simpleactor/benchmarks-out/softy_subst.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_subst.rkt @@ -1,16 +1,3051 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7229 #t)) g7229))) + (meta (lambda (v) (letrec ((g7230 v)) g7230))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7231 + (letrec ((g7232 + (letrec ((x-e7233 lst)) + (match + x-e7233 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7234 (eq? v v1))) + (if x-cnd7234 #t (member v vs))))))))) + g7232))) + g7231))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (cond - ((equal? old t) new) - ((pair? t) (cons (subst* new old (car t)) (subst* new old (cdr t)))) - (else t)))) + (actor? + (lambda (k j) + (letrec ((g7235 (lambda (v) (letrec ((g7236 v)) g7236)))) g7235))) + (nonzero? + (lambda (v) + (letrec ((g7237 (letrec ((x7238 (= v 0))) (not x7238)))) g7237)))) + (letrec ((g7239 + (letrec ((g7240 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7241 + (letrec ((x-cnd7242 (real? g7162))) + (if x-cnd7242 + g7162 + (blame g7160 'real?))))) + g7241))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7243 + (letrec ((x-cnd7244 + (boolean? g7165))) + (if x-cnd7244 + g7165 + (blame g7163 'boolean?))))) + g7243))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7245 + (letrec ((x-cnd7246 + (number? g7168))) + (if x-cnd7246 + g7168 + (blame g7166 'number?))))) + g7245))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7247 + (letrec ((x-cnd7248 + ((lambda (v) #t) g7171))) + (if x-cnd7248 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7247))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7249 + (letrec ((x-cnd7250 + ((lambda (v) #t) g7174))) + (if x-cnd7250 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7249))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7251 + (letrec ((x-cnd7252 (pair? g7177))) + (if x-cnd7252 + g7177 + (blame g7175 'pair?))))) + g7251))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7253 + (letrec ((x-cnd7254 (pair? g7180))) + (if x-cnd7254 + g7180 + (blame g7178 'pair?))))) + g7253))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7255 + (letrec ((x-cnd7256 + (integer? g7183))) + (if x-cnd7256 + g7183 + (blame g7181 'integer?))))) + g7255))) + (and/c + (lambda (c1 c2) + (letrec ((g7257 + (lambda (k j v) + (letrec ((g7258 + (letrec ((x-cnd7259 + (c1 k j v))) + (if x-cnd7259 + (c2 k j v) + #f)))) + g7258)))) + g7257))) + (list-of + (lambda (contract) + (letrec ((g7260 + (lambda (k j v) + (letrec ((g7261 + (letrec ((x-cnd7262 + (null? v))) + (if x-cnd7262 + '() + (letrec ((x7266 + (letrec ((x7267 + (car + v))) + (contract + k + j + x7267))) + (x7263 + (letrec ((x7265 + (list-of + contract)) + (x7264 + (cdr + v))) + (x7265 + k + j + x7264)))) + (cons + x7266 + x7263)))))) + g7261)))) + g7260))) + (any? (lambda (v) (letrec ((g7268 #t)) g7268))) + (nonzero? + (lambda (v) + (letrec ((g7269 + (letrec ((x7270 (= v 0))) + (not x7270)))) + g7269))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7271 + (letrec ((x-cnd7272 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7272 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7271))) + (meta (lambda (v) (letrec ((g7273 v)) g7273))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7274 #t)) g7274))) + (cdddr + (lambda (x) + (letrec ((g7275 + (letrec ((x7276 + (letrec ((x7277 (cdr x))) + (cdr x7277)))) + (cdr x7276)))) + g7275))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7278 + (letrec ((x7281 (procedure? f))) + (assert x7281))) + (g7279 + (letrec ((x7282 (list? l))) + (assert x7282))) + (g7280 + (letrec ((x-cnd7283 (null? l))) + (if x-cnd7283 + '() + (letrec ((x7286 + (letrec ((x7287 + (car l))) + (f x7287))) + (x7284 + (letrec ((x7285 + (cdr l))) + (map f x7285)))) + (cons x7286 x7284)))))) + g7280))) + (cdar + (lambda (x) + (letrec ((g7288 + (letrec ((x7289 (car x))) + (cdr x7289)))) + g7288))) + (cadadr + (lambda (x) + (letrec ((g7290 + (letrec ((x7291 + (letrec ((x7292 + (letrec ((x7293 + (cdr + x))) + (car + x7293)))) + (cdr x7292)))) + (car x7291)))) + g7290))) + (cdadar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 + (letrec ((x7296 + (letrec ((x7297 + (car + x))) + (cdr + x7297)))) + (car x7296)))) + (cdr x7295)))) + g7294))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7298 + (letrec ((x7301 + (string? filename))) + (assert x7301))) + (g7299 + (letrec ((x7302 (procedure? proc))) + (assert x7302))) + (g7300 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7303 + (close-output-port + output-port)) + (g7304 res)) + g7304)))) + g7300))) + (caddr + (lambda (x) + (letrec ((g7305 + (letrec ((x7306 + (letrec ((x7307 (cdr x))) + (cdr x7307)))) + (car x7306)))) + g7305))) + (cdaadr + (lambda (x) + (letrec ((g7308 + (letrec ((x7309 + (letrec ((x7310 + (letrec ((x7311 + (cdr + x))) + (car + x7311)))) + (car x7310)))) + (cdr x7309)))) + g7308))) + (assq + (lambda (k l) + (letrec ((g7312 + (letrec ((x7314 (list? l))) + (assert x7314))) + (g7313 + (letrec ((x-cnd7315 (null? l))) + (if x-cnd7315 + #f + (letrec ((x-cnd7316 + (letrec ((x7317 + (caar l))) + (eq? x7317 k)))) + (if x-cnd7316 + (car l) + (letrec ((x7318 (cdr l))) + (assq k x7318)))))))) + g7313))) + (even? + (lambda (x) + (letrec ((g7319 + (letrec ((x7320 (modulo x 2))) + (= 0 x7320)))) + g7319))) + (list->string + (lambda (l) + (letrec ((g7321 + (letrec ((x7323 (list? l))) + (assert x7323))) + (g7322 + (letrec ((x-cnd7324 (null? l))) + (if x-cnd7324 + "" + (letrec ((x7327 + (letrec ((x7328 + (car l))) + (char->string + x7328))) + (x7325 + (letrec ((x7326 + (cdr l))) + (list->string + x7326)))) + (string-append + x7327 + x7325)))))) + g7322))) + (char<=? + (lambda (c1 c2) + (letrec ((g7329 + (letrec ((x7332 (char? c1))) + (assert x7332))) + (g7330 + (letrec ((x7333 (char? c2))) + (assert x7333))) + (g7331 + (letrec ((val7143 (char=? c x7350)))) + (if x-cnd7349 + (letrec ((x7351 #\z)) + (char-ci<=? c x7351)) + #f)))) + g7348))) + (<= + (lambda (x y) + (letrec ((g7352 + (letrec ((x7354 (number? x))) + (assert x7354))) + (g7353 + (letrec ((val7144 (< x y))) + (letrec ((g7355 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7356 + (if val7145 + val7145 + #f))) + g7356))))) + g7355)))) + g7353))) + (char-whitespace? + (lambda (c) + (letrec ((g7357 + (letrec ((val7146 + (letrec ((x7358 + (char->integer + c))) + (= x7358 9)))) + (letrec ((g7359 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7360 + (char->integer + c))) + (= + x7360 + 10)))) + (letrec ((g7361 + (if val7147 + val7147 + (letrec ((x7362 + (char->integer + c))) + (= + x7362 + 32))))) + g7361))))) + g7359)))) + g7357))) + (cddar + (lambda (x) + (letrec ((g7363 + (letrec ((x7364 + (letrec ((x7365 (car x))) + (cdr x7365)))) + (cdr x7364)))) + g7363))) + (positive? + (lambda (x) + (letrec ((g7366 + (letrec ((x7368 (number? x))) + (assert x7368))) + (g7367 (> x 0))) + g7367))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7369 #f)) g7369))) + (cddr + (lambda (x) + (letrec ((g7370 + (letrec ((x7371 (cdr x))) + (cdr x7371)))) + g7370))) + (truncate + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 + (letrec ((x-cnd7375 (< x 0))) + (if x-cnd7375 + (ceiling x) + (floor x))))) + g7373))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7376 + (letrec ((val7148 (eq? a b))) + (letrec ((g7377 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7379 + (null? + a)) + (x7378 + (null? + b))) + (and x7379 + x7378)))) + (letrec ((g7380 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7383 + (string? + a)) + (x7382 + (string? + b)) + (x7381 + (string=? + a + b))) + (and x7383 + x7382 + x7381)))) + (letrec ((g7384 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7392 + (pair? + a)) + (x7391 + (pair? + b)) + (x7388 + (letrec ((x7390 + (car + a)) + (x7389 + (car + b))) + (equal? + x7390 + x7389))) + (x7385 + (letrec ((x7387 + (cdr + a)) + (x7386 + (cdr + b))) + (equal? + x7387 + x7386)))) + (and x7392 + x7391 + x7388 + x7385)))) + (letrec ((g7393 + (if val7151 + val7151 + (letrec ((x7412 + (vector? + a)) + (x7411 + (vector? + b)) + (x7394 + (letrec ((x7408 + (letrec ((x7409 + (letrec ((x7410 + (vector-length + a))) + (n + x7410)))) + (x7409))) + (x7395 + (letrec ((x7406 + (letrec ((x7407 + (vector-length + b))) + (= + x7407 + n))) + (x7396 + (letrec ((loop + (lambda (i) + (letrec ((g7397 + (letrec ((x7404 + (= + i + n)) + (x7398 + (letrec ((x7401 + (letrec ((x7403 + (vector-ref + a + i)) + (x7402 + (vector-ref + b + i))) + (equal? + x7403 + x7402))) + (x7399 + (letrec ((x7400 + (+ + i + 1))) + (loop + x7400)))) + (and x7401 + x7399)))) + (or x7404 + x7398)))) + g7397)))) + (letrec ((g7405 + (loop + 0))) + g7405)))) + (and x7406 + x7396)))) + (let x7408 x7395)))) + (and x7412 + x7411 + x7394))))) + g7393))))) + g7384))))) + g7380))))) + g7377)))) + g7376))) + (cdaaar + (lambda (x) + (letrec ((g7413 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (car + x))) + (car + x7416)))) + (car x7415)))) + (cdr x7414)))) + g7413))) + (caaddr + (lambda (x) + (letrec ((g7417 + (letrec ((x7418 + (letrec ((x7419 + (letrec ((x7420 + (cdr + x))) + (cdr + x7420)))) + (car x7419)))) + (car x7418)))) + g7417))) + (eqv? + (lambda (x y) + (letrec ((g7421 (eq? x y))) g7421))) + (>= + (lambda (x y) + (letrec ((g7422 + (letrec ((x7424 (number? x))) + (assert x7424))) + (g7423 + (letrec ((val7152 (> x y))) + (letrec ((g7425 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7426 + (if val7153 + val7153 + #f))) + g7426))))) + g7425)))) + g7423))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7427 + (letrec ((x7430 + (string? filename))) + (assert x7430))) + (g7428 + (letrec ((x7431 (procedure? proc))) + (assert x7431))) + (g7429 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7432 + (close-input-port + input-port)) + (g7433 res)) + g7433)))) + g7429))) + (ref + (lambda (x) + (letrec ((g7434 (cons x '()))) g7434))) + (char>=? + (lambda (c1 c2) + (letrec ((g7435 + (letrec ((x7438 (char? c1))) + (assert x7438))) + (g7436 + (letrec ((x7439 (char? c2))) + (assert x7439))) + (g7437 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7440 + (if val7154 + val7154 + (char=? c1 c2)))) + g7440)))) + g7437))) + (cdaar + (lambda (x) + (letrec ((g7441 + (letrec ((x7442 + (letrec ((x7443 (car x))) + (car x7443)))) + (cdr x7442)))) + g7441))) + (cdaddr + (lambda (x) + (letrec ((g7444 + (letrec ((x7445 + (letrec ((x7446 + (letrec ((x7447 + (cdr + x))) + (cdr + x7447)))) + (car x7446)))) + (cdr x7445)))) + g7444))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7448 + (letrec ((x7449 + (letrec ((x7450 (car x))) + (cdr x7450)))) + (car x7449)))) + g7448))) + (caadr + (lambda (x) + (letrec ((g7451 + (letrec ((x7452 + (letrec ((x7453 (cdr x))) + (car x7453)))) + (car x7452)))) + g7451))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7454 + (letrec ((x7457 (char? c1))) + (assert x7457))) + (g7455 + (letrec ((x7458 (char? c2))) + (assert x7458))) + (g7456 + (letrec ((x7459 + (char-ci<=? c1 c2))) + (not x7459)))) + g7456))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7460 + (letrec ((x7461 + (letrec ((x7462 + (letrec ((x7463 + (car + x))) + (car + x7463)))) + (car x7462)))) + (car x7461)))) + g7460))) + (negative? + (lambda (x) + (letrec ((g7464 + (letrec ((x7466 (number? x))) + (assert x7466))) + (g7465 (< x 0))) + g7465))) + (memv + (lambda (e l) + (letrec ((g7467 (memq e l))) g7467))) + (caaar + (lambda (x) + (letrec ((g7468 + (letrec ((x7469 + (letrec ((x7470 (car x))) + (car x7470)))) + (car x7469)))) + g7468))) + (debug + (lambda (e) (letrec ((g7471 '())) g7471))) + (reverse + (lambda (l) + (letrec ((g7472 + (letrec ((x7474 (list? l))) + (assert x7474))) + (g7473 + (letrec ((x-cnd7475 (null? l))) + (if x-cnd7475 + '() + (letrec ((x7478 + (letrec ((x7479 + (cdr l))) + (reverse x7479))) + (x7476 + (letrec ((x7477 + (car l))) + (list x7477)))) + (append x7478 x7476)))))) + g7473))) + (caaadr + (lambda (x) + (letrec ((g7480 + (letrec ((x7481 + (letrec ((x7482 + (letrec ((x7483 + (cdr + x))) + (car + x7483)))) + (car x7482)))) + (car x7481)))) + g7480))) + (cddadr + (lambda (x) + (letrec ((g7484 + (letrec ((x7485 + (letrec ((x7486 + (letrec ((x7487 + (cdr + x))) + (car + x7487)))) + (cdr x7486)))) + (cdr x7485)))) + g7484))) + (odd? + (lambda (x) + (letrec ((g7488 + (letrec ((x7490 (number? x))) + (assert x7490))) + (g7489 + (letrec ((x7491 (modulo x 2))) + (= 1 x7491)))) + g7489))) + (caadar + (lambda (x) + (letrec ((g7492 + (letrec ((x7493 + (letrec ((x7494 + (letrec ((x7495 + (car + x))) + (cdr + x7495)))) + (car x7494)))) + (car x7493)))) + g7492))) + (apply + (lambda (proc args) + (letrec ((g7496 + (letrec ((x7499 (procedure? proc))) + (assert x7499))) + (g7497 + (letrec ((x7500 (list? args))) + (assert x7500))) + (g7498 + (if cnd + (letrec ((g7501 (proc))) g7501) + (if cnd + (letrec ((g7502 + (letrec ((x7503 + (car + args))) + (proc x7503)))) + g7502) + (if cnd + (letrec ((g7504 + (letrec ((x7506 + (car + args)) + (x7505 + (cadr + args))) + (proc + x7506 + x7505)))) + g7504) + (if cnd + (letrec ((g7507 + (letrec ((x7510 + (car + args)) + (x7509 + (cadr + args)) + (x7508 + (caddr + args))) + (proc + x7510 + x7509 + x7508)))) + g7507) + (if cnd + (letrec ((g7511 + (letrec ((x7515 + (car + args)) + (x7514 + (cadr + args)) + (x7513 + (caddr + args)) + (x7512 + (cadddr + args))) + (proc + x7515 + x7514 + x7513 + x7512)))) + g7511) + (if cnd + (letrec ((g7516 + (letrec ((x7522 + (car + args)) + (x7521 + (cadr + args)) + (x7520 + (caddr + args)) + (x7519 + (cadddr + args)) + (x7517 + (letrec ((x7518 + (cddddr + args))) + (car + x7518)))) + (proc + x7522 + x7521 + x7520 + x7519 + x7517)))) + g7516) + (if cnd + (letrec ((g7523 + (letrec ((x7531 + (car + args)) + (x7530 + (cadr + args)) + (x7529 + (caddr + args)) + (x7528 + (cadddr + args)) + (x7526 + (letrec ((x7527 + (cddddr + args))) + (car + x7527))) + (x7524 + (letrec ((x7525 + (cddddr + args))) + (cadr + x7525)))) + (proc + x7531 + x7530 + x7529 + x7528 + x7526 + x7524)))) + g7523) + (if cnd + (letrec ((g7532 + (letrec ((x7542 + (car + args)) + (x7541 + (cadr + args)) + (x7540 + (caddr + args)) + (x7539 + (cadddr + args)) + (x7537 + (letrec ((x7538 + (cddddr + args))) + (car + x7538))) + (x7535 + (letrec ((x7536 + (cddddr + args))) + (cadr + x7536))) + (x7533 + (letrec ((x7534 + (cddddr + args))) + (caddr + x7534)))) + (proc + x7542 + x7541 + x7540 + x7539 + x7537 + x7535 + x7533)))) + g7532) + (letrec ((g7543 + (error + "Unsupported call."))) + g7543))))))))))) + g7498))) + (member + (lambda (e l) + (letrec ((g7544 + (letrec ((x7546 (list? l))) + (assert x7546))) + (g7545 + (letrec ((x-cnd7547 (null? l))) + (if x-cnd7547 + #f + (letrec ((x-cnd7548 + (letrec ((x7549 + (car l))) + (equal? x7549 e)))) + (if x-cnd7548 + l + (letrec ((x7550 (cdr l))) + (member e x7550)))))))) + g7545))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7551 + (letrec ((x7552 + (letrec ((x7553 + (letrec ((x7554 + (cdr + x))) + (cdr + x7554)))) + (cdr x7553)))) + (cdr x7552)))) + g7551))) + (cadddr + (lambda (x) + (letrec ((g7555 + (letrec ((x7556 + (letrec ((x7557 + (letrec ((x7558 + (cdr + x))) + (cdr + x7558)))) + (cdr x7557)))) + (car x7556)))) + g7555))) + (int-top + (lambda () + (letrec ((g7559 (random 42))) g7559))) + (zero? + (lambda (x) + (letrec ((g7560 + (letrec ((x7562 (number? x))) + (assert x7562))) + (g7561 (= x 0))) + g7561))) + (string>=? + (lambda (s1 s2) + (letrec ((g7563 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7564 + (if val7155 + val7155 + (string=? s1 s2)))) + g7564)))) + g7563))) + (cadr + (lambda (x) + (letrec ((g7565 + (letrec ((x7566 (cdr x))) + (car x7566)))) + g7565))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7567 + (letrec ((val7156 + (letrec ((x7570 + (pair? l)) + (x7568 + (letrec ((x7569 + (cdr + l))) + (list? + x7569)))) + (and x7570 x7568)))) + (letrec ((g7571 + (if val7156 + val7156 + (null? l)))) + g7571)))) + g7567))) + (cddaar + (lambda (x) + (letrec ((g7572 + (letrec ((x7573 + (letrec ((x7574 + (letrec ((x7575 + (car + x))) + (car + x7575)))) + (cdr x7574)))) + (cdr x7573)))) + g7572))) + (char-numeric? + (lambda (c) + (letrec ((g7576 + (letrec ((x-cnd7577 + (letrec ((x7578 #\0)) + (char<=? x7578 c)))) + (if x-cnd7577 + (letrec ((x7579 #\9)) + (char<=? c x7579)) + #f)))) + g7576))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7580 + (letrec ((x7582 (list? l))) + (assert x7582))) + (g7581 + (letrec ((x-cnd7583 (null? l))) + (if x-cnd7583 + #f + (letrec ((x-cnd7584 + (letrec ((x7585 + (caar l))) + (eqv? x7585 k)))) + (if x-cnd7584 + (car l) + (letrec ((x7586 (cdr l))) + (assq k x7586)))))))) + g7581))) + (not + (lambda (x) + (letrec ((g7587 (if x #f #t))) g7587))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7588 (append l1 l2))) g7588))) + (memq + (lambda (e l) + (letrec ((g7589 + (letrec ((x7591 (list? l))) + (assert x7591))) + (g7590 + (letrec ((x-cnd7592 (null? l))) + (if x-cnd7592 + #f + (letrec ((x-cnd7593 + (letrec ((x7594 + (car l))) + (eq? x7594 e)))) + (if x-cnd7593 + l + (letrec ((x7595 (cdr l))) + (memq e x7595)))))))) + g7590))) + (cadaar + (lambda (x) + (letrec ((g7596 + (letrec ((x7597 + (letrec ((x7598 + (letrec ((x7599 + (car + x))) + (car + x7599)))) + (cdr x7598)))) + (car x7597)))) + g7596))) + (length + (lambda (l) + (letrec ((g7600 + (letrec ((x7602 (list? l))) + (assert x7602))) + (g7601 + (letrec ((rec + (lambda (l) + (letrec ((g7603 + (letrec ((x-cnd7604 + (null? + l))) + (if x-cnd7604 + 0 + (letrec ((x7605 + (letrec ((x7606 + (cdr + l))) + (rec + x7606)))) + (+ + 1 + x7605)))))) + g7603)))) + (letrec ((g7607 (rec l))) + g7607)))) + g7601))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7608 + (letrec ((x7611 (char? c1))) + (assert x7611))) + (g7609 + (letrec ((x7612 (char? c2))) + (assert x7612))) + (g7610 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7614 + (letrec ((x7615 (string<=? s1 s2))) + (not x7615)))) + g7614))) + (cdadr + (lambda (x) + (letrec ((g7616 + (letrec ((x7617 + (letrec ((x7618 (cdr x))) + (car x7618)))) + (cdr x7617)))) + g7616))) + (assoc + (lambda (k l) + (letrec ((g7619 + (letrec ((x7621 (list? l))) + (assert x7621))) + (g7620 + (letrec ((x-cnd7622 (null? l))) + (if x-cnd7622 + #f + (letrec ((x-cnd7623 + (letrec ((x7624 + (caar l))) + (equal? x7624 k)))) + (if x-cnd7623 + (car l) + (letrec ((x7625 (cdr l))) + (assoc k x7625)))))))) + g7620))) + (caar + (lambda (x) + (letrec ((g7626 + (letrec ((x7627 (car x))) + (car x7627)))) + g7626))) + (char>? + (lambda (c1 c2) + (letrec ((g7628 + (letrec ((x7631 (char? c1))) + (assert x7631))) + (g7629 + (letrec ((x7632 (char? c2))) + (assert x7632))) + (g7630 + (letrec ((x7633 (char<=? c1 c2))) + (not x7633)))) + g7630))) + (string<=? + (lambda (s1 s2) + (letrec ((g7634 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7651 + (letrec ((x7654 (char? c1))) + (assert x7654))) + (g7652 + (letrec ((x7655 (char? c2))) + (assert x7655))) + (g7653 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7656 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7656)))) + g7653))) + (caddar + (lambda (x) + (letrec ((g7657 + (letrec ((x7658 + (letrec ((x7659 + (letrec ((x7660 + (car + x))) + (cdr + x7660)))) + (cdr x7659)))) + (car x7658)))) + g7657))) + (newline + (lambda () (letrec ((g7661 #f)) g7661))) + (lcm + (lambda (m n) + (letrec ((g7662 + (letrec ((x7664 + (letrec ((x7665 (* m n))) + (abs x7665))) + (x7663 (gcd m n))) + (/ x7664 x7663)))) + g7662))) + (deref car) + (> + (lambda (x y) + (letrec ((g7666 + (letrec ((x7668 (number? x))) + (assert x7668))) + (g7667 + (letrec ((x7669 (<= x y))) + (not x7669)))) + g7667))) + (list-ref + (lambda (l index) + (letrec ((g7670 + (letrec ((x7674 (list? l))) + (assert x7674))) + (g7671 + (letrec ((x7675 (number? index))) + (assert x7675))) + (g7672 + (letrec ((x7676 + (letrec ((x7677 + (length l))) + (< index x7677)))) + (assert x7676))) + (g7673 + (letrec ((x-cnd7678 (= index 0))) + (if x-cnd7678 + (car l) + (letrec ((x7680 (cdr l)) + (x7679 (- index 1))) + (list-ref x7680 x7679)))))) + g7673))) + (gcd + (lambda (a b) + (letrec ((g7681 + (letrec ((x-cnd7682 (= b 0))) + (if x-cnd7682 + a + (letrec ((x7683 (modulo a b))) + (gcd b x7683)))))) + g7681))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7684 + (letrec ((x-cnd7685 (real? g7162))) + (if x-cnd7685 + g7162 + (blame g7160 'real?))))) + g7684))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7686 + (letrec ((x-cnd7687 + (boolean? g7165))) + (if x-cnd7687 + g7165 + (blame g7163 'boolean?))))) + g7686))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7688 + (letrec ((x-cnd7689 + (number? g7168))) + (if x-cnd7689 + g7168 + (blame g7166 'number?))))) + g7688))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7690 + (letrec ((x-cnd7691 + ((lambda (v) #t) g7171))) + (if x-cnd7691 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7690))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7692 + (letrec ((x-cnd7693 + ((lambda (v) #t) g7174))) + (if x-cnd7693 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7692))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7694 + (letrec ((x-cnd7695 (pair? g7177))) + (if x-cnd7695 + g7177 + (blame g7175 'pair?))))) + g7694))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7696 + (letrec ((x-cnd7697 (pair? g7180))) + (if x-cnd7697 + g7180 + (blame g7178 'pair?))))) + g7696))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7698 + (letrec ((x-cnd7699 + (integer? g7183))) + (if x-cnd7699 + g7183 + (blame g7181 'integer?))))) + g7698))) + (and/c + (lambda (c1 c2) + (letrec ((g7700 + (lambda (k j v) + (letrec ((g7701 + (letrec ((x-cnd7702 + (c1 k j v))) + (if x-cnd7702 + (c2 k j v) + #f)))) + g7701)))) + g7700))) + (list-of + (lambda (contract) + (letrec ((g7703 + (lambda (k j v) + (letrec ((g7704 + (letrec ((x-cnd7705 + (null? v))) + (if x-cnd7705 + '() + (letrec ((x7709 + (letrec ((x7710 + (car + v))) + (contract + k + j + x7710))) + (x7706 + (letrec ((x7708 + (list-of + contract)) + (x7707 + (cdr + v))) + (x7708 + k + j + x7707)))) + (cons + x7709 + x7706)))))) + g7704)))) + g7703))) + (any? (lambda (v) (letrec ((g7711 #t)) g7711))) + (nonzero? + (lambda (v) + (letrec ((g7712 + (letrec ((x7713 (= v 0))) + (not x7713)))) + g7712))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7714 + (letrec ((x-cnd7715 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7715 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7714))) + (meta (lambda (v) (letrec ((g7716 v)) g7716))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7717 #t)) g7717))) + (cdddr + (lambda (x) + (letrec ((g7718 + (letrec ((x7719 + (letrec ((x7720 (cdr x))) + (cdr x7720)))) + (cdr x7719)))) + g7718))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7721 + (letrec ((x7724 (procedure? f))) + (assert x7724))) + (g7722 + (letrec ((x7725 (list? l))) + (assert x7725))) + (g7723 + (letrec ((x-cnd7726 (null? l))) + (if x-cnd7726 + '() + (letrec ((x7729 + (letrec ((x7730 + (car l))) + (f x7730))) + (x7727 + (letrec ((x7728 + (cdr l))) + (map f x7728)))) + (cons x7729 x7727)))))) + g7723))) + (cdar + (lambda (x) + (letrec ((g7731 + (letrec ((x7732 (car x))) + (cdr x7732)))) + g7731))) + (cadadr + (lambda (x) + (letrec ((g7733 + (letrec ((x7734 + (letrec ((x7735 + (letrec ((x7736 + (cdr + x))) + (car + x7736)))) + (cdr x7735)))) + (car x7734)))) + g7733))) + (cdadar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 + (letrec ((x7739 + (letrec ((x7740 + (car + x))) + (cdr + x7740)))) + (car x7739)))) + (cdr x7738)))) + g7737))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7741 + (letrec ((x7744 + (string? filename))) + (assert x7744))) + (g7742 + (letrec ((x7745 (procedure? proc))) + (assert x7745))) + (g7743 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7746 + (close-output-port + output-port)) + (g7747 res)) + g7747)))) + g7743))) + (caddr + (lambda (x) + (letrec ((g7748 + (letrec ((x7749 + (letrec ((x7750 (cdr x))) + (cdr x7750)))) + (car x7749)))) + g7748))) + (cdaadr + (lambda (x) + (letrec ((g7751 + (letrec ((x7752 + (letrec ((x7753 + (letrec ((x7754 + (cdr + x))) + (car + x7754)))) + (car x7753)))) + (cdr x7752)))) + g7751))) + (assq + (lambda (k l) + (letrec ((g7755 + (letrec ((x7757 (list? l))) + (assert x7757))) + (g7756 + (letrec ((x-cnd7758 (null? l))) + (if x-cnd7758 + #f + (letrec ((x-cnd7759 + (letrec ((x7760 + (caar l))) + (eq? x7760 k)))) + (if x-cnd7759 + (car l) + (letrec ((x7761 (cdr l))) + (assq k x7761)))))))) + g7756))) + (even? + (lambda (x) + (letrec ((g7762 + (letrec ((x7763 (modulo x 2))) + (= 0 x7763)))) + g7762))) + (list->string + (lambda (l) + (letrec ((g7764 + (letrec ((x7766 (list? l))) + (assert x7766))) + (g7765 + (letrec ((x-cnd7767 (null? l))) + (if x-cnd7767 + "" + (letrec ((x7770 + (letrec ((x7771 + (car l))) + (char->string + x7771))) + (x7768 + (letrec ((x7769 + (cdr l))) + (list->string + x7769)))) + (string-append + x7770 + x7768)))))) + g7765))) + (char<=? + (lambda (c1 c2) + (letrec ((g7772 + (letrec ((x7775 (char? c1))) + (assert x7775))) + (g7773 + (letrec ((x7776 (char? c2))) + (assert x7776))) + (g7774 + (letrec ((val7143 (char=? c x7793)))) + (if x-cnd7792 + (letrec ((x7794 #\z)) + (char-ci<=? c x7794)) + #f)))) + g7791))) + (<= + (lambda (x y) + (letrec ((g7795 + (letrec ((x7797 (number? x))) + (assert x7797))) + (g7796 + (letrec ((val7144 (< x y))) + (letrec ((g7798 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7799 + (if val7145 + val7145 + #f))) + g7799))))) + g7798)))) + g7796))) + (char-whitespace? + (lambda (c) + (letrec ((g7800 + (letrec ((val7146 + (letrec ((x7801 + (char->integer + c))) + (= x7801 9)))) + (letrec ((g7802 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7803 + (char->integer + c))) + (= + x7803 + 10)))) + (letrec ((g7804 + (if val7147 + val7147 + (letrec ((x7805 + (char->integer + c))) + (= + x7805 + 32))))) + g7804))))) + g7802)))) + g7800))) + (cddar + (lambda (x) + (letrec ((g7806 + (letrec ((x7807 + (letrec ((x7808 (car x))) + (cdr x7808)))) + (cdr x7807)))) + g7806))) + (positive? + (lambda (x) + (letrec ((g7809 + (letrec ((x7811 (number? x))) + (assert x7811))) + (g7810 (> x 0))) + g7810))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7812 #f)) g7812))) + (cddr + (lambda (x) + (letrec ((g7813 + (letrec ((x7814 (cdr x))) + (cdr x7814)))) + g7813))) + (truncate + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 + (letrec ((x-cnd7818 (< x 0))) + (if x-cnd7818 + (ceiling x) + (floor x))))) + g7816))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7819 + (letrec ((val7148 (eq? a b))) + (letrec ((g7820 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7822 + (null? + a)) + (x7821 + (null? + b))) + (and x7822 + x7821)))) + (letrec ((g7823 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7826 + (string? + a)) + (x7825 + (string? + b)) + (x7824 + (string=? + a + b))) + (and x7826 + x7825 + x7824)))) + (letrec ((g7827 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7835 + (pair? + a)) + (x7834 + (pair? + b)) + (x7831 + (letrec ((x7833 + (car + a)) + (x7832 + (car + b))) + (equal? + x7833 + x7832))) + (x7828 + (letrec ((x7830 + (cdr + a)) + (x7829 + (cdr + b))) + (equal? + x7830 + x7829)))) + (and x7835 + x7834 + x7831 + x7828)))) + (letrec ((g7836 + (if val7151 + val7151 + (letrec ((x7855 + (vector? + a)) + (x7854 + (vector? + b)) + (x7837 + (letrec ((x7851 + (letrec ((x7852 + (letrec ((x7853 + (vector-length + a))) + (n + x7853)))) + (x7852))) + (x7838 + (letrec ((x7849 + (letrec ((x7850 + (vector-length + b))) + (= + x7850 + n))) + (x7839 + (letrec ((loop + (lambda (i) + (letrec ((g7840 + (letrec ((x7847 + (= + i + n)) + (x7841 + (letrec ((x7844 + (letrec ((x7846 + (vector-ref + a + i)) + (x7845 + (vector-ref + b + i))) + (equal? + x7846 + x7845))) + (x7842 + (letrec ((x7843 + (+ + i + 1))) + (loop + x7843)))) + (and x7844 + x7842)))) + (or x7847 + x7841)))) + g7840)))) + (letrec ((g7848 + (loop + 0))) + g7848)))) + (and x7849 + x7839)))) + (let x7851 x7838)))) + (and x7855 + x7854 + x7837))))) + g7836))))) + g7827))))) + g7823))))) + g7820)))) + g7819))) + (cdaaar + (lambda (x) + (letrec ((g7856 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (car + x))) + (car + x7859)))) + (car x7858)))) + (cdr x7857)))) + g7856))) + (caaddr + (lambda (x) + (letrec ((g7860 + (letrec ((x7861 + (letrec ((x7862 + (letrec ((x7863 + (cdr + x))) + (cdr + x7863)))) + (car x7862)))) + (car x7861)))) + g7860))) + (eqv? + (lambda (x y) + (letrec ((g7864 (eq? x y))) g7864))) + (>= + (lambda (x y) + (letrec ((g7865 + (letrec ((x7867 (number? x))) + (assert x7867))) + (g7866 + (letrec ((val7152 (> x y))) + (letrec ((g7868 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7869 + (if val7153 + val7153 + #f))) + g7869))))) + g7868)))) + g7866))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7870 + (letrec ((x7873 + (string? filename))) + (assert x7873))) + (g7871 + (letrec ((x7874 (procedure? proc))) + (assert x7874))) + (g7872 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7875 + (close-input-port + input-port)) + (g7876 res)) + g7876)))) + g7872))) + (ref + (lambda (x) + (letrec ((g7877 (cons x '()))) g7877))) + (char>=? + (lambda (c1 c2) + (letrec ((g7878 + (letrec ((x7881 (char? c1))) + (assert x7881))) + (g7879 + (letrec ((x7882 (char? c2))) + (assert x7882))) + (g7880 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7883 + (if val7154 + val7154 + (char=? c1 c2)))) + g7883)))) + g7880))) + (cdaar + (lambda (x) + (letrec ((g7884 + (letrec ((x7885 + (letrec ((x7886 (car x))) + (car x7886)))) + (cdr x7885)))) + g7884))) + (cdaddr + (lambda (x) + (letrec ((g7887 + (letrec ((x7888 + (letrec ((x7889 + (letrec ((x7890 + (cdr + x))) + (cdr + x7890)))) + (car x7889)))) + (cdr x7888)))) + g7887))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7891 + (letrec ((x7892 + (letrec ((x7893 (car x))) + (cdr x7893)))) + (car x7892)))) + g7891))) + (caadr + (lambda (x) + (letrec ((g7894 + (letrec ((x7895 + (letrec ((x7896 (cdr x))) + (car x7896)))) + (car x7895)))) + g7894))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7897 + (letrec ((x7900 (char? c1))) + (assert x7900))) + (g7898 + (letrec ((x7901 (char? c2))) + (assert x7901))) + (g7899 + (letrec ((x7902 + (char-ci<=? c1 c2))) + (not x7902)))) + g7899))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7903 + (letrec ((x7904 + (letrec ((x7905 + (letrec ((x7906 + (car + x))) + (car + x7906)))) + (car x7905)))) + (car x7904)))) + g7903))) + (negative? + (lambda (x) + (letrec ((g7907 + (letrec ((x7909 (number? x))) + (assert x7909))) + (g7908 (< x 0))) + g7908))) + (memv + (lambda (e l) + (letrec ((g7910 (memq e l))) g7910))) + (caaar + (lambda (x) + (letrec ((g7911 + (letrec ((x7912 + (letrec ((x7913 (car x))) + (car x7913)))) + (car x7912)))) + g7911))) + (debug + (lambda (e) (letrec ((g7914 '())) g7914))) + (reverse + (lambda (l) + (letrec ((g7915 + (letrec ((x7917 (list? l))) + (assert x7917))) + (g7916 + (letrec ((x-cnd7918 (null? l))) + (if x-cnd7918 + '() + (letrec ((x7921 + (letrec ((x7922 + (cdr l))) + (reverse x7922))) + (x7919 + (letrec ((x7920 + (car l))) + (list x7920)))) + (append x7921 x7919)))))) + g7916))) + (caaadr + (lambda (x) + (letrec ((g7923 + (letrec ((x7924 + (letrec ((x7925 + (letrec ((x7926 + (cdr + x))) + (car + x7926)))) + (car x7925)))) + (car x7924)))) + g7923))) + (cddadr + (lambda (x) + (letrec ((g7927 + (letrec ((x7928 + (letrec ((x7929 + (letrec ((x7930 + (cdr + x))) + (car + x7930)))) + (cdr x7929)))) + (cdr x7928)))) + g7927))) + (odd? + (lambda (x) + (letrec ((g7931 + (letrec ((x7933 (number? x))) + (assert x7933))) + (g7932 + (letrec ((x7934 (modulo x 2))) + (= 1 x7934)))) + g7932))) + (caadar + (lambda (x) + (letrec ((g7935 + (letrec ((x7936 + (letrec ((x7937 + (letrec ((x7938 + (car + x))) + (cdr + x7938)))) + (car x7937)))) + (car x7936)))) + g7935))) + (apply + (lambda (proc args) + (letrec ((g7939 + (letrec ((x7942 (procedure? proc))) + (assert x7942))) + (g7940 + (letrec ((x7943 (list? args))) + (assert x7943))) + (g7941 + (if cnd + (letrec ((g7944 (proc))) g7944) + (if cnd + (letrec ((g7945 + (letrec ((x7946 + (car + args))) + (proc x7946)))) + g7945) + (if cnd + (letrec ((g7947 + (letrec ((x7949 + (car + args)) + (x7948 + (cadr + args))) + (proc + x7949 + x7948)))) + g7947) + (if cnd + (letrec ((g7950 + (letrec ((x7953 + (car + args)) + (x7952 + (cadr + args)) + (x7951 + (caddr + args))) + (proc + x7953 + x7952 + x7951)))) + g7950) + (if cnd + (letrec ((g7954 + (letrec ((x7958 + (car + args)) + (x7957 + (cadr + args)) + (x7956 + (caddr + args)) + (x7955 + (cadddr + args))) + (proc + x7958 + x7957 + x7956 + x7955)))) + g7954) + (if cnd + (letrec ((g7959 + (letrec ((x7965 + (car + args)) + (x7964 + (cadr + args)) + (x7963 + (caddr + args)) + (x7962 + (cadddr + args)) + (x7960 + (letrec ((x7961 + (cddddr + args))) + (car + x7961)))) + (proc + x7965 + x7964 + x7963 + x7962 + x7960)))) + g7959) + (if cnd + (letrec ((g7966 + (letrec ((x7974 + (car + args)) + (x7973 + (cadr + args)) + (x7972 + (caddr + args)) + (x7971 + (cadddr + args)) + (x7969 + (letrec ((x7970 + (cddddr + args))) + (car + x7970))) + (x7967 + (letrec ((x7968 + (cddddr + args))) + (cadr + x7968)))) + (proc + x7974 + x7973 + x7972 + x7971 + x7969 + x7967)))) + g7966) + (if cnd + (letrec ((g7975 + (letrec ((x7985 + (car + args)) + (x7984 + (cadr + args)) + (x7983 + (caddr + args)) + (x7982 + (cadddr + args)) + (x7980 + (letrec ((x7981 + (cddddr + args))) + (car + x7981))) + (x7978 + (letrec ((x7979 + (cddddr + args))) + (cadr + x7979))) + (x7976 + (letrec ((x7977 + (cddddr + args))) + (caddr + x7977)))) + (proc + x7985 + x7984 + x7983 + x7982 + x7980 + x7978 + x7976)))) + g7975) + (letrec ((g7986 + (error + "Unsupported call."))) + g7986))))))))))) + g7941))) + (member + (lambda (e l) + (letrec ((g7987 + (letrec ((x7989 (list? l))) + (assert x7989))) + (g7988 + (letrec ((x-cnd7990 (null? l))) + (if x-cnd7990 + #f + (letrec ((x-cnd7991 + (letrec ((x7992 + (car l))) + (equal? x7992 e)))) + (if x-cnd7991 + l + (letrec ((x7993 (cdr l))) + (member e x7993)))))))) + g7988))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7994 + (letrec ((x7995 + (letrec ((x7996 + (letrec ((x7997 + (cdr + x))) + (cdr + x7997)))) + (cdr x7996)))) + (cdr x7995)))) + g7994))) + (cadddr + (lambda (x) + (letrec ((g7998 + (letrec ((x7999 + (letrec ((x8000 + (letrec ((x8001 + (cdr + x))) + (cdr + x8001)))) + (cdr x8000)))) + (car x7999)))) + g7998))) + (int-top + (lambda () + (letrec ((g8002 (random 42))) g8002))) + (zero? + (lambda (x) + (letrec ((g8003 + (letrec ((x8005 (number? x))) + (assert x8005))) + (g8004 (= x 0))) + g8004))) + (string>=? + (lambda (s1 s2) + (letrec ((g8006 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8007 + (if val7155 + val7155 + (string=? s1 s2)))) + g8007)))) + g8006))) + (cadr + (lambda (x) + (letrec ((g8008 + (letrec ((x8009 (cdr x))) + (car x8009)))) + g8008))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8010 + (letrec ((val7156 + (letrec ((x8013 + (pair? l)) + (x8011 + (letrec ((x8012 + (cdr + l))) + (list? + x8012)))) + (and x8013 x8011)))) + (letrec ((g8014 + (if val7156 + val7156 + (null? l)))) + g8014)))) + g8010))) + (cddaar + (lambda (x) + (letrec ((g8015 + (letrec ((x8016 + (letrec ((x8017 + (letrec ((x8018 + (car + x))) + (car + x8018)))) + (cdr x8017)))) + (cdr x8016)))) + g8015))) + (char-numeric? + (lambda (c) + (letrec ((g8019 + (letrec ((x-cnd8020 + (letrec ((x8021 #\0)) + (char<=? x8021 c)))) + (if x-cnd8020 + (letrec ((x8022 #\9)) + (char<=? c x8022)) + #f)))) + g8019))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8023 + (letrec ((x8025 (list? l))) + (assert x8025))) + (g8024 + (letrec ((x-cnd8026 (null? l))) + (if x-cnd8026 + #f + (letrec ((x-cnd8027 + (letrec ((x8028 + (caar l))) + (eqv? x8028 k)))) + (if x-cnd8027 + (car l) + (letrec ((x8029 (cdr l))) + (assq k x8029)))))))) + g8024))) + (not + (lambda (x) + (letrec ((g8030 (if x #f #t))) g8030))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8031 (append l1 l2))) g8031))) + (memq + (lambda (e l) + (letrec ((g8032 + (letrec ((x8034 (list? l))) + (assert x8034))) + (g8033 + (letrec ((x-cnd8035 (null? l))) + (if x-cnd8035 + #f + (letrec ((x-cnd8036 + (letrec ((x8037 + (car l))) + (eq? x8037 e)))) + (if x-cnd8036 + l + (letrec ((x8038 (cdr l))) + (memq e x8038)))))))) + g8033))) + (cadaar + (lambda (x) + (letrec ((g8039 + (letrec ((x8040 + (letrec ((x8041 + (letrec ((x8042 + (car + x))) + (car + x8042)))) + (cdr x8041)))) + (car x8040)))) + g8039))) + (length + (lambda (l) + (letrec ((g8043 + (letrec ((x8045 (list? l))) + (assert x8045))) + (g8044 + (letrec ((rec + (lambda (l) + (letrec ((g8046 + (letrec ((x-cnd8047 + (null? + l))) + (if x-cnd8047 + 0 + (letrec ((x8048 + (letrec ((x8049 + (cdr + l))) + (rec + x8049)))) + (+ + 1 + x8048)))))) + g8046)))) + (letrec ((g8050 (rec l))) + g8050)))) + g8044))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8051 + (letrec ((x8054 (char? c1))) + (assert x8054))) + (g8052 + (letrec ((x8055 (char? c2))) + (assert x8055))) + (g8053 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8057 + (letrec ((x8058 (string<=? s1 s2))) + (not x8058)))) + g8057))) + (cdadr + (lambda (x) + (letrec ((g8059 + (letrec ((x8060 + (letrec ((x8061 (cdr x))) + (car x8061)))) + (cdr x8060)))) + g8059))) + (assoc + (lambda (k l) + (letrec ((g8062 + (letrec ((x8064 (list? l))) + (assert x8064))) + (g8063 + (letrec ((x-cnd8065 (null? l))) + (if x-cnd8065 + #f + (letrec ((x-cnd8066 + (letrec ((x8067 + (caar l))) + (equal? x8067 k)))) + (if x-cnd8066 + (car l) + (letrec ((x8068 (cdr l))) + (assoc k x8068)))))))) + g8063))) + (caar + (lambda (x) + (letrec ((g8069 + (letrec ((x8070 (car x))) + (car x8070)))) + g8069))) + (char>? + (lambda (c1 c2) + (letrec ((g8071 + (letrec ((x8074 (char? c1))) + (assert x8074))) + (g8072 + (letrec ((x8075 (char? c2))) + (assert x8075))) + (g8073 + (letrec ((x8076 (char<=? c1 c2))) + (not x8076)))) + g8073))) + (string<=? + (lambda (s1 s2) + (letrec ((g8077 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8094 + (letrec ((x8097 (char? c1))) + (assert x8097))) + (g8095 + (letrec ((x8098 (char? c2))) + (assert x8098))) + (g8096 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8099 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8099)))) + g8096))) + (caddar + (lambda (x) + (letrec ((g8100 + (letrec ((x8101 + (letrec ((x8102 + (letrec ((x8103 + (car + x))) + (cdr + x8103)))) + (cdr x8102)))) + (car x8101)))) + g8100))) + (newline + (lambda () (letrec ((g8104 #f)) g8104))) + (lcm + (lambda (m n) + (letrec ((g8105 + (letrec ((x8107 + (letrec ((x8108 (* m n))) + (abs x8108))) + (x8106 (gcd m n))) + (/ x8107 x8106)))) + g8105))) + (deref car) + (> + (lambda (x y) + (letrec ((g8109 + (letrec ((x8111 (number? x))) + (assert x8111))) + (g8110 + (letrec ((x8112 (<= x y))) + (not x8112)))) + g8110))) + (list-ref + (lambda (l index) + (letrec ((g8113 + (letrec ((x8117 (list? l))) + (assert x8117))) + (g8114 + (letrec ((x8118 (number? index))) + (assert x8118))) + (g8115 + (letrec ((x8119 + (letrec ((x8120 + (length l))) + (< index x8120)))) + (assert x8119))) + (g8116 + (letrec ((x-cnd8121 (= index 0))) + (if x-cnd8121 + (car l) + (letrec ((x8123 (cdr l)) + (x8122 (- index 1))) + (list-ref x8123 x8122)))))) + g8116))) + (gcd + (lambda (a b) + (letrec ((g8124 + (letrec ((x-cnd8125 (= b 0))) + (if x-cnd8125 + a + (letrec ((x8126 (modulo a b))) + (gcd b x8126)))))) + g8124)))) + (letrec ((g8127 + (letrec ((g8128 + (if cnd + (letrec ((g8129 new)) g8129) + (if cnd + (letrec ((g8130 + (letrec ((x8133 + (letrec ((x8134 + (car + t))) + (subst* + new + old + x8134))) + (x8131 + (letrec ((x8132 + (cdr + t))) + (subst* + new + old + x8132)))) + (cons + x8133 + x8131)))) + g8130) + (letrec ((g8135 t)) g8135))))) + g8128))) + g8127)))) + g7240))) + g7239)) diff --git a/analyses/simpleactor/benchmarks-out/softy_tak.rkt b/analyses/simpleactor/benchmarks-out/softy_tak.rkt index cd90a52d..d958a70a 100644 --- a/analyses/simpleactor/benchmarks-out/softy_tak.rkt +++ b/analyses/simpleactor/benchmarks-out/softy_tak.rkt @@ -1,32 +1,3109 @@ -(letrec ((any? (lambda (v) #t)) - (meta (lambda (v) v)) +(letrec ((any? (lambda (v) (letrec ((g7235 #t)) g7235))) + (meta (lambda (v) (letrec ((g7236 v)) g7236))) (member (lambda (v lst) - (begin - (match - lst - ((() #f) ((pair v1 vs) (if (eq? v v1) #t (member v vs)))))))) + (letrec ((g7237 + (letrec ((g7238 + (letrec ((x-e7239 lst)) + (match + x-e7239 + ((() #f) + ((pair v1 vs) + (letrec ((x-cnd7240 (eq? v v1))) + (if x-cnd7240 #t (member v vs))))))))) + g7238))) + g7237))) (unconstrained/c #f) - (actor? (lambda (k j) (lambda (v) v))) - (nonzero? (lambda (v) (not (= v 0))))) - (begin - (define (tak x y z) - (if (< y x) - (tak (tak (- x 1) y z) (tak (- y 1) z x) (tak (- z 1) x y)) - z)) - (begin - ((((lambda (j3986 k3987 f3988) - (lambda (g3983 g3984 g3985) - (number? - j3986 - k3987 - (f3988 - (number? j3986 k3987 g3983) - (number? j3986 k3987 g3984) - (number? j3986 k3987 g3985))))) - 'module - 'importer - tak) - (input) - (input) - (input)))))) + (actor? + (lambda (k j) + (letrec ((g7241 (lambda (v) (letrec ((g7242 v)) g7242)))) g7241))) + (nonzero? + (lambda (v) + (letrec ((g7243 (letrec ((x7244 (= v 0))) (not x7244)))) g7243)))) + (letrec ((g7245 + (letrec ((g7246 + (letrec ((real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7247 + (letrec ((x-cnd7248 (real? g7162))) + (if x-cnd7248 + g7162 + (blame g7160 'real?))))) + g7247))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7249 + (letrec ((x-cnd7250 + (boolean? g7165))) + (if x-cnd7250 + g7165 + (blame g7163 'boolean?))))) + g7249))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7251 + (letrec ((x-cnd7252 + (number? g7168))) + (if x-cnd7252 + g7168 + (blame g7166 'number?))))) + g7251))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7253 + (letrec ((x-cnd7254 + ((lambda (v) #t) g7171))) + (if x-cnd7254 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7253))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7255 + (letrec ((x-cnd7256 + ((lambda (v) #t) g7174))) + (if x-cnd7256 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7255))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7257 + (letrec ((x-cnd7258 (pair? g7177))) + (if x-cnd7258 + g7177 + (blame g7175 'pair?))))) + g7257))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7259 + (letrec ((x-cnd7260 (pair? g7180))) + (if x-cnd7260 + g7180 + (blame g7178 'pair?))))) + g7259))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7261 + (letrec ((x-cnd7262 + (integer? g7183))) + (if x-cnd7262 + g7183 + (blame g7181 'integer?))))) + g7261))) + (and/c + (lambda (c1 c2) + (letrec ((g7263 + (lambda (k j v) + (letrec ((g7264 + (letrec ((x-cnd7265 + (c1 k j v))) + (if x-cnd7265 + (c2 k j v) + #f)))) + g7264)))) + g7263))) + (list-of + (lambda (contract) + (letrec ((g7266 + (lambda (k j v) + (letrec ((g7267 + (letrec ((x-cnd7268 + (null? v))) + (if x-cnd7268 + '() + (letrec ((x7272 + (letrec ((x7273 + (car + v))) + (contract + k + j + x7273))) + (x7269 + (letrec ((x7271 + (list-of + contract)) + (x7270 + (cdr + v))) + (x7271 + k + j + x7270)))) + (cons + x7272 + x7269)))))) + g7267)))) + g7266))) + (any? (lambda (v) (letrec ((g7274 #t)) g7274))) + (nonzero? + (lambda (v) + (letrec ((g7275 + (letrec ((x7276 (= v 0))) + (not x7276)))) + g7275))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7277 + (letrec ((x-cnd7278 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7278 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7277))) + (meta (lambda (v) (letrec ((g7279 v)) g7279))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7280 #t)) g7280))) + (cdddr + (lambda (x) + (letrec ((g7281 + (letrec ((x7282 + (letrec ((x7283 (cdr x))) + (cdr x7283)))) + (cdr x7282)))) + g7281))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7284 + (letrec ((x7287 (procedure? f))) + (assert x7287))) + (g7285 + (letrec ((x7288 (list? l))) + (assert x7288))) + (g7286 + (letrec ((x-cnd7289 (null? l))) + (if x-cnd7289 + '() + (letrec ((x7292 + (letrec ((x7293 + (car l))) + (f x7293))) + (x7290 + (letrec ((x7291 + (cdr l))) + (map f x7291)))) + (cons x7292 x7290)))))) + g7286))) + (cdar + (lambda (x) + (letrec ((g7294 + (letrec ((x7295 (car x))) + (cdr x7295)))) + g7294))) + (cadadr + (lambda (x) + (letrec ((g7296 + (letrec ((x7297 + (letrec ((x7298 + (letrec ((x7299 + (cdr + x))) + (car + x7299)))) + (cdr x7298)))) + (car x7297)))) + g7296))) + (cdadar + (lambda (x) + (letrec ((g7300 + (letrec ((x7301 + (letrec ((x7302 + (letrec ((x7303 + (car + x))) + (cdr + x7303)))) + (car x7302)))) + (cdr x7301)))) + g7300))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7304 + (letrec ((x7307 + (string? filename))) + (assert x7307))) + (g7305 + (letrec ((x7308 (procedure? proc))) + (assert x7308))) + (g7306 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7309 + (close-output-port + output-port)) + (g7310 res)) + g7310)))) + g7306))) + (caddr + (lambda (x) + (letrec ((g7311 + (letrec ((x7312 + (letrec ((x7313 (cdr x))) + (cdr x7313)))) + (car x7312)))) + g7311))) + (cdaadr + (lambda (x) + (letrec ((g7314 + (letrec ((x7315 + (letrec ((x7316 + (letrec ((x7317 + (cdr + x))) + (car + x7317)))) + (car x7316)))) + (cdr x7315)))) + g7314))) + (assq + (lambda (k l) + (letrec ((g7318 + (letrec ((x7320 (list? l))) + (assert x7320))) + (g7319 + (letrec ((x-cnd7321 (null? l))) + (if x-cnd7321 + #f + (letrec ((x-cnd7322 + (letrec ((x7323 + (caar l))) + (eq? x7323 k)))) + (if x-cnd7322 + (car l) + (letrec ((x7324 (cdr l))) + (assq k x7324)))))))) + g7319))) + (even? + (lambda (x) + (letrec ((g7325 + (letrec ((x7326 (modulo x 2))) + (= 0 x7326)))) + g7325))) + (list->string + (lambda (l) + (letrec ((g7327 + (letrec ((x7329 (list? l))) + (assert x7329))) + (g7328 + (letrec ((x-cnd7330 (null? l))) + (if x-cnd7330 + "" + (letrec ((x7333 + (letrec ((x7334 + (car l))) + (char->string + x7334))) + (x7331 + (letrec ((x7332 + (cdr l))) + (list->string + x7332)))) + (string-append + x7333 + x7331)))))) + g7328))) + (char<=? + (lambda (c1 c2) + (letrec ((g7335 + (letrec ((x7338 (char? c1))) + (assert x7338))) + (g7336 + (letrec ((x7339 (char? c2))) + (assert x7339))) + (g7337 + (letrec ((val7143 (char=? c x7356)))) + (if x-cnd7355 + (letrec ((x7357 #\z)) + (char-ci<=? c x7357)) + #f)))) + g7354))) + (<= + (lambda (x y) + (letrec ((g7358 + (letrec ((x7360 (number? x))) + (assert x7360))) + (g7359 + (letrec ((val7144 (< x y))) + (letrec ((g7361 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7362 + (if val7145 + val7145 + #f))) + g7362))))) + g7361)))) + g7359))) + (char-whitespace? + (lambda (c) + (letrec ((g7363 + (letrec ((val7146 + (letrec ((x7364 + (char->integer + c))) + (= x7364 9)))) + (letrec ((g7365 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7366 + (char->integer + c))) + (= + x7366 + 10)))) + (letrec ((g7367 + (if val7147 + val7147 + (letrec ((x7368 + (char->integer + c))) + (= + x7368 + 32))))) + g7367))))) + g7365)))) + g7363))) + (cddar + (lambda (x) + (letrec ((g7369 + (letrec ((x7370 + (letrec ((x7371 (car x))) + (cdr x7371)))) + (cdr x7370)))) + g7369))) + (positive? + (lambda (x) + (letrec ((g7372 + (letrec ((x7374 (number? x))) + (assert x7374))) + (g7373 (> x 0))) + g7373))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7375 #f)) g7375))) + (cddr + (lambda (x) + (letrec ((g7376 + (letrec ((x7377 (cdr x))) + (cdr x7377)))) + g7376))) + (truncate + (lambda (x) + (letrec ((g7378 + (letrec ((x7380 (number? x))) + (assert x7380))) + (g7379 + (letrec ((x-cnd7381 (< x 0))) + (if x-cnd7381 + (ceiling x) + (floor x))))) + g7379))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7382 + (letrec ((val7148 (eq? a b))) + (letrec ((g7383 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7385 + (null? + a)) + (x7384 + (null? + b))) + (and x7385 + x7384)))) + (letrec ((g7386 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7389 + (string? + a)) + (x7388 + (string? + b)) + (x7387 + (string=? + a + b))) + (and x7389 + x7388 + x7387)))) + (letrec ((g7390 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7398 + (pair? + a)) + (x7397 + (pair? + b)) + (x7394 + (letrec ((x7396 + (car + a)) + (x7395 + (car + b))) + (equal? + x7396 + x7395))) + (x7391 + (letrec ((x7393 + (cdr + a)) + (x7392 + (cdr + b))) + (equal? + x7393 + x7392)))) + (and x7398 + x7397 + x7394 + x7391)))) + (letrec ((g7399 + (if val7151 + val7151 + (letrec ((x7418 + (vector? + a)) + (x7417 + (vector? + b)) + (x7400 + (letrec ((x7414 + (letrec ((x7415 + (letrec ((x7416 + (vector-length + a))) + (n + x7416)))) + (x7415))) + (x7401 + (letrec ((x7412 + (letrec ((x7413 + (vector-length + b))) + (= + x7413 + n))) + (x7402 + (letrec ((loop + (lambda (i) + (letrec ((g7403 + (letrec ((x7410 + (= + i + n)) + (x7404 + (letrec ((x7407 + (letrec ((x7409 + (vector-ref + a + i)) + (x7408 + (vector-ref + b + i))) + (equal? + x7409 + x7408))) + (x7405 + (letrec ((x7406 + (+ + i + 1))) + (loop + x7406)))) + (and x7407 + x7405)))) + (or x7410 + x7404)))) + g7403)))) + (letrec ((g7411 + (loop + 0))) + g7411)))) + (and x7412 + x7402)))) + (let x7414 x7401)))) + (and x7418 + x7417 + x7400))))) + g7399))))) + g7390))))) + g7386))))) + g7383)))) + g7382))) + (cdaaar + (lambda (x) + (letrec ((g7419 + (letrec ((x7420 + (letrec ((x7421 + (letrec ((x7422 + (car + x))) + (car + x7422)))) + (car x7421)))) + (cdr x7420)))) + g7419))) + (caaddr + (lambda (x) + (letrec ((g7423 + (letrec ((x7424 + (letrec ((x7425 + (letrec ((x7426 + (cdr + x))) + (cdr + x7426)))) + (car x7425)))) + (car x7424)))) + g7423))) + (eqv? + (lambda (x y) + (letrec ((g7427 (eq? x y))) g7427))) + (>= + (lambda (x y) + (letrec ((g7428 + (letrec ((x7430 (number? x))) + (assert x7430))) + (g7429 + (letrec ((val7152 (> x y))) + (letrec ((g7431 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7432 + (if val7153 + val7153 + #f))) + g7432))))) + g7431)))) + g7429))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7433 + (letrec ((x7436 + (string? filename))) + (assert x7436))) + (g7434 + (letrec ((x7437 (procedure? proc))) + (assert x7437))) + (g7435 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7438 + (close-input-port + input-port)) + (g7439 res)) + g7439)))) + g7435))) + (ref + (lambda (x) + (letrec ((g7440 (cons x '()))) g7440))) + (char>=? + (lambda (c1 c2) + (letrec ((g7441 + (letrec ((x7444 (char? c1))) + (assert x7444))) + (g7442 + (letrec ((x7445 (char? c2))) + (assert x7445))) + (g7443 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7446 + (if val7154 + val7154 + (char=? c1 c2)))) + g7446)))) + g7443))) + (cdaar + (lambda (x) + (letrec ((g7447 + (letrec ((x7448 + (letrec ((x7449 (car x))) + (car x7449)))) + (cdr x7448)))) + g7447))) + (cdaddr + (lambda (x) + (letrec ((g7450 + (letrec ((x7451 + (letrec ((x7452 + (letrec ((x7453 + (cdr + x))) + (cdr + x7453)))) + (car x7452)))) + (cdr x7451)))) + g7450))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7454 + (letrec ((x7455 + (letrec ((x7456 (car x))) + (cdr x7456)))) + (car x7455)))) + g7454))) + (caadr + (lambda (x) + (letrec ((g7457 + (letrec ((x7458 + (letrec ((x7459 (cdr x))) + (car x7459)))) + (car x7458)))) + g7457))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7460 + (letrec ((x7463 (char? c1))) + (assert x7463))) + (g7461 + (letrec ((x7464 (char? c2))) + (assert x7464))) + (g7462 + (letrec ((x7465 + (char-ci<=? c1 c2))) + (not x7465)))) + g7462))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7466 + (letrec ((x7467 + (letrec ((x7468 + (letrec ((x7469 + (car + x))) + (car + x7469)))) + (car x7468)))) + (car x7467)))) + g7466))) + (negative? + (lambda (x) + (letrec ((g7470 + (letrec ((x7472 (number? x))) + (assert x7472))) + (g7471 (< x 0))) + g7471))) + (memv + (lambda (e l) + (letrec ((g7473 (memq e l))) g7473))) + (caaar + (lambda (x) + (letrec ((g7474 + (letrec ((x7475 + (letrec ((x7476 (car x))) + (car x7476)))) + (car x7475)))) + g7474))) + (debug + (lambda (e) (letrec ((g7477 '())) g7477))) + (reverse + (lambda (l) + (letrec ((g7478 + (letrec ((x7480 (list? l))) + (assert x7480))) + (g7479 + (letrec ((x-cnd7481 (null? l))) + (if x-cnd7481 + '() + (letrec ((x7484 + (letrec ((x7485 + (cdr l))) + (reverse x7485))) + (x7482 + (letrec ((x7483 + (car l))) + (list x7483)))) + (append x7484 x7482)))))) + g7479))) + (caaadr + (lambda (x) + (letrec ((g7486 + (letrec ((x7487 + (letrec ((x7488 + (letrec ((x7489 + (cdr + x))) + (car + x7489)))) + (car x7488)))) + (car x7487)))) + g7486))) + (cddadr + (lambda (x) + (letrec ((g7490 + (letrec ((x7491 + (letrec ((x7492 + (letrec ((x7493 + (cdr + x))) + (car + x7493)))) + (cdr x7492)))) + (cdr x7491)))) + g7490))) + (odd? + (lambda (x) + (letrec ((g7494 + (letrec ((x7496 (number? x))) + (assert x7496))) + (g7495 + (letrec ((x7497 (modulo x 2))) + (= 1 x7497)))) + g7495))) + (caadar + (lambda (x) + (letrec ((g7498 + (letrec ((x7499 + (letrec ((x7500 + (letrec ((x7501 + (car + x))) + (cdr + x7501)))) + (car x7500)))) + (car x7499)))) + g7498))) + (apply + (lambda (proc args) + (letrec ((g7502 + (letrec ((x7505 (procedure? proc))) + (assert x7505))) + (g7503 + (letrec ((x7506 (list? args))) + (assert x7506))) + (g7504 + (if cnd + (letrec ((g7507 (proc))) g7507) + (if cnd + (letrec ((g7508 + (letrec ((x7509 + (car + args))) + (proc x7509)))) + g7508) + (if cnd + (letrec ((g7510 + (letrec ((x7512 + (car + args)) + (x7511 + (cadr + args))) + (proc + x7512 + x7511)))) + g7510) + (if cnd + (letrec ((g7513 + (letrec ((x7516 + (car + args)) + (x7515 + (cadr + args)) + (x7514 + (caddr + args))) + (proc + x7516 + x7515 + x7514)))) + g7513) + (if cnd + (letrec ((g7517 + (letrec ((x7521 + (car + args)) + (x7520 + (cadr + args)) + (x7519 + (caddr + args)) + (x7518 + (cadddr + args))) + (proc + x7521 + x7520 + x7519 + x7518)))) + g7517) + (if cnd + (letrec ((g7522 + (letrec ((x7528 + (car + args)) + (x7527 + (cadr + args)) + (x7526 + (caddr + args)) + (x7525 + (cadddr + args)) + (x7523 + (letrec ((x7524 + (cddddr + args))) + (car + x7524)))) + (proc + x7528 + x7527 + x7526 + x7525 + x7523)))) + g7522) + (if cnd + (letrec ((g7529 + (letrec ((x7537 + (car + args)) + (x7536 + (cadr + args)) + (x7535 + (caddr + args)) + (x7534 + (cadddr + args)) + (x7532 + (letrec ((x7533 + (cddddr + args))) + (car + x7533))) + (x7530 + (letrec ((x7531 + (cddddr + args))) + (cadr + x7531)))) + (proc + x7537 + x7536 + x7535 + x7534 + x7532 + x7530)))) + g7529) + (if cnd + (letrec ((g7538 + (letrec ((x7548 + (car + args)) + (x7547 + (cadr + args)) + (x7546 + (caddr + args)) + (x7545 + (cadddr + args)) + (x7543 + (letrec ((x7544 + (cddddr + args))) + (car + x7544))) + (x7541 + (letrec ((x7542 + (cddddr + args))) + (cadr + x7542))) + (x7539 + (letrec ((x7540 + (cddddr + args))) + (caddr + x7540)))) + (proc + x7548 + x7547 + x7546 + x7545 + x7543 + x7541 + x7539)))) + g7538) + (letrec ((g7549 + (error + "Unsupported call."))) + g7549))))))))))) + g7504))) + (member + (lambda (e l) + (letrec ((g7550 + (letrec ((x7552 (list? l))) + (assert x7552))) + (g7551 + (letrec ((x-cnd7553 (null? l))) + (if x-cnd7553 + #f + (letrec ((x-cnd7554 + (letrec ((x7555 + (car l))) + (equal? x7555 e)))) + (if x-cnd7554 + l + (letrec ((x7556 (cdr l))) + (member e x7556)))))))) + g7551))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g7557 + (letrec ((x7558 + (letrec ((x7559 + (letrec ((x7560 + (cdr + x))) + (cdr + x7560)))) + (cdr x7559)))) + (cdr x7558)))) + g7557))) + (cadddr + (lambda (x) + (letrec ((g7561 + (letrec ((x7562 + (letrec ((x7563 + (letrec ((x7564 + (cdr + x))) + (cdr + x7564)))) + (cdr x7563)))) + (car x7562)))) + g7561))) + (int-top + (lambda () + (letrec ((g7565 (random 42))) g7565))) + (zero? + (lambda (x) + (letrec ((g7566 + (letrec ((x7568 (number? x))) + (assert x7568))) + (g7567 (= x 0))) + g7567))) + (string>=? + (lambda (s1 s2) + (letrec ((g7569 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g7570 + (if val7155 + val7155 + (string=? s1 s2)))) + g7570)))) + g7569))) + (cadr + (lambda (x) + (letrec ((g7571 + (letrec ((x7572 (cdr x))) + (car x7572)))) + g7571))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g7573 + (letrec ((val7156 + (letrec ((x7576 + (pair? l)) + (x7574 + (letrec ((x7575 + (cdr + l))) + (list? + x7575)))) + (and x7576 x7574)))) + (letrec ((g7577 + (if val7156 + val7156 + (null? l)))) + g7577)))) + g7573))) + (cddaar + (lambda (x) + (letrec ((g7578 + (letrec ((x7579 + (letrec ((x7580 + (letrec ((x7581 + (car + x))) + (car + x7581)))) + (cdr x7580)))) + (cdr x7579)))) + g7578))) + (char-numeric? + (lambda (c) + (letrec ((g7582 + (letrec ((x-cnd7583 + (letrec ((x7584 #\0)) + (char<=? x7584 c)))) + (if x-cnd7583 + (letrec ((x7585 #\9)) + (char<=? c x7585)) + #f)))) + g7582))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g7586 + (letrec ((x7588 (list? l))) + (assert x7588))) + (g7587 + (letrec ((x-cnd7589 (null? l))) + (if x-cnd7589 + #f + (letrec ((x-cnd7590 + (letrec ((x7591 + (caar l))) + (eqv? x7591 k)))) + (if x-cnd7590 + (car l) + (letrec ((x7592 (cdr l))) + (assq k x7592)))))))) + g7587))) + (not + (lambda (x) + (letrec ((g7593 (if x #f #t))) g7593))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g7594 (append l1 l2))) g7594))) + (memq + (lambda (e l) + (letrec ((g7595 + (letrec ((x7597 (list? l))) + (assert x7597))) + (g7596 + (letrec ((x-cnd7598 (null? l))) + (if x-cnd7598 + #f + (letrec ((x-cnd7599 + (letrec ((x7600 + (car l))) + (eq? x7600 e)))) + (if x-cnd7599 + l + (letrec ((x7601 (cdr l))) + (memq e x7601)))))))) + g7596))) + (cadaar + (lambda (x) + (letrec ((g7602 + (letrec ((x7603 + (letrec ((x7604 + (letrec ((x7605 + (car + x))) + (car + x7605)))) + (cdr x7604)))) + (car x7603)))) + g7602))) + (length + (lambda (l) + (letrec ((g7606 + (letrec ((x7608 (list? l))) + (assert x7608))) + (g7607 + (letrec ((rec + (lambda (l) + (letrec ((g7609 + (letrec ((x-cnd7610 + (null? + l))) + (if x-cnd7610 + 0 + (letrec ((x7611 + (letrec ((x7612 + (cdr + l))) + (rec + x7612)))) + (+ + 1 + x7611)))))) + g7609)))) + (letrec ((g7613 (rec l))) + g7613)))) + g7607))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g7614 + (letrec ((x7617 (char? c1))) + (assert x7617))) + (g7615 + (letrec ((x7618 (char? c2))) + (assert x7618))) + (g7616 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g7620 + (letrec ((x7621 (string<=? s1 s2))) + (not x7621)))) + g7620))) + (cdadr + (lambda (x) + (letrec ((g7622 + (letrec ((x7623 + (letrec ((x7624 (cdr x))) + (car x7624)))) + (cdr x7623)))) + g7622))) + (assoc + (lambda (k l) + (letrec ((g7625 + (letrec ((x7627 (list? l))) + (assert x7627))) + (g7626 + (letrec ((x-cnd7628 (null? l))) + (if x-cnd7628 + #f + (letrec ((x-cnd7629 + (letrec ((x7630 + (caar l))) + (equal? x7630 k)))) + (if x-cnd7629 + (car l) + (letrec ((x7631 (cdr l))) + (assoc k x7631)))))))) + g7626))) + (caar + (lambda (x) + (letrec ((g7632 + (letrec ((x7633 (car x))) + (car x7633)))) + g7632))) + (char>? + (lambda (c1 c2) + (letrec ((g7634 + (letrec ((x7637 (char? c1))) + (assert x7637))) + (g7635 + (letrec ((x7638 (char? c2))) + (assert x7638))) + (g7636 + (letrec ((x7639 (char<=? c1 c2))) + (not x7639)))) + g7636))) + (string<=? + (lambda (s1 s2) + (letrec ((g7640 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g7657 + (letrec ((x7660 (char? c1))) + (assert x7660))) + (g7658 + (letrec ((x7661 (char? c2))) + (assert x7661))) + (g7659 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g7662 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g7662)))) + g7659))) + (caddar + (lambda (x) + (letrec ((g7663 + (letrec ((x7664 + (letrec ((x7665 + (letrec ((x7666 + (car + x))) + (cdr + x7666)))) + (cdr x7665)))) + (car x7664)))) + g7663))) + (newline + (lambda () (letrec ((g7667 #f)) g7667))) + (lcm + (lambda (m n) + (letrec ((g7668 + (letrec ((x7670 + (letrec ((x7671 (* m n))) + (abs x7671))) + (x7669 (gcd m n))) + (/ x7670 x7669)))) + g7668))) + (deref car) + (> + (lambda (x y) + (letrec ((g7672 + (letrec ((x7674 (number? x))) + (assert x7674))) + (g7673 + (letrec ((x7675 (<= x y))) + (not x7675)))) + g7673))) + (list-ref + (lambda (l index) + (letrec ((g7676 + (letrec ((x7680 (list? l))) + (assert x7680))) + (g7677 + (letrec ((x7681 (number? index))) + (assert x7681))) + (g7678 + (letrec ((x7682 + (letrec ((x7683 + (length l))) + (< index x7683)))) + (assert x7682))) + (g7679 + (letrec ((x-cnd7684 (= index 0))) + (if x-cnd7684 + (car l) + (letrec ((x7686 (cdr l)) + (x7685 (- index 1))) + (list-ref x7686 x7685)))))) + g7679))) + (gcd + (lambda (a b) + (letrec ((g7687 + (letrec ((x-cnd7688 (= b 0))) + (if x-cnd7688 + a + (letrec ((x7689 (modulo a b))) + (gcd b x7689)))))) + g7687))) + (real/c + (lambda (g7160 g7161 g7162) + (letrec ((g7690 + (letrec ((x-cnd7691 (real? g7162))) + (if x-cnd7691 + g7162 + (blame g7160 'real?))))) + g7690))) + (boolean?/c + (lambda (g7163 g7164 g7165) + (letrec ((g7692 + (letrec ((x-cnd7693 + (boolean? g7165))) + (if x-cnd7693 + g7165 + (blame g7163 'boolean?))))) + g7692))) + (number?/c + (lambda (g7166 g7167 g7168) + (letrec ((g7694 + (letrec ((x-cnd7695 + (number? g7168))) + (if x-cnd7695 + g7168 + (blame g7166 'number?))))) + g7694))) + (any/c + (lambda (g7169 g7170 g7171) + (letrec ((g7696 + (letrec ((x-cnd7697 + ((lambda (v) #t) g7171))) + (if x-cnd7697 + g7171 + (blame + g7169 + '(lambda (v) #t)))))) + g7696))) + (any?/c + (lambda (g7172 g7173 g7174) + (letrec ((g7698 + (letrec ((x-cnd7699 + ((lambda (v) #t) g7174))) + (if x-cnd7699 + g7174 + (blame + g7172 + '(lambda (v) #t)))))) + g7698))) + (image? any/c) + (cons?/c + (lambda (g7175 g7176 g7177) + (letrec ((g7700 + (letrec ((x-cnd7701 (pair? g7177))) + (if x-cnd7701 + g7177 + (blame g7175 'pair?))))) + g7700))) + (pair?/c + (lambda (g7178 g7179 g7180) + (letrec ((g7702 + (letrec ((x-cnd7703 (pair? g7180))) + (if x-cnd7703 + g7180 + (blame g7178 'pair?))))) + g7702))) + (integer? + (lambda (g7181 g7182 g7183) + (letrec ((g7704 + (letrec ((x-cnd7705 + (integer? g7183))) + (if x-cnd7705 + g7183 + (blame g7181 'integer?))))) + g7704))) + (and/c + (lambda (c1 c2) + (letrec ((g7706 + (lambda (k j v) + (letrec ((g7707 + (letrec ((x-cnd7708 + (c1 k j v))) + (if x-cnd7708 + (c2 k j v) + #f)))) + g7707)))) + g7706))) + (list-of + (lambda (contract) + (letrec ((g7709 + (lambda (k j v) + (letrec ((g7710 + (letrec ((x-cnd7711 + (null? v))) + (if x-cnd7711 + '() + (letrec ((x7715 + (letrec ((x7716 + (car + v))) + (contract + k + j + x7716))) + (x7712 + (letrec ((x7714 + (list-of + contract)) + (x7713 + (cdr + v))) + (x7714 + k + j + x7713)))) + (cons + x7715 + x7712)))))) + g7710)))) + g7709))) + (any? (lambda (v) (letrec ((g7717 #t)) g7717))) + (nonzero? + (lambda (v) + (letrec ((g7718 + (letrec ((x7719 (= v 0))) + (not x7719)))) + g7718))) + (nonzero?/c + (lambda (g7184 g7185 g7186) + (letrec ((g7720 + (letrec ((x-cnd7721 + ((lambda (v) + (not (= v 0))) + g7186))) + (if x-cnd7721 + g7186 + (blame + g7184 + '(lambda (v) + (not (= v 0)))))))) + g7720))) + (meta (lambda (v) (letrec ((g7722 v)) g7722))) + (orig-+ +) + (+ + ((lambda (j7189 k7190 f7191) + (lambda (g7187 g7188) + (number?/c + j7189 + k7190 + (f7191 + (number?/c j7189 k7190 g7187) + (number?/c j7189 k7190 g7188))))) + 'server + 'client + (lambda (a b) (orig-+ a b)))) + (orig-- -) + (- + ((lambda (j7194 k7195 f7196) + (lambda (g7192 g7193) + (number?/c + j7194 + k7195 + (f7196 + (number?/c j7194 k7195 g7192) + (number?/c j7194 k7195 g7193))))) + 'server + 'client + (lambda (a b) (orig-- a b)))) + (orig-* *) + (* + ((lambda (j7199 k7200 f7201) + (lambda (g7197 g7198) + (number?/c + j7199 + k7200 + (f7201 + (number?/c j7199 k7200 g7197) + (number?/c j7199 k7200 g7198))))) + 'server + 'client + (lambda (a b) (orig-* a b)))) + (orig-/ /) + (/ + ((lambda (j7204 k7205 f7206) + (lambda (g7202 g7203) + (number?/c + j7204 + k7205 + (f7206 + (number?/c j7204 k7205 g7202) + (number?/c j7204 k7205 g7203))))) + 'server + 'client + (lambda (a b) (orig-/ a b)))) + (orig-car car) + (car + ((lambda (j7208 k7209 f7210) + (lambda (g7207) + (any/c + j7208 + k7209 + (f7210 (pair?/c j7208 k7209 g7207))))) + 'server + 'client + (lambda (p) (orig-car p)))) + (orig-cdr cdr) + (cdr + ((lambda (j7212 k7213 f7214) + (lambda (g7211) + (any/c + j7212 + k7213 + (f7214 (pair?/c j7212 k7213 g7211))))) + 'server + 'client + (lambda (p) (orig-cdr p)))) + (orig-cons cons) + (cons + ((lambda (j7217 k7218 f7219) + (lambda (g7215 g7216) + (pair?/c + j7217 + k7218 + (f7219 + (any/c j7217 k7218 g7215) + (any/c j7217 k7218 g7216))))) + 'server + 'client + (lambda (a b) (cons a b)))) + (orig-vector-ref vector-ref) + (vector-ref + ((lambda (j7221 k7222 f7223) + (lambda (g7220) + (integer?/c + j7221 + k7222 + (f7223 (vector?/c j7221 k7222 g7220))))) + 'server + 'client + (lambda (v i) (orig-vector-ref v i)))) + (orig-vector-set vector-set!) + (vector-set! + ((lambda (j7226 k7227 f7228) + (lambda (g7224 g7225) + (any/c + j7226 + k7227 + (f7228 + (vector?/c j7226 k7227 g7224) + (integer?/c j7226 k7227 g7225))))) + 'server + 'client + (lambda (vec i v) + (orig-vector-set! vec i v)))) + (assert + (lambda (cnd) (letrec ((g7723 #t)) g7723))) + (cdddr + (lambda (x) + (letrec ((g7724 + (letrec ((x7725 + (letrec ((x7726 (cdr x))) + (cdr x7726)))) + (cdr x7725)))) + g7724))) + (__toplevel_set-car! set-car!) + (map + (lambda (f l) + (letrec ((g7727 + (letrec ((x7730 (procedure? f))) + (assert x7730))) + (g7728 + (letrec ((x7731 (list? l))) + (assert x7731))) + (g7729 + (letrec ((x-cnd7732 (null? l))) + (if x-cnd7732 + '() + (letrec ((x7735 + (letrec ((x7736 + (car l))) + (f x7736))) + (x7733 + (letrec ((x7734 + (cdr l))) + (map f x7734)))) + (cons x7735 x7733)))))) + g7729))) + (cdar + (lambda (x) + (letrec ((g7737 + (letrec ((x7738 (car x))) + (cdr x7738)))) + g7737))) + (cadadr + (lambda (x) + (letrec ((g7739 + (letrec ((x7740 + (letrec ((x7741 + (letrec ((x7742 + (cdr + x))) + (car + x7742)))) + (cdr x7741)))) + (car x7740)))) + g7739))) + (cdadar + (lambda (x) + (letrec ((g7743 + (letrec ((x7744 + (letrec ((x7745 + (letrec ((x7746 + (car + x))) + (cdr + x7746)))) + (car x7745)))) + (cdr x7744)))) + g7743))) + (call-with-output-file + (lambda (filename proc) + (letrec ((g7747 + (letrec ((x7750 + (string? filename))) + (assert x7750))) + (g7748 + (letrec ((x7751 (procedure? proc))) + (assert x7751))) + (g7749 + (letrec ((output-port + (open-output-file + filename)) + (res (proc output-port))) + (letrec ((g7752 + (close-output-port + output-port)) + (g7753 res)) + g7753)))) + g7749))) + (caddr + (lambda (x) + (letrec ((g7754 + (letrec ((x7755 + (letrec ((x7756 (cdr x))) + (cdr x7756)))) + (car x7755)))) + g7754))) + (cdaadr + (lambda (x) + (letrec ((g7757 + (letrec ((x7758 + (letrec ((x7759 + (letrec ((x7760 + (cdr + x))) + (car + x7760)))) + (car x7759)))) + (cdr x7758)))) + g7757))) + (assq + (lambda (k l) + (letrec ((g7761 + (letrec ((x7763 (list? l))) + (assert x7763))) + (g7762 + (letrec ((x-cnd7764 (null? l))) + (if x-cnd7764 + #f + (letrec ((x-cnd7765 + (letrec ((x7766 + (caar l))) + (eq? x7766 k)))) + (if x-cnd7765 + (car l) + (letrec ((x7767 (cdr l))) + (assq k x7767)))))))) + g7762))) + (even? + (lambda (x) + (letrec ((g7768 + (letrec ((x7769 (modulo x 2))) + (= 0 x7769)))) + g7768))) + (list->string + (lambda (l) + (letrec ((g7770 + (letrec ((x7772 (list? l))) + (assert x7772))) + (g7771 + (letrec ((x-cnd7773 (null? l))) + (if x-cnd7773 + "" + (letrec ((x7776 + (letrec ((x7777 + (car l))) + (char->string + x7777))) + (x7774 + (letrec ((x7775 + (cdr l))) + (list->string + x7775)))) + (string-append + x7776 + x7774)))))) + g7771))) + (char<=? + (lambda (c1 c2) + (letrec ((g7778 + (letrec ((x7781 (char? c1))) + (assert x7781))) + (g7779 + (letrec ((x7782 (char? c2))) + (assert x7782))) + (g7780 + (letrec ((val7143 (char=? c x7799)))) + (if x-cnd7798 + (letrec ((x7800 #\z)) + (char-ci<=? c x7800)) + #f)))) + g7797))) + (<= + (lambda (x y) + (letrec ((g7801 + (letrec ((x7803 (number? x))) + (assert x7803))) + (g7802 + (letrec ((val7144 (< x y))) + (letrec ((g7804 + (if val7144 + val7144 + (letrec ((val7145 + (= x y))) + (letrec ((g7805 + (if val7145 + val7145 + #f))) + g7805))))) + g7804)))) + g7802))) + (char-whitespace? + (lambda (c) + (letrec ((g7806 + (letrec ((val7146 + (letrec ((x7807 + (char->integer + c))) + (= x7807 9)))) + (letrec ((g7808 + (if val7146 + val7146 + (letrec ((val7147 + (letrec ((x7809 + (char->integer + c))) + (= + x7809 + 10)))) + (letrec ((g7810 + (if val7147 + val7147 + (letrec ((x7811 + (char->integer + c))) + (= + x7811 + 32))))) + g7810))))) + g7808)))) + g7806))) + (cddar + (lambda (x) + (letrec ((g7812 + (letrec ((x7813 + (letrec ((x7814 (car x))) + (cdr x7814)))) + (cdr x7813)))) + g7812))) + (positive? + (lambda (x) + (letrec ((g7815 + (letrec ((x7817 (number? x))) + (assert x7817))) + (g7816 (> x 0))) + g7816))) + ($pc '()) + (ref-set set-car!) + (void (lambda () (letrec ((g7818 #f)) g7818))) + (cddr + (lambda (x) + (letrec ((g7819 + (letrec ((x7820 (cdr x))) + (cdr x7820)))) + g7819))) + (truncate + (lambda (x) + (letrec ((g7821 + (letrec ((x7823 (number? x))) + (assert x7823))) + (g7822 + (letrec ((x-cnd7824 (< x 0))) + (if x-cnd7824 + (ceiling x) + (floor x))))) + g7822))) + ($cmp '()) + (equal? + (lambda (a b) + (letrec ((g7825 + (letrec ((val7148 (eq? a b))) + (letrec ((g7826 + (if val7148 + val7148 + (letrec ((val7149 + (letrec ((x7828 + (null? + a)) + (x7827 + (null? + b))) + (and x7828 + x7827)))) + (letrec ((g7829 + (if val7149 + val7149 + (letrec ((val7150 + (letrec ((x7832 + (string? + a)) + (x7831 + (string? + b)) + (x7830 + (string=? + a + b))) + (and x7832 + x7831 + x7830)))) + (letrec ((g7833 + (if val7150 + val7150 + (letrec ((val7151 + (letrec ((x7841 + (pair? + a)) + (x7840 + (pair? + b)) + (x7837 + (letrec ((x7839 + (car + a)) + (x7838 + (car + b))) + (equal? + x7839 + x7838))) + (x7834 + (letrec ((x7836 + (cdr + a)) + (x7835 + (cdr + b))) + (equal? + x7836 + x7835)))) + (and x7841 + x7840 + x7837 + x7834)))) + (letrec ((g7842 + (if val7151 + val7151 + (letrec ((x7861 + (vector? + a)) + (x7860 + (vector? + b)) + (x7843 + (letrec ((x7857 + (letrec ((x7858 + (letrec ((x7859 + (vector-length + a))) + (n + x7859)))) + (x7858))) + (x7844 + (letrec ((x7855 + (letrec ((x7856 + (vector-length + b))) + (= + x7856 + n))) + (x7845 + (letrec ((loop + (lambda (i) + (letrec ((g7846 + (letrec ((x7853 + (= + i + n)) + (x7847 + (letrec ((x7850 + (letrec ((x7852 + (vector-ref + a + i)) + (x7851 + (vector-ref + b + i))) + (equal? + x7852 + x7851))) + (x7848 + (letrec ((x7849 + (+ + i + 1))) + (loop + x7849)))) + (and x7850 + x7848)))) + (or x7853 + x7847)))) + g7846)))) + (letrec ((g7854 + (loop + 0))) + g7854)))) + (and x7855 + x7845)))) + (let x7857 x7844)))) + (and x7861 + x7860 + x7843))))) + g7842))))) + g7833))))) + g7829))))) + g7826)))) + g7825))) + (cdaaar + (lambda (x) + (letrec ((g7862 + (letrec ((x7863 + (letrec ((x7864 + (letrec ((x7865 + (car + x))) + (car + x7865)))) + (car x7864)))) + (cdr x7863)))) + g7862))) + (caaddr + (lambda (x) + (letrec ((g7866 + (letrec ((x7867 + (letrec ((x7868 + (letrec ((x7869 + (cdr + x))) + (cdr + x7869)))) + (car x7868)))) + (car x7867)))) + g7866))) + (eqv? + (lambda (x y) + (letrec ((g7870 (eq? x y))) g7870))) + (>= + (lambda (x y) + (letrec ((g7871 + (letrec ((x7873 (number? x))) + (assert x7873))) + (g7872 + (letrec ((val7152 (> x y))) + (letrec ((g7874 + (if val7152 + val7152 + (letrec ((val7153 + (= x y))) + (letrec ((g7875 + (if val7153 + val7153 + #f))) + g7875))))) + g7874)))) + g7872))) + (call-with-input-file + (lambda (filename proc) + (letrec ((g7876 + (letrec ((x7879 + (string? filename))) + (assert x7879))) + (g7877 + (letrec ((x7880 (procedure? proc))) + (assert x7880))) + (g7878 + (letrec ((input-port + (open-input-file + filename)) + (res (proc input-port))) + (letrec ((g7881 + (close-input-port + input-port)) + (g7882 res)) + g7882)))) + g7878))) + (ref + (lambda (x) + (letrec ((g7883 (cons x '()))) g7883))) + (char>=? + (lambda (c1 c2) + (letrec ((g7884 + (letrec ((x7887 (char? c1))) + (assert x7887))) + (g7885 + (letrec ((x7888 (char? c2))) + (assert x7888))) + (g7886 + (letrec ((val7154 (char>? c1 c2))) + (letrec ((g7889 + (if val7154 + val7154 + (char=? c1 c2)))) + g7889)))) + g7886))) + (cdaar + (lambda (x) + (letrec ((g7890 + (letrec ((x7891 + (letrec ((x7892 (car x))) + (car x7892)))) + (cdr x7891)))) + g7890))) + (cdaddr + (lambda (x) + (letrec ((g7893 + (letrec ((x7894 + (letrec ((x7895 + (letrec ((x7896 + (cdr + x))) + (cdr + x7896)))) + (car x7895)))) + (cdr x7894)))) + g7893))) + (__toplevel_cdr cdr) + (cadar + (lambda (x) + (letrec ((g7897 + (letrec ((x7898 + (letrec ((x7899 (car x))) + (cdr x7899)))) + (car x7898)))) + g7897))) + (caadr + (lambda (x) + (letrec ((g7900 + (letrec ((x7901 + (letrec ((x7902 (cdr x))) + (car x7902)))) + (car x7901)))) + g7900))) + (char-ci>? + (lambda (c1 c2) + (letrec ((g7903 + (letrec ((x7906 (char? c1))) + (assert x7906))) + (g7904 + (letrec ((x7907 (char? c2))) + (assert x7907))) + (g7905 + (letrec ((x7908 + (char-ci<=? c1 c2))) + (not x7908)))) + g7905))) + (__toplevel_set-cdr! set-cdr!) + (caaaar + (lambda (x) + (letrec ((g7909 + (letrec ((x7910 + (letrec ((x7911 + (letrec ((x7912 + (car + x))) + (car + x7912)))) + (car x7911)))) + (car x7910)))) + g7909))) + (negative? + (lambda (x) + (letrec ((g7913 + (letrec ((x7915 (number? x))) + (assert x7915))) + (g7914 (< x 0))) + g7914))) + (memv + (lambda (e l) + (letrec ((g7916 (memq e l))) g7916))) + (caaar + (lambda (x) + (letrec ((g7917 + (letrec ((x7918 + (letrec ((x7919 (car x))) + (car x7919)))) + (car x7918)))) + g7917))) + (debug + (lambda (e) (letrec ((g7920 '())) g7920))) + (reverse + (lambda (l) + (letrec ((g7921 + (letrec ((x7923 (list? l))) + (assert x7923))) + (g7922 + (letrec ((x-cnd7924 (null? l))) + (if x-cnd7924 + '() + (letrec ((x7927 + (letrec ((x7928 + (cdr l))) + (reverse x7928))) + (x7925 + (letrec ((x7926 + (car l))) + (list x7926)))) + (append x7927 x7925)))))) + g7922))) + (caaadr + (lambda (x) + (letrec ((g7929 + (letrec ((x7930 + (letrec ((x7931 + (letrec ((x7932 + (cdr + x))) + (car + x7932)))) + (car x7931)))) + (car x7930)))) + g7929))) + (cddadr + (lambda (x) + (letrec ((g7933 + (letrec ((x7934 + (letrec ((x7935 + (letrec ((x7936 + (cdr + x))) + (car + x7936)))) + (cdr x7935)))) + (cdr x7934)))) + g7933))) + (odd? + (lambda (x) + (letrec ((g7937 + (letrec ((x7939 (number? x))) + (assert x7939))) + (g7938 + (letrec ((x7940 (modulo x 2))) + (= 1 x7940)))) + g7938))) + (caadar + (lambda (x) + (letrec ((g7941 + (letrec ((x7942 + (letrec ((x7943 + (letrec ((x7944 + (car + x))) + (cdr + x7944)))) + (car x7943)))) + (car x7942)))) + g7941))) + (apply + (lambda (proc args) + (letrec ((g7945 + (letrec ((x7948 (procedure? proc))) + (assert x7948))) + (g7946 + (letrec ((x7949 (list? args))) + (assert x7949))) + (g7947 + (if cnd + (letrec ((g7950 (proc))) g7950) + (if cnd + (letrec ((g7951 + (letrec ((x7952 + (car + args))) + (proc x7952)))) + g7951) + (if cnd + (letrec ((g7953 + (letrec ((x7955 + (car + args)) + (x7954 + (cadr + args))) + (proc + x7955 + x7954)))) + g7953) + (if cnd + (letrec ((g7956 + (letrec ((x7959 + (car + args)) + (x7958 + (cadr + args)) + (x7957 + (caddr + args))) + (proc + x7959 + x7958 + x7957)))) + g7956) + (if cnd + (letrec ((g7960 + (letrec ((x7964 + (car + args)) + (x7963 + (cadr + args)) + (x7962 + (caddr + args)) + (x7961 + (cadddr + args))) + (proc + x7964 + x7963 + x7962 + x7961)))) + g7960) + (if cnd + (letrec ((g7965 + (letrec ((x7971 + (car + args)) + (x7970 + (cadr + args)) + (x7969 + (caddr + args)) + (x7968 + (cadddr + args)) + (x7966 + (letrec ((x7967 + (cddddr + args))) + (car + x7967)))) + (proc + x7971 + x7970 + x7969 + x7968 + x7966)))) + g7965) + (if cnd + (letrec ((g7972 + (letrec ((x7980 + (car + args)) + (x7979 + (cadr + args)) + (x7978 + (caddr + args)) + (x7977 + (cadddr + args)) + (x7975 + (letrec ((x7976 + (cddddr + args))) + (car + x7976))) + (x7973 + (letrec ((x7974 + (cddddr + args))) + (cadr + x7974)))) + (proc + x7980 + x7979 + x7978 + x7977 + x7975 + x7973)))) + g7972) + (if cnd + (letrec ((g7981 + (letrec ((x7991 + (car + args)) + (x7990 + (cadr + args)) + (x7989 + (caddr + args)) + (x7988 + (cadddr + args)) + (x7986 + (letrec ((x7987 + (cddddr + args))) + (car + x7987))) + (x7984 + (letrec ((x7985 + (cddddr + args))) + (cadr + x7985))) + (x7982 + (letrec ((x7983 + (cddddr + args))) + (caddr + x7983)))) + (proc + x7991 + x7990 + x7989 + x7988 + x7986 + x7984 + x7982)))) + g7981) + (letrec ((g7992 + (error + "Unsupported call."))) + g7992))))))))))) + g7947))) + (member + (lambda (e l) + (letrec ((g7993 + (letrec ((x7995 (list? l))) + (assert x7995))) + (g7994 + (letrec ((x-cnd7996 (null? l))) + (if x-cnd7996 + #f + (letrec ((x-cnd7997 + (letrec ((x7998 + (car l))) + (equal? x7998 e)))) + (if x-cnd7997 + l + (letrec ((x7999 (cdr l))) + (member e x7999)))))))) + g7994))) + (call-with-current-continuation call/cc) + (cddddr + (lambda (x) + (letrec ((g8000 + (letrec ((x8001 + (letrec ((x8002 + (letrec ((x8003 + (cdr + x))) + (cdr + x8003)))) + (cdr x8002)))) + (cdr x8001)))) + g8000))) + (cadddr + (lambda (x) + (letrec ((g8004 + (letrec ((x8005 + (letrec ((x8006 + (letrec ((x8007 + (cdr + x))) + (cdr + x8007)))) + (cdr x8006)))) + (car x8005)))) + g8004))) + (int-top + (lambda () + (letrec ((g8008 (random 42))) g8008))) + (zero? + (lambda (x) + (letrec ((g8009 + (letrec ((x8011 (number? x))) + (assert x8011))) + (g8010 (= x 0))) + g8010))) + (string>=? + (lambda (s1 s2) + (letrec ((g8012 + (letrec ((val7155 + (string>? s1 s2))) + (letrec ((g8013 + (if val7155 + val7155 + (string=? s1 s2)))) + g8013)))) + g8012))) + (cadr + (lambda (x) + (letrec ((g8014 + (letrec ((x8015 (cdr x))) + (car x8015)))) + g8014))) + (__toplevel_car car) + (list? + (lambda (l) + (letrec ((g8016 + (letrec ((val7156 + (letrec ((x8019 + (pair? l)) + (x8017 + (letrec ((x8018 + (cdr + l))) + (list? + x8018)))) + (and x8019 x8017)))) + (letrec ((g8020 + (if val7156 + val7156 + (null? l)))) + g8020)))) + g8016))) + (cddaar + (lambda (x) + (letrec ((g8021 + (letrec ((x8022 + (letrec ((x8023 + (letrec ((x8024 + (car + x))) + (car + x8024)))) + (cdr x8023)))) + (cdr x8022)))) + g8021))) + (char-numeric? + (lambda (c) + (letrec ((g8025 + (letrec ((x-cnd8026 + (letrec ((x8027 #\0)) + (char<=? x8027 c)))) + (if x-cnd8026 + (letrec ((x8028 #\9)) + (char<=? c x8028)) + #f)))) + g8025))) + (__toplevel_cons cons) + (assv + (lambda (k l) + (letrec ((g8029 + (letrec ((x8031 (list? l))) + (assert x8031))) + (g8030 + (letrec ((x-cnd8032 (null? l))) + (if x-cnd8032 + #f + (letrec ((x-cnd8033 + (letrec ((x8034 + (caar l))) + (eqv? x8034 k)))) + (if x-cnd8033 + (car l) + (letrec ((x8035 (cdr l))) + (assq k x8035)))))))) + g8030))) + (not + (lambda (x) + (letrec ((g8036 (if x #f #t))) g8036))) + (__toplevel_append + (lambda (l1 l2) + (letrec ((g8037 (append l1 l2))) g8037))) + (memq + (lambda (e l) + (letrec ((g8038 + (letrec ((x8040 (list? l))) + (assert x8040))) + (g8039 + (letrec ((x-cnd8041 (null? l))) + (if x-cnd8041 + #f + (letrec ((x-cnd8042 + (letrec ((x8043 + (car l))) + (eq? x8043 e)))) + (if x-cnd8042 + l + (letrec ((x8044 (cdr l))) + (memq e x8044)))))))) + g8039))) + (cadaar + (lambda (x) + (letrec ((g8045 + (letrec ((x8046 + (letrec ((x8047 + (letrec ((x8048 + (car + x))) + (car + x8048)))) + (cdr x8047)))) + (car x8046)))) + g8045))) + (length + (lambda (l) + (letrec ((g8049 + (letrec ((x8051 (list? l))) + (assert x8051))) + (g8050 + (letrec ((rec + (lambda (l) + (letrec ((g8052 + (letrec ((x-cnd8053 + (null? + l))) + (if x-cnd8053 + 0 + (letrec ((x8054 + (letrec ((x8055 + (cdr + l))) + (rec + x8055)))) + (+ + 1 + x8054)))))) + g8052)))) + (letrec ((g8056 (rec l))) + g8056)))) + g8050))) + (char-ci<=? + (lambda (c1 c2) + (letrec ((g8057 + (letrec ((x8060 (char? c1))) + (assert x8060))) + (g8058 + (letrec ((x8061 (char? c2))) + (assert x8061))) + (g8059 + (letrec ((val7157 + (char-ci? + (lambda (s1 s2) + (letrec ((g8063 + (letrec ((x8064 (string<=? s1 s2))) + (not x8064)))) + g8063))) + (cdadr + (lambda (x) + (letrec ((g8065 + (letrec ((x8066 + (letrec ((x8067 (cdr x))) + (car x8067)))) + (cdr x8066)))) + g8065))) + (assoc + (lambda (k l) + (letrec ((g8068 + (letrec ((x8070 (list? l))) + (assert x8070))) + (g8069 + (letrec ((x-cnd8071 (null? l))) + (if x-cnd8071 + #f + (letrec ((x-cnd8072 + (letrec ((x8073 + (caar l))) + (equal? x8073 k)))) + (if x-cnd8072 + (car l) + (letrec ((x8074 (cdr l))) + (assoc k x8074)))))))) + g8069))) + (caar + (lambda (x) + (letrec ((g8075 + (letrec ((x8076 (car x))) + (car x8076)))) + g8075))) + (char>? + (lambda (c1 c2) + (letrec ((g8077 + (letrec ((x8080 (char? c1))) + (assert x8080))) + (g8078 + (letrec ((x8081 (char? c2))) + (assert x8081))) + (g8079 + (letrec ((x8082 (char<=? c1 c2))) + (not x8082)))) + g8079))) + (string<=? + (lambda (s1 s2) + (letrec ((g8083 + (letrec ((val7158 + (string=? + (lambda (c1 c2) + (letrec ((g8100 + (letrec ((x8103 (char? c1))) + (assert x8103))) + (g8101 + (letrec ((x8104 (char? c2))) + (assert x8104))) + (g8102 + (letrec ((val7159 + (char-ci>? c1 c2))) + (letrec ((g8105 + (if val7159 + val7159 + (char-ci=? c1 c2)))) + g8105)))) + g8102))) + (caddar + (lambda (x) + (letrec ((g8106 + (letrec ((x8107 + (letrec ((x8108 + (letrec ((x8109 + (car + x))) + (cdr + x8109)))) + (cdr x8108)))) + (car x8107)))) + g8106))) + (newline + (lambda () (letrec ((g8110 #f)) g8110))) + (lcm + (lambda (m n) + (letrec ((g8111 + (letrec ((x8113 + (letrec ((x8114 (* m n))) + (abs x8114))) + (x8112 (gcd m n))) + (/ x8113 x8112)))) + g8111))) + (deref car) + (> + (lambda (x y) + (letrec ((g8115 + (letrec ((x8117 (number? x))) + (assert x8117))) + (g8116 + (letrec ((x8118 (<= x y))) + (not x8118)))) + g8116))) + (list-ref + (lambda (l index) + (letrec ((g8119 + (letrec ((x8123 (list? l))) + (assert x8123))) + (g8120 + (letrec ((x8124 (number? index))) + (assert x8124))) + (g8121 + (letrec ((x8125 + (letrec ((x8126 + (length l))) + (< index x8126)))) + (assert x8125))) + (g8122 + (letrec ((x-cnd8127 (= index 0))) + (if x-cnd8127 + (car l) + (letrec ((x8129 (cdr l)) + (x8128 (- index 1))) + (list-ref x8129 x8128)))))) + g8122))) + (gcd + (lambda (a b) + (letrec ((g8130 + (letrec ((x-cnd8131 (= b 0))) + (if x-cnd8131 + a + (letrec ((x8132 (modulo a b))) + (gcd b x8132)))))) + g8130)))) + (letrec ((g8133 + (letrec ((g8134 + (letrec ((tak + (lambda (x y z) + (letrec ((g8135 + (letrec ((x-cnd8136 + (< + y + x))) + (if x-cnd8136 + (letrec ((x8141 + (letrec ((x8142 + (- + x + 1))) + (tak + x8142 + y + z))) + (x8139 + (letrec ((x8140 + (- + y + 1))) + (tak + x8140 + z + x))) + (x8137 + (letrec ((x8138 + (- + z + 1))) + (tak + x8138 + x + y)))) + (tak + x8141 + x8139 + x8137)) + z)))) + g8135)))) + (letrec ((g8143 + (letrec ((g8144 + (letrec ((g8145 + (letrec ((x8149 + ((lambda (j7232 + k7233 + f7234) + (lambda (g7229 + g7230 + g7231) + (number?/c + j7232 + k7233 + (f7234 + (number?/c + j7232 + k7233 + g7229) + (number?/c + j7232 + k7233 + g7230) + (number?/c + j7232 + k7233 + g7231))))) + 'module + 'importer + tak)) + (x8148 + (input)) + (x8147 + (input)) + (x8146 + (input))) + (x8149 + x8148 + x8147 + x8146)))) + g8145))) + g8144))) + g8143)))) + g8134))) + g8133)))) + g7246))) + g7245)) diff --git a/analyses/simpleactor/racket/run/translate-full.rkt b/analyses/simpleactor/racket/run/translate-full.rkt index faa51fa9..ec92f644 100644 --- a/analyses/simpleactor/racket/run/translate-full.rkt +++ b/analyses/simpleactor/racket/run/translate-full.rkt @@ -2,11 +2,13 @@ (require racket/pretty) +(require (prefix-in an: "../translations/anf.rkt")) (require (prefix-in un: "../translations/undefiner.rkt")) (require (prefix-in st: "../translations/structs-to-pair.rkt")) (require (prefix-in cc: "../translations/cc-combinator.rkt")) (require (prefix-in ac: "../translations/actor-translation.rkt")) (require (prefix-in co: "../translations/contract-out-translation.rkt")) +(require (prefix-in ap: "../translations/add-prelude.scm")) ;; A full translation from Racket actors ;; with their contracts to λα/c @@ -24,9 +26,11 @@ ;; -(pretty-display - (un:undefine-single - (st:translate - (cc:translate - #:meta #f - (ac:translate (co:translate (read))))))) +;(pretty-display +; (un:undefine-single +; (st:translate +; (cc:translate +; #:meta #f +; (ac:translate (ap:translate (co:translate (read)))))))) +; (pretty-display (st:translate (ap:translate (co:translate (read))))) +(pretty-write (an:translate (un:undefine-single (st:translate (cc:translate #:meta #f (ac:translate (ap:translate (co:translate (read))))))))) diff --git a/analyses/simpleactor/racket/simpleactor-prelude.scm b/analyses/simpleactor/racket/simpleactor-prelude.scm index fac1dbf0..e0ffbc40 100644 --- a/analyses/simpleactor/racket/simpleactor-prelude.scm +++ b/analyses/simpleactor/racket/simpleactor-prelude.scm @@ -1,15 +1,362 @@ ;; This module does not contain executable code. Instead it contains a prelude for the simple actor language. ;; It has to be compiled to SimpleActor since SimpleActor does not understand `flat` neither does is understand `define`. -;; Built-in flat contracts -(define real/c (flat real?)) -(define boolean?/c (flat boolean?)) -(define number?/c (flat number?)) -(define image? any/c) ;; TODO: unsupported, not sure how to support this? -(define cons?/c (flat pair?)) -(define pair?/c (flat pair?)) -(define integer? (flat integer?)) -(define (and/c c1 c2) - (lambda (k j) - (lambda (v) - (and (c1 k j v) (c2 k j v))))) +(begin + ;; Built-in flat contracts + (define real/c (flat real?)) + (define boolean?/c (flat boolean?)) + (define number?/c (flat number?)) + (define any/c (flat (lambda (v) #t))) + (define any?/c (flat (lambda (v) #t))) + (define image? any/c) ;; TODO: unsupported, not sure how to support this? + (define cons?/c (flat pair?)) + (define pair?/c (flat pair?)) + (define integer? (flat integer?)) + (define (and/c c1 c2) + (lambda (k j v) + (and (c1 k j v) (c2 k j v)))) + (define (list-of contract) + (lambda (k j v) + (if (null? v) + '() + (cons (contract k j (car v)) ((list-of contract) k j (cdr v)))))) + (define (any? v) #t) + (define nonzero? (lambda (v) (not (= v 0)))) + (define nonzero?/c (flat (lambda (v) (not (= v 0))))) + + ;; Other utility functionsa + + (define (meta v) v) + + ;; Contracts on primitive functions (these shadow the primitive functions) + + ;; Arithmetic operations + (define orig-+ +) + (define + (mon server client (-> number?/c number?/c number?/c) (lambda (a b) (orig-+ a b)))) + + (define orig-- -) + (define - (mon server client (-> number?/c number?/c number?/c) (lambda (a b) (orig-- a b)))) + + (define orig-* *) + (define * (mon server client (-> number?/c number?/c number?/c) (lambda (a b) (orig-* a b)))) + + (define orig-/ /) + (define / (mon server client (-> number?/c number?/c number?/c) (lambda (a b) (orig-/ a b)))) + + ;; Datastructor operations + + ;; Pairs + (define orig-car car) + (define car (mon server client (-> pair?/c any/c) (lambda (p) (orig-car p)))) + + (define orig-cdr cdr) + (define cdr (mon server client (-> pair?/c any/c) (lambda (p) (orig-cdr p)))) + + (define orig-cons cons) + (define cons (mon server client (-> any/c any/c pair?/c) (lambda (a b) (cons a b)))) + + ;; Vectors + + (define orig-vector-ref vector-ref) + (define vector-ref (mon server client (-> vector?/c integer?/c) (lambda (v i) (orig-vector-ref v i)))) + + (define orig-vector-set vector-set!) + (define vector-set! (mon server client (-> vector?/c integer?/c any/c) (lambda (vec i v) (orig-vector-set! vec i v)))) + + ;; Assertions + (define (assert cnd) #t) + + ;; Other preluded functions + + (define (cdddr x) (cdr (cdr (cdr x)))) + (define __toplevel_set-car! set-car!) + (define (map f l) + (assert (procedure? f)) + (assert (list? l)) + (if (null? l) + '() + (cons (f (car l)) (map f (cdr l))))) + (define (cdar x) (cdr (car x))) + (define (cadadr x) (car (cdr (car (cdr x))))) + (define (cdadar x) (cdr (car (cdr (car x))))) + (define (call-with-output-file filename proc) + (assert (string? filename)) + (assert (procedure? proc)) + (let* ((output-port (open-output-file filename)) + (res (proc output-port))) + (close-output-port output-port) + res)) + ;(define (vector->list v) + ; + ; (assert (vector? v)) + + ; (let construct ((i (- (vector-length v) 1)) (lst '())) + ; + ; (if (< i 0) + ; lst + ; (construct (- i 1) + ; (cons (vector-ref v i) lst))))) + (define (caddr x) (car (cdr (cdr x)))) + (define (cdaadr x) (cdr (car (car (cdr x))))) + (define (assq k l) + + (assert (list? l)) + (if (null? l) + #f + (if (eq? (caar l) k) + (car l) + (assq k (cdr l))))) + (define (even? x) (= 0 (modulo x 2))) + (define (list->string l) + (assert (list? l)) + (if (null? l) + "" + (string-append (char->string (car l)) (list->string (cdr l))))) + (define (char<=? c1 c2) (assert (char? c1)) (assert (char? c2)) (or (char=? c #\a) (char-ci<=? c #\z))) + (define (<= x y) (assert (number? x)) (or (< x y) (= x y) #f)) + (define (char-whitespace? c) (or (= (char->integer c) 9) (= (char->integer c) 10) (= (char->integer c) 32))) + (define (cddar x) (cdr (cdr (car x)))) + (define (positive? x) (assert (number? x)) (> x 0)) + ;(define (string=? s1 s2) + ; + ; (assert (string? s1)) + ; (assert (string? s2)) + ; (and (= (string-length s1)(string-length s2)) + ; (let loop ((i (- (string-length s1) 1))) + ; + ; (if (< i 0) + ; #t + ; (and (char=? (string-ref s1 i) (string-ref s2 i)) + ; (loop (- i 1))))))) + ;(define (string->list string) + ; + ; (assert (string? string)) + ; (let ((len (string-length string))) + ; (let convert ((n (- len 1)) + ; (r '())) + ; + ; (if (< n 0) + ; r + ; (convert (- n 1) + ; (cons (string-ref string n) r)))))) + (define $pc '()) + (define ref-set set-car!) + (define (void) #f) + (define (cddr x) (cdr (cdr x))) + (define (truncate x) (assert (number? x)) (if (< x 0) (ceiling x) (floor x))) + (define $cmp '()) + (define (equal? a b) + + (or (eq? a b) + (and (null? a) (null? b)) + (and (string? a) (string? b) (string=? a b)) + (and (pair? a) (pair? b) (equal? (car a) (car b)) (equal? (cdr a) (cdr b))) + (and (vector? a) (vector? b) + (let ((n (vector-length a))) + (and (= (vector-length b) n) + (letrec ((loop (lambda (i) + + (or (= i n) + (and (equal? (vector-ref a i) (vector-ref b i)) + (loop (+ i 1))))))) + (loop 0))))))) + (define (cdaaar x) (cdr (car (car (car x))))) + (define (caaddr x) (car (car (cdr (cdr x))))) + (define (eqv? x y) (eq? x y)) + (define (>= x y) (assert (number? x)) (or (> x y) (= x y) #f)) + (define (call-with-input-file filename proc) + (assert (string? filename)) + (assert (procedure? proc)) + (let* ((input-port (open-input-file filename)) + (res (proc input-port))) + (close-input-port input-port) + res)) + ;(define (min ag0 . ags) + ; (let loop ((cur ags) + ; (acc ag0)) + ; (if (null? cur) + ; acc + ; (let ((elm (car cur)) + ; (rst (cdr cur))) + ; (loop rst (if (< elm acc) elm acc)))))) + (define (ref x) (cons x '())) + ;(define (string . chars) (list->string chars)) + (define (char>=? c1 c2) (assert (char? c1)) (assert (char? c2)) (or (char>? c1 c2) (char=? c1 c2))) + (define (cdaar x) (cdr (car (car x)))) + (define (cdaddr x) (cdr (car (cdr (cdr x))))) + (define __toplevel_cdr cdr) + (define (cadar x) (car (cdr (car x)))) + (define (caadr x) (car (car (cdr x)))) + (define (char-ci>? c1 c2) (assert (char? c1)) (assert (char? c2)) (not (char-ci<=? c1 c2))) + (define __toplevel_set-cdr! set-cdr!) + (define (caaaar x) (car (car (car (car x))))) + (define (negative? x) (assert (number? x)) (< x 0)) + (define (memv e l) (memq e l)) + (define (caaar x) (car (car (car x)))) + (define (debug e) '()) + (define (reverse l) + (assert (list? l)) + (if (null? l) + '() + (append (reverse (cdr l)) + (list (car l))))) + (define (caaadr x) (car (car (car (cdr x))))) + (define (cddadr x) (cdr (cdr (car (cdr x))))) + (define (odd? x) (assert (number? x)) (= 1 (modulo x 2))) + (define (caadar x) (car (car (cdr (car x))))) + ;(define (max ag0 . ags) + ; (let loop ((cur ags) + ; (acc ag0)) + ; (if (null? cur) + ; acc + ; (let ((elm (car cur)) + ; (rst (cdr cur))) + ; (loop rst (if (> elm acc) elm acc)))))) + (define (apply proc args) + (assert (procedure? proc)) + (assert (list? args)) + (cond + ((null? args) (proc)) + ((null? ( cdr args)) (proc (car args))) + ((null? ( cddr args)) (proc (car args) (cadr args))) + ((null? ( cdddr args)) (proc (car args) (cadr args) (caddr args))) + ((null? (cddddr args)) (proc (car args) (cadr args) (caddr args) (cadddr args))) + ((null? ( cdr (cddddr args))) (proc (car args) (cadr args) (caddr args) (cadddr args) (car (cddddr args)))) + ((null? ( cddr (cddddr args))) (proc (car args) (cadr args) (caddr args) (cadddr args) (car (cddddr args)) (cadr (cddddr args)))) + ((null? (cdddr (cddddr args))) (proc (car args) (cadr args) (caddr args) (cadddr args) (car (cddddr args)) (cadr (cddddr args)) (caddr (cddddr args)))) + (else (error "Unsupported call.")))) + (define (member e l) + + (assert (list? l)) + (if (null? l) + #f + (if (equal? (car l) e) + l + (member e (cdr l))))) + (define call-with-current-continuation call/cc) + (define (cddddr x) (cdr (cdr (cdr (cdr x))))) + (define (cadddr x) (car (cdr (cdr (cdr x))))) + (define (int-top) (random 42)) + (define (zero? x) (assert (number? x)) (= x 0)) + (define (string>=? s1 s2) (or (string>? s1 s2) (string=? s1 s2))) + (define (cadr x) (car (cdr x))) + (define __toplevel_car car) + (define (list? l) (or (and (pair? l) (list? (cdr l))) (null? l))) + (define (cddaar x) (cdr (cdr (car (car x))))) + (define (char-numeric? c) (and (char<=? #\0 c) (char<=? c #\9))) + (define __toplevel_cons cons) + ;(define (string-fill! s c) + ; (let loop ((i (- (string-length s) 1))) + ; (if (< i 0) + ; #t + ; (begin (string-set! s i c) + ; (loop (- i 1)))))) + (define (assv k l) + + (assert (list? l)) + (if (null? l) + #f + (if (eqv? (caar l) k) + (car l) + (assq k (cdr l))))) + (define (not x) (if x #f #t)) + (define (__toplevel_append l1 l2) (append l1 l2)) + (define (memq e l) + + (assert (list? l)) + (if (null? l) + #f + (if (eq? (car l) e) + l + (memq e (cdr l))))) + (define (cadaar x) (car (cdr (car (car x))))) + (define (length l) + + (assert (list? l)) + (letrec ((rec (lambda (l) + (if (null? l) + 0 + (+ 1 (rec (cdr l))))))) + (rec l))) + (define (char-ci<=? c1 c2) (assert (char? c1)) (assert (char? c2)) (or (char-ci? s1 s2) (not (string<=? s1 s2))) + ;(define (string-ci=? s1 s2) + ; + ; (assert (string? s1)) + ; (assert (string? s2)) + ; (and (= (string-length s1)(string-length s2)) + ; (let loop ((i (- (string-length s1) 1))) + ; + ; (if (< i 0) + ; #t + ; (and (char-ci=? (string-ref s1 i) (string-ref s2 i)) + ; (loop (- i 1))))))) + ;(define (list->vector l) + ; + ; (assert (list? l)) + ; (let ((v (make-vector (length l)))) + ; (let fill ((lst l) (i 0)) + ; (if (null? lst) + ; v + ; (begin (vector-set! v i (car lst)) + ; (fill (cdr lst) (+ i 1))))))) + (define (cdadr x) (cdr (car (cdr x)))) + (define (assoc k l) + + (assert (list? l)) + (if (null? l) + #f + (if (equal? (caar l) k) + (car l) + (assoc k (cdr l))))) + (define (caar x) (car (car x))) + (define (char>? c1 c2) (assert (char? c1)) (assert (char? c2)) (not (char<=? c1 c2))) + (define (string<=? s1 s2) (or (string=? c1 c2) (assert (char? c1)) (assert (char? c2)) (or (char-ci>? c1 c2) (char-ci=? c1 c2))) + (define (caddar x) (car (cdr (cdr (car x))))) + (define (newline) #f) + (define (lcm m n) (/ (abs (* m n)) (gcd m n))) + (define deref car) + (define (> x y) (assert (number? x)) (not (<= x y))) + ; (define (list . args) args) + (define (list-ref l index) + + (assert (list? l)) + (assert (number? index)) + (assert (< index (length l))) + (if (= index 0) + (car l) + (list-ref (cdr l) (- index 1)))) + (define (gcd a b) (if (= b 0) a (gcd b (modulo a b))))) + ;(define (append . lsts) + ; (define (app lsts) + ; (cond ((null? lsts) '()) + ; ((null? (cdr lsts)) (car lsts)) ; Structure sharing. + ; (else (let loop ((first (car lsts)) + ; (rest (app (cdr lsts)))) + ; (if (null? first) + ; rest + ; (cons (car first) + ; (loop (cdr first) + ; rest))))))) + ; (app lsts))) + diff --git a/analyses/simpleactor/racket/translations/actor-translation.rkt b/analyses/simpleactor/racket/translations/actor-translation.rkt index 7acae611..86a01b89 100644 --- a/analyses/simpleactor/racket/translations/actor-translation.rkt +++ b/analyses/simpleactor/racket/translations/actor-translation.rkt @@ -7,6 +7,35 @@ (define (invalid-syntax for e) (error (format "invalid syntax for ~a at ~a" for e))) +(define (translate-cond clauses) + (if (null? clauses) + '() + (let* ((clause (car clauses)) + (cnd (car clause)) + (bdy (cdr clause))) + (if (eq? cnd 'else) + `(begin ,@bdy) + `(if cnd + (begin ,@bdy) + ,(translate-cond (cdr clauses))))))) + +(define (translate-and conditions) + (cond + ((null? conditions) #f) + ((null? (cdr conditions)) (car conditions)) + (else `(if ,(car conditions) ,(translate-and (cdr conditions)) #f)))) + +(define (translate-or conditions) + (cond + ((null? conditions) #t) + ((null? (cdr conditions)) (car conditions)) + (else + (let ((val (gensym "val"))) + `(letrec ((,val ,(car conditions))) + (if ,val + ,val + ,(translate-or (cdr conditions)))))))) + (define (translate e) (match e [(quasiquote (behavior ,ags ,handlers)) @@ -33,6 +62,16 @@ (send^ act msg)))] [(quasiquote (spawn ,@es)) (invalid-syntax "spawn" e)] + [(quasiquote (let ,bds ,@bdy)) + `(letrec ,(map (lambda (bdn) (list (car bdn) (translate (cadr bdn)))) bds) ,@(map translate bdy))] + [(quasiquote (let* ,bds ,@bdy)) + `(letrec ,(map (lambda (bdn) (list (car bdn) (translate (cadr bdn)))) bds) ,@(map translate bdy))] + [(quasiquote (cond ,@clauses)) + (translate-cond clauses)] + [(quasiquote (and ,@conditions)) + (translate-and conditions)] + [(quasiquote (or ,@conditions)) + (translate-or conditions)] [(quasiquote self) '(dyn self)] [(quasiquote (,es ...)) diff --git a/analyses/simpleactor/racket/translations/add-prelude.scm b/analyses/simpleactor/racket/translations/add-prelude.scm new file mode 100644 index 00000000..de54110a --- /dev/null +++ b/analyses/simpleactor/racket/translations/add-prelude.scm @@ -0,0 +1,10 @@ +#lang racket + +;; This module adds a prelude to the input file + +(define (translate exp) + (let ((input-file (open-input-file "../racket/simpleactor-prelude.scm"))) + `(begin ,(read input-file) ,exp))) + +(provide translate) + diff --git a/analyses/simpleactor/racket/translations/anf.rkt b/analyses/simpleactor/racket/translations/anf.rkt index 2cd8ab5e..01f3131c 100644 --- a/analyses/simpleactor/racket/translations/anf.rkt +++ b/analyses/simpleactor/racket/translations/anf.rkt @@ -11,25 +11,32 @@ ae ::= λx . e | l | self | blame | x | dyn x e ::= ae | if ae e e | let x = e in e | ae ae ... | match ae with (pat => e) ... | pair ae ae |# +(define (empty-begin? beg) + (match beg + [(quasiquote (begin)) #t] + [_ #f])) + +(define (nonempty-begin? beg) (not (empty-begin? beg))) + (define (translate-parts lst) (if (null? lst) (values '() '() '()) (let-values ([(aes xs es) (translate-parts (cdr lst))]) (if (atomic? (car lst)) (values (cons (car lst) aes) xs es) - (letrec ((x (gensym))) + (letrec ((x (gensym "x"))) (values (cons x aes) (cons x xs) (cons (translate (car lst)) es))))))) (define (translate exp) (match exp [(quasiquote (lambda (,@xs) ,@exs)) - `(lambda (,@xs) ,@(map translate exs))] + `(lambda (,@xs) ,(translate `(begin ,@exs)))] [(quasiquote (spawn ,e)) (let ((x (gensym))) `(letrec ((,x ,(translate e))) (spawn ,x)))] [(quasiquote (letrec ,bds ,@bdy)) `(letrec ,(map (lambda (bdn) (list (car bdn) (translate (cadr bdn)))) bds) - ,@(map translate bdy))] + ,(translate `(begin ,@bdy)))] [(quasiquote (terminate)) `(terminate)] [(quasiquote (self)) `(self)] [(quasiquote (pair ,e1 ,e2)) @@ -49,12 +56,14 @@ e ::= ae | if ae e e | let x = e in e | ae ae ... | match ae with (pat => e) .. `(letrec ((,x-cnd ,(translate e1))) (if ,x-cnd ,(translate e2) ,(translate e3)))))] [(quasiquote (dyn ,x)) `(dyn ,x)] - [(quasiquote (begin ,@es)) - (letrec ((xs (map (lambda ign (gensym)) es))) - `(letrec - (,@(map (lambda (x e) (list x (translate e))) xs es)) - - ,(last xs)))] + [(quasiquote (begin ,@es0)) + (if (null? es0) + '() + (let ((es (filter nonempty-begin? es0))) + (letrec ((xs (map (lambda ign (gensym)) es))) + `(letrec + (,@(map (lambda (x e) (list x (translate e))) xs es)) + ,(last xs)))))] [(quasiquote (meta ,e)) `(meta ,(translate e))] ;[(quasiquote (receive ,@xs)) (error "translate: receive not implemented")] [(quasiquote (match ,e ,clauses)) @@ -64,6 +73,7 @@ e ::= ae | if ae e e | let x = e in e | ae ae ... | match ae with (pat => e) .. ;[(quasiquote (parametrize ,@xs)) (error "translate: parametrize not implemented")] [(quasiquote (,operator ,@operands)) + (let-values ([(aes xs es) (translate-parts (cons operator operands))]) (if (null? xs) aes @@ -74,6 +84,9 @@ e ::= ae | if ae e e | let x = e in e | ae ae ... | match ae with (pat => e) .. (define (lambda? x) (match x [(quasiquote (lambda ,xs ,@bdy)) #t] [_ #f])) -(define (atomic? x) (or (boolean? x) (number? x) (symbol? x) (string? x) (lambda? x))) +(define (atomic? x) + (match x + [(quasiquote (quote ,x)) #t] + [_ (or (null? x) (boolean? x) (number? x) (symbol? x) (string? x) (lambda? x))])) (provide translate) diff --git a/analyses/simpleactor/racket/translations/cc-combinator.rkt b/analyses/simpleactor/racket/translations/cc-combinator.rkt index 9cf4bf97..f0650a34 100644 --- a/analyses/simpleactor/racket/translations/cc-combinator.rkt +++ b/analyses/simpleactor/racket/translations/cc-combinator.rkt @@ -245,6 +245,22 @@ `(lambda (,j ,k ,f) (lambda ,vs ,(instrument-meta `(,(translate-aux ret) ,j ,k (,f ,@(map (lambda (arg v) (instrument-meta `(,(translate-aux arg) ,j ,k ,v))) ags vs))))))))] + [(quasiquote (->d ,@κs)) + (let* ((ags (drop-right κs 1)) + (ret (last κs)) + (vs (map (lambda ign (gensym)) ags)) + (j (gensym "j")) + (k (gensym "k")) + (f (gensym "f")) + (xs (map (lambda ags (gensym "x")) ags))) + + (instrument-meta + `(lambda (,j ,k ,f) + (lambda ,vs + (letrec + ,(map (lambda (arg v x) (list x (instrument-meta `(,(translate-aux arg) ,j ,k ,v)))) ags vs xs) + ;; TODO: blame assignment is actually wrong here: a third party is needed now! + ,(instrument-meta `((,(translate-aux ret) ,@xs) ,j ,k (,f ,@xs))))))))] [(quasiquote (-> ,κ1 ,κ2)) (let ((j (gensym)) (k (gensym)) (f (gensym)) (v (gensym))) (instrument-meta @@ -255,6 +271,24 @@ (instrument-meta `(,(translate-aux κ) (quote ,j) (quote ,k) ,(translate-aux v)))] [(quasiquote (behavior/c ,@messages)) (translate-behavior/c e)] + [(quasiquote (one-of/c ,@options)) + (let ((j (gensym "j")) (k (gensym "k")) (v (gensym "v"))) + (define (gen-oneof options v) + (if (null? (cdr options)) + `(eq? ,(car options) ,v) + `(if (eq? ,(car options) ,v) + #t + ,(gen-oneof (cdr options) v)))) + (translate-aux `(flat (lambda (,v) ,(gen-oneof options v)))))] + [(quasiquote (struct/c ,name ,@fields)) + (define (gen-field-checks j k fields v checked-v) + (let ((checked (gensym "checked"))) + (if (null? fields) + (consify (reverse checked-v)) + `(letrec ((,checked (,(translate-aux (car fields)) (quote ,j) (quote ,k) (car ,v)))) + ,(gen-field-checks j k (cdr fields) `(cdr ,v) (cons checked checked-v)))))) + (let ((v (gensym "v")) (j (gensym "j")) (k (gensym "k"))) + `(lambda (,j ,k ,v) ,(gen-field-checks j k fields v (list name))))] [(quasiquote (receive ,pats)) `(receive ,(append pats (enhanced-receive-patterns pats)))] [(quasiquote (,es ...)) @@ -282,6 +316,7 @@ (module+ main (require "../tests/prelude.rkt") + (require racket/pretty) ;(displayln (translate test-1)) @@ -291,10 +326,10 @@ ;(displayln (eval_ `(,(translate test-3) (lambda (x) (* x 2))))) ;; returns 84 ;(displayln (eval_ `(,(translate test-3) (lambda (x) (* x -2))))) ;; return blame error on k - (displayln (translate test-4 #:meta #t)) - (displayln (eval_ (translate test-4 #:meta #t))) ;; returns 5 - (displayln (eval_ `(,(translate test-5) 2))) ;; returns 1 - (displayln (eval_ `(,(translate test-5) 1))) ;; blame error blaming k - + ;(displayln (translate test-4 #:meta #t)) + ;(displayln (eval_ (translate test-4 #:meta #t))) ;; returns 5 + ;(displayln (eval_ `(,(translate test-5) 2))) ;; returns 1 + ;(displayln (eval_ `(,(translate test-5) 1))) ;; blame error blaming k + (pretty-display (translate `(struct/c world TETRA/C BSET/C))) ) diff --git a/analyses/simpleactor/racket/translations/contract-out-translation.rkt b/analyses/simpleactor/racket/translations/contract-out-translation.rkt index 308b817e..c550c76c 100644 --- a/analyses/simpleactor/racket/translations/contract-out-translation.rkt +++ b/analyses/simpleactor/racket/translations/contract-out-translation.rkt @@ -1,5 +1,7 @@ #lang racket +(require "../utils.rkt") + ;; This module translates files containing `contract-out` ;; definitions to equivalent files ready for verification. ;; @@ -8,7 +10,7 @@ ;; inputs. -;; Attempt to derrive the arity of the function +;; Attempt to derive the arity of the function ;; monitored by the contract, returns an arity of ;; zero if the contract does not depict a function ;; but is a constant, in that case a function @@ -19,6 +21,31 @@ (- (length contracts) 1)] [_ 0])) +(define (initial xs) + (if (null? (cdr xs)) + '() + (cons (car xs) (initial (cdr xs))))) + + +;; Get the contracts on the arguments +(define (argument-contracts contract) + (match contract + [(quasiquote (-> ,@contract)) + (initial contract)] + [_ '()])) + +;; Derive the shape of the input +(define (derive-input-shape contract) + (match contract + [(quasiquote (listof ,contract)) '(input)] ; TODO: provide a better representation here + [(quasiquote ,contract-name) + (let ((contract (assoc contract-name *struct-contracts*))) + (if contract + (let ((name (caadr contract)) + (fields (cdadr contract))) + (consify (cons `(quote ,name) (map derive-input-shape fields)))) + '(input)))])) + ;; Translate a single contract (define (translate-contract contract) (match contract @@ -27,16 +54,27 @@ (arity (contract-arity contract))) (if (= arity 0) monitor - `(,monitor ,@(build-list arity (lambda ags '(input))))))] + `(,monitor ,@(map derive-input-shape (argument-contracts contract)))))] [_ (error "invalid contract-out specification")])) ;; Translate a list of contracts (define (translate-contracts contracts) - (map translate-contract contracts)) + `(begin ,@(map translate-contract contracts))) + +;; Contract definitions for structs represented as an association +;; list mapping the names of the contract to the fields of the contract +(define *struct-contracts* '()) ;; Translate a program that could contain a contract-out statement (define (translate exp) (match exp + ;; this is a little "hack" to know whether there are contracts + ;; for structs in scope, normally we should do proper modelling of + ;; the environment but this should be sufficient to detect top-level + ;; contracts on structs. + [(quasiquote (define ,contractname (struct/c ,name ,@fields))) + (set! *struct-contracts* (cons (list contractname (cons name fields)) *struct-contracts*)) + exp] [(quasiquote (contract-out ,@contracts)) (translate-contracts contracts)] [(quasiquote (provide ,@exports)) diff --git a/analyses/simpleactor/racket/translations/undefiner.rkt b/analyses/simpleactor/racket/translations/undefiner.rkt index 0e3499bc..3e813df1 100644 --- a/analyses/simpleactor/racket/translations/undefiner.rkt +++ b/analyses/simpleactor/racket/translations/undefiner.rkt @@ -51,26 +51,27 @@ ;; expressions are allowed at that location (define (undefine exp allowed) (match exp - [(quasiquote (letrec ,bds ,bdy)) + [(quasiquote (letrec ,bds ,@bdy)) (let ((names (map car bds)) (values (map cadr bds))) (parameterize [(*defines* '())] `(letrec ,(map (lambda (name value) `(,name ,(undefine value #f))) names values) - ,(undefine-sequence bdy #t))))] - [(quasiquote (let ,bds ,bdy)) + ,@(undefine-sequence bdy #t))))] + [(quasiquote (let ,bds ,@bdy)) (let ((names (map car bds)) (values (map cadr bds))) (parameterize [(*defines* '())] `(let ,(map (lambda (name value) `(,name ,(undefine value #f))) names values) - ,(undefine-sequence bdy #t))))] - [(quasiquote (let* ,bds ,bdy)) + ,@(undefine-sequence bdy #t))))] + [(quasiquote (let* ,bds ,@bdy)) (let ((names (map car bds)) (values (map cadr bds))) (parameterize [(*defines* '())] `(let* ,(map (lambda (name value) `(,name ,(undefine value #f))) names values) - ,(undefine-sequence bdy #t))))] + ,@(undefine-sequence bdy #t))))] [(quasiquote (begin ,@exs)) - (undefine-sequence exs allowed)] + (define undefined-sequence (undefine-sequence exs allowed)) + `(begin ,@undefined-sequence)] [(quasiquote (lambda ,ags ,@bdy)) (parameterize [(*defines* '())] `(lambda ,ags ,@(undefine-sequence bdy #t)))] [(quasiquote (define (,f ,@ags) ,@bdy)) @@ -95,7 +96,6 @@ ;; should only contain a single expression (define result (undefine-sequence program #t)) (unless (null? (cdr result)) - (pretty-display result) (error (format "program should only contain a single `letrec` expression ~a~n" result))) (car result)) @@ -105,11 +105,12 @@ (module+ main (define test-program - `((define x 10) - (display (+ x 2)) - (define y 20) - (define (foo x) (+ x y)) - (foo 20))) + `((letrec ((x 10)) + (define x 10) + (display (+ x 2)) + (define y 20) + (define (foo x) (+ x y)) + (foo 20)))) (displayln (undefine-program test-program)) (displayln (undefine-program '(42)))) diff --git a/analyses/simpleactor/racket/utils.rkt b/analyses/simpleactor/racket/utils.rkt index 3c51954e..fa0261b9 100644 --- a/analyses/simpleactor/racket/utils.rkt +++ b/analyses/simpleactor/racket/utils.rkt @@ -7,3 +7,7 @@ ((null? (cdr ags)) (car ags)) ((pair? ags) `(pair ,(car ags) ,(uncurry (cdr ags)))))) +(define (consify lst) + (if (null? lst) + ''() + `(cons ,(car lst) ,(consify (cdr lst))))) diff --git a/analyses/simpleactor/src/Analysis/SimpleActor/Semantics.hs b/analyses/simpleactor/src/Analysis/SimpleActor/Semantics.hs index db2beb50..0f856d65 100644 --- a/analyses/simpleactor/src/Analysis/SimpleActor/Semantics.hs +++ b/analyses/simpleactor/src/Analysis/SimpleActor/Semantics.hs @@ -174,6 +174,7 @@ injectLit :: SchemeDomain v => Lit -> v injectLit (Boolean b) = inject b injectLit (Symbol s) = symbol s injectLit (Num n) = inject n +injectLit (Character c) = inject c injectLit Nil = nil ------------------------------------------------------------ diff --git a/analyses/simpleactor/src/Syntax/AST.hs b/analyses/simpleactor/src/Syntax/AST.hs index cfda6702..6cb88840 100644 --- a/analyses/simpleactor/src/Syntax/AST.hs +++ b/analyses/simpleactor/src/Syntax/AST.hs @@ -36,7 +36,7 @@ data Exp = Lam [Ide] Exp Span instance NFData Exp -- | Literals are expressions that evaluate to themselves -data Lit = Num Integer | Boolean Bool | Symbol String | Nil deriving (Eq, Ord, Generic) +data Lit = Num Integer | Character Char | Boolean Bool | Symbol String | String String | Nil deriving (Eq, Ord, Generic) instance NFData Lit @@ -44,6 +44,8 @@ instance Show Lit where show (Num n) = show n show (Boolean b) = show b show (Symbol s) = show s + show (String str) = show str + show (Character c) = "\\#" ++ show c show Nil = "'()" -- | Pattern language diff --git a/analyses/simpleactor/src/Syntax/Compiler.hs b/analyses/simpleactor/src/Syntax/Compiler.hs index ea0de788..cae11605 100644 --- a/analyses/simpleactor/src/Syntax/Compiler.hs +++ b/analyses/simpleactor/src/Syntax/Compiler.hs @@ -78,6 +78,10 @@ compile ex@(op ::: oprs) = compile ex@(Atom x _) = return $ Var $ Ide x (spanOf ex) compile ex@(Quo (Atom s _) _) = return $ Literal (Symbol s) (spanOf ex) +compile ex@(Quo (SNil _) _) = return $ Literal Nil (spanOf ex) +-- TODO: strings are not symbols! +compile ex@(Str str _) = return $ Literal (Symbol str) (spanOf ex) +compile ex@(Cha c _) = return $ Literal (Character c) (spanOf ex) compile e = throwError $ "invalid syntax " ++ show e compileBdn :: MonadError String m => SExp -> m (Ide, Exp)