diff --git a/tests/experimental/diviter.c b/tests/experimental/diviter.c
new file mode 100644
index 00000000..046e558c
--- /dev/null
+++ b/tests/experimental/diviter.c
@@ -0,0 +1,1988 @@
+/**
+ ** This file was automatically generated by the Cyclone scheme compiler
+ ** http://justinethier.github.io/cyclone/
+ **
+ ** (c) 2014-2018 Justin Ethier
+ ** Version 0.9.4 
+ **
+ **/
+
+#define closcall1(td, clo,a1) \
+if (type_is_pair_prim(clo)) { \
+   Cyc_apply(td, 0, (closure)(a1), clo); \
+} else { \
+   ((clo)->fn)(td, 1, clo,a1);\
+}
+#define return_closcall1(td, clo,a1) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[1]; buf[0] = a1;\
+     GC(td, clo, buf, 1); \
+     return; \
+ } else {\
+     closcall1(td, (closure) (clo),a1); \
+     return;\
+ } \
+}
+
+#define return_direct1(td, _fn,a1) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[1]; buf[0] = a1; \
+     mclosure0(c1, (function_type) _fn); \
+     GC(td, &c1, buf, 1); \
+     return; \
+ } else { \
+     (_fn)(td, 1, (closure)_fn,a1); \
+ }}
+
+#define return_direct_with_clo1(td, clo, _fn,a1) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[1]; buf[0] = a1;\
+     GC(td, clo, buf, 1); \
+     return; \
+ } else { \
+     (_fn)(td, 1, (closure)(clo),a1); \
+ }}
+
+#define closcall2(td, clo,a1,a2) \
+if (type_is_pair_prim(clo)) { \
+   Cyc_apply(td, 1, (closure)(a1), clo,a2); \
+} else { \
+   ((clo)->fn)(td, 2, clo,a1,a2);\
+}
+#define return_closcall2(td, clo,a1,a2) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[2]; buf[0] = a1;buf[1] = a2;\
+     GC(td, clo, buf, 2); \
+     return; \
+ } else {\
+     closcall2(td, (closure) (clo),a1,a2); \
+     return;\
+ } \
+}
+
+#define return_direct2(td, _fn,a1,a2) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[2]; buf[0] = a1;buf[1] = a2; \
+     mclosure0(c1, (function_type) _fn); \
+     GC(td, &c1, buf, 2); \
+     return; \
+ } else { \
+     (_fn)(td, 2, (closure)_fn,a1,a2); \
+ }}
+
+#define return_direct_with_clo2(td, clo, _fn,a1,a2) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[2]; buf[0] = a1;buf[1] = a2;\
+     GC(td, clo, buf, 2); \
+     return; \
+ } else { \
+     (_fn)(td, 2, (closure)(clo),a1,a2); \
+ }}
+
+#define closcall3(td, clo,a1,a2,a3) \
+if (type_is_pair_prim(clo)) { \
+   Cyc_apply(td, 2, (closure)(a1), clo,a2,a3); \
+} else { \
+   ((clo)->fn)(td, 3, clo,a1,a2,a3);\
+}
+#define return_closcall3(td, clo,a1,a2,a3) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[3]; buf[0] = a1;buf[1] = a2;buf[2] = a3;\
+     GC(td, clo, buf, 3); \
+     return; \
+ } else {\
+     closcall3(td, (closure) (clo),a1,a2,a3); \
+     return;\
+ } \
+}
+
+#define return_direct3(td, _fn,a1,a2,a3) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[3]; buf[0] = a1;buf[1] = a2;buf[2] = a3; \
+     mclosure0(c1, (function_type) _fn); \
+     GC(td, &c1, buf, 3); \
+     return; \
+ } else { \
+     (_fn)(td, 3, (closure)_fn,a1,a2,a3); \
+ }}
+
+#define return_direct_with_clo3(td, clo, _fn,a1,a2,a3) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[3]; buf[0] = a1;buf[1] = a2;buf[2] = a3;\
+     GC(td, clo, buf, 3); \
+     return; \
+ } else { \
+     (_fn)(td, 3, (closure)(clo),a1,a2,a3); \
+ }}
+
+#define closcall5(td, clo,a1,a2,a3,a4,a5) \
+if (type_is_pair_prim(clo)) { \
+   Cyc_apply(td, 4, (closure)(a1), clo,a2,a3,a4,a5); \
+} else { \
+   ((clo)->fn)(td, 5, clo,a1,a2,a3,a4,a5);\
+}
+#define return_closcall5(td, clo,a1,a2,a3,a4,a5) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[5]; buf[0] = a1;buf[1] = a2;buf[2] = a3;buf[3] = a4;buf[4] = a5;\
+     GC(td, clo, buf, 5); \
+     return; \
+ } else {\
+     closcall5(td, (closure) (clo),a1,a2,a3,a4,a5); \
+     return;\
+ } \
+}
+
+#define return_direct5(td, _fn,a1,a2,a3,a4,a5) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[5]; buf[0] = a1;buf[1] = a2;buf[2] = a3;buf[3] = a4;buf[4] = a5; \
+     mclosure0(c1, (function_type) _fn); \
+     GC(td, &c1, buf, 5); \
+     return; \
+ } else { \
+     (_fn)(td, 5, (closure)_fn,a1,a2,a3,a4,a5); \
+ }}
+
+#define return_direct_with_clo5(td, clo, _fn,a1,a2,a3,a4,a5) { \
+ char top; \
+ if (stack_overflow(&top, (((gc_thread_data *)data)->stack_limit))) { \
+     object buf[5]; buf[0] = a1;buf[1] = a2;buf[2] = a3;buf[3] = a4;buf[4] = a5;\
+     GC(td, clo, buf, 5); \
+     return; \
+ } else { \
+     (_fn)(td, 5, (closure)(clo),a1,a2,a3,a4,a5); \
+ }}
+
+#include "cyclone/types.h"
+object __glo_this_91scheme_91implementation_91name = NULL;
+object __glo_run_91r7rs_91benchmark = NULL;
+object __glo_hide = NULL;
+object __glo_main = NULL;
+object __glo_iterative_91div2 = NULL;
+object __glo_create_91n = NULL;
+extern object __glo_member_scheme_base;
+extern object __glo_assoc_scheme_base;
+extern object __glo_cons_91source_scheme_base;
+extern object __glo_syntax_91rules_scheme_base;
+extern object __glo_letrec_85_scheme_base;
+extern object __glo_guard_scheme_base;
+extern object __glo_guard_91aux_scheme_base;
+extern object __glo_define_91record_91type_scheme_base;
+extern object __glo_record_127_scheme_base;
+extern object __glo_is_91a_127_scheme_base;
+extern object __glo_register_91simple_91type_scheme_base;
+extern object __glo_make_91type_91predicate_scheme_base;
+extern object __glo_make_91constructor_scheme_base;
+extern object __glo_make_91getter_scheme_base;
+extern object __glo_make_91setter_scheme_base;
+extern object __glo_slot_91ref_scheme_base;
+extern object __glo_slot_91set_67_scheme_base;
+extern object __glo_type_91slot_91offset_scheme_base;
+extern object __glo_receive_scheme_base;
+extern object __glo_abs_scheme_base;
+extern object __glo_max_scheme_base;
+extern object __glo_min_scheme_base;
+extern object __glo_modulo_scheme_base;
+extern object __glo_floor_91remainder_scheme_base;
+extern object __glo_even_127_scheme_base;
+extern object __glo_exact_91integer_127_scheme_base;
+extern object __glo_exact_91integer_91sqrt_scheme_base;
+extern object __glo_exact_127_scheme_base;
+extern object __glo_inexact_127_scheme_base;
+extern object __glo_odd_127_scheme_base;
+extern object __glo_complex_127_scheme_base;
+extern object __glo_rational_127_scheme_base;
+extern object __glo_bignum_127_scheme_base;
+extern object __glo_gcd_scheme_base;
+extern object __glo_lcm_scheme_base;
+extern object __glo_quotient_scheme_base;
+extern object __glo_remainder_scheme_base;
+extern object __glo_truncate_91quotient_scheme_base;
+extern object __glo_truncate_91remainder_scheme_base;
+extern object __glo_truncate_95_scheme_base;
+extern object __glo_floor_91quotient_scheme_base;
+extern object __glo_floor_91remainder_scheme_base;
+extern object __glo_floor_95_scheme_base;
+extern object __glo_square_scheme_base;
+extern object __glo_expt_scheme_base;
+extern object __glo_call_91with_91current_91continuation_scheme_base;
+extern object __glo_call_95cc_scheme_base;
+extern object __glo_call_91with_91values_scheme_base;
+extern object __glo_dynamic_91wind_scheme_base;
+extern object __glo_values_scheme_base;
+extern object __glo_char_123_127_scheme_base;
+extern object __glo_char_121_127_scheme_base;
+extern object __glo_char_125_127_scheme_base;
+extern object __glo_char_121_123_127_scheme_base;
+extern object __glo_char_125_123_127_scheme_base;
+extern object __glo_string_123_127_scheme_base;
+extern object __glo_string_121_127_scheme_base;
+extern object __glo_string_121_123_127_scheme_base;
+extern object __glo_string_125_127_scheme_base;
+extern object __glo_string_125_123_127_scheme_base;
+extern object __glo_foldl_scheme_base;
+extern object __glo_foldr_scheme_base;
+extern object __glo_not_scheme_base;
+extern object __glo_list_127_scheme_base;
+extern object __glo_zero_127_scheme_base;
+extern object __glo_positive_127_scheme_base;
+extern object __glo_negative_127_scheme_base;
+extern object __glo_append_scheme_base;
+extern object __glo__list_scheme_base;
+extern object __glo_make_91list_scheme_base;
+extern object __glo_list_91copy_scheme_base;
+extern object __glo_map_scheme_base;
+extern object __glo_Cyc_91map_91loop_911_scheme_base;
+extern object __glo_Cyc_91for_91each_91loop_911_scheme_base;
+extern object __glo_for_91each_scheme_base;
+extern object __glo_list_91tail_scheme_base;
+extern object __glo_list_91ref_scheme_base;
+extern object __glo_list_91set_67_scheme_base;
+extern object __glo_reverse_scheme_base;
+extern object __glo_boolean_123_127_scheme_base;
+extern object __glo_symbol_123_127_scheme_base;
+extern object __glo_Cyc_91obj_123_127_scheme_base;
+extern object __glo_vector_scheme_base;
+extern object __glo_vector_91append_scheme_base;
+extern object __glo_vector_91copy_scheme_base;
+extern object __glo_vector_91copy_67_scheme_base;
+extern object __glo_vector_91fill_67_scheme_base;
+extern object __glo_vector_91_125list_scheme_base;
+extern object __glo_vector_91_125string_scheme_base;
+extern object __glo_vector_91map_scheme_base;
+extern object __glo_vector_91for_91each_scheme_base;
+extern object __glo_make_91string_scheme_base;
+extern object __glo_string_scheme_base;
+extern object __glo_string_91copy_scheme_base;
+extern object __glo_string_91copy_67_scheme_base;
+extern object __glo_string_91fill_67_scheme_base;
+extern object __glo_string_91_125list_scheme_base;
+extern object __glo_string_91_125vector_scheme_base;
+extern object __glo_string_91map_scheme_base;
+extern object __glo_string_91for_91each_scheme_base;
+extern object __glo_make_91parameter_scheme_base;
+extern object __glo_current_91output_91port_scheme_base;
+extern object __glo_current_91input_91port_scheme_base;
+extern object __glo_current_91error_91port_scheme_base;
+extern object __glo_call_91with_91port_scheme_base;
+extern object __glo_error_91object_127_scheme_base;
+extern object __glo_error_91object_91message_scheme_base;
+extern object __glo_error_91object_91irritants_scheme_base;
+extern object __glo_error_scheme_base;
+extern object __glo_raise_scheme_base;
+extern object __glo_raise_91continuable_scheme_base;
+extern object __glo_with_91handler_scheme_base;
+extern object __glo_with_91exception_91handler_scheme_base;
+extern object __glo_Cyc_91add_91exception_91handler_scheme_base;
+extern object __glo_Cyc_91remove_91exception_91handler_scheme_base;
+extern object __glo_newline_scheme_base;
+extern object __glo_write_91char_scheme_base;
+extern object __glo_write_91string_scheme_base;
+extern object __glo_flush_91output_91port_scheme_base;
+extern object __glo_peek_91char_scheme_base;
+extern object __glo_read_91char_scheme_base;
+extern object __glo_read_91line_scheme_base;
+extern object __glo_read_91string_scheme_base;
+extern object __glo_input_91port_127_scheme_base;
+extern object __glo_output_91port_127_scheme_base;
+extern object __glo_input_91port_91open_127_scheme_base;
+extern object __glo_output_91port_91open_127_scheme_base;
+extern object __glo_get_91output_91string_scheme_base;
+extern object __glo_open_91output_91string_scheme_base;
+extern object __glo_open_91input_91string_scheme_base;
+extern object __glo_get_91output_91bytevector_scheme_base;
+extern object __glo_open_91input_91bytevector_scheme_base;
+extern object __glo_open_91output_91bytevector_scheme_base;
+extern object __glo_features_scheme_base;
+extern object __glo_Cyc_91version_scheme_base;
+extern object __glo_any_scheme_base;
+extern object __glo_every_scheme_base;
+extern object __glo_and_scheme_base;
+extern object __glo_or_scheme_base;
+extern object __glo_let_scheme_base;
+extern object __glo_let_85_scheme_base;
+extern object __glo_letrec_scheme_base;
+extern object __glo_let_85_91values_scheme_base;
+extern object __glo_let_91values_scheme_base;
+extern object __glo_begin_scheme_base;
+extern object __glo__case_scheme_base;
+extern object __glo_cond_scheme_base;
+extern object __glo_cond_91expand_scheme_base;
+extern object __glo__do_scheme_base;
+extern object __glo_when_scheme_base;
+extern object __glo_unless_scheme_base;
+extern object __glo_quasiquote_scheme_base;
+extern object __glo_floor_scheme_base;
+extern object __glo_ceiling_scheme_base;
+extern object __glo_truncate_scheme_base;
+extern object __glo_round_scheme_base;
+extern object __glo_exact_scheme_base;
+extern object __glo_inexact_scheme_base;
+extern object __glo_eof_91object_scheme_base;
+extern object __glo_syntax_91error_scheme_base;
+extern object __glo_bytevector_91copy_scheme_base;
+extern object __glo_bytevector_91copy_67_scheme_base;
+extern object __glo_utf8_91_125string_scheme_base;
+extern object __glo_string_91_125utf8_scheme_base;
+extern object __glo_denominator_scheme_base;
+extern object __glo_numerator_scheme_base;
+extern object __glo_parameterize_scheme_base;
+extern object __glo_peek_91u8_scheme_base;
+extern object __glo_read_91u8_scheme_base;
+extern object __glo_write_91u8_scheme_base;
+extern object __glo_read_scheme_read;
+extern object __glo_read_91all_scheme_read;
+extern object __glo_include_scheme_read;
+extern object __glo_include_91ci_scheme_read;
+extern object __glo_display_scheme_write;
+extern object __glo_write_scheme_write;
+extern object __glo_write_91shared_scheme_write;
+extern object __glo_write_91simple_scheme_write;
+extern object __glo_current_91second_scheme_time;
+extern object __glo_current_91jiffy_scheme_time;
+extern object __glo_jiffies_91per_91second_scheme_time;
+#include "cyclone/runtime.h"
+#include "cyclone/runtime-main.h"
+static void __lambda_73(void *data, int argc, closure _,object k_73243) ;
+static void __lambda_74(void *data, int argc, object self_73317, object r_73244) ;
+static void __lambda_29(void *data, int argc, closure _,object k_73191, object name_7347_73116, object count_7348_73117, object thunk_7349_73118, object ok_127_7350_73119) ;
+static void __lambda_30(void *data, int argc, object self_73272, object rounded_73121) ;
+static void __lambda_78(void *data, int argc, object self_73273, object rounded_73121) ;
+static void __lambda_71(void *data, int argc, object self_73274, object k_73238, object x_7351_73123) ;
+static void __lambda_72(void *data, int argc, object self_73275, object r_73239) ;
+static void __lambda_31(void *data, int argc, object self_73276, object r_73192) ;
+static void __lambda_32(void *data, int argc, object self_73277, object r_73193) ;
+static void __lambda_33(void *data, int argc, object self_73278, object r_73194) ;
+static void __lambda_34(void *data, int argc, object self_73279, object r_73195) ;
+static void __lambda_35(void *data, int argc, object self_73280, object r_73236) ;
+static void __lambda_36(void *data, int argc, object self_73281, object r_73196) ;
+static void __lambda_37(void *data, int argc, object self_73282, object j_95s_7354_73124) ;
+static void __lambda_38(void *data, int argc, object self_73283, object t0_7357_73125) ;
+static void __lambda_39(void *data, int argc, object self_73284, object j0_7360_73126) ;
+static void __lambda_40(void *data, int argc, object self_73285, object loop_7365_73129) ;
+static void __lambda_77(void *data, int argc, object self_73286, object loop_7365_73129) ;
+static void __lambda_42(void *data, int argc, object self_73287, object k_73202, object i_7366_73130, object result_7367_73131) ;
+static void __lambda_44(void *data, int argc, object self_73289, object r_73206) ;
+static void __lambda_66(void *data, int argc, object self_73311, object r_73231) ;
+static void __lambda_67(void *data, int argc, object self_73312, object r_73232) ;
+static void __lambda_68(void *data, int argc, object self_73313, object r_73233) ;
+static void __lambda_69(void *data, int argc, object self_73314, object r_73235) ;
+static void __lambda_70(void *data, int argc, object self_73315, object r_73234) ;
+static void __lambda_45(void *data, int argc, object self_73290, object j1_7376_73132) ;
+static void __lambda_46(void *data, int argc, object self_73291, object t1_7379_73133) ;
+static void __lambda_47(void *data, int argc, object self_73292, object secs_7385_73135) ;
+static void __lambda_48(void *data, int argc, object self_73293, object secs2_7388_73136) ;
+static void __lambda_49(void *data, int argc, object self_73294, object r_73213) ;
+static void __lambda_50(void *data, int argc, object self_73295, object r_73214) ;
+static void __lambda_51(void *data, int argc, object self_73296, object r_73215) ;
+static void __lambda_52(void *data, int argc, object self_73297, object r_73216) ;
+static void __lambda_53(void *data, int argc, object self_73298, object r_73217) ;
+static void __lambda_54(void *data, int argc, object self_73299, object r_73218) ;
+static void __lambda_55(void *data, int argc, object self_73300, object r_73219) ;
+static void __lambda_56(void *data, int argc, object self_73301, object r_73220) ;
+static void __lambda_57(void *data, int argc, object self_73302, object r_73228) ;
+static void __lambda_58(void *data, int argc, object self_73303, object r_73221) ;
+static void __lambda_59(void *data, int argc, object self_73304, object r_73222) ;
+static void __lambda_60(void *data, int argc, object self_73305, object r_73223) ;
+static void __lambda_61(void *data, int argc, object self_73306, object r_73224) ;
+static void __lambda_62(void *data, int argc, object self_73307, object r_73225) ;
+static void __lambda_63(void *data, int argc, object self_73308, object r_73226) ;
+static void __lambda_64(void *data, int argc, object self_73309, object r_73227) ;
+static void __lambda_65(void *data, int argc, object self_73310, object r_73207) ;
+static void __lambda_43(void *data, int argc, object self_73288, object r_73205) ;
+static void __lambda_41(void *data, int argc, object self_73316, object r_73200) ;
+static void __lambda_22(void *data, int argc, closure _,object k_73177, object r_7342_73111, object x_7343_73112) ;
+static void __lambda_28(void *data, int argc, object self_73271, object k_73180, object v_7345_73114, object i_7346_73115) ;
+static void __lambda_23(void *data, int argc, object self_73266, object k_73182) ;
+static void __lambda_27(void *data, int argc, object self_73270, object k_73188, object x_7344_73113) ;
+static void __lambda_24(void *data, int argc, object self_73267, object r_73183) ;
+static void __lambda_26(void *data, int argc, object self_73268, object r_73184) ;
+static void __lambda_25(void *data, int argc, object self_73269, object k_73185) ;
+static void __lambda_11(void *data, int argc, closure _,object k_73161) ;
+static void __lambda_12(void *data, int argc, object self_73256, object count_7321_73103) ;
+static void __lambda_13(void *data, int argc, object self_73257, object input1_7324_73104) ;
+static void __lambda_14(void *data, int argc, object self_73258, object output_7327_73105) ;
+static void __lambda_15(void *data, int argc, object self_73259, object s2_7330_73106) ;
+static void __lambda_16(void *data, int argc, object self_73260, object s1_7333_73107) ;
+static void __lambda_17(void *data, int argc, object self_73261, object r_73174) ;
+static void __lambda_18(void *data, int argc, object self_73262, object ll_7336_73108) ;
+static void __lambda_19(void *data, int argc, object self_73263, object r_73168) ;
+static void __lambda_21(void *data, int argc, object self_73265, object k_73171, object result_7341_73110) ;
+static void __lambda_20(void *data, int argc, object self_73264, object k_73173) ;
+static void __lambda_6(void *data, int argc, closure _,object k_73150, object l_7310_7397) ;
+static void __lambda_7(void *data, int argc, object self_73251, object l_7314_7398, object a_7315_7399) ;
+static void __lambda_8(void *data, int argc, object self_73252, object lp_7311_7316_73100) ;
+static void __lambda_76(void *data, int argc, object self_73253, object lp_7311_7316_73100) ;
+static void __lambda_10(void *data, int argc, object self_73254, object k_73154, object l_7317_73101, object a_7318_73102) ;
+static void __lambda_9(void *data, int argc, object self_73255, object r_73152) ;
+static void __lambda_1(void *data, int argc, closure _,object k_73139, object n_731_7391) ;
+static void __lambda_2(void *data, int argc, object self_73246, object n_735_7392, object a_736_7393) ;
+static void __lambda_3(void *data, int argc, object self_73247, object lp_732_737_7394) ;
+static void __lambda_75(void *data, int argc, object self_73248, object lp_732_737_7394) ;
+static void __lambda_5(void *data, int argc, object self_73249, object k_73143, object n_738_7395, object a_739_7396) ;
+static void __lambda_4(void *data, int argc, object self_73250, object r_73141) ;
+
+static void __lambda_73(void *data, int argc, closure _,object k_73243) {
+  Cyc_st_add(data, "diviter.scm:this-scheme-implementation-name");
+
+closureN_type c_73636;
+c_73636.hdr.mark = gc_color_red;
+ c_73636.hdr.grayed = 0;
+c_73636.tag = closureN_tag;
+ c_73636.fn = (function_type)__lambda_74;
+c_73636.pc = 0;
+c_73636.num_args = 1;
+c_73636.num_elements = 1;
+c_73636.elements = (object *)alloca(sizeof(object) * 1);
+c_73636.elements[0] = k_73243;
+
+return_closcall1(data,  __glo_Cyc_91version_scheme_base,  &c_73636);; 
+}
+
+static void __lambda_74(void *data, int argc, object self_73317, object r_73244) {
+  
+make_utf8_string_with_len(c_73642, "cyclone-", 8, 8);
+
+object c_73641 = Cyc_string_append(data,  ((closureN)self_73317)->elements[0],2,&c_73642, r_73244);
+return_closcall1(data,  ((closureN)self_73317)->elements[0],  c_73641);; 
+}
+
+static void __lambda_29(void *data, int argc, closure _,object k_73191, object name_7347_73116, object count_7348_73117, object thunk_7349_73118, object ok_127_7350_73119) {
+  Cyc_st_add(data, "diviter.scm:run-r7rs-benchmark");
+
+closureN_type c_73465;
+c_73465.hdr.mark = gc_color_red;
+ c_73465.hdr.grayed = 0;
+c_73465.tag = closureN_tag;
+ c_73465.fn = (function_type)__lambda_30;
+c_73465.pc = 0;
+c_73465.num_args = 1;
+c_73465.num_elements = 5;
+c_73465.elements = (object *)alloca(sizeof(object) * 5);
+c_73465.elements[0] = count_7348_73117;
+c_73465.elements[1] = k_73191;
+c_73465.elements[2] = name_7347_73116;
+c_73465.elements[3] = ok_127_7350_73119;
+c_73465.elements[4] = thunk_7349_73118;
+
+return_direct_with_clo1(data,(closure)&c_73465,__lambda_30,  boolean_f);; 
+}
+
+static void __lambda_30(void *data, int argc, object self_73272, object rounded_73121) {
+  
+closureN_type c_73467;
+c_73467.hdr.mark = gc_color_red;
+ c_73467.hdr.grayed = 0;
+c_73467.tag = closureN_tag;
+ c_73467.fn = (function_type)__lambda_78;
+c_73467.pc = 0;
+c_73467.num_args = 1;
+c_73467.num_elements = 5;
+c_73467.elements = (object *)alloca(sizeof(object) * 5);
+c_73467.elements[0] = ((closureN)self_73272)->elements[0];
+c_73467.elements[1] = ((closureN)self_73272)->elements[1];
+c_73467.elements[2] = ((closureN)self_73272)->elements[2];
+c_73467.elements[3] = ((closureN)self_73272)->elements[3];
+c_73467.elements[4] = ((closureN)self_73272)->elements[4];
+
+
+make_cell(c_73633,rounded_73121);
+return_direct_with_clo1(data,(closure)&c_73467,__lambda_78,  &c_73633);; 
+}
+
+static void __lambda_78(void *data, int argc, object self_73273, object rounded_73121) {
+  
+closureN_type c_73469;
+c_73469.hdr.mark = gc_color_red;
+ c_73469.hdr.grayed = 0;
+c_73469.tag = closureN_tag;
+ c_73469.fn = (function_type)__lambda_31;
+c_73469.pc = 0;
+c_73469.num_args = 1;
+c_73469.num_elements = 6;
+c_73469.elements = (object *)alloca(sizeof(object) * 6);
+c_73469.elements[0] = ((closureN)self_73273)->elements[0];
+c_73469.elements[1] = ((closureN)self_73273)->elements[1];
+c_73469.elements[2] = ((closureN)self_73273)->elements[2];
+c_73469.elements[3] = ((closureN)self_73273)->elements[3];
+c_73469.elements[4] = rounded_73121;
+c_73469.elements[5] = ((closureN)self_73273)->elements[4];
+
+
+mclosure0(c_73618, (function_type)__lambda_71);c_73618.num_args = 1;
+return_direct_with_clo1(data,(closure)&c_73469,__lambda_31,  Cyc_set_cell(data, rounded_73121, &c_73618));; 
+}
+
+static void __lambda_71(void *data, int argc, object self_73274, object k_73238, object x_7351_73123) {
+  
+closureN_type c_73620;
+c_73620.hdr.mark = gc_color_red;
+ c_73620.hdr.grayed = 0;
+c_73620.tag = closureN_tag;
+ c_73620.fn = (function_type)__lambda_72;
+c_73620.pc = 0;
+c_73620.num_args = 1;
+c_73620.num_elements = 1;
+c_73620.elements = (object *)alloca(sizeof(object) * 1);
+c_73620.elements[0] = k_73238;
+
+
+complex_num_type local_73629; object c_73630 = Cyc_fast_mul(data,&local_73629,obj_int2obj(1000), x_7351_73123);
+return_closcall2(data,  __glo_round_scheme_base,  &c_73620, c_73630);; 
+}
+
+static void __lambda_72(void *data, int argc, object self_73275, object r_73239) {
+  
+complex_num_type local_73625; object c_73626 = Cyc_fast_div(data,&local_73625,r_73239, obj_int2obj(1000));
+return_closcall1(data,  ((closureN)self_73275)->elements[0],  c_73626);; 
+}
+
+static void __lambda_31(void *data, int argc, object self_73276, object r_73192) {
+  
+closureN_type c_73471;
+c_73471.hdr.mark = gc_color_red;
+ c_73471.hdr.grayed = 0;
+c_73471.tag = closureN_tag;
+ c_73471.fn = (function_type)__lambda_32;
+c_73471.pc = 0;
+c_73471.num_args = 1;
+c_73471.num_elements = 6;
+c_73471.elements = (object *)alloca(sizeof(object) * 6);
+c_73471.elements[0] = ((closureN)self_73276)->elements[0];
+c_73471.elements[1] = ((closureN)self_73276)->elements[1];
+c_73471.elements[2] = ((closureN)self_73276)->elements[2];
+c_73471.elements[3] = ((closureN)self_73276)->elements[3];
+c_73471.elements[4] = ((closureN)self_73276)->elements[4];
+c_73471.elements[5] = ((closureN)self_73276)->elements[5];
+
+
+make_utf8_string_with_len(c_73615, "Running ", 8, 8);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73471, &c_73615);; 
+}
+
+static void __lambda_32(void *data, int argc, object self_73277, object r_73193) {
+  
+closureN_type c_73473;
+c_73473.hdr.mark = gc_color_red;
+ c_73473.hdr.grayed = 0;
+c_73473.tag = closureN_tag;
+ c_73473.fn = (function_type)__lambda_33;
+c_73473.pc = 0;
+c_73473.num_args = 1;
+c_73473.num_elements = 6;
+c_73473.elements = (object *)alloca(sizeof(object) * 6);
+c_73473.elements[0] = ((closureN)self_73277)->elements[0];
+c_73473.elements[1] = ((closureN)self_73277)->elements[1];
+c_73473.elements[2] = ((closureN)self_73277)->elements[2];
+c_73473.elements[3] = ((closureN)self_73277)->elements[3];
+c_73473.elements[4] = ((closureN)self_73277)->elements[4];
+c_73473.elements[5] = ((closureN)self_73277)->elements[5];
+
+return_closcall2(data,  __glo_display_scheme_write,  &c_73473, ((closureN)self_73277)->elements[2]);; 
+}
+
+static void __lambda_33(void *data, int argc, object self_73278, object r_73194) {
+  
+closureN_type c_73475;
+c_73475.hdr.mark = gc_color_red;
+ c_73475.hdr.grayed = 0;
+c_73475.tag = closureN_tag;
+ c_73475.fn = (function_type)__lambda_34;
+c_73475.pc = 0;
+c_73475.num_args = 1;
+c_73475.num_elements = 6;
+c_73475.elements = (object *)alloca(sizeof(object) * 6);
+c_73475.elements[0] = ((closureN)self_73278)->elements[0];
+c_73475.elements[1] = ((closureN)self_73278)->elements[1];
+c_73475.elements[2] = ((closureN)self_73278)->elements[2];
+c_73475.elements[3] = ((closureN)self_73278)->elements[3];
+c_73475.elements[4] = ((closureN)self_73278)->elements[4];
+c_73475.elements[5] = ((closureN)self_73278)->elements[5];
+
+return_closcall1(data,  __glo_newline_scheme_base,  &c_73475);; 
+}
+
+static void __lambda_34(void *data, int argc, object self_73279, object r_73195) {
+  
+closureN_type c_73477;
+c_73477.hdr.mark = gc_color_red;
+ c_73477.hdr.grayed = 0;
+c_73477.tag = closureN_tag;
+ c_73477.fn = (function_type)__lambda_35;
+c_73477.pc = 0;
+c_73477.num_args = 1;
+c_73477.num_elements = 6;
+c_73477.elements = (object *)alloca(sizeof(object) * 6);
+c_73477.elements[0] = ((closureN)self_73279)->elements[0];
+c_73477.elements[1] = ((closureN)self_73279)->elements[1];
+c_73477.elements[2] = ((closureN)self_73279)->elements[2];
+c_73477.elements[3] = ((closureN)self_73279)->elements[3];
+c_73477.elements[4] = ((closureN)self_73279)->elements[4];
+c_73477.elements[5] = ((closureN)self_73279)->elements[5];
+
+return_closcall1(data,  __glo_current_91output_91port_scheme_base,  &c_73477);; 
+}
+
+static void __lambda_35(void *data, int argc, object self_73280, object r_73236) {
+  
+closureN_type c_73479;
+c_73479.hdr.mark = gc_color_red;
+ c_73479.hdr.grayed = 0;
+c_73479.tag = closureN_tag;
+ c_73479.fn = (function_type)__lambda_36;
+c_73479.pc = 0;
+c_73479.num_args = 1;
+c_73479.num_elements = 6;
+c_73479.elements = (object *)alloca(sizeof(object) * 6);
+c_73479.elements[0] = ((closureN)self_73280)->elements[0];
+c_73479.elements[1] = ((closureN)self_73280)->elements[1];
+c_73479.elements[2] = ((closureN)self_73280)->elements[2];
+c_73479.elements[3] = ((closureN)self_73280)->elements[3];
+c_73479.elements[4] = ((closureN)self_73280)->elements[4];
+c_73479.elements[5] = ((closureN)self_73280)->elements[5];
+
+return_closcall2(data,  __glo_flush_91output_91port_scheme_base,  &c_73479, r_73236);; 
+}
+
+static void __lambda_36(void *data, int argc, object self_73281, object r_73196) {
+  
+closureN_type c_73481;
+c_73481.hdr.mark = gc_color_red;
+ c_73481.hdr.grayed = 0;
+c_73481.tag = closureN_tag;
+ c_73481.fn = (function_type)__lambda_37;
+c_73481.pc = 0;
+c_73481.num_args = 1;
+c_73481.num_elements = 6;
+c_73481.elements = (object *)alloca(sizeof(object) * 6);
+c_73481.elements[0] = ((closureN)self_73281)->elements[0];
+c_73481.elements[1] = ((closureN)self_73281)->elements[1];
+c_73481.elements[2] = ((closureN)self_73281)->elements[2];
+c_73481.elements[3] = ((closureN)self_73281)->elements[3];
+c_73481.elements[4] = ((closureN)self_73281)->elements[4];
+c_73481.elements[5] = ((closureN)self_73281)->elements[5];
+
+return_closcall1(data,  __glo_jiffies_91per_91second_scheme_time,  &c_73481);; 
+}
+
+static void __lambda_37(void *data, int argc, object self_73282, object j_95s_7354_73124) {
+  
+closureN_type c_73483;
+c_73483.hdr.mark = gc_color_red;
+ c_73483.hdr.grayed = 0;
+c_73483.tag = closureN_tag;
+ c_73483.fn = (function_type)__lambda_38;
+c_73483.pc = 0;
+c_73483.num_args = 1;
+c_73483.num_elements = 7;
+c_73483.elements = (object *)alloca(sizeof(object) * 7);
+c_73483.elements[0] = ((closureN)self_73282)->elements[0];
+c_73483.elements[1] = j_95s_7354_73124;
+c_73483.elements[2] = ((closureN)self_73282)->elements[1];
+c_73483.elements[3] = ((closureN)self_73282)->elements[2];
+c_73483.elements[4] = ((closureN)self_73282)->elements[3];
+c_73483.elements[5] = ((closureN)self_73282)->elements[4];
+c_73483.elements[6] = ((closureN)self_73282)->elements[5];
+
+return_closcall1(data,  __glo_current_91second_scheme_time,  &c_73483);; 
+}
+
+static void __lambda_38(void *data, int argc, object self_73283, object t0_7357_73125) {
+  
+closureN_type c_73485;
+c_73485.hdr.mark = gc_color_red;
+ c_73485.hdr.grayed = 0;
+c_73485.tag = closureN_tag;
+ c_73485.fn = (function_type)__lambda_39;
+c_73485.pc = 0;
+c_73485.num_args = 1;
+c_73485.num_elements = 8;
+c_73485.elements = (object *)alloca(sizeof(object) * 8);
+c_73485.elements[0] = ((closureN)self_73283)->elements[0];
+c_73485.elements[1] = ((closureN)self_73283)->elements[1];
+c_73485.elements[2] = ((closureN)self_73283)->elements[2];
+c_73485.elements[3] = ((closureN)self_73283)->elements[3];
+c_73485.elements[4] = ((closureN)self_73283)->elements[4];
+c_73485.elements[5] = ((closureN)self_73283)->elements[5];
+c_73485.elements[6] = t0_7357_73125;
+c_73485.elements[7] = ((closureN)self_73283)->elements[6];
+
+return_closcall1(data,  __glo_current_91jiffy_scheme_time,  &c_73485);; 
+}
+
+static void __lambda_39(void *data, int argc, object self_73284, object j0_7360_73126) {
+  
+closureN_type c_73487;
+c_73487.hdr.mark = gc_color_red;
+ c_73487.hdr.grayed = 0;
+c_73487.tag = closureN_tag;
+ c_73487.fn = (function_type)__lambda_40;
+c_73487.pc = 0;
+c_73487.num_args = 1;
+c_73487.num_elements = 9;
+c_73487.elements = (object *)alloca(sizeof(object) * 9);
+c_73487.elements[0] = ((closureN)self_73284)->elements[0];
+c_73487.elements[1] = ((closureN)self_73284)->elements[1];
+c_73487.elements[2] = j0_7360_73126;
+c_73487.elements[3] = ((closureN)self_73284)->elements[2];
+c_73487.elements[4] = ((closureN)self_73284)->elements[3];
+c_73487.elements[5] = ((closureN)self_73284)->elements[4];
+c_73487.elements[6] = ((closureN)self_73284)->elements[5];
+c_73487.elements[7] = ((closureN)self_73284)->elements[6];
+c_73487.elements[8] = ((closureN)self_73284)->elements[7];
+
+return_direct_with_clo1(data,(closure)&c_73487,__lambda_40,  boolean_f);; 
+}
+
+static void __lambda_40(void *data, int argc, object self_73285, object loop_7365_73129) {
+  
+closureN_type c_73489;
+c_73489.hdr.mark = gc_color_red;
+ c_73489.hdr.grayed = 0;
+c_73489.tag = closureN_tag;
+ c_73489.fn = (function_type)__lambda_77;
+c_73489.pc = 0;
+c_73489.num_args = 1;
+c_73489.num_elements = 9;
+c_73489.elements = (object *)alloca(sizeof(object) * 9);
+c_73489.elements[0] = ((closureN)self_73285)->elements[0];
+c_73489.elements[1] = ((closureN)self_73285)->elements[1];
+c_73489.elements[2] = ((closureN)self_73285)->elements[2];
+c_73489.elements[3] = ((closureN)self_73285)->elements[3];
+c_73489.elements[4] = ((closureN)self_73285)->elements[4];
+c_73489.elements[5] = ((closureN)self_73285)->elements[5];
+c_73489.elements[6] = ((closureN)self_73285)->elements[6];
+c_73489.elements[7] = ((closureN)self_73285)->elements[7];
+c_73489.elements[8] = ((closureN)self_73285)->elements[8];
+
+
+make_cell(c_73613,loop_7365_73129);
+return_direct_with_clo1(data,(closure)&c_73489,__lambda_77,  &c_73613);; 
+}
+
+static void __lambda_77(void *data, int argc, object self_73286, object loop_7365_73129) {
+  
+closureN_type c_73491;
+c_73491.hdr.mark = gc_color_red;
+ c_73491.hdr.grayed = 0;
+c_73491.tag = closureN_tag;
+ c_73491.fn = (function_type)__lambda_41;
+c_73491.pc = 0;
+c_73491.num_args = 1;
+c_73491.num_elements = 2;
+c_73491.elements = (object *)alloca(sizeof(object) * 2);
+c_73491.elements[0] = ((closureN)self_73286)->elements[3];
+c_73491.elements[1] = loop_7365_73129;
+
+
+closureN_type c_73499;
+c_73499.hdr.mark = gc_color_red;
+ c_73499.hdr.grayed = 0;
+c_73499.tag = closureN_tag;
+ c_73499.fn = (function_type)__lambda_42;
+c_73499.pc = 0;
+c_73499.num_args = 2;
+c_73499.num_elements = 9;
+c_73499.elements = (object *)alloca(sizeof(object) * 9);
+c_73499.elements[0] = ((closureN)self_73286)->elements[0];
+c_73499.elements[1] = ((closureN)self_73286)->elements[1];
+c_73499.elements[2] = ((closureN)self_73286)->elements[2];
+c_73499.elements[3] = loop_7365_73129;
+c_73499.elements[4] = ((closureN)self_73286)->elements[4];
+c_73499.elements[5] = ((closureN)self_73286)->elements[5];
+c_73499.elements[6] = ((closureN)self_73286)->elements[6];
+c_73499.elements[7] = ((closureN)self_73286)->elements[7];
+c_73499.elements[8] = ((closureN)self_73286)->elements[8];
+
+return_direct_with_clo1(data,(closure)&c_73491,__lambda_41,  Cyc_set_cell(data, loop_7365_73129, &c_73499));; 
+}
+
+static void __lambda_42(void *data, int argc, object self_73287, object k_73202, object i_7366_73130, object result_7367_73131) {
+    object c_73502 = Cyc_num_fast_lt_op(data,i_7366_73130, ((closureN)self_73287)->elements[0]);
+if( (boolean_f != c_73502) ){ 
+  
+closureN_type c_73506;
+c_73506.hdr.mark = gc_color_red;
+ c_73506.hdr.grayed = 0;
+c_73506.tag = closureN_tag;
+ c_73506.fn = (function_type)__lambda_43;
+c_73506.pc = 0;
+c_73506.num_args = 1;
+c_73506.num_elements = 3;
+c_73506.elements = (object *)alloca(sizeof(object) * 3);
+c_73506.elements[0] = i_7366_73130;
+c_73506.elements[1] = k_73202;
+c_73506.elements[2] = ((closureN)self_73287)->elements[3];
+
+return_closcall1(data,  ((closureN)self_73287)->elements[8],  &c_73506);
+} else { 
+  
+closureN_type c_73519;
+c_73519.hdr.mark = gc_color_red;
+ c_73519.hdr.grayed = 0;
+c_73519.tag = closureN_tag;
+ c_73519.fn = (function_type)__lambda_44;
+c_73519.pc = 0;
+c_73519.num_args = 1;
+c_73519.num_elements = 7;
+c_73519.elements = (object *)alloca(sizeof(object) * 7);
+c_73519.elements[0] = ((closureN)self_73287)->elements[1];
+c_73519.elements[1] = ((closureN)self_73287)->elements[2];
+c_73519.elements[2] = k_73202;
+c_73519.elements[3] = ((closureN)self_73287)->elements[4];
+c_73519.elements[4] = result_7367_73131;
+c_73519.elements[5] = ((closureN)self_73287)->elements[6];
+c_73519.elements[6] = ((closureN)self_73287)->elements[7];
+
+return_closcall2(data,  ((closureN)self_73287)->elements[5],  &c_73519, result_7367_73131);}
+; 
+}
+
+static void __lambda_44(void *data, int argc, object self_73289, object r_73206) {
+  if( (boolean_f != r_73206) ){ 
+  
+closureN_type c_73521;
+c_73521.hdr.mark = gc_color_red;
+ c_73521.hdr.grayed = 0;
+c_73521.tag = closureN_tag;
+ c_73521.fn = (function_type)__lambda_45;
+c_73521.pc = 0;
+c_73521.num_args = 1;
+c_73521.num_elements = 7;
+c_73521.elements = (object *)alloca(sizeof(object) * 7);
+c_73521.elements[0] = ((closureN)self_73289)->elements[0];
+c_73521.elements[1] = ((closureN)self_73289)->elements[1];
+c_73521.elements[2] = ((closureN)self_73289)->elements[2];
+c_73521.elements[3] = ((closureN)self_73289)->elements[3];
+c_73521.elements[4] = ((closureN)self_73289)->elements[4];
+c_73521.elements[5] = ((closureN)self_73289)->elements[5];
+c_73521.elements[6] = ((closureN)self_73289)->elements[6];
+
+return_closcall1(data,  __glo_current_91jiffy_scheme_time,  &c_73521);
+} else { 
+  
+closureN_type c_73597;
+c_73597.hdr.mark = gc_color_red;
+ c_73597.hdr.grayed = 0;
+c_73597.tag = closureN_tag;
+ c_73597.fn = (function_type)__lambda_66;
+c_73597.pc = 0;
+c_73597.num_args = 1;
+c_73597.num_elements = 2;
+c_73597.elements = (object *)alloca(sizeof(object) * 2);
+c_73597.elements[0] = ((closureN)self_73289)->elements[2];
+c_73597.elements[1] = ((closureN)self_73289)->elements[4];
+
+
+make_utf8_string_with_len(c_73610, "ERROR: returned incorrect result: ", 34, 34);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73597, &c_73610);}
+; 
+}
+
+static void __lambda_66(void *data, int argc, object self_73311, object r_73231) {
+  
+closureN_type c_73599;
+c_73599.hdr.mark = gc_color_red;
+ c_73599.hdr.grayed = 0;
+c_73599.tag = closureN_tag;
+ c_73599.fn = (function_type)__lambda_67;
+c_73599.pc = 0;
+c_73599.num_args = 1;
+c_73599.num_elements = 2;
+c_73599.elements = (object *)alloca(sizeof(object) * 2);
+c_73599.elements[0] = ((closureN)self_73311)->elements[0];
+c_73599.elements[1] = ((closureN)self_73311)->elements[1];
+
+return_closcall2(data,  __glo_write_scheme_write,  &c_73599, ((closureN)self_73311)->elements[1]);; 
+}
+
+static void __lambda_67(void *data, int argc, object self_73312, object r_73232) {
+  
+closureN_type c_73601;
+c_73601.hdr.mark = gc_color_red;
+ c_73601.hdr.grayed = 0;
+c_73601.tag = closureN_tag;
+ c_73601.fn = (function_type)__lambda_68;
+c_73601.pc = 0;
+c_73601.num_args = 1;
+c_73601.num_elements = 2;
+c_73601.elements = (object *)alloca(sizeof(object) * 2);
+c_73601.elements[0] = ((closureN)self_73312)->elements[0];
+c_73601.elements[1] = ((closureN)self_73312)->elements[1];
+
+return_closcall1(data,  __glo_newline_scheme_base,  &c_73601);; 
+}
+
+static void __lambda_68(void *data, int argc, object self_73313, object r_73233) {
+  
+closureN_type c_73603;
+c_73603.hdr.mark = gc_color_red;
+ c_73603.hdr.grayed = 0;
+c_73603.tag = closureN_tag;
+ c_73603.fn = (function_type)__lambda_69;
+c_73603.pc = 0;
+c_73603.num_args = 1;
+c_73603.num_elements = 2;
+c_73603.elements = (object *)alloca(sizeof(object) * 2);
+c_73603.elements[0] = ((closureN)self_73313)->elements[0];
+c_73603.elements[1] = ((closureN)self_73313)->elements[1];
+
+return_closcall1(data,  __glo_current_91output_91port_scheme_base,  &c_73603);; 
+}
+
+static void __lambda_69(void *data, int argc, object self_73314, object r_73235) {
+  
+closureN_type c_73605;
+c_73605.hdr.mark = gc_color_red;
+ c_73605.hdr.grayed = 0;
+c_73605.tag = closureN_tag;
+ c_73605.fn = (function_type)__lambda_70;
+c_73605.pc = 0;
+c_73605.num_args = 1;
+c_73605.num_elements = 2;
+c_73605.elements = (object *)alloca(sizeof(object) * 2);
+c_73605.elements[0] = ((closureN)self_73314)->elements[0];
+c_73605.elements[1] = ((closureN)self_73314)->elements[1];
+
+return_closcall2(data,  __glo_flush_91output_91port_scheme_base,  &c_73605, r_73235);; 
+}
+
+static void __lambda_70(void *data, int argc, object self_73315, object r_73234) {
+  return_closcall1(data,  ((closureN)self_73315)->elements[0],  ((closureN)self_73315)->elements[1]);; 
+}
+
+static void __lambda_45(void *data, int argc, object self_73290, object j1_7376_73132) {
+  
+closureN_type c_73523;
+c_73523.hdr.mark = gc_color_red;
+ c_73523.hdr.grayed = 0;
+c_73523.tag = closureN_tag;
+ c_73523.fn = (function_type)__lambda_46;
+c_73523.pc = 0;
+c_73523.num_args = 1;
+c_73523.num_elements = 8;
+c_73523.elements = (object *)alloca(sizeof(object) * 8);
+c_73523.elements[0] = ((closureN)self_73290)->elements[0];
+c_73523.elements[1] = ((closureN)self_73290)->elements[1];
+c_73523.elements[2] = j1_7376_73132;
+c_73523.elements[3] = ((closureN)self_73290)->elements[2];
+c_73523.elements[4] = ((closureN)self_73290)->elements[3];
+c_73523.elements[5] = ((closureN)self_73290)->elements[4];
+c_73523.elements[6] = ((closureN)self_73290)->elements[5];
+c_73523.elements[7] = ((closureN)self_73290)->elements[6];
+
+return_closcall1(data,  __glo_current_91second_scheme_time,  &c_73523);; 
+}
+
+static void __lambda_46(void *data, int argc, object self_73291, object t1_7379_73133) {
+  
+closureN_type c_73525;
+c_73525.hdr.mark = gc_color_red;
+ c_73525.hdr.grayed = 0;
+c_73525.tag = closureN_tag;
+ c_73525.fn = (function_type)__lambda_47;
+c_73525.pc = 0;
+c_73525.num_args = 1;
+c_73525.num_elements = 6;
+c_73525.elements = (object *)alloca(sizeof(object) * 6);
+c_73525.elements[0] = ((closureN)self_73291)->elements[3];
+c_73525.elements[1] = ((closureN)self_73291)->elements[4];
+c_73525.elements[2] = ((closureN)self_73291)->elements[5];
+c_73525.elements[3] = ((closureN)self_73291)->elements[6];
+c_73525.elements[4] = ((closureN)self_73291)->elements[7];
+c_73525.elements[5] = t1_7379_73133;
+
+
+complex_num_type local_73591; object c_73592 = Cyc_fast_sub(data,&local_73591,((closureN)self_73291)->elements[2], ((closureN)self_73291)->elements[1]);
+
+complex_num_type local_73587; object c_73588 = Cyc_fast_div(data,&local_73587,c_73592, ((closureN)self_73291)->elements[0]);
+return_closcall2(data,  __glo_inexact_scheme_base,  &c_73525, c_73588);; 
+}
+
+static void __lambda_47(void *data, int argc, object self_73292, object secs_7385_73135) {
+  
+closureN_type c_73530;
+c_73530.hdr.mark = gc_color_red;
+ c_73530.hdr.grayed = 0;
+c_73530.tag = closureN_tag;
+ c_73530.fn = (function_type)__lambda_48;
+c_73530.pc = 0;
+c_73530.num_args = 1;
+c_73530.num_elements = 4;
+c_73530.elements = (object *)alloca(sizeof(object) * 4);
+c_73530.elements[0] = ((closureN)self_73292)->elements[0];
+c_73530.elements[1] = ((closureN)self_73292)->elements[1];
+c_73530.elements[2] = ((closureN)self_73292)->elements[2];
+c_73530.elements[3] = secs_7385_73135;
+
+
+complex_num_type local_73581; object c_73582 = Cyc_fast_sub(data,&local_73581,((closureN)self_73292)->elements[5], ((closureN)self_73292)->elements[4]);
+return_closcall2(data,  car(((closureN)self_73292)->elements[3]),  &c_73530, c_73582);; 
+}
+
+static void __lambda_48(void *data, int argc, object self_73293, object secs2_7388_73136) {
+  
+closureN_type c_73532;
+c_73532.hdr.mark = gc_color_red;
+ c_73532.hdr.grayed = 0;
+c_73532.tag = closureN_tag;
+ c_73532.fn = (function_type)__lambda_49;
+c_73532.pc = 0;
+c_73532.num_args = 1;
+c_73532.num_elements = 5;
+c_73532.elements = (object *)alloca(sizeof(object) * 5);
+c_73532.elements[0] = ((closureN)self_73293)->elements[0];
+c_73532.elements[1] = ((closureN)self_73293)->elements[1];
+c_73532.elements[2] = ((closureN)self_73293)->elements[2];
+c_73532.elements[3] = ((closureN)self_73293)->elements[3];
+c_73532.elements[4] = secs2_7388_73136;
+
+
+make_utf8_string_with_len(c_73578, "Elapsed time: ", 14, 14);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73532, &c_73578);; 
+}
+
+static void __lambda_49(void *data, int argc, object self_73294, object r_73213) {
+  
+closureN_type c_73534;
+c_73534.hdr.mark = gc_color_red;
+ c_73534.hdr.grayed = 0;
+c_73534.tag = closureN_tag;
+ c_73534.fn = (function_type)__lambda_50;
+c_73534.pc = 0;
+c_73534.num_args = 1;
+c_73534.num_elements = 5;
+c_73534.elements = (object *)alloca(sizeof(object) * 5);
+c_73534.elements[0] = ((closureN)self_73294)->elements[0];
+c_73534.elements[1] = ((closureN)self_73294)->elements[1];
+c_73534.elements[2] = ((closureN)self_73294)->elements[2];
+c_73534.elements[3] = ((closureN)self_73294)->elements[3];
+c_73534.elements[4] = ((closureN)self_73294)->elements[4];
+
+return_closcall2(data,  __glo_write_scheme_write,  &c_73534, ((closureN)self_73294)->elements[3]);; 
+}
+
+static void __lambda_50(void *data, int argc, object self_73295, object r_73214) {
+  
+closureN_type c_73536;
+c_73536.hdr.mark = gc_color_red;
+ c_73536.hdr.grayed = 0;
+c_73536.tag = closureN_tag;
+ c_73536.fn = (function_type)__lambda_51;
+c_73536.pc = 0;
+c_73536.num_args = 1;
+c_73536.num_elements = 5;
+c_73536.elements = (object *)alloca(sizeof(object) * 5);
+c_73536.elements[0] = ((closureN)self_73295)->elements[0];
+c_73536.elements[1] = ((closureN)self_73295)->elements[1];
+c_73536.elements[2] = ((closureN)self_73295)->elements[2];
+c_73536.elements[3] = ((closureN)self_73295)->elements[3];
+c_73536.elements[4] = ((closureN)self_73295)->elements[4];
+
+
+make_utf8_string_with_len(c_73576, " seconds (", 10, 10);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73536, &c_73576);; 
+}
+
+static void __lambda_51(void *data, int argc, object self_73296, object r_73215) {
+  
+closureN_type c_73538;
+c_73538.hdr.mark = gc_color_red;
+ c_73538.hdr.grayed = 0;
+c_73538.tag = closureN_tag;
+ c_73538.fn = (function_type)__lambda_52;
+c_73538.pc = 0;
+c_73538.num_args = 1;
+c_73538.num_elements = 4;
+c_73538.elements = (object *)alloca(sizeof(object) * 4);
+c_73538.elements[0] = ((closureN)self_73296)->elements[0];
+c_73538.elements[1] = ((closureN)self_73296)->elements[1];
+c_73538.elements[2] = ((closureN)self_73296)->elements[2];
+c_73538.elements[3] = ((closureN)self_73296)->elements[3];
+
+return_closcall2(data,  __glo_write_scheme_write,  &c_73538, ((closureN)self_73296)->elements[4]);; 
+}
+
+static void __lambda_52(void *data, int argc, object self_73297, object r_73216) {
+  
+closureN_type c_73540;
+c_73540.hdr.mark = gc_color_red;
+ c_73540.hdr.grayed = 0;
+c_73540.tag = closureN_tag;
+ c_73540.fn = (function_type)__lambda_53;
+c_73540.pc = 0;
+c_73540.num_args = 1;
+c_73540.num_elements = 4;
+c_73540.elements = (object *)alloca(sizeof(object) * 4);
+c_73540.elements[0] = ((closureN)self_73297)->elements[0];
+c_73540.elements[1] = ((closureN)self_73297)->elements[1];
+c_73540.elements[2] = ((closureN)self_73297)->elements[2];
+c_73540.elements[3] = ((closureN)self_73297)->elements[3];
+
+
+make_utf8_string_with_len(c_73574, ") for ", 6, 6);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73540, &c_73574);; 
+}
+
+static void __lambda_53(void *data, int argc, object self_73298, object r_73217) {
+  
+closureN_type c_73542;
+c_73542.hdr.mark = gc_color_red;
+ c_73542.hdr.grayed = 0;
+c_73542.tag = closureN_tag;
+ c_73542.fn = (function_type)__lambda_54;
+c_73542.pc = 0;
+c_73542.num_args = 1;
+c_73542.num_elements = 4;
+c_73542.elements = (object *)alloca(sizeof(object) * 4);
+c_73542.elements[0] = ((closureN)self_73298)->elements[0];
+c_73542.elements[1] = ((closureN)self_73298)->elements[1];
+c_73542.elements[2] = ((closureN)self_73298)->elements[2];
+c_73542.elements[3] = ((closureN)self_73298)->elements[3];
+
+return_closcall2(data,  __glo_display_scheme_write,  &c_73542, ((closureN)self_73298)->elements[1]);; 
+}
+
+static void __lambda_54(void *data, int argc, object self_73299, object r_73218) {
+  
+closureN_type c_73544;
+c_73544.hdr.mark = gc_color_red;
+ c_73544.hdr.grayed = 0;
+c_73544.tag = closureN_tag;
+ c_73544.fn = (function_type)__lambda_55;
+c_73544.pc = 0;
+c_73544.num_args = 1;
+c_73544.num_elements = 4;
+c_73544.elements = (object *)alloca(sizeof(object) * 4);
+c_73544.elements[0] = ((closureN)self_73299)->elements[0];
+c_73544.elements[1] = ((closureN)self_73299)->elements[1];
+c_73544.elements[2] = ((closureN)self_73299)->elements[2];
+c_73544.elements[3] = ((closureN)self_73299)->elements[3];
+
+return_closcall1(data,  __glo_newline_scheme_base,  &c_73544);; 
+}
+
+static void __lambda_55(void *data, int argc, object self_73300, object r_73219) {
+  
+closureN_type c_73546;
+c_73546.hdr.mark = gc_color_red;
+ c_73546.hdr.grayed = 0;
+c_73546.tag = closureN_tag;
+ c_73546.fn = (function_type)__lambda_56;
+c_73546.pc = 0;
+c_73546.num_args = 1;
+c_73546.num_elements = 4;
+c_73546.elements = (object *)alloca(sizeof(object) * 4);
+c_73546.elements[0] = ((closureN)self_73300)->elements[0];
+c_73546.elements[1] = ((closureN)self_73300)->elements[1];
+c_73546.elements[2] = ((closureN)self_73300)->elements[2];
+c_73546.elements[3] = ((closureN)self_73300)->elements[3];
+
+
+make_utf8_string_with_len(c_73572, "+!CSVLINE!+", 11, 11);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73546, &c_73572);; 
+}
+
+static void __lambda_56(void *data, int argc, object self_73301, object r_73220) {
+  
+closureN_type c_73548;
+c_73548.hdr.mark = gc_color_red;
+ c_73548.hdr.grayed = 0;
+c_73548.tag = closureN_tag;
+ c_73548.fn = (function_type)__lambda_57;
+c_73548.pc = 0;
+c_73548.num_args = 1;
+c_73548.num_elements = 4;
+c_73548.elements = (object *)alloca(sizeof(object) * 4);
+c_73548.elements[0] = ((closureN)self_73301)->elements[0];
+c_73548.elements[1] = ((closureN)self_73301)->elements[1];
+c_73548.elements[2] = ((closureN)self_73301)->elements[2];
+c_73548.elements[3] = ((closureN)self_73301)->elements[3];
+
+return_closcall1(data,  __glo_this_91scheme_91implementation_91name,  &c_73548);; 
+}
+
+static void __lambda_57(void *data, int argc, object self_73302, object r_73228) {
+  
+closureN_type c_73550;
+c_73550.hdr.mark = gc_color_red;
+ c_73550.hdr.grayed = 0;
+c_73550.tag = closureN_tag;
+ c_73550.fn = (function_type)__lambda_58;
+c_73550.pc = 0;
+c_73550.num_args = 1;
+c_73550.num_elements = 4;
+c_73550.elements = (object *)alloca(sizeof(object) * 4);
+c_73550.elements[0] = ((closureN)self_73302)->elements[0];
+c_73550.elements[1] = ((closureN)self_73302)->elements[1];
+c_73550.elements[2] = ((closureN)self_73302)->elements[2];
+c_73550.elements[3] = ((closureN)self_73302)->elements[3];
+
+return_closcall2(data,  __glo_display_scheme_write,  &c_73550, r_73228);; 
+}
+
+static void __lambda_58(void *data, int argc, object self_73303, object r_73221) {
+  
+closureN_type c_73552;
+c_73552.hdr.mark = gc_color_red;
+ c_73552.hdr.grayed = 0;
+c_73552.tag = closureN_tag;
+ c_73552.fn = (function_type)__lambda_59;
+c_73552.pc = 0;
+c_73552.num_args = 1;
+c_73552.num_elements = 4;
+c_73552.elements = (object *)alloca(sizeof(object) * 4);
+c_73552.elements[0] = ((closureN)self_73303)->elements[0];
+c_73552.elements[1] = ((closureN)self_73303)->elements[1];
+c_73552.elements[2] = ((closureN)self_73303)->elements[2];
+c_73552.elements[3] = ((closureN)self_73303)->elements[3];
+
+
+make_utf8_string_with_len(c_73571, ",", 1, 1);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73552, &c_73571);; 
+}
+
+static void __lambda_59(void *data, int argc, object self_73304, object r_73222) {
+  
+closureN_type c_73554;
+c_73554.hdr.mark = gc_color_red;
+ c_73554.hdr.grayed = 0;
+c_73554.tag = closureN_tag;
+ c_73554.fn = (function_type)__lambda_60;
+c_73554.pc = 0;
+c_73554.num_args = 1;
+c_73554.num_elements = 3;
+c_73554.elements = (object *)alloca(sizeof(object) * 3);
+c_73554.elements[0] = ((closureN)self_73304)->elements[0];
+c_73554.elements[1] = ((closureN)self_73304)->elements[2];
+c_73554.elements[2] = ((closureN)self_73304)->elements[3];
+
+return_closcall2(data,  __glo_display_scheme_write,  &c_73554, ((closureN)self_73304)->elements[1]);; 
+}
+
+static void __lambda_60(void *data, int argc, object self_73305, object r_73223) {
+  
+closureN_type c_73556;
+c_73556.hdr.mark = gc_color_red;
+ c_73556.hdr.grayed = 0;
+c_73556.tag = closureN_tag;
+ c_73556.fn = (function_type)__lambda_61;
+c_73556.pc = 0;
+c_73556.num_args = 1;
+c_73556.num_elements = 3;
+c_73556.elements = (object *)alloca(sizeof(object) * 3);
+c_73556.elements[0] = ((closureN)self_73305)->elements[0];
+c_73556.elements[1] = ((closureN)self_73305)->elements[1];
+c_73556.elements[2] = ((closureN)self_73305)->elements[2];
+
+
+make_utf8_string_with_len(c_73569, ",", 1, 1);
+return_closcall2(data,  __glo_display_scheme_write,  &c_73556, &c_73569);; 
+}
+
+static void __lambda_61(void *data, int argc, object self_73306, object r_73224) {
+  
+closureN_type c_73558;
+c_73558.hdr.mark = gc_color_red;
+ c_73558.hdr.grayed = 0;
+c_73558.tag = closureN_tag;
+ c_73558.fn = (function_type)__lambda_62;
+c_73558.pc = 0;
+c_73558.num_args = 1;
+c_73558.num_elements = 2;
+c_73558.elements = (object *)alloca(sizeof(object) * 2);
+c_73558.elements[0] = ((closureN)self_73306)->elements[0];
+c_73558.elements[1] = ((closureN)self_73306)->elements[1];
+
+return_closcall2(data,  __glo_display_scheme_write,  &c_73558, ((closureN)self_73306)->elements[2]);; 
+}
+
+static void __lambda_62(void *data, int argc, object self_73307, object r_73225) {
+  
+closureN_type c_73560;
+c_73560.hdr.mark = gc_color_red;
+ c_73560.hdr.grayed = 0;
+c_73560.tag = closureN_tag;
+ c_73560.fn = (function_type)__lambda_63;
+c_73560.pc = 0;
+c_73560.num_args = 1;
+c_73560.num_elements = 2;
+c_73560.elements = (object *)alloca(sizeof(object) * 2);
+c_73560.elements[0] = ((closureN)self_73307)->elements[0];
+c_73560.elements[1] = ((closureN)self_73307)->elements[1];
+
+return_closcall1(data,  __glo_newline_scheme_base,  &c_73560);; 
+}
+
+static void __lambda_63(void *data, int argc, object self_73308, object r_73226) {
+  
+closureN_type c_73562;
+c_73562.hdr.mark = gc_color_red;
+ c_73562.hdr.grayed = 0;
+c_73562.tag = closureN_tag;
+ c_73562.fn = (function_type)__lambda_64;
+c_73562.pc = 0;
+c_73562.num_args = 1;
+c_73562.num_elements = 2;
+c_73562.elements = (object *)alloca(sizeof(object) * 2);
+c_73562.elements[0] = ((closureN)self_73308)->elements[0];
+c_73562.elements[1] = ((closureN)self_73308)->elements[1];
+
+return_closcall1(data,  __glo_current_91output_91port_scheme_base,  &c_73562);; 
+}
+
+static void __lambda_64(void *data, int argc, object self_73309, object r_73227) {
+  
+closureN_type c_73564;
+c_73564.hdr.mark = gc_color_red;
+ c_73564.hdr.grayed = 0;
+c_73564.tag = closureN_tag;
+ c_73564.fn = (function_type)__lambda_65;
+c_73564.pc = 0;
+c_73564.num_args = 1;
+c_73564.num_elements = 2;
+c_73564.elements = (object *)alloca(sizeof(object) * 2);
+c_73564.elements[0] = ((closureN)self_73309)->elements[0];
+c_73564.elements[1] = ((closureN)self_73309)->elements[1];
+
+return_closcall2(data,  __glo_flush_91output_91port_scheme_base,  &c_73564, r_73227);; 
+}
+
+static void __lambda_65(void *data, int argc, object self_73310, object r_73207) {
+  return_closcall1(data,  ((closureN)self_73310)->elements[0],  ((closureN)self_73310)->elements[1]);; 
+}
+
+static void __lambda_43(void *data, int argc, object self_73288, object r_73205) {
+  
+complex_num_type local_73514; object c_73515 = Cyc_fast_sum(data,&local_73514,((closureN)self_73288)->elements[0], obj_int2obj(1));
+return_closcall3(data,  car(((closureN)self_73288)->elements[2]),  ((closureN)self_73288)->elements[1], c_73515, r_73205);; 
+}
+
+static void __lambda_41(void *data, int argc, object self_73316, object r_73200) {
+  return_closcall3(data,  car(((closureN)self_73316)->elements[1]),  ((closureN)self_73316)->elements[0], obj_int2obj(0), boolean_f);; 
+}
+
+static void __lambda_22(void *data, int argc, closure _,object k_73177, object r_7342_73111, object x_7343_73112) {
+  Cyc_st_add(data, "diviter.scm:hide");
+
+closureN_type c_73441;
+c_73441.hdr.mark = gc_color_red;
+ c_73441.hdr.grayed = 0;
+c_73441.tag = closureN_tag;
+ c_73441.fn = (function_type)__lambda_23;
+c_73441.pc = 0;
+c_73441.num_args = 0;
+c_73441.num_elements = 1;
+c_73441.elements = (object *)alloca(sizeof(object) * 1);
+c_73441.elements[0] = r_7342_73111;
+
+
+closureN_type c_73458;
+c_73458.hdr.mark = gc_color_red;
+ c_73458.hdr.grayed = 0;
+c_73458.tag = closureN_tag;
+ c_73458.fn = (function_type)__lambda_28;
+c_73458.pc = 0;
+c_73458.num_args = 2;
+c_73458.num_elements = 1;
+c_73458.elements = (object *)alloca(sizeof(object) * 1);
+c_73458.elements[0] = x_7343_73112;
+
+return_closcall3(data,  __glo_call_91with_91values_scheme_base,  k_73177, &c_73441, &c_73458);; 
+}
+
+static void __lambda_28(void *data, int argc, object self_73271, object k_73180, object v_7345_73114, object i_7346_73115) {
+  return_closcall2(data,  Cyc_vector_ref(data, v_7345_73114, i_7346_73115),  k_73180, ((closureN)self_73271)->elements[0]);; 
+}
+
+static void __lambda_23(void *data, int argc, object self_73266, object k_73182) {
+  
+closureN_type c_73443;
+c_73443.hdr.mark = gc_color_red;
+ c_73443.hdr.grayed = 0;
+c_73443.tag = closureN_tag;
+ c_73443.fn = (function_type)__lambda_24;
+c_73443.pc = 0;
+c_73443.num_args = 1;
+c_73443.num_elements = 2;
+c_73443.elements = (object *)alloca(sizeof(object) * 2);
+c_73443.elements[0] = k_73182;
+c_73443.elements[1] = ((closureN)self_73266)->elements[0];
+
+
+mclosure0(c_73456, (function_type)__lambda_27);c_73456.num_args = 1;
+return_closcall3(data,  __glo_vector_scheme_base,  &c_73443, __glo_values_scheme_base, &c_73456);; 
+}
+
+static void __lambda_27(void *data, int argc, object self_73270, object k_73188, object x_7344_73113) {
+  return_closcall1(data,  k_73188,  x_7344_73113);; 
+}
+
+static void __lambda_24(void *data, int argc, object self_73267, object r_73183) {
+  
+closureN_type c_73445;
+c_73445.hdr.mark = gc_color_red;
+ c_73445.hdr.grayed = 0;
+c_73445.tag = closureN_tag;
+ c_73445.fn = (function_type)__lambda_25;
+c_73445.pc = 0;
+c_73445.num_args = 0;
+c_73445.num_elements = 1;
+c_73445.elements = (object *)alloca(sizeof(object) * 1);
+c_73445.elements[0] = ((closureN)self_73267)->elements[1];
+
+
+closureN_type c_73452;
+c_73452.hdr.mark = gc_color_red;
+ c_73452.hdr.grayed = 0;
+c_73452.tag = closureN_tag;
+ c_73452.fn = (function_type)__lambda_26;
+c_73452.pc = 0;
+c_73452.num_args = 1;
+c_73452.num_elements = 2;
+c_73452.elements = (object *)alloca(sizeof(object) * 2);
+c_73452.elements[0] = ((closureN)self_73267)->elements[0];
+c_73452.elements[1] = r_73183;
+
+return_direct_with_clo1(data,(closure)&c_73445,__lambda_25,  &c_73452);; 
+}
+
+static void __lambda_26(void *data, int argc, object self_73268, object r_73184) {
+  return_closcall3(data,  __glo_values_scheme_base,  ((closureN)self_73268)->elements[0], ((closureN)self_73268)->elements[1], r_73184);; 
+}
+
+static void __lambda_25(void *data, int argc, object self_73269, object k_73185) {
+    object c_73448 = Cyc_num_fast_lt_op(data,((closureN)self_73269)->elements[0], obj_int2obj(100));
+if( (boolean_f != c_73448) ){ 
+  return_direct_with_clo1(data,  k_73185,__lambda_26,  obj_int2obj(0));
+} else { 
+  return_direct_with_clo1(data,  k_73185,__lambda_26,  obj_int2obj(1));}
+; 
+}
+
+static void __lambda_11(void *data, int argc, closure _,object k_73161) {
+  Cyc_st_add(data, "diviter.scm:main");
+
+closureN_type c_73393;
+c_73393.hdr.mark = gc_color_red;
+ c_73393.hdr.grayed = 0;
+c_73393.tag = closureN_tag;
+ c_73393.fn = (function_type)__lambda_12;
+c_73393.pc = 0;
+c_73393.num_args = 1;
+c_73393.num_elements = 1;
+c_73393.elements = (object *)alloca(sizeof(object) * 1);
+c_73393.elements[0] = k_73161;
+
+return_closcall1(data,  __glo_read_scheme_read,  &c_73393);; 
+}
+
+static void __lambda_12(void *data, int argc, object self_73256, object count_7321_73103) {
+  
+closureN_type c_73395;
+c_73395.hdr.mark = gc_color_red;
+ c_73395.hdr.grayed = 0;
+c_73395.tag = closureN_tag;
+ c_73395.fn = (function_type)__lambda_13;
+c_73395.pc = 0;
+c_73395.num_args = 1;
+c_73395.num_elements = 2;
+c_73395.elements = (object *)alloca(sizeof(object) * 2);
+c_73395.elements[0] = count_7321_73103;
+c_73395.elements[1] = ((closureN)self_73256)->elements[0];
+
+return_closcall1(data,  __glo_read_scheme_read,  &c_73395);; 
+}
+
+static void __lambda_13(void *data, int argc, object self_73257, object input1_7324_73104) {
+  
+closureN_type c_73397;
+c_73397.hdr.mark = gc_color_red;
+ c_73397.hdr.grayed = 0;
+c_73397.tag = closureN_tag;
+ c_73397.fn = (function_type)__lambda_14;
+c_73397.pc = 0;
+c_73397.num_args = 1;
+c_73397.num_elements = 3;
+c_73397.elements = (object *)alloca(sizeof(object) * 3);
+c_73397.elements[0] = ((closureN)self_73257)->elements[0];
+c_73397.elements[1] = input1_7324_73104;
+c_73397.elements[2] = ((closureN)self_73257)->elements[1];
+
+return_closcall1(data,  __glo_read_scheme_read,  &c_73397);; 
+}
+
+static void __lambda_14(void *data, int argc, object self_73258, object output_7327_73105) {
+  
+closureN_type c_73399;
+c_73399.hdr.mark = gc_color_red;
+ c_73399.hdr.grayed = 0;
+c_73399.tag = closureN_tag;
+ c_73399.fn = (function_type)__lambda_15;
+c_73399.pc = 0;
+c_73399.num_args = 1;
+c_73399.num_elements = 4;
+c_73399.elements = (object *)alloca(sizeof(object) * 4);
+c_73399.elements[0] = ((closureN)self_73258)->elements[0];
+c_73399.elements[1] = ((closureN)self_73258)->elements[1];
+c_73399.elements[2] = ((closureN)self_73258)->elements[2];
+c_73399.elements[3] = output_7327_73105;
+
+
+object c_73437 = Cyc_number2string2(data,(closure)&c_73399,1,((closureN)self_73258)->elements[0]);
+return_closcall1(data,(closure)&c_73399,  c_73437);; 
+}
+
+static void __lambda_15(void *data, int argc, object self_73259, object s2_7330_73106) {
+  
+closureN_type c_73401;
+c_73401.hdr.mark = gc_color_red;
+ c_73401.hdr.grayed = 0;
+c_73401.tag = closureN_tag;
+ c_73401.fn = (function_type)__lambda_16;
+c_73401.pc = 0;
+c_73401.num_args = 1;
+c_73401.num_elements = 5;
+c_73401.elements = (object *)alloca(sizeof(object) * 5);
+c_73401.elements[0] = ((closureN)self_73259)->elements[0];
+c_73401.elements[1] = ((closureN)self_73259)->elements[1];
+c_73401.elements[2] = ((closureN)self_73259)->elements[2];
+c_73401.elements[3] = ((closureN)self_73259)->elements[3];
+c_73401.elements[4] = s2_7330_73106;
+
+
+object c_73433 = Cyc_number2string2(data,(closure)&c_73401,1,((closureN)self_73259)->elements[1]);
+return_closcall1(data,(closure)&c_73401,  c_73433);; 
+}
+
+static void __lambda_16(void *data, int argc, object self_73260, object s1_7333_73107) {
+  
+closureN_type c_73403;
+c_73403.hdr.mark = gc_color_red;
+ c_73403.hdr.grayed = 0;
+c_73403.tag = closureN_tag;
+ c_73403.fn = (function_type)__lambda_17;
+c_73403.pc = 0;
+c_73403.num_args = 1;
+c_73403.num_elements = 5;
+c_73403.elements = (object *)alloca(sizeof(object) * 5);
+c_73403.elements[0] = ((closureN)self_73260)->elements[0];
+c_73403.elements[1] = ((closureN)self_73260)->elements[2];
+c_73403.elements[2] = ((closureN)self_73260)->elements[3];
+c_73403.elements[3] = s1_7333_73107;
+c_73403.elements[4] = ((closureN)self_73260)->elements[4];
+
+return_closcall3(data,  __glo_hide,  &c_73403, ((closureN)self_73260)->elements[0], ((closureN)self_73260)->elements[1]);; 
+}
+
+static void __lambda_17(void *data, int argc, object self_73261, object r_73174) {
+  
+closureN_type c_73405;
+c_73405.hdr.mark = gc_color_red;
+ c_73405.hdr.grayed = 0;
+c_73405.tag = closureN_tag;
+ c_73405.fn = (function_type)__lambda_18;
+c_73405.pc = 0;
+c_73405.num_args = 1;
+c_73405.num_elements = 5;
+c_73405.elements = (object *)alloca(sizeof(object) * 5);
+c_73405.elements[0] = ((closureN)self_73261)->elements[0];
+c_73405.elements[1] = ((closureN)self_73261)->elements[1];
+c_73405.elements[2] = ((closureN)self_73261)->elements[2];
+c_73405.elements[3] = ((closureN)self_73261)->elements[3];
+c_73405.elements[4] = ((closureN)self_73261)->elements[4];
+
+return_closcall2(data,  __glo_create_91n,  &c_73405, r_73174);; 
+}
+
+static void __lambda_18(void *data, int argc, object self_73262, object ll_7336_73108) {
+  
+closureN_type c_73407;
+c_73407.hdr.mark = gc_color_red;
+ c_73407.hdr.grayed = 0;
+c_73407.tag = closureN_tag;
+ c_73407.fn = (function_type)__lambda_19;
+c_73407.pc = 0;
+c_73407.num_args = 1;
+c_73407.num_elements = 4;
+c_73407.elements = (object *)alloca(sizeof(object) * 4);
+c_73407.elements[0] = ((closureN)self_73262)->elements[0];
+c_73407.elements[1] = ((closureN)self_73262)->elements[1];
+c_73407.elements[2] = ll_7336_73108;
+c_73407.elements[3] = ((closureN)self_73262)->elements[2];
+
+
+make_utf8_string_with_len(c_73424, "diviter", 7, 7);
+
+make_utf8_string_with_len(c_73425, ":", 1, 1);
+
+make_utf8_string_with_len(c_73427, ":", 1, 1);
+
+object c_73423 = Cyc_string_append(data,(closure)&c_73407,5,&c_73424, &c_73425, ((closureN)self_73262)->elements[3], &c_73427, ((closureN)self_73262)->elements[4]);
+return_closcall1(data,(closure)&c_73407,  c_73423);; 
+}
+
+static void __lambda_19(void *data, int argc, object self_73263, object r_73168) {
+  
+closureN_type c_73411;
+c_73411.hdr.mark = gc_color_red;
+ c_73411.hdr.grayed = 0;
+c_73411.tag = closureN_tag;
+ c_73411.fn = (function_type)__lambda_20;
+c_73411.pc = 0;
+c_73411.num_args = 0;
+c_73411.num_elements = 1;
+c_73411.elements = (object *)alloca(sizeof(object) * 1);
+c_73411.elements[0] = ((closureN)self_73263)->elements[2];
+
+
+closureN_type c_73414;
+c_73414.hdr.mark = gc_color_red;
+ c_73414.hdr.grayed = 0;
+c_73414.tag = closureN_tag;
+ c_73414.fn = (function_type)__lambda_21;
+c_73414.pc = 0;
+c_73414.num_args = 1;
+c_73414.num_elements = 1;
+c_73414.elements = (object *)alloca(sizeof(object) * 1);
+c_73414.elements[0] = ((closureN)self_73263)->elements[3];
+
+return_closcall5(data,  __glo_run_91r7rs_91benchmark,  ((closureN)self_73263)->elements[1], r_73168, ((closureN)self_73263)->elements[0], &c_73411, &c_73414);; 
+}
+
+static void __lambda_21(void *data, int argc, object self_73265, object k_73171, object result_7341_73110) {
+  return_closcall1(data,  k_73171,  equalp(Cyc_length(data, result_7341_73110), ((closureN)self_73265)->elements[0]));; 
+}
+
+static void __lambda_20(void *data, int argc, object self_73264, object k_73173) {
+  return_closcall2(data,  __glo_iterative_91div2,  k_73173, ((closureN)self_73264)->elements[0]);; 
+}
+
+static void __host_lambda_1(void *data, int argc, closure self);
+static void __host_lambda_1(void *data, int argc, closure self){
+ while(1) {
+  object *stack = ((gc_thread_data *)data)->args; // TODO: do it inline for benchmarks/production code
+  object top = alloca(sizeof(object)); // TODO: is there a more efficient way?
+  if (stack_overflow(top, (((gc_thread_data *)data)->stack_limit))) { 
+     GC(data, self, ((gc_thread_data *)data)->args, argc); 
+     return;
+  }
+
+  switch(((gc_thread_data *)data)->pc) {
+//static void __lambda_6(void *data, int argc, closure _,object k_73150, object l_7310_7397) {
+  case 6: {
+  Cyc_st_add(data, "diviter.scm:iterative-div2");
+
+object c_73357 = alloca(closureN_type);
+c_73357->hdr.mark = gc_color_red;
+ c_73357->hdr.grayed = 0;
+c_73357->tag = closureN_tag;
+ c_73357->fn = (function_type)__host_lambda_1; //__lambda_7;
+c_73357->pc = 7;
+c_73357->num_args = 2;
+c_73357->num_elements = 1;
+c_73357->elements = (object *)alloca(sizeof(object) * 1);
+c_73357->elements[0] = stack[0]; //k_73150;
+
+//return_direct_with_clo2(data,(closure)c_73357,__lambda_7,  l_7310_7397, NULL);; 
+
+((gc_thread_data *)data)->args = alloca(sizeof(object) * 2);
+((gc_thread_data *)data)->args[0] = stack[1];
+((gc_thread_data *)data)->args[1] = NULL;
+((gc_thread_data *)data)->pc = 7;
+self = c_73357;
+argc = 2;
+continue;
+}
+
+//static void __lambda_7(void *data, int argc, object self_73251, object l_7314_7398, object a_7315_7399) {
+case 7: {  
+object c_73359 = alloca(sizeof(closureN_type));
+c_73359->hdr.mark = gc_color_red;
+ c_73359->hdr.grayed = 0;
+c_73359->tag = closureN_tag;
+ c_73359->fn = (function_type)__host_lambda_1; //__lambda_8;
+c_73359->pc = 8;
+c_73359->num_args = 1;
+c_73359->num_elements = 3;
+c_73359->elements = (object *)alloca(sizeof(object) * 3);
+c_73359->elements[0] = stack[1]; //a_7315_7399;
+c_73359->elements[1] = ((closureN)self /*_73251*/)->elements[0];
+c_73359->elements[2] = stack[0]; //l_7314_7398;
+
+//return_direct_with_clo1(data,(closure)&c_73359,__lambda_8,  boolean_f);; 
+((gc_thread_data *)data)->args = alloca(sizeof(object) * 1);
+((gc_thread_data *)data)->args[0] = boolean_f;
+((gc_thread_data *)data)->pc = 8;
+self = c_73359;
+argc = 1;
+continue;
+}
+
+//static void __lambda_8(void *data, int argc, object self_73252, object lp_7311_7316_73100) {
+  case 8: {
+object c_73361 = alloca(sizeof(closureN_type));
+c_73361->hdr.mark = gc_color_red;
+ c_73361->hdr.grayed = 0;
+c_73361->tag = closureN_tag;
+ c_73361->fn = (function_type)__host_lambda_1; //__lambda_76;
+c_73361->pc = 76;
+c_73361->num_args = 1;
+c_73361->num_elements = 3;
+c_73361->elements = (object *)alloca(sizeof(object) * 3);
+c_73361->elements[0] = ((closureN)self /*_73252*/)->elements[0];
+c_73361->elements[1] = ((closureN)self /*_73252*/)->elements[1];
+c_73361->elements[2] = ((closureN)self /*_73252*/)->elements[2];
+
+
+make_cell(c_73390,lp_7311_7316_73100);
+//return_direct_with_clo1(data,(closure)&c_73361,__lambda_76,  &c_73390);; 
+((gc_thread_data *)data)->args = alloca(sizeof(object) * 1);
+((gc_thread_data *)data)->args[0] = boolean_f;
+((gc_thread_data *)data)->pc = 8;
+self = c_73359;
+argc = 1;
+continue;
+}
+
+TODO: continue conversion
+static void __lambda_76(void *data, int argc, object self_73253, object lp_7311_7316_73100) {
+  
+closureN_type c_73363;
+c_73363.hdr.mark = gc_color_red;
+ c_73363.hdr.grayed = 0;
+c_73363.tag = closureN_tag;
+ c_73363.fn = (function_type)__lambda_9;
+c_73363.pc = 0;
+c_73363.num_args = 1;
+c_73363.num_elements = 4;
+c_73363.elements = (object *)alloca(sizeof(object) * 4);
+c_73363.elements[0] = ((closureN)self_73253)->elements[0];
+c_73363.elements[1] = ((closureN)self_73253)->elements[1];
+c_73363.elements[2] = ((closureN)self_73253)->elements[2];
+c_73363.elements[3] = lp_7311_7316_73100;
+
+
+closureN_type c_73373;
+c_73373.hdr.mark = gc_color_red;
+ c_73373.hdr.grayed = 0;
+c_73373.tag = closureN_tag;
+ c_73373.fn = (function_type)__lambda_10;
+c_73373.pc = 0;
+c_73373.num_args = 2;
+c_73373.num_elements = 1;
+c_73373.elements = (object *)alloca(sizeof(object) * 1);
+c_73373.elements[0] = lp_7311_7316_73100;
+
+return_direct_with_clo1(data,(closure)&c_73363,__lambda_9,  Cyc_set_cell(data, lp_7311_7316_73100, &c_73373));; 
+}
+
+static void __lambda_10(void *data, int argc, object self_73254, object k_73154, object l_7317_73101, object a_7318_73102) {
+  if( (boolean_f != Cyc_is_null(l_7317_73101)) ){ 
+  return_closcall1(data,  k_73154,  a_7318_73102);
+} else { 
+  
+make_pair(c_73385,Cyc_car(data, l_7317_73101), a_7318_73102);
+return_closcall3(data,  car(((closureN)self_73254)->elements[0]),  k_73154, Cyc_cddr(data, l_7317_73101), &c_73385);}
+; 
+}
+
+static void __lambda_9(void *data, int argc, object self_73255, object r_73152) {
+  return_closcall3(data,  car(((closureN)self_73255)->elements[3]),  ((closureN)self_73255)->elements[1], ((closureN)self_73255)->elements[2], ((closureN)self_73255)->elements[0]);; 
+}
+
+static void __lambda_1(void *data, int argc, closure _,object k_73139, object n_731_7391) {
+  Cyc_st_add(data, "diviter.scm:create-n");
+
+closureN_type c_73320;
+c_73320.hdr.mark = gc_color_red;
+ c_73320.hdr.grayed = 0;
+c_73320.tag = closureN_tag;
+ c_73320.fn = (function_type)__lambda_2;
+c_73320.pc = 0;
+c_73320.num_args = 2;
+c_73320.num_elements = 1;
+c_73320.elements = (object *)alloca(sizeof(object) * 1);
+c_73320.elements[0] = k_73139;
+
+return_direct_with_clo2(data,(closure)&c_73320,__lambda_2,  n_731_7391, NULL);; 
+}
+
+static void __lambda_2(void *data, int argc, object self_73246, object n_735_7392, object a_736_7393) {
+  
+closureN_type c_73322;
+c_73322.hdr.mark = gc_color_red;
+ c_73322.hdr.grayed = 0;
+c_73322.tag = closureN_tag;
+ c_73322.fn = (function_type)__lambda_3;
+c_73322.pc = 0;
+c_73322.num_args = 1;
+c_73322.num_elements = 3;
+c_73322.elements = (object *)alloca(sizeof(object) * 3);
+c_73322.elements[0] = a_736_7393;
+c_73322.elements[1] = ((closureN)self_73246)->elements[0];
+c_73322.elements[2] = n_735_7392;
+
+return_direct_with_clo1(data,(closure)&c_73322,__lambda_3,  boolean_f);; 
+}
+
+static void __lambda_3(void *data, int argc, object self_73247, object lp_732_737_7394) {
+  
+closureN_type c_73324;
+c_73324.hdr.mark = gc_color_red;
+ c_73324.hdr.grayed = 0;
+c_73324.tag = closureN_tag;
+ c_73324.fn = (function_type)__lambda_75;
+c_73324.pc = 0;
+c_73324.num_args = 1;
+c_73324.num_elements = 3;
+c_73324.elements = (object *)alloca(sizeof(object) * 3);
+c_73324.elements[0] = ((closureN)self_73247)->elements[0];
+c_73324.elements[1] = ((closureN)self_73247)->elements[1];
+c_73324.elements[2] = ((closureN)self_73247)->elements[2];
+
+
+make_cell(c_73354,lp_732_737_7394);
+return_direct_with_clo1(data,(closure)&c_73324,__lambda_75,  &c_73354);; 
+}
+
+static void __lambda_75(void *data, int argc, object self_73248, object lp_732_737_7394) {
+  
+closureN_type c_73326;
+c_73326.hdr.mark = gc_color_red;
+ c_73326.hdr.grayed = 0;
+c_73326.tag = closureN_tag;
+ c_73326.fn = (function_type)__lambda_4;
+c_73326.pc = 0;
+c_73326.num_args = 1;
+c_73326.num_elements = 4;
+c_73326.elements = (object *)alloca(sizeof(object) * 4);
+c_73326.elements[0] = ((closureN)self_73248)->elements[0];
+c_73326.elements[1] = ((closureN)self_73248)->elements[1];
+c_73326.elements[2] = lp_732_737_7394;
+c_73326.elements[3] = ((closureN)self_73248)->elements[2];
+
+
+closureN_type c_73336;
+c_73336.hdr.mark = gc_color_red;
+ c_73336.hdr.grayed = 0;
+c_73336.tag = closureN_tag;
+ c_73336.fn = (function_type)__lambda_5;
+c_73336.pc = 0;
+c_73336.num_args = 2;
+c_73336.num_elements = 1;
+c_73336.elements = (object *)alloca(sizeof(object) * 1);
+c_73336.elements[0] = lp_732_737_7394;
+
+return_direct_with_clo1(data,(closure)&c_73326,__lambda_4,  Cyc_set_cell(data, lp_732_737_7394, &c_73336));; 
+}
+
+static void __lambda_5(void *data, int argc, object self_73249, object k_73143, object n_738_7395, object a_739_7396) {
+    object c_73339 = Cyc_num_fast_eq_op(data,n_738_7395, obj_int2obj(0));
+if( (boolean_f != c_73339) ){ 
+  return_closcall1(data,  k_73143,  a_739_7396);
+} else { 
+  
+complex_num_type local_73347; object c_73348 = Cyc_fast_sub(data,&local_73347,n_738_7395, obj_int2obj(1));
+
+make_pair(c_73351,NULL, a_739_7396);
+return_closcall3(data,  car(((closureN)self_73249)->elements[0]),  k_73143, c_73348, &c_73351);}
+; 
+}
+
+static void __lambda_4(void *data, int argc, object self_73250, object r_73141) {
+  return_closcall3(data,  car(((closureN)self_73250)->elements[2]),  ((closureN)self_73250)->elements[1], ((closureN)self_73250)->elements[3], ((closureN)self_73250)->elements[0]);; 
+}
+
+static void c_entry_pt_first_lambda(void *data, int argc, closure cont, object value);
+extern void c_schemecyclonecommon_entry_pt(void *data, int argc, closure cont, object value);
+extern void c_schemebase_entry_pt(void *data, int argc, closure cont, object value);
+extern void c_schemetime_entry_pt(void *data, int argc, closure cont, object value);
+extern void c_schemewrite_entry_pt(void *data, int argc, closure cont, object value);
+extern void c_scheme_char_entry_pt(void *data, int argc, closure cont, object value);
+extern void c_schemeread_entry_pt(void *data, int argc, closure cont, object value);
+static void c_entry_pt(data, argc, env,cont) void *data; int argc; closure env,cont; { 
+Cyc_set_globals_changed((gc_thread_data *)data);
+
+  add_global((object *) &__glo_this_91scheme_91implementation_91name);
+  add_global((object *) &__glo_run_91r7rs_91benchmark);
+  add_global((object *) &__glo_hide);
+  add_global((object *) &__glo_main);
+  add_global((object *) &__glo_iterative_91div2);
+  add_global((object *) &__glo_create_91n);
+  mclosure0(c_73634, (function_type)__lambda_73);c_73634.num_args = 0; 
+  __glo_this_91scheme_91implementation_91name = &c_73634; 
+  mclosure0(c_73463, (function_type)__lambda_29);c_73463.num_args = 4; 
+  __glo_run_91r7rs_91benchmark = &c_73463; 
+  mclosure0(c_73439, (function_type)__lambda_22);c_73439.num_args = 2; 
+  __glo_hide = &c_73439; 
+  mclosure0(c_73391, (function_type)__lambda_11);c_73391.num_args = 0; 
+  __glo_main = &c_73391; 
+  mclosure0(c_73355, (function_type)__host_lambda_1 /*__lambda_6*/);c_73355.num_args = 1; c_73355.pc = 6;
+  __glo_iterative_91div2 = &c_73355; 
+  mclosure0(c_73318, (function_type)__host_lambda_1 /*__lambda_1*/);c_73318.num_args = 1; c_73318.pc = 1;
+  __glo_create_91n = &c_73318; 
+
+  make_cvar(cvar_73644, (object *)&__glo_this_91scheme_91implementation_91name);make_pair(pair_73645, find_or_add_symbol("this-scheme-implementation-name"), &cvar_73644);
+  make_cvar(cvar_73646, (object *)&__glo_run_91r7rs_91benchmark);make_pair(pair_73647, find_or_add_symbol("run-r7rs-benchmark"), &cvar_73646);
+  make_cvar(cvar_73648, (object *)&__glo_hide);make_pair(pair_73649, find_or_add_symbol("hide"), &cvar_73648);
+  make_cvar(cvar_73650, (object *)&__glo_main);make_pair(pair_73651, find_or_add_symbol("main"), &cvar_73650);
+  make_cvar(cvar_73652, (object *)&__glo_iterative_91div2);make_pair(pair_73653, find_or_add_symbol("iterative-div2"), &cvar_73652);
+  make_cvar(cvar_73654, (object *)&__glo_create_91n);make_pair(pair_73655, find_or_add_symbol("create-n"), &cvar_73654);
+make_pair(c_73661, &pair_73645,Cyc_global_variables);
+make_pair(c_73660, &pair_73647, &c_73661);
+make_pair(c_73659, &pair_73649, &c_73660);
+make_pair(c_73658, &pair_73651, &c_73659);
+make_pair(c_73657, &pair_73653, &c_73658);
+make_pair(c_73656, &pair_73655, &c_73657);
+Cyc_global_variables = &c_73656;
+mclosure1(c_done, c_entry_pt_first_lambda, &c_done);
+mclosure1(c_73662, c_schemeread_entry_pt, &c_done);
+mclosure1(c_73663, c_scheme_char_entry_pt, &c_73662);
+mclosure1(c_73664, c_schemewrite_entry_pt, &c_73663);
+mclosure1(c_73665, c_schemetime_entry_pt, &c_73664);
+mclosure1(c_73666, c_schemebase_entry_pt, &c_73665);
+mclosure1(c_73667, c_schemecyclonecommon_entry_pt, &c_73666);
+(c_73667.fn)(data, 0, &c_73667, &c_73667);
+}
+static void c_entry_pt_first_lambda(void *data, int argc, closure cont, object value) {
+  
+    
+    
+    
+    
+    
+    return_closcall1(data,  __glo_main,  primitive__75halt);
+;
+}
+int main(int argc, char **argv, char **envp)
+{gc_thread_data *thd;
+ long stack_size = global_stack_size = STACK_SIZE;
+ long heap_size = global_heap_size = HEAP_SIZE;
+ mclosure0(clos_halt,&Cyc_halt);  // Halt if final closure is reached
+ mclosure0(entry_pt,&c_entry_pt); // First function to execute
+ _cyc_argc = argc;
+ _cyc_argv = argv;
+ set_env_variables(envp);
+ gc_initialize();
+ thd = malloc(sizeof(gc_thread_data));
+ gc_thread_data_init(thd, 0, (char *) &stack_size, stack_size);
+ thd->gc_cont = &entry_pt;
+ thd->gc_args[0] = &clos_halt;
+ thd->gc_num_args = 1;
+ thd->thread_id = pthread_self();
+ gc_add_mutator(thd);
+ Cyc_heap_init(heap_size);
+ thd->thread_state = CYC_THREAD_STATE_RUNNABLE;
+ Cyc_start_trampoline(thd);
+ return 0;}
diff --git a/tests/experimental/diviter.scm b/tests/experimental/diviter.scm
index cee13f63..989d3d50 100644
--- a/tests/experimental/diviter.scm
+++ b/tests/experimental/diviter.scm
@@ -13,9 +13,9 @@
       ((null? l) a)))
 
 (define (main)
-  (let* ((count 1000000)
-         (input1 1000)
-         (output 500)
+  (let* ((count (read))
+         (input1 (read))
+         (output (read))
          (s2 (number->string count))
          (s1 (number->string input1))
          (ll (create-n (hide count input1)))
@@ -26,3 +26,73 @@
      (lambda ()
        (iterative-div2 ll))
      (lambda (result) (equal? (length result) output)))))
+
+;;; The following code is appended to all benchmarks.
+
+;;; Given an integer and an object, returns the object
+;;; without making it too easy for compilers to tell
+;;; the object will be returned.
+
+(define (hide r x)
+  (call-with-values
+   (lambda ()
+     (values (vector values (lambda (x) x))
+             (if (< r 100) 0 1)))
+   (lambda (v i)
+     ((vector-ref v i) x))))
+
+;;; Given the name of a benchmark,
+;;; the number of times it should be executed,
+;;; a thunk that runs the benchmark once,
+;;; and a unary predicate that is true of the
+;;; correct results the thunk may return,
+;;; runs the benchmark for the number of specified iterations.
+
+(define (run-r7rs-benchmark name count thunk ok?)
+
+  ;; Rounds to thousandths.
+  (define (rounded x)
+    (/ (round (* 1000 x)) 1000))
+
+  (display "Running ")
+  (display name)
+  (newline)
+  (flush-output-port (current-output-port))
+  (let* ((j/s (jiffies-per-second))
+         (t0 (current-second))
+         (j0 (current-jiffy)))
+    (let loop ((i 0)
+               (result #f))
+      (cond ((< i count)
+             (loop (+ i 1) (thunk)))
+            ((ok? result)
+             (let* ((j1 (current-jiffy))
+                    (t1 (current-second))
+                    (jifs (- j1 j0))
+                    (secs (inexact (/ jifs j/s)))
+                    (secs2 (rounded (- t1 t0))))
+               (display "Elapsed time: ")
+               (write secs)
+               (display " seconds (")
+               (write secs2)
+               (display ") for ")
+               (display name)
+               (newline)
+               (display "+!CSVLINE!+")
+               (display (this-scheme-implementation-name))
+               (display ",")
+               (display name)
+               (display ",")
+               (display secs)
+               (newline)
+               (flush-output-port (current-output-port)))
+             result)
+            (else
+             (display "ERROR: returned incorrect result: ")
+             (write result)
+             (newline)
+             (flush-output-port (current-output-port))
+             result)))))
+(define (this-scheme-implementation-name)
+  (string-append "cyclone-" (Cyc-version)))
+(main)