diff --git a/byterun/include/stack.h b/byterun/include/stack.h
index be7ad2545..90a768ecc 100644
--- a/byterun/include/stack.h
+++ b/byterun/include/stack.h
@@ -7,94 +7,92 @@
 
 #include "stdlib.h"
 
+extern struct State s;
+
 extern size_t __gc_stack_top, __gc_stack_bottom;
 
-static inline void **s_top(struct State *s) {
-  return s->stack + STACK_SIZE - s->bf->global_area_size;
+static inline void **s_top() {
+  return s.stack + STACK_SIZE - s.bf->global_area_size;
 }
 
-static inline bool s_is_empty(struct State *s) {
-  if (s->sp == s_top(s) || (s->fp != NULL && s->sp == f_locals(s->fp))) {
+static inline bool s_is_empty() {
+  if (s.sp == s_top() || (s.fp != NULL && s.sp == f_locals(s.fp))) {
     return true;
   }
   return false;
 }
 
-static inline void **s_nth(struct State *s, aint n) {
+static inline void **s_nth(aint n) {
   if (n < 0) {
-    s_failure(s, "can't access stack by negative index");
+    s_failure(&s, "can't access stack by negative index");
   }
-  if (s->sp + n >= s_top(s)) {
-    s_failure(s, "not enough elements in stack");
+  if (s.sp + n >= s_top()) {
+    s_failure(&s, "not enough elements in stack");
   }
-  if (s->fp != NULL && s->sp + n >= f_locals(s->fp)) {
-    s_failure(s, "not enough elements in function stack");
+  if (s.fp != NULL && s.sp + n >= f_locals(s.fp)) {
+    s_failure(&s, "not enough elements in function stack");
   }
 
-  return s->sp + n;
+  return s.sp + n;
 }
 
-static inline void **s_peek(struct State *s) {
-  if (s->sp == s_top(s)) {
-    s_failure(s, "empty stack");
+static inline void **s_peek() {
+  if (s.sp == s_top()) {
+    s_failure(&s, "empty stack");
   }
-  if (s->fp != NULL && s->sp == f_locals(s->fp)) {
-    s_failure(s, "empty function stack");
+  if (s.fp != NULL && s.sp == f_locals(s.fp)) {
+    s_failure(&s, "empty function stack");
   }
 
-  return s->sp;
+  return s.sp;
 }
 
-static inline aint *s_peek_i(struct State *s) { return (aint *)s_peek(s); }
+static inline aint *s_peek_i() { return (aint *)s_peek(); }
 
-static inline void s_push(struct State *s, void *val) {
-  if (s->sp == s->stack) {
-    s_failure(s, "stack overflow");
+static inline void s_push(void *val) {
+  if (s.sp == s.stack) {
+    s_failure(&s, "stack overflow");
   }
 #ifdef DEBUG_VERSION
   printf("--> push\n");
 #endif
-  --s->sp;
-  *s->sp = val;
-  __gc_stack_top = (size_t)(s->sp);
-  __gc_stack_top -= __gc_stack_top & 0xF;
+  --s.sp;
+  *s.sp = val;
+  __gc_stack_top = (size_t)(s.sp) - (size_t)(s.sp) & 0xF;
 }
 
-static inline void s_push_i(struct State *s, aint val) {
-  s_push(s, (void *)val);
-}
+static inline void s_push_i(aint val) { s_push((void *)val); }
 
-static inline void s_push_nil(struct State *s) { s_push(s, NULL); }
+static inline void s_push_nil() { s_push(NULL); }
 
-static inline void s_pushn_nil(struct State *s, size_t n) {
+static inline void s_pushn_nil(size_t n) {
   for (size_t i = 0; i < n; ++i) {
-    s_push(s, NULL);
+    s_push(NULL);
   }
 }
 
-static inline void *s_pop(struct State *s) {
-  if (s->sp == s_top(s)) {
-    s_failure(s, "empty stack");
+static inline void *s_pop() {
+  if (s.sp == s_top()) {
+    s_failure(&s, "empty stack");
   }
-  if (s->fp != NULL && s->sp == f_locals(s->fp)) {
-    s_failure(s, "empty function stack");
+  if (s.fp != NULL && s.sp == f_locals(s.fp)) {
+    s_failure(&s, "empty function stack");
   }
 #ifdef DEBUG_VERSION
   printf("--> pop\n");
 #endif
-  void *value = *s->sp;
-  *s->sp = NULL;
-  ++s->sp;
-  __gc_stack_top = (size_t)(s->sp);
-  __gc_stack_top -= __gc_stack_top & 0xF;
+  void *value = *s.sp;
+  *s.sp = NULL;
+  ++s.sp;
+  __gc_stack_top = (size_t)(s.sp) - (size_t)(s.sp) & 0xF;
   return value;
 }
 
-static inline aint s_pop_i(struct State *s) { return (aint)s_pop(s); }
+static inline aint s_pop_i() { return (aint)s_pop(); }
 
-static inline void s_popn(struct State *s, size_t n) {
+static inline void s_popn(size_t n) {
   for (size_t i = 0; i < n; ++i) {
-    s_pop(s);
+    s_pop();
   }
 }
 
@@ -106,79 +104,79 @@ static inline void s_popn(struct State *s, size_t n) {
 //
 // where |> defines corresponding frame pointer, | is stack pointer
 // location before / after new frame added
-static inline void s_enter_f(struct State *s, char *rp, bool is_closure_call,
-                             auint args_sz, auint locals_sz) {
+static inline void s_enter_f(char *rp, bool is_closure_call, auint args_sz,
+                             auint locals_sz) {
 #ifdef DEBUG_VERSION
   printf("-> %i args sz\n", args_sz);
   printf("-> %i locals sz\n", locals_sz);
 #endif
 
   // check that params count is valid
-  if (s->sp + (aint)args_sz - (is_closure_call ? 0 : 1) >= s_top(s)) {
-    s_failure(s, "not enough parameters in stack");
+  if (s.sp + (aint)args_sz - (is_closure_call ? 0 : 1) >= s_top()) {
+    s_failure(&s, "not enough parameters in stack");
   }
-  if (s->fp != NULL &&
-      s->sp + (aint)args_sz - (is_closure_call ? 0 : 1) >= f_locals(s->fp)) {
-    s_failure(s, "not enough parameters in function stack");
+  if (s.fp != NULL &&
+      s.sp + (aint)args_sz - (is_closure_call ? 0 : 1) >= f_locals(s.fp)) {
+    s_failure(&s, "not enough parameters in function stack");
   }
 
-  void *closure = is_closure_call ? s_nth(s, args_sz) : NULL;
+  void *closure = is_closure_call ? s_nth(args_sz) : NULL;
 
   // s_push_nil(s); // sp contains value, frame starts with next value
-  s_pushn_nil(s, frame_sz());
+  s_pushn_nil(frame_sz());
 
   // create frame
   struct Frame frame = {
       .closure = closure,
       .ret = NULL, // field in frame itself
       .rp = rp,
-      .prev_fp = (void **)s->fp,
+      .prev_fp = (void **)s.fp,
       .args_sz_box = BOX(args_sz),
       .locals_sz_box = BOX(locals_sz),
   };
 
   // put frame on stack
-  s->fp = (struct Frame *)s->sp;
-  (*s->fp) = frame;
+  s.fp = (struct Frame *)s.sp;
+  (*s.fp) = frame;
 
-  s_pushn_nil(s, locals_sz);
+  s_pushn_nil(locals_sz);
 }
 
-static inline void s_exit_f(struct State *s) {
-  if (s->fp == NULL) {
-    s_failure(s, "exit: no func");
+static inline void s_exit_f() {
+  if (s.fp == NULL) {
+    s_failure(&s, "exit: no func");
   }
 
-  struct Frame frame = *s->fp;
+  struct Frame frame = *s.fp;
   push_extra_root((void **)&frame.ret);
 
   // drop stack entities, locals, frame
-  size_t to_pop = f_args(s->fp) - s->sp;
-  s->fp = (struct Frame *)f_prev_fp(&frame);
+  size_t to_pop = f_args(s.fp) - s.sp;
+  s.fp = (struct Frame *)f_prev_fp(&frame);
 #ifdef DEBUG_VERSION
   printf("-> %zu to pop\n", to_pop);
 #endif
-  s_popn(s, to_pop);
+  s_popn(to_pop);
 
   // drop args
 #ifdef DEBUG_VERSION
   printf("-> + %zu to pop\n", f_args_sz(&frame));
 #endif
-  s_popn(s, f_args_sz(&frame));
+  s_popn(f_args_sz(&frame));
 
   // save returned value, not in main
   if (frame.prev_fp != 0) {
-    s_push(s, frame.ret);
+    s_push(frame.ret);
   }
 
-  s->ip = frame.rp;
+  s.ip = frame.rp;
 
   pop_extra_root((void **)&frame.ret);
 }
 
-static inline void print_stack(struct State *s) {
-  printf("stack (%i) is\n[", s->stack + STACK_SIZE - s->sp);
-  for (void **x = s->stack + STACK_SIZE - 1; x >= s->sp; --x) {
+static inline void print_stack() {
+  printf("stack (%i) is\n[", s.stack + STACK_SIZE - s.sp);
+  for (void **x = s.stack + STACK_SIZE - 1; x >= s.sp; --x) {
     printf("%li ", (long)UNBOX(*x));
   }
   printf("]\n");
@@ -186,60 +184,59 @@ static inline void print_stack(struct State *s) {
 
 // --- category ---
 
-static inline void **var_by_category(struct State *s, enum VarCategory category,
-                                     int id) {
+static inline void **var_by_category(enum VarCategory category, int id) {
   if (id < 0) {
-    s_failure(s, "can't read variable: negative id"); // %i", id);
+    s_failure(&s, "can't read variable: negative id"); // %i", id);
   }
   void **var = NULL;
   switch (category) {
   case VAR_GLOBAL:
-    if (s->bf->global_area_size <= id) {
-      s_failure(s,
+    if (s.bf->global_area_size <= id) {
+      s_failure(&s,
                 "can't read global: too big id"); //, %i >= %ul", id,
-                                                  // s->bf->global_area_size);
+                                                  // s.bf->global_area_size);
     }
-    var = s->stack + STACK_SIZE - 1 - id;
+    var = s.stack + STACK_SIZE - 1 - id;
     break;
   case VAR_LOCAL:
-    if (s->fp == NULL) {
-      s_failure(s, "can't read local outside of function");
+    if (s.fp == NULL) {
+      s_failure(&s, "can't read local outside of function");
     }
-    if (f_locals_sz(s->fp) <= id) {
-      s_failure(s, "can't read local: too big id"); //, %i >= %ul", id,
-                                                    // f_locals_sz(s->fp));
+    if (f_locals_sz(s.fp) <= id) {
+      s_failure(&s, "can't read local: too big id"); //, %i >= %ul", id,
+                                                     // f_locals_sz(s.fp));
     }
     // printf("id is %i, local is %i, %i\n", id,
-    // UNBOX((auint)*((void**)f_locals(s->fp) + id)), f_locals(s->fp) - s->sp);
-    var = f_locals(s->fp) + (f_locals_sz(s->fp) - id - 1);
+    // UNBOX((auint)*((void**)f_locals(s.fp) + id)), f_locals(s.fp) - s.sp);
+    var = f_locals(s.fp) + (f_locals_sz(s.fp) - id - 1);
     break;
   case VAR_ARGUMENT:
-    if (s->fp == NULL) {
-      s_failure(s, "can't read argument outside of function");
+    if (s.fp == NULL) {
+      s_failure(&s, "can't read argument outside of function");
     }
-    if (f_args_sz(s->fp) <= id) {
-      s_failure(s, "can't read arguments: too big id"); //, %i >= %ul", id,
-                                                        // f_args_sz(s->fp));
+    if (f_args_sz(s.fp) <= id) {
+      s_failure(&s, "can't read arguments: too big id"); //, %i >= %ul", id,
+                                                         // f_args_sz(s.fp));
     }
-    var = f_args(s->fp) + (f_args_sz(s->fp) - id - 1);
+    var = f_args(s.fp) + (f_args_sz(s.fp) - id - 1);
     break;
   case VAR_CLOSURE:
-    if (s->fp == NULL) {
-      s_failure(s, "can't read closure parameter outside of function");
+    if (s.fp == NULL) {
+      s_failure(&s, "can't read closure parameter outside of function");
     }
-    if (s->fp->closure == NULL) {
-      s_failure(s, "can't read closure parameter not in closure");
+    if (s.fp->closure == NULL) {
+      s_failure(&s, "can't read closure parameter not in closure");
     }
-    if (UNBOXED(s->fp->closure)) {
-      s_failure(s, "not boxed value expected in closure index");
+    if (UNBOXED(s.fp->closure)) {
+      s_failure(&s, "not boxed value expected in closure index");
     }
-    data *d = TO_DATA(s->fp->closure);
+    data *d = TO_DATA(s.fp->closure);
     size_t count = get_len(d) - 1;
 #ifdef DEBUG_VERSION
     printf("id is %i, count is %i\n", id, count);
 #endif
     if (count <= id) {
-      s_failure(s,
+      s_failure(&s,
                 "can't read arguments: too big id"); //, %i >= %ul", id, count);
     }
     return (void **)d->contents + id; // order is not important
diff --git a/byterun/include/types.h b/byterun/include/types.h
index af97fdc44..9d033cba1 100644
--- a/byterun/include/types.h
+++ b/byterun/include/types.h
@@ -52,7 +52,7 @@ static inline void **f_args(struct Frame *fp) {
 // ------ State ------
 
 struct State {
-  void *stack[STACK_SIZE + 1];
+  void **stack;
   void **sp;        // stack pointer
   struct Frame *fp; // function frame pointer
   bytefile *bf;
@@ -65,7 +65,7 @@ struct State {
   char *call_ip;  // prev instruction pointer (to remember jmp locations)
 };
 
-void init_state(bytefile *bf, struct State *s);
+void construct_state(bytefile *bf, struct State *s, void **stack);
 void cleanup_state(struct State *state);
 
 static inline void s_failure(struct State *s, const char *msg) {
@@ -82,10 +82,11 @@ enum VarCategory {
   VAR_CLOSURE = 3
 };
 
-static inline enum VarCategory to_var_category(struct State *s,
-                                               uint8_t category) {
+extern struct State s;
+
+static inline enum VarCategory to_var_category(uint8_t category) {
   if (category > 3) {
-    s_failure(s, "unexpected variable category");
+    s_failure(&s, "unexpected variable category");
   }
   return (enum VarCategory)category;
 }
diff --git a/byterun/src/interpreter.c b/byterun/src/interpreter.c
index 248fc566b..599309aac 100644
--- a/byterun/src/interpreter.c
+++ b/byterun/src/interpreter.c
@@ -8,23 +8,25 @@
 #include "types.h"
 #include "utils.h"
 
-int ip_read_int(char **ip) {
+struct State s;
+
+static inline int ip_read_int(char **ip) {
   *ip += sizeof(int);
   return *(int *)((*ip) - sizeof(int));
 }
 
-char ip_read_byte(char **ip) { return *(*ip)++; }
+static inline char ip_read_byte(char **ip) { return *(*ip)++; }
 
-char *ip_read_string(char **ip, bytefile *bf) {
+static inline char *ip_read_string(char **ip, bytefile *bf) {
   return get_string(bf, ip_read_int(ip));
 }
 
 const size_t BUFFER_SIZE = 1000;
 
 void run(bytefile *bf, int argc, char **argv) {
+  void *stack[STACK_SIZE];
   void *buffer[BUFFER_SIZE];
-  struct State s;
-  init_state(bf, &s);
+  construct_state(bf, &s, stack);
 
 #ifdef DEBUG_VERSION
   printf("--- interpreter run ---\n");
@@ -55,12 +57,12 @@ void run(bytefile *bf, int argc, char **argv) {
 
   // argc, argv
   {
-    s_push_i(&s, BOX(argc));
+    s_push_i(BOX(argc));
     void **argv_strs = calloc(argc, sizeof(void *));
     for (size_t i = 0; i < argc; ++i) {
       argv_strs[i] = Bstring((aint *)&argv[i]);
     }
-    s_push(&s, Barray((aint *)&argv_strs, argc));
+    s_push(Barray((aint *)&argv_strs, argc));
     free(argv_strs);
   }
 
@@ -90,20 +92,20 @@ void run(bytefile *bf, int argc, char **argv) {
       if (l < 1) {
         s_failure(&s, "negative binop type index");
       }
-      void *left = s_pop(&s);
-      void *right = s_pop(&s);
-      s_push(&s, (void *)ops_func[l - 1](right, left));
+      void *left = s_pop();
+      void *right = s_pop();
+      s_push((void *)ops_func[l - 1](right, left));
       break;
 
     case 1:
       switch (l) {
       case 0: // CONST %d
-        s_push_i(&s, BOX(ip_read_int(&s.ip)));
+        s_push_i(BOX(ip_read_int(&s.ip)));
         break;
 
       case 1: { // STRING %s
         void *str = ip_read_string(&s.ip, bf);
-        s_push(&s, Bstring((aint *)&str));
+        s_push(Bstring((aint *)&str));
         break;
       }
 
@@ -123,14 +125,14 @@ void run(bytefile *bf, int argc, char **argv) {
         void **opr_buffer = args_count >= BUFFER_SIZE ? calloc(args_count + 1, sizeof(void *)) : buffer;
 
         for (size_t i = 1; i <= args_count; ++i) {
-          opr_buffer[args_count - i] = s_pop(&s);
+          opr_buffer[args_count - i] = s_pop();
         }
         opr_buffer[args_count] = (void *)LtagHash((char *)name);
 
         void *sexp = Bsexp((aint *)opr_buffer, BOX(args_count + 1));
 
         push_extra_root(sexp);
-        s_push(&s, sexp);
+        s_push(sexp);
         pop_extra_root(sexp);
 
         if (args_count >= BUFFER_SIZE) {
@@ -141,18 +143,18 @@ void run(bytefile *bf, int argc, char **argv) {
 
       case 3: { // STI - write by ref (?)
         // NOTE: example not found, no checks done
-        void *elem = s_pop(&s);
-        void **addr = (void **)s_pop(&s);
+        void *elem = s_pop();
+        void **addr = (void **)s_pop();
         *addr = elem;
-        s_push(&s, elem);
+        s_push(elem);
         break;
       }
 
       case 4: { // STA - write to array elem
-        void *elem = s_pop(&s);
-        aint index = s_pop_i(&s);
-        void *data = s_pop(&s);
-        s_push(&s, Bsta(data, index, elem));
+        void *elem = s_pop();
+        aint index = s_pop_i();
+        void *data = s_pop();
+        s_push(Bsta(data, index, elem));
         break;
       }
 
@@ -167,37 +169,37 @@ void run(bytefile *bf, int argc, char **argv) {
       }
 
       case 6: // END
-        if (!s_is_empty(&s) && s.fp->prev_fp != 0) {
-          s.fp->ret = *s_peek(&s);
-          s_pop(&s);
+        if (!s_is_empty() && s.fp->prev_fp != 0) {
+          s.fp->ret = *s_peek();
+          s_pop();
         }
-        s_exit_f(&s);
+        s_exit_f();
         break;
 
       case 7: // RET
-        if (!s_is_empty(&s) && s.fp->prev_fp != 0) {
-          s.fp->ret = *s_peek(&s);
-          s_pop(&s);
+        if (!s_is_empty() && s.fp->prev_fp != 0) {
+          s.fp->ret = *s_peek();
+          s_pop();
         }
-        s_exit_f(&s);
+        s_exit_f();
         break;
 
       case 8: // DROP
-        s_pop(&s);
+        s_pop();
         break;
 
       case 9: // DUP
       {
-        s_push(&s, *s_peek(&s));
+        s_push(*s_peek());
         break;
       }
 
       case 10: // SWAP
       {
-        void* x = s_pop(&s);
-        void* y = s_pop(&s);
-        s_push(&s, y);
-        s_push(&s, x);
+        void* x = s_pop();
+        void* y = s_pop();
+        s_push(y);
+        s_push(x);
 
         // if (s.sp + 1 >= s.stack + STACK_SIZE ||
         //     (s.fp != NULL && s.sp + 1 >= f_locals(s.fp))) {
@@ -212,9 +214,9 @@ void run(bytefile *bf, int argc, char **argv) {
 
       case 11: // ELEM
       {
-        aint index = s_pop_i(&s);
-        void *data = s_pop(&s);
-        s_push(&s, Belem(data, index));
+        aint index = s_pop_i();
+        void *data = s_pop();
+        s_push(Belem(data, index));
       } break;
 
       default:
@@ -224,21 +226,21 @@ void run(bytefile *bf, int argc, char **argv) {
 
     case 2: { // LD %d
       void **var_ptr =
-          var_by_category(&s, to_var_category(&s, l), ip_read_int(&s.ip));
-      s_push(&s, *var_ptr);
+          var_by_category(to_var_category(l), ip_read_int(&s.ip));
+      s_push(*var_ptr);
       break;
     }
 
     case 3: { // LDA %d
       void **var_ptr =
-          var_by_category(&s, to_var_category(&s, l), ip_read_int(&s.ip));
-      s_push(&s, var_ptr);
+          var_by_category(to_var_category(l), ip_read_int(&s.ip));
+      s_push(*var_ptr);
       break;
     }
     case 4: { // ST %d
       void **var_ptr =
-          var_by_category(&s, to_var_category(&s, l), ip_read_int(&s.ip));
-      *var_ptr = *s_peek(&s);
+          var_by_category(to_var_category(l), ip_read_int(&s.ip));
+      *var_ptr = *s_peek();
       break;
     }
 
@@ -250,7 +252,7 @@ void run(bytefile *bf, int argc, char **argv) {
         if (jmp_p < 0) {
           s_failure(&s, "negative file offset jumps are not allowed");
         }
-        if (UNBOX(s_pop_i(&s)) == 0) {
+        if (UNBOX(s_pop_i()) == 0) {
           s.ip = bf->code_ptr + jmp_p;
         }
         break;
@@ -262,7 +264,7 @@ void run(bytefile *bf, int argc, char **argv) {
         if (jmp_p < 0) {
           s_failure(&s, "negative file offset jumps are not allowed");
         }
-        if (UNBOX(s_pop_i(&s)) != 0) {
+        if (UNBOX(s_pop_i()) != 0) {
           s.ip = bf->code_ptr + jmp_p;
         }
         break;
@@ -274,7 +276,7 @@ void run(bytefile *bf, int argc, char **argv) {
         if (s.fp != NULL && s.call_ip == NULL) {
           s_failure(&s, "begin should only be called after call");
         }
-        s_enter_f(&s, s.call_ip /*ip from call*/, s.is_closure_call, args_sz,
+        s_enter_f(s.call_ip /*ip from call*/, s.is_closure_call, args_sz,
                   locals_sz);
         break;
       }
@@ -286,7 +288,7 @@ void run(bytefile *bf, int argc, char **argv) {
         if (s.fp != NULL && s.call_ip == NULL) {
           s_failure(&s, "begin should only be called after call");
         }
-        s_enter_f(&s, s.call_ip /*ip from call*/, s.is_closure_call, args_sz,
+        s_enter_f(s.call_ip /*ip from call*/, s.is_closure_call, args_sz,
                   locals_sz);
         break;
       }
@@ -300,16 +302,16 @@ void run(bytefile *bf, int argc, char **argv) {
           aint arg_id = ip_read_int(&s.ip);
 
           void **var_ptr =
-              var_by_category(&s, to_var_category(&s, l), ip_read_int(&s.ip));
-          s_push(&s, *var_ptr);
+              var_by_category(to_var_category(l), ip_read_int(&s.ip));
+          s_push(*var_ptr);
         }
-        s_push(&s, bf->code_ptr + call_offset);
+        s_push(bf->code_ptr + call_offset);
 
         void *closure = Bclosure((aint *)s.sp, args_count);
 
         push_extra_root(closure);
-        s_popn(&s, args_count + 1);
-        s_push(&s, closure);
+        s_popn(args_count + 1);
+        s_push(closure);
         pop_extra_root(closure);
         break;
       }
@@ -321,7 +323,7 @@ void run(bytefile *bf, int argc, char **argv) {
         s.is_closure_call = true;
         s.call_ip = s.ip;
 
-        s.ip = Belem(*s_nth(&s, args_count), BOX(0)); // use offset instead ??
+        s.ip = Belem(*s_nth(args_count), BOX(0)); // use offset instead ??
         break;
       }
 
@@ -349,18 +351,18 @@ void run(bytefile *bf, int argc, char **argv) {
                UNBOX(LtagHash((char *)name)), args_count, s_peek(&s));
 #endif
 
-        s_push_i(&s, Btag(s_pop(&s), LtagHash((char *)name), BOX(args_count)));
+        s_push_i(Btag(s_pop(), LtagHash((char *)name), BOX(args_count)));
         break;
       }
 
       case 8: // ARRAY %d
-        s_push_i(&s, Barray_patt(s_pop(&s), BOX(ip_read_int(&s.ip))));
+        s_push_i(Barray_patt(s_pop(), BOX(ip_read_int(&s.ip))));
         break;
 
       case 9: {                        // FAIL %d %d
         int line = ip_read_int(&s.ip); // ??
         int col = ip_read_int(&s.ip);  // ??
-        Bmatch_failure(s_pop(&s), argv[0], BOX(line), BOX(col));
+        Bmatch_failure(s_pop(), argv[0], BOX(line), BOX(col));
         break;
       }
 
@@ -378,25 +380,25 @@ void run(bytefile *bf, int argc, char **argv) {
       // {"=str", "#string", "#array", "#sexp", "#ref", "#val", "#fun"}
       switch (l) {
       case 0: // =str
-        s_push_i(&s, Bstring_patt(s_pop(&s), s_pop(&s)));
+        s_push_i(Bstring_patt(s_pop(), s_pop()));
         break;
       case 1: // #string
-        s_push_i(&s, Bstring_tag_patt(s_pop(&s)));
+        s_push_i(Bstring_tag_patt(s_pop()));
         break;
       case 2: // #array
-        s_push_i(&s, Barray_tag_patt(s_pop(&s)));
+        s_push_i(Barray_tag_patt(s_pop()));
         break;
       case 3: // #sexp
-        s_push_i(&s, Bsexp_tag_patt(s_pop(&s)));
+        s_push_i(Bsexp_tag_patt(s_pop()));
         break;
       case 4: // #ref
-        s_push_i(&s, Bunboxed_patt(s_pop(&s)));
+        s_push_i(Bunboxed_patt(s_pop()));
         break;
       case 5: // #val
-        s_push_i(&s, Bboxed_patt(s_pop(&s)));
+        s_push_i(Bboxed_patt(s_pop()));
         break;
       case 6: // #fun
-        s_push_i(&s, Bclosure_tag_patt(s_pop(&s)));
+        s_push_i(Bclosure_tag_patt(s_pop()));
         break;
       default:
         s_failure(&s, "invalid opcode"); // %d-%d\n", h, l);
@@ -406,21 +408,21 @@ void run(bytefile *bf, int argc, char **argv) {
     case 7: {
       switch (l) {
       case 0: // CALL Lread
-        s_push_i(&s, Lread());
+        s_push_i(Lread());
         break;
 
       case 1: // CALL Lwrite
-        Lwrite(*s_peek_i(&s));
+        Lwrite(*s_peek_i());
         break;
 
       case 2: // CALL Llength
-        s_push_i(&s, Llength(s_pop(&s)));
+        s_push_i(Llength(s_pop()));
         break;
 
       case 3: { // CALL Lstring
-        void *val = s_pop(&s);
+        void *val = s_pop();
         void *str = Lstring((aint *)&val);
-        s_push(&s, str);
+        s_push(str);
         break;
       }
 
@@ -432,12 +434,12 @@ void run(bytefile *bf, int argc, char **argv) {
 
         void **opr_buffer = elem_count > BUFFER_SIZE ? calloc(elem_count, sizeof(void *)) : buffer;
         for (size_t i = 0; i < elem_count; ++i) {
-          opr_buffer[elem_count - i - 1] = s_pop(&s);
+          opr_buffer[elem_count - i - 1] = s_pop();
         }
 
         void *array =
             Barray((aint *)opr_buffer, BOX(elem_count)); // NOTE: not shure if elems should be added
-        s_push(&s, array);
+        s_push(array);
 
         if (elem_count > BUFFER_SIZE) {
           free(opr_buffer);
diff --git a/byterun/src/types.c b/byterun/src/types.c
index 57970efa6..fed704fc6 100644
--- a/byterun/src/types.c
+++ b/byterun/src/types.c
@@ -11,8 +11,8 @@ extern size_t __gc_stack_top, __gc_stack_bottom;
 
 // --- State ---
 
-static void alloc_state(bytefile *bf, struct State* s) {
-  // s->stack = calloc(STACK_SIZE + 1, sizeof(void*));
+static void init_state(bytefile *bf, struct State* s, void** stack) {
+  s->stack = stack;
   s->bf = bf;
   s->is_closure_call = false;
   s->ip = bf->code_ptr;
@@ -28,13 +28,13 @@ static void alloc_state(bytefile *bf, struct State* s) {
   s->fp = NULL;
 }
 
-void init_state(bytefile *bf, struct State* s) {
+void construct_state(bytefile *bf, struct State* s, void** stack) {
   __init();
-  alloc_state(bf, s);
+  init_state(bf, s, stack);
   __gc_stack_bottom = (size_t)s->sp;
   __gc_stack_top = __gc_stack_bottom;
 
-  s_pushn_nil(s, bf->global_area_size);
+  s_pushn_nil(bf->global_area_size);
 
 #ifdef DEBUG_VERSION
   print_stack(s);