diff --git a/tests/experimental/fac-test.c b/tests/experimental/fac-test.c
index a9612229..b54a2b06 100644
--- a/tests/experimental/fac-test.c
+++ b/tests/experimental/fac-test.c
@@ -3082,43 +3082,107 @@ extern object __glo_square_191_191inline_191_191_scheme_base;
 extern object __glo_eof_91object_191_191inline_191_191_scheme_base;
 #include "cyclone/runtime.h"
 #include "cyclone/runtime-main.h"
-static void __lambda_3(void *data, int argc, object self_7312, object r_7310) ;
-static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) ;
-static void __lambda_2(void *data, int argc, object self_7311, object r_737) ;
+static void __host_lambda_1(void *data, int pc, int argc, object *args);
+static void __host_lambda_1(void *data, int pc, int argc, object *args) { // TODO: self? cont?
+  object top;
+  object stack = ((gc_thread_data *)data)->args; // TODO: do it inline for benchmarks/production code
+//  // initialize "stack" here, and unload arguments.
+//  // assumes the compile can compute the stack's max size, since it knows the number of args each function has
+//  memcpy(stack, args, sizeof(object) * argc);
 
-static void __lambda_3(void *data, int argc, object self_7312, object r_7310) {
-  return_closcall2(data,  __glo_write_scheme_write,  primitive__75halt, r_7310);; 
-}
+  loop:
+  top = alloca(sizeof(object)); // TODO: is there a more efficient way?
+  // TODO: if exceeded stack limit, initiate minor GC
+  //       bundle up args, pc, and pass them along
 
-static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) {
-  Cyc_st_add(data, "fac-test.scm:fac");
-  object c_7316 = Cyc_num_fast_eq_op(data,n_731_732, obj_int2obj(0));
+  switch(((gc_thread_data *)data)->pc) {
+    3: { // Lambda ID 3
+      //static void __lambda_3(void *data, int argc, object self_7312, object r_7310) {
+      //  return_closcall2(data,  __glo_write_scheme_write,  primitive__75halt, r_7310);; 
+      return_closcall2(data,  __glo_write_scheme_write,  primitive__75halt, stack[1]); 
+      break;
+    }
+    1: { // Lambda ID 1
+//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) {
+Cyc_st_add(data, "fac-test.scm:fac");
+// TODO: how much smarter does our compiler need to be to compute local jumps for the below instead of C fnc calls?
+object c_7316 = Cyc_num_fast_eq_op(data, stack[1], obj_int2obj(0));
 if( (boolean_f != c_7316) ){ 
   return_closcall1(data,  k_735,  obj_int2obj(1));
 } else { 
   
-closureN_type c_7319;
-c_7319.hdr.mark = gc_color_red;
- c_7319.hdr.grayed = 0;
-c_7319.tag = closureN_tag;
- c_7319.fn = (function_type)__lambda_2;
-c_7319.num_args = 1;
-c_7319.num_elements = 2;
-c_7319.elements = (object *)alloca(sizeof(object) * 2);
-c_7319.elements[0] = k_735;
-c_7319.elements[1] = n_731_732;
+closureN_type* c_7319 = alloca(sizeof(closureN_type));
+c_7319->hdr.mark = gc_color_red;
+c_7319->hdr.grayed = 0;
+c_7319->tag = closureN_tag;
+c_7319->fn = (function_type)__lambda_2;
+c_7319->num_args = 1;
+c_7319->num_elements = 2;
+c_7319->elements = (object *)alloca(sizeof(object) * 2);
+c_7319->elements[0] = stack[0];
+c_7319->elements[1] = stack[1];
 
-
-complex_num_type local_7329; object c_7330 = Cyc_fast_sub(data,&local_7329,n_731_732, obj_int2obj(1));
-return_closcall2(data,  __glo_fac,  &c_7319, c_7330);}
-; 
+object local_7329 = alloca(sizeof(complex_num_type));
+object c_7330 = Cyc_fast_sub(data,local_7329, stack[1], obj_int2obj(1));
+return_closcall2(data,  __glo_fac,  &c_7319, c_7330);
 }
-
-static void __lambda_2(void *data, int argc, object self_7311, object r_737) {
-  
-complex_num_type local_7324; object c_7325 = Cyc_fast_mul(data,&local_7324,((closureN)self_7311)->elements[1], r_737);
-return_closcall1(data,  ((closureN)self_7311)->elements[0],  c_7325);; 
+      // TODO
+      break;
+    }
+    2: { // Lambda ID 2
+      //static void __lambda_2(void *data, int argc, object self_7311, object r_737) {
+      //complex_num_type local_7324; object c_7325 = Cyc_fast_mul(data,&local_7324,((closureN)self_7311)->elements[1], r_737);
+      //return_closcall1(data,  ((closureN)self_7311)->elements[0],  c_7325);; 
+      object local_7324 = alloca(sizeof(complex_num_type));
+      object c_7325 = Cyc_fast_mul(data,local_7324,((closureN)stack[0])->elements[1], stack[1]);
+ // TODO: can we be smart enough to call lambda directly, instead of via closure?
+      return_closcall1(data,  ((closureN)stack[0])->elements[0],  c_7325); 
+      break;
+    }
+    default: {
+      // raise error
+      fprintf(stderr, "Unknown PC value %d\n", ((gc_thread_data *)data)->pc);
+      exit(1);
+    }
+  }
 }
+//static void __lambda_3(void *data, int argc, object self_7312, object r_7310) ;
+//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) ;
+//static void __lambda_2(void *data, int argc, object self_7311, object r_737) ;
+//
+//static void __lambda_3(void *data, int argc, object self_7312, object r_7310) {
+//  return_closcall2(data,  __glo_write_scheme_write,  primitive__75halt, r_7310);; 
+//}
+//
+//static void __lambda_1(void *data, int argc, closure _,object k_735, object n_731_732) {
+//  Cyc_st_add(data, "fac-test.scm:fac");
+//  object c_7316 = Cyc_num_fast_eq_op(data,n_731_732, obj_int2obj(0));
+//if( (boolean_f != c_7316) ){ 
+//  return_closcall1(data,  k_735,  obj_int2obj(1));
+//} else { 
+//  
+//closureN_type c_7319;
+//c_7319.hdr.mark = gc_color_red;
+// c_7319.hdr.grayed = 0;
+//c_7319.tag = closureN_tag;
+// c_7319.fn = (function_type)__lambda_2;
+//c_7319.num_args = 1;
+//c_7319.num_elements = 2;
+//c_7319.elements = (object *)alloca(sizeof(object) * 2);
+//c_7319.elements[0] = k_735;
+//c_7319.elements[1] = n_731_732;
+//
+//
+//complex_num_type local_7329; object c_7330 = Cyc_fast_sub(data,&local_7329,n_731_732, obj_int2obj(1));
+//return_closcall2(data,  __glo_fac,  &c_7319, c_7330);}
+//; 
+//}
+//
+//static void __lambda_2(void *data, int argc, object self_7311, object r_737) {
+//  
+//complex_num_type local_7324; object c_7325 = Cyc_fast_mul(data,&local_7324,((closureN)self_7311)->elements[1], r_737);
+//return_closcall1(data,  ((closureN)self_7311)->elements[0],  c_7325);; 
+//}
 
 static void c_entry_pt_first_lambda(void *data, int argc, closure cont, object value);
 extern void c_schemecyclonecommon_entry_pt(void *data, int argc, closure cont, object value);