diff --git a/TaskB01/run b/TaskB01/run
index 1b9110e..f906ba0 100644
--- a/TaskB01/run
+++ b/TaskB01/run
@@ -7,69 +7,52 @@ class automata:
     # class variables init
     def __init__(self):
         # dictionary of connections between nodes
-        self.graph = {}
+        self.storage = {}
         # list of accepting states
         self.accepting_states = []
         # list of current states
         self.state = ['0']
-        # word variable
-        self.word = ''
 
     # print for debug purposes
     def __repr__(self):
-        return('%s\n\n%s\n\n%s\n\n' % (self.graph, self.accepting_states, self.state))
+        return('%s\n\n%s\n\n%s\n\n' % (self.storage, self.accepting_states, self.state))
 
     # add node in open fst format
     def add_node(self, line):
         node = line.replace('\n', '').split(' ')
         if len(node) == 3:
-            if node[0] in self.graph:
+            if node[0] in self.storage:
                 # add value to existing node
-                self.graph[node[0]].append({node[2]: node[1]})
+                self.storage[node[0]].append({node[2]: node[1]})
             else:
                 # create new node
-                self.graph[node[0]] = [{node[2]: node[1]}]
+                self.storage[node[0]] = [{node[2]: node[1]}]
         elif len(node) == 1:
             # add accepting state
             self.accepting_states.append(node[0])
 
     # check if string is accepted by automate
-    def test_string(self, word):
+    def test_string(self, text):
         self.state = ['0']
-        self.word = word.replace('\n', '')
-        # for all values in word
-        for i in self.word:
-            # for all actual states
-            result = []
+        text = text.replace('\n', '')
+        for i in text:
             for q in self.state:
-                # move state to its transition
-                result = self.get_node_transition(q, i)
-            # if the list is empty, return false
+                self.state = self.get_node_transition(q, i)
             if not self.state:
                 return False
-            # flatten list of states
-            self.state = [item for sublist in result for item in sublist]
-        # check if automata is in accepting state
         return self.check_if_accepted()
 
-    # check if there is common part between states of automata and accepting states
     def check_if_accepted(self):
         return not set(self.state).isdisjoint(self.accepting_states)
 
-    def get_node_transition(self, q, i):
-        result = []
-        # if the node exists
-        try:
-            # search through all its connections to find value
-            for connections in self.graph[q]:
-                for value in connections:
-                    if value == i:
-                        # append next node
-                        result.append(connections[value])
-        except KeyError:
-            return result
-        # return list of next nodes
-        return result
+    def get_node_transition(self, query):
+        for i in self.storage:
+            if i[0] == query:
+                return i[1]
+        return []
+
+    def sort(self):
+        self.storage = sorted(self.storage, key = lambda x: (x[0][0], x[0][1]))            
 
 
 auto = automata()
@@ -80,7 +63,4 @@ for line in sys.stdin:
 f = open(sys.argv[1], 'r')
 
 for line in f:
-    if auto.test_string(line):
-        print("TRUE %s" % auto.word)
-    else:
-        print("FALSE %s" % auto.word)
+    print(auto.test_string(line))