diff --git a/examples/hello-library/int-test/base.c b/examples/hello-library/int-test/base.c new file mode 100644 index 00000000..ed79592a --- /dev/null +++ b/examples/hello-library/int-test/base.c @@ -0,0 +1,2894 @@ +/** + ** This file was automatically generated by the Cyclone scheme compiler + ** + ** (c) 2014 Justin Ethier + ** Version 0.0.1 (Pre-release) + ** + **/ + +#define funcall0(cfn) ((cfn)->fn)(0,cfn) +/* Return to continuation after checking for stack overflow. */ +#define return_funcall0(cfn) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[0]; \ + GC(cfn,buf,0); return; \ + } else {funcall0((closure) (cfn)); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check0(_fn) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[0]; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 0); return; \ + } else { (_fn)(0,(closure)_fn); }} + +#define funcall1(cfn,a1) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(0, (closure)a1, cfn); } else { ((cfn)->fn)(1,cfn,a1);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall1(cfn,a1) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[1]; buf[0] = a1;\ + GC(cfn,buf,1); return; \ + } else {funcall1((closure) (cfn),a1); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check1(_fn,a1) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[1]; buf[0] = a1; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 1); return; \ + } else { (_fn)(1,(closure)_fn,a1); }} + +#define funcall2(cfn,a1,a2) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(1, (closure)a1, cfn,a2); } else { ((cfn)->fn)(2,cfn,a1,a2);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall2(cfn,a1,a2) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[2]; buf[0] = a1;buf[1] = a2;\ + GC(cfn,buf,2); return; \ + } else {funcall2((closure) (cfn),a1,a2); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check2(_fn,a1,a2) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[2]; buf[0] = a1;buf[1] = a2; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 2); return; \ + } else { (_fn)(2,(closure)_fn,a1,a2); }} + +#define funcall3(cfn,a1,a2,a3) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(2, (closure)a1, cfn,a2,a3); } else { ((cfn)->fn)(3,cfn,a1,a2,a3);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall3(cfn,a1,a2,a3) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[3]; buf[0] = a1;buf[1] = a2;buf[2] = a3;\ + GC(cfn,buf,3); return; \ + } else {funcall3((closure) (cfn),a1,a2,a3); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check3(_fn,a1,a2,a3) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[3]; buf[0] = a1;buf[1] = a2;buf[2] = a3; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 3); return; \ + } else { (_fn)(3,(closure)_fn,a1,a2,a3); }} + +#define funcall4(cfn,a1,a2,a3,a4) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(3, (closure)a1, cfn,a2,a3,a4); } else { ((cfn)->fn)(4,cfn,a1,a2,a3,a4);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall4(cfn,a1,a2,a3,a4) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[4]; buf[0] = a1;buf[1] = a2;buf[2] = a3;buf[3] = a4;\ + GC(cfn,buf,4); return; \ + } else {funcall4((closure) (cfn),a1,a2,a3,a4); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check4(_fn,a1,a2,a3,a4) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[4]; buf[0] = a1;buf[1] = a2;buf[2] = a3;buf[3] = a4; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 4); return; \ + } else { (_fn)(4,(closure)_fn,a1,a2,a3,a4); }} + +#include "cyclone.h" +object __glo_Cyc_91remove_91exception_91handler = nil; +object __glo_Cyc_91add_91exception_91handler = nil; +object __glo__85exception_91handler_91stack_85 = nil; +object __glo_with_91exception_91handler = nil; +object __glo_raise_91continuable = nil; +object __glo_raise = nil; +object __glo_error = nil; +object __glo_make_91string = nil; +object __glo_Cyc_91obj_123_127 = nil; +object __glo_symbol_123_127 = nil; +object __glo_boolean_123_127 = nil; +object __glo_reverse = nil; +object __glo_list_91set_67 = nil; +object __glo_list_91ref = nil; +object __glo_list_91tail = nil; +object __glo_for_91each = nil; +object __glo_map = nil; +object __glo_list_91copy = nil; +object __glo_make_91list = nil; +object __glo__list = nil; +object __glo_append = nil; +object __glo_negative_127 = nil; +object __glo_positive_127 = nil; +object __glo_zero_127 = nil; +object __glo_list_127 = nil; +object __glo_not = nil; +object __glo_foldr = nil; +object __glo_foldl = nil; +object __glo_digit_91value = nil; +object __glo_char_91whitespace_127 = nil; +object __glo_char_91numeric_127 = nil; +object __glo_char_91lower_91case_127 = nil; +object __glo_char_91upper_91case_127 = nil; +object __glo_char_91alphabetic_127 = nil; +object __glo_char_91downcase = nil; +object __glo_char_91upcase = nil; +object __glo_char_125_123_127 = nil; +object __glo_char_121_123_127 = nil; +object __glo_char_125_127 = nil; +object __glo_char_121_127 = nil; +object __glo_char_123_127 = nil; +object __glo_Cyc_91bin_91op_91char = nil; +object __glo_Cyc_91bin_91op = nil; +object __glo_call_91with_91current_91continuation = nil; +object __glo__85Cyc_91version_91banner_85 = nil; +object __glo__85features_85 = nil; +object __glo__85c_91file_91header_91comment_85 = nil; +object __glo__85version_91banner_85 = nil; +object __glo__85version_85 = nil; +object __glo_call_95cc = nil; +#include "runtime.h" +defsymbol(cyclone, cyclone); +defsymbol(continuable, continuable); +defsymbol(raised, raised); +static void __lambda_191(int argc, closure _) ; +static void __lambda_190(int argc, closure _,object r_73370) ; +static void __lambda_189(int argc, closure _,object r_73377) ; +static void __lambda_188(int argc, closure _,object r_73371) ; +static void __lambda_187(int argc, closure _,object r_73376) ; +static void __lambda_186(int argc, closure _,object r_73372) ; +static void __lambda_185(int argc, closure _,object r_73375) ; +static void __lambda_184(int argc, closure _,object r_73373) ; +static void __lambda_183(int argc, closure _,object r_73374) ; +static void __lambda_182(int argc, closure _,object k_73366) ; +static void __lambda_181(int argc, object self_73515, object r_73369) ; +static void __lambda_180(int argc, object self_73516, object r_73367) ; +static void __lambda_179(int argc, object self_73517, object r_73368) ; +static void __lambda_178(int argc, closure _,object k_73362, object h_73107) ; +static void __lambda_177(int argc, object self_73514, object r_73363) ; +static void __lambda_176(int argc, closure _,object k_73342, object handler_73100, object thunk_73101) ; +static void __lambda_175(int argc, object self_73495, object k_73348, object obj_73104) ; +static void __lambda_174(int argc, object self_73496, object r_73349) ; +static void __lambda_173(int argc, object self_73497, object result_73105, object continuable_127_73106) ; +static void __lambda_172(int argc, object self_73498, object result_73105) ; +static void __lambda_171(int argc, object self_73499, object r_73350) ; +static void __lambda_170(int argc, object self_73500, object r_73353) ; +static void __lambda_169(int argc, object self_73501, object r_73352) ; +static void __lambda_168(int argc, object self_73502, object r_73351) ; +static void __lambda_167(int argc, object self_73503, object k_73354) ; +static void __lambda_166(int argc, object self_73504, object r_73355) ; +static void __lambda_165(int argc, object self_73505, object r_73356) ; +static void __lambda_164(int argc, object self_73506, object r_73357) ; +static void __lambda_163(int argc, object self_73507, object r_73343) ; +static void __lambda_162(int argc, object self_73508, object result_73102, object my_91handler_73103) ; +static void __lambda_161(int argc, object self_73509, object result_73102) ; +static void __lambda_160(int argc, object self_73510, object r_73344) ; +static void __lambda_159(int argc, object self_73511, object r_73347) ; +static void __lambda_158(int argc, object self_73512, object r_73345) ; +static void __lambda_157(int argc, object self_73513, object r_73346) ; +static void __lambda_156(int argc, closure _,object k_73336, object obj_7399) ; +static void __lambda_155(int argc, object self_73492, object r_73337) ; +static void __lambda_154(int argc, object self_73493, object r_73339) ; +static void __lambda_153(int argc, object self_73494, object r_73338) ; +static void __lambda_152(int argc, closure _,object k_73330, object obj_7398) ; +static void __lambda_151(int argc, object self_73489, object r_73331) ; +static void __lambda_150(int argc, object self_73490, object r_73333) ; +static void __lambda_149(int argc, object self_73491, object r_73332) ; +static void __lambda_148(int argc, closure _,object k_73326, object msg_7396, object args_7397_raw, ...) ; +static void __lambda_147(int argc, object self_73488, object r_73327) ; +static void __lambda_146(int argc, closure _,object k_73318, object k_7393, object fill_7394_raw, ...) ; +static void __lambda_145(int argc, object self_73482, object r_73319) ; +static void __lambda_144(int argc, object self_73483, object fill_85_7395) ; +static void __lambda_143(int argc, object self_73484, object r_73321) ; +static void __lambda_142(int argc, object self_73485, object r_73320) ; +static void __lambda_141(int argc, object self_73486, object k_73322) ; +static void __lambda_140(int argc, object self_73487, object r_73323) ; +static void __lambda_139(int argc, closure _,object k_73307, object type_127_7388, object obj_7389, object objs_7390) ; +static void __lambda_138(int argc, object self_73474, object r_73308) ; +static void __lambda_137(int argc, object self_73475, object k_73310, object return_7391) ; +static void __lambda_136(int argc, object self_73476, object k_73313, object o_7392) ; +static void __lambda_135(int argc, object self_73477, object r_73315) ; +static void __lambda_134(int argc, object self_73478, object r_73314) ; +static void __lambda_133(int argc, object self_73479, object r_73312) ; +static void __lambda_132(int argc, object self_73480, object r_73311) ; +static void __lambda_131(int argc, object self_73481, object r_73309) ; +static void __lambda_130(int argc, closure _,object k_73303, object sym1_7385, object sym2_7386, object syms_7387_raw, ...) ; +static void __lambda_129(int argc, object self_73473, object r_73304) ; +static void __lambda_128(int argc, closure _,object k_73299, object b1_7382, object b2_7383, object bs_7384_raw, ...) ; +static void __lambda_127(int argc, object self_73472, object r_73300) ; +static void __lambda_126(int argc, closure _,object k_73295, object lst_7381) ; +static void __lambda_125(int argc, object self_73471, object r_73296) ; +static void __lambda_124(int argc, closure _,object k_73291, object lst_7377, object k_7378, object obj_7379) ; +static void __lambda_123(int argc, object self_73469, object r_73292) ; +static void __lambda_122(int argc, object self_73470, object kth_7380) ; +static void __lambda_121(int argc, closure _,object k_73287, object lst_7375, object k_7376) ; +static void __lambda_120(int argc, object self_73468, object r_73288) ; +static void __lambda_119(int argc, closure _,object k_73281, object lst_7373, object k_7374) ; +static void __lambda_118(int argc, object self_73465, object r_73282) ; +static void __lambda_117(int argc, object self_73466, object r_73283) ; +static void __lambda_116(int argc, object self_73467, object r_73284) ; +static void __lambda_115(int argc, closure _,object k_73274, object f_7371, object lst_7372) ; +static void __lambda_114(int argc, object self_73460, object r_73275) ; +static void __lambda_113(int argc, object self_73461) ; +static void __lambda_112(int argc, object self_73462, object r_73278) ; +static void __lambda_111(int argc, object self_73463, object r_73276) ; +static void __lambda_110(int argc, object self_73464, object r_73277) ; +static void __lambda_109(int argc, closure _,object k_73267, object func_7367, object lst_7368) ; +static void __lambda_108(int argc, object self_73456, object k_73270, object x_7369, object y_7370) ; +static void __lambda_107(int argc, object self_73457, object r_73271) ; +static void __lambda_106(int argc, object self_73458, object r_73268) ; +static void __lambda_105(int argc, object self_73459, object r_73269) ; +static void __lambda_104(int argc, closure _,object k_73261, object lst_7364) ; +static void __lambda_103(int argc, object self_73453, object k_73264, object x_7365, object y_7366) ; +static void __lambda_102(int argc, object self_73454, object r_73262) ; +static void __lambda_101(int argc, object self_73455, object r_73263) ; +static void __lambda_100(int argc, closure _,object k_73248, object k_7358, object fill_7359_raw, ...) ; +static void __lambda_99(int argc, object self_73439, object x_7360, object make_7361) ; +static void __lambda_98(int argc, object self_73440, object x_7360) ; +static void __lambda_97(int argc, object self_73441, object make_7361) ; +static void __lambda_96(int argc, object self_73442) ; +static void __lambda_95(int argc, object self_73443, object r_73256) ; +static void __lambda_94(int argc, object self_73444, object r_73249) ; +static void __lambda_93(int argc, object self_73445, object k_73252, object n_7362, object obj_7363) ; +static void __lambda_92(int argc, object self_73446, object r_73253) ; +static void __lambda_91(int argc, object self_73447, object r_73255) ; +static void __lambda_90(int argc, object self_73448, object r_73254) ; +static void __lambda_89(int argc, object self_73449, object r_73251) ; +static void __lambda_88(int argc, object self_73450, object r_73250) ; +static void __lambda_87(int argc, object self_73451, object k_73257) ; +static void __lambda_86(int argc, object self_73452, object r_73258) ; +static void __lambda_85(int argc, closure _,object k_73245, object objs_7357_raw, ...) ; +static void __lambda_84(int argc, closure _,object k_73230, object lst_7347_raw, ...) ; +static void __lambda_83(int argc, object self_73424, object append_912_7349) ; +static void __lambda_82(int argc, object self_73425, object append_912_7349) ; +static void __lambda_81(int argc, object self_73426, object append_912_7350) ; +static void __lambda_80(int argc, object self_73427, object k_73240, object inlist_7351, object alist_7352) ; +static void __lambda_79(int argc, object self_73428, object k_73242, object ap_7353, object in_7354) ; +static void __lambda_78(int argc, object self_73429, object r_73241) ; +static void __lambda_77(int argc, object self_73430, object r_73239) ; +static void __lambda_76(int argc, object self_73431, object r_73231) ; +static void __lambda_75(int argc, object self_73432, object r_73232) ; +static void __lambda_74(int argc, object self_73433, object r_73238) ; +static void __lambda_73(int argc, object self_73434, object r_73233) ; +static void __lambda_72(int argc, object self_73435, object k_73237, object a_7355, object b_7356) ; +static void __lambda_71(int argc, object self_73436, object r_73234) ; +static void __lambda_70(int argc, object self_73437, object r_73235) ; +static void __lambda_69(int argc, object self_73438, object r_73236) ; +static void __lambda_68(int argc, closure _,object k_73227, object n_7346) ; +static void __lambda_67(int argc, closure _,object k_73224, object n_7345) ; +static void __lambda_66(int argc, closure _,object k_73221, object n_7344) ; +static void __lambda_65(int argc, closure _,object k_73211, object o_7339) ; +static void __lambda_64(int argc, object self_73414, object _191list_127_7341) ; +static void __lambda_63(int argc, object self_73415, object _191list_127_7341) ; +static void __lambda_62(int argc, object self_73416, object _191list_127_7342) ; +static void __lambda_61(int argc, object self_73417, object k_73215, object obj_7343) ; +static void __lambda_60(int argc, object self_73418, object r_73216) ; +static void __lambda_59(int argc, object self_73419, object r_73217) ; +static void __lambda_58(int argc, object self_73420, object r_73218) ; +static void __lambda_57(int argc, object self_73421, object r_73214) ; +static void __lambda_56(int argc, object self_73422, object r_73212) ; +static void __lambda_55(int argc, object self_73423, object r_73213) ; +static void __lambda_54(int argc, closure _,object k_73208, object x_7338) ; +static void __lambda_53(int argc, closure _,object k_73201, object func_7335, object end_7336, object lst_7337) ; +static void __lambda_52(int argc, object self_73410, object r_73202) ; +static void __lambda_51(int argc, object self_73411, object r_73203) ; +static void __lambda_50(int argc, object self_73412, object r_73205) ; +static void __lambda_49(int argc, object self_73413, object r_73204) ; +static void __lambda_48(int argc, closure _,object k_73194, object func_7332, object accum_7333, object lst_7334) ; +static void __lambda_47(int argc, object self_73406, object r_73195) ; +static void __lambda_46(int argc, object self_73407, object r_73198) ; +static void __lambda_45(int argc, object self_73408, object r_73196) ; +static void __lambda_44(int argc, object self_73409, object r_73197) ; +static void __lambda_43(int argc, closure _,object k_73189, object c_7331) ; +static void __lambda_42(int argc, object self_73404, object r_73190) ; +static void __lambda_41(int argc, object self_73405, object r_73191) ; +static void __lambda_40(int argc, closure _,object k_73185, object c_7330) ; +static void __lambda_39(int argc, object self_73403, object r_73186) ; +static void __lambda_38(int argc, closure _,object k_73181, object c_7329) ; +static void __lambda_37(int argc, object self_73402, object r_73182) ; +static void __lambda_36(int argc, closure _,object k_73177, object c_7328) ; +static void __lambda_35(int argc, object self_73401, object r_73178) ; +static void __lambda_34(int argc, closure _,object k_73173, object c_7327) ; +static void __lambda_33(int argc, object self_73400, object r_73174) ; +static void __lambda_32(int argc, closure _,object k_73169, object c_7326) ; +static void __lambda_31(int argc, object self_73399, object r_73170) ; +static void __lambda_30(int argc, closure _,object k_73163, object c_7325) ; +static void __lambda_29(int argc, object self_73396, object r_73164) ; +static void __lambda_28(int argc, object self_73397, object r_73166) ; +static void __lambda_27(int argc, object self_73398, object r_73165) ; +static void __lambda_26(int argc, closure _,object k_73157, object c_7324) ; +static void __lambda_25(int argc, object self_73393, object r_73158) ; +static void __lambda_24(int argc, object self_73394, object r_73160) ; +static void __lambda_23(int argc, object self_73395, object r_73159) ; +static void __lambda_22(int argc, closure _,object k_73153, object c1_7321, object c2_7322, object cs_7323_raw, ...) ; +static void __lambda_21(int argc, object self_73392, object r_73154) ; +static void __lambda_20(int argc, closure _,object k_73149, object c1_7318, object c2_7319, object cs_7320_raw, ...) ; +static void __lambda_19(int argc, object self_73391, object r_73150) ; +static void __lambda_18(int argc, closure _,object k_73145, object c1_7315, object c2_7316, object cs_7317_raw, ...) ; +static void __lambda_17(int argc, object self_73390, object r_73146) ; +static void __lambda_16(int argc, closure _,object k_73141, object c1_7312, object c2_7313, object cs_7314_raw, ...) ; +static void __lambda_15(int argc, object self_73389, object r_73142) ; +static void __lambda_14(int argc, closure _,object k_73137, object c1_739, object c2_7310, object cs_7311_raw, ...) ; +static void __lambda_13(int argc, object self_73388, object r_73138) ; +static void __lambda_12(int argc, closure _,object k_73130, object cmp_734, object c_735, object cs_736) ; +static void __lambda_11(int argc, object self_73384, object k_73132, object x_737, object y_738) ; +static void __lambda_10(int argc, object self_73385, object r_73133) ; +static void __lambda_9(int argc, object self_73386, object r_73134) ; +static void __lambda_8(int argc, object self_73387, object r_73131) ; +static void __lambda_7(int argc, closure _,object k_73122, object cmp_731, object x_732, object lst_733) ; +static void __lambda_6(int argc, object self_73379, object r_73123) ; +static void __lambda_5(int argc, object self_73380, object r_73127) ; +static void __lambda_4(int argc, object self_73381, object r_73124) ; +static void __lambda_3(int argc, object self_73382, object r_73125) ; +static void __lambda_2(int argc, object self_73383, object r_73126) ; +static void __lambda_1(int argc, closure _,object k, object f) ; +static void __lambda_0(int argc, object self_73378, object _191, object result) ; + +static void __lambda_191(int argc, closure _) { + make_int(c_731369, 0); +return_check1(__lambda_190,&c_731369);; +} + +static void __lambda_190(int argc, closure _,object r_73370) { + make_string(c_731367, "\n :@ \n @@@ \n @@@@: \n `@@@@@+ \n .@@@+@@@ Cyclone \n @@ @@ An experimental Scheme compiler\n ,@ https://github.com/justinethier/cyclone\n '@ \n .@ \n @@ #@ (c) 2014 Justin Ethier\n `@@@#@@@. Version "); +make_string(c_731368, "\n #@@@@@ \n +@@@+ \n @@# \n `@. \n \n"); +string_type c_731366 = Cyc_string_append(3,&c_731367, __glo__85version_85, &c_731368); +return_check1(__lambda_189,&c_731366);; +} + +static void __lambda_189(int argc, closure _,object r_73377) { + return_check1(__lambda_188,global_set(__glo__85version_91banner_85, r_73377));; +} + +static void __lambda_188(int argc, closure _,object r_73371) { + make_string(c_731360, "/**\n ** This file was automatically generated by the Cyclone scheme compiler\n **\n ** (c) 2014 Justin Ethier\n ** Version "); +make_string(c_731361, "\n **\n **/\n"); +string_type c_731359 = Cyc_string_append(3,&c_731360, __glo__85version_85, &c_731361); +return_check1(__lambda_187,&c_731359);; +} + +static void __lambda_187(int argc, closure _,object r_73376) { + return_check1(__lambda_186,global_set(__glo__85c_91file_91header_91comment_85, r_73376));; +} + +static void __lambda_186(int argc, closure _,object r_73372) { + make_cons(c_731354,quote_cyclone,nil); +return_check1(__lambda_185,&c_731354);; +} + +static void __lambda_185(int argc, closure _,object r_73375) { + return_check1(__lambda_184,global_set(__glo__85features_85, r_73375));; +} + +static void __lambda_184(int argc, closure _,object r_73373) { + return_check1(__lambda_183,nil);; +} + +static void __lambda_183(int argc, closure _,object r_73374) { + __halt(global_set(__glo__85exception_91handler_91stack_85, r_73374)); +} + +static void __lambda_182(int argc, closure _,object k_73366) { + +closureN_type c_731324; +c_731324.tag = closureN_tag; + c_731324.fn = __lambda_181; +c_731324.num_elt = 1; +c_731324.elts = (object *)alloca(sizeof(object) * 1); +c_731324.elts[0] = k_73366; + +return_funcall1((closure)&c_731324, Cyc_is_null(__glo__85exception_91handler_91stack_85));; +} + +static void __lambda_181(int argc, object self_73515, object r_73369) { + +closureN_type c_731326; +c_731326.tag = closureN_tag; + c_731326.fn = __lambda_180; +c_731326.num_elt = 1; +c_731326.elts = (object *)alloca(sizeof(object) * 1); +c_731326.elts[0] = ((closureN)self_73515)->elts[0]; + +return_funcall2( __glo_not, &c_731326, r_73369);; +} + +static void __lambda_180(int argc, object self_73516, object r_73367) { + if( !eq(boolean_f, r_73367) ){ + +closureN_type c_731328; +c_731328.tag = closureN_tag; + c_731328.fn = __lambda_179; +c_731328.num_elt = 1; +c_731328.elts = (object *)alloca(sizeof(object) * 1); +c_731328.elts[0] = ((closureN)self_73516)->elts[0]; + +return_funcall1((closure)&c_731328, cdr(__glo__85exception_91handler_91stack_85)); +} else { + return_funcall1( ((closureN)self_73516)->elts[0], boolean_f);} +; +} + +static void __lambda_179(int argc, object self_73517, object r_73368) { + return_funcall1( ((closureN)self_73517)->elts[0], global_set(__glo__85exception_91handler_91stack_85, r_73368));; +} + +static void __lambda_178(int argc, closure _,object k_73362, object h_73107) { + +closureN_type c_731314; +c_731314.tag = closureN_tag; + c_731314.fn = __lambda_177; +c_731314.num_elt = 1; +c_731314.elts = (object *)alloca(sizeof(object) * 1); +c_731314.elts[0] = k_73362; + + +make_cons(c_731321,h_73107, __glo__85exception_91handler_91stack_85); +return_funcall1((closure)&c_731314, &c_731321);; +} + +static void __lambda_177(int argc, object self_73514, object r_73363) { + return_funcall1( ((closureN)self_73514)->elts[0], global_set(__glo__85exception_91handler_91stack_85, r_73363));; +} + +static void __lambda_176(int argc, closure _,object k_73342, object handler_73100, object thunk_73101) { + +closureN_type c_731232; +c_731232.tag = closureN_tag; + c_731232.fn = __lambda_163; +c_731232.num_elt = 2; +c_731232.elts = (object *)alloca(sizeof(object) * 2); +c_731232.elts[0] = k_73342; +c_731232.elts[1] = thunk_73101; + + +closureN_type c_731258; +c_731258.tag = closureN_tag; + c_731258.fn = __lambda_175; +c_731258.num_elt = 1; +c_731258.elts = (object *)alloca(sizeof(object) * 1); +c_731258.elts[0] = handler_73100; + +return_funcall1((closure)&c_731232, &c_731258);; +} + +static void __lambda_175(int argc, object self_73495, object k_73348, object obj_73104) { + +closureN_type c_731260; +c_731260.tag = closureN_tag; + c_731260.fn = __lambda_167; +c_731260.num_elt = 1; +c_731260.elts = (object *)alloca(sizeof(object) * 1); +c_731260.elts[0] = obj_73104; + + +closureN_type c_731280; +c_731280.tag = closureN_tag; + c_731280.fn = __lambda_174; +c_731280.num_elt = 3; +c_731280.elts = (object *)alloca(sizeof(object) * 3); +c_731280.elts[0] = ((closureN)self_73495)->elts[0]; +c_731280.elts[1] = k_73348; +c_731280.elts[2] = obj_73104; + +return_funcall1((closure)&c_731260, &c_731280);; +} + +static void __lambda_174(int argc, object self_73496, object r_73349) { + +closureN_type c_731282; +c_731282.tag = closureN_tag; + c_731282.fn = __lambda_173; +c_731282.num_elt = 3; +c_731282.elts = (object *)alloca(sizeof(object) * 3); +c_731282.elts[0] = ((closureN)self_73496)->elts[0]; +c_731282.elts[1] = ((closureN)self_73496)->elts[1]; +c_731282.elts[2] = ((closureN)self_73496)->elts[2]; + +return_funcall2((closure)&c_731282, boolean_f, r_73349);; +} + +static void __lambda_173(int argc, object self_73497, object result_73105, object continuable_127_73106) { + +closureN_type c_731284; +c_731284.tag = closureN_tag; + c_731284.fn = __lambda_172; +c_731284.num_elt = 4; +c_731284.elts = (object *)alloca(sizeof(object) * 4); +c_731284.elts[0] = continuable_127_73106; +c_731284.elts[1] = ((closureN)self_73497)->elts[0]; +c_731284.elts[2] = ((closureN)self_73497)->elts[1]; +c_731284.elts[3] = ((closureN)self_73497)->elts[2]; + + +make_cell(c_731311,result_73105); +return_funcall1((closure)&c_731284, &c_731311);; +} + +static void __lambda_172(int argc, object self_73498, object result_73105) { + +closureN_type c_731286; +c_731286.tag = closureN_tag; + c_731286.fn = __lambda_171; +c_731286.num_elt = 5; +c_731286.elts = (object *)alloca(sizeof(object) * 5); +c_731286.elts[0] = ((closureN)self_73498)->elts[0]; +c_731286.elts[1] = ((closureN)self_73498)->elts[1]; +c_731286.elts[2] = ((closureN)self_73498)->elts[2]; +c_731286.elts[3] = ((closureN)self_73498)->elts[3]; +c_731286.elts[4] = result_73105; + +return_funcall1( __glo_Cyc_91remove_91exception_91handler, &c_731286);; +} + +static void __lambda_171(int argc, object self_73499, object r_73350) { + +closureN_type c_731288; +c_731288.tag = closureN_tag; + c_731288.fn = __lambda_170; +c_731288.num_elt = 4; +c_731288.elts = (object *)alloca(sizeof(object) * 4); +c_731288.elts[0] = ((closureN)self_73499)->elts[0]; +c_731288.elts[1] = ((closureN)self_73499)->elts[1]; +c_731288.elts[2] = ((closureN)self_73499)->elts[2]; +c_731288.elts[3] = ((closureN)self_73499)->elts[4]; + +return_funcall1((closure)&c_731288, cadr(((closureN)self_73499)->elts[3]));; +} + +static void __lambda_170(int argc, object self_73500, object r_73353) { + +closureN_type c_731291; +c_731291.tag = closureN_tag; + c_731291.fn = __lambda_169; +c_731291.num_elt = 3; +c_731291.elts = (object *)alloca(sizeof(object) * 3); +c_731291.elts[0] = ((closureN)self_73500)->elts[0]; +c_731291.elts[1] = ((closureN)self_73500)->elts[2]; +c_731291.elts[2] = ((closureN)self_73500)->elts[3]; + +return_funcall2( ((closureN)self_73500)->elts[1], &c_731291, r_73353);; +} + +static void __lambda_169(int argc, object self_73501, object r_73352) { + +closureN_type c_731293; +c_731293.tag = closureN_tag; + c_731293.fn = __lambda_168; +c_731293.num_elt = 3; +c_731293.elts = (object *)alloca(sizeof(object) * 3); +c_731293.elts[0] = ((closureN)self_73501)->elts[0]; +c_731293.elts[1] = ((closureN)self_73501)->elts[1]; +c_731293.elts[2] = ((closureN)self_73501)->elts[2]; + +return_funcall1((closure)&c_731293, Cyc_set_car(((closureN)self_73501)->elts[2], r_73352));; +} + +static void __lambda_168(int argc, object self_73502, object r_73351) { + if( !eq(boolean_f, ((closureN)self_73502)->elts[0]) ){ + return_funcall1( ((closureN)self_73502)->elts[1], cell_get(((closureN)self_73502)->elts[2])); +} else { + +make_string(c_731302, "exception handler returned"); +return_funcall2( __glo_error, ((closureN)self_73502)->elts[1], &c_731302);} +; +} + +static void __lambda_167(int argc, object self_73503, object k_73354) { + +closureN_type c_731262; +c_731262.tag = closureN_tag; + c_731262.fn = __lambda_166; +c_731262.num_elt = 2; +c_731262.elts = (object *)alloca(sizeof(object) * 2); +c_731262.elts[0] = k_73354; +c_731262.elts[1] = ((closureN)self_73503)->elts[0]; + +return_funcall1((closure)&c_731262, Cyc_is_cons(((closureN)self_73503)->elts[0]));; +} + +static void __lambda_166(int argc, object self_73504, object r_73355) { + if( !eq(boolean_f, r_73355) ){ + +closureN_type c_731264; +c_731264.tag = closureN_tag; + c_731264.fn = __lambda_165; +c_731264.num_elt = 1; +c_731264.elts = (object *)alloca(sizeof(object) * 1); +c_731264.elts[0] = ((closureN)self_73504)->elts[0]; + +return_funcall1((closure)&c_731264, car(((closureN)self_73504)->elts[1])); +} else { + return_funcall1( ((closureN)self_73504)->elts[0], boolean_f);} +; +} + +static void __lambda_165(int argc, object self_73505, object r_73356) { + +closureN_type c_731266; +c_731266.tag = closureN_tag; + c_731266.fn = __lambda_164; +c_731266.num_elt = 2; +c_731266.elts = (object *)alloca(sizeof(object) * 2); +c_731266.elts[0] = ((closureN)self_73505)->elts[0]; +c_731266.elts[1] = r_73356; + +return_funcall1((closure)&c_731266, quote_continuable);; +} + +static void __lambda_164(int argc, object self_73506, object r_73357) { + return_funcall1( ((closureN)self_73506)->elts[0], equalp(((closureN)self_73506)->elts[1], r_73357));; +} + +static void __lambda_163(int argc, object self_73507, object r_73343) { + +closureN_type c_731234; +c_731234.tag = closureN_tag; + c_731234.fn = __lambda_162; +c_731234.num_elt = 2; +c_731234.elts = (object *)alloca(sizeof(object) * 2); +c_731234.elts[0] = ((closureN)self_73507)->elts[0]; +c_731234.elts[1] = ((closureN)self_73507)->elts[1]; + +return_funcall2((closure)&c_731234, boolean_f, r_73343);; +} + +static void __lambda_162(int argc, object self_73508, object result_73102, object my_91handler_73103) { + +closureN_type c_731236; +c_731236.tag = closureN_tag; + c_731236.fn = __lambda_161; +c_731236.num_elt = 3; +c_731236.elts = (object *)alloca(sizeof(object) * 3); +c_731236.elts[0] = ((closureN)self_73508)->elts[0]; +c_731236.elts[1] = my_91handler_73103; +c_731236.elts[2] = ((closureN)self_73508)->elts[1]; + + +make_cell(c_731257,result_73102); +return_funcall1((closure)&c_731236, &c_731257);; +} + +static void __lambda_161(int argc, object self_73509, object result_73102) { + +closureN_type c_731238; +c_731238.tag = closureN_tag; + c_731238.fn = __lambda_160; +c_731238.num_elt = 3; +c_731238.elts = (object *)alloca(sizeof(object) * 3); +c_731238.elts[0] = ((closureN)self_73509)->elts[0]; +c_731238.elts[1] = result_73102; +c_731238.elts[2] = ((closureN)self_73509)->elts[2]; + +return_funcall2( __glo_Cyc_91add_91exception_91handler, &c_731238, ((closureN)self_73509)->elts[1]);; +} + +static void __lambda_160(int argc, object self_73510, object r_73344) { + +closureN_type c_731241; +c_731241.tag = closureN_tag; + c_731241.fn = __lambda_159; +c_731241.num_elt = 2; +c_731241.elts = (object *)alloca(sizeof(object) * 2); +c_731241.elts[0] = ((closureN)self_73510)->elts[0]; +c_731241.elts[1] = ((closureN)self_73510)->elts[1]; + +return_funcall1( ((closureN)self_73510)->elts[2], &c_731241);; +} + +static void __lambda_159(int argc, object self_73511, object r_73347) { + +closureN_type c_731243; +c_731243.tag = closureN_tag; + c_731243.fn = __lambda_158; +c_731243.num_elt = 2; +c_731243.elts = (object *)alloca(sizeof(object) * 2); +c_731243.elts[0] = ((closureN)self_73511)->elts[0]; +c_731243.elts[1] = ((closureN)self_73511)->elts[1]; + +return_funcall1((closure)&c_731243, Cyc_set_car(((closureN)self_73511)->elts[1], r_73347));; +} + +static void __lambda_158(int argc, object self_73512, object r_73345) { + +closureN_type c_731245; +c_731245.tag = closureN_tag; + c_731245.fn = __lambda_157; +c_731245.num_elt = 2; +c_731245.elts = (object *)alloca(sizeof(object) * 2); +c_731245.elts[0] = ((closureN)self_73512)->elts[0]; +c_731245.elts[1] = ((closureN)self_73512)->elts[1]; + +return_funcall1( __glo_Cyc_91remove_91exception_91handler, &c_731245);; +} + +static void __lambda_157(int argc, object self_73513, object r_73346) { + return_funcall1( ((closureN)self_73513)->elts[0], cell_get(((closureN)self_73513)->elts[1]));; +} + +static void __lambda_156(int argc, closure _,object k_73336, object obj_7399) { + +closureN_type c_731219; +c_731219.tag = closureN_tag; + c_731219.fn = __lambda_155; +c_731219.num_elt = 2; +c_731219.elts = (object *)alloca(sizeof(object) * 2); +c_731219.elts[0] = k_73336; +c_731219.elts[1] = obj_7399; + +return_funcall1((closure)&c_731219, Cyc_current_exception_handler());; +} + +static void __lambda_155(int argc, object self_73492, object r_73337) { + +closureN_type c_731221; +c_731221.tag = closureN_tag; + c_731221.fn = __lambda_154; +c_731221.num_elt = 3; +c_731221.elts = (object *)alloca(sizeof(object) * 3); +c_731221.elts[0] = ((closureN)self_73492)->elts[0]; +c_731221.elts[1] = ((closureN)self_73492)->elts[1]; +c_731221.elts[2] = r_73337; + +return_funcall1((closure)&c_731221, quote_continuable);; +} + +static void __lambda_154(int argc, object self_73493, object r_73339) { + +closureN_type c_731223; +c_731223.tag = closureN_tag; + c_731223.fn = __lambda_153; +c_731223.num_elt = 2; +c_731223.elts = (object *)alloca(sizeof(object) * 2); +c_731223.elts[0] = ((closureN)self_73493)->elts[0]; +c_731223.elts[1] = ((closureN)self_73493)->elts[2]; + +return_funcall3( __glo__list, &c_731223, r_73339, ((closureN)self_73493)->elts[1]);; +} + +static void __lambda_153(int argc, object self_73494, object r_73338) { + return_funcall2( ((closureN)self_73494)->elts[1], ((closureN)self_73494)->elts[0], r_73338);; +} + +static void __lambda_152(int argc, closure _,object k_73330, object obj_7398) { + +closureN_type c_731206; +c_731206.tag = closureN_tag; + c_731206.fn = __lambda_151; +c_731206.num_elt = 2; +c_731206.elts = (object *)alloca(sizeof(object) * 2); +c_731206.elts[0] = k_73330; +c_731206.elts[1] = obj_7398; + +return_funcall1((closure)&c_731206, Cyc_current_exception_handler());; +} + +static void __lambda_151(int argc, object self_73489, object r_73331) { + +closureN_type c_731208; +c_731208.tag = closureN_tag; + c_731208.fn = __lambda_150; +c_731208.num_elt = 3; +c_731208.elts = (object *)alloca(sizeof(object) * 3); +c_731208.elts[0] = ((closureN)self_73489)->elts[0]; +c_731208.elts[1] = ((closureN)self_73489)->elts[1]; +c_731208.elts[2] = r_73331; + +return_funcall1((closure)&c_731208, quote_raised);; +} + +static void __lambda_150(int argc, object self_73490, object r_73333) { + +closureN_type c_731210; +c_731210.tag = closureN_tag; + c_731210.fn = __lambda_149; +c_731210.num_elt = 2; +c_731210.elts = (object *)alloca(sizeof(object) * 2); +c_731210.elts[0] = ((closureN)self_73490)->elts[0]; +c_731210.elts[1] = ((closureN)self_73490)->elts[2]; + +return_funcall3( __glo__list, &c_731210, r_73333, ((closureN)self_73490)->elts[1]);; +} + +static void __lambda_149(int argc, object self_73491, object r_73332) { + return_funcall2( ((closureN)self_73491)->elts[1], ((closureN)self_73491)->elts[0], r_73332);; +} + +static void __lambda_148(int argc, closure _,object k_73326, object msg_7396, object args_7397_raw, ...) { +load_varargs(args_7397, args_7397_raw, argc - 2); + +closureN_type c_731198; +c_731198.tag = closureN_tag; + c_731198.fn = __lambda_147; +c_731198.num_elt = 1; +c_731198.elts = (object *)alloca(sizeof(object) * 1); +c_731198.elts[0] = k_73326; + + +make_cons(c_731203,msg_7396, args_7397); +return_funcall1((closure)&c_731198, &c_731203);; +} + +static void __lambda_147(int argc, object self_73488, object r_73327) { + return_funcall2( __glo_raise, ((closureN)self_73488)->elts[0], r_73327);; +} + +static void __lambda_146(int argc, closure _,object k_73318, object k_7393, object fill_7394_raw, ...) { +load_varargs(fill_7394, fill_7394_raw, argc - 2); + +closureN_type c_731165; +c_731165.tag = closureN_tag; + c_731165.fn = __lambda_141; +c_731165.num_elt = 1; +c_731165.elts = (object *)alloca(sizeof(object) * 1); +c_731165.elts[0] = fill_7394; + + +closureN_type c_731177; +c_731177.tag = closureN_tag; + c_731177.fn = __lambda_145; +c_731177.num_elt = 2; +c_731177.elts = (object *)alloca(sizeof(object) * 2); +c_731177.elts[0] = k_73318; +c_731177.elts[1] = k_7393; + +return_funcall1((closure)&c_731165, &c_731177);; +} + +static void __lambda_145(int argc, object self_73482, object r_73319) { + +closureN_type c_731179; +c_731179.tag = closureN_tag; + c_731179.fn = __lambda_144; +c_731179.num_elt = 2; +c_731179.elts = (object *)alloca(sizeof(object) * 2); +c_731179.elts[0] = ((closureN)self_73482)->elts[0]; +c_731179.elts[1] = ((closureN)self_73482)->elts[1]; + +return_funcall1((closure)&c_731179, r_73319);; +} + +static void __lambda_144(int argc, object self_73483, object fill_85_7395) { + +closureN_type c_731181; +c_731181.tag = closureN_tag; + c_731181.fn = __lambda_143; +c_731181.num_elt = 1; +c_731181.elts = (object *)alloca(sizeof(object) * 1); +c_731181.elts[0] = ((closureN)self_73483)->elts[0]; + + +make_cons(c_731194,((closureN)self_73483)->elts[1], fill_85_7395); +return_funcall1((closure)&c_731181, &c_731194);; +} + +static void __lambda_143(int argc, object self_73484, object r_73321) { + +closureN_type c_731183; +c_731183.tag = closureN_tag; + c_731183.fn = __lambda_142; +c_731183.num_elt = 1; +c_731183.elts = (object *)alloca(sizeof(object) * 1); +c_731183.elts[0] = ((closureN)self_73484)->elts[0]; + + +object c_731191 = apply((closure)&c_731183, __glo_make_91list, r_73321); +return_funcall1((closure)&c_731183, c_731191);; +} + +static void __lambda_142(int argc, object self_73485, object r_73320) { + +string_type c_731188 = Cyc_list2string(r_73320); +return_funcall1( ((closureN)self_73485)->elts[0], &c_731188);; +} + +static void __lambda_141(int argc, object self_73486, object k_73322) { + +closureN_type c_731167; +c_731167.tag = closureN_tag; + c_731167.fn = __lambda_140; +c_731167.num_elt = 2; +c_731167.elts = (object *)alloca(sizeof(object) * 2); +c_731167.elts[0] = ((closureN)self_73486)->elts[0]; +c_731167.elts[1] = k_73322; + +return_funcall1((closure)&c_731167, Cyc_is_null(((closureN)self_73486)->elts[0]));; +} + +static void __lambda_140(int argc, object self_73487, object r_73323) { + if( !eq(boolean_f, r_73323) ){ + +make_cons(c_731170,obj_char2obj(32),nil); +return_funcall1( ((closureN)self_73487)->elts[1], &c_731170); +} else { + return_funcall1( ((closureN)self_73487)->elts[1], ((closureN)self_73487)->elts[0]);} +; +} + +static void __lambda_139(int argc, closure _,object k_73307, object type_127_7388, object obj_7389, object objs_7390) { + +closureN_type c_731135; +c_731135.tag = closureN_tag; + c_731135.fn = __lambda_138; +c_731135.num_elt = 3; +c_731135.elts = (object *)alloca(sizeof(object) * 3); +c_731135.elts[0] = k_73307; +c_731135.elts[1] = obj_7389; +c_731135.elts[2] = objs_7390; + +return_funcall2( type_127_7388, &c_731135, obj_7389);; +} + +static void __lambda_138(int argc, object self_73474, object r_73308) { + if( !eq(boolean_f, r_73308) ){ + +closureN_type c_731137; +c_731137.tag = closureN_tag; + c_731137.fn = __lambda_131; +c_731137.num_elt = 1; +c_731137.elts = (object *)alloca(sizeof(object) * 1); +c_731137.elts[0] = ((closureN)self_73474)->elts[0]; + + +closureN_type c_731140; +c_731140.tag = closureN_tag; + c_731140.fn = __lambda_137; +c_731140.num_elt = 2; +c_731140.elts = (object *)alloca(sizeof(object) * 2); +c_731140.elts[0] = ((closureN)self_73474)->elts[1]; +c_731140.elts[1] = ((closureN)self_73474)->elts[2]; + +return_funcall1((closure)&c_731137, &c_731140); +} else { + return_funcall1( ((closureN)self_73474)->elts[0], boolean_f);} +; +} + +static void __lambda_137(int argc, object self_73475, object k_73310, object return_7391) { + +closureN_type c_731142; +c_731142.tag = closureN_tag; + c_731142.fn = __lambda_133; +c_731142.num_elt = 2; +c_731142.elts = (object *)alloca(sizeof(object) * 2); +c_731142.elts[0] = k_73310; +c_731142.elts[1] = ((closureN)self_73475)->elts[1]; + + +closureN_type c_731148; +c_731148.tag = closureN_tag; + c_731148.fn = __lambda_136; +c_731148.num_elt = 2; +c_731148.elts = (object *)alloca(sizeof(object) * 2); +c_731148.elts[0] = ((closureN)self_73475)->elts[0]; +c_731148.elts[1] = return_7391; + +return_funcall1((closure)&c_731142, &c_731148);; +} + +static void __lambda_136(int argc, object self_73476, object k_73313, object o_7392) { + +closureN_type c_731150; +c_731150.tag = closureN_tag; + c_731150.fn = __lambda_135; +c_731150.num_elt = 2; +c_731150.elts = (object *)alloca(sizeof(object) * 2); +c_731150.elts[0] = k_73313; +c_731150.elts[1] = ((closureN)self_73476)->elts[1]; + +return_funcall1((closure)&c_731150, Cyc_eq(o_7392, ((closureN)self_73476)->elts[0]));; +} + +static void __lambda_135(int argc, object self_73477, object r_73315) { + +closureN_type c_731152; +c_731152.tag = closureN_tag; + c_731152.fn = __lambda_134; +c_731152.num_elt = 2; +c_731152.elts = (object *)alloca(sizeof(object) * 2); +c_731152.elts[0] = ((closureN)self_73477)->elts[0]; +c_731152.elts[1] = ((closureN)self_73477)->elts[1]; + +return_funcall2( __glo_not, &c_731152, r_73315);; +} + +static void __lambda_134(int argc, object self_73478, object r_73314) { + if( !eq(boolean_f, r_73314) ){ + return_funcall2( ((closureN)self_73478)->elts[1], ((closureN)self_73478)->elts[0], boolean_f); +} else { + return_funcall1( ((closureN)self_73478)->elts[0], boolean_f);} +; +} + +static void __lambda_133(int argc, object self_73479, object r_73312) { + +closureN_type c_731144; +c_731144.tag = closureN_tag; + c_731144.fn = __lambda_132; +c_731144.num_elt = 1; +c_731144.elts = (object *)alloca(sizeof(object) * 1); +c_731144.elts[0] = ((closureN)self_73479)->elts[0]; + +return_funcall3( __glo_for_91each, &c_731144, r_73312, ((closureN)self_73479)->elts[1]);; +} + +static void __lambda_132(int argc, object self_73480, object r_73311) { + return_funcall1( ((closureN)self_73480)->elts[0], boolean_t);; +} + +static void __lambda_131(int argc, object self_73481, object r_73309) { + return_funcall2( __glo_call_95cc, ((closureN)self_73481)->elts[0], r_73309);; +} + +static void __lambda_130(int argc, closure _,object k_73303, object sym1_7385, object sym2_7386, object syms_7387_raw, ...) { +load_varargs(syms_7387, syms_7387_raw, argc - 3); + +closureN_type c_731126; +c_731126.tag = closureN_tag; + c_731126.fn = __lambda_129; +c_731126.num_elt = 2; +c_731126.elts = (object *)alloca(sizeof(object) * 2); +c_731126.elts[0] = k_73303; +c_731126.elts[1] = sym1_7385; + + +make_cons(c_731132,sym2_7386, syms_7387); +return_funcall1((closure)&c_731126, &c_731132);; +} + +static void __lambda_129(int argc, object self_73473, object r_73304) { + return_funcall4( __glo_Cyc_91obj_123_127, ((closureN)self_73473)->elts[0], primitive_symbol_127, ((closureN)self_73473)->elts[1], r_73304);; +} + +static void __lambda_128(int argc, closure _,object k_73299, object b1_7382, object b2_7383, object bs_7384_raw, ...) { +load_varargs(bs_7384, bs_7384_raw, argc - 3); + +closureN_type c_731117; +c_731117.tag = closureN_tag; + c_731117.fn = __lambda_127; +c_731117.num_elt = 2; +c_731117.elts = (object *)alloca(sizeof(object) * 2); +c_731117.elts[0] = b1_7382; +c_731117.elts[1] = k_73299; + + +make_cons(c_731123,b2_7383, bs_7384); +return_funcall1((closure)&c_731117, &c_731123);; +} + +static void __lambda_127(int argc, object self_73472, object r_73300) { + return_funcall4( __glo_Cyc_91obj_123_127, ((closureN)self_73472)->elts[1], primitive_boolean_127, ((closureN)self_73472)->elts[0], r_73300);; +} + +static void __lambda_126(int argc, closure _,object k_73295, object lst_7381) { + +closureN_type c_731111; +c_731111.tag = closureN_tag; + c_731111.fn = __lambda_125; +c_731111.num_elt = 2; +c_731111.elts = (object *)alloca(sizeof(object) * 2); +c_731111.elts[0] = k_73295; +c_731111.elts[1] = lst_7381; + +return_funcall1((closure)&c_731111, nil);; +} + +static void __lambda_125(int argc, object self_73471, object r_73296) { + return_funcall4( __glo_foldl, ((closureN)self_73471)->elts[0], primitive_cons, r_73296, ((closureN)self_73471)->elts[1]);; +} + +static void __lambda_124(int argc, closure _,object k_73291, object lst_7377, object k_7378, object obj_7379) { + +closureN_type c_731101; +c_731101.tag = closureN_tag; + c_731101.fn = __lambda_123; +c_731101.num_elt = 2; +c_731101.elts = (object *)alloca(sizeof(object) * 2); +c_731101.elts[0] = k_73291; +c_731101.elts[1] = obj_7379; + +return_funcall3( __glo_list_91tail, &c_731101, lst_7377, k_7378);; +} + +static void __lambda_123(int argc, object self_73469, object r_73292) { + +closureN_type c_731103; +c_731103.tag = closureN_tag; + c_731103.fn = __lambda_122; +c_731103.num_elt = 2; +c_731103.elts = (object *)alloca(sizeof(object) * 2); +c_731103.elts[0] = ((closureN)self_73469)->elts[0]; +c_731103.elts[1] = ((closureN)self_73469)->elts[1]; + +return_funcall1((closure)&c_731103, r_73292);; +} + +static void __lambda_122(int argc, object self_73470, object kth_7380) { + return_funcall1( ((closureN)self_73470)->elts[0], Cyc_set_car(kth_7380, ((closureN)self_73470)->elts[1]));; +} + +static void __lambda_121(int argc, closure _,object k_73287, object lst_7375, object k_7376) { + +closureN_type c_731094; +c_731094.tag = closureN_tag; + c_731094.fn = __lambda_120; +c_731094.num_elt = 1; +c_731094.elts = (object *)alloca(sizeof(object) * 1); +c_731094.elts[0] = k_73287; + +return_funcall3( __glo_list_91tail, &c_731094, lst_7375, k_7376);; +} + +static void __lambda_120(int argc, object self_73468, object r_73288) { + return_funcall1( ((closureN)self_73468)->elts[0], car(r_73288));; +} + +static void __lambda_119(int argc, closure _,object k_73281, object lst_7373, object k_7374) { + +closureN_type c_731073; +c_731073.tag = closureN_tag; + c_731073.fn = __lambda_118; +c_731073.num_elt = 3; +c_731073.elts = (object *)alloca(sizeof(object) * 3); +c_731073.elts[0] = k_73281; +c_731073.elts[1] = k_7374; +c_731073.elts[2] = lst_7373; + +return_funcall2( __glo_zero_127, &c_731073, k_7374);; +} + +static void __lambda_118(int argc, object self_73465, object r_73282) { + if( !eq(boolean_f, r_73282) ){ + return_funcall1( ((closureN)self_73465)->elts[0], ((closureN)self_73465)->elts[2]); +} else { + +closureN_type c_731078; +c_731078.tag = closureN_tag; + c_731078.fn = __lambda_117; +c_731078.num_elt = 2; +c_731078.elts = (object *)alloca(sizeof(object) * 2); +c_731078.elts[0] = ((closureN)self_73465)->elts[0]; +c_731078.elts[1] = ((closureN)self_73465)->elts[1]; + +return_funcall1((closure)&c_731078, cdr(((closureN)self_73465)->elts[2]));} +; +} + +static void __lambda_117(int argc, object self_73466, object r_73283) { + +closureN_type c_731080; +c_731080.tag = closureN_tag; + c_731080.fn = __lambda_116; +c_731080.num_elt = 2; +c_731080.elts = (object *)alloca(sizeof(object) * 2); +c_731080.elts[0] = ((closureN)self_73466)->elts[0]; +c_731080.elts[1] = r_73283; + + +make_int(c_731088, 1); + +common_type c_731086 = Cyc_sub(2,((closureN)self_73466)->elts[1], &c_731088); +return_funcall1((closure)&c_731080, &c_731086);; +} + +static void __lambda_116(int argc, object self_73467, object r_73284) { + return_funcall3( __glo_list_91tail, ((closureN)self_73467)->elts[0], ((closureN)self_73467)->elts[1], r_73284);; +} + +static void __lambda_115(int argc, closure _,object k_73274, object f_7371, object lst_7372) { + +closureN_type c_731048; +c_731048.tag = closureN_tag; + c_731048.fn = __lambda_114; +c_731048.num_elt = 3; +c_731048.elts = (object *)alloca(sizeof(object) * 3); +c_731048.elts[0] = f_7371; +c_731048.elts[1] = k_73274; +c_731048.elts[2] = lst_7372; + +return_funcall1((closure)&c_731048, Cyc_is_null(lst_7372));; +} + +static void __lambda_114(int argc, object self_73460, object r_73275) { + if( !eq(boolean_f, r_73275) ){ + return_funcall1( ((closureN)self_73460)->elts[1], boolean_t); +} else { + +closureN_type c_731052; +c_731052.tag = closureN_tag; + c_731052.fn = __lambda_113; +c_731052.num_elt = 3; +c_731052.elts = (object *)alloca(sizeof(object) * 3); +c_731052.elts[0] = ((closureN)self_73460)->elts[0]; +c_731052.elts[1] = ((closureN)self_73460)->elts[1]; +c_731052.elts[2] = ((closureN)self_73460)->elts[2]; + +return_funcall0((closure)&c_731052);} +; +} + +static void __lambda_113(int argc, object self_73461) { + +closureN_type c_731054; +c_731054.tag = closureN_tag; + c_731054.fn = __lambda_112; +c_731054.num_elt = 3; +c_731054.elts = (object *)alloca(sizeof(object) * 3); +c_731054.elts[0] = ((closureN)self_73461)->elts[0]; +c_731054.elts[1] = ((closureN)self_73461)->elts[1]; +c_731054.elts[2] = ((closureN)self_73461)->elts[2]; + +return_funcall1((closure)&c_731054, car(((closureN)self_73461)->elts[2]));; +} + +static void __lambda_112(int argc, object self_73462, object r_73278) { + +closureN_type c_731057; +c_731057.tag = closureN_tag; + c_731057.fn = __lambda_111; +c_731057.num_elt = 3; +c_731057.elts = (object *)alloca(sizeof(object) * 3); +c_731057.elts[0] = ((closureN)self_73462)->elts[0]; +c_731057.elts[1] = ((closureN)self_73462)->elts[1]; +c_731057.elts[2] = ((closureN)self_73462)->elts[2]; + +return_funcall2( ((closureN)self_73462)->elts[0], &c_731057, r_73278);; +} + +static void __lambda_111(int argc, object self_73463, object r_73276) { + +closureN_type c_731059; +c_731059.tag = closureN_tag; + c_731059.fn = __lambda_110; +c_731059.num_elt = 2; +c_731059.elts = (object *)alloca(sizeof(object) * 2); +c_731059.elts[0] = ((closureN)self_73463)->elts[0]; +c_731059.elts[1] = ((closureN)self_73463)->elts[1]; + +return_funcall1((closure)&c_731059, cdr(((closureN)self_73463)->elts[2]));; +} + +static void __lambda_110(int argc, object self_73464, object r_73277) { + return_funcall3( __glo_for_91each, ((closureN)self_73464)->elts[1], ((closureN)self_73464)->elts[0], r_73277);; +} + +static void __lambda_109(int argc, closure _,object k_73267, object func_7367, object lst_7368) { + +closureN_type c_731029; +c_731029.tag = closureN_tag; + c_731029.fn = __lambda_106; +c_731029.num_elt = 2; +c_731029.elts = (object *)alloca(sizeof(object) * 2); +c_731029.elts[0] = k_73267; +c_731029.elts[1] = lst_7368; + + +closureN_type c_731036; +c_731036.tag = closureN_tag; + c_731036.fn = __lambda_108; +c_731036.num_elt = 1; +c_731036.elts = (object *)alloca(sizeof(object) * 1); +c_731036.elts[0] = func_7367; + +return_funcall1((closure)&c_731029, &c_731036);; +} + +static void __lambda_108(int argc, object self_73456, object k_73270, object x_7369, object y_7370) { + +closureN_type c_731039; +c_731039.tag = closureN_tag; + c_731039.fn = __lambda_107; +c_731039.num_elt = 2; +c_731039.elts = (object *)alloca(sizeof(object) * 2); +c_731039.elts[0] = k_73270; +c_731039.elts[1] = y_7370; + +return_funcall2( ((closureN)self_73456)->elts[0], &c_731039, x_7369);; +} + +static void __lambda_107(int argc, object self_73457, object r_73271) { + +make_cons(c_731044,r_73271, ((closureN)self_73457)->elts[1]); +return_funcall1( ((closureN)self_73457)->elts[0], &c_731044);; +} + +static void __lambda_106(int argc, object self_73458, object r_73268) { + +closureN_type c_731031; +c_731031.tag = closureN_tag; + c_731031.fn = __lambda_105; +c_731031.num_elt = 3; +c_731031.elts = (object *)alloca(sizeof(object) * 3); +c_731031.elts[0] = ((closureN)self_73458)->elts[0]; +c_731031.elts[1] = ((closureN)self_73458)->elts[1]; +c_731031.elts[2] = r_73268; + +return_funcall1((closure)&c_731031, nil);; +} + +static void __lambda_105(int argc, object self_73459, object r_73269) { + return_funcall4( __glo_foldr, ((closureN)self_73459)->elts[0], ((closureN)self_73459)->elts[2], r_73269, ((closureN)self_73459)->elts[1]);; +} + +static void __lambda_104(int argc, closure _,object k_73261, object lst_7364) { + +closureN_type c_731015; +c_731015.tag = closureN_tag; + c_731015.fn = __lambda_102; +c_731015.num_elt = 2; +c_731015.elts = (object *)alloca(sizeof(object) * 2); +c_731015.elts[0] = k_73261; +c_731015.elts[1] = lst_7364; + + +mclosure0(c_731022, (function_type)__lambda_103); +return_funcall1((closure)&c_731015, &c_731022);; +} + +static void __lambda_103(int argc, object self_73453, object k_73264, object x_7365, object y_7366) { + +make_cons(c_731026,x_7365, y_7366); +return_funcall1( k_73264, &c_731026);; +} + +static void __lambda_102(int argc, object self_73454, object r_73262) { + +closureN_type c_731017; +c_731017.tag = closureN_tag; + c_731017.fn = __lambda_101; +c_731017.num_elt = 3; +c_731017.elts = (object *)alloca(sizeof(object) * 3); +c_731017.elts[0] = ((closureN)self_73454)->elts[0]; +c_731017.elts[1] = ((closureN)self_73454)->elts[1]; +c_731017.elts[2] = r_73262; + +return_funcall1((closure)&c_731017, nil);; +} + +static void __lambda_101(int argc, object self_73455, object r_73263) { + return_funcall4( __glo_foldr, ((closureN)self_73455)->elts[0], ((closureN)self_73455)->elts[2], r_73263, ((closureN)self_73455)->elts[1]);; +} + +static void __lambda_100(int argc, closure _,object k_73248, object k_7358, object fill_7359_raw, ...) { +load_varargs(fill_7359, fill_7359_raw, argc - 2); + +closureN_type c_73939; +c_73939.tag = closureN_tag; + c_73939.fn = __lambda_99; +c_73939.num_elt = 3; +c_73939.elts = (object *)alloca(sizeof(object) * 3); +c_73939.elts[0] = fill_7359; +c_73939.elts[1] = k_73248; +c_73939.elts[2] = k_7358; + +return_funcall2((closure)&c_73939, boolean_f, boolean_f);; +} + +static void __lambda_99(int argc, object self_73439, object x_7360, object make_7361) { + +closureN_type c_73941; +c_73941.tag = closureN_tag; + c_73941.fn = __lambda_98; +c_73941.num_elt = 4; +c_73941.elts = (object *)alloca(sizeof(object) * 4); +c_73941.elts[0] = ((closureN)self_73439)->elts[0]; +c_73941.elts[1] = ((closureN)self_73439)->elts[1]; +c_73941.elts[2] = ((closureN)self_73439)->elts[2]; +c_73941.elts[3] = make_7361; + + +make_cell(c_731012,x_7360); +return_funcall1((closure)&c_73941, &c_731012);; +} + +static void __lambda_98(int argc, object self_73440, object x_7360) { + +closureN_type c_73943; +c_73943.tag = closureN_tag; + c_73943.fn = __lambda_97; +c_73943.num_elt = 4; +c_73943.elts = (object *)alloca(sizeof(object) * 4); +c_73943.elts[0] = ((closureN)self_73440)->elts[0]; +c_73943.elts[1] = ((closureN)self_73440)->elts[1]; +c_73943.elts[2] = ((closureN)self_73440)->elts[2]; +c_73943.elts[3] = x_7360; + + +make_cell(c_731008,((closureN)self_73440)->elts[3]); +return_funcall1((closure)&c_73943, &c_731008);; +} + +static void __lambda_97(int argc, object self_73441, object make_7361) { + +closureN_type c_73945; +c_73945.tag = closureN_tag; + c_73945.fn = __lambda_96; +c_73945.num_elt = 5; +c_73945.elts = (object *)alloca(sizeof(object) * 5); +c_73945.elts[0] = ((closureN)self_73441)->elts[0]; +c_73945.elts[1] = ((closureN)self_73441)->elts[1]; +c_73945.elts[2] = ((closureN)self_73441)->elts[2]; +c_73945.elts[3] = make_7361; +c_73945.elts[4] = ((closureN)self_73441)->elts[3]; + +return_funcall0((closure)&c_73945);; +} + +static void __lambda_96(int argc, object self_73442) { + +closureN_type c_73947; +c_73947.tag = closureN_tag; + c_73947.fn = __lambda_87; +c_73947.num_elt = 1; +c_73947.elts = (object *)alloca(sizeof(object) * 1); +c_73947.elts[0] = ((closureN)self_73442)->elts[0]; + + +closureN_type c_73960; +c_73960.tag = closureN_tag; + c_73960.fn = __lambda_95; +c_73960.num_elt = 4; +c_73960.elts = (object *)alloca(sizeof(object) * 4); +c_73960.elts[0] = ((closureN)self_73442)->elts[1]; +c_73960.elts[1] = ((closureN)self_73442)->elts[2]; +c_73960.elts[2] = ((closureN)self_73442)->elts[3]; +c_73960.elts[3] = ((closureN)self_73442)->elts[4]; + +return_funcall1((closure)&c_73947, &c_73960);; +} + +static void __lambda_95(int argc, object self_73443, object r_73256) { + +closureN_type c_73962; +c_73962.tag = closureN_tag; + c_73962.fn = __lambda_94; +c_73962.num_elt = 4; +c_73962.elts = (object *)alloca(sizeof(object) * 4); +c_73962.elts[0] = ((closureN)self_73443)->elts[0]; +c_73962.elts[1] = ((closureN)self_73443)->elts[1]; +c_73962.elts[2] = ((closureN)self_73443)->elts[2]; +c_73962.elts[3] = ((closureN)self_73443)->elts[3]; + +return_funcall1((closure)&c_73962, Cyc_set_car(((closureN)self_73443)->elts[3], r_73256));; +} + +static void __lambda_94(int argc, object self_73444, object r_73249) { + +closureN_type c_73964; +c_73964.tag = closureN_tag; + c_73964.fn = __lambda_89; +c_73964.num_elt = 4; +c_73964.elts = (object *)alloca(sizeof(object) * 4); +c_73964.elts[0] = ((closureN)self_73444)->elts[0]; +c_73964.elts[1] = ((closureN)self_73444)->elts[1]; +c_73964.elts[2] = ((closureN)self_73444)->elts[2]; +c_73964.elts[3] = ((closureN)self_73444)->elts[3]; + + +closureN_type c_73979; +c_73979.tag = closureN_tag; + c_73979.fn = __lambda_93; +c_73979.num_elt = 1; +c_73979.elts = (object *)alloca(sizeof(object) * 1); +c_73979.elts[0] = ((closureN)self_73444)->elts[2]; + +return_funcall1((closure)&c_73964, &c_73979);; +} + +static void __lambda_93(int argc, object self_73445, object k_73252, object n_7362, object obj_7363) { + +closureN_type c_73981; +c_73981.tag = closureN_tag; + c_73981.fn = __lambda_92; +c_73981.num_elt = 4; +c_73981.elts = (object *)alloca(sizeof(object) * 4); +c_73981.elts[0] = k_73252; +c_73981.elts[1] = ((closureN)self_73445)->elts[0]; +c_73981.elts[2] = n_7362; +c_73981.elts[3] = obj_7363; + +return_funcall2( __glo_zero_127, &c_73981, n_7362);; +} + +static void __lambda_92(int argc, object self_73446, object r_73253) { + if( !eq(boolean_f, r_73253) ){ + return_funcall1( ((closureN)self_73446)->elts[0], nil); +} else { + +closureN_type c_73985; +c_73985.tag = closureN_tag; + c_73985.fn = __lambda_91; +c_73985.num_elt = 3; +c_73985.elts = (object *)alloca(sizeof(object) * 3); +c_73985.elts[0] = ((closureN)self_73446)->elts[0]; +c_73985.elts[1] = ((closureN)self_73446)->elts[1]; +c_73985.elts[2] = ((closureN)self_73446)->elts[3]; + + +make_int(c_731002, 1); + +common_type c_731000 = Cyc_sub(2,((closureN)self_73446)->elts[2], &c_731002); +return_funcall1((closure)&c_73985, &c_731000);} +; +} + +static void __lambda_91(int argc, object self_73447, object r_73255) { + +closureN_type c_73990; +c_73990.tag = closureN_tag; + c_73990.fn = __lambda_90; +c_73990.num_elt = 2; +c_73990.elts = (object *)alloca(sizeof(object) * 2); +c_73990.elts[0] = ((closureN)self_73447)->elts[0]; +c_73990.elts[1] = ((closureN)self_73447)->elts[2]; + +return_funcall3( cell_get(((closureN)self_73447)->elts[1]), &c_73990, r_73255, ((closureN)self_73447)->elts[2]);; +} + +static void __lambda_90(int argc, object self_73448, object r_73254) { + +make_cons(c_73995,((closureN)self_73448)->elts[1], r_73254); +return_funcall1( ((closureN)self_73448)->elts[0], &c_73995);; +} + +static void __lambda_89(int argc, object self_73449, object r_73251) { + +closureN_type c_73966; +c_73966.tag = closureN_tag; + c_73966.fn = __lambda_88; +c_73966.num_elt = 4; +c_73966.elts = (object *)alloca(sizeof(object) * 4); +c_73966.elts[0] = ((closureN)self_73449)->elts[0]; +c_73966.elts[1] = ((closureN)self_73449)->elts[1]; +c_73966.elts[2] = ((closureN)self_73449)->elts[2]; +c_73966.elts[3] = ((closureN)self_73449)->elts[3]; + +return_funcall1((closure)&c_73966, Cyc_set_car(((closureN)self_73449)->elts[2], r_73251));; +} + +static void __lambda_88(int argc, object self_73450, object r_73250) { + return_funcall3( cell_get(((closureN)self_73450)->elts[2]), ((closureN)self_73450)->elts[0], ((closureN)self_73450)->elts[1], cell_get(((closureN)self_73450)->elts[3]));; +} + +static void __lambda_87(int argc, object self_73451, object k_73257) { + +closureN_type c_73949; +c_73949.tag = closureN_tag; + c_73949.fn = __lambda_86; +c_73949.num_elt = 2; +c_73949.elts = (object *)alloca(sizeof(object) * 2); +c_73949.elts[0] = ((closureN)self_73451)->elts[0]; +c_73949.elts[1] = k_73257; + +return_funcall1((closure)&c_73949, Cyc_is_null(((closureN)self_73451)->elts[0]));; +} + +static void __lambda_86(int argc, object self_73452, object r_73258) { + if( !eq(boolean_f, r_73258) ){ + return_funcall1( ((closureN)self_73452)->elts[1], boolean_f); +} else { + return_funcall1( ((closureN)self_73452)->elts[1], car(((closureN)self_73452)->elts[0]));} +; +} + +static void __lambda_85(int argc, closure _,object k_73245, object objs_7357_raw, ...) { +load_varargs(objs_7357, objs_7357_raw, argc - 1); + return_funcall1( k_73245, objs_7357);; +} + +static void __lambda_84(int argc, closure _,object k_73230, object lst_7347_raw, ...) { +load_varargs(lst_7347, lst_7347_raw, argc - 1); + +closureN_type c_73865; +c_73865.tag = closureN_tag; + c_73865.fn = __lambda_83; +c_73865.num_elt = 2; +c_73865.elts = (object *)alloca(sizeof(object) * 2); +c_73865.elts[0] = k_73230; +c_73865.elts[1] = lst_7347; + +return_funcall1((closure)&c_73865, boolean_f);; +} + +static void __lambda_83(int argc, object self_73424, object append_912_7349) { + +closureN_type c_73867; +c_73867.tag = closureN_tag; + c_73867.fn = __lambda_82; +c_73867.num_elt = 2; +c_73867.elts = (object *)alloca(sizeof(object) * 2); +c_73867.elts[0] = ((closureN)self_73424)->elts[0]; +c_73867.elts[1] = ((closureN)self_73424)->elts[1]; + + +make_cell(c_73934,append_912_7349); +return_funcall1((closure)&c_73867, &c_73934);; +} + +static void __lambda_82(int argc, object self_73425, object append_912_7349) { + +closureN_type c_73869; +c_73869.tag = closureN_tag; + c_73869.fn = __lambda_81; +c_73869.num_elt = 3; +c_73869.elts = (object *)alloca(sizeof(object) * 3); +c_73869.elts[0] = append_912_7349; +c_73869.elts[1] = ((closureN)self_73425)->elts[0]; +c_73869.elts[2] = ((closureN)self_73425)->elts[1]; + +return_funcall1((closure)&c_73869, boolean_f);; +} + +static void __lambda_81(int argc, object self_73426, object append_912_7350) { + +closureN_type c_73871; +c_73871.tag = closureN_tag; + c_73871.fn = __lambda_77; +c_73871.num_elt = 3; +c_73871.elts = (object *)alloca(sizeof(object) * 3); +c_73871.elts[0] = ((closureN)self_73426)->elts[0]; +c_73871.elts[1] = ((closureN)self_73426)->elts[1]; +c_73871.elts[2] = ((closureN)self_73426)->elts[2]; + + +mclosure0(c_73920, (function_type)__lambda_80); +return_funcall1((closure)&c_73871, &c_73920);; +} + +static void __lambda_80(int argc, object self_73427, object k_73240, object inlist_7351, object alist_7352) { + +closureN_type c_73922; +c_73922.tag = closureN_tag; + c_73922.fn = __lambda_78; +c_73922.num_elt = 3; +c_73922.elts = (object *)alloca(sizeof(object) * 3); +c_73922.elts[0] = alist_7352; +c_73922.elts[1] = inlist_7351; +c_73922.elts[2] = k_73240; + + +mclosure0(c_73927, (function_type)__lambda_79); +return_funcall1((closure)&c_73922, &c_73927);; +} + +static void __lambda_79(int argc, object self_73428, object k_73242, object ap_7353, object in_7354) { + +make_cons(c_73931,ap_7353, in_7354); +return_funcall1( k_73242, &c_73931);; +} + +static void __lambda_78(int argc, object self_73429, object r_73241) { + return_funcall4( __glo_foldr, ((closureN)self_73429)->elts[2], r_73241, ((closureN)self_73429)->elts[0], ((closureN)self_73429)->elts[1]);; +} + +static void __lambda_77(int argc, object self_73430, object r_73239) { + +closureN_type c_73873; +c_73873.tag = closureN_tag; + c_73873.fn = __lambda_76; +c_73873.num_elt = 3; +c_73873.elts = (object *)alloca(sizeof(object) * 3); +c_73873.elts[0] = ((closureN)self_73430)->elts[0]; +c_73873.elts[1] = ((closureN)self_73430)->elts[1]; +c_73873.elts[2] = ((closureN)self_73430)->elts[2]; + +return_funcall1((closure)&c_73873, Cyc_set_car(((closureN)self_73430)->elts[0], r_73239));; +} + +static void __lambda_76(int argc, object self_73431, object r_73231) { + +closureN_type c_73875; +c_73875.tag = closureN_tag; + c_73875.fn = __lambda_75; +c_73875.num_elt = 3; +c_73875.elts = (object *)alloca(sizeof(object) * 3); +c_73875.elts[0] = ((closureN)self_73431)->elts[0]; +c_73875.elts[1] = ((closureN)self_73431)->elts[1]; +c_73875.elts[2] = ((closureN)self_73431)->elts[2]; + +return_funcall1((closure)&c_73875, Cyc_is_null(((closureN)self_73431)->elts[2]));; +} + +static void __lambda_75(int argc, object self_73432, object r_73232) { + if( !eq(boolean_f, r_73232) ){ + return_funcall1( ((closureN)self_73432)->elts[1], ((closureN)self_73432)->elts[2]); +} else { + +closureN_type c_73880; +c_73880.tag = closureN_tag; + c_73880.fn = __lambda_74; +c_73880.num_elt = 3; +c_73880.elts = (object *)alloca(sizeof(object) * 3); +c_73880.elts[0] = ((closureN)self_73432)->elts[0]; +c_73880.elts[1] = ((closureN)self_73432)->elts[1]; +c_73880.elts[2] = ((closureN)self_73432)->elts[2]; + +return_funcall1((closure)&c_73880, cdr(((closureN)self_73432)->elts[2]));} +; +} + +static void __lambda_74(int argc, object self_73433, object r_73238) { + +closureN_type c_73882; +c_73882.tag = closureN_tag; + c_73882.fn = __lambda_73; +c_73882.num_elt = 3; +c_73882.elts = (object *)alloca(sizeof(object) * 3); +c_73882.elts[0] = ((closureN)self_73433)->elts[0]; +c_73882.elts[1] = ((closureN)self_73433)->elts[1]; +c_73882.elts[2] = ((closureN)self_73433)->elts[2]; + +return_funcall1((closure)&c_73882, Cyc_is_null(r_73238));; +} + +static void __lambda_73(int argc, object self_73434, object r_73233) { + if( !eq(boolean_f, r_73233) ){ + return_funcall1( ((closureN)self_73434)->elts[1], car(((closureN)self_73434)->elts[2])); +} else { + +closureN_type c_73889; +c_73889.tag = closureN_tag; + c_73889.fn = __lambda_71; +c_73889.num_elt = 2; +c_73889.elts = (object *)alloca(sizeof(object) * 2); +c_73889.elts[0] = ((closureN)self_73434)->elts[1]; +c_73889.elts[1] = ((closureN)self_73434)->elts[2]; + + +closureN_type c_73904; +c_73904.tag = closureN_tag; + c_73904.fn = __lambda_72; +c_73904.num_elt = 1; +c_73904.elts = (object *)alloca(sizeof(object) * 1); +c_73904.elts[0] = ((closureN)self_73434)->elts[0]; + +return_funcall1((closure)&c_73889, &c_73904);} +; +} + +static void __lambda_72(int argc, object self_73435, object k_73237, object a_7355, object b_7356) { + return_funcall3( cell_get(((closureN)self_73435)->elts[0]), k_73237, b_7356, a_7355);; +} + +static void __lambda_71(int argc, object self_73436, object r_73234) { + +closureN_type c_73891; +c_73891.tag = closureN_tag; + c_73891.fn = __lambda_70; +c_73891.num_elt = 3; +c_73891.elts = (object *)alloca(sizeof(object) * 3); +c_73891.elts[0] = ((closureN)self_73436)->elts[0]; +c_73891.elts[1] = ((closureN)self_73436)->elts[1]; +c_73891.elts[2] = r_73234; + +return_funcall1((closure)&c_73891, car(((closureN)self_73436)->elts[1]));; +} + +static void __lambda_70(int argc, object self_73437, object r_73235) { + +closureN_type c_73893; +c_73893.tag = closureN_tag; + c_73893.fn = __lambda_69; +c_73893.num_elt = 3; +c_73893.elts = (object *)alloca(sizeof(object) * 3); +c_73893.elts[0] = ((closureN)self_73437)->elts[0]; +c_73893.elts[1] = ((closureN)self_73437)->elts[2]; +c_73893.elts[2] = r_73235; + +return_funcall1((closure)&c_73893, cdr(((closureN)self_73437)->elts[1]));; +} + +static void __lambda_69(int argc, object self_73438, object r_73236) { + return_funcall4( __glo_foldl, ((closureN)self_73438)->elts[0], ((closureN)self_73438)->elts[1], ((closureN)self_73438)->elts[2], r_73236);; +} + +static void __lambda_68(int argc, closure _,object k_73227, object n_7346) { + +make_int(c_73862, 0); +return_funcall1( k_73227, __num_lt(n_7346, &c_73862));; +} + +static void __lambda_67(int argc, closure _,object k_73224, object n_7345) { + +make_int(c_73857, 0); +return_funcall1( k_73224, __num_gt(n_7345, &c_73857));; +} + +static void __lambda_66(int argc, closure _,object k_73221, object n_7344) { + +make_int(c_73852, 0); +return_funcall1( k_73221, __num_eq(n_7344, &c_73852));; +} + +static void __lambda_65(int argc, closure _,object k_73211, object o_7339) { + +closureN_type c_73796; +c_73796.tag = closureN_tag; + c_73796.fn = __lambda_64; +c_73796.num_elt = 2; +c_73796.elts = (object *)alloca(sizeof(object) * 2); +c_73796.elts[0] = k_73211; +c_73796.elts[1] = o_7339; + +return_funcall1((closure)&c_73796, boolean_f);; +} + +static void __lambda_64(int argc, object self_73414, object _191list_127_7341) { + +closureN_type c_73798; +c_73798.tag = closureN_tag; + c_73798.fn = __lambda_63; +c_73798.num_elt = 2; +c_73798.elts = (object *)alloca(sizeof(object) * 2); +c_73798.elts[0] = ((closureN)self_73414)->elts[0]; +c_73798.elts[1] = ((closureN)self_73414)->elts[1]; + + +make_cell(c_73847,_191list_127_7341); +return_funcall1((closure)&c_73798, &c_73847);; +} + +static void __lambda_63(int argc, object self_73415, object _191list_127_7341) { + +closureN_type c_73800; +c_73800.tag = closureN_tag; + c_73800.fn = __lambda_62; +c_73800.num_elt = 3; +c_73800.elts = (object *)alloca(sizeof(object) * 3); +c_73800.elts[0] = _191list_127_7341; +c_73800.elts[1] = ((closureN)self_73415)->elts[0]; +c_73800.elts[2] = ((closureN)self_73415)->elts[1]; + +return_funcall1((closure)&c_73800, boolean_f);; +} + +static void __lambda_62(int argc, object self_73416, object _191list_127_7342) { + +closureN_type c_73802; +c_73802.tag = closureN_tag; + c_73802.fn = __lambda_57; +c_73802.num_elt = 3; +c_73802.elts = (object *)alloca(sizeof(object) * 3); +c_73802.elts[0] = ((closureN)self_73416)->elts[0]; +c_73802.elts[1] = ((closureN)self_73416)->elts[1]; +c_73802.elts[2] = ((closureN)self_73416)->elts[2]; + + +closureN_type c_73821; +c_73821.tag = closureN_tag; + c_73821.fn = __lambda_61; +c_73821.num_elt = 1; +c_73821.elts = (object *)alloca(sizeof(object) * 1); +c_73821.elts[0] = ((closureN)self_73416)->elts[0]; + +return_funcall1((closure)&c_73802, &c_73821);; +} + +static void __lambda_61(int argc, object self_73417, object k_73215, object obj_7343) { + +closureN_type c_73823; +c_73823.tag = closureN_tag; + c_73823.fn = __lambda_60; +c_73823.num_elt = 3; +c_73823.elts = (object *)alloca(sizeof(object) * 3); +c_73823.elts[0] = ((closureN)self_73417)->elts[0]; +c_73823.elts[1] = k_73215; +c_73823.elts[2] = obj_7343; + +return_funcall1((closure)&c_73823, Cyc_is_null(obj_7343));; +} + +static void __lambda_60(int argc, object self_73418, object r_73216) { + if( !eq(boolean_f, r_73216) ){ + return_funcall1( ((closureN)self_73418)->elts[1], boolean_t); +} else { + +closureN_type c_73827; +c_73827.tag = closureN_tag; + c_73827.fn = __lambda_59; +c_73827.num_elt = 3; +c_73827.elts = (object *)alloca(sizeof(object) * 3); +c_73827.elts[0] = ((closureN)self_73418)->elts[0]; +c_73827.elts[1] = ((closureN)self_73418)->elts[1]; +c_73827.elts[2] = ((closureN)self_73418)->elts[2]; + +return_funcall1((closure)&c_73827, Cyc_is_cons(((closureN)self_73418)->elts[2]));} +; +} + +static void __lambda_59(int argc, object self_73419, object r_73217) { + if( !eq(boolean_f, r_73217) ){ + +closureN_type c_73829; +c_73829.tag = closureN_tag; + c_73829.fn = __lambda_58; +c_73829.num_elt = 2; +c_73829.elts = (object *)alloca(sizeof(object) * 2); +c_73829.elts[0] = ((closureN)self_73419)->elts[0]; +c_73829.elts[1] = ((closureN)self_73419)->elts[1]; + +return_funcall1((closure)&c_73829, cdr(((closureN)self_73419)->elts[2])); +} else { + return_funcall1( ((closureN)self_73419)->elts[1], boolean_f);} +; +} + +static void __lambda_58(int argc, object self_73420, object r_73218) { + return_funcall2( cell_get(((closureN)self_73420)->elts[0]), ((closureN)self_73420)->elts[1], r_73218);; +} + +static void __lambda_57(int argc, object self_73421, object r_73214) { + +closureN_type c_73804; +c_73804.tag = closureN_tag; + c_73804.fn = __lambda_56; +c_73804.num_elt = 3; +c_73804.elts = (object *)alloca(sizeof(object) * 3); +c_73804.elts[0] = ((closureN)self_73421)->elts[0]; +c_73804.elts[1] = ((closureN)self_73421)->elts[1]; +c_73804.elts[2] = ((closureN)self_73421)->elts[2]; + +return_funcall1((closure)&c_73804, Cyc_set_car(((closureN)self_73421)->elts[0], r_73214));; +} + +static void __lambda_56(int argc, object self_73422, object r_73212) { + +closureN_type c_73806; +c_73806.tag = closureN_tag; + c_73806.fn = __lambda_55; +c_73806.num_elt = 3; +c_73806.elts = (object *)alloca(sizeof(object) * 3); +c_73806.elts[0] = ((closureN)self_73422)->elts[0]; +c_73806.elts[1] = ((closureN)self_73422)->elts[1]; +c_73806.elts[2] = ((closureN)self_73422)->elts[2]; + +return_funcall1((closure)&c_73806, Cyc_has_cycle(((closureN)self_73422)->elts[2]));; +} + +static void __lambda_55(int argc, object self_73423, object r_73213) { + if( !eq(boolean_f, r_73213) ){ + return_funcall1( ((closureN)self_73423)->elts[1], boolean_t); +} else { + return_funcall2( cell_get(((closureN)self_73423)->elts[0]), ((closureN)self_73423)->elts[1], ((closureN)self_73423)->elts[2]);} +; +} + +static void __lambda_54(int argc, closure _,object k_73208, object x_7338) { + if( !eq(boolean_f, x_7338) ){ + return_funcall1( k_73208, boolean_f); +} else { + return_funcall1( k_73208, boolean_t);} +; +} + +static void __lambda_53(int argc, closure _,object k_73201, object func_7335, object end_7336, object lst_7337) { + +closureN_type c_73767; +c_73767.tag = closureN_tag; + c_73767.fn = __lambda_52; +c_73767.num_elt = 4; +c_73767.elts = (object *)alloca(sizeof(object) * 4); +c_73767.elts[0] = end_7336; +c_73767.elts[1] = func_7335; +c_73767.elts[2] = k_73201; +c_73767.elts[3] = lst_7337; + +return_funcall1((closure)&c_73767, Cyc_is_null(lst_7337));; +} + +static void __lambda_52(int argc, object self_73410, object r_73202) { + if( !eq(boolean_f, r_73202) ){ + return_funcall1( ((closureN)self_73410)->elts[2], ((closureN)self_73410)->elts[0]); +} else { + +closureN_type c_73772; +c_73772.tag = closureN_tag; + c_73772.fn = __lambda_51; +c_73772.num_elt = 4; +c_73772.elts = (object *)alloca(sizeof(object) * 4); +c_73772.elts[0] = ((closureN)self_73410)->elts[0]; +c_73772.elts[1] = ((closureN)self_73410)->elts[1]; +c_73772.elts[2] = ((closureN)self_73410)->elts[2]; +c_73772.elts[3] = ((closureN)self_73410)->elts[3]; + +return_funcall1((closure)&c_73772, car(((closureN)self_73410)->elts[3]));} +; +} + +static void __lambda_51(int argc, object self_73411, object r_73203) { + +closureN_type c_73774; +c_73774.tag = closureN_tag; + c_73774.fn = __lambda_50; +c_73774.num_elt = 4; +c_73774.elts = (object *)alloca(sizeof(object) * 4); +c_73774.elts[0] = ((closureN)self_73411)->elts[0]; +c_73774.elts[1] = ((closureN)self_73411)->elts[1]; +c_73774.elts[2] = ((closureN)self_73411)->elts[2]; +c_73774.elts[3] = r_73203; + +return_funcall1((closure)&c_73774, cdr(((closureN)self_73411)->elts[3]));; +} + +static void __lambda_50(int argc, object self_73412, object r_73205) { + +closureN_type c_73776; +c_73776.tag = closureN_tag; + c_73776.fn = __lambda_49; +c_73776.num_elt = 3; +c_73776.elts = (object *)alloca(sizeof(object) * 3); +c_73776.elts[0] = ((closureN)self_73412)->elts[1]; +c_73776.elts[1] = ((closureN)self_73412)->elts[2]; +c_73776.elts[2] = ((closureN)self_73412)->elts[3]; + +return_funcall4( __glo_foldr, &c_73776, ((closureN)self_73412)->elts[1], ((closureN)self_73412)->elts[0], r_73205);; +} + +static void __lambda_49(int argc, object self_73413, object r_73204) { + return_funcall3( ((closureN)self_73413)->elts[0], ((closureN)self_73413)->elts[1], ((closureN)self_73413)->elts[2], r_73204);; +} + +static void __lambda_48(int argc, closure _,object k_73194, object func_7332, object accum_7333, object lst_7334) { + +closureN_type c_73741; +c_73741.tag = closureN_tag; + c_73741.fn = __lambda_47; +c_73741.num_elt = 4; +c_73741.elts = (object *)alloca(sizeof(object) * 4); +c_73741.elts[0] = accum_7333; +c_73741.elts[1] = func_7332; +c_73741.elts[2] = k_73194; +c_73741.elts[3] = lst_7334; + +return_funcall1((closure)&c_73741, Cyc_is_null(lst_7334));; +} + +static void __lambda_47(int argc, object self_73406, object r_73195) { + if( !eq(boolean_f, r_73195) ){ + return_funcall1( ((closureN)self_73406)->elts[2], ((closureN)self_73406)->elts[0]); +} else { + +closureN_type c_73746; +c_73746.tag = closureN_tag; + c_73746.fn = __lambda_46; +c_73746.num_elt = 4; +c_73746.elts = (object *)alloca(sizeof(object) * 4); +c_73746.elts[0] = ((closureN)self_73406)->elts[0]; +c_73746.elts[1] = ((closureN)self_73406)->elts[1]; +c_73746.elts[2] = ((closureN)self_73406)->elts[2]; +c_73746.elts[3] = ((closureN)self_73406)->elts[3]; + +return_funcall1((closure)&c_73746, car(((closureN)self_73406)->elts[3]));} +; +} + +static void __lambda_46(int argc, object self_73407, object r_73198) { + +closureN_type c_73749; +c_73749.tag = closureN_tag; + c_73749.fn = __lambda_45; +c_73749.num_elt = 3; +c_73749.elts = (object *)alloca(sizeof(object) * 3); +c_73749.elts[0] = ((closureN)self_73407)->elts[1]; +c_73749.elts[1] = ((closureN)self_73407)->elts[2]; +c_73749.elts[2] = ((closureN)self_73407)->elts[3]; + +return_funcall3( ((closureN)self_73407)->elts[1], &c_73749, r_73198, ((closureN)self_73407)->elts[0]);; +} + +static void __lambda_45(int argc, object self_73408, object r_73196) { + +closureN_type c_73751; +c_73751.tag = closureN_tag; + c_73751.fn = __lambda_44; +c_73751.num_elt = 3; +c_73751.elts = (object *)alloca(sizeof(object) * 3); +c_73751.elts[0] = ((closureN)self_73408)->elts[0]; +c_73751.elts[1] = ((closureN)self_73408)->elts[1]; +c_73751.elts[2] = r_73196; + +return_funcall1((closure)&c_73751, cdr(((closureN)self_73408)->elts[2]));; +} + +static void __lambda_44(int argc, object self_73409, object r_73197) { + return_funcall4( __glo_foldl, ((closureN)self_73409)->elts[1], ((closureN)self_73409)->elts[0], ((closureN)self_73409)->elts[2], r_73197);; +} + +static void __lambda_43(int argc, closure _,object k_73189, object c_7331) { + +closureN_type c_73724; +c_73724.tag = closureN_tag; + c_73724.fn = __lambda_42; +c_73724.num_elt = 2; +c_73724.elts = (object *)alloca(sizeof(object) * 2); +c_73724.elts[0] = c_7331; +c_73724.elts[1] = k_73189; + +return_funcall2( __glo_char_91numeric_127, &c_73724, c_7331);; +} + +static void __lambda_42(int argc, object self_73404, object r_73190) { + if( !eq(boolean_f, r_73190) ){ + +closureN_type c_73726; +c_73726.tag = closureN_tag; + c_73726.fn = __lambda_41; +c_73726.num_elt = 1; +c_73726.elts = (object *)alloca(sizeof(object) * 1); +c_73726.elts[0] = ((closureN)self_73404)->elts[1]; + + +integer_type c_73735 = Cyc_char2integer(((closureN)self_73404)->elts[0]); +return_funcall1((closure)&c_73726, &c_73735); +} else { + return_funcall1( ((closureN)self_73404)->elts[1], boolean_f);} +; +} + +static void __lambda_41(int argc, object self_73405, object r_73191) { + +make_int(c_73732, 48); + +common_type c_73731 = Cyc_sub(2,r_73191, &c_73732); +return_funcall1( ((closureN)self_73405)->elts[0], &c_73731);; +} + +static void __lambda_40(int argc, closure _,object k_73185, object c_7330) { + +closureN_type c_73712; +c_73712.tag = closureN_tag; + c_73712.fn = __lambda_39; +c_73712.num_elt = 2; +c_73712.elts = (object *)alloca(sizeof(object) * 2); +c_73712.elts[0] = c_7330; +c_73712.elts[1] = k_73185; + + +make_cons(c_73721,obj_char2obj(10),nil); + +make_cons(c_73720,obj_char2obj(13),&c_73721); + +make_cons(c_73719,obj_char2obj(32),&c_73720); + +make_cons(c_73718,obj_char2obj(9),&c_73719); +return_funcall1((closure)&c_73712, &c_73718);; +} + +static void __lambda_39(int argc, object self_73403, object r_73186) { + return_funcall1( ((closureN)self_73403)->elts[1], memberp(((closureN)self_73403)->elts[0], r_73186));; +} + +static void __lambda_38(int argc, closure _,object k_73181, object c_7329) { + +closureN_type c_73694; +c_73694.tag = closureN_tag; + c_73694.fn = __lambda_37; +c_73694.num_elt = 2; +c_73694.elts = (object *)alloca(sizeof(object) * 2); +c_73694.elts[0] = c_7329; +c_73694.elts[1] = k_73181; + + +make_cons(c_73709,obj_char2obj(57),nil); + +make_cons(c_73708,obj_char2obj(56),&c_73709); + +make_cons(c_73707,obj_char2obj(55),&c_73708); + +make_cons(c_73706,obj_char2obj(54),&c_73707); + +make_cons(c_73705,obj_char2obj(53),&c_73706); + +make_cons(c_73704,obj_char2obj(52),&c_73705); + +make_cons(c_73703,obj_char2obj(51),&c_73704); + +make_cons(c_73702,obj_char2obj(50),&c_73703); + +make_cons(c_73701,obj_char2obj(49),&c_73702); + +make_cons(c_73700,obj_char2obj(48),&c_73701); +return_funcall1((closure)&c_73694, &c_73700);; +} + +static void __lambda_37(int argc, object self_73402, object r_73182) { + return_funcall1( ((closureN)self_73402)->elts[1], memberp(((closureN)self_73402)->elts[0], r_73182));; +} + +static void __lambda_36(int argc, closure _,object k_73177, object c_7328) { + +closureN_type c_73686; +c_73686.tag = closureN_tag; + c_73686.fn = __lambda_35; +c_73686.num_elt = 2; +c_73686.elts = (object *)alloca(sizeof(object) * 2); +c_73686.elts[0] = c_7328; +c_73686.elts[1] = k_73177; + +return_funcall3( __glo_char_125_123_127, &c_73686, c_7328, obj_char2obj(97));; +} + +static void __lambda_35(int argc, object self_73401, object r_73178) { + if( !eq(boolean_f, r_73178) ){ + return_funcall3( __glo_char_121_123_127, ((closureN)self_73401)->elts[1], ((closureN)self_73401)->elts[0], obj_char2obj(122)); +} else { + return_funcall1( ((closureN)self_73401)->elts[1], boolean_f);} +; +} + +static void __lambda_34(int argc, closure _,object k_73173, object c_7327) { + +closureN_type c_73678; +c_73678.tag = closureN_tag; + c_73678.fn = __lambda_33; +c_73678.num_elt = 2; +c_73678.elts = (object *)alloca(sizeof(object) * 2); +c_73678.elts[0] = c_7327; +c_73678.elts[1] = k_73173; + +return_funcall3( __glo_char_125_123_127, &c_73678, c_7327, obj_char2obj(65));; +} + +static void __lambda_33(int argc, object self_73400, object r_73174) { + if( !eq(boolean_f, r_73174) ){ + return_funcall3( __glo_char_121_123_127, ((closureN)self_73400)->elts[1], ((closureN)self_73400)->elts[0], obj_char2obj(90)); +} else { + return_funcall1( ((closureN)self_73400)->elts[1], boolean_f);} +; +} + +static void __lambda_32(int argc, closure _,object k_73169, object c_7326) { + +closureN_type c_73670; +c_73670.tag = closureN_tag; + c_73670.fn = __lambda_31; +c_73670.num_elt = 2; +c_73670.elts = (object *)alloca(sizeof(object) * 2); +c_73670.elts[0] = c_7326; +c_73670.elts[1] = k_73169; + +return_funcall3( __glo_char_125_123_127, &c_73670, c_7326, obj_char2obj(65));; +} + +static void __lambda_31(int argc, object self_73399, object r_73170) { + if( !eq(boolean_f, r_73170) ){ + return_funcall3( __glo_char_121_123_127, ((closureN)self_73399)->elts[1], ((closureN)self_73399)->elts[0], obj_char2obj(122)); +} else { + return_funcall1( ((closureN)self_73399)->elts[1], boolean_f);} +; +} + +static void __lambda_30(int argc, closure _,object k_73163, object c_7325) { + +closureN_type c_73648; +c_73648.tag = closureN_tag; + c_73648.fn = __lambda_29; +c_73648.num_elt = 2; +c_73648.elts = (object *)alloca(sizeof(object) * 2); +c_73648.elts[0] = c_7325; +c_73648.elts[1] = k_73163; + +return_funcall2( __glo_char_91upper_91case_127, &c_73648, c_7325);; +} + +static void __lambda_29(int argc, object self_73396, object r_73164) { + if( !eq(boolean_f, r_73164) ){ + +closureN_type c_73650; +c_73650.tag = closureN_tag; + c_73650.fn = __lambda_28; +c_73650.num_elt = 1; +c_73650.elts = (object *)alloca(sizeof(object) * 1); +c_73650.elts[0] = ((closureN)self_73396)->elts[1]; + + +integer_type c_73663 = Cyc_char2integer(((closureN)self_73396)->elts[0]); +return_funcall1((closure)&c_73650, &c_73663); +} else { + return_funcall1( ((closureN)self_73396)->elts[1], ((closureN)self_73396)->elts[0]);} +; +} + +static void __lambda_28(int argc, object self_73397, object r_73166) { + +closureN_type c_73652; +c_73652.tag = closureN_tag; + c_73652.fn = __lambda_27; +c_73652.num_elt = 1; +c_73652.elts = (object *)alloca(sizeof(object) * 1); +c_73652.elts[0] = ((closureN)self_73397)->elts[0]; + + +make_int(c_73660, 32); + +common_type c_73659 = Cyc_sum(2,r_73166, &c_73660); +return_funcall1((closure)&c_73652, &c_73659);; +} + +static void __lambda_27(int argc, object self_73398, object r_73165) { + return_funcall1( ((closureN)self_73398)->elts[0], Cyc_integer2char(r_73165));; +} + +static void __lambda_26(int argc, closure _,object k_73157, object c_7324) { + +closureN_type c_73626; +c_73626.tag = closureN_tag; + c_73626.fn = __lambda_25; +c_73626.num_elt = 2; +c_73626.elts = (object *)alloca(sizeof(object) * 2); +c_73626.elts[0] = c_7324; +c_73626.elts[1] = k_73157; + +return_funcall2( __glo_char_91lower_91case_127, &c_73626, c_7324);; +} + +static void __lambda_25(int argc, object self_73393, object r_73158) { + if( !eq(boolean_f, r_73158) ){ + +closureN_type c_73628; +c_73628.tag = closureN_tag; + c_73628.fn = __lambda_24; +c_73628.num_elt = 1; +c_73628.elts = (object *)alloca(sizeof(object) * 1); +c_73628.elts[0] = ((closureN)self_73393)->elts[1]; + + +integer_type c_73641 = Cyc_char2integer(((closureN)self_73393)->elts[0]); +return_funcall1((closure)&c_73628, &c_73641); +} else { + return_funcall1( ((closureN)self_73393)->elts[1], ((closureN)self_73393)->elts[0]);} +; +} + +static void __lambda_24(int argc, object self_73394, object r_73160) { + +closureN_type c_73630; +c_73630.tag = closureN_tag; + c_73630.fn = __lambda_23; +c_73630.num_elt = 1; +c_73630.elts = (object *)alloca(sizeof(object) * 1); +c_73630.elts[0] = ((closureN)self_73394)->elts[0]; + + +make_int(c_73638, 32); + +common_type c_73637 = Cyc_sub(2,r_73160, &c_73638); +return_funcall1((closure)&c_73630, &c_73637);; +} + +static void __lambda_23(int argc, object self_73395, object r_73159) { + return_funcall1( ((closureN)self_73395)->elts[0], Cyc_integer2char(r_73159));; +} + +static void __lambda_22(int argc, closure _,object k_73153, object c1_7321, object c2_7322, object cs_7323_raw, ...) { +load_varargs(cs_7323, cs_7323_raw, argc - 3); + +closureN_type c_73617; +c_73617.tag = closureN_tag; + c_73617.fn = __lambda_21; +c_73617.num_elt = 2; +c_73617.elts = (object *)alloca(sizeof(object) * 2); +c_73617.elts[0] = c1_7321; +c_73617.elts[1] = k_73153; + + +make_cons(c_73623,c2_7322, cs_7323); +return_funcall1((closure)&c_73617, &c_73623);; +} + +static void __lambda_21(int argc, object self_73392, object r_73154) { + return_funcall4( __glo_Cyc_91bin_91op_91char, ((closureN)self_73392)->elts[1], primitive__125_123, ((closureN)self_73392)->elts[0], r_73154);; +} + +static void __lambda_20(int argc, closure _,object k_73149, object c1_7318, object c2_7319, object cs_7320_raw, ...) { +load_varargs(cs_7320, cs_7320_raw, argc - 3); + +closureN_type c_73608; +c_73608.tag = closureN_tag; + c_73608.fn = __lambda_19; +c_73608.num_elt = 2; +c_73608.elts = (object *)alloca(sizeof(object) * 2); +c_73608.elts[0] = c1_7318; +c_73608.elts[1] = k_73149; + + +make_cons(c_73614,c2_7319, cs_7320); +return_funcall1((closure)&c_73608, &c_73614);; +} + +static void __lambda_19(int argc, object self_73391, object r_73150) { + return_funcall4( __glo_Cyc_91bin_91op_91char, ((closureN)self_73391)->elts[1], primitive__121_123, ((closureN)self_73391)->elts[0], r_73150);; +} + +static void __lambda_18(int argc, closure _,object k_73145, object c1_7315, object c2_7316, object cs_7317_raw, ...) { +load_varargs(cs_7317, cs_7317_raw, argc - 3); + +closureN_type c_73599; +c_73599.tag = closureN_tag; + c_73599.fn = __lambda_17; +c_73599.num_elt = 2; +c_73599.elts = (object *)alloca(sizeof(object) * 2); +c_73599.elts[0] = c1_7315; +c_73599.elts[1] = k_73145; + + +make_cons(c_73605,c2_7316, cs_7317); +return_funcall1((closure)&c_73599, &c_73605);; +} + +static void __lambda_17(int argc, object self_73390, object r_73146) { + return_funcall4( __glo_Cyc_91bin_91op_91char, ((closureN)self_73390)->elts[1], primitive__125, ((closureN)self_73390)->elts[0], r_73146);; +} + +static void __lambda_16(int argc, closure _,object k_73141, object c1_7312, object c2_7313, object cs_7314_raw, ...) { +load_varargs(cs_7314, cs_7314_raw, argc - 3); + +closureN_type c_73590; +c_73590.tag = closureN_tag; + c_73590.fn = __lambda_15; +c_73590.num_elt = 2; +c_73590.elts = (object *)alloca(sizeof(object) * 2); +c_73590.elts[0] = c1_7312; +c_73590.elts[1] = k_73141; + + +make_cons(c_73596,c2_7313, cs_7314); +return_funcall1((closure)&c_73590, &c_73596);; +} + +static void __lambda_15(int argc, object self_73389, object r_73142) { + return_funcall4( __glo_Cyc_91bin_91op_91char, ((closureN)self_73389)->elts[1], primitive__121, ((closureN)self_73389)->elts[0], r_73142);; +} + +static void __lambda_14(int argc, closure _,object k_73137, object c1_739, object c2_7310, object cs_7311_raw, ...) { +load_varargs(cs_7311, cs_7311_raw, argc - 3); + +closureN_type c_73581; +c_73581.tag = closureN_tag; + c_73581.fn = __lambda_13; +c_73581.num_elt = 2; +c_73581.elts = (object *)alloca(sizeof(object) * 2); +c_73581.elts[0] = c1_739; +c_73581.elts[1] = k_73137; + + +make_cons(c_73587,c2_7310, cs_7311); +return_funcall1((closure)&c_73581, &c_73587);; +} + +static void __lambda_13(int argc, object self_73388, object r_73138) { + return_funcall4( __glo_Cyc_91bin_91op_91char, ((closureN)self_73388)->elts[1], primitive__123, ((closureN)self_73388)->elts[0], r_73138);; +} + +static void __lambda_12(int argc, closure _,object k_73130, object cmp_734, object c_735, object cs_736) { + +closureN_type c_73558; +c_73558.tag = closureN_tag; + c_73558.fn = __lambda_8; +c_73558.num_elt = 3; +c_73558.elts = (object *)alloca(sizeof(object) * 3); +c_73558.elts[0] = c_735; +c_73558.elts[1] = cs_736; +c_73558.elts[2] = k_73130; + + +closureN_type c_73563; +c_73563.tag = closureN_tag; + c_73563.fn = __lambda_11; +c_73563.num_elt = 1; +c_73563.elts = (object *)alloca(sizeof(object) * 1); +c_73563.elts[0] = cmp_734; + +return_funcall1((closure)&c_73558, &c_73563);; +} + +static void __lambda_11(int argc, object self_73384, object k_73132, object x_737, object y_738) { + +closureN_type c_73565; +c_73565.tag = closureN_tag; + c_73565.fn = __lambda_10; +c_73565.num_elt = 3; +c_73565.elts = (object *)alloca(sizeof(object) * 3); +c_73565.elts[0] = ((closureN)self_73384)->elts[0]; +c_73565.elts[1] = k_73132; +c_73565.elts[2] = y_738; + + +integer_type c_73578 = Cyc_char2integer(x_737); +return_funcall1((closure)&c_73565, &c_73578);; +} + +static void __lambda_10(int argc, object self_73385, object r_73133) { + +closureN_type c_73567; +c_73567.tag = closureN_tag; + c_73567.fn = __lambda_9; +c_73567.num_elt = 3; +c_73567.elts = (object *)alloca(sizeof(object) * 3); +c_73567.elts[0] = ((closureN)self_73385)->elts[0]; +c_73567.elts[1] = ((closureN)self_73385)->elts[1]; +c_73567.elts[2] = r_73133; + + +integer_type c_73574 = Cyc_char2integer(((closureN)self_73385)->elts[2]); +return_funcall1((closure)&c_73567, &c_73574);; +} + +static void __lambda_9(int argc, object self_73386, object r_73134) { + return_funcall3( ((closureN)self_73386)->elts[0], ((closureN)self_73386)->elts[1], ((closureN)self_73386)->elts[2], r_73134);; +} + +static void __lambda_8(int argc, object self_73387, object r_73131) { + return_funcall4( __glo_Cyc_91bin_91op, ((closureN)self_73387)->elts[2], r_73131, ((closureN)self_73387)->elts[0], ((closureN)self_73387)->elts[1]);; +} + +static void __lambda_7(int argc, closure _,object k_73122, object cmp_731, object x_732, object lst_733) { + +closureN_type c_73526; +c_73526.tag = closureN_tag; + c_73526.fn = __lambda_6; +c_73526.num_elt = 4; +c_73526.elts = (object *)alloca(sizeof(object) * 4); +c_73526.elts[0] = cmp_731; +c_73526.elts[1] = k_73122; +c_73526.elts[2] = lst_733; +c_73526.elts[3] = x_732; + +return_funcall1((closure)&c_73526, Cyc_is_null(lst_733));; +} + +static void __lambda_6(int argc, object self_73379, object r_73123) { + if( !eq(boolean_f, r_73123) ){ + return_funcall1( ((closureN)self_73379)->elts[1], boolean_t); +} else { + +closureN_type c_73530; +c_73530.tag = closureN_tag; + c_73530.fn = __lambda_5; +c_73530.num_elt = 4; +c_73530.elts = (object *)alloca(sizeof(object) * 4); +c_73530.elts[0] = ((closureN)self_73379)->elts[0]; +c_73530.elts[1] = ((closureN)self_73379)->elts[1]; +c_73530.elts[2] = ((closureN)self_73379)->elts[2]; +c_73530.elts[3] = ((closureN)self_73379)->elts[3]; + +return_funcall1((closure)&c_73530, car(((closureN)self_73379)->elts[2]));} +; +} + +static void __lambda_5(int argc, object self_73380, object r_73127) { + +closureN_type c_73533; +c_73533.tag = closureN_tag; + c_73533.fn = __lambda_4; +c_73533.num_elt = 3; +c_73533.elts = (object *)alloca(sizeof(object) * 3); +c_73533.elts[0] = ((closureN)self_73380)->elts[0]; +c_73533.elts[1] = ((closureN)self_73380)->elts[1]; +c_73533.elts[2] = ((closureN)self_73380)->elts[2]; + +return_funcall3( ((closureN)self_73380)->elts[0], &c_73533, ((closureN)self_73380)->elts[3], r_73127);; +} + +static void __lambda_4(int argc, object self_73381, object r_73124) { + if( !eq(boolean_f, r_73124) ){ + +closureN_type c_73535; +c_73535.tag = closureN_tag; + c_73535.fn = __lambda_3; +c_73535.num_elt = 3; +c_73535.elts = (object *)alloca(sizeof(object) * 3); +c_73535.elts[0] = ((closureN)self_73381)->elts[0]; +c_73535.elts[1] = ((closureN)self_73381)->elts[1]; +c_73535.elts[2] = ((closureN)self_73381)->elts[2]; + +return_funcall1((closure)&c_73535, car(((closureN)self_73381)->elts[2])); +} else { + return_funcall1( ((closureN)self_73381)->elts[1], boolean_f);} +; +} + +static void __lambda_3(int argc, object self_73382, object r_73125) { + +closureN_type c_73537; +c_73537.tag = closureN_tag; + c_73537.fn = __lambda_2; +c_73537.num_elt = 3; +c_73537.elts = (object *)alloca(sizeof(object) * 3); +c_73537.elts[0] = ((closureN)self_73382)->elts[0]; +c_73537.elts[1] = ((closureN)self_73382)->elts[1]; +c_73537.elts[2] = r_73125; + +return_funcall1((closure)&c_73537, cdr(((closureN)self_73382)->elts[2]));; +} + +static void __lambda_2(int argc, object self_73383, object r_73126) { + return_funcall4( __glo_Cyc_91bin_91op, ((closureN)self_73383)->elts[1], ((closureN)self_73383)->elts[0], ((closureN)self_73383)->elts[2], r_73126);; +} + +static void __lambda_1(int argc, closure _,object k, object f) { + +closureN_type c_73520; +c_73520.tag = closureN_tag; + c_73520.fn = __lambda_0; +c_73520.num_elt = 1; +c_73520.elts = (object *)alloca(sizeof(object) * 1); +c_73520.elts[0] = k; + +return_funcall2( f, k, &c_73520);; +} + +static void __lambda_0(int argc, object self_73378, object _191, object result) { + return_funcall1( ((closureN)self_73378)->elts[0], result);; +} + +void c_schemebase_entry_pt(argc, env,cont) int argc; closure env,cont; { + + add_global((object *) &__glo_Cyc_91remove_91exception_91handler); + add_global((object *) &__glo_Cyc_91add_91exception_91handler); + add_global((object *) &__glo__85exception_91handler_91stack_85); + add_global((object *) &__glo_with_91exception_91handler); + add_global((object *) &__glo_raise_91continuable); + add_global((object *) &__glo_raise); + add_global((object *) &__glo_error); + add_global((object *) &__glo_make_91string); + add_global((object *) &__glo_Cyc_91obj_123_127); + add_global((object *) &__glo_symbol_123_127); + add_global((object *) &__glo_boolean_123_127); + add_global((object *) &__glo_reverse); + add_global((object *) &__glo_list_91set_67); + add_global((object *) &__glo_list_91ref); + add_global((object *) &__glo_list_91tail); + add_global((object *) &__glo_for_91each); + add_global((object *) &__glo_map); + add_global((object *) &__glo_list_91copy); + add_global((object *) &__glo_make_91list); + add_global((object *) &__glo__list); + add_global((object *) &__glo_append); + add_global((object *) &__glo_negative_127); + add_global((object *) &__glo_positive_127); + add_global((object *) &__glo_zero_127); + add_global((object *) &__glo_list_127); + add_global((object *) &__glo_not); + add_global((object *) &__glo_foldr); + add_global((object *) &__glo_foldl); + add_global((object *) &__glo_digit_91value); + add_global((object *) &__glo_char_91whitespace_127); + add_global((object *) &__glo_char_91numeric_127); + add_global((object *) &__glo_char_91lower_91case_127); + add_global((object *) &__glo_char_91upper_91case_127); + add_global((object *) &__glo_char_91alphabetic_127); + add_global((object *) &__glo_char_91downcase); + add_global((object *) &__glo_char_91upcase); + add_global((object *) &__glo_char_125_123_127); + add_global((object *) &__glo_char_121_123_127); + add_global((object *) &__glo_char_125_127); + add_global((object *) &__glo_char_121_127); + add_global((object *) &__glo_char_123_127); + add_global((object *) &__glo_Cyc_91bin_91op_91char); + add_global((object *) &__glo_Cyc_91bin_91op); + add_global((object *) &__glo_call_91with_91current_91continuation); + add_global((object *) &__glo__85Cyc_91version_91banner_85); + add_global((object *) &__glo__85features_85); + add_global((object *) &__glo__85c_91file_91header_91comment_85); + add_global((object *) &__glo__85version_91banner_85); + add_global((object *) &__glo__85version_85); + add_global((object *) &__glo_call_95cc); + add_symbol(quote_cyclone); + add_symbol(quote_continuable); + add_symbol(quote_raised); + mclosure0(c_731322, (function_type)__lambda_182); + __glo_Cyc_91remove_91exception_91handler = &c_731322; + mclosure0(c_731312, (function_type)__lambda_178); + __glo_Cyc_91add_91exception_91handler = &c_731312; + mclosure0(c_731230, (function_type)__lambda_176); + __glo_with_91exception_91handler = &c_731230; + mclosure0(c_731217, (function_type)__lambda_156); + __glo_raise_91continuable = &c_731217; + mclosure0(c_731204, (function_type)__lambda_152); + __glo_raise = &c_731204; + mclosure0(c_731196, (function_type)__lambda_148); + __glo_error = &c_731196; + mclosure0(c_731163, (function_type)__lambda_146); + __glo_make_91string = &c_731163; + mclosure0(c_731133, (function_type)__lambda_139); + __glo_Cyc_91obj_123_127 = &c_731133; + mclosure0(c_731124, (function_type)__lambda_130); + __glo_symbol_123_127 = &c_731124; + mclosure0(c_731115, (function_type)__lambda_128); + __glo_boolean_123_127 = &c_731115; + mclosure0(c_731109, (function_type)__lambda_126); + __glo_reverse = &c_731109; + mclosure0(c_731099, (function_type)__lambda_124); + __glo_list_91set_67 = &c_731099; + mclosure0(c_731092, (function_type)__lambda_121); + __glo_list_91ref = &c_731092; + mclosure0(c_731071, (function_type)__lambda_119); + __glo_list_91tail = &c_731071; + mclosure0(c_731046, (function_type)__lambda_115); + __glo_for_91each = &c_731046; + mclosure0(c_731027, (function_type)__lambda_109); + __glo_map = &c_731027; + mclosure0(c_731013, (function_type)__lambda_104); + __glo_list_91copy = &c_731013; + mclosure0(c_73937, (function_type)__lambda_100); + __glo_make_91list = &c_73937; + mclosure0(c_73935, (function_type)__lambda_85); + __glo__list = &c_73935; + mclosure0(c_73863, (function_type)__lambda_84); + __glo_append = &c_73863; + mclosure0(c_73858, (function_type)__lambda_68); + __glo_negative_127 = &c_73858; + mclosure0(c_73853, (function_type)__lambda_67); + __glo_positive_127 = &c_73853; + mclosure0(c_73848, (function_type)__lambda_66); + __glo_zero_127 = &c_73848; + mclosure0(c_73794, (function_type)__lambda_65); + __glo_list_127 = &c_73794; + mclosure0(c_73791, (function_type)__lambda_54); + __glo_not = &c_73791; + mclosure0(c_73765, (function_type)__lambda_53); + __glo_foldr = &c_73765; + mclosure0(c_73739, (function_type)__lambda_48); + __glo_foldl = &c_73739; + mclosure0(c_73722, (function_type)__lambda_43); + __glo_digit_91value = &c_73722; + mclosure0(c_73710, (function_type)__lambda_40); + __glo_char_91whitespace_127 = &c_73710; + mclosure0(c_73692, (function_type)__lambda_38); + __glo_char_91numeric_127 = &c_73692; + mclosure0(c_73684, (function_type)__lambda_36); + __glo_char_91lower_91case_127 = &c_73684; + mclosure0(c_73676, (function_type)__lambda_34); + __glo_char_91upper_91case_127 = &c_73676; + mclosure0(c_73668, (function_type)__lambda_32); + __glo_char_91alphabetic_127 = &c_73668; + mclosure0(c_73646, (function_type)__lambda_30); + __glo_char_91downcase = &c_73646; + mclosure0(c_73624, (function_type)__lambda_26); + __glo_char_91upcase = &c_73624; + mclosure0(c_73615, (function_type)__lambda_22); + __glo_char_125_123_127 = &c_73615; + mclosure0(c_73606, (function_type)__lambda_20); + __glo_char_121_123_127 = &c_73606; + mclosure0(c_73597, (function_type)__lambda_18); + __glo_char_125_127 = &c_73597; + mclosure0(c_73588, (function_type)__lambda_16); + __glo_char_121_127 = &c_73588; + mclosure0(c_73579, (function_type)__lambda_14); + __glo_char_123_127 = &c_73579; + mclosure0(c_73556, (function_type)__lambda_12); + __glo_Cyc_91bin_91op_91char = &c_73556; + mclosure0(c_73524, (function_type)__lambda_7); + __glo_Cyc_91bin_91op = &c_73524; + mclosure0(c_73518, (function_type)__lambda_1); + __glo_call_95cc = &c_73518; + __glo__85exception_91handler_91stack_85 = boolean_f; + __glo_call_91with_91current_91continuation = __glo_call_95cc; + __glo__85Cyc_91version_91banner_85 = __glo__85version_91banner_85; + __glo__85features_85 = boolean_f; + __glo__85c_91file_91header_91comment_85 = boolean_f; + __glo__85version_91banner_85 = boolean_f; + make_string(c_73523, "0.0.1 (Pre-release)"); + __glo__85version_85 = &c_73523; + + make_cvar(cvar_731370, (object *)&__glo_Cyc_91remove_91exception_91handler);make_cons(pair_731371, find_or_add_symbol("Cyc-remove-exception-handler"), &cvar_731370); + make_cvar(cvar_731372, (object *)&__glo_Cyc_91add_91exception_91handler);make_cons(pair_731373, find_or_add_symbol("Cyc-add-exception-handler"), &cvar_731372); + make_cvar(cvar_731374, (object *)&__glo__85exception_91handler_91stack_85);make_cons(pair_731375, find_or_add_symbol("*exception-handler-stack*"), &cvar_731374); + make_cvar(cvar_731376, (object *)&__glo_with_91exception_91handler);make_cons(pair_731377, find_or_add_symbol("with-exception-handler"), &cvar_731376); + make_cvar(cvar_731378, (object *)&__glo_raise_91continuable);make_cons(pair_731379, find_or_add_symbol("raise-continuable"), &cvar_731378); + make_cvar(cvar_731380, (object *)&__glo_raise);make_cons(pair_731381, find_or_add_symbol("raise"), &cvar_731380); + make_cvar(cvar_731382, (object *)&__glo_error);make_cons(pair_731383, find_or_add_symbol("error"), &cvar_731382); + make_cvar(cvar_731384, (object *)&__glo_make_91string);make_cons(pair_731385, find_or_add_symbol("make-string"), &cvar_731384); + make_cvar(cvar_731386, (object *)&__glo_Cyc_91obj_123_127);make_cons(pair_731387, find_or_add_symbol("Cyc-obj=?"), &cvar_731386); + make_cvar(cvar_731388, (object *)&__glo_symbol_123_127);make_cons(pair_731389, find_or_add_symbol("symbol=?"), &cvar_731388); + make_cvar(cvar_731390, (object *)&__glo_boolean_123_127);make_cons(pair_731391, find_or_add_symbol("boolean=?"), &cvar_731390); + make_cvar(cvar_731392, (object *)&__glo_reverse);make_cons(pair_731393, find_or_add_symbol("reverse"), &cvar_731392); + make_cvar(cvar_731394, (object *)&__glo_list_91set_67);make_cons(pair_731395, find_or_add_symbol("list-set!"), &cvar_731394); + make_cvar(cvar_731396, (object *)&__glo_list_91ref);make_cons(pair_731397, find_or_add_symbol("list-ref"), &cvar_731396); + make_cvar(cvar_731398, (object *)&__glo_list_91tail);make_cons(pair_731399, find_or_add_symbol("list-tail"), &cvar_731398); + make_cvar(cvar_731400, (object *)&__glo_for_91each);make_cons(pair_731401, find_or_add_symbol("for-each"), &cvar_731400); + make_cvar(cvar_731402, (object *)&__glo_map);make_cons(pair_731403, find_or_add_symbol("map"), &cvar_731402); + make_cvar(cvar_731404, (object *)&__glo_list_91copy);make_cons(pair_731405, find_or_add_symbol("list-copy"), &cvar_731404); + make_cvar(cvar_731406, (object *)&__glo_make_91list);make_cons(pair_731407, find_or_add_symbol("make-list"), &cvar_731406); + make_cvar(cvar_731408, (object *)&__glo__list);make_cons(pair_731409, find_or_add_symbol("list"), &cvar_731408); + make_cvar(cvar_731410, (object *)&__glo_append);make_cons(pair_731411, find_or_add_symbol("append"), &cvar_731410); + make_cvar(cvar_731412, (object *)&__glo_negative_127);make_cons(pair_731413, find_or_add_symbol("negative?"), &cvar_731412); + make_cvar(cvar_731414, (object *)&__glo_positive_127);make_cons(pair_731415, find_or_add_symbol("positive?"), &cvar_731414); + make_cvar(cvar_731416, (object *)&__glo_zero_127);make_cons(pair_731417, find_or_add_symbol("zero?"), &cvar_731416); + make_cvar(cvar_731418, (object *)&__glo_list_127);make_cons(pair_731419, find_or_add_symbol("list?"), &cvar_731418); + make_cvar(cvar_731420, (object *)&__glo_not);make_cons(pair_731421, find_or_add_symbol("not"), &cvar_731420); + make_cvar(cvar_731422, (object *)&__glo_foldr);make_cons(pair_731423, find_or_add_symbol("foldr"), &cvar_731422); + make_cvar(cvar_731424, (object *)&__glo_foldl);make_cons(pair_731425, find_or_add_symbol("foldl"), &cvar_731424); + make_cvar(cvar_731426, (object *)&__glo_digit_91value);make_cons(pair_731427, find_or_add_symbol("digit-value"), &cvar_731426); + make_cvar(cvar_731428, (object *)&__glo_char_91whitespace_127);make_cons(pair_731429, find_or_add_symbol("char-whitespace?"), &cvar_731428); + make_cvar(cvar_731430, (object *)&__glo_char_91numeric_127);make_cons(pair_731431, find_or_add_symbol("char-numeric?"), &cvar_731430); + make_cvar(cvar_731432, (object *)&__glo_char_91lower_91case_127);make_cons(pair_731433, find_or_add_symbol("char-lower-case?"), &cvar_731432); + make_cvar(cvar_731434, (object *)&__glo_char_91upper_91case_127);make_cons(pair_731435, find_or_add_symbol("char-upper-case?"), &cvar_731434); + make_cvar(cvar_731436, (object *)&__glo_char_91alphabetic_127);make_cons(pair_731437, find_or_add_symbol("char-alphabetic?"), &cvar_731436); + make_cvar(cvar_731438, (object *)&__glo_char_91downcase);make_cons(pair_731439, find_or_add_symbol("char-downcase"), &cvar_731438); + make_cvar(cvar_731440, (object *)&__glo_char_91upcase);make_cons(pair_731441, find_or_add_symbol("char-upcase"), &cvar_731440); + make_cvar(cvar_731442, (object *)&__glo_char_125_123_127);make_cons(pair_731443, find_or_add_symbol("char>=?"), &cvar_731442); + make_cvar(cvar_731444, (object *)&__glo_char_121_123_127);make_cons(pair_731445, find_or_add_symbol("char<=?"), &cvar_731444); + make_cvar(cvar_731446, (object *)&__glo_char_125_127);make_cons(pair_731447, find_or_add_symbol("char>?"), &cvar_731446); + make_cvar(cvar_731448, (object *)&__glo_char_121_127);make_cons(pair_731449, find_or_add_symbol("charinteger x) (char->integer y))) - c - cs))) - (define char=? (lambda (c1 c2 . cs) (Cyc-bin-op-char = c1 (cons c2 cs)))) - (define char? (lambda (c1 c2 . cs) (Cyc-bin-op-char > c1 (cons c2 cs)))) - (define char<=? (lambda (c1 c2 . cs) (Cyc-bin-op-char <= c1 (cons c2 cs)))) - (define char>=? (lambda (c1 c2 . cs) (Cyc-bin-op-char >= c1 (cons c2 cs)))) - (define char-upcase - (lambda (c) - (if (char-lower-case? c) - (integer->char - (- (char->integer c) (- (char->integer #\a) (char->integer #\A)))) - c))) - (define char-downcase - (lambda (c) - (if (char-upper-case? c) - (integer->char - (+ (char->integer c) (- (char->integer #\a) (char->integer #\A)))) - c))) - (define char-alphabetic? (lambda (c) (if (char>=? c #\A) (char<=? c #\z) #f))) - (define char-upper-case? (lambda (c) (if (char>=? c #\A) (char<=? c #\Z) #f))) - (define char-lower-case? (lambda (c) (if (char>=? c #\a) (char<=? c #\z) #f))) - (define char-numeric? - (lambda (c) (member c '(#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)))) - (define char-whitespace? - (lambda (c) (member c '(#\tab #\space #\return #\newline)))) - (define digit-value - (lambda (c) - (if (char-numeric? c) (- (char->integer c) (char->integer #\0)) #f))) - (define foldl - (lambda (func accum lst) - (if (null? lst) accum (foldl func (func (car lst) accum) (cdr lst))))) - (define foldr - (lambda (func end lst) - (if (null? lst) end (func (car lst) (foldr func end (cdr lst)))))) - (define not (lambda (x) (if x #f #t))) - (define list? - (lambda (o) - (define _list? - (lambda (obj) - (if (null? obj) #t (if (pair? obj) (_list? (cdr obj)) #f)))) - (if (Cyc-has-cycle? o) #t (_list? o)))) - (define zero? (lambda (n) (= n 0))) - (define positive? (lambda (n) (> n 0))) - (define negative? (lambda (n) (< n 0))) - (define append - (lambda lst - (define append-2 - (lambda (inlist alist) - (foldr (lambda (ap in) (cons ap in)) alist inlist))) - (if (null? lst) - lst - (if (null? (cdr lst)) - (car lst) - (foldl (lambda (a b) (append-2 b a)) (car lst) (cdr lst)))))) - (define list (lambda objs objs)) - (define make-list - (lambda (k . fill) - ((lambda (x make) - ((lambda () - (set! x (if (null? fill) #f (car fill))) - (set! make - (lambda (n obj) (if (zero? n) '() (cons obj (make (- n 1) obj))))) - (make k x)))) - #f - #f))) - (define list-copy (lambda (lst) (foldr (lambda (x y) (cons x y)) '() lst))) - (define map - (lambda (func lst) (foldr (lambda (x y) (cons (func x) y)) '() lst))) - (define for-each - (lambda (f lst) - (if (null? lst) #t ((lambda () (f (car lst)) (for-each f (cdr lst))))))) - (define list-tail - (lambda (lst k) (if (zero? k) lst (list-tail (cdr lst) (- k 1))))) - (define list-ref (lambda (lst k) (car (list-tail lst k)))) - (define list-set! - (lambda (lst k obj) ((lambda (kth) (set-car! kth obj)) (list-tail lst k)))) - (define reverse (lambda (lst) (foldl cons '() lst))) - (define boolean=? (lambda (b1 b2 . bs) (Cyc-obj=? boolean? b1 (cons b2 bs)))) - (define symbol=? - (lambda (sym1 sym2 . syms) (Cyc-obj=? symbol? sym1 (cons sym2 syms)))) - (define Cyc-obj=? - (lambda (type? obj objs) - (if (type? obj) - (call/cc - (lambda (return) - (for-each (lambda (o) (if (not (eq? o obj)) (return #f) #f)) objs) - #t)) - #f))) - (define make-string - (lambda (k . fill) - ((lambda (fill*) (list->string (apply make-list (cons k fill*)))) - (if (null? fill) '(#\space) fill)))) - (define error (lambda (msg . args) (raise (cons msg args)))) - (define raise - (lambda (obj) ((Cyc-current-exception-handler) (list 'raised obj)))) - (define raise-continuable - (lambda (obj) ((Cyc-current-exception-handler) (list 'continuable obj)))) - (define with-exception-handler - (lambda (handler thunk) - ((lambda (result my-handler) - (Cyc-add-exception-handler my-handler) - (set! result (thunk)) - (Cyc-remove-exception-handler) - result) - #f - (lambda (obj) - ((lambda (result continuable?) - (Cyc-remove-exception-handler) - (set! result (handler (cadr obj))) - (if continuable? result (error "exception handler returned"))) - #f - (if (pair? obj) (equal? (car obj) 'continuable) #f)))))) - (define *exception-handler-stack* '()) - (define Cyc-add-exception-handler - (lambda (h) - (set! *exception-handler-stack* (cons h *exception-handler-stack*)))) - (define Cyc-remove-exception-handler - (lambda () - (if (not (null? *exception-handler-stack*)) - (set! *exception-handler-stack* (cdr *exception-handler-stack*)) - #f))) - (define lib2-hello "Hello from library #2") - (write lib2-hello)) - */ -/* -"---------------- after processing globals" - */ -/* -((define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - ((lambda () (set! *exception-handler-stack* '()) (write lib2-hello)))) - */ -/* -"---------------- after alpha conversion:" - */ -/* -((define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - ((lambda () (set! *exception-handler-stack* '()) (write lib2-hello)))) - */ -/* -"---------------- after CPS:" - */ -/* -((define call/cc (lambda (k f) (f k (lambda (_ result) (k result))))) - (define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - ((lambda () - ((lambda (r$6) - ((lambda (r$5) (%halt (write lib2-hello))) - (set! *exception-handler-stack* r$6))) - '())))) - */ -/* -"---------------- after wrap-mutables:" - */ -/* -((define call/cc (lambda (k f) (f k (lambda (_ result) (k result))))) - (define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - ((lambda () - ((lambda (r$6) - ((lambda (r$5) (%halt (write lib2-hello))) - (set-global! *exception-handler-stack* r$6))) - '())))) - */ -/* -"---------------- after closure-convert:" - */ -/* -((define call/cc - (lambda (k f) - ((%closure-ref f 0) - f - k - (%closure - (lambda (self$7 _ result) - ((%closure-ref (%closure-ref self$7 1) 0) - (%closure-ref self$7 1) - result)) - k)))) - (define *exception-handler-stack* (%closure-ref #f 0) #f) - (define lib2-hello - (%closure-ref "Hello from library #2" 0) - "Hello from library #2") - ((lambda () - ((lambda (r$6) - ((lambda (r$5) (%halt (write lib2-hello))) - (set-global! *exception-handler-stack* r$6))) - '())))) - */ -/* -"---------------- C code:" - */ #define funcall0(cfn) ((cfn)->fn)(0,cfn) /* Return to continuation after checking for stack overflow. */ #define return_funcall0(cfn) \ @@ -278,71 +61,85 @@ } else { (_fn)(2,(closure)_fn,a1,a2); }} #include "cyclone.h" -extern object __glo_lib2_91hello; -//object __glo_lib2_91hello = nil; -object __glo__85exception_91handler_91stack_85 = nil; -object __glo_call_95cc = nil; - - +extern object __glo__85Cyc_91version_91banner_85; +extern object __glo_call_91with_91current_91continuation; +extern object __glo_call_95cc; +extern object __glo_char_123_127; +extern object __glo_char_121_127; +extern object __glo_char_125_127; +extern object __glo_char_121_123_127; +extern object __glo_char_125_123_127; +extern object __glo_char_91upcase; +extern object __glo_char_91downcase; +extern object __glo_char_91alphabetic_127; +extern object __glo_char_91upper_91case_127; +extern object __glo_char_91lower_91case_127; +extern object __glo_char_91numeric_127; +extern object __glo_char_91whitespace_127; +extern object __glo_digit_91value; +extern object __glo_foldl; +extern object __glo_foldr; +extern object __glo_not; +extern object __glo_list_127; +extern object __glo_zero_127; +extern object __glo_positive_127; +extern object __glo_negative_127; +extern object __glo_append; +extern object __glo__list; +extern object __glo_make_91list; +extern object __glo_list_91copy; +extern object __glo_map; +extern object __glo_for_91each; +extern object __glo_list_91tail; +extern object __glo_list_91ref; +extern object __glo_list_91set_67; +extern object __glo_reverse; +extern object __glo_boolean_123_127; +extern object __glo_symbol_123_127; +extern object __glo_Cyc_91obj_123_127; +extern object __glo_make_91string; +extern object __glo_error; +extern object __glo_raise; +extern object __glo_raise_91continuable; +extern object __glo_with_91exception_91handler; +extern object __glo__85exception_91handler_91stack_85; +extern object __glo_Cyc_91add_91exception_91handler; +extern object __glo_Cyc_91remove_91exception_91handler; +extern object __glo_lib1_91hello; +extern object __glo_lib1_91test; #include "runtime.h" #include "runtime-main.h" -static void __lambda_4(int argc, closure _) ; -static void __lambda_3(int argc, closure _,object r_736) ; -static void __lambda_2(int argc, closure _,object r_735) ; -static void __lambda_1(int argc, closure _,object k, object f) ; -static void __lambda_0(int argc, object self_737, object _191, object result) ; +static void __lambda_3(int argc, closure _) ; +static void __lambda_2(int argc, closure _,object r_731) ; +static void __lambda_1(int argc, closure _,object r_732) ; +static void __lambda_0(int argc, closure _,object r_733) ; -static void __lambda_4(int argc, closure _) { - return_check1(__lambda_3,nil);; +static void __lambda_3(int argc, closure _) { + make_int(c_7318, 0); +return_check1(__lambda_2,&c_7318);; } -static void __lambda_3(int argc, closure _,object r_736) { - return_check1(__lambda_2,global_set(__glo__85exception_91handler_91stack_85, r_736));; +static void __lambda_2(int argc, closure _,object r_731) { + make_string(c_7317, "hello"); +return_check1(__lambda_1,Cyc_write(&c_7317));; } -static void __lambda_2(int argc, closure _,object r_735) { - __halt(Cyc_write(__glo_lib2_91hello)); +static void __lambda_1(int argc, closure _,object r_732) { + return_check1(__lambda_0,Cyc_write(__glo_lib1_91hello));; } -static void __lambda_1(int argc, closure _,object k, object f) { - -closureN_type c_7310; -c_7310.tag = closureN_tag; - c_7310.fn = __lambda_0; -c_7310.num_elt = 1; -c_7310.elts = (object *)alloca(sizeof(object) * 1); -c_7310.elts[0] = k; - -return_funcall2( f, k, &c_7310);; +static void __lambda_0(int argc, closure _,object r_733) { + make_string(c_7312, "world"); + __halt(Cyc_write(&c_7312)); } -static void __lambda_0(int argc, object self_737, object _191, object result) { - return_funcall1( ((closureN)self_737)->elts[0], result);; -} +static void c_entry_pt(argc, env,cont) int argc; closure env,cont; { + c_schemebase_entry_pt(argc, env,cont); + c_libslib1_entry_pt(argc, env, cont); + c_libslib2_entry_pt(argc, env, cont); - static void c_entry_pt(argc, env,cont) int argc; closure env,cont; { - - //add_global((object *) &__glo_lib2_91hello); - add_global((object *) &__glo__85exception_91handler_91stack_85); - add_global((object *) &__glo_call_95cc); - mclosure0(c_738, (function_type)__lambda_1); - __glo_call_95cc = &c_738; - //make_string(c_7313, "Hello from library #2"); - //__glo_lib2_91hello = &c_7313; - __glo__85exception_91handler_91stack_85 = boolean_f; - - //make_cvar(cvar_7323, (object *)&__glo_lib2_91hello);make_cons(pair_7324, find_or_add_symbol("lib2-hello"), &cvar_7323); - make_cvar(cvar_7325, (object *)&__glo__85exception_91handler_91stack_85);make_cons(pair_7326, find_or_add_symbol("*exception-handler-stack*"), &cvar_7325); - make_cvar(cvar_7327, (object *)&__glo_call_95cc);make_cons(pair_7328, find_or_add_symbol("call/cc"), &cvar_7327); -//make_cons(c_7331, &pair_7324,nil); -make_cons(c_7330, &pair_7326, nil); //&c_7331); -make_cons(c_7329, &pair_7328, &c_7330); -Cyc_global_variables = &c_7329; - - c_lib2_entry_pt(argc, env, cont); - - return_check0(__lambda_4); + return_check0(__lambda_3); } main(int argc,char **argv) {long stack_size = long_arg(argc,argv,"-s",STACK_SIZE); diff --git a/examples/hello-library/int-test/lib2.c b/examples/hello-library/int-test/lib2.c deleted file mode 100644 index 07869809..00000000 --- a/examples/hello-library/int-test/lib2.c +++ /dev/null @@ -1,315 +0,0 @@ -/** - ** This file was automatically generated by the Cyclone scheme compiler - ** - ** (c) 2014 Justin Ethier - ** Version 0.0.1 (Pre-release) - ** - **/ - -/* -"---------------- input program:" - */ -/* -((define-library - (libs lib2) - (export lib2-hello) - (begin (define lib2-hello "Hello from library #2")))) - */ -/* -"---------------- after macro expansion:" - */ -/* -((define *Cyc-version-banner* - "\n :@ \n @@@ \n @@@@: \n `@@@@@+ \n .@@@+@@@ Cyclone \n @@ @@ An experimental Scheme compiler\n ,@ https://github.com/justinethier/cyclone\n '@ \n .@ \n @@ #@ (c) 2014 Justin Ethier\n `@@@#@@@. Version 0.0.1 (Pre-release)\n #@@@@@ \n +@@@+ \n @@# \n `@. \n \n") - (define call-with-current-continuation call/cc) - (define Cyc-bin-op - (lambda (cmp x lst) - (if (null? lst) - #t - (if (cmp x (car lst)) (Cyc-bin-op cmp (car lst) (cdr lst)) #f)))) - (define Cyc-bin-op-char - (lambda (cmp c cs) - (Cyc-bin-op - (lambda (x y) (cmp (char->integer x) (char->integer y))) - c - cs))) - (define char=? (lambda (c1 c2 . cs) (Cyc-bin-op-char = c1 (cons c2 cs)))) - (define char? (lambda (c1 c2 . cs) (Cyc-bin-op-char > c1 (cons c2 cs)))) - (define char<=? (lambda (c1 c2 . cs) (Cyc-bin-op-char <= c1 (cons c2 cs)))) - (define char>=? (lambda (c1 c2 . cs) (Cyc-bin-op-char >= c1 (cons c2 cs)))) - (define char-upcase - (lambda (c) - (if (char-lower-case? c) - (integer->char - (- (char->integer c) (- (char->integer #\a) (char->integer #\A)))) - c))) - (define char-downcase - (lambda (c) - (if (char-upper-case? c) - (integer->char - (+ (char->integer c) (- (char->integer #\a) (char->integer #\A)))) - c))) - (define char-alphabetic? (lambda (c) (if (char>=? c #\A) (char<=? c #\z) #f))) - (define char-upper-case? (lambda (c) (if (char>=? c #\A) (char<=? c #\Z) #f))) - (define char-lower-case? (lambda (c) (if (char>=? c #\a) (char<=? c #\z) #f))) - (define char-numeric? - (lambda (c) (member c '(#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)))) - (define char-whitespace? - (lambda (c) (member c '(#\tab #\space #\return #\newline)))) - (define digit-value - (lambda (c) - (if (char-numeric? c) (- (char->integer c) (char->integer #\0)) #f))) - (define foldl - (lambda (func accum lst) - (if (null? lst) accum (foldl func (func (car lst) accum) (cdr lst))))) - (define foldr - (lambda (func end lst) - (if (null? lst) end (func (car lst) (foldr func end (cdr lst)))))) - (define not (lambda (x) (if x #f #t))) - (define list? - (lambda (o) - (define _list? - (lambda (obj) - (if (null? obj) #t (if (pair? obj) (_list? (cdr obj)) #f)))) - (if (Cyc-has-cycle? o) #t (_list? o)))) - (define zero? (lambda (n) (= n 0))) - (define positive? (lambda (n) (> n 0))) - (define negative? (lambda (n) (< n 0))) - (define append - (lambda lst - (define append-2 - (lambda (inlist alist) - (foldr (lambda (ap in) (cons ap in)) alist inlist))) - (if (null? lst) - lst - (if (null? (cdr lst)) - (car lst) - (foldl (lambda (a b) (append-2 b a)) (car lst) (cdr lst)))))) - (define list (lambda objs objs)) - (define make-list - (lambda (k . fill) - ((lambda (x make) - ((lambda () - (set! x (if (null? fill) #f (car fill))) - (set! make - (lambda (n obj) (if (zero? n) '() (cons obj (make (- n 1) obj))))) - (make k x)))) - #f - #f))) - (define list-copy (lambda (lst) (foldr (lambda (x y) (cons x y)) '() lst))) - (define map - (lambda (func lst) (foldr (lambda (x y) (cons (func x) y)) '() lst))) - (define for-each - (lambda (f lst) - (if (null? lst) #t ((lambda () (f (car lst)) (for-each f (cdr lst))))))) - (define list-tail - (lambda (lst k) (if (zero? k) lst (list-tail (cdr lst) (- k 1))))) - (define list-ref (lambda (lst k) (car (list-tail lst k)))) - (define list-set! - (lambda (lst k obj) ((lambda (kth) (set-car! kth obj)) (list-tail lst k)))) - (define reverse (lambda (lst) (foldl cons '() lst))) - (define boolean=? (lambda (b1 b2 . bs) (Cyc-obj=? boolean? b1 (cons b2 bs)))) - (define symbol=? - (lambda (sym1 sym2 . syms) (Cyc-obj=? symbol? sym1 (cons sym2 syms)))) - (define Cyc-obj=? - (lambda (type? obj objs) - (if (type? obj) - (call/cc - (lambda (return) - (for-each (lambda (o) (if (not (eq? o obj)) (return #f) #f)) objs) - #t)) - #f))) - (define make-string - (lambda (k . fill) - ((lambda (fill*) (list->string (apply make-list (cons k fill*)))) - (if (null? fill) '(#\space) fill)))) - (define error (lambda (msg . args) (raise (cons msg args)))) - (define raise - (lambda (obj) ((Cyc-current-exception-handler) (list 'raised obj)))) - (define raise-continuable - (lambda (obj) ((Cyc-current-exception-handler) (list 'continuable obj)))) - (define with-exception-handler - (lambda (handler thunk) - ((lambda (result my-handler) - (Cyc-add-exception-handler my-handler) - (set! result (thunk)) - (Cyc-remove-exception-handler) - result) - #f - (lambda (obj) - ((lambda (result continuable?) - (Cyc-remove-exception-handler) - (set! result (handler (cadr obj))) - (if continuable? result (error "exception handler returned"))) - #f - (if (pair? obj) (equal? (car obj) 'continuable) #f)))))) - (define *exception-handler-stack* '()) - (define Cyc-add-exception-handler - (lambda (h) - (set! *exception-handler-stack* (cons h *exception-handler-stack*)))) - (define Cyc-remove-exception-handler - (lambda () - (if (not (null? *exception-handler-stack*)) - (set! *exception-handler-stack* (cdr *exception-handler-stack*)) - #f))) - (define lib2-hello "Hello from library #2")) - */ -/* -"---------------- after processing globals" - */ -/* -((define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - (set! *exception-handler-stack* '())) - */ -/* -"---------------- after alpha conversion:" - */ -/* -((define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - (set! *exception-handler-stack* '())) - */ -/* -"---------------- after CPS:" - */ -/* -((define call/cc (lambda (k f) (f k (lambda (_ result) (k result))))) - (define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - ((lambda (r$5) (%halt (set! *exception-handler-stack* r$5))) '())) - */ -/* -"---------------- after wrap-mutables:" - */ -/* -((define call/cc (lambda (k f) (f k (lambda (_ result) (k result))))) - (define *exception-handler-stack* #f) - (define lib2-hello "Hello from library #2") - ((lambda (r$5) (%halt (set-global! *exception-handler-stack* r$5))) '())) - */ -/* -"---------------- after closure-convert:" - */ -/* -((define call/cc - (lambda (k f) - ((%closure-ref f 0) - f - k - (%closure - (lambda (self$6 _ result) - ((%closure-ref (%closure-ref self$6 1) 0) - (%closure-ref self$6 1) - result)) - k)))) - (define *exception-handler-stack* (%closure-ref #f 0) #f) - (define lib2-hello - (%closure-ref "Hello from library #2" 0) - "Hello from library #2") - ((lambda (r$5) (%halt (set-global! *exception-handler-stack* r$5))) '())) - */ -/* -"---------------- C code:" - */ - -#define funcall1(cfn,a1) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(0, (closure)a1, cfn); } else { ((cfn)->fn)(1,cfn,a1);} -/* Return to continuation after checking for stack overflow. */ -#define return_funcall1(cfn,a1) \ -{char stack; \ - if (check_overflow(&stack,stack_limit1)) { \ - object buf[1]; buf[0] = a1;\ - GC(cfn,buf,1); return; \ - } else {funcall1((closure) (cfn),a1); return;}} - -/* Evaluate an expression after checking for stack overflow. */ -#define return_check1(_fn,a1) { \ - char stack; \ - if (check_overflow(&stack,stack_limit1)) { \ - object buf[1]; buf[0] = a1; \ - mclosure0(c1, _fn); \ - GC(&c1, buf, 1); return; \ - } else { (_fn)(1,(closure)_fn,a1); }} - -#define funcall2(cfn,a1,a2) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(1, (closure)a1, cfn,a2); } else { ((cfn)->fn)(2,cfn,a1,a2);} -/* Return to continuation after checking for stack overflow. */ -#define return_funcall2(cfn,a1,a2) \ -{char stack; \ - if (check_overflow(&stack,stack_limit1)) { \ - object buf[2]; buf[0] = a1;buf[1] = a2;\ - GC(cfn,buf,2); return; \ - } else {funcall2((closure) (cfn),a1,a2); return;}} - -/* Evaluate an expression after checking for stack overflow. */ -#define return_check2(_fn,a1,a2) { \ - char stack; \ - if (check_overflow(&stack,stack_limit1)) { \ - object buf[2]; buf[0] = a1;buf[1] = a2; \ - mclosure0(c1, _fn); \ - GC(&c1, buf, 2); return; \ - } else { (_fn)(2,(closure)_fn,a1,a2); }} - -#include "cyclone.h" - -object __glo_lib2_91hello = nil; - -#include "runtime.h" - -static void __lambda_2(int argc, closure _,object r_735) ; -static void __lambda_1(int argc, closure _,object k, object f) ; -static void __lambda_0(int argc, object self_736, object _191, object result) ; - -static void __lambda_2(int argc, closure _,object r_735) { - __halt(global_set(__glo__85exception_91handler_91stack_85, r_735)); -} - -static void __lambda_1(int argc, closure _,object k, object f) { - -closureN_type c_739; -c_739.tag = closureN_tag; - c_739.fn = __lambda_0; -c_739.num_elt = 1; -c_739.elts = (object *)alloca(sizeof(object) * 1); -c_739.elts[0] = k; - -return_funcall2( f, k, &c_739);; -} - -static void __lambda_0(int argc, object self_736, object _191, object result) { - return_funcall1( ((closureN)self_736)->elts[0], result);; -} - - - void c_lib2_entry_pt(argc, env,cont) int argc; closure env,cont; { -// static void c_entry_pt(argc, env,cont) int argc; closure env,cont; { -// mclosure0(c_737, (function_type)__lambda_1); -// __glo_call_95cc = &c_737; - add_global((object *) &__glo_lib2_91hello); - make_string(c_7312, "Hello from library #2"); - __glo_lib2_91hello = &c_7312; - // TODO: How to assign lib2 to Cyc_global_variables? - make_cvar(cvar_7323, (object *)&__glo_lib2_91hello);make_cons(pair_7324, find_or_add_symbol("lib2-hello"), &cvar_7323); - make_cons(c_1, &pair_7324, Cyc_global_variables); - Cyc_global_variables = &c_1; - -// __glo__85exception_91handler_91stack_85 = boolean_f; -// -// make_cvar(cvar_7318, (object *)&__glo_lib2_91hello);make_cons(pair_7319, find_or_add_symbol("lib2-hello"), &cvar_7318); -// make_cvar(cvar_7320, (object *)&__glo__85exception_91handler_91stack_85);make_cons(pair_7321, find_or_add_symbol("*exception-handler-stack*"), &cvar_7320); -// make_cvar(cvar_7322, (object *)&__glo_call_95cc);make_cons(pair_7323, find_or_add_symbol("call/cc"), &cvar_7322); -//make_cons(c_7326, &pair_7319,nil); -//make_cons(c_7325, &pair_7321, &c_7326); -//make_cons(c_7324, &pair_7323, &c_7325); -//Cyc_global_variables = &c_7324; -// -// -// return_check1(__lambda_2,nil); -} -//main(int argc,char **argv) -//{long stack_size = long_arg(argc,argv,"-s",STACK_SIZE); -// long heap_size = long_arg(argc,argv,"-h",HEAP_SIZE); -// global_stack_size = stack_size; -// global_heap_size = heap_size; -// main_main(stack_size,heap_size,(char *) &stack_size); -// return 0;} diff --git a/examples/hello-library/int-test/libs/lib1.c b/examples/hello-library/int-test/libs/lib1.c new file mode 100644 index 00000000..201b93fc --- /dev/null +++ b/examples/hello-library/int-test/libs/lib1.c @@ -0,0 +1,139 @@ +/** + ** This file was automatically generated by the Cyclone scheme compiler + ** + ** (c) 2014 Justin Ethier + ** Version 0.0.1 (Pre-release) + ** + **/ + +#define funcall1(cfn,a1) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(0, (closure)a1, cfn); } else { ((cfn)->fn)(1,cfn,a1);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall1(cfn,a1) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[1]; buf[0] = a1;\ + GC(cfn,buf,1); return; \ + } else {funcall1((closure) (cfn),a1); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check1(_fn,a1) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[1]; buf[0] = a1; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 1); return; \ + } else { (_fn)(1,(closure)_fn,a1); }} + +#define funcall2(cfn,a1,a2) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(1, (closure)a1, cfn,a2); } else { ((cfn)->fn)(2,cfn,a1,a2);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall2(cfn,a1,a2) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[2]; buf[0] = a1;buf[1] = a2;\ + GC(cfn,buf,2); return; \ + } else {funcall2((closure) (cfn),a1,a2); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check2(_fn,a1,a2) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[2]; buf[0] = a1;buf[1] = a2; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 2); return; \ + } else { (_fn)(2,(closure)_fn,a1,a2); }} + +#include "cyclone.h" +object __glo_lib1_91hello = nil; +object __glo_internal_91func = nil; +object __glo_lib1_91test = nil; +extern object __glo__85Cyc_91version_91banner_85; +extern object __glo_call_91with_91current_91continuation; +extern object __glo_call_95cc; +extern object __glo_char_123_127; +extern object __glo_char_121_127; +extern object __glo_char_125_127; +extern object __glo_char_121_123_127; +extern object __glo_char_125_123_127; +extern object __glo_char_91upcase; +extern object __glo_char_91downcase; +extern object __glo_char_91alphabetic_127; +extern object __glo_char_91upper_91case_127; +extern object __glo_char_91lower_91case_127; +extern object __glo_char_91numeric_127; +extern object __glo_char_91whitespace_127; +extern object __glo_digit_91value; +extern object __glo_foldl; +extern object __glo_foldr; +extern object __glo_not; +extern object __glo_list_127; +extern object __glo_zero_127; +extern object __glo_positive_127; +extern object __glo_negative_127; +extern object __glo_append; +extern object __glo__list; +extern object __glo_make_91list; +extern object __glo_list_91copy; +extern object __glo_map; +extern object __glo_for_91each; +extern object __glo_list_91tail; +extern object __glo_list_91ref; +extern object __glo_list_91set_67; +extern object __glo_reverse; +extern object __glo_boolean_123_127; +extern object __glo_symbol_123_127; +extern object __glo_Cyc_91obj_123_127; +extern object __glo_make_91string; +extern object __glo_error; +extern object __glo_raise; +extern object __glo_raise_91continuable; +extern object __glo_with_91exception_91handler; +extern object __glo__85exception_91handler_91stack_85; +extern object __glo_Cyc_91add_91exception_91handler; +extern object __glo_Cyc_91remove_91exception_91handler; +extern object __glo_lib2_91hello; +#include "runtime.h" +void __lambda_2(int argc, closure _,object k_738) ; +void __lambda_1(int argc, object self_7310, object r_739) ; +void __lambda_0(int argc, closure _,object k_735) ; + +void __lambda_2(int argc, closure _,object k_738) { + +closureN_type c_7318; +c_7318.tag = closureN_tag; + c_7318.fn = __lambda_1; +c_7318.num_elt = 1; +c_7318.elts = (object *)alloca(sizeof(object) * 1); +c_7318.elts[0] = k_738; + +return_funcall1( __glo_internal_91func, &c_7318);; +} + +void __lambda_1(int argc, object self_7310, object r_739) { + +make_int(c_7321, 1); +return_funcall1( ((closureN)self_7310)->elts[0], &c_7321);; +} + +void __lambda_0(int argc, closure _,object k_735) { + return_funcall1( k_735, Cyc_write(__glo_lib2_91hello));; +} + +void c_libslib1_entry_pt(argc, env,cont) int argc; closure env,cont; { + + add_global((object *) &__glo_lib1_91hello); + add_global((object *) &__glo_internal_91func); + add_global((object *) &__glo_lib1_91test); + mclosure0(c_7316, (function_type)__lambda_2); + __glo_lib1_91hello = &c_7316; + mclosure0(c_7312, (function_type)__lambda_0); + __glo_internal_91func = &c_7312; + make_string(c_7311, "test of include from a library"); + __glo_lib1_91test = &c_7311; + + make_cvar(cvar_7325, (object *)&__glo_lib1_91hello);make_cons(pair_7326, find_or_add_symbol("lib1-hello"), &cvar_7325); + make_cvar(cvar_7327, (object *)&__glo_internal_91func);make_cons(pair_7328, find_or_add_symbol("internal-func"), &cvar_7327); + make_cvar(cvar_7329, (object *)&__glo_lib1_91test);make_cons(pair_7330, find_or_add_symbol("lib1-test"), &cvar_7329); +make_cons(c_7333, &pair_7326,Cyc_global_variables); +make_cons(c_7332, &pair_7328, &c_7333); +make_cons(c_7331, &pair_7330, &c_7332); +Cyc_global_variables = &c_7331;} diff --git a/examples/hello-library/int-test/libs/lib2.c b/examples/hello-library/int-test/libs/lib2.c new file mode 100644 index 00000000..3599c844 --- /dev/null +++ b/examples/hello-library/int-test/libs/lib2.c @@ -0,0 +1,58 @@ +/** + ** This file was automatically generated by the Cyclone scheme compiler + ** + ** (c) 2014 Justin Ethier + ** Version 0.0.1 (Pre-release) + ** + **/ + +#define funcall1(cfn,a1) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(0, (closure)a1, cfn); } else { ((cfn)->fn)(1,cfn,a1);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall1(cfn,a1) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[1]; buf[0] = a1;\ + GC(cfn,buf,1); return; \ + } else {funcall1((closure) (cfn),a1); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check1(_fn,a1) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[1]; buf[0] = a1; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 1); return; \ + } else { (_fn)(1,(closure)_fn,a1); }} + +#define funcall2(cfn,a1,a2) if (type_of(cfn) == cons_tag || prim(cfn)) { Cyc_apply(1, (closure)a1, cfn,a2); } else { ((cfn)->fn)(2,cfn,a1,a2);} +/* Return to continuation after checking for stack overflow. */ +#define return_funcall2(cfn,a1,a2) \ +{char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[2]; buf[0] = a1;buf[1] = a2;\ + GC(cfn,buf,2); return; \ + } else {funcall2((closure) (cfn),a1,a2); return;}} + +/* Evaluate an expression after checking for stack overflow. */ +#define return_check2(_fn,a1,a2) { \ + char stack; \ + if (check_overflow(&stack,stack_limit1)) { \ + object buf[2]; buf[0] = a1;buf[1] = a2; \ + mclosure0(c1, _fn); \ + GC(&c1, buf, 2); return; \ + } else { (_fn)(2,(closure)_fn,a1,a2); }} + +#include "cyclone.h" +object __glo_lib2_91hello = nil; +#include "runtime.h" + +void c_libslib2_entry_pt(argc, env,cont) int argc; closure env,cont; { + + add_global((object *) &__glo_lib2_91hello); + make_string(c_733, "Hello from library #2"); + __glo_lib2_91hello = &c_733; + + make_cvar(cvar_737, (object *)&__glo_lib2_91hello);make_cons(pair_738, find_or_add_symbol("lib2-hello"), &cvar_737); +make_cons(c_739, &pair_738,Cyc_global_variables); +Cyc_global_variables = &c_739; +}