diff --git a/ODIN_II/SRC/include/simulator_bit_map.h b/ODIN_II/SRC/include/simulator_bit_map.h
index b58bd61..f1bff1a 100644
--- a/ODIN_II/SRC/include/simulator_bit_map.h
+++ b/ODIN_II/SRC/include/simulator_bit_map.h
@@ -7,16 +7,17 @@
 typedef struct bit_tree_map_t bit_tree_map;
 struct bit_tree_map_t
 {
-	bit_tree_map *childs[3];
-	char my_value;
-	int depth;
-    int result_len;
-	char *result;
-    char *related_node_name;
-    bool is_root;
+	bit_tree_map *branch[3];
     bool is_leaf;
 };
 
+typedef struct bit_tree_root_t
+{
+	bit_tree_map *branch[2];
+    int depth;
+    char *related_node_name;
+}bit_tree_root;
+
 typedef enum
 {
     _0 = 0,
@@ -26,8 +27,8 @@
 
 bit_map_values get_mapped_value(signed char value);
 
-bit_tree_map *free_bit_tree(bit_tree_map *bit_map);
-bit_tree_map *consume_bit_map_line(std::vector<std::string> lines, std::vector<std::string> results, const char *related_node_name);
-std::string find_result(bit_tree_map *bit_map, std::string line);
+bit_tree_root *free_bit_tree(bit_tree_root *bit_map);
+bit_tree_root *consume_bit_map_line(std::vector<std::string> lines, std::vector<char> results, const char *related_node_name);
+char find_result(bit_tree_root *bit_map, std::string line);
 
 #endif
\ No newline at end of file
diff --git a/ODIN_II/SRC/include/types.h b/ODIN_II/SRC/include/types.h
index 720633b..aec542b 100644
--- a/ODIN_II/SRC/include/types.h
+++ b/ODIN_II/SRC/include/types.h
@@ -490,7 +490,7 @@
 
 	short *associated_function;
 
-	bit_tree_map *bit_map; /*storing the bit map */
+	bit_tree_root *bit_map; /*storing the bit map */
 	std::vector<std::string> orig_bit_map;
 
 	// For simulation
diff --git a/ODIN_II/SRC/read_blif.cpp b/ODIN_II/SRC/read_blif.cpp
index 4415970..32fd31c 100644
--- a/ODIN_II/SRC/read_blif.cpp
+++ b/ODIN_II/SRC/read_blif.cpp
@@ -295,7 +295,7 @@
 	}
 
 	/* assigning the new_node */
-	if(input_token_count != 5)
+	if(input_token_count == 5)
 	{
 		/* supported added for the ABC .latch output without control */
 		if(input_token_count == 3)
@@ -743,7 +743,7 @@
 	}
 
 	std::vector<std::string> bit_map;
-	std::vector<std::string> output_bit_map;
+	std::vector<char> output_bit_map;
 	char buffer[READ_BLIF_BUFFER];
 	while(1)
 	{
@@ -752,16 +752,14 @@
 			break;
 
 		bit_map.push_back(vtr::strtok(buffer,TOKENS, file, buffer));
-		output_bit_map.push_back(vtr::strtok(NULL,TOKENS, file, buffer));
+		char *tmp = vtr::strtok(NULL,TOKENS, file, buffer);
+		output_bit_map.push_back(tmp[0]);
 	}
 
 	file_line_number = last_line;
 	fsetpos(file,&pos);
 	node->orig_bit_map = bit_map;
-	
-	bit_tree_map *root = consume_bit_map_line(bit_map, output_bit_map, parent_node_name);
-	
-	node->bit_map = root;
+	node->bit_map = consume_bit_map_line(bit_map, output_bit_map, parent_node_name);
 
 	return GENERIC;
 }
diff --git a/ODIN_II/SRC/simulate_blif.cpp b/ODIN_II/SRC/simulate_blif.cpp
index ddf4446..921e664 100644
--- a/ODIN_II/SRC/simulate_blif.cpp
+++ b/ODIN_II/SRC/simulate_blif.cpp
@@ -1813,21 +1813,9 @@
 	std::string input_bit_string = "";
 	for(int i =0; i < node->num_input_pins; i++)
 		input_bit_string.push_back(convert_result_to_chr(get_pin_value(node->input_pins[i],cycle)));
-	
-	if(node->num_input_pins != node->bit_map->depth)
-	{
-		error_message(SIMULATION_ERROR, -1, -1, "input length miss-match: (pin_len<%d> != bit_map_depth<%d>) current input<%s>"
-			,node->num_input_pins ,node->bit_map->depth, input_bit_string.c_str());
-	}
-	else if(node->num_output_pins != node->bit_map->result_len)
-	{
-		error_message(SIMULATION_ERROR, -1, -1, "output length miss-match: (pin_len<%d> != bit_map_depth<%d>) current input<%s>"
-			,node->num_output_pins ,node->bit_map->result_len, input_bit_string.c_str());
-	}
 
