diff --git a/src/main.cpp b/src/main.cpp
index f2cd7c1..92084ee 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -75,24 +75,24 @@ enum class special_indef_eval {NONE, PROGN, IF_BEGIN, FORCE_RETURN_NEXT_ARG};
 
 
 struct Registers {
-    std::variant<size_t, Data *> Exp;
+    size_t Exp;
     size_t args_front;
     size_t args_current;
     size_t args_left;
 
     // general registers
-    std::variant<size_t, Data *> A;
-    std::variant<size_t, Data *> B;
-    std::variant<size_t, Data *> C;
-    std::variant<size_t, Data *> D;
+    size_t A;
+    size_t B;
+    size_t C;
+    size_t D;
 
     bool argflag = false;
 
-    std::variant<size_t, Data *> op;
+	size_t op;
 
     locs RP;
 
-    std::variant<size_t, Data *> R;
+    size_t R;
     Env E;
 
 	special_indef_eval screen = special_indef_eval::NONE;
@@ -129,38 +129,42 @@ struct Machine {
         while (true) {
             switch (reg.RP) {
             case locs::EVAL_START: { // Expects data* in D;
-                Data *d = std::get<Data *>(reg.D);
+				size_t loc = reg.D;
+				
+				Data * d = mem[loc].d;
+
+                //Data *d = std::get<Data *>(reg.D);
                 if (SelfEval *h = dynamic_cast<SelfEval *>(d)) {
 					if(stack.empty()) {
-						reg.R = h;
+						reg.R = loc; //return addressof
 						return;
 					}
                     reg = stack.back();
                     stack.pop_back();
-                    reg.R = h;
+                    reg.R = loc; //return addressof
 
                     // return h;
                 } else if (Symbol *h = dynamic_cast<Symbol *>(d)) {
                     if (reg.E.builtin.contains(h->data)) {
 						if(stack.empty()) {
-							reg.R = h;
+							reg.R = loc; //return addressof
 							return;
 						}
                         reg = stack.back();
                         stack.pop_back();
-                        reg.R = h;
+                        reg.R = loc; //return addressof
                     } else {
 						if(stack.empty()) {
-							reg.R = mem[reg.E.userdef[h->data]].d;
+							reg.R = reg.E.userdef[h->data];
 							return;
 						}
                         reg = stack.back();
                         stack.pop_back();
-                        reg.R = mem[reg.E.userdef[h->data]].d;
+                        reg.R = reg.E.userdef[h->data];
                     }
                 } else if (Fork *h = dynamic_cast<Fork *>(d)) {
-                    reg.Exp = h;
-                    reg.D = mem[h->data].d; // pass car into eval
+                    reg.Exp = loc; //set exp to addressof
+                    reg.D = h->data; // pass car into eval
                     reg.RP = locs::EVAL_OP_FIN;
 					reg.argflag = false;
                     stack.push_back(reg);
@@ -174,11 +178,11 @@ struct Machine {
             case locs::EVAL_OP_FIN: {
                 reg.op = reg.R; // save op
 				reg.screen = special_indef_eval::NONE;
-				if (Symbol * c = dynamic_cast<Symbol*>(std::get<Data*>(reg.op))) {
+				if (Symbol * c = dynamic_cast<Symbol*>(mem[reg.op].d)) {
 					if(c->data == "lambda") {
 						reg.args_left = 0;
 						reg.args_current = 0;
-						reg.args_front =  mem[((Fork *)std::get<Data *>(reg.Exp))->data].cdr;
+						reg.args_front =  mem[((Fork *) mem[reg.Exp].d)->data].cdr;
 						reg.RP = locs::EVAL_TOP_ARG;
 						reg.argflag=false;
 						break;
@@ -190,7 +194,7 @@ struct Machine {
 						reg.screen = special_indef_eval::IF_BEGIN;
 					}
 				}
-                reg.args_left = mem[((Fork *)std::get<Data *>(reg.Exp))->data].cdr;
+                reg.args_left = mem[((Fork *) mem[reg.Exp].d)->data].cdr;
 				reg.args_current = 0;
 				reg.args_front = 0;
                 reg.RP = locs::EVAL_TOP_ARG;
@@ -207,7 +211,7 @@ struct Machine {
                         mem[reg.args_current].cdr = temp;
                         reg.args_current = temp;
                     }
-                    mem[reg.args_current].d = std::get<Data*>(reg.R);
+                    mem[reg.args_current].d = mem[reg.R].d;
 
 					// is in an 'if' statement but got first arg back
 					if (reg.screen == special_indef_eval::IF_BEGIN) {
@@ -238,7 +242,7 @@ struct Machine {
 						newframe = true;
 
 					}
-                    reg.D = mem[reg.args_left].d;
+                    reg.D = reg.args_left;
                     reg.args_left = mem[reg.args_left].cdr;
 					if (newframe) {
 						stack.back().args_left = reg.args_left;
@@ -251,17 +255,18 @@ struct Machine {
                 break;
             }
             case locs::APPLY: {
-                Data *d = std::get<Data *>(reg.op);
+				size_t loc = reg.op;
+                Data *d = mem[loc].d;
                 if (Symbol *fname = dynamic_cast<Symbol *>(d)) {
                     if (reg.E.builtin.contains(fname->data)) {
                         auto temp = ApplyBuiltin(fname->data, reg.args_front);
 						if(stack.empty()) {
-							reg.R = mem[temp].d; //special case for term;
+							reg.R = temp; //special case for term;
 							return;
 						}
                         reg = stack.back();
                         stack.pop_back();
-                        reg.R = mem[temp].d;
+                        reg.R = temp;
                         break;
                     } else {
 						throw "err2";
@@ -269,7 +274,7 @@ struct Machine {
                 } else if (Lambda *f = dynamic_cast<Lambda *>(d)) {
                     reg.A = f->args;
 
-					reg.A = ((Fork *) mem[std::get<size_t>(reg.A)].d)->data;
+					reg.A = ((Fork *) mem[reg.A].d)->data;
 
 
                     //reg.A = (   (Fork *)   (std::get<Cell>(reg.A)).d)    ->data;
@@ -277,23 +282,23 @@ struct Machine {
                     reg.B = reg.args_front;
                     // reg.E = f->env;
 					reg.E.userdef = f->env.userdef;
-                    while (std::get<size_t>(reg.A) != 0) {
-                        reg.E.userdef[((Symbol *)mem[std::get<size_t>(reg.A)].d)->data] =
-                            std::get<size_t>(reg.B);
-                        reg.A = mem[std::get<size_t>(reg.A)].cdr;
-                        reg.B = mem[std::get<size_t>(reg.B)].cdr;
+                    while (reg.A != 0) {
+                        reg.E.userdef[((Symbol *)mem[reg.A].d)->data] =
+                            reg.B;
+                        reg.A = mem[reg.A].cdr;
+                        reg.B = mem[reg.B].cdr;
                     }
 
                     //reg.D = f->f.d;
 
-					reg.D = mem[f->f].d;
+					reg.D = f->f;
 
 
                     //reg.E.userdef.merge(f->env.userdef);
                     reg.RP = locs::EVAL_START;
 					break;
                 } else {
-					throw "err";
+					throw "err wrong type";
 				}
             }
 
@@ -568,7 +573,7 @@ int main() {
 
 	m.stack = std::vector<Registers>();
     auto exp = m.read_expr(std::cin);
-    r.D = m.mem[exp].d;
+    r.D = exp;
     m.reg = r;
     m.reg.RP = locs::EVAL_START;
 	m.reg.E.builtin.insert("+");
@@ -589,7 +594,7 @@ int main() {
 	}
     std::cout << "out of loop" << std::endl;
 
-    c.d = std::get<Data *>(m.reg.R);
+    c.d = m.mem[m.reg.R].d;
     m.ListPrint(c);
     std::cout << std::endl;
 	}