diff --git a/.gitignore b/.gitignore
index 5a6df94..4527475 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@
 *.4c
 *.bin
 
-*.c
\ No newline at end of file
+*.c
+backup
\ No newline at end of file
diff --git a/bytecode_interpreter.cpp b/bytecode_interpreter.cpp
index 12df954..248e285 100644
--- a/bytecode_interpreter.cpp
+++ b/bytecode_interpreter.cpp
@@ -420,81 +420,81 @@ run_bytecode_interp(Bc *b){
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left + right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] + [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] + [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SUB_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left - right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] - [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] - [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_DIV_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left / right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] / [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] / [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_MUL_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left * right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] * [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] * [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_MOD_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left % right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] % [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] % [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SHR_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left >> right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] >> [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] >> [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SHL_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left << right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] << [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] << [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITAND_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left & right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] & [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] & [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITOR_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left | right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] | [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] | [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITXOR_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left ^ right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] ^ [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] ^ [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITNOT_S64:{
         S64 left = (S64)b->registers[instr->index_a].s64;
         S64 result = ~left;
@@ -502,143 +502,143 @@ run_bytecode_interp(Bc *b){
         *dst = result;
         bc_log("~ [%lld] = [%lld]", left, result);
       }break;
-
+      
       case BC_EQ_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left == right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] == [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] == [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_NEQ_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left != right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] != [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] != [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_GT_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left > right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] > [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] > [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_LT_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left < right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] < [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] < [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_OR_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left || right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] || [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] || [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_GTE_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left >= right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] >= [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] >= [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_LTE_S64:{
         S64 left                     = b->registers[instr->index_a].s64;
         S64 right                    = b->registers[instr->index_b].s64;
         S64 result                   = left <= right;
         b->registers[instr->index_c].s64 = result;
-        bc_log("r%s + r%s = r%s => [%lld] <= [%lld] = [%lld]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %lld] <= [r%s, %lld] = [r%s, %lld]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_ADD_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left + right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] + [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] + [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SUB_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left - right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] - [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] - [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_DIV_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left / right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] / [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] / [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_MUL_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left * right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] * [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] * [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_MOD_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left % right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] % [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] % [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SHR_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left >> right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] >> [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] >> [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SHL_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left << right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] << [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] << [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITAND_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left & right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] & [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] & [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITOR_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left | right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] | [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] | [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITXOR_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left ^ right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] ^ [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] ^ [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_BITNOT_U64:{
         U64 left = (U64)b->registers[instr->index_a].u64;
         U64 result = ~left;
@@ -646,143 +646,143 @@ run_bytecode_interp(Bc *b){
         *dst = result;
         bc_log("~ [%llu] = [%llu]", left, result);
       }break;
-
+      
       case BC_EQ_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left == right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] == [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] == [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_NEQ_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left != right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] != [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] != [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_GT_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left > right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] > [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] > [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_LT_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left < right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] < [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] < [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_OR_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left || right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] || [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] || [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_GTE_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left >= right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] >= [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] >= [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_LTE_U64:{
         U64 left                     = b->registers[instr->index_a].u64;
         U64 right                    = b->registers[instr->index_b].u64;
         U64 result                   = left <= right;
         b->registers[instr->index_c].u64 = result;
-        bc_log("r%s + r%s = r%s => [%llu] <= [%llu] = [%llu]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %llu] <= [r%s, %llu] = [r%s, %llu]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_ADD_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left + right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] + [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] + [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_SUB_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left - right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] - [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] - [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_DIV_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left / right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] / [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] / [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_MUL_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left * right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] * [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] * [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_EQ_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left == right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] == [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] == [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_NEQ_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left != right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] != [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] != [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_GT_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left > right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] > [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] > [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_LT_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left < right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] < [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] < [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_GTE_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left >= right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] >= [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] >= [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
       case BC_LTE_F64:{
         F64 left                     = b->registers[instr->index_a].f64;
         F64 right                    = b->registers[instr->index_b].f64;
         F64 result                   = left <= right;
         b->registers[instr->index_c].f64 = result;
-        bc_log("r%s + r%s = r%s => [%f] <= [%f] = [%f]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, %f] <= [r%s, %f] = [r%s, %f]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }break;
-
+      
 //
 // *End* of switch_cases generated using code_generating_script.py
 //
diff --git a/code_generating_script.py b/code_generating_script.py
index 2be1b8c..75b6c13 100644
--- a/code_generating_script.py
+++ b/code_generating_script.py
@@ -1,5 +1,3 @@
-result = ""
-
 sizes = ["64", "32", "16", "8"]
 types =      ["S64", "U64", "F64"]
 print_sign = ["%lld", "%llu", "%f"]
@@ -46,7 +44,7 @@ def update_file(filename, comment_name, data_to_write):
 
     a_part = data[0:begin_index]
     b_part = data[begin_index:end_index]
-    c_part = data[end_index:-1]
+    c_part = data[end_index:len(data)]
 
     data_to_write = begin + data_to_write + end
 
@@ -55,7 +53,8 @@ def update_file(filename, comment_name, data_to_write):
 
 
 
-if False:
+if True:
+  result = ""
   enum_members = []
   enum_members.append("BC_END_OF_INSTRUCTIONS")
   enum_members.append("BC_POP_STACK")
@@ -90,6 +89,7 @@ if False:
 # Generate switch cases
 #
 if True:
+  result = ""
   for sign, T in zip(print_sign, types):
     t = T.lower()
 
@@ -121,7 +121,7 @@ if True:
         {T} right                    = b->registers[instr->index_b].{t};
         {T} result                   = left {symbol} right;
         b->registers[instr->index_c].{t} = result;
-        bc_log("r%s + r%s = r%s => [{sign}] {symbol} [{sign}] = [{sign}]", instr->index_a, instr->index_b, instr->index_c, left, right, result);
+        bc_log("[r%s, {sign}] {symbol} [r%s, {sign}] = [r%s, {sign}]", instr->index_a, left, instr->index_b, right, instr->index_c, result);
       }}break;
       """
       ################################