-	std::string result = find_result(node->bit_map, input_bit_string);
-	for(int i =0; i < node->num_output_pins; i++)
-		update_pin_value(node->output_pins[0], convert_result(result[i]), cycle);
+	char result = find_result(node->bit_map, input_bit_string);
+	update_pin_value(node->output_pins[0], convert_result(result), cycle);
 }
 
 /*
diff --git a/ODIN_II/SRC/simulator_bit_map.cpp b/ODIN_II/SRC/simulator_bit_map.cpp
index 9d66d5c..174e41a 100644
--- a/ODIN_II/SRC/simulator_bit_map.cpp
+++ b/ODIN_II/SRC/simulator_bit_map.cpp
@@ -14,141 +14,152 @@
 		return _x;
 }
 
-inline static bit_tree_map *bit_map_node(const char *related_node_name, char value, int depth, int result_len)
+inline static bit_tree_map *bit_map_node()
 {
 	bit_tree_map *node = (bit_tree_map *)vtr::malloc(sizeof(bit_tree_map));
 	for(int i=0; i<3; i++)
-	{
-		node->childs[i] = NULL;
-	}
-	node->my_value = value;
-	node->depth = depth;
-	node->related_node_name = vtr::strdup(related_node_name);
-	node->result_len = result_len;
+		node->branch[i] = NULL;
+	
 	return node;
 }
 
-bit_tree_map *free_bit_tree(bit_tree_map *bit_map)
+inline static bit_tree_root *bit_map_root(const char *related_node_name, int depth)
 {
-	if(!bit_map)
-		return NULL;
-
-	if(bit_map->is_leaf)
-	{
-		vtr::free(bit_map->related_node_name);
-		vtr::free(bit_map);
-		return NULL;
-	}
-	else
-	{
-		bit_map->childs[_0] = free_bit_tree(bit_map->childs[_0]);
-		bit_map->childs[_1] = free_bit_tree(bit_map->childs[_1]);
-		bit_map->childs[_x] = free_bit_tree(bit_map->childs[_x]);
-		vtr::free(bit_map);
-		return NULL;
-	}
+	bit_tree_root *root = (bit_tree_root *)vtr::malloc(sizeof(bit_tree_root));
+	root->depth = depth;
+	root->related_node_name = vtr::strdup(related_node_name);
+	root->branch[_0] = bit_map_node();
+	root->branch[_1] = bit_map_node();
+	return root;
 }
 
-bit_tree_map *consume_bit_map_line(std::vector<std::string> lines, std::vector<std::string> results, const char *related_node_name)
+inline static bit_tree_map *free_bit_branches(bit_tree_map *bit_map)
+{
+	if(bit_map)
+	{
+		if(!bit_map->is_leaf)
+		{
+			bit_map->branch[_0] = free_bit_branches(bit_map->branch[_0]);
+			bit_map->branch[_1] = free_bit_branches(bit_map->branch[_1]);
+			bit_map->branch[_x] = free_bit_branches(bit_map->branch[_x]);
+		}
+		vtr::free(bit_map);
+	}
+	return NULL;
+}
+
+bit_tree_root *free_bit_tree(bit_tree_root *bit_map)
+{
+	if(bit_map)
+	{
+		vtr::free(bit_map->related_node_name);
+		bit_map->branch[_0] = free_bit_branches(bit_map->branch[_0]);
+		bit_map->branch[_1] = free_bit_branches(bit_map->branch[_1]);
+		vtr::free(bit_map);
+	}
+	return NULL;
+}
+
+
+bit_tree_root *consume_bit_map_line(std::vector<std::string> lines, std::vector<char> results, const char *related_node_name)
 {
 	if(lines.empty() || results.empty())
 		return NULL;
 
-	bit_tree_map *root = bit_map_node(related_node_name, 0, lines[0].size(), results[0].size());
-	root->is_root = true;
+	bit_tree_root *root = bit_map_root(related_node_name, lines[0].size());
 
 	for(int i=0; i < lines.size(); i++)
 	{
-		bit_tree_map *cur_node = root;
+		bit_map_values cur_trunk = get_mapped_value(results[i]);
+		bit_tree_map *cur_node = root->branch[cur_trunk];
+
 		if(lines[i].size() != lines[0].size())
 			error_message(SIMULATION_ERROR, -1, -1, "mismatched length in input lut @ line %d for node <%s>",i,root->related_node_name);
 
-		if(results[i].size() != results[0].size())
-			error_message(SIMULATION_ERROR, -1, -1, "mismatched length in input lut @ line %d for node <%s>",i,root->related_node_name);
-
-		for(int j=1; j <= lines[i].size(); j++)
+		for(int j=0; j < lines[i].size(); j++)
 		{
-			char input_value = lines[i][j-1];
-			bit_map_values cur_value = get_mapped_value(input_value);
+			bit_map_values cur_value = get_mapped_value(lines[i][j]);
 
-			if(!cur_node->childs[cur_value])
-				cur_node->childs[cur_value] = bit_map_node(root->related_node_name, input_value, lines[i].size(), results[i].size());
+			if(!cur_node->branch[cur_value])
+				cur_node->branch[cur_value] = bit_map_node();
 
-			/* this holds the result */
-			if(j == lines[i].size())
-			{
-				cur_node->result = vtr::strdup(results[i].c_str());
+			if(j+1 == lines[i].size())
 				cur_node->is_leaf = true;
-			}
+			
 		}
 	}
 	return root;
 }
 
-std::string find_result(bit_tree_map *root, std::string line)
+static signed char explore_trunk(bit_tree_map *trunk, char result, const std::string& line, char set_to)
 {
-	if(!root)
-		error_message(SIMULATION_ERROR, -1, -1, "root bit_map is empty");
-
-	if(line == "")
-		return "";
-
-	std::vector<bit_tree_map*> Q = {root};
+	int end = line.size()-1;
+	bool error = false;
+	std::vector<bit_tree_map*> Q = {trunk};
 	std::vector<bit_tree_map*> new_Q;
-
-	std::string result = "";
-
-	for(int j=0; j < line.size(); j++)
+	for(int j=0; j <= end && !Q.empty() && !error; j++)
 	{
-		if(Q.empty())
-			break;
-
-		char input_value = line[j];
-		bit_map_values cur_value = get_mapped_value(input_value);
-
-		for(int i=0; i < Q.size(); i++)
+		bit_map_values cur_value = get_mapped_value(line[j]);
+		for(int i=0; i < Q.size() && !error; i++)
 		{
 			bit_tree_map *bit_map = Q[i];
-
-			if(!bit_map->is_leaf && j == line.size()-1)
-				error_message(SIMULATION_ERROR, -1, -1, "input missmatch: bit map length != input length ");
-
-			if(!bit_map->is_root)
-				printf("######## exploring node #%d @%d for node:%s with input: %s @input id:%d\n", i, bit_map->depth, bit_map->related_node_name, line.c_str(), j);
-			
-			/* this node holds the result */
 			if(bit_map->is_leaf)
 			{
-				if(result == "")
-					result = bit_map->result;
+				if(result)
+				{
+					error = true;
+					result = '!';
+				}
 				else
 				{
-					warning_message(SIMULATION_ERROR, -1, -1, "ambiguous bit map for .name <%s> with multiple result for pattern", bit_map->related_node_name);
-					break;
+					result = set_to;
 				}
 			}
 			else
 			{
-				if(bit_map->childs[cur_value])
-					new_Q.push_back(bit_map->childs[cur_value]);
+				if(bit_map->branch[cur_value])
+					new_Q.push_back(bit_map->branch[cur_value]);
 
 				//include unknown in defined search
-				if(cur_value != _x && bit_map->childs[_x])
-					new_Q.push_back(bit_map->childs[_x]);
-
+				if(cur_value != _x && bit_map->branch[_x])
+					new_Q.push_back(bit_map->branch[_x]);
 			}
 		}
 
 		Q.clear();
 		Q = new_Q;
 		new_Q.clear();
-
 	}
+	return result;
+}
 
-	if(result == "")
+char find_result(bit_tree_root *root, std::string line)
+{
+	if(!root)
+		error_message(SIMULATION_ERROR, -1, -1, "root bit_map is empty");
+
+	if(line == "")
+		return 3;
+ 
+	char result = 0;
+
+
+	if(root->depth > line.size())
+		error_message(SIMULATION_ERROR, -1, -1, "input missmatch: bit map length > input length ");
+	else if(root->depth < line.size())
+		error_message(SIMULATION_ERROR, -1, -1, "input missmatch: bit map length < input length ");
+
+	result = explore_trunk(root->branch[_0], result, line, '0');
+	result = explore_trunk(root->branch[_1], result, line, '1');
+	if(result == '!')
 	{
-		warning_message(SIMULATION_ERROR, -1, -1, "missmatch between input and lut depth");
-		result = "x";
+		warning_message(SIMULATION_ERROR, -1, -1, "ambiguous bit map for .name <%s> with multiple, or no result for pattern", root->related_node_name);
+		result = 'x';
 	}
+	else if(!result)
+	{
+		result = 'x';
+	}
+
 	return result;
 }
\ No newline at end of file
diff --git a/ODIN_II/regression_test/benchmark/syntax/bm_simple_memory.v b/ODIN_II/regression_test/benchmark/syntax/bm_simple_memory.v
index d9e790f..fb7c6af 100644
--- a/ODIN_II/regression_test/benchmark/syntax/bm_simple_memory.v
+++ b/ODIN_II/regression_test/benchmark/syntax/bm_simple_memory.v
@@ -6,7 +6,6 @@
 	clock, 
 	reset, 
 	addr_in,
-	addr_out,
 	value_out,
 	value_in
 );
@@ -16,7 +15,6 @@
 input 	reset;
 input 	[`WORD_SIZE-1:0]	value_in;
 input 	[`BITS-1:0] 		addr_in;
-input 	[`BITS-1:0] 		addr_out;
 
 output	[`WORD_SIZE-1:0]	value_out;
 
@@ -25,7 +23,7 @@
 always @(posedge clock)
 begin
 	memory[addr_in] = value_in;
-	value_out = memory[addr_out];
+	value_out = memory[0];
 end