From a2285e2885b845769744aa1fd92536f70482d980 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 13 Dec 2021 18:14:40 -0800
Subject: [PATCH 01/83] cmp files

---
 src/cmp/__init__.py                           |   0
 src/cmp/ast.py                                |  62 +++
 src/cmp/automata.py                           | 207 +++++++
 src/cmp/cil.py                                | 231 ++++++++
 src/cmp/evaluation.py                         |  33 ++
 src/cmp/languages.py                          | 228 ++++++++
 src/cmp/nbpackage.py                          |  87 +++
 src/cmp/pycompiler.py                         | 512 ++++++++++++++++++
 src/cmp/semantic.py                           | 264 +++++++++
 .../.ipynb_checkpoints/__init__-checkpoint.py |   0
 .../.ipynb_checkpoints/automata-checkpoint.py |   3 +
 .../evaluation-checkpoint.py                  |   3 +
 .../.ipynb_checkpoints/parsing-checkpoint.py  |  10 +
 src/cmp/tools/__init__.py                     |   0
 src/cmp/tools/automata.py                     |   3 +
 src/cmp/tools/evaluation.py                   |   3 +
 src/cmp/tools/parsing.py                      |  16 +
 src/cmp/tools/regex.py                        |   3 +
 src/cmp/utils.py                              | 219 ++++++++
 src/cmp/visitor.py                            |  80 +++
 20 files changed, 1964 insertions(+)
 create mode 100644 src/cmp/__init__.py
 create mode 100644 src/cmp/ast.py
 create mode 100644 src/cmp/automata.py
 create mode 100644 src/cmp/cil.py
 create mode 100644 src/cmp/evaluation.py
 create mode 100644 src/cmp/languages.py
 create mode 100644 src/cmp/nbpackage.py
 create mode 100644 src/cmp/pycompiler.py
 create mode 100644 src/cmp/semantic.py
 create mode 100644 src/cmp/tools/.ipynb_checkpoints/__init__-checkpoint.py
 create mode 100644 src/cmp/tools/.ipynb_checkpoints/automata-checkpoint.py
 create mode 100644 src/cmp/tools/.ipynb_checkpoints/evaluation-checkpoint.py
 create mode 100644 src/cmp/tools/.ipynb_checkpoints/parsing-checkpoint.py
 create mode 100644 src/cmp/tools/__init__.py
 create mode 100644 src/cmp/tools/automata.py
 create mode 100644 src/cmp/tools/evaluation.py
 create mode 100644 src/cmp/tools/parsing.py
 create mode 100644 src/cmp/tools/regex.py
 create mode 100644 src/cmp/utils.py
 create mode 100644 src/cmp/visitor.py

diff --git a/src/cmp/__init__.py b/src/cmp/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/cmp/ast.py b/src/cmp/ast.py
new file mode 100644
index 000000000..ec162b83b
--- /dev/null
+++ b/src/cmp/ast.py
@@ -0,0 +1,62 @@
+import cmp.visitor as visitor
+
+class Node:
+    def evaluate(self):
+        raise NotImplementedError()
+
+class AtomicNode(Node):
+    def __init__(self, lex):
+        self.lex = lex
+
+class UnaryNode(Node):
+    def __init__(self, node):
+        self.node = node
+
+    def evaluate(self):
+        value = self.node.evaluate()
+        return self.operate(value)
+
+    @staticmethod
+    def operate(value):
+        raise NotImplementedError()
+
+class BinaryNode(Node):
+    def __init__(self, left, right):
+        self.left = left
+        self.right = right
+
+    def evaluate(self):
+        lvalue = self.left.evaluate()
+        rvalue = self.right.evaluate()
+        return self.operate(lvalue, rvalue)
+
+    @staticmethod
+    def operate(lvalue, rvalue):
+        raise NotImplementedError()
+
+def get_printer(AtomicNode=AtomicNode, UnaryNode=UnaryNode, BinaryNode=BinaryNode, ):
+
+    class PrintVisitor(object):
+        @visitor.on('node')
+        def visit(self, node, tabs):
+            pass
+
+        @visitor.when(UnaryNode)
+        def visit(self, node, tabs=0):
+            ans = '\t' * tabs + f'\\__<expr> {node.__class__.__name__}'
+            child = self.visit(node.node, tabs + 1)
+            return f'{ans}\n{child}'
+
+        @visitor.when(BinaryNode)
+        def visit(self, node, tabs=0):
+            ans = '\t' * tabs + f'\\__<expr> {node.__class__.__name__} <expr>'
+            left = self.visit(node.left, tabs + 1)
+            right = self.visit(node.right, tabs + 1)
+            return f'{ans}\n{left}\n{right}'
+
+        @visitor.when(AtomicNode)
+        def visit(self, node, tabs=0):
+            return '\t' * tabs + f'\\__ {node.__class__.__name__}: {node.lex}'
+
+    printer = PrintVisitor()
+    return (lambda ast: printer.visit(ast))
\ No newline at end of file
diff --git a/src/cmp/automata.py b/src/cmp/automata.py
new file mode 100644
index 000000000..f42b6f00c
--- /dev/null
+++ b/src/cmp/automata.py
@@ -0,0 +1,207 @@
+try:
+    import pydot
+except:
+    pass
+
+class State:
+    def __init__(self, state, final=False, formatter=lambda x: str(x), shape='circle'):
+        self.state = state
+        self.final = final
+        self.transitions = {}
+        self.epsilon_transitions = set()
+        self.tag = None
+        self.formatter = formatter
+        self.shape = shape
+
+    # The method name is set this way from compatibility issues.
+    def set_formatter(self, value, attr='formatter', visited=None):
+        if visited is None:
+            visited = set()
+        elif self in visited:
+            return
+
+        visited.add(self)
+        self.__setattr__(attr, value)
+        for destinations in self.transitions.values():
+            for node in destinations:
+                node.set_formatter(value, attr, visited)
+        for node in self.epsilon_transitions:
+            node.set_formatter(value, attr, visited)
+        return self
+
+    def has_transition(self, symbol):
+        return symbol in self.transitions
+
+    def add_transition(self, symbol, state):
+        try:
+            self.transitions[symbol].append(state)
+        except:
+            self.transitions[symbol] = [state]
+        return self
+
+    def add_epsilon_transition(self, state):
+        self.epsilon_transitions.add(state)
+        return self
+
+    def recognize(self, string):
+        states = self.epsilon_closure
+        for symbol in string:
+            states = self.move_by_state(symbol, *states)
+            states = self.epsilon_closure_by_state(*states)
+        return any(s.final for s in states)
+
+    def to_deterministic(self, formatter=lambda x: str(x)):
+        closure = self.epsilon_closure
+        start = State(tuple(closure), any(s.final for s in closure), formatter)
+
+        closures = [ closure ]
+        states = [ start ]
+        pending = [ start ]
+
+        while pending:
+            state = pending.pop()
+            symbols = { symbol for s in state.state for symbol in s.transitions }
+
+            for symbol in symbols:
+                move = self.move_by_state(symbol, *state.state)
+                closure = self.epsilon_closure_by_state(*move)
+
+                if closure not in closures:
+                    new_state = State(tuple(closure), any(s.final for s in closure), formatter)
+                    closures.append(closure)
+                    states.append(new_state)
+                    pending.append(new_state)
+                else:
+                    index = closures.index(closure)
+                    new_state = states[index]
+
+                state.add_transition(symbol, new_state)
+
+        return start
+
+    @staticmethod
+    def from_nfa(nfa, get_states=False):
+        states = []
+        for n in range(nfa.states):
+            state = State(n, n in nfa.finals)
+            states.append(state)
+
+        for (origin, symbol), destinations in nfa.map.items():
+            origin = states[origin]
+            origin[symbol] = [ states[d] for d in destinations ]
+
+        if get_states:
+            return states[nfa.start], states
+        return states[nfa.start]
+
+    @staticmethod
+    def move_by_state(symbol, *states):
+        return { s for state in states if state.has_transition(symbol) for s in state[symbol]}
+
+    @staticmethod
+    def epsilon_closure_by_state(*states):
+        closure = { state for state in states }
+
+        l = 0
+        while l != len(closure):
+            l = len(closure)
+            tmp = [s for s in closure]
+            for s in tmp:
+                for epsilon_state in s.epsilon_transitions:
+                        closure.add(epsilon_state)
+        return closure
+
+    @property
+    def epsilon_closure(self):
+        return self.epsilon_closure_by_state(self)
+
+    @property
+    def name(self):
+        return self.formatter(self.state)
+
+    def get(self, symbol):
+        target = self.transitions[symbol]
+        assert len(target) == 1
+        return target[0]
+
+    def __getitem__(self, symbol):
+        if symbol == '':
+            return self.epsilon_transitions
+        try:
+            return self.transitions[symbol]
+        except KeyError:
+            return None
+
+    def __setitem__(self, symbol, value):
+        if symbol == '':
+            self.epsilon_transitions = value
+        else:
+            self.transitions[symbol] = value
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return str(self.state)
+
+    def __hash__(self):
+        return hash(self.state)
+
+    def __iter__(self):
+        yield from self._visit()
+
+    def _visit(self, visited=None):
+        if visited is None:
+            visited = set()
+        elif self in visited:
+            return
+
+        visited.add(self)
+        yield self
+
+        for destinations in self.transitions.values():
+            for node in destinations:
+                yield from node._visit(visited)
+        for node in self.epsilon_transitions:
+            yield from node._visit(visited)
+
+    def graph(self):
+        G = pydot.Dot(rankdir='LR', margin=0.1)
+        G.add_node(pydot.Node('start', shape='plaintext', label='', width=0, height=0))
+
+        visited = set()
+        def visit(start):
+            ids = id(start)
+            if ids not in visited:
+                visited.add(ids)
+                G.add_node(pydot.Node(ids, label=start.name, shape=self.shape, style='bold' if start.final else ''))
+                for tran, destinations in start.transitions.items():
+                    for end in destinations:
+                        visit(end)
+                        G.add_edge(pydot.Edge(ids, id(end), label=tran, labeldistance=2))
+                for end in start.epsilon_transitions:
+                    visit(end)
+                    G.add_edge(pydot.Edge(ids, id(end), label='ε', labeldistance=2))
+
+        visit(self)
+        G.add_edge(pydot.Edge('start', id(self), label='', style='dashed'))
+
+        return G
+
+    def _repr_svg_(self):
+        try:
+            return self.graph().create_svg().decode('utf8')
+        except:
+            pass
+
+    def write_to(self, fname):
+        return self.graph().write_svg(fname)
+
+def multiline_formatter(state):
+    return '\n'.join(str(item) for item in state)
+
+def lr0_formatter(state):
+    try:
+        return '\n'.join(str(item)[:-4] for item in state)
+    except TypeError:
+        return str(state)[:-4]
\ No newline at end of file
diff --git a/src/cmp/cil.py b/src/cmp/cil.py
new file mode 100644
index 000000000..de6782c16
--- /dev/null
+++ b/src/cmp/cil.py
@@ -0,0 +1,231 @@
+import cmp.visitor as visitor
+
+
+class Node:
+    pass
+
+class ProgramNode(Node):
+    def __init__(self, dottypes, dotdata, dotcode):
+        self.dottypes = dottypes
+        self.dotdata = dotdata
+        self.dotcode = dotcode
+
+class TypeNode(Node):
+    def __init__(self, name):
+        self.name = name
+        self.attributes = []
+        self.methods = []
+
+class DataNode(Node):
+    def __init__(self, vname, value):
+        self.name = vname
+        self.value = value
+
+class FunctionNode(Node):
+    def __init__(self, fname, params, localvars, instructions):
+        self.name = fname
+        self.params = params
+        self.localvars = localvars
+        self.instructions = instructions
+
+class ParamNode(Node):
+    def __init__(self, name):
+        self.name = name
+
+class LocalNode(Node):
+    def __init__(self, name):
+        self.name = name
+
+class InstructionNode(Node):
+    pass
+
+class AssignNode(InstructionNode):
+    def __init__(self, dest, source):
+        self.dest = dest
+        self.source = source
+
+class ArithmeticNode(InstructionNode):
+    def __init__(self, dest, left, right):
+        self.dest = dest
+        self.left = left
+        self.right = right
+
+class PlusNode(ArithmeticNode):
+    pass
+
+class MinusNode(ArithmeticNode):
+    pass
+
+class StarNode(ArithmeticNode):
+    pass
+
+class DivNode(ArithmeticNode):
+    pass
+
+class GetAttribNode(InstructionNode):
+    pass
+
+class SetAttribNode(InstructionNode):
+    pass
+
+class GetIndexNode(InstructionNode):
+    pass
+
+class SetIndexNode(InstructionNode):
+    pass
+
+class AllocateNode(InstructionNode):
+    def __init__(self, itype, dest):
+        self.type = itype
+        self.dest = dest
+
+class ArrayNode(InstructionNode):
+    pass
+
+class TypeOfNode(InstructionNode):
+    def __init__(self, obj, dest):
+        self.obj = obj
+        self.dest = dest
+
+class LabelNode(InstructionNode):
+    pass
+
+class GotoNode(InstructionNode):
+    pass
+
+class GotoIfNode(InstructionNode):
+    pass
+
+class StaticCallNode(InstructionNode):
+    def __init__(self, function, dest):
+        self.function = function
+        self.dest = dest
+
+class DynamicCallNode(InstructionNode):
+    def __init__(self, xtype, method, dest):
+        self.type = xtype
+        self.method = method
+        self.dest = dest
+
+class ArgNode(InstructionNode):
+    def __init__(self, name):
+        self.name = name
+
+class ReturnNode(InstructionNode):
+    def __init__(self, value=None):
+        self.value = value
+
+class LoadNode(InstructionNode):
+    def __init__(self, dest, msg):
+        self.dest = dest
+        self.msg = msg
+
+class LengthNode(InstructionNode):
+    pass
+
+class ConcatNode(InstructionNode):
+    pass
+
+class PrefixNode(InstructionNode):
+    pass
+
+class SubstringNode(InstructionNode):
+    pass
+
+class ToStrNode(InstructionNode):
+    def __init__(self, dest, ivalue):
+        self.dest = dest
+        self.ivalue = ivalue
+
+class ReadNode(InstructionNode):
+    def __init__(self, dest):
+        self.dest = dest
+
+class PrintNode(InstructionNode):
+    def __init__(self, str_addr):
+        self.str_addr = str_addr
+
+def get_formatter():
+
+    class PrintVisitor(object):
+        @visitor.on('node')
+        def visit(self, node):
+            pass
+
+        @visitor.when(ProgramNode)
+        def visit(self, node):
+            dottypes = '\n'.join(self.visit(t) for t in node.dottypes)
+            dotdata = '\n'.join(self.visit(t) for t in node.dotdata)
+            dotcode = '\n'.join(self.visit(t) for t in node.dotcode)
+
+            return f'.TYPES\n{dottypes}\n\n.DATA\n{dotdata}\n\n.CODE\n{dotcode}'
+
+        @visitor.when(TypeNode)
+        def visit(self, node):
+            attributes = '\n\t'.join(f'attribute {x}' for x in node.attributes)
+            methods = '\n\t'.join(f'method {x}: {y}' for x,y in node.methods)
+
+            return f'type {node.name} {{\n\t{attributes}\n\n\t{methods}\n}}'
+
+        @visitor.when(FunctionNode)
+        def visit(self, node):
+            params = '\n\t'.join(self.visit(x) for x in node.params)
+            localvars = '\n\t'.join(self.visit(x) for x in node.localvars)
+            instructions = '\n\t'.join(self.visit(x) for x in node.instructions)
+
+            return f'function {node.name} {{\n\t{params}\n\n\t{localvars}\n\n\t{instructions}\n}}'
+
+        @visitor.when(ParamNode)
+        def visit(self, node):
+            return f'PARAM {node.name}'
+
+        @visitor.when(LocalNode)
+        def visit(self, node):
+            return f'LOCAL {node.name}'
+
+        @visitor.when(AssignNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.source}'
+
+        @visitor.when(PlusNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.left} + {node.right}'
+
+        @visitor.when(MinusNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.left} - {node.right}'
+
+        @visitor.when(StarNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.left} * {node.right}'
+
+        @visitor.when(DivNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.left} / {node.right}'
+
+        @visitor.when(AllocateNode)
+        def visit(self, node):
+            return f'{node.dest} = ALLOCATE {node.type}'
+
+        @visitor.when(TypeOfNode)
+        def visit(self, node):
+            return f'{node.dest} = TYPEOF {node.type}'
+
+        @visitor.when(StaticCallNode)
+        def visit(self, node):
+            return f'{node.dest} = CALL {node.function}'
+
+        @visitor.when(DynamicCallNode)
+        def visit(self, node):
+            return f'{node.dest} = VCALL {node.type} {node.method}'
+
+        @visitor.when(ArgNode)
+        def visit(self, node):
+            return f'ARG {node.name}'
+
+        @visitor.when(ReturnNode)
+        def visit(self, node):
+            return f'RETURN {node.value if node.value is not None else ""}'
+
+    printer = PrintVisitor()
+    return (lambda ast: printer.visit(ast))
\ No newline at end of file
diff --git a/src/cmp/evaluation.py b/src/cmp/evaluation.py
new file mode 100644
index 000000000..90bdbf935
--- /dev/null
+++ b/src/cmp/evaluation.py
@@ -0,0 +1,33 @@
+from cmp.pycompiler import EOF
+from cmp.tools.parsing import ShiftReduceParser
+
+def evaluate_reverse_parse(G, right_parse, operations, tokens):
+    if not right_parse or not operations or not tokens:
+        return
+
+    right_parse = iter(right_parse)
+    tokens = iter(tokens)
+    stack = []
+    for operation in operations:
+        if operation == ShiftReduceParser.SHIFT:
+            token = next(tokens)
+            stack.append(token.lex)
+        elif operation == ShiftReduceParser.REDUCE:
+            production = next(right_parse)
+            head, body = production
+            attributes = production.attributes
+            assert all(rule is None for rule in attributes[1:]), 'There must be only synteticed attributes.'
+            rule = attributes[0]
+
+            if len(body):
+                synteticed = [None] + stack[-len(body):]
+                value = rule(None, synteticed)
+                stack[-len(body):] = [value]
+            else:
+                stack.append(rule(None, None))
+        else:
+            raise Exception('Invalid action!!!')
+
+    assert len(stack) == 1
+    assert isinstance(G[next(tokens).token_type], EOF)
+    return stack[0]
\ No newline at end of file
diff --git a/src/cmp/languages.py b/src/cmp/languages.py
new file mode 100644
index 000000000..e2c0c33da
--- /dev/null
+++ b/src/cmp/languages.py
@@ -0,0 +1,228 @@
+from cmp.pycompiler import Sentence, Production
+from cmp.utils import ContainerSet, Token, UnknownToken
+from cmp.tools.parsing import build_parsing_table, metodo_predictivo_no_recursivo
+
+class BasicXCool:
+    def __init__(self, G):
+        self.G = G
+        self.fixed_tokens = { lex: Token(lex, G[lex]) for lex in '+ - * / ( )'.split() }
+
+    @property
+    def firsts(self):
+        G = self.G
+        return {
+            G['+']: ContainerSet(G['+'] , contains_epsilon=False),
+            G['-']: ContainerSet(G['-'] , contains_epsilon=False),
+            G['*']: ContainerSet(G['*'] , contains_epsilon=False),
+            G['/']: ContainerSet(G['/'] , contains_epsilon=False),
+            G['(']: ContainerSet(G['('] , contains_epsilon=False),
+            G[')']: ContainerSet(G[')'] , contains_epsilon=False),
+            G['num']: ContainerSet(G['num'] , contains_epsilon=False),
+            G['E']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['T']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['F']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['X']: ContainerSet(G['-'], G['+'] , contains_epsilon=True),
+            G['Y']: ContainerSet(G['/'], G['*'] , contains_epsilon=True),
+            Sentence(G['T'], G['X']): ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            Sentence(G['+'], G['T'], G['X']): ContainerSet(G['+'] , contains_epsilon=False),
+            Sentence(G['-'], G['T'], G['X']): ContainerSet(G['-'] , contains_epsilon=False),
+            G.Epsilon: ContainerSet( contains_epsilon=True),
+            Sentence(G['F'], G['Y']): ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            Sentence(G['*'], G['F'], G['Y']): ContainerSet(G['*'] , contains_epsilon=False),
+            Sentence(G['/'], G['F'], G['Y']): ContainerSet(G['/'] , contains_epsilon=False),
+            Sentence(G['num']): ContainerSet(G['num'] , contains_epsilon=False),
+            Sentence(G['('], G['E'], G[')']): ContainerSet(G['('] , contains_epsilon=False)
+        }
+
+    @property
+    def follows(self):
+        G = self.G
+        return {
+            G['E']: ContainerSet(G[')'], G.EOF , contains_epsilon=False),
+            G['T']: ContainerSet(G[')'], G['-'], G.EOF, G['+'] , contains_epsilon=False),
+            G['F']: ContainerSet(G['-'], G.EOF, G['*'], G['/'], G[')'], G['+'] , contains_epsilon=False),
+            G['X']: ContainerSet(G[')'], G.EOF , contains_epsilon=False),
+            G['Y']: ContainerSet(G[')'], G['-'], G.EOF, G['+'] , contains_epsilon=False)
+        }
+
+    @property
+    def table(self):
+        G = self.G
+        return {
+            ( G['E'], G['num'], ): [ Production(G['E'], Sentence(G['T'], G['X'])), ],
+            ( G['E'], G['('], ): [ Production(G['E'], Sentence(G['T'], G['X'])), ],
+            ( G['X'], G['+'], ): [ Production(G['X'], Sentence(G['+'], G['T'], G['X'])), ],
+            ( G['X'], G['-'], ): [ Production(G['X'], Sentence(G['-'], G['T'], G['X'])), ],
+            ( G['X'], G[')'], ): [ Production(G['X'], G.Epsilon), ],
+            ( G['X'], G.EOF, ): [ Production(G['X'], G.Epsilon), ],
+            ( G['T'], G['num'], ): [ Production(G['T'], Sentence(G['F'], G['Y'])), ],
+            ( G['T'], G['('], ): [ Production(G['T'], Sentence(G['F'], G['Y'])), ],
+            ( G['Y'], G['*'], ): [ Production(G['Y'], Sentence(G['*'], G['F'], G['Y'])), ],
+            ( G['Y'], G['/'], ): [ Production(G['Y'], Sentence(G['/'], G['F'], G['Y'])), ],
+            ( G['Y'], G[')'], ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['Y'], G['-'], ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['Y'], G.EOF, ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['Y'], G['+'], ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['F'], G['num'], ): [ Production(G['F'], Sentence(G['num'])), ],
+            ( G['F'], G['('], ): [ Production(G['F'], Sentence(G['('], G['E'], G[')'])), ]
+        }
+
+    @property
+    def tokenizer(self):
+        G = self.G
+        fixed_tokens = self.fixed_tokens
+
+        def tokenize_text(text):
+            tokens = []
+            for item in text.split():
+                try:
+                    float(item)
+                    token = Token(item, G['num'])
+                except ValueError:
+                    try:
+                        token = fixed_tokens[item]
+                    except:
+                        token = UnknownToken(item)
+                tokens.append(token)
+            eof = Token('$', G.EOF)
+            tokens.append(eof)
+            return tokens
+
+        return tokenize_text
+
+class PowXCool:
+    def __init__(self, G):
+        self.G = G
+
+    @property
+    def firsts(self):
+        G = self.G
+        return {
+            G['+']: ContainerSet(G['+'] , contains_epsilon=False),
+            G['-']: ContainerSet(G['-'] , contains_epsilon=False),
+            G['*']: ContainerSet(G['*'] , contains_epsilon=False),
+            G['/']: ContainerSet(G['/'] , contains_epsilon=False),
+            G['^']: ContainerSet(G['^'] , contains_epsilon=False),
+            G['(']: ContainerSet(G['('] , contains_epsilon=False),
+            G[')']: ContainerSet(G[')'] , contains_epsilon=False),
+            G['num']: ContainerSet(G['num'] , contains_epsilon=False),
+            G['E']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['T']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['F']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['A']: ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            G['X']: ContainerSet(G['-'], G['+'] , contains_epsilon=True),
+            G['Y']: ContainerSet(G['/'], G['*'] , contains_epsilon=True),
+            G['Z']: ContainerSet(G['^'] , contains_epsilon=True),
+            Sentence(G['T'], G['X']): ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            Sentence(G['+'], G['T'], G['X']): ContainerSet(G['+'] , contains_epsilon=False),
+            Sentence(G['-'], G['T'], G['X']): ContainerSet(G['-'] , contains_epsilon=False),
+            G.Epsilon: ContainerSet( contains_epsilon=True),
+            Sentence(G['F'], G['Y']): ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            Sentence(G['*'], G['F'], G['Y']): ContainerSet(G['*'] , contains_epsilon=False),
+            Sentence(G['/'], G['F'], G['Y']): ContainerSet(G['/'] , contains_epsilon=False),
+            Sentence(G['A'], G['Z']): ContainerSet(G['num'], G['('] , contains_epsilon=False),
+            Sentence(G['^'], G['F']): ContainerSet(G['^'] , contains_epsilon=False),
+            Sentence(G['num']): ContainerSet(G['num'] , contains_epsilon=False),
+            Sentence(G['('], G['E'], G[')']): ContainerSet(G['('] , contains_epsilon=False)
+        }
+
+    @property
+    def follows(self):
+        G = self.G
+        return {
+            G['E']: ContainerSet(G[')'], G.EOF , contains_epsilon=False),
+            G['T']: ContainerSet(G['-'], G[')'], G.EOF, G['+'] , contains_epsilon=False),
+            G['F']: ContainerSet(G['-'], G['*'], G['/'], G[')'], G.EOF, G['+'] , contains_epsilon=False),
+            G['A']: ContainerSet(G['-'], G['*'], G['/'], G['^'], G[')'], G.EOF, G['+'] , contains_epsilon=False),
+            G['X']: ContainerSet(G[')'], G.EOF , contains_epsilon=False),
+            G['Y']: ContainerSet(G['-'], G[')'], G.EOF, G['+'] , contains_epsilon=False),
+            G['Z']: ContainerSet(G['-'], G['*'], G['/'], G[')'], G.EOF, G['+'] , contains_epsilon=False)
+        }
+
+class Regex:
+    def __init__(self, G):
+        self.G = G
+
+    @property
+    def firsts(self):
+        G = self.G
+        return {
+            G['|']: ContainerSet(G['|'] , contains_epsilon=False),
+            G['*']: ContainerSet(G['*'] , contains_epsilon=False),
+            G['(']: ContainerSet(G['('] , contains_epsilon=False),
+            G[')']: ContainerSet(G[')'] , contains_epsilon=False),
+            G['symbol']: ContainerSet(G['symbol'] , contains_epsilon=False),
+            G['ε']: ContainerSet(G['ε'] , contains_epsilon=False),
+            G['E']: ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            G['T']: ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            G['F']: ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            G['A']: ContainerSet(G['ε'], G['symbol'], G['('] , contains_epsilon=False),
+            G['X']: ContainerSet(G['|'] , contains_epsilon=True),
+            G['Y']: ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=True),
+            G['Z']: ContainerSet(G['*'] , contains_epsilon=True),
+            Sentence(G['T'], G['X']): ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            Sentence(G['|'], G['E']): ContainerSet(G['|'] , contains_epsilon=False),
+            G.Epsilon: ContainerSet( contains_epsilon=True),
+            Sentence(G['F'], G['Y']): ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            Sentence(G['T']): ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            Sentence(G['A'], G['Z']): ContainerSet(G['symbol'], G['ε'], G['('] , contains_epsilon=False),
+            Sentence(G['*']): ContainerSet(G['*'] , contains_epsilon=False),
+            Sentence(G['symbol']): ContainerSet(G['symbol'] , contains_epsilon=False),
+            Sentence(G['ε']): ContainerSet(G['ε'] , contains_epsilon=False),
+            Sentence(G['('], G['E'], G[')']): ContainerSet(G['('] , contains_epsilon=False) 
+        }
+
+    @property
+    def follows(self):
+        G = self.G
+        return {
+            G['E']: ContainerSet(G[')'], G.EOF , contains_epsilon=False),
+            G['T']: ContainerSet(G[')'], G.EOF, G['|'] , contains_epsilon=False),
+            G['F']: ContainerSet(G[')'], G.EOF, G['symbol'], G['|'], G['ε'], G['('] , contains_epsilon=False),
+            G['A']: ContainerSet(G.EOF, G['|'], G['*'], G['('], G[')'], G['symbol'], G['ε'] , contains_epsilon=False),
+            G['X']: ContainerSet(G[')'], G.EOF , contains_epsilon=False),
+            G['Y']: ContainerSet(G[')'], G.EOF, G['|'] , contains_epsilon=False),
+            G['Z']: ContainerSet(G.EOF, G['|'], G['('], G[')'], G['symbol'], G['ε'] , contains_epsilon=False)
+        }
+
+    @property
+    def table(self):
+        G = self.G
+        return {
+            ( G['E'], G['symbol'], ): [ Production(G['E'], Sentence(G['T'], G['X'])), ],
+            ( G['E'], G['ε'], ): [ Production(G['E'], Sentence(G['T'], G['X'])), ],
+            ( G['E'], G['('], ): [ Production(G['E'], Sentence(G['T'], G['X'])), ],
+            ( G['X'], G['|'], ): [ Production(G['X'], Sentence(G['|'], G['E'])), ],
+            ( G['X'], G[')'], ): [ Production(G['X'], G.Epsilon), ],
+            ( G['X'], G.EOF, ): [ Production(G['X'], G.Epsilon), ],
+            ( G['T'], G['symbol'], ): [ Production(G['T'], Sentence(G['F'], G['Y'])), ],
+            ( G['T'], G['ε'], ): [ Production(G['T'], Sentence(G['F'], G['Y'])), ],
+            ( G['T'], G['('], ): [ Production(G['T'], Sentence(G['F'], G['Y'])), ],
+            ( G['Y'], G['symbol'], ): [ Production(G['Y'], Sentence(G['T'])), ],
+            ( G['Y'], G['ε'], ): [ Production(G['Y'], Sentence(G['T'])), ],
+            ( G['Y'], G['('], ): [ Production(G['Y'], Sentence(G['T'])), ],
+            ( G['Y'], G[')'], ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['Y'], G.EOF, ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['Y'], G['|'], ): [ Production(G['Y'], G.Epsilon), ],
+            ( G['F'], G['symbol'], ): [ Production(G['F'], Sentence(G['A'], G['Z'])), ],
+            ( G['F'], G['ε'], ): [ Production(G['F'], Sentence(G['A'], G['Z'])), ],
+            ( G['F'], G['('], ): [ Production(G['F'], Sentence(G['A'], G['Z'])), ],
+            ( G['Z'], G['*'], ): [ Production(G['Z'], Sentence(G['*'])), ],
+            ( G['Z'], G.EOF, ): [ Production(G['Z'], G.Epsilon), ],
+            ( G['Z'], G['|'], ): [ Production(G['Z'], G.Epsilon), ],
+            ( G['Z'], G['('], ): [ Production(G['Z'], G.Epsilon), ],
+            ( G['Z'], G[')'], ): [ Production(G['Z'], G.Epsilon), ],
+            ( G['Z'], G['symbol'], ): [ Production(G['Z'], G.Epsilon), ],
+            ( G['Z'], G['ε'], ): [ Production(G['Z'], G.Epsilon), ],
+            ( G['A'], G['symbol'], ): [ Production(G['A'], Sentence(G['symbol'])), ],
+            ( G['A'], G['ε'], ): [ Production(G['A'], Sentence(G['ε'])), ],
+            ( G['A'], G['('], ): [ Production(G['A'], Sentence(G['('], G['E'], G[')'])), ] 
+        }
+
+    @property
+    def parser(self):
+        firsts = self.firsts
+        follows = self.follows
+        M = build_parsing_table(self.G, firsts, follows)
+        parser = metodo_predictivo_no_recursivo(self.G, M)
+        return parser
\ No newline at end of file
diff --git a/src/cmp/nbpackage.py b/src/cmp/nbpackage.py
new file mode 100644
index 000000000..e89c62ad3
--- /dev/null
+++ b/src/cmp/nbpackage.py
@@ -0,0 +1,87 @@
+import io, os, sys, types
+
+from IPython import get_ipython
+from nbformat import read
+from IPython.core.interactiveshell import InteractiveShell
+
+def find_notebook(fullname, path=None):
+    """find a notebook, given its fully qualified name and an optional path
+
+    This turns "foo.bar" into "foo/bar.ipynb"
+    and tries turning "Foo_Bar" into "Foo Bar" if Foo_Bar
+    does not exist.
+    """
+    name = fullname.rsplit('.', 1)[-1]
+    if not path:
+        path = ['']
+    for d in path:
+        nb_path = os.path.join(d, name + ".ipynb")
+        if os.path.isfile(nb_path):
+            return nb_path
+        # let import Notebook_Name find "Notebook Name.ipynb"
+        nb_path = nb_path.replace("_", " ")
+        if os.path.isfile(nb_path):
+            return nb_path
+
+class NotebookLoader(object):
+    """Module Loader for Jupyter Notebooks"""
+    def __init__(self, path=None):
+        self.shell = InteractiveShell.instance()
+        self.path = path
+
+    def load_module(self, fullname):
+        """import a notebook as a module"""
+        path = find_notebook(fullname, self.path)
+
+        print ("importing Jupyter notebook from %s" % path)
+
+        # load the notebook object
+        with io.open(path, 'r', encoding='utf-8') as f:
+            nb = read(f, 4)
+
+
+        # create the module and add it to sys.modules
+        # if name in sys.modules:
+        #    return sys.modules[name]
+        mod = types.ModuleType(fullname)
+        mod.__file__ = path
+        mod.__loader__ = self
+        mod.__dict__['get_ipython'] = get_ipython
+        sys.modules[fullname] = mod
+
+        # extra work to ensure that magics that would affect the user_ns
+        # actually affect the notebook module's ns
+        save_user_ns = self.shell.user_ns
+        self.shell.user_ns = mod.__dict__
+
+        try:
+          for cell in nb.cells:
+            if cell.cell_type == 'code':
+                # transform the input to executable Python
+                code = self.shell.input_transformer_manager.transform_cell(cell.source)
+                # run the code in themodule
+                exec(code, mod.__dict__)
+        finally:
+            self.shell.user_ns = save_user_ns
+        return mod
+
+class NotebookFinder(object):
+    """Module finder that locates Jupyter Notebooks"""
+    def __init__(self):
+        self.loaders = {}
+
+    def find_module(self, fullname, path=None):
+        nb_path = find_notebook(fullname, path)
+        if not nb_path:
+            return
+
+        key = path
+        if path:
+            # lists aren't hashable
+            key = os.path.sep.join(path)
+
+        if key not in self.loaders:
+            self.loaders[key] = NotebookLoader(path)
+        return self.loaders[key]
+
+sys.meta_path.append(NotebookFinder())
\ No newline at end of file
diff --git a/src/cmp/pycompiler.py b/src/cmp/pycompiler.py
new file mode 100644
index 000000000..2815e9ea3
--- /dev/null
+++ b/src/cmp/pycompiler.py
@@ -0,0 +1,512 @@
+import json
+
+class Symbol(object):
+
+    def __init__(self, name, grammar):
+        self.Name = name
+        self.Grammar = grammar
+
+    def __str__(self):
+        return self.Name
+
+    def __repr__(self):
+        return repr(self.Name)
+
+    def __add__(self, other):
+        if isinstance(other, Symbol):
+            return Sentence(self, other)
+
+        raise TypeError(other)
+
+    def __or__(self, other):
+
+        if isinstance(other, (Sentence)):
+            return SentenceList(Sentence(self), other)
+
+        raise TypeError(other)
+
+    @property
+    def IsEpsilon(self):
+        return False
+
+    def __len__(self):
+        return 1
+
+class NonTerminal(Symbol):
+
+
+    def __init__(self, name, grammar):
+        super().__init__(name, grammar)
+        self.productions = []
+
+
+    def __imod__(self, other):
+
+        if isinstance(other, (Sentence)):
+            p = Production(self, other)
+            self.Grammar.Add_Production(p)
+            return self
+
+        if isinstance(other, tuple):
+            assert len(other) > 1
+
+            if len(other) == 2:
+                other += (None,) * len(other[0])
+
+            assert len(other) == len(other[0]) + 2, "Debe definirse una, y solo una, regla por cada símbolo de la producción"
+            # assert len(other) == 2, "Tiene que ser una Tupla de 2 elementos (sentence, attribute)"
+
+            if isinstance(other[0], Symbol) or isinstance(other[0], Sentence):
+                p = AttributeProduction(self, other[0], other[1:])
+            else:
+                raise Exception("")
+
+            self.Grammar.Add_Production(p)
+            return self
+
+        if isinstance(other, Symbol):
+            p = Production(self, Sentence(other))
+            self.Grammar.Add_Production(p)
+            return self
+
+        if isinstance(other, SentenceList):
+
+            for s in other:
+                p = Production(self, s)
+                self.Grammar.Add_Production(p)
+
+            return self
+
+        raise TypeError(other)
+
+    @property
+    def IsTerminal(self):
+        return False
+
+    @property
+    def IsNonTerminal(self):
+        return True
+
+    @property
+    def IsEpsilon(self):
+        return False
+
+class Terminal(Symbol):
+
+    def __init__(self, name, grammar):
+        super().__init__(name, grammar)
+
+    @property
+    def IsTerminal(self):
+        return True
+
+    @property
+    def IsNonTerminal(self):
+        return False
+
+    @property
+    def IsEpsilon(self):
+        return False
+
+class EOF(Terminal):
+
+    def __init__(self, Grammar):
+        super().__init__('$', Grammar)
+
+class Sentence(object):
+
+    def __init__(self, *args):
+        self._symbols = tuple(x for x in args if not x.IsEpsilon)
+        self.hash = hash(self._symbols)
+
+    def __len__(self):
+        return len(self._symbols)
+
+    def __add__(self, other):
+        if isinstance(other, Symbol):
+            return Sentence(*(self._symbols + (other,)))
+
+        if isinstance(other, Sentence):
+            return Sentence(*(self._symbols + other._symbols))
+
+        raise TypeError(other)
+
+    def __or__(self, other):
+        if isinstance(other, Sentence):
+            return SentenceList(self, other)
+
+        if isinstance(other, Symbol):
+            return SentenceList(self, Sentence(other))
+
+        raise TypeError(other)
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return ("%s " * len(self._symbols) % tuple(self._symbols)).strip()
+
+    def __iter__(self):
+        return iter(self._symbols)
+
+    def __getitem__(self, index):
+        return self._symbols[index]
+
+    def __eq__(self, other):
+        return self._symbols == other._symbols
+
+    def __hash__(self):
+        return self.hash
+
+    @property
+    def IsEpsilon(self):
+        return False
+
+class SentenceList(object):
+
+    def __init__(self, *args):
+        self._sentences = list(args)
+
+    def Add(self, symbol):
+        if not symbol and (symbol is None or not symbol.IsEpsilon):
+            raise ValueError(symbol)
+
+        self._sentences.append(symbol)
+
+    def __iter__(self):
+        return iter(self._sentences)
+
+    def __or__(self, other):
+        if isinstance(other, Sentence):
+            self.Add(other)
+            return self
+
+        if isinstance(other, Symbol):
+            return self | Sentence(other)
+
+
+class Epsilon(Terminal, Sentence):
+
+    def __init__(self, grammar):
+        super().__init__('epsilon', grammar)
+
+
+    def __str__(self):
+        return "e"
+
+    def __repr__(self):
+        return 'epsilon'
+
+    def __iter__(self):
+        yield from ()
+
+    def __len__(self):
+        return 0
+
+    def __add__(self, other):
+        return other
+
+    def __eq__(self, other):
+        return isinstance(other, (Epsilon,))
+
+    def __hash__(self):
+        return hash("")
+
+    @property
+    def IsEpsilon(self):
+        return True
+
+class Production(object):
+
+    def __init__(self, nonTerminal, sentence):
+
+        self.Left = nonTerminal
+        self.Right = sentence
+
+    def __str__(self):
+
+        return '%s := %s' % (self.Left, self.Right)
+
+    def __repr__(self):
+        return '%s -> %s' % (self.Left, self.Right)
+
+    def __iter__(self):
+        yield self.Left
+        yield self.Right
+
+    def __eq__(self, other):
+        return isinstance(other, Production) and self.Left == other.Left and self.Right == other.Right
+
+    def __hash__(self):
+        return hash((self.Left, self.Right))
+
+    @property
+    def IsEpsilon(self):
+        return self.Right.IsEpsilon
+
+class AttributeProduction(Production):
+
+    def __init__(self, nonTerminal, sentence, attributes):
+        if not isinstance(sentence, Sentence) and isinstance(sentence, Symbol):
+            sentence = Sentence(sentence)
+        super(AttributeProduction, self).__init__(nonTerminal, sentence)
+
+        self.attributes = attributes
+
+    def __str__(self):
+        return '%s := %s' % (self.Left, self.Right)
+
+    def __repr__(self):
+        return '%s -> %s' % (self.Left, self.Right)
+
+    def __iter__(self):
+        yield self.Left
+        yield self.Right
+
+
+    @property
+    def IsEpsilon(self):
+        return self.Right.IsEpsilon
+
+    # sintetizar en ingles??????, pending aggrement
+    def syntetice(self):
+        pass
+
+class Grammar():
+
+    def __init__(self):
+
+        self.Productions = []
+        self.nonTerminals = []
+        self.terminals = []
+        self.startSymbol = None
+        # production type
+        self.pType = None
+        self.Epsilon = Epsilon(self)
+        self.EOF = EOF(self)
+
+        self.symbDict = { 'eof': self.EOF }
+
+    def NonTerminal(self, name, startSymbol = False):
+
+        name = name.strip()
+        if not name:
+            raise Exception("Empty name")
+
+        term = NonTerminal(name,self)
+
+        if startSymbol:
+
+            if self.startSymbol is None:
+                self.startSymbol = term
+            else:
+                raise Exception("Cannot define more than one start symbol.")
+
+        self.nonTerminals.append(term)
+        self.symbDict[name] = term
+        return term
+
+    def NonTerminals(self, names):
+
+        ans = tuple((self.NonTerminal(x) for x in names.strip().split()))
+
+        return ans
+
+
+    def Add_Production(self, production):
+
+        if len(self.Productions) == 0:
+            self.pType = type(production)
+
+        assert type(production) == self.pType, "The Productions most be of only 1 type."
+
+        production.Left.productions.append(production)
+        self.Productions.append(production)
+
+
+    def Terminal(self, name):
+
+        name = name.strip()
+        if not name:
+            raise Exception("Empty name")
+
+        term = Terminal(name, self)
+        self.terminals.append(term)
+        self.symbDict[name] = term
+        return term
+
+    def Terminals(self, names):
+
+        ans = tuple((self.Terminal(x) for x in names.strip().split()))
+
+        return ans
+
+
+    def __str__(self):
+
+        mul = '%s, '
+
+        ans = 'Non-Terminals:\n\t'
+
+        nonterminals = mul * (len(self.nonTerminals)-1) + '%s\n'
+
+        ans += nonterminals % tuple(self.nonTerminals)
+
+        ans += 'Terminals:\n\t'
+
+        terminals = mul * (len(self.terminals)-1) + '%s\n'
+
+        ans += terminals % tuple(self.terminals)
+
+        ans += 'Productions:\n\t'
+
+        ans += str(self.Productions)
+
+        return ans
+
+    def __getitem__(self, name):
+        try:
+            return self.symbDict[name]
+        except KeyError:
+            return None
+
+    @property
+    def to_json(self):
+
+        productions = []
+
+        for p in self.Productions:
+            head = p.Left.Name
+
+            body = []
+
+            for s in p.Right:
+                body.append(s.Name)
+
+            productions.append({'Head':head, 'Body':body})
+
+        d={'NonTerminals':[symb.Name for symb in self.nonTerminals], 'Terminals': [symb.Name for symb in self.terminals],\
+         'Productions':productions}
+
+         # [{'Head':p.Left.Name, "Body": [s.Name for s in p.Right]} for p in self.Productions]
+        return json.dumps(d)
+
+    @staticmethod
+    def from_json(data):
+        data = json.loads(data)
+
+        G = Grammar()
+        dic = {'epsilon':G.Epsilon}
+
+        for term in data['Terminals']:
+            dic[term] = G.Terminal(term)
+
+        for noTerm in data['NonTerminals']:
+            dic[noTerm] = G.NonTerminal(noTerm)
+
+        for p in data['Productions']:
+            head = p['Head']
+            dic[head] %= Sentence(*[dic[term] for term in p['Body']])
+
+        return G
+
+    def copy(self):
+        G = Grammar()
+        G.Productions = self.Productions.copy()
+        G.nonTerminals = self.nonTerminals.copy()
+        G.terminals = self.terminals.copy()
+        G.pType = self.pType
+        G.startSymbol = self.startSymbol
+        G.Epsilon = self.Epsilon
+        G.EOF = self.EOF
+        G.symbDict = self.symbDict.copy()
+
+        return G
+
+    @property
+    def IsAugmentedGrammar(self):
+        augmented = 0
+        for left, right in self.Productions:
+            if self.startSymbol == left:
+                augmented += 1
+        if augmented <= 1:
+            return True
+        else:
+            return False
+
+    def AugmentedGrammar(self, force=False):
+        if not self.IsAugmentedGrammar or force:
+
+            G = self.copy()
+            # S, self.startSymbol, SS = self.startSymbol, None, self.NonTerminal('S\'', True)
+            S = G.startSymbol
+            G.startSymbol = None
+            SS = G.NonTerminal('S\'', True)
+            if G.pType is AttributeProduction:
+                SS %= S + G.Epsilon, lambda x : x
+            else:
+                SS %= S + G.Epsilon
+
+            return G
+        else:
+            return self.copy()
+    #endchange
+
+class Item:
+
+    def __init__(self, production, pos, lookaheads=[]):
+        self.production = production
+        self.pos = pos
+        self.lookaheads = frozenset(look for look in lookaheads)
+
+    def __str__(self):
+        s = str(self.production.Left) + " -> "
+        if len(self.production.Right) > 0:
+            for i,c in enumerate(self.production.Right):
+                if i == self.pos:
+                    s += "."
+                s += str(self.production.Right[i])
+            if self.pos == len(self.production.Right):
+                s += "."
+        else:
+            s += "."
+        s += ", " + str(self.lookaheads)[10:-1]
+        return s
+
+    def __repr__(self):
+        return str(self)
+
+
+    def __eq__(self, other):
+        return (
+            (self.pos == other.pos) and
+            (self.production == other.production) and
+            (set(self.lookaheads) == set(other.lookaheads))
+        )
+
+    def __hash__(self):
+        return hash((self.production,self.pos,self.lookaheads))
+
+    @property
+    def IsReduceItem(self):
+        return len(self.production.Right) == self.pos
+
+    @property
+    def NextSymbol(self):
+        if self.pos < len(self.production.Right):
+            return self.production.Right[self.pos]
+        else:
+            return None
+
+    def NextItem(self):
+        if self.pos < len(self.production.Right):
+            return Item(self.production,self.pos+1,self.lookaheads)
+        else:
+            return None
+
+    def Preview(self, skip=1):
+        unseen = self.production.Right[self.pos+skip:]
+        return [ unseen + (lookahead,) for lookahead in self.lookaheads ]
+
+    def Center(self):
+        return Item(self.production, self.pos)
\ No newline at end of file
diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
new file mode 100644
index 000000000..c463fbe25
--- /dev/null
+++ b/src/cmp/semantic.py
@@ -0,0 +1,264 @@
+import itertools as itt
+from collections import OrderedDict
+
+
+class SemanticError(Exception):
+    @property
+    def text(self):
+        return self.args[0]
+
+class Attribute:
+    def __init__(self, name, typex):
+        self.name = name
+        self.type = typex
+
+    def __str__(self):
+        return f'[attrib] {self.name} : {self.type.name};'
+
+    def __repr__(self):
+        return str(self)
+
+class Method:
+    def __init__(self, name, param_names, params_types, return_type):
+        self.name = name
+        self.param_names = param_names
+        self.param_types = params_types
+        self.return_type = return_type
+        self.expected_param_types = dict()
+        self.expected_return_type = None
+
+    def __str__(self):
+        params = ', '.join(f'{n}:{t.name}' for n,t in zip(self.param_names, self.param_types))
+        return f'[method] {self.name}({params}): {self.return_type.name};'
+
+    def __eq__(self, other):
+        return other.name == self.name and \
+            other.return_type == self.return_type and \
+            other.param_types == self.param_types
+
+class Type:
+    def __init__(self, name:str):
+        self.name = name
+        self.attributes = []
+        self.methods = []
+        self.parent = None
+
+    def set_parent(self, parent):
+        if self.parent is not None:
+            raise SemanticError(f'Parent type is already set for {self.name}.')
+        self.parent = parent
+
+    def get_attribute(self, name:str):
+        try:
+            return next(attr for attr in self.attributes if attr.name == name)
+        except StopIteration:
+            if self.parent is None:
+                raise SemanticError(f'Attribute "{name}" is not defined in {self.name}.')
+            try:
+                return self.parent.get_attribute(name)
+            except SemanticError:
+                raise SemanticError(f'Attribute "{name}" is not defined in {self.name}.')
+
+    def define_attribute(self, name:str, typex):
+        try:
+            self.get_attribute(name)
+        except SemanticError:
+            attribute = Attribute(name, typex)
+            self.attributes.append(attribute)
+            return attribute
+        else:
+            raise SemanticError(f'Attribute "{name}" is already defined in {self.name}.')
+
+    def get_method(self, name:str):
+        try:
+            return next(method for method in self.methods if method.name == name)
+        except StopIteration:
+            if self.parent is None:
+                raise SemanticError(f'Method "{name}" is not defined in {self.name}.')
+            try:
+                return self.parent.get_method(name)
+            except SemanticError:
+                raise SemanticError(f'Method "{name}" is not defined in {self.name}.')
+
+    def define_method(self, name:str, param_names:list, param_types:list, return_type):
+        if name in (method.name for method in self.methods):
+            raise SemanticError(f'Method "{name}" already defined in {self.name}')
+
+        method = Method(name, param_names, param_types, return_type)
+        self.methods.append(method)
+        return method
+
+    def all_attributes(self, clean=True):
+        plain = OrderedDict() if self.parent is None else self.parent.all_attributes(False)
+        for attr in self.attributes:
+            plain[attr.name] = (attr, self)
+        return plain.values() if clean else plain
+
+    def all_methods(self, clean=True):
+        plain = OrderedDict() if self.parent is None else self.parent.all_methods(False)
+        for method in self.methods:
+            plain[method.name] = (method, self)
+        return plain.values() if clean else plain
+
+    def conforms_to(self, other):
+        return other.bypass() or self == other or self.parent is not None and self.parent.conforms_to(other)
+
+    def bypass(self):
+        return False
+
+    def __str__(self):
+        output = f'type {self.name}'
+        parent = '' if self.parent is None else f' : {self.parent.name}'
+        output += parent
+        output += ' {'
+        output += '\n\t' if self.attributes or self.methods else ''
+        output += '\n\t'.join(str(x) for x in self.attributes)
+        output += '\n\t' if self.attributes else ''
+        output += '\n\t'.join(str(x) for x in self.methods)
+        output += '\n' if self.methods else ''
+        output += '}\n'
+        return output
+
+    def __repr__(self):
+        return str(self)
+
+    def join(self, other):
+        if self is ErrorType(): return ErrorType()
+        if self.name == 'AUTO_TYPE' or other.name == 'AUTO_TYPE':
+            return self if self.name != 'AUTO_TYPE' else other
+
+        current_parent = other
+        while not self.conforms_to(current_parent):
+            current_parent = current_parent.parent
+
+        return current_parent
+
+class AutoType(Type):
+    def __init__(self):
+        Type.__init__(self, 'AUTO_TYPE')
+
+    def conforms_to(self, other):
+        return True
+
+    def bypass(self):
+        return True
+
+    def get_method(self, name:str):
+        raise SemanticError(None)
+
+    def __eq__(self, other):
+        return isinstance(other, Type)
+
+class ErrorType(Type):
+    def __init__(self):
+        Type.__init__(self, '<error>')
+
+    def conforms_to(self, other):
+        return True
+
+    def bypass(self):
+        return True
+
+    def get_method(self, name:str):
+        raise SemanticError(None)
+    
+    def __eq__(self, other):
+        return isinstance(other, Type)
+
+class VoidType(Type):
+    def __init__(self):
+        Type.__init__(self, '<void>')
+
+    def conforms_to(self, other):
+        raise Exception('Invalid type: void type.')
+
+    def bypass(self):
+        return True
+
+    def __eq__(self, other):
+        return isinstance(other, VoidType)
+
+class IntType(Type):
+    def __init__(self):
+        Type.__init__(self, 'int')
+
+    def __eq__(self, other):
+        return other.name == self.name or isinstance(other, IntType)
+
+class Context:
+    def __init__(self):
+        self.types = {}
+
+    def create_type(self, name:str):
+        if name in self.types:
+            raise SemanticError(f'Type with the same name ({name}) already in context.')
+        typex = self.types[name] = Type(name)
+        return typex
+
+    def get_type(self, name:str):
+        if name == '<error>':
+            return ErrorType()
+            
+        try:
+            return self.types[name]
+        except KeyError:
+            raise SemanticError(f'Type "{name}" is not defined.')
+
+    def __str__(self):
+        return '{\n\t' + '\n\t'.join(y for x in self.types.values() for y in str(x).split('\n')) + '\n}'
+
+    def __repr__(self):
+        return str(self)
+
+class VariableInfo:
+    def __init__(self, name, vtype):
+        self.name = name
+        self.type = vtype
+        self.expected_types = []
+
+    def update_type(self):
+        infered_type = self.expected_types[0] if self.expected_types else None
+        
+        for typex in self.expected_types[1:]:
+            infered_type = infered_type.join(typex)
+            
+        self.type = infered_type
+        
+        if not self.type:
+            self.type = AutoType()
+        
+        self.expected_types = []
+
+
+class Scope:
+    def __init__(self, parent=None):
+        self.locals = []
+        self.parent = parent
+        self.children = []
+        self.index = 0 if parent is None else len(parent)
+
+    def __len__(self):
+        return len(self.locals)
+
+    def create_child(self):
+        child = Scope(self)
+        self.children.append(child)
+        return child
+
+    def define_variable(self, vname, vtype):
+        info = VariableInfo(vname, vtype)
+        self.locals.append(info)
+        return info
+
+    def find_variable(self, vname, index=None):
+        locals = self.locals if index is None else itt.islice(self.locals, index)
+        try:
+            return next(x for x in locals if x.name == vname)
+        except StopIteration:
+            return self.parent.find_variable(vname, self.index) if self.parent is not None else None
+
+    def is_defined(self, vname):
+        return self.find_variable(vname) is not None
+
+    def is_local(self, vname):
+        return any(True for x in self.locals if x.name == vname)
diff --git a/src/cmp/tools/.ipynb_checkpoints/__init__-checkpoint.py b/src/cmp/tools/.ipynb_checkpoints/__init__-checkpoint.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/cmp/tools/.ipynb_checkpoints/automata-checkpoint.py b/src/cmp/tools/.ipynb_checkpoints/automata-checkpoint.py
new file mode 100644
index 000000000..59643cc5b
--- /dev/null
+++ b/src/cmp/tools/.ipynb_checkpoints/automata-checkpoint.py
@@ -0,0 +1,3 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('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')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
diff --git a/src/cmp/tools/.ipynb_checkpoints/evaluation-checkpoint.py b/src/cmp/tools/.ipynb_checkpoints/evaluation-checkpoint.py
new file mode 100644
index 000000000..d49df0ce5
--- /dev/null
+++ b/src/cmp/tools/.ipynb_checkpoints/evaluation-checkpoint.py
@@ -0,0 +1,3 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('eJxdUMFuwjAMvecrfGy3qoLrJN86YGViCO2GECrF1SLSpErcqf37OUWwsZPtZ/v5+TXetVC3Xd6NtWs7bciDbjvnGV4/FmqJmsmrE1oaWFnUQdvAla1JFbhxltQaDVm1QLJ9S75iUmdqgL4r00tx7CofKGmyMn1RoBuwjqEB56ekFAw8ce+tggaXSZMqKCWWEge8kSQnaWSRQ0EVAok2K1iZ5uwuZI88dpSJWmlfyWB4EJF03p37mrWzkSXT9ou8/HU+xgHCImrbZAZ/5xSMf6q8Yvb61DMFBYz74vCUrBOTPs/l5OV/vZ8d8N8J+U5e1tkOtIVFYrJ5PBn92OVv4ZN8q21lInR78LLXBx2giBBLjtO/hgYByASaZld4miy7b+0QV/k7NRyxLY6yGDO5swVhi54X0+bEj9vkknF6P3H3azXZFEekGWlmh7u1150HxkmQSP0BhJm25Q==')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
diff --git a/src/cmp/tools/.ipynb_checkpoints/parsing-checkpoint.py b/src/cmp/tools/.ipynb_checkpoints/parsing-checkpoint.py
new file mode 100644
index 000000000..02d672f4b
--- /dev/null
+++ b/src/cmp/tools/.ipynb_checkpoints/parsing-checkpoint.py
@@ -0,0 +1,10 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('eJytVVtr2zAUfvevEH2yqWfa14AeypKGlXlNL5SCMUZO5FTMlhRZbpZu++87ujiOm3QwGJRU56pzvu8cuVKiQUxTpYWoW8QaKZRGrK3ZkgaVMS4bmXSaDcbPgmvCOFUPVAcrWqGlaGSnaVGLJamLiqlWh/a3jUktX0g0CVCFnSZAEltlgKb4MFMYBUirHbiiBZbJl3YmW1YLHiD6Y0mldoZrUrc0QKxCC6OYJi3VBXWeJgMFszFUQqE5YhxJI6EUV9k8N6dp0skV0TRMIyNCIi40SpOlK6Xtk9kwVCpKvsOpT3t8oaK6UxxNR0C4VsO5a/zn7wDN8KPqoHBTV2nqmieAecM49GPrzcp8DEcZOW/tvLngj+MAnR/ht31hNUUzY5/1UNkkty7JQolVt9RMcJsDPePb5CuttDlLON+z9YsVrgCvZ4uXpwQ6B5W0qoGPXntUCEI3+ORUxNJaZ7/wNHkhalV4Nm569dWR2iNcjREWdS22AHHssB6P2GaEObXSX7DcnMJyk82TVhOlH3ZNKep3DvNkdnv9PxG/xxuPuIlmcbszCSjvGqoMEjJygMPAtjvYjm9DD86A7iBDu8udsKcN8pWYZjJm3nLI3oHxA7rcQxCCx/llDHfSKHKRQNVdv0pV6ZVQXFV+sErjkPuB2I0ltuxYvSokUS3j60KTsqZ7cmPP9pjkCo5OH8B+9xSTk7g/Y9LDvoBjj7oJoCagyhb5ZDTuafYc0zwhUlK+Ckn0fvCdHWfEwGr6hgynOx8uMTvlogd6Tt0z5ujwJg9ZaiFrqBYrUUhFVwxafRUFF4Wiyw4wfBWAXooNYx5Ef3aIWcHCyQY8xYAnNJTCRwAZt4lvkB0qTODRa+cdxdhR4FNLa5xT/BHrUCc42CbDrZ38J5zZnYvHWwmWpsEX8O8NZ0ZyC2kW396+xk+JFNK9SQRvs6bJ/bu/hi0ar5BRYkwm+2EGyV7aT3D/OUAHXwRkKjjHl8E7rVSM6/BsppRQCboq4csJPSZJcuaXxXNpgApGocNwLHCarWOSZxd+ee3bYGZJEb6mYU15uHDTHH26jO1f1Ff11A+V98hY7m9+21tOjNs/1u2lt/1sNsEfuhaMXQ==')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
+
+deprecated_metodo_predictivo_no_recursivo = metodo_predictivo_no_recursivo
+def metodo_predictivo_no_recursivo(G, M=None, firsts=None, follows=None):
+    parser = deprecated_metodo_predictivo_no_recursivo(G, M, firsts, follows)
+    def updated(tokens):
+        return parser([t.token_type for t in tokens])
+    return updated
\ No newline at end of file
diff --git a/src/cmp/tools/__init__.py b/src/cmp/tools/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/cmp/tools/automata.py b/src/cmp/tools/automata.py
new file mode 100644
index 000000000..59643cc5b
--- /dev/null
+++ b/src/cmp/tools/automata.py
@@ -0,0 +1,3 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('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')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
diff --git a/src/cmp/tools/evaluation.py b/src/cmp/tools/evaluation.py
new file mode 100644
index 000000000..d49df0ce5
--- /dev/null
+++ b/src/cmp/tools/evaluation.py
@@ -0,0 +1,3 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('eJxdUMFuwjAMvecrfGy3qoLrJN86YGViCO2GECrF1SLSpErcqf37OUWwsZPtZ/v5+TXetVC3Xd6NtWs7bciDbjvnGV4/FmqJmsmrE1oaWFnUQdvAla1JFbhxltQaDVm1QLJ9S75iUmdqgL4r00tx7CofKGmyMn1RoBuwjqEB56ekFAw8ce+tggaXSZMqKCWWEge8kSQnaWSRQ0EVAok2K1iZ5uwuZI88dpSJWmlfyWB4EJF03p37mrWzkSXT9ou8/HU+xgHCImrbZAZ/5xSMf6q8Yvb61DMFBYz74vCUrBOTPs/l5OV/vZ8d8N8J+U5e1tkOtIVFYrJ5PBn92OVv4ZN8q21lInR78LLXBx2giBBLjtO/hgYByASaZld4miy7b+0QV/k7NRyxLY6yGDO5swVhi54X0+bEj9vkknF6P3H3azXZFEekGWlmh7u1150HxkmQSP0BhJm25Q==')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
diff --git a/src/cmp/tools/parsing.py b/src/cmp/tools/parsing.py
new file mode 100644
index 000000000..d0275cbcb
--- /dev/null
+++ b/src/cmp/tools/parsing.py
@@ -0,0 +1,16 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('eJytVVtr2zAUfvevEH2yqWfa14AeypKGlXlNL5SCMUZO5FTMlhRZbpZu++87ujiOm3QwGJRU56pzvu8cuVKiQUxTpYWoW8QaKZRGrK3ZkgaVMS4bmXSaDcbPgmvCOFUPVAcrWqGlaGSnaVGLJamLiqlWh/a3jUktX0g0CVCFnSZAEltlgKb4MFMYBUirHbiiBZbJl3YmW1YLHiD6Y0mldoZrUrc0QKxCC6OYJi3VBXWeJgMFszFUQqE5YhxJI6EUV9k8N6dp0skV0TRMIyNCIi40SpOlK6Xtk9kwVCpKvsOpT3t8oaK6UxxNR0C4VsO5a/zn7wDN8KPqoHBTV2nqmieAecM49GPrzcp8DEcZOW/tvLngj+MAnR/ht31hNUUzY5/1UNkkty7JQolVt9RMcJsDPePb5CuttDlLON+z9YsVrgCvZ4uXpwQ6B5W0qoGPXntUCEI3+ORUxNJaZ7/wNHkhalV4Nm569dWR2iNcjREWdS22AHHssB6P2GaEObXSX7DcnMJyk82TVhOlH3ZNKep3DvNkdnv9PxG/xxuPuIlmcbszCSjvGqoMEjJygMPAtjvYjm9DD86A7iBDu8udsKcN8pWYZjJm3nLI3oHxA7rcQxCCx/llDHfSKHKRQNVdv0pV6ZVQXFV+sErjkPuB2I0ltuxYvSokUS3j60KTsqZ7cmPP9pjkCo5OH8B+9xSTk7g/Y9LDvoBjj7oJoCagyhb5ZDTuafYc0zwhUlK+Ckn0fvCdHWfEwGr6hgynOx8uMTvlogd6Tt0z5ujwJg9ZaiFrqBYrUUhFVwxafRUFF4Wiyw4wfBWAXooNYx5Ef3aIWcHCyQY8xYAnNJTCRwAZt4lvkB0qTODRa+cdxdhR4FNLa5xT/BHrUCc42CbDrZ38J5zZnYvHWwmWpsEX8O8NZ0ZyC2kW396+xk+JFNK9SQRvs6bJ/bu/hi0ar5BRYkwm+2EGyV7aT3D/OUAHXwRkKjjHl8E7rVSM6/BsppRQCboq4csJPSZJcuaXxXNpgApGocNwLHCarWOSZxd+ee3bYGZJEb6mYU15uHDTHH26jO1f1Ff11A+V98hY7m9+21tOjNs/1u2lt/1sNsEfuhaMXQ==')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
+
+deprecated_metodo_predictivo_no_recursivo = metodo_predictivo_no_recursivo
+def metodo_predictivo_no_recursivo(G, M=None, firsts=None, follows=None):
+    parser = deprecated_metodo_predictivo_no_recursivo(G, M, firsts, follows)
+    def updated(tokens):
+        return parser([t.token_type for t in tokens])
+    return updated
+
+exec(zlib.decompress(base64.b64decode('eJx9U8GO2jAQvfMVZi9JtCFarqiuVLUsRUilWranCEUmGcBaY0e2s3TV7b/X9iQhpaiXxJ4Zv3nzZqYUzBiyOfK9fYKqKeE70wb0bEQ2X5ePzzQKv2hEnuZffnye0wj/zrBe0Wi9cocK9qQouOS2KGIDYp8u0lfQO2WAPjJhIHFoxDuyBV10xy6i/XdmVlquJP31uzMclFWDa7FruKiK2rHk8lBYthMQJy2JWz7/KhDQjBsg35RdnmoBJ5AWqrnWSvfPi5IJ0dVwTg9gC+OFKXRQZliMZeULzR+27lw22ihNH9xRNbZuLM29WdWgma/F4P185ALIs27AA3gECzTg5JOpDyBCqRd2BFbRc46gwcz3fwk2qzWXNg4v0+jDZDJ5f3efj1HavZptE3wXhyRpj5tIZQmXQ6EDF4KQ/4QnA+ddkCojn3ZKW6dulmV36NdgGy2dsNI3kSBuatmBDvLkV9hdZW27MTSMGjK6qJexugZZxZcITBsEuKd5D+lTBti2I/d06m8grtPgBP83D4ZgImxq53ZJ0BxS7lT1Rp0pWPZKE/N22inhRdbgGmagin1MgtmQdFarOkYQ4pYPtB3aHcmA0RV5PSUkLES/Gq2wvaa9LoGfj9jeVmG9mo1uUbrJKOxu5mzabi7s2lABEsfRRU6HI4HK+Tb7wbteJ8fJQIwx6aUPCdI1uCbt1s5/llB7dxwt5SsTvGqLGY/HUTL6AyImjec=')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
+
+exec(zlib.decompress(base64.b64decode('eJyFVltP4zoQfu+v8D41OcfHWl6RLJ0KekEgqLg+dKtiGrf1ktiR7RS6iP9+ZuykSYE9ywOKLzPzzTffjLuypiDLomSVV7kjqiiN9eTEaC+UlvZG+t6queKNyR0rhXVKr5urS1OUlZeLlbLOO9osc7MUedxsHZQ7PFa5tI31mZdFL5MrIl9LobMkozo97pEdz9ilfPU3u+LJ5D2iVmRHlCOXRktiLNHGkx07c7C+lbZQWuRgRaz0ldWzeY/c824KSdojKzAbEqVJxqZWbpV8STASeeZfQE40HYINuWdVmQkvk2dYCeckQMbY92wZ3buFLJ3Kje41wTGjpLQmo9/pfYpRcYGBdwy/qqVXRrt5yBpDW+lcMkAsOX97j0DD/QHCWwETJ1J7aTEJ4u0OdyG/fLaCPIG3pSw9OZe7obXGhkM84vfcxcTbJDKWG/MsNlJkLm0AvwXArx1sFBbGUTR/TkMGr/QZAeVMwV2XpO8RfG5cZYE3e5QMYt0mh7T/NYAwV/zWVrJHXjZQeHKFCK/4SOQO9oj4VKc2/0lIRjDQgQRpdBSSBh+TJi+xT6YldJIGjGvjTQ1wSqNEOYqI/qycXzxLq2UewSD8usKdMxRbNEP5YemDdf8xbj6SAu6SJ4lF3qpMZijVx0/OH/s9MuDQB7+kRl6jugPzaVtvtO3qnvNpm1k47SKT4PdDDSKotG04UXlTCC+adrvxwBctqhyaHThfQGw4BnEFsp4qlWeLi+ujRW1ndDLu8JJLWDPnha0BdgWdcn5E+2MrikLYPS2iWheo3gwI0PxwVoBv2JyN2fBqND/UQdiD0zP+23iz7yB/wwOHZ9BrrbR5NKcoE98hfWbmKUq0y5kHNQHFPBCTtHcnKUXVwtmWzzxE2vA3f2zfGxlvUZsXfAudUgbV3vHN7GJey3eK5RwzX48m9/eY6XZSuaDrQxwXAQcha75X7AQU2xVSjYegDlCI6+CG4CBSGhusnQ7kBdCsEc2X8+FD7HUdu7b6Hy7gb8tEWWI7rsP6joksW3grtFNYlmTKLkUh6QuyysC6lVjyhexaeds/PDM3G7Xy1xKqL6dwAopd5iBLAmqN6+TTDVQuynoRdV07XHjxlMvkIQz/MX9gYzZoRFqrN2nStfzrlqjLrOgpFlrqqpAWOQshQ4Ee2FbaJ+PkcWmV9omi/R++D//0D0/67KdROnHeJq9xvqKbU1S6lyle6gdyT5nKXrmqo4VYsYCShyP83E+P2jwWOAySMxfZwBaJ26SE16TtobgHd0t2IVeeHzZbbQKpLKxcK4clfGAiPhGJpLFHKexdnVOcimlUSBhMjfG+G7pvT3P4W9fT4PZ6eHp3MqRl7bfjdvrh5wEJnXPK1qDWKMC04SfkNwUuur8T/hz7ZnI2uqXrr1I6NMR2rc2wI/7FIqhlIf3GZLX89rdHFIgKEqkH6nloZGBnhO/MaHY+5/yS9oOS/4nFw4P41WxAw69ytfTfvn2DoRqtLnv/ATLgLos=')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
diff --git a/src/cmp/tools/regex.py b/src/cmp/tools/regex.py
new file mode 100644
index 000000000..85d74325a
--- /dev/null
+++ b/src/cmp/tools/regex.py
@@ -0,0 +1,3 @@
+import zlib, base64
+exec(zlib.decompress(base64.b64decode('eJytVsFu2zgQvesreFhDVE0IdY8BCNTZtVRg2yyaOKgdwxAYiYrZSKRK0qnttp+1v7HftCQlWbLWTXPYgwzyzXDem9Fw5FyKEqRlFRKlASsrITWYalGy9EpkFF0yTuTeLW/blZe3Z6p9KsqKFVS2R2NJypLIzkULUaiQbE1IoknjBv+IpujKPC2epIVQW0l7gOAp0ZQTzQTv4JJxVrLDAN1yu+U5SbRIspwEQ376RIqtO9QKbRCaVEQqOvS3IOMPrXNJtchEUkmasVSzJ5FwkUiabo3Xk+gObzUrVHtoLh4p975gk6uXFkQpMKsUKwS3NYRdjYMLD2Q0PyqCiha5BYGkeis5+AKVNrjCE5Sb11EovHq9RloSrphNSeFvPwJP4l74hvBmX96L4sV8CttlWNDdGfI3R/LJgBy+Riq4mBgNKe4YGwm/1y/WaTh2kGV7a+Oy1JR2I7JakaiotIKsMNqvwLBNGg/vI+6FbwhvbS84uq53f8FXuHBI/pzXNdjAz7vGR642Wde0/zf5yVUYiogi3LF6NrCkD3RnLoLpPnagEmq60yhG6pFVydcNM++yIql5oXNZ823wau2BOMbfdheuZ+EOxavdOsiFBDvA+Mr/7iP/lXmgeQLz/PO3v/7hAetwMA7AUljlLAdDGkB4Bg4hU24LXYLAZKQZ31Kz1nLvoM84jlcHIwTQXUorDf6k+5mUQjbWWtnBKPOV6zF/HRiL68miDrEJSVVRnsHPxnLc1Af933wUh7O/osDYmgJvXLnut6zIkod6bjl9MY7bnQdmOA6vBJ9TWVoq6M985CrngTmK0BQt0BLdnTop6M9BBKZgAZbgzjeuFfqAbtAlIujWuPb8voNXAIIA1DkBU1jLOcLz8QIVpLzPCNggdaFWb9bIMNBTcGLqtRjhajzr49dwYweEPRM4u0m8Hg19L+tjchjhaLx8IdXS6OqjUdQyTSzT8lmmaISn47sXMt2N8Ic++tERBc7wDMd0hEkfTWEjzRhu+wbZM9yMZ+PLoa5jk8RejAct4r3Hz38QYBw0A+Ha3sVm3iaJ+XbpJHHzFrlb+t9LGZmuqKfAJzeM7SJ0vtj9un0zGQTHn8Ja2xGBzitoGVNzOVpGe0lPIzcp9gIaqlQ82LnhxkZwdnKdpXwulQ0ezqT6yJmhVB+yFxu/hxu7mOPTTzXMkcPf4Xl4/IRZYIG7PwDwnUUe8dn/DXARdMk/ev8C0IsPHg==')))
+# Created by pyminifier (https://github.com/liftoff/pyminifier)
diff --git a/src/cmp/utils.py b/src/cmp/utils.py
new file mode 100644
index 000000000..a839ff5ee
--- /dev/null
+++ b/src/cmp/utils.py
@@ -0,0 +1,219 @@
+from cmp.pycompiler import Production, Sentence, Symbol, EOF, Epsilon
+
+class ContainerSet:
+    def __init__(self, *values, contains_epsilon=False):
+        self.set = set(values)
+        self.contains_epsilon = contains_epsilon
+
+    def add(self, value):
+        n = len(self.set)
+        self.set.add(value)
+        return n != len(self.set)
+
+    def extend(self, values):
+        change = False
+        for value in values:
+            change |= self.add(value)
+        return change
+
+    def set_epsilon(self, value=True):
+        last = self.contains_epsilon
+        self.contains_epsilon = value
+        return last != self.contains_epsilon
+
+    def update(self, other):
+        n = len(self.set)
+        self.set.update(other.set)
+        return n != len(self.set)
+
+    def epsilon_update(self, other):
+        return self.set_epsilon(self.contains_epsilon | other.contains_epsilon)
+
+    def hard_update(self, other):
+        return self.update(other) | self.epsilon_update(other)
+
+    def find_match(self, match):
+        for item in self.set:
+            if item == match:
+                return item
+        return None
+
+    def __len__(self):
+        return len(self.set) + int(self.contains_epsilon)
+
+    def __str__(self):
+        return '%s-%s' % (str(self.set), self.contains_epsilon)
+
+    def __repr__(self):
+        return str(self)
+
+    def __iter__(self):
+        return iter(self.set)
+
+    def __nonzero__(self):
+        return len(self) > 0
+
+    def __eq__(self, other):
+        if isinstance(other, set):
+            return self.set == other
+        return isinstance(other, ContainerSet) and self.set == other.set and self.contains_epsilon == other.contains_epsilon
+
+
+def inspect(item, grammar_name='G', mapper=None):
+    try:
+        return mapper[item]
+    except (TypeError, KeyError ):
+        if isinstance(item, dict):
+            items = ',\n   '.join(f'{inspect(key, grammar_name, mapper)}: {inspect(value, grammar_name, mapper)}' for key, value in item.items() )
+            return f'{{\n   {items} \n}}'
+        elif isinstance(item, ContainerSet):
+            args = f'{ ", ".join(inspect(x, grammar_name, mapper) for x in item.set) } ,' if item.set else ''
+            return f'ContainerSet({args} contains_epsilon={item.contains_epsilon})'
+        elif isinstance(item, EOF):
+            return f'{grammar_name}.EOF'
+        elif isinstance(item, Epsilon):
+            return f'{grammar_name}.Epsilon'
+        elif isinstance(item, Symbol):
+            return f"G['{item.Name}']"
+        elif isinstance(item, Sentence):
+            items = ', '.join(inspect(s, grammar_name, mapper) for s in item._symbols)
+            return f'Sentence({items})'
+        elif isinstance(item, Production):
+            left = inspect(item.Left, grammar_name, mapper)
+            right = inspect(item.Right, grammar_name, mapper)
+            return f'Production({left}, {right})'
+        elif isinstance(item, tuple) or isinstance(item, list):
+            ctor = ('(', ')') if isinstance(item, tuple) else ('[',']')
+            return f'{ctor[0]} {("%s, " * len(item)) % tuple(inspect(x, grammar_name, mapper) for x in item)}{ctor[1]}'
+        else:
+            raise ValueError(f'Invalid: {item}')
+
+def pprint(item, header=""):
+    if header:
+        print(header)
+
+    if isinstance(item, dict):
+        for key, value in item.items():
+            print(f'{key}  --->  {value}')
+    elif isinstance(item, list):
+        print('[')
+        for x in item:
+            print(f'   {repr(x)}')
+        print(']')
+    else:
+        print(item)
+
+class Token:
+    """
+    Basic token class.
+
+    Parameters
+    ----------
+    lex : str
+        Token's lexeme.
+    token_type : Enum
+        Token's type.
+    """
+
+    def __init__(self, lex, token_type):
+        self.lex = lex
+        self.token_type = token_type
+
+    def __str__(self):
+        return f'{self.token_type}: {self.lex}'
+
+    def __repr__(self):
+        return str(self)
+
+    @property
+    def is_valid(self):
+        return True
+
+class UnknownToken(Token):
+    def __init__(self, lex):
+        Token.__init__(self, lex, None)
+
+    def transform_to(self, token_type):
+        return Token(self.lex, token_type)
+
+    @property
+    def is_valid(self):
+        return False
+
+def tokenizer(G, fixed_tokens):
+    def decorate(func):
+        def tokenize_text(text):
+            tokens = []
+            for lex in text.split():
+                try:
+                    token = fixed_tokens[lex]
+                except KeyError:
+                    token = UnknownToken(lex)
+                    try:
+                        token = func(token)
+                    except TypeError:
+                        pass
+                tokens.append(token)
+            tokens.append(Token('$', G.EOF))
+            return tokens
+
+        if hasattr(func, '__call__'):
+            return tokenize_text
+        elif isinstance(func, str):
+            return tokenize_text(func)
+        else:
+            raise TypeError('Argument must be "str" or a callable object.')
+    return decorate
+
+class DisjointSet:
+    def __init__(self, *items):
+        self.nodes = { x: DisjointNode(x) for x in items }
+
+    def merge(self, items):
+        items = (self.nodes[x] for x in items)
+        try:
+            head, *others = items
+            for other in others:
+                head.merge(other)
+        except ValueError:
+            pass
+
+    @property
+    def representatives(self):
+        return { n.representative for n in self.nodes.values() }
+
+    @property
+    def groups(self):
+        return [[n for n in self.nodes.values() if n.representative == r] for r in self.representatives]
+
+    def __len__(self):
+        return len(self.representatives)
+
+    def __getitem__(self, item):
+        return self.nodes[item]
+
+    def __str__(self):
+        return str(self.groups)
+
+    def __repr__(self):
+        return str(self)
+
+class DisjointNode:
+    def __init__(self, value):
+        self.value = value
+        self.parent = self
+
+    @property
+    def representative(self):
+        if self.parent != self:
+            self.parent = self.parent.representative
+        return self.parent
+
+    def merge(self, other):
+        other.representative.parent = self.representative
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return str(self)
\ No newline at end of file
diff --git a/src/cmp/visitor.py b/src/cmp/visitor.py
new file mode 100644
index 000000000..964842836
--- /dev/null
+++ b/src/cmp/visitor.py
@@ -0,0 +1,80 @@
+# The MIT License (MIT)
+#
+# Copyright (c) 2013 Curtis Schlak
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import inspect
+
+__all__ = ['on', 'when']
+
+def on(param_name):
+  def f(fn):
+    dispatcher = Dispatcher(param_name, fn)
+    return dispatcher
+  return f
+
+
+def when(param_type):
+  def f(fn):
+    frame = inspect.currentframe().f_back
+    func_name = fn.func_name if 'func_name' in dir(fn) else fn.__name__
+    dispatcher = frame.f_locals[func_name]
+    if not isinstance(dispatcher, Dispatcher):
+      dispatcher = dispatcher.dispatcher
+    dispatcher.add_target(param_type, fn)
+    def ff(*args, **kw):
+      return dispatcher(*args, **kw)
+    ff.dispatcher = dispatcher
+    return ff
+  return f
+
+
+class Dispatcher(object):
+  def __init__(self, param_name, fn):
+    frame = inspect.currentframe().f_back.f_back
+    top_level = frame.f_locals == frame.f_globals
+    self.param_index = self.__argspec(fn).args.index(param_name)
+    self.param_name = param_name
+    self.targets = {}
+
+  def __call__(self, *args, **kw):
+    typ = args[self.param_index].__class__
+    d = self.targets.get(typ)
+    if d is not None:
+      return d(*args, **kw)
+    else:
+      issub = issubclass
+      t = self.targets
+      ks = t.keys()
+      ans = [t[k](*args, **kw) for k in ks if issub(typ, k)]
+      if len(ans) == 1:
+        return ans.pop()
+      return ans
+
+  def add_target(self, typ, target):
+    self.targets[typ] = target
+
+  @staticmethod
+  def __argspec(fn):
+    # Support for Python 3 type hints requires inspect.getfullargspec
+    if hasattr(inspect, 'getfullargspec'):
+      return inspect.getfullargspec(fn)
+    else:
+      return inspect.getargspec(fn)

From c212a4168c2bf02ad359d35eef905ffed77401a9 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 13 Dec 2021 18:16:29 -0800
Subject: [PATCH 02/83] Lexer

---
 src/utils/COOL_Lexer.py | 209 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 209 insertions(+)
 create mode 100644 src/utils/COOL_Lexer.py

diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
new file mode 100644
index 000000000..2d53d4307
--- /dev/null
+++ b/src/utils/COOL_Lexer.py
@@ -0,0 +1,209 @@
+import re
+import sys
+
+'''
+Recibe como parametros el lexema, tipo, linea y columna donde se encuentra
+'''
+class Token:
+ 
+    def __init__(self, lex, ttype, line, column): 
+        
+        self.lex = lex 
+        self.token_type = ttype
+        self.line = line
+        self.column = column
+ 
+    def __str__(self): 
+        return f'{self.ttype}: {self.lex}'
+ 
+'''
+El lexer es el resultado de la union de todas las expresiones regulares que forman
+el lenguaje
+'''
+class Lexer: 
+
+    def __init__(self, table, keywords, ignored_tokens, eof):
+        self.line = 1
+        self.column = 0
+        self.table = table
+        self.keywords = keywords
+        self.ignored_tokens = ignored_tokens
+        self.regex = self._build_regex(table)
+        self.errors = []
+        self.eof = eof
+ 
+    def tokenize(self,text):    
+        while len(text) > 0:
+
+            match = self.regex.match(text)
+            error_token = ''
+ 
+            while not match:
+                error_token += text[0]
+                text = text[1:]
+                if len(text) <= 0: break
+                match = self.regex.match(text)
+
+            if error_token:
+                self.errors.append(f'({self.line}, {self.column + 1}) - LexicographicError: ERROR "{error_token}"')
+                self.column += len(error_token)
+                if len(text) <= 0: continue
+
+            lexeme = match.group()
+            self.column += len(lexeme)
+
+            if lexeme == '\n':
+                self.line += 1
+                self.column = 0
+
+            # COMMENTS
+            elif lexeme == '(*':
+                text = text[2:]
+                openx = 1
+
+                while len(text) > 0:
+                    lexeme += text[0]
+                    text = text[1:]
+                    self.column += 1
+
+                    if lexeme[-1] == '\n':
+                        self.line += 1
+                        self.column = 0
+
+                    elif lexeme[-2:] == '(*':
+                        openx += 1
+
+                    elif lexeme[-2:] == '*)':
+                        openx -= 1
+                        if openx == 0:
+                            break
+
+                else:
+                    self.errors.append(f'({self.line}, {self.column + 1}) - LexicographicError: EOF in comment')
+
+            # STRINGS
+            elif lexeme == '"':
+                text = text[1:]
+                while len(text) > 0:
+                    c = text[0]
+                    text = text[1:]
+                    self.column += 1
+
+                    if c == '\\':
+                        if text[0] == '\n':
+                            lexeme += '\n'
+                            self.line += 1
+                            self.column = 0
+
+                        elif text[0] == 'b':
+                            lexeme += '\\b'
+
+                        elif text[0] == 't':
+                            lexeme += '\\t'
+
+                        elif text[0] == 'n':
+                            lexeme += '\\n'
+
+                        elif text[0] == 'f':
+                            lexeme += '\\f'
+                        
+                        else:
+                            lexeme += text[0]
+
+                        text = text[1:]
+                        self.column += 1
+                    
+                    elif c == '\n':
+                        self.errors.append(f'({self.line}, {self.column}) - LexicographicError: Unterminated string constant')
+                        self.line += 1
+                        self.column = 0
+                        break
+                    
+                    elif c == '\0':
+                        self.errors.append(f'({self.line}, {self.column}) - LexicographicError: String contains null character')
+                    
+                    else:
+                        lexeme += c
+                        if c == '"':
+                            break
+                
+                else:
+                    self.errors.append(f'({self.line}, {self.column + 1}) - LexicographicError: EOF in string constant')
+
+
+
+            token_type = match.lastgroup if lexeme.lower() not in self.keywords and match.lastgroup is not None else match.group().lower()
+
+            a = self.column - len(lexeme) + 1 if lexeme[:2] != '(*' and lexeme[0] != '"' else self.column
+            yield lexeme, token_type, self.line, self.column - len(lexeme) + 1 if lexeme[:2] != '(*' and lexeme[0] != '"' else self.column 
+ 
+            text = text[match.end():] if lexeme[:2] != '(*' and lexeme[0] != '"' else text
+
+        yield '$', self.eof, self.line, 1
+ 
+    def _build_regex(sef,table):
+        return re.compile('|'.join([f'(?P<{name}>{regex})' if name != regex else f'({name})' for name,regex in table.items()]))
+ 
+    def __call__(self, text): 
+        return [Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens]
+
+
+'''
+Esta clase guardara las propiedades sintacticas de COOL
+'''
+class COOL_Lexer(Lexer):
+    def __init__(self):
+        self.regexs = {
+        'id'        : r'[a-z][a-zA-Z0-9_]*'         ,
+        'type'      : r'[A-Z][a-zA-Z0-9_]*'         ,
+        'string'    : r'\"'                         ,
+        'int'       : r'\d+'                        ,
+        'comment'   : r'(\(\*)|--.*'                ,
+        'newline'   : r'\n'                         ,
+        'whitespace': r' +'                         ,
+        'tabulation': r'\t+'                        ,
+        'inherits'  : r'inherits'                   ,
+        'isvoid'    : r'isvoid'                     ,
+        'class'     : r'class'                      ,
+        'while'     : r'while'                      , 
+        'false'     : r'false'                      , 
+        'then'      : r'then'                       , 
+        'else'      : r'else'                       , 
+        'loop'      : r'loop'                       ,
+        'pool'      : r'pool'                       , 
+        'case'      : r'case'                       , 
+        'esac'      : r'esac'                       ,
+        'true'      : r'true'                       , 
+        '<\-'       : r'<\-'                        ,
+        'let'       : r'let'                        , 
+        'new'       : r'new'                        ,
+        'not'       : r'not'                        ,
+        '\{'        : r'\{'                         ,
+        '\}'        : r'\}'                         ,
+        '\('        : r'\('                         ,
+        '\)'        : r'\)'                         ,
+        '\.'        : r'\.'                         , 
+        '=>'        : r'=>'                         ,
+        'if'        : r'if'                         ,
+        'fi'        : r'fi'                         , 
+        'in'        : r'in'                         ,
+        'of'        : r'of'                         , 
+        '\+'        : r'\+'                         , 
+        '\-'        : r'\-'                         , 
+        '\*'        : r'\*'                         , 
+        '<='        : r'<='                         , 
+        '\~'        : r'\~'                         ,
+        ','         : r','                          , 
+        ':'         : r':'                          , 
+        ';'         : r';'                          , 
+        '@'         : r'@'                          ,
+        '/'         : r'/'                          , 
+        '<'         : r'<'                          , 
+        '='         : r'='                          }
+
+        self.keywords = ['inherits','isvoid','class','while','false','then','else','loop',
+        'pool','case','esac','true','let','new','not','if','fi','in','of']
+
+        self.ignored_tokens = ['newline','whitespace','tabulation','comment']
+
+        Lexer.__init__(self, self.regexs, self.keywords, self.ignored_tokens, 'eof')
\ No newline at end of file

From f5ce791c2d831a3f8fd49aa0e63b3997512b9d6e Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 13 Dec 2021 18:19:12 -0800
Subject: [PATCH 03/83] cool grammar

---
 src/utils/COOL_Grammar.py | 109 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 src/utils/COOL_Grammar.py

diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
new file mode 100644
index 000000000..1bd287126
--- /dev/null
+++ b/src/utils/COOL_Grammar.py
@@ -0,0 +1,109 @@
+from cmp.pycompiler import Grammar
+from utils.ast.AST_Nodes import ast_nodes as node
+
+def build_COOL_Grammar():
+    # gramatica
+    G = Grammar()
+    
+    # no terminales
+    program = G.NonTerminal('<program>', startSymbol=True)
+    class_list, def_class, param_list, param = G.NonTerminals('<class-list> <def-class> <param-list> <param>')
+    feature_list, def_attr, def_meth, arg_list = G.NonTerminals('<feature-list> <def-attr> <def-meth> <arg-list>')
+    expr, expr_list, id_list, case_list, comp = G.NonTerminals('<expr> <expr-list> <id-list> <case-list> <comp>')
+    expr, arith, term, factor, atom, dispatch = G.NonTerminals('<expr> <arith> <term> <factor> <atom> <dispatch>')
+    not_empty = G.NonTerminal('<not_empty>')
+
+    #terminales
+    classx, let, inx = G.Terminals('class let in')
+    semi, colon, arrow, comma, dot, opar, cpar, ocur, ccur, darrow = G.Terminals('; : <- , . ( ) { } =>')
+    equal, plus, minus, star, div, less, lesse, tilde, at = G.Terminals('= + - * / < <= ~ @')
+    typex, inherits, idx, whilex, loop, pool, num, new = G.Terminals('type inherits id while loop pool int new')
+    ifx, then, elsex, fi, case, esac, of, notx, isvoid = G.Terminals('if then else fi case esac of not isvoid')
+    true, false, string = G.Terminals('true false string')
+
+
+    #produciones
+    program %= class_list, lambda h,s: node.ProgramNode(s[1])
+
+    class_list %= def_class + semi, lambda h,s: [s[1]]
+    class_list %= def_class + semi + class_list, lambda h,s: [s[1]] + s[3]
+
+    def_class %= classx + typex + ocur + feature_list + ccur, lambda h,s: node.ClassDeclarationNode(s[2],s[4])
+    def_class %= classx + typex + inherits + typex + ocur + feature_list + ccur, lambda h,s: node.ClassDeclarationNode(s[2],s[6],s[4])
+
+    feature_list %= def_attr + semi + feature_list, lambda h,s: [s[1]] + s[3]
+    feature_list %= def_meth + semi + feature_list, lambda h,s: [s[1]] + s[3]
+    feature_list %= G.Epsilon, lambda h,s: []
+
+    def_attr %= idx + colon + typex, lambda h,s: node.AttrDeclarationNode(s[1],s[3])
+    def_attr %= idx + colon + typex + arrow + expr, lambda h,s: node.AttrDeclarationNode(s[1],s[3],s[5])
+
+    def_meth %= idx + opar + param_list + cpar + colon + typex + ocur + expr + ccur, lambda h,s: node.MethDeclarationNode(s[1],s[3],s[6],s[8])
+
+    param_list %= param, lambda h,s: [s[1]]
+    param_list %= param + comma + param_list, lambda h,s: [s[1]] + s[3]
+    param_list %= G.Epsilon, lambda h,s: []
+
+    param %= idx + colon + typex, lambda h,s: [s[1],s[3]]
+
+    expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3])
+    expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6])
+    expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4])
+    expr %= notx + expr, lambda h,s: node.NotNode(s[2])
+
+    expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2])
+
+    expr_list %= expr + semi, lambda h,s: [s[1]]
+    expr_list %= expr + semi + expr_list, lambda h,s: [s[1]] + s[3]
+    
+    expr %= let + id_list + inx + expr, lambda h,s: node.LetNode(s[2],s[4])
+
+    id_list %= idx + colon + typex, lambda h,s: [(s[1],s[3],None)]
+    id_list %= idx + colon + typex + arrow + expr, lambda h,s: [(s[1],s[3],s[5])]
+    id_list %= idx + colon + typex + comma + id_list, lambda h,s: [(s[1],s[3],None)] + s[5]
+    id_list %= idx + colon + typex + arrow + expr + comma + id_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]
+
+    expr %= case + expr + of + case_list + esac, lambda h,s: node.CaseNode(s[2],s[4])
+
+    case_list %= idx + colon + typex + darrow + expr + semi, lambda h,s: [(s[1],s[3],s[5])]
+    case_list %= idx + colon + typex + darrow + expr + semi + case_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]
+
+    expr %= comp, lambda h,s: s[1]
+
+    comp %= comp + less + arith, lambda h,s: node.LessThanNode(s[1],s[3])
+    comp %= comp + lesse + arith, lambda h,s: node.LessEqualNode(s[1],s[3])
+    comp %= comp + equal + arith, lambda h,s: node.EqualNode(s[1],s[3])
+    comp %= arith, lambda h,s: s[1]
+
+    arith %= arith + plus + term, lambda h,s: node.PlusNode(s[1],s[3])
+    arith %= arith + minus + term, lambda h,s: node.MinusNode(s[1],s[3])
+    arith %= term, lambda h,s:s[1]
+
+    term %= term + star + factor, lambda h,s: node.StarNode(s[1],s[3])
+    term %= term + div + factor, lambda h,s: node.DivNode(s[1],s[3])
+    term %= factor, lambda h,s: s[1]
+
+    factor %= isvoid + factor, lambda h,s: node.IsVoidNode(s[2])
+    factor %= tilde + factor, lambda h,s: node.ComplementNode(s[2])
+    factor %= atom, lambda h,s: s[1]
+
+    atom %= true, lambda h,s: node.ConstantBoolNode(s[1])
+    atom %= false, lambda h,s: node.ConstantBoolNode(s[1])
+    atom %= string, lambda h,s: node.ConstantStringNode(s[1])
+    atom %= num, lambda h,s: node.ConstantNumNode(s[1])
+    atom %= idx, lambda h,s: node.VariableNode(s[1])
+    atom %= new + typex, lambda h,s: node.InstantiateNode(s[2])
+    atom %= opar + expr + cpar, lambda h,s: s[2]
+    atom %= dispatch, lambda h,s: s[1]
+
+    dispatch %= atom + dot + idx + opar + arg_list + cpar, lambda h,s: node.CallNode(s[3],s[5],s[1])
+    dispatch %= idx + opar + arg_list + cpar, lambda h,s: node.CallNode(s[1],s[3])
+    dispatch %= atom + at + typex + dot + idx + opar + arg_list + cpar, lambda h,s: node.CallNode(s[5],s[7],s[1],s[3])
+
+    arg_list %= expr, lambda h,s: [s[1]]
+    arg_list %= expr + comma + arg_list, lambda h,s: [s[1]] + s[3]
+    arg_list %= G.Epsilon, lambda h,s: []
+
+    return G
+
+

From f2048437af81ae85ba23bd2a5606a86493d5c54c Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 13 Dec 2021 18:22:30 -0800
Subject: [PATCH 04/83] ast

---
 src/utils/ast/AST_Nodes.py | 116 +++++++++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)
 create mode 100644 src/utils/ast/AST_Nodes.py

diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
new file mode 100644
index 000000000..009e17348
--- /dev/null
+++ b/src/utils/ast/AST_Nodes.py
@@ -0,0 +1,116 @@
+class ast_nodes:
+
+    class Node:
+        pass
+
+
+    class ProgramNode(Node):
+        def __init__(self, declarations):
+            self.declarations = declarations
+
+    class DeclarationNode(Node):
+        pass
+    class ExpressionNode(Node):
+        pass
+
+
+    class ClassDeclarationNode(DeclarationNode):
+        def __init__(self, idx, features, parent=None):
+            self.id = idx
+            self.parent = parent
+            self.features = features
+
+    class MethDeclarationNode(DeclarationNode):
+        def __init__(self, idx, params, return_type, body):
+            self.id = idx
+            self.params = params
+            self.type = return_type
+            self.body = body
+
+    class AttrDeclarationNode(DeclarationNode):
+        def __init__(self, idx, typex, expr = None):
+            self.id = idx
+            self.type = typex
+            self.expr = expr
+
+    class AssignNode(ExpressionNode):
+        def __init__(self, idx, expr):
+            self.id = idx
+            self.expr = expr
+
+    class CallNode(ExpressionNode):
+        def __init__(self, idx, args, obj = None, typex = None):
+            self.obj = obj
+            self.type = typex
+            self.id = idx
+            self.args = args
+    
+    class IfThenElseNode(ExpressionNode):
+        def __init__(self, if_expr, then_expr, else_expr):
+            self.if_expr = if_expr
+            self.then_expr = then_expr
+            self.else_expr = else_expr
+    
+    class WhileNode(ExpressionNode):
+        def __init__(self, conditional_expr, loop_expr):
+            self.conditional_expr = conditional_expr
+            self.loop_expr = loop_expr
+
+    class BlockNode(ExpressionNode):
+        def __init__(self, expr_list):
+            self.expr_list = expr_list
+    
+    class LetNode(ExpressionNode):
+        def __init__(self, identifiers, in_expr):
+            self.identifiers = identifiers
+            self.in_expr = in_expr
+
+    class CaseNode(ExpressionNode):
+        def __init__(self, predicate, branches):
+            self.predicate = predicate
+            self.branches = branches
+    
+    class NotNode(ExpressionNode):
+        def __init__(self, expr):
+            self.expr = expr
+
+    class AtomicNode(ExpressionNode):
+        def __init__(self, lex):
+            self.lex = lex
+
+    class BinaryNode(ExpressionNode):
+        def __init__(self, left, right):
+            self.left = left
+            self.right = right
+
+
+    class ConstantNumNode(AtomicNode):
+        pass
+    class ConstantBoolNode(AtomicNode):
+        pass
+    class ConstantStringNode(AtomicNode):
+        pass
+    class VariableNode(AtomicNode):
+        pass
+    class InstantiateNode(AtomicNode):
+        pass
+    class IsVoidNode(AtomicNode):
+        pass
+    class ComplementNode(AtomicNode):
+        pass
+
+
+    class PlusNode(BinaryNode):
+        pass
+    class MinusNode(BinaryNode):
+        pass
+    class StarNode(BinaryNode):
+        pass
+    class DivNode(BinaryNode):
+        pass
+    class LessThanNode(BinaryNode):
+        pass
+    class LessEqualNode(BinaryNode):
+        pass
+    class EqualNode(BinaryNode):
+        pass
\ No newline at end of file

From 84c7c4c3781eb6243439153abaef5021f81b498c Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 13 Dec 2021 22:43:56 -0800
Subject: [PATCH 05/83] parser

---
 src/utils/parser/COOL_parser.py         | 1284 +++++++++++++++++++++++
 src/utils/parser/LALR_1.py              |   64 ++
 src/utils/parser/LR_1.py                |  136 +++
 src/utils/parser/parser.py              |  130 +++
 src/utils/parser/shift_reduce_parser.py |   65 ++
 5 files changed, 1679 insertions(+)
 create mode 100644 src/utils/parser/COOL_parser.py
 create mode 100644 src/utils/parser/LALR_1.py
 create mode 100644 src/utils/parser/LR_1.py
 create mode 100644 src/utils/parser/parser.py
 create mode 100644 src/utils/parser/shift_reduce_parser.py

diff --git a/src/utils/parser/COOL_parser.py b/src/utils/parser/COOL_parser.py
new file mode 100644
index 000000000..7966d556b
--- /dev/null
+++ b/src/utils/parser/COOL_parser.py
@@ -0,0 +1,1284 @@
+from utils.parser.shift_reduce_parser import ShiftReduceParser
+
+'''
+Las tablas action y goto del parser lalr1 se precompilaron porque demora mucho su calculo
+El algoritmo para copiarlas fue el siguiente:
+
+###code###
+parser = LALR1_Parser(G)
+
+with open('action.txt','w') as action:
+    for key,value in parser.action.items():
+        action.write(f'{key} : {value},\n')
+
+with open('goto.txt','w') as goto:
+    for key,value in parser.goto.items():
+        goto.write(f'{key} : {value},\n')
+#### ### ### ##
+'''
+
+class COOL_Parser(ShiftReduceParser):
+    
+    def __init__(self, G):
+        self.action = {
+        (0, 'class') : ('SHIFT', 1),
+        (1, 'type') : ('SHIFT', 2),
+        (2, '{') : ('SHIFT', 3),
+        (2, 'inherits') : ('SHIFT', 131),
+        (3, 'id') : ('SHIFT', 4),
+        (3, '}') : ('REDUCE', 7),
+        (4, ':') : ('SHIFT', 5),
+        (4, '(') : ('SHIFT', 109),
+        (5, 'type') : ('SHIFT', 6),
+        (6, ';') : ('REDUCE', 8),
+        (6, '<-') : ('SHIFT', 7),
+        (7, 'if') : ('SHIFT', 24),
+        (7, 'not') : ('SHIFT', 26),
+        (7, 'id') : ('SHIFT', 18),
+        (7, 'false') : ('SHIFT', 29),
+        (7, 'int') : ('SHIFT', 21),
+        (7, 'string') : ('SHIFT', 30),
+        (7, '(') : ('SHIFT', 13),
+        (7, 'true') : ('SHIFT', 28),
+        (7, 'let') : ('SHIFT', 8),
+        (7, 'isvoid') : ('SHIFT', 27),
+        (7, '~') : ('SHIFT', 15),
+        (7, 'case') : ('SHIFT', 25),
+        (7, '{') : ('SHIFT', 14),
+        (7, 'new') : ('SHIFT', 22),
+        (7, 'while') : ('SHIFT', 20),
+        (8, 'id') : ('SHIFT', 9),
+        (9, ':') : ('SHIFT', 10),
+        (10, 'type') : ('SHIFT', 11),
+        (11, '<-') : ('SHIFT', 12),
+        (11, 'in') : ('REDUCE', 23),
+        (11, ',') : ('SHIFT', 103),
+        (12, 'case') : ('SHIFT', 25),
+        (12, '{') : ('SHIFT', 14),
+        (12, '~') : ('SHIFT', 15),
+        (12, 'int') : ('SHIFT', 21),
+        (12, 'while') : ('SHIFT', 20),
+        (12, 'id') : ('SHIFT', 18),
+        (12, '(') : ('SHIFT', 13),
+        (12, 'true') : ('SHIFT', 28),
+        (12, 'if') : ('SHIFT', 24),
+        (12, 'not') : ('SHIFT', 26),
+        (12, 'false') : ('SHIFT', 29),
+        (12, 'isvoid') : ('SHIFT', 27),
+        (12, 'string') : ('SHIFT', 30),
+        (12, 'new') : ('SHIFT', 22),
+        (12, 'let') : ('SHIFT', 8),
+        (13, 'true') : ('SHIFT', 28),
+        (13, 'id') : ('SHIFT', 18),
+        (13, 'false') : ('SHIFT', 29),
+        (13, 'let') : ('SHIFT', 8),
+        (13, 'int') : ('SHIFT', 21),
+        (13, 'string') : ('SHIFT', 30),
+        (13, '(') : ('SHIFT', 13),
+        (13, 'case') : ('SHIFT', 25),
+        (13, '{') : ('SHIFT', 14),
+        (13, 'while') : ('SHIFT', 20),
+        (13, 'isvoid') : ('SHIFT', 27),
+        (13, '~') : ('SHIFT', 15),
+        (13, 'if') : ('SHIFT', 24),
+        (13, 'not') : ('SHIFT', 26),
+        (13, 'new') : ('SHIFT', 22),
+        (14, 'if') : ('SHIFT', 24),
+        (14, 'not') : ('SHIFT', 26),
+        (14, 'false') : ('SHIFT', 29),
+        (14, 'id') : ('SHIFT', 18),
+        (14, 'int') : ('SHIFT', 21),
+        (14, 'string') : ('SHIFT', 30),
+        (14, '(') : ('SHIFT', 13),
+        (14, 'true') : ('SHIFT', 28),
+        (14, 'let') : ('SHIFT', 8),
+        (14, 'isvoid') : ('SHIFT', 27),
+        (14, '~') : ('SHIFT', 15),
+        (14, 'case') : ('SHIFT', 25),
+        (14, '{') : ('SHIFT', 14),
+        (14, 'new') : ('SHIFT', 22),
+        (14, 'while') : ('SHIFT', 20),
+        (15, 'id') : ('SHIFT', 16),
+        (15, 'false') : ('SHIFT', 29),
+        (15, 'string') : ('SHIFT', 30),
+        (15, 'true') : ('SHIFT', 28),
+        (15, 'int') : ('SHIFT', 21),
+        (15, 'isvoid') : ('SHIFT', 27),
+        (15, '~') : ('SHIFT', 15),
+        (15, '(') : ('SHIFT', 13),
+        (15, 'new') : ('SHIFT', 22),
+        (16, 'then') : ('REDUCE', 48),
+        (16, 'else') : ('REDUCE', 48),
+        (16, 'fi') : ('REDUCE', 48),
+        (16, 'of') : ('REDUCE', 48),
+        (16, 'in') : ('REDUCE', 48),
+        (16, ';') : ('REDUCE', 48),
+        (16, ',') : ('REDUCE', 48),
+        (16, '.') : ('REDUCE', 48),
+        (16, ')') : ('REDUCE', 48),
+        (16, '}') : ('REDUCE', 48),
+        (16, '=') : ('REDUCE', 48),
+        (16, '+') : ('REDUCE', 48),
+        (16, '-') : ('REDUCE', 48),
+        (16, '*') : ('REDUCE', 48),
+        (16, '/') : ('REDUCE', 48),
+        (16, '<') : ('REDUCE', 48),
+        (16, '<=') : ('REDUCE', 48),
+        (16, '@') : ('REDUCE', 48),
+        (16, 'loop') : ('REDUCE', 48),
+        (16, 'pool') : ('REDUCE', 48),
+        (16, '(') : ('SHIFT', 17),
+        (17, 'while') : ('SHIFT', 20),
+        (17, 'id') : ('SHIFT', 18),
+        (17, 'new') : ('SHIFT', 22),
+        (17, '~') : ('SHIFT', 15),
+        (17, 'case') : ('SHIFT', 25),
+        (17, 'if') : ('SHIFT', 24),
+        (17, 'not') : ('SHIFT', 26),
+        (17, 'true') : ('SHIFT', 28),
+        (17, 'false') : ('SHIFT', 29),
+        (17, 'int') : ('SHIFT', 21),
+        (17, 'string') : ('SHIFT', 30),
+        (17, 'isvoid') : ('SHIFT', 27),
+        (17, '(') : ('SHIFT', 13),
+        (17, ')') : ('REDUCE', 57),
+        (17, 'let') : ('SHIFT', 8),
+        (17, '{') : ('SHIFT', 14),
+        (18, '(') : ('SHIFT', 17),
+        (18, 'then') : ('REDUCE', 48),
+        (18, 'else') : ('REDUCE', 48),
+        (18, 'fi') : ('REDUCE', 48),
+        (18, 'of') : ('REDUCE', 48),
+        (18, 'in') : ('REDUCE', 48),
+        (18, ';') : ('REDUCE', 48),
+        (18, ',') : ('REDUCE', 48),
+        (18, '.') : ('REDUCE', 48),
+        (18, ')') : ('REDUCE', 48),
+        (18, '}') : ('REDUCE', 48),
+        (18, '=') : ('REDUCE', 48),
+        (18, '+') : ('REDUCE', 48),
+        (18, '-') : ('REDUCE', 48),
+        (18, '*') : ('REDUCE', 48),
+        (18, '/') : ('REDUCE', 48),
+        (18, '<') : ('REDUCE', 48),
+        (18, '<=') : ('REDUCE', 48),
+        (18, '@') : ('REDUCE', 48),
+        (18, 'loop') : ('REDUCE', 48),
+        (18, 'pool') : ('REDUCE', 48),
+        (18, '<-') : ('SHIFT', 19),
+        (19, 'id') : ('SHIFT', 18),
+        (19, 'false') : ('SHIFT', 29),
+        (19, 'let') : ('SHIFT', 8),
+        (19, 'string') : ('SHIFT', 30),
+        (19, 'isvoid') : ('SHIFT', 27),
+        (19, 'case') : ('SHIFT', 25),
+        (19, '~') : ('SHIFT', 15),
+        (19, '{') : ('SHIFT', 14),
+        (19, 'new') : ('SHIFT', 22),
+        (19, 'while') : ('SHIFT', 20),
+        (19, 'if') : ('SHIFT', 24),
+        (19, 'not') : ('SHIFT', 26),
+        (19, 'int') : ('SHIFT', 21),
+        (19, '(') : ('SHIFT', 13),
+        (19, 'true') : ('SHIFT', 28),
+        (20, 'id') : ('SHIFT', 18),
+        (20, 'true') : ('SHIFT', 28),
+        (20, 'false') : ('SHIFT', 29),
+        (20, 'if') : ('SHIFT', 24),
+        (20, 'not') : ('SHIFT', 26),
+        (20, 'let') : ('SHIFT', 8),
+        (20, 'string') : ('SHIFT', 30),
+        (20, 'new') : ('SHIFT', 22),
+        (20, '{') : ('SHIFT', 14),
+        (20, 'isvoid') : ('SHIFT', 27),
+        (20, '~') : ('SHIFT', 15),
+        (20, 'case') : ('SHIFT', 25),
+        (20, 'int') : ('SHIFT', 21),
+        (20, '(') : ('SHIFT', 13),
+        (20, 'while') : ('SHIFT', 20),
+        (21, 'then') : ('REDUCE', 47),
+        (21, 'else') : ('REDUCE', 47),
+        (21, 'fi') : ('REDUCE', 47),
+        (21, 'of') : ('REDUCE', 47),
+        (21, 'in') : ('REDUCE', 47),
+        (21, ';') : ('REDUCE', 47),
+        (21, ',') : ('REDUCE', 47),
+        (21, '.') : ('REDUCE', 47),
+        (21, ')') : ('REDUCE', 47),
+        (21, '}') : ('REDUCE', 47),
+        (21, '=') : ('REDUCE', 47),
+        (21, '+') : ('REDUCE', 47),
+        (21, '-') : ('REDUCE', 47),
+        (21, '*') : ('REDUCE', 47),
+        (21, '/') : ('REDUCE', 47),
+        (21, '<') : ('REDUCE', 47),
+        (21, '<=') : ('REDUCE', 47),
+        (21, '@') : ('REDUCE', 47),
+        (21, 'loop') : ('REDUCE', 47),
+        (21, 'pool') : ('REDUCE', 47),
+        (22, 'type') : ('SHIFT', 23),
+        (23, 'then') : ('REDUCE', 49),
+        (23, 'else') : ('REDUCE', 49),
+        (23, 'fi') : ('REDUCE', 49),
+        (23, 'of') : ('REDUCE', 49),
+        (23, 'in') : ('REDUCE', 49),
+        (23, ';') : ('REDUCE', 49),
+        (23, ',') : ('REDUCE', 49),
+        (23, '.') : ('REDUCE', 49),
+        (23, ')') : ('REDUCE', 49),
+        (23, '}') : ('REDUCE', 49),
+        (23, '=') : ('REDUCE', 49),
+        (23, '+') : ('REDUCE', 49),
+        (23, '-') : ('REDUCE', 49),
+        (23, '*') : ('REDUCE', 49),
+        (23, '/') : ('REDUCE', 49),
+        (23, '<') : ('REDUCE', 49),
+        (23, '<=') : ('REDUCE', 49),
+        (23, '@') : ('REDUCE', 49),
+        (23, 'loop') : ('REDUCE', 49),
+        (23, 'pool') : ('REDUCE', 49),
+        (24, 'not') : ('SHIFT', 26),
+        (24, 'true') : ('SHIFT', 28),
+        (24, 'string') : ('SHIFT', 30),
+        (24, 'let') : ('SHIFT', 8),
+        (24, 'id') : ('SHIFT', 18),
+        (24, 'new') : ('SHIFT', 22),
+        (24, 'isvoid') : ('SHIFT', 27),
+        (24, '~') : ('SHIFT', 15),
+        (24, 'case') : ('SHIFT', 25),
+        (24, '{') : ('SHIFT', 14),
+        (24, 'while') : ('SHIFT', 20),
+        (24, 'false') : ('SHIFT', 29),
+        (24, 'int') : ('SHIFT', 21),
+        (24, '(') : ('SHIFT', 13),
+        (24, 'if') : ('SHIFT', 24),
+        (25, 'while') : ('SHIFT', 20),
+        (25, 'true') : ('SHIFT', 28),
+        (25, 'false') : ('SHIFT', 29),
+        (25, 'id') : ('SHIFT', 18),
+        (25, 'int') : ('SHIFT', 21),
+        (25, 'let') : ('SHIFT', 8),
+        (25, 'string') : ('SHIFT', 30),
+        (25, 'isvoid') : ('SHIFT', 27),
+        (25, '~') : ('SHIFT', 15),
+        (25, 'new') : ('SHIFT', 22),
+        (25, '{') : ('SHIFT', 14),
+        (25, 'case') : ('SHIFT', 25),
+        (25, 'if') : ('SHIFT', 24),
+        (25, 'not') : ('SHIFT', 26),
+        (25, '(') : ('SHIFT', 13),
+        (26, 'id') : ('SHIFT', 18),
+        (26, 'false') : ('SHIFT', 29),
+        (26, 'let') : ('SHIFT', 8),
+        (26, 'string') : ('SHIFT', 30),
+        (26, 'isvoid') : ('SHIFT', 27),
+        (26, '~') : ('SHIFT', 15),
+        (26, 'case') : ('SHIFT', 25),
+        (26, '{') : ('SHIFT', 14),
+        (26, 'new') : ('SHIFT', 22),
+        (26, 'while') : ('SHIFT', 20),
+        (26, 'if') : ('SHIFT', 24),
+        (26, 'not') : ('SHIFT', 26),
+        (26, 'int') : ('SHIFT', 21),
+        (26, '(') : ('SHIFT', 13),
+        (26, 'true') : ('SHIFT', 28),
+        (27, 'id') : ('SHIFT', 16),
+        (27, 'false') : ('SHIFT', 29),
+        (27, 'string') : ('SHIFT', 30),
+        (27, 'true') : ('SHIFT', 28),
+        (27, 'int') : ('SHIFT', 21),
+        (27, 'isvoid') : ('SHIFT', 27),
+        (27, '~') : ('SHIFT', 15),
+        (27, '(') : ('SHIFT', 13),
+        (27, 'new') : ('SHIFT', 22),
+        (28, 'then') : ('REDUCE', 44),
+        (28, 'else') : ('REDUCE', 44),
+        (28, 'fi') : ('REDUCE', 44),
+        (28, 'of') : ('REDUCE', 44),
+        (28, 'in') : ('REDUCE', 44),
+        (28, ';') : ('REDUCE', 44),
+        (28, ',') : ('REDUCE', 44),
+        (28, '.') : ('REDUCE', 44),
+        (28, ')') : ('REDUCE', 44),
+        (28, '}') : ('REDUCE', 44),
+        (28, '=') : ('REDUCE', 44),
+        (28, '+') : ('REDUCE', 44),
+        (28, '-') : ('REDUCE', 44),
+        (28, '*') : ('REDUCE', 44),
+        (28, '/') : ('REDUCE', 44),
+        (28, '<') : ('REDUCE', 44),
+        (28, '<=') : ('REDUCE', 44),
+        (28, '@') : ('REDUCE', 44),
+        (28, 'loop') : ('REDUCE', 44),
+        (28, 'pool') : ('REDUCE', 44),
+        (29, 'then') : ('REDUCE', 45),
+        (29, 'else') : ('REDUCE', 45),
+        (29, 'fi') : ('REDUCE', 45),
+        (29, 'of') : ('REDUCE', 45),
+        (29, 'in') : ('REDUCE', 45),
+        (29, ';') : ('REDUCE', 45),
+        (29, ',') : ('REDUCE', 45),
+        (29, '.') : ('REDUCE', 45),
+        (29, ')') : ('REDUCE', 45),
+        (29, '}') : ('REDUCE', 45),
+        (29, '=') : ('REDUCE', 45),
+        (29, '+') : ('REDUCE', 45),
+        (29, '-') : ('REDUCE', 45),
+        (29, '*') : ('REDUCE', 45),
+        (29, '/') : ('REDUCE', 45),
+        (29, '<') : ('REDUCE', 45),
+        (29, '<=') : ('REDUCE', 45),
+        (29, '@') : ('REDUCE', 45),
+        (29, 'loop') : ('REDUCE', 45),
+        (29, 'pool') : ('REDUCE', 45),
+        (30, 'then') : ('REDUCE', 46),
+        (30, 'else') : ('REDUCE', 46),
+        (30, 'fi') : ('REDUCE', 46),
+        (30, 'of') : ('REDUCE', 46),
+        (30, 'in') : ('REDUCE', 46),
+        (30, ';') : ('REDUCE', 46),
+        (30, ',') : ('REDUCE', 46),
+        (30, '.') : ('REDUCE', 46),
+        (30, ')') : ('REDUCE', 46),
+        (30, '}') : ('REDUCE', 46),
+        (30, '=') : ('REDUCE', 46),
+        (30, '+') : ('REDUCE', 46),
+        (30, '-') : ('REDUCE', 46),
+        (30, '*') : ('REDUCE', 46),
+        (30, '/') : ('REDUCE', 46),
+        (30, '<') : ('REDUCE', 46),
+        (30, '<=') : ('REDUCE', 46),
+        (30, '@') : ('REDUCE', 46),
+        (30, 'loop') : ('REDUCE', 46),
+        (30, 'pool') : ('REDUCE', 46),
+        (31, '<') : ('REDUCE', 41),
+        (31, '<=') : ('REDUCE', 41),
+        (31, ')') : ('REDUCE', 41),
+        (31, 'then') : ('REDUCE', 41),
+        (31, '}') : ('REDUCE', 41),
+        (31, 'else') : ('REDUCE', 41),
+        (31, 'fi') : ('REDUCE', 41),
+        (31, '=') : ('REDUCE', 41),
+        (31, 'in') : ('REDUCE', 41),
+        (31, ';') : ('REDUCE', 41),
+        (31, '+') : ('REDUCE', 41),
+        (31, '-') : ('REDUCE', 41),
+        (31, 'loop') : ('REDUCE', 41),
+        (31, 'of') : ('REDUCE', 41),
+        (31, '*') : ('REDUCE', 41),
+        (31, 'pool') : ('REDUCE', 41),
+        (31, ',') : ('REDUCE', 41),
+        (31, '/') : ('REDUCE', 41),
+        (32, '@') : ('SHIFT', 60),
+        (32, '<') : ('REDUCE', 43),
+        (32, '<=') : ('REDUCE', 43),
+        (32, ')') : ('REDUCE', 43),
+        (32, 'then') : ('REDUCE', 43),
+        (32, '}') : ('REDUCE', 43),
+        (32, 'else') : ('REDUCE', 43),
+        (32, 'fi') : ('REDUCE', 43),
+        (32, '=') : ('REDUCE', 43),
+        (32, 'in') : ('REDUCE', 43),
+        (32, ';') : ('REDUCE', 43),
+        (32, '+') : ('REDUCE', 43),
+        (32, '-') : ('REDUCE', 43),
+        (32, 'loop') : ('REDUCE', 43),
+        (32, 'of') : ('REDUCE', 43),
+        (32, '*') : ('REDUCE', 43),
+        (32, 'pool') : ('REDUCE', 43),
+        (32, ',') : ('REDUCE', 43),
+        (32, '/') : ('REDUCE', 43),
+        (32, '.') : ('SHIFT', 33),
+        (33, 'id') : ('SHIFT', 34),
+        (34, '(') : ('SHIFT', 35),
+        (35, 'while') : ('SHIFT', 20),
+        (35, 'id') : ('SHIFT', 18),
+        (35, 'new') : ('SHIFT', 22),
+        (35, '~') : ('SHIFT', 15),
+        (35, 'case') : ('SHIFT', 25),
+        (35, 'if') : ('SHIFT', 24),
+        (35, 'not') : ('SHIFT', 26),
+        (35, 'true') : ('SHIFT', 28),
+        (35, 'false') : ('SHIFT', 29),
+        (35, 'int') : ('SHIFT', 21),
+        (35, 'string') : ('SHIFT', 30),
+        (35, 'isvoid') : ('SHIFT', 27),
+        (35, '(') : ('SHIFT', 13),
+        (35, ')') : ('REDUCE', 57),
+        (35, 'let') : ('SHIFT', 8),
+        (35, '{') : ('SHIFT', 14),
+        (36, ')') : ('SHIFT', 37),
+        (37, 'then') : ('REDUCE', 52),
+        (37, 'else') : ('REDUCE', 52),
+        (37, 'fi') : ('REDUCE', 52),
+        (37, 'of') : ('REDUCE', 52),
+        (37, 'in') : ('REDUCE', 52),
+        (37, ';') : ('REDUCE', 52),
+        (37, ',') : ('REDUCE', 52),
+        (37, '.') : ('REDUCE', 52),
+        (37, ')') : ('REDUCE', 52),
+        (37, '}') : ('REDUCE', 52),
+        (37, '=') : ('REDUCE', 52),
+        (37, '+') : ('REDUCE', 52),
+        (37, '-') : ('REDUCE', 52),
+        (37, '*') : ('REDUCE', 52),
+        (37, '/') : ('REDUCE', 52),
+        (37, '<') : ('REDUCE', 52),
+        (37, '<=') : ('REDUCE', 52),
+        (37, '@') : ('REDUCE', 52),
+        (37, 'loop') : ('REDUCE', 52),
+        (37, 'pool') : ('REDUCE', 52),
+        (38, '<=') : ('SHIFT', 54),
+        (38, '<') : ('SHIFT', 52),
+        (38, ')') : ('REDUCE', 30),
+        (38, 'then') : ('REDUCE', 30),
+        (38, '}') : ('REDUCE', 30),
+        (38, 'else') : ('REDUCE', 30),
+        (38, 'fi') : ('REDUCE', 30),
+        (38, 'in') : ('REDUCE', 30),
+        (38, ';') : ('REDUCE', 30),
+        (38, 'loop') : ('REDUCE', 30),
+        (38, 'of') : ('REDUCE', 30),
+        (38, 'pool') : ('REDUCE', 30),
+        (38, ',') : ('REDUCE', 30),
+        (38, '=') : ('SHIFT', 39),
+        (39, 'false') : ('SHIFT', 29),
+        (39, 'id') : ('SHIFT', 16),
+        (39, 'string') : ('SHIFT', 30),
+        (39, 'isvoid') : ('SHIFT', 27),
+        (39, '~') : ('SHIFT', 15),
+        (39, 'int') : ('SHIFT', 21),
+        (39, '(') : ('SHIFT', 13),
+        (39, 'new') : ('SHIFT', 22),
+        (39, 'true') : ('SHIFT', 28),
+        (40, '+') : ('SHIFT', 41),
+        (40, '<') : ('REDUCE', 33),
+        (40, '<=') : ('REDUCE', 33),
+        (40, ')') : ('REDUCE', 33),
+        (40, 'then') : ('REDUCE', 33),
+        (40, '}') : ('REDUCE', 33),
+        (40, 'else') : ('REDUCE', 33),
+        (40, 'fi') : ('REDUCE', 33),
+        (40, '=') : ('REDUCE', 33),
+        (40, 'in') : ('REDUCE', 33),
+        (40, ';') : ('REDUCE', 33),
+        (40, 'loop') : ('REDUCE', 33),
+        (40, 'of') : ('REDUCE', 33),
+        (40, 'pool') : ('REDUCE', 33),
+        (40, ',') : ('REDUCE', 33),
+        (40, '-') : ('SHIFT', 49),
+        (41, 'id') : ('SHIFT', 16),
+        (41, 'false') : ('SHIFT', 29),
+        (41, 'string') : ('SHIFT', 30),
+        (41, 'int') : ('SHIFT', 21),
+        (41, '~') : ('SHIFT', 15),
+        (41, 'isvoid') : ('SHIFT', 27),
+        (41, '(') : ('SHIFT', 13),
+        (41, 'new') : ('SHIFT', 22),
+        (41, 'true') : ('SHIFT', 28),
+        (42, '<') : ('REDUCE', 35),
+        (42, '<=') : ('REDUCE', 35),
+        (42, ')') : ('REDUCE', 35),
+        (42, 'then') : ('REDUCE', 35),
+        (42, '}') : ('REDUCE', 35),
+        (42, 'else') : ('REDUCE', 35),
+        (42, 'fi') : ('REDUCE', 35),
+        (42, '=') : ('REDUCE', 35),
+        (42, 'in') : ('REDUCE', 35),
+        (42, ';') : ('REDUCE', 35),
+        (42, '+') : ('REDUCE', 35),
+        (42, '-') : ('REDUCE', 35),
+        (42, 'loop') : ('REDUCE', 35),
+        (42, 'of') : ('REDUCE', 35),
+        (42, 'pool') : ('REDUCE', 35),
+        (42, ',') : ('REDUCE', 35),
+        (42, '/') : ('SHIFT', 46),
+        (42, '*') : ('SHIFT', 43),
+        (43, 'false') : ('SHIFT', 29),
+        (43, 'id') : ('SHIFT', 16),
+        (43, 'string') : ('SHIFT', 30),
+        (43, 'true') : ('SHIFT', 28),
+        (43, 'int') : ('SHIFT', 21),
+        (43, 'isvoid') : ('SHIFT', 27),
+        (43, '~') : ('SHIFT', 15),
+        (43, '(') : ('SHIFT', 13),
+        (43, 'new') : ('SHIFT', 22),
+        (44, '<') : ('REDUCE', 38),
+        (44, '<=') : ('REDUCE', 38),
+        (44, ')') : ('REDUCE', 38),
+        (44, 'then') : ('REDUCE', 38),
+        (44, '}') : ('REDUCE', 38),
+        (44, 'else') : ('REDUCE', 38),
+        (44, 'fi') : ('REDUCE', 38),
+        (44, '=') : ('REDUCE', 38),
+        (44, 'in') : ('REDUCE', 38),
+        (44, ';') : ('REDUCE', 38),
+        (44, '+') : ('REDUCE', 38),
+        (44, '-') : ('REDUCE', 38),
+        (44, 'loop') : ('REDUCE', 38),
+        (44, 'of') : ('REDUCE', 38),
+        (44, '*') : ('REDUCE', 38),
+        (44, 'pool') : ('REDUCE', 38),
+        (44, ',') : ('REDUCE', 38),
+        (44, '/') : ('REDUCE', 38),
+        (45, 'then') : ('REDUCE', 51),
+        (45, 'else') : ('REDUCE', 51),
+        (45, 'fi') : ('REDUCE', 51),
+        (45, 'of') : ('REDUCE', 51),
+        (45, 'in') : ('REDUCE', 51),
+        (45, ';') : ('REDUCE', 51),
+        (45, ',') : ('REDUCE', 51),
+        (45, '.') : ('REDUCE', 51),
+        (45, ')') : ('REDUCE', 51),
+        (45, '}') : ('REDUCE', 51),
+        (45, '=') : ('REDUCE', 51),
+        (45, '+') : ('REDUCE', 51),
+        (45, '-') : ('REDUCE', 51),
+        (45, '*') : ('REDUCE', 51),
+        (45, '/') : ('REDUCE', 51),
+        (45, '<') : ('REDUCE', 51),
+        (45, '<=') : ('REDUCE', 51),
+        (45, '@') : ('REDUCE', 51),
+        (45, 'loop') : ('REDUCE', 51),
+        (45, 'pool') : ('REDUCE', 51),
+        (46, 'false') : ('SHIFT', 29),
+        (46, 'id') : ('SHIFT', 16),
+        (46, 'string') : ('SHIFT', 30),
+        (46, 'true') : ('SHIFT', 28),
+        (46, 'int') : ('SHIFT', 21),
+        (46, 'isvoid') : ('SHIFT', 27),
+        (46, '~') : ('SHIFT', 15),
+        (46, '(') : ('SHIFT', 13),
+        (46, 'new') : ('SHIFT', 22),
+        (47, '<') : ('REDUCE', 39),
+        (47, '<=') : ('REDUCE', 39),
+        (47, ')') : ('REDUCE', 39),
+        (47, 'then') : ('REDUCE', 39),
+        (47, '}') : ('REDUCE', 39),
+        (47, 'else') : ('REDUCE', 39),
+        (47, 'fi') : ('REDUCE', 39),
+        (47, '=') : ('REDUCE', 39),
+        (47, 'in') : ('REDUCE', 39),
+        (47, ';') : ('REDUCE', 39),
+        (47, '+') : ('REDUCE', 39),
+        (47, '-') : ('REDUCE', 39),
+        (47, 'loop') : ('REDUCE', 39),
+        (47, 'of') : ('REDUCE', 39),
+        (47, '*') : ('REDUCE', 39),
+        (47, 'pool') : ('REDUCE', 39),
+        (47, ',') : ('REDUCE', 39),
+        (47, '/') : ('REDUCE', 39),
+        (48, '<') : ('REDUCE', 40),
+        (48, '<=') : ('REDUCE', 40),
+        (48, ')') : ('REDUCE', 40),
+        (48, 'then') : ('REDUCE', 40),
+        (48, '}') : ('REDUCE', 40),
+        (48, 'else') : ('REDUCE', 40),
+        (48, 'fi') : ('REDUCE', 40),
+        (48, '=') : ('REDUCE', 40),
+        (48, 'in') : ('REDUCE', 40),
+        (48, ';') : ('REDUCE', 40),
+        (48, '+') : ('REDUCE', 40),
+        (48, '-') : ('REDUCE', 40),
+        (48, 'loop') : ('REDUCE', 40),
+        (48, 'of') : ('REDUCE', 40),
+        (48, '*') : ('REDUCE', 40),
+        (48, 'pool') : ('REDUCE', 40),
+        (48, ',') : ('REDUCE', 40),
+        (48, '/') : ('REDUCE', 40),
+        (49, 'id') : ('SHIFT', 16),
+        (49, 'false') : ('SHIFT', 29),
+        (49, 'string') : ('SHIFT', 30),
+        (49, 'int') : ('SHIFT', 21),
+        (49, '~') : ('SHIFT', 15),
+        (49, 'isvoid') : ('SHIFT', 27),
+        (49, '(') : ('SHIFT', 13),
+        (49, 'new') : ('SHIFT', 22),
+        (49, 'true') : ('SHIFT', 28),
+        (50, '/') : ('SHIFT', 46),
+        (50, '<') : ('REDUCE', 36),
+        (50, '<=') : ('REDUCE', 36),
+        (50, ')') : ('REDUCE', 36),
+        (50, 'then') : ('REDUCE', 36),
+        (50, '}') : ('REDUCE', 36),
+        (50, 'else') : ('REDUCE', 36),
+        (50, 'fi') : ('REDUCE', 36),
+        (50, '=') : ('REDUCE', 36),
+        (50, 'in') : ('REDUCE', 36),
+        (50, ';') : ('REDUCE', 36),
+        (50, '+') : ('REDUCE', 36),
+        (50, '-') : ('REDUCE', 36),
+        (50, 'loop') : ('REDUCE', 36),
+        (50, 'of') : ('REDUCE', 36),
+        (50, 'pool') : ('REDUCE', 36),
+        (50, ',') : ('REDUCE', 36),
+        (50, '*') : ('SHIFT', 43),
+        (51, '<') : ('REDUCE', 37),
+        (51, '<=') : ('REDUCE', 37),
+        (51, ')') : ('REDUCE', 37),
+        (51, 'then') : ('REDUCE', 37),
+        (51, '}') : ('REDUCE', 37),
+        (51, 'else') : ('REDUCE', 37),
+        (51, 'fi') : ('REDUCE', 37),
+        (51, '=') : ('REDUCE', 37),
+        (51, 'in') : ('REDUCE', 37),
+        (51, ';') : ('REDUCE', 37),
+        (51, '+') : ('REDUCE', 37),
+        (51, '-') : ('REDUCE', 37),
+        (51, 'loop') : ('REDUCE', 37),
+        (51, 'of') : ('REDUCE', 37),
+        (51, 'pool') : ('REDUCE', 37),
+        (51, ',') : ('REDUCE', 37),
+        (51, '/') : ('SHIFT', 46),
+        (51, '*') : ('SHIFT', 43),
+        (52, 'false') : ('SHIFT', 29),
+        (52, 'id') : ('SHIFT', 16),
+        (52, 'string') : ('SHIFT', 30),
+        (52, 'isvoid') : ('SHIFT', 27),
+        (52, '~') : ('SHIFT', 15),
+        (52, 'int') : ('SHIFT', 21),
+        (52, '(') : ('SHIFT', 13),
+        (52, 'new') : ('SHIFT', 22),
+        (52, 'true') : ('SHIFT', 28),
+        (53, '<') : ('REDUCE', 31),
+        (53, '<=') : ('REDUCE', 31),
+        (53, ')') : ('REDUCE', 31),
+        (53, 'then') : ('REDUCE', 31),
+        (53, '}') : ('REDUCE', 31),
+        (53, 'else') : ('REDUCE', 31),
+        (53, 'fi') : ('REDUCE', 31),
+        (53, '=') : ('REDUCE', 31),
+        (53, 'in') : ('REDUCE', 31),
+        (53, ';') : ('REDUCE', 31),
+        (53, 'loop') : ('REDUCE', 31),
+        (53, 'of') : ('REDUCE', 31),
+        (53, 'pool') : ('REDUCE', 31),
+        (53, ',') : ('REDUCE', 31),
+        (53, '+') : ('SHIFT', 41),
+        (53, '-') : ('SHIFT', 49),
+        (54, 'false') : ('SHIFT', 29),
+        (54, 'id') : ('SHIFT', 16),
+        (54, 'string') : ('SHIFT', 30),
+        (54, 'isvoid') : ('SHIFT', 27),
+        (54, '~') : ('SHIFT', 15),
+        (54, 'int') : ('SHIFT', 21),
+        (54, '(') : ('SHIFT', 13),
+        (54, 'new') : ('SHIFT', 22),
+        (54, 'true') : ('SHIFT', 28),
+        (55, '-') : ('SHIFT', 49),
+        (55, '+') : ('SHIFT', 41),
+        (55, '<') : ('REDUCE', 32),
+        (55, '<=') : ('REDUCE', 32),
+        (55, ')') : ('REDUCE', 32),
+        (55, 'then') : ('REDUCE', 32),
+        (55, '}') : ('REDUCE', 32),
+        (55, 'else') : ('REDUCE', 32),
+        (55, 'fi') : ('REDUCE', 32),
+        (55, '=') : ('REDUCE', 32),
+        (55, 'in') : ('REDUCE', 32),
+        (55, ';') : ('REDUCE', 32),
+        (55, 'loop') : ('REDUCE', 32),
+        (55, 'of') : ('REDUCE', 32),
+        (55, 'pool') : ('REDUCE', 32),
+        (55, ',') : ('REDUCE', 32),
+        (56, ',') : ('SHIFT', 57),
+        (56, ')') : ('REDUCE', 55),
+        (57, 'while') : ('SHIFT', 20),
+        (57, 'id') : ('SHIFT', 18),
+        (57, 'new') : ('SHIFT', 22),
+        (57, '~') : ('SHIFT', 15),
+        (57, 'case') : ('SHIFT', 25),
+        (57, 'if') : ('SHIFT', 24),
+        (57, 'not') : ('SHIFT', 26),
+        (57, 'true') : ('SHIFT', 28),
+        (57, 'false') : ('SHIFT', 29),
+        (57, 'int') : ('SHIFT', 21),
+        (57, 'string') : ('SHIFT', 30),
+        (57, 'isvoid') : ('SHIFT', 27),
+        (57, '(') : ('SHIFT', 13),
+        (57, ')') : ('REDUCE', 57),
+        (57, 'let') : ('SHIFT', 8),
+        (57, '{') : ('SHIFT', 14),
+        (58, ')') : ('REDUCE', 56),
+        (59, '<') : ('REDUCE', 34),
+        (59, '<=') : ('REDUCE', 34),
+        (59, ')') : ('REDUCE', 34),
+        (59, 'then') : ('REDUCE', 34),
+        (59, '}') : ('REDUCE', 34),
+        (59, 'else') : ('REDUCE', 34),
+        (59, 'fi') : ('REDUCE', 34),
+        (59, '=') : ('REDUCE', 34),
+        (59, 'in') : ('REDUCE', 34),
+        (59, ';') : ('REDUCE', 34),
+        (59, 'loop') : ('REDUCE', 34),
+        (59, 'of') : ('REDUCE', 34),
+        (59, 'pool') : ('REDUCE', 34),
+        (59, ',') : ('REDUCE', 34),
+        (59, '+') : ('SHIFT', 41),
+        (59, '-') : ('SHIFT', 49),
+        (60, 'type') : ('SHIFT', 61),
+        (61, '.') : ('SHIFT', 62),
+        (62, 'id') : ('SHIFT', 63),
+        (63, '(') : ('SHIFT', 64),
+        (64, 'while') : ('SHIFT', 20),
+        (64, 'id') : ('SHIFT', 18),
+        (64, 'new') : ('SHIFT', 22),
+        (64, '~') : ('SHIFT', 15),
+        (64, 'case') : ('SHIFT', 25),
+        (64, 'if') : ('SHIFT', 24),
+        (64, 'not') : ('SHIFT', 26),
+        (64, 'true') : ('SHIFT', 28),
+        (64, 'false') : ('SHIFT', 29),
+        (64, 'int') : ('SHIFT', 21),
+        (64, 'string') : ('SHIFT', 30),
+        (64, 'isvoid') : ('SHIFT', 27),
+        (64, '(') : ('SHIFT', 13),
+        (64, ')') : ('REDUCE', 57),
+        (64, 'let') : ('SHIFT', 8),
+        (64, '{') : ('SHIFT', 14),
+        (65, ')') : ('SHIFT', 66),
+        (66, 'then') : ('REDUCE', 54),
+        (66, 'else') : ('REDUCE', 54),
+        (66, 'fi') : ('REDUCE', 54),
+        (66, 'of') : ('REDUCE', 54),
+        (66, 'in') : ('REDUCE', 54),
+        (66, ';') : ('REDUCE', 54),
+        (66, ',') : ('REDUCE', 54),
+        (66, '.') : ('REDUCE', 54),
+        (66, ')') : ('REDUCE', 54),
+        (66, '}') : ('REDUCE', 54),
+        (66, '=') : ('REDUCE', 54),
+        (66, '+') : ('REDUCE', 54),
+        (66, '-') : ('REDUCE', 54),
+        (66, '*') : ('REDUCE', 54),
+        (66, '/') : ('REDUCE', 54),
+        (66, '<') : ('REDUCE', 54),
+        (66, '<=') : ('REDUCE', 54),
+        (66, '@') : ('REDUCE', 54),
+        (66, 'loop') : ('REDUCE', 54),
+        (66, 'pool') : ('REDUCE', 54),
+        (67, ')') : ('REDUCE', 18),
+        (67, 'then') : ('REDUCE', 18),
+        (67, '}') : ('REDUCE', 18),
+        (67, 'else') : ('REDUCE', 18),
+        (67, 'fi') : ('REDUCE', 18),
+        (67, 'in') : ('REDUCE', 18),
+        (67, ';') : ('REDUCE', 18),
+        (67, 'loop') : ('REDUCE', 18),
+        (67, 'of') : ('REDUCE', 18),
+        (67, 'pool') : ('REDUCE', 18),
+        (67, ',') : ('REDUCE', 18),
+        (68, 'of') : ('SHIFT', 69),
+        (69, 'id') : ('SHIFT', 70),
+        (70, ':') : ('SHIFT', 71),
+        (71, 'type') : ('SHIFT', 72),
+        (72, '=>') : ('SHIFT', 73),
+        (73, 'if') : ('SHIFT', 24),
+        (73, 'not') : ('SHIFT', 26),
+        (73, 'id') : ('SHIFT', 18),
+        (73, 'false') : ('SHIFT', 29),
+        (73, 'int') : ('SHIFT', 21),
+        (73, 'string') : ('SHIFT', 30),
+        (73, '(') : ('SHIFT', 13),
+        (73, 'true') : ('SHIFT', 28),
+        (73, 'let') : ('SHIFT', 8),
+        (73, 'isvoid') : ('SHIFT', 27),
+        (73, '~') : ('SHIFT', 15),
+        (73, 'case') : ('SHIFT', 25),
+        (73, '{') : ('SHIFT', 14),
+        (73, 'new') : ('SHIFT', 22),
+        (73, 'while') : ('SHIFT', 20),
+        (74, ';') : ('SHIFT', 75),
+        (75, 'id') : ('SHIFT', 70),
+        (75, 'esac') : ('REDUCE', 28),
+        (76, 'esac') : ('REDUCE', 29),
+        (77, 'esac') : ('SHIFT', 78),
+        (78, ')') : ('REDUCE', 27),
+        (78, 'then') : ('REDUCE', 27),
+        (78, '}') : ('REDUCE', 27),
+        (78, 'else') : ('REDUCE', 27),
+        (78, 'fi') : ('REDUCE', 27),
+        (78, 'in') : ('REDUCE', 27),
+        (78, ';') : ('REDUCE', 27),
+        (78, 'loop') : ('REDUCE', 27),
+        (78, 'of') : ('REDUCE', 27),
+        (78, 'pool') : ('REDUCE', 27),
+        (78, ',') : ('REDUCE', 27),
+        (79, 'then') : ('SHIFT', 80),
+        (80, 'id') : ('SHIFT', 18),
+        (80, 'let') : ('SHIFT', 8),
+        (80, 'false') : ('SHIFT', 29),
+        (80, 'int') : ('SHIFT', 21),
+        (80, 'isvoid') : ('SHIFT', 27),
+        (80, '~') : ('SHIFT', 15),
+        (80, 'string') : ('SHIFT', 30),
+        (80, '(') : ('SHIFT', 13),
+        (80, 'case') : ('SHIFT', 25),
+        (80, 'new') : ('SHIFT', 22),
+        (80, 'while') : ('SHIFT', 20),
+        (80, 'if') : ('SHIFT', 24),
+        (80, 'not') : ('SHIFT', 26),
+        (80, '{') : ('SHIFT', 14),
+        (80, 'true') : ('SHIFT', 28),
+        (81, 'else') : ('SHIFT', 82),
+        (82, 'case') : ('SHIFT', 25),
+        (82, 'not') : ('SHIFT', 26),
+        (82, 'int') : ('SHIFT', 21),
+        (82, '(') : ('SHIFT', 13),
+        (82, 'while') : ('SHIFT', 20),
+        (82, 'id') : ('SHIFT', 18),
+        (82, 'true') : ('SHIFT', 28),
+        (82, 'if') : ('SHIFT', 24),
+        (82, 'false') : ('SHIFT', 29),
+        (82, 'let') : ('SHIFT', 8),
+        (82, 'string') : ('SHIFT', 30),
+        (82, 'isvoid') : ('SHIFT', 27),
+        (82, '~') : ('SHIFT', 15),
+        (82, 'new') : ('SHIFT', 22),
+        (82, '{') : ('SHIFT', 14),
+        (83, 'fi') : ('SHIFT', 84),
+        (84, ')') : ('REDUCE', 16),
+        (84, 'then') : ('REDUCE', 16),
+        (84, '}') : ('REDUCE', 16),
+        (84, 'else') : ('REDUCE', 16),
+        (84, 'fi') : ('REDUCE', 16),
+        (84, 'in') : ('REDUCE', 16),
+        (84, ';') : ('REDUCE', 16),
+        (84, 'loop') : ('REDUCE', 16),
+        (84, 'of') : ('REDUCE', 16),
+        (84, 'pool') : ('REDUCE', 16),
+        (84, ',') : ('REDUCE', 16),
+        (85, 'loop') : ('SHIFT', 86),
+        (86, 'let') : ('SHIFT', 8),
+        (86, 'new') : ('SHIFT', 22),
+        (86, 'id') : ('SHIFT', 18),
+        (86, 'isvoid') : ('SHIFT', 27),
+        (86, '~') : ('SHIFT', 15),
+        (86, 'case') : ('SHIFT', 25),
+        (86, '{') : ('SHIFT', 14),
+        (86, 'true') : ('SHIFT', 28),
+        (86, 'while') : ('SHIFT', 20),
+        (86, 'false') : ('SHIFT', 29),
+        (86, 'int') : ('SHIFT', 21),
+        (86, 'string') : ('SHIFT', 30),
+        (86, '(') : ('SHIFT', 13),
+        (86, 'if') : ('SHIFT', 24),
+        (86, 'not') : ('SHIFT', 26),
+        (87, 'pool') : ('SHIFT', 88),
+        (88, ')') : ('REDUCE', 17),
+        (88, 'then') : ('REDUCE', 17),
+        (88, '}') : ('REDUCE', 17),
+        (88, 'else') : ('REDUCE', 17),
+        (88, 'fi') : ('REDUCE', 17),
+        (88, 'in') : ('REDUCE', 17),
+        (88, ';') : ('REDUCE', 17),
+        (88, 'loop') : ('REDUCE', 17),
+        (88, 'of') : ('REDUCE', 17),
+        (88, 'pool') : ('REDUCE', 17),
+        (88, ',') : ('REDUCE', 17),
+        (89, ')') : ('REDUCE', 15),
+        (89, 'then') : ('REDUCE', 15),
+        (89, '}') : ('REDUCE', 15),
+        (89, 'else') : ('REDUCE', 15),
+        (89, 'fi') : ('REDUCE', 15),
+        (89, 'in') : ('REDUCE', 15),
+        (89, ';') : ('REDUCE', 15),
+        (89, 'loop') : ('REDUCE', 15),
+        (89, 'of') : ('REDUCE', 15),
+        (89, 'pool') : ('REDUCE', 15),
+        (89, ',') : ('REDUCE', 15),
+        (90, ')') : ('SHIFT', 91),
+        (91, 'then') : ('REDUCE', 53),
+        (91, 'else') : ('REDUCE', 53),
+        (91, 'fi') : ('REDUCE', 53),
+        (91, 'of') : ('REDUCE', 53),
+        (91, 'in') : ('REDUCE', 53),
+        (91, ';') : ('REDUCE', 53),
+        (91, ',') : ('REDUCE', 53),
+        (91, '.') : ('REDUCE', 53),
+        (91, ')') : ('REDUCE', 53),
+        (91, '}') : ('REDUCE', 53),
+        (91, '=') : ('REDUCE', 53),
+        (91, '+') : ('REDUCE', 53),
+        (91, '-') : ('REDUCE', 53),
+        (91, '*') : ('REDUCE', 53),
+        (91, '/') : ('REDUCE', 53),
+        (91, '<') : ('REDUCE', 53),
+        (91, '<=') : ('REDUCE', 53),
+        (91, '@') : ('REDUCE', 53),
+        (91, 'loop') : ('REDUCE', 53),
+        (91, 'pool') : ('REDUCE', 53),
+        (92, '<') : ('REDUCE', 42),
+        (92, '<=') : ('REDUCE', 42),
+        (92, ')') : ('REDUCE', 42),
+        (92, 'then') : ('REDUCE', 42),
+        (92, '}') : ('REDUCE', 42),
+        (92, 'else') : ('REDUCE', 42),
+        (92, 'fi') : ('REDUCE', 42),
+        (92, '=') : ('REDUCE', 42),
+        (92, 'in') : ('REDUCE', 42),
+        (92, ';') : ('REDUCE', 42),
+        (92, '+') : ('REDUCE', 42),
+        (92, '-') : ('REDUCE', 42),
+        (92, 'loop') : ('REDUCE', 42),
+        (92, 'of') : ('REDUCE', 42),
+        (92, '*') : ('REDUCE', 42),
+        (92, 'pool') : ('REDUCE', 42),
+        (92, ',') : ('REDUCE', 42),
+        (92, '/') : ('REDUCE', 42),
+        (93, '}') : ('SHIFT', 94),
+        (94, ')') : ('REDUCE', 19),
+        (94, 'then') : ('REDUCE', 19),
+        (94, '}') : ('REDUCE', 19),
+        (94, 'else') : ('REDUCE', 19),
+        (94, 'fi') : ('REDUCE', 19),
+        (94, 'in') : ('REDUCE', 19),
+        (94, ';') : ('REDUCE', 19),
+        (94, 'loop') : ('REDUCE', 19),
+        (94, 'of') : ('REDUCE', 19),
+        (94, 'pool') : ('REDUCE', 19),
+        (94, ',') : ('REDUCE', 19),
+        (95, ';') : ('SHIFT', 96),
+        (96, 'if') : ('SHIFT', 24),
+        (96, 'not') : ('SHIFT', 26),
+        (96, 'id') : ('SHIFT', 18),
+        (96, 'false') : ('SHIFT', 29),
+        (96, 'int') : ('SHIFT', 21),
+        (96, 'string') : ('SHIFT', 30),
+        (96, '(') : ('SHIFT', 13),
+        (96, '}') : ('REDUCE', 20),
+        (96, 'true') : ('SHIFT', 28),
+        (96, 'let') : ('SHIFT', 8),
+        (96, 'isvoid') : ('SHIFT', 27),
+        (96, '~') : ('SHIFT', 15),
+        (96, 'case') : ('SHIFT', 25),
+        (96, '{') : ('SHIFT', 14),
+        (96, 'new') : ('SHIFT', 22),
+        (96, 'while') : ('SHIFT', 20),
+        (97, '}') : ('REDUCE', 21),
+        (98, ')') : ('SHIFT', 99),
+        (99, 'then') : ('REDUCE', 50),
+        (99, 'else') : ('REDUCE', 50),
+        (99, 'fi') : ('REDUCE', 50),
+        (99, 'of') : ('REDUCE', 50),
+        (99, 'in') : ('REDUCE', 50),
+        (99, ';') : ('REDUCE', 50),
+        (99, ',') : ('REDUCE', 50),
+        (99, '.') : ('REDUCE', 50),
+        (99, ')') : ('REDUCE', 50),
+        (99, '}') : ('REDUCE', 50),
+        (99, '=') : ('REDUCE', 50),
+        (99, '+') : ('REDUCE', 50),
+        (99, '-') : ('REDUCE', 50),
+        (99, '*') : ('REDUCE', 50),
+        (99, '/') : ('REDUCE', 50),
+        (99, '<') : ('REDUCE', 50),
+        (99, '<=') : ('REDUCE', 50),
+        (99, '@') : ('REDUCE', 50),
+        (99, 'loop') : ('REDUCE', 50),
+        (99, 'pool') : ('REDUCE', 50),
+        (100, 'in') : ('REDUCE', 24),
+        (100, ',') : ('SHIFT', 101),
+        (101, 'id') : ('SHIFT', 9),
+        (102, 'in') : ('REDUCE', 26),
+        (103, 'id') : ('SHIFT', 9),
+        (104, 'in') : ('REDUCE', 25),
+        (105, 'in') : ('SHIFT', 106),
+        (106, 'id') : ('SHIFT', 18),
+        (106, 'false') : ('SHIFT', 29),
+        (106, 'let') : ('SHIFT', 8),
+        (106, 'string') : ('SHIFT', 30),
+        (106, 'isvoid') : ('SHIFT', 27),
+        (106, 'case') : ('SHIFT', 25),
+        (106, '~') : ('SHIFT', 15),
+        (106, '{') : ('SHIFT', 14),
+        (106, 'new') : ('SHIFT', 22),
+        (106, 'while') : ('SHIFT', 20),
+        (106, 'if') : ('SHIFT', 24),
+        (106, 'not') : ('SHIFT', 26),
+        (106, 'int') : ('SHIFT', 21),
+        (106, '(') : ('SHIFT', 13),
+        (106, 'true') : ('SHIFT', 28),
+        (107, ')') : ('REDUCE', 22),
+        (107, 'then') : ('REDUCE', 22),
+        (107, '}') : ('REDUCE', 22),
+        (107, 'else') : ('REDUCE', 22),
+        (107, 'fi') : ('REDUCE', 22),
+        (107, 'in') : ('REDUCE', 22),
+        (107, ';') : ('REDUCE', 22),
+        (107, 'loop') : ('REDUCE', 22),
+        (107, 'of') : ('REDUCE', 22),
+        (107, 'pool') : ('REDUCE', 22),
+        (107, ',') : ('REDUCE', 22),
+        (108, ';') : ('REDUCE', 9),
+        (109, ')') : ('REDUCE', 13),
+        (109, 'id') : ('SHIFT', 110),
+        (110, ':') : ('SHIFT', 111),
+        (111, 'type') : ('SHIFT', 112),
+        (112, ',') : ('REDUCE', 14),
+        (112, ')') : ('REDUCE', 14),
+        (113, ')') : ('SHIFT', 114),
+        (114, ':') : ('SHIFT', 115),
+        (115, 'type') : ('SHIFT', 116),
+        (116, '{') : ('SHIFT', 117),
+        (117, 'string') : ('SHIFT', 30),
+        (117, '(') : ('SHIFT', 13),
+        (117, 'isvoid') : ('SHIFT', 27),
+        (117, '~') : ('SHIFT', 15),
+        (117, 'let') : ('SHIFT', 8),
+        (117, 'true') : ('SHIFT', 28),
+        (117, 'case') : ('SHIFT', 25),
+        (117, '{') : ('SHIFT', 14),
+        (117, 'while') : ('SHIFT', 20),
+        (117, 'id') : ('SHIFT', 18),
+        (117, 'new') : ('SHIFT', 22),
+        (117, 'if') : ('SHIFT', 24),
+        (117, 'not') : ('SHIFT', 26),
+        (117, 'false') : ('SHIFT', 29),
+        (117, 'int') : ('SHIFT', 21),
+        (118, '}') : ('SHIFT', 119),
+        (119, ';') : ('REDUCE', 10),
+        (120, ',') : ('SHIFT', 121),
+        (120, ')') : ('REDUCE', 11),
+        (121, ')') : ('REDUCE', 13),
+        (121, 'id') : ('SHIFT', 110),
+        (122, ')') : ('REDUCE', 12),
+        (123, '}') : ('SHIFT', 124),
+        (124, ';') : ('REDUCE', 3),
+        (125, ';') : ('SHIFT', 126),
+        (126, 'id') : ('SHIFT', 4),
+        (126, '}') : ('REDUCE', 7),
+        (127, '}') : ('REDUCE', 5),
+        (128, ';') : ('SHIFT', 129),
+        (129, 'id') : ('SHIFT', 4),
+        (129, '}') : ('REDUCE', 7),
+        (130, '}') : ('REDUCE', 6),
+        (131, 'type') : ('SHIFT', 132),
+        (132, '{') : ('SHIFT', 133),
+        (133, 'id') : ('SHIFT', 4),
+        (133, '}') : ('REDUCE', 7),
+        (134, '}') : ('SHIFT', 135),
+        (135, ';') : ('REDUCE', 4),
+        (136, '$') : ('REDUCE', 0),
+        (137, ';') : ('SHIFT', 138),
+        (138, 'class') : ('SHIFT', 1),
+        (138, '$') : ('REDUCE', 1),
+        (139, '$') : ('REDUCE', 2),
+        (140, '$') : ('OK', None)
+        }
+
+
+
+
+        self.goto = {
+        (0, '<def-class>') : 137,
+        (0, '<program>'): 140,
+        (0, '<class-list>') : 136,
+        (3, '<feature-list>') : 123,
+        (3, '<def-attr>') : 125,
+        (3, '<def-meth>') : 128,
+        (7, '<arith>') : 59,
+        (7, '<comp>') : 38,
+        (7, '<factor>') : 48,
+        (7, '<term>') : 51,
+        (7, '<atom>') : 32,
+        (7, '<dispatch>') : 45,
+        (7, '<expr>') : 108,
+        (8, '<id-list>') : 105,
+        (12, '<term>') : 51,
+        (12, '<factor>') : 48,
+        (12, '<comp>') : 38,
+        (12, '<expr>') : 100,
+        (12, '<atom>') : 32,
+        (12, '<dispatch>') : 45,
+        (12, '<arith>') : 59,
+        (13, '<term>') : 51,
+        (13, '<comp>') : 38,
+        (13, '<arith>') : 59,
+        (13, '<atom>') : 32,
+        (13, '<dispatch>') : 45,
+        (13, '<expr>') : 98,
+        (13, '<factor>') : 48,
+        (14, '<expr>') : 95,
+        (14, '<atom>') : 32,
+        (14, '<arith>') : 59,
+        (14, '<comp>') : 38,
+        (14, '<factor>') : 48,
+        (14, '<term>') : 51,
+        (14, '<dispatch>') : 45,
+        (14, '<expr-list>') : 93,
+        (15, '<dispatch>') : 45,
+        (15, '<factor>') : 92,
+        (15, '<atom>') : 32,
+        (17, '<comp>') : 38,
+        (17, '<factor>') : 48,
+        (17, '<term>') : 51,
+        (17, '<arith>') : 59,
+        (17, '<atom>') : 32,
+        (17, '<arg-list>') : 90,
+        (17, '<dispatch>') : 45,
+        (17, '<expr>') : 56,
+        (19, '<comp>') : 38,
+        (19, '<term>') : 51,
+        (19, '<atom>') : 32,
+        (19, '<arith>') : 59,
+        (19, '<factor>') : 48,
+        (19, '<expr>') : 89,
+        (19, '<dispatch>') : 45,
+        (20, '<arith>') : 59,
+        (20, '<comp>') : 38,
+        (20, '<atom>') : 32,
+        (20, '<term>') : 51,
+        (20, '<factor>') : 48,
+        (20, '<expr>') : 85,
+        (20, '<dispatch>') : 45,
+        (24, '<comp>') : 38,
+        (24, '<atom>') : 32,
+        (24, '<term>') : 51,
+        (24, '<arith>') : 59,
+        (24, '<factor>') : 48,
+        (24, '<expr>') : 79,
+        (24, '<dispatch>') : 45,
+        (25, '<arith>') : 59,
+        (25, '<term>') : 51,
+        (25, '<comp>') : 38,
+        (25, '<atom>') : 32,
+        (25, '<factor>') : 48,
+        (25, '<dispatch>') : 45,
+        (25, '<expr>') : 68,
+        (26, '<comp>') : 38,
+        (26, '<term>') : 51,
+        (26, '<atom>') : 32,
+        (26, '<expr>') : 67,
+        (26, '<arith>') : 59,
+        (26, '<factor>') : 48,
+        (26, '<dispatch>') : 45,
+        (27, '<factor>') : 31,
+        (27, '<dispatch>') : 45,
+        (27, '<atom>') : 32,
+        (35, '<comp>') : 38,
+        (35, '<arg-list>') : 36,
+        (35, '<factor>') : 48,
+        (35, '<term>') : 51,
+        (35, '<arith>') : 59,
+        (35, '<atom>') : 32,
+        (35, '<dispatch>') : 45,
+        (35, '<expr>') : 56,
+        (39, '<arith>') : 40,
+        (39, '<term>') : 51,
+        (39, '<atom>') : 32,
+        (39, '<factor>') : 48,
+        (39, '<dispatch>') : 45,
+        (41, '<term>') : 42,
+        (41, '<atom>') : 32,
+        (41, '<factor>') : 48,
+        (41, '<dispatch>') : 45,
+        (43, '<dispatch>') : 45,
+        (43, '<atom>') : 32,
+        (43, '<factor>') : 44,
+        (46, '<dispatch>') : 45,
+        (46, '<atom>') : 32,
+        (46, '<factor>') : 47,
+        (49, '<term>') : 50,
+        (49, '<atom>') : 32,
+        (49, '<factor>') : 48,
+        (49, '<dispatch>') : 45,
+        (52, '<arith>') : 53,
+        (52, '<term>') : 51,
+        (52, '<atom>') : 32,
+        (52, '<factor>') : 48,
+        (52, '<dispatch>') : 45,
+        (54, '<arith>') : 55,
+        (54, '<term>') : 51,
+        (54, '<atom>') : 32,
+        (54, '<factor>') : 48,
+        (54, '<dispatch>') : 45,
+        (57, '<comp>') : 38,
+        (57, '<factor>') : 48,
+        (57, '<term>') : 51,
+        (57, '<arith>') : 59,
+        (57, '<atom>') : 32,
+        (57, '<arg-list>') : 58,
+        (57, '<dispatch>') : 45,
+        (57, '<expr>') : 56,
+        (64, '<comp>') : 38,
+        (64, '<factor>') : 48,
+        (64, '<term>') : 51,
+        (64, '<arith>') : 59,
+        (64, '<atom>') : 32,
+        (64, '<dispatch>') : 45,
+        (64, '<expr>') : 56,
+        (64, '<arg-list>') : 65,
+        (69, '<case-list>') : 77,
+        (73, '<arith>') : 59,
+        (73, '<comp>') : 38,
+        (73, '<factor>') : 48,
+        (73, '<term>') : 51,
+        (73, '<atom>') : 32,
+        (73, '<expr>') : 74,
+        (73, '<dispatch>') : 45,
+        (75, '<case-list>') : 76,
+        (80, '<factor>') : 48,
+        (80, '<term>') : 51,
+        (80, '<arith>') : 59,
+        (80, '<atom>') : 32,
+        (80, '<comp>') : 38,
+        (80, '<dispatch>') : 45,
+        (80, '<expr>') : 81,
+        (82, '<atom>') : 32,
+        (82, '<comp>') : 38,
+        (82, '<arith>') : 59,
+        (82, '<term>') : 51,
+        (82, '<dispatch>') : 45,
+        (82, '<factor>') : 48,
+        (82, '<expr>') : 83,
+        (86, '<arith>') : 59,
+        (86, '<factor>') : 48,
+        (86, '<term>') : 51,
+        (86, '<comp>') : 38,
+        (86, '<atom>') : 32,
+        (86, '<dispatch>') : 45,
+        (86, '<expr>') : 87,
+        (96, '<expr>') : 95,
+        (96, '<arith>') : 59,
+        (96, '<comp>') : 38,
+        (96, '<factor>') : 48,
+        (96, '<term>') : 51,
+        (96, '<atom>') : 32,
+        (96, '<dispatch>') : 45,
+        (96, '<expr-list>') : 97,
+        (101, '<id-list>') : 102,
+        (103, '<id-list>') : 104,
+        (106, '<comp>') : 38,
+        (106, '<term>') : 51,
+        (106, '<atom>') : 32,
+        (106, '<arith>') : 59,
+        (106, '<factor>') : 48,
+        (106, '<dispatch>') : 45,
+        (106, '<expr>') : 107,
+        (109, '<param-list>') : 113,
+        (109, '<param>') : 120,
+        (117, '<term>') : 51,
+        (117, '<arith>') : 59,
+        (117, '<dispatch>') : 45,
+        (117, '<atom>') : 32,
+        (117, '<expr>') : 118,
+        (117, '<comp>') : 38,
+        (117, '<factor>') : 48,
+        (121, '<param>') : 120,
+        (121, '<param-list>') : 122,
+        (126, '<feature-list>') : 127,
+        (126, '<def-attr>') : 125,
+        (126, '<def-meth>') : 128,
+        (129, '<feature-list>') : 130,
+        (129, '<def-attr>') : 125,
+        (129, '<def-meth>') : 128,
+        (133, '<feature-list>') : 134,
+        (133, '<def-attr>') : 125,
+        (133, '<def-meth>') : 128,
+        (138, '<def-class>') : 137,
+        (138, '<class-list>') : 139
+        }
+
+
+        ShiftReduceParser.__init__(self,G)
\ No newline at end of file
diff --git a/src/utils/parser/LALR_1.py b/src/utils/parser/LALR_1.py
new file mode 100644
index 000000000..e9dfb1374
--- /dev/null
+++ b/src/utils/parser/LALR_1.py
@@ -0,0 +1,64 @@
+from utils.parser.LR_1 import LR1_Parser
+from cmp.automata import State, multiline_formatter
+from cmp.utils import ContainerSet
+from cmp.pycompiler import Item
+
+class LALR1_Parser(LR1_Parser):
+    
+    def build_automaton(self,G):
+        assert len(G.startSymbol.productions) == 1, 'Grammar must be augmented' 
+    
+        firsts = self.firsts
+        firsts[G.EOF] = ContainerSet(G.EOF)
+    
+        start_production = G.startSymbol.productions[0] 
+        start_item = Item(start_production, 0, lookaheads=ContainerSet(G.EOF)) 
+        start = frozenset([start_item.Center()]) 
+    
+        closure = self.closure_lr1([start_item], firsts) 
+        automaton = State(frozenset(closure), True) 
+    
+        pending = [start] 
+        visited = {start: automaton} 
+    
+        while pending: 
+            current = pending.pop() 
+            current_state = visited[current] 
+    
+            for symbol in G.terminals + G.nonTerminals: 
+                a = self.goto_lr1(current_state.state, symbol, just_kernel=True) 
+                closure = self.closure_lr1(a, firsts) 
+                center = frozenset(item.Center() for item in a)
+    
+                if not a:
+                    continue 
+    
+                try: 
+                    next_state = visited[center] 
+                    centers = {item.Center(): item for item in next_state.state} 
+                    centers = {item.Center(): (centers[item.Center()], item) for item in closure} 
+    
+                    updated_items = set() 
+                    for c, (itemA, itemB) in centers.items(): 
+                        item = Item(c.production, c.pos, itemA.lookaheads | itemB.lookaheads) 
+                        updated_items.add(item) 
+    
+                    updated_items = frozenset(updated_items) 
+                    if next_state.state != updated_items: 
+                        pending.append(center) 
+                    next_state.state = updated_items 
+
+                except KeyError: 
+                    visited[center] = next_state = State(frozenset(closure), True) 
+                    pending.append(center) 
+    
+                if current_state[symbol.Name] is None: 
+                    current_state.add_transition(symbol.Name, next_state) 
+                else: 
+                    assert current_state.get(symbol.Name) is next_state, 'Error!!!' 
+    
+        automaton.set_formatter(multiline_formatter) 
+        return automaton 
+
+    def __str__(self):
+        return 'LALR(1)'
\ No newline at end of file
diff --git a/src/utils/parser/LR_1.py b/src/utils/parser/LR_1.py
new file mode 100644
index 000000000..5125d2d33
--- /dev/null
+++ b/src/utils/parser/LR_1.py
@@ -0,0 +1,136 @@
+from utils.parser.shift_reduce_parser import ShiftReduceParser
+from cmp.automata import State, multiline_formatter
+from cmp.utils import ContainerSet
+from cmp.pycompiler import Item
+
+class LR1_Parser(ShiftReduceParser):
+    
+    def _build_parsing_table(self):
+        
+        automaton = self.build_automaton(self.G)
+        self.automaton = automaton
+
+        for i, node in enumerate(automaton):
+            node.idx = i
+
+        for node in automaton:
+            idx = node.idx
+            for item in node.state:
+
+                # - Fill `self.Action` and `self.Goto` according to `item`)
+                # - Feel free to use `self._register(...)`)
+                p = item.production
+                if item.IsReduceItem:
+                    if p.Left == self.G.startSymbol:
+                        self._register(self.action,(idx,self.G.EOF.Name),(ShiftReduceParser.OK,None))
+                    else:
+                        for c in item.lookaheads:
+                            self._register(self.action,(idx,c.Name),(ShiftReduceParser.REDUCE,self.G.Productions.index(p)))
+                else:
+                    
+                    if item.NextSymbol.IsTerminal:
+                        self._register(self.action,(idx,item.NextSymbol.Name),(ShiftReduceParser.SHIFT, node[item.NextSymbol.Name][0].idx))
+                    else:
+                        self._register(self.goto,(idx,item.NextSymbol.Name),(node[item.NextSymbol.Name][0].idx))
+   
+
+    def build_automaton(self,G):
+        assert len(G.startSymbol.productions) == 1, 'Grammar must be augmented'
+        
+        firsts = self.firsts
+        firsts[G.EOF] = ContainerSet(G.EOF)
+        
+        start_production = G.startSymbol.productions[0]
+        start_item = Item(start_production, 0, lookaheads=(G.EOF,))
+        start = frozenset([start_item])
+        
+        closure = self.closure_lr1(start, firsts)
+        automaton = State(frozenset(closure), True)
+        
+        pending = [ start ]
+        visited = { start: automaton }
+        
+        while pending:
+            current = pending.pop()
+            current_state = visited[current]
+            
+            for symbol in G.terminals + G.nonTerminals:
+                #  (Get/Build `next_state`)
+                a = self.goto_lr1(current_state.state,symbol,firsts,True)
+                
+                if not a:
+                    continue
+                    
+                try:
+                    next_state = visited[a]
+                except:
+                    next_state = State(frozenset(self.goto_lr1(current_state.state,symbol,firsts)),True)
+                    visited[a] = next_state
+                    pending.append(a)
+                
+                current_state.add_transition(symbol.Name, next_state)
+        
+        automaton.set_formatter(multiline_formatter)
+        return automaton
+    
+
+    def goto_lr1(self,items, symbol, firsts=None, just_kernel=False):
+        assert just_kernel or firsts is not None, '`firsts` must be provided if `just_kernel=False`'
+        items = frozenset(item.NextItem() for item in items if item.NextSymbol == symbol)
+        return items if just_kernel else self.closure_lr1(items, firsts)
+
+
+    def closure_lr1(self,items, firsts):
+        closure = ContainerSet(*items)
+        
+        changed = True
+        while changed:
+            changed = False
+            
+            new_items = ContainerSet()
+
+            #por cada item hacer expand y añadirlo a new_items
+            for item in closure:
+                e = self.expand(item,firsts)
+                new_items.extend(e)
+
+            changed = closure.update(new_items)
+            
+        return self.compress(closure)
+
+
+    def compress(self,items):
+        centers = {}
+
+        for item in items:
+            center = item.Center()
+            try:
+                lookaheads = centers[center]
+            except KeyError:
+                centers[center] = lookaheads = set()
+            lookaheads.update(item.lookaheads)
+        
+        return { Item(x.production, x.pos, set(lookahead)) for x, lookahead in centers.items() }
+    
+
+    def expand(self,item, firsts):
+        next_symbol = item.NextSymbol
+        if next_symbol is None or not next_symbol.IsNonTerminal:
+            return []
+        
+        lookaheads = ContainerSet()
+        #  (Compute lookahead for child items)
+        #calcular el first a todos los preview posibles
+        for p in item.Preview():
+            for first in self.compute_local_first(firsts,p):
+                lookaheads.add(first)
+        
+        assert not lookaheads.contains_epsilon
+        #  (Build and return child items)
+        _list = []
+        for production in next_symbol.productions:
+            _list.append(Item(production,0,lookaheads))
+        return _list
+
+    def __str__(self):
+        return 'LR(1)'
\ No newline at end of file
diff --git a/src/utils/parser/parser.py b/src/utils/parser/parser.py
new file mode 100644
index 000000000..c94fbc8cc
--- /dev/null
+++ b/src/utils/parser/parser.py
@@ -0,0 +1,130 @@
+from cmp.utils import ContainerSet
+from cmp.pycompiler import Sentence
+from itertools import islice
+from collections import deque
+
+class Parser:
+    def __init__(self,G):
+        self.G = G
+        if not self.action:
+            self.firsts = self.compute_firsts()
+            self.follows = self.compute_follows()
+            self._build_parsing_table()
+
+    def _build_parsing_table(self):
+        raise NotImplementedError()
+    
+    def _find_conflict(self):
+        raise NotImplementedError()
+    
+    # Computes First(Vt) U First(Vn) U First(alpha)
+    # P: X -> alpha
+    def compute_firsts(self):
+        firsts = {}
+        change = True
+        
+        # init First(Vt)
+        for terminal in self.G.terminals:
+            firsts[terminal] = ContainerSet(terminal)
+            
+        # init First(Vn)
+        for nonterminal in self.G.nonTerminals:
+            firsts[nonterminal] = ContainerSet()
+        
+        while change:
+            change = False
+            
+            # P: X -> alpha
+            for production in self.G.Productions:
+                X = production.Left
+                alpha = production.Right
+                
+                # get current First(X)
+                first_X = firsts[X]
+                    
+                # init First(alpha)
+                try:
+                    first_alpha = firsts[alpha]
+                except:
+                    first_alpha = firsts[alpha] = ContainerSet()
+                
+                # CurrentFirst(alpha)???
+                local_first = self.compute_local_first(firsts, alpha)
+                
+                # update First(X) and First(alpha) from CurrentFirst(alpha)
+                change |= first_alpha.hard_update(local_first)
+                change |= first_X.hard_update(local_first)
+                        
+        # First(Vt) + First(Vt) + First(RightSides)
+        return firsts
+
+    # Computes First(alpha), given First(Vt) and First(Vn) 
+    # alpha in (Vt U Vn)*
+    def compute_local_first(self,firsts, alpha):
+        first_alpha = ContainerSet()
+        
+        try:
+            alpha_is_epsilon = alpha.IsEpsilon
+        except:
+            alpha_is_epsilon = False
+        
+        # alpha == epsilon ? First(alpha) = { epsilon }
+        if alpha_is_epsilon:
+            first_alpha.set_epsilon()
+
+        # alpha = X1 ... XN
+        # First(Xi) subconjunto First(alpha)
+        # epsilon pertenece a First(X1)...First(Xi) ? First(Xi+1) subconjunto de First(X) y First(alpha)
+        # epsilon pertenece a First(X1)...First(XN) ? epsilon pertence a First(X) y al First(alpha)
+        else:
+            for item in alpha:
+                first_symbol = firsts[item]
+                first_alpha.update(first_symbol)
+                if not  first_symbol.contains_epsilon:
+                    break
+            else:
+                first_alpha.set_epsilon()
+        
+        # First(alpha)
+        return first_alpha
+    
+
+    def compute_follows(self):
+        follows = { }
+        change = True
+        
+        local_firsts = {}
+        
+        # init Follow(Vn)
+        for nonterminal in self.G.nonTerminals:
+            follows[nonterminal] = ContainerSet()
+        follows[self.G.startSymbol] = ContainerSet(self.G.EOF)
+        
+        while change:
+            change = False
+            
+            # P: X -> alpha
+            for production in self.G.Productions:
+                X = production.Left
+                alpha = production.Right
+                
+                follow_X = follows[X]
+                
+                # X -> zeta Y beta
+                # First(beta) - { epsilon } subset of Follow(Y)
+                # beta ->* epsilon or X -> zeta Y ? Follow(X) subset of Follow(Y)
+                for i,symbol in enumerate(alpha):
+                        if symbol.IsNonTerminal:
+                            follow_Y = follows[symbol]
+                            try:
+                                firts_beta = local_firsts[alpha,i]
+                            except KeyError:
+                                firts_beta = local_firsts[alpha,i] = self.compute_local_first(self.firsts,islice(alpha,i+1,None))
+
+                            change |= follow_Y.update(firts_beta)
+
+                            if firts_beta.contains_epsilon:
+                                change |= follow_Y.update(follow_X)
+
+        # Follow(Vn)
+        return follows
\ No newline at end of file
diff --git a/src/utils/parser/shift_reduce_parser.py b/src/utils/parser/shift_reduce_parser.py
new file mode 100644
index 000000000..bed02cf7b
--- /dev/null
+++ b/src/utils/parser/shift_reduce_parser.py
@@ -0,0 +1,65 @@
+from utils.parser.parser import Parser
+
+class ShiftReduceParser(Parser):
+    SHIFT = 'SHIFT'
+    REDUCE = 'REDUCE'
+    OK = 'OK'
+    
+    def __init__(self, G):
+        try:
+            self.action
+        except AttributeError:
+            self.action = {}
+            self.goto = {}
+            self.automaton = None
+
+        self.error = ''
+        Parser.__init__(self, G)
+
+    def __call__(self, w):
+        stack = [ 0 ]
+        cursor = 0
+        output = []
+        operations = []
+        
+        while True:
+            state = stack[-1]
+            lookahead = w[cursor]
+                
+            # (Detect error)
+            
+            try:
+                action, tag = self.action[state, self.G[lookahead.token_type].Name]
+
+                # (Shift case)
+                if action == self.SHIFT:
+                    stack.append(tag)
+                    cursor += 1
+
+                # (Reduce case)
+                elif action == self.REDUCE:
+                    tag = self.G.Productions[tag]
+                    output.append(tag)
+                    for _ in tag.Right: stack.pop()
+                    a = self.goto[stack[-1], tag.Left.Name]
+                    stack.append(a)
+
+
+                # (OK case)
+                elif action == self.OK:
+                    return output, operations
+
+                # (Invalid case)
+                else:
+                    raise Exception ['Error...']
+
+                operations.append(action)
+
+            except:
+                self.error = f'({lookahead.line}, {lookahead.column}) - SyntacticError: ERROR at or near "{lookahead.lex}"'
+                return None, None
+
+    @staticmethod
+    def _register(table, key, value):
+        assert key not in table or table[key] == value, 'Shift-Reduce or Reduce-Reduce conflict!!!'
+        table[key] = value
\ No newline at end of file

From 59abcc7633d473dd20a71f30be7f8f5c32deb9af Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 00:28:24 -0800
Subject: [PATCH 06/83] type_collector-type_builder

---
 src/cmp/evaluation.py                      |  2 +-
 src/cmp/semantic.py                        | 26 ++-----
 src/utils/semantic_check/type_builder.py   | 89 ++++++++++++++++++++++
 src/utils/semantic_check/type_collector.py | 56 ++++++++++++++
 4 files changed, 152 insertions(+), 21 deletions(-)
 create mode 100644 src/utils/semantic_check/type_builder.py
 create mode 100644 src/utils/semantic_check/type_collector.py

diff --git a/src/cmp/evaluation.py b/src/cmp/evaluation.py
index 90bdbf935..37390cfdc 100644
--- a/src/cmp/evaluation.py
+++ b/src/cmp/evaluation.py
@@ -11,7 +11,7 @@ def evaluate_reverse_parse(G, right_parse, operations, tokens):
     for operation in operations:
         if operation == ShiftReduceParser.SHIFT:
             token = next(tokens)
-            stack.append(token.lex)
+            stack.append(token)
         elif operation == ShiftReduceParser.REDUCE:
             production = next(right_parse)
             head, body = production
diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
index c463fbe25..8cf53c8a2 100644
--- a/src/cmp/semantic.py
+++ b/src/cmp/semantic.py
@@ -1,6 +1,8 @@
 import itertools as itt
 from collections import OrderedDict
 
+from utils.COOL_Lexer import Token
+
 
 class SemanticError(Exception):
     @property
@@ -124,8 +126,6 @@ def __repr__(self):
 
     def join(self, other):
         if self is ErrorType(): return ErrorType()
-        if self.name == 'AUTO_TYPE' or other.name == 'AUTO_TYPE':
-            return self if self.name != 'AUTO_TYPE' else other
 
         current_parent = other
         while not self.conforms_to(current_parent):
@@ -133,22 +133,6 @@ def join(self, other):
 
         return current_parent
 
-class AutoType(Type):
-    def __init__(self):
-        Type.__init__(self, 'AUTO_TYPE')
-
-    def conforms_to(self, other):
-        return True
-
-    def bypass(self):
-        return True
-
-    def get_method(self, name:str):
-        raise SemanticError(None)
-
-    def __eq__(self, other):
-        return isinstance(other, Type)
-
 class ErrorType(Type):
     def __init__(self):
         Type.__init__(self, '<error>')
@@ -189,13 +173,15 @@ class Context:
     def __init__(self):
         self.types = {}
 
-    def create_type(self, name:str):
+    def create_type(self, token):
+        name = token.lex if isinstance(token, Token) else token
         if name in self.types:
             raise SemanticError(f'Type with the same name ({name}) already in context.')
         typex = self.types[name] = Type(name)
         return typex
 
-    def get_type(self, name:str):
+    def get_type(self, token):
+        name = token.lex if isinstance(token, Token) else token
         if name == '<error>':
             return ErrorType()
             
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
new file mode 100644
index 000000000..de0ba4add
--- /dev/null
+++ b/src/utils/semantic_check/type_builder.py
@@ -0,0 +1,89 @@
+import cmp.visitor as visitor
+from utils.ast.AST_Nodes import ast_nodes as nodes
+from cmp.semantic import SemanticError, ErrorType
+
+class TypeBuilder:
+    def __init__(self, context, errors):
+        self.context = context
+        self.current_type = None
+        self.errors = errors
+    
+    @visitor.on('node')
+    def visit(self, node):
+        pass
+    
+    @visitor.when(nodes.ProgramNode)
+    def visit(self,node):
+        for dec in node.declarations:
+            self.visit(dec)
+        return
+    
+
+    @visitor.when(nodes.ClassDeclarationNode)
+    def visit(self,node):
+        self.current_type = self.context.get_type(node.id)
+
+        if node.parent is not None:
+
+            if node.parent.lex in ['Int', 'String', 'SELF_TYPE', 'Bool']:
+                self.errors.append(f'Cannot inherit from {node.parent}')
+
+            else:
+                try:
+                    parent_type = self.context.get_type(node.parent)
+                except SemanticError as se:
+                    parent_type = ErrorType()
+                    self.errors.append(se.text)
+                    
+                try:
+                    self.current_type.set_parent(parent_type)
+                except SemanticError as se:
+                    self.errors.append(se.text)
+
+        elif not self.current_type.parent:
+            self.current_type.set_parent(self.context.get_type('Object'))
+        
+        for feat in node.features:
+            self.visit(feat)
+
+        return
+    
+
+    @visitor.when(nodes.AttrDeclarationNode)
+    def visit(self,node):
+        try:
+            attrType = self.context.get_type(node.type)
+            self.current_type.define_attribute(node.id, attrType)
+        except SemanticError as se:
+            self.errors.append(se.text)
+            self.current_type.define_attribute(node.id, ErrorType())
+
+        return
+
+    
+    @visitor.when(nodes.MethDeclarationNode)
+    def visit(self,node):
+        param_names = []
+        param_types = []
+
+        for name, typex in node.params:
+            param_names.append(name)
+
+            try:
+                param_types.append(self.context.get_type(typex))
+            except SemanticError as se:
+                self.errors.append(se.text)
+                param_types.append(ErrorType())
+
+        try:       
+            returnType = self.context.get_type(node.type)
+        except SemanticError as se:
+            self.errors.append(se.text)
+            returnType = ErrorType()
+        
+        try:
+            self.current_type.define_method(node.id, param_names, param_types, returnType)
+        except SemanticError as se:
+            self.errors.append(se.text)
+
+        return
\ No newline at end of file
diff --git a/src/utils/semantic_check/type_collector.py b/src/utils/semantic_check/type_collector.py
new file mode 100644
index 000000000..1a5b4f828
--- /dev/null
+++ b/src/utils/semantic_check/type_collector.py
@@ -0,0 +1,56 @@
+import cmp.visitor as visitor
+from utils.ast.AST_Nodes import ast_nodes as nodes
+from cmp.semantic import SemanticError
+
+class TypeCollector(object):
+    def __init__(self, context, errors):
+        self.context = context
+        self.errors = errors
+    
+    @visitor.on('node')
+    def visit(self, node):
+        pass
+    
+    @visitor.when(nodes.ProgramNode)
+    def visit(self, node):
+
+        # añadimos algunos tipos predeterminados
+        object_type = self.context.create_type('Object')
+        self_type = self.context.create_type('SELF_TYPE')
+        int_type = self.context.create_type('Int')
+        string_type = self.context.create_type('String')
+        bool_type = self.context.create_type('Bool')
+        io_type = self.context.create_type('IO')
+
+        # todos heredan de Object
+        int_type.set_parent(object_type)
+        string_type.set_parent(object_type)
+        bool_type.set_parent(object_type)
+        io_type.set_parent(object_type)
+
+        # agregar los metodos a los tipos basicos
+        object_type.define_method('abort', [], [], object_type) 
+        object_type.define_method('type_name', [], [], string_type) 
+        object_type.define_method('copy', [], [], self_type) 
+
+        io_type.define_method('out_string', ['x'], [string_type], self_type) 
+        io_type.define_method('out_int', ['x'], [int_type], self_type) 
+        io_type.define_method('in_string', [], [], string_type) 
+        io_type.define_method('in_int', [], [], int_type) 
+
+        string_type.define_method('length', [], [], int_type) 
+        string_type.define_method('concat', ['s'], [string_type], string_type) 
+        string_type.define_method('substr', ['i', 'l'], [int_type, int_type], string_type) 
+
+        for dec in node.declarations:
+            self.visit(dec)
+        return
+    
+
+    @visitor.when(nodes.ClassDeclarationNode)
+    def visit(self,node):
+        try:
+            self.context.create_type(node.id)
+        except SemanticError as se:
+            self.errors.append(se.text)
+        return
\ No newline at end of file

From 06712f449213f3f12d5ded1850c11a0b7e490cc6 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 16:11:51 -0800
Subject: [PATCH 07/83] fixing some issues for type_check

---
 src/cmp/evaluation.py                    |  1 +
 src/cmp/semantic.py                      | 44 ++++++++++--------------
 src/utils/COOL_Grammar.py                | 18 +++++-----
 src/utils/COOL_Lexer.py                  |  5 ++-
 src/utils/ast/AST_Nodes.py               |  3 +-
 src/utils/semantic_check/type_builder.py |  5 ++-
 6 files changed, 36 insertions(+), 40 deletions(-)

diff --git a/src/cmp/evaluation.py b/src/cmp/evaluation.py
index 37390cfdc..aa6e8f665 100644
--- a/src/cmp/evaluation.py
+++ b/src/cmp/evaluation.py
@@ -12,6 +12,7 @@ def evaluate_reverse_parse(G, right_parse, operations, tokens):
         if operation == ShiftReduceParser.SHIFT:
             token = next(tokens)
             stack.append(token)
+            
         elif operation == ShiftReduceParser.REDUCE:
             production = next(right_parse)
             head, body = production
diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
index 8cf53c8a2..1555fabf2 100644
--- a/src/cmp/semantic.py
+++ b/src/cmp/semantic.py
@@ -50,7 +50,8 @@ def set_parent(self, parent):
             raise SemanticError(f'Parent type is already set for {self.name}.')
         self.parent = parent
 
-    def get_attribute(self, name:str):
+    def get_attribute(self, token):
+        name = token if isinstance(token, str) else token.lex
         try:
             return next(attr for attr in self.attributes if attr.name == name)
         except StopIteration:
@@ -61,7 +62,8 @@ def get_attribute(self, name:str):
             except SemanticError:
                 raise SemanticError(f'Attribute "{name}" is not defined in {self.name}.')
 
-    def define_attribute(self, name:str, typex):
+    def define_attribute(self, token, typex):
+        name = token if isinstance(token, str) else token.lex
         try:
             self.get_attribute(name)
         except SemanticError:
@@ -71,7 +73,8 @@ def define_attribute(self, name:str, typex):
         else:
             raise SemanticError(f'Attribute "{name}" is already defined in {self.name}.')
 
-    def get_method(self, name:str):
+    def get_method(self, token):
+        name = token if isinstance(token, str) else token.lex
         try:
             return next(method for method in self.methods if method.name == name)
         except StopIteration:
@@ -82,7 +85,8 @@ def get_method(self, name:str):
             except SemanticError:
                 raise SemanticError(f'Method "{name}" is not defined in {self.name}.')
 
-    def define_method(self, name:str, param_names:list, param_types:list, return_type):
+    def define_method(self, token, param_names:list, param_types:list, return_type):
+        name = token if isinstance(token, str) else token.lex
         if name in (method.name for method in self.methods):
             raise SemanticError(f'Method "{name}" already defined in {self.name}')
 
@@ -143,7 +147,7 @@ def conforms_to(self, other):
     def bypass(self):
         return True
 
-    def get_method(self, name:str):
+    def get_method(self, token):
         raise SemanticError(None)
     
     def __eq__(self, other):
@@ -174,14 +178,14 @@ def __init__(self):
         self.types = {}
 
     def create_type(self, token):
-        name = token.lex if isinstance(token, Token) else token
+        name = token if isinstance(token, str) else token.lex
         if name in self.types:
             raise SemanticError(f'Type with the same name ({name}) already in context.')
         typex = self.types[name] = Type(name)
         return typex
 
     def get_type(self, token):
-        name = token.lex if isinstance(token, Token) else token
+        name = token if isinstance(token, str) else token.lex
         if name == '<error>':
             return ErrorType()
             
@@ -200,20 +204,6 @@ class VariableInfo:
     def __init__(self, name, vtype):
         self.name = name
         self.type = vtype
-        self.expected_types = []
-
-    def update_type(self):
-        infered_type = self.expected_types[0] if self.expected_types else None
-        
-        for typex in self.expected_types[1:]:
-            infered_type = infered_type.join(typex)
-            
-        self.type = infered_type
-        
-        if not self.type:
-            self.type = AutoType()
-        
-        self.expected_types = []
 
 
 class Scope:
@@ -231,20 +221,24 @@ def create_child(self):
         self.children.append(child)
         return child
 
-    def define_variable(self, vname, vtype):
+    def define_variable(self, token, vtype):
+        vname = token if isinstance(token, str) else token.lex
         info = VariableInfo(vname, vtype)
         self.locals.append(info)
         return info
 
-    def find_variable(self, vname, index=None):
+    def find_variable(self, token, index=None):
+        vname = token if isinstance(token, str) else token.lex
         locals = self.locals if index is None else itt.islice(self.locals, index)
         try:
             return next(x for x in locals if x.name == vname)
         except StopIteration:
             return self.parent.find_variable(vname, self.index) if self.parent is not None else None
 
-    def is_defined(self, vname):
+    def is_defined(self, token):
+        vname = token if isinstance(token, str) else token.lex
         return self.find_variable(vname) is not None
 
-    def is_local(self, vname):
+    def is_local(self, token):
+        vname = token if isinstance(token, str) else token.lex
         return any(True for x in self.locals if x.name == vname)
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 1bd287126..9cd165f25 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -70,17 +70,17 @@ def build_COOL_Grammar():
 
     expr %= comp, lambda h,s: s[1]
 
-    comp %= comp + less + arith, lambda h,s: node.LessThanNode(s[1],s[3])
-    comp %= comp + lesse + arith, lambda h,s: node.LessEqualNode(s[1],s[3])
-    comp %= comp + equal + arith, lambda h,s: node.EqualNode(s[1],s[3])
+    comp %= comp + less + arith, lambda h,s: node.LessThanNode(s[1],s[3],s[2])
+    comp %= comp + lesse + arith, lambda h,s: node.LessEqualNode(s[1],s[3],s[2])
+    comp %= comp + equal + arith, lambda h,s: node.EqualNode(s[1],s[3],s[2])
     comp %= arith, lambda h,s: s[1]
 
-    arith %= arith + plus + term, lambda h,s: node.PlusNode(s[1],s[3])
-    arith %= arith + minus + term, lambda h,s: node.MinusNode(s[1],s[3])
+    arith %= arith + plus + term, lambda h,s: node.PlusNode(s[1],s[3],s[2])
+    arith %= arith + minus + term, lambda h,s: node.MinusNode(s[1],s[3],s[2])
     arith %= term, lambda h,s:s[1]
 
-    term %= term + star + factor, lambda h,s: node.StarNode(s[1],s[3])
-    term %= term + div + factor, lambda h,s: node.DivNode(s[1],s[3])
+    term %= term + star + factor, lambda h,s: node.StarNode(s[1],s[3],s[2])
+    term %= term + div + factor, lambda h,s: node.DivNode(s[1],s[3],s[2])
     term %= factor, lambda h,s: s[1]
 
     factor %= isvoid + factor, lambda h,s: node.IsVoidNode(s[2])
@@ -104,6 +104,4 @@ def build_COOL_Grammar():
     arg_list %= expr + comma + arg_list, lambda h,s: [s[1]] + s[3]
     arg_list %= G.Epsilon, lambda h,s: []
 
-    return G
-
-
+    return G
\ No newline at end of file
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 2d53d4307..9b684991f 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -14,7 +14,7 @@ def __init__(self, lex, ttype, line, column):
         self.column = column
  
     def __str__(self): 
-        return f'{self.ttype}: {self.lex}'
+        return f'{self.token_type}: {self.lex}'
  
 '''
 El lexer es el resultado de la union de todas las expresiones regulares que forman
@@ -50,7 +50,7 @@ def tokenize(self,text):
                 if len(text) <= 0: continue
 
             lexeme = match.group()
-            self.column += len(lexeme)
+            self.column += len(lexeme) if lexeme != '\t' else 4
 
             if lexeme == '\n':
                 self.line += 1
@@ -134,7 +134,6 @@ def tokenize(self,text):
 
             token_type = match.lastgroup if lexeme.lower() not in self.keywords and match.lastgroup is not None else match.group().lower()
 
-            a = self.column - len(lexeme) + 1 if lexeme[:2] != '(*' and lexeme[0] != '"' else self.column
             yield lexeme, token_type, self.line, self.column - len(lexeme) + 1 if lexeme[:2] != '(*' and lexeme[0] != '"' else self.column 
  
             text = text[match.end():] if lexeme[:2] != '(*' and lexeme[0] != '"' else text
diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index 009e17348..0f45c1f1d 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -79,9 +79,10 @@ def __init__(self, lex):
             self.lex = lex
 
     class BinaryNode(ExpressionNode):
-        def __init__(self, left, right):
+        def __init__(self, left, right, symbol):
             self.left = left
             self.right = right
+            self.symbol = symbol
 
 
     class ConstantNumNode(AtomicNode):
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index de0ba4add..cec2f0ab8 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -2,6 +2,9 @@
 from utils.ast.AST_Nodes import ast_nodes as nodes
 from cmp.semantic import SemanticError, ErrorType
 
+NOT_INHERIT_FROM_BASICS_TYPES = '(%s, %s) - TypeError: Type %s cannot inherit from basic type %s'
+
+
 class TypeBuilder:
     def __init__(self, context, errors):
         self.context = context
@@ -26,7 +29,7 @@ def visit(self,node):
         if node.parent is not None:
 
             if node.parent.lex in ['Int', 'String', 'SELF_TYPE', 'Bool']:
-                self.errors.append(f'Cannot inherit from {node.parent}')
+                self.errors.append(NOT_INHERIT_FROM_BASICS_TYPES % (node.id.line, node.id.column, node.id.lex, node.parent.lex))
 
             else:
                 try:

From c9f53ac3ca6f62e6e6bdfda378e6a5531a8eda39 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 23:08:51 -0800
Subject: [PATCH 08/83] ast with tokens files-columns

---
 src/utils/ast/AST_Nodes.py | 77 ++++++++++++++++++++++++++------------
 1 file changed, 53 insertions(+), 24 deletions(-)

diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index 0f45c1f1d..afb715ae8 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -1,7 +1,11 @@
+from utils.COOL_Lexer import Token
+
+
 class ast_nodes:
 
     class Node:
-        pass
+        line = 0
+        column = 0
 
 
     class ProgramNode(Node):
@@ -15,74 +19,99 @@ class ExpressionNode(Node):
 
 
     class ClassDeclarationNode(DeclarationNode):
-        def __init__(self, idx, features, parent=None):
-            self.id = idx
+        def __init__(self, token, features, parent=None):
+            self.id = token.lex
+            self.line = token.line
+            self.column = token.column
             self.parent = parent
             self.features = features
 
     class MethDeclarationNode(DeclarationNode):
-        def __init__(self, idx, params, return_type, body):
-            self.id = idx
+        def __init__(self, token, params, return_type, body):
+            self.id = token.lex
+            self.line = token.line
+            self.column = token.column
             self.params = params
             self.type = return_type
             self.body = body
 
     class AttrDeclarationNode(DeclarationNode):
-        def __init__(self, idx, typex, expr = None):
-            self.id = idx
+        def __init__(self, token, typex, expr = None):
+            self.id = token.lex
+            self.line = token.line
+            self.column = token.column
             self.type = typex
             self.expr = expr
 
     class AssignNode(ExpressionNode):
-        def __init__(self, idx, expr):
-            self.id = idx
+        def __init__(self, token, expr, token_pos):
+            self.id = token.lex
+            self.line = token_pos.line
+            self.column = token_pos.column
             self.expr = expr
 
     class CallNode(ExpressionNode):
-        def __init__(self, idx, args, obj = None, typex = None):
-            self.obj = obj
+        def __init__(self, token, args, obj = None, typex = None):
+            self.obj = obj.lex
             self.type = typex
-            self.id = idx
+            self.id = token.lex
+            self.line = token.line
+            self.column = token.column
             self.args = args
     
     class IfThenElseNode(ExpressionNode):
-        def __init__(self, if_expr, then_expr, else_expr):
+        def __init__(self, if_expr, then_expr, else_expr,token):
             self.if_expr = if_expr
             self.then_expr = then_expr
             self.else_expr = else_expr
+            self.line = token.line
+            self.column = token.column
     
     class WhileNode(ExpressionNode):
-        def __init__(self, conditional_expr, loop_expr):
+        def __init__(self, conditional_expr, loop_expr, token):
             self.conditional_expr = conditional_expr
             self.loop_expr = loop_expr
+            self.line = token.line
+            self.column = token.column
 
     class BlockNode(ExpressionNode):
-        def __init__(self, expr_list):
+        def __init__(self, expr_list, token):
             self.expr_list = expr_list
+            self.line = token.line
+            self.column = token.column
     
     class LetNode(ExpressionNode):
-        def __init__(self, identifiers, in_expr):
-            self.identifiers = identifiers
+        def __init__(self, identifiers, in_expr, token):
+            self.identifiers = [tuple([item.lex if isinstance(item, Token) else item for item in _list]) for _list in identifiers]
             self.in_expr = in_expr
+            self.line = token.line
+            self.column = token.column
 
     class CaseNode(ExpressionNode):
-        def __init__(self, predicate, branches):
+        def __init__(self, predicate, branches, token):
             self.predicate = predicate
-            self.branches = branches
+            self.branches = [tuple([item.lex if isinstance(item, Token) else item for item in _list]) for _list in branches]
+            self.line = token.line
+            self.column = token.column
     
     class NotNode(ExpressionNode):
-        def __init__(self, expr):
+        def __init__(self, expr, token):
             self.expr = expr
+            self.line = token.line
+            self.column = token.column
 
     class AtomicNode(ExpressionNode):
-        def __init__(self, lex):
-            self.lex = lex
+        def __init__(self, token):
+            self.lex = token.lex
+            self.line = token.line
+            self.column = token.column
 
     class BinaryNode(ExpressionNode):
-        def __init__(self, left, right, symbol):
+        def __init__(self, left, right, token):
             self.left = left
             self.right = right
-            self.symbol = symbol
+            self.line = token.line
+            self.column = token.column 
 
 
     class ConstantNumNode(AtomicNode):

From 08ec1767c76047ec680cf7f9f998d6db6843bca2 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 23:10:22 -0800
Subject: [PATCH 09/83] cool grammar lines-columns

---
 src/utils/COOL_Grammar.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 9cd165f25..ed1760b15 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -46,24 +46,24 @@ def build_COOL_Grammar():
 
     param %= idx + colon + typex, lambda h,s: [s[1],s[3]]
 
-    expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3])
-    expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6])
-    expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4])
-    expr %= notx + expr, lambda h,s: node.NotNode(s[2])
+    expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3],s[2])
+    expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6],s[1])
+    expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4],s[1])
+    expr %= notx + expr, lambda h,s: node.NotNode(s[2],s[1])
 
-    expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2])
+    expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2],s[1])
 
     expr_list %= expr + semi, lambda h,s: [s[1]]
     expr_list %= expr + semi + expr_list, lambda h,s: [s[1]] + s[3]
     
-    expr %= let + id_list + inx + expr, lambda h,s: node.LetNode(s[2],s[4])
+    expr %= let + id_list + inx + expr, lambda h,s: node.LetNode(s[2],s[4],s[1])
 
     id_list %= idx + colon + typex, lambda h,s: [(s[1],s[3],None)]
     id_list %= idx + colon + typex + arrow + expr, lambda h,s: [(s[1],s[3],s[5])]
     id_list %= idx + colon + typex + comma + id_list, lambda h,s: [(s[1],s[3],None)] + s[5]
     id_list %= idx + colon + typex + arrow + expr + comma + id_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]
 
-    expr %= case + expr + of + case_list + esac, lambda h,s: node.CaseNode(s[2],s[4])
+    expr %= case + expr + of + case_list + esac, lambda h,s: node.CaseNode(s[2],s[4],s[1])
 
     case_list %= idx + colon + typex + darrow + expr + semi, lambda h,s: [(s[1],s[3],s[5])]
     case_list %= idx + colon + typex + darrow + expr + semi + case_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]

From 74b84d17aeafc63f566cf58b65d05cdab70f6352 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 23:28:32 -0800
Subject: [PATCH 10/83] type checker

---
 src/utils/semantic_check/type_checker.py | 452 +++++++++++++++++++++++
 1 file changed, 452 insertions(+)
 create mode 100644 src/utils/semantic_check/type_checker.py

diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
new file mode 100644
index 000000000..b21d62088
--- /dev/null
+++ b/src/utils/semantic_check/type_checker.py
@@ -0,0 +1,452 @@
+import cmp.visitor as visitor
+from utils.ast.AST_Nodes import ast_nodes as nodes
+from cmp.semantic import SemanticError, ErrorType, Scope
+
+MAIN_DONT_EXISTS = '(0, 0) - TypeError: COOL program must have a class Main'
+MAIN_METHOD_DONT_EXISTS = '(%s, %s) - TypeError: Main class must have a method main()'
+MAIN_METHOD_DONT_HAVE_PARAMS = '(%s, %s) - TypeError: main method must not have params'
+
+INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
+
+INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
+WRONG_SIGNATURE = '(%s, %s) - TypeError: Method "%s" already defined in "%s" with a different signature.'
+SELF_IS_READONLY = '(%s, %s) - TypeError: Variable "self" is read-only.'
+LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable "%s" is already defined in method "%s".'
+
+VARIABLE_NOT_DEFINED = '(%s, %s) - TypeError: Variable "%s" is not defined in "%s".'
+
+
+
+class TypeChecker:
+    def __init__(self, context, errors):
+        self.context = context
+        self.current_type = None
+        self.current_method = None
+        self.errors = errors
+
+    @visitor.on('node')
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.ProgramNode)
+    def visit(self, node, scope=None):
+        # verificando que el programa tenga una clase Main
+        try:
+            self.context.get_type('Main')
+
+        except SemanticError:
+            self.errors.append(MAIN_DONT_EXISTS)
+
+
+        scope = Scope() if scope == None else scope
+
+        for dec in node.declarations:
+            self.visit(dec, scope.create_child())
+        
+        return scope
+    
+
+    @visitor.when(nodes.ClassDeclarationNode)
+    def visit(self, node, scope):
+        self.current_type = self.context.get_type(node.id)
+
+        # verificando la existencia del metodo main
+        if self.current_type.name == 'Main':
+            try:
+                self.current_type.get_method('main')
+
+            except SemanticError:
+                self.errors.append(MAIN_METHOD_DONT_EXISTS % (node.id.line, node.id.column))
+
+
+        # verficando herencia circular en los ancestros de current_type (deben llegar a object sin pasar por el nuevamente)
+        current_parent = self.current_type.parent
+
+        while current_parent != self.context.get_type('Object') and current_parent != None:
+            if current_parent == self.current_type:
+                self.errors.append(f'Class {self.current_type.name} cannot inherit from class {self.current_type.parent.name}')
+                self.current_type.parent = ErrorType()
+                break
+            current_parent = current_parent.parent
+        
+        attrs = [feat for feat in node.features if isinstance(feat, nodes.AttrDeclarationNode)]
+        for attr in attrs:
+            self.visit(attr, scope)
+
+        meths = [feat for feat in node.features if isinstance(feat, nodes.MethDeclarationNode)]
+        for meth in meths:
+            self.visit(meth, scope.create_child())
+
+        return
+
+    @visitor.when(nodes.AttrDeclarationNode)
+    def visit(self, node, scope):
+        attr_type = self.context.get_type(node.type) if node.type.lex != 'SELF_TYPE' else self.current_type
+
+        if node.expr:
+            type_expr = self.visit(node.expr, scope.create_child())
+
+            if not type_expr.conforms_to(attr_type):
+                self.errors.append(INCOMPATIBLE_TYPES % (node.type.line, node.type.column, type_expr.name, attr_type.name))
+
+        if node.id.lex == 'self':
+            self.errors.append('self cannot be used as an attribute name')
+
+        scope.define_variable(node.id, attr_type)
+
+        return 
+    
+
+    @visitor.when(nodes.MethDeclarationNode)
+    def visit(self, node, scope):
+        self.current_method = self.current_type.get_method(node.id)
+
+        # verificando que el metodo main no tenga parametros
+        if self.current_method.name == 'main' and self.current_method.param_names:
+            self.errors.append(MAIN_METHOD_DONT_HAVE_PARAMS % (node.id.line, node.id.column))
+
+        # verificabdo redefinicion de metodos
+        current_parent = self.current_type.parent
+
+        while current_parent != self.context.get_type('Object') and current_parent != None:
+            try:
+                parent_method = current_parent.get_method(node.id)
+                if parent_method != self.current_method:
+                    self.error.append(WRONG_SIGNATURE % (self.current_method.name, current_parent.name))
+                    break
+            except:
+                pass
+            current_parent = current_parent.parent 
+
+
+        scope.define_variable('self', self.current_type)
+
+        for name, typex in zip(self.current_method.param_names, self.current_method.param_types):
+            if scope.is_local(name):
+                self.errors.append(LOCAL_ALREADY_DEFINED % (name,self.current_method.name))
+
+            elif typex == 'SELF_TYPE':
+                self.errors.append('SELF_TYPE cannot be used as a parameter type')
+                scope.define_variable(name, ErrorType())
+
+            else:
+                scope.define_variable(name, self.context.get_type(typex.name))
+        
+        body_type = self.visit(node.body, scope)
+        try:
+            returnType = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
+        except SemanticError as se:
+            self.errors.append(se.text)
+            returnType = ErrorType()
+
+        if not body_type.conforms_to(returnType):
+            self.errors.append(INCOMPATIBLE_TYPES % (body_type.name, returnType.name))
+
+        return
+
+
+    @visitor.when(nodes.AssignNode)
+    def visit(self, node, scope):
+        var = scope.find_variable(node.id)
+
+        type_expr = self.visit(node.expr, scope.create_child())
+
+        if var is None:
+            self.errors.append(VARIABLE_NOT_DEFINED % (node.id, self.current_method.name))
+
+        elif var.name == 'self':
+            self.errors.append(SELF_IS_READONLY)
+
+        elif not type_expr.conforms_to(var.type):
+            self.errors.append(INCOMPATIBLE_TYPES % (type_expr.name, var.type.name))
+
+        return type_expr
+
+
+    @visitor.when(nodes.CallNode)
+    def visit(self, node, scope):
+        if node.obj is None:
+            obj_type = self.current_type
+        else:
+            obj_type = self.visit(node.obj, scope)
+
+        if node.type is not None:
+            if node.type == 'SELF_TYPE':
+                self.errors.append('SELF_TYPE cannot be used as a type of a dispatch')
+                typex = ErrorType()
+
+            else:
+                try:
+                    typex = self.context.get_type(node.type)
+                except SemanticError as se:
+                    self.errors.append(se.text)
+                    typex = ErrorType()
+
+                if not obj_type.conforms_to(typex):
+                    self.errors.append(INCOMPATIBLE_TYPES % (obj_type.name, typex.name))
+
+            obj_type = typex
+
+        try:
+            meth = obj_type.get_method(node.id)
+        except SemanticError as se:
+            if se.text: self.errors.append(se.text)
+            for arg in node.args:
+                self.visit(arg, scope)
+            return ErrorType()
+        
+        if len(node.args) != len(meth.param_names):
+            self.errors.append(f'Method {meth.name} defined in {obj_type.name} receive {len(meth.param_names)} parameters')
+
+        for i,arg in enumerate(node.args):
+            type_arg = self.visit(arg, scope)
+            if i< len(meth.param_types) and not type_arg.conforms_to(meth.param_types[i]):
+                self.errors.append(INCOMPATIBLE_TYPES % (type_arg.name, meth.param_types[i].name))
+        
+        return meth.return_type if meth.return_type.name != 'SELF_TYPE' else obj_type
+
+
+    @visitor.when(nodes.IfThenElseNode)
+    def visit(self, node, scope):
+        if_type = self.visit(node.if_expr, scope.create_child())
+
+        if not if_type.conforms_to(self.context.get_type('Bool')):
+            self.errors.append(INCOMPATIBLE_TYPES % (if_type.name, 'Bool'))
+        
+        then_type = self.visit(node.then_expr, scope.create_child())
+        else_type = self.visit(node.else_expr, scope.create_child())
+
+        return then_type.join(else_type)
+
+
+    @visitor.when(nodes.WhileNode)
+    def visit(self, node, scope):
+        type_conditional = self.visit(node.conditional_expr, scope)
+
+        if not type_conditional.conforms_to(self.context.get_type('Bool')):
+            self.errors.append(INCOMPATIBLE_TYPES % (type_conditional.name, 'Bool'))
+        
+        self.visit(node.loop_expr, scope.create_child())
+
+        return self.context.get_type('Object')
+    
+
+    @visitor.when(nodes.BlockNode)
+    def visit(self, node, scope):
+        type_expr = ErrorType()
+
+        for expr in node.expr_list:
+            type_expr = self.visit(expr, scope.create_child())
+
+        return type_expr
+
+    
+    @visitor.when(nodes.LetNode)
+    def visit(self, node, scope):
+        for idx, typex, id_expr in node.identifiers:
+            try:
+                id_type = self.context.get_type(typex) if typex != 'SELF_TYPE' else self.current_type
+            except SemanticError as se:
+                id_type = ErrorType()
+                self.errors.append(se.text)
+            
+            if scope.is_local(idx):
+                self.errors.append(LOCAL_ALREADY_DEFINED % (idx, self.current_method.name))
+            else:
+                scope.define_variable(idx, id_type)
+            
+            if id_expr is not None:
+                id_expr_type = self.visit(id_expr, scope.create_child())
+                if not id_expr_type.conforms_to(id_type):
+                    self.errors.append(INCOMPATIBLE_TYPES % (id_expr_type.name, id_type.name))
+            
+        body_type = self.visit(node.in_expr, scope.create_child())
+
+        return body_type
+            
+
+    @visitor.when(nodes.CaseNode)
+    def visit(self, node, scope):
+        self.visit(node.predicate, scope)
+        case_type = None
+
+        for idx, typex, expr in node.branches:
+            if typex == 'SELF_TYPE':
+                self.errors.append('SELF_TYPE cannot be used as a type of a case branch')
+                id_type = ErrorType()
+                
+            else:
+                try:
+                    id_type = self.context.get_type(typex)
+                except SemanticError as se:
+                    id_type = ErrorType()
+                    self.errors.append(se.text)
+            
+            inner_scope = scope.create_child()
+            inner_scope.define_variable(idx, id_type)
+
+            type_expr = self.visit(expr, inner_scope)
+            case_type = case_type.join(type_expr) if case_type is not None else type_expr
+
+        return case_type
+
+    
+    @visitor.when(nodes.NotNode)
+    def visit(self, node, scope):
+        typex = self.visit(node.expr, scope)
+
+        if not typex.conforms_to(self.context.get_type('Bool')):
+            self.errors.append(INCOMPATIBLE_TYPES % (typex.name, 'Bool'))
+            return ErrorType()
+
+        return typex
+
+    
+    @visitor.when(nodes.ConstantNumNode)
+    def visit(self, node, scope):
+        return self.context.get_type('Int')
+
+    
+    @visitor.when(nodes.ConstantBoolNode)
+    def visit(self, node, scope):
+        return self.context.get_type('Bool')
+
+
+    @visitor.when(nodes.ConstantStringNode)
+    def visit(self, node, scope):
+        return self.context.get_type('String')
+
+
+    @visitor.when(nodes.VariableNode)
+    def visit(self, node, scope):
+        var = scope.find_variable(node.lex)
+
+        if var is None:
+            self.errors.append(VARIABLE_NOT_DEFINED % (node.lex, self.current_method.name))
+            return ErrorType()
+
+        return var.type
+
+    
+    @visitor.when(nodes.InstantiateNode)
+    def visit(self, node, scope):
+        if node.lex == 'SELF_TYPE':
+            return self.current_type
+        
+        try:
+            return self.context.get_type(node.lex)
+        except SemanticError as se:
+            self.errors.append(se.text)
+            return ErrorType()
+
+    
+    @visitor.when(nodes.IsVoidNode)
+    def visit(self, node, scope):
+        self.visit(node.lex, scope)
+        return self.context.get_type('Bool')
+
+
+    @visitor.when(nodes.ComplementNode)
+    def visit(self, node, scope):
+        typex = self.visit(node.lex, scope)
+
+        if not typex.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INCOMPATIBLE_TYPES % (typex.name, 'Int'))
+            return ErrorType()
+
+        return typex
+
+
+    @visitor.when(nodes.PlusNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '+', type_right.name))
+            return ErrorType()
+
+        else:
+            return self.context.get_type('Int')
+    
+
+    @visitor.when(nodes.MinusNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '-', type_right.name))
+            return ErrorType()
+
+        else:
+            return self.context.get_type('Int')
+
+    
+    @visitor.when(nodes.StarNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '*', type_right.name))
+            return ErrorType()
+
+        else:
+            return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.DivNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '/', type_right.name))
+            return ErrorType()
+
+        else:
+            return self.context.get_type('Int')
+    
+
+    @visitor.when(nodes.LessThanNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '<', type_right.name))
+            return ErrorType()
+
+        else:
+            return self.context.get_type('Bool')
+
+    
+    @visitor.when(nodes.LessEqualNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '<=', type_right.name))
+            return ErrorType()
+
+        else:
+            return self.context.get_type('Bool')
+    
+
+    @visitor.when(nodes.EqualNode)
+    def visit(self, node, scope):
+        type_left = self.visit(node.left, scope)
+        type_right = self.visit(node.right, scope)
+
+        int_type = self.context.get_type('Int')
+        bool_type = self.context.get_type('Bool')
+        string_type = self.context.get_type('String')
+        
+        if (type_left == int_type and not type_right.conforms_to(int_type)) or (type_right == int_type and not type_left.conforms_to(int_type)) or (type_left == bool_type and not type_right.conforms_to(bool_type)) or (type_right == bool_type and not type_left.conforms_to(bool_type)) or (type_left == string_type and not type_right.conforms_to(string_type)) or (type_right == string_type and not type_left.conforms_to(string_type)):
+            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '=', type_right.name))
+            return ErrorType()
+
+        return bool_type
\ No newline at end of file

From 80b120bfb208d73f476b8648485df353f09cfcaf Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 23:52:54 -0800
Subject: [PATCH 11/83] semantic fixed

---
 src/cmp/semantic.py | 34 +++++++++++-----------------------
 1 file changed, 11 insertions(+), 23 deletions(-)

diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
index 1555fabf2..3cf8c49a6 100644
--- a/src/cmp/semantic.py
+++ b/src/cmp/semantic.py
@@ -1,8 +1,6 @@
 import itertools as itt
 from collections import OrderedDict
 
-from utils.COOL_Lexer import Token
-
 
 class SemanticError(Exception):
     @property
@@ -50,8 +48,7 @@ def set_parent(self, parent):
             raise SemanticError(f'Parent type is already set for {self.name}.')
         self.parent = parent
 
-    def get_attribute(self, token):
-        name = token if isinstance(token, str) else token.lex
+    def get_attribute(self, name:str):
         try:
             return next(attr for attr in self.attributes if attr.name == name)
         except StopIteration:
@@ -62,8 +59,7 @@ def get_attribute(self, token):
             except SemanticError:
                 raise SemanticError(f'Attribute "{name}" is not defined in {self.name}.')
 
-    def define_attribute(self, token, typex):
-        name = token if isinstance(token, str) else token.lex
+    def define_attribute(self, name:str, typex):
         try:
             self.get_attribute(name)
         except SemanticError:
@@ -73,8 +69,7 @@ def define_attribute(self, token, typex):
         else:
             raise SemanticError(f'Attribute "{name}" is already defined in {self.name}.')
 
-    def get_method(self, token):
-        name = token if isinstance(token, str) else token.lex
+    def get_method(self, name:str):
         try:
             return next(method for method in self.methods if method.name == name)
         except StopIteration:
@@ -85,8 +80,7 @@ def get_method(self, token):
             except SemanticError:
                 raise SemanticError(f'Method "{name}" is not defined in {self.name}.')
 
-    def define_method(self, token, param_names:list, param_types:list, return_type):
-        name = token if isinstance(token, str) else token.lex
+    def define_method(self, name:str, param_names:list, param_types:list, return_type):
         if name in (method.name for method in self.methods):
             raise SemanticError(f'Method "{name}" already defined in {self.name}')
 
@@ -147,7 +141,7 @@ def conforms_to(self, other):
     def bypass(self):
         return True
 
-    def get_method(self, token):
+    def get_method(self, name:str):
         raise SemanticError(None)
     
     def __eq__(self, other):
@@ -177,15 +171,13 @@ class Context:
     def __init__(self):
         self.types = {}
 
-    def create_type(self, token):
-        name = token if isinstance(token, str) else token.lex
+    def create_type(self, name:str):
         if name in self.types:
             raise SemanticError(f'Type with the same name ({name}) already in context.')
         typex = self.types[name] = Type(name)
         return typex
 
-    def get_type(self, token):
-        name = token if isinstance(token, str) else token.lex
+    def get_type(self, name:str):
         if name == '<error>':
             return ErrorType()
             
@@ -221,24 +213,20 @@ def create_child(self):
         self.children.append(child)
         return child
 
-    def define_variable(self, token, vtype):
-        vname = token if isinstance(token, str) else token.lex
+    def define_variable(self, vname, vtype):
         info = VariableInfo(vname, vtype)
         self.locals.append(info)
         return info
 
-    def find_variable(self, token, index=None):
-        vname = token if isinstance(token, str) else token.lex
+    def find_variable(self, vname, index=None):
         locals = self.locals if index is None else itt.islice(self.locals, index)
         try:
             return next(x for x in locals if x.name == vname)
         except StopIteration:
             return self.parent.find_variable(vname, self.index) if self.parent is not None else None
 
-    def is_defined(self, token):
-        vname = token if isinstance(token, str) else token.lex
+    def is_defined(self, vname):
         return self.find_variable(vname) is not None
 
-    def is_local(self, token):
-        vname = token if isinstance(token, str) else token.lex
+    def is_local(self, vname):
         return any(True for x in self.locals if x.name == vname)

From 0ae8c6dc6fb67252797d07e40093bc990e49541c Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 14 Dec 2021 23:54:25 -0800
Subject: [PATCH 12/83] type builder fixed

---
 src/utils/semantic_check/type_builder.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index cec2f0ab8..f6af1804e 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -28,8 +28,8 @@ def visit(self,node):
 
         if node.parent is not None:
 
-            if node.parent.lex in ['Int', 'String', 'SELF_TYPE', 'Bool']:
-                self.errors.append(NOT_INHERIT_FROM_BASICS_TYPES % (node.id.line, node.id.column, node.id.lex, node.parent.lex))
+            if node.parent in ['Int', 'String', 'SELF_TYPE', 'Bool']:
+                self.errors.append(NOT_INHERIT_FROM_BASICS_TYPES % (node.line, node.column, node.id, node.parent))
 
             else:
                 try:

From f6607a7e8599a75e3680e4f56ec79ff79850a68b Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 15 Dec 2021 01:06:08 -0800
Subject: [PATCH 13/83] fixing tokens in ast

---
 src/utils/ast/AST_Nodes.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index afb715ae8..f05451370 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -23,7 +23,7 @@ def __init__(self, token, features, parent=None):
             self.id = token.lex
             self.line = token.line
             self.column = token.column
-            self.parent = parent
+            self.parent = parent.lex if parent else parent
             self.features = features
 
     class MethDeclarationNode(DeclarationNode):
@@ -31,8 +31,8 @@ def __init__(self, token, params, return_type, body):
             self.id = token.lex
             self.line = token.line
             self.column = token.column
-            self.params = params
-            self.type = return_type
+            self.params = [[item.lex if isinstance(item, Token) else item for item in _list] for _list in params]
+            self.type = return_type.lex
             self.body = body
 
     class AttrDeclarationNode(DeclarationNode):
@@ -52,7 +52,7 @@ def __init__(self, token, expr, token_pos):
 
     class CallNode(ExpressionNode):
         def __init__(self, token, args, obj = None, typex = None):
-            self.obj = obj.lex
+            self.obj = obj
             self.type = typex
             self.id = token.lex
             self.line = token.line

From cb800e71615ba34a5b0e91473fadfd80fe624356 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 15 Dec 2021 01:08:02 -0800
Subject: [PATCH 14/83] working on type errors

---
 src/utils/semantic_check/type_checker.py | 92 +++++++++++++-----------
 1 file changed, 50 insertions(+), 42 deletions(-)

diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index b21d62088..de37e1e1d 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -6,14 +6,19 @@
 MAIN_METHOD_DONT_EXISTS = '(%s, %s) - TypeError: Main class must have a method main()'
 MAIN_METHOD_DONT_HAVE_PARAMS = '(%s, %s) - TypeError: main method must not have params'
 
-INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
-
-INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
-WRONG_SIGNATURE = '(%s, %s) - TypeError: Method "%s" already defined in "%s" with a different signature.'
+SELF_ERROR = '(%s, %s) - TypeError: self cannot be used as an attribute name'
 SELF_IS_READONLY = '(%s, %s) - TypeError: Variable "self" is read-only.'
-LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable "%s" is already defined in method "%s".'
+SELF_TYPE_ERROR = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a parameter type in method %s'
+SELF_TYPE_IN_DISPATCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a dispatch'
+SELF_TYPE_IN_CASE_BRANCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a case branch'
 
-VARIABLE_NOT_DEFINED = '(%s, %s) - TypeError: Variable "%s" is not defined in "%s".'
+INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
+WRONG_SIGNATURE = '(%s, %s) - TypeError: Method %s already defined in %s with a different signature.'
+LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable %s is already defined in method %s.'
+INVALID_OPERATION = '(%s, %s) - TypeError: Operation "%s" is not defined between %s and %s.'
+VARIABLE_NOT_DEFINED = '(%s, %s) - TypeError: Variable %s is not defined in %s.'
+INHERIT_ERROR = '(%s, %s) - TypeError: Class %s cannot inherit from class %s because they form a cycle.'
+METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
 
 
 
@@ -34,9 +39,9 @@ def visit(self, node, scope=None):
         # verificando que el programa tenga una clase Main
         try:
             self.context.get_type('Main')
-
+            
         except SemanticError:
-            self.errors.append(MAIN_DONT_EXISTS)
+                self.errors.append(MAIN_DONT_EXISTS)
 
 
         scope = Scope() if scope == None else scope
@@ -57,7 +62,8 @@ def visit(self, node, scope):
                 self.current_type.get_method('main')
 
             except SemanticError:
-                self.errors.append(MAIN_METHOD_DONT_EXISTS % (node.id.line, node.id.column))
+                self.errors.append(MAIN_METHOD_DONT_EXISTS % (node.line, node.column))
+
 
 
         # verficando herencia circular en los ancestros de current_type (deben llegar a object sin pasar por el nuevamente)
@@ -65,7 +71,7 @@ def visit(self, node, scope):
 
         while current_parent != self.context.get_type('Object') and current_parent != None:
             if current_parent == self.current_type:
-                self.errors.append(f'Class {self.current_type.name} cannot inherit from class {self.current_type.parent.name}')
+                self.errors.append(INHERIT_ERROR % (node.line, node.column, self.current_type.name, self.current_type.parent.name))
                 self.current_type.parent = ErrorType()
                 break
             current_parent = current_parent.parent
@@ -82,16 +88,16 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.AttrDeclarationNode)
     def visit(self, node, scope):
-        attr_type = self.context.get_type(node.type) if node.type.lex != 'SELF_TYPE' else self.current_type
+        attr_type = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
 
         if node.expr:
             type_expr = self.visit(node.expr, scope.create_child())
 
             if not type_expr.conforms_to(attr_type):
-                self.errors.append(INCOMPATIBLE_TYPES % (node.type.line, node.type.column, type_expr.name, attr_type.name))
+                self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_expr.name, attr_type.name))
 
-        if node.id.lex == 'self':
-            self.errors.append('self cannot be used as an attribute name')
+        if node.id == 'self':
+            self.errors.append(SELF_ERROR % (node.line, node.column))
 
         scope.define_variable(node.id, attr_type)
 
@@ -104,7 +110,7 @@ def visit(self, node, scope):
 
         # verificando que el metodo main no tenga parametros
         if self.current_method.name == 'main' and self.current_method.param_names:
-            self.errors.append(MAIN_METHOD_DONT_HAVE_PARAMS % (node.id.line, node.id.column))
+            self.errors.append(MAIN_METHOD_DONT_HAVE_PARAMS % (node.line, node.column))
 
         # verificabdo redefinicion de metodos
         current_parent = self.current_type.parent
@@ -113,7 +119,7 @@ def visit(self, node, scope):
             try:
                 parent_method = current_parent.get_method(node.id)
                 if parent_method != self.current_method:
-                    self.error.append(WRONG_SIGNATURE % (self.current_method.name, current_parent.name))
+                    self.errors.append(WRONG_SIGNATURE % (node.line, node.column, self.current_method.name, self.current_type.name))
                     break
             except:
                 pass
@@ -124,10 +130,10 @@ def visit(self, node, scope):
 
         for name, typex in zip(self.current_method.param_names, self.current_method.param_types):
             if scope.is_local(name):
-                self.errors.append(LOCAL_ALREADY_DEFINED % (name,self.current_method.name))
+                self.errors.append(LOCAL_ALREADY_DEFINED % (node.line, node.column, name,self.current_method.name))
 
             elif typex == 'SELF_TYPE':
-                self.errors.append('SELF_TYPE cannot be used as a parameter type')
+                self.errors.append(SELF_TYPE_ERROR % (node.line, node.column, self.current_method.name))
                 scope.define_variable(name, ErrorType())
 
             else:
@@ -141,7 +147,7 @@ def visit(self, node, scope):
             returnType = ErrorType()
 
         if not body_type.conforms_to(returnType):
-            self.errors.append(INCOMPATIBLE_TYPES % (body_type.name, returnType.name))
+            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, body_type.name, returnType.name))
 
         return
 
@@ -153,13 +159,13 @@ def visit(self, node, scope):
         type_expr = self.visit(node.expr, scope.create_child())
 
         if var is None:
-            self.errors.append(VARIABLE_NOT_DEFINED % (node.id, self.current_method.name))
+            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.id, self.current_method.name))
 
         elif var.name == 'self':
-            self.errors.append(SELF_IS_READONLY)
+            self.errors.append(SELF_IS_READONLY % (node.line, node.column))
 
         elif not type_expr.conforms_to(var.type):
-            self.errors.append(INCOMPATIBLE_TYPES % (type_expr.name, var.type.name))
+            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_expr.name, var.type.name))
 
         return type_expr
 
@@ -173,7 +179,7 @@ def visit(self, node, scope):
 
         if node.type is not None:
             if node.type == 'SELF_TYPE':
-                self.errors.append('SELF_TYPE cannot be used as a type of a dispatch')
+                self.errors.append(SELF_TYPE_IN_DISPATCH % (node.line, node.column))
                 typex = ErrorType()
 
             else:
@@ -184,7 +190,7 @@ def visit(self, node, scope):
                     typex = ErrorType()
 
                 if not obj_type.conforms_to(typex):
-                    self.errors.append(INCOMPATIBLE_TYPES % (obj_type.name, typex.name))
+                    self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, obj_type.name, typex.name))
 
             obj_type = typex
 
@@ -197,12 +203,12 @@ def visit(self, node, scope):
             return ErrorType()
         
         if len(node.args) != len(meth.param_names):
-            self.errors.append(f'Method {meth.name} defined in {obj_type.name} receive {len(meth.param_names)} parameters')
+            self.errors.append(METHOD_PARAMETERS % (node.line, node.column, meth.name, obj_type.name, len(meth.param_names)))
 
         for i,arg in enumerate(node.args):
             type_arg = self.visit(arg, scope)
             if i< len(meth.param_types) and not type_arg.conforms_to(meth.param_types[i]):
-                self.errors.append(INCOMPATIBLE_TYPES % (type_arg.name, meth.param_types[i].name))
+                self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_arg.name, meth.param_types[i].name))
         
         return meth.return_type if meth.return_type.name != 'SELF_TYPE' else obj_type
 
@@ -212,7 +218,7 @@ def visit(self, node, scope):
         if_type = self.visit(node.if_expr, scope.create_child())
 
         if not if_type.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES % (if_type.name, 'Bool'))
+            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, if_type.name, 'Bool'))
         
         then_type = self.visit(node.then_expr, scope.create_child())
         else_type = self.visit(node.else_expr, scope.create_child())
@@ -225,7 +231,7 @@ def visit(self, node, scope):
         type_conditional = self.visit(node.conditional_expr, scope)
 
         if not type_conditional.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES % (type_conditional.name, 'Bool'))
+            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_conditional.name, 'Bool'))
         
         self.visit(node.loop_expr, scope.create_child())
 
@@ -252,14 +258,14 @@ def visit(self, node, scope):
                 self.errors.append(se.text)
             
             if scope.is_local(idx):
-                self.errors.append(LOCAL_ALREADY_DEFINED % (idx, self.current_method.name))
+                self.errors.append(LOCAL_ALREADY_DEFINED % (node.line, node.column, idx, self.current_method.name))
             else:
                 scope.define_variable(idx, id_type)
             
             if id_expr is not None:
                 id_expr_type = self.visit(id_expr, scope.create_child())
                 if not id_expr_type.conforms_to(id_type):
-                    self.errors.append(INCOMPATIBLE_TYPES % (id_expr_type.name, id_type.name))
+                    self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, id_expr_type.name, id_type.name))
             
         body_type = self.visit(node.in_expr, scope.create_child())
 
@@ -273,7 +279,7 @@ def visit(self, node, scope):
 
         for idx, typex, expr in node.branches:
             if typex == 'SELF_TYPE':
-                self.errors.append('SELF_TYPE cannot be used as a type of a case branch')
+                self.errors.append(SELF_TYPE_IN_CASE_BRANCH % (node.line, node.column))
                 id_type = ErrorType()
                 
             else:
@@ -297,7 +303,7 @@ def visit(self, node, scope):
         typex = self.visit(node.expr, scope)
 
         if not typex.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES % (typex.name, 'Bool'))
+            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, typex.name, 'Bool'))
             return ErrorType()
 
         return typex
@@ -323,7 +329,7 @@ def visit(self, node, scope):
         var = scope.find_variable(node.lex)
 
         if var is None:
-            self.errors.append(VARIABLE_NOT_DEFINED % (node.lex, self.current_method.name))
+            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.lex, self.current_method.name))
             return ErrorType()
 
         return var.type
@@ -352,7 +358,7 @@ def visit(self, node, scope):
         typex = self.visit(node.lex, scope)
 
         if not typex.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INCOMPATIBLE_TYPES % (typex.name, 'Int'))
+            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, typex.name, 'Int'))
             return ErrorType()
 
         return typex
@@ -364,7 +370,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '+', type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '+', type_left.name, type_right.name))
             return ErrorType()
 
         else:
@@ -377,7 +383,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '-', type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '-', type_left.name, type_right.name))
             return ErrorType()
 
         else:
@@ -390,7 +396,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '*', type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '*', type_left.name, type_right.name))
             return ErrorType()
 
         else:
@@ -403,7 +409,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '/', type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '/', type_left.name, type_right.name))
             return ErrorType()
 
         else:
@@ -416,7 +422,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '<', type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '<', type_left.name, type_right.name))
             return ErrorType()
 
         else:
@@ -429,7 +435,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '<=', type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '<=', type_left.name, type_right.name))
             return ErrorType()
 
         else:
@@ -445,8 +451,10 @@ def visit(self, node, scope):
         bool_type = self.context.get_type('Bool')
         string_type = self.context.get_type('String')
         
-        if (type_left == int_type and not type_right.conforms_to(int_type)) or (type_right == int_type and not type_left.conforms_to(int_type)) or (type_left == bool_type and not type_right.conforms_to(bool_type)) or (type_right == bool_type and not type_left.conforms_to(bool_type)) or (type_left == string_type and not type_right.conforms_to(string_type)) or (type_right == string_type and not type_left.conforms_to(string_type)):
-            self.errors.append(INVALID_OPERATION % (node.symbol.line, node.symbol.column, type_left.name, '=', type_right.name))
+        if type_left.name == 'AUTO_TYPE' or type_right.name == 'AUTO_TYPE':
+            pass
+        elif (type_left == int_type and not type_right.conforms_to(int_type)) or (type_right == int_type and not type_left.conforms_to(int_type)) or (type_left == bool_type and not type_right.conforms_to(bool_type)) or (type_right == bool_type and not type_left.conforms_to(bool_type)) or (type_left == string_type and not type_right.conforms_to(string_type)) or (type_right == string_type and not type_left.conforms_to(string_type)):
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, '=', type_left.name, type_right.name))
             return ErrorType()
 
         return bool_type
\ No newline at end of file

From d2f0420c6e87f6a8de5ae92e3fa90600895e5ac6 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Thu, 16 Dec 2021 14:34:40 -0800
Subject: [PATCH 15/83] main

---
 src/main.py | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 src/main.py

diff --git a/src/main.py b/src/main.py
new file mode 100644
index 000000000..f90e0cd20
--- /dev/null
+++ b/src/main.py
@@ -0,0 +1,67 @@
+import argparse 
+from utils.COOL_Grammar import build_COOL_Grammar
+from utils.COOL_Lexer import COOL_Lexer
+from utils.parser.COOL_parser import COOL_Parser
+from cmp.evaluation import evaluate_reverse_parse
+from cmp.semantic import Context
+from utils.semantic_check.type_collector import TypeCollector
+from utils.semantic_check.type_builder import TypeBuilder
+from utils.semantic_check.type_checker import TypeChecker
+from utils.semantic_check.type_inference import TypeInference
+from utils.print_code import PrintCode
+
+def main(args):
+    
+    try:
+        with open(args.file, 'r') as file:
+            code = file.read()
+    except:
+        print(f"(0,0) - CompilerError: file {args.file} not found")
+        exit(1)
+
+    G = build_COOL_Grammar()
+
+    # lexer
+    lexer = COOL_Lexer() 
+    tokens = lexer(code)
+
+    if lexer.errors:
+        for error in lexer.errors:
+            print(error)
+        exit(1)
+
+    # parser
+    parser = COOL_Parser(G)
+    derivation, operations = parser(tokens)
+    
+    if parser.error:
+        print(parser.error)
+        exit(1)
+
+    # ast       
+    ast = evaluate_reverse_parse(G, derivation, operations, tokens)
+            
+    context = Context()
+    semantic_errors = []
+
+    collector = TypeCollector(context, semantic_errors)
+    collector.visit(ast)
+
+    builder = TypeBuilder(context, semantic_errors)
+    builder.visit(ast)
+
+    checker = TypeChecker(context, semantic_errors)
+    scope = checker.visit(ast)
+            
+    if semantic_errors:
+        for error in semantic_errors:
+            print(error)                          
+        exit(1)
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='description')
+    parser.add_argument('-f', '--file', type=str, default='', help='file to read')
+
+    args = parser.parse_args()
+    main(args)
\ No newline at end of file

From 9373a10034da22960815e8eea437954aaca54c1b Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Thu, 16 Dec 2021 14:38:31 -0800
Subject: [PATCH 16/83] changing lin-col in some tokens like tests

---
 src/utils/COOL_Grammar.py  |  4 ++--
 src/utils/COOL_Lexer.py    |  4 ++--
 src/utils/ast/AST_Nodes.py | 23 +++++++++++++----------
 3 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index ed1760b15..914f9f0cf 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -49,7 +49,7 @@ def build_COOL_Grammar():
     expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3],s[2])
     expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6],s[1])
     expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4],s[1])
-    expr %= notx + expr, lambda h,s: node.NotNode(s[2],s[1])
+    expr %= notx + expr, lambda h,s: node.NotNode(s[2])
 
     expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2],s[1])
 
@@ -92,7 +92,7 @@ def build_COOL_Grammar():
     atom %= string, lambda h,s: node.ConstantStringNode(s[1])
     atom %= num, lambda h,s: node.ConstantNumNode(s[1])
     atom %= idx, lambda h,s: node.VariableNode(s[1])
-    atom %= new + typex, lambda h,s: node.InstantiateNode(s[2])
+    atom %= new + typex, lambda h,s: node.InstantiateNode(s[2],s[1])
     atom %= opar + expr + cpar, lambda h,s: s[2]
     atom %= dispatch, lambda h,s: s[1]
 
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 9b684991f..3fd1bc052 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -156,11 +156,11 @@ def __init__(self):
         'id'        : r'[a-z][a-zA-Z0-9_]*'         ,
         'type'      : r'[A-Z][a-zA-Z0-9_]*'         ,
         'string'    : r'\"'                         ,
-        'int'       : r'\d+'                        ,
+        'int'       : r'\d'                         ,
         'comment'   : r'(\(\*)|--.*'                ,
         'newline'   : r'\n'                         ,
         'whitespace': r' +'                         ,
-        'tabulation': r'\t+'                        ,
+        'tabulation': r'\t'                         ,
         'inherits'  : r'inherits'                   ,
         'isvoid'    : r'isvoid'                     ,
         'class'     : r'class'                      ,
diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index f05451370..899be306f 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -38,9 +38,9 @@ def __init__(self, token, params, return_type, body):
     class AttrDeclarationNode(DeclarationNode):
         def __init__(self, token, typex, expr = None):
             self.id = token.lex
-            self.line = token.line
-            self.column = token.column
-            self.type = typex
+            self.line = expr.line if expr else token.line
+            self.column = expr.column if expr else token.column
+            self.type = typex.lex
             self.expr = expr
 
     class AssignNode(ExpressionNode):
@@ -52,11 +52,11 @@ def __init__(self, token, expr, token_pos):
 
     class CallNode(ExpressionNode):
         def __init__(self, token, args, obj = None, typex = None):
-            self.obj = obj
+            self.obj = obj.lex if isinstance(obj, Token) else obj
             self.type = typex
             self.id = token.lex
-            self.line = token.line
-            self.column = token.column
+            self.line = obj.line if obj else token.line
+            self.column = obj.column if obj else token.column
             self.args = args
     
     class IfThenElseNode(ExpressionNode):
@@ -97,12 +97,12 @@ def __init__(self, predicate, branches, token):
     class NotNode(ExpressionNode):
         def __init__(self, expr, token):
             self.expr = expr
-            self.line = token.line
-            self.column = token.column
+            self.line = token.line + 4
+            self.column = token.column + 4
 
     class AtomicNode(ExpressionNode):
         def __init__(self, token):
-            self.lex = token.lex
+            self.lex = token.lex if isinstance(token, Token) else token
             self.line = token.line
             self.column = token.column
 
@@ -123,7 +123,10 @@ class ConstantStringNode(AtomicNode):
     class VariableNode(AtomicNode):
         pass
     class InstantiateNode(AtomicNode):
-        pass
+        def __init__(self, typex, token):
+            self.lex =  typex.lex
+            self.line = token.line
+            self.column = token.column
     class IsVoidNode(AtomicNode):
         pass
     class ComplementNode(AtomicNode):

From f04e9152295606b66629592cba7f065d4383160c Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Thu, 16 Dec 2021 14:43:12 -0800
Subject: [PATCH 17/83] execute project

---
 src/coolc.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/coolc.sh b/src/coolc.sh
index 3088de4f9..5d3764e5f 100755
--- a/src/coolc.sh
+++ b/src/coolc.sh
@@ -1,4 +1,4 @@
-# Incluya aquí las instrucciones necesarias para ejecutar su compilador
+# Incluya aquí las instrucciones necesarias para ejecutar su compilador
 
 INPUT_FILE=$1
 OUTPUT_FILE=${INPUT_FILE:0: -2}mips
@@ -9,3 +9,4 @@ echo "Copyright (c) 2019: Nombre1, Nombre2, Nombre3"    # TODO: líneas a los va
 
 # Llamar al compilador
 echo "Compiling $INPUT_FILE into $OUTPUT_FILE"
+python main.py -f $INPUT_FILE
\ No newline at end of file

From 5fa3965ddba24cb72671903d206f750c165502fd Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Thu, 16 Dec 2021 14:50:08 -0800
Subject: [PATCH 18/83] changing some semantic errors like tests

---
 src/utils/semantic_check/type_checker.py | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index de37e1e1d..89a4b74c4 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -12,10 +12,12 @@
 SELF_TYPE_IN_DISPATCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a dispatch'
 SELF_TYPE_IN_CASE_BRANCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a case branch'
 
+INCOMPATIBLE_TYPES_ATTR = '(%s, %s) - TypeError: Inferred type %s of initialization of attribute %s does not conform to declared type %s.'
+INCOMPATIBLE_TYPES_COMPLEMENT = '(%s, %s) - TypeError: Argument of %s has type %s instead of %s.'
 INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
 WRONG_SIGNATURE = '(%s, %s) - TypeError: Method %s already defined in %s with a different signature.'
 LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable %s is already defined in method %s.'
-INVALID_OPERATION = '(%s, %s) - TypeError: Operation "%s" is not defined between %s and %s.'
+INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
 VARIABLE_NOT_DEFINED = '(%s, %s) - TypeError: Variable %s is not defined in %s.'
 INHERIT_ERROR = '(%s, %s) - TypeError: Class %s cannot inherit from class %s because they form a cycle.'
 METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
@@ -94,7 +96,7 @@ def visit(self, node, scope):
             type_expr = self.visit(node.expr, scope.create_child())
 
             if not type_expr.conforms_to(attr_type):
-                self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_expr.name, attr_type.name))
+                self.errors.append(INCOMPATIBLE_TYPES_ATTR % (node.line, node.column, type_expr.name, node.id, attr_type.name))
 
         if node.id == 'self':
             self.errors.append(SELF_ERROR % (node.line, node.column))
@@ -358,7 +360,7 @@ def visit(self, node, scope):
         typex = self.visit(node.lex, scope)
 
         if not typex.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, typex.name, 'Int'))
+            self.errors.append(INCOMPATIBLE_TYPES_COMPLEMENT % (node.line, node.column, '~' ,typex.name, 'Int'))
             return ErrorType()
 
         return typex
@@ -370,7 +372,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '+', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '+', type_right.name))
             return ErrorType()
 
         else:
@@ -383,7 +385,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '-', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '-', type_right.name))
             return ErrorType()
 
         else:
@@ -396,7 +398,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '*', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '*', type_right.name))
             return ErrorType()
 
         else:
@@ -409,7 +411,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '/', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '/', type_right.name))
             return ErrorType()
 
         else:
@@ -422,7 +424,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '<', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '<', type_right.name))
             return ErrorType()
 
         else:
@@ -435,7 +437,7 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '<=', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '<=', type_right.name))
             return ErrorType()
 
         else:
@@ -454,7 +456,7 @@ def visit(self, node, scope):
         if type_left.name == 'AUTO_TYPE' or type_right.name == 'AUTO_TYPE':
             pass
         elif (type_left == int_type and not type_right.conforms_to(int_type)) or (type_right == int_type and not type_left.conforms_to(int_type)) or (type_left == bool_type and not type_right.conforms_to(bool_type)) or (type_right == bool_type and not type_left.conforms_to(bool_type)) or (type_left == string_type and not type_right.conforms_to(string_type)) or (type_right == string_type and not type_left.conforms_to(string_type)):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, '=', type_left.name, type_right.name))
+            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '=', type_right.name))
             return ErrorType()
 
         return bool_type
\ No newline at end of file

From d72b55d7076de57cfe6525da816ac7ba9b99acce Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 18 Dec 2021 21:59:05 -0800
Subject: [PATCH 19/83] including fixed_tokens

---
 src/main.py                |  2 --
 src/utils/COOL_Grammar.py  |  2 +-
 src/utils/COOL_Lexer.py    | 22 +++++++++++++++++-----
 src/utils/ast/AST_Nodes.py |  4 ++--
 4 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/main.py b/src/main.py
index f90e0cd20..5e80559a7 100644
--- a/src/main.py
+++ b/src/main.py
@@ -7,8 +7,6 @@
 from utils.semantic_check.type_collector import TypeCollector
 from utils.semantic_check.type_builder import TypeBuilder
 from utils.semantic_check.type_checker import TypeChecker
-from utils.semantic_check.type_inference import TypeInference
-from utils.print_code import PrintCode
 
 def main(args):
     
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 914f9f0cf..5790cabbe 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -49,7 +49,7 @@ def build_COOL_Grammar():
     expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3],s[2])
     expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6],s[1])
     expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4],s[1])
-    expr %= notx + expr, lambda h,s: node.NotNode(s[2])
+    expr %= notx + expr, lambda h,s: node.NotNode(s[2],s[1])
 
     expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2],s[1])
 
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 3fd1bc052..0075c1398 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -14,7 +14,7 @@ def __init__(self, lex, ttype, line, column):
         self.column = column
  
     def __str__(self): 
-        return f'{self.token_type}: {self.lex}'
+        return f'({self.line}, {self.column}) - {self.token_type}: {self.lex}'
  
 '''
 El lexer es el resultado de la union de todas las expresiones regulares que forman
@@ -22,12 +22,13 @@ def __str__(self):
 '''
 class Lexer: 
 
-    def __init__(self, table, keywords, ignored_tokens, eof):
+    def __init__(self, table, keywords, ignored_tokens, tokens_toFix, eof):
         self.line = 1
         self.column = 0
         self.table = table
         self.keywords = keywords
         self.ignored_tokens = ignored_tokens
+        self.tokens_toFix = tokens_toFix
         self.regex = self._build_regex(table)
         self.errors = []
         self.eof = eof
@@ -142,11 +143,19 @@ def tokenize(self,text):
  
     def _build_regex(sef,table):
         return re.compile('|'.join([f'(?P<{name}>{regex})' if name != regex else f'({name})' for name,regex in table.items()]))
- 
+    
     def __call__(self, text): 
-        return [Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens]
+        return self.fixed_tokens([Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens])
+
+    def fixed_tokens(self, tokens):
+        for i, token in enumerate(tokens):
+            if token.lex in self.tokens_toFix:
+                token.line = tokens[i + 1].line
+                token.column = tokens[i + 1].column
 
 
+    
+
 '''
 Esta clase guardara las propiedades sintacticas de COOL
 '''
@@ -205,4 +214,7 @@ def __init__(self):
 
         self.ignored_tokens = ['newline','whitespace','tabulation','comment']
 
-        Lexer.__init__(self, self.regexs, self.keywords, self.ignored_tokens, 'eof')
\ No newline at end of file
+        self.tokens_toFix = ['inherits','isvoid','class','while','then','else','loop','case',
+        'let','new','not','if','in','of']
+
+        Lexer.__init__(self, self.regexs, self.keywords, self.ignored_tokens, self.tokens_toFix, 'eof')
\ No newline at end of file
diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index 899be306f..c31d90ed2 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -125,8 +125,8 @@ class VariableNode(AtomicNode):
     class InstantiateNode(AtomicNode):
         def __init__(self, typex, token):
             self.lex =  typex.lex
-            self.line = token.line
-            self.column = token.column
+            self.line = token.line + 4
+            self.column = token.column + 4
     class IsVoidNode(AtomicNode):
         pass
     class ComplementNode(AtomicNode):

From 12dbd4ff769789db3a4a76c73a0f045f30ea7f73 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 18 Dec 2021 22:13:44 -0800
Subject: [PATCH 20/83] fixed tokens in ast

---
 src/main.py             | 4 ++--
 src/utils/COOL_Lexer.py | 3 ++-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/main.py b/src/main.py
index 5e80559a7..77550ed4c 100644
--- a/src/main.py
+++ b/src/main.py
@@ -35,9 +35,9 @@ def main(args):
     if parser.error:
         print(parser.error)
         exit(1)
-
+        
     # ast       
-    ast = evaluate_reverse_parse(G, derivation, operations, tokens)
+    ast = evaluate_reverse_parse(G, derivation, operations, lexer.fixed_tokens(tokens))
             
     context = Context()
     semantic_errors = []
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 0075c1398..a3e733f40 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -145,13 +145,14 @@ def _build_regex(sef,table):
         return re.compile('|'.join([f'(?P<{name}>{regex})' if name != regex else f'({name})' for name,regex in table.items()]))
     
     def __call__(self, text): 
-        return self.fixed_tokens([Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens])
+        return [Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens]
 
     def fixed_tokens(self, tokens):
         for i, token in enumerate(tokens):
             if token.lex in self.tokens_toFix:
                 token.line = tokens[i + 1].line
                 token.column = tokens[i + 1].column
+        return tokens
 
 
     

From 7a136143b9b0593ff632a815b59bd327d7420c42 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 12 Feb 2022 16:56:17 -0800
Subject: [PATCH 21/83] update errors tags and fixind variables in parents

---
 src/utils/semantic_check/type_checker.py | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 89a4b74c4..b63740c0a 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -13,12 +13,13 @@
 SELF_TYPE_IN_CASE_BRANCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a case branch'
 
 INCOMPATIBLE_TYPES_ATTR = '(%s, %s) - TypeError: Inferred type %s of initialization of attribute %s does not conform to declared type %s.'
-INCOMPATIBLE_TYPES_COMPLEMENT = '(%s, %s) - TypeError: Argument of %s has type %s instead of %s.'
+INCOMPATIBLE_TYPES_ARG = '(%s, %s) - TypeError: Argument of \'%s\' has type %s instead of %s.'
+INCOMPATIBLE_TYPES_METH = '(%s, %s) - TypeError: Inferred return type %s of method %s does not conform to declared return type %s.'
 INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
 WRONG_SIGNATURE = '(%s, %s) - TypeError: Method %s already defined in %s with a different signature.'
 LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable %s is already defined in method %s.'
 INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
-VARIABLE_NOT_DEFINED = '(%s, %s) - TypeError: Variable %s is not defined in %s.'
+VARIABLE_NOT_DEFINED = '(%s, %s) - NameError: Undeclared identifier %s.'
 INHERIT_ERROR = '(%s, %s) - TypeError: Class %s cannot inherit from class %s because they form a cycle.'
 METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
 
@@ -76,6 +77,10 @@ def visit(self, node, scope):
                 self.errors.append(INHERIT_ERROR % (node.line, node.column, self.current_type.name, self.current_type.parent.name))
                 self.current_type.parent = ErrorType()
                 break
+            
+            for attr in current_parent.attributes:
+                scope.define_variable(attr.name, attr.type)
+
             current_parent = current_parent.parent
         
         attrs = [feat for feat in node.features if isinstance(feat, nodes.AttrDeclarationNode)]
@@ -149,7 +154,7 @@ def visit(self, node, scope):
             returnType = ErrorType()
 
         if not body_type.conforms_to(returnType):
-            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, body_type.name, returnType.name))
+            self.errors.append(INCOMPATIBLE_TYPES_METH % (node.body_line, node.body_column, body_type.name , node.id, returnType.name ))
 
         return
 
@@ -161,7 +166,7 @@ def visit(self, node, scope):
         type_expr = self.visit(node.expr, scope.create_child())
 
         if var is None:
-            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.id, self.current_method.name))
+            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.id))
 
         elif var.name == 'self':
             self.errors.append(SELF_IS_READONLY % (node.line, node.column))
@@ -305,7 +310,7 @@ def visit(self, node, scope):
         typex = self.visit(node.expr, scope)
 
         if not typex.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, typex.name, 'Bool'))
+            self.errors.append(INCOMPATIBLE_TYPES_ARG % (node.line, node.column, 'not' ,typex.name, 'Bool'))
             return ErrorType()
 
         return typex
@@ -331,7 +336,7 @@ def visit(self, node, scope):
         var = scope.find_variable(node.lex)
 
         if var is None:
-            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.lex, self.current_method.name))
+            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.lex))
             return ErrorType()
 
         return var.type
@@ -360,7 +365,7 @@ def visit(self, node, scope):
         typex = self.visit(node.lex, scope)
 
         if not typex.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INCOMPATIBLE_TYPES_COMPLEMENT % (node.line, node.column, '~' ,typex.name, 'Int'))
+            self.errors.append(INCOMPATIBLE_TYPES_ARG % (node.line, node.column, '~' ,typex.name, 'Int'))
             return ErrorType()
 
         return typex

From deac2a5cd44acaf60cc5f106ff68b289e987ff8c Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Tue, 15 Feb 2022 10:16:10 -0800
Subject: [PATCH 22/83] Update requirements.txt

---
 requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/requirements.txt b/requirements.txt
index 9eb0cad1a..4d792d537 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,3 @@
 pytest
 pytest-ordering
+ply~=3.11

From ce0fabc9e446017eefe06122afce725a2f2d1703 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 13:23:38 -0800
Subject: [PATCH 23/83] updating all

---
 requirements.txt                            |   2 +-
 src/.vscode/launch.json                     |  30 +
 src/main.py                                 |  20 +-
 src/tester/01_program.cl                    |  16 +
 src/tester/02_program.cl                    |  15 +
 src/tester/03_program.cl                    |  17 +
 src/tester/04_program.cl                    |  16 +
 src/tester/05_program.cl                    |  16 +
 src/tester/06_program.cl                    |  44 ++
 src/tester/07_program.cl                    |  19 +
 src/tester/08_program.cl                    |  33 +
 src/tester/inference/01_program.cl          |  16 +
 src/tester/inference/02_program.cl          |  15 +
 src/tester/inference/03_program.cl          |  17 +
 src/tester/inference/04_program.cl          |  16 +
 src/tester/inference/05_program.cl          |  16 +
 src/tester/inference/06_program.cl          |  44 ++
 src/tester/inference/07_program.cl          |  19 +
 src/tester/inference/08_program.cl          |  33 +
 src/tester/lexer/comment1.cl                |  55 ++
 src/tester/lexer/iis1.cl                    | 111 +++
 src/tester/lexer/iis2.cl                    | 120 +++
 src/tester/lexer/iis3.cl                    | 121 +++
 src/tester/lexer/iis4.cl                    | 120 +++
 src/tester/lexer/iis5.cl                    | 121 +++
 src/tester/lexer/iis6.cl                    | 125 ++++
 src/tester/lexer/mixed1.cl                  |  14 +
 src/tester/lexer/mixed2.cl                  |  20 +
 src/tester/lexer/string1.cl                 |   6 +
 src/tester/lexer/string2.cl                 |  19 +
 src/tester/lexer/string3.cl                 | Bin 0 -> 234 bytes
 src/tester/lexer/string4.cl                 |  38 +
 src/tester/parser/assignment1.cl            |  37 +
 src/tester/parser/assignment2.cl            |  37 +
 src/tester/parser/assignment3.cl            |  37 +
 src/tester/parser/attribute1.cl             |  34 +
 src/tester/parser/attribute2.cl             |  34 +
 src/tester/parser/attribute3.cl             |  34 +
 src/tester/parser/block1.cl                 |  87 +++
 src/tester/parser/block2.cl                 |  87 +++
 src/tester/parser/block3.cl                 |  87 +++
 src/tester/parser/block4.cl                 |  88 +++
 src/tester/parser/case1.cl                  |  91 +++
 src/tester/parser/case2.cl                  |  93 +++
 src/tester/parser/case3.cl                  |  93 +++
 src/tester/parser/case4.cl                  |  93 +++
 src/tester/parser/case5.cl                  |  93 +++
 src/tester/parser/case6.cl                  |  93 +++
 src/tester/parser/class1.cl                 |  20 +
 src/tester/parser/class2.cl                 |  20 +
 src/tester/parser/class3.cl                 |  34 +
 src/tester/parser/class4.cl                 |  36 +
 src/tester/parser/class5.cl                 |  34 +
 src/tester/parser/class6.cl                 |  34 +
 src/tester/parser/conditional1.cl           |  69 ++
 src/tester/parser/conditional2.cl           |  69 ++
 src/tester/parser/conditional3.cl           |  69 ++
 src/tester/parser/conditional4.cl           |  73 ++
 src/tester/parser/conditional5.cl           |  73 ++
 src/tester/parser/conditional6.cl           |  73 ++
 src/tester/parser/dispatch1.cl              |  45 ++
 src/tester/parser/dispatch2.cl              |  45 ++
 src/tester/parser/dispatch4.cl              |  53 ++
 src/tester/parser/dispatch5.cl              |  53 ++
 src/tester/parser/dispatch6.cl              |  57 ++
 src/tester/parser/dispatch7.cl              |  57 ++
 src/tester/parser/dispatch8.cl              |  57 ++
 src/tester/parser/dispatch9.cl              |  61 ++
 src/tester/parser/let1.cl                   |  85 +++
 src/tester/parser/let2.cl                   |  85 +++
 src/tester/parser/let3.cl                   |  85 +++
 src/tester/parser/let4.cl                   |  85 +++
 src/tester/parser/let5.cl                   |  85 +++
 src/tester/parser/let6.cl                   |  74 ++
 src/tester/parser/let7.cl                   |  85 +++
 src/tester/parser/loop1.cl                  |  78 ++
 src/tester/parser/loop2.cl                  |  78 ++
 src/tester/parser/loop3.cl                  |  78 ++
 src/tester/parser/loop4.cl                  |  78 ++
 src/tester/parser/method1.cl                |  34 +
 src/tester/parser/method2.cl                |  34 +
 src/tester/parser/method3.cl                |  34 +
 src/tester/parser/method4.cl                |  34 +
 src/tester/parser/method5.cl                |  34 +
 src/tester/parser/method6.cl                |  33 +
 src/tester/parser/mixed2.cl                 |  14 +
 src/tester/parser/mixed3.cl                 |  40 +
 src/tester/parser/mixed4.cl                 |  21 +
 src/tester/parser/mixed5.cl                 |  20 +
 src/tester/parser/mixed6.cl                 |   5 +
 src/tester/parser/operation1.cl             | 101 +++
 src/tester/parser/operation2.cl             | 101 +++
 src/tester/parser/operation3.cl             | 101 +++
 src/tester/parser/operation4.cl             | 101 +++
 src/tester/parser/program1.cl               |   1 +
 src/tester/parser/program3.cl               |  24 +
 src/tester/semantic/01_program.cl           |  16 +
 src/tester/semantic/arithmetic1.cl          |  11 +
 src/tester/semantic/arithmetic10.cl         |  15 +
 src/tester/semantic/arithmetic10_error.txt  |   1 +
 src/tester/semantic/arithmetic11.cl         |  14 +
 src/tester/semantic/arithmetic11_error.txt  |   1 +
 src/tester/semantic/arithmetic12.cl         |  14 +
 src/tester/semantic/arithmetic12_error.txt  |   1 +
 src/tester/semantic/arithmetic1_error.txt   |   1 +
 src/tester/semantic/arithmetic2.cl          |  11 +
 src/tester/semantic/arithmetic2_error.txt   |   1 +
 src/tester/semantic/arithmetic3.cl          |  11 +
 src/tester/semantic/arithmetic3_error.txt   |   1 +
 src/tester/semantic/arithmetic4.cl          |  11 +
 src/tester/semantic/arithmetic4_error.txt   |   1 +
 src/tester/semantic/arithmetic5.cl          |  11 +
 src/tester/semantic/arithmetic5_error.txt   |   1 +
 src/tester/semantic/arithmetic6.cl          |  11 +
 src/tester/semantic/arithmetic6_error.txt   |   1 +
 src/tester/semantic/arithmetic7.cl          |  12 +
 src/tester/semantic/arithmetic7_error.txt   |   1 +
 src/tester/semantic/arithmetic8.cl          |  13 +
 src/tester/semantic/arithmetic8_error.txt   |   1 +
 src/tester/semantic/arithmetic9.cl          |  15 +
 src/tester/semantic/arithmetic9_error.txt   |   1 +
 src/tester/semantic/assignment1.cl          |   7 +
 src/tester/semantic/assignment1_error.txt   |   1 +
 src/tester/semantic/assignment2.cl          |  13 +
 src/tester/semantic/assignment2_error.txt   |   1 +
 src/tester/semantic/assignment3.cl          |  14 +
 src/tester/semantic/assignment3_error.txt   |   1 +
 src/tester/semantic/attributes1.cl          |  13 +
 src/tester/semantic/attributes1_error.txt   |   1 +
 src/tester/semantic/attributes2.cl          |  13 +
 src/tester/semantic/attributes2_error.txt   |   1 +
 src/tester/semantic/attributes3.cl          |  25 +
 src/tester/semantic/attributes3_error.txt   |   1 +
 src/tester/semantic/attributes4.cl          |  39 +
 src/tester/semantic/attributes4_error.txt   |   1 +
 src/tester/semantic/basics1.cl              |  10 +
 src/tester/semantic/basics1_error.txt       |   1 +
 src/tester/semantic/basics2.cl              |   9 +
 src/tester/semantic/basics2_error.txt       |   1 +
 src/tester/semantic/basics3.cl              |   9 +
 src/tester/semantic/basics3_error.txt       |   1 +
 src/tester/semantic/basics4.cl              |   9 +
 src/tester/semantic/basics4_error.txt       |   1 +
 src/tester/semantic/basics5.cl              |   9 +
 src/tester/semantic/basics5_error.txt       |   1 +
 src/tester/semantic/basics6.cl              |   9 +
 src/tester/semantic/basics6_error.txt       |   1 +
 src/tester/semantic/basics7.cl              |   9 +
 src/tester/semantic/basics7_error.txt       |   1 +
 src/tester/semantic/basics8.cl              |   9 +
 src/tester/semantic/basics8_error.txt       |   1 +
 src/tester/semantic/blocks1.cl              |  31 +
 src/tester/semantic/blocks1_error.txt       |   1 +
 src/tester/semantic/case1.cl                |  23 +
 src/tester/semantic/case1_error.txt         |   1 +
 src/tester/semantic/case2.cl                |  23 +
 src/tester/semantic/case2_error.txt         |   1 +
 src/tester/semantic/case3.cl                |  23 +
 src/tester/semantic/case3_error.txt         |   1 +
 src/tester/semantic/class1.cl               |   9 +
 src/tester/semantic/class1_error.txt        |   2 +
 src/tester/semantic/conditionals1.cl        |  14 +
 src/tester/semantic/conditionals1_error.txt |   1 +
 src/tester/semantic/conditionals2.cl        |  24 +
 src/tester/semantic/conditionals2_error.txt |   2 +
 src/tester/semantic/dispatch1.cl            |  33 +
 src/tester/semantic/dispatch1_error.txt     |   1 +
 src/tester/semantic/dispatch2.cl            |  34 +
 src/tester/semantic/dispatch2_error.txt     |   1 +
 src/tester/semantic/dispatch3.cl            |  36 +
 src/tester/semantic/dispatch3_error.txt     |   1 +
 src/tester/semantic/dispatch4.cl            |  36 +
 src/tester/semantic/dispatch4_error.txt     |   1 +
 src/tester/semantic/dispatch5.cl            |  31 +
 src/tester/semantic/dispatch5_error.txt     |   1 +
 src/tester/semantic/dispatch6.cl            |  32 +
 src/tester/semantic/dispatch6_error.txt     |   1 +
 src/tester/semantic/eq1.cl                  |  17 +
 src/tester/semantic/eq1_error.txt           |   1 +
 src/tester/semantic/eq2.cl                  |  17 +
 src/tester/semantic/eq2_error.txt           |   1 +
 src/tester/semantic/eq3.cl                  |  17 +
 src/tester/semantic/eq3_error.txt           |   1 +
 src/tester/semantic/eq4.cl                  |  17 +
 src/tester/semantic/eq4_error.txt           |   1 +
 src/tester/semantic/features1.cl            |  19 +
 src/tester/semantic/features1_error.txt     |   1 +
 src/tester/semantic/features2.cl            |  19 +
 src/tester/semantic/features2_error.txt     |   1 +
 src/tester/semantic/features3.cl            |  15 +
 src/tester/semantic/features3_error.txt     |   1 +
 src/tester/semantic/inheritance1.cl         |  19 +
 src/tester/semantic/inheritance1_error.txt  |   1 +
 src/tester/semantic/inheritance2.cl         |  19 +
 src/tester/semantic/inheritance2_error.txt  |   1 +
 src/tester/semantic/inheritance3.cl         |  13 +
 src/tester/semantic/inheritance3_error.txt  |   1 +
 src/tester/semantic/inheritance4.cl         |  19 +
 src/tester/semantic/inheritance4_error.txt  |   1 +
 src/tester/semantic/inheritance5.cl         |  21 +
 src/tester/semantic/inheritance5_error.txt  |   1 +
 src/tester/semantic/isvoid1.cl              |  26 +
 src/tester/semantic/isvoid1_error.txt       |   1 +
 src/tester/semantic/let1.cl                 |  15 +
 src/tester/semantic/let1_error.txt          |   1 +
 src/tester/semantic/let2.cl                 |  15 +
 src/tester/semantic/let2_error.txt          |   1 +
 src/tester/semantic/let3.cl                 |  15 +
 src/tester/semantic/let3_error.txt          |   1 +
 src/tester/semantic/loops1.cl               |   8 +
 src/tester/semantic/loops1_error.txt        |   1 +
 src/tester/semantic/loops2.cl               |   9 +
 src/tester/semantic/loops2_error.txt        |   1 +
 src/tester/semantic/methods1.cl             |  12 +
 src/tester/semantic/methods1_error.txt      |   1 +
 src/tester/semantic/methods2.cl             |  12 +
 src/tester/semantic/methods2_error.txt      |   1 +
 src/tester/semantic/methods3.cl             |  14 +
 src/tester/semantic/methods3_error.txt      |   1 +
 src/tester/semantic/methods4.cl             |  19 +
 src/tester/semantic/methods4_error.txt      |   1 +
 src/tester/semantic/methods5.cl             |  20 +
 src/tester/semantic/methods5_error.txt      |   1 +
 src/tester/semantic/methods6.cl             |  27 +
 src/tester/semantic/methods6_error.txt      |   1 +
 src/tester/semantic/methods7.cl             |  12 +
 src/tester/semantic/methods7_error.txt      |   1 +
 src/tester/semantic/methods8.cl             |  12 +
 src/tester/semantic/methods8_error.txt      |   1 +
 src/tester/semantic/new1.cl                 |  31 +
 src/tester/semantic/new1_error.txt          |   1 +
 src/tester/semantic/self1.cl                |  11 +
 src/tester/semantic/self1_error.txt         |   1 +
 src/tester/semantic/self2.cl                |  10 +
 src/tester/semantic/self2_error.txt         |   1 +
 src/tester/semantic/self3.cl                |  10 +
 src/tester/semantic/self3_error.txt         |   1 +
 src/tester/semantic/self4.cl                |  10 +
 src/tester/semantic/self4_error.txt         |   1 +
 src/tests/codegen/arith.cl                  | 430 +++++++++++
 src/tests/codegen/arith_input.txt           |  13 +
 src/tests/codegen/arith_output.txt          | 158 ++++
 src/tests/codegen/atoi.cl                   | 121 +++
 src/tests/codegen/atoi_input.txt            |   0
 src/tests/codegen/atoi_output.txt           |   1 +
 src/tests/codegen/book_list.cl              | 132 ++++
 src/tests/codegen/book_list_input.txt       |   0
 src/tests/codegen/book_list_output.txt      |   7 +
 src/tests/codegen/cells.cl                  |  97 +++
 src/tests/codegen/cells_input.txt           |   0
 src/tests/codegen/cells_output.txt          |  21 +
 src/tests/codegen/complex.cl                |  52 ++
 src/tests/codegen/complex_input.txt         |   0
 src/tests/codegen/complex_output.txt        |   1 +
 src/tests/codegen/fib.cl                    |  29 +
 src/tests/codegen/fib_input.txt             |   1 +
 src/tests/codegen/fib_output.txt            |   2 +
 src/tests/codegen/graph.cl                  | 381 ++++++++++
 src/tests/codegen/graph_input.txt           |   5 +
 src/tests/codegen/graph_output.txt          |   7 +
 src/tests/codegen/hairyscary.cl             |  67 ++
 src/tests/codegen/hairyscary_input.txt      |   0
 src/tests/codegen/hairyscary_output.txt     |   1 +
 src/tests/codegen/hello_world.cl            |   5 +
 src/tests/codegen/hello_world_input.txt     |   0
 src/tests/codegen/hello_world_output.txt    |   1 +
 src/tests/codegen/io.cl                     | 103 +++
 src/tests/codegen/io_input.txt              |   0
 src/tests/codegen/io_output.txt             |   5 +
 src/tests/codegen/life.cl                   | 436 +++++++++++
 src/tests/codegen/life_input.txt            |  66 ++
 src/tests/codegen/life_output.txt           | 778 ++++++++++++++++++++
 src/tests/codegen/list.cl                   | 141 ++++
 src/tests/codegen/list_input.txt            |   0
 src/tests/codegen/list_output.txt           |   5 +
 src/tests/codegen/new_complex.cl            |  79 ++
 src/tests/codegen/new_complex_input.txt     |   0
 src/tests/codegen/new_complex_output.txt    |   2 +
 src/tests/codegen/palindrome.cl             |  25 +
 src/tests/codegen/palindrome_input.txt      |   1 +
 src/tests/codegen/palindrome_output.txt     |   2 +
 src/tests/codegen/primes.cl                 |  84 +++
 src/tests/codegen/primes_input.txt          |   0
 src/tests/codegen/primes_output.txt         |  96 +++
 src/tests/codegen/print-cool.cl             |   9 +
 src/tests/codegen/print-cool_input.txt      |   0
 src/tests/codegen/print-cool_output.txt     |   1 +
 src/tests/codegen/sort-list.cl              | 146 ++++
 src/tests/codegen/sort-list_input.txt       |   1 +
 src/tests/codegen/sort-list_output.txt      |  10 +
 src/tests/codegen_test.py                   |  17 +
 src/tests/conftest.py                       |   6 +
 src/tests/lexer/comment1.cl                 |  55 ++
 src/tests/lexer/comment1_error.txt          |   1 +
 src/tests/lexer/iis1.cl                     | 111 +++
 src/tests/lexer/iis1_error.txt              |   1 +
 src/tests/lexer/iis2.cl                     | 120 +++
 src/tests/lexer/iis2_error.txt              |   1 +
 src/tests/lexer/iis3.cl                     | 121 +++
 src/tests/lexer/iis3_error.txt              |   1 +
 src/tests/lexer/iis4.cl                     | 120 +++
 src/tests/lexer/iis4_error.txt              |   1 +
 src/tests/lexer/iis5.cl                     | 121 +++
 src/tests/lexer/iis5_error.txt              |   2 +
 src/tests/lexer/iis6.cl                     | 125 ++++
 src/tests/lexer/iis6_error.txt              |   1 +
 src/tests/lexer/mixed1.cl                   |  14 +
 src/tests/lexer/mixed1_error.txt            |   1 +
 src/tests/lexer/mixed2.cl                   |  20 +
 src/tests/lexer/mixed2_error.txt            |   3 +
 src/tests/lexer/string1.cl                  |   6 +
 src/tests/lexer/string1_error.txt           |   2 +
 src/tests/lexer/string2.cl                  |  19 +
 src/tests/lexer/string2_error.txt           |   1 +
 src/tests/lexer/string3.cl                  | Bin 0 -> 234 bytes
 src/tests/lexer/string3_error.txt           |   1 +
 src/tests/lexer/string4.cl                  |  38 +
 src/tests/lexer/string4_error.txt           |   3 +
 src/tests/lexer_test.py                     |  13 +
 src/tests/parser/assignment1.cl             |  37 +
 src/tests/parser/assignment1_error.txt      |   1 +
 src/tests/parser/assignment2.cl             |  37 +
 src/tests/parser/assignment2_error.txt      |   1 +
 src/tests/parser/assignment3.cl             |  37 +
 src/tests/parser/assignment3_error.txt      |   1 +
 src/tests/parser/attribute1.cl              |  34 +
 src/tests/parser/attribute1_error.txt       |   1 +
 src/tests/parser/attribute2.cl              |  34 +
 src/tests/parser/attribute2_error.txt       |   1 +
 src/tests/parser/attribute3.cl              |  34 +
 src/tests/parser/attribute3_error.txt       |   1 +
 src/tests/parser/block1.cl                  |  87 +++
 src/tests/parser/block1_error.txt           |   1 +
 src/tests/parser/block2.cl                  |  87 +++
 src/tests/parser/block2_error.txt           |   1 +
 src/tests/parser/block3.cl                  |  87 +++
 src/tests/parser/block3_error.txt           |   1 +
 src/tests/parser/block4.cl                  |  88 +++
 src/tests/parser/block4_error.txt           |   1 +
 src/tests/parser/case1.cl                   |  91 +++
 src/tests/parser/case1_error.txt            |   1 +
 src/tests/parser/case2.cl                   |  93 +++
 src/tests/parser/case2_error.txt            |   1 +
 src/tests/parser/case3.cl                   |  93 +++
 src/tests/parser/case3_error.txt            |   1 +
 src/tests/parser/case4.cl                   |  93 +++
 src/tests/parser/case4_error.txt            |   1 +
 src/tests/parser/case5.cl                   |  93 +++
 src/tests/parser/case5_error.txt            |   1 +
 src/tests/parser/case6.cl                   |  93 +++
 src/tests/parser/case6_error.txt            |   1 +
 src/tests/parser/class1.cl                  |  20 +
 src/tests/parser/class1_error.txt           |   1 +
 src/tests/parser/class2.cl                  |  20 +
 src/tests/parser/class2_error.txt           |   1 +
 src/tests/parser/class3.cl                  |  34 +
 src/tests/parser/class3_error.txt           |   1 +
 src/tests/parser/class4.cl                  |  36 +
 src/tests/parser/class4_error.txt           |   1 +
 src/tests/parser/class5.cl                  |  34 +
 src/tests/parser/class5_error.txt           |   1 +
 src/tests/parser/class6.cl                  |  34 +
 src/tests/parser/class6_error.txt           |   1 +
 src/tests/parser/conditional1.cl            |  69 ++
 src/tests/parser/conditional1_error.txt     |   1 +
 src/tests/parser/conditional2.cl            |  69 ++
 src/tests/parser/conditional2_error.txt     |   1 +
 src/tests/parser/conditional3.cl            |  69 ++
 src/tests/parser/conditional3_error.txt     |   1 +
 src/tests/parser/conditional4.cl            |  73 ++
 src/tests/parser/conditional4_error.txt     |   1 +
 src/tests/parser/conditional5.cl            |  73 ++
 src/tests/parser/conditional5_error.txt     |   1 +
 src/tests/parser/conditional6.cl            |  73 ++
 src/tests/parser/conditional6_error.txt     |   1 +
 src/tests/parser/dispatch1.cl               |  45 ++
 src/tests/parser/dispatch1_error.txt        |   1 +
 src/tests/parser/dispatch2.cl               |  45 ++
 src/tests/parser/dispatch2_error.txt        |   1 +
 src/tests/parser/dispatch3.cl               |  45 ++
 src/tests/parser/dispatch3_error.txt        |   1 +
 src/tests/parser/dispatch4.cl               |  53 ++
 src/tests/parser/dispatch4_error.txt        |   1 +
 src/tests/parser/dispatch5.cl               |  53 ++
 src/tests/parser/dispatch5_error.txt        |   1 +
 src/tests/parser/dispatch6.cl               |  57 ++
 src/tests/parser/dispatch6_error.txt        |   1 +
 src/tests/parser/dispatch7.cl               |  57 ++
 src/tests/parser/dispatch7_error.txt        |   1 +
 src/tests/parser/dispatch8.cl               |  57 ++
 src/tests/parser/dispatch8_error.txt        |   1 +
 src/tests/parser/dispatch9.cl               |  61 ++
 src/tests/parser/dispatch9_error.txt        |   1 +
 src/tests/parser/let1.cl                    |  85 +++
 src/tests/parser/let1_error.txt             |   1 +
 src/tests/parser/let2.cl                    |  85 +++
 src/tests/parser/let2_error.txt             |   1 +
 src/tests/parser/let3.cl                    |  85 +++
 src/tests/parser/let3_error.txt             |   1 +
 src/tests/parser/let4.cl                    |  85 +++
 src/tests/parser/let4_error.txt             |   1 +
 src/tests/parser/let5.cl                    |  85 +++
 src/tests/parser/let5_error.txt             |   1 +
 src/tests/parser/let6.cl                    |  74 ++
 src/tests/parser/let6_error.txt             |   1 +
 src/tests/parser/let7.cl                    |  85 +++
 src/tests/parser/let7_error.txt             |   1 +
 src/tests/parser/loop1.cl                   |  78 ++
 src/tests/parser/loop1_error.txt            |   1 +
 src/tests/parser/loop2.cl                   |  78 ++
 src/tests/parser/loop2_error.txt            |   1 +
 src/tests/parser/loop3.cl                   |  78 ++
 src/tests/parser/loop3_error.txt            |   1 +
 src/tests/parser/loop4.cl                   |  78 ++
 src/tests/parser/loop4_error.txt            |   1 +
 src/tests/parser/method1.cl                 |  34 +
 src/tests/parser/method1_error.txt          |   1 +
 src/tests/parser/method2.cl                 |  34 +
 src/tests/parser/method2_error.txt          |   1 +
 src/tests/parser/method3.cl                 |  34 +
 src/tests/parser/method3_error.txt          |   1 +
 src/tests/parser/method4.cl                 |  34 +
 src/tests/parser/method4_error.txt          |   1 +
 src/tests/parser/method5.cl                 |  34 +
 src/tests/parser/method5_error.txt          |   1 +
 src/tests/parser/method6.cl                 |  33 +
 src/tests/parser/method6_error.txt          |   1 +
 src/tests/parser/mixed1.cl                  | 100 +++
 src/tests/parser/mixed1_error.txt           |   1 +
 src/tests/parser/mixed2.cl                  |  14 +
 src/tests/parser/mixed2_error.txt           |   1 +
 src/tests/parser/mixed3.cl                  |  40 +
 src/tests/parser/mixed3_error.txt           |   1 +
 src/tests/parser/mixed4.cl                  |  21 +
 src/tests/parser/mixed4_error.txt           |   1 +
 src/tests/parser/mixed5.cl                  |  20 +
 src/tests/parser/mixed5_error.txt           |   1 +
 src/tests/parser/mixed6.cl                  |   5 +
 src/tests/parser/mixed6_error.txt           |   1 +
 src/tests/parser/operation1.cl              | 101 +++
 src/tests/parser/operation1_error.txt       |   1 +
 src/tests/parser/operation2.cl              | 101 +++
 src/tests/parser/operation2_error.txt       |   1 +
 src/tests/parser/operation3.cl              | 101 +++
 src/tests/parser/operation3_error.txt       |   1 +
 src/tests/parser/operation4.cl              | 101 +++
 src/tests/parser/operation4_error.txt       |   1 +
 src/tests/parser/program1.cl                |   1 +
 src/tests/parser/program1_error.txt         |   1 +
 src/tests/parser/program2.cl                |  20 +
 src/tests/parser/program2_error.txt         |   1 +
 src/tests/parser/program3.cl                |  24 +
 src/tests/parser/program3_error.txt         |   1 +
 src/tests/parser_test.py                    |  13 +
 src/tests/semantic/arithmetic1.cl           |  11 +
 src/tests/semantic/arithmetic10.cl          |  15 +
 src/tests/semantic/arithmetic10_error.txt   |   1 +
 src/tests/semantic/arithmetic11.cl          |  14 +
 src/tests/semantic/arithmetic11_error.txt   |   1 +
 src/tests/semantic/arithmetic12.cl          |  14 +
 src/tests/semantic/arithmetic12_error.txt   |   1 +
 src/tests/semantic/arithmetic1_error.txt    |   1 +
 src/tests/semantic/arithmetic2.cl           |  11 +
 src/tests/semantic/arithmetic2_error.txt    |   1 +
 src/tests/semantic/arithmetic3.cl           |  11 +
 src/tests/semantic/arithmetic3_error.txt    |   1 +
 src/tests/semantic/arithmetic4.cl           |  11 +
 src/tests/semantic/arithmetic4_error.txt    |   1 +
 src/tests/semantic/arithmetic5.cl           |  11 +
 src/tests/semantic/arithmetic5_error.txt    |   1 +
 src/tests/semantic/arithmetic6.cl           |  11 +
 src/tests/semantic/arithmetic6_error.txt    |   1 +
 src/tests/semantic/arithmetic7.cl           |  12 +
 src/tests/semantic/arithmetic7_error.txt    |   1 +
 src/tests/semantic/arithmetic8.cl           |  13 +
 src/tests/semantic/arithmetic8_error.txt    |   1 +
 src/tests/semantic/arithmetic9.cl           |  15 +
 src/tests/semantic/arithmetic9_error.txt    |   1 +
 src/tests/semantic/assignment1.cl           |   7 +
 src/tests/semantic/assignment1_error.txt    |   1 +
 src/tests/semantic/assignment2.cl           |  13 +
 src/tests/semantic/assignment2_error.txt    |   1 +
 src/tests/semantic/assignment3.cl           |  14 +
 src/tests/semantic/assignment3_error.txt    |   1 +
 src/tests/semantic/attributes1.cl           |  13 +
 src/tests/semantic/attributes1_error.txt    |   1 +
 src/tests/semantic/attributes2.cl           |  13 +
 src/tests/semantic/attributes2_error.txt    |   1 +
 src/tests/semantic/attributes3.cl           |  25 +
 src/tests/semantic/attributes3_error.txt    |   1 +
 src/tests/semantic/attributes4.cl           |  39 +
 src/tests/semantic/attributes4_error.txt    |   1 +
 src/tests/semantic/basics1.cl               |  10 +
 src/tests/semantic/basics1_error.txt        |   1 +
 src/tests/semantic/basics2.cl               |   9 +
 src/tests/semantic/basics2_error.txt        |   1 +
 src/tests/semantic/basics3.cl               |   9 +
 src/tests/semantic/basics3_error.txt        |   1 +
 src/tests/semantic/basics4.cl               |   9 +
 src/tests/semantic/basics4_error.txt        |   1 +
 src/tests/semantic/basics5.cl               |   9 +
 src/tests/semantic/basics5_error.txt        |   1 +
 src/tests/semantic/basics6.cl               |   9 +
 src/tests/semantic/basics6_error.txt        |   1 +
 src/tests/semantic/basics7.cl               |   9 +
 src/tests/semantic/basics7_error.txt        |   1 +
 src/tests/semantic/basics8.cl               |   9 +
 src/tests/semantic/basics8_error.txt        |   1 +
 src/tests/semantic/blocks1.cl               |  31 +
 src/tests/semantic/blocks1_error.txt        |   1 +
 src/tests/semantic/case1.cl                 |  23 +
 src/tests/semantic/case1_error.txt          |   1 +
 src/tests/semantic/case2.cl                 |  23 +
 src/tests/semantic/case2_error.txt          |   1 +
 src/tests/semantic/case3.cl                 |  23 +
 src/tests/semantic/case3_error.txt          |   1 +
 src/tests/semantic/class1.cl                |   9 +
 src/tests/semantic/class1_error.txt         |   2 +
 src/tests/semantic/conditionals1.cl         |  14 +
 src/tests/semantic/conditionals1_error.txt  |   1 +
 src/tests/semantic/conditionals2.cl         |  24 +
 src/tests/semantic/conditionals2_error.txt  |   2 +
 src/tests/semantic/dispatch1.cl             |  33 +
 src/tests/semantic/dispatch1_error.txt      |   1 +
 src/tests/semantic/dispatch2.cl             |  34 +
 src/tests/semantic/dispatch2_error.txt      |   1 +
 src/tests/semantic/dispatch3.cl             |  36 +
 src/tests/semantic/dispatch3_error.txt      |   1 +
 src/tests/semantic/dispatch4.cl             |  36 +
 src/tests/semantic/dispatch4_error.txt      |   1 +
 src/tests/semantic/dispatch5.cl             |  31 +
 src/tests/semantic/dispatch5_error.txt      |   1 +
 src/tests/semantic/dispatch6.cl             |  32 +
 src/tests/semantic/dispatch6_error.txt      |   1 +
 src/tests/semantic/eq1.cl                   |  17 +
 src/tests/semantic/eq1_error.txt            |   1 +
 src/tests/semantic/eq2.cl                   |  17 +
 src/tests/semantic/eq2_error.txt            |   1 +
 src/tests/semantic/eq3.cl                   |  17 +
 src/tests/semantic/eq3_error.txt            |   1 +
 src/tests/semantic/eq4.cl                   |  17 +
 src/tests/semantic/eq4_error.txt            |   1 +
 src/tests/semantic/features1.cl             |  19 +
 src/tests/semantic/features1_error.txt      |   1 +
 src/tests/semantic/features2.cl             |  19 +
 src/tests/semantic/features2_error.txt      |   1 +
 src/tests/semantic/features3.cl             |  15 +
 src/tests/semantic/features3_error.txt      |   1 +
 src/tests/semantic/inheritance1.cl          |  19 +
 src/tests/semantic/inheritance1_error.txt   |   1 +
 src/tests/semantic/inheritance2.cl          |  19 +
 src/tests/semantic/inheritance2_error.txt   |   1 +
 src/tests/semantic/inheritance3.cl          |  13 +
 src/tests/semantic/inheritance3_error.txt   |   1 +
 src/tests/semantic/inheritance4.cl          |  19 +
 src/tests/semantic/inheritance4_error.txt   |   1 +
 src/tests/semantic/inheritance5.cl          |  21 +
 src/tests/semantic/inheritance5_error.txt   |   1 +
 src/tests/semantic/isvoid1.cl               |  26 +
 src/tests/semantic/isvoid1_error.txt        |   1 +
 src/tests/semantic/let1.cl                  |  15 +
 src/tests/semantic/let1_error.txt           |   1 +
 src/tests/semantic/let2.cl                  |  15 +
 src/tests/semantic/let2_error.txt           |   1 +
 src/tests/semantic/let3.cl                  |  15 +
 src/tests/semantic/let3_error.txt           |   1 +
 src/tests/semantic/loops1.cl                |   8 +
 src/tests/semantic/loops1_error.txt         |   1 +
 src/tests/semantic/loops2.cl                |   9 +
 src/tests/semantic/loops2_error.txt         |   1 +
 src/tests/semantic/methods1.cl              |  12 +
 src/tests/semantic/methods1_error.txt       |   1 +
 src/tests/semantic/methods2.cl              |  12 +
 src/tests/semantic/methods2_error.txt       |   1 +
 src/tests/semantic/methods3.cl              |  14 +
 src/tests/semantic/methods3_error.txt       |   1 +
 src/tests/semantic/methods4.cl              |  19 +
 src/tests/semantic/methods4_error.txt       |   1 +
 src/tests/semantic/methods5.cl              |  20 +
 src/tests/semantic/methods5_error.txt       |   1 +
 src/tests/semantic/methods6.cl              |  27 +
 src/tests/semantic/methods6_error.txt       |   1 +
 src/tests/semantic/methods7.cl              |  12 +
 src/tests/semantic/methods7_error.txt       |   1 +
 src/tests/semantic/methods8.cl              |  12 +
 src/tests/semantic/methods8_error.txt       |   1 +
 src/tests/semantic/new1.cl                  |  31 +
 src/tests/semantic/new1_error.txt           |   1 +
 src/tests/semantic/self1.cl                 |  11 +
 src/tests/semantic/self1_error.txt          |   1 +
 src/tests/semantic/self2.cl                 |  10 +
 src/tests/semantic/self2_error.txt          |   1 +
 src/tests/semantic/self3.cl                 |  10 +
 src/tests/semantic/self3_error.txt          |   1 +
 src/tests/semantic/self4.cl                 |  10 +
 src/tests/semantic/self4_error.txt          |   1 +
 src/tests/semantic_test.py                  |  14 +
 src/tests/utils/__init__.py                 |   1 +
 src/tests/utils/utils.py                    |  91 +++
 src/utils/COOL_Grammar.py                   |  10 +-
 src/utils/COOL_Lexer.py                     |  11 +-
 src/utils/ast/AST_Nodes.py                  |  61 +-
 src/utils/print_code.py                     | 153 ++++
 src/utils/semantic_check/type_builder.py    |   6 +-
 src/utils/semantic_check/type_checker.py    |  18 +-
 src/utils/semantic_check/type_collector.py  |   8 +-
 src/utils/semantic_check/type_inference.py  | 376 ++++++++++
 607 files changed, 16771 insertions(+), 52 deletions(-)
 create mode 100644 src/.vscode/launch.json
 create mode 100644 src/tester/01_program.cl
 create mode 100644 src/tester/02_program.cl
 create mode 100644 src/tester/03_program.cl
 create mode 100644 src/tester/04_program.cl
 create mode 100644 src/tester/05_program.cl
 create mode 100644 src/tester/06_program.cl
 create mode 100644 src/tester/07_program.cl
 create mode 100644 src/tester/08_program.cl
 create mode 100644 src/tester/inference/01_program.cl
 create mode 100644 src/tester/inference/02_program.cl
 create mode 100644 src/tester/inference/03_program.cl
 create mode 100644 src/tester/inference/04_program.cl
 create mode 100644 src/tester/inference/05_program.cl
 create mode 100644 src/tester/inference/06_program.cl
 create mode 100644 src/tester/inference/07_program.cl
 create mode 100644 src/tester/inference/08_program.cl
 create mode 100644 src/tester/lexer/comment1.cl
 create mode 100644 src/tester/lexer/iis1.cl
 create mode 100644 src/tester/lexer/iis2.cl
 create mode 100644 src/tester/lexer/iis3.cl
 create mode 100644 src/tester/lexer/iis4.cl
 create mode 100644 src/tester/lexer/iis5.cl
 create mode 100644 src/tester/lexer/iis6.cl
 create mode 100644 src/tester/lexer/mixed1.cl
 create mode 100644 src/tester/lexer/mixed2.cl
 create mode 100644 src/tester/lexer/string1.cl
 create mode 100644 src/tester/lexer/string2.cl
 create mode 100644 src/tester/lexer/string3.cl
 create mode 100644 src/tester/lexer/string4.cl
 create mode 100644 src/tester/parser/assignment1.cl
 create mode 100644 src/tester/parser/assignment2.cl
 create mode 100644 src/tester/parser/assignment3.cl
 create mode 100644 src/tester/parser/attribute1.cl
 create mode 100644 src/tester/parser/attribute2.cl
 create mode 100644 src/tester/parser/attribute3.cl
 create mode 100644 src/tester/parser/block1.cl
 create mode 100644 src/tester/parser/block2.cl
 create mode 100644 src/tester/parser/block3.cl
 create mode 100644 src/tester/parser/block4.cl
 create mode 100644 src/tester/parser/case1.cl
 create mode 100644 src/tester/parser/case2.cl
 create mode 100644 src/tester/parser/case3.cl
 create mode 100644 src/tester/parser/case4.cl
 create mode 100644 src/tester/parser/case5.cl
 create mode 100644 src/tester/parser/case6.cl
 create mode 100644 src/tester/parser/class1.cl
 create mode 100644 src/tester/parser/class2.cl
 create mode 100644 src/tester/parser/class3.cl
 create mode 100644 src/tester/parser/class4.cl
 create mode 100644 src/tester/parser/class5.cl
 create mode 100644 src/tester/parser/class6.cl
 create mode 100644 src/tester/parser/conditional1.cl
 create mode 100644 src/tester/parser/conditional2.cl
 create mode 100644 src/tester/parser/conditional3.cl
 create mode 100644 src/tester/parser/conditional4.cl
 create mode 100644 src/tester/parser/conditional5.cl
 create mode 100644 src/tester/parser/conditional6.cl
 create mode 100644 src/tester/parser/dispatch1.cl
 create mode 100644 src/tester/parser/dispatch2.cl
 create mode 100644 src/tester/parser/dispatch4.cl
 create mode 100644 src/tester/parser/dispatch5.cl
 create mode 100644 src/tester/parser/dispatch6.cl
 create mode 100644 src/tester/parser/dispatch7.cl
 create mode 100644 src/tester/parser/dispatch8.cl
 create mode 100644 src/tester/parser/dispatch9.cl
 create mode 100644 src/tester/parser/let1.cl
 create mode 100644 src/tester/parser/let2.cl
 create mode 100644 src/tester/parser/let3.cl
 create mode 100644 src/tester/parser/let4.cl
 create mode 100644 src/tester/parser/let5.cl
 create mode 100644 src/tester/parser/let6.cl
 create mode 100644 src/tester/parser/let7.cl
 create mode 100644 src/tester/parser/loop1.cl
 create mode 100644 src/tester/parser/loop2.cl
 create mode 100644 src/tester/parser/loop3.cl
 create mode 100644 src/tester/parser/loop4.cl
 create mode 100644 src/tester/parser/method1.cl
 create mode 100644 src/tester/parser/method2.cl
 create mode 100644 src/tester/parser/method3.cl
 create mode 100644 src/tester/parser/method4.cl
 create mode 100644 src/tester/parser/method5.cl
 create mode 100644 src/tester/parser/method6.cl
 create mode 100644 src/tester/parser/mixed2.cl
 create mode 100644 src/tester/parser/mixed3.cl
 create mode 100644 src/tester/parser/mixed4.cl
 create mode 100644 src/tester/parser/mixed5.cl
 create mode 100644 src/tester/parser/mixed6.cl
 create mode 100644 src/tester/parser/operation1.cl
 create mode 100644 src/tester/parser/operation2.cl
 create mode 100644 src/tester/parser/operation3.cl
 create mode 100644 src/tester/parser/operation4.cl
 create mode 100644 src/tester/parser/program1.cl
 create mode 100644 src/tester/parser/program3.cl
 create mode 100644 src/tester/semantic/01_program.cl
 create mode 100644 src/tester/semantic/arithmetic1.cl
 create mode 100644 src/tester/semantic/arithmetic10.cl
 create mode 100644 src/tester/semantic/arithmetic10_error.txt
 create mode 100644 src/tester/semantic/arithmetic11.cl
 create mode 100644 src/tester/semantic/arithmetic11_error.txt
 create mode 100644 src/tester/semantic/arithmetic12.cl
 create mode 100644 src/tester/semantic/arithmetic12_error.txt
 create mode 100644 src/tester/semantic/arithmetic1_error.txt
 create mode 100644 src/tester/semantic/arithmetic2.cl
 create mode 100644 src/tester/semantic/arithmetic2_error.txt
 create mode 100644 src/tester/semantic/arithmetic3.cl
 create mode 100644 src/tester/semantic/arithmetic3_error.txt
 create mode 100644 src/tester/semantic/arithmetic4.cl
 create mode 100644 src/tester/semantic/arithmetic4_error.txt
 create mode 100644 src/tester/semantic/arithmetic5.cl
 create mode 100644 src/tester/semantic/arithmetic5_error.txt
 create mode 100644 src/tester/semantic/arithmetic6.cl
 create mode 100644 src/tester/semantic/arithmetic6_error.txt
 create mode 100644 src/tester/semantic/arithmetic7.cl
 create mode 100644 src/tester/semantic/arithmetic7_error.txt
 create mode 100644 src/tester/semantic/arithmetic8.cl
 create mode 100644 src/tester/semantic/arithmetic8_error.txt
 create mode 100644 src/tester/semantic/arithmetic9.cl
 create mode 100644 src/tester/semantic/arithmetic9_error.txt
 create mode 100644 src/tester/semantic/assignment1.cl
 create mode 100644 src/tester/semantic/assignment1_error.txt
 create mode 100644 src/tester/semantic/assignment2.cl
 create mode 100644 src/tester/semantic/assignment2_error.txt
 create mode 100644 src/tester/semantic/assignment3.cl
 create mode 100644 src/tester/semantic/assignment3_error.txt
 create mode 100644 src/tester/semantic/attributes1.cl
 create mode 100644 src/tester/semantic/attributes1_error.txt
 create mode 100644 src/tester/semantic/attributes2.cl
 create mode 100644 src/tester/semantic/attributes2_error.txt
 create mode 100644 src/tester/semantic/attributes3.cl
 create mode 100644 src/tester/semantic/attributes3_error.txt
 create mode 100644 src/tester/semantic/attributes4.cl
 create mode 100644 src/tester/semantic/attributes4_error.txt
 create mode 100644 src/tester/semantic/basics1.cl
 create mode 100644 src/tester/semantic/basics1_error.txt
 create mode 100644 src/tester/semantic/basics2.cl
 create mode 100644 src/tester/semantic/basics2_error.txt
 create mode 100644 src/tester/semantic/basics3.cl
 create mode 100644 src/tester/semantic/basics3_error.txt
 create mode 100644 src/tester/semantic/basics4.cl
 create mode 100644 src/tester/semantic/basics4_error.txt
 create mode 100644 src/tester/semantic/basics5.cl
 create mode 100644 src/tester/semantic/basics5_error.txt
 create mode 100644 src/tester/semantic/basics6.cl
 create mode 100644 src/tester/semantic/basics6_error.txt
 create mode 100644 src/tester/semantic/basics7.cl
 create mode 100644 src/tester/semantic/basics7_error.txt
 create mode 100644 src/tester/semantic/basics8.cl
 create mode 100644 src/tester/semantic/basics8_error.txt
 create mode 100644 src/tester/semantic/blocks1.cl
 create mode 100644 src/tester/semantic/blocks1_error.txt
 create mode 100644 src/tester/semantic/case1.cl
 create mode 100644 src/tester/semantic/case1_error.txt
 create mode 100644 src/tester/semantic/case2.cl
 create mode 100644 src/tester/semantic/case2_error.txt
 create mode 100644 src/tester/semantic/case3.cl
 create mode 100644 src/tester/semantic/case3_error.txt
 create mode 100644 src/tester/semantic/class1.cl
 create mode 100644 src/tester/semantic/class1_error.txt
 create mode 100644 src/tester/semantic/conditionals1.cl
 create mode 100644 src/tester/semantic/conditionals1_error.txt
 create mode 100644 src/tester/semantic/conditionals2.cl
 create mode 100644 src/tester/semantic/conditionals2_error.txt
 create mode 100644 src/tester/semantic/dispatch1.cl
 create mode 100644 src/tester/semantic/dispatch1_error.txt
 create mode 100644 src/tester/semantic/dispatch2.cl
 create mode 100644 src/tester/semantic/dispatch2_error.txt
 create mode 100644 src/tester/semantic/dispatch3.cl
 create mode 100644 src/tester/semantic/dispatch3_error.txt
 create mode 100644 src/tester/semantic/dispatch4.cl
 create mode 100644 src/tester/semantic/dispatch4_error.txt
 create mode 100644 src/tester/semantic/dispatch5.cl
 create mode 100644 src/tester/semantic/dispatch5_error.txt
 create mode 100644 src/tester/semantic/dispatch6.cl
 create mode 100644 src/tester/semantic/dispatch6_error.txt
 create mode 100644 src/tester/semantic/eq1.cl
 create mode 100644 src/tester/semantic/eq1_error.txt
 create mode 100644 src/tester/semantic/eq2.cl
 create mode 100644 src/tester/semantic/eq2_error.txt
 create mode 100644 src/tester/semantic/eq3.cl
 create mode 100644 src/tester/semantic/eq3_error.txt
 create mode 100644 src/tester/semantic/eq4.cl
 create mode 100644 src/tester/semantic/eq4_error.txt
 create mode 100644 src/tester/semantic/features1.cl
 create mode 100644 src/tester/semantic/features1_error.txt
 create mode 100644 src/tester/semantic/features2.cl
 create mode 100644 src/tester/semantic/features2_error.txt
 create mode 100644 src/tester/semantic/features3.cl
 create mode 100644 src/tester/semantic/features3_error.txt
 create mode 100644 src/tester/semantic/inheritance1.cl
 create mode 100644 src/tester/semantic/inheritance1_error.txt
 create mode 100644 src/tester/semantic/inheritance2.cl
 create mode 100644 src/tester/semantic/inheritance2_error.txt
 create mode 100644 src/tester/semantic/inheritance3.cl
 create mode 100644 src/tester/semantic/inheritance3_error.txt
 create mode 100644 src/tester/semantic/inheritance4.cl
 create mode 100644 src/tester/semantic/inheritance4_error.txt
 create mode 100644 src/tester/semantic/inheritance5.cl
 create mode 100644 src/tester/semantic/inheritance5_error.txt
 create mode 100644 src/tester/semantic/isvoid1.cl
 create mode 100644 src/tester/semantic/isvoid1_error.txt
 create mode 100644 src/tester/semantic/let1.cl
 create mode 100644 src/tester/semantic/let1_error.txt
 create mode 100644 src/tester/semantic/let2.cl
 create mode 100644 src/tester/semantic/let2_error.txt
 create mode 100644 src/tester/semantic/let3.cl
 create mode 100644 src/tester/semantic/let3_error.txt
 create mode 100644 src/tester/semantic/loops1.cl
 create mode 100644 src/tester/semantic/loops1_error.txt
 create mode 100644 src/tester/semantic/loops2.cl
 create mode 100644 src/tester/semantic/loops2_error.txt
 create mode 100644 src/tester/semantic/methods1.cl
 create mode 100644 src/tester/semantic/methods1_error.txt
 create mode 100644 src/tester/semantic/methods2.cl
 create mode 100644 src/tester/semantic/methods2_error.txt
 create mode 100644 src/tester/semantic/methods3.cl
 create mode 100644 src/tester/semantic/methods3_error.txt
 create mode 100644 src/tester/semantic/methods4.cl
 create mode 100644 src/tester/semantic/methods4_error.txt
 create mode 100644 src/tester/semantic/methods5.cl
 create mode 100644 src/tester/semantic/methods5_error.txt
 create mode 100644 src/tester/semantic/methods6.cl
 create mode 100644 src/tester/semantic/methods6_error.txt
 create mode 100644 src/tester/semantic/methods7.cl
 create mode 100644 src/tester/semantic/methods7_error.txt
 create mode 100644 src/tester/semantic/methods8.cl
 create mode 100644 src/tester/semantic/methods8_error.txt
 create mode 100644 src/tester/semantic/new1.cl
 create mode 100644 src/tester/semantic/new1_error.txt
 create mode 100644 src/tester/semantic/self1.cl
 create mode 100644 src/tester/semantic/self1_error.txt
 create mode 100644 src/tester/semantic/self2.cl
 create mode 100644 src/tester/semantic/self2_error.txt
 create mode 100644 src/tester/semantic/self3.cl
 create mode 100644 src/tester/semantic/self3_error.txt
 create mode 100644 src/tester/semantic/self4.cl
 create mode 100644 src/tester/semantic/self4_error.txt
 create mode 100644 src/tests/codegen/arith.cl
 create mode 100644 src/tests/codegen/arith_input.txt
 create mode 100644 src/tests/codegen/arith_output.txt
 create mode 100644 src/tests/codegen/atoi.cl
 create mode 100644 src/tests/codegen/atoi_input.txt
 create mode 100644 src/tests/codegen/atoi_output.txt
 create mode 100644 src/tests/codegen/book_list.cl
 create mode 100644 src/tests/codegen/book_list_input.txt
 create mode 100644 src/tests/codegen/book_list_output.txt
 create mode 100644 src/tests/codegen/cells.cl
 create mode 100644 src/tests/codegen/cells_input.txt
 create mode 100644 src/tests/codegen/cells_output.txt
 create mode 100644 src/tests/codegen/complex.cl
 create mode 100644 src/tests/codegen/complex_input.txt
 create mode 100644 src/tests/codegen/complex_output.txt
 create mode 100644 src/tests/codegen/fib.cl
 create mode 100644 src/tests/codegen/fib_input.txt
 create mode 100644 src/tests/codegen/fib_output.txt
 create mode 100644 src/tests/codegen/graph.cl
 create mode 100644 src/tests/codegen/graph_input.txt
 create mode 100644 src/tests/codegen/graph_output.txt
 create mode 100644 src/tests/codegen/hairyscary.cl
 create mode 100644 src/tests/codegen/hairyscary_input.txt
 create mode 100644 src/tests/codegen/hairyscary_output.txt
 create mode 100644 src/tests/codegen/hello_world.cl
 create mode 100644 src/tests/codegen/hello_world_input.txt
 create mode 100644 src/tests/codegen/hello_world_output.txt
 create mode 100644 src/tests/codegen/io.cl
 create mode 100644 src/tests/codegen/io_input.txt
 create mode 100644 src/tests/codegen/io_output.txt
 create mode 100644 src/tests/codegen/life.cl
 create mode 100644 src/tests/codegen/life_input.txt
 create mode 100644 src/tests/codegen/life_output.txt
 create mode 100644 src/tests/codegen/list.cl
 create mode 100644 src/tests/codegen/list_input.txt
 create mode 100644 src/tests/codegen/list_output.txt
 create mode 100644 src/tests/codegen/new_complex.cl
 create mode 100644 src/tests/codegen/new_complex_input.txt
 create mode 100644 src/tests/codegen/new_complex_output.txt
 create mode 100644 src/tests/codegen/palindrome.cl
 create mode 100644 src/tests/codegen/palindrome_input.txt
 create mode 100644 src/tests/codegen/palindrome_output.txt
 create mode 100644 src/tests/codegen/primes.cl
 create mode 100644 src/tests/codegen/primes_input.txt
 create mode 100644 src/tests/codegen/primes_output.txt
 create mode 100644 src/tests/codegen/print-cool.cl
 create mode 100644 src/tests/codegen/print-cool_input.txt
 create mode 100644 src/tests/codegen/print-cool_output.txt
 create mode 100644 src/tests/codegen/sort-list.cl
 create mode 100644 src/tests/codegen/sort-list_input.txt
 create mode 100644 src/tests/codegen/sort-list_output.txt
 create mode 100644 src/tests/codegen_test.py
 create mode 100644 src/tests/conftest.py
 create mode 100644 src/tests/lexer/comment1.cl
 create mode 100644 src/tests/lexer/comment1_error.txt
 create mode 100644 src/tests/lexer/iis1.cl
 create mode 100644 src/tests/lexer/iis1_error.txt
 create mode 100644 src/tests/lexer/iis2.cl
 create mode 100644 src/tests/lexer/iis2_error.txt
 create mode 100644 src/tests/lexer/iis3.cl
 create mode 100644 src/tests/lexer/iis3_error.txt
 create mode 100644 src/tests/lexer/iis4.cl
 create mode 100644 src/tests/lexer/iis4_error.txt
 create mode 100644 src/tests/lexer/iis5.cl
 create mode 100644 src/tests/lexer/iis5_error.txt
 create mode 100644 src/tests/lexer/iis6.cl
 create mode 100644 src/tests/lexer/iis6_error.txt
 create mode 100644 src/tests/lexer/mixed1.cl
 create mode 100644 src/tests/lexer/mixed1_error.txt
 create mode 100644 src/tests/lexer/mixed2.cl
 create mode 100644 src/tests/lexer/mixed2_error.txt
 create mode 100644 src/tests/lexer/string1.cl
 create mode 100644 src/tests/lexer/string1_error.txt
 create mode 100644 src/tests/lexer/string2.cl
 create mode 100644 src/tests/lexer/string2_error.txt
 create mode 100644 src/tests/lexer/string3.cl
 create mode 100644 src/tests/lexer/string3_error.txt
 create mode 100644 src/tests/lexer/string4.cl
 create mode 100644 src/tests/lexer/string4_error.txt
 create mode 100644 src/tests/lexer_test.py
 create mode 100644 src/tests/parser/assignment1.cl
 create mode 100644 src/tests/parser/assignment1_error.txt
 create mode 100644 src/tests/parser/assignment2.cl
 create mode 100644 src/tests/parser/assignment2_error.txt
 create mode 100644 src/tests/parser/assignment3.cl
 create mode 100644 src/tests/parser/assignment3_error.txt
 create mode 100644 src/tests/parser/attribute1.cl
 create mode 100644 src/tests/parser/attribute1_error.txt
 create mode 100644 src/tests/parser/attribute2.cl
 create mode 100644 src/tests/parser/attribute2_error.txt
 create mode 100644 src/tests/parser/attribute3.cl
 create mode 100644 src/tests/parser/attribute3_error.txt
 create mode 100644 src/tests/parser/block1.cl
 create mode 100644 src/tests/parser/block1_error.txt
 create mode 100644 src/tests/parser/block2.cl
 create mode 100644 src/tests/parser/block2_error.txt
 create mode 100644 src/tests/parser/block3.cl
 create mode 100644 src/tests/parser/block3_error.txt
 create mode 100644 src/tests/parser/block4.cl
 create mode 100644 src/tests/parser/block4_error.txt
 create mode 100644 src/tests/parser/case1.cl
 create mode 100644 src/tests/parser/case1_error.txt
 create mode 100644 src/tests/parser/case2.cl
 create mode 100644 src/tests/parser/case2_error.txt
 create mode 100644 src/tests/parser/case3.cl
 create mode 100644 src/tests/parser/case3_error.txt
 create mode 100644 src/tests/parser/case4.cl
 create mode 100644 src/tests/parser/case4_error.txt
 create mode 100644 src/tests/parser/case5.cl
 create mode 100644 src/tests/parser/case5_error.txt
 create mode 100644 src/tests/parser/case6.cl
 create mode 100644 src/tests/parser/case6_error.txt
 create mode 100644 src/tests/parser/class1.cl
 create mode 100644 src/tests/parser/class1_error.txt
 create mode 100644 src/tests/parser/class2.cl
 create mode 100644 src/tests/parser/class2_error.txt
 create mode 100644 src/tests/parser/class3.cl
 create mode 100644 src/tests/parser/class3_error.txt
 create mode 100644 src/tests/parser/class4.cl
 create mode 100644 src/tests/parser/class4_error.txt
 create mode 100644 src/tests/parser/class5.cl
 create mode 100644 src/tests/parser/class5_error.txt
 create mode 100644 src/tests/parser/class6.cl
 create mode 100644 src/tests/parser/class6_error.txt
 create mode 100644 src/tests/parser/conditional1.cl
 create mode 100644 src/tests/parser/conditional1_error.txt
 create mode 100644 src/tests/parser/conditional2.cl
 create mode 100644 src/tests/parser/conditional2_error.txt
 create mode 100644 src/tests/parser/conditional3.cl
 create mode 100644 src/tests/parser/conditional3_error.txt
 create mode 100644 src/tests/parser/conditional4.cl
 create mode 100644 src/tests/parser/conditional4_error.txt
 create mode 100644 src/tests/parser/conditional5.cl
 create mode 100644 src/tests/parser/conditional5_error.txt
 create mode 100644 src/tests/parser/conditional6.cl
 create mode 100644 src/tests/parser/conditional6_error.txt
 create mode 100644 src/tests/parser/dispatch1.cl
 create mode 100644 src/tests/parser/dispatch1_error.txt
 create mode 100644 src/tests/parser/dispatch2.cl
 create mode 100644 src/tests/parser/dispatch2_error.txt
 create mode 100644 src/tests/parser/dispatch3.cl
 create mode 100644 src/tests/parser/dispatch3_error.txt
 create mode 100644 src/tests/parser/dispatch4.cl
 create mode 100644 src/tests/parser/dispatch4_error.txt
 create mode 100644 src/tests/parser/dispatch5.cl
 create mode 100644 src/tests/parser/dispatch5_error.txt
 create mode 100644 src/tests/parser/dispatch6.cl
 create mode 100644 src/tests/parser/dispatch6_error.txt
 create mode 100644 src/tests/parser/dispatch7.cl
 create mode 100644 src/tests/parser/dispatch7_error.txt
 create mode 100644 src/tests/parser/dispatch8.cl
 create mode 100644 src/tests/parser/dispatch8_error.txt
 create mode 100644 src/tests/parser/dispatch9.cl
 create mode 100644 src/tests/parser/dispatch9_error.txt
 create mode 100644 src/tests/parser/let1.cl
 create mode 100644 src/tests/parser/let1_error.txt
 create mode 100644 src/tests/parser/let2.cl
 create mode 100644 src/tests/parser/let2_error.txt
 create mode 100644 src/tests/parser/let3.cl
 create mode 100644 src/tests/parser/let3_error.txt
 create mode 100644 src/tests/parser/let4.cl
 create mode 100644 src/tests/parser/let4_error.txt
 create mode 100644 src/tests/parser/let5.cl
 create mode 100644 src/tests/parser/let5_error.txt
 create mode 100644 src/tests/parser/let6.cl
 create mode 100644 src/tests/parser/let6_error.txt
 create mode 100644 src/tests/parser/let7.cl
 create mode 100644 src/tests/parser/let7_error.txt
 create mode 100644 src/tests/parser/loop1.cl
 create mode 100644 src/tests/parser/loop1_error.txt
 create mode 100644 src/tests/parser/loop2.cl
 create mode 100644 src/tests/parser/loop2_error.txt
 create mode 100644 src/tests/parser/loop3.cl
 create mode 100644 src/tests/parser/loop3_error.txt
 create mode 100644 src/tests/parser/loop4.cl
 create mode 100644 src/tests/parser/loop4_error.txt
 create mode 100644 src/tests/parser/method1.cl
 create mode 100644 src/tests/parser/method1_error.txt
 create mode 100644 src/tests/parser/method2.cl
 create mode 100644 src/tests/parser/method2_error.txt
 create mode 100644 src/tests/parser/method3.cl
 create mode 100644 src/tests/parser/method3_error.txt
 create mode 100644 src/tests/parser/method4.cl
 create mode 100644 src/tests/parser/method4_error.txt
 create mode 100644 src/tests/parser/method5.cl
 create mode 100644 src/tests/parser/method5_error.txt
 create mode 100644 src/tests/parser/method6.cl
 create mode 100644 src/tests/parser/method6_error.txt
 create mode 100644 src/tests/parser/mixed1.cl
 create mode 100644 src/tests/parser/mixed1_error.txt
 create mode 100644 src/tests/parser/mixed2.cl
 create mode 100644 src/tests/parser/mixed2_error.txt
 create mode 100644 src/tests/parser/mixed3.cl
 create mode 100644 src/tests/parser/mixed3_error.txt
 create mode 100644 src/tests/parser/mixed4.cl
 create mode 100644 src/tests/parser/mixed4_error.txt
 create mode 100644 src/tests/parser/mixed5.cl
 create mode 100644 src/tests/parser/mixed5_error.txt
 create mode 100644 src/tests/parser/mixed6.cl
 create mode 100644 src/tests/parser/mixed6_error.txt
 create mode 100644 src/tests/parser/operation1.cl
 create mode 100644 src/tests/parser/operation1_error.txt
 create mode 100644 src/tests/parser/operation2.cl
 create mode 100644 src/tests/parser/operation2_error.txt
 create mode 100644 src/tests/parser/operation3.cl
 create mode 100644 src/tests/parser/operation3_error.txt
 create mode 100644 src/tests/parser/operation4.cl
 create mode 100644 src/tests/parser/operation4_error.txt
 create mode 100644 src/tests/parser/program1.cl
 create mode 100644 src/tests/parser/program1_error.txt
 create mode 100644 src/tests/parser/program2.cl
 create mode 100644 src/tests/parser/program2_error.txt
 create mode 100644 src/tests/parser/program3.cl
 create mode 100644 src/tests/parser/program3_error.txt
 create mode 100644 src/tests/parser_test.py
 create mode 100644 src/tests/semantic/arithmetic1.cl
 create mode 100644 src/tests/semantic/arithmetic10.cl
 create mode 100644 src/tests/semantic/arithmetic10_error.txt
 create mode 100644 src/tests/semantic/arithmetic11.cl
 create mode 100644 src/tests/semantic/arithmetic11_error.txt
 create mode 100644 src/tests/semantic/arithmetic12.cl
 create mode 100644 src/tests/semantic/arithmetic12_error.txt
 create mode 100644 src/tests/semantic/arithmetic1_error.txt
 create mode 100644 src/tests/semantic/arithmetic2.cl
 create mode 100644 src/tests/semantic/arithmetic2_error.txt
 create mode 100644 src/tests/semantic/arithmetic3.cl
 create mode 100644 src/tests/semantic/arithmetic3_error.txt
 create mode 100644 src/tests/semantic/arithmetic4.cl
 create mode 100644 src/tests/semantic/arithmetic4_error.txt
 create mode 100644 src/tests/semantic/arithmetic5.cl
 create mode 100644 src/tests/semantic/arithmetic5_error.txt
 create mode 100644 src/tests/semantic/arithmetic6.cl
 create mode 100644 src/tests/semantic/arithmetic6_error.txt
 create mode 100644 src/tests/semantic/arithmetic7.cl
 create mode 100644 src/tests/semantic/arithmetic7_error.txt
 create mode 100644 src/tests/semantic/arithmetic8.cl
 create mode 100644 src/tests/semantic/arithmetic8_error.txt
 create mode 100644 src/tests/semantic/arithmetic9.cl
 create mode 100644 src/tests/semantic/arithmetic9_error.txt
 create mode 100644 src/tests/semantic/assignment1.cl
 create mode 100644 src/tests/semantic/assignment1_error.txt
 create mode 100644 src/tests/semantic/assignment2.cl
 create mode 100644 src/tests/semantic/assignment2_error.txt
 create mode 100644 src/tests/semantic/assignment3.cl
 create mode 100644 src/tests/semantic/assignment3_error.txt
 create mode 100644 src/tests/semantic/attributes1.cl
 create mode 100644 src/tests/semantic/attributes1_error.txt
 create mode 100644 src/tests/semantic/attributes2.cl
 create mode 100644 src/tests/semantic/attributes2_error.txt
 create mode 100644 src/tests/semantic/attributes3.cl
 create mode 100644 src/tests/semantic/attributes3_error.txt
 create mode 100644 src/tests/semantic/attributes4.cl
 create mode 100644 src/tests/semantic/attributes4_error.txt
 create mode 100644 src/tests/semantic/basics1.cl
 create mode 100644 src/tests/semantic/basics1_error.txt
 create mode 100644 src/tests/semantic/basics2.cl
 create mode 100644 src/tests/semantic/basics2_error.txt
 create mode 100644 src/tests/semantic/basics3.cl
 create mode 100644 src/tests/semantic/basics3_error.txt
 create mode 100644 src/tests/semantic/basics4.cl
 create mode 100644 src/tests/semantic/basics4_error.txt
 create mode 100644 src/tests/semantic/basics5.cl
 create mode 100644 src/tests/semantic/basics5_error.txt
 create mode 100644 src/tests/semantic/basics6.cl
 create mode 100644 src/tests/semantic/basics6_error.txt
 create mode 100644 src/tests/semantic/basics7.cl
 create mode 100644 src/tests/semantic/basics7_error.txt
 create mode 100644 src/tests/semantic/basics8.cl
 create mode 100644 src/tests/semantic/basics8_error.txt
 create mode 100644 src/tests/semantic/blocks1.cl
 create mode 100644 src/tests/semantic/blocks1_error.txt
 create mode 100644 src/tests/semantic/case1.cl
 create mode 100644 src/tests/semantic/case1_error.txt
 create mode 100644 src/tests/semantic/case2.cl
 create mode 100644 src/tests/semantic/case2_error.txt
 create mode 100644 src/tests/semantic/case3.cl
 create mode 100644 src/tests/semantic/case3_error.txt
 create mode 100644 src/tests/semantic/class1.cl
 create mode 100644 src/tests/semantic/class1_error.txt
 create mode 100644 src/tests/semantic/conditionals1.cl
 create mode 100644 src/tests/semantic/conditionals1_error.txt
 create mode 100644 src/tests/semantic/conditionals2.cl
 create mode 100644 src/tests/semantic/conditionals2_error.txt
 create mode 100644 src/tests/semantic/dispatch1.cl
 create mode 100644 src/tests/semantic/dispatch1_error.txt
 create mode 100644 src/tests/semantic/dispatch2.cl
 create mode 100644 src/tests/semantic/dispatch2_error.txt
 create mode 100644 src/tests/semantic/dispatch3.cl
 create mode 100644 src/tests/semantic/dispatch3_error.txt
 create mode 100644 src/tests/semantic/dispatch4.cl
 create mode 100644 src/tests/semantic/dispatch4_error.txt
 create mode 100644 src/tests/semantic/dispatch5.cl
 create mode 100644 src/tests/semantic/dispatch5_error.txt
 create mode 100644 src/tests/semantic/dispatch6.cl
 create mode 100644 src/tests/semantic/dispatch6_error.txt
 create mode 100644 src/tests/semantic/eq1.cl
 create mode 100644 src/tests/semantic/eq1_error.txt
 create mode 100644 src/tests/semantic/eq2.cl
 create mode 100644 src/tests/semantic/eq2_error.txt
 create mode 100644 src/tests/semantic/eq3.cl
 create mode 100644 src/tests/semantic/eq3_error.txt
 create mode 100644 src/tests/semantic/eq4.cl
 create mode 100644 src/tests/semantic/eq4_error.txt
 create mode 100644 src/tests/semantic/features1.cl
 create mode 100644 src/tests/semantic/features1_error.txt
 create mode 100644 src/tests/semantic/features2.cl
 create mode 100644 src/tests/semantic/features2_error.txt
 create mode 100644 src/tests/semantic/features3.cl
 create mode 100644 src/tests/semantic/features3_error.txt
 create mode 100644 src/tests/semantic/inheritance1.cl
 create mode 100644 src/tests/semantic/inheritance1_error.txt
 create mode 100644 src/tests/semantic/inheritance2.cl
 create mode 100644 src/tests/semantic/inheritance2_error.txt
 create mode 100644 src/tests/semantic/inheritance3.cl
 create mode 100644 src/tests/semantic/inheritance3_error.txt
 create mode 100644 src/tests/semantic/inheritance4.cl
 create mode 100644 src/tests/semantic/inheritance4_error.txt
 create mode 100644 src/tests/semantic/inheritance5.cl
 create mode 100644 src/tests/semantic/inheritance5_error.txt
 create mode 100644 src/tests/semantic/isvoid1.cl
 create mode 100644 src/tests/semantic/isvoid1_error.txt
 create mode 100644 src/tests/semantic/let1.cl
 create mode 100644 src/tests/semantic/let1_error.txt
 create mode 100644 src/tests/semantic/let2.cl
 create mode 100644 src/tests/semantic/let2_error.txt
 create mode 100644 src/tests/semantic/let3.cl
 create mode 100644 src/tests/semantic/let3_error.txt
 create mode 100644 src/tests/semantic/loops1.cl
 create mode 100644 src/tests/semantic/loops1_error.txt
 create mode 100644 src/tests/semantic/loops2.cl
 create mode 100644 src/tests/semantic/loops2_error.txt
 create mode 100644 src/tests/semantic/methods1.cl
 create mode 100644 src/tests/semantic/methods1_error.txt
 create mode 100644 src/tests/semantic/methods2.cl
 create mode 100644 src/tests/semantic/methods2_error.txt
 create mode 100644 src/tests/semantic/methods3.cl
 create mode 100644 src/tests/semantic/methods3_error.txt
 create mode 100644 src/tests/semantic/methods4.cl
 create mode 100644 src/tests/semantic/methods4_error.txt
 create mode 100644 src/tests/semantic/methods5.cl
 create mode 100644 src/tests/semantic/methods5_error.txt
 create mode 100644 src/tests/semantic/methods6.cl
 create mode 100644 src/tests/semantic/methods6_error.txt
 create mode 100644 src/tests/semantic/methods7.cl
 create mode 100644 src/tests/semantic/methods7_error.txt
 create mode 100644 src/tests/semantic/methods8.cl
 create mode 100644 src/tests/semantic/methods8_error.txt
 create mode 100644 src/tests/semantic/new1.cl
 create mode 100644 src/tests/semantic/new1_error.txt
 create mode 100644 src/tests/semantic/self1.cl
 create mode 100644 src/tests/semantic/self1_error.txt
 create mode 100644 src/tests/semantic/self2.cl
 create mode 100644 src/tests/semantic/self2_error.txt
 create mode 100644 src/tests/semantic/self3.cl
 create mode 100644 src/tests/semantic/self3_error.txt
 create mode 100644 src/tests/semantic/self4.cl
 create mode 100644 src/tests/semantic/self4_error.txt
 create mode 100644 src/tests/semantic_test.py
 create mode 100644 src/tests/utils/__init__.py
 create mode 100644 src/tests/utils/utils.py
 create mode 100644 src/utils/print_code.py
 create mode 100644 src/utils/semantic_check/type_inference.py

diff --git a/requirements.txt b/requirements.txt
index 9eb0cad1a..46208609f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
 pytest
-pytest-ordering
+pytest-ordering
\ No newline at end of file
diff --git a/src/.vscode/launch.json b/src/.vscode/launch.json
new file mode 100644
index 000000000..0ddbd8f8b
--- /dev/null
+++ b/src/.vscode/launch.json
@@ -0,0 +1,30 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File",
+            "type": "python",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        },
+        {
+            "name": "Python: Remote Attach",
+            "type": "python",
+            "request": "attach",
+            "connect": {
+                "host": "localhost",
+                "port": 5678
+            },
+            "pathMappings": [
+                {
+                    "localRoot": "${workspaceFolder}",
+                    "remoteRoot": "."
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/main.py b/src/main.py
index 77550ed4c..7b8464413 100644
--- a/src/main.py
+++ b/src/main.py
@@ -1,4 +1,5 @@
 import argparse 
+import os
 from utils.COOL_Grammar import build_COOL_Grammar
 from utils.COOL_Lexer import COOL_Lexer
 from utils.parser.COOL_parser import COOL_Parser
@@ -8,10 +9,13 @@
 from utils.semantic_check.type_builder import TypeBuilder
 from utils.semantic_check.type_checker import TypeChecker
 
+a = 'arithmetic1.cl' 
+
 def main(args):
     
     try:
-        with open(args.file, 'r') as file:
+        #with open(args.file, 'r') as file:
+        with open(os.getcwd() + '/tester/semantic/' + args, 'r') as file:
             code = file.read()
     except:
         print(f"(0,0) - CompilerError: file {args.file} not found")
@@ -26,7 +30,7 @@ def main(args):
     if lexer.errors:
         for error in lexer.errors:
             print(error)
-        exit(1)
+        raise Exception()
 
     # parser
     parser = COOL_Parser(G)
@@ -56,10 +60,12 @@ def main(args):
             print(error)                          
         exit(1)
 
-if __name__ == "__main__":
+# if __name__ == "__main__":
+
+#     parser = argparse.ArgumentParser(description='description')
+#     parser.add_argument('-f', '--file', type=str, default='', help='file to read')
 
-    parser = argparse.ArgumentParser(description='description')
-    parser.add_argument('-f', '--file', type=str, default='', help='file to read')
+#     args = parser.parse_args()
+#     main(args)
 
-    args = parser.parse_args()
-    main(args)
\ No newline at end of file
+main('dispatch1.cl')
\ No newline at end of file
diff --git a/src/tester/01_program.cl b/src/tester/01_program.cl
new file mode 100644
index 000000000..ba0d51f47
--- /dev/null
+++ b/src/tester/01_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    main (): Object {
+        0
+    };
+};
+
+class Point {
+    x: AUTO_TYPE;
+    y: AUTO_TYPE;
+
+    init(x0: Int, y0: Int): AUTO_TYPE {{
+        x <- x0;
+        y <- y0;
+        self;
+    }};
+};
\ No newline at end of file
diff --git a/src/tester/02_program.cl b/src/tester/02_program.cl
new file mode 100644
index 000000000..553bb606a
--- /dev/null
+++ b/src/tester/02_program.cl
@@ -0,0 +1,15 @@
+class Main {
+    main (): Object {
+        0
+    };
+};
+
+class Ackermann {
+    ackermann(m: AUTO_TYPE, n: AUTO_TYPE): AUTO_TYPE {
+        if m = 0 then n + 1 else
+            if n = 0 then ackermann(m - 1, 1) else
+                ackermann(m - 1, ackermann(m, n - 1))
+            fi
+        fi
+    };
+};
\ No newline at end of file
diff --git a/src/tester/03_program.cl b/src/tester/03_program.cl
new file mode 100644
index 000000000..0f74ed244
--- /dev/null
+++ b/src/tester/03_program.cl
@@ -0,0 +1,17 @@
+class Main {
+    main (): Object {
+        0
+    };
+
+    f(a: AUTO_TYPE, b: AUTO_TYPE): AUTO_TYPE {
+        if a = 1 then b else
+            g(a + 1, b / 1)
+        fi
+    };
+
+    g(a: AUTO_TYPE, b: AUTO_TYPE): AUTO_TYPE {
+        if b = 1 then a else
+            f(a / 2, b + 1)
+        fi
+    };
+};
\ No newline at end of file
diff --git a/src/tester/04_program.cl b/src/tester/04_program.cl
new file mode 100644
index 000000000..ab46ef273
--- /dev/null
+++ b/src/tester/04_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    main (): Object {
+        0
+    };
+};
+
+class Point {
+    x: Int;
+    y: Int;
+
+    init(x0: AUTO_TYPE, y0: AUTO_TYPE): AUTO_TYPE {{
+        x <- x0;
+        y <- y0;
+        self;
+    }};
+};
\ No newline at end of file
diff --git a/src/tester/05_program.cl b/src/tester/05_program.cl
new file mode 100644
index 000000000..38339b055
--- /dev/null
+++ b/src/tester/05_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    main (): Object {
+        0
+    };
+
+    f (a: AUTO_TYPE, b: AUTO_TYPE, c: AUTO_TYPE, d: AUTO_TYPE): AUTO_TYPE {
+        {
+            a <- b;
+            b <- c;
+            c <- d;
+            d <- a;
+            d + 1;
+            a;
+        }
+    };
+};
\ No newline at end of file
diff --git a/src/tester/06_program.cl b/src/tester/06_program.cl
new file mode 100644
index 000000000..aec900c57
--- /dev/null
+++ b/src/tester/06_program.cl
@@ -0,0 +1,44 @@
+class Main inherits IO {
+    main(): IO {
+        let vector: AUTO_TYPE <- (new Vector2).init(0, 0) in
+            vector.print_vector()
+    };
+};
+
+class Vector2 {
+    x: AUTO_TYPE;
+    y: AUTO_TYPE;
+
+    init(x_: AUTO_TYPE, y_: AUTO_TYPE): AUTO_TYPE {{
+        x <- x_;
+        y <- y_;
+        self;
+    }};
+
+
+    get_x(): AUTO_TYPE {
+        x
+    };
+
+    get_y(): AUTO_TYPE {
+        y
+    };
+
+    add(v: Vector2): AUTO_TYPE {
+        (new Vector2).init(x + v.get_x(), y + v.get_y())
+    };
+
+    print_vector(): AUTO_TYPE {
+        let io: IO <- new IO in {
+            io.out_string("(");
+            io.out_int(get_x());
+            io.out_string("; ");
+            io.out_int(get_y());
+            io.out_string(")\n");
+        }
+    };
+
+    clone_vector(): AUTO_TYPE {
+        (new Vector2).init(x, y)
+    };
+};
\ No newline at end of file
diff --git a/src/tester/07_program.cl b/src/tester/07_program.cl
new file mode 100644
index 000000000..81a2c38cd
--- /dev/null
+++ b/src/tester/07_program.cl
@@ -0,0 +1,19 @@
+(* This program prints the first 10 numbers of fibonacci *)
+class Main {
+
+    main(): Object {
+        let total: AUTO_TYPE <- 10,
+            i: AUTO_TYPE <- 1 ,
+            io: AUTO_TYPE <- new IO in
+                while i <= total loop {
+                    io.out_int(fibonacci(i));
+                    io.out_string("\n");
+                    i <- i + 1;
+                }
+                pool
+    };
+
+    fibonacci (n: AUTO_TYPE): AUTO_TYPE {
+        if n <= 2 then 1 else fibonacci(n - 1) + fibonacci(n - 2) fi
+    };
+};
\ No newline at end of file
diff --git a/src/tester/08_program.cl b/src/tester/08_program.cl
new file mode 100644
index 000000000..5a81c0633
--- /dev/null
+++ b/src/tester/08_program.cl
@@ -0,0 +1,33 @@
+(* Testing IO *)
+class Main inherits IO {
+
+    main(): Object {
+        let id: AUTO_TYPE, name: AUTO_TYPE, email: AUTO_TYPE in {
+            out_string("Introduzca su id: ");
+            id <- self.in_int();
+            out_string("Introduzca su nombre: ");
+            name <- self.in_string();
+            out_string("Introduzca su email: ");
+            email <- self.in_string();
+            let user: AUTO_TYPE <- (new User).init(id, name, email) in
+                out_string("Created user: ".concat(user.get_name()).concat("\n"));
+        }
+    };
+};
+
+class User {
+    id: AUTO_TYPE;
+    name: AUTO_TYPE;
+    email: AUTO_TYPE;
+
+    init(id_: AUTO_TYPE, name_: AUTO_TYPE, email_: AUTO_TYPE): AUTO_TYPE {{
+        id <- id_;
+        name <- name_;
+        email <- email_;
+        self;
+    }};
+
+    get_name(): AUTO_TYPE {
+        name
+    };
+};
\ No newline at end of file
diff --git a/src/tester/inference/01_program.cl b/src/tester/inference/01_program.cl
new file mode 100644
index 000000000..ba0d51f47
--- /dev/null
+++ b/src/tester/inference/01_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    main (): Object {
+        0
+    };
+};
+
+class Point {
+    x: AUTO_TYPE;
+    y: AUTO_TYPE;
+
+    init(x0: Int, y0: Int): AUTO_TYPE {{
+        x <- x0;
+        y <- y0;
+        self;
+    }};
+};
\ No newline at end of file
diff --git a/src/tester/inference/02_program.cl b/src/tester/inference/02_program.cl
new file mode 100644
index 000000000..553bb606a
--- /dev/null
+++ b/src/tester/inference/02_program.cl
@@ -0,0 +1,15 @@
+class Main {
+    main (): Object {
+        0
+    };
+};
+
+class Ackermann {
+    ackermann(m: AUTO_TYPE, n: AUTO_TYPE): AUTO_TYPE {
+        if m = 0 then n + 1 else
+            if n = 0 then ackermann(m - 1, 1) else
+                ackermann(m - 1, ackermann(m, n - 1))
+            fi
+        fi
+    };
+};
\ No newline at end of file
diff --git a/src/tester/inference/03_program.cl b/src/tester/inference/03_program.cl
new file mode 100644
index 000000000..0f74ed244
--- /dev/null
+++ b/src/tester/inference/03_program.cl
@@ -0,0 +1,17 @@
+class Main {
+    main (): Object {
+        0
+    };
+
+    f(a: AUTO_TYPE, b: AUTO_TYPE): AUTO_TYPE {
+        if a = 1 then b else
+            g(a + 1, b / 1)
+        fi
+    };
+
+    g(a: AUTO_TYPE, b: AUTO_TYPE): AUTO_TYPE {
+        if b = 1 then a else
+            f(a / 2, b + 1)
+        fi
+    };
+};
\ No newline at end of file
diff --git a/src/tester/inference/04_program.cl b/src/tester/inference/04_program.cl
new file mode 100644
index 000000000..ab46ef273
--- /dev/null
+++ b/src/tester/inference/04_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    main (): Object {
+        0
+    };
+};
+
+class Point {
+    x: Int;
+    y: Int;
+
+    init(x0: AUTO_TYPE, y0: AUTO_TYPE): AUTO_TYPE {{
+        x <- x0;
+        y <- y0;
+        self;
+    }};
+};
\ No newline at end of file
diff --git a/src/tester/inference/05_program.cl b/src/tester/inference/05_program.cl
new file mode 100644
index 000000000..38339b055
--- /dev/null
+++ b/src/tester/inference/05_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    main (): Object {
+        0
+    };
+
+    f (a: AUTO_TYPE, b: AUTO_TYPE, c: AUTO_TYPE, d: AUTO_TYPE): AUTO_TYPE {
+        {
+            a <- b;
+            b <- c;
+            c <- d;
+            d <- a;
+            d + 1;
+            a;
+        }
+    };
+};
\ No newline at end of file
diff --git a/src/tester/inference/06_program.cl b/src/tester/inference/06_program.cl
new file mode 100644
index 000000000..aec900c57
--- /dev/null
+++ b/src/tester/inference/06_program.cl
@@ -0,0 +1,44 @@
+class Main inherits IO {
+    main(): IO {
+        let vector: AUTO_TYPE <- (new Vector2).init(0, 0) in
+            vector.print_vector()
+    };
+};
+
+class Vector2 {
+    x: AUTO_TYPE;
+    y: AUTO_TYPE;
+
+    init(x_: AUTO_TYPE, y_: AUTO_TYPE): AUTO_TYPE {{
+        x <- x_;
+        y <- y_;
+        self;
+    }};
+
+
+    get_x(): AUTO_TYPE {
+        x
+    };
+
+    get_y(): AUTO_TYPE {
+        y
+    };
+
+    add(v: Vector2): AUTO_TYPE {
+        (new Vector2).init(x + v.get_x(), y + v.get_y())
+    };
+
+    print_vector(): AUTO_TYPE {
+        let io: IO <- new IO in {
+            io.out_string("(");
+            io.out_int(get_x());
+            io.out_string("; ");
+            io.out_int(get_y());
+            io.out_string(")\n");
+        }
+    };
+
+    clone_vector(): AUTO_TYPE {
+        (new Vector2).init(x, y)
+    };
+};
\ No newline at end of file
diff --git a/src/tester/inference/07_program.cl b/src/tester/inference/07_program.cl
new file mode 100644
index 000000000..81a2c38cd
--- /dev/null
+++ b/src/tester/inference/07_program.cl
@@ -0,0 +1,19 @@
+(* This program prints the first 10 numbers of fibonacci *)
+class Main {
+
+    main(): Object {
+        let total: AUTO_TYPE <- 10,
+            i: AUTO_TYPE <- 1 ,
+            io: AUTO_TYPE <- new IO in
+                while i <= total loop {
+                    io.out_int(fibonacci(i));
+                    io.out_string("\n");
+                    i <- i + 1;
+                }
+                pool
+    };
+
+    fibonacci (n: AUTO_TYPE): AUTO_TYPE {
+        if n <= 2 then 1 else fibonacci(n - 1) + fibonacci(n - 2) fi
+    };
+};
\ No newline at end of file
diff --git a/src/tester/inference/08_program.cl b/src/tester/inference/08_program.cl
new file mode 100644
index 000000000..5a81c0633
--- /dev/null
+++ b/src/tester/inference/08_program.cl
@@ -0,0 +1,33 @@
+(* Testing IO *)
+class Main inherits IO {
+
+    main(): Object {
+        let id: AUTO_TYPE, name: AUTO_TYPE, email: AUTO_TYPE in {
+            out_string("Introduzca su id: ");
+            id <- self.in_int();
+            out_string("Introduzca su nombre: ");
+            name <- self.in_string();
+            out_string("Introduzca su email: ");
+            email <- self.in_string();
+            let user: AUTO_TYPE <- (new User).init(id, name, email) in
+                out_string("Created user: ".concat(user.get_name()).concat("\n"));
+        }
+    };
+};
+
+class User {
+    id: AUTO_TYPE;
+    name: AUTO_TYPE;
+    email: AUTO_TYPE;
+
+    init(id_: AUTO_TYPE, name_: AUTO_TYPE, email_: AUTO_TYPE): AUTO_TYPE {{
+        id <- id_;
+        name <- name_;
+        email <- email_;
+        self;
+    }};
+
+    get_name(): AUTO_TYPE {
+        name
+    };
+};
\ No newline at end of file
diff --git a/src/tester/lexer/comment1.cl b/src/tester/lexer/comment1.cl
new file mode 100644
index 000000000..c2bb9938c
--- /dev/null
+++ b/src/tester/lexer/comment1.cl
@@ -0,0 +1,55 @@
+--Any characters between two dashes "--" and the next newline
+--(or EOF, if there is no next newline) are treated as comments
+
+(*(*(*
+Comments may also be written by enclosing
+text in (∗ . . . ∗). The latter form of comment may be nested.
+Comments cannot cross file boundaries.
+*)*)*)
+
+class Error() {
+
+        (* There was once a comment,
+         that was quite long.
+         But, the reader soon discovered that
+         the comment was indeed longer than
+         previously assumed. Now, the reader
+         was in a real dilemma; is the comment
+         ever gonna end? If I stop reading, will
+         it end?
+         He started imagining all sorts of things.
+         He thought about heisenberg's cat and how
+         how that relates to the end of the sentence.
+         He thought to himself "I'm gonna stop reading".
+         "If I keep reading this comment, I'm gonna know
+         the fate of this sentence; That will be disastorous."
+         He knew that such a comment was gonna extend to
+         another file. It was too awesome to be contained in
+         a single file. And he would have kept reading too...
+         if only...
+         cool wasn't a super-duper-fab-awesomest language;
+         but cool is that language;
+         "This comment shall go not cross this file" said cool.
+         Alas! The reader could read no more.
+         There was once a comment,
+         that was quite long.
+         But, the reader soon discovered that
+         the comment was indeed longer than
+         previously assumed. Now, the reader
+         was in a real dilemma; is the comment
+         ever gonna end? If I stop reading, will
+         it end?
+         He started imagining all sorts of things.
+         He thought about heisenberg's cat and how
+         how that relates to the end of the sentence.
+         He thought to himself "I'm gonna stop reading".
+         "If I keep reading this comment, I'm gonna know
+         the fate of this sentence; That will be disastorous."
+         He knew that such a comment was gonna extend to
+         another file. It was too awesome to be contained in
+         a single file. And he would have kept reading too...
+         if only...
+         cool wasn't a super-duper-fab-awesomest language;
+         but cool is that language;
+         "This comment shall go not cross this file" said cool.
+         Alas! The reader could read no more.
\ No newline at end of file
diff --git a/src/tester/lexer/iis1.cl b/src/tester/lexer/iis1.cl
new file mode 100644
index 000000000..12cb52beb
--- /dev/null
+++ b/src/tester/lexer/iis1.cl
@@ -0,0 +1,111 @@
+(* Integers, Identifiers, and Special Notation *)
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+5! = 120, 2 + 2 = 5 or E = mc2; p + 1 @ p = 1:  for x in range(len(b))
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+class Class if then else fi testing Testing ~007agent_bond james_007B0N3SS___
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+(*
+#3 INT_CONST 0007
+#3 INT_CONST 123
+#3 '+'
+#3 INT_CONST 1
+#3 '-'
+#3 INT_CONST 1
+#3 '+'
+#3 INT_CONST 90
+#3 '-'
+#3 INT_CONST 09
+#3 '+'
+#3 INT_CONST 11113
+#3 '-'
+#3 INT_CONST 4
+#3 OBJECTID r
+#3 '*'
+#3 OBJECTID a
+#3 '*'
+#3 OBJECTID self
+#3 '*'
+#3 OBJECTID c
+#3 '+'
+#3 '+'
+#4 INT_CONST 5
+#4 ERROR "!"
+#4 '='
+#4 INT_CONST 120
+#4 ','
+#4 INT_CONST 2
+#4 '+'
+#4 INT_CONST 2
+#4 '='
+#4 INT_CONST 5
+#4 OBJECTID or
+#4 TYPEID E
+#4 '='
+#4 OBJECTID mc2
+#4 ';'
+#4 OBJECTID p
+#4 '+'
+#4 INT_CONST 1
+#4 '@'
+#4 OBJECTID p
+#4 '='
+#4 INT_CONST 1
+#4 ':'
+#4 OBJECTID for
+#4 OBJECTID x
+#4 IN
+#4 OBJECTID range
+#4 '('
+#4 OBJECTID len
+#4 '('
+#4 OBJECTID b
+#4 ')'
+#4 ')'
+#5 NEW
+#5 '/'
+#5 ASSIGN
+#5 '<'
+#5 LE
+#5 DARROW
+#5 '{'
+#5 '('
+#5 TYPEID Int
+#5 ':'
+#5 TYPEID Objet
+#5 ','
+#5 TYPEID Bool
+#5 ';'
+#5 TYPEID String
+#5 '.'
+#5 OBJECTID string
+#5 TYPEID SELF_TYPE
+#5 ISVOID
+#5 '}'
+#5 ')'
+#6 CLASS
+#6 CLASS
+#6 IF
+#6 THEN
+#6 ELSE
+#6 FI
+#6 OBJECTID testing
+#6 TYPEID Testing
+#6 '~'
+#6 INT_CONST 007
+#6 OBJECTID agent_bond
+#6 OBJECTID james_007B0N3SS___
+#7 LOOP
+#7 POOL
+#7 WHILE
+#7 BOOL_CONST true
+#7 OBJECTID or
+#7 NOT
+#7 BOOL_CONST false
+#7 LET
+#7 IN
+#7 CASE
+#7 OF
+#7 ESAC
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/iis2.cl b/src/tester/lexer/iis2.cl
new file mode 100644
index 000000000..9b25715d4
--- /dev/null
+++ b/src/tester/lexer/iis2.cl
@@ -0,0 +1,120 @@
+(* Integers, Identifiers, and Special Notation *)
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+factorial(5) = 120, 2 + 2 = 5? or E = mc2; p + 1 resto p = 1: (@ for x in range(len(b)))
+
+(*
+#3 INT_CONST 0007
+#3 INT_CONST 123
+#3 '+'
+#3 INT_CONST 1
+#3 '-'
+#3 INT_CONST 1
+#3 '+'
+#3 INT_CONST 90
+#3 '-'
+#3 INT_CONST 09
+#3 '+'
+#3 INT_CONST 11113
+#3 '-'
+#3 INT_CONST 4
+#3 OBJECTID r
+#3 '*'
+#3 OBJECTID a
+#3 '*'
+#3 OBJECTID self
+#3 '*'
+#3 OBJECTID c
+#3 '+'
+#3 '+'
+#4 CLASS
+#4 CLASS
+#4 IF
+#4 THEN
+#4 ELSE
+#4 FI
+#4 OBJECTID testing
+#4 TYPEID Testing
+#4 '~'
+#4 INT_CONST 007
+#4 OBJECTID agent_bond
+#4 OBJECTID james_007bones___
+#7 NEW
+#7 '/'
+#7 ASSIGN
+#7 '<'
+#7 LE
+#7 DARROW
+#7 '{'
+#7 '('
+#7 TYPEID Int
+#7 ':'
+#7 TYPEID Objet
+#7 ','
+#7 TYPEID Bool
+#7 ';'
+#7 TYPEID String
+#7 '.'
+#7 OBJECTID string
+#7 TYPEID SELF_TYPE
+#7 ISVOID
+#7 '}'
+#7 ')'
+#8 LOOP
+#8 POOL
+#8 WHILE
+#8 BOOL_CONST true
+#8 OBJECTID or
+#8 NOT
+#8 BOOL_CONST false
+#8 LET
+#8 IN
+#8 CASE
+#8 OF
+#8 ESAC
+#10 OBJECTID factorial
+#10 '('
+#10 INT_CONST 5
+#10 ')'
+#10 '='
+#10 INT_CONST 120
+#10 ','
+#10 INT_CONST 2
+#10 '+'
+#10 INT_CONST 2
+#10 '='
+#10 INT_CONST 5
+#10 ERROR "?"
+#10 OBJECTID or
+#10 TYPEID E
+#10 '='
+#10 OBJECTID mc2
+#10 ';'
+#10 OBJECTID p
+#10 '+'
+#10 INT_CONST 1
+#10 OBJECTID resto
+#10 OBJECTID p
+#10 '='
+#10 INT_CONST 1
+#10 ':'
+#10 '('
+#10 '@'
+#10 OBJECTID for
+#10 OBJECTID x
+#10 IN
+#10 OBJECTID range
+#10 '('
+#10 OBJECTID len
+#10 '('
+#10 OBJECTID b
+#10 ')'
+#10 ')'
+#10 ')'
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/iis3.cl b/src/tester/lexer/iis3.cl
new file mode 100644
index 000000000..0b965ddea
--- /dev/null
+++ b/src/tester/lexer/iis3.cl
@@ -0,0 +1,121 @@
+(* Integers, Identifiers, and Special Notation *)
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc^2; p + 1 @ p = 1: z for x in range(len(b)))
+
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+(*
+#3 OBJECTID factorial
+#3 '('
+#3 INT_CONST 5
+#3 ')'
+#3 '='
+#3 INT_CONST 120
+#3 ','
+#3 INT_CONST 2
+#3 '+'
+#3 INT_CONST 2
+#3 '='
+#3 INT_CONST 5
+#3 OBJECTID or
+#3 TYPEID E
+#3 '='
+#3 OBJECTID mc
+#3 ERROR "^"
+#3 INT_CONST 2
+#3 ';'
+#3 OBJECTID p
+#3 '+'
+#3 INT_CONST 1
+#3 '@'
+#3 OBJECTID p
+#3 '='
+#3 INT_CONST 1
+#3 ':'
+#3 OBJECTID z
+#3 OBJECTID for
+#3 OBJECTID x
+#3 IN
+#3 OBJECTID range
+#3 '('
+#3 OBJECTID len
+#3 '('
+#3 OBJECTID b
+#3 ')'
+#3 ')'
+#3 ')'
+#5 LOOP
+#5 POOL
+#5 WHILE
+#5 BOOL_CONST true
+#5 OBJECTID or
+#5 NOT
+#5 BOOL_CONST false
+#5 LET
+#5 IN
+#5 CASE
+#5 OF
+#5 ESAC
+#7 NEW
+#7 '/'
+#7 ASSIGN
+#7 '<'
+#7 LE
+#7 DARROW
+#7 '{'
+#7 '('
+#7 TYPEID Int
+#7 ':'
+#7 TYPEID Objet
+#7 ','
+#7 TYPEID Bool
+#7 ';'
+#7 TYPEID String
+#7 '.'
+#7 OBJECTID string
+#7 TYPEID SELF_TYPE
+#7 ISVOID
+#7 '}'
+#7 ')'
+#10 INT_CONST 0007
+#10 INT_CONST 123
+#10 '+'
+#10 INT_CONST 1
+#10 '-'
+#10 INT_CONST 1
+#10 '+'
+#10 INT_CONST 90
+#10 '-'
+#10 INT_CONST 09
+#10 '+'
+#10 INT_CONST 11113
+#10 '-'
+#10 INT_CONST 4
+#10 OBJECTID r
+#10 '*'
+#10 OBJECTID a
+#10 '*'
+#10 OBJECTID self
+#10 '*'
+#10 OBJECTID c
+#10 '+'
+#10 '+'
+#11 CLASS
+#11 CLASS
+#11 IF
+#11 THEN
+#11 ELSE
+#11 FI
+#11 OBJECTID testing
+#11 TYPEID Testing
+#11 '~'
+#11 INT_CONST 007
+#11 OBJECTID agent_bond
+#11 OBJECTID james_007bones___
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/iis4.cl b/src/tester/lexer/iis4.cl
new file mode 100644
index 000000000..9e7a9cb62
--- /dev/null
+++ b/src/tester/lexer/iis4.cl
@@ -0,0 +1,120 @@
+(* Integers, Identifiers, and Special Notation *)
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc2; p + 1 % p = 1: @.@ for x in range(len(b))~
+
+
+loop pool while tRuE or noT faLsE let in case of ESAC
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+(*
+#3 NEW
+#3 '/'
+#3 ASSIGN
+#3 '<'
+#3 LE
+#3 DARROW
+#3 '{'
+#3 '('
+#3 TYPEID Int
+#3 ':'
+#3 TYPEID Objet
+#3 ','
+#3 TYPEID Bool
+#3 ';'
+#3 TYPEID String
+#3 '.'
+#3 OBJECTID string
+#3 TYPEID SELF_TYPE
+#3 ISVOID
+#3 '}'
+#3 ')'
+#4 INT_CONST 0007
+#4 INT_CONST 123
+#4 '+'
+#4 INT_CONST 1
+#4 '-'
+#4 INT_CONST 1
+#4 '+'
+#4 INT_CONST 90
+#4 '-'
+#4 INT_CONST 09
+#4 '+'
+#4 INT_CONST 11113
+#4 '-'
+#4 INT_CONST 4
+#4 OBJECTID r
+#4 '*'
+#4 OBJECTID a
+#4 '*'
+#4 OBJECTID self
+#4 '*'
+#4 OBJECTID c
+#4 '+'
+#4 '+'
+#6 OBJECTID factorial
+#6 '('
+#6 INT_CONST 5
+#6 ')'
+#6 '='
+#6 INT_CONST 120
+#6 ','
+#6 INT_CONST 2
+#6 '+'
+#6 INT_CONST 2
+#6 '='
+#6 INT_CONST 5
+#6 OBJECTID or
+#6 TYPEID E
+#6 '='
+#6 OBJECTID mc2
+#6 ';'
+#6 OBJECTID p
+#6 '+'
+#6 INT_CONST 1
+#6 ERROR "%"
+#6 OBJECTID p
+#6 '='
+#6 INT_CONST 1
+#6 ':'
+#6 '@'
+#6 '.'
+#6 '@'
+#6 OBJECTID for
+#6 OBJECTID x
+#6 IN
+#6 OBJECTID range
+#6 '('
+#6 OBJECTID len
+#6 '('
+#6 OBJECTID b
+#6 ')'
+#6 ')'
+#6 '~'
+#9 LOOP
+#9 POOL
+#9 WHILE
+#9 BOOL_CONST true
+#9 OBJECTID or
+#9 NOT
+#9 BOOL_CONST false
+#9 LET
+#9 IN
+#9 CASE
+#9 OF
+#9 ESAC
+#10 CLASS
+#10 CLASS
+#10 IF
+#10 THEN
+#10 ELSE
+#10 FI
+#10 OBJECTID testing
+#10 TYPEID Testing
+#10 '~'
+#10 INT_CONST 007
+#10 OBJECTID agent_bond
+#10 OBJECTID james_007bones___
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/iis5.cl b/src/tester/lexer/iis5.cl
new file mode 100644
index 000000000..d146c0547
--- /dev/null
+++ b/src/tester/lexer/iis5.cl
@@ -0,0 +1,121 @@
+(* Integers, Identifiers, and Special Notation *)
+
+
+loop pool while tRuE or noT faLsE let in case of ESAC
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc2; p + 1 resto p = 1: [@.@ for x in range(len(b))]
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++
+
+(*
+#4 LOOP
+#4 POOL
+#4 WHILE
+#4 BOOL_CONST true
+#4 OBJECTID or
+#4 NOT
+#4 BOOL_CONST false
+#4 LET
+#4 IN
+#4 CASE
+#4 OF
+#4 ESAC
+#5 NEW
+#5 '/'
+#5 ASSIGN
+#5 '<'
+#5 LE
+#5 DARROW
+#5 '{'
+#5 '('
+#5 TYPEID Int
+#5 ':'
+#5 TYPEID Objet
+#5 ','
+#5 TYPEID Bool
+#5 ';'
+#5 TYPEID String
+#5 '.'
+#5 OBJECTID string
+#5 TYPEID SELF_TYPE
+#5 ISVOID
+#5 '}'
+#5 ')'
+#6 CLASS
+#6 CLASS
+#6 IF
+#6 THEN
+#6 ELSE
+#6 FI
+#6 OBJECTID testing
+#6 TYPEID Testing
+#6 '~'
+#6 INT_CONST 007
+#6 OBJECTID agent_bond
+#6 OBJECTID james_007bones___
+#8 OBJECTID factorial
+#8 '('
+#8 INT_CONST 5
+#8 ')'
+#8 '='
+#8 INT_CONST 120
+#8 ','
+#8 INT_CONST 2
+#8 '+'
+#8 INT_CONST 2
+#8 '='
+#8 INT_CONST 5
+#8 OBJECTID or
+#8 TYPEID E
+#8 '='
+#8 OBJECTID mc2
+#8 ';'
+#8 OBJECTID p
+#8 '+'
+#8 INT_CONST 1
+#8 OBJECTID resto
+#8 OBJECTID p
+#8 '='
+#8 INT_CONST 1
+#8 ':'
+#8 ERROR "["
+#8 '@'
+#8 '.'
+#8 '@'
+#8 OBJECTID for
+#8 OBJECTID x
+#8 IN
+#8 OBJECTID range
+#8 '('
+#8 OBJECTID len
+#8 '('
+#8 OBJECTID b
+#8 ')'
+#8 ')'
+#8 ERROR "]"
+#10 INT_CONST 0007
+#10 INT_CONST 123
+#10 '+'
+#10 INT_CONST 1
+#10 '-'
+#10 INT_CONST 1
+#10 '+'
+#10 INT_CONST 90
+#10 '-'
+#10 INT_CONST 09
+#10 '+'
+#10 INT_CONST 11113
+#10 '-'
+#10 INT_CONST 4
+#10 OBJECTID r
+#10 '*'
+#10 OBJECTID a
+#10 '*'
+#10 OBJECTID self
+#10 '*'
+#10 OBJECTID c
+#10 '+'
+#10 '+'
+*)
diff --git a/src/tester/lexer/iis6.cl b/src/tester/lexer/iis6.cl
new file mode 100644
index 000000000..1042f132b
--- /dev/null
+++ b/src/tester/lexer/iis6.cl
@@ -0,0 +1,125 @@
+(* Integers, Identifiers, and Special Notation *)
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc2; p + 1 resto p = 1: {@.@ for x in range(len(b))}
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+
+
+class Class if then else fi testing Testing ~007agent_bond _james_007bones___
+
+
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+(*
+#3 OBJECTID factorial
+#3 '('
+#3 INT_CONST 5
+#3 ')'
+#3 '='
+#3 INT_CONST 120
+#3 ','
+#3 INT_CONST 2
+#3 '+'
+#3 INT_CONST 2
+#3 '='
+#3 INT_CONST 5
+#3 OBJECTID or
+#3 TYPEID E
+#3 '='
+#3 OBJECTID mc2
+#3 ';'
+#3 OBJECTID p
+#3 '+'
+#3 INT_CONST 1
+#3 OBJECTID resto
+#3 OBJECTID p
+#3 '='
+#3 INT_CONST 1
+#3 ':'
+#3 '{'
+#3 '@'
+#3 '.'
+#3 '@'
+#3 OBJECTID for
+#3 OBJECTID x
+#3 IN
+#3 OBJECTID range
+#3 '('
+#3 OBJECTID len
+#3 '('
+#3 OBJECTID b
+#3 ')'
+#3 ')'
+#3 '}'
+#5 NEW
+#5 '/'
+#5 ASSIGN
+#5 '<'
+#5 LE
+#5 DARROW
+#5 '{'
+#5 '('
+#5 TYPEID Int
+#5 ':'
+#5 TYPEID Objet
+#5 ','
+#5 TYPEID Bool
+#5 ';'
+#5 TYPEID String
+#5 '.'
+#5 OBJECTID string
+#5 TYPEID SELF_TYPE
+#5 ISVOID
+#5 '}'
+#5 ')'
+#8 CLASS
+#8 CLASS
+#8 IF
+#8 THEN
+#8 ELSE
+#8 FI
+#8 OBJECTID testing
+#8 TYPEID Testing
+#8 '~'
+#8 INT_CONST 007
+#8 OBJECTID agent_bond
+#8 ERROR "_"
+#8 OBJECTID james_007bones___
+#12 INT_CONST 0007
+#12 INT_CONST 123
+#12 '+'
+#12 INT_CONST 1
+#12 '-'
+#12 INT_CONST 1
+#12 '+'
+#12 INT_CONST 90
+#12 '-'
+#12 INT_CONST 09
+#12 '+'
+#12 INT_CONST 11113
+#12 '-'
+#12 INT_CONST 4
+#12 OBJECTID r
+#12 '*'
+#12 OBJECTID a
+#12 '*'
+#12 OBJECTID self
+#12 '*'
+#12 OBJECTID c
+#12 '+'
+#12 '+'
+#13 LOOP
+#13 POOL
+#13 WHILE
+#13 BOOL_CONST true
+#13 OBJECTID or
+#13 NOT
+#13 BOOL_CONST false
+#13 LET
+#13 IN
+#13 CASE
+#13 OF
+#13 ESAC
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/mixed1.cl b/src/tester/lexer/mixed1.cl
new file mode 100644
index 000000000..803d58ef5
--- /dev/null
+++ b/src/tester/lexer/mixed1.cl
@@ -0,0 +1,14 @@
+"lkjdsafkljdsalfj\u0000dsafdsaf\u0000djafslkjdsalf\nsdajf\" lkjfdsasdkjfl"123
+adsfasklj#
+LKldsajf iNhERITS
+"lkdsajf"
+
+(*
+#1 STR_CONST "lkjdsafkljdsalfju0000dsafdsafu0000djafslkjdsalf\nsdajf\" lkjfdsasdkjfl"
+#1 INT_CONST 123
+#2 OBJECTID adsfasklj
+#2 ERROR "#"
+#3 TYPEID LKldsajf
+#3 INHERITS
+#4 STR_CONST "lkdsajf"
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/mixed2.cl b/src/tester/lexer/mixed2.cl
new file mode 100644
index 000000000..12039e123
--- /dev/null
+++ b/src/tester/lexer/mixed2.cl
@@ -0,0 +1,20 @@
+"kjas\"lnnsdj\nfljrdsaf"
+@.$.@
+@*%*@
+"alkjfldajf""dasfadsf
+
+(*
+#1 STR_CONST "kjas\"lnnsdj\nfljrdsaf"
+#2 '@'
+#2 '.'
+#2 ERROR "$"
+#2 '.'
+#2 '@'
+#3 '@'
+#3 '*'
+#3 ERROR "%"
+#3 '*'
+#3 '@'
+#4 STR_CONST "alkjfldajf"
+#4 ERROR "Unterminated string constant"
+*)
\ No newline at end of file
diff --git a/src/tester/lexer/string1.cl b/src/tester/lexer/string1.cl
new file mode 100644
index 000000000..6c3c00833
--- /dev/null
+++ b/src/tester/lexer/string1.cl
@@ -0,0 +1,6 @@
+(* A non-escaped newline character may not appear in a string *)
+
+"This \
+is OK"
+"This is not
+OK"
\ No newline at end of file
diff --git a/src/tester/lexer/string2.cl b/src/tester/lexer/string2.cl
new file mode 100644
index 000000000..3704b6ae7
--- /dev/null
+++ b/src/tester/lexer/string2.cl
@@ -0,0 +1,19 @@
+(* A string may not contain EOF *)
+
+"               May the Triforce              \
+                      0                       \
+                     0v0                      \
+                    0vvv0                     \
+                   0vvvvv0                    \
+                  0vvvvvvv0                   \
+                 0vvvvvvvvv0                  \
+                0vvvvvvvvvvv0                 \
+               000000000000000                \
+              0v0           0v0               \
+             0vvv0         0vvv0              \
+            0vvvvv0       0vvvvv0             \
+           0vvvvvvv0     0vvvvvvv0            \
+          0vvvvvvvvv0   0vvvvvvvvv0           \
+         0vvvvvvvvvvv0 0vvvvvvvvvvv0          \
+        00000000000000000000000000000         \
+                be with you!
\ No newline at end of file
diff --git a/src/tester/lexer/string3.cl b/src/tester/lexer/string3.cl
new file mode 100644
index 0000000000000000000000000000000000000000..78abc4972e218bca373ba1750c99a3450cef4ea3
GIT binary patch
literal 234
zcmX|4yAH!34D8HToS2dhRoZ?*=Jpd<90*B>0}_xSe_!a!lI8Q=*(aJadZZi|KVhQ-
zK4j?NGc6u@9^rRpG<v2;I*$>mYcJ^ifl$<lzaZ-IFk<nVcQcv-K)=W5RtU+fGl}fV
zb+C16?@Cpw_IGn+)5pkG`DDmhB~h4aN~TPfAf7^8@)jV~psY&Q+g)WT$Rtat1c>K@
Mi{IIrdU_-I0>Lp*mH+?%

literal 0
HcmV?d00001

diff --git a/src/tester/lexer/string4.cl b/src/tester/lexer/string4.cl
new file mode 100644
index 000000000..f4d39c027
--- /dev/null
+++ b/src/tester/lexer/string4.cl
@@ -0,0 +1,38 @@
+class Main {
+    str <- "The big brown fox
+            jumped over the fence";
+	main() : Object {
+        {
+            out_string("Yay! This is the newest shites );
+        }
+    };
+};
+
+(*
+#1 CLASS
+#1 TYPEID Main
+#1 '{'
+#2 OBJECTID str
+#2 ASSIGN
+#3 ERROR "Unterminated string constant"
+#3 OBJECTID jumped
+#3 OBJECTID over
+#3 OBJECTID the
+#3 OBJECTID fence
+#4 ERROR "Unterminated string constant"
+#4 OBJECTID main
+#4 '('
+#4 ')'
+#4 ':'
+#4 TYPEID Object
+#4 '{'
+#5 '{'
+#6 OBJECTID out_string
+#6 '('
+#7 ERROR "Unterminated string constant"
+#7 '}'
+#8 '}'
+#8 ';'
+#9 '}'
+#9 ';'
+*)
\ No newline at end of file
diff --git a/src/tester/parser/assignment1.cl b/src/tester/parser/assignment1.cl
new file mode 100644
index 000000000..75b4c5bbd
--- /dev/null
+++ b/src/tester/parser/assignment1.cl
@@ -0,0 +1,37 @@
+(* An assignment has the form <id> <- <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(): String {
+        Test1 <- "Hello World" -- Identifiers begin with a lower case letter
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/assignment2.cl b/src/tester/parser/assignment2.cl
new file mode 100644
index 000000000..4efb96487
--- /dev/null
+++ b/src/tester/parser/assignment2.cl
@@ -0,0 +1,37 @@
+(* An assignment has the form <id> <- <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 - 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(): Int {
+        test1 <-- ~(1 + 2 + 3 + 4 + 5) -- The left side must be an expression
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/assignment3.cl b/src/tester/parser/assignment3.cl
new file mode 100644
index 000000000..ff633f331
--- /dev/null
+++ b/src/tester/parser/assignment3.cl
@@ -0,0 +1,37 @@
+(* An assignment has the form <id> <- <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(): Bool {
+        test1 <- true++ -- The left side must be an expression
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/attribute1.cl b/src/tester/parser/attribute1.cl
new file mode 100644
index 000000000..063a02c02
--- /dev/null
+++ b/src/tester/parser/attribute1.cl
@@ -0,0 +1,34 @@
+(* An attribute of class A specifies a variable that is part of the state of objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    -- Attributes names must begin with lowercase letters
+    Test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/attribute2.cl b/src/tester/parser/attribute2.cl
new file mode 100644
index 000000000..c05211483
--- /dev/null
+++ b/src/tester/parser/attribute2.cl
@@ -0,0 +1,34 @@
+(* An attribute of class A specifies a variable that is part of the state of objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    -- Type names must begin with uppercase letters
+    test3: string <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/attribute3.cl b/src/tester/parser/attribute3.cl
new file mode 100644
index 000000000..d858ae47c
--- /dev/null
+++ b/src/tester/parser/attribute3.cl
@@ -0,0 +1,34 @@
+(* An attribute of class A specifies a variable that is part of the state of objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    -- Expected '<-' not '<='
+    test3: String <= "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/block1.cl b/src/tester/parser/block1.cl
new file mode 100644
index 000000000..3613d9268
--- /dev/null
+++ b/src/tester/parser/block1.cl
@@ -0,0 +1,87 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2 -- Missing ";"
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/block2.cl b/src/tester/parser/block2.cl
new file mode 100644
index 000000000..f485dd0b1
--- /dev/null
+++ b/src/tester/parser/block2.cl
@@ -0,0 +1,87 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        -- Missing "{"
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/block3.cl b/src/tester/parser/block3.cl
new file mode 100644
index 000000000..ae1598c3b
--- /dev/null
+++ b/src/tester/parser/block3.cl
@@ -0,0 +1,87 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                -- Missing "}" 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/block4.cl b/src/tester/parser/block4.cl
new file mode 100644
index 000000000..8fd883d02
--- /dev/null
+++ b/src/tester/parser/block4.cl
@@ -0,0 +1,88 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                    true++; -- Only expressions
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/case1.cl b/src/tester/parser/case1.cl
new file mode 100644
index 000000000..eb56d8eba
--- /dev/null
+++ b/src/tester/parser/case1.cl
@@ -0,0 +1,91 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            --  Every case expression must have at least one branch
+        esac
+    };
+}
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/case2.cl b/src/tester/parser/case2.cl
new file mode 100644
index 000000000..f9162e49f
--- /dev/null
+++ b/src/tester/parser/case2.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case "2 + 2" of
+            x: Int => new IO.out_string("Es un entero!") -- Missing ";"
+            y: String => new IO.out_string("Es una cadena!");
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/case3.cl b/src/tester/parser/case3.cl
new file mode 100644
index 000000000..a7eedc18b
--- /dev/null
+++ b/src/tester/parser/case3.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + false of
+            x: Int => new IO.out_string("Es un entero!");
+            y: string => new IO.out_string("Es una cadena!"); -- Type identifiers starts with a uppercase letter
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/case4.cl b/src/tester/parser/case4.cl
new file mode 100644
index 000000000..25ca3858f
--- /dev/null
+++ b/src/tester/parser/case4.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case true of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            Mazinger_Z: Bool => new IO.out_string("Es un booleano!"); -- Identifiers starts with a lowercase letter
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/case5.cl b/src/tester/parser/case5.cl
new file mode 100644
index 000000000..b36c663e1
--- /dev/null
+++ b/src/tester/parser/case5.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case test2 of
+            x: Int <- new IO.out_string("Es un entero!"); -- Must be '=>' not '<-';
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/case6.cl b/src/tester/parser/case6.cl
new file mode 100644
index 000000000..66e7df2ab
--- /dev/null
+++ b/src/tester/parser/case6.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 -- Missing "of"
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/class1.cl b/src/tester/parser/class1.cl
new file mode 100644
index 000000000..f4815e3f4
--- /dev/null
+++ b/src/tester/parser/class1.cl
@@ -0,0 +1,20 @@
+(* A class is a list of features *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    testing(): Int {
+        2 + 2
+    };
+};
+
+-- Class names must begin with uppercase letters
+class alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/parser/class2.cl b/src/tester/parser/class2.cl
new file mode 100644
index 000000000..f363b032a
--- /dev/null
+++ b/src/tester/parser/class2.cl
@@ -0,0 +1,20 @@
+(* A class is a list of features *)
+
+CLaSS Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+CLaSS Test {
+    testing(): Int {
+        2 + 2
+    };
+};
+
+-- Type names must begin with uppercase letters
+CLaSS Alpha iNHeRiTS iO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/parser/class3.cl b/src/tester/parser/class3.cl
new file mode 100644
index 000000000..0c801372a
--- /dev/null
+++ b/src/tester/parser/class3.cl
@@ -0,0 +1,34 @@
+(* A class is a list of features *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Missing semicolon
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    }
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/parser/class4.cl b/src/tester/parser/class4.cl
new file mode 100644
index 000000000..5c286b5e6
--- /dev/null
+++ b/src/tester/parser/class4.cl
@@ -0,0 +1,36 @@
+(* A class is a list of features *)
+
+CLaSS Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+CLaSS Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    -- Only features
+    2 + 2;
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+CLaSS Alpha iNHeRiTS IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/parser/class5.cl b/src/tester/parser/class5.cl
new file mode 100644
index 000000000..3f40c36eb
--- /dev/null
+++ b/src/tester/parser/class5.cl
@@ -0,0 +1,34 @@
+(* A class is a list of features *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+-- Missing '{'
+class Test
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/parser/class6.cl b/src/tester/parser/class6.cl
new file mode 100644
index 000000000..8501d2593
--- /dev/null
+++ b/src/tester/parser/class6.cl
@@ -0,0 +1,34 @@
+(* A class is a list of features *)
+
+CLaSS Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+-- Missing '}'
+CLaSS Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+;
+
+CLaSS Alpha iNHeRiTS IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/parser/conditional1.cl b/src/tester/parser/conditional1.cl
new file mode 100644
index 000000000..4d546fc44
--- /dev/null
+++ b/src/tester/parser/conditional1.cl
@@ -0,0 +1,69 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        if a.length() < b.length() -- Mising "then"
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        else
+            if a.length() = b.length() then
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            else
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fi
+        fi
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/conditional2.cl b/src/tester/parser/conditional2.cl
new file mode 100644
index 000000000..4f10c2957
--- /dev/null
+++ b/src/tester/parser/conditional2.cl
@@ -0,0 +1,69 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        if a.length() < b.length() then
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        else
+            if a.length() = b.length() then
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            else
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            -- Missing "fi"
+        fi
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/conditional3.cl b/src/tester/parser/conditional3.cl
new file mode 100644
index 000000000..67e991ade
--- /dev/null
+++ b/src/tester/parser/conditional3.cl
@@ -0,0 +1,69 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        iF a.length() < b.length() tHen
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        elsE
+            if a.length() = b.length() then
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            eLseif -- elseif isn't a keyword
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/conditional4.cl b/src/tester/parser/conditional4.cl
new file mode 100644
index 000000000..0792fdc85
--- /dev/null
+++ b/src/tester/parser/conditional4.cl
@@ -0,0 +1,73 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(): Int {
+        if true++ then 1 else 0 -- Condition must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/conditional5.cl b/src/tester/parser/conditional5.cl
new file mode 100644
index 000000000..0c1e1aad0
--- /dev/null
+++ b/src/tester/parser/conditional5.cl
@@ -0,0 +1,73 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(): Int {
+        if true then true++ else 0 -- If branch must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/conditional6.cl b/src/tester/parser/conditional6.cl
new file mode 100644
index 000000000..02310404a
--- /dev/null
+++ b/src/tester/parser/conditional6.cl
@@ -0,0 +1,73 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(): Int {
+        if true then 1 else false++ -- Else branch must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch1.cl b/src/tester/parser/dispatch1.cl
new file mode 100644
index 000000000..07d173987
--- /dev/null
+++ b/src/tester/parser/dispatch1.cl
@@ -0,0 +1,45 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        Test1.testing4(1, 2).testing4(3, 4).testing4(5, 6) -- Objet identifiers begin with a lower case letter
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch2.cl b/src/tester/parser/dispatch2.cl
new file mode 100644
index 000000000..e05385139
--- /dev/null
+++ b/src/tester/parser/dispatch2.cl
@@ -0,0 +1,45 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13,,) -- Extra comma
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch4.cl b/src/tester/parser/dispatch4.cl
new file mode 100644
index 000000000..34674c7cf
--- /dev/null
+++ b/src/tester/parser/dispatch4.cl
@@ -0,0 +1,53 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        self.testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true++) -- Arguments must be expressions
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch5.cl b/src/tester/parser/dispatch5.cl
new file mode 100644
index 000000000..971b23572
--- /dev/null
+++ b/src/tester/parser/dispatch5.cl
@@ -0,0 +1,53 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, ,true + fALSE) -- Extra comma
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch6.cl b/src/tester/parser/dispatch6.cl
new file mode 100644
index 000000000..c8d3d5d89
--- /dev/null
+++ b/src/tester/parser/dispatch6.cl
@@ -0,0 +1,57 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@object.copy() -- Type identifiers begin with a upper case letter
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch7.cl b/src/tester/parser/dispatch7.cl
new file mode 100644
index 000000000..946097167
--- /dev/null
+++ b/src/tester/parser/dispatch7.cl
@@ -0,0 +1,57 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.Copy() -- Identifiers begin with a lower case letter
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+}
\ No newline at end of file
diff --git a/src/tester/parser/dispatch8.cl b/src/tester/parser/dispatch8.cl
new file mode 100644
index 000000000..df96d9142
--- /dev/null
+++ b/src/tester/parser/dispatch8.cl
@@ -0,0 +1,57 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy(,) -- Extra comma
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/dispatch9.cl b/src/tester/parser/dispatch9.cl
new file mode 100644
index 000000000..e9369540c
--- /dev/null
+++ b/src/tester/parser/dispatch9.cl
@@ -0,0 +1,61 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+
+    testing5(): Object {
+        test1:Object.copy() -- Must be '@' not ':'
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let1.cl b/src/tester/parser/let1.cl
new file mode 100644
index 000000000..576ae383c
--- /dev/null
+++ b/src/tester/parser/let1.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let Count: Int <- 0, pow: Int <- 1 -- Object identifiers starts with a lowercase letter
+        in {
+            -- count <- 0;
+            -- pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let2.cl b/src/tester/parser/let2.cl
new file mode 100644
index 000000000..4cfaef0f8
--- /dev/null
+++ b/src/tester/parser/let2.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int, pow: int <- 1 -- Type identifiers starts with a uppercase letter 
+        in {
+            count <- 0;
+            -- pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let3.cl b/src/tester/parser/let3.cl
new file mode 100644
index 000000000..91e567fd8
--- /dev/null
+++ b/src/tester/parser/let3.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int, pow: Int, -- Extra comma
+        in {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let4.cl b/src/tester/parser/let4.cl
new file mode 100644
index 000000000..a716c332d
--- /dev/null
+++ b/src/tester/parser/let4.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- true++, pow: Int <- 1 -- Initialization must be an expression
+        in {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let5.cl b/src/tester/parser/let5.cl
new file mode 100644
index 000000000..d974cc138
--- /dev/null
+++ b/src/tester/parser/let5.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int = 0, pow: Int -- Must be '<-' not '=' 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let6.cl b/src/tester/parser/let6.cl
new file mode 100644
index 000000000..b6e51d7e1
--- /dev/null
+++ b/src/tester/parser/let6.cl
@@ -0,0 +1,74 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int <- 1 
+        in false++ -- Let body must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/let7.cl b/src/tester/parser/let7.cl
new file mode 100644
index 000000000..6fd63e6a7
--- /dev/null
+++ b/src/tester/parser/let7.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        (* Missing "in" *) {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/loop1.cl b/src/tester/parser/loop1.cl
new file mode 100644
index 000000000..7d0d7688f
--- /dev/null
+++ b/src/tester/parser/loop1.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count < 1024*1024 
+        -- Missing "loop" 
+            count <- count * 2 
+        pool
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/loop2.cl b/src/tester/parser/loop2.cl
new file mode 100644
index 000000000..a9613c487
--- /dev/null
+++ b/src/tester/parser/loop2.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count < 1024*1024 
+        loop 
+            count <- count * 2 
+        -- Missing "pool"
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/loop3.cl b/src/tester/parser/loop3.cl
new file mode 100644
index 000000000..860adb4d1
--- /dev/null
+++ b/src/tester/parser/loop3.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count => 1024*1024 -- Condition must be an expression
+        loop 
+            count <- count * 2 
+        pool
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/loop4.cl b/src/tester/parser/loop4.cl
new file mode 100644
index 000000000..0a1194e82
--- /dev/null
+++ b/src/tester/parser/loop4.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count < 1024*1024 
+        loop 
+            count <- true++ -- While body must be an expression
+        pool
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/method1.cl b/src/tester/parser/method1.cl
new file mode 100644
index 000000000..fcfbbcd30
--- /dev/null
+++ b/src/tester/parser/method1.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Method names must begin with lowercase letters
+    Testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/method2.cl b/src/tester/parser/method2.cl
new file mode 100644
index 000000000..d5bdfd85c
--- /dev/null
+++ b/src/tester/parser/method2.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Parameter names must begin with lowercase letters
+    testing2(a: Alpha, B: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/method3.cl b/src/tester/parser/method3.cl
new file mode 100644
index 000000000..1e5c9eb53
--- /dev/null
+++ b/src/tester/parser/method3.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Type names must begin with uppercase letters
+    testing2(a: Alpha, b: int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/method4.cl b/src/tester/parser/method4.cl
new file mode 100644
index 000000000..53aba25cb
--- /dev/null
+++ b/src/tester/parser/method4.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    -- Missing paremeter
+    testing3(x: Int,,): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/method5.cl b/src/tester/parser/method5.cl
new file mode 100644
index 000000000..13127f664
--- /dev/null
+++ b/src/tester/parser/method5.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    -- Type names must begin with uppercase letters
+    testing3(): string {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/method6.cl b/src/tester/parser/method6.cl
new file mode 100644
index 000000000..d48cd1293
--- /dev/null
+++ b/src/tester/parser/method6.cl
@@ -0,0 +1,33 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Body can't be empty
+    testing2(a: Alpha, b: Int): Int {
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/mixed2.cl b/src/tester/parser/mixed2.cl
new file mode 100644
index 000000000..f5477e0bb
--- /dev/null
+++ b/src/tester/parser/mixed2.cl
@@ -0,0 +1,14 @@
+class Main {
+        main(): Object {
+                (new Alpha).print()
+        };
+
+};
+
+(* Class names must begin with uppercase letters *)
+class alpha inherits IO {
+    print() : Object {
+            out_string("reached!!\n");
+    };
+};
+
diff --git a/src/tester/parser/mixed3.cl b/src/tester/parser/mixed3.cl
new file mode 100644
index 000000000..e34edc888
--- /dev/null
+++ b/src/tester/parser/mixed3.cl
@@ -0,0 +1,40 @@
+class Main inherits IO {
+    main() : Object {
+        {
+            out_string("Enter a number to check if number is prime\n");
+            let i : Int <- in_int() in {
+                if(i <= 1) then {
+                    out_string("Invalid Input\n");
+                    abort();
+                } else {
+                    if (isPrime(i) = 1) then
+                        out_string("Number is prime\n")
+                    else
+                        out_string("Number is composite\n")
+                    fi;
+                }
+                fi;
+            };
+        }
+    };
+
+    mod(i : Int,, ) : Int {    -- Formal list must be comma separated. A comma does not terminate a list of formals.
+      i - (i/k)*k
+    };
+
+    isPrime(i : Int) : Int {
+        {
+            let x : Int <- 2,
+                c : Int <- 1 in
+            {
+                while (not (x = i)) loop
+                if (mod(i, x) = 0) then {
+                    c <- 0;
+                    x <- i;
+                } else x <- x + 1 fi
+                pool;
+                c;
+            };
+        }
+    };
+};
diff --git a/src/tester/parser/mixed4.cl b/src/tester/parser/mixed4.cl
new file mode 100644
index 000000000..e752253be
--- /dev/null
+++ b/src/tester/parser/mixed4.cl
@@ -0,0 +1,21 @@
+class Main inherits IO {
+    main() : Object {
+            {
+                    out_string("Enter number of numbers to multiply\n");
+                    out_int(prod(in_int()));
+                    out_string("\n");
+            }
+    };
+
+    prod(i : Int) : Int {
+        let y : Int <- 1 in {
+                while (not (i = 0) ) loop {
+                        out_string("Enter Number: ");
+                        y <- y * in_int(Main : Int);    -- the parser correctly catches the error here
+                        i <- i - 1;
+                }
+                    pool;
+                y;
+        }
+    };
+};
diff --git a/src/tester/parser/mixed5.cl b/src/tester/parser/mixed5.cl
new file mode 100644
index 000000000..41a1f3b00
--- /dev/null
+++ b/src/tester/parser/mixed5.cl
@@ -0,0 +1,20 @@
+class Main inherits IO {
+    str <- "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
+    main() : Object {
+            {
+                    out_string("Enter number of numbers to multiply\n");
+                    out_int(prod(in_int()));
+                    out_string("\n");
+            }
+    };
+    prod(i : Int) : Int {
+        let y : Int <- 1 in {
+            while (not (i = 0) ) loop {
+                out_string("Enter Number: ");
+                y <- y * in_int();
+                i <- i - 1;
+            }
+            y;
+        }
+    };
+};
diff --git a/src/tester/parser/mixed6.cl b/src/tester/parser/mixed6.cl
new file mode 100644
index 000000000..5da80da31
--- /dev/null
+++ b/src/tester/parser/mixed6.cl
@@ -0,0 +1,5 @@
+classs Doom {
+    i : Int <- 0;
+    main() : Object {
+            if i = 0 then out_string("This is da real *h*t")
+
diff --git a/src/tester/parser/operation1.cl b/src/tester/parser/operation1.cl
new file mode 100644
index 000000000..d38eb72d0
--- /dev/null
+++ b/src/tester/parser/operation1.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Missing ')'
+        in isvoid (3 + a * (x / w + new Int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a)/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/operation2.cl b/src/tester/parser/operation2.cl
new file mode 100644
index 000000000..2dc628359
--- /dev/null
+++ b/src/tester/parser/operation2.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Type identifiers starts with a uppercase letter
+        in isvoid (3 + a * (x / w + new int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/operation3.cl b/src/tester/parser/operation3.cl
new file mode 100644
index 000000000..61d6cbfa8
--- /dev/null
+++ b/src/tester/parser/operation3.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Object identifiers starts with a lowercase letter
+        in isvoid (3 + a * (x / w + new Int) - y - (((if tRue = not faLSe then ~Mazinger_Z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/operation4.cl b/src/tester/parser/operation4.cl
new file mode 100644
index 000000000..bae7de5b5
--- /dev/null
+++ b/src/tester/parser/operation4.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Double "+"
+        in isvoid (3 + a * (x / w++ new Int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tester/parser/program1.cl b/src/tester/parser/program1.cl
new file mode 100644
index 000000000..8e5cf617f
--- /dev/null
+++ b/src/tester/parser/program1.cl
@@ -0,0 +1 @@
+(* A Cool program can't be empty *)
\ No newline at end of file
diff --git a/src/tester/parser/program3.cl b/src/tester/parser/program3.cl
new file mode 100644
index 000000000..e27889c57
--- /dev/null
+++ b/src/tester/parser/program3.cl
@@ -0,0 +1,24 @@
+(* Cool programs are sets of classes *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    testing(): Int {
+        2 + 2
+    };
+};
+
+-- Only classes
+suma(a: Int, b: Int) int {
+    a + b
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tester/semantic/01_program.cl b/src/tester/semantic/01_program.cl
new file mode 100644
index 000000000..acb44954b
--- /dev/null
+++ b/src/tester/semantic/01_program.cl
@@ -0,0 +1,16 @@
+class Main {
+    a: Int;
+
+    b: String;
+
+    main () : String { 
+        let a: Int <- "" in 0 
+    };
+
+    function_with_errors() : Object {
+        case a of
+            x: Int => (new IO).out_int(x);
+            y: String => (new IO).out_string(x);
+        esac
+    };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic1.cl b/src/tester/semantic/arithmetic1.cl
new file mode 100644
index 000000000..bf94eb194
--- /dev/null
+++ b/src/tester/semantic/arithmetic1.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 * 2 / 3 - 4 + new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x + new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic10.cl b/src/tester/semantic/arithmetic10.cl
new file mode 100644
index 000000000..bbfe6cdb3
--- /dev/null
+++ b/src/tester/semantic/arithmetic10.cl
@@ -0,0 +1,15 @@
+(*
+The expression ~<expr> is the integer
+complement of <expr>. The expression <expr> must have static type Int and the entire expression
+has static type Int.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in ~new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic10_error.txt b/src/tester/semantic/arithmetic10_error.txt
new file mode 100644
index 000000000..b2be0476f
--- /dev/null
+++ b/src/tester/semantic/arithmetic10_error.txt
@@ -0,0 +1 @@
+(13, 19) - TypeError: Inferred type Int of initialization of attribute test does not conform to declared type Bool.
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic11.cl b/src/tester/semantic/arithmetic11.cl
new file mode 100644
index 000000000..fc067dc1a
--- /dev/null
+++ b/src/tester/semantic/arithmetic11.cl
@@ -0,0 +1,14 @@
+(*
+The expression not <expr> is the boolean complement of <expr>. The expression
+<expr> must have static type Bool and the entire expression has static type Bool.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in not 1 + new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic11_error.txt b/src/tester/semantic/arithmetic11_error.txt
new file mode 100644
index 000000000..bb4b8e1ca
--- /dev/null
+++ b/src/tester/semantic/arithmetic11_error.txt
@@ -0,0 +1 @@
+(13, 24) - TypeError: Argument of 'not' has type Int instead of Bool.
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic12.cl b/src/tester/semantic/arithmetic12.cl
new file mode 100644
index 000000000..2e012fc41
--- /dev/null
+++ b/src/tester/semantic/arithmetic12.cl
@@ -0,0 +1,14 @@
+(*
+The expression not <expr> is the boolean complement of <expr>. The expression
+<expr> must have static type Bool and the entire expression has static type Bool.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in not 1 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic12_error.txt b/src/tester/semantic/arithmetic12_error.txt
new file mode 100644
index 000000000..d25eab65e
--- /dev/null
+++ b/src/tester/semantic/arithmetic12_error.txt
@@ -0,0 +1 @@
+(12, 18) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type Int.
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic1_error.txt b/src/tester/semantic/arithmetic1_error.txt
new file mode 100644
index 000000000..a74ebf3da
--- /dev/null
+++ b/src/tester/semantic/arithmetic1_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int + String 
diff --git a/src/tester/semantic/arithmetic2.cl b/src/tester/semantic/arithmetic2.cl
new file mode 100644
index 000000000..59532573d
--- /dev/null
+++ b/src/tester/semantic/arithmetic2.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 + 2 * 3 / 4 - new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x - new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic2_error.txt b/src/tester/semantic/arithmetic2_error.txt
new file mode 100644
index 000000000..2c7952af8
--- /dev/null
+++ b/src/tester/semantic/arithmetic2_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int - String
diff --git a/src/tester/semantic/arithmetic3.cl b/src/tester/semantic/arithmetic3.cl
new file mode 100644
index 000000000..b208957f5
--- /dev/null
+++ b/src/tester/semantic/arithmetic3.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 - 2 + 3 * 4 / new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x / new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic3_error.txt b/src/tester/semantic/arithmetic3_error.txt
new file mode 100644
index 000000000..81d88331a
--- /dev/null
+++ b/src/tester/semantic/arithmetic3_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int / String
diff --git a/src/tester/semantic/arithmetic4.cl b/src/tester/semantic/arithmetic4.cl
new file mode 100644
index 000000000..2c7dd4fc9
--- /dev/null
+++ b/src/tester/semantic/arithmetic4.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 / 2 - 3 + 4 * new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x * new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic4_error.txt b/src/tester/semantic/arithmetic4_error.txt
new file mode 100644
index 000000000..1ca6df022
--- /dev/null
+++ b/src/tester/semantic/arithmetic4_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int * String
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic5.cl b/src/tester/semantic/arithmetic5.cl
new file mode 100644
index 000000000..bc08c6e82
--- /dev/null
+++ b/src/tester/semantic/arithmetic5.cl
@@ -0,0 +1,11 @@
+--The static type of the expression is Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Int <- 1 / 2 - 3 + 4 * new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x * new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic5_error.txt b/src/tester/semantic/arithmetic5_error.txt
new file mode 100644
index 000000000..dd5346844
--- /dev/null
+++ b/src/tester/semantic/arithmetic5_error.txt
@@ -0,0 +1 @@
+(9, 19) - TypeError: Inferred type Int of initialization of attribute test does not conform to declared type Bool.
diff --git a/src/tester/semantic/arithmetic6.cl b/src/tester/semantic/arithmetic6.cl
new file mode 100644
index 000000000..a0c3d03ff
--- /dev/null
+++ b/src/tester/semantic/arithmetic6.cl
@@ -0,0 +1,11 @@
+ --The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 <= new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 <= new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
diff --git a/src/tester/semantic/arithmetic6_error.txt b/src/tester/semantic/arithmetic6_error.txt
new file mode 100644
index 000000000..2e43dfc17
--- /dev/null
+++ b/src/tester/semantic/arithmetic6_error.txt
@@ -0,0 +1 @@
+(10, 22) - TypeError: non-Int arguments: Int <= String
diff --git a/src/tester/semantic/arithmetic7.cl b/src/tester/semantic/arithmetic7.cl
new file mode 100644
index 000000000..c00c75cde
--- /dev/null
+++ b/src/tester/semantic/arithmetic7.cl
@@ -0,0 +1,12 @@
+ --The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 < new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
+ 
diff --git a/src/tester/semantic/arithmetic7_error.txt b/src/tester/semantic/arithmetic7_error.txt
new file mode 100644
index 000000000..6f3537117
--- /dev/null
+++ b/src/tester/semantic/arithmetic7_error.txt
@@ -0,0 +1 @@
+(10, 22) - TypeError: non-Int arguments: Int < String
diff --git a/src/tester/semantic/arithmetic8.cl b/src/tester/semantic/arithmetic8.cl
new file mode 100644
index 000000000..3210bdb8a
--- /dev/null
+++ b/src/tester/semantic/arithmetic8.cl
@@ -0,0 +1,13 @@
+ --The rules are exactly the same as for the binary arithmetic operations, except that the result is a Bool.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
+ 
+ 
diff --git a/src/tester/semantic/arithmetic8_error.txt b/src/tester/semantic/arithmetic8_error.txt
new file mode 100644
index 000000000..ebcaa3797
--- /dev/null
+++ b/src/tester/semantic/arithmetic8_error.txt
@@ -0,0 +1 @@
+(9, 18) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type Int.
diff --git a/src/tester/semantic/arithmetic9.cl b/src/tester/semantic/arithmetic9.cl
new file mode 100644
index 000000000..95579e134
--- /dev/null
+++ b/src/tester/semantic/arithmetic9.cl
@@ -0,0 +1,15 @@
+(*
+The expression ~<expr> is the integer
+complement of <expr>. The expression <expr> must have static type Int and the entire expression
+has static type Int.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 + ~new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tester/semantic/arithmetic9_error.txt b/src/tester/semantic/arithmetic9_error.txt
new file mode 100644
index 000000000..99fafbbfc
--- /dev/null
+++ b/src/tester/semantic/arithmetic9_error.txt
@@ -0,0 +1 @@
+(14, 25) - TypeError: Argument of '~' has type String instead of Int.
\ No newline at end of file
diff --git a/src/tester/semantic/assignment1.cl b/src/tester/semantic/assignment1.cl
new file mode 100644
index 000000000..19ab70219
--- /dev/null
+++ b/src/tester/semantic/assignment1.cl
@@ -0,0 +1,7 @@
+--The static type of the expression must conform to the declared type of the identifier
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: Int <- "String";
+}; 
diff --git a/src/tester/semantic/assignment1_error.txt b/src/tester/semantic/assignment1_error.txt
new file mode 100644
index 000000000..6eb883012
--- /dev/null
+++ b/src/tester/semantic/assignment1_error.txt
@@ -0,0 +1 @@
+(6, 18) - TypeError: Inferred type String of initialization of attribute test does not conform to declared type Int.
diff --git a/src/tester/semantic/assignment2.cl b/src/tester/semantic/assignment2.cl
new file mode 100644
index 000000000..cace221ae
--- /dev/null
+++ b/src/tester/semantic/assignment2.cl
@@ -0,0 +1,13 @@
+--The static type of an assignment is the static type of <expr>.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A): B { a <- new C };
+	test2(a: A): D { a <- new C };
+}; 
diff --git a/src/tester/semantic/assignment2_error.txt b/src/tester/semantic/assignment2_error.txt
new file mode 100644
index 000000000..ed10b7f38
--- /dev/null
+++ b/src/tester/semantic/assignment2_error.txt
@@ -0,0 +1 @@
+(12, 22) - TypeError: Inferred return type C of method test2 does not conform to declared return type D.
diff --git a/src/tester/semantic/assignment3.cl b/src/tester/semantic/assignment3.cl
new file mode 100644
index 000000000..eba0d69e2
--- /dev/null
+++ b/src/tester/semantic/assignment3.cl
@@ -0,0 +1,14 @@
+--The static type of an assignment is the static type of <expr>.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: A;
+	b: B <- a <- new C;
+	d: D <- a <- new C;
+}; 
diff --git a/src/tester/semantic/assignment3_error.txt b/src/tester/semantic/assignment3_error.txt
new file mode 100644
index 000000000..bc9a718cc
--- /dev/null
+++ b/src/tester/semantic/assignment3_error.txt
@@ -0,0 +1 @@
+(13, 13) - TypeError: Inferred type C of initialization of attribute d does not conform to declared type D.
\ No newline at end of file
diff --git a/src/tester/semantic/attributes1.cl b/src/tester/semantic/attributes1.cl
new file mode 100644
index 000000000..3fa0440e4
--- /dev/null
+++ b/src/tester/semantic/attributes1.cl
@@ -0,0 +1,13 @@
+--The static type of the expression must conform to the declared type of the attribute.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	test1: IO <- new Main;
+	test2: B <- new A;
+
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/attributes1_error.txt b/src/tester/semantic/attributes1_error.txt
new file mode 100644
index 000000000..9cb8460c9
--- /dev/null
+++ b/src/tester/semantic/attributes1_error.txt
@@ -0,0 +1 @@
+(10, 17) - TypeError: Inferred type A of initialization of attribute test2 does not conform to declared type B. 
diff --git a/src/tester/semantic/attributes2.cl b/src/tester/semantic/attributes2.cl
new file mode 100644
index 000000000..7937c2cc8
--- /dev/null
+++ b/src/tester/semantic/attributes2.cl
@@ -0,0 +1,13 @@
+--The static type of the expression must conform to the declared type of the attribute.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	test1: IO <- new Main;
+	test2: C <- new D;
+
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/attributes2_error.txt b/src/tester/semantic/attributes2_error.txt
new file mode 100644
index 000000000..6d601b7cd
--- /dev/null
+++ b/src/tester/semantic/attributes2_error.txt
@@ -0,0 +1 @@
+(10, 17) - TypeError: Inferred type D of initialization of attribute test2 does not conform to declared type C. 
diff --git a/src/tester/semantic/attributes3.cl b/src/tester/semantic/attributes3.cl
new file mode 100644
index 000000000..8a67decd1
--- /dev/null
+++ b/src/tester/semantic/attributes3.cl
@@ -0,0 +1,25 @@
+--Attributes are local to the class in which they are defined or inherited.
+
+class A {
+	a: Int <- 5;
+	test(x1: Int, y1: Int): Int {
+		let x: Int <- x1, y: Int <-y1 in {
+			x <- x + a;
+			y <- y + a;
+			if b then x + y else x - y fi;
+		}
+	};
+};
+class B inherits A {
+	b: Bool <- true; 
+};
+class C inherits B {
+	c: String <- "C"; 
+};
+class D inherits B {
+	d: IO <- new Main.main();
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!") };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/attributes3_error.txt b/src/tester/semantic/attributes3_error.txt
new file mode 100644
index 000000000..6195c816c
--- /dev/null
+++ b/src/tester/semantic/attributes3_error.txt
@@ -0,0 +1 @@
+(9, 16) - NameError: Undeclared identifier b.
diff --git a/src/tester/semantic/attributes4.cl b/src/tester/semantic/attributes4.cl
new file mode 100644
index 000000000..a7f63adbd
--- /dev/null
+++ b/src/tester/semantic/attributes4.cl
@@ -0,0 +1,39 @@
+--Attributes are local to the class in which they are defined or inherited.
+
+class A {
+	a: Int <- 5;
+};
+class B inherits A {
+	b: Bool <- true;
+	test(x1: Int, y1: Int): Int {
+		let x: Int <- x1, y: Int <-y1 in {
+			x <- x + a;
+			y <- y + a;
+			if b then x + y else x - y fi;
+		}
+	};
+};
+class D inherits B {
+	d: IO <- new Main.main();
+	test3(x1: Int, y1: Int): IO {
+		let x: Int <- x1, y: Int <-y1, c: String <- "C" in {
+			x <- x + a;
+			y <- y + a;
+			if b then new IO.out_string(c) else d fi;
+		}
+	};
+};
+class C inherits B {
+	c: String <- "C";
+	test2(x1: Int, y1: Int): IO {
+		let x: Int <- x1, y: Int <-y1 in {
+			x <- x + a;
+			y <- y + a;
+			if b then new IO.out_string(c) else d fi;
+		}
+	};
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!") };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/attributes4_error.txt b/src/tester/semantic/attributes4_error.txt
new file mode 100644
index 000000000..fa5fcfa89
--- /dev/null
+++ b/src/tester/semantic/attributes4_error.txt
@@ -0,0 +1 @@
+(32, 49) - NameError: Undeclared identifier d.
\ No newline at end of file
diff --git a/src/tester/semantic/basics1.cl b/src/tester/semantic/basics1.cl
new file mode 100644
index 000000000..32ae16564
--- /dev/null
+++ b/src/tester/semantic/basics1.cl
@@ -0,0 +1,10 @@
+-- It is an error to redefine the IO class.
+
+class IO {
+	scan(): String { ":)" };
+	print(s: String): IO { new IO };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics1_error.txt b/src/tester/semantic/basics1_error.txt
new file mode 100644
index 000000000..676f5049c
--- /dev/null
+++ b/src/tester/semantic/basics1_error.txt
@@ -0,0 +1 @@
+(3, 7) - SemanticError: Redefinition of basic class IO. 
diff --git a/src/tester/semantic/basics2.cl b/src/tester/semantic/basics2.cl
new file mode 100644
index 000000000..cf2b1cd2f
--- /dev/null
+++ b/src/tester/semantic/basics2.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Int.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class A inherits Int {
+	is_prime(): Bool { false };
+};
diff --git a/src/tester/semantic/basics2_error.txt b/src/tester/semantic/basics2_error.txt
new file mode 100644
index 000000000..69a3b6814
--- /dev/null
+++ b/src/tester/semantic/basics2_error.txt
@@ -0,0 +1 @@
+(7, 18) - SemanticError: Class A cannot inherit class Int. 
diff --git a/src/tester/semantic/basics3.cl b/src/tester/semantic/basics3.cl
new file mode 100644
index 000000000..fef017a8d
--- /dev/null
+++ b/src/tester/semantic/basics3.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Int.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class Int {
+	is_prime(): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics3_error.txt b/src/tester/semantic/basics3_error.txt
new file mode 100644
index 000000000..d8f80cb12
--- /dev/null
+++ b/src/tester/semantic/basics3_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class Int. 
diff --git a/src/tester/semantic/basics4.cl b/src/tester/semantic/basics4.cl
new file mode 100644
index 000000000..9266ec79b
--- /dev/null
+++ b/src/tester/semantic/basics4.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine String.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class A inherits String {
+	is_palindrome(): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics4_error.txt b/src/tester/semantic/basics4_error.txt
new file mode 100644
index 000000000..d5cd4c3db
--- /dev/null
+++ b/src/tester/semantic/basics4_error.txt
@@ -0,0 +1 @@
+(7, 18) - SemanticError: Class A cannot inherit class String. 
diff --git a/src/tester/semantic/basics5.cl b/src/tester/semantic/basics5.cl
new file mode 100644
index 000000000..bad5eff13
--- /dev/null
+++ b/src/tester/semantic/basics5.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine String.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class String {
+	is_palindrome(): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics5_error.txt b/src/tester/semantic/basics5_error.txt
new file mode 100644
index 000000000..8437accf7
--- /dev/null
+++ b/src/tester/semantic/basics5_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class String.
diff --git a/src/tester/semantic/basics6.cl b/src/tester/semantic/basics6.cl
new file mode 100644
index 000000000..47266ebed
--- /dev/null
+++ b/src/tester/semantic/basics6.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Bool.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class A inherits Bool {
+	xor(b: Bool): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics6_error.txt b/src/tester/semantic/basics6_error.txt
new file mode 100644
index 000000000..b4d22da13
--- /dev/null
+++ b/src/tester/semantic/basics6_error.txt
@@ -0,0 +1 @@
+(7, 18) - SemanticError: Class A cannot inherit class Bool.
diff --git a/src/tester/semantic/basics7.cl b/src/tester/semantic/basics7.cl
new file mode 100644
index 000000000..0f30aaec3
--- /dev/null
+++ b/src/tester/semantic/basics7.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Bool.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class Bool {
+	xor(b: Bool): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics7_error.txt b/src/tester/semantic/basics7_error.txt
new file mode 100644
index 000000000..92660ab9f
--- /dev/null
+++ b/src/tester/semantic/basics7_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class Bool.
diff --git a/src/tester/semantic/basics8.cl b/src/tester/semantic/basics8.cl
new file mode 100644
index 000000000..3b9697d4f
--- /dev/null
+++ b/src/tester/semantic/basics8.cl
@@ -0,0 +1,9 @@
+-- It is an error redefine Object.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class Object {
+	xor(b: Bool): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/basics8_error.txt b/src/tester/semantic/basics8_error.txt
new file mode 100644
index 000000000..652f47b30
--- /dev/null
+++ b/src/tester/semantic/basics8_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class Object.
diff --git a/src/tester/semantic/blocks1.cl b/src/tester/semantic/blocks1.cl
new file mode 100644
index 000000000..1e928908b
--- /dev/null
+++ b/src/tester/semantic/blocks1.cl
@@ -0,0 +1,31 @@
+--The static type of a block is the static type of the last expression.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: B <- {
+		new A;
+		{ 
+			new B;
+			{
+				new C;
+				{
+					new D;
+					{
+						new E;
+						{
+							new F;
+						};
+					};
+				};
+			};
+		};
+	};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/blocks1_error.txt b/src/tester/semantic/blocks1_error.txt
new file mode 100644
index 000000000..2f0e2caf3
--- /dev/null
+++ b/src/tester/semantic/blocks1_error.txt
@@ -0,0 +1 @@
+(13, 16) - TypeError: Inferred type F of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tester/semantic/case1.cl b/src/tester/semantic/case1.cl
new file mode 100644
index 000000000..82c6a4d61
--- /dev/null
+++ b/src/tester/semantic/case1.cl
@@ -0,0 +1,23 @@
+--For each branch, let Ti be the static type of <expri>. The static type of a case expression is Join 1≤i≤n Ti.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- case "true" of
+				i: Int => New C;
+				b: Bool => New D;
+				s: String => New E;
+			esac;
+
+	test: B <- case 0 of
+				b: Bool => new F;
+				i: Int => new E;
+			esac;
+};  
diff --git a/src/tester/semantic/case1_error.txt b/src/tester/semantic/case1_error.txt
new file mode 100644
index 000000000..f05ce31b9
--- /dev/null
+++ b/src/tester/semantic/case1_error.txt
@@ -0,0 +1 @@
+(19, 16) - TypeError: Inferred type A of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tester/semantic/case2.cl b/src/tester/semantic/case2.cl
new file mode 100644
index 000000000..ae97b41da
--- /dev/null
+++ b/src/tester/semantic/case2.cl
@@ -0,0 +1,23 @@
+-- The variables declared on each branch of a case must all have distinct types.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- case "true" of
+				i: Int => New C;
+				b: Bool => New D;
+				s: String => New E;
+			esac;
+
+	test: A <- case 0 of
+				b: Bool => new F;
+				i: Bool => new E;
+			esac;
+};
\ No newline at end of file
diff --git a/src/tester/semantic/case2_error.txt b/src/tester/semantic/case2_error.txt
new file mode 100644
index 000000000..302fec38c
--- /dev/null
+++ b/src/tester/semantic/case2_error.txt
@@ -0,0 +1 @@
+(21, 20) - SemanticError: Duplicate branch Bool in case statement.
\ No newline at end of file
diff --git a/src/tester/semantic/case3.cl b/src/tester/semantic/case3.cl
new file mode 100644
index 000000000..da79bbfe6
--- /dev/null
+++ b/src/tester/semantic/case3.cl
@@ -0,0 +1,23 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- case "true" of
+				i: Int => New C;
+				b: Bool => New D;
+				s: String => New E;
+			esac;
+
+	test: A <- case 0 of
+				b: Bool => new F;
+				i: Ball => new E;
+			esac;
+};
\ No newline at end of file
diff --git a/src/tester/semantic/case3_error.txt b/src/tester/semantic/case3_error.txt
new file mode 100644
index 000000000..fea261e5b
--- /dev/null
+++ b/src/tester/semantic/case3_error.txt
@@ -0,0 +1 @@
+(21, 20) - TypeError: Class Ball of case branch is undefined.
\ No newline at end of file
diff --git a/src/tester/semantic/class1.cl b/src/tester/semantic/class1.cl
new file mode 100644
index 000000000..ed83da9d1
--- /dev/null
+++ b/src/tester/semantic/class1.cl
@@ -0,0 +1,9 @@
+-- Classes may not be redefined.
+
+class Repeat {
+	sum(a: Int, b: Int): Int { a + b };
+};
+
+class Repeat {
+	mult(a: Int, b: Int): Int { a * b };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/class1_error.txt b/src/tester/semantic/class1_error.txt
new file mode 100644
index 000000000..19c507672
--- /dev/null
+++ b/src/tester/semantic/class1_error.txt
@@ -0,0 +1,2 @@
+(7, 5) - SemanticError: Classes may not be redefined
+ 
diff --git a/src/tester/semantic/conditionals1.cl b/src/tester/semantic/conditionals1.cl
new file mode 100644
index 000000000..3446a8b0f
--- /dev/null
+++ b/src/tester/semantic/conditionals1.cl
@@ -0,0 +1,14 @@
+--The predicate must have static type Bool.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: A <- if new F then new D else new C fi; 
+};
\ No newline at end of file
diff --git a/src/tester/semantic/conditionals1_error.txt b/src/tester/semantic/conditionals1_error.txt
new file mode 100644
index 000000000..b86345359
--- /dev/null
+++ b/src/tester/semantic/conditionals1_error.txt
@@ -0,0 +1 @@
+(13, 16) - TypeError: Predicate of 'if' does not have type Bool. 
diff --git a/src/tester/semantic/conditionals2.cl b/src/tester/semantic/conditionals2.cl
new file mode 100644
index 000000000..9d6313d75
--- /dev/null
+++ b/src/tester/semantic/conditionals2.cl
@@ -0,0 +1,24 @@
+(*
+Let T and F be the static types of the branches of the conditional. Then the static type of the
+conditional is T t F. (think: Walk towards Object from each of T and F until the paths meet.)
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- if true then 
+				new C 
+			else 
+				if false then new D 
+				else new E fi
+			fi;
+
+	test: B <- if not true then new F else new E fi;
+}; 
diff --git a/src/tester/semantic/conditionals2_error.txt b/src/tester/semantic/conditionals2_error.txt
new file mode 100644
index 000000000..d6f5fc307
--- /dev/null
+++ b/src/tester/semantic/conditionals2_error.txt
@@ -0,0 +1,2 @@
+(23, 16) - TypeError: Inferred type A of initialization of attribute test does not conform to declared type B.
+ 
diff --git a/src/tester/semantic/dispatch1.cl b/src/tester/semantic/dispatch1.cl
new file mode 100644
index 000000000..1c0457fa3
--- /dev/null
+++ b/src/tester/semantic/dispatch1.cl
@@ -0,0 +1,33 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: B <- new D.back("Hello ").back("World!");
+};
\ No newline at end of file
diff --git a/src/tester/semantic/dispatch1_error.txt b/src/tester/semantic/dispatch1_error.txt
new file mode 100644
index 000000000..7fb22edce
--- /dev/null
+++ b/src/tester/semantic/dispatch1_error.txt
@@ -0,0 +1 @@
+(32, 37) - AttributeError: Dispatch to undefined method back. 
diff --git a/src/tester/semantic/dispatch2.cl b/src/tester/semantic/dispatch2.cl
new file mode 100644
index 000000000..5182912b8
--- /dev/null
+++ b/src/tester/semantic/dispatch2.cl
@@ -0,0 +1,34 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+the dispatch and the definition of f must have the same number of arguments
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: Int <- new D.back("Hello ").g(2, 2);
+};
\ No newline at end of file
diff --git a/src/tester/semantic/dispatch2_error.txt b/src/tester/semantic/dispatch2_error.txt
new file mode 100644
index 000000000..a86c35340
--- /dev/null
+++ b/src/tester/semantic/dispatch2_error.txt
@@ -0,0 +1 @@
+(33, 39) - SemanticError: Method g called with wrong number of arguments. 
diff --git a/src/tester/semantic/dispatch3.cl b/src/tester/semantic/dispatch3.cl
new file mode 100644
index 000000000..ecb1535db
--- /dev/null
+++ b/src/tester/semantic/dispatch3.cl
@@ -0,0 +1,36 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+the static type of the ith actual parameter must conform to the declared type of the ith formal parameter.
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+
+	alphabet(a: A, b: B, c: C): D { self };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: B <- new D.alphabet(new D, new D, new D.back("Hello ")).back("World!");
+};
\ No newline at end of file
diff --git a/src/tester/semantic/dispatch3_error.txt b/src/tester/semantic/dispatch3_error.txt
new file mode 100644
index 000000000..0def5cf03
--- /dev/null
+++ b/src/tester/semantic/dispatch3_error.txt
@@ -0,0 +1 @@
+(35, 45) - TypeError: In call of method alphabet, type B of parameter c does not conform to declared type C. 
diff --git a/src/tester/semantic/dispatch4.cl b/src/tester/semantic/dispatch4.cl
new file mode 100644
index 000000000..9cadd8332
--- /dev/null
+++ b/src/tester/semantic/dispatch4.cl
@@ -0,0 +1,36 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+If f has return type B and B is a class name, then the static type of the dispatch is B.
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+
+	alphabet(a: A, b: B, c: C): D { self };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: D <- new D.alphabet(new D, new D.back("Hello "), new C).back("World!");
+};
\ No newline at end of file
diff --git a/src/tester/semantic/dispatch4_error.txt b/src/tester/semantic/dispatch4_error.txt
new file mode 100644
index 000000000..9699f166b
--- /dev/null
+++ b/src/tester/semantic/dispatch4_error.txt
@@ -0,0 +1 @@
+(35, 16) - TypeError: Inferred type B of initialization of attribute test does not conform to declared type D.
\ No newline at end of file
diff --git a/src/tester/semantic/dispatch5.cl b/src/tester/semantic/dispatch5.cl
new file mode 100644
index 000000000..b4437b1b4
--- /dev/null
+++ b/src/tester/semantic/dispatch5.cl
@@ -0,0 +1,31 @@
+(*
+<id>(<expr>,...,<expr>)  is shorthand for self.<id>(<expr>,...,<expr>).
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+	sum(m: Int, n: Int, p: Int): Int { m + n + p };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+
+	back(s: String): B { {
+		out_string(s);
+		g(2);
+		sum(1, 2, 3);
+		self; 
+	} };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/dispatch5_error.txt b/src/tester/semantic/dispatch5_error.txt
new file mode 100644
index 000000000..d26bf34a1
--- /dev/null
+++ b/src/tester/semantic/dispatch5_error.txt
@@ -0,0 +1 @@
+(24, 9) - AttributeError: Dispatch to undefined method sum. 
diff --git a/src/tester/semantic/dispatch6.cl b/src/tester/semantic/dispatch6.cl
new file mode 100644
index 000000000..fcc033f2c
--- /dev/null
+++ b/src/tester/semantic/dispatch6.cl
@@ -0,0 +1,32 @@
+(*
+e@B.f() invokes the method
+f in class B on the object that is the value of e. For this form of dispatch, the static type to the left of
+“@”must conform to the type specified to the right of “@”.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+	sum(m: Int, n: Int, p: Int): Int { m + n + p };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+	sum(v: Int, w: Int, z: Int): Int { v - w - z };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: A <- new D;
+	b: Int <- new D@B.sum(1, 2, 3);
+	test: Int <- a@B.sum(1, 2, 3);
+}; 
diff --git a/src/tester/semantic/dispatch6_error.txt b/src/tester/semantic/dispatch6_error.txt
new file mode 100644
index 000000000..ae9184b2f
--- /dev/null
+++ b/src/tester/semantic/dispatch6_error.txt
@@ -0,0 +1 @@
+(31, 18) - TypeError: Expression type A does not conform to declared static dispatch type B. 
diff --git a/src/tester/semantic/eq1.cl b/src/tester/semantic/eq1.cl
new file mode 100644
index 000000000..88f2a7ffe
--- /dev/null
+++ b/src/tester/semantic/eq1.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared.
+*)
+
+class A { };
+class B inherits A { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	test: Bool <- 1 = new A;
+	y: Bool <- "1" = "2";
+	z: Bool <- true = not false;
+};  
\ No newline at end of file
diff --git a/src/tester/semantic/eq1_error.txt b/src/tester/semantic/eq1_error.txt
new file mode 100644
index 000000000..f81425683
--- /dev/null
+++ b/src/tester/semantic/eq1_error.txt
@@ -0,0 +1 @@
+(14, 21) - TypeError: Illegal comparison with a basic type. 
diff --git a/src/tester/semantic/eq2.cl b/src/tester/semantic/eq2.cl
new file mode 100644
index 000000000..d76852780
--- /dev/null
+++ b/src/tester/semantic/eq2.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared.
+*)
+
+class A { };
+class B inherits A { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	y: Bool <- "1" = "2";
+	test: Bool <- "1" = new B;
+	z: Bool <- true = not false;
+}; 
diff --git a/src/tester/semantic/eq2_error.txt b/src/tester/semantic/eq2_error.txt
new file mode 100644
index 000000000..a44ab0d51
--- /dev/null
+++ b/src/tester/semantic/eq2_error.txt
@@ -0,0 +1 @@
+(15, 23) - TypeError: Illegal comparison with a basic type. 
diff --git a/src/tester/semantic/eq3.cl b/src/tester/semantic/eq3.cl
new file mode 100644
index 000000000..4dad693ee
--- /dev/null
+++ b/src/tester/semantic/eq3.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared.
+*)
+
+class A { };
+class B inherits A { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	y: Bool <- "1" = "2";
+	z: Bool <- true = not false;
+	test: Bool <- "true" = not false;
+};  
diff --git a/src/tester/semantic/eq3_error.txt b/src/tester/semantic/eq3_error.txt
new file mode 100644
index 000000000..c4e27eb8a
--- /dev/null
+++ b/src/tester/semantic/eq3_error.txt
@@ -0,0 +1 @@
+(16, 26) - TypeError: Illegal comparison with a basic type. 
diff --git a/src/tester/semantic/eq4.cl b/src/tester/semantic/eq4.cl
new file mode 100644
index 000000000..11afc119f
--- /dev/null
+++ b/src/tester/semantic/eq4.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared. The result is a Bool.
+*)
+
+class A { };
+class B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	y: Bool <- "1" = "2";
+	z: Bool <- new A = new B;
+	test: Int <- new A = new B;
+}; 
diff --git a/src/tester/semantic/eq4_error.txt b/src/tester/semantic/eq4_error.txt
new file mode 100644
index 000000000..3ead21d0e
--- /dev/null
+++ b/src/tester/semantic/eq4_error.txt
@@ -0,0 +1 @@
+(16, 18) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type Int. 
diff --git a/src/tester/semantic/features1.cl b/src/tester/semantic/features1.cl
new file mode 100644
index 000000000..66f650f4a
--- /dev/null
+++ b/src/tester/semantic/features1.cl
@@ -0,0 +1,19 @@
+(*
+No method name may be defined multiple times in
+a class, and no attribute name may be defined multiple times in a class, but a method and an attribute
+may have the same name.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): Int { 3 };
+
+	x: String <- ":)";
+};
\ No newline at end of file
diff --git a/src/tester/semantic/features1_error.txt b/src/tester/semantic/features1_error.txt
new file mode 100644
index 000000000..40033e9b3
--- /dev/null
+++ b/src/tester/semantic/features1_error.txt
@@ -0,0 +1 @@
+(18, 5) - SemanticError: Attribute x is multiply defined in class.
\ No newline at end of file
diff --git a/src/tester/semantic/features2.cl b/src/tester/semantic/features2.cl
new file mode 100644
index 000000000..5b1f7e9df
--- /dev/null
+++ b/src/tester/semantic/features2.cl
@@ -0,0 +1,19 @@
+(*
+No method name may be defined multiple times in
+a class, and no attribute name may be defined multiple times in a class, but a method and an attribute
+may have the same name.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): String { "3" };
+
+	x(): String { ":)" };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/features2_error.txt b/src/tester/semantic/features2_error.txt
new file mode 100644
index 000000000..117e06042
--- /dev/null
+++ b/src/tester/semantic/features2_error.txt
@@ -0,0 +1 @@
+(18, 5) - SemanticError: Method x is multiply defined.
\ No newline at end of file
diff --git a/src/tester/semantic/features3.cl b/src/tester/semantic/features3.cl
new file mode 100644
index 000000000..3e75c88bb
--- /dev/null
+++ b/src/tester/semantic/features3.cl
@@ -0,0 +1,15 @@
+-- Missing type
+
+class Main inherits IO {
+	main(): IO { not a+b};
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): Int { 3 };
+
+	c: Cadena;
+};
\ No newline at end of file
diff --git a/src/tester/semantic/features3_error.txt b/src/tester/semantic/features3_error.txt
new file mode 100644
index 000000000..53f1abe26
--- /dev/null
+++ b/src/tester/semantic/features3_error.txt
@@ -0,0 +1 @@
+(14, 8) - TypeError: Class Cadena of attribute c is undefined.
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance1.cl b/src/tester/semantic/inheritance1.cl
new file mode 100644
index 000000000..1d92da307
--- /dev/null
+++ b/src/tester/semantic/inheritance1.cl
@@ -0,0 +1,19 @@
+--It is illegal to redefine attribute names.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
+
+class B inherits A {
+	x: Int;
+
+	div(a: Int, b: Int): Int { a / b};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance1_error.txt b/src/tester/semantic/inheritance1_error.txt
new file mode 100644
index 000000000..ec5b504e6
--- /dev/null
+++ b/src/tester/semantic/inheritance1_error.txt
@@ -0,0 +1 @@
+(16, 5) - SemanticError: Attribute x is an attribute of an inherited class.
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance2.cl b/src/tester/semantic/inheritance2.cl
new file mode 100644
index 000000000..d453eca09
--- /dev/null
+++ b/src/tester/semantic/inheritance2.cl
@@ -0,0 +1,19 @@
+--If C inherits from P, then P must have a class definition somewhere in the program.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class Alo {
+	x: Int <- 3;
+
+	x(): String { "3" };
+};
+
+class B inherits A {
+	div(a: Int, b: Int): Int { a / b};
+	
+	x: String <- "2";
+};
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance2_error.txt b/src/tester/semantic/inheritance2_error.txt
new file mode 100644
index 000000000..1ec7669b5
--- /dev/null
+++ b/src/tester/semantic/inheritance2_error.txt
@@ -0,0 +1 @@
+(15, 18) - TypeError: Class B inherits from an undefined class A.
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance3.cl b/src/tester/semantic/inheritance3.cl
new file mode 100644
index 000000000..3ff170dec
--- /dev/null
+++ b/src/tester/semantic/inheritance3.cl
@@ -0,0 +1,13 @@
+--The parent-child relation on classes defines a graph. This graph may not contain cycles.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A inherits A {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance3_error.txt b/src/tester/semantic/inheritance3_error.txt
new file mode 100644
index 000000000..d17ca7f49
--- /dev/null
+++ b/src/tester/semantic/inheritance3_error.txt
@@ -0,0 +1 @@
+(9, 18) - SemanticError: Class A, or an ancestor of A, is involved in an inheritance cycle.
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance4.cl b/src/tester/semantic/inheritance4.cl
new file mode 100644
index 000000000..c985484ba
--- /dev/null
+++ b/src/tester/semantic/inheritance4.cl
@@ -0,0 +1,19 @@
+--The parent-child relation on classes defines a graph. This graph may not contain cycles.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A inherits B {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
+
+class B inherits A {
+	y: Int <- 2;
+
+	div(a: Int, b: Int): Int { a / b};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance4_error.txt b/src/tester/semantic/inheritance4_error.txt
new file mode 100644
index 000000000..b437ec667
--- /dev/null
+++ b/src/tester/semantic/inheritance4_error.txt
@@ -0,0 +1 @@
+(15, 18) - SemanticError: Class B, or an ancestor of B, is involved in an inheritance cycle.
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance5.cl b/src/tester/semantic/inheritance5.cl
new file mode 100644
index 000000000..f6ed885c8
--- /dev/null
+++ b/src/tester/semantic/inheritance5.cl
@@ -0,0 +1,21 @@
+--The parent-child relation on classes defines a graph. This graph may not contain cycles.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A inherits B {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
+
+class B inherits C {
+	y: Int <- 2;
+
+	div(a: Int, b: Int): Int { a / b};
+};
+
+class C inherits A { };
\ No newline at end of file
diff --git a/src/tester/semantic/inheritance5_error.txt b/src/tester/semantic/inheritance5_error.txt
new file mode 100644
index 000000000..da72ba547
--- /dev/null
+++ b/src/tester/semantic/inheritance5_error.txt
@@ -0,0 +1 @@
+(21, 18) - SemanticError: Class C, or an ancestor of C, is involved in an inheritance cycle.
\ No newline at end of file
diff --git a/src/tester/semantic/isvoid1.cl b/src/tester/semantic/isvoid1.cl
new file mode 100644
index 000000000..072720d85
--- /dev/null
+++ b/src/tester/semantic/isvoid1.cl
@@ -0,0 +1,26 @@
+--evaluates to true if expr is void and evaluates to false if expr is not void.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- if isvoid new F then 
+				new C 
+			else 
+				if false then new D 
+				else new E fi
+			fi;
+
+	test: B <- isvoid if isvoid new F then 
+				new C 
+			else 
+				if false then new D 
+				else new E fi
+			fi;
+}; 
\ No newline at end of file
diff --git a/src/tester/semantic/isvoid1_error.txt b/src/tester/semantic/isvoid1_error.txt
new file mode 100644
index 000000000..0922de909
--- /dev/null
+++ b/src/tester/semantic/isvoid1_error.txt
@@ -0,0 +1 @@
+(20, 16) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tester/semantic/let1.cl b/src/tester/semantic/let1.cl
new file mode 100644
index 000000000..26ef63026
--- /dev/null
+++ b/src/tester/semantic/let1.cl
@@ -0,0 +1,15 @@
+--The type of an initialization expression must conform to the declared type of the identifier.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: B <- new E in b;
+	test: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: C <- new E in b;
+}; 
\ No newline at end of file
diff --git a/src/tester/semantic/let1_error.txt b/src/tester/semantic/let1_error.txt
new file mode 100644
index 000000000..16ecf780c
--- /dev/null
+++ b/src/tester/semantic/let1_error.txt
@@ -0,0 +1 @@
+(14, 76) - TypeError: Inferred type E of initialization of b does not conform to identifier's declared type C. 
diff --git a/src/tester/semantic/let2.cl b/src/tester/semantic/let2.cl
new file mode 100644
index 000000000..c5956ead3
--- /dev/null
+++ b/src/tester/semantic/let2.cl
@@ -0,0 +1,15 @@
+--The type of let is the type of the body.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: B <- new E in b;
+	test: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: A <- new E in b;
+};
\ No newline at end of file
diff --git a/src/tester/semantic/let2_error.txt b/src/tester/semantic/let2_error.txt
new file mode 100644
index 000000000..b1e8a365d
--- /dev/null
+++ b/src/tester/semantic/let2_error.txt
@@ -0,0 +1 @@
+(14, 16) - TypeError: Inferred type A of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tester/semantic/let3.cl b/src/tester/semantic/let3.cl
new file mode 100644
index 000000000..8c0670ab8
--- /dev/null
+++ b/src/tester/semantic/let3.cl
@@ -0,0 +1,15 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: B <- new E in b;
+	test: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: Cadena in new B;
+}; 
\ No newline at end of file
diff --git a/src/tester/semantic/let3_error.txt b/src/tester/semantic/let3_error.txt
new file mode 100644
index 000000000..39c5315d8
--- /dev/null
+++ b/src/tester/semantic/let3_error.txt
@@ -0,0 +1 @@
+(14, 71) - TypeError: Class Cadena of let-bound identifier b is undefined.
\ No newline at end of file
diff --git a/src/tester/semantic/loops1.cl b/src/tester/semantic/loops1.cl
new file mode 100644
index 000000000..de3a624d2
--- /dev/null
+++ b/src/tester/semantic/loops1.cl
@@ -0,0 +1,8 @@
+--The predicate must have static type Bool.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	i: Int <- 1;
+	test: Object <- while "true" loop i <- i + 1 pool; 
+};
\ No newline at end of file
diff --git a/src/tester/semantic/loops1_error.txt b/src/tester/semantic/loops1_error.txt
new file mode 100644
index 000000000..b160214b4
--- /dev/null
+++ b/src/tester/semantic/loops1_error.txt
@@ -0,0 +1 @@
+(7, 27) - TypeError: Loop condition does not have type Bool.
\ No newline at end of file
diff --git a/src/tester/semantic/loops2.cl b/src/tester/semantic/loops2.cl
new file mode 100644
index 000000000..dea69fa14
--- /dev/null
+++ b/src/tester/semantic/loops2.cl
@@ -0,0 +1,9 @@
+--The static type of a loop expression is Object.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	i: Int <- 1;
+	test: Object <- while not false loop i <- i + 1 pool; 
+	test2: Int <- while not false loop i <- i + 1 pool; 
+}; 
diff --git a/src/tester/semantic/loops2_error.txt b/src/tester/semantic/loops2_error.txt
new file mode 100644
index 000000000..9711cdf6a
--- /dev/null
+++ b/src/tester/semantic/loops2_error.txt
@@ -0,0 +1 @@
+(8, 19) - TypeError: Inferred type Object of initialization of attribute test2 does not conform to declared type Int. 
diff --git a/src/tester/semantic/methods1.cl b/src/tester/semantic/methods1.cl
new file mode 100644
index 000000000..d12031970
--- /dev/null
+++ b/src/tester/semantic/methods1.cl
@@ -0,0 +1,12 @@
+--The identifiers used in the formal parameter list must be distinct
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, a: B): Int { 4 };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods1_error.txt b/src/tester/semantic/methods1_error.txt
new file mode 100644
index 000000000..06ab88a92
--- /dev/null
+++ b/src/tester/semantic/methods1_error.txt
@@ -0,0 +1 @@
+(11, 16) - SemanticError: Formal parameter a is multiply defined.
diff --git a/src/tester/semantic/methods2.cl b/src/tester/semantic/methods2.cl
new file mode 100644
index 000000000..3865f0e13
--- /dev/null
+++ b/src/tester/semantic/methods2.cl
@@ -0,0 +1,12 @@
+--The type of the method body must conform to the declared return type.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, b: B): C { new D };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods2_error.txt b/src/tester/semantic/methods2_error.txt
new file mode 100644
index 000000000..f7e4a330d
--- /dev/null
+++ b/src/tester/semantic/methods2_error.txt
@@ -0,0 +1 @@
+(11, 27) - TypeError: Inferred return type D of method test does not conform to declared return type C.
diff --git a/src/tester/semantic/methods3.cl b/src/tester/semantic/methods3.cl
new file mode 100644
index 000000000..b92faeb97
--- /dev/null
+++ b/src/tester/semantic/methods3.cl
@@ -0,0 +1,14 @@
+--A formal parameter hides any definition of an attribute of the same name.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: C <- new C;
+	test(a: D): D { a };
+	test2(a: B): C { a };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods3_error.txt b/src/tester/semantic/methods3_error.txt
new file mode 100644
index 000000000..1165b7595
--- /dev/null
+++ b/src/tester/semantic/methods3_error.txt
@@ -0,0 +1 @@
+(13, 22) - TypeError: Inferred return type B of method test2 does not conform to declared return type C.
diff --git a/src/tester/semantic/methods4.cl b/src/tester/semantic/methods4.cl
new file mode 100644
index 000000000..be8fa36ef
--- /dev/null
+++ b/src/tester/semantic/methods4.cl
@@ -0,0 +1,19 @@
+(*
+The rule is
+simple: If a class C inherits a method f from an ancestor class P, then C may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+};
+class B inherits A {
+	f(x: Int, y: Object): Int { x };
+};
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods4_error.txt b/src/tester/semantic/methods4_error.txt
new file mode 100644
index 000000000..9f1486dec
--- /dev/null
+++ b/src/tester/semantic/methods4_error.txt
@@ -0,0 +1 @@
+(12, 15) - SemanticError: In redefined method f, parameter type Object is different from original type Int.
diff --git a/src/tester/semantic/methods5.cl b/src/tester/semantic/methods5.cl
new file mode 100644
index 000000000..3905dfdd6
--- /dev/null
+++ b/src/tester/semantic/methods5.cl
@@ -0,0 +1,20 @@
+(*
+The rule is
+simple: If a class C inherits a method f from an ancestor class P, then C may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+};
+class B inherits A {
+	f(a: Int, b: Int): Object { a - b };
+};
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
+ 
diff --git a/src/tester/semantic/methods5_error.txt b/src/tester/semantic/methods5_error.txt
new file mode 100644
index 000000000..8b6bdf36e
--- /dev/null
+++ b/src/tester/semantic/methods5_error.txt
@@ -0,0 +1 @@
+(12, 24) - SemanticError: In redefined method f, return type Object is different from original return type Int.
diff --git a/src/tester/semantic/methods6.cl b/src/tester/semantic/methods6.cl
new file mode 100644
index 000000000..dd2b73da6
--- /dev/null
+++ b/src/tester/semantic/methods6.cl
@@ -0,0 +1,27 @@
+(*
+The rule is
+simple: If a class C inherits a method f from an ancestor class P, then C may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int, w: Int, z: Int): Int { v + w + z };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods6_error.txt b/src/tester/semantic/methods6_error.txt
new file mode 100644
index 000000000..8e32663b9
--- /dev/null
+++ b/src/tester/semantic/methods6_error.txt
@@ -0,0 +1 @@
+(22, 5) - SemanticError: Incompatible number of formal parameters in redefined method g.
diff --git a/src/tester/semantic/methods7.cl b/src/tester/semantic/methods7.cl
new file mode 100644
index 000000000..e5a01f682
--- /dev/null
+++ b/src/tester/semantic/methods7.cl
@@ -0,0 +1,12 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, b: Ball): Int { 4 };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods7_error.txt b/src/tester/semantic/methods7_error.txt
new file mode 100644
index 000000000..472cbd9d1
--- /dev/null
+++ b/src/tester/semantic/methods7_error.txt
@@ -0,0 +1 @@
+(11, 19) - TypeError: Class Ball of formal parameter b is undefined.
\ No newline at end of file
diff --git a/src/tester/semantic/methods8.cl b/src/tester/semantic/methods8.cl
new file mode 100644
index 000000000..3fccab54c
--- /dev/null
+++ b/src/tester/semantic/methods8.cl
@@ -0,0 +1,12 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, b: B): Integrer { 4 };
+};
\ No newline at end of file
diff --git a/src/tester/semantic/methods8_error.txt b/src/tester/semantic/methods8_error.txt
new file mode 100644
index 000000000..dc9302ec0
--- /dev/null
+++ b/src/tester/semantic/methods8_error.txt
@@ -0,0 +1 @@
+(11, 23) - TypeError: Undefined return type Integrer in method test.
\ No newline at end of file
diff --git a/src/tester/semantic/new1.cl b/src/tester/semantic/new1.cl
new file mode 100644
index 000000000..d007fc03d
--- /dev/null
+++ b/src/tester/semantic/new1.cl
@@ -0,0 +1,31 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: F <- {
+		new A;
+		{ 
+			new Ball;
+			{
+				new C;
+				{
+					new D;
+					{
+						new E;
+						{
+							new F;
+						};
+					};
+				};
+			};
+		};
+	};
+};
\ No newline at end of file
diff --git a/src/tester/semantic/new1_error.txt b/src/tester/semantic/new1_error.txt
new file mode 100644
index 000000000..612a3d427
--- /dev/null
+++ b/src/tester/semantic/new1_error.txt
@@ -0,0 +1 @@
+(16, 17) - TypeError: 'new' used with undefined class Ball.
\ No newline at end of file
diff --git a/src/tester/semantic/self1.cl b/src/tester/semantic/self1.cl
new file mode 100644
index 000000000..3387fd263
--- /dev/null
+++ b/src/tester/semantic/self1.cl
@@ -0,0 +1,11 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: Main): IO { self <- a };
+}; 
diff --git a/src/tester/semantic/self1_error.txt b/src/tester/semantic/self1_error.txt
new file mode 100644
index 000000000..6beb3cda2
--- /dev/null
+++ b/src/tester/semantic/self1_error.txt
@@ -0,0 +1 @@
+(10, 30) - SemanticError: Cannot assign to 'self'.
diff --git a/src/tester/semantic/self2.cl b/src/tester/semantic/self2.cl
new file mode 100644
index 000000000..2e6921a92
--- /dev/null
+++ b/src/tester/semantic/self2.cl
@@ -0,0 +1,10 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(): IO { let self: Main <- new Main in self };
+}; 
diff --git a/src/tester/semantic/self2_error.txt b/src/tester/semantic/self2_error.txt
new file mode 100644
index 000000000..20c883c91
--- /dev/null
+++ b/src/tester/semantic/self2_error.txt
@@ -0,0 +1 @@
+(9, 22) - SemanticError: 'self' cannot be bound in a 'let' expression.
diff --git a/src/tester/semantic/self3.cl b/src/tester/semantic/self3.cl
new file mode 100644
index 000000000..81709b4b5
--- /dev/null
+++ b/src/tester/semantic/self3.cl
@@ -0,0 +1,10 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(self: IO): IO { self };
+};
diff --git a/src/tester/semantic/self3_error.txt b/src/tester/semantic/self3_error.txt
new file mode 100644
index 000000000..0ae382007
--- /dev/null
+++ b/src/tester/semantic/self3_error.txt
@@ -0,0 +1 @@
+(9, 10) - SemanticError: 'self' cannot be the name of a formal parameter.
diff --git a/src/tester/semantic/self4.cl b/src/tester/semantic/self4.cl
new file mode 100644
index 000000000..7c2b960cb
--- /dev/null
+++ b/src/tester/semantic/self4.cl
@@ -0,0 +1,10 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	self: IO <- self;
+};
\ No newline at end of file
diff --git a/src/tester/semantic/self4_error.txt b/src/tester/semantic/self4_error.txt
new file mode 100644
index 000000000..c19ca400f
--- /dev/null
+++ b/src/tester/semantic/self4_error.txt
@@ -0,0 +1 @@
+(9, 5) - SemanticError: 'self' cannot be the name of an attribute.
diff --git a/src/tests/codegen/arith.cl b/src/tests/codegen/arith.cl
new file mode 100644
index 000000000..af5951cf7
--- /dev/null
+++ b/src/tests/codegen/arith.cl
@@ -0,0 +1,430 @@
+(*
+ *  A contribution from Anne Sheets (sheets@cory)
+ *
+ *  Tests the arithmetic operations and various other things
+ *)
+
+class A {
+
+   var : Int <- 0;
+
+   value() : Int { var };
+
+   set_var(num : Int) : A{
+      {
+         var <- num;
+         self;
+      }
+   };
+
+   method1(num : Int) : A {  -- same
+      self
+   };
+
+   method2(num1 : Int, num2 : Int) : A {  -- plus
+      (let x : Int in
+	 {
+            x <- num1 + num2;
+	    (new B).set_var(x);
+	 }
+      )
+   };
+
+   method3(num : Int) : A {  -- negate
+      (let x : Int in
+	 {
+            x <- ~num;
+	    (new C).set_var(x);
+	 }
+      )
+   };
+
+   method4(num1 : Int, num2 : Int) : A {  -- diff
+            if num2 < num1 then
+               (let x : Int in
+		  {
+                     x <- num1 - num2;
+	             (new D).set_var(x);
+	          }
+               )
+            else
+               (let x : Int in
+		  {
+	             x <- num2 - num1;
+	             (new D).set_var(x);
+		  }
+               )
+            fi
+   };
+
+   method5(num : Int) : A {  -- factorial
+      (let x : Int <- 1 in
+	 {
+	    (let y : Int <- 1 in
+	       while y <= num loop
+	          {
+                     x <- x * y;
+	             y <- y + 1;
+	          }
+	       pool
+	    );
+	    (new E).set_var(x);
+	 }
+      )
+   };
+
+};
+
+class B inherits A {  -- B is a number squared
+
+   method5(num : Int) : A { -- square
+      (let x : Int in
+	 {
+            x <- num * num;
+	    (new E).set_var(x);
+	 }
+      )
+   };
+
+};
+
+class C inherits B {
+
+   method6(num : Int) : A { -- negate
+      (let x : Int in
+         {
+            x <- ~num;
+	    (new A).set_var(x);
+         }
+      )
+   };
+
+   method5(num : Int) : A {  -- cube
+      (let x : Int in
+	 {
+            x <- num * num * num;
+	    (new E).set_var(x);
+	 }
+      )
+   };
+
+};
+
+class D inherits B {  
+		
+   method7(num : Int) : Bool {  -- divisible by 3
+      (let x : Int <- num in
+            if x < 0 then method7(~x) else
+            if 0 = x then true else
+            if 1 = x then false else
+	    if 2 = x then false else
+	       method7(x - 3)
+	    fi fi fi fi
+      )
+   };
+
+};
+
+class E inherits D {
+
+   method6(num : Int) : A {  -- division
+      (let x : Int in
+         {
+            x <- num / 8;
+	    (new A).set_var(x);
+         }
+      )
+   };
+
+};
+
+(* The following code is from atoi.cl in ~cs164/examples *)
+
+(*
+   The class A2I provides integer-to-string and string-to-integer
+conversion routines.  To use these routines, either inherit them
+in the class where needed, have a dummy variable bound to
+something of type A2I, or simpl write (new A2I).method(argument).
+*)
+
+
+(*
+   c2i   Converts a 1-character string to an integer.  Aborts
+         if the string is not "0" through "9"
+*)
+class A2I {
+
+     c2i(char : String) : Int {
+	if char = "0" then 0 else
+	if char = "1" then 1 else
+	if char = "2" then 2 else
+        if char = "3" then 3 else
+        if char = "4" then 4 else
+        if char = "5" then 5 else
+        if char = "6" then 6 else
+        if char = "7" then 7 else
+        if char = "8" then 8 else
+        if char = "9" then 9 else
+        { abort(); 0; }  (* the 0 is needed to satisfy the
+				  typchecker *)
+        fi fi fi fi fi fi fi fi fi fi
+     };
+
+(*
+   i2c is the inverse of c2i.
+*)
+     i2c(i : Int) : String {
+	if i = 0 then "0" else
+	if i = 1 then "1" else
+	if i = 2 then "2" else
+	if i = 3 then "3" else
+	if i = 4 then "4" else
+	if i = 5 then "5" else
+	if i = 6 then "6" else
+	if i = 7 then "7" else
+	if i = 8 then "8" else
+	if i = 9 then "9" else
+	{ abort(); ""; }  -- the "" is needed to satisfy the typchecker
+        fi fi fi fi fi fi fi fi fi fi
+     };
+
+(*
+   a2i converts an ASCII string into an integer.  The empty string
+is converted to 0.  Signed and unsigned strings are handled.  The
+method aborts if the string does not represent an integer.  Very
+long strings of digits produce strange answers because of arithmetic 
+overflow.
+
+*)
+     a2i(s : String) : Int {
+        if s.length() = 0 then 0 else
+	if s.substr(0,1) = "-" then ~a2i_aux(s.substr(1,s.length()-1)) else
+        if s.substr(0,1) = "+" then a2i_aux(s.substr(1,s.length()-1)) else
+           a2i_aux(s)
+        fi fi fi
+     };
+
+(* a2i_aux converts the usigned portion of the string.  As a
+   programming example, this method is written iteratively.  *)
+
+
+     a2i_aux(s : String) : Int {
+	(let int : Int <- 0 in	
+           {	
+               (let j : Int <- s.length() in
+	          (let i : Int <- 0 in
+		    while i < j loop
+			{
+			    int <- int * 10 + c2i(s.substr(i,1));
+			    i <- i + 1;
+			}
+		    pool
+		  )
+	       );
+              int;
+	    }
+        )
+     };
+
+(* i2a converts an integer to a string.  Positive and negative 
+   numbers are handled correctly.  *)
+
+    i2a(i : Int) : String {
+	if i = 0 then "0" else 
+        if 0 < i then i2a_aux(i) else
+          "-".concat(i2a_aux(i * ~1)) 
+        fi fi
+    };
+	
+(* i2a_aux is an example using recursion.  *)		
+
+    i2a_aux(i : Int) : String {
+        if i = 0 then "" else 
+	    (let next : Int <- i / 10 in
+		i2a_aux(next).concat(i2c(i - next * 10))
+	    )
+        fi
+    };
+
+};
+
+class Main inherits IO {
+   
+   char : String;
+   avar : A; 
+   a_var : A;
+   flag : Bool <- true;
+
+
+   menu() : String {
+      {
+         out_string("\n\tTo add a number to ");
+         print(avar);
+         out_string("...enter a:\n");
+         out_string("\tTo negate ");
+         print(avar);
+         out_string("...enter b:\n");
+         out_string("\tTo find the difference between ");
+         print(avar);
+         out_string("and another number...enter c:\n");
+         out_string("\tTo find the factorial of ");
+         print(avar);
+         out_string("...enter d:\n");
+         out_string("\tTo square ");
+         print(avar);
+         out_string("...enter e:\n");
+         out_string("\tTo cube ");
+         print(avar);
+         out_string("...enter f:\n");
+         out_string("\tTo find out if ");
+         print(avar);
+         out_string("is a multiple of 3...enter g:\n");
+         out_string("\tTo divide ");
+         print(avar);
+         out_string("by 8...enter h:\n");
+	 out_string("\tTo get a new number...enter j:\n");
+	 out_string("\tTo quit...enter q:\n\n");
+         in_string();
+      }
+   };
+
+   prompt() : String {
+      {
+         out_string("\n");
+         out_string("Please enter a number...  ");
+         in_string();
+      }
+   };
+
+   get_int() : Int {
+      {
+	 (let z : A2I <- new A2I in
+	    (let s : String <- prompt() in
+	       z.a2i(s)
+	    )
+         );
+      }
+   };
+
+   is_even(num : Int) : Bool {
+      (let x : Int <- num in
+            if x < 0 then is_even(~x) else
+            if 0 = x then true else
+	    if 1 = x then false else
+	          is_even(x - 2)
+	    fi fi fi
+      )
+   };
+
+   class_type(var : A) : IO {
+      case var of
+	 a : A => out_string("Class type is now A\n");
+	 b : B => out_string("Class type is now B\n");
+	 c : C => out_string("Class type is now C\n");
+	 d : D => out_string("Class type is now D\n");
+	 e : E => out_string("Class type is now E\n");
+	 o : Object => out_string("Oooops\n");
+      esac
+   };
+ 
+   print(var : A) : IO {
+     (let z : A2I <- new A2I in
+	{
+	   out_string(z.i2a(var.value()));
+	   out_string(" ");
+	}
+     )
+   };
+
+   main() : Object {
+      {
+         avar <- (new A);
+         while flag loop
+            {
+	       -- avar <- (new A).set_var(get_int());
+	       out_string("number ");
+	       print(avar);
+	       if is_even(avar.value()) then
+	          out_string("is even!\n")
+	       else
+	          out_string("is odd!\n")
+	       fi;
+	       -- print(avar); -- prints out answer
+	       class_type(avar);
+	       char <- menu();
+                  if char = "a" then -- add
+                     {
+                        a_var <- (new A).set_var(get_int());
+	                avar <- (new B).method2(avar.value(), a_var.value());
+	             } else
+                  if char = "b" then -- negate
+                     case avar of
+	                   c : C => avar <- c.method6(c.value());
+	                   a : A => avar <- a.method3(a.value());
+	                   o : Object => {
+		                  out_string("Oooops\n");
+		                  abort(); 0;
+		               };
+                     esac else
+                  if char = "c" then -- diff
+                     {
+                        a_var <- (new A).set_var(get_int());
+	                avar <- (new D).method4(avar.value(), a_var.value());
+	             } else
+                  if char = "d" then avar <- (new C)@A.method5(avar.value()) else
+		          -- factorial
+                  if char = "e" then avar <- (new C)@B.method5(avar.value()) else
+			  -- square
+                  if char = "f" then avar <- (new C)@C.method5(avar.value()) else
+			  -- cube
+                  if char = "g" then -- multiple of 3?
+		      if ((new D).method7(avar.value()))
+		                       then -- avar <- (new A).method1(avar.value())
+			 {
+	                    out_string("number ");
+	                    print(avar);
+	                    out_string("is divisible by 3.\n");
+			 }
+			 else  -- avar <- (new A).set_var(0)
+			 {
+	                    out_string("number ");
+	                    print(avar);
+	                    out_string("is not divisible by 3.\n");
+			 }
+		      fi else
+                  if char = "h" then 
+		      (let x : A in
+			 {
+		            x <- (new E).method6(avar.value());
+			    (let r : Int <- (avar.value() - (x.value() * 8)) in
+			       {
+			          out_string("number ");
+			          print(avar);
+			          out_string("is equal to ");
+			          print(x);
+			          out_string("times 8 with a remainder of ");
+				  (let a : A2I <- new A2I in
+				     {
+			                out_string(a.i2a(r));
+			                out_string("\n");
+				     }
+				  ); -- end let a:
+			       }
+                            ); -- end let r:
+			    avar <- x;
+		         } 
+		      )  -- end let x:
+		      else
+                  if char = "j" then avar <- (new A)
+		      else
+                  if char = "q" then flag <- false
+		      else
+                      avar <- (new A).method1(avar.value()) -- divide/8
+                  fi fi fi fi fi fi fi fi fi fi;
+            }
+         pool;
+       }
+   };
+
+};
+
diff --git a/src/tests/codegen/arith_input.txt b/src/tests/codegen/arith_input.txt
new file mode 100644
index 000000000..83e05b1ea
--- /dev/null
+++ b/src/tests/codegen/arith_input.txt
@@ -0,0 +1,13 @@
+a
+1
+b
+c
+0
+d
+e
+f
+g
+h
+j
+5
+q
diff --git a/src/tests/codegen/arith_output.txt b/src/tests/codegen/arith_output.txt
new file mode 100644
index 000000000..44b4ce73e
--- /dev/null
+++ b/src/tests/codegen/arith_output.txt
@@ -0,0 +1,158 @@
+number 0 is even!
+Class type is now A
+
+	To add a number to 0 ...enter a:
+	To negate 0 ...enter b:
+	To find the difference between 0 and another number...enter c:
+	To find the factorial of 0 ...enter d:
+	To square 0 ...enter e:
+	To cube 0 ...enter f:
+	To find out if 0 is a multiple of 3...enter g:
+	To divide 0 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+
+Please enter a number...  number 1 is odd!
+Class type is now B
+
+	To add a number to 1 ...enter a:
+	To negate 1 ...enter b:
+	To find the difference between 1 and another number...enter c:
+	To find the factorial of 1 ...enter d:
+	To square 1 ...enter e:
+	To cube 1 ...enter f:
+	To find out if 1 is a multiple of 3...enter g:
+	To divide 1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number -1 is odd!
+Class type is now C
+
+	To add a number to -1 ...enter a:
+	To negate -1 ...enter b:
+	To find the difference between -1 and another number...enter c:
+	To find the factorial of -1 ...enter d:
+	To square -1 ...enter e:
+	To cube -1 ...enter f:
+	To find out if -1 is a multiple of 3...enter g:
+	To divide -1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+
+Please enter a number...  number 1 is odd!
+Class type is now D
+
+	To add a number to 1 ...enter a:
+	To negate 1 ...enter b:
+	To find the difference between 1 and another number...enter c:
+	To find the factorial of 1 ...enter d:
+	To square 1 ...enter e:
+	To cube 1 ...enter f:
+	To find out if 1 is a multiple of 3...enter g:
+	To divide 1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 1 is odd!
+Class type is now E
+
+	To add a number to 1 ...enter a:
+	To negate 1 ...enter b:
+	To find the difference between 1 and another number...enter c:
+	To find the factorial of 1 ...enter d:
+	To square 1 ...enter e:
+	To cube 1 ...enter f:
+	To find out if 1 is a multiple of 3...enter g:
+	To divide 1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 1 is odd!
+Class type is now E
+
+	To add a number to 1 ...enter a:
+	To negate 1 ...enter b:
+	To find the difference between 1 and another number...enter c:
+	To find the factorial of 1 ...enter d:
+	To square 1 ...enter e:
+	To cube 1 ...enter f:
+	To find out if 1 is a multiple of 3...enter g:
+	To divide 1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 1 is odd!
+Class type is now E
+
+	To add a number to 1 ...enter a:
+	To negate 1 ...enter b:
+	To find the difference between 1 and another number...enter c:
+	To find the factorial of 1 ...enter d:
+	To square 1 ...enter e:
+	To cube 1 ...enter f:
+	To find out if 1 is a multiple of 3...enter g:
+	To divide 1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 1 is not divisible by 3.
+number 1 is odd!
+Class type is now E
+
+	To add a number to 1 ...enter a:
+	To negate 1 ...enter b:
+	To find the difference between 1 and another number...enter c:
+	To find the factorial of 1 ...enter d:
+	To square 1 ...enter e:
+	To cube 1 ...enter f:
+	To find out if 1 is a multiple of 3...enter g:
+	To divide 1 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 1 is equal to 0 times 8 with a remainder of 1
+number 0 is even!
+Class type is now A
+
+	To add a number to 0 ...enter a:
+	To negate 0 ...enter b:
+	To find the difference between 0 and another number...enter c:
+	To find the factorial of 0 ...enter d:
+	To square 0 ...enter e:
+	To cube 0 ...enter f:
+	To find out if 0 is a multiple of 3...enter g:
+	To divide 0 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 0 is even!
+Class type is now A
+
+	To add a number to 0 ...enter a:
+	To negate 0 ...enter b:
+	To find the difference between 0 and another number...enter c:
+	To find the factorial of 0 ...enter d:
+	To square 0 ...enter e:
+	To cube 0 ...enter f:
+	To find out if 0 is a multiple of 3...enter g:
+	To divide 0 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
+number 0 is even!
+Class type is now A
+
+	To add a number to 0 ...enter a:
+	To negate 0 ...enter b:
+	To find the difference between 0 and another number...enter c:
+	To find the factorial of 0 ...enter d:
+	To square 0 ...enter e:
+	To cube 0 ...enter f:
+	To find out if 0 is a multiple of 3...enter g:
+	To divide 0 by 8...enter h:
+	To get a new number...enter j:
+	To quit...enter q:
+
diff --git a/src/tests/codegen/atoi.cl b/src/tests/codegen/atoi.cl
new file mode 100644
index 000000000..f4125a2f8
--- /dev/null
+++ b/src/tests/codegen/atoi.cl
@@ -0,0 +1,121 @@
+(*
+   The class A2I provides integer-to-string and string-to-integer
+conversion routines.  To use these routines, either inherit them
+in the class where needed, have a dummy variable bound to
+something of type A2I, or simpl write (new A2I).method(argument).
+*)
+
+
+(*
+   c2i   Converts a 1-character string to an integer.  Aborts
+         if the string is not "0" through "9"
+*)
+class A2I {
+
+     c2i(char : String) : Int {
+	if char = "0" then 0 else
+	if char = "1" then 1 else
+	if char = "2" then 2 else
+        if char = "3" then 3 else
+        if char = "4" then 4 else
+        if char = "5" then 5 else
+        if char = "6" then 6 else
+        if char = "7" then 7 else
+        if char = "8" then 8 else
+        if char = "9" then 9 else
+        { abort(); 0; }  -- the 0 is needed to satisfy the typchecker
+        fi fi fi fi fi fi fi fi fi fi
+     };
+
+(*
+   i2c is the inverse of c2i.
+*)
+     i2c(i : Int) : String {
+	if i = 0 then "0" else
+	if i = 1 then "1" else
+	if i = 2 then "2" else
+	if i = 3 then "3" else
+	if i = 4 then "4" else
+	if i = 5 then "5" else
+	if i = 6 then "6" else
+	if i = 7 then "7" else
+	if i = 8 then "8" else
+	if i = 9 then "9" else
+	{ abort(); ""; }  -- the "" is needed to satisfy the typchecker
+        fi fi fi fi fi fi fi fi fi fi
+     };
+
+(*
+   a2i converts an ASCII string into an integer.  The empty string
+is converted to 0.  Signed and unsigned strings are handled.  The
+method aborts if the string does not represent an integer.  Very
+long strings of digits produce strange answers because of arithmetic 
+overflow.
+
+*)
+     a2i(s : String) : Int {
+        if s.length() = 0 then 0 else
+	if s.substr(0,1) = "-" then ~a2i_aux(s.substr(1,s.length()-1)) else
+        if s.substr(0,1) = "+" then a2i_aux(s.substr(1,s.length()-1)) else
+           a2i_aux(s)
+        fi fi fi
+     };
+
+(*
+  a2i_aux converts the usigned portion of the string.  As a programming
+example, this method is written iteratively.
+*)
+     a2i_aux(s : String) : Int {
+	(let int : Int <- 0 in	
+           {	
+               (let j : Int <- s.length() in
+	          (let i : Int <- 0 in
+		    while i < j loop
+			{
+			    int <- int * 10 + c2i(s.substr(i,1));
+			    i <- i + 1;
+			}
+		    pool
+		  )
+	       );
+              int;
+	    }
+        )
+     };
+
+(*
+    i2a converts an integer to a string.  Positive and negative 
+numbers are handled correctly.  
+*)
+    i2a(i : Int) : String {
+	if i = 0 then "0" else 
+        if 0 < i then i2a_aux(i) else
+          "-".concat(i2a_aux(i * ~1)) 
+        fi fi
+    };
+	
+(*
+    i2a_aux is an example using recursion.
+*)		
+    i2a_aux(i : Int) : String {
+        if i = 0 then "" else 
+	    (let next : Int <- i / 10 in
+		i2a_aux(next).concat(i2c(i - next * 10))
+	    )
+        fi
+    };
+
+};
+
+class Main inherits IO {
+  main () : Object { 
+      let a : Int <- (new A2I).a2i("678987"), 
+          b : String <- (new A2I).i2a(678987) in
+      { 
+        out_int(a) ;
+        out_string(" == ") ;
+        out_string(b) ;
+        out_string("\n"); 
+      } 
+  } ;
+} ;
diff --git a/src/tests/codegen/atoi_input.txt b/src/tests/codegen/atoi_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/atoi_output.txt b/src/tests/codegen/atoi_output.txt
new file mode 100644
index 000000000..51b815a48
--- /dev/null
+++ b/src/tests/codegen/atoi_output.txt
@@ -0,0 +1 @@
+678987 == 678987
diff --git a/src/tests/codegen/book_list.cl b/src/tests/codegen/book_list.cl
new file mode 100644
index 000000000..025ea1695
--- /dev/null
+++ b/src/tests/codegen/book_list.cl
@@ -0,0 +1,132 @@
+-- example of static and dynamic type differing for a dispatch
+
+Class Book inherits IO {
+    title : String;
+    author : String;
+
+    initBook(title_p : String, author_p : String) : Book {
+        {
+            title <- title_p;
+            author <- author_p;
+            self;
+        }
+    };
+
+    print() : Book {
+        {
+            out_string("title:      ").out_string(title).out_string("\n");
+            out_string("author:     ").out_string(author).out_string("\n");
+            self;
+        }
+    };
+};
+
+Class Article inherits Book {
+    per_title : String;
+
+    initArticle(title_p : String, author_p : String,
+		per_title_p : String) : Article {
+        {
+            initBook(title_p, author_p);
+            per_title <- per_title_p;
+            self;
+        }
+    };
+
+    print() : Book {
+        {
+	    self@Book.print();
+            out_string("periodical:  ").out_string(per_title).out_string("\n");
+            self;
+        }
+    };
+};
+
+Class BookList inherits IO { 
+    (* Since abort "returns" type Object, we have to add
+       an expression of type Bool here to satisfy the typechecker.
+       This code is unreachable, since abort() halts the program.
+    *)
+    isNil() : Bool { { abort(); true; } };
+    
+    cons(hd : Book) : Cons {
+        (let new_cell : Cons <- new Cons in
+            new_cell.init(hd,self)
+        )
+    };
+
+    (* Since abort "returns" type Object, we have to add
+       an expression of type Book here to satisfy the typechecker.
+       This code is unreachable, since abort() halts the program.
+    *)
+    car() : Book { { abort(); new Book; } };
+    
+    (* Since abort "returns" type Object, we have to add
+       an expression of type BookList here to satisfy the typechecker.
+       This code is unreachable, since abort() halts the program.
+    *)
+    cdr() : BookList { { abort(); new BookList; } };
+    
+    print_list() : Object { abort() };
+};
+
+Class Cons inherits BookList {
+    xcar : Book;  -- We keep the car and cdr in attributes.
+    xcdr : BookList; -- Because methods and features must have different names,
+    -- we use xcar and xcdr for the attributes and reserve
+    -- car and cdr for the features.
+    
+    isNil() : Bool { false };
+    
+    init(hd : Book, tl : BookList) : Cons {
+        {
+            xcar <- hd;
+            xcdr <- tl;
+            self;
+        }
+    };
+
+    car() : Book { xcar };
+
+    cdr() : BookList { xcdr };
+    
+    print_list() : Object {
+        {
+            case xcar.print() of
+                dummy : Book => out_string("- dynamic type was Book -\n");
+                dummy : Article => out_string("- dynamic type was Article -\n");
+            esac;
+            xcdr.print_list();
+        }
+    };
+};
+
+Class Nil inherits BookList {
+    isNil() : Bool { true };
+
+    print_list() : Object { true };
+};
+
+
+Class Main {
+
+    books : BookList;
+
+    main() : Object {
+        (let a_book : Book <-
+            (new Book).initBook("Compilers, Principles, Techniques, and Tools",
+                                "Aho, Sethi, and Ullman")
+        in
+            (let an_article : Article <-
+                (new Article).initArticle("The Top 100 CD_ROMs",
+                                          "Ulanoff",
+                                          "PC Magazine")
+            in
+                {
+                    books <- (new Nil).cons(a_book).cons(an_article);
+                    books.print_list();
+                }
+            )  -- end let an_article
+        )  -- end let a_book
+    };
+};
diff --git a/src/tests/codegen/book_list_input.txt b/src/tests/codegen/book_list_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/book_list_output.txt b/src/tests/codegen/book_list_output.txt
new file mode 100644
index 000000000..3408320b2
--- /dev/null
+++ b/src/tests/codegen/book_list_output.txt
@@ -0,0 +1,7 @@
+title:      The Top 100 CD_ROMs
+author:     Ulanoff
+periodical:  PC Magazine
+- dynamic type was Article -
+title:      Compilers, Principles, Techniques, and Tools
+author:     Aho, Sethi, and Ullman
+- dynamic type was Book -
diff --git a/src/tests/codegen/cells.cl b/src/tests/codegen/cells.cl
new file mode 100644
index 000000000..9fd6741bb
--- /dev/null
+++ b/src/tests/codegen/cells.cl
@@ -0,0 +1,97 @@
+(* models one-dimensional cellular automaton on a circle of finite radius
+   arrays are faked as Strings,
+   X's respresent live cells, dots represent dead cells,
+   no error checking is done *)
+class CellularAutomaton inherits IO {
+    population_map : String;
+   
+    init(map : String) : CellularAutomaton {
+        {
+            population_map <- map;
+            self;
+        }
+    };
+   
+    print() : CellularAutomaton {
+        {
+            out_string(population_map.concat("\n"));
+            self;
+        }
+    };
+   
+    num_cells() : Int {
+        population_map.length()
+    };
+   
+    cell(position : Int) : String {
+        population_map.substr(position, 1)
+    };
+   
+    cell_left_neighbor(position : Int) : String {
+        if position = 0 then
+            cell(num_cells() - 1)
+        else
+            cell(position - 1)
+        fi
+    };
+   
+    cell_right_neighbor(position : Int) : String {
+        if position = num_cells() - 1 then
+            cell(0)
+        else
+            cell(position + 1)
+        fi
+    };
+   
+    (* a cell will live if exactly 1 of itself and it's immediate
+       neighbors are alive *)
+    cell_at_next_evolution(position : Int) : String {
+        if (if cell(position) = "X" then 1 else 0 fi
+            + if cell_left_neighbor(position) = "X" then 1 else 0 fi
+            + if cell_right_neighbor(position) = "X" then 1 else 0 fi
+            = 1)
+        then
+            "X"
+        else
+            "."
+        fi
+    };
+   
+    evolve() : CellularAutomaton {
+        (let position : Int in
+        (let num : Int <- num_cells() in
+        (let temp : String in
+            {
+                while position < num loop
+                    {
+                        temp <- temp.concat(cell_at_next_evolution(position));
+                        position <- position + 1;
+                    }
+                pool;
+                population_map <- temp;
+                self;
+            }
+        ) ) )
+    };
+};
+
+class Main {
+    cells : CellularAutomaton;
+   
+    main() : Main {
+        {
+            cells <- (new CellularAutomaton).init("         X         ");
+            cells.print();
+            (let countdown : Int <- 20 in
+                while 0 < countdown loop
+                    {
+                        cells.evolve();
+                        cells.print();
+                        countdown <- countdown - 1;
+                    }
+                pool
+            );
+            self;
+        }
+    };
+};
diff --git a/src/tests/codegen/cells_input.txt b/src/tests/codegen/cells_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/cells_output.txt b/src/tests/codegen/cells_output.txt
new file mode 100644
index 000000000..6304902cc
--- /dev/null
+++ b/src/tests/codegen/cells_output.txt
@@ -0,0 +1,21 @@
+         X         
+........XXX........
+.......X...X.......
+......XXX.XXX......
+.....X.......X.....
+....XXX.....XXX....
+...X...X...X...X...
+..XXX.XXX.XXX.XXX..
+.X...............X.
+XXX.............XXX
+...X...........X...
+..XXX.........XXX..
+.X...X.......X...X.
+XXX.XXX.....XXX.XXX
+.......X...X.......
+......XXX.XXX......
+.....X.......X.....
+....XXX.....XXX....
+...X...X...X...X...
+..XXX.XXX.XXX.XXX..
+.X...............X.
diff --git a/src/tests/codegen/complex.cl b/src/tests/codegen/complex.cl
new file mode 100644
index 000000000..0b7aa44e9
--- /dev/null
+++ b/src/tests/codegen/complex.cl
@@ -0,0 +1,52 @@
+class Main inherits IO {
+    main() : IO {
+	(let c : Complex <- (new Complex).init(1, 1) in
+	    if c.reflect_X().reflect_Y() = c.reflect_0()
+	    then out_string("=)\n")
+	    else out_string("=(\n")
+	    fi
+	)
+    };
+};
+
+class Complex inherits IO {
+    x : Int;
+    y : Int;
+
+    init(a : Int, b : Int) : Complex {
+	{
+	    x = a;
+	    y = b;
+	    self;
+	}
+    };
+
+    print() : Object {
+	if y = 0
+	then out_int(x)
+	else out_int(x).out_string("+").out_int(y).out_string("I")
+	fi
+    };
+
+    reflect_0() : Complex {
+	{
+	    x = ~x;
+	    y = ~y;
+	    self;
+	}
+    };
+
+    reflect_X() : Complex {
+	{
+	    y = ~y;
+	    self;
+	}
+    };
+
+    reflect_Y() : Complex {
+	{
+	    x = ~x;
+	    self;
+	}
+    };
+};
diff --git a/src/tests/codegen/complex_input.txt b/src/tests/codegen/complex_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/complex_output.txt b/src/tests/codegen/complex_output.txt
new file mode 100644
index 000000000..18b77c1fc
--- /dev/null
+++ b/src/tests/codegen/complex_output.txt
@@ -0,0 +1 @@
+=)
diff --git a/src/tests/codegen/fib.cl b/src/tests/codegen/fib.cl
new file mode 100644
index 000000000..08ceaede8
--- /dev/null
+++ b/src/tests/codegen/fib.cl
@@ -0,0 +1,29 @@
+class Main inherits IO {
+	-- the class has features. Only methods in this case.
+	main(): Object {
+		{
+			out_string("Enter n to find nth fibonacci number!\n");
+			out_int(fib(in_int()));
+			out_string("\n");
+		}
+	};
+
+	fib(i : Int) : Int {	-- list of formals. And the return type of the method.
+			let a : Int <- 1,
+					b : Int <- 0,
+					c : Int <- 0
+			in
+			{
+			while (not (i = 0)) loop	-- expressions are nested.
+			{
+				c <- a + b;
+				i <- i - 1;
+				b <- a;
+				a <- c;
+			}
+			pool;
+			c;
+			}
+	};
+
+};
diff --git a/src/tests/codegen/fib_input.txt b/src/tests/codegen/fib_input.txt
new file mode 100644
index 000000000..f599e28b8
--- /dev/null
+++ b/src/tests/codegen/fib_input.txt
@@ -0,0 +1 @@
+10
diff --git a/src/tests/codegen/fib_output.txt b/src/tests/codegen/fib_output.txt
new file mode 100644
index 000000000..d402da6af
--- /dev/null
+++ b/src/tests/codegen/fib_output.txt
@@ -0,0 +1,2 @@
+Enter n to find nth fibonacci number!
+89
diff --git a/src/tests/codegen/graph.cl b/src/tests/codegen/graph.cl
new file mode 100644
index 000000000..8e511358c
--- /dev/null
+++ b/src/tests/codegen/graph.cl
@@ -0,0 +1,381 @@
+(*
+ *   Cool program reading descriptions of weighted directed graphs
+ *   from stdin. It builds up a graph objects with a list of vertices
+ *   and a list of edges. Every vertice has a list of outgoing edges.
+ *
+ *  INPUT FORMAT
+ *      Every line has the form		vertice successor*
+ *      Where vertice is an int, and successor is   vertice,weight
+ *
+ *      An empty line or EOF terminates the input.
+ *
+ *   The list of vertices and the edge list is printed out by the Main
+ *   class. 
+ *
+ *  TEST
+ *     Once compiled, the file g1.graph can be fed to the program.
+ *     The output should look like this:
+
+nautilus.CS.Berkeley.EDU 53# spim -file graph.s <g1.graph 
+SPIM Version 5.4 of Jan. 17, 1994
+Copyright 1990-1994 by James R. Larus (larus@cs.wisc.edu).
+All Rights Reserved.
+See the file README a full copyright notice.
+Loaded: /home/n/cs164/lib/trap.handler
+5 (5,5)5 (5,4)4 (5,3)3 (5,2)2 (5,1)1
+4 (4,5)100 (4,3)55
+3 (3,2)10
+2 (2,1)150 (2,3)200
+1 (1,2)100
+
+ (5,5)5 (5,4)4 (5,3)3 (5,2)2 (5,1)1 (4,5)100 (4,3)55 (3,2)10 (2,1)150 (2,3)200 (1,2)100
+COOL program successfully executed
+
+ *)
+
+
+
+class Graph {
+
+   vertices : VList <- new VList;
+   edges    : EList <- new EList;
+
+   add_vertice(v : Vertice) : Object { {
+      edges <- v.outgoing().append(edges);
+      vertices <- vertices.cons(v);
+   } };
+
+   print_E() : Object { edges.print() };
+   print_V() : Object { vertices.print() };
+
+};
+
+class Vertice inherits IO { 
+
+   num  : Int;
+   out  : EList <- new EList;
+
+   outgoing() : EList { out };
+
+   number() : Int { num };
+
+   init(n : Int) : Vertice {
+      {
+         num <- n;
+         self;
+      }
+   };
+
+
+   add_out(s : Edge) : Vertice {
+      {
+	 out <- out.cons(s);
+         self;
+      }
+   };
+
+   print() : Object {
+      {
+         out_int(num);
+	 out.print();
+      }
+   };
+
+};
+
+class Edge inherits IO {
+
+   from   : Int;
+   to     : Int;
+   weight : Int;
+
+   init(f : Int, t : Int, w : Int) : Edge {
+      {
+         from <- f;
+	 to <- t;
+	 weight <- w;
+	 self;
+      }
+   };
+
+   print() : Object {
+      {
+         out_string(" (");
+	 out_int(from);
+	 out_string(",");
+	 out_int(to);
+	 out_string(")");
+	 out_int(weight);
+      }
+   };
+
+};
+
+
+
+class EList inherits IO {
+   -- Define operations on empty lists of Edges.
+
+   car : Edge;
+
+   isNil() : Bool { true };
+
+   head()  : Edge { { abort(); car; } };
+
+   tail()  : EList { { abort(); self; } };
+
+   -- When we cons and element onto the empty list we get a non-empty
+   -- list. The (new Cons) expression creates a new list cell of class
+   -- Cons, which is initialized by a dispatch to init().
+   -- The result of init() is an element of class Cons, but it
+   -- conforms to the return type List, because Cons is a subclass of
+   -- List.
+
+   cons(e : Edge) : EList {
+      (new ECons).init(e, self)
+   };
+
+   append(l : EList) : EList {
+     if self.isNil() then l
+     else tail().append(l).cons(head())
+     fi
+   };
+
+   print() : Object {
+     out_string("\n")
+   };
+
+};
+
+
+(*
+ *  Cons inherits all operations from List. We can reuse only the cons
+ *  method though, because adding an element to the front of an emtpy
+ *  list is the same as adding it to the front of a non empty
+ *  list. All other methods have to be redefined, since the behaviour
+ *  for them is different from the empty list.
+ *
+ *  Cons needs an extra attribute to hold the rest of the list.
+ *
+ *  The init() method is used by the cons() method to initialize the
+ *  cell.
+ *)
+
+class ECons inherits EList {
+
+   cdr : EList;	-- The rest of the list
+
+   isNil() : Bool { false };
+
+   head()  : Edge { car };
+
+   tail()  : EList { cdr };
+
+   init(e : Edge, rest : EList) : EList {
+      {
+	 car <- e;
+	 cdr <- rest;
+	 self;
+      }
+   };
+
+   print() : Object {
+     {
+       car.print();
+       cdr.print();
+     } 
+   };
+
+};
+
+
+
+
+class VList inherits IO {
+   -- Define operations on empty lists of vertices.
+
+   car : Vertice;
+
+   isNil() : Bool { true };
+
+   head()  : Vertice { { abort(); car; } };
+
+   tail()  : VList { { abort(); self; } };
+
+   -- When we cons and element onto the empty list we get a non-empty
+   -- list. The (new Cons) expression creates a new list cell of class
+   -- ECons, which is initialized by a dispatch to init().
+   -- The result of init() is an element of class Cons, but it
+   -- conforms to the return type List, because Cons is a subclass of
+   -- List.
+
+   cons(v : Vertice) : VList {
+      (new VCons).init(v, self)
+   };
+
+   print() : Object { out_string("\n") };
+
+};
+
+
+class VCons inherits VList {
+
+   cdr : VList;	-- The rest of the list
+
+   isNil() : Bool { false };
+
+   head()  : Vertice { car };
+
+   tail()  : VList { cdr };
+
+   init(v : Vertice, rest : VList) : VList {
+      {
+	 car <- v;
+	 cdr <- rest;
+	 self;
+      }
+   };
+
+   print() : Object {
+     {
+       car.print();
+       cdr.print();
+     } 
+   };
+
+};
+
+
+class Parse inherits IO {
+
+
+   boolop : BoolOp <- new BoolOp;
+
+   -- Reads the input and parses the fields
+
+   read_input() : Graph {
+
+      (let g : Graph <- new Graph in {
+         (let line : String <- in_string() in
+            while (boolop.and(not line="\n", not line="")) loop {
+		-- out_string(line);
+		-- out_string("\n");
+		g.add_vertice(parse_line(line));
+		line <- in_string();
+	    } pool
+         );
+	 g;
+      } )
+   };
+
+
+   parse_line(s : String) : Vertice {
+      (let v : Vertice <- (new Vertice).init(a2i(s)) in {
+	 while (not rest.length() = 0) loop {
+	       -- out_string(rest);
+	       -- out_string("\n");
+	       (let succ : Int <- a2i(rest) in (let
+	           weight : Int <- a2i(rest)
+               in
+	          v.add_out(new Edge.init(v.number(), 
+                                          succ,
+					  weight))
+	       ) );
+	 } pool;
+	 v;
+         }
+      )
+   };
+
+     c2i(char : String) : Int {
+	if char = "0" then 0 else
+	if char = "1" then 1 else
+	if char = "2" then 2 else
+        if char = "3" then 3 else
+        if char = "4" then 4 else
+        if char = "5" then 5 else
+        if char = "6" then 6 else
+        if char = "7" then 7 else
+        if char = "8" then 8 else
+        if char = "9" then 9 else
+        { abort(); 0; }  -- the 0 is needed to satisfy the typchecker
+        fi fi fi fi fi fi fi fi fi fi
+     };
+
+     rest : String;
+
+     a2i(s : String) : Int {
+        if s.length() = 0 then 0 else
+	if s.substr(0,1) = "-" then ~a2i_aux(s.substr(1,s.length()-1)) else
+        if s.substr(0,1) = " " then a2i(s.substr(1,s.length()-1)) else
+           a2i_aux(s)
+        fi fi fi
+     };
+
+(*
+  a2i_aux converts the usigned portion of the string.  As a programming
+example, this method is written iteratively.
+  The conversion stops at a space or comma.
+  As a side effect, r is set to the remaining string (without the comma).
+*)
+     a2i_aux(s : String) : Int {
+	(let int : Int <- 0 in	
+           {	
+               (let j : Int <- s.length() in
+	          (let i : Int <- 0 in
+		    while i < j loop
+			(let c : String <- s.substr(i,1) in
+			    if (c = " ") then
+			       {
+				  rest <- s.substr(i+1,s.length()-i-1);
+				  i <- j;
+			       }
+			    else if (c = ",") then
+		               {
+				  rest <- s.substr(i+1, s.length()-i-1);
+				  i <- j;
+		               }
+			    else
+			       {
+				 int <- int * 10 + c2i(s.substr(i,1));
+				 i <- i + 1;
+				 if i=j then rest <- "" else "" fi;
+			       }
+			    fi fi
+			)
+		    pool
+		  )
+	       );
+              int;
+	    }
+        )
+     };
+
+};
+
+
+class Main inherits Parse {
+
+   g : Graph <- read_input();
+
+   main() : Object {
+      {
+	 g.print_V();
+         g.print_E();
+      }
+   };
+
+};
+
+class BoolOp {
+
+  and(b1 : Bool, b2 : Bool) : Bool {
+     if b1 then b2 else false fi
+  };
+
+
+  or(b1 : Bool, b2 : Bool) : Bool {
+     if b1 then true else b2 fi
+  };
+
+};
diff --git a/src/tests/codegen/graph_input.txt b/src/tests/codegen/graph_input.txt
new file mode 100644
index 000000000..b67d90210
--- /dev/null
+++ b/src/tests/codegen/graph_input.txt
@@ -0,0 +1,5 @@
+1   2,100
+2   3,200 1,150
+3   2,10
+4   3,55 5,100
+5   1,1 2,2 3,3 4,4 5,5
diff --git a/src/tests/codegen/graph_output.txt b/src/tests/codegen/graph_output.txt
new file mode 100644
index 000000000..ef446522c
--- /dev/null
+++ b/src/tests/codegen/graph_output.txt
@@ -0,0 +1,7 @@
+5 (5,5)5 (5,4)4 (5,3)3 (5,2)2 (5,1)1
+4 (4,5)100 (4,3)55
+3 (3,2)10
+2 (2,1)150 (2,3)200
+1 (1,2)100
+
+ (5,5)5 (5,4)4 (5,3)3 (5,2)2 (5,1)1 (4,5)100 (4,3)55 (3,2)10 (2,1)150 (2,3)200 (1,2)100
diff --git a/src/tests/codegen/hairyscary.cl b/src/tests/codegen/hairyscary.cl
new file mode 100644
index 000000000..ec38a7766
--- /dev/null
+++ b/src/tests/codegen/hairyscary.cl
@@ -0,0 +1,67 @@
+(* hairy  . . .*)
+
+class Foo inherits Bazz {
+     a : Razz <- case self of
+		      n : Razz => (new Bar);
+		      n : Foo => (new Razz);
+		      n : Bar => n;
+   	         esac;
+
+     b : Int <- a.doh() + g.doh() + doh() + printh();
+
+     doh() : Int { (let i : Int <- h in { h <- h + 2; i; } ) };
+
+};
+
+class Bar inherits Razz {
+
+     c : Int <- doh();
+
+     d : Object <- printh();
+};
+
+
+class Razz inherits Foo {
+
+     e : Bar <- case self of
+		  n : Razz => (new Bar);
+		  n : Bar => n;
+		esac;
+
+     f : Int <- a@Bazz.doh() + g.doh() + e.doh() + doh() + printh();
+
+};
+
+class Bazz inherits IO {
+
+     h : Int <- 1;
+
+     g : Foo  <- case self of
+		     	n : Bazz => (new Foo);
+		     	n : Razz => (new Bar);
+			n : Foo  => (new Razz);
+			n : Bar => n;
+		  esac;
+
+     i : Object <- printh();
+
+     printh() : Int { { out_int(h); 0; } };
+
+     doh() : Int { (let i: Int <- h in { h <- h + 1; i; } ) };
+};
+
+(* scary . . . *)
+class Main {
+  a : Bazz <- new Bazz;
+  b : Foo <- new Foo;
+  c : Razz <- new Razz;
+  d : Bar <- new Bar;
+
+  main(): String { "do nothing" };
+
+};
+
+
+
+
+
diff --git a/src/tests/codegen/hairyscary_input.txt b/src/tests/codegen/hairyscary_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/hairyscary_output.txt b/src/tests/codegen/hairyscary_output.txt
new file mode 100644
index 000000000..8985c22f2
--- /dev/null
+++ b/src/tests/codegen/hairyscary_output.txt
@@ -0,0 +1 @@
+17141611714163171416511714161171416317141653117141611714163171416511714161171416317141653171416117141631714165171416
\ No newline at end of file
diff --git a/src/tests/codegen/hello_world.cl b/src/tests/codegen/hello_world.cl
new file mode 100644
index 000000000..0c818f908
--- /dev/null
+++ b/src/tests/codegen/hello_world.cl
@@ -0,0 +1,5 @@
+class Main inherits IO {
+   main(): IO {
+	out_string("Hello, World.\n")
+   };
+};
diff --git a/src/tests/codegen/hello_world_input.txt b/src/tests/codegen/hello_world_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/hello_world_output.txt b/src/tests/codegen/hello_world_output.txt
new file mode 100644
index 000000000..349db2bfe
--- /dev/null
+++ b/src/tests/codegen/hello_world_output.txt
@@ -0,0 +1 @@
+Hello, World.
diff --git a/src/tests/codegen/io.cl b/src/tests/codegen/io.cl
new file mode 100644
index 000000000..7f0de869e
--- /dev/null
+++ b/src/tests/codegen/io.cl
@@ -0,0 +1,103 @@
+(*
+ *  The IO class is predefined and has 4 methods:
+ *
+ *    out_string(s : String) : SELF_TYPE
+ *    out_int(i : Int) : SELF_TYPE
+ *    in_string() : String
+ *    in_int() : Int
+ *
+ *    The out operations print their argument to the terminal. The
+ *    in_string method reads an entire line from the terminal and returns a
+ *    string not containing the new line. The in_int method also reads
+ *    an entire line from the terminal and returns the integer
+ *    corresponding to the first non blank word on the line. If that
+ *    word is not an integer, it returns 0.
+ *
+ *
+ *  Because our language is object oriented, we need an object of type
+ *  IO in order to call any of these methods.
+ *
+ *  There are basically two ways of getting access to IO in a class C.
+ *
+ *   1) Define C to Inherit from IO. This way the IO methods become
+ *      methods of C, and they can be called using the abbreviated
+ *      dispatch, i.e.
+ *
+ *      class C inherits IO is
+ *          ...
+ *          out_string("Hello world\n")
+ *          ...
+ *      end;
+ *
+ *   2) If your class C does not directly or indirectly inherit from
+ *      IO, the best way to access IO is through an initialized
+ *      attribute of type IO. 
+ *
+ *      class C inherits Foo is
+ *         io : IO <- new IO;
+ *         ...
+ *             io.out_string("Hello world\n");
+ *         ...
+ *      end;
+ *
+ *  Approach 1) is most often used, in particular when you need IO
+ *  functions in the Main class.
+ *
+ *)
+
+
+class A {
+
+   -- Let's assume that we don't want A to not inherit from IO.
+
+   io : IO <- new IO;
+
+   out_a() : Object { io.out_string("A: Hello world\n") };
+
+};
+
+
+class B inherits A {
+
+   -- B does not have to an extra attribute, since it inherits io from A.
+
+   out_b() : Object { io.out_string("B: Hello world\n") };
+
+};
+
+
+class C inherits IO {
+
+   -- Now the IO methods are part of C.
+
+   out_c() : Object { out_string("C: Hello world\n") };
+
+   -- Note that out_string(...) is just a shorthand for self.out_string(...)
+
+};
+
+
+class D inherits C {
+
+   -- Inherits IO methods from C.
+
+   out_d() : Object { out_string("D: Hello world\n") };
+
+};
+
+
+class Main inherits IO {
+
+   -- Same case as class C.
+
+   main() : Object {
+      {
+	 (new A).out_a();
+	 (new B).out_b();
+	 (new C).out_c();
+	 (new D).out_d();
+	 out_string("Done.\n");
+      }
+   };
+
+};
diff --git a/src/tests/codegen/io_input.txt b/src/tests/codegen/io_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/io_output.txt b/src/tests/codegen/io_output.txt
new file mode 100644
index 000000000..f846f596d
--- /dev/null
+++ b/src/tests/codegen/io_output.txt
@@ -0,0 +1,5 @@
+A: Hello world
+B: Hello world
+C: Hello world
+D: Hello world
+Done.
diff --git a/src/tests/codegen/life.cl b/src/tests/codegen/life.cl
new file mode 100644
index 000000000..b83d97957
--- /dev/null
+++ b/src/tests/codegen/life.cl
@@ -0,0 +1,436 @@
+(* The Game of Life 
+   Tendo Kayiira, Summer '95
+   With code taken from /private/cool/class/examples/cells.cl
+
+ This introduction was taken off the internet. It gives a brief 
+ description of the Game Of Life. It also gives the rules by which 
+ this particular game follows.
+
+	Introduction
+
+   John Conway's Game of Life is a mathematical amusement, but it 
+   is also much more: an insight into how a system of simple 
+   cellualar automata can create complex, odd, and often aesthetically 
+   pleasing patterns. It is played on a cartesian grid of cells
+   which are either 'on' or 'off' The game gets it's name from the 
+   similarity between the behaviour of these cells and the behaviour 
+   of living organisms.
+
+ The Rules
+
+  The playfield is a cartesian grid of arbitrary size. Each cell in 
+  this grid can be in an 'on' state or an 'off' state. On each 'turn' 
+  (called a generation,) the state of each cell changes simultaneously 
+  depending on it's state and the state of all cells adjacent to it.
+
+   For 'on' cells, 
+      If the cell has 0 or 1 neighbours which are 'on', the cell turns 
+        'off'. ('dies of loneliness') 
+      If the cell has 2 or 3 neighbours which are 'on', the cell stays 
+        'on'. (nothing happens to that cell) 
+      If the cell has 4, 5, 6, 7, 8, or 9 neighbours which are 'on', 
+        the cell turns 'off'. ('dies of overcrowding') 
+
+   For 'off' cells, 
+      If the cell has 0, 1, 2, 4, 5, 6, 7, 8, or 9 neighbours which 
+        are 'on', the cell stays 'off'. (nothing happens to that cell) 
+      If the cell has 3 neighbours which are 'on', the cell turns 
+        'on'. (3 neighbouring 'alive' cells 'give birth' to a fourth.) 
+
+   Repeat for as many generations as desired. 
+
+ *)
+ 
+
+class Board inherits IO { 
+ 
+ rows : Int;
+ columns : Int;
+ board_size : Int;
+
+ size_of_board(initial : String) : Int {
+   initial.length()
+ };
+
+ board_init(start : String) : Board {
+   (let size :Int  <- size_of_board(start) in
+    {
+	if size = 15 then
+	 {
+	  rows <- 3;
+	  columns <- 5;
+	  board_size <- size;
+	 }
+	else if size = 16 then
+	  {
+	  rows <- 4;
+	  columns <- 4;
+	  board_size <- size;
+	 }
+	else if size = 20 then
+	 {
+	  rows <- 4;
+	  columns <- 5;
+	  board_size <- size;
+	 }
+	else if size = 21 then
+	 {
+	  rows <- 3;
+	  columns <- 7;
+	  board_size <- size;
+	 }
+	else if size = 25 then
+	 {
+	  rows <- 5;
+	  columns <- 5;
+	  board_size <- size;
+	 }
+	else if size = 28 then
+	 {
+	  rows <- 7;
+	  columns <- 4;
+	  board_size <- size;
+	 }
+	else 	-- If none of the above fit, then just give 
+	 {  -- the configuration of the most common board
+	  rows <- 5;
+	  columns <- 5;
+	  board_size <- size;
+	 }
+	fi fi fi fi fi fi;
+	self;
+    }
+   )
+ };
+
+};
+
+
+
+class CellularAutomaton inherits Board {
+    population_map : String;
+   
+    init(map : String) : CellularAutomaton {
+        {
+            population_map <- map;
+	    board_init(map);
+            self;
+        }
+    };
+
+
+
+   
+    print() : CellularAutomaton {
+        
+	(let i : Int <- 0 in
+	(let num : Int <- board_size in
+	{
+ 	out_string("\n");
+	 while i < num loop
+           {
+	    out_string(population_map.substr(i,columns));
+	    out_string("\n"); 
+	    i <- i + columns;
+	   }
+	 pool;
+ 	out_string("\n");
+	self;
+	}
+	) ) 
+    };
+   
+    num_cells() : Int {
+        population_map.length()
+    };
+   
+    cell(position : Int) : String {
+	if board_size - 1 < position then
+		" "
+	else 
+        	population_map.substr(position, 1)
+	fi
+    };
+   
+ north(position : Int): String {
+	if (position - columns) < 0 then
+	      " "	                       
+	else
+	   cell(position - columns)
+	fi
+ };
+
+ south(position : Int): String {
+	if board_size < (position + columns) then
+	      " "                     
+	else
+	   cell(position + columns)
+	fi
+ };
+
+ east(position : Int): String {
+	if (((position + 1) /columns ) * columns) = (position + 1) then
+	      " "                
+	else
+	   cell(position + 1)
+	fi 
+ };
+
+ west(position : Int): String {
+	if position = 0 then
+	      " "
+	else 
+	   if ((position / columns) * columns) = position then
+	      " "
+	   else
+	      cell(position - 1)
+	fi fi
+ };
+
+ northwest(position : Int): String {
+	if (position - columns) < 0 then
+	      " "	                       
+	else  if ((position / columns) * columns) = position then
+	      " "
+	      else
+		north(position - 1)
+	fi fi
+ };
+
+ northeast(position : Int): String {
+	if (position - columns) < 0 then
+	      " "	
+	else if (((position + 1) /columns ) * columns) = (position + 1) then
+	      " "     
+	     else
+	       north(position + 1)
+	fi fi
+ };
+
+ southeast(position : Int): String {
+	if board_size < (position + columns) then
+	      " "                     
+	else if (((position + 1) /columns ) * columns) = (position + 1) then
+	       " "                
+	     else
+	       south(position + 1)
+	fi fi
+ };
+
+ southwest(position : Int): String {
+	if board_size < (position + columns) then
+	      " "                     
+	else  if ((position / columns) * columns) = position then
+	      " "
+	      else
+	       south(position - 1)
+	fi fi
+ };
+
+ neighbors(position: Int): Int { 
+ 	{
+	     if north(position) = "X" then 1 else 0 fi
+	     + if south(position) = "X" then 1 else 0 fi
+ 	     + if east(position) = "X" then 1 else 0 fi
+ 	     + if west(position) = "X" then 1 else 0 fi
+	     + if northeast(position) = "X" then 1 else 0 fi
+	     + if northwest(position) = "X" then 1 else 0 fi
+ 	     + if southeast(position) = "X" then 1 else 0 fi
+	     + if southwest(position) = "X" then 1 else 0 fi;
+	 }
+ };
+
+ 
+(* A cell will live if 2 or 3 of it's neighbors are alive. It dies 
+   otherwise. A cell is born if only 3 of it's neighbors are alive. *)
+    
+    cell_at_next_evolution(position : Int) : String {
+
+	if neighbors(position) = 3 then
+		"X"
+	else
+	   if neighbors(position) = 2 then
+		if cell(position) = "X" then
+			"X"
+		else
+			"-"
+	        fi
+	   else
+		"-"
+	fi fi
+    };
+  
+
+    evolve() : CellularAutomaton {
+        (let position : Int <- 0 in
+        (let num : Int <- num_cells() in
+        (let temp : String in
+            {
+                while position < num loop
+                    {
+                        temp <- temp.concat(cell_at_next_evolution(position));
+                        position <- position + 1;
+                    }
+                pool;
+                population_map <- temp;
+                self;
+            }
+        ) ) )
+    };
+
+(* This is where the background pattern is detremined by the user. More 
+   patterns can be added as long as whoever adds keeps the board either
+   3x5, 4x5, 5x5, 3x7, 7x4, 4x4 with the row first then column. *) 
+ option(): String {
+ {
+  (let num : Int in
+   {
+   out_string("\nPlease chose a number:\n");
+   out_string("\t1: A cross\n"); 
+   out_string("\t2: A slash from the upper left to lower right\n");
+   out_string("\t3: A slash from the upper right to lower left\n"); 
+   out_string("\t4: An X\n"); 
+   out_string("\t5: A greater than sign \n"); 
+   out_string("\t6: A less than sign\n"); 
+   out_string("\t7: Two greater than signs\n"); 
+   out_string("\t8: Two less than signs\n"); 
+   out_string("\t9: A 'V'\n"); 
+   out_string("\t10: An inverse 'V'\n"); 
+   out_string("\t11: Numbers 9 and 10 combined\n"); 
+   out_string("\t12: A full grid\n"); 
+   out_string("\t13: A 'T'\n");
+   out_string("\t14: A plus '+'\n");
+   out_string("\t15: A 'W'\n");
+   out_string("\t16: An 'M'\n");
+   out_string("\t17: An 'E'\n");
+   out_string("\t18: A '3'\n");
+   out_string("\t19: An 'O'\n");
+   out_string("\t20: An '8'\n");
+   out_string("\t21: An 'S'\n");
+   out_string("Your choice => ");
+   num <- in_int();
+   out_string("\n");
+   if num = 1 then
+    	" XX  XXXX XXXX  XX  "
+   else if num = 2 then
+    	"    X   X   X   X   X    "
+   else if num = 3 then
+    	"X     X     X     X     X"
+   else if num = 4 then
+	"X   X X X   X   X X X   X"
+   else if num = 5 then
+	"X     X     X   X   X    "
+   else if num = 6 then
+	"    X   X   X     X     X"
+   else if num = 7 then
+	"X  X  X  XX  X      "
+   else if num = 8 then
+	" X  XX  X  X  X     "
+   else if num = 9 then
+	"X   X X X   X  "
+   else if num = 10 then
+	"  X   X X X   X"
+   else if num = 11 then
+	"X X X X X X X X"
+   else if num = 12 then
+	"XXXXXXXXXXXXXXXXXXXXXXXXX"
+   else if num = 13 then
+    	"XXXXX  X    X    X    X  "
+   else if num = 14 then
+    	"  X    X  XXXXX  X    X  "
+   else if num = 15 then
+    	"X     X X X X   X X  "
+   else if num = 16 then
+    	"  X X   X X X X     X"
+   else if num = 17 then
+	"XXXXX   X   XXXXX   X   XXXX"
+   else if num = 18 then
+	"XXX    X   X  X    X   XXXX "
+   else if num = 19 then
+	" XX X  XX  X XX "
+   else if num = 20 then
+	" XX X  XX  X XX X  XX  X XX "
+   else if num = 21 then
+	" XXXX   X    XX    X   XXXX "
+   else
+	"                         "
+  fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi fi;
+    }
+   );
+ }
+ };
+
+
+
+
+ prompt() : Bool { 
+ {
+  (let ans : String in
+   {
+   out_string("Would you like to continue with the next generation? \n");
+   out_string("Please use lowercase y or n for your answer [y]: ");
+   ans <- in_string();
+   out_string("\n");
+   if ans = "n" then 
+	false
+   else
+	true
+   fi;
+   }
+  );
+ }
+ };
+
+
+ prompt2() : Bool { 
+  (let ans : String in
+   {
+   out_string("\n\n");
+   out_string("Would you like to choose a background pattern? \n");
+   out_string("Please use lowercase y or n for your answer [n]: ");
+   ans <- in_string();
+   if ans = "y" then 
+	true
+   else
+	false
+   fi;
+   }
+  )
+ };
+
+
+};
+
+class Main inherits CellularAutomaton {
+    cells : CellularAutomaton;
+   
+    main() : Main {
+        {
+	 (let continue : Bool  in
+	  (let choice : String  in
+	   {
+	   out_string("Welcome to the Game of Life.\n");
+	   out_string("There are many initial states to choose from. \n");
+	   while prompt2() loop
+	    {
+	     continue <- true;
+	     choice <- option();
+	     cells <- (new CellularAutomaton).init(choice);
+	     cells.print();
+             while continue loop
+		if prompt() then
+                    {
+                        cells.evolve();
+                        cells.print();
+                    }
+		else
+		    continue <- false
+	      fi 
+                pool;
+            }
+            pool;
+	    self;
+      }  ) ); }
+    };
+};
+
diff --git a/src/tests/codegen/life_input.txt b/src/tests/codegen/life_input.txt
new file mode 100644
index 000000000..07e016726
--- /dev/null
+++ b/src/tests/codegen/life_input.txt
@@ -0,0 +1,66 @@
+y
+1
+n
+y
+2
+n
+y
+3
+n
+y
+4
+n
+y
+5
+n
+y
+6
+n
+y
+7
+n
+y
+8
+n
+y
+9
+n
+y
+10
+n
+y
+11
+n
+y
+12
+n
+y
+13
+n
+y
+14
+n
+y
+15
+n
+y
+16
+n
+y
+17
+n
+y
+18
+n
+y
+19
+n
+y
+20
+n
+y
+21
+y
+y
+n
+n
\ No newline at end of file
diff --git a/src/tests/codegen/life_output.txt b/src/tests/codegen/life_output.txt
new file mode 100644
index 000000000..5a9b9f73d
--- /dev/null
+++ b/src/tests/codegen/life_output.txt
@@ -0,0 +1,778 @@
+Welcome to the Game of Life.
+There are many initial states to choose from. 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+ XX  
+XXXX 
+XXXX 
+ XX  
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+    X
+   X 
+  X  
+ X   
+X    
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X    
+ X   
+  X  
+   X 
+    X
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X   X
+ X X 
+  X  
+ X X 
+X   X
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X    
+ X   
+  X  
+ X   
+X    
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+    X
+   X 
+  X  
+   X 
+    X
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X  X 
+ X  X
+X  X 
+     
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+ X  X
+X  X 
+ X  X
+     
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X   X
+ X X 
+  X  
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+  X  
+ X X 
+X   X
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X X X
+ X X 
+X X X
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+XXXXX
+XXXXX
+XXXXX
+XXXXX
+XXXXX
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+XXXXX
+  X  
+  X  
+  X  
+  X  
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+  X  
+  X  
+XXXXX
+  X  
+  X  
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+X     X
+ X X X 
+  X X  
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+  X X  
+ X X X 
+X     X
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+XXXX
+X   
+X   
+XXXX
+X   
+X   
+XXXX
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+XXX 
+   X
+   X
+  X 
+   X
+   X
+XXX 
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+ XX 
+X  X
+X  X
+ XX 
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+ XX 
+X  X
+X  X
+ XX 
+X  X
+X  X
+ XX 
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
+Please chose a number:
+	1: A cross
+	2: A slash from the upper left to lower right
+	3: A slash from the upper right to lower left
+	4: An X
+	5: A greater than sign 
+	6: A less than sign
+	7: Two greater than signs
+	8: Two less than signs
+	9: A 'V'
+	10: An inverse 'V'
+	11: Numbers 9 and 10 combined
+	12: A full grid
+	13: A 'T'
+	14: A plus '+'
+	15: A 'W'
+	16: An 'M'
+	17: An 'E'
+	18: A '3'
+	19: An 'O'
+	20: An '8'
+	21: An 'S'
+Your choice => 
+
+ XXX
+X   
+X   
+ XX 
+   X
+   X
+XXX 
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+-XX-
+X-X-
+X---
+-XX-
+---X
+-X-X
+-XX-
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+-XX-
+X-X-
+X-X-
+-XX-
+-X-X
+-X-X
+-XX-
+
+Would you like to continue with the next generation? 
+Please use lowercase y or n for your answer [y]: 
+
+
+Would you like to choose a background pattern? 
+Please use lowercase y or n for your answer [n]: 
\ No newline at end of file
diff --git a/src/tests/codegen/list.cl b/src/tests/codegen/list.cl
new file mode 100644
index 000000000..e8bbcb844
--- /dev/null
+++ b/src/tests/codegen/list.cl
@@ -0,0 +1,141 @@
+(*
+ *  This file shows how to implement a list data type for lists of integers.
+ *  It makes use of INHERITANCE and DYNAMIC DISPATCH.
+ *
+ *  The List class has 4 operations defined on List objects. If 'l' is
+ *  a list, then the methods dispatched on 'l' have the following effects:
+ *
+ *    isNil() : Bool		Returns true if 'l' is empty, false otherwise.
+ *    head()  : Int		Returns the integer at the head of 'l'.
+ *				If 'l' is empty, execution aborts.
+ *    tail()  : List		Returns the remainder of the 'l',
+ *				i.e. without the first element.
+ *    cons(i : Int) : List	Return a new list containing i as the
+ *				first element, followed by the
+ *				elements in 'l'.
+ *
+ *  There are 2 kinds of lists, the empty list and a non-empty
+ *  list. We can think of the non-empty list as a specialization of
+ *  the empty list.
+ *  The class List defines the operations on empty list. The class
+ *  Cons inherits from List and redefines things to handle non-empty
+ *  lists.
+ *)
+
+
+class List {
+   -- Define operations on empty lists.
+
+   isNil() : Bool { true };
+
+   -- Since abort() has return type Object and head() has return type
+   -- Int, we need to have an Int as the result of the method body,
+   -- even though abort() never returns.
+
+   head()  : Int { { abort(); 0; } };
+
+   -- As for head(), the self is just to make sure the return type of
+   -- tail() is correct.
+
+   tail()  : List { { abort(); self; } };
+
+   -- When we cons and element onto the empty list we get a non-empty
+   -- list. The (new Cons) expression creates a new list cell of class
+   -- Cons, which is initialized by a dispatch to init().
+   -- The result of init() is an element of class Cons, but it
+   -- conforms to the return type List, because Cons is a subclass of
+   -- List.
+
+   cons(i : Int) : List {
+      (new Cons).init(i, self)
+   };
+
+};
+
+
+(*
+ *  Cons inherits all operations from List. We can reuse only the cons
+ *  method though, because adding an element to the front of an emtpy
+ *  list is the same as adding it to the front of a non empty
+ *  list. All other methods have to be redefined, since the behaviour
+ *  for them is different from the empty list.
+ *
+ *  Cons needs two attributes to hold the integer of this list
+ *  cell and to hold the rest of the list.
+ *
+ *  The init() method is used by the cons() method to initialize the
+ *  cell.
+ *)
+
+class Cons inherits List {
+
+   car : Int;	-- The element in this list cell
+
+   cdr : List;	-- The rest of the list
+
+   isNil() : Bool { false };
+
+   head()  : Int { car };
+
+   tail()  : List { cdr };
+
+   init(i : Int, rest : List) : List {
+      {
+	 car <- i;
+	 cdr <- rest;
+	 self;
+      }
+   };
+
+};
+
+
+
+(*
+ *  The Main class shows how to use the List class. It creates a small
+ *  list and then repeatedly prints out its elements and takes off the
+ *  first element of the list.
+ *)
+
+class Main inherits IO {
+
+   mylist : List;
+
+   -- Print all elements of the list. Calls itself recursively with
+   -- the tail of the list, until the end of the list is reached.
+
+   print_list(l : List) : Object {
+      if l.isNil() then out_string("\n")
+                   else {
+			   out_int(l.head());
+			   out_string(" ");
+			   print_list(l.tail());
+		        }
+      fi
+   };
+
+   -- Note how the dynamic dispatch mechanism is responsible to end
+   -- the while loop. As long as mylist is bound to an object of 
+   -- dynamic type Cons, the dispatch to isNil calls the isNil method of
+   -- the Cons class, which returns false. However when we reach the
+   -- end of the list, mylist gets bound to the object that was
+   -- created by the (new List) expression. This object is of dynamic type
+   -- List, and thus the method isNil in the List class is called and
+   -- returns true.
+
+   main() : Object {
+      {
+	 mylist <- new List.cons(1).cons(2).cons(3).cons(4).cons(5);
+	 while (not mylist.isNil()) loop
+	    {
+	       print_list(mylist);
+	       mylist <- mylist.tail();
+	    }
+	 pool;
+      }
+   };
+
+};
+
+
+
diff --git a/src/tests/codegen/list_input.txt b/src/tests/codegen/list_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/list_output.txt b/src/tests/codegen/list_output.txt
new file mode 100644
index 000000000..fca724903
--- /dev/null
+++ b/src/tests/codegen/list_output.txt
@@ -0,0 +1,5 @@
+5 4 3 2 1 
+4 3 2 1 
+3 2 1 
+2 1 
+1 
diff --git a/src/tests/codegen/new_complex.cl b/src/tests/codegen/new_complex.cl
new file mode 100644
index 000000000..a4fe714ce
--- /dev/null
+++ b/src/tests/codegen/new_complex.cl
@@ -0,0 +1,79 @@
+class Main inherits IO {
+    main() : IO {
+	(let c : Complex <- (new Complex).init(1, 1) in
+	    {
+	        -- trivially equal (see CoolAid)
+	        if c.reflect_X() = c.reflect_0()
+	        then out_string("=)\n")
+	        else out_string("=(\n")
+	        fi;
+		-- equal
+	        if c.reflect_X().reflect_Y().equal(c.reflect_0())
+	        then out_string("=)\n")
+	        else out_string("=(\n")
+	        fi;
+	    }
+	)
+    };
+};
+
+class Complex inherits IO {
+    x : Int;
+    y : Int;
+
+    init(a : Int, b : Int) : Complex {
+	{
+	    x = a;
+	    y = b;
+	    self;
+	}
+    };
+
+    print() : Object {
+	if y = 0
+	then out_int(x)
+	else out_int(x).out_string("+").out_int(y).out_string("I")
+	fi
+    };
+
+    reflect_0() : Complex {
+	{
+	    x = ~x;
+	    y = ~y;
+	    self;
+	}
+    };
+
+    reflect_X() : Complex {
+	{
+	    y = ~y;
+	    self;
+	}
+    };
+
+    reflect_Y() : Complex {
+	{
+	    x = ~x;
+	    self;
+	}
+    };
+
+    equal(d : Complex) : Bool {
+	if x = d.x_value()
+	then
+	    if y = d.y_value()
+	    then true
+	    else false
+	    fi
+	else false
+	fi
+    };
+
+    x_value() : Int {
+	x
+    };
+
+    y_value() : Int {
+	y
+    };
+};
diff --git a/src/tests/codegen/new_complex_input.txt b/src/tests/codegen/new_complex_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/new_complex_output.txt b/src/tests/codegen/new_complex_output.txt
new file mode 100644
index 000000000..0e8da112c
--- /dev/null
+++ b/src/tests/codegen/new_complex_output.txt
@@ -0,0 +1,2 @@
+=)
+=)
diff --git a/src/tests/codegen/palindrome.cl b/src/tests/codegen/palindrome.cl
new file mode 100644
index 000000000..7f24789f9
--- /dev/null
+++ b/src/tests/codegen/palindrome.cl
@@ -0,0 +1,25 @@
+class Main inherits IO {
+    pal(s : String) : Bool {
+	if s.length() = 0
+	then true
+	else if s.length() = 1
+	then true
+	else if s.substr(0, 1) = s.substr(s.length() - 1, 1)
+	then pal(s.substr(1, s.length() -2))
+	else false
+	fi fi fi
+    };
+
+    i : Int;
+
+    main() : IO {
+	{
+            i <- ~1;
+	    out_string("enter a string\n");
+	    if pal(in_string())
+	    then out_string("that was a palindrome\n")
+	    else out_string("that was not a palindrome\n")
+	    fi;
+	}
+    };
+};
diff --git a/src/tests/codegen/palindrome_input.txt b/src/tests/codegen/palindrome_input.txt
new file mode 100644
index 000000000..8e1b64142
--- /dev/null
+++ b/src/tests/codegen/palindrome_input.txt
@@ -0,0 +1 @@
+anitalabalatina
diff --git a/src/tests/codegen/palindrome_output.txt b/src/tests/codegen/palindrome_output.txt
new file mode 100644
index 000000000..7a0095959
--- /dev/null
+++ b/src/tests/codegen/palindrome_output.txt
@@ -0,0 +1,2 @@
+enter a string
+that was a palindrome
diff --git a/src/tests/codegen/primes.cl b/src/tests/codegen/primes.cl
new file mode 100644
index 000000000..ea9533298
--- /dev/null
+++ b/src/tests/codegen/primes.cl
@@ -0,0 +1,84 @@
+
+(*
+ * methodless-primes.cl
+ *
+ * Designed by Jesse H. Willett, jhw@cory, 11103234, with 
+ *             Istvan Siposs, isiposs@cory, 12342921.
+ *
+ * This program generates primes in order without using any methods.
+ * Actually, it does use three methods: those of IO to print out each
+ * prime, and abort() to halt the program.  These methods are incidental,
+ * however, to the information-processing functionality of the program.  We
+ * could regard the attribute 'out's sequential values as our output, and
+ * the string "halt" as our terminate signal.
+ *
+ * Naturally, using Cool this way is a real waste, basically reducing it 
+ * to assembly without the benefit of compilation.  
+ *
+ * There could even be a subroutine-like construction, in that different
+ * code could be in the assign fields of attributes of other classes,
+ * and it could be executed by calling 'new Sub', but no parameters
+ * could be passed to the subroutine, and it could only return itself.
+ * but returning itself would be useless since we couldn't call methods
+ * and the only operators we have are for Int and Bool, which do nothing
+ * interesting when we initialize them!
+ *)
+
+class Main inherits IO {
+
+  main() : Int {	-- main() is an atrophied method so we can parse. 
+    0 
+  };
+
+  out : Int <-		-- out is our 'output'.  Its values are the primes.
+    {
+      out_string("2 is trivially prime.\n");
+      2;
+    };
+
+  testee : Int <- out;	-- testee is a number to be tested for primeness.   
+
+  divisor : Int;	-- divisor is a number which may factor testee.
+
+  stop : Int <- 500;	-- stop is an arbitrary value limiting testee. 	
+
+  m : Object <-		-- m supplants the main method.
+    while true loop 
+      {
+
+        testee <- testee + 1;
+        divisor <- 2;
+
+        while 
+          if testee < divisor * divisor 
+            then false 		-- can stop if divisor > sqrt(testee).
+	  else if testee - divisor*(testee/divisor) = 0 
+            then false 		-- can stop if divisor divides testee. 
+            else true
+          fi fi     
+        loop 
+          divisor <- divisor + 1
+        pool;        
+
+        if testee < divisor * divisor	-- which reason did we stop for?
+        then 	-- testee has no factors less than sqrt(testee).
+          {
+            out <- testee;	-- we could think of out itself as the output.
+            out_int(out); 
+            out_string(" is prime.\n");
+          }
+        else	-- the loop halted on testee/divisor = 0, testee isn't prime.
+          0	-- testee isn't prime, do nothing.
+	fi;   	
+
+        if stop <= testee then 
+          "halt".abort()	-- we could think of "halt" as SIGTERM.
+        else 
+          "continue"
+        fi;       
+
+      } 
+    pool;
+
+}; (* end of Main *)
+
diff --git a/src/tests/codegen/primes_input.txt b/src/tests/codegen/primes_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/primes_output.txt b/src/tests/codegen/primes_output.txt
new file mode 100644
index 000000000..a4d0fcb3f
--- /dev/null
+++ b/src/tests/codegen/primes_output.txt
@@ -0,0 +1,96 @@
+2 is trivially prime.
+3 is prime.
+5 is prime.
+7 is prime.
+11 is prime.
+13 is prime.
+17 is prime.
+19 is prime.
+23 is prime.
+29 is prime.
+31 is prime.
+37 is prime.
+41 is prime.
+43 is prime.
+47 is prime.
+53 is prime.
+59 is prime.
+61 is prime.
+67 is prime.
+71 is prime.
+73 is prime.
+79 is prime.
+83 is prime.
+89 is prime.
+97 is prime.
+101 is prime.
+103 is prime.
+107 is prime.
+109 is prime.
+113 is prime.
+127 is prime.
+131 is prime.
+137 is prime.
+139 is prime.
+149 is prime.
+151 is prime.
+157 is prime.
+163 is prime.
+167 is prime.
+173 is prime.
+179 is prime.
+181 is prime.
+191 is prime.
+193 is prime.
+197 is prime.
+199 is prime.
+211 is prime.
+223 is prime.
+227 is prime.
+229 is prime.
+233 is prime.
+239 is prime.
+241 is prime.
+251 is prime.
+257 is prime.
+263 is prime.
+269 is prime.
+271 is prime.
+277 is prime.
+281 is prime.
+283 is prime.
+293 is prime.
+307 is prime.
+311 is prime.
+313 is prime.
+317 is prime.
+331 is prime.
+337 is prime.
+347 is prime.
+349 is prime.
+353 is prime.
+359 is prime.
+367 is prime.
+373 is prime.
+379 is prime.
+383 is prime.
+389 is prime.
+397 is prime.
+401 is prime.
+409 is prime.
+419 is prime.
+421 is prime.
+431 is prime.
+433 is prime.
+439 is prime.
+443 is prime.
+449 is prime.
+457 is prime.
+461 is prime.
+463 is prime.
+467 is prime.
+479 is prime.
+487 is prime.
+491 is prime.
+499 is prime.
+Abort called from class String
diff --git a/src/tests/codegen/print-cool.cl b/src/tests/codegen/print-cool.cl
new file mode 100644
index 000000000..8d7a336f3
--- /dev/null
+++ b/src/tests/codegen/print-cool.cl
@@ -0,0 +1,9 @@
+class Main inherits IO {
+    main() : IO {
+	{
+	    out_string((new Object).type_name().substr(4,1)).
+	    out_string((isvoid self).type_name().substr(1,3));	-- demonstrates the dispatch rules.
+	    out_string("\n");
+	}
+    };
+};
diff --git a/src/tests/codegen/print-cool_input.txt b/src/tests/codegen/print-cool_input.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/tests/codegen/print-cool_output.txt b/src/tests/codegen/print-cool_output.txt
new file mode 100644
index 000000000..2b58f8985
--- /dev/null
+++ b/src/tests/codegen/print-cool_output.txt
@@ -0,0 +1 @@
+cool
diff --git a/src/tests/codegen/sort-list.cl b/src/tests/codegen/sort-list.cl
new file mode 100644
index 000000000..d49d56c4b
--- /dev/null
+++ b/src/tests/codegen/sort-list.cl
@@ -0,0 +1,146 @@
+(*
+   This file presents a fairly large example of Cool programming.  The
+class List defines the names of standard list operations ala Scheme:
+car, cdr, cons, isNil, rev, sort, rcons (add an element to the end of
+the list), and print_list.  In the List class most of these functions
+are just stubs that abort if ever called.  The classes Nil and Cons
+inherit from List and define the same operations, but now as
+appropriate to the empty list (for the Nil class) and for cons cells (for
+the Cons class).
+
+The Main class puts all of this code through the following silly 
+test exercise:
+
+   1. prompt for a number N
+   2. generate a list of numbers 0..N-1
+   3. reverse the list
+   4. sort the list
+   5. print the sorted list
+
+Because the sort used is a quadratic space insertion sort, sorting
+moderately large lists can be quite slow. 
+*)
+
+Class List inherits IO { 
+        (* Since abort() returns Object, we need something of
+	   type Bool at the end of the block to satisfy the typechecker. 
+           This code is unreachable, since abort() halts the program. *)
+	isNil() : Bool { { abort(); true; } };
+
+	cons(hd : Int) : Cons {
+	  (let new_cell : Cons <- new Cons in
+		new_cell.init(hd,self)
+	  )
+	};
+
+	(* 
+	   Since abort "returns" type Object, we have to add
+	   an expression of type Int here to satisfy the typechecker.
+	   This code is, of course, unreachable.
+        *)
+	car() : Int { { abort(); new Int; } };
+
+	cdr() : List { { abort(); new List; } };
+
+	rev() : List { cdr() };
+
+	sort() : List { cdr() };
+
+	insert(i : Int) : List { cdr() };
+
+	rcons(i : Int) : List { cdr() };
+	
+	print_list() : Object { abort() };
+};
+
+Class Cons inherits List {
+	xcar : Int;  -- We keep the car in cdr in attributes.
+	xcdr : List; 
+
+	isNil() : Bool { false };
+
+	init(hd : Int, tl : List) : Cons {
+	  {
+	    xcar <- hd;
+	    xcdr <- tl;
+	    self;
+	  }
+	};
+	  
+	car() : Int { xcar };
+
+	cdr() : List { xcdr };
+
+	rev() : List { (xcdr.rev()).rcons(xcar) };
+
+	sort() : List { (xcdr.sort()).insert(xcar) };
+
+	insert(i : Int) : List {
+		if i < xcar then
+			(new Cons).init(i,self)
+		else
+			(new Cons).init(xcar,xcdr.insert(i))
+		fi
+	};
+
+
+	rcons(i : Int) : List { (new Cons).init(xcar, xcdr.rcons(i)) };
+
+	print_list() : Object {
+		{
+		     out_int(xcar);
+		     out_string("\n");
+		     xcdr.print_list();
+		}
+	};
+};
+
+Class Nil inherits List {
+	isNil() : Bool { true };
+
+        rev() : List { self };
+
+	sort() : List { self };
+
+	insert(i : Int) : List { rcons(i) };
+
+	rcons(i : Int) : List { (new Cons).init(i,self) };
+
+	print_list() : Object { true };
+
+};
+
+
+Class Main inherits IO {
+
+	l : List;
+
+	(* iota maps its integer argument n into the list 0..n-1 *)
+	iota(i : Int) : List {
+	    {
+		l <- new Nil;
+		(let j : Int <- 0 in
+		   while j < i 
+		   loop 
+		     {
+		       l <- (new Cons).init(j,l);
+		       j <- j + 1;
+		     } 
+		   pool
+		);
+		l;
+	    }
+	};		
+
+	main() : Object {
+	   {
+	     out_string("How many numbers to sort? ");
+	     iota(in_int()).rev().sort().print_list();
+	   }
+	};
+};			    
+
+
+
+
+
diff --git a/src/tests/codegen/sort-list_input.txt b/src/tests/codegen/sort-list_input.txt
new file mode 100644
index 000000000..f599e28b8
--- /dev/null
+++ b/src/tests/codegen/sort-list_input.txt
@@ -0,0 +1 @@
+10
diff --git a/src/tests/codegen/sort-list_output.txt b/src/tests/codegen/sort-list_output.txt
new file mode 100644
index 000000000..9878d57ea
--- /dev/null
+++ b/src/tests/codegen/sort-list_output.txt
@@ -0,0 +1,10 @@
+How many numbers to sort? 0
+1
+2
+3
+4
+5
+6
+7
+8
+9
diff --git a/src/tests/codegen_test.py b/src/tests/codegen_test.py
new file mode 100644
index 000000000..48df768ff
--- /dev/null
+++ b/src/tests/codegen_test.py
@@ -0,0 +1,17 @@
+import pytest
+import os
+from utils import compare_outputs
+
+tests_dir = __file__.rpartition('/')[0] + '/codegen/'
+tests = [(file) for file in os.listdir(tests_dir) if file.endswith('.cl')]
+
+# @pytest.mark.lexer
+# @pytest.mark.parser
+# @pytest.mark.semantic
+@pytest.mark.codegen
+@pytest.mark.ok
+@pytest.mark.run(order=4)
+@pytest.mark.parametrize("cool_file", tests)
+def test_codegen(compiler_path, cool_file):
+    compare_outputs(compiler_path, tests_dir + cool_file, tests_dir + cool_file[:-3] + '_input.txt',\
+        tests_dir + cool_file[:-3] + '_output.txt')
\ No newline at end of file
diff --git a/src/tests/conftest.py b/src/tests/conftest.py
new file mode 100644
index 000000000..1f44eeb72
--- /dev/null
+++ b/src/tests/conftest.py
@@ -0,0 +1,6 @@
+import pytest
+import os
+
+@pytest.fixture
+def compiler_path():
+	return os.path.abspath('./coolc.sh')
\ No newline at end of file
diff --git a/src/tests/lexer/comment1.cl b/src/tests/lexer/comment1.cl
new file mode 100644
index 000000000..69533f23c
--- /dev/null
+++ b/src/tests/lexer/comment1.cl
@@ -0,0 +1,55 @@
+--Any characters between two dashes “--” and the next newline
+--(or EOF, if there is no next newline) are treated as comments
+
+(*(*(*
+Comments may also be written by enclosing
+text in (∗ . . . ∗). The latter form of comment may be nested.
+Comments cannot cross file boundaries.
+*)*)*)
+
+class Error() {
+
+        (* There was once a comment,
+         that was quite long.
+         But, the reader soon discovered that
+         the comment was indeed longer than
+         previously assumed. Now, the reader
+         was in a real dilemma; is the comment
+         ever gonna end? If I stop reading, will
+         it end?
+         He started imagining all sorts of things.
+         He thought about heisenberg's cat and how
+         how that relates to the end of the sentence.
+         He thought to himself "I'm gonna stop reading".
+         "If I keep reading this comment, I'm gonna know
+         the fate of this sentence; That will be disastorous."
+         He knew that such a comment was gonna extend to
+         another file. It was too awesome to be contained in
+         a single file. And he would have kept reading too...
+         if only...
+         cool wasn't a super-duper-fab-awesomest language;
+         but cool is that language;
+         "This comment shall go not cross this file" said cool.
+         Alas! The reader could read no more.
+         There was once a comment,
+         that was quite long.
+         But, the reader soon discovered that
+         the comment was indeed longer than
+         previously assumed. Now, the reader
+         was in a real dilemma; is the comment
+         ever gonna end? If I stop reading, will
+         it end?
+         He started imagining all sorts of things.
+         He thought about heisenberg's cat and how
+         how that relates to the end of the sentence.
+         He thought to himself "I'm gonna stop reading".
+         "If I keep reading this comment, I'm gonna know
+         the fate of this sentence; That will be disastorous."
+         He knew that such a comment was gonna extend to
+         another file. It was too awesome to be contained in
+         a single file. And he would have kept reading too...
+         if only...
+         cool wasn't a super-duper-fab-awesomest language;
+         but cool is that language;
+         "This comment shall go not cross this file" said cool.
+         Alas! The reader could read no more.
\ No newline at end of file
diff --git a/src/tests/lexer/comment1_error.txt b/src/tests/lexer/comment1_error.txt
new file mode 100644
index 000000000..9fd7b8d67
--- /dev/null
+++ b/src/tests/lexer/comment1_error.txt
@@ -0,0 +1 @@
+(55, 46) - LexicographicError: EOF in comment
diff --git a/src/tests/lexer/iis1.cl b/src/tests/lexer/iis1.cl
new file mode 100644
index 000000000..12cb52beb
--- /dev/null
+++ b/src/tests/lexer/iis1.cl
@@ -0,0 +1,111 @@
+(* Integers, Identifiers, and Special Notation *)
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+5! = 120, 2 + 2 = 5 or E = mc2; p + 1 @ p = 1:  for x in range(len(b))
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+class Class if then else fi testing Testing ~007agent_bond james_007B0N3SS___
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+(*
+#3 INT_CONST 0007
+#3 INT_CONST 123
+#3 '+'
+#3 INT_CONST 1
+#3 '-'
+#3 INT_CONST 1
+#3 '+'
+#3 INT_CONST 90
+#3 '-'
+#3 INT_CONST 09
+#3 '+'
+#3 INT_CONST 11113
+#3 '-'
+#3 INT_CONST 4
+#3 OBJECTID r
+#3 '*'
+#3 OBJECTID a
+#3 '*'
+#3 OBJECTID self
+#3 '*'
+#3 OBJECTID c
+#3 '+'
+#3 '+'
+#4 INT_CONST 5
+#4 ERROR "!"
+#4 '='
+#4 INT_CONST 120
+#4 ','
+#4 INT_CONST 2
+#4 '+'
+#4 INT_CONST 2
+#4 '='
+#4 INT_CONST 5
+#4 OBJECTID or
+#4 TYPEID E
+#4 '='
+#4 OBJECTID mc2
+#4 ';'
+#4 OBJECTID p
+#4 '+'
+#4 INT_CONST 1
+#4 '@'
+#4 OBJECTID p
+#4 '='
+#4 INT_CONST 1
+#4 ':'
+#4 OBJECTID for
+#4 OBJECTID x
+#4 IN
+#4 OBJECTID range
+#4 '('
+#4 OBJECTID len
+#4 '('
+#4 OBJECTID b
+#4 ')'
+#4 ')'
+#5 NEW
+#5 '/'
+#5 ASSIGN
+#5 '<'
+#5 LE
+#5 DARROW
+#5 '{'
+#5 '('
+#5 TYPEID Int
+#5 ':'
+#5 TYPEID Objet
+#5 ','
+#5 TYPEID Bool
+#5 ';'
+#5 TYPEID String
+#5 '.'
+#5 OBJECTID string
+#5 TYPEID SELF_TYPE
+#5 ISVOID
+#5 '}'
+#5 ')'
+#6 CLASS
+#6 CLASS
+#6 IF
+#6 THEN
+#6 ELSE
+#6 FI
+#6 OBJECTID testing
+#6 TYPEID Testing
+#6 '~'
+#6 INT_CONST 007
+#6 OBJECTID agent_bond
+#6 OBJECTID james_007B0N3SS___
+#7 LOOP
+#7 POOL
+#7 WHILE
+#7 BOOL_CONST true
+#7 OBJECTID or
+#7 NOT
+#7 BOOL_CONST false
+#7 LET
+#7 IN
+#7 CASE
+#7 OF
+#7 ESAC
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/iis1_error.txt b/src/tests/lexer/iis1_error.txt
new file mode 100644
index 000000000..9e6d66cac
--- /dev/null
+++ b/src/tests/lexer/iis1_error.txt
@@ -0,0 +1 @@
+(4, 2) - LexicographicError: ERROR "!"  
diff --git a/src/tests/lexer/iis2.cl b/src/tests/lexer/iis2.cl
new file mode 100644
index 000000000..9b25715d4
--- /dev/null
+++ b/src/tests/lexer/iis2.cl
@@ -0,0 +1,120 @@
+(* Integers, Identifiers, and Special Notation *)
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+factorial(5) = 120, 2 + 2 = 5? or E = mc2; p + 1 resto p = 1: (@ for x in range(len(b)))
+
+(*
+#3 INT_CONST 0007
+#3 INT_CONST 123
+#3 '+'
+#3 INT_CONST 1
+#3 '-'
+#3 INT_CONST 1
+#3 '+'
+#3 INT_CONST 90
+#3 '-'
+#3 INT_CONST 09
+#3 '+'
+#3 INT_CONST 11113
+#3 '-'
+#3 INT_CONST 4
+#3 OBJECTID r
+#3 '*'
+#3 OBJECTID a
+#3 '*'
+#3 OBJECTID self
+#3 '*'
+#3 OBJECTID c
+#3 '+'
+#3 '+'
+#4 CLASS
+#4 CLASS
+#4 IF
+#4 THEN
+#4 ELSE
+#4 FI
+#4 OBJECTID testing
+#4 TYPEID Testing
+#4 '~'
+#4 INT_CONST 007
+#4 OBJECTID agent_bond
+#4 OBJECTID james_007bones___
+#7 NEW
+#7 '/'
+#7 ASSIGN
+#7 '<'
+#7 LE
+#7 DARROW
+#7 '{'
+#7 '('
+#7 TYPEID Int
+#7 ':'
+#7 TYPEID Objet
+#7 ','
+#7 TYPEID Bool
+#7 ';'
+#7 TYPEID String
+#7 '.'
+#7 OBJECTID string
+#7 TYPEID SELF_TYPE
+#7 ISVOID
+#7 '}'
+#7 ')'
+#8 LOOP
+#8 POOL
+#8 WHILE
+#8 BOOL_CONST true
+#8 OBJECTID or
+#8 NOT
+#8 BOOL_CONST false
+#8 LET
+#8 IN
+#8 CASE
+#8 OF
+#8 ESAC
+#10 OBJECTID factorial
+#10 '('
+#10 INT_CONST 5
+#10 ')'
+#10 '='
+#10 INT_CONST 120
+#10 ','
+#10 INT_CONST 2
+#10 '+'
+#10 INT_CONST 2
+#10 '='
+#10 INT_CONST 5
+#10 ERROR "?"
+#10 OBJECTID or
+#10 TYPEID E
+#10 '='
+#10 OBJECTID mc2
+#10 ';'
+#10 OBJECTID p
+#10 '+'
+#10 INT_CONST 1
+#10 OBJECTID resto
+#10 OBJECTID p
+#10 '='
+#10 INT_CONST 1
+#10 ':'
+#10 '('
+#10 '@'
+#10 OBJECTID for
+#10 OBJECTID x
+#10 IN
+#10 OBJECTID range
+#10 '('
+#10 OBJECTID len
+#10 '('
+#10 OBJECTID b
+#10 ')'
+#10 ')'
+#10 ')'
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/iis2_error.txt b/src/tests/lexer/iis2_error.txt
new file mode 100644
index 000000000..922391a9d
--- /dev/null
+++ b/src/tests/lexer/iis2_error.txt
@@ -0,0 +1 @@
+(10, 30) - LexicographicError: ERROR "?" 
diff --git a/src/tests/lexer/iis3.cl b/src/tests/lexer/iis3.cl
new file mode 100644
index 000000000..0b965ddea
--- /dev/null
+++ b/src/tests/lexer/iis3.cl
@@ -0,0 +1,121 @@
+(* Integers, Identifiers, and Special Notation *)
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc^2; p + 1 @ p = 1: z for x in range(len(b)))
+
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+(*
+#3 OBJECTID factorial
+#3 '('
+#3 INT_CONST 5
+#3 ')'
+#3 '='
+#3 INT_CONST 120
+#3 ','
+#3 INT_CONST 2
+#3 '+'
+#3 INT_CONST 2
+#3 '='
+#3 INT_CONST 5
+#3 OBJECTID or
+#3 TYPEID E
+#3 '='
+#3 OBJECTID mc
+#3 ERROR "^"
+#3 INT_CONST 2
+#3 ';'
+#3 OBJECTID p
+#3 '+'
+#3 INT_CONST 1
+#3 '@'
+#3 OBJECTID p
+#3 '='
+#3 INT_CONST 1
+#3 ':'
+#3 OBJECTID z
+#3 OBJECTID for
+#3 OBJECTID x
+#3 IN
+#3 OBJECTID range
+#3 '('
+#3 OBJECTID len
+#3 '('
+#3 OBJECTID b
+#3 ')'
+#3 ')'
+#3 ')'
+#5 LOOP
+#5 POOL
+#5 WHILE
+#5 BOOL_CONST true
+#5 OBJECTID or
+#5 NOT
+#5 BOOL_CONST false
+#5 LET
+#5 IN
+#5 CASE
+#5 OF
+#5 ESAC
+#7 NEW
+#7 '/'
+#7 ASSIGN
+#7 '<'
+#7 LE
+#7 DARROW
+#7 '{'
+#7 '('
+#7 TYPEID Int
+#7 ':'
+#7 TYPEID Objet
+#7 ','
+#7 TYPEID Bool
+#7 ';'
+#7 TYPEID String
+#7 '.'
+#7 OBJECTID string
+#7 TYPEID SELF_TYPE
+#7 ISVOID
+#7 '}'
+#7 ')'
+#10 INT_CONST 0007
+#10 INT_CONST 123
+#10 '+'
+#10 INT_CONST 1
+#10 '-'
+#10 INT_CONST 1
+#10 '+'
+#10 INT_CONST 90
+#10 '-'
+#10 INT_CONST 09
+#10 '+'
+#10 INT_CONST 11113
+#10 '-'
+#10 INT_CONST 4
+#10 OBJECTID r
+#10 '*'
+#10 OBJECTID a
+#10 '*'
+#10 OBJECTID self
+#10 '*'
+#10 OBJECTID c
+#10 '+'
+#10 '+'
+#11 CLASS
+#11 CLASS
+#11 IF
+#11 THEN
+#11 ELSE
+#11 FI
+#11 OBJECTID testing
+#11 TYPEID Testing
+#11 '~'
+#11 INT_CONST 007
+#11 OBJECTID agent_bond
+#11 OBJECTID james_007bones___
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/iis3_error.txt b/src/tests/lexer/iis3_error.txt
new file mode 100644
index 000000000..b001b6a71
--- /dev/null
+++ b/src/tests/lexer/iis3_error.txt
@@ -0,0 +1 @@
+(3, 40) - LexicographicError: ERROR "^"  
diff --git a/src/tests/lexer/iis4.cl b/src/tests/lexer/iis4.cl
new file mode 100644
index 000000000..9e7a9cb62
--- /dev/null
+++ b/src/tests/lexer/iis4.cl
@@ -0,0 +1,120 @@
+(* Integers, Identifiers, and Special Notation *)
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc2; p + 1 % p = 1: @.@ for x in range(len(b))~
+
+
+loop pool while tRuE or noT faLsE let in case of ESAC
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+(*
+#3 NEW
+#3 '/'
+#3 ASSIGN
+#3 '<'
+#3 LE
+#3 DARROW
+#3 '{'
+#3 '('
+#3 TYPEID Int
+#3 ':'
+#3 TYPEID Objet
+#3 ','
+#3 TYPEID Bool
+#3 ';'
+#3 TYPEID String
+#3 '.'
+#3 OBJECTID string
+#3 TYPEID SELF_TYPE
+#3 ISVOID
+#3 '}'
+#3 ')'
+#4 INT_CONST 0007
+#4 INT_CONST 123
+#4 '+'
+#4 INT_CONST 1
+#4 '-'
+#4 INT_CONST 1
+#4 '+'
+#4 INT_CONST 90
+#4 '-'
+#4 INT_CONST 09
+#4 '+'
+#4 INT_CONST 11113
+#4 '-'
+#4 INT_CONST 4
+#4 OBJECTID r
+#4 '*'
+#4 OBJECTID a
+#4 '*'
+#4 OBJECTID self
+#4 '*'
+#4 OBJECTID c
+#4 '+'
+#4 '+'
+#6 OBJECTID factorial
+#6 '('
+#6 INT_CONST 5
+#6 ')'
+#6 '='
+#6 INT_CONST 120
+#6 ','
+#6 INT_CONST 2
+#6 '+'
+#6 INT_CONST 2
+#6 '='
+#6 INT_CONST 5
+#6 OBJECTID or
+#6 TYPEID E
+#6 '='
+#6 OBJECTID mc2
+#6 ';'
+#6 OBJECTID p
+#6 '+'
+#6 INT_CONST 1
+#6 ERROR "%"
+#6 OBJECTID p
+#6 '='
+#6 INT_CONST 1
+#6 ':'
+#6 '@'
+#6 '.'
+#6 '@'
+#6 OBJECTID for
+#6 OBJECTID x
+#6 IN
+#6 OBJECTID range
+#6 '('
+#6 OBJECTID len
+#6 '('
+#6 OBJECTID b
+#6 ')'
+#6 ')'
+#6 '~'
+#9 LOOP
+#9 POOL
+#9 WHILE
+#9 BOOL_CONST true
+#9 OBJECTID or
+#9 NOT
+#9 BOOL_CONST false
+#9 LET
+#9 IN
+#9 CASE
+#9 OF
+#9 ESAC
+#10 CLASS
+#10 CLASS
+#10 IF
+#10 THEN
+#10 ELSE
+#10 FI
+#10 OBJECTID testing
+#10 TYPEID Testing
+#10 '~'
+#10 INT_CONST 007
+#10 OBJECTID agent_bond
+#10 OBJECTID james_007bones___
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/iis4_error.txt b/src/tests/lexer/iis4_error.txt
new file mode 100644
index 000000000..f24076a8c
--- /dev/null
+++ b/src/tests/lexer/iis4_error.txt
@@ -0,0 +1 @@
+(6, 49) - LexicographicError: ERROR "!"  
diff --git a/src/tests/lexer/iis5.cl b/src/tests/lexer/iis5.cl
new file mode 100644
index 000000000..d146c0547
--- /dev/null
+++ b/src/tests/lexer/iis5.cl
@@ -0,0 +1,121 @@
+(* Integers, Identifiers, and Special Notation *)
+
+
+loop pool while tRuE or noT faLsE let in case of ESAC
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+class Class if then else fi testing Testing ~007agent_bond james_007bones___
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc2; p + 1 resto p = 1: [@.@ for x in range(len(b))]
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++
+
+(*
+#4 LOOP
+#4 POOL
+#4 WHILE
+#4 BOOL_CONST true
+#4 OBJECTID or
+#4 NOT
+#4 BOOL_CONST false
+#4 LET
+#4 IN
+#4 CASE
+#4 OF
+#4 ESAC
+#5 NEW
+#5 '/'
+#5 ASSIGN
+#5 '<'
+#5 LE
+#5 DARROW
+#5 '{'
+#5 '('
+#5 TYPEID Int
+#5 ':'
+#5 TYPEID Objet
+#5 ','
+#5 TYPEID Bool
+#5 ';'
+#5 TYPEID String
+#5 '.'
+#5 OBJECTID string
+#5 TYPEID SELF_TYPE
+#5 ISVOID
+#5 '}'
+#5 ')'
+#6 CLASS
+#6 CLASS
+#6 IF
+#6 THEN
+#6 ELSE
+#6 FI
+#6 OBJECTID testing
+#6 TYPEID Testing
+#6 '~'
+#6 INT_CONST 007
+#6 OBJECTID agent_bond
+#6 OBJECTID james_007bones___
+#8 OBJECTID factorial
+#8 '('
+#8 INT_CONST 5
+#8 ')'
+#8 '='
+#8 INT_CONST 120
+#8 ','
+#8 INT_CONST 2
+#8 '+'
+#8 INT_CONST 2
+#8 '='
+#8 INT_CONST 5
+#8 OBJECTID or
+#8 TYPEID E
+#8 '='
+#8 OBJECTID mc2
+#8 ';'
+#8 OBJECTID p
+#8 '+'
+#8 INT_CONST 1
+#8 OBJECTID resto
+#8 OBJECTID p
+#8 '='
+#8 INT_CONST 1
+#8 ':'
+#8 ERROR "["
+#8 '@'
+#8 '.'
+#8 '@'
+#8 OBJECTID for
+#8 OBJECTID x
+#8 IN
+#8 OBJECTID range
+#8 '('
+#8 OBJECTID len
+#8 '('
+#8 OBJECTID b
+#8 ')'
+#8 ')'
+#8 ERROR "]"
+#10 INT_CONST 0007
+#10 INT_CONST 123
+#10 '+'
+#10 INT_CONST 1
+#10 '-'
+#10 INT_CONST 1
+#10 '+'
+#10 INT_CONST 90
+#10 '-'
+#10 INT_CONST 09
+#10 '+'
+#10 INT_CONST 11113
+#10 '-'
+#10 INT_CONST 4
+#10 OBJECTID r
+#10 '*'
+#10 OBJECTID a
+#10 '*'
+#10 OBJECTID self
+#10 '*'
+#10 OBJECTID c
+#10 '+'
+#10 '+'
+*)
diff --git a/src/tests/lexer/iis5_error.txt b/src/tests/lexer/iis5_error.txt
new file mode 100644
index 000000000..b3dbadcb6
--- /dev/null
+++ b/src/tests/lexer/iis5_error.txt
@@ -0,0 +1,2 @@
+(8, 62) - LexicographicError: ERROR "["
+(8, 89) - LexicographicError: ERROR "]"
diff --git a/src/tests/lexer/iis6.cl b/src/tests/lexer/iis6.cl
new file mode 100644
index 000000000..1042f132b
--- /dev/null
+++ b/src/tests/lexer/iis6.cl
@@ -0,0 +1,125 @@
+(* Integers, Identifiers, and Special Notation *)
+
+factorial(5) = 120, 2 + 2 = 5 or E = mc2; p + 1 resto p = 1: {@.@ for x in range(len(b))}
+
+new / <- <<==> {( Int: Objet, Bool; String.string SELF_TYPE isvoid })
+
+
+class Class if then else fi testing Testing ~007agent_bond _james_007bones___
+
+
+
+0007 123 +1 -1 +90 -09 +11113 -4r *a *self* c++ 
+loop pool while tRuE or noT faLsE let in case of ESAC
+
+(*
+#3 OBJECTID factorial
+#3 '('
+#3 INT_CONST 5
+#3 ')'
+#3 '='
+#3 INT_CONST 120
+#3 ','
+#3 INT_CONST 2
+#3 '+'
+#3 INT_CONST 2
+#3 '='
+#3 INT_CONST 5
+#3 OBJECTID or
+#3 TYPEID E
+#3 '='
+#3 OBJECTID mc2
+#3 ';'
+#3 OBJECTID p
+#3 '+'
+#3 INT_CONST 1
+#3 OBJECTID resto
+#3 OBJECTID p
+#3 '='
+#3 INT_CONST 1
+#3 ':'
+#3 '{'
+#3 '@'
+#3 '.'
+#3 '@'
+#3 OBJECTID for
+#3 OBJECTID x
+#3 IN
+#3 OBJECTID range
+#3 '('
+#3 OBJECTID len
+#3 '('
+#3 OBJECTID b
+#3 ')'
+#3 ')'
+#3 '}'
+#5 NEW
+#5 '/'
+#5 ASSIGN
+#5 '<'
+#5 LE
+#5 DARROW
+#5 '{'
+#5 '('
+#5 TYPEID Int
+#5 ':'
+#5 TYPEID Objet
+#5 ','
+#5 TYPEID Bool
+#5 ';'
+#5 TYPEID String
+#5 '.'
+#5 OBJECTID string
+#5 TYPEID SELF_TYPE
+#5 ISVOID
+#5 '}'
+#5 ')'
+#8 CLASS
+#8 CLASS
+#8 IF
+#8 THEN
+#8 ELSE
+#8 FI
+#8 OBJECTID testing
+#8 TYPEID Testing
+#8 '~'
+#8 INT_CONST 007
+#8 OBJECTID agent_bond
+#8 ERROR "_"
+#8 OBJECTID james_007bones___
+#12 INT_CONST 0007
+#12 INT_CONST 123
+#12 '+'
+#12 INT_CONST 1
+#12 '-'
+#12 INT_CONST 1
+#12 '+'
+#12 INT_CONST 90
+#12 '-'
+#12 INT_CONST 09
+#12 '+'
+#12 INT_CONST 11113
+#12 '-'
+#12 INT_CONST 4
+#12 OBJECTID r
+#12 '*'
+#12 OBJECTID a
+#12 '*'
+#12 OBJECTID self
+#12 '*'
+#12 OBJECTID c
+#12 '+'
+#12 '+'
+#13 LOOP
+#13 POOL
+#13 WHILE
+#13 BOOL_CONST true
+#13 OBJECTID or
+#13 NOT
+#13 BOOL_CONST false
+#13 LET
+#13 IN
+#13 CASE
+#13 OF
+#13 ESAC
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/iis6_error.txt b/src/tests/lexer/iis6_error.txt
new file mode 100644
index 000000000..d7fad9c79
--- /dev/null
+++ b/src/tests/lexer/iis6_error.txt
@@ -0,0 +1 @@
+(8, 60) - LexicographicError: ERROR "_" 
diff --git a/src/tests/lexer/mixed1.cl b/src/tests/lexer/mixed1.cl
new file mode 100644
index 000000000..803d58ef5
--- /dev/null
+++ b/src/tests/lexer/mixed1.cl
@@ -0,0 +1,14 @@
+"lkjdsafkljdsalfj\u0000dsafdsaf\u0000djafslkjdsalf\nsdajf\" lkjfdsasdkjfl"123
+adsfasklj#
+LKldsajf iNhERITS
+"lkdsajf"
+
+(*
+#1 STR_CONST "lkjdsafkljdsalfju0000dsafdsafu0000djafslkjdsalf\nsdajf\" lkjfdsasdkjfl"
+#1 INT_CONST 123
+#2 OBJECTID adsfasklj
+#2 ERROR "#"
+#3 TYPEID LKldsajf
+#3 INHERITS
+#4 STR_CONST "lkdsajf"
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/mixed1_error.txt b/src/tests/lexer/mixed1_error.txt
new file mode 100644
index 000000000..99af5fbdc
--- /dev/null
+++ b/src/tests/lexer/mixed1_error.txt
@@ -0,0 +1 @@
+(2, 10) - LexicographicError: ERROR "#" 
diff --git a/src/tests/lexer/mixed2.cl b/src/tests/lexer/mixed2.cl
new file mode 100644
index 000000000..12039e123
--- /dev/null
+++ b/src/tests/lexer/mixed2.cl
@@ -0,0 +1,20 @@
+"kjas\"lnnsdj\nfljrdsaf"
+@.$.@
+@*%*@
+"alkjfldajf""dasfadsf
+
+(*
+#1 STR_CONST "kjas\"lnnsdj\nfljrdsaf"
+#2 '@'
+#2 '.'
+#2 ERROR "$"
+#2 '.'
+#2 '@'
+#3 '@'
+#3 '*'
+#3 ERROR "%"
+#3 '*'
+#3 '@'
+#4 STR_CONST "alkjfldajf"
+#4 ERROR "Unterminated string constant"
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/mixed2_error.txt b/src/tests/lexer/mixed2_error.txt
new file mode 100644
index 000000000..097dc2a07
--- /dev/null
+++ b/src/tests/lexer/mixed2_error.txt
@@ -0,0 +1,3 @@
+(2, 3) - LexicographicError: ERROR "$"
+(3, 3) - LexicographicError: ERROR "%"
+(4, 22) - LexicographicError: Unterminated string constant
diff --git a/src/tests/lexer/string1.cl b/src/tests/lexer/string1.cl
new file mode 100644
index 000000000..6c3c00833
--- /dev/null
+++ b/src/tests/lexer/string1.cl
@@ -0,0 +1,6 @@
+(* A non-escaped newline character may not appear in a string *)
+
+"This \
+is OK"
+"This is not
+OK"
\ No newline at end of file
diff --git a/src/tests/lexer/string1_error.txt b/src/tests/lexer/string1_error.txt
new file mode 100644
index 000000000..078c12bbb
--- /dev/null
+++ b/src/tests/lexer/string1_error.txt
@@ -0,0 +1,2 @@
+(5, 13) - LexicographicError: Unterminated string constant
+(6, 4) - LexicographicError: EOF in string constant
\ No newline at end of file
diff --git a/src/tests/lexer/string2.cl b/src/tests/lexer/string2.cl
new file mode 100644
index 000000000..3704b6ae7
--- /dev/null
+++ b/src/tests/lexer/string2.cl
@@ -0,0 +1,19 @@
+(* A string may not contain EOF *)
+
+"               May the Triforce              \
+                      0                       \
+                     0v0                      \
+                    0vvv0                     \
+                   0vvvvv0                    \
+                  0vvvvvvv0                   \
+                 0vvvvvvvvv0                  \
+                0vvvvvvvvvvv0                 \
+               000000000000000                \
+              0v0           0v0               \
+             0vvv0         0vvv0              \
+            0vvvvv0       0vvvvv0             \
+           0vvvvvvv0     0vvvvvvv0            \
+          0vvvvvvvvv0   0vvvvvvvvv0           \
+         0vvvvvvvvvvv0 0vvvvvvvvvvv0          \
+        00000000000000000000000000000         \
+                be with you!
\ No newline at end of file
diff --git a/src/tests/lexer/string2_error.txt b/src/tests/lexer/string2_error.txt
new file mode 100644
index 000000000..7fbbcb526
--- /dev/null
+++ b/src/tests/lexer/string2_error.txt
@@ -0,0 +1 @@
+(19, 29) - LexicographicError: EOF in string constant
\ No newline at end of file
diff --git a/src/tests/lexer/string3.cl b/src/tests/lexer/string3.cl
new file mode 100644
index 0000000000000000000000000000000000000000..78abc4972e218bca373ba1750c99a3450cef4ea3
GIT binary patch
literal 234
zcmX|4yAH!34D8HToS2dhRoZ?*=Jpd<90*B>0}_xSe_!a!lI8Q=*(aJadZZi|KVhQ-
zK4j?NGc6u@9^rRpG<v2;I*$>mYcJ^ifl$<lzaZ-IFk<nVcQcv-K)=W5RtU+fGl}fV
zb+C16?@Cpw_IGn+)5pkG`DDmhB~h4aN~TPfAf7^8@)jV~psY&Q+g)WT$Rtat1c>K@
Mi{IIrdU_-I0>Lp*mH+?%

literal 0
HcmV?d00001

diff --git a/src/tests/lexer/string3_error.txt b/src/tests/lexer/string3_error.txt
new file mode 100644
index 000000000..35695d07e
--- /dev/null
+++ b/src/tests/lexer/string3_error.txt
@@ -0,0 +1 @@
+(8, 4) - LexicographicError: String contains null character
\ No newline at end of file
diff --git a/src/tests/lexer/string4.cl b/src/tests/lexer/string4.cl
new file mode 100644
index 000000000..f4d39c027
--- /dev/null
+++ b/src/tests/lexer/string4.cl
@@ -0,0 +1,38 @@
+class Main {
+    str <- "The big brown fox
+            jumped over the fence";
+	main() : Object {
+        {
+            out_string("Yay! This is the newest shites );
+        }
+    };
+};
+
+(*
+#1 CLASS
+#1 TYPEID Main
+#1 '{'
+#2 OBJECTID str
+#2 ASSIGN
+#3 ERROR "Unterminated string constant"
+#3 OBJECTID jumped
+#3 OBJECTID over
+#3 OBJECTID the
+#3 OBJECTID fence
+#4 ERROR "Unterminated string constant"
+#4 OBJECTID main
+#4 '('
+#4 ')'
+#4 ':'
+#4 TYPEID Object
+#4 '{'
+#5 '{'
+#6 OBJECTID out_string
+#6 '('
+#7 ERROR "Unterminated string constant"
+#7 '}'
+#8 '}'
+#8 ';'
+#9 '}'
+#9 ';'
+*)
\ No newline at end of file
diff --git a/src/tests/lexer/string4_error.txt b/src/tests/lexer/string4_error.txt
new file mode 100644
index 000000000..5ab0ea847
--- /dev/null
+++ b/src/tests/lexer/string4_error.txt
@@ -0,0 +1,3 @@
+(2, 30) - LexicographicError: Unterminated string constant
+(3, 36) - LexicographicError: Unterminated string constant
+(6, 58) - LexicographicError: Unterminated string constant
\ No newline at end of file
diff --git a/src/tests/lexer_test.py b/src/tests/lexer_test.py
new file mode 100644
index 000000000..2a27223d3
--- /dev/null
+++ b/src/tests/lexer_test.py
@@ -0,0 +1,13 @@
+import pytest
+import os
+from utils import compare_errors
+
+tests_dir = __file__.rpartition('/')[0] + '/lexer/'
+tests = [(file) for file in os.listdir(tests_dir) if file.endswith('.cl')]
+
+@pytest.mark.lexer
+@pytest.mark.error
+@pytest.mark.run(order=1)
+@pytest.mark.parametrize("cool_file", tests)
+def test_lexer_errors(compiler_path, cool_file):
+    compare_errors(compiler_path, tests_dir + cool_file, tests_dir + cool_file[:-3] + '_error.txt')
\ No newline at end of file
diff --git a/src/tests/parser/assignment1.cl b/src/tests/parser/assignment1.cl
new file mode 100644
index 000000000..75b4c5bbd
--- /dev/null
+++ b/src/tests/parser/assignment1.cl
@@ -0,0 +1,37 @@
+(* An assignment has the form <id> <- <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(): String {
+        Test1 <- "Hello World" -- Identifiers begin with a lower case letter
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/assignment1_error.txt b/src/tests/parser/assignment1_error.txt
new file mode 100644
index 000000000..cef0d3946
--- /dev/null
+++ b/src/tests/parser/assignment1_error.txt
@@ -0,0 +1 @@
+(29, 9) - SyntacticError: ERROR at or near "Test1"
\ No newline at end of file
diff --git a/src/tests/parser/assignment2.cl b/src/tests/parser/assignment2.cl
new file mode 100644
index 000000000..4efb96487
--- /dev/null
+++ b/src/tests/parser/assignment2.cl
@@ -0,0 +1,37 @@
+(* An assignment has the form <id> <- <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 - 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(): Int {
+        test1 <-- ~(1 + 2 + 3 + 4 + 5) -- The left side must be an expression
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/assignment2_error.txt b/src/tests/parser/assignment2_error.txt
new file mode 100644
index 000000000..dc611c159
--- /dev/null
+++ b/src/tests/parser/assignment2_error.txt
@@ -0,0 +1 @@
+(29, 17) - SyntacticError: ERROR at or near "-"
\ No newline at end of file
diff --git a/src/tests/parser/assignment3.cl b/src/tests/parser/assignment3.cl
new file mode 100644
index 000000000..ff633f331
--- /dev/null
+++ b/src/tests/parser/assignment3.cl
@@ -0,0 +1,37 @@
+(* An assignment has the form <id> <- <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(): Bool {
+        test1 <- true++ -- The left side must be an expression
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/assignment3_error.txt b/src/tests/parser/assignment3_error.txt
new file mode 100644
index 000000000..a69ac3a81
--- /dev/null
+++ b/src/tests/parser/assignment3_error.txt
@@ -0,0 +1 @@
+(29, 23) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/attribute1.cl b/src/tests/parser/attribute1.cl
new file mode 100644
index 000000000..063a02c02
--- /dev/null
+++ b/src/tests/parser/attribute1.cl
@@ -0,0 +1,34 @@
+(* An attribute of class A specifies a variable that is part of the state of objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    -- Attributes names must begin with lowercase letters
+    Test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/attribute1_error.txt b/src/tests/parser/attribute1_error.txt
new file mode 100644
index 000000000..a4e9eb060
--- /dev/null
+++ b/src/tests/parser/attribute1_error.txt
@@ -0,0 +1 @@
+(17, 5) - SyntacticError: ERROR at or near "Test2"
\ No newline at end of file
diff --git a/src/tests/parser/attribute2.cl b/src/tests/parser/attribute2.cl
new file mode 100644
index 000000000..c05211483
--- /dev/null
+++ b/src/tests/parser/attribute2.cl
@@ -0,0 +1,34 @@
+(* An attribute of class A specifies a variable that is part of the state of objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    -- Type names must begin with uppercase letters
+    test3: string <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/attribute2_error.txt b/src/tests/parser/attribute2_error.txt
new file mode 100644
index 000000000..b02a52ee1
--- /dev/null
+++ b/src/tests/parser/attribute2_error.txt
@@ -0,0 +1 @@
+(19, 12) - SyntacticError: ERROR at or near "string"
\ No newline at end of file
diff --git a/src/tests/parser/attribute3.cl b/src/tests/parser/attribute3.cl
new file mode 100644
index 000000000..d858ae47c
--- /dev/null
+++ b/src/tests/parser/attribute3.cl
@@ -0,0 +1,34 @@
+(* An attribute of class A specifies a variable that is part of the state of objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    -- Expected '<-' not '<='
+    test3: String <= "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/attribute3_error.txt b/src/tests/parser/attribute3_error.txt
new file mode 100644
index 000000000..71f5bc0b7
--- /dev/null
+++ b/src/tests/parser/attribute3_error.txt
@@ -0,0 +1 @@
+(19, 19) - SyntacticError: ERROR at or near "<="
\ No newline at end of file
diff --git a/src/tests/parser/block1.cl b/src/tests/parser/block1.cl
new file mode 100644
index 000000000..3613d9268
--- /dev/null
+++ b/src/tests/parser/block1.cl
@@ -0,0 +1,87 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2 -- Missing ";"
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/block1_error.txt b/src/tests/parser/block1_error.txt
new file mode 100644
index 000000000..c78fb0b96
--- /dev/null
+++ b/src/tests/parser/block1_error.txt
@@ -0,0 +1 @@
+(56, 17) - SyntacticError: ERROR at or near "}"
\ No newline at end of file
diff --git a/src/tests/parser/block2.cl b/src/tests/parser/block2.cl
new file mode 100644
index 000000000..f485dd0b1
--- /dev/null
+++ b/src/tests/parser/block2.cl
@@ -0,0 +1,87 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        -- Missing "{"
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/block2_error.txt b/src/tests/parser/block2_error.txt
new file mode 100644
index 000000000..f85f4303c
--- /dev/null
+++ b/src/tests/parser/block2_error.txt
@@ -0,0 +1 @@
+(49, 23) - SyntacticError: ERROR at or near ";"
\ No newline at end of file
diff --git a/src/tests/parser/block3.cl b/src/tests/parser/block3.cl
new file mode 100644
index 000000000..ae1598c3b
--- /dev/null
+++ b/src/tests/parser/block3.cl
@@ -0,0 +1,87 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                -- Missing "}" 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/block3_error.txt b/src/tests/parser/block3_error.txt
new file mode 100644
index 000000000..cda9949a2
--- /dev/null
+++ b/src/tests/parser/block3_error.txt
@@ -0,0 +1 @@
+(57, 13) - SyntacticError: ERROR at or near "pool"
\ No newline at end of file
diff --git a/src/tests/parser/block4.cl b/src/tests/parser/block4.cl
new file mode 100644
index 000000000..8fd883d02
--- /dev/null
+++ b/src/tests/parser/block4.cl
@@ -0,0 +1,88 @@
+(* A block has the form { <expr>; ... <expr>; } *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    pow: Int <- 1;
+    count: Int <- 0;
+
+    testing6(a: Int): IO {
+        {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                    true++; -- Only expressions
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/block4_error.txt b/src/tests/parser/block4_error.txt
new file mode 100644
index 000000000..ddbeb32ef
--- /dev/null
+++ b/src/tests/parser/block4_error.txt
@@ -0,0 +1 @@
+(56, 26) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/case1.cl b/src/tests/parser/case1.cl
new file mode 100644
index 000000000..c2f508809
--- /dev/null
+++ b/src/tests/parser/case1.cl
@@ -0,0 +1,91 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            --  Every case expression must have at least one branch
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/case1_error.txt b/src/tests/parser/case1_error.txt
new file mode 100644
index 000000000..61fca14f7
--- /dev/null
+++ b/src/tests/parser/case1_error.txt
@@ -0,0 +1 @@
+(63, 9) - SyntacticError: ERROR at or near ESAC
\ No newline at end of file
diff --git a/src/tests/parser/case2.cl b/src/tests/parser/case2.cl
new file mode 100644
index 000000000..f9162e49f
--- /dev/null
+++ b/src/tests/parser/case2.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case "2 + 2" of
+            x: Int => new IO.out_string("Es un entero!") -- Missing ";"
+            y: String => new IO.out_string("Es una cadena!");
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/case2_error.txt b/src/tests/parser/case2_error.txt
new file mode 100644
index 000000000..40b030dd9
--- /dev/null
+++ b/src/tests/parser/case2_error.txt
@@ -0,0 +1 @@
+(63, 13) - SyntacticError: ERROR at or near "y"
\ No newline at end of file
diff --git a/src/tests/parser/case3.cl b/src/tests/parser/case3.cl
new file mode 100644
index 000000000..a7eedc18b
--- /dev/null
+++ b/src/tests/parser/case3.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + false of
+            x: Int => new IO.out_string("Es un entero!");
+            y: string => new IO.out_string("Es una cadena!"); -- Type identifiers starts with a uppercase letter
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/case3_error.txt b/src/tests/parser/case3_error.txt
new file mode 100644
index 000000000..f25c5c563
--- /dev/null
+++ b/src/tests/parser/case3_error.txt
@@ -0,0 +1 @@
+(63, 16) - SyntacticError: ERROR at or near "string"
\ No newline at end of file
diff --git a/src/tests/parser/case4.cl b/src/tests/parser/case4.cl
new file mode 100644
index 000000000..25ca3858f
--- /dev/null
+++ b/src/tests/parser/case4.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case true of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            Mazinger_Z: Bool => new IO.out_string("Es un booleano!"); -- Identifiers starts with a lowercase letter
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/case4_error.txt b/src/tests/parser/case4_error.txt
new file mode 100644
index 000000000..c5a16ddec
--- /dev/null
+++ b/src/tests/parser/case4_error.txt
@@ -0,0 +1 @@
+(64, 13) - SyntacticError: ERROR at or near "Mazinger_Z"
\ No newline at end of file
diff --git a/src/tests/parser/case5.cl b/src/tests/parser/case5.cl
new file mode 100644
index 000000000..b36c663e1
--- /dev/null
+++ b/src/tests/parser/case5.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case test2 of
+            x: Int <- new IO.out_string("Es un entero!"); -- Must be '=>' not '<-';
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/case5_error.txt b/src/tests/parser/case5_error.txt
new file mode 100644
index 000000000..fc6ec0eda
--- /dev/null
+++ b/src/tests/parser/case5_error.txt
@@ -0,0 +1 @@
+(62, 20) - SyntacticError: ERROR at or near ASSIGN
\ No newline at end of file
diff --git a/src/tests/parser/case6.cl b/src/tests/parser/case6.cl
new file mode 100644
index 000000000..66e7df2ab
--- /dev/null
+++ b/src/tests/parser/case6.cl
@@ -0,0 +1,93 @@
+(* Case expressions provide runtime type tests on objects *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 -- Missing "of"
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/case6_error.txt b/src/tests/parser/case6_error.txt
new file mode 100644
index 000000000..2ae2f723b
--- /dev/null
+++ b/src/tests/parser/case6_error.txt
@@ -0,0 +1 @@
+(62, 13) - SyntacticError: ERROR at or near "x"
\ No newline at end of file
diff --git a/src/tests/parser/class1.cl b/src/tests/parser/class1.cl
new file mode 100644
index 000000000..f4815e3f4
--- /dev/null
+++ b/src/tests/parser/class1.cl
@@ -0,0 +1,20 @@
+(* A class is a list of features *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    testing(): Int {
+        2 + 2
+    };
+};
+
+-- Class names must begin with uppercase letters
+class alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/class1_error.txt b/src/tests/parser/class1_error.txt
new file mode 100644
index 000000000..acaa52a6e
--- /dev/null
+++ b/src/tests/parser/class1_error.txt
@@ -0,0 +1 @@
+(16, 7) - SyntacticError: ERROR at or near "alpha"
\ No newline at end of file
diff --git a/src/tests/parser/class2.cl b/src/tests/parser/class2.cl
new file mode 100644
index 000000000..f363b032a
--- /dev/null
+++ b/src/tests/parser/class2.cl
@@ -0,0 +1,20 @@
+(* A class is a list of features *)
+
+CLaSS Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+CLaSS Test {
+    testing(): Int {
+        2 + 2
+    };
+};
+
+-- Type names must begin with uppercase letters
+CLaSS Alpha iNHeRiTS iO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/class2_error.txt b/src/tests/parser/class2_error.txt
new file mode 100644
index 000000000..59d065913
--- /dev/null
+++ b/src/tests/parser/class2_error.txt
@@ -0,0 +1 @@
+(16, 22) - SyntacticError: ERROR at or near "iO"
\ No newline at end of file
diff --git a/src/tests/parser/class3.cl b/src/tests/parser/class3.cl
new file mode 100644
index 000000000..0c801372a
--- /dev/null
+++ b/src/tests/parser/class3.cl
@@ -0,0 +1,34 @@
+(* A class is a list of features *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Missing semicolon
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    }
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/class3_error.txt b/src/tests/parser/class3_error.txt
new file mode 100644
index 000000000..bc2f946b2
--- /dev/null
+++ b/src/tests/parser/class3_error.txt
@@ -0,0 +1 @@
+(25, 5) - SyntacticError: ERROR at or near "testing3"
\ No newline at end of file
diff --git a/src/tests/parser/class4.cl b/src/tests/parser/class4.cl
new file mode 100644
index 000000000..5c286b5e6
--- /dev/null
+++ b/src/tests/parser/class4.cl
@@ -0,0 +1,36 @@
+(* A class is a list of features *)
+
+CLaSS Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+CLaSS Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    -- Only features
+    2 + 2;
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+CLaSS Alpha iNHeRiTS IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/class4_error.txt b/src/tests/parser/class4_error.txt
new file mode 100644
index 000000000..1007f033d
--- /dev/null
+++ b/src/tests/parser/class4_error.txt
@@ -0,0 +1 @@
+(25, 5) - SyntacticError: ERROR at or near "2"
\ No newline at end of file
diff --git a/src/tests/parser/class5.cl b/src/tests/parser/class5.cl
new file mode 100644
index 000000000..3f40c36eb
--- /dev/null
+++ b/src/tests/parser/class5.cl
@@ -0,0 +1,34 @@
+(* A class is a list of features *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+-- Missing '{'
+class Test
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/class5_error.txt b/src/tests/parser/class5_error.txt
new file mode 100644
index 000000000..400e4d614
--- /dev/null
+++ b/src/tests/parser/class5_error.txt
@@ -0,0 +1 @@
+(11, 5) - SyntacticError: ERROR at or near "test1"
\ No newline at end of file
diff --git a/src/tests/parser/class6.cl b/src/tests/parser/class6.cl
new file mode 100644
index 000000000..8501d2593
--- /dev/null
+++ b/src/tests/parser/class6.cl
@@ -0,0 +1,34 @@
+(* A class is a list of features *)
+
+CLaSS Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+-- Missing '}'
+CLaSS Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+;
+
+CLaSS Alpha iNHeRiTS IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/class6_error.txt b/src/tests/parser/class6_error.txt
new file mode 100644
index 000000000..73574c94c
--- /dev/null
+++ b/src/tests/parser/class6_error.txt
@@ -0,0 +1 @@
+(28, 1) - SyntacticError: ERROR at or near ";"
\ No newline at end of file
diff --git a/src/tests/parser/conditional1.cl b/src/tests/parser/conditional1.cl
new file mode 100644
index 000000000..4d546fc44
--- /dev/null
+++ b/src/tests/parser/conditional1.cl
@@ -0,0 +1,69 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        if a.length() < b.length() -- Mising "then"
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        else
+            if a.length() = b.length() then
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            else
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fi
+        fi
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/conditional1_error.txt b/src/tests/parser/conditional1_error.txt
new file mode 100644
index 000000000..ee533fd84
--- /dev/null
+++ b/src/tests/parser/conditional1_error.txt
@@ -0,0 +1 @@
+(34, 13) - SyntacticError: ERROR at or near NEW
\ No newline at end of file
diff --git a/src/tests/parser/conditional2.cl b/src/tests/parser/conditional2.cl
new file mode 100644
index 000000000..4f10c2957
--- /dev/null
+++ b/src/tests/parser/conditional2.cl
@@ -0,0 +1,69 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        if a.length() < b.length() then
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        else
+            if a.length() = b.length() then
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            else
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            -- Missing "fi"
+        fi
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/conditional2_error.txt b/src/tests/parser/conditional2_error.txt
new file mode 100644
index 000000000..c72f78d7e
--- /dev/null
+++ b/src/tests/parser/conditional2_error.txt
@@ -0,0 +1 @@
+(42, 5) - SyntacticError: ERROR at or near "}"
\ No newline at end of file
diff --git a/src/tests/parser/conditional3.cl b/src/tests/parser/conditional3.cl
new file mode 100644
index 000000000..67e991ade
--- /dev/null
+++ b/src/tests/parser/conditional3.cl
@@ -0,0 +1,69 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        iF a.length() < b.length() tHen
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        elsE
+            if a.length() = b.length() then
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            eLseif -- elseif isn't a keyword
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/conditional3_error.txt b/src/tests/parser/conditional3_error.txt
new file mode 100644
index 000000000..ad95552b5
--- /dev/null
+++ b/src/tests/parser/conditional3_error.txt
@@ -0,0 +1 @@
+(38, 13) - SyntacticError: ERROR at or near "eLseif"
\ No newline at end of file
diff --git a/src/tests/parser/conditional4.cl b/src/tests/parser/conditional4.cl
new file mode 100644
index 000000000..0792fdc85
--- /dev/null
+++ b/src/tests/parser/conditional4.cl
@@ -0,0 +1,73 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(): Int {
+        if true++ then 1 else 0 -- Condition must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/conditional4_error.txt b/src/tests/parser/conditional4_error.txt
new file mode 100644
index 000000000..f5511445b
--- /dev/null
+++ b/src/tests/parser/conditional4_error.txt
@@ -0,0 +1 @@
+(45, 17) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/conditional5.cl b/src/tests/parser/conditional5.cl
new file mode 100644
index 000000000..0c1e1aad0
--- /dev/null
+++ b/src/tests/parser/conditional5.cl
@@ -0,0 +1,73 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(): Int {
+        if true then true++ else 0 -- If branch must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/conditional5_error.txt b/src/tests/parser/conditional5_error.txt
new file mode 100644
index 000000000..b3214010d
--- /dev/null
+++ b/src/tests/parser/conditional5_error.txt
@@ -0,0 +1 @@
+(45, 27) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/conditional6.cl b/src/tests/parser/conditional6.cl
new file mode 100644
index 000000000..02310404a
--- /dev/null
+++ b/src/tests/parser/conditional6.cl
@@ -0,0 +1,73 @@
+(* A conditional has the form if <expr> then <expr> else <expr> fi *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(): Int {
+        if true then 1 else false++ -- Else branch must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/conditional6_error.txt b/src/tests/parser/conditional6_error.txt
new file mode 100644
index 000000000..968b78ad9
--- /dev/null
+++ b/src/tests/parser/conditional6_error.txt
@@ -0,0 +1 @@
+(45, 35) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch1.cl b/src/tests/parser/dispatch1.cl
new file mode 100644
index 000000000..2ca394716
--- /dev/null
+++ b/src/tests/parser/dispatch1.cl
@@ -0,0 +1,45 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        Test1.testing4(1, 2).testing4(3, 4).testing4(5, 6) -- Objet identifiers begin with a lower case letter
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch1_error.txt b/src/tests/parser/dispatch1_error.txt
new file mode 100644
index 000000000..ba8e9e84c
--- /dev/null
+++ b/src/tests/parser/dispatch1_error.txt
@@ -0,0 +1 @@
+(37, 9) - SyntacticError: ERROR at or near "Test1"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch2.cl b/src/tests/parser/dispatch2.cl
new file mode 100644
index 000000000..0b57467a1
--- /dev/null
+++ b/src/tests/parser/dispatch2.cl
@@ -0,0 +1,45 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13,) -- Extra comma
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch2_error.txt b/src/tests/parser/dispatch2_error.txt
new file mode 100644
index 000000000..134e266b2
--- /dev/null
+++ b/src/tests/parser/dispatch2_error.txt
@@ -0,0 +1 @@
+(37, 84) - SyntacticError: ERROR at or near ")"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch3.cl b/src/tests/parser/dispatch3.cl
new file mode 100644
index 000000000..9f1a5afff
--- /dev/null
+++ b/src/tests/parser/dispatch3.cl
@@ -0,0 +1,45 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).Testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13) -- Identifiers begin with a lower case letter
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch3_error.txt b/src/tests/parser/dispatch3_error.txt
new file mode 100644
index 000000000..86d2d5142
--- /dev/null
+++ b/src/tests/parser/dispatch3_error.txt
@@ -0,0 +1 @@
+(37, 38) - SyntacticError: ERROR at or near "Testing4"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch4.cl b/src/tests/parser/dispatch4.cl
new file mode 100644
index 000000000..d1efc469d
--- /dev/null
+++ b/src/tests/parser/dispatch4.cl
@@ -0,0 +1,53 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        self.testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true++) -- Arguments must be expressions
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch4_error.txt b/src/tests/parser/dispatch4_error.txt
new file mode 100644
index 000000000..d03bb4c53
--- /dev/null
+++ b/src/tests/parser/dispatch4_error.txt
@@ -0,0 +1 @@
+(45, 81) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch5.cl b/src/tests/parser/dispatch5.cl
new file mode 100644
index 000000000..63a5afa79
--- /dev/null
+++ b/src/tests/parser/dispatch5.cl
@@ -0,0 +1,53 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, ,true + fALSE) -- Extra comma
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch5_error.txt b/src/tests/parser/dispatch5_error.txt
new file mode 100644
index 000000000..3fc39c625
--- /dev/null
+++ b/src/tests/parser/dispatch5_error.txt
@@ -0,0 +1 @@
+(45, 71) - SyntacticError: ERROR at or near ","
\ No newline at end of file
diff --git a/src/tests/parser/dispatch6.cl b/src/tests/parser/dispatch6.cl
new file mode 100644
index 000000000..0a953e2e6
--- /dev/null
+++ b/src/tests/parser/dispatch6.cl
@@ -0,0 +1,57 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@object.copy() -- Type identifiers begin with a upper case letter
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch6_error.txt b/src/tests/parser/dispatch6_error.txt
new file mode 100644
index 000000000..543f3a38c
--- /dev/null
+++ b/src/tests/parser/dispatch6_error.txt
@@ -0,0 +1 @@
+(49, 15) - SyntacticError: ERROR at or near "object"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch7.cl b/src/tests/parser/dispatch7.cl
new file mode 100644
index 000000000..3ecac4d0f
--- /dev/null
+++ b/src/tests/parser/dispatch7.cl
@@ -0,0 +1,57 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.Copy() -- Identifiers begin with a lower case letter
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch7_error.txt b/src/tests/parser/dispatch7_error.txt
new file mode 100644
index 000000000..27235d118
--- /dev/null
+++ b/src/tests/parser/dispatch7_error.txt
@@ -0,0 +1 @@
+(49, 22) - SyntacticError: ERROR at or near "Copy"
\ No newline at end of file
diff --git a/src/tests/parser/dispatch8.cl b/src/tests/parser/dispatch8.cl
new file mode 100644
index 000000000..eef0455ef
--- /dev/null
+++ b/src/tests/parser/dispatch8.cl
@@ -0,0 +1,57 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy(,) -- Extra comma
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch8_error.txt b/src/tests/parser/dispatch8_error.txt
new file mode 100644
index 000000000..04704520a
--- /dev/null
+++ b/src/tests/parser/dispatch8_error.txt
@@ -0,0 +1 @@
+(49, 27) - SyntacticError: ERROR at or near ","
\ No newline at end of file
diff --git a/src/tests/parser/dispatch9.cl b/src/tests/parser/dispatch9.cl
new file mode 100644
index 000000000..5fdef22d6
--- /dev/null
+++ b/src/tests/parser/dispatch9.cl
@@ -0,0 +1,61 @@
+(* There are three forms of dispatch (i.e. method call) in Cool. The three forms differ only in how the called method is selected *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+
+    testing5(): Object {
+        test1:Object.copy() -- Must be '@' not ':'
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/dispatch9_error.txt b/src/tests/parser/dispatch9_error.txt
new file mode 100644
index 000000000..eb0b3397d
--- /dev/null
+++ b/src/tests/parser/dispatch9_error.txt
@@ -0,0 +1 @@
+(53, 14) - SyntacticError: ERROR at or near ":"
\ No newline at end of file
diff --git a/src/tests/parser/let1.cl b/src/tests/parser/let1.cl
new file mode 100644
index 000000000..576ae383c
--- /dev/null
+++ b/src/tests/parser/let1.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let Count: Int <- 0, pow: Int <- 1 -- Object identifiers starts with a lowercase letter
+        in {
+            -- count <- 0;
+            -- pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let1_error.txt b/src/tests/parser/let1_error.txt
new file mode 100644
index 000000000..8b7fe63d1
--- /dev/null
+++ b/src/tests/parser/let1_error.txt
@@ -0,0 +1 @@
+(45, 13) - SyntacticError: ERROR at or near "Count"
\ No newline at end of file
diff --git a/src/tests/parser/let2.cl b/src/tests/parser/let2.cl
new file mode 100644
index 000000000..4cfaef0f8
--- /dev/null
+++ b/src/tests/parser/let2.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int, pow: int <- 1 -- Type identifiers starts with a uppercase letter 
+        in {
+            count <- 0;
+            -- pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let2_error.txt b/src/tests/parser/let2_error.txt
new file mode 100644
index 000000000..6fb3f8e9c
--- /dev/null
+++ b/src/tests/parser/let2_error.txt
@@ -0,0 +1 @@
+(45, 30) - SyntacticError: ERROR at or near "int"
\ No newline at end of file
diff --git a/src/tests/parser/let3.cl b/src/tests/parser/let3.cl
new file mode 100644
index 000000000..91e567fd8
--- /dev/null
+++ b/src/tests/parser/let3.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int, pow: Int, -- Extra comma
+        in {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let3_error.txt b/src/tests/parser/let3_error.txt
new file mode 100644
index 000000000..71fa08812
--- /dev/null
+++ b/src/tests/parser/let3_error.txt
@@ -0,0 +1 @@
+(46, 9) - SyntacticError: ERROR at or near IN
\ No newline at end of file
diff --git a/src/tests/parser/let4.cl b/src/tests/parser/let4.cl
new file mode 100644
index 000000000..a716c332d
--- /dev/null
+++ b/src/tests/parser/let4.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- true++, pow: Int <- 1 -- Initialization must be an expression
+        in {
+            count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let4_error.txt b/src/tests/parser/let4_error.txt
new file mode 100644
index 000000000..e12c7478c
--- /dev/null
+++ b/src/tests/parser/let4_error.txt
@@ -0,0 +1 @@
+(45, 32) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/let5.cl b/src/tests/parser/let5.cl
new file mode 100644
index 000000000..d974cc138
--- /dev/null
+++ b/src/tests/parser/let5.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int = 0, pow: Int -- Must be '<-' not '=' 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let5_error.txt b/src/tests/parser/let5_error.txt
new file mode 100644
index 000000000..e561f846c
--- /dev/null
+++ b/src/tests/parser/let5_error.txt
@@ -0,0 +1 @@
+(45, 24) - SyntacticError: ERROR at or near "="
\ No newline at end of file
diff --git a/src/tests/parser/let6.cl b/src/tests/parser/let6.cl
new file mode 100644
index 000000000..b6e51d7e1
--- /dev/null
+++ b/src/tests/parser/let6.cl
@@ -0,0 +1,74 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int <- 1 
+        in false++ -- Let body must be an expression
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let6_error.txt b/src/tests/parser/let6_error.txt
new file mode 100644
index 000000000..7a77928b9
--- /dev/null
+++ b/src/tests/parser/let6_error.txt
@@ -0,0 +1 @@
+(46, 18) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/let7.cl b/src/tests/parser/let7.cl
new file mode 100644
index 000000000..6fd63e6a7
--- /dev/null
+++ b/src/tests/parser/let7.cl
@@ -0,0 +1,85 @@
+(* A let expression has the form let <id1> : <type1> [ <- <expr1> ], ..., <idn> : <typen> [ <- <exprn> ] in <expr> *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        (* Missing "in" *) {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/let7_error.txt b/src/tests/parser/let7_error.txt
new file mode 100644
index 000000000..654b1ce60
--- /dev/null
+++ b/src/tests/parser/let7_error.txt
@@ -0,0 +1 @@
+(46, 28) - SyntacticError: ERROR at or near "{"
\ No newline at end of file
diff --git a/src/tests/parser/loop1.cl b/src/tests/parser/loop1.cl
new file mode 100644
index 000000000..7d0d7688f
--- /dev/null
+++ b/src/tests/parser/loop1.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count < 1024*1024 
+        -- Missing "loop" 
+            count <- count * 2 
+        pool
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/loop1_error.txt b/src/tests/parser/loop1_error.txt
new file mode 100644
index 000000000..94248ff00
--- /dev/null
+++ b/src/tests/parser/loop1_error.txt
@@ -0,0 +1 @@
+(49, 13) - SyntacticError: ERROR at or near "count"
\ No newline at end of file
diff --git a/src/tests/parser/loop2.cl b/src/tests/parser/loop2.cl
new file mode 100644
index 000000000..a9613c487
--- /dev/null
+++ b/src/tests/parser/loop2.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count < 1024*1024 
+        loop 
+            count <- count * 2 
+        -- Missing "pool"
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/loop2_error.txt b/src/tests/parser/loop2_error.txt
new file mode 100644
index 000000000..6447101f8
--- /dev/null
+++ b/src/tests/parser/loop2_error.txt
@@ -0,0 +1 @@
+(51, 5) - SyntacticError: ERROR at or near "}"
\ No newline at end of file
diff --git a/src/tests/parser/loop3.cl b/src/tests/parser/loop3.cl
new file mode 100644
index 000000000..860adb4d1
--- /dev/null
+++ b/src/tests/parser/loop3.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count => 1024*1024 -- Condition must be an expression
+        loop 
+            count <- count * 2 
+        pool
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/loop3_error.txt b/src/tests/parser/loop3_error.txt
new file mode 100644
index 000000000..3da8bcde0
--- /dev/null
+++ b/src/tests/parser/loop3_error.txt
@@ -0,0 +1 @@
+(47, 21) - SyntacticError: ERROR at or near DARROW
\ No newline at end of file
diff --git a/src/tests/parser/loop4.cl b/src/tests/parser/loop4.cl
new file mode 100644
index 000000000..0a1194e82
--- /dev/null
+++ b/src/tests/parser/loop4.cl
@@ -0,0 +1,78 @@
+(* A loop has the form while <expr> loop <expr> pool *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    count: Int <- 1;
+
+    testing6(): Object {
+        while count < 1024*1024 
+        loop 
+            count <- true++ -- While body must be an expression
+        pool
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/loop4_error.txt b/src/tests/parser/loop4_error.txt
new file mode 100644
index 000000000..c39f35fe1
--- /dev/null
+++ b/src/tests/parser/loop4_error.txt
@@ -0,0 +1 @@
+(49, 27) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/method1.cl b/src/tests/parser/method1.cl
new file mode 100644
index 000000000..fcfbbcd30
--- /dev/null
+++ b/src/tests/parser/method1.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Method names must begin with lowercase letters
+    Testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/method1_error.txt b/src/tests/parser/method1_error.txt
new file mode 100644
index 000000000..0eff41999
--- /dev/null
+++ b/src/tests/parser/method1_error.txt
@@ -0,0 +1 @@
+(21, 5) - SyntacticError: ERROR at or near "Testing2"
\ No newline at end of file
diff --git a/src/tests/parser/method2.cl b/src/tests/parser/method2.cl
new file mode 100644
index 000000000..d5bdfd85c
--- /dev/null
+++ b/src/tests/parser/method2.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Parameter names must begin with lowercase letters
+    testing2(a: Alpha, B: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/method2_error.txt b/src/tests/parser/method2_error.txt
new file mode 100644
index 000000000..1843fb7b4
--- /dev/null
+++ b/src/tests/parser/method2_error.txt
@@ -0,0 +1 @@
+(21, 24) - SyntacticError: ERROR at or near "B"
\ No newline at end of file
diff --git a/src/tests/parser/method3.cl b/src/tests/parser/method3.cl
new file mode 100644
index 000000000..1e5c9eb53
--- /dev/null
+++ b/src/tests/parser/method3.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Type names must begin with uppercase letters
+    testing2(a: Alpha, b: int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/method3_error.txt b/src/tests/parser/method3_error.txt
new file mode 100644
index 000000000..dbecf552e
--- /dev/null
+++ b/src/tests/parser/method3_error.txt
@@ -0,0 +1 @@
+(21, 27) - SyntacticError: ERROR at or near "int"
\ No newline at end of file
diff --git a/src/tests/parser/method4.cl b/src/tests/parser/method4.cl
new file mode 100644
index 000000000..019ada276
--- /dev/null
+++ b/src/tests/parser/method4.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    -- Missing paremeter
+    testing3(x: Int,): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/method4_error.txt b/src/tests/parser/method4_error.txt
new file mode 100644
index 000000000..6421cee2b
--- /dev/null
+++ b/src/tests/parser/method4_error.txt
@@ -0,0 +1 @@
+(25, 21) - SyntacticError: ERROR at or near ")"
\ No newline at end of file
diff --git a/src/tests/parser/method5.cl b/src/tests/parser/method5.cl
new file mode 100644
index 000000000..13127f664
--- /dev/null
+++ b/src/tests/parser/method5.cl
@@ -0,0 +1,34 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    -- Type names must begin with uppercase letters
+    testing3(): string {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/method5_error.txt b/src/tests/parser/method5_error.txt
new file mode 100644
index 000000000..9bda07041
--- /dev/null
+++ b/src/tests/parser/method5_error.txt
@@ -0,0 +1 @@
+(25, 17) - SyntacticError: ERROR at or near "string"
\ No newline at end of file
diff --git a/src/tests/parser/method6.cl b/src/tests/parser/method6.cl
new file mode 100644
index 000000000..d48cd1293
--- /dev/null
+++ b/src/tests/parser/method6.cl
@@ -0,0 +1,33 @@
+(* A method of class A is a procedure that may manipulate the variables and objects of class A *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    -- Body can't be empty
+    testing2(a: Alpha, b: Int): Int {
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/method6_error.txt b/src/tests/parser/method6_error.txt
new file mode 100644
index 000000000..e7d5de400
--- /dev/null
+++ b/src/tests/parser/method6_error.txt
@@ -0,0 +1 @@
+(22, 5) - SyntacticError: ERROR at or near "}"
\ No newline at end of file
diff --git a/src/tests/parser/mixed1.cl b/src/tests/parser/mixed1.cl
new file mode 100644
index 000000000..a27879513
--- /dev/null
+++ b/src/tests/parser/mixed1.cl
@@ -0,0 +1,100 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        in isvoid (3 + a * (x / w + new Int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+}-- Mising ";"
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/mixed1_error.txt b/src/tests/parser/mixed1_error.txt
new file mode 100644
index 000000000..d5b0ff8bb
--- /dev/null
+++ b/src/tests/parser/mixed1_error.txt
@@ -0,0 +1 @@
+(76, 1) - SyntacticError: ERROR at or near CLASS
\ No newline at end of file
diff --git a/src/tests/parser/mixed2.cl b/src/tests/parser/mixed2.cl
new file mode 100644
index 000000000..f5477e0bb
--- /dev/null
+++ b/src/tests/parser/mixed2.cl
@@ -0,0 +1,14 @@
+class Main {
+        main(): Object {
+                (new Alpha).print()
+        };
+
+};
+
+(* Class names must begin with uppercase letters *)
+class alpha inherits IO {
+    print() : Object {
+            out_string("reached!!\n");
+    };
+};
+
diff --git a/src/tests/parser/mixed2_error.txt b/src/tests/parser/mixed2_error.txt
new file mode 100644
index 000000000..b5613c52a
--- /dev/null
+++ b/src/tests/parser/mixed2_error.txt
@@ -0,0 +1 @@
+(9, 7) - SyntacticError: ERROR at or near "alpha"
\ No newline at end of file
diff --git a/src/tests/parser/mixed3.cl b/src/tests/parser/mixed3.cl
new file mode 100644
index 000000000..1bdcad743
--- /dev/null
+++ b/src/tests/parser/mixed3.cl
@@ -0,0 +1,40 @@
+class Main inherits IO {
+    main() : Object {
+        {
+            out_string("Enter a number to check if number is prime\n");
+            let i : Int <- in_int() in {
+                if(i <= 1) then {
+                    out_string("Invalid Input\n");
+                    abort();
+                } else {
+                    if (isPrime(i) = 1) then
+                        out_string("Number is prime\n")
+                    else
+                        out_string("Number is composite\n")
+                    fi;
+                }
+                fi;
+            };
+        }
+    };
+
+    mod(i : Int, ) : Int {    -- Formal list must be comma separated. A comma does not terminate a list of formals.
+      i - (i/k)*k
+    };
+
+    isPrime(i : Int) : Int {
+        {
+            let x : Int <- 2,
+                c : Int <- 1 in
+            {
+                while (not (x = i)) loop
+                if (mod(i, x) = 0) then {
+                    c <- 0;
+                    x <- i;
+                } else x <- x + 1 fi
+                pool;
+                c;
+            };
+        }
+    };
+};
diff --git a/src/tests/parser/mixed3_error.txt b/src/tests/parser/mixed3_error.txt
new file mode 100644
index 000000000..159bdca63
--- /dev/null
+++ b/src/tests/parser/mixed3_error.txt
@@ -0,0 +1 @@
+(21, 18) - SyntacticError: ERROR at or near ")"
\ No newline at end of file
diff --git a/src/tests/parser/mixed4.cl b/src/tests/parser/mixed4.cl
new file mode 100644
index 000000000..e752253be
--- /dev/null
+++ b/src/tests/parser/mixed4.cl
@@ -0,0 +1,21 @@
+class Main inherits IO {
+    main() : Object {
+            {
+                    out_string("Enter number of numbers to multiply\n");
+                    out_int(prod(in_int()));
+                    out_string("\n");
+            }
+    };
+
+    prod(i : Int) : Int {
+        let y : Int <- 1 in {
+                while (not (i = 0) ) loop {
+                        out_string("Enter Number: ");
+                        y <- y * in_int(Main : Int);    -- the parser correctly catches the error here
+                        i <- i - 1;
+                }
+                    pool;
+                y;
+        }
+    };
+};
diff --git a/src/tests/parser/mixed4_error.txt b/src/tests/parser/mixed4_error.txt
new file mode 100644
index 000000000..2349f28a5
--- /dev/null
+++ b/src/tests/parser/mixed4_error.txt
@@ -0,0 +1 @@
+(14, 41) - SyntacticError: ERROR at or near "Main"
\ No newline at end of file
diff --git a/src/tests/parser/mixed5.cl b/src/tests/parser/mixed5.cl
new file mode 100644
index 000000000..c9176a890
--- /dev/null
+++ b/src/tests/parser/mixed5.cl
@@ -0,0 +1,20 @@
+class Main inherits IO {
+    str <- "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
+    main() : Object {
+            {
+                    out_string("Enter number of numbers to multiply\n");
+                    out_int(prod(in_int()));
+                    out_string("\n");
+            }
+    };
+    prod(i : Int) : Int {
+        let y : Int <- 1 in {
+            while (not (i = 0) ) loop {
+                out_string("Enter Number: ");
+                y <- y * in_int();
+                i <- i - 1;
+            }
+            y;
+        }
+    };
+}
diff --git a/src/tests/parser/mixed5_error.txt b/src/tests/parser/mixed5_error.txt
new file mode 100644
index 000000000..443037eca
--- /dev/null
+++ b/src/tests/parser/mixed5_error.txt
@@ -0,0 +1 @@
+(2, 9) - SyntacticError: ERROR at or near ASSIGN
\ No newline at end of file
diff --git a/src/tests/parser/mixed6.cl b/src/tests/parser/mixed6.cl
new file mode 100644
index 000000000..5da80da31
--- /dev/null
+++ b/src/tests/parser/mixed6.cl
@@ -0,0 +1,5 @@
+classs Doom {
+    i : Int <- 0;
+    main() : Object {
+            if i = 0 then out_string("This is da real *h*t")
+
diff --git a/src/tests/parser/mixed6_error.txt b/src/tests/parser/mixed6_error.txt
new file mode 100644
index 000000000..af75ca925
--- /dev/null
+++ b/src/tests/parser/mixed6_error.txt
@@ -0,0 +1 @@
+(1, 1) - SyntacticError: ERROR at or near "classs"
\ No newline at end of file
diff --git a/src/tests/parser/operation1.cl b/src/tests/parser/operation1.cl
new file mode 100644
index 000000000..d38eb72d0
--- /dev/null
+++ b/src/tests/parser/operation1.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Missing ')'
+        in isvoid (3 + a * (x / w + new Int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a)/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/operation1_error.txt b/src/tests/parser/operation1_error.txt
new file mode 100644
index 000000000..b30202399
--- /dev/null
+++ b/src/tests/parser/operation1_error.txt
@@ -0,0 +1 @@
+(74, 5) - SyntacticError: ERROR at or near "}"
\ No newline at end of file
diff --git a/src/tests/parser/operation2.cl b/src/tests/parser/operation2.cl
new file mode 100644
index 000000000..2dc628359
--- /dev/null
+++ b/src/tests/parser/operation2.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Type identifiers starts with a uppercase letter
+        in isvoid (3 + a * (x / w + new int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/operation2_error.txt b/src/tests/parser/operation2_error.txt
new file mode 100644
index 000000000..37b458f3a
--- /dev/null
+++ b/src/tests/parser/operation2_error.txt
@@ -0,0 +1 @@
+(73, 41) - SyntacticError: ERROR at or near "int"
\ No newline at end of file
diff --git a/src/tests/parser/operation3.cl b/src/tests/parser/operation3.cl
new file mode 100644
index 000000000..61d6cbfa8
--- /dev/null
+++ b/src/tests/parser/operation3.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Object identifiers starts with a lowercase letter
+        in isvoid (3 + a * (x / w + new Int) - y - (((if tRue = not faLSe then ~Mazinger_Z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/operation3_error.txt b/src/tests/parser/operation3_error.txt
new file mode 100644
index 000000000..6b266f3f3
--- /dev/null
+++ b/src/tests/parser/operation3_error.txt
@@ -0,0 +1 @@
+(73, 81) - SyntacticError: ERROR at or near "Mazinger_Z"
\ No newline at end of file
diff --git a/src/tests/parser/operation4.cl b/src/tests/parser/operation4.cl
new file mode 100644
index 000000000..bae7de5b5
--- /dev/null
+++ b/src/tests/parser/operation4.cl
@@ -0,0 +1,101 @@
+(* Cool has four binary arithmetic operations: +, -, *, /. *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    test1: Object;
+    
+    testing1(): Int {
+        2 + 2
+    };
+
+    test2: Int <- 1;
+
+    test3: String <- "1";
+
+    testing2(a: Alpha, b: Int): Int {
+        2 + 2
+    };
+
+    testing3(): String {
+        "2 + 2"
+    };
+
+    testing4(x: Int, y: Int): Test {
+        self
+    };
+
+    testing5(a: String, b: String): IO {
+        If a.length() < b.length() THeN
+            new IO.out_string("La cadena \"".concat(b).concat("\" es mas larga que la cadena \"").concat(a).concat("\"."))
+        eLSe
+            if a.length() = b.length() THeN
+                new IO.out_string("La cadena \"".concat(a).concat("\" mide igual que la cadena \"").concat(b).concat("\"."))
+            ElsE
+                new IO.out_string("La cadena \"".concat(a).concat("\" es mas larga que la cadena \"").concat(b).concat("\"."))
+            fI
+        Fi
+    };
+
+    testing6(a: Int): IO {
+        let count: Int <- 0, pow: Int 
+        in {
+            -- count <- 0;
+            pow <- 1;
+            while pow < a 
+            loop 
+                {
+                    count <- count + 1;
+                    pow <- pow * 2;
+                } 
+            pool;
+            new IO.out_string("El logaritmo en base 2 de ").out_int(a).out_string(" es ").out_int(count);
+        }
+    };
+
+    testing7(): Object {
+        case 2 + 2 of
+            x: Int => new IO.out_string("Es un entero!");
+            y: String => new IO.out_string("Es una cadena!"); 
+            z: Bool => new IO.out_string("Es un booleano!");
+        esac
+    };
+
+    a: Int <- 1;
+
+    testing8(x: Int, y: Int): Bool {
+        let z: Int <- 3, w: Int <- 4
+        -- Double "+"
+        in isvoid (3 + a * (x / w++ new Int) - y - (((if tRue = not faLSe then ~z else 3 <= 4 + "hey".length() fi + a))/(0)*(((4 * 4)))))
+    };
+};
+
+class Test2 {
+    test1: Test <- new Test;
+
+    testing1(): Test {
+        test1.testing4(1 + 1, 1 + 2).testing4(2 + 3, 3 + 5).testing4(5 + 8, 8 + 13)
+    };
+
+    testing2(x: Int, y: Int): Test2 {
+        self
+    };
+
+    testing3(): Test2 {
+        testing2(1 + 1, 1 + 2).testing2(2 + 3, 3 + 5).testing2(5 + 8, true + fALSE)
+    };
+
+    testing4(): Object {
+        test1@Object.copy()
+    };
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
\ No newline at end of file
diff --git a/src/tests/parser/operation4_error.txt b/src/tests/parser/operation4_error.txt
new file mode 100644
index 000000000..e0ebb0985
--- /dev/null
+++ b/src/tests/parser/operation4_error.txt
@@ -0,0 +1 @@
+(73, 35) - SyntacticError: ERROR at or near "+"
\ No newline at end of file
diff --git a/src/tests/parser/program1.cl b/src/tests/parser/program1.cl
new file mode 100644
index 000000000..8e5cf617f
--- /dev/null
+++ b/src/tests/parser/program1.cl
@@ -0,0 +1 @@
+(* A Cool program can't be empty *)
\ No newline at end of file
diff --git a/src/tests/parser/program1_error.txt b/src/tests/parser/program1_error.txt
new file mode 100644
index 000000000..de00ac46b
--- /dev/null
+++ b/src/tests/parser/program1_error.txt
@@ -0,0 +1 @@
+(0, 0) - SyntacticError: ERROR at or near EOF
\ No newline at end of file
diff --git a/src/tests/parser/program2.cl b/src/tests/parser/program2.cl
new file mode 100644
index 000000000..f8b16779c
--- /dev/null
+++ b/src/tests/parser/program2.cl
@@ -0,0 +1,20 @@
+(* Cool programs are sets of classes *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+-- Missing semicolon
+class Test {
+    testing(): Int {
+        2 + 2
+    };
+}
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/program2_error.txt b/src/tests/parser/program2_error.txt
new file mode 100644
index 000000000..94ba8df65
--- /dev/null
+++ b/src/tests/parser/program2_error.txt
@@ -0,0 +1 @@
+(16, 1) - SyntacticError: ERROR at or near CLASS
\ No newline at end of file
diff --git a/src/tests/parser/program3.cl b/src/tests/parser/program3.cl
new file mode 100644
index 000000000..e27889c57
--- /dev/null
+++ b/src/tests/parser/program3.cl
@@ -0,0 +1,24 @@
+(* Cool programs are sets of classes *)
+
+class Main {
+    main(): Object {
+        (new Alpha).print()
+    };
+};
+
+class Test {
+    testing(): Int {
+        2 + 2
+    };
+};
+
+-- Only classes
+suma(a: Int, b: Int) int {
+    a + b
+};
+
+class Alpha inherits IO {
+    print() : Object {
+        out_string("reached!!\n")
+    };
+};
diff --git a/src/tests/parser/program3_error.txt b/src/tests/parser/program3_error.txt
new file mode 100644
index 000000000..dd3b3947a
--- /dev/null
+++ b/src/tests/parser/program3_error.txt
@@ -0,0 +1 @@
+(16, 1) - SyntacticError: ERROR at or near "suma"
\ No newline at end of file
diff --git a/src/tests/parser_test.py b/src/tests/parser_test.py
new file mode 100644
index 000000000..129c0f20a
--- /dev/null
+++ b/src/tests/parser_test.py
@@ -0,0 +1,13 @@
+import pytest
+import os
+from utils import compare_errors
+
+tests_dir = __file__.rpartition('/')[0] + '/parser/'
+tests = [(file) for file in os.listdir(tests_dir) if file.endswith('.cl')]
+
+@pytest.mark.parser
+@pytest.mark.error
+@pytest.mark.run(order=2)
+@pytest.mark.parametrize("cool_file", tests)
+def test_parser_errors(compiler_path, cool_file):
+    compare_errors(compiler_path, tests_dir + cool_file, tests_dir + cool_file[:-3] + '_error.txt')
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic1.cl b/src/tests/semantic/arithmetic1.cl
new file mode 100644
index 000000000..bf94eb194
--- /dev/null
+++ b/src/tests/semantic/arithmetic1.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 * 2 / 3 - 4 + new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x + new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic10.cl b/src/tests/semantic/arithmetic10.cl
new file mode 100644
index 000000000..bbfe6cdb3
--- /dev/null
+++ b/src/tests/semantic/arithmetic10.cl
@@ -0,0 +1,15 @@
+(*
+The expression ~<expr> is the integer
+complement of <expr>. The expression <expr> must have static type Int and the entire expression
+has static type Int.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in ~new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic10_error.txt b/src/tests/semantic/arithmetic10_error.txt
new file mode 100644
index 000000000..b2be0476f
--- /dev/null
+++ b/src/tests/semantic/arithmetic10_error.txt
@@ -0,0 +1 @@
+(13, 19) - TypeError: Inferred type Int of initialization of attribute test does not conform to declared type Bool.
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic11.cl b/src/tests/semantic/arithmetic11.cl
new file mode 100644
index 000000000..fc067dc1a
--- /dev/null
+++ b/src/tests/semantic/arithmetic11.cl
@@ -0,0 +1,14 @@
+(*
+The expression not <expr> is the boolean complement of <expr>. The expression
+<expr> must have static type Bool and the entire expression has static type Bool.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in not 1 + new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic11_error.txt b/src/tests/semantic/arithmetic11_error.txt
new file mode 100644
index 000000000..bb4b8e1ca
--- /dev/null
+++ b/src/tests/semantic/arithmetic11_error.txt
@@ -0,0 +1 @@
+(13, 24) - TypeError: Argument of 'not' has type Int instead of Bool.
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic12.cl b/src/tests/semantic/arithmetic12.cl
new file mode 100644
index 000000000..2e012fc41
--- /dev/null
+++ b/src/tests/semantic/arithmetic12.cl
@@ -0,0 +1,14 @@
+(*
+The expression not <expr> is the boolean complement of <expr>. The expression
+<expr> must have static type Bool and the entire expression has static type Bool.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in not 1 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic12_error.txt b/src/tests/semantic/arithmetic12_error.txt
new file mode 100644
index 000000000..d25eab65e
--- /dev/null
+++ b/src/tests/semantic/arithmetic12_error.txt
@@ -0,0 +1 @@
+(12, 18) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type Int.
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic1_error.txt b/src/tests/semantic/arithmetic1_error.txt
new file mode 100644
index 000000000..a74ebf3da
--- /dev/null
+++ b/src/tests/semantic/arithmetic1_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int + String 
diff --git a/src/tests/semantic/arithmetic2.cl b/src/tests/semantic/arithmetic2.cl
new file mode 100644
index 000000000..59532573d
--- /dev/null
+++ b/src/tests/semantic/arithmetic2.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 + 2 * 3 / 4 - new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x - new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic2_error.txt b/src/tests/semantic/arithmetic2_error.txt
new file mode 100644
index 000000000..2c7952af8
--- /dev/null
+++ b/src/tests/semantic/arithmetic2_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int - String
diff --git a/src/tests/semantic/arithmetic3.cl b/src/tests/semantic/arithmetic3.cl
new file mode 100644
index 000000000..b208957f5
--- /dev/null
+++ b/src/tests/semantic/arithmetic3.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 - 2 + 3 * 4 / new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x / new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic3_error.txt b/src/tests/semantic/arithmetic3_error.txt
new file mode 100644
index 000000000..81d88331a
--- /dev/null
+++ b/src/tests/semantic/arithmetic3_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int / String
diff --git a/src/tests/semantic/arithmetic4.cl b/src/tests/semantic/arithmetic4.cl
new file mode 100644
index 000000000..2c7dd4fc9
--- /dev/null
+++ b/src/tests/semantic/arithmetic4.cl
@@ -0,0 +1,11 @@
+--The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Int <- 1 / 2 - 3 + 4 * new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x * new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic4_error.txt b/src/tests/semantic/arithmetic4_error.txt
new file mode 100644
index 000000000..1ca6df022
--- /dev/null
+++ b/src/tests/semantic/arithmetic4_error.txt
@@ -0,0 +1 @@
+(10, 27) - TypeError: non-Int arguments: Int * String
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic5.cl b/src/tests/semantic/arithmetic5.cl
new file mode 100644
index 000000000..bc08c6e82
--- /dev/null
+++ b/src/tests/semantic/arithmetic5.cl
@@ -0,0 +1,11 @@
+--The static type of the expression is Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Int <- 1 / 2 - 3 + 4 * new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in x <- x * new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic5_error.txt b/src/tests/semantic/arithmetic5_error.txt
new file mode 100644
index 000000000..dd5346844
--- /dev/null
+++ b/src/tests/semantic/arithmetic5_error.txt
@@ -0,0 +1 @@
+(9, 19) - TypeError: Inferred type Int of initialization of attribute test does not conform to declared type Bool.
diff --git a/src/tests/semantic/arithmetic6.cl b/src/tests/semantic/arithmetic6.cl
new file mode 100644
index 000000000..a0c3d03ff
--- /dev/null
+++ b/src/tests/semantic/arithmetic6.cl
@@ -0,0 +1,11 @@
+ --The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 <= new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 <= new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
diff --git a/src/tests/semantic/arithmetic6_error.txt b/src/tests/semantic/arithmetic6_error.txt
new file mode 100644
index 000000000..2e43dfc17
--- /dev/null
+++ b/src/tests/semantic/arithmetic6_error.txt
@@ -0,0 +1 @@
+(10, 22) - TypeError: non-Int arguments: Int <= String
diff --git a/src/tests/semantic/arithmetic7.cl b/src/tests/semantic/arithmetic7.cl
new file mode 100644
index 000000000..c00c75cde
--- /dev/null
+++ b/src/tests/semantic/arithmetic7.cl
@@ -0,0 +1,12 @@
+ --The static types of the two sub-expressions must be Int.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Bool <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 < new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
+ 
diff --git a/src/tests/semantic/arithmetic7_error.txt b/src/tests/semantic/arithmetic7_error.txt
new file mode 100644
index 000000000..6f3537117
--- /dev/null
+++ b/src/tests/semantic/arithmetic7_error.txt
@@ -0,0 +1 @@
+(10, 22) - TypeError: non-Int arguments: Int < String
diff --git a/src/tests/semantic/arithmetic8.cl b/src/tests/semantic/arithmetic8.cl
new file mode 100644
index 000000000..3210bdb8a
--- /dev/null
+++ b/src/tests/semantic/arithmetic8.cl
@@ -0,0 +1,13 @@
+ --The rules are exactly the same as for the binary arithmetic operations, except that the result is a Bool.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length();
+};
+ 
+ 
diff --git a/src/tests/semantic/arithmetic8_error.txt b/src/tests/semantic/arithmetic8_error.txt
new file mode 100644
index 000000000..ebcaa3797
--- /dev/null
+++ b/src/tests/semantic/arithmetic8_error.txt
@@ -0,0 +1 @@
+(9, 18) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type Int.
diff --git a/src/tests/semantic/arithmetic9.cl b/src/tests/semantic/arithmetic9.cl
new file mode 100644
index 000000000..95579e134
--- /dev/null
+++ b/src/tests/semantic/arithmetic9.cl
@@ -0,0 +1,15 @@
+(*
+The expression ~<expr> is the integer
+complement of <expr>. The expression <expr> must have static type Int and the entire expression
+has static type Int.
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+	test: Int <- let x: Bool <- 1 / 2 - 3 + 4 < new A.type_name().concat(new B.type_name().concat(new C.type_name())).length()
+				in 1 + ~new A.type_name().concat(new B.type_name().concat(new C.type_name()));
+};
\ No newline at end of file
diff --git a/src/tests/semantic/arithmetic9_error.txt b/src/tests/semantic/arithmetic9_error.txt
new file mode 100644
index 000000000..99fafbbfc
--- /dev/null
+++ b/src/tests/semantic/arithmetic9_error.txt
@@ -0,0 +1 @@
+(14, 25) - TypeError: Argument of '~' has type String instead of Int.
\ No newline at end of file
diff --git a/src/tests/semantic/assignment1.cl b/src/tests/semantic/assignment1.cl
new file mode 100644
index 000000000..19ab70219
--- /dev/null
+++ b/src/tests/semantic/assignment1.cl
@@ -0,0 +1,7 @@
+--The static type of the expression must conform to the declared type of the identifier
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: Int <- "String";
+}; 
diff --git a/src/tests/semantic/assignment1_error.txt b/src/tests/semantic/assignment1_error.txt
new file mode 100644
index 000000000..6eb883012
--- /dev/null
+++ b/src/tests/semantic/assignment1_error.txt
@@ -0,0 +1 @@
+(6, 18) - TypeError: Inferred type String of initialization of attribute test does not conform to declared type Int.
diff --git a/src/tests/semantic/assignment2.cl b/src/tests/semantic/assignment2.cl
new file mode 100644
index 000000000..cace221ae
--- /dev/null
+++ b/src/tests/semantic/assignment2.cl
@@ -0,0 +1,13 @@
+--The static type of an assignment is the static type of <expr>.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A): B { a <- new C };
+	test2(a: A): D { a <- new C };
+}; 
diff --git a/src/tests/semantic/assignment2_error.txt b/src/tests/semantic/assignment2_error.txt
new file mode 100644
index 000000000..ed10b7f38
--- /dev/null
+++ b/src/tests/semantic/assignment2_error.txt
@@ -0,0 +1 @@
+(12, 22) - TypeError: Inferred return type C of method test2 does not conform to declared return type D.
diff --git a/src/tests/semantic/assignment3.cl b/src/tests/semantic/assignment3.cl
new file mode 100644
index 000000000..eba0d69e2
--- /dev/null
+++ b/src/tests/semantic/assignment3.cl
@@ -0,0 +1,14 @@
+--The static type of an assignment is the static type of <expr>.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: A;
+	b: B <- a <- new C;
+	d: D <- a <- new C;
+}; 
diff --git a/src/tests/semantic/assignment3_error.txt b/src/tests/semantic/assignment3_error.txt
new file mode 100644
index 000000000..bc9a718cc
--- /dev/null
+++ b/src/tests/semantic/assignment3_error.txt
@@ -0,0 +1 @@
+(13, 13) - TypeError: Inferred type C of initialization of attribute d does not conform to declared type D.
\ No newline at end of file
diff --git a/src/tests/semantic/attributes1.cl b/src/tests/semantic/attributes1.cl
new file mode 100644
index 000000000..3fa0440e4
--- /dev/null
+++ b/src/tests/semantic/attributes1.cl
@@ -0,0 +1,13 @@
+--The static type of the expression must conform to the declared type of the attribute.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	test1: IO <- new Main;
+	test2: B <- new A;
+
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/attributes1_error.txt b/src/tests/semantic/attributes1_error.txt
new file mode 100644
index 000000000..9cb8460c9
--- /dev/null
+++ b/src/tests/semantic/attributes1_error.txt
@@ -0,0 +1 @@
+(10, 17) - TypeError: Inferred type A of initialization of attribute test2 does not conform to declared type B. 
diff --git a/src/tests/semantic/attributes2.cl b/src/tests/semantic/attributes2.cl
new file mode 100644
index 000000000..7937c2cc8
--- /dev/null
+++ b/src/tests/semantic/attributes2.cl
@@ -0,0 +1,13 @@
+--The static type of the expression must conform to the declared type of the attribute.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	test1: IO <- new Main;
+	test2: C <- new D;
+
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/attributes2_error.txt b/src/tests/semantic/attributes2_error.txt
new file mode 100644
index 000000000..6d601b7cd
--- /dev/null
+++ b/src/tests/semantic/attributes2_error.txt
@@ -0,0 +1 @@
+(10, 17) - TypeError: Inferred type D of initialization of attribute test2 does not conform to declared type C. 
diff --git a/src/tests/semantic/attributes3.cl b/src/tests/semantic/attributes3.cl
new file mode 100644
index 000000000..8a67decd1
--- /dev/null
+++ b/src/tests/semantic/attributes3.cl
@@ -0,0 +1,25 @@
+--Attributes are local to the class in which they are defined or inherited.
+
+class A {
+	a: Int <- 5;
+	test(x1: Int, y1: Int): Int {
+		let x: Int <- x1, y: Int <-y1 in {
+			x <- x + a;
+			y <- y + a;
+			if b then x + y else x - y fi;
+		}
+	};
+};
+class B inherits A {
+	b: Bool <- true; 
+};
+class C inherits B {
+	c: String <- "C"; 
+};
+class D inherits B {
+	d: IO <- new Main.main();
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!") };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/attributes3_error.txt b/src/tests/semantic/attributes3_error.txt
new file mode 100644
index 000000000..6195c816c
--- /dev/null
+++ b/src/tests/semantic/attributes3_error.txt
@@ -0,0 +1 @@
+(9, 16) - NameError: Undeclared identifier b.
diff --git a/src/tests/semantic/attributes4.cl b/src/tests/semantic/attributes4.cl
new file mode 100644
index 000000000..a7f63adbd
--- /dev/null
+++ b/src/tests/semantic/attributes4.cl
@@ -0,0 +1,39 @@
+--Attributes are local to the class in which they are defined or inherited.
+
+class A {
+	a: Int <- 5;
+};
+class B inherits A {
+	b: Bool <- true;
+	test(x1: Int, y1: Int): Int {
+		let x: Int <- x1, y: Int <-y1 in {
+			x <- x + a;
+			y <- y + a;
+			if b then x + y else x - y fi;
+		}
+	};
+};
+class D inherits B {
+	d: IO <- new Main.main();
+	test3(x1: Int, y1: Int): IO {
+		let x: Int <- x1, y: Int <-y1, c: String <- "C" in {
+			x <- x + a;
+			y <- y + a;
+			if b then new IO.out_string(c) else d fi;
+		}
+	};
+};
+class C inherits B {
+	c: String <- "C";
+	test2(x1: Int, y1: Int): IO {
+		let x: Int <- x1, y: Int <-y1 in {
+			x <- x + a;
+			y <- y + a;
+			if b then new IO.out_string(c) else d fi;
+		}
+	};
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!") };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/attributes4_error.txt b/src/tests/semantic/attributes4_error.txt
new file mode 100644
index 000000000..fa5fcfa89
--- /dev/null
+++ b/src/tests/semantic/attributes4_error.txt
@@ -0,0 +1 @@
+(32, 49) - NameError: Undeclared identifier d.
\ No newline at end of file
diff --git a/src/tests/semantic/basics1.cl b/src/tests/semantic/basics1.cl
new file mode 100644
index 000000000..32ae16564
--- /dev/null
+++ b/src/tests/semantic/basics1.cl
@@ -0,0 +1,10 @@
+-- It is an error to redefine the IO class.
+
+class IO {
+	scan(): String { ":)" };
+	print(s: String): IO { new IO };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics1_error.txt b/src/tests/semantic/basics1_error.txt
new file mode 100644
index 000000000..676f5049c
--- /dev/null
+++ b/src/tests/semantic/basics1_error.txt
@@ -0,0 +1 @@
+(3, 7) - SemanticError: Redefinition of basic class IO. 
diff --git a/src/tests/semantic/basics2.cl b/src/tests/semantic/basics2.cl
new file mode 100644
index 000000000..cf2b1cd2f
--- /dev/null
+++ b/src/tests/semantic/basics2.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Int.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class A inherits Int {
+	is_prime(): Bool { false };
+};
diff --git a/src/tests/semantic/basics2_error.txt b/src/tests/semantic/basics2_error.txt
new file mode 100644
index 000000000..69a3b6814
--- /dev/null
+++ b/src/tests/semantic/basics2_error.txt
@@ -0,0 +1 @@
+(7, 18) - SemanticError: Class A cannot inherit class Int. 
diff --git a/src/tests/semantic/basics3.cl b/src/tests/semantic/basics3.cl
new file mode 100644
index 000000000..fef017a8d
--- /dev/null
+++ b/src/tests/semantic/basics3.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Int.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class Int {
+	is_prime(): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics3_error.txt b/src/tests/semantic/basics3_error.txt
new file mode 100644
index 000000000..d8f80cb12
--- /dev/null
+++ b/src/tests/semantic/basics3_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class Int. 
diff --git a/src/tests/semantic/basics4.cl b/src/tests/semantic/basics4.cl
new file mode 100644
index 000000000..9266ec79b
--- /dev/null
+++ b/src/tests/semantic/basics4.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine String.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class A inherits String {
+	is_palindrome(): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics4_error.txt b/src/tests/semantic/basics4_error.txt
new file mode 100644
index 000000000..d5cd4c3db
--- /dev/null
+++ b/src/tests/semantic/basics4_error.txt
@@ -0,0 +1 @@
+(7, 18) - SemanticError: Class A cannot inherit class String. 
diff --git a/src/tests/semantic/basics5.cl b/src/tests/semantic/basics5.cl
new file mode 100644
index 000000000..bad5eff13
--- /dev/null
+++ b/src/tests/semantic/basics5.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine String.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class String {
+	is_palindrome(): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics5_error.txt b/src/tests/semantic/basics5_error.txt
new file mode 100644
index 000000000..8437accf7
--- /dev/null
+++ b/src/tests/semantic/basics5_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class String.
diff --git a/src/tests/semantic/basics6.cl b/src/tests/semantic/basics6.cl
new file mode 100644
index 000000000..47266ebed
--- /dev/null
+++ b/src/tests/semantic/basics6.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Bool.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class A inherits Bool {
+	xor(b: Bool): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics6_error.txt b/src/tests/semantic/basics6_error.txt
new file mode 100644
index 000000000..b4d22da13
--- /dev/null
+++ b/src/tests/semantic/basics6_error.txt
@@ -0,0 +1 @@
+(7, 18) - SemanticError: Class A cannot inherit class Bool.
diff --git a/src/tests/semantic/basics7.cl b/src/tests/semantic/basics7.cl
new file mode 100644
index 000000000..0f30aaec3
--- /dev/null
+++ b/src/tests/semantic/basics7.cl
@@ -0,0 +1,9 @@
+-- It is an error to inherit from or redefine Bool.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class Bool {
+	xor(b: Bool): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics7_error.txt b/src/tests/semantic/basics7_error.txt
new file mode 100644
index 000000000..92660ab9f
--- /dev/null
+++ b/src/tests/semantic/basics7_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class Bool.
diff --git a/src/tests/semantic/basics8.cl b/src/tests/semantic/basics8.cl
new file mode 100644
index 000000000..3b9697d4f
--- /dev/null
+++ b/src/tests/semantic/basics8.cl
@@ -0,0 +1,9 @@
+-- It is an error redefine Object.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+}; 
+ 
+class Object {
+	xor(b: Bool): Bool { false };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/basics8_error.txt b/src/tests/semantic/basics8_error.txt
new file mode 100644
index 000000000..652f47b30
--- /dev/null
+++ b/src/tests/semantic/basics8_error.txt
@@ -0,0 +1 @@
+(7, 7) - SemanticError: Redefinition of basic class Object.
diff --git a/src/tests/semantic/blocks1.cl b/src/tests/semantic/blocks1.cl
new file mode 100644
index 000000000..1e928908b
--- /dev/null
+++ b/src/tests/semantic/blocks1.cl
@@ -0,0 +1,31 @@
+--The static type of a block is the static type of the last expression.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: B <- {
+		new A;
+		{ 
+			new B;
+			{
+				new C;
+				{
+					new D;
+					{
+						new E;
+						{
+							new F;
+						};
+					};
+				};
+			};
+		};
+	};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/blocks1_error.txt b/src/tests/semantic/blocks1_error.txt
new file mode 100644
index 000000000..2f0e2caf3
--- /dev/null
+++ b/src/tests/semantic/blocks1_error.txt
@@ -0,0 +1 @@
+(13, 16) - TypeError: Inferred type F of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tests/semantic/case1.cl b/src/tests/semantic/case1.cl
new file mode 100644
index 000000000..82c6a4d61
--- /dev/null
+++ b/src/tests/semantic/case1.cl
@@ -0,0 +1,23 @@
+--For each branch, let Ti be the static type of <expri>. The static type of a case expression is Join 1≤i≤n Ti.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- case "true" of
+				i: Int => New C;
+				b: Bool => New D;
+				s: String => New E;
+			esac;
+
+	test: B <- case 0 of
+				b: Bool => new F;
+				i: Int => new E;
+			esac;
+};  
diff --git a/src/tests/semantic/case1_error.txt b/src/tests/semantic/case1_error.txt
new file mode 100644
index 000000000..f05ce31b9
--- /dev/null
+++ b/src/tests/semantic/case1_error.txt
@@ -0,0 +1 @@
+(19, 16) - TypeError: Inferred type A of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tests/semantic/case2.cl b/src/tests/semantic/case2.cl
new file mode 100644
index 000000000..ae97b41da
--- /dev/null
+++ b/src/tests/semantic/case2.cl
@@ -0,0 +1,23 @@
+-- The variables declared on each branch of a case must all have distinct types.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- case "true" of
+				i: Int => New C;
+				b: Bool => New D;
+				s: String => New E;
+			esac;
+
+	test: A <- case 0 of
+				b: Bool => new F;
+				i: Bool => new E;
+			esac;
+};
\ No newline at end of file
diff --git a/src/tests/semantic/case2_error.txt b/src/tests/semantic/case2_error.txt
new file mode 100644
index 000000000..302fec38c
--- /dev/null
+++ b/src/tests/semantic/case2_error.txt
@@ -0,0 +1 @@
+(21, 20) - SemanticError: Duplicate branch Bool in case statement.
\ No newline at end of file
diff --git a/src/tests/semantic/case3.cl b/src/tests/semantic/case3.cl
new file mode 100644
index 000000000..da79bbfe6
--- /dev/null
+++ b/src/tests/semantic/case3.cl
@@ -0,0 +1,23 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- case "true" of
+				i: Int => New C;
+				b: Bool => New D;
+				s: String => New E;
+			esac;
+
+	test: A <- case 0 of
+				b: Bool => new F;
+				i: Ball => new E;
+			esac;
+};
\ No newline at end of file
diff --git a/src/tests/semantic/case3_error.txt b/src/tests/semantic/case3_error.txt
new file mode 100644
index 000000000..fea261e5b
--- /dev/null
+++ b/src/tests/semantic/case3_error.txt
@@ -0,0 +1 @@
+(21, 20) - TypeError: Class Ball of case branch is undefined.
\ No newline at end of file
diff --git a/src/tests/semantic/class1.cl b/src/tests/semantic/class1.cl
new file mode 100644
index 000000000..ed83da9d1
--- /dev/null
+++ b/src/tests/semantic/class1.cl
@@ -0,0 +1,9 @@
+-- Classes may not be redefined.
+
+class Repeat {
+	sum(a: Int, b: Int): Int { a + b };
+};
+
+class Repeat {
+	mult(a: Int, b: Int): Int { a * b };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/class1_error.txt b/src/tests/semantic/class1_error.txt
new file mode 100644
index 000000000..19c507672
--- /dev/null
+++ b/src/tests/semantic/class1_error.txt
@@ -0,0 +1,2 @@
+(7, 5) - SemanticError: Classes may not be redefined
+ 
diff --git a/src/tests/semantic/conditionals1.cl b/src/tests/semantic/conditionals1.cl
new file mode 100644
index 000000000..3446a8b0f
--- /dev/null
+++ b/src/tests/semantic/conditionals1.cl
@@ -0,0 +1,14 @@
+--The predicate must have static type Bool.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: A <- if new F then new D else new C fi; 
+};
\ No newline at end of file
diff --git a/src/tests/semantic/conditionals1_error.txt b/src/tests/semantic/conditionals1_error.txt
new file mode 100644
index 000000000..b86345359
--- /dev/null
+++ b/src/tests/semantic/conditionals1_error.txt
@@ -0,0 +1 @@
+(13, 16) - TypeError: Predicate of 'if' does not have type Bool. 
diff --git a/src/tests/semantic/conditionals2.cl b/src/tests/semantic/conditionals2.cl
new file mode 100644
index 000000000..9d6313d75
--- /dev/null
+++ b/src/tests/semantic/conditionals2.cl
@@ -0,0 +1,24 @@
+(*
+Let T and F be the static types of the branches of the conditional. Then the static type of the
+conditional is T t F. (think: Walk towards Object from each of T and F until the paths meet.)
+*)
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- if true then 
+				new C 
+			else 
+				if false then new D 
+				else new E fi
+			fi;
+
+	test: B <- if not true then new F else new E fi;
+}; 
diff --git a/src/tests/semantic/conditionals2_error.txt b/src/tests/semantic/conditionals2_error.txt
new file mode 100644
index 000000000..d6f5fc307
--- /dev/null
+++ b/src/tests/semantic/conditionals2_error.txt
@@ -0,0 +1,2 @@
+(23, 16) - TypeError: Inferred type A of initialization of attribute test does not conform to declared type B.
+ 
diff --git a/src/tests/semantic/dispatch1.cl b/src/tests/semantic/dispatch1.cl
new file mode 100644
index 000000000..1c0457fa3
--- /dev/null
+++ b/src/tests/semantic/dispatch1.cl
@@ -0,0 +1,33 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: B <- new D.back("Hello ").back("World!");
+};
\ No newline at end of file
diff --git a/src/tests/semantic/dispatch1_error.txt b/src/tests/semantic/dispatch1_error.txt
new file mode 100644
index 000000000..7fb22edce
--- /dev/null
+++ b/src/tests/semantic/dispatch1_error.txt
@@ -0,0 +1 @@
+(32, 37) - AttributeError: Dispatch to undefined method back. 
diff --git a/src/tests/semantic/dispatch2.cl b/src/tests/semantic/dispatch2.cl
new file mode 100644
index 000000000..5182912b8
--- /dev/null
+++ b/src/tests/semantic/dispatch2.cl
@@ -0,0 +1,34 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+the dispatch and the definition of f must have the same number of arguments
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: Int <- new D.back("Hello ").g(2, 2);
+};
\ No newline at end of file
diff --git a/src/tests/semantic/dispatch2_error.txt b/src/tests/semantic/dispatch2_error.txt
new file mode 100644
index 000000000..a86c35340
--- /dev/null
+++ b/src/tests/semantic/dispatch2_error.txt
@@ -0,0 +1 @@
+(33, 39) - SemanticError: Method g called with wrong number of arguments. 
diff --git a/src/tests/semantic/dispatch3.cl b/src/tests/semantic/dispatch3.cl
new file mode 100644
index 000000000..ecb1535db
--- /dev/null
+++ b/src/tests/semantic/dispatch3.cl
@@ -0,0 +1,36 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+the static type of the ith actual parameter must conform to the declared type of the ith formal parameter.
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+
+	alphabet(a: A, b: B, c: C): D { self };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: B <- new D.alphabet(new D, new D, new D.back("Hello ")).back("World!");
+};
\ No newline at end of file
diff --git a/src/tests/semantic/dispatch3_error.txt b/src/tests/semantic/dispatch3_error.txt
new file mode 100644
index 000000000..0def5cf03
--- /dev/null
+++ b/src/tests/semantic/dispatch3_error.txt
@@ -0,0 +1 @@
+(35, 45) - TypeError: In call of method alphabet, type B of parameter c does not conform to declared type C. 
diff --git a/src/tests/semantic/dispatch4.cl b/src/tests/semantic/dispatch4.cl
new file mode 100644
index 000000000..9cadd8332
--- /dev/null
+++ b/src/tests/semantic/dispatch4.cl
@@ -0,0 +1,36 @@
+(*
+e0 .f(e1, . . . , en )
+Assume e0 has static type A.
+Class A must have a method f
+If f has return type B and B is a class name, then the static type of the dispatch is B.
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+
+	back(s: String): B { {
+		out_string(s);
+		self; 
+	} };
+
+	alphabet(a: A, b: B, c: C): D { self };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: D <- new D.alphabet(new D, new D.back("Hello "), new C).back("World!");
+};
\ No newline at end of file
diff --git a/src/tests/semantic/dispatch4_error.txt b/src/tests/semantic/dispatch4_error.txt
new file mode 100644
index 000000000..9699f166b
--- /dev/null
+++ b/src/tests/semantic/dispatch4_error.txt
@@ -0,0 +1 @@
+(35, 16) - TypeError: Inferred type B of initialization of attribute test does not conform to declared type D.
\ No newline at end of file
diff --git a/src/tests/semantic/dispatch5.cl b/src/tests/semantic/dispatch5.cl
new file mode 100644
index 000000000..b4437b1b4
--- /dev/null
+++ b/src/tests/semantic/dispatch5.cl
@@ -0,0 +1,31 @@
+(*
+<id>(<expr>,...,<expr>)  is shorthand for self.<id>(<expr>,...,<expr>).
+*)
+
+class A inherits IO {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+	sum(m: Int, n: Int, p: Int): Int { m + n + p };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+
+	back(s: String): B { {
+		out_string(s);
+		g(2);
+		sum(1, 2, 3);
+		self; 
+	} };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/dispatch5_error.txt b/src/tests/semantic/dispatch5_error.txt
new file mode 100644
index 000000000..d26bf34a1
--- /dev/null
+++ b/src/tests/semantic/dispatch5_error.txt
@@ -0,0 +1 @@
+(24, 9) - AttributeError: Dispatch to undefined method sum. 
diff --git a/src/tests/semantic/dispatch6.cl b/src/tests/semantic/dispatch6.cl
new file mode 100644
index 000000000..fcc033f2c
--- /dev/null
+++ b/src/tests/semantic/dispatch6.cl
@@ -0,0 +1,32 @@
+(*
+e@B.f() invokes the method
+f in class B on the object that is the value of e. For this form of dispatch, the static type to the left of
+“@”must conform to the type specified to the right of “@”.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+	sum(m: Int, n: Int, p: Int): Int { m + n + p };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int): Int { v + v + v };
+	sum(v: Int, w: Int, z: Int): Int { v - w - z };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: A <- new D;
+	b: Int <- new D@B.sum(1, 2, 3);
+	test: Int <- a@B.sum(1, 2, 3);
+}; 
diff --git a/src/tests/semantic/dispatch6_error.txt b/src/tests/semantic/dispatch6_error.txt
new file mode 100644
index 000000000..ae9184b2f
--- /dev/null
+++ b/src/tests/semantic/dispatch6_error.txt
@@ -0,0 +1 @@
+(31, 18) - TypeError: Expression type A does not conform to declared static dispatch type B. 
diff --git a/src/tests/semantic/eq1.cl b/src/tests/semantic/eq1.cl
new file mode 100644
index 000000000..88f2a7ffe
--- /dev/null
+++ b/src/tests/semantic/eq1.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared.
+*)
+
+class A { };
+class B inherits A { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	test: Bool <- 1 = new A;
+	y: Bool <- "1" = "2";
+	z: Bool <- true = not false;
+};  
\ No newline at end of file
diff --git a/src/tests/semantic/eq1_error.txt b/src/tests/semantic/eq1_error.txt
new file mode 100644
index 000000000..f81425683
--- /dev/null
+++ b/src/tests/semantic/eq1_error.txt
@@ -0,0 +1 @@
+(14, 21) - TypeError: Illegal comparison with a basic type. 
diff --git a/src/tests/semantic/eq2.cl b/src/tests/semantic/eq2.cl
new file mode 100644
index 000000000..d76852780
--- /dev/null
+++ b/src/tests/semantic/eq2.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared.
+*)
+
+class A { };
+class B inherits A { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	y: Bool <- "1" = "2";
+	test: Bool <- "1" = new B;
+	z: Bool <- true = not false;
+}; 
diff --git a/src/tests/semantic/eq2_error.txt b/src/tests/semantic/eq2_error.txt
new file mode 100644
index 000000000..a44ab0d51
--- /dev/null
+++ b/src/tests/semantic/eq2_error.txt
@@ -0,0 +1 @@
+(15, 23) - TypeError: Illegal comparison with a basic type. 
diff --git a/src/tests/semantic/eq3.cl b/src/tests/semantic/eq3.cl
new file mode 100644
index 000000000..4dad693ee
--- /dev/null
+++ b/src/tests/semantic/eq3.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared.
+*)
+
+class A { };
+class B inherits A { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	y: Bool <- "1" = "2";
+	z: Bool <- true = not false;
+	test: Bool <- "true" = not false;
+};  
diff --git a/src/tests/semantic/eq3_error.txt b/src/tests/semantic/eq3_error.txt
new file mode 100644
index 000000000..c4e27eb8a
--- /dev/null
+++ b/src/tests/semantic/eq3_error.txt
@@ -0,0 +1 @@
+(16, 26) - TypeError: Illegal comparison with a basic type. 
diff --git a/src/tests/semantic/eq4.cl b/src/tests/semantic/eq4.cl
new file mode 100644
index 000000000..11afc119f
--- /dev/null
+++ b/src/tests/semantic/eq4.cl
@@ -0,0 +1,17 @@
+(*
+The comparison = is a special
+case. If either <expr1> or <expr2> has static type Int, Bool, or String, then the other must have the
+same static type. Any other types, including SELF TYPE, may be freely compared. The result is a Bool.
+*)
+
+class A { };
+class B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	x: Bool <- 1 = 2;
+	y: Bool <- "1" = "2";
+	z: Bool <- new A = new B;
+	test: Int <- new A = new B;
+}; 
diff --git a/src/tests/semantic/eq4_error.txt b/src/tests/semantic/eq4_error.txt
new file mode 100644
index 000000000..3ead21d0e
--- /dev/null
+++ b/src/tests/semantic/eq4_error.txt
@@ -0,0 +1 @@
+(16, 18) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type Int. 
diff --git a/src/tests/semantic/features1.cl b/src/tests/semantic/features1.cl
new file mode 100644
index 000000000..66f650f4a
--- /dev/null
+++ b/src/tests/semantic/features1.cl
@@ -0,0 +1,19 @@
+(*
+No method name may be defined multiple times in
+a class, and no attribute name may be defined multiple times in a class, but a method and an attribute
+may have the same name.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): Int { 3 };
+
+	x: String <- ":)";
+};
\ No newline at end of file
diff --git a/src/tests/semantic/features1_error.txt b/src/tests/semantic/features1_error.txt
new file mode 100644
index 000000000..40033e9b3
--- /dev/null
+++ b/src/tests/semantic/features1_error.txt
@@ -0,0 +1 @@
+(18, 5) - SemanticError: Attribute x is multiply defined in class.
\ No newline at end of file
diff --git a/src/tests/semantic/features2.cl b/src/tests/semantic/features2.cl
new file mode 100644
index 000000000..5b1f7e9df
--- /dev/null
+++ b/src/tests/semantic/features2.cl
@@ -0,0 +1,19 @@
+(*
+No method name may be defined multiple times in
+a class, and no attribute name may be defined multiple times in a class, but a method and an attribute
+may have the same name.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): String { "3" };
+
+	x(): String { ":)" };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/features2_error.txt b/src/tests/semantic/features2_error.txt
new file mode 100644
index 000000000..117e06042
--- /dev/null
+++ b/src/tests/semantic/features2_error.txt
@@ -0,0 +1 @@
+(18, 5) - SemanticError: Method x is multiply defined.
\ No newline at end of file
diff --git a/src/tests/semantic/features3.cl b/src/tests/semantic/features3.cl
new file mode 100644
index 000000000..a892d011d
--- /dev/null
+++ b/src/tests/semantic/features3.cl
@@ -0,0 +1,15 @@
+-- Missing type
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): Int { 3 };
+
+	c: Cadena;
+};
\ No newline at end of file
diff --git a/src/tests/semantic/features3_error.txt b/src/tests/semantic/features3_error.txt
new file mode 100644
index 000000000..53f1abe26
--- /dev/null
+++ b/src/tests/semantic/features3_error.txt
@@ -0,0 +1 @@
+(14, 8) - TypeError: Class Cadena of attribute c is undefined.
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance1.cl b/src/tests/semantic/inheritance1.cl
new file mode 100644
index 000000000..1d92da307
--- /dev/null
+++ b/src/tests/semantic/inheritance1.cl
@@ -0,0 +1,19 @@
+--It is illegal to redefine attribute names.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
+
+class B inherits A {
+	x: Int;
+
+	div(a: Int, b: Int): Int { a / b};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance1_error.txt b/src/tests/semantic/inheritance1_error.txt
new file mode 100644
index 000000000..ec5b504e6
--- /dev/null
+++ b/src/tests/semantic/inheritance1_error.txt
@@ -0,0 +1 @@
+(16, 5) - SemanticError: Attribute x is an attribute of an inherited class.
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance2.cl b/src/tests/semantic/inheritance2.cl
new file mode 100644
index 000000000..d453eca09
--- /dev/null
+++ b/src/tests/semantic/inheritance2.cl
@@ -0,0 +1,19 @@
+--If C inherits from P, then P must have a class definition somewhere in the program.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class Alo {
+	x: Int <- 3;
+
+	x(): String { "3" };
+};
+
+class B inherits A {
+	div(a: Int, b: Int): Int { a / b};
+	
+	x: String <- "2";
+};
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance2_error.txt b/src/tests/semantic/inheritance2_error.txt
new file mode 100644
index 000000000..1ec7669b5
--- /dev/null
+++ b/src/tests/semantic/inheritance2_error.txt
@@ -0,0 +1 @@
+(15, 18) - TypeError: Class B inherits from an undefined class A.
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance3.cl b/src/tests/semantic/inheritance3.cl
new file mode 100644
index 000000000..3ff170dec
--- /dev/null
+++ b/src/tests/semantic/inheritance3.cl
@@ -0,0 +1,13 @@
+--The parent-child relation on classes defines a graph. This graph may not contain cycles.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A inherits A {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance3_error.txt b/src/tests/semantic/inheritance3_error.txt
new file mode 100644
index 000000000..d17ca7f49
--- /dev/null
+++ b/src/tests/semantic/inheritance3_error.txt
@@ -0,0 +1 @@
+(9, 18) - SemanticError: Class A, or an ancestor of A, is involved in an inheritance cycle.
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance4.cl b/src/tests/semantic/inheritance4.cl
new file mode 100644
index 000000000..c985484ba
--- /dev/null
+++ b/src/tests/semantic/inheritance4.cl
@@ -0,0 +1,19 @@
+--The parent-child relation on classes defines a graph. This graph may not contain cycles.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A inherits B {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
+
+class B inherits A {
+	y: Int <- 2;
+
+	div(a: Int, b: Int): Int { a / b};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance4_error.txt b/src/tests/semantic/inheritance4_error.txt
new file mode 100644
index 000000000..b437ec667
--- /dev/null
+++ b/src/tests/semantic/inheritance4_error.txt
@@ -0,0 +1 @@
+(15, 18) - SemanticError: Class B, or an ancestor of B, is involved in an inheritance cycle.
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance5.cl b/src/tests/semantic/inheritance5.cl
new file mode 100644
index 000000000..f6ed885c8
--- /dev/null
+++ b/src/tests/semantic/inheritance5.cl
@@ -0,0 +1,21 @@
+--The parent-child relation on classes defines a graph. This graph may not contain cycles.
+
+class Main inherits IO {
+	main(): IO { out_string("hi!") };
+
+	main: IO <- out_string("bye!");
+};
+
+class A inherits B {
+	x: Int <- 3;
+
+	x(): String { ":)" };
+};
+
+class B inherits C {
+	y: Int <- 2;
+
+	div(a: Int, b: Int): Int { a / b};
+};
+
+class C inherits A { };
\ No newline at end of file
diff --git a/src/tests/semantic/inheritance5_error.txt b/src/tests/semantic/inheritance5_error.txt
new file mode 100644
index 000000000..da72ba547
--- /dev/null
+++ b/src/tests/semantic/inheritance5_error.txt
@@ -0,0 +1 @@
+(21, 18) - SemanticError: Class C, or an ancestor of C, is involved in an inheritance cycle.
\ No newline at end of file
diff --git a/src/tests/semantic/isvoid1.cl b/src/tests/semantic/isvoid1.cl
new file mode 100644
index 000000000..072720d85
--- /dev/null
+++ b/src/tests/semantic/isvoid1.cl
@@ -0,0 +1,26 @@
+--evaluates to true if expr is void and evaluates to false if expr is not void.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- if isvoid new F then 
+				new C 
+			else 
+				if false then new D 
+				else new E fi
+			fi;
+
+	test: B <- isvoid if isvoid new F then 
+				new C 
+			else 
+				if false then new D 
+				else new E fi
+			fi;
+}; 
\ No newline at end of file
diff --git a/src/tests/semantic/isvoid1_error.txt b/src/tests/semantic/isvoid1_error.txt
new file mode 100644
index 000000000..0922de909
--- /dev/null
+++ b/src/tests/semantic/isvoid1_error.txt
@@ -0,0 +1 @@
+(20, 16) - TypeError: Inferred type Bool of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tests/semantic/let1.cl b/src/tests/semantic/let1.cl
new file mode 100644
index 000000000..26ef63026
--- /dev/null
+++ b/src/tests/semantic/let1.cl
@@ -0,0 +1,15 @@
+--The type of an initialization expression must conform to the declared type of the identifier.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: B <- new E in b;
+	test: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: C <- new E in b;
+}; 
\ No newline at end of file
diff --git a/src/tests/semantic/let1_error.txt b/src/tests/semantic/let1_error.txt
new file mode 100644
index 000000000..16ecf780c
--- /dev/null
+++ b/src/tests/semantic/let1_error.txt
@@ -0,0 +1 @@
+(14, 76) - TypeError: Inferred type E of initialization of b does not conform to identifier's declared type C. 
diff --git a/src/tests/semantic/let2.cl b/src/tests/semantic/let2.cl
new file mode 100644
index 000000000..c5956ead3
--- /dev/null
+++ b/src/tests/semantic/let2.cl
@@ -0,0 +1,15 @@
+--The type of let is the type of the body.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: B <- new E in b;
+	test: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: A <- new E in b;
+};
\ No newline at end of file
diff --git a/src/tests/semantic/let2_error.txt b/src/tests/semantic/let2_error.txt
new file mode 100644
index 000000000..b1e8a365d
--- /dev/null
+++ b/src/tests/semantic/let2_error.txt
@@ -0,0 +1 @@
+(14, 16) - TypeError: Inferred type A of initialization of attribute test does not conform to declared type B. 
diff --git a/src/tests/semantic/let3.cl b/src/tests/semantic/let3.cl
new file mode 100644
index 000000000..8c0670ab8
--- /dev/null
+++ b/src/tests/semantic/let3.cl
@@ -0,0 +1,15 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	b: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: B <- new E in b;
+	test: B <- let a: Bool, a: Int <- 5, a: String, a: A <- new F, b: Cadena in new B;
+}; 
\ No newline at end of file
diff --git a/src/tests/semantic/let3_error.txt b/src/tests/semantic/let3_error.txt
new file mode 100644
index 000000000..39c5315d8
--- /dev/null
+++ b/src/tests/semantic/let3_error.txt
@@ -0,0 +1 @@
+(14, 71) - TypeError: Class Cadena of let-bound identifier b is undefined.
\ No newline at end of file
diff --git a/src/tests/semantic/loops1.cl b/src/tests/semantic/loops1.cl
new file mode 100644
index 000000000..de3a624d2
--- /dev/null
+++ b/src/tests/semantic/loops1.cl
@@ -0,0 +1,8 @@
+--The predicate must have static type Bool.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	i: Int <- 1;
+	test: Object <- while "true" loop i <- i + 1 pool; 
+};
\ No newline at end of file
diff --git a/src/tests/semantic/loops1_error.txt b/src/tests/semantic/loops1_error.txt
new file mode 100644
index 000000000..b160214b4
--- /dev/null
+++ b/src/tests/semantic/loops1_error.txt
@@ -0,0 +1 @@
+(7, 27) - TypeError: Loop condition does not have type Bool.
\ No newline at end of file
diff --git a/src/tests/semantic/loops2.cl b/src/tests/semantic/loops2.cl
new file mode 100644
index 000000000..dea69fa14
--- /dev/null
+++ b/src/tests/semantic/loops2.cl
@@ -0,0 +1,9 @@
+--The static type of a loop expression is Object.
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	i: Int <- 1;
+	test: Object <- while not false loop i <- i + 1 pool; 
+	test2: Int <- while not false loop i <- i + 1 pool; 
+}; 
diff --git a/src/tests/semantic/loops2_error.txt b/src/tests/semantic/loops2_error.txt
new file mode 100644
index 000000000..9711cdf6a
--- /dev/null
+++ b/src/tests/semantic/loops2_error.txt
@@ -0,0 +1 @@
+(8, 19) - TypeError: Inferred type Object of initialization of attribute test2 does not conform to declared type Int. 
diff --git a/src/tests/semantic/methods1.cl b/src/tests/semantic/methods1.cl
new file mode 100644
index 000000000..d12031970
--- /dev/null
+++ b/src/tests/semantic/methods1.cl
@@ -0,0 +1,12 @@
+--The identifiers used in the formal parameter list must be distinct
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, a: B): Int { 4 };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods1_error.txt b/src/tests/semantic/methods1_error.txt
new file mode 100644
index 000000000..06ab88a92
--- /dev/null
+++ b/src/tests/semantic/methods1_error.txt
@@ -0,0 +1 @@
+(11, 16) - SemanticError: Formal parameter a is multiply defined.
diff --git a/src/tests/semantic/methods2.cl b/src/tests/semantic/methods2.cl
new file mode 100644
index 000000000..3865f0e13
--- /dev/null
+++ b/src/tests/semantic/methods2.cl
@@ -0,0 +1,12 @@
+--The type of the method body must conform to the declared return type.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, b: B): C { new D };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods2_error.txt b/src/tests/semantic/methods2_error.txt
new file mode 100644
index 000000000..f7e4a330d
--- /dev/null
+++ b/src/tests/semantic/methods2_error.txt
@@ -0,0 +1 @@
+(11, 27) - TypeError: Inferred return type D of method test does not conform to declared return type C.
diff --git a/src/tests/semantic/methods3.cl b/src/tests/semantic/methods3.cl
new file mode 100644
index 000000000..b92faeb97
--- /dev/null
+++ b/src/tests/semantic/methods3.cl
@@ -0,0 +1,14 @@
+--A formal parameter hides any definition of an attribute of the same name.
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	a: C <- new C;
+	test(a: D): D { a };
+	test2(a: B): C { a };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods3_error.txt b/src/tests/semantic/methods3_error.txt
new file mode 100644
index 000000000..1165b7595
--- /dev/null
+++ b/src/tests/semantic/methods3_error.txt
@@ -0,0 +1 @@
+(13, 22) - TypeError: Inferred return type B of method test2 does not conform to declared return type C.
diff --git a/src/tests/semantic/methods4.cl b/src/tests/semantic/methods4.cl
new file mode 100644
index 000000000..be8fa36ef
--- /dev/null
+++ b/src/tests/semantic/methods4.cl
@@ -0,0 +1,19 @@
+(*
+The rule is
+simple: If a class C inherits a method f from an ancestor class P, then C may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+};
+class B inherits A {
+	f(x: Int, y: Object): Int { x };
+};
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods4_error.txt b/src/tests/semantic/methods4_error.txt
new file mode 100644
index 000000000..9f1486dec
--- /dev/null
+++ b/src/tests/semantic/methods4_error.txt
@@ -0,0 +1 @@
+(12, 15) - SemanticError: In redefined method f, parameter type Object is different from original type Int.
diff --git a/src/tests/semantic/methods5.cl b/src/tests/semantic/methods5.cl
new file mode 100644
index 000000000..3905dfdd6
--- /dev/null
+++ b/src/tests/semantic/methods5.cl
@@ -0,0 +1,20 @@
+(*
+The rule is
+simple: If a class C inherits a method f from an ancestor class P, then C may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+};
+class B inherits A {
+	f(a: Int, b: Int): Object { a - b };
+};
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
+ 
diff --git a/src/tests/semantic/methods5_error.txt b/src/tests/semantic/methods5_error.txt
new file mode 100644
index 000000000..8b6bdf36e
--- /dev/null
+++ b/src/tests/semantic/methods5_error.txt
@@ -0,0 +1 @@
+(12, 24) - SemanticError: In redefined method f, return type Object is different from original return type Int.
diff --git a/src/tests/semantic/methods6.cl b/src/tests/semantic/methods6.cl
new file mode 100644
index 000000000..dd2b73da6
--- /dev/null
+++ b/src/tests/semantic/methods6.cl
@@ -0,0 +1,27 @@
+(*
+The rule is
+simple: If a class C inherits a method f from an ancestor class P, then C may override the inherited
+definition of f provided the number of arguments, the types of the formal parameters, and the return
+type are exactly the same in both definitions.
+*)
+
+class A {
+	f(x: Int, y: Int): Int { x + y };
+	g(x: Int): Int { x + x };
+};
+class B inherits A {
+	f(a: Int, b: Int): Int { a - b };
+};
+class C inherits B {
+	ident(m: Int): Int { m };
+	f(m: Int, n: Int): Int { m * n };
+};
+class D inherits B { 
+	ident(v: String): IO { new IO.out_string(v) };
+	f(v: Int, w: Int): Int { v / w };
+	g(v: Int, w: Int, z: Int): Int { v + w + z };
+};
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods6_error.txt b/src/tests/semantic/methods6_error.txt
new file mode 100644
index 000000000..8e32663b9
--- /dev/null
+++ b/src/tests/semantic/methods6_error.txt
@@ -0,0 +1 @@
+(22, 5) - SemanticError: Incompatible number of formal parameters in redefined method g.
diff --git a/src/tests/semantic/methods7.cl b/src/tests/semantic/methods7.cl
new file mode 100644
index 000000000..e5a01f682
--- /dev/null
+++ b/src/tests/semantic/methods7.cl
@@ -0,0 +1,12 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, b: Ball): Int { 4 };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods7_error.txt b/src/tests/semantic/methods7_error.txt
new file mode 100644
index 000000000..472cbd9d1
--- /dev/null
+++ b/src/tests/semantic/methods7_error.txt
@@ -0,0 +1 @@
+(11, 19) - TypeError: Class Ball of formal parameter b is undefined.
\ No newline at end of file
diff --git a/src/tests/semantic/methods8.cl b/src/tests/semantic/methods8.cl
new file mode 100644
index 000000000..3fccab54c
--- /dev/null
+++ b/src/tests/semantic/methods8.cl
@@ -0,0 +1,12 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: A, b: B): Integrer { 4 };
+};
\ No newline at end of file
diff --git a/src/tests/semantic/methods8_error.txt b/src/tests/semantic/methods8_error.txt
new file mode 100644
index 000000000..dc9302ec0
--- /dev/null
+++ b/src/tests/semantic/methods8_error.txt
@@ -0,0 +1 @@
+(11, 23) - TypeError: Undefined return type Integrer in method test.
\ No newline at end of file
diff --git a/src/tests/semantic/new1.cl b/src/tests/semantic/new1.cl
new file mode 100644
index 000000000..d007fc03d
--- /dev/null
+++ b/src/tests/semantic/new1.cl
@@ -0,0 +1,31 @@
+-- Missing type
+
+class A { };
+class B inherits A { };
+class C inherits B { };
+class D inherits B { };
+class E inherits B { }; 
+class F inherits A { }; 
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test: F <- {
+		new A;
+		{ 
+			new Ball;
+			{
+				new C;
+				{
+					new D;
+					{
+						new E;
+						{
+							new F;
+						};
+					};
+				};
+			};
+		};
+	};
+};
\ No newline at end of file
diff --git a/src/tests/semantic/new1_error.txt b/src/tests/semantic/new1_error.txt
new file mode 100644
index 000000000..612a3d427
--- /dev/null
+++ b/src/tests/semantic/new1_error.txt
@@ -0,0 +1 @@
+(16, 17) - TypeError: 'new' used with undefined class Ball.
\ No newline at end of file
diff --git a/src/tests/semantic/self1.cl b/src/tests/semantic/self1.cl
new file mode 100644
index 000000000..3387fd263
--- /dev/null
+++ b/src/tests/semantic/self1.cl
@@ -0,0 +1,11 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(a: Main): IO { self <- a };
+}; 
diff --git a/src/tests/semantic/self1_error.txt b/src/tests/semantic/self1_error.txt
new file mode 100644
index 000000000..6beb3cda2
--- /dev/null
+++ b/src/tests/semantic/self1_error.txt
@@ -0,0 +1 @@
+(10, 30) - SemanticError: Cannot assign to 'self'.
diff --git a/src/tests/semantic/self2.cl b/src/tests/semantic/self2.cl
new file mode 100644
index 000000000..2e6921a92
--- /dev/null
+++ b/src/tests/semantic/self2.cl
@@ -0,0 +1,10 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(): IO { let self: Main <- new Main in self };
+}; 
diff --git a/src/tests/semantic/self2_error.txt b/src/tests/semantic/self2_error.txt
new file mode 100644
index 000000000..20c883c91
--- /dev/null
+++ b/src/tests/semantic/self2_error.txt
@@ -0,0 +1 @@
+(9, 22) - SemanticError: 'self' cannot be bound in a 'let' expression.
diff --git a/src/tests/semantic/self3.cl b/src/tests/semantic/self3.cl
new file mode 100644
index 000000000..81709b4b5
--- /dev/null
+++ b/src/tests/semantic/self3.cl
@@ -0,0 +1,10 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	test(self: IO): IO { self };
+};
diff --git a/src/tests/semantic/self3_error.txt b/src/tests/semantic/self3_error.txt
new file mode 100644
index 000000000..0ae382007
--- /dev/null
+++ b/src/tests/semantic/self3_error.txt
@@ -0,0 +1 @@
+(9, 10) - SemanticError: 'self' cannot be the name of a formal parameter.
diff --git a/src/tests/semantic/self4.cl b/src/tests/semantic/self4.cl
new file mode 100644
index 000000000..7c2b960cb
--- /dev/null
+++ b/src/tests/semantic/self4.cl
@@ -0,0 +1,10 @@
+(*
+But it is an error to assign to self or to bind self in a let, a
+case, or as a formal parameter. It is also illegal to have attributes named self.
+*)
+
+class Main inherits IO {
+	main(): IO { out_string("Hello World!")};
+
+	self: IO <- self;
+};
\ No newline at end of file
diff --git a/src/tests/semantic/self4_error.txt b/src/tests/semantic/self4_error.txt
new file mode 100644
index 000000000..c19ca400f
--- /dev/null
+++ b/src/tests/semantic/self4_error.txt
@@ -0,0 +1 @@
+(9, 5) - SemanticError: 'self' cannot be the name of an attribute.
diff --git a/src/tests/semantic_test.py b/src/tests/semantic_test.py
new file mode 100644
index 000000000..cac9cd78b
--- /dev/null
+++ b/src/tests/semantic_test.py
@@ -0,0 +1,14 @@
+import pytest
+import os
+from utils import compare_errors, first_error_only_line
+
+tests_dir = __file__.rpartition('/')[0] + '/semantic/'
+tests = [(file) for file in os.listdir(tests_dir) if file.endswith('.cl')]
+
+@pytest.mark.semantic
+@pytest.mark.error
+@pytest.mark.run(order=3)
+@pytest.mark.parametrize("cool_file", tests)
+def test_semantic_errors(compiler_path, cool_file):
+    compare_errors(compiler_path, tests_dir + cool_file, tests_dir + cool_file[:-3] + '_error.txt', \
+        cmp=first_error_only_line)
\ No newline at end of file
diff --git a/src/tests/utils/__init__.py b/src/tests/utils/__init__.py
new file mode 100644
index 000000000..90f60fdd8
--- /dev/null
+++ b/src/tests/utils/__init__.py
@@ -0,0 +1 @@
+from .utils import *
\ No newline at end of file
diff --git a/src/tests/utils/utils.py b/src/tests/utils/utils.py
new file mode 100644
index 000000000..961cf7cbc
--- /dev/null
+++ b/src/tests/utils/utils.py
@@ -0,0 +1,91 @@
+import subprocess
+import re
+
+
+COMPILER_TIMEOUT = 'El compilador tarda mucho en responder.'
+SPIM_TIMEOUT = 'El spim tarda mucho en responder.'
+TEST_MUST_FAIL = 'El test %s debe fallar al compilar'
+TEST_MUST_COMPILE = 'El test %s debe compilar'
+BAD_ERROR_FORMAT = '''El error no esta en formato: (<línea>,<columna>) - <tipo_de_error>: <texto_del_error>
+                        o no se encuentra en la 3ra linea\n\n%s'''
+UNEXPECTED_ERROR = 'Se esperaba un %s en (%d, %d). Su error fue un %s en (%d, %d)'
+UNEXPECTED_OUTPUT = 'La salida de %s no es la esperada:\n%s\nEsperada:\n%s'
+
+ERROR_FORMAT = r'^\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)\s*-\s*(\w+)\s*:(.*)$'
+
+def parse_error(error: str):
+    merror = re.fullmatch(ERROR_FORMAT, error)
+    assert merror, BAD_ERROR_FORMAT % error
+
+    return (t(x) for t, x in zip([int, int, str, str], merror.groups()))
+
+
+def first_error(compiler_output: list, errors: list):
+    line, column, error_type, _ = parse_error(errors[0])
+
+    oline, ocolumn, oerror_type, _ = parse_error(compiler_output[0])
+
+    assert line == oline and column == ocolumn and error_type == oerror_type,\
+        UNEXPECTED_ERROR % (error_type, line, column, oerror_type, oline, ocolumn)
+
+def first_error_only_line(compiler_output: list, errors: list):
+    line, column, error_type, _ = parse_error(errors[0])
+
+    oline, ocolumn, oerror_type, _ = parse_error(compiler_output[0])
+
+    assert line == oline and error_type == oerror_type,\
+        UNEXPECTED_ERROR % (error_type, line, column, oerror_type, oline, ocolumn)
+
+
+def get_file_name(path: str):
+    try:
+        return path[path.rindex('/') + 1:]
+    except ValueError:
+        return path
+
+def compare_errors(compiler_path: str, cool_file_path: str, error_file_path: str, cmp=first_error, timeout=100):
+    try:
+        sp = subprocess.run(['bash', compiler_path, cool_file_path], capture_output=True, timeout=timeout)
+        return_code, output = sp.returncode, sp.stdout.decode()
+    except subprocess.TimeoutExpired:
+        assert False, COMPILER_TIMEOUT
+
+    assert return_code == 1, TEST_MUST_FAIL % get_file_name(cool_file_path)
+
+    fd = open(error_file_path, 'r')
+    errors = fd.read().split('\n')
+    fd.close()
+
+    # checking the errors of compiler
+    compiler_output = output.split('\n')
+    cmp(compiler_output[2:], errors)
+
+SPIM_HEADER = r'''^SPIM Version .+ of .+
+Copyright .+\, James R\. Larus\.
+All Rights Reserved\.
+See the file README for a full copyright notice\.
+(?:Loaded: .+\n)*'''
+def compare_outputs(compiler_path: str, cool_file_path: str, input_file_path: str, output_file_path: str, timeout=100):
+    try:
+        sp = subprocess.run(['bash', compiler_path, cool_file_path], capture_output=True, timeout=timeout)
+        assert sp.returncode == 0, TEST_MUST_COMPILE % get_file_name(cool_file_path)
+    except subprocess.TimeoutExpired:
+        assert False, COMPILER_TIMEOUT
+
+    spim_file = cool_file_path[:-2] + 'mips'
+
+    try:
+        fd = open(input_file_path, 'rb')
+        sp = subprocess.run(['spim', '-file', spim_file], input=fd.read(), capture_output=True, timeout=timeout)
+        fd.close()
+        mo = re.match(SPIM_HEADER, sp.stdout.decode())
+        if mo:
+            output = mo.string[mo.end():]
+    except subprocess.TimeoutExpired:
+        assert False, SPIM_TIMEOUT
+
+    fd = open(output_file_path, 'r')
+    eoutput = fd.read()
+    fd.close()
+
+    assert output == eoutput, UNEXPECTED_OUTPUT % (spim_file, repr(output), repr(eoutput))
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 5790cabbe..2fe488dcb 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -28,17 +28,17 @@ def build_COOL_Grammar():
     class_list %= def_class + semi, lambda h,s: [s[1]]
     class_list %= def_class + semi + class_list, lambda h,s: [s[1]] + s[3]
 
-    def_class %= classx + typex + ocur + feature_list + ccur, lambda h,s: node.ClassDeclarationNode(s[2],s[4])
-    def_class %= classx + typex + inherits + typex + ocur + feature_list + ccur, lambda h,s: node.ClassDeclarationNode(s[2],s[6],s[4])
+    def_class %= classx + typex + ocur + feature_list + ccur, lambda h,s: node.ClassDeclarationNode(s[2],s[4],s[1])
+    def_class %= classx + typex + inherits + typex + ocur + feature_list + ccur, lambda h,s: node.ClassDeclarationNode(s[2],s[6],s[1],s[4])
 
     feature_list %= def_attr + semi + feature_list, lambda h,s: [s[1]] + s[3]
     feature_list %= def_meth + semi + feature_list, lambda h,s: [s[1]] + s[3]
     feature_list %= G.Epsilon, lambda h,s: []
 
     def_attr %= idx + colon + typex, lambda h,s: node.AttrDeclarationNode(s[1],s[3])
-    def_attr %= idx + colon + typex + arrow + expr, lambda h,s: node.AttrDeclarationNode(s[1],s[3],s[5])
+    def_attr %= idx + colon + typex + arrow + expr, lambda h,s: node.AttrDeclarationNode(s[1],s[3],s[4],s[5])
 
-    def_meth %= idx + opar + param_list + cpar + colon + typex + ocur + expr + ccur, lambda h,s: node.MethDeclarationNode(s[1],s[3],s[6],s[8])
+    def_meth %= idx + opar + param_list + cpar + colon + typex + ocur + expr + ccur, lambda h,s: node.MethDeclarationNode(s[1],s[3],s[6],s[8],s[7])
 
     param_list %= param, lambda h,s: [s[1]]
     param_list %= param + comma + param_list, lambda h,s: [s[1]] + s[3]
@@ -84,7 +84,7 @@ def build_COOL_Grammar():
     term %= factor, lambda h,s: s[1]
 
     factor %= isvoid + factor, lambda h,s: node.IsVoidNode(s[2])
-    factor %= tilde + factor, lambda h,s: node.ComplementNode(s[2])
+    factor %= tilde + factor, lambda h,s: node.ComplementNode(s[2], s[1])
     factor %= atom, lambda h,s: s[1]
 
     atom %= true, lambda h,s: node.ConstantBoolNode(s[1])
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index a3e733f40..dc241493d 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -12,6 +12,7 @@ def __init__(self, lex, ttype, line, column):
         self.token_type = ttype
         self.line = line
         self.column = column
+        self.next_token = None
  
     def __str__(self): 
         return f'({self.line}, {self.column}) - {self.token_type}: {self.lex}'
@@ -135,7 +136,7 @@ def tokenize(self,text):
 
             token_type = match.lastgroup if lexeme.lower() not in self.keywords and match.lastgroup is not None else match.group().lower()
 
-            yield lexeme, token_type, self.line, self.column - len(lexeme) + 1 if lexeme[:2] != '(*' and lexeme[0] != '"' else self.column 
+            yield lexeme, token_type, self.line, self.column - len(lexeme) + 1
  
             text = text[match.end():] if lexeme[:2] != '(*' and lexeme[0] != '"' else text
 
@@ -148,10 +149,8 @@ def __call__(self, text):
         return [Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens]
 
     def fixed_tokens(self, tokens):
-        for i, token in enumerate(tokens):
-            if token.lex in self.tokens_toFix:
-                token.line = tokens[i + 1].line
-                token.column = tokens[i + 1].column
+        for i, token in enumerate(tokens[:(len(tokens) - 1)]):
+                token.next_token = tokens[i+1]
         return tokens
 
 
@@ -216,6 +215,6 @@ def __init__(self):
         self.ignored_tokens = ['newline','whitespace','tabulation','comment']
 
         self.tokens_toFix = ['inherits','isvoid','class','while','then','else','loop','case',
-        'let','new','not','if','in','of']
+        'let','new','not','if','in','of', '<-']
 
         Lexer.__init__(self, self.regexs, self.keywords, self.ignored_tokens, self.tokens_toFix, 'eof')
\ No newline at end of file
diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index c31d90ed2..41f76e6a3 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -19,27 +19,32 @@ class ExpressionNode(Node):
 
 
     class ClassDeclarationNode(DeclarationNode):
-        def __init__(self, token, features, parent=None):
-            self.id = token.lex
-            self.line = token.line
-            self.column = token.column
+        def __init__(self, idx, features, token, parent=None):
+            self.id = idx.lex
+            self.line = idx.line
+            self.column = idx.column
+            self.classt_line = token.line
+            self.classt_column = token.column + 4
             self.parent = parent.lex if parent else parent
+            self.parent_column = parent.column if parent else None
             self.features = features
 
     class MethDeclarationNode(DeclarationNode):
-        def __init__(self, token, params, return_type, body):
-            self.id = token.lex
-            self.line = token.line
-            self.column = token.column
+        def __init__(self, idx, params, return_type, body, ocurToken):
+            self.id = idx.lex
+            self.line = idx.line
+            self.column = idx.column
+            self.body_line = ocurToken.next_token.line
+            self.body_column = ocurToken.next_token.column
             self.params = [[item.lex if isinstance(item, Token) else item for item in _list] for _list in params]
             self.type = return_type.lex
             self.body = body
 
     class AttrDeclarationNode(DeclarationNode):
-        def __init__(self, token, typex, expr = None):
-            self.id = token.lex
-            self.line = expr.line if expr else token.line
-            self.column = expr.column if expr else token.column
+        def __init__(self, idx, typex, arrowToken = None, expr = None):
+            self.id = idx.lex
+            self.line = arrowToken.next_token.line if expr else typex.line
+            self.column = arrowToken.next_token.column if expr else typex.column
             self.type = typex.lex
             self.expr = expr
 
@@ -64,8 +69,8 @@ def __init__(self, if_expr, then_expr, else_expr,token):
             self.if_expr = if_expr
             self.then_expr = then_expr
             self.else_expr = else_expr
-            self.line = token.line
-            self.column = token.column
+            self.line = token.next_token.line
+            self.column = token.next_token.column
     
     class WhileNode(ExpressionNode):
         def __init__(self, conditional_expr, loop_expr, token):
@@ -90,21 +95,26 @@ def __init__(self, identifiers, in_expr, token):
     class CaseNode(ExpressionNode):
         def __init__(self, predicate, branches, token):
             self.predicate = predicate
-            self.branches = [tuple([item.lex if isinstance(item, Token) else item for item in _list]) for _list in branches]
+            self.branches = []
+            self.branchesPos = []
+            for branch in branches:
+                self.branches.append(tuple([item.lex if isinstance(item, Token) else item for item in branch]))
+                _,typex,_ = branch
+                self.branchesPos.append((typex.line,typex.column))
             self.line = token.line
             self.column = token.column
     
     class NotNode(ExpressionNode):
         def __init__(self, expr, token):
             self.expr = expr
-            self.line = token.line + 4
-            self.column = token.column + 4
+            self.line = token.next_token.line
+            self.column = token.next_token.column
 
     class AtomicNode(ExpressionNode):
-        def __init__(self, token):
-            self.lex = token.lex if isinstance(token, Token) else token
-            self.line = token.line
-            self.column = token.column
+        def __init__(self, expr):
+            self.lex = expr.lex if isinstance(expr, Token) else expr
+            self.line = expr.line
+            self.column = expr.column
 
     class BinaryNode(ExpressionNode):
         def __init__(self, left, right, token):
@@ -125,12 +135,15 @@ class VariableNode(AtomicNode):
     class InstantiateNode(AtomicNode):
         def __init__(self, typex, token):
             self.lex =  typex.lex
-            self.line = token.line + 4
-            self.column = token.column + 4
+            self.line = token.next_token.line
+            self.column = token.next_token.column
     class IsVoidNode(AtomicNode):
         pass
     class ComplementNode(AtomicNode):
-        pass
+        def __init__(self, expr, token):
+            self.lex = expr.lex if isinstance(expr, Token) else expr
+            self.line = token.next_token.line
+            self.column = token.next_token.column
 
 
     class PlusNode(BinaryNode):
diff --git a/src/utils/print_code.py b/src/utils/print_code.py
new file mode 100644
index 000000000..1ff4ac195
--- /dev/null
+++ b/src/utils/print_code.py
@@ -0,0 +1,153 @@
+import cmp.visitor as visitor
+from utils.ast.AST_Nodes import ast_nodes as nodes
+
+class PrintCode:
+    @visitor.on('node')
+    def visit(self, node, tabs = 0):
+        pass
+
+    @visitor.when(nodes.ProgramNode)
+    def visit(self, node, tabs = 0):
+        return '\n'.join(self.visit(dec, tabs) for dec in node.declarations)
+
+
+    @visitor.when(nodes.ClassDeclarationNode)
+    def visit(self, node, tabs = 0):
+        parent = '' if node.parent is None else f'inherits {node.parent}'
+        ans = '\t' * tabs + f'class {node.id} {parent}'
+        features = '\n'.join(self.visit(feat, tabs + 1) for feat in node.features)
+        return f'{ans} {{\n{features}\n}};'
+
+
+    @visitor.when(nodes.AttrDeclarationNode)
+    def visit(self, node, tabs = 0):
+        expr = '' if node.expr is None else f'<- {self.visit(node.expr)}'
+        return '\t' * tabs + f'{node.id}: {node.type} {expr};'
+    
+
+    @visitor.when(nodes.MethDeclarationNode)
+    def visit(self, node, tabs = 0):
+        params = ', '.join(': '.join(param) for param in node.params)
+        ans = '\t' * tabs + f'{node.id} ({params}): {node.type}'
+        body = self.visit(node.body, tabs + 1)
+        return f'{ans} {{\n{body}\n' + '\t' * tabs + '};'
+    
+
+    @visitor.when(nodes.AssignNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{node.id} <- {self.visit(node.expr)}'
+
+
+    @visitor.when(nodes.CallNode)
+    def visit(self, node, tabs = 0):
+        obj = '' if node.obj is None else f'{self.visit(node.obj)}' if node.type else f'{self.visit(node.obj)}.'
+        args = ', '.join(self.visit(arg) for arg in node.args)
+        typex = '' if node.type is None else f'@ {node.type}'
+        return '\t' * tabs + f'{obj}{typex}{node.id} ({args})'
+
+    
+    @visitor.when(nodes.IfThenElseNode)
+    def visit(self, node, tabs = 0):
+        ifx = self.visit(node.if_expr)
+        then = self.visit(node.then_expr, tabs + 1)
+        elsex = self.visit(node.else_expr, tabs + 1)
+
+        return '\t' * tabs + f'if {ifx}\n' + '\t' * tabs + f'then\n{then}\n' + '\t' * tabs + f'else\n{elsex}\n' + '\t' * tabs + 'fi'
+
+
+    @visitor.when(nodes.WhileNode)
+    def visit(self, node, tabs = 0):
+        ans = f'while {self.visit(node.conditional_expr)} loop'
+        body = self.visit(node.loop_expr, tabs + 1)
+
+        return '\t' * tabs + f'{ans}\n{body}\n' + '\t' * tabs + 'pool'
+
+
+    @visitor.when(nodes.BlockNode)
+    def visit(self, node, tabs = 0):
+        expr_list = ';\n'.join(self.visit(expr, tabs + 1) for expr in node.expr_list)
+        return '\t' * tabs + f'{{\n{expr_list};\n' + '\t' * tabs + '}'
+
+
+    @visitor.when(nodes.LetNode)
+    def visit(self, node, tabs = 0):
+        identifiers = []
+        for idx, typex, id_expr in node.identifiers:
+            if id_expr:
+                identifiers.append(f'{idx}: {typex} <- {self.visit(id_expr)}')
+            else:
+                identifiers.append(f'{idx}: {typex}')
+        
+        identifiers = (',\n' + '\t' * (tabs + 1)).join(identifiers)
+        return '\t' * tabs + f'let {identifiers} in\n{self.visit(node.in_expr, tabs + 1)}'
+    
+
+    @visitor.when(nodes.CaseNode)
+    def visit(self, node, tabs = 0):
+        predicate = self.visit(node.predicate)
+        branches = '\n'.join(f'\t' * (tabs + 1) + f'{idx}: {typex} =>\n{self.visit(expr, tabs + 2)};' for idx, typex, expr in node.branches)
+
+        return '\t' * tabs + f'case {predicate} of \n{branches}\n' + '\t' * tabs + 'esac'
+
+    @visitor.when(nodes.NotNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'not {self.visit(node.expr)}'
+
+
+    @visitor.when(nodes.ConstantNumNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{node.lex}' 
+    
+    @visitor.when(nodes.ConstantBoolNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{node.lex}'
+
+    @visitor.when(nodes.ConstantStringNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{node.lex}'
+
+    @visitor.when(nodes.VariableNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{node.lex}'
+
+
+    @visitor.when(nodes.InstantiateNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'(new {node.lex})'
+
+    @visitor.when(nodes.IsVoidNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'isvoid {self.visit(node.lex)}'
+    
+    @visitor.when(nodes.ComplementNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'~ {self.visit(node.lex)}'
+
+
+    @visitor.when(nodes.PlusNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} + {self.visit(node.right)}'
+
+    @visitor.when(nodes.MinusNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} - {self.visit(node.right)}'
+    
+    @visitor.when(nodes.StarNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} * {self.visit(node.right)}'
+
+    @visitor.when(nodes.DivNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} / {self.visit(node.right)}'
+
+    @visitor.when(nodes.LessThanNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} < {self.visit(node.right)}'
+    
+    @visitor.when(nodes.LessEqualNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} <= {self.visit(node.right)}'
+    
+    @visitor.when(nodes.EqualNode)
+    def visit(self, node, tabs = 0):
+        return '\t' * tabs + f'{self.visit(node.left)} = {self.visit(node.right)}'
\ No newline at end of file
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index f6af1804e..556c12060 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -2,7 +2,7 @@
 from utils.ast.AST_Nodes import ast_nodes as nodes
 from cmp.semantic import SemanticError, ErrorType
 
-NOT_INHERIT_FROM_BASICS_TYPES = '(%s, %s) - TypeError: Type %s cannot inherit from basic type %s'
+NOT_INHERIT_FROM_BASICS_TYPES = '(%s, %s) - SemanticError: Class %s cannot inherit class %s. '
 
 
 class TypeBuilder:
@@ -28,8 +28,8 @@ def visit(self,node):
 
         if node.parent is not None:
 
-            if node.parent in ['Int', 'String', 'SELF_TYPE', 'Bool']:
-                self.errors.append(NOT_INHERIT_FROM_BASICS_TYPES % (node.line, node.column, node.id, node.parent))
+            if node.parent in ['Int', 'String', 'SELF_TYPE', 'Bool', 'Object']:
+                self.errors.append(NOT_INHERIT_FROM_BASICS_TYPES % (node.line, node.parent_column, node.id, node.parent))
 
             else:
                 try:
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index b63740c0a..b910b92cc 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -15,6 +15,7 @@
 INCOMPATIBLE_TYPES_ATTR = '(%s, %s) - TypeError: Inferred type %s of initialization of attribute %s does not conform to declared type %s.'
 INCOMPATIBLE_TYPES_ARG = '(%s, %s) - TypeError: Argument of \'%s\' has type %s instead of %s.'
 INCOMPATIBLE_TYPES_METH = '(%s, %s) - TypeError: Inferred return type %s of method %s does not conform to declared return type %s.'
+INCOMPATIBLE_TYPES_IF = '(%s, %s) - TypeError: Predicate of \'%s\' does not have type %s.'
 INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
 WRONG_SIGNATURE = '(%s, %s) - TypeError: Method %s already defined in %s with a different signature.'
 LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable %s is already defined in method %s.'
@@ -23,6 +24,9 @@
 INHERIT_ERROR = '(%s, %s) - TypeError: Class %s cannot inherit from class %s because they form a cycle.'
 METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
 
+DUPLICATE_BRANCH = '(%s, %s) - SemanticError: Duplicate branch %s in case statement.'
+UNDEFINED_TYPE_BRANCH = '(%s, %s) - TypeError: Class %s of case branch is undefined.'
+
 
 
 class TypeChecker:
@@ -77,7 +81,7 @@ def visit(self, node, scope):
                 self.errors.append(INHERIT_ERROR % (node.line, node.column, self.current_type.name, self.current_type.parent.name))
                 self.current_type.parent = ErrorType()
                 break
-            
+
             for attr in current_parent.attributes:
                 scope.define_variable(attr.name, attr.type)
 
@@ -225,7 +229,7 @@ def visit(self, node, scope):
         if_type = self.visit(node.if_expr, scope.create_child())
 
         if not if_type.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, if_type.name, 'Bool'))
+            self.errors.append(INCOMPATIBLE_TYPES_IF % (node.line, node.column,'if','Bool'))
         
         then_type = self.visit(node.then_expr, scope.create_child())
         else_type = self.visit(node.else_expr, scope.create_child())
@@ -284,9 +288,13 @@ def visit(self, node, scope):
         self.visit(node.predicate, scope)
         case_type = None
 
-        for idx, typex, expr in node.branches:
+        for i,branch in enumerate(node.branches):
+            (idx, typex, expr) = branch
+            (line,column) = node.branchesPos[i]
+            if typex in [b[1] for b in node.branches[:i]]:
+                self.errors.append(DUPLICATE_BRANCH % (line, column, typex))
             if typex == 'SELF_TYPE':
-                self.errors.append(SELF_TYPE_IN_CASE_BRANCH % (node.line, node.column))
+                self.errors.append(SELF_TYPE_IN_CASE_BRANCH % (line, column))
                 id_type = ErrorType()
                 
             else:
@@ -294,7 +302,7 @@ def visit(self, node, scope):
                     id_type = self.context.get_type(typex)
                 except SemanticError as se:
                     id_type = ErrorType()
-                    self.errors.append(se.text)
+                    self.errors.append(UNDEFINED_TYPE_BRANCH % (line, column, typex))
             
             inner_scope = scope.create_child()
             inner_scope.define_variable(idx, id_type)
diff --git a/src/utils/semantic_check/type_collector.py b/src/utils/semantic_check/type_collector.py
index 1a5b4f828..dc160530f 100644
--- a/src/utils/semantic_check/type_collector.py
+++ b/src/utils/semantic_check/type_collector.py
@@ -2,6 +2,9 @@
 from utils.ast.AST_Nodes import ast_nodes as nodes
 from cmp.semantic import SemanticError
 
+NOT_REDEFINE_BASIC_TYPES = '(%s, %s) - SemanticError: Redefinition of basic class %s.'
+NOT_REDEFINE_CLASSES = '(%s, %s) - SemanticError: Classes may not be redefined'
+
 class TypeCollector(object):
     def __init__(self, context, errors):
         self.context = context
@@ -50,7 +53,10 @@ def visit(self, node):
     @visitor.when(nodes.ClassDeclarationNode)
     def visit(self,node):
         try:
+            if node.id in ["Object", "Int", "String", "Bool", "IO"]:
+                self.errors.append(NOT_REDEFINE_BASIC_TYPES % (node.line, node.column, node.id))
+                node.id = 'error_type'
             self.context.create_type(node.id)
         except SemanticError as se:
-            self.errors.append(se.text)
+            self.errors.append(NOT_REDEFINE_CLASSES % (node.classt_line, node.classt_column))
         return
\ No newline at end of file
diff --git a/src/utils/semantic_check/type_inference.py b/src/utils/semantic_check/type_inference.py
new file mode 100644
index 000000000..cf23de1d5
--- /dev/null
+++ b/src/utils/semantic_check/type_inference.py
@@ -0,0 +1,376 @@
+import cmp.visitor as visitor
+from utils.ast.AST_Nodes import ast_nodes as nodes
+from cmp.semantic import SemanticError, ErrorType, Scope, VariableInfo
+
+INFERENCE_ATTR_ERROR = 'Cannot infer type for attribute "%s" in class "%s".'
+INFERENCE_METH_ERROR = 'Cannot infer return type for method "%s" in class "%s".'
+INFERENCE_PARAMETER_ERROR = 'Cannot infer type for parameter "%s" of method "%s" in class "%s".'
+INFERENCE_VARIABLE_ERROR = 'Cannot infer type for variable "%s" of method "%s" in class "%s".'
+
+class TypeInference:
+    def __init__(self, context, errors = []):
+        self.context = context
+        self.current_type = None
+        self.current_method = None
+        self.errors = errors
+        self.update = True
+
+    
+    @visitor.on('node')
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.ProgramNode)
+    def visit(self, node, scope=None):
+        for i,dec in enumerate(node.declarations):
+            self.visit(dec, scope.children[i])
+        
+        return scope
+
+
+    @visitor.when(nodes.ClassDeclarationNode)
+    def visit(self, node, scope):
+        self.current_type = self.context.get_type(node.id)
+
+        attrs = [feat for feat in node.features if isinstance(feat, nodes.AttrDeclarationNode)]
+        i = 0
+        for attr in attrs:
+            if attr.expr is not None:
+                attr.index = i
+                i += 1
+            self.visit(attr, scope)
+        
+        meths = [feat for feat in node.features if isinstance(feat, nodes.MethDeclarationNode)]
+        for meth in meths:
+            self.visit(meth, scope.children[i])
+            i+=1
+
+        for attr in attrs:
+            var = scope.find_variable(attr.id)
+            if var.type.name == 'AUTO_TYPE':
+                var.update_type()
+                if var.type.name == 'AUTO_TYPE':
+                    self.errors.append(INFERENCE_ATTR_ERROR % (attr.id, self.current_type.name))
+                else:
+                    self.update = True
+                    self.current_type.get_attribute(attr.id).type = var.type
+                    attr.type = var.type.name
+                    
+        return
+
+
+    @visitor.when(nodes.AttrDeclarationNode)
+    def visit(self, node, scope):
+
+        if node.expr is not None:
+            attr = self.current_type.get_attribute(node.id)
+            var = scope.find_variable(node.id)
+
+            type_expr = self.visit(node.expr, scope.children[node.index], attr.type)
+            
+            # se infiere el tipo a partir de su expresion de inicializacion
+            if type_expr.name != 'AUTO_TYPE':
+                var.expected_types.append(type_expr)
+        return
+        
+    @visitor.when(nodes.MethDeclarationNode)
+    def visit(self, node, scope):
+        self.current_method = self.current_type.get_method(node.id)
+        
+        return_type = self.current_method.return_type
+
+        # el tipo del body se espera que sea el tipo de return type
+        body_type = self.visit(node.body, scope, self.current_type if return_type.name == 'SELF_TYPE' else return_type if return_type.name != 'AUTO_TYPE' else None)
+
+        for i, (name, typex) in enumerate(node.params):
+            var = scope.find_variable(name)
+            var.expected_types = var.expected_types + self.current_method.expected_param_types[name] if name in self.current_method.expected_param_types else var.expected_types
+
+            if var.type.name == 'AUTO_TYPE':
+                var.update_type()
+                if var.type.name == 'AUTO_TYPE':
+                    self.errors.append(INFERENCE_PARAMETER_ERROR % (self.current_method.param_names[i], self.current_method.name, self.current_type.name))
+                else:
+                    self.update = True
+                    self.current_method.param_types[i] = var.type
+                    node.params[i][1] = var.type.name
+        
+        var = VariableInfo(self.current_method.name, return_type)
+
+        # se infiere el tipo de retorno a partir del tipo del cuerpo del metodo
+        if body_type.name != 'AUTO_TYPE':
+            var.expected_types.append(body_type)
+
+        var.expected_types = var.expected_types + [self.current_method.expected_return_type] if self.current_method.expected_return_type else var.expected_types
+
+        if var.type.name == 'AUTO_TYPE':
+                var.update_type()
+                if var.type.name == 'AUTO_TYPE':
+                    self.errors.append(INFERENCE_METH_ERROR % (self.current_method.name, self.current_type.name))
+                else:
+                    self.update = True
+                    self.current_method.return_type = var.type
+                    node.type = var.type.name
+
+        self.current_method.expected_param_types = {}
+        self.current_method.expected_return_type = None
+        return
+
+
+    @visitor.when(nodes.AssignNode)
+    def visit(self, node, scope, expected_type = None):
+        var = scope.find_variable(node.id) if scope.is_defined(node.id) else None
+
+        # el tipo de la expresion se inifere a partir del tipo esperado de la asignacion
+        type_expr = self.visit(node.expr, scope.children[0], var.type if var and var.type.name != 'AUTO_TYPE' else expected_type)
+
+        # se infiere el tipo de la variable a partir de la expresion de asignacion
+        if type_expr.name != 'AUTO_TYPE':
+            var.expected_types.append(type_expr)
+
+        return type_expr
+
+
+    @visitor.when(nodes.CallNode)
+    def visit(self, node, scope, expected_type = None):
+        typex = None
+        if node.type is not None:
+            try:
+                typex = self.context.get_type(node.type)
+            except SemanticError:
+                typex = ErrorType()
+            else:
+                if typex.name == 'SELF_TYPE' or typex.name == 'AUTO_TYPE':
+                    typex = ErrorType()
+            
+        if node.obj is None:
+            type_obj = self.current_type
+        else:
+            type_obj = self.visit(node.obj, scope, typex)
+        
+        type_obj = type_obj if not typex else typex
+
+        try:
+            meth = type_obj.get_method(node.id)
+        except SemanticError:
+            for arg in node.args:
+                self.visit(node.args, scope)
+            return ErrorType()
+        
+        for i, arg in enumerate(node.args):
+            type_arg = self.visit(arg, scope, meth.param_types[i] if i < len(meth.param_types) and meth.param_types[i].name != 'AUTO_TYPE' else None)
+
+            # el tipo esperado de los parametros se infiere a partir del tipo de los argumentos
+            if i < len(meth.param_types) and type_arg.name != 'AUTO_TYPE':
+                try:
+                    meth.expected_param_types[meth.param_names[i]].append(type_arg)
+                except KeyError:
+                    meth.expected_param_types[meth.param_names[i]] = [type_arg]
+
+        # el tipo de retorno del metodo llamado se infiere a partir del tipo esperado del llamado
+        meth.expected_return_type = expected_type if expected_type and expected_type.name != 'AUTO_TYPE' else meth.expected_return_type
+        
+        return meth.return_type if meth.return_type.name != 'SELF_TYPE' else type_obj 
+
+
+    @visitor.when(nodes.IfThenElseNode)
+    def visit(self, node, scope, expected_type = None):  
+        # se espera que el tipo de la expresion if sea Bool
+        if_type = self.visit(node.if_expr, scope.children[0], self.context.get_type('Bool'))
+
+        then_type = self.visit(node.then_expr, scope.children[1])
+        else_type = self.visit(node.else_expr, scope.children[2])
+
+        return then_type.join(else_type)
+
+
+    @visitor.when(nodes.WhileNode)
+    def visit(self, node, scope, expected_type = None):
+
+        # la condicion del while debe ser de tipo Bool
+        self.visit(node.conditional_expr, scope, self.context.get_type('Bool'))
+
+        self.visit(node.loop_expr, scope.children[0])
+
+        return self.context.get_type('Object')
+
+
+    @visitor.when(nodes.BlockNode)
+    def visit(self, node, scope, expected_type = None):
+        type_expr = ErrorType()
+        for i, expr in enumerate(node.expr_list):
+            # el tipo de la expresion se inifiere a partir de expected_type
+            type_expr = self.visit(expr, scope.children[i]) if i != len(node.expr_list) - 1 else self.visit(expr, scope.children[i], expected_type)
+        
+        return type_expr
+
+
+    @visitor.when(nodes.LetNode)
+    def visit(self, node, scope, expected_type = None):
+        # se inifiere l tipo a partir de expected_type
+        body_type = self.visit(node.in_expr, scope.children[-1], expected_type)
+
+        child_scope_index = 0
+        for i, (idx, typex, id_expr) in enumerate(node.identifiers):
+            if id_expr:
+                var = scope.find_variable(idx)
+                id_expr_type = self.visit(id_expr, scope.children[child_scope_index], var.type if var.type.name != 'AUTO_TYPE' else None)
+                child_scope_index += 1
+
+                # se inifere el tipo de un identificador a partir de su expresion de inicializacion
+                if id_expr_type.name != 'AUTO_TYPE':
+                    var.expected_types.append(id_expr_type)
+
+        
+        for i, (idx, typex, id_expr) in enumerate(node.identifiers):
+            var = scope.find_variable(idx)
+            if var.type.name == 'AUTO_TYPE':
+                var.update_type()
+                if var.type.name == 'AUTO_TYPE':
+                    self.errors.append(INFERENCE_VARIABLE_ERROR % (var.name, self.current_method.name, self.current_type.name))
+                else:
+                    self.update = True
+                    node.identifiers[i] = (idx, var.type.name, id_expr)
+
+
+        return body_type
+
+
+    @visitor.when(nodes.CaseNode)
+    def visit(self, node, scope, expected_type = None):
+        case_type = None
+
+        for i, (idx, typex, expr) in enumerate(node.branches):
+            type_expr = self.visit(expr, scope.children[i])
+            
+            case_type = case_type.join(type_expr) if case_type else type_expr
+
+        return case_type
+
+
+    @visitor.when(nodes.NotNode)
+    def visit(self, node, scope, expected_type = None):
+        # se el tipo de la expresion de not se infiere que sea Bool
+        self.visit(node.expr, scope, self.context.get_type('Bool'))
+
+        return self.context.get_type('Bool')
+
+
+    @visitor.when(nodes.ConstantNumNode)
+    def visit(self, node, scope, expected_type = None):
+        return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.ConstantBoolNode)
+    def visit(self, node, scope, expected_type = None):
+        return self.context.get_type('Bool')
+
+
+    @visitor.when(nodes.ConstantStringNode)
+    def visit(self, node, scope, expected_type = None):
+        return self.context.get_type('String')
+
+
+    @visitor.when(nodes.VariableNode)
+    def visit(self, node, scope, expected_type = None):
+        var = scope.find_variable(node.lex)
+        
+        if var is not None:
+            # el tipo esperado de var es expected_type
+            if expected_type and expected_type != 'AUTO_TYPE':
+                var.expected_types.append(expected_type)
+            return var.type
+
+        return ErrorType()
+
+
+    @visitor.when(nodes.InstantiateNode)
+    def visit(self, node, scope, expected_type = None):
+        if node.lex in self.context.types:
+            return self.context.get_type(node.lex)
+        
+        return ErrorType()
+
+
+    @visitor.when(nodes.IsVoidNode)
+    def visit(self, node, scope, expected_type = None):
+        self.visit(node.lex, scope)
+
+        return self.context.get_type('Bool')
+
+
+    @visitor.when(nodes.ComplementNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expression se espera que sea Int
+        self.visit(node.lex, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.PlusNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expresiones se espera que sea Int
+        self.visit(node.left, scope, self.context.get_type('Int'))
+        self.visit(node.right, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.MinusNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expresiones se espera que sea Int
+        self.visit(node.left, scope, self.context.get_type('Int'))
+        self.visit(node.right, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.StarNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expresiones se espera que sea Int
+        self.visit(node.left, scope, self.context.get_type('Int'))
+        self.visit(node.right, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.DivNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expresiones se espera que sea Int
+        self.visit(node.left, scope, self.context.get_type('Int'))
+        self.visit(node.right, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Int')
+
+
+    @visitor.when(nodes.LessThanNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expresiones se espera que sea Int
+        self.visit(node.left, scope, self.context.get_type('Int'))
+        self.visit(node.right, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Bool')
+
+
+    @visitor.when(nodes.LessEqualNode)
+    def visit(self, node, scope, expected_type = None):
+        # el tipo de la expresiones se espera que sea Int
+        self.visit(node.left, scope, self.context.get_type('Int'))
+        self.visit(node.right, scope, self.context.get_type('Int'))
+
+        return self.context.get_type('Bool')
+
+
+
+    @visitor.when(nodes.EqualNode)
+    def visit(self, node, scope, expected_type = None):
+        type_left = self.visit(node.left, scope)
+        # se infiere el tipo a la derecha del igual a partir del tipo izquierdo
+        type_right = self.visit(node.right, scope, type_left if type_left.name != 'AUTO_TYPE' else None)
+
+        if type_left.name == 'AUTO_TYPE':
+            # se inifiere el tipo a la izquierda del igual a partir de su tipo derecho
+            self.visit(node.left, scope, type_right if type_right.name != 'AUTO_TYPE' else None)
+
+        return self.context.get_type('Bool')
\ No newline at end of file

From 44538fb7772ecc3fb2b8e2135a53964acbca0f71 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 13:30:20 -0800
Subject: [PATCH 24/83] update main

---
 src/main.py | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/src/main.py b/src/main.py
index 7b8464413..6f77af4ee 100644
--- a/src/main.py
+++ b/src/main.py
@@ -7,9 +7,7 @@
 from cmp.semantic import Context
 from utils.semantic_check.type_collector import TypeCollector
 from utils.semantic_check.type_builder import TypeBuilder
-from utils.semantic_check.type_checker import TypeChecker
-
-a = 'arithmetic1.cl' 
+from utils.semantic_check.type_checker import TypeChecker 
 
 def main(args):
     
@@ -38,7 +36,7 @@ def main(args):
     
     if parser.error:
         print(parser.error)
-        exit(1)
+        raise Exception()
         
     # ast       
     ast = evaluate_reverse_parse(G, derivation, operations, lexer.fixed_tokens(tokens))
@@ -58,14 +56,14 @@ def main(args):
     if semantic_errors:
         for error in semantic_errors:
             print(error)                          
-        exit(1)
+        raise Exception()
 
-# if __name__ == "__main__":
+if __name__ == "__main__":
 
-#     parser = argparse.ArgumentParser(description='description')
-#     parser.add_argument('-f', '--file', type=str, default='', help='file to read')
+    parser = argparse.ArgumentParser(description='description')
+    parser.add_argument('-f', '--file', type=str, default='', help='file to read')
 
-#     args = parser.parse_args()
-#     main(args)
+    args = parser.parse_args()
+    main(args)
 
-main('dispatch1.cl')
\ No newline at end of file
+#main('dispatch1.cl')
\ No newline at end of file

From 2ff9e9211566e2262b960c33198737acf38cc746 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 13:51:36 -0800
Subject: [PATCH 25/83] instructions to run code

---
 src/coolc.sh |  9 +++++----
 src/main.py  | 33 +++++++++++++--------------------
 2 files changed, 18 insertions(+), 24 deletions(-)

diff --git a/src/coolc.sh b/src/coolc.sh
index 5d3764e5f..5a4697ff8 100755
--- a/src/coolc.sh
+++ b/src/coolc.sh
@@ -4,9 +4,10 @@ INPUT_FILE=$1
 OUTPUT_FILE=${INPUT_FILE:0: -2}mips
 
 # Si su compilador no lo hace ya, aquí puede imprimir la información de contacto
-echo "LINEA_CON_NOMBRE_Y_VERSION_DEL_COMPILADOR"        # TODO: Recuerde cambiar estas
-echo "Copyright (c) 2019: Nombre1, Nombre2, Nombre3"    # TODO: líneas a los valores correctos
+echo "Cool Compiler 2021 v1"        # TODO: Recuerde cambiar estas
+echo "Copyright (c) 2021: Alejandro Campos, Darian Dominguez"    # TODO: líneas a los valores correctos
+
+FILE="main.py"
 
 # Llamar al compilador
-echo "Compiling $INPUT_FILE into $OUTPUT_FILE"
-python main.py -f $INPUT_FILE
\ No newline at end of file
+python ${FILE} $INPUT_FILE $OUTPUT_FILE
diff --git a/src/main.py b/src/main.py
index 6f77af4ee..f3dbe3c78 100644
--- a/src/main.py
+++ b/src/main.py
@@ -1,5 +1,7 @@
-import argparse 
+import argparse
 import os
+import sys
+from pathlib import Path
 from utils.COOL_Grammar import build_COOL_Grammar
 from utils.COOL_Lexer import COOL_Lexer
 from utils.parser.COOL_parser import COOL_Parser
@@ -9,15 +11,16 @@
 from utils.semantic_check.type_builder import TypeBuilder
 from utils.semantic_check.type_checker import TypeChecker 
 
-def main(args):
+if __name__ == "__main__":
+    add = "lexer/comment1.cl"
+
+    path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
+        f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
+
+    _in = sys.argv[1] if len(sys.argv) > 1 else path
     
-    try:
-        #with open(args.file, 'r') as file:
-        with open(os.getcwd() + '/tester/semantic/' + args, 'r') as file:
-            code = file.read()
-    except:
-        print(f"(0,0) - CompilerError: file {args.file} not found")
-        exit(1)
+    with open(_in) as file:
+        code = file.read()
 
     G = build_COOL_Grammar()
 
@@ -56,14 +59,4 @@ def main(args):
     if semantic_errors:
         for error in semantic_errors:
             print(error)                          
-        raise Exception()
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser(description='description')
-    parser.add_argument('-f', '--file', type=str, default='', help='file to read')
-
-    args = parser.parse_args()
-    main(args)
-
-#main('dispatch1.cl')
\ No newline at end of file
+        raise Exception()
\ No newline at end of file

From 30572b8c3175def428ee5dea9d7210ba548b6cc6 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 13:55:45 -0800
Subject: [PATCH 26/83] updating code

---
 src/main.py                                |   1 -
 src/utils/COOL_Lexer.py                    |   1 -
 src/utils/semantic_check/type_inference.py | 376 ---------------------
 3 files changed, 378 deletions(-)
 delete mode 100644 src/utils/semantic_check/type_inference.py

diff --git a/src/main.py b/src/main.py
index f3dbe3c78..ecf6ee5c4 100644
--- a/src/main.py
+++ b/src/main.py
@@ -1,4 +1,3 @@
-import argparse
 import os
 import sys
 from pathlib import Path
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index dc241493d..22aead8af 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -1,5 +1,4 @@
 import re
-import sys
 
 '''
 Recibe como parametros el lexema, tipo, linea y columna donde se encuentra
diff --git a/src/utils/semantic_check/type_inference.py b/src/utils/semantic_check/type_inference.py
deleted file mode 100644
index cf23de1d5..000000000
--- a/src/utils/semantic_check/type_inference.py
+++ /dev/null
@@ -1,376 +0,0 @@
-import cmp.visitor as visitor
-from utils.ast.AST_Nodes import ast_nodes as nodes
-from cmp.semantic import SemanticError, ErrorType, Scope, VariableInfo
-
-INFERENCE_ATTR_ERROR = 'Cannot infer type for attribute "%s" in class "%s".'
-INFERENCE_METH_ERROR = 'Cannot infer return type for method "%s" in class "%s".'
-INFERENCE_PARAMETER_ERROR = 'Cannot infer type for parameter "%s" of method "%s" in class "%s".'
-INFERENCE_VARIABLE_ERROR = 'Cannot infer type for variable "%s" of method "%s" in class "%s".'
-
-class TypeInference:
-    def __init__(self, context, errors = []):
-        self.context = context
-        self.current_type = None
-        self.current_method = None
-        self.errors = errors
-        self.update = True
-
-    
-    @visitor.on('node')
-    def visit(self, node, scope):
-        pass
-
-
-    @visitor.when(nodes.ProgramNode)
-    def visit(self, node, scope=None):
-        for i,dec in enumerate(node.declarations):
-            self.visit(dec, scope.children[i])
-        
-        return scope
-
-
-    @visitor.when(nodes.ClassDeclarationNode)
-    def visit(self, node, scope):
-        self.current_type = self.context.get_type(node.id)
-
-        attrs = [feat for feat in node.features if isinstance(feat, nodes.AttrDeclarationNode)]
-        i = 0
-        for attr in attrs:
-            if attr.expr is not None:
-                attr.index = i
-                i += 1
-            self.visit(attr, scope)
-        
-        meths = [feat for feat in node.features if isinstance(feat, nodes.MethDeclarationNode)]
-        for meth in meths:
-            self.visit(meth, scope.children[i])
-            i+=1
-
-        for attr in attrs:
-            var = scope.find_variable(attr.id)
-            if var.type.name == 'AUTO_TYPE':
-                var.update_type()
-                if var.type.name == 'AUTO_TYPE':
-                    self.errors.append(INFERENCE_ATTR_ERROR % (attr.id, self.current_type.name))
-                else:
-                    self.update = True
-                    self.current_type.get_attribute(attr.id).type = var.type
-                    attr.type = var.type.name
-                    
-        return
-
-
-    @visitor.when(nodes.AttrDeclarationNode)
-    def visit(self, node, scope):
-
-        if node.expr is not None:
-            attr = self.current_type.get_attribute(node.id)
-            var = scope.find_variable(node.id)
-
-            type_expr = self.visit(node.expr, scope.children[node.index], attr.type)
-            
-            # se infiere el tipo a partir de su expresion de inicializacion
-            if type_expr.name != 'AUTO_TYPE':
-                var.expected_types.append(type_expr)
-        return
-        
-    @visitor.when(nodes.MethDeclarationNode)
-    def visit(self, node, scope):
-        self.current_method = self.current_type.get_method(node.id)
-        
-        return_type = self.current_method.return_type
-
-        # el tipo del body se espera que sea el tipo de return type
-        body_type = self.visit(node.body, scope, self.current_type if return_type.name == 'SELF_TYPE' else return_type if return_type.name != 'AUTO_TYPE' else None)
-
-        for i, (name, typex) in enumerate(node.params):
-            var = scope.find_variable(name)
-            var.expected_types = var.expected_types + self.current_method.expected_param_types[name] if name in self.current_method.expected_param_types else var.expected_types
-
-            if var.type.name == 'AUTO_TYPE':
-                var.update_type()
-                if var.type.name == 'AUTO_TYPE':
-                    self.errors.append(INFERENCE_PARAMETER_ERROR % (self.current_method.param_names[i], self.current_method.name, self.current_type.name))
-                else:
-                    self.update = True
-                    self.current_method.param_types[i] = var.type
-                    node.params[i][1] = var.type.name
-        
-        var = VariableInfo(self.current_method.name, return_type)
-
-        # se infiere el tipo de retorno a partir del tipo del cuerpo del metodo
-        if body_type.name != 'AUTO_TYPE':
-            var.expected_types.append(body_type)
-
-        var.expected_types = var.expected_types + [self.current_method.expected_return_type] if self.current_method.expected_return_type else var.expected_types
-
-        if var.type.name == 'AUTO_TYPE':
-                var.update_type()
-                if var.type.name == 'AUTO_TYPE':
-                    self.errors.append(INFERENCE_METH_ERROR % (self.current_method.name, self.current_type.name))
-                else:
-                    self.update = True
-                    self.current_method.return_type = var.type
-                    node.type = var.type.name
-
-        self.current_method.expected_param_types = {}
-        self.current_method.expected_return_type = None
-        return
-
-
-    @visitor.when(nodes.AssignNode)
-    def visit(self, node, scope, expected_type = None):
-        var = scope.find_variable(node.id) if scope.is_defined(node.id) else None
-
-        # el tipo de la expresion se inifere a partir del tipo esperado de la asignacion
-        type_expr = self.visit(node.expr, scope.children[0], var.type if var and var.type.name != 'AUTO_TYPE' else expected_type)
-
-        # se infiere el tipo de la variable a partir de la expresion de asignacion
-        if type_expr.name != 'AUTO_TYPE':
-            var.expected_types.append(type_expr)
-
-        return type_expr
-
-
-    @visitor.when(nodes.CallNode)
-    def visit(self, node, scope, expected_type = None):
-        typex = None
-        if node.type is not None:
-            try:
-                typex = self.context.get_type(node.type)
-            except SemanticError:
-                typex = ErrorType()
-            else:
-                if typex.name == 'SELF_TYPE' or typex.name == 'AUTO_TYPE':
-                    typex = ErrorType()
-            
-        if node.obj is None:
-            type_obj = self.current_type
-        else:
-            type_obj = self.visit(node.obj, scope, typex)
-        
-        type_obj = type_obj if not typex else typex
-
-        try:
-            meth = type_obj.get_method(node.id)
-        except SemanticError:
-            for arg in node.args:
-                self.visit(node.args, scope)
-            return ErrorType()
-        
-        for i, arg in enumerate(node.args):
-            type_arg = self.visit(arg, scope, meth.param_types[i] if i < len(meth.param_types) and meth.param_types[i].name != 'AUTO_TYPE' else None)
-
-            # el tipo esperado de los parametros se infiere a partir del tipo de los argumentos
-            if i < len(meth.param_types) and type_arg.name != 'AUTO_TYPE':
-                try:
-                    meth.expected_param_types[meth.param_names[i]].append(type_arg)
-                except KeyError:
-                    meth.expected_param_types[meth.param_names[i]] = [type_arg]
-
-        # el tipo de retorno del metodo llamado se infiere a partir del tipo esperado del llamado
-        meth.expected_return_type = expected_type if expected_type and expected_type.name != 'AUTO_TYPE' else meth.expected_return_type
-        
-        return meth.return_type if meth.return_type.name != 'SELF_TYPE' else type_obj 
-
-
-    @visitor.when(nodes.IfThenElseNode)
-    def visit(self, node, scope, expected_type = None):  
-        # se espera que el tipo de la expresion if sea Bool
-        if_type = self.visit(node.if_expr, scope.children[0], self.context.get_type('Bool'))
-
-        then_type = self.visit(node.then_expr, scope.children[1])
-        else_type = self.visit(node.else_expr, scope.children[2])
-
-        return then_type.join(else_type)
-
-
-    @visitor.when(nodes.WhileNode)
-    def visit(self, node, scope, expected_type = None):
-
-        # la condicion del while debe ser de tipo Bool
-        self.visit(node.conditional_expr, scope, self.context.get_type('Bool'))
-
-        self.visit(node.loop_expr, scope.children[0])
-
-        return self.context.get_type('Object')
-
-
-    @visitor.when(nodes.BlockNode)
-    def visit(self, node, scope, expected_type = None):
-        type_expr = ErrorType()
-        for i, expr in enumerate(node.expr_list):
-            # el tipo de la expresion se inifiere a partir de expected_type
-            type_expr = self.visit(expr, scope.children[i]) if i != len(node.expr_list) - 1 else self.visit(expr, scope.children[i], expected_type)
-        
-        return type_expr
-
-
-    @visitor.when(nodes.LetNode)
-    def visit(self, node, scope, expected_type = None):
-        # se inifiere l tipo a partir de expected_type
-        body_type = self.visit(node.in_expr, scope.children[-1], expected_type)
-
-        child_scope_index = 0
-        for i, (idx, typex, id_expr) in enumerate(node.identifiers):
-            if id_expr:
-                var = scope.find_variable(idx)
-                id_expr_type = self.visit(id_expr, scope.children[child_scope_index], var.type if var.type.name != 'AUTO_TYPE' else None)
-                child_scope_index += 1
-
-                # se inifere el tipo de un identificador a partir de su expresion de inicializacion
-                if id_expr_type.name != 'AUTO_TYPE':
-                    var.expected_types.append(id_expr_type)
-
-        
-        for i, (idx, typex, id_expr) in enumerate(node.identifiers):
-            var = scope.find_variable(idx)
-            if var.type.name == 'AUTO_TYPE':
-                var.update_type()
-                if var.type.name == 'AUTO_TYPE':
-                    self.errors.append(INFERENCE_VARIABLE_ERROR % (var.name, self.current_method.name, self.current_type.name))
-                else:
-                    self.update = True
-                    node.identifiers[i] = (idx, var.type.name, id_expr)
-
-
-        return body_type
-
-
-    @visitor.when(nodes.CaseNode)
-    def visit(self, node, scope, expected_type = None):
-        case_type = None
-
-        for i, (idx, typex, expr) in enumerate(node.branches):
-            type_expr = self.visit(expr, scope.children[i])
-            
-            case_type = case_type.join(type_expr) if case_type else type_expr
-
-        return case_type
-
-
-    @visitor.when(nodes.NotNode)
-    def visit(self, node, scope, expected_type = None):
-        # se el tipo de la expresion de not se infiere que sea Bool
-        self.visit(node.expr, scope, self.context.get_type('Bool'))
-
-        return self.context.get_type('Bool')
-
-
-    @visitor.when(nodes.ConstantNumNode)
-    def visit(self, node, scope, expected_type = None):
-        return self.context.get_type('Int')
-
-
-    @visitor.when(nodes.ConstantBoolNode)
-    def visit(self, node, scope, expected_type = None):
-        return self.context.get_type('Bool')
-
-
-    @visitor.when(nodes.ConstantStringNode)
-    def visit(self, node, scope, expected_type = None):
-        return self.context.get_type('String')
-
-
-    @visitor.when(nodes.VariableNode)
-    def visit(self, node, scope, expected_type = None):
-        var = scope.find_variable(node.lex)
-        
-        if var is not None:
-            # el tipo esperado de var es expected_type
-            if expected_type and expected_type != 'AUTO_TYPE':
-                var.expected_types.append(expected_type)
-            return var.type
-
-        return ErrorType()
-
-
-    @visitor.when(nodes.InstantiateNode)
-    def visit(self, node, scope, expected_type = None):
-        if node.lex in self.context.types:
-            return self.context.get_type(node.lex)
-        
-        return ErrorType()
-
-
-    @visitor.when(nodes.IsVoidNode)
-    def visit(self, node, scope, expected_type = None):
-        self.visit(node.lex, scope)
-
-        return self.context.get_type('Bool')
-
-
-    @visitor.when(nodes.ComplementNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expression se espera que sea Int
-        self.visit(node.lex, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Int')
-
-
-    @visitor.when(nodes.PlusNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expresiones se espera que sea Int
-        self.visit(node.left, scope, self.context.get_type('Int'))
-        self.visit(node.right, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Int')
-
-
-    @visitor.when(nodes.MinusNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expresiones se espera que sea Int
-        self.visit(node.left, scope, self.context.get_type('Int'))
-        self.visit(node.right, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Int')
-
-
-    @visitor.when(nodes.StarNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expresiones se espera que sea Int
-        self.visit(node.left, scope, self.context.get_type('Int'))
-        self.visit(node.right, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Int')
-
-
-    @visitor.when(nodes.DivNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expresiones se espera que sea Int
-        self.visit(node.left, scope, self.context.get_type('Int'))
-        self.visit(node.right, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Int')
-
-
-    @visitor.when(nodes.LessThanNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expresiones se espera que sea Int
-        self.visit(node.left, scope, self.context.get_type('Int'))
-        self.visit(node.right, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Bool')
-
-
-    @visitor.when(nodes.LessEqualNode)
-    def visit(self, node, scope, expected_type = None):
-        # el tipo de la expresiones se espera que sea Int
-        self.visit(node.left, scope, self.context.get_type('Int'))
-        self.visit(node.right, scope, self.context.get_type('Int'))
-
-        return self.context.get_type('Bool')
-
-
-
-    @visitor.when(nodes.EqualNode)
-    def visit(self, node, scope, expected_type = None):
-        type_left = self.visit(node.left, scope)
-        # se infiere el tipo a la derecha del igual a partir del tipo izquierdo
-        type_right = self.visit(node.right, scope, type_left if type_left.name != 'AUTO_TYPE' else None)
-
-        if type_left.name == 'AUTO_TYPE':
-            # se inifiere el tipo a la izquierda del igual a partir de su tipo derecho
-            self.visit(node.left, scope, type_right if type_right.name != 'AUTO_TYPE' else None)
-
-        return self.context.get_type('Bool')
\ No newline at end of file

From 63922dd6fc0fd239d78fac242d02456ebc1de173 Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Tue, 15 Feb 2022 10:57:20 -0800
Subject: [PATCH 27/83] Update requirements.txt

---
 requirements.txt | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/requirements.txt b/requirements.txt
index da2d20840..9eb0cad1a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,2 @@
 pytest
-<<<<<<< HEAD
 pytest-ordering
-=======
-pytest-ordering
-ply~=3.11
->>>>>>> deac2a5cd44acaf60cc5f106ff68b289e987ff8c

From 3c6dc705511baa5421ef7511b6aa799339383b29 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 14:06:00 -0800
Subject: [PATCH 28/83] update lexer

---
 src/main.py             | 2 +-
 src/utils/COOL_Lexer.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main.py b/src/main.py
index ecf6ee5c4..8fa911acd 100644
--- a/src/main.py
+++ b/src/main.py
@@ -11,7 +11,7 @@
 from utils.semantic_check.type_checker import TypeChecker 
 
 if __name__ == "__main__":
-    add = "lexer/comment1.cl"
+    add = "lexer/string2.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 22aead8af..1aebf87b0 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -129,7 +129,7 @@ def tokenize(self,text):
                             break
                 
                 else:
-                    self.errors.append(f'({self.line}, {self.column + 1}) - LexicographicError: EOF in string constant')
+                    self.errors.append(f'({self.line}, {self.column}) - LexicographicError: EOF in string constant')
 
 
 

From 71ebe1ddfa5fa9214f1ab55c9921d51f9d22eaa2 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 14:44:14 -0800
Subject: [PATCH 29/83] modifing lexer

---
 src/main.py             | 2 +-
 src/utils/COOL_Lexer.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main.py b/src/main.py
index 8fa911acd..2d0b7ec94 100644
--- a/src/main.py
+++ b/src/main.py
@@ -11,7 +11,7 @@
 from utils.semantic_check.type_checker import TypeChecker 
 
 if __name__ == "__main__":
-    add = "lexer/string2.cl"
+    add = "parser/dispatch8.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 1aebf87b0..7da7753a7 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -156,7 +156,7 @@ def fixed_tokens(self, tokens):
     
 
 '''
-Esta clase guardara las propiedades sintacticas de COOL
+Esta clase guarda las propiedades sintacticas de COOL
 '''
 class COOL_Lexer(Lexer):
     def __init__(self):
@@ -164,7 +164,7 @@ def __init__(self):
         'id'        : r'[a-z][a-zA-Z0-9_]*'         ,
         'type'      : r'[A-Z][a-zA-Z0-9_]*'         ,
         'string'    : r'\"'                         ,
-        'int'       : r'\d'                         ,
+        'int'       : r'\d+'                         ,
         'comment'   : r'(\(\*)|--.*'                ,
         'newline'   : r'\n'                         ,
         'whitespace': r' +'                         ,

From f5c351e1c734266458b615bef0a0c52cfc662a2e Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 21:48:43 -0800
Subject: [PATCH 30/83] fixing grammar-parser

---
 src/main.py                     |    4 +-
 src/utils/COOL_Grammar.py       |    9 +-
 src/utils/COOL_Lexer.py         |    2 +-
 src/utils/parser/COOL_parser.py | 2054 ++++++++++++++++---------------
 src/utils/parser/parser.py      |    2 -
 5 files changed, 1050 insertions(+), 1021 deletions(-)

diff --git a/src/main.py b/src/main.py
index 2d0b7ec94..afbd22b00 100644
--- a/src/main.py
+++ b/src/main.py
@@ -11,7 +11,7 @@
 from utils.semantic_check.type_checker import TypeChecker 
 
 if __name__ == "__main__":
-    add = "parser/dispatch8.cl"
+    add = "parser/operation3.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -21,6 +21,7 @@
     with open(_in) as file:
         code = file.read()
 
+
     G = build_COOL_Grammar()
 
     # lexer
@@ -34,6 +35,7 @@
 
     # parser
     parser = COOL_Parser(G)
+        
     derivation, operations = parser(tokens)
     
     if parser.error:
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 2fe488dcb..3ce91bc26 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -11,7 +11,7 @@ def build_COOL_Grammar():
     feature_list, def_attr, def_meth, arg_list = G.NonTerminals('<feature-list> <def-attr> <def-meth> <arg-list>')
     expr, expr_list, id_list, case_list, comp = G.NonTerminals('<expr> <expr-list> <id-list> <case-list> <comp>')
     expr, arith, term, factor, atom, dispatch = G.NonTerminals('<expr> <arith> <term> <factor> <atom> <dispatch>')
-    not_empty = G.NonTerminal('<not_empty>')
+    boolean = G.NonTerminal('<boolean>')
 
     #terminales
     classx, let, inx = G.Terminals('class let in')
@@ -49,7 +49,7 @@ def build_COOL_Grammar():
     expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3],s[2])
     expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6],s[1])
     expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4],s[1])
-    expr %= notx + expr, lambda h,s: node.NotNode(s[2],s[1])
+    
 
     expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2],s[1])
 
@@ -68,7 +68,10 @@ def build_COOL_Grammar():
     case_list %= idx + colon + typex + darrow + expr + semi, lambda h,s: [(s[1],s[3],s[5])]
     case_list %= idx + colon + typex + darrow + expr + semi + case_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]
 
-    expr %= comp, lambda h,s: s[1]
+    expr %= boolean, lambda h,s: s[1]
+
+    boolean %= comp, lambda h,s: s[1]
+    boolean %= notx + comp, lambda h,s: node.NotNode(s[2], s[1])
 
     comp %= comp + less + arith, lambda h,s: node.LessThanNode(s[1],s[3],s[2])
     comp %= comp + lesse + arith, lambda h,s: node.LessEqualNode(s[1],s[3],s[2])
diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 7da7753a7..7f7f4e860 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -139,7 +139,7 @@ def tokenize(self,text):
  
             text = text[match.end():] if lexeme[:2] != '(*' and lexeme[0] != '"' else text
 
-        yield '$', self.eof, self.line, 1
+        yield '$', self.eof, 0, 0
  
     def _build_regex(sef,table):
         return re.compile('|'.join([f'(?P<{name}>{regex})' if name != regex else f'({name})' for name,regex in table.items()]))
diff --git a/src/utils/parser/COOL_parser.py b/src/utils/parser/COOL_parser.py
index 7966d556b..c764f13da 100644
--- a/src/utils/parser/COOL_parser.py
+++ b/src/utils/parser/COOL_parser.py
@@ -24,1161 +24,1178 @@ def __init__(self, G):
         (0, 'class') : ('SHIFT', 1),
         (1, 'type') : ('SHIFT', 2),
         (2, '{') : ('SHIFT', 3),
-        (2, 'inherits') : ('SHIFT', 131),
+        (2, 'inherits') : ('SHIFT', 132),
         (3, 'id') : ('SHIFT', 4),
         (3, '}') : ('REDUCE', 7),
         (4, ':') : ('SHIFT', 5),
-        (4, '(') : ('SHIFT', 109),
+        (4, '(') : ('SHIFT', 110),
         (5, 'type') : ('SHIFT', 6),
         (6, ';') : ('REDUCE', 8),
         (6, '<-') : ('SHIFT', 7),
+        (7, 'isvoid') : ('SHIFT', 27),
+        (7, '{') : ('SHIFT', 14),
+        (7, '(') : ('SHIFT', 13),
+        (7, 'let') : ('SHIFT', 8),
         (7, 'if') : ('SHIFT', 24),
-        (7, 'not') : ('SHIFT', 26),
+        (7, 'case') : ('SHIFT', 25),
         (7, 'id') : ('SHIFT', 18),
         (7, 'false') : ('SHIFT', 29),
         (7, 'int') : ('SHIFT', 21),
         (7, 'string') : ('SHIFT', 30),
-        (7, '(') : ('SHIFT', 13),
-        (7, 'true') : ('SHIFT', 28),
-        (7, 'let') : ('SHIFT', 8),
-        (7, 'isvoid') : ('SHIFT', 27),
+        (7, 'while') : ('SHIFT', 20),
         (7, '~') : ('SHIFT', 15),
-        (7, 'case') : ('SHIFT', 25),
-        (7, '{') : ('SHIFT', 14),
         (7, 'new') : ('SHIFT', 22),
-        (7, 'while') : ('SHIFT', 20),
+        (7, 'true') : ('SHIFT', 28),
+        (7, 'not') : ('SHIFT', 26),
         (8, 'id') : ('SHIFT', 9),
         (9, ':') : ('SHIFT', 10),
         (10, 'type') : ('SHIFT', 11),
+        (11, 'in') : ('REDUCE', 22),
         (11, '<-') : ('SHIFT', 12),
-        (11, 'in') : ('REDUCE', 23),
-        (11, ',') : ('SHIFT', 103),
-        (12, 'case') : ('SHIFT', 25),
-        (12, '{') : ('SHIFT', 14),
-        (12, '~') : ('SHIFT', 15),
-        (12, 'int') : ('SHIFT', 21),
-        (12, 'while') : ('SHIFT', 20),
-        (12, 'id') : ('SHIFT', 18),
+        (11, ',') : ('SHIFT', 104),
+        (12, 'isvoid') : ('SHIFT', 27),
         (12, '(') : ('SHIFT', 13),
-        (12, 'true') : ('SHIFT', 28),
-        (12, 'if') : ('SHIFT', 24),
         (12, 'not') : ('SHIFT', 26),
         (12, 'false') : ('SHIFT', 29),
-        (12, 'isvoid') : ('SHIFT', 27),
+        (12, 'id') : ('SHIFT', 18),
+        (12, 'int') : ('SHIFT', 21),
+        (12, '{') : ('SHIFT', 14),
         (12, 'string') : ('SHIFT', 30),
-        (12, 'new') : ('SHIFT', 22),
+        (12, 'if') : ('SHIFT', 24),
         (12, 'let') : ('SHIFT', 8),
+        (12, 'case') : ('SHIFT', 25),
+        (12, '~') : ('SHIFT', 15),
+        (12, 'new') : ('SHIFT', 22),
+        (12, 'true') : ('SHIFT', 28),
+        (12, 'while') : ('SHIFT', 20),
+        (13, 'while') : ('SHIFT', 20),
+        (13, '~') : ('SHIFT', 15),
+        (13, 'new') : ('SHIFT', 22),
         (13, 'true') : ('SHIFT', 28),
-        (13, 'id') : ('SHIFT', 18),
-        (13, 'false') : ('SHIFT', 29),
-        (13, 'let') : ('SHIFT', 8),
-        (13, 'int') : ('SHIFT', 21),
-        (13, 'string') : ('SHIFT', 30),
+        (13, 'not') : ('SHIFT', 26),
+        (13, 'isvoid') : ('SHIFT', 27),
         (13, '(') : ('SHIFT', 13),
-        (13, 'case') : ('SHIFT', 25),
         (13, '{') : ('SHIFT', 14),
-        (13, 'while') : ('SHIFT', 20),
-        (13, 'isvoid') : ('SHIFT', 27),
-        (13, '~') : ('SHIFT', 15),
+        (13, 'let') : ('SHIFT', 8),
         (13, 'if') : ('SHIFT', 24),
-        (13, 'not') : ('SHIFT', 26),
-        (13, 'new') : ('SHIFT', 22),
+        (13, 'id') : ('SHIFT', 18),
+        (13, 'case') : ('SHIFT', 25),
+        (13, 'false') : ('SHIFT', 29),
+        (13, 'string') : ('SHIFT', 30),
+        (13, 'int') : ('SHIFT', 21),
+        (14, 'isvoid') : ('SHIFT', 27),
+        (14, '{') : ('SHIFT', 14),
+        (14, '(') : ('SHIFT', 13),
+        (14, 'let') : ('SHIFT', 8),
         (14, 'if') : ('SHIFT', 24),
-        (14, 'not') : ('SHIFT', 26),
-        (14, 'false') : ('SHIFT', 29),
+        (14, 'case') : ('SHIFT', 25),
         (14, 'id') : ('SHIFT', 18),
+        (14, 'false') : ('SHIFT', 29),
         (14, 'int') : ('SHIFT', 21),
         (14, 'string') : ('SHIFT', 30),
-        (14, '(') : ('SHIFT', 13),
-        (14, 'true') : ('SHIFT', 28),
-        (14, 'let') : ('SHIFT', 8),
-        (14, 'isvoid') : ('SHIFT', 27),
+        (14, 'while') : ('SHIFT', 20),
         (14, '~') : ('SHIFT', 15),
-        (14, 'case') : ('SHIFT', 25),
-        (14, '{') : ('SHIFT', 14),
         (14, 'new') : ('SHIFT', 22),
-        (14, 'while') : ('SHIFT', 20),
-        (15, 'id') : ('SHIFT', 16),
+        (14, 'true') : ('SHIFT', 28),
+        (14, 'not') : ('SHIFT', 26),
         (15, 'false') : ('SHIFT', 29),
-        (15, 'string') : ('SHIFT', 30),
-        (15, 'true') : ('SHIFT', 28),
+        (15, 'id') : ('SHIFT', 16),
+        (15, 'new') : ('SHIFT', 22),
         (15, 'int') : ('SHIFT', 21),
+        (15, 'string') : ('SHIFT', 30),
         (15, 'isvoid') : ('SHIFT', 27),
+        (15, 'true') : ('SHIFT', 28),
         (15, '~') : ('SHIFT', 15),
         (15, '(') : ('SHIFT', 13),
-        (15, 'new') : ('SHIFT', 22),
-        (16, 'then') : ('REDUCE', 48),
-        (16, 'else') : ('REDUCE', 48),
-        (16, 'fi') : ('REDUCE', 48),
-        (16, 'of') : ('REDUCE', 48),
-        (16, 'in') : ('REDUCE', 48),
-        (16, ';') : ('REDUCE', 48),
-        (16, ',') : ('REDUCE', 48),
-        (16, '.') : ('REDUCE', 48),
-        (16, ')') : ('REDUCE', 48),
-        (16, '}') : ('REDUCE', 48),
-        (16, '=') : ('REDUCE', 48),
-        (16, '+') : ('REDUCE', 48),
-        (16, '-') : ('REDUCE', 48),
-        (16, '*') : ('REDUCE', 48),
-        (16, '/') : ('REDUCE', 48),
-        (16, '<') : ('REDUCE', 48),
-        (16, '<=') : ('REDUCE', 48),
-        (16, '@') : ('REDUCE', 48),
-        (16, 'loop') : ('REDUCE', 48),
-        (16, 'pool') : ('REDUCE', 48),
+        (16, 'fi') : ('REDUCE', 49),
+        (16, '=') : ('REDUCE', 49),
+        (16, '+') : ('REDUCE', 49),
+        (16, '-') : ('REDUCE', 49),
+        (16, 'of') : ('REDUCE', 49),
+        (16, '*') : ('REDUCE', 49),
+        (16, '/') : ('REDUCE', 49),
+        (16, '<') : ('REDUCE', 49),
+        (16, '<=') : ('REDUCE', 49),
+        (16, '@') : ('REDUCE', 49),
+        (16, 'in') : ('REDUCE', 49),
+        (16, ';') : ('REDUCE', 49),
+        (16, 'loop') : ('REDUCE', 49),
+        (16, 'pool') : ('REDUCE', 49),
+        (16, ',') : ('REDUCE', 49),
+        (16, '.') : ('REDUCE', 49),
+        (16, ')') : ('REDUCE', 49),
+        (16, 'then') : ('REDUCE', 49),
+        (16, 'else') : ('REDUCE', 49),
+        (16, '}') : ('REDUCE', 49),
         (16, '(') : ('SHIFT', 17),
-        (17, 'while') : ('SHIFT', 20),
+        (17, ')') : ('REDUCE', 58),
+        (17, '~') : ('SHIFT', 15),
         (17, 'id') : ('SHIFT', 18),
         (17, 'new') : ('SHIFT', 22),
-        (17, '~') : ('SHIFT', 15),
-        (17, 'case') : ('SHIFT', 25),
-        (17, 'if') : ('SHIFT', 24),
-        (17, 'not') : ('SHIFT', 26),
+        (17, '{') : ('SHIFT', 14),
         (17, 'true') : ('SHIFT', 28),
-        (17, 'false') : ('SHIFT', 29),
-        (17, 'int') : ('SHIFT', 21),
+        (17, 'let') : ('SHIFT', 8),
+        (17, 'if') : ('SHIFT', 24),
+        (17, 'case') : ('SHIFT', 25),
         (17, 'string') : ('SHIFT', 30),
         (17, 'isvoid') : ('SHIFT', 27),
+        (17, 'while') : ('SHIFT', 20),
         (17, '(') : ('SHIFT', 13),
-        (17, ')') : ('REDUCE', 57),
-        (17, 'let') : ('SHIFT', 8),
-        (17, '{') : ('SHIFT', 14),
-        (18, '(') : ('SHIFT', 17),
-        (18, 'then') : ('REDUCE', 48),
-        (18, 'else') : ('REDUCE', 48),
-        (18, 'fi') : ('REDUCE', 48),
-        (18, 'of') : ('REDUCE', 48),
-        (18, 'in') : ('REDUCE', 48),
-        (18, ';') : ('REDUCE', 48),
-        (18, ',') : ('REDUCE', 48),
-        (18, '.') : ('REDUCE', 48),
-        (18, ')') : ('REDUCE', 48),
-        (18, '}') : ('REDUCE', 48),
-        (18, '=') : ('REDUCE', 48),
-        (18, '+') : ('REDUCE', 48),
-        (18, '-') : ('REDUCE', 48),
-        (18, '*') : ('REDUCE', 48),
-        (18, '/') : ('REDUCE', 48),
-        (18, '<') : ('REDUCE', 48),
-        (18, '<=') : ('REDUCE', 48),
-        (18, '@') : ('REDUCE', 48),
-        (18, 'loop') : ('REDUCE', 48),
-        (18, 'pool') : ('REDUCE', 48),
+        (17, 'false') : ('SHIFT', 29),
+        (17, 'int') : ('SHIFT', 21),
+        (17, 'not') : ('SHIFT', 26),
         (18, '<-') : ('SHIFT', 19),
-        (19, 'id') : ('SHIFT', 18),
+        (18, 'fi') : ('REDUCE', 49),
+        (18, '=') : ('REDUCE', 49),
+        (18, '+') : ('REDUCE', 49),
+        (18, '-') : ('REDUCE', 49),
+        (18, 'of') : ('REDUCE', 49),
+        (18, '*') : ('REDUCE', 49),
+        (18, '/') : ('REDUCE', 49),
+        (18, '<') : ('REDUCE', 49),
+        (18, '<=') : ('REDUCE', 49),
+        (18, '@') : ('REDUCE', 49),
+        (18, 'in') : ('REDUCE', 49),
+        (18, ';') : ('REDUCE', 49),
+        (18, 'loop') : ('REDUCE', 49),
+        (18, 'pool') : ('REDUCE', 49),
+        (18, ',') : ('REDUCE', 49),
+        (18, '.') : ('REDUCE', 49),
+        (18, ')') : ('REDUCE', 49),
+        (18, 'then') : ('REDUCE', 49),
+        (18, 'else') : ('REDUCE', 49),
+        (18, '}') : ('REDUCE', 49),
+        (18, '(') : ('SHIFT', 17),
         (19, 'false') : ('SHIFT', 29),
-        (19, 'let') : ('SHIFT', 8),
+        (19, '{') : ('SHIFT', 14),
+        (19, 'id') : ('SHIFT', 18),
         (19, 'string') : ('SHIFT', 30),
+        (19, 'int') : ('SHIFT', 21),
         (19, 'isvoid') : ('SHIFT', 27),
+        (19, 'let') : ('SHIFT', 8),
+        (19, 'if') : ('SHIFT', 24),
         (19, 'case') : ('SHIFT', 25),
-        (19, '~') : ('SHIFT', 15),
-        (19, '{') : ('SHIFT', 14),
         (19, 'new') : ('SHIFT', 22),
+        (19, 'true') : ('SHIFT', 28),
         (19, 'while') : ('SHIFT', 20),
-        (19, 'if') : ('SHIFT', 24),
-        (19, 'not') : ('SHIFT', 26),
-        (19, 'int') : ('SHIFT', 21),
+        (19, '~') : ('SHIFT', 15),
         (19, '(') : ('SHIFT', 13),
-        (19, 'true') : ('SHIFT', 28),
-        (20, 'id') : ('SHIFT', 18),
-        (20, 'true') : ('SHIFT', 28),
-        (20, 'false') : ('SHIFT', 29),
+        (19, 'not') : ('SHIFT', 26),
+        (20, 'isvoid') : ('SHIFT', 27),
         (20, 'if') : ('SHIFT', 24),
-        (20, 'not') : ('SHIFT', 26),
         (20, 'let') : ('SHIFT', 8),
+        (20, 'case') : ('SHIFT', 25),
+        (20, 'id') : ('SHIFT', 18),
+        (20, 'false') : ('SHIFT', 29),
         (20, 'string') : ('SHIFT', 30),
+        (20, 'int') : ('SHIFT', 21),
+        (20, 'while') : ('SHIFT', 20),
         (20, 'new') : ('SHIFT', 22),
-        (20, '{') : ('SHIFT', 14),
-        (20, 'isvoid') : ('SHIFT', 27),
+        (20, 'true') : ('SHIFT', 28),
         (20, '~') : ('SHIFT', 15),
-        (20, 'case') : ('SHIFT', 25),
-        (20, 'int') : ('SHIFT', 21),
+        (20, 'not') : ('SHIFT', 26),
         (20, '(') : ('SHIFT', 13),
-        (20, 'while') : ('SHIFT', 20),
-        (21, 'then') : ('REDUCE', 47),
-        (21, 'else') : ('REDUCE', 47),
-        (21, 'fi') : ('REDUCE', 47),
-        (21, 'of') : ('REDUCE', 47),
-        (21, 'in') : ('REDUCE', 47),
-        (21, ';') : ('REDUCE', 47),
-        (21, ',') : ('REDUCE', 47),
-        (21, '.') : ('REDUCE', 47),
-        (21, ')') : ('REDUCE', 47),
-        (21, '}') : ('REDUCE', 47),
-        (21, '=') : ('REDUCE', 47),
-        (21, '+') : ('REDUCE', 47),
-        (21, '-') : ('REDUCE', 47),
-        (21, '*') : ('REDUCE', 47),
-        (21, '/') : ('REDUCE', 47),
-        (21, '<') : ('REDUCE', 47),
-        (21, '<=') : ('REDUCE', 47),
-        (21, '@') : ('REDUCE', 47),
-        (21, 'loop') : ('REDUCE', 47),
-        (21, 'pool') : ('REDUCE', 47),
+        (20, '{') : ('SHIFT', 14),
+        (21, 'fi') : ('REDUCE', 48),
+        (21, '=') : ('REDUCE', 48),
+        (21, '+') : ('REDUCE', 48),
+        (21, '-') : ('REDUCE', 48),
+        (21, 'of') : ('REDUCE', 48),
+        (21, '*') : ('REDUCE', 48),
+        (21, '/') : ('REDUCE', 48),
+        (21, '<') : ('REDUCE', 48),
+        (21, '<=') : ('REDUCE', 48),
+        (21, '@') : ('REDUCE', 48),
+        (21, 'in') : ('REDUCE', 48),
+        (21, ';') : ('REDUCE', 48),
+        (21, 'loop') : ('REDUCE', 48),
+        (21, 'pool') : ('REDUCE', 48),
+        (21, ',') : ('REDUCE', 48),
+        (21, '.') : ('REDUCE', 48),
+        (21, ')') : ('REDUCE', 48),
+        (21, 'then') : ('REDUCE', 48),
+        (21, 'else') : ('REDUCE', 48),
+        (21, '}') : ('REDUCE', 48),
         (22, 'type') : ('SHIFT', 23),
-        (23, 'then') : ('REDUCE', 49),
-        (23, 'else') : ('REDUCE', 49),
-        (23, 'fi') : ('REDUCE', 49),
-        (23, 'of') : ('REDUCE', 49),
-        (23, 'in') : ('REDUCE', 49),
-        (23, ';') : ('REDUCE', 49),
-        (23, ',') : ('REDUCE', 49),
-        (23, '.') : ('REDUCE', 49),
-        (23, ')') : ('REDUCE', 49),
-        (23, '}') : ('REDUCE', 49),
-        (23, '=') : ('REDUCE', 49),
-        (23, '+') : ('REDUCE', 49),
-        (23, '-') : ('REDUCE', 49),
-        (23, '*') : ('REDUCE', 49),
-        (23, '/') : ('REDUCE', 49),
-        (23, '<') : ('REDUCE', 49),
-        (23, '<=') : ('REDUCE', 49),
-        (23, '@') : ('REDUCE', 49),
-        (23, 'loop') : ('REDUCE', 49),
-        (23, 'pool') : ('REDUCE', 49),
+        (23, 'fi') : ('REDUCE', 50),
+        (23, '=') : ('REDUCE', 50),
+        (23, '+') : ('REDUCE', 50),
+        (23, '-') : ('REDUCE', 50),
+        (23, 'of') : ('REDUCE', 50),
+        (23, '*') : ('REDUCE', 50),
+        (23, '/') : ('REDUCE', 50),
+        (23, '<') : ('REDUCE', 50),
+        (23, '<=') : ('REDUCE', 50),
+        (23, '@') : ('REDUCE', 50),
+        (23, 'in') : ('REDUCE', 50),
+        (23, ';') : ('REDUCE', 50),
+        (23, 'loop') : ('REDUCE', 50),
+        (23, 'pool') : ('REDUCE', 50),
+        (23, ',') : ('REDUCE', 50),
+        (23, '.') : ('REDUCE', 50),
+        (23, ')') : ('REDUCE', 50),
+        (23, 'then') : ('REDUCE', 50),
+        (23, 'else') : ('REDUCE', 50),
+        (23, '}') : ('REDUCE', 50),
+        (24, 'isvoid') : ('SHIFT', 27),
+        (24, '(') : ('SHIFT', 13),
         (24, 'not') : ('SHIFT', 26),
-        (24, 'true') : ('SHIFT', 28),
+        (24, '{') : ('SHIFT', 14),
+        (24, 'false') : ('SHIFT', 29),
+        (24, 'id') : ('SHIFT', 18),
+        (24, 'int') : ('SHIFT', 21),
         (24, 'string') : ('SHIFT', 30),
+        (24, 'if') : ('SHIFT', 24),
         (24, 'let') : ('SHIFT', 8),
-        (24, 'id') : ('SHIFT', 18),
+        (24, 'case') : ('SHIFT', 25),
         (24, 'new') : ('SHIFT', 22),
-        (24, 'isvoid') : ('SHIFT', 27),
+        (24, 'true') : ('SHIFT', 28),
         (24, '~') : ('SHIFT', 15),
-        (24, 'case') : ('SHIFT', 25),
-        (24, '{') : ('SHIFT', 14),
         (24, 'while') : ('SHIFT', 20),
-        (24, 'false') : ('SHIFT', 29),
-        (24, 'int') : ('SHIFT', 21),
-        (24, '(') : ('SHIFT', 13),
-        (24, 'if') : ('SHIFT', 24),
-        (25, 'while') : ('SHIFT', 20),
+        (25, 'not') : ('SHIFT', 26),
         (25, 'true') : ('SHIFT', 28),
-        (25, 'false') : ('SHIFT', 29),
-        (25, 'id') : ('SHIFT', 18),
-        (25, 'int') : ('SHIFT', 21),
-        (25, 'let') : ('SHIFT', 8),
-        (25, 'string') : ('SHIFT', 30),
-        (25, 'isvoid') : ('SHIFT', 27),
-        (25, '~') : ('SHIFT', 15),
-        (25, 'new') : ('SHIFT', 22),
         (25, '{') : ('SHIFT', 14),
-        (25, 'case') : ('SHIFT', 25),
+        (25, '~') : ('SHIFT', 15),
+        (25, 'let') : ('SHIFT', 8),
         (25, 'if') : ('SHIFT', 24),
-        (25, 'not') : ('SHIFT', 26),
+        (25, 'case') : ('SHIFT', 25),
+        (25, 'id') : ('SHIFT', 18),
         (25, '(') : ('SHIFT', 13),
-        (26, 'id') : ('SHIFT', 18),
+        (25, 'new') : ('SHIFT', 22),
+        (25, 'while') : ('SHIFT', 20),
+        (25, 'isvoid') : ('SHIFT', 27),
+        (25, 'false') : ('SHIFT', 29),
+        (25, 'int') : ('SHIFT', 21),
+        (25, 'string') : ('SHIFT', 30),
         (26, 'false') : ('SHIFT', 29),
-        (26, 'let') : ('SHIFT', 8),
+        (26, 'id') : ('SHIFT', 16),
+        (26, 'int') : ('SHIFT', 21),
         (26, 'string') : ('SHIFT', 30),
         (26, 'isvoid') : ('SHIFT', 27),
         (26, '~') : ('SHIFT', 15),
-        (26, 'case') : ('SHIFT', 25),
-        (26, '{') : ('SHIFT', 14),
-        (26, 'new') : ('SHIFT', 22),
-        (26, 'while') : ('SHIFT', 20),
-        (26, 'if') : ('SHIFT', 24),
-        (26, 'not') : ('SHIFT', 26),
-        (26, 'int') : ('SHIFT', 21),
         (26, '(') : ('SHIFT', 13),
+        (26, 'new') : ('SHIFT', 22),
         (26, 'true') : ('SHIFT', 28),
-        (27, 'id') : ('SHIFT', 16),
         (27, 'false') : ('SHIFT', 29),
-        (27, 'string') : ('SHIFT', 30),
-        (27, 'true') : ('SHIFT', 28),
+        (27, 'id') : ('SHIFT', 16),
+        (27, 'new') : ('SHIFT', 22),
         (27, 'int') : ('SHIFT', 21),
+        (27, 'string') : ('SHIFT', 30),
         (27, 'isvoid') : ('SHIFT', 27),
+        (27, 'true') : ('SHIFT', 28),
         (27, '~') : ('SHIFT', 15),
         (27, '(') : ('SHIFT', 13),
-        (27, 'new') : ('SHIFT', 22),
-        (28, 'then') : ('REDUCE', 44),
-        (28, 'else') : ('REDUCE', 44),
-        (28, 'fi') : ('REDUCE', 44),
-        (28, 'of') : ('REDUCE', 44),
-        (28, 'in') : ('REDUCE', 44),
-        (28, ';') : ('REDUCE', 44),
-        (28, ',') : ('REDUCE', 44),
-        (28, '.') : ('REDUCE', 44),
-        (28, ')') : ('REDUCE', 44),
-        (28, '}') : ('REDUCE', 44),
-        (28, '=') : ('REDUCE', 44),
-        (28, '+') : ('REDUCE', 44),
-        (28, '-') : ('REDUCE', 44),
-        (28, '*') : ('REDUCE', 44),
-        (28, '/') : ('REDUCE', 44),
-        (28, '<') : ('REDUCE', 44),
-        (28, '<=') : ('REDUCE', 44),
-        (28, '@') : ('REDUCE', 44),
-        (28, 'loop') : ('REDUCE', 44),
-        (28, 'pool') : ('REDUCE', 44),
-        (29, 'then') : ('REDUCE', 45),
-        (29, 'else') : ('REDUCE', 45),
-        (29, 'fi') : ('REDUCE', 45),
-        (29, 'of') : ('REDUCE', 45),
-        (29, 'in') : ('REDUCE', 45),
-        (29, ';') : ('REDUCE', 45),
-        (29, ',') : ('REDUCE', 45),
-        (29, '.') : ('REDUCE', 45),
-        (29, ')') : ('REDUCE', 45),
-        (29, '}') : ('REDUCE', 45),
-        (29, '=') : ('REDUCE', 45),
-        (29, '+') : ('REDUCE', 45),
-        (29, '-') : ('REDUCE', 45),
-        (29, '*') : ('REDUCE', 45),
-        (29, '/') : ('REDUCE', 45),
-        (29, '<') : ('REDUCE', 45),
-        (29, '<=') : ('REDUCE', 45),
-        (29, '@') : ('REDUCE', 45),
-        (29, 'loop') : ('REDUCE', 45),
-        (29, 'pool') : ('REDUCE', 45),
-        (30, 'then') : ('REDUCE', 46),
-        (30, 'else') : ('REDUCE', 46),
-        (30, 'fi') : ('REDUCE', 46),
-        (30, 'of') : ('REDUCE', 46),
-        (30, 'in') : ('REDUCE', 46),
-        (30, ';') : ('REDUCE', 46),
-        (30, ',') : ('REDUCE', 46),
-        (30, '.') : ('REDUCE', 46),
-        (30, ')') : ('REDUCE', 46),
-        (30, '}') : ('REDUCE', 46),
-        (30, '=') : ('REDUCE', 46),
-        (30, '+') : ('REDUCE', 46),
-        (30, '-') : ('REDUCE', 46),
-        (30, '*') : ('REDUCE', 46),
-        (30, '/') : ('REDUCE', 46),
-        (30, '<') : ('REDUCE', 46),
-        (30, '<=') : ('REDUCE', 46),
-        (30, '@') : ('REDUCE', 46),
-        (30, 'loop') : ('REDUCE', 46),
-        (30, 'pool') : ('REDUCE', 46),
-        (31, '<') : ('REDUCE', 41),
-        (31, '<=') : ('REDUCE', 41),
-        (31, ')') : ('REDUCE', 41),
-        (31, 'then') : ('REDUCE', 41),
-        (31, '}') : ('REDUCE', 41),
-        (31, 'else') : ('REDUCE', 41),
-        (31, 'fi') : ('REDUCE', 41),
-        (31, '=') : ('REDUCE', 41),
-        (31, 'in') : ('REDUCE', 41),
-        (31, ';') : ('REDUCE', 41),
-        (31, '+') : ('REDUCE', 41),
-        (31, '-') : ('REDUCE', 41),
-        (31, 'loop') : ('REDUCE', 41),
-        (31, 'of') : ('REDUCE', 41),
-        (31, '*') : ('REDUCE', 41),
-        (31, 'pool') : ('REDUCE', 41),
-        (31, ',') : ('REDUCE', 41),
-        (31, '/') : ('REDUCE', 41),
-        (32, '@') : ('SHIFT', 60),
-        (32, '<') : ('REDUCE', 43),
-        (32, '<=') : ('REDUCE', 43),
-        (32, ')') : ('REDUCE', 43),
-        (32, 'then') : ('REDUCE', 43),
-        (32, '}') : ('REDUCE', 43),
-        (32, 'else') : ('REDUCE', 43),
-        (32, 'fi') : ('REDUCE', 43),
-        (32, '=') : ('REDUCE', 43),
-        (32, 'in') : ('REDUCE', 43),
-        (32, ';') : ('REDUCE', 43),
-        (32, '+') : ('REDUCE', 43),
-        (32, '-') : ('REDUCE', 43),
-        (32, 'loop') : ('REDUCE', 43),
-        (32, 'of') : ('REDUCE', 43),
-        (32, '*') : ('REDUCE', 43),
-        (32, 'pool') : ('REDUCE', 43),
-        (32, ',') : ('REDUCE', 43),
-        (32, '/') : ('REDUCE', 43),
+        (28, 'fi') : ('REDUCE', 45),
+        (28, '=') : ('REDUCE', 45),
+        (28, '+') : ('REDUCE', 45),
+        (28, '-') : ('REDUCE', 45),
+        (28, 'of') : ('REDUCE', 45),
+        (28, '*') : ('REDUCE', 45),
+        (28, '/') : ('REDUCE', 45),
+        (28, '<') : ('REDUCE', 45),
+        (28, '<=') : ('REDUCE', 45),
+        (28, '@') : ('REDUCE', 45),
+        (28, 'in') : ('REDUCE', 45),
+        (28, ';') : ('REDUCE', 45),
+        (28, 'loop') : ('REDUCE', 45),
+        (28, 'pool') : ('REDUCE', 45),
+        (28, ',') : ('REDUCE', 45),
+        (28, '.') : ('REDUCE', 45),
+        (28, ')') : ('REDUCE', 45),
+        (28, 'then') : ('REDUCE', 45),
+        (28, 'else') : ('REDUCE', 45),
+        (28, '}') : ('REDUCE', 45),
+        (29, 'fi') : ('REDUCE', 46),
+        (29, '=') : ('REDUCE', 46),
+        (29, '+') : ('REDUCE', 46),
+        (29, '-') : ('REDUCE', 46),
+        (29, 'of') : ('REDUCE', 46),
+        (29, '*') : ('REDUCE', 46),
+        (29, '/') : ('REDUCE', 46),
+        (29, '<') : ('REDUCE', 46),
+        (29, '<=') : ('REDUCE', 46),
+        (29, '@') : ('REDUCE', 46),
+        (29, 'in') : ('REDUCE', 46),
+        (29, ';') : ('REDUCE', 46),
+        (29, 'loop') : ('REDUCE', 46),
+        (29, 'pool') : ('REDUCE', 46),
+        (29, ',') : ('REDUCE', 46),
+        (29, '.') : ('REDUCE', 46),
+        (29, ')') : ('REDUCE', 46),
+        (29, 'then') : ('REDUCE', 46),
+        (29, 'else') : ('REDUCE', 46),
+        (29, '}') : ('REDUCE', 46),
+        (30, 'fi') : ('REDUCE', 47),
+        (30, '=') : ('REDUCE', 47),
+        (30, '+') : ('REDUCE', 47),
+        (30, '-') : ('REDUCE', 47),
+        (30, 'of') : ('REDUCE', 47),
+        (30, '*') : ('REDUCE', 47),
+        (30, '/') : ('REDUCE', 47),
+        (30, '<') : ('REDUCE', 47),
+        (30, '<=') : ('REDUCE', 47),
+        (30, '@') : ('REDUCE', 47),
+        (30, 'in') : ('REDUCE', 47),
+        (30, ';') : ('REDUCE', 47),
+        (30, 'loop') : ('REDUCE', 47),
+        (30, 'pool') : ('REDUCE', 47),
+        (30, ',') : ('REDUCE', 47),
+        (30, '.') : ('REDUCE', 47),
+        (30, ')') : ('REDUCE', 47),
+        (30, 'then') : ('REDUCE', 47),
+        (30, 'else') : ('REDUCE', 47),
+        (30, '}') : ('REDUCE', 47),
+        (31, '/') : ('REDUCE', 42),
+        (31, '}') : ('REDUCE', 42),
+        (31, 'fi') : ('REDUCE', 42),
+        (31, 'in') : ('REDUCE', 42),
+        (31, '<') : ('REDUCE', 42),
+        (31, '=') : ('REDUCE', 42),
+        (31, ';') : ('REDUCE', 42),
+        (31, '<=') : ('REDUCE', 42),
+        (31, '+') : ('REDUCE', 42),
+        (31, 'else') : ('REDUCE', 42),
+        (31, ')') : ('REDUCE', 42),
+        (31, '-') : ('REDUCE', 42),
+        (31, 'then') : ('REDUCE', 42),
+        (31, 'of') : ('REDUCE', 42),
+        (31, 'loop') : ('REDUCE', 42),
+        (31, '*') : ('REDUCE', 42),
+        (31, 'pool') : ('REDUCE', 42),
+        (31, ',') : ('REDUCE', 42),
+        (32, '@') : ('SHIFT', 61),
         (32, '.') : ('SHIFT', 33),
+        (32, '/') : ('REDUCE', 44),
+        (32, '}') : ('REDUCE', 44),
+        (32, 'fi') : ('REDUCE', 44),
+        (32, 'in') : ('REDUCE', 44),
+        (32, '<') : ('REDUCE', 44),
+        (32, '=') : ('REDUCE', 44),
+        (32, ';') : ('REDUCE', 44),
+        (32, '<=') : ('REDUCE', 44),
+        (32, '+') : ('REDUCE', 44),
+        (32, 'else') : ('REDUCE', 44),
+        (32, ')') : ('REDUCE', 44),
+        (32, '-') : ('REDUCE', 44),
+        (32, 'then') : ('REDUCE', 44),
+        (32, 'of') : ('REDUCE', 44),
+        (32, 'loop') : ('REDUCE', 44),
+        (32, '*') : ('REDUCE', 44),
+        (32, 'pool') : ('REDUCE', 44),
+        (32, ',') : ('REDUCE', 44),
         (33, 'id') : ('SHIFT', 34),
         (34, '(') : ('SHIFT', 35),
-        (35, 'while') : ('SHIFT', 20),
+        (35, ')') : ('REDUCE', 58),
+        (35, '~') : ('SHIFT', 15),
         (35, 'id') : ('SHIFT', 18),
         (35, 'new') : ('SHIFT', 22),
-        (35, '~') : ('SHIFT', 15),
-        (35, 'case') : ('SHIFT', 25),
-        (35, 'if') : ('SHIFT', 24),
-        (35, 'not') : ('SHIFT', 26),
+        (35, '{') : ('SHIFT', 14),
         (35, 'true') : ('SHIFT', 28),
-        (35, 'false') : ('SHIFT', 29),
-        (35, 'int') : ('SHIFT', 21),
+        (35, 'let') : ('SHIFT', 8),
+        (35, 'if') : ('SHIFT', 24),
+        (35, 'case') : ('SHIFT', 25),
         (35, 'string') : ('SHIFT', 30),
         (35, 'isvoid') : ('SHIFT', 27),
+        (35, 'while') : ('SHIFT', 20),
         (35, '(') : ('SHIFT', 13),
-        (35, ')') : ('REDUCE', 57),
-        (35, 'let') : ('SHIFT', 8),
-        (35, '{') : ('SHIFT', 14),
+        (35, 'false') : ('SHIFT', 29),
+        (35, 'int') : ('SHIFT', 21),
+        (35, 'not') : ('SHIFT', 26),
         (36, ')') : ('SHIFT', 37),
-        (37, 'then') : ('REDUCE', 52),
-        (37, 'else') : ('REDUCE', 52),
-        (37, 'fi') : ('REDUCE', 52),
-        (37, 'of') : ('REDUCE', 52),
-        (37, 'in') : ('REDUCE', 52),
-        (37, ';') : ('REDUCE', 52),
-        (37, ',') : ('REDUCE', 52),
-        (37, '.') : ('REDUCE', 52),
-        (37, ')') : ('REDUCE', 52),
-        (37, '}') : ('REDUCE', 52),
-        (37, '=') : ('REDUCE', 52),
-        (37, '+') : ('REDUCE', 52),
-        (37, '-') : ('REDUCE', 52),
-        (37, '*') : ('REDUCE', 52),
-        (37, '/') : ('REDUCE', 52),
-        (37, '<') : ('REDUCE', 52),
-        (37, '<=') : ('REDUCE', 52),
-        (37, '@') : ('REDUCE', 52),
-        (37, 'loop') : ('REDUCE', 52),
-        (37, 'pool') : ('REDUCE', 52),
-        (38, '<=') : ('SHIFT', 54),
-        (38, '<') : ('SHIFT', 52),
-        (38, ')') : ('REDUCE', 30),
-        (38, 'then') : ('REDUCE', 30),
-        (38, '}') : ('REDUCE', 30),
-        (38, 'else') : ('REDUCE', 30),
+        (37, 'fi') : ('REDUCE', 53),
+        (37, '=') : ('REDUCE', 53),
+        (37, '+') : ('REDUCE', 53),
+        (37, '-') : ('REDUCE', 53),
+        (37, 'of') : ('REDUCE', 53),
+        (37, '*') : ('REDUCE', 53),
+        (37, '/') : ('REDUCE', 53),
+        (37, '<') : ('REDUCE', 53),
+        (37, '<=') : ('REDUCE', 53),
+        (37, '@') : ('REDUCE', 53),
+        (37, 'in') : ('REDUCE', 53),
+        (37, ';') : ('REDUCE', 53),
+        (37, 'loop') : ('REDUCE', 53),
+        (37, 'pool') : ('REDUCE', 53),
+        (37, ',') : ('REDUCE', 53),
+        (37, '.') : ('REDUCE', 53),
+        (37, ')') : ('REDUCE', 53),
+        (37, 'then') : ('REDUCE', 53),
+        (37, 'else') : ('REDUCE', 53),
+        (37, '}') : ('REDUCE', 53),
+        (38, 'pool') : ('REDUCE', 30),
         (38, 'fi') : ('REDUCE', 30),
         (38, 'in') : ('REDUCE', 30),
         (38, ';') : ('REDUCE', 30),
-        (38, 'loop') : ('REDUCE', 30),
+        (38, ')') : ('REDUCE', 30),
+        (38, 'then') : ('REDUCE', 30),
         (38, 'of') : ('REDUCE', 30),
-        (38, 'pool') : ('REDUCE', 30),
+        (38, 'loop') : ('REDUCE', 30),
+        (38, 'else') : ('REDUCE', 30),
+        (38, '}') : ('REDUCE', 30),
         (38, ',') : ('REDUCE', 30),
+        (38, '<=') : ('SHIFT', 54),
+        (38, '<') : ('SHIFT', 52),
         (38, '=') : ('SHIFT', 39),
         (39, 'false') : ('SHIFT', 29),
         (39, 'id') : ('SHIFT', 16),
         (39, 'string') : ('SHIFT', 30),
+        (39, 'int') : ('SHIFT', 21),
         (39, 'isvoid') : ('SHIFT', 27),
         (39, '~') : ('SHIFT', 15),
-        (39, 'int') : ('SHIFT', 21),
         (39, '(') : ('SHIFT', 13),
         (39, 'new') : ('SHIFT', 22),
         (39, 'true') : ('SHIFT', 28),
-        (40, '+') : ('SHIFT', 41),
-        (40, '<') : ('REDUCE', 33),
-        (40, '<=') : ('REDUCE', 33),
-        (40, ')') : ('REDUCE', 33),
-        (40, 'then') : ('REDUCE', 33),
-        (40, '}') : ('REDUCE', 33),
-        (40, 'else') : ('REDUCE', 33),
-        (40, 'fi') : ('REDUCE', 33),
-        (40, '=') : ('REDUCE', 33),
-        (40, 'in') : ('REDUCE', 33),
-        (40, ';') : ('REDUCE', 33),
-        (40, 'loop') : ('REDUCE', 33),
-        (40, 'of') : ('REDUCE', 33),
-        (40, 'pool') : ('REDUCE', 33),
-        (40, ',') : ('REDUCE', 33),
+        (40, '}') : ('REDUCE', 34),
+        (40, 'fi') : ('REDUCE', 34),
+        (40, 'in') : ('REDUCE', 34),
+        (40, '<') : ('REDUCE', 34),
+        (40, '=') : ('REDUCE', 34),
+        (40, ';') : ('REDUCE', 34),
+        (40, '<=') : ('REDUCE', 34),
+        (40, ')') : ('REDUCE', 34),
+        (40, 'then') : ('REDUCE', 34),
+        (40, 'loop') : ('REDUCE', 34),
+        (40, 'of') : ('REDUCE', 34),
+        (40, 'else') : ('REDUCE', 34),
+        (40, 'pool') : ('REDUCE', 34),
+        (40, ',') : ('REDUCE', 34),
         (40, '-') : ('SHIFT', 49),
-        (41, 'id') : ('SHIFT', 16),
+        (40, '+') : ('SHIFT', 41),
         (41, 'false') : ('SHIFT', 29),
-        (41, 'string') : ('SHIFT', 30),
+        (41, 'id') : ('SHIFT', 16),
         (41, 'int') : ('SHIFT', 21),
-        (41, '~') : ('SHIFT', 15),
+        (41, 'string') : ('SHIFT', 30),
         (41, 'isvoid') : ('SHIFT', 27),
+        (41, '~') : ('SHIFT', 15),
         (41, '(') : ('SHIFT', 13),
         (41, 'new') : ('SHIFT', 22),
         (41, 'true') : ('SHIFT', 28),
-        (42, '<') : ('REDUCE', 35),
-        (42, '<=') : ('REDUCE', 35),
-        (42, ')') : ('REDUCE', 35),
-        (42, 'then') : ('REDUCE', 35),
-        (42, '}') : ('REDUCE', 35),
-        (42, 'else') : ('REDUCE', 35),
-        (42, 'fi') : ('REDUCE', 35),
-        (42, '=') : ('REDUCE', 35),
-        (42, 'in') : ('REDUCE', 35),
-        (42, ';') : ('REDUCE', 35),
-        (42, '+') : ('REDUCE', 35),
-        (42, '-') : ('REDUCE', 35),
-        (42, 'loop') : ('REDUCE', 35),
-        (42, 'of') : ('REDUCE', 35),
-        (42, 'pool') : ('REDUCE', 35),
-        (42, ',') : ('REDUCE', 35),
         (42, '/') : ('SHIFT', 46),
         (42, '*') : ('SHIFT', 43),
+        (42, '}') : ('REDUCE', 36),
+        (42, 'fi') : ('REDUCE', 36),
+        (42, 'in') : ('REDUCE', 36),
+        (42, '<') : ('REDUCE', 36),
+        (42, '=') : ('REDUCE', 36),
+        (42, ';') : ('REDUCE', 36),
+        (42, '<=') : ('REDUCE', 36),
+        (42, '+') : ('REDUCE', 36),
+        (42, ')') : ('REDUCE', 36),
+        (42, '-') : ('REDUCE', 36),
+        (42, 'then') : ('REDUCE', 36),
+        (42, 'of') : ('REDUCE', 36),
+        (42, 'loop') : ('REDUCE', 36),
+        (42, 'else') : ('REDUCE', 36),
+        (42, 'pool') : ('REDUCE', 36),
+        (42, ',') : ('REDUCE', 36),
         (43, 'false') : ('SHIFT', 29),
         (43, 'id') : ('SHIFT', 16),
+        (43, 'new') : ('SHIFT', 22),
         (43, 'string') : ('SHIFT', 30),
-        (43, 'true') : ('SHIFT', 28),
         (43, 'int') : ('SHIFT', 21),
+        (43, 'true') : ('SHIFT', 28),
         (43, 'isvoid') : ('SHIFT', 27),
         (43, '~') : ('SHIFT', 15),
         (43, '(') : ('SHIFT', 13),
-        (43, 'new') : ('SHIFT', 22),
-        (44, '<') : ('REDUCE', 38),
-        (44, '<=') : ('REDUCE', 38),
-        (44, ')') : ('REDUCE', 38),
-        (44, 'then') : ('REDUCE', 38),
-        (44, '}') : ('REDUCE', 38),
-        (44, 'else') : ('REDUCE', 38),
-        (44, 'fi') : ('REDUCE', 38),
-        (44, '=') : ('REDUCE', 38),
-        (44, 'in') : ('REDUCE', 38),
-        (44, ';') : ('REDUCE', 38),
-        (44, '+') : ('REDUCE', 38),
-        (44, '-') : ('REDUCE', 38),
-        (44, 'loop') : ('REDUCE', 38),
-        (44, 'of') : ('REDUCE', 38),
-        (44, '*') : ('REDUCE', 38),
-        (44, 'pool') : ('REDUCE', 38),
-        (44, ',') : ('REDUCE', 38),
-        (44, '/') : ('REDUCE', 38),
-        (45, 'then') : ('REDUCE', 51),
-        (45, 'else') : ('REDUCE', 51),
-        (45, 'fi') : ('REDUCE', 51),
-        (45, 'of') : ('REDUCE', 51),
-        (45, 'in') : ('REDUCE', 51),
-        (45, ';') : ('REDUCE', 51),
-        (45, ',') : ('REDUCE', 51),
-        (45, '.') : ('REDUCE', 51),
-        (45, ')') : ('REDUCE', 51),
-        (45, '}') : ('REDUCE', 51),
-        (45, '=') : ('REDUCE', 51),
-        (45, '+') : ('REDUCE', 51),
-        (45, '-') : ('REDUCE', 51),
-        (45, '*') : ('REDUCE', 51),
-        (45, '/') : ('REDUCE', 51),
-        (45, '<') : ('REDUCE', 51),
-        (45, '<=') : ('REDUCE', 51),
-        (45, '@') : ('REDUCE', 51),
-        (45, 'loop') : ('REDUCE', 51),
-        (45, 'pool') : ('REDUCE', 51),
+        (44, '/') : ('REDUCE', 39),
+        (44, '}') : ('REDUCE', 39),
+        (44, 'fi') : ('REDUCE', 39),
+        (44, 'in') : ('REDUCE', 39),
+        (44, '<') : ('REDUCE', 39),
+        (44, '=') : ('REDUCE', 39),
+        (44, ';') : ('REDUCE', 39),
+        (44, '<=') : ('REDUCE', 39),
+        (44, '+') : ('REDUCE', 39),
+        (44, 'else') : ('REDUCE', 39),
+        (44, ')') : ('REDUCE', 39),
+        (44, '-') : ('REDUCE', 39),
+        (44, 'then') : ('REDUCE', 39),
+        (44, 'of') : ('REDUCE', 39),
+        (44, 'loop') : ('REDUCE', 39),
+        (44, '*') : ('REDUCE', 39),
+        (44, 'pool') : ('REDUCE', 39),
+        (44, ',') : ('REDUCE', 39),
+        (45, 'fi') : ('REDUCE', 52),
+        (45, '=') : ('REDUCE', 52),
+        (45, '+') : ('REDUCE', 52),
+        (45, '-') : ('REDUCE', 52),
+        (45, 'of') : ('REDUCE', 52),
+        (45, '*') : ('REDUCE', 52),
+        (45, '/') : ('REDUCE', 52),
+        (45, '<') : ('REDUCE', 52),
+        (45, '<=') : ('REDUCE', 52),
+        (45, '@') : ('REDUCE', 52),
+        (45, 'in') : ('REDUCE', 52),
+        (45, ';') : ('REDUCE', 52),
+        (45, 'loop') : ('REDUCE', 52),
+        (45, 'pool') : ('REDUCE', 52),
+        (45, ',') : ('REDUCE', 52),
+        (45, '.') : ('REDUCE', 52),
+        (45, ')') : ('REDUCE', 52),
+        (45, 'then') : ('REDUCE', 52),
+        (45, 'else') : ('REDUCE', 52),
+        (45, '}') : ('REDUCE', 52),
         (46, 'false') : ('SHIFT', 29),
         (46, 'id') : ('SHIFT', 16),
+        (46, 'new') : ('SHIFT', 22),
         (46, 'string') : ('SHIFT', 30),
-        (46, 'true') : ('SHIFT', 28),
         (46, 'int') : ('SHIFT', 21),
+        (46, 'true') : ('SHIFT', 28),
         (46, 'isvoid') : ('SHIFT', 27),
         (46, '~') : ('SHIFT', 15),
         (46, '(') : ('SHIFT', 13),
-        (46, 'new') : ('SHIFT', 22),
-        (47, '<') : ('REDUCE', 39),
-        (47, '<=') : ('REDUCE', 39),
-        (47, ')') : ('REDUCE', 39),
-        (47, 'then') : ('REDUCE', 39),
-        (47, '}') : ('REDUCE', 39),
-        (47, 'else') : ('REDUCE', 39),
-        (47, 'fi') : ('REDUCE', 39),
-        (47, '=') : ('REDUCE', 39),
-        (47, 'in') : ('REDUCE', 39),
-        (47, ';') : ('REDUCE', 39),
-        (47, '+') : ('REDUCE', 39),
-        (47, '-') : ('REDUCE', 39),
-        (47, 'loop') : ('REDUCE', 39),
-        (47, 'of') : ('REDUCE', 39),
-        (47, '*') : ('REDUCE', 39),
-        (47, 'pool') : ('REDUCE', 39),
-        (47, ',') : ('REDUCE', 39),
-        (47, '/') : ('REDUCE', 39),
-        (48, '<') : ('REDUCE', 40),
-        (48, '<=') : ('REDUCE', 40),
-        (48, ')') : ('REDUCE', 40),
-        (48, 'then') : ('REDUCE', 40),
-        (48, '}') : ('REDUCE', 40),
-        (48, 'else') : ('REDUCE', 40),
-        (48, 'fi') : ('REDUCE', 40),
-        (48, '=') : ('REDUCE', 40),
-        (48, 'in') : ('REDUCE', 40),
-        (48, ';') : ('REDUCE', 40),
-        (48, '+') : ('REDUCE', 40),
-        (48, '-') : ('REDUCE', 40),
-        (48, 'loop') : ('REDUCE', 40),
-        (48, 'of') : ('REDUCE', 40),
-        (48, '*') : ('REDUCE', 40),
-        (48, 'pool') : ('REDUCE', 40),
-        (48, ',') : ('REDUCE', 40),
-        (48, '/') : ('REDUCE', 40),
-        (49, 'id') : ('SHIFT', 16),
+        (47, '/') : ('REDUCE', 40),
+        (47, '}') : ('REDUCE', 40),
+        (47, 'fi') : ('REDUCE', 40),
+        (47, 'in') : ('REDUCE', 40),
+        (47, '<') : ('REDUCE', 40),
+        (47, '=') : ('REDUCE', 40),
+        (47, ';') : ('REDUCE', 40),
+        (47, '<=') : ('REDUCE', 40),
+        (47, '+') : ('REDUCE', 40),
+        (47, 'else') : ('REDUCE', 40),
+        (47, ')') : ('REDUCE', 40),
+        (47, '-') : ('REDUCE', 40),
+        (47, 'then') : ('REDUCE', 40),
+        (47, 'of') : ('REDUCE', 40),
+        (47, 'loop') : ('REDUCE', 40),
+        (47, '*') : ('REDUCE', 40),
+        (47, 'pool') : ('REDUCE', 40),
+        (47, ',') : ('REDUCE', 40),
+        (48, '/') : ('REDUCE', 41),
+        (48, '}') : ('REDUCE', 41),
+        (48, 'fi') : ('REDUCE', 41),
+        (48, 'in') : ('REDUCE', 41),
+        (48, '<') : ('REDUCE', 41),
+        (48, '=') : ('REDUCE', 41),
+        (48, ';') : ('REDUCE', 41),
+        (48, '<=') : ('REDUCE', 41),
+        (48, '+') : ('REDUCE', 41),
+        (48, 'else') : ('REDUCE', 41),
+        (48, ')') : ('REDUCE', 41),
+        (48, '-') : ('REDUCE', 41),
+        (48, 'then') : ('REDUCE', 41),
+        (48, 'of') : ('REDUCE', 41),
+        (48, 'loop') : ('REDUCE', 41),
+        (48, '*') : ('REDUCE', 41),
+        (48, 'pool') : ('REDUCE', 41),
+        (48, ',') : ('REDUCE', 41),
         (49, 'false') : ('SHIFT', 29),
-        (49, 'string') : ('SHIFT', 30),
+        (49, 'id') : ('SHIFT', 16),
         (49, 'int') : ('SHIFT', 21),
-        (49, '~') : ('SHIFT', 15),
+        (49, 'string') : ('SHIFT', 30),
         (49, 'isvoid') : ('SHIFT', 27),
+        (49, '~') : ('SHIFT', 15),
         (49, '(') : ('SHIFT', 13),
         (49, 'new') : ('SHIFT', 22),
         (49, 'true') : ('SHIFT', 28),
         (50, '/') : ('SHIFT', 46),
-        (50, '<') : ('REDUCE', 36),
-        (50, '<=') : ('REDUCE', 36),
-        (50, ')') : ('REDUCE', 36),
-        (50, 'then') : ('REDUCE', 36),
-        (50, '}') : ('REDUCE', 36),
-        (50, 'else') : ('REDUCE', 36),
-        (50, 'fi') : ('REDUCE', 36),
-        (50, '=') : ('REDUCE', 36),
-        (50, 'in') : ('REDUCE', 36),
-        (50, ';') : ('REDUCE', 36),
-        (50, '+') : ('REDUCE', 36),
-        (50, '-') : ('REDUCE', 36),
-        (50, 'loop') : ('REDUCE', 36),
-        (50, 'of') : ('REDUCE', 36),
-        (50, 'pool') : ('REDUCE', 36),
-        (50, ',') : ('REDUCE', 36),
+        (50, '}') : ('REDUCE', 37),
+        (50, 'fi') : ('REDUCE', 37),
+        (50, 'in') : ('REDUCE', 37),
+        (50, '<') : ('REDUCE', 37),
+        (50, '=') : ('REDUCE', 37),
+        (50, ';') : ('REDUCE', 37),
+        (50, '<=') : ('REDUCE', 37),
+        (50, '+') : ('REDUCE', 37),
+        (50, ')') : ('REDUCE', 37),
+        (50, '-') : ('REDUCE', 37),
+        (50, 'then') : ('REDUCE', 37),
+        (50, 'of') : ('REDUCE', 37),
+        (50, 'loop') : ('REDUCE', 37),
+        (50, 'else') : ('REDUCE', 37),
+        (50, 'pool') : ('REDUCE', 37),
+        (50, ',') : ('REDUCE', 37),
         (50, '*') : ('SHIFT', 43),
-        (51, '<') : ('REDUCE', 37),
-        (51, '<=') : ('REDUCE', 37),
-        (51, ')') : ('REDUCE', 37),
-        (51, 'then') : ('REDUCE', 37),
-        (51, '}') : ('REDUCE', 37),
-        (51, 'else') : ('REDUCE', 37),
-        (51, 'fi') : ('REDUCE', 37),
-        (51, '=') : ('REDUCE', 37),
-        (51, 'in') : ('REDUCE', 37),
-        (51, ';') : ('REDUCE', 37),
-        (51, '+') : ('REDUCE', 37),
-        (51, '-') : ('REDUCE', 37),
-        (51, 'loop') : ('REDUCE', 37),
-        (51, 'of') : ('REDUCE', 37),
-        (51, 'pool') : ('REDUCE', 37),
-        (51, ',') : ('REDUCE', 37),
         (51, '/') : ('SHIFT', 46),
         (51, '*') : ('SHIFT', 43),
+        (51, '}') : ('REDUCE', 38),
+        (51, 'fi') : ('REDUCE', 38),
+        (51, 'in') : ('REDUCE', 38),
+        (51, '<') : ('REDUCE', 38),
+        (51, '=') : ('REDUCE', 38),
+        (51, ';') : ('REDUCE', 38),
+        (51, '<=') : ('REDUCE', 38),
+        (51, '+') : ('REDUCE', 38),
+        (51, ')') : ('REDUCE', 38),
+        (51, '-') : ('REDUCE', 38),
+        (51, 'then') : ('REDUCE', 38),
+        (51, 'of') : ('REDUCE', 38),
+        (51, 'loop') : ('REDUCE', 38),
+        (51, 'else') : ('REDUCE', 38),
+        (51, 'pool') : ('REDUCE', 38),
+        (51, ',') : ('REDUCE', 38),
         (52, 'false') : ('SHIFT', 29),
         (52, 'id') : ('SHIFT', 16),
         (52, 'string') : ('SHIFT', 30),
+        (52, 'int') : ('SHIFT', 21),
         (52, 'isvoid') : ('SHIFT', 27),
         (52, '~') : ('SHIFT', 15),
-        (52, 'int') : ('SHIFT', 21),
         (52, '(') : ('SHIFT', 13),
         (52, 'new') : ('SHIFT', 22),
         (52, 'true') : ('SHIFT', 28),
-        (53, '<') : ('REDUCE', 31),
-        (53, '<=') : ('REDUCE', 31),
-        (53, ')') : ('REDUCE', 31),
-        (53, 'then') : ('REDUCE', 31),
-        (53, '}') : ('REDUCE', 31),
-        (53, 'else') : ('REDUCE', 31),
-        (53, 'fi') : ('REDUCE', 31),
-        (53, '=') : ('REDUCE', 31),
-        (53, 'in') : ('REDUCE', 31),
-        (53, ';') : ('REDUCE', 31),
-        (53, 'loop') : ('REDUCE', 31),
-        (53, 'of') : ('REDUCE', 31),
-        (53, 'pool') : ('REDUCE', 31),
-        (53, ',') : ('REDUCE', 31),
-        (53, '+') : ('SHIFT', 41),
+        (53, '}') : ('REDUCE', 32),
+        (53, 'fi') : ('REDUCE', 32),
+        (53, 'in') : ('REDUCE', 32),
+        (53, '<') : ('REDUCE', 32),
+        (53, '=') : ('REDUCE', 32),
+        (53, ';') : ('REDUCE', 32),
+        (53, '<=') : ('REDUCE', 32),
+        (53, ')') : ('REDUCE', 32),
+        (53, 'then') : ('REDUCE', 32),
+        (53, 'loop') : ('REDUCE', 32),
+        (53, 'of') : ('REDUCE', 32),
+        (53, 'else') : ('REDUCE', 32),
+        (53, 'pool') : ('REDUCE', 32),
+        (53, ',') : ('REDUCE', 32),
         (53, '-') : ('SHIFT', 49),
+        (53, '+') : ('SHIFT', 41),
         (54, 'false') : ('SHIFT', 29),
         (54, 'id') : ('SHIFT', 16),
         (54, 'string') : ('SHIFT', 30),
+        (54, 'int') : ('SHIFT', 21),
         (54, 'isvoid') : ('SHIFT', 27),
         (54, '~') : ('SHIFT', 15),
-        (54, 'int') : ('SHIFT', 21),
         (54, '(') : ('SHIFT', 13),
         (54, 'new') : ('SHIFT', 22),
         (54, 'true') : ('SHIFT', 28),
         (55, '-') : ('SHIFT', 49),
+        (55, '}') : ('REDUCE', 33),
+        (55, 'fi') : ('REDUCE', 33),
+        (55, 'in') : ('REDUCE', 33),
+        (55, '<') : ('REDUCE', 33),
+        (55, '=') : ('REDUCE', 33),
+        (55, ';') : ('REDUCE', 33),
+        (55, '<=') : ('REDUCE', 33),
+        (55, ')') : ('REDUCE', 33),
+        (55, 'then') : ('REDUCE', 33),
+        (55, 'loop') : ('REDUCE', 33),
+        (55, 'of') : ('REDUCE', 33),
+        (55, 'else') : ('REDUCE', 33),
+        (55, 'pool') : ('REDUCE', 33),
+        (55, ',') : ('REDUCE', 33),
         (55, '+') : ('SHIFT', 41),
-        (55, '<') : ('REDUCE', 32),
-        (55, '<=') : ('REDUCE', 32),
-        (55, ')') : ('REDUCE', 32),
-        (55, 'then') : ('REDUCE', 32),
-        (55, '}') : ('REDUCE', 32),
-        (55, 'else') : ('REDUCE', 32),
-        (55, 'fi') : ('REDUCE', 32),
-        (55, '=') : ('REDUCE', 32),
-        (55, 'in') : ('REDUCE', 32),
-        (55, ';') : ('REDUCE', 32),
-        (55, 'loop') : ('REDUCE', 32),
-        (55, 'of') : ('REDUCE', 32),
-        (55, 'pool') : ('REDUCE', 32),
-        (55, ',') : ('REDUCE', 32),
         (56, ',') : ('SHIFT', 57),
-        (56, ')') : ('REDUCE', 55),
-        (57, 'while') : ('SHIFT', 20),
+        (56, ')') : ('REDUCE', 56),
+        (57, ')') : ('REDUCE', 58),
+        (57, 'int') : ('SHIFT', 21),
         (57, 'id') : ('SHIFT', 18),
         (57, 'new') : ('SHIFT', 22),
-        (57, '~') : ('SHIFT', 15),
-        (57, 'case') : ('SHIFT', 25),
+        (57, '{') : ('SHIFT', 14),
+        (57, 'true') : ('SHIFT', 28),
+        (57, 'let') : ('SHIFT', 8),
         (57, 'if') : ('SHIFT', 24),
+        (57, 'case') : ('SHIFT', 25),
         (57, 'not') : ('SHIFT', 26),
-        (57, 'true') : ('SHIFT', 28),
-        (57, 'false') : ('SHIFT', 29),
-        (57, 'int') : ('SHIFT', 21),
-        (57, 'string') : ('SHIFT', 30),
         (57, 'isvoid') : ('SHIFT', 27),
+        (57, 'while') : ('SHIFT', 20),
         (57, '(') : ('SHIFT', 13),
-        (57, ')') : ('REDUCE', 57),
-        (57, 'let') : ('SHIFT', 8),
-        (57, '{') : ('SHIFT', 14),
-        (58, ')') : ('REDUCE', 56),
-        (59, '<') : ('REDUCE', 34),
-        (59, '<=') : ('REDUCE', 34),
-        (59, ')') : ('REDUCE', 34),
-        (59, 'then') : ('REDUCE', 34),
-        (59, '}') : ('REDUCE', 34),
-        (59, 'else') : ('REDUCE', 34),
-        (59, 'fi') : ('REDUCE', 34),
-        (59, '=') : ('REDUCE', 34),
-        (59, 'in') : ('REDUCE', 34),
-        (59, ';') : ('REDUCE', 34),
-        (59, 'loop') : ('REDUCE', 34),
-        (59, 'of') : ('REDUCE', 34),
-        (59, 'pool') : ('REDUCE', 34),
-        (59, ',') : ('REDUCE', 34),
-        (59, '+') : ('SHIFT', 41),
+        (57, 'false') : ('SHIFT', 29),
+        (57, 'string') : ('SHIFT', 30),
+        (57, '~') : ('SHIFT', 15),
+        (58, ')') : ('REDUCE', 57),
+        (59, '}') : ('REDUCE', 35),
+        (59, 'fi') : ('REDUCE', 35),
+        (59, 'in') : ('REDUCE', 35),
+        (59, '<') : ('REDUCE', 35),
+        (59, '=') : ('REDUCE', 35),
+        (59, ';') : ('REDUCE', 35),
+        (59, '<=') : ('REDUCE', 35),
+        (59, ')') : ('REDUCE', 35),
+        (59, 'then') : ('REDUCE', 35),
+        (59, 'loop') : ('REDUCE', 35),
+        (59, 'of') : ('REDUCE', 35),
+        (59, 'else') : ('REDUCE', 35),
+        (59, 'pool') : ('REDUCE', 35),
+        (59, ',') : ('REDUCE', 35),
         (59, '-') : ('SHIFT', 49),
-        (60, 'type') : ('SHIFT', 61),
-        (61, '.') : ('SHIFT', 62),
-        (62, 'id') : ('SHIFT', 63),
-        (63, '(') : ('SHIFT', 64),
-        (64, 'while') : ('SHIFT', 20),
-        (64, 'id') : ('SHIFT', 18),
-        (64, 'new') : ('SHIFT', 22),
-        (64, '~') : ('SHIFT', 15),
-        (64, 'case') : ('SHIFT', 25),
-        (64, 'if') : ('SHIFT', 24),
-        (64, 'not') : ('SHIFT', 26),
-        (64, 'true') : ('SHIFT', 28),
-        (64, 'false') : ('SHIFT', 29),
-        (64, 'int') : ('SHIFT', 21),
-        (64, 'string') : ('SHIFT', 30),
-        (64, 'isvoid') : ('SHIFT', 27),
-        (64, '(') : ('SHIFT', 13),
-        (64, ')') : ('REDUCE', 57),
-        (64, 'let') : ('SHIFT', 8),
-        (64, '{') : ('SHIFT', 14),
-        (65, ')') : ('SHIFT', 66),
-        (66, 'then') : ('REDUCE', 54),
-        (66, 'else') : ('REDUCE', 54),
-        (66, 'fi') : ('REDUCE', 54),
-        (66, 'of') : ('REDUCE', 54),
-        (66, 'in') : ('REDUCE', 54),
-        (66, ';') : ('REDUCE', 54),
-        (66, ',') : ('REDUCE', 54),
-        (66, '.') : ('REDUCE', 54),
-        (66, ')') : ('REDUCE', 54),
-        (66, '}') : ('REDUCE', 54),
-        (66, '=') : ('REDUCE', 54),
-        (66, '+') : ('REDUCE', 54),
-        (66, '-') : ('REDUCE', 54),
-        (66, '*') : ('REDUCE', 54),
-        (66, '/') : ('REDUCE', 54),
-        (66, '<') : ('REDUCE', 54),
-        (66, '<=') : ('REDUCE', 54),
-        (66, '@') : ('REDUCE', 54),
-        (66, 'loop') : ('REDUCE', 54),
-        (66, 'pool') : ('REDUCE', 54),
-        (67, ')') : ('REDUCE', 18),
-        (67, 'then') : ('REDUCE', 18),
-        (67, '}') : ('REDUCE', 18),
-        (67, 'else') : ('REDUCE', 18),
-        (67, 'fi') : ('REDUCE', 18),
-        (67, 'in') : ('REDUCE', 18),
-        (67, ';') : ('REDUCE', 18),
-        (67, 'loop') : ('REDUCE', 18),
-        (67, 'of') : ('REDUCE', 18),
-        (67, 'pool') : ('REDUCE', 18),
-        (67, ',') : ('REDUCE', 18),
-        (68, 'of') : ('SHIFT', 69),
-        (69, 'id') : ('SHIFT', 70),
-        (70, ':') : ('SHIFT', 71),
-        (71, 'type') : ('SHIFT', 72),
-        (72, '=>') : ('SHIFT', 73),
-        (73, 'if') : ('SHIFT', 24),
-        (73, 'not') : ('SHIFT', 26),
-        (73, 'id') : ('SHIFT', 18),
-        (73, 'false') : ('SHIFT', 29),
-        (73, 'int') : ('SHIFT', 21),
-        (73, 'string') : ('SHIFT', 30),
-        (73, '(') : ('SHIFT', 13),
-        (73, 'true') : ('SHIFT', 28),
-        (73, 'let') : ('SHIFT', 8),
-        (73, 'isvoid') : ('SHIFT', 27),
-        (73, '~') : ('SHIFT', 15),
-        (73, 'case') : ('SHIFT', 25),
-        (73, '{') : ('SHIFT', 14),
-        (73, 'new') : ('SHIFT', 22),
-        (73, 'while') : ('SHIFT', 20),
-        (74, ';') : ('SHIFT', 75),
-        (75, 'id') : ('SHIFT', 70),
-        (75, 'esac') : ('REDUCE', 28),
-        (76, 'esac') : ('REDUCE', 29),
-        (77, 'esac') : ('SHIFT', 78),
-        (78, ')') : ('REDUCE', 27),
-        (78, 'then') : ('REDUCE', 27),
-        (78, '}') : ('REDUCE', 27),
-        (78, 'else') : ('REDUCE', 27),
-        (78, 'fi') : ('REDUCE', 27),
-        (78, 'in') : ('REDUCE', 27),
-        (78, ';') : ('REDUCE', 27),
-        (78, 'loop') : ('REDUCE', 27),
-        (78, 'of') : ('REDUCE', 27),
-        (78, 'pool') : ('REDUCE', 27),
-        (78, ',') : ('REDUCE', 27),
-        (79, 'then') : ('SHIFT', 80),
-        (80, 'id') : ('SHIFT', 18),
-        (80, 'let') : ('SHIFT', 8),
-        (80, 'false') : ('SHIFT', 29),
-        (80, 'int') : ('SHIFT', 21),
-        (80, 'isvoid') : ('SHIFT', 27),
-        (80, '~') : ('SHIFT', 15),
-        (80, 'string') : ('SHIFT', 30),
-        (80, '(') : ('SHIFT', 13),
-        (80, 'case') : ('SHIFT', 25),
-        (80, 'new') : ('SHIFT', 22),
-        (80, 'while') : ('SHIFT', 20),
-        (80, 'if') : ('SHIFT', 24),
-        (80, 'not') : ('SHIFT', 26),
-        (80, '{') : ('SHIFT', 14),
-        (80, 'true') : ('SHIFT', 28),
-        (81, 'else') : ('SHIFT', 82),
-        (82, 'case') : ('SHIFT', 25),
-        (82, 'not') : ('SHIFT', 26),
-        (82, 'int') : ('SHIFT', 21),
-        (82, '(') : ('SHIFT', 13),
-        (82, 'while') : ('SHIFT', 20),
-        (82, 'id') : ('SHIFT', 18),
-        (82, 'true') : ('SHIFT', 28),
-        (82, 'if') : ('SHIFT', 24),
-        (82, 'false') : ('SHIFT', 29),
-        (82, 'let') : ('SHIFT', 8),
-        (82, 'string') : ('SHIFT', 30),
-        (82, 'isvoid') : ('SHIFT', 27),
-        (82, '~') : ('SHIFT', 15),
-        (82, 'new') : ('SHIFT', 22),
-        (82, '{') : ('SHIFT', 14),
-        (83, 'fi') : ('SHIFT', 84),
-        (84, ')') : ('REDUCE', 16),
-        (84, 'then') : ('REDUCE', 16),
-        (84, '}') : ('REDUCE', 16),
-        (84, 'else') : ('REDUCE', 16),
-        (84, 'fi') : ('REDUCE', 16),
-        (84, 'in') : ('REDUCE', 16),
-        (84, ';') : ('REDUCE', 16),
-        (84, 'loop') : ('REDUCE', 16),
-        (84, 'of') : ('REDUCE', 16),
-        (84, 'pool') : ('REDUCE', 16),
-        (84, ',') : ('REDUCE', 16),
-        (85, 'loop') : ('SHIFT', 86),
-        (86, 'let') : ('SHIFT', 8),
-        (86, 'new') : ('SHIFT', 22),
-        (86, 'id') : ('SHIFT', 18),
-        (86, 'isvoid') : ('SHIFT', 27),
-        (86, '~') : ('SHIFT', 15),
-        (86, 'case') : ('SHIFT', 25),
-        (86, '{') : ('SHIFT', 14),
-        (86, 'true') : ('SHIFT', 28),
-        (86, 'while') : ('SHIFT', 20),
-        (86, 'false') : ('SHIFT', 29),
-        (86, 'int') : ('SHIFT', 21),
-        (86, 'string') : ('SHIFT', 30),
-        (86, '(') : ('SHIFT', 13),
-        (86, 'if') : ('SHIFT', 24),
-        (86, 'not') : ('SHIFT', 26),
-        (87, 'pool') : ('SHIFT', 88),
-        (88, ')') : ('REDUCE', 17),
-        (88, 'then') : ('REDUCE', 17),
-        (88, '}') : ('REDUCE', 17),
-        (88, 'else') : ('REDUCE', 17),
-        (88, 'fi') : ('REDUCE', 17),
-        (88, 'in') : ('REDUCE', 17),
-        (88, ';') : ('REDUCE', 17),
-        (88, 'loop') : ('REDUCE', 17),
-        (88, 'of') : ('REDUCE', 17),
-        (88, 'pool') : ('REDUCE', 17),
-        (88, ',') : ('REDUCE', 17),
-        (89, ')') : ('REDUCE', 15),
-        (89, 'then') : ('REDUCE', 15),
-        (89, '}') : ('REDUCE', 15),
-        (89, 'else') : ('REDUCE', 15),
-        (89, 'fi') : ('REDUCE', 15),
-        (89, 'in') : ('REDUCE', 15),
-        (89, ';') : ('REDUCE', 15),
-        (89, 'loop') : ('REDUCE', 15),
-        (89, 'of') : ('REDUCE', 15),
-        (89, 'pool') : ('REDUCE', 15),
-        (89, ',') : ('REDUCE', 15),
-        (90, ')') : ('SHIFT', 91),
-        (91, 'then') : ('REDUCE', 53),
-        (91, 'else') : ('REDUCE', 53),
-        (91, 'fi') : ('REDUCE', 53),
-        (91, 'of') : ('REDUCE', 53),
-        (91, 'in') : ('REDUCE', 53),
-        (91, ';') : ('REDUCE', 53),
-        (91, ',') : ('REDUCE', 53),
-        (91, '.') : ('REDUCE', 53),
-        (91, ')') : ('REDUCE', 53),
-        (91, '}') : ('REDUCE', 53),
-        (91, '=') : ('REDUCE', 53),
-        (91, '+') : ('REDUCE', 53),
-        (91, '-') : ('REDUCE', 53),
-        (91, '*') : ('REDUCE', 53),
-        (91, '/') : ('REDUCE', 53),
-        (91, '<') : ('REDUCE', 53),
-        (91, '<=') : ('REDUCE', 53),
-        (91, '@') : ('REDUCE', 53),
-        (91, 'loop') : ('REDUCE', 53),
-        (91, 'pool') : ('REDUCE', 53),
-        (92, '<') : ('REDUCE', 42),
-        (92, '<=') : ('REDUCE', 42),
-        (92, ')') : ('REDUCE', 42),
-        (92, 'then') : ('REDUCE', 42),
-        (92, '}') : ('REDUCE', 42),
-        (92, 'else') : ('REDUCE', 42),
-        (92, 'fi') : ('REDUCE', 42),
-        (92, '=') : ('REDUCE', 42),
-        (92, 'in') : ('REDUCE', 42),
-        (92, ';') : ('REDUCE', 42),
-        (92, '+') : ('REDUCE', 42),
-        (92, '-') : ('REDUCE', 42),
-        (92, 'loop') : ('REDUCE', 42),
-        (92, 'of') : ('REDUCE', 42),
-        (92, '*') : ('REDUCE', 42),
-        (92, 'pool') : ('REDUCE', 42),
-        (92, ',') : ('REDUCE', 42),
-        (92, '/') : ('REDUCE', 42),
-        (93, '}') : ('SHIFT', 94),
-        (94, ')') : ('REDUCE', 19),
-        (94, 'then') : ('REDUCE', 19),
-        (94, '}') : ('REDUCE', 19),
-        (94, 'else') : ('REDUCE', 19),
-        (94, 'fi') : ('REDUCE', 19),
-        (94, 'in') : ('REDUCE', 19),
-        (94, ';') : ('REDUCE', 19),
-        (94, 'loop') : ('REDUCE', 19),
-        (94, 'of') : ('REDUCE', 19),
-        (94, 'pool') : ('REDUCE', 19),
-        (94, ',') : ('REDUCE', 19),
-        (95, ';') : ('SHIFT', 96),
-        (96, 'if') : ('SHIFT', 24),
-        (96, 'not') : ('SHIFT', 26),
-        (96, 'id') : ('SHIFT', 18),
-        (96, 'false') : ('SHIFT', 29),
-        (96, 'int') : ('SHIFT', 21),
-        (96, 'string') : ('SHIFT', 30),
-        (96, '(') : ('SHIFT', 13),
-        (96, '}') : ('REDUCE', 20),
-        (96, 'true') : ('SHIFT', 28),
-        (96, 'let') : ('SHIFT', 8),
-        (96, 'isvoid') : ('SHIFT', 27),
-        (96, '~') : ('SHIFT', 15),
-        (96, 'case') : ('SHIFT', 25),
-        (96, '{') : ('SHIFT', 14),
-        (96, 'new') : ('SHIFT', 22),
-        (96, 'while') : ('SHIFT', 20),
-        (97, '}') : ('REDUCE', 21),
-        (98, ')') : ('SHIFT', 99),
-        (99, 'then') : ('REDUCE', 50),
-        (99, 'else') : ('REDUCE', 50),
-        (99, 'fi') : ('REDUCE', 50),
-        (99, 'of') : ('REDUCE', 50),
-        (99, 'in') : ('REDUCE', 50),
-        (99, ';') : ('REDUCE', 50),
-        (99, ',') : ('REDUCE', 50),
-        (99, '.') : ('REDUCE', 50),
-        (99, ')') : ('REDUCE', 50),
-        (99, '}') : ('REDUCE', 50),
-        (99, '=') : ('REDUCE', 50),
-        (99, '+') : ('REDUCE', 50),
-        (99, '-') : ('REDUCE', 50),
-        (99, '*') : ('REDUCE', 50),
-        (99, '/') : ('REDUCE', 50),
-        (99, '<') : ('REDUCE', 50),
-        (99, '<=') : ('REDUCE', 50),
-        (99, '@') : ('REDUCE', 50),
-        (99, 'loop') : ('REDUCE', 50),
-        (99, 'pool') : ('REDUCE', 50),
-        (100, 'in') : ('REDUCE', 24),
-        (100, ',') : ('SHIFT', 101),
-        (101, 'id') : ('SHIFT', 9),
-        (102, 'in') : ('REDUCE', 26),
-        (103, 'id') : ('SHIFT', 9),
-        (104, 'in') : ('REDUCE', 25),
-        (105, 'in') : ('SHIFT', 106),
-        (106, 'id') : ('SHIFT', 18),
-        (106, 'false') : ('SHIFT', 29),
-        (106, 'let') : ('SHIFT', 8),
-        (106, 'string') : ('SHIFT', 30),
-        (106, 'isvoid') : ('SHIFT', 27),
-        (106, 'case') : ('SHIFT', 25),
-        (106, '~') : ('SHIFT', 15),
-        (106, '{') : ('SHIFT', 14),
-        (106, 'new') : ('SHIFT', 22),
-        (106, 'while') : ('SHIFT', 20),
-        (106, 'if') : ('SHIFT', 24),
-        (106, 'not') : ('SHIFT', 26),
-        (106, 'int') : ('SHIFT', 21),
-        (106, '(') : ('SHIFT', 13),
-        (106, 'true') : ('SHIFT', 28),
-        (107, ')') : ('REDUCE', 22),
-        (107, 'then') : ('REDUCE', 22),
-        (107, '}') : ('REDUCE', 22),
-        (107, 'else') : ('REDUCE', 22),
-        (107, 'fi') : ('REDUCE', 22),
-        (107, 'in') : ('REDUCE', 22),
-        (107, ';') : ('REDUCE', 22),
-        (107, 'loop') : ('REDUCE', 22),
-        (107, 'of') : ('REDUCE', 22),
-        (107, 'pool') : ('REDUCE', 22),
-        (107, ',') : ('REDUCE', 22),
-        (108, ';') : ('REDUCE', 9),
-        (109, ')') : ('REDUCE', 13),
-        (109, 'id') : ('SHIFT', 110),
-        (110, ':') : ('SHIFT', 111),
-        (111, 'type') : ('SHIFT', 112),
-        (112, ',') : ('REDUCE', 14),
-        (112, ')') : ('REDUCE', 14),
-        (113, ')') : ('SHIFT', 114),
-        (114, ':') : ('SHIFT', 115),
-        (115, 'type') : ('SHIFT', 116),
-        (116, '{') : ('SHIFT', 117),
-        (117, 'string') : ('SHIFT', 30),
-        (117, '(') : ('SHIFT', 13),
-        (117, 'isvoid') : ('SHIFT', 27),
-        (117, '~') : ('SHIFT', 15),
-        (117, 'let') : ('SHIFT', 8),
-        (117, 'true') : ('SHIFT', 28),
-        (117, 'case') : ('SHIFT', 25),
-        (117, '{') : ('SHIFT', 14),
-        (117, 'while') : ('SHIFT', 20),
-        (117, 'id') : ('SHIFT', 18),
-        (117, 'new') : ('SHIFT', 22),
-        (117, 'if') : ('SHIFT', 24),
-        (117, 'not') : ('SHIFT', 26),
-        (117, 'false') : ('SHIFT', 29),
-        (117, 'int') : ('SHIFT', 21),
-        (118, '}') : ('SHIFT', 119),
-        (119, ';') : ('REDUCE', 10),
-        (120, ',') : ('SHIFT', 121),
-        (120, ')') : ('REDUCE', 11),
-        (121, ')') : ('REDUCE', 13),
-        (121, 'id') : ('SHIFT', 110),
-        (122, ')') : ('REDUCE', 12),
-        (123, '}') : ('SHIFT', 124),
-        (124, ';') : ('REDUCE', 3),
-        (125, ';') : ('SHIFT', 126),
-        (126, 'id') : ('SHIFT', 4),
-        (126, '}') : ('REDUCE', 7),
-        (127, '}') : ('REDUCE', 5),
-        (128, ';') : ('SHIFT', 129),
-        (129, 'id') : ('SHIFT', 4),
-        (129, '}') : ('REDUCE', 7),
-        (130, '}') : ('REDUCE', 6),
-        (131, 'type') : ('SHIFT', 132),
-        (132, '{') : ('SHIFT', 133),
-        (133, 'id') : ('SHIFT', 4),
-        (133, '}') : ('REDUCE', 7),
-        (134, '}') : ('SHIFT', 135),
-        (135, ';') : ('REDUCE', 4),
-        (136, '$') : ('REDUCE', 0),
-        (137, ';') : ('SHIFT', 138),
-        (138, 'class') : ('SHIFT', 1),
-        (138, '$') : ('REDUCE', 1),
-        (139, '$') : ('REDUCE', 2),
-        (140, '$') : ('OK', None)
+        (59, '+') : ('SHIFT', 41),
+        (60, 'pool') : ('REDUCE', 29),
+        (60, 'fi') : ('REDUCE', 29),
+        (60, 'in') : ('REDUCE', 29),
+        (60, ';') : ('REDUCE', 29),
+        (60, ')') : ('REDUCE', 29),
+        (60, 'then') : ('REDUCE', 29),
+        (60, 'of') : ('REDUCE', 29),
+        (60, 'loop') : ('REDUCE', 29),
+        (60, 'else') : ('REDUCE', 29),
+        (60, '}') : ('REDUCE', 29),
+        (60, ',') : ('REDUCE', 29),
+        (61, 'type') : ('SHIFT', 62),
+        (62, '.') : ('SHIFT', 63),
+        (63, 'id') : ('SHIFT', 64),
+        (64, '(') : ('SHIFT', 65),
+        (65, ')') : ('REDUCE', 58),
+        (65, '~') : ('SHIFT', 15),
+        (65, 'id') : ('SHIFT', 18),
+        (65, 'new') : ('SHIFT', 22),
+        (65, '{') : ('SHIFT', 14),
+        (65, 'true') : ('SHIFT', 28),
+        (65, 'let') : ('SHIFT', 8),
+        (65, 'if') : ('SHIFT', 24),
+        (65, 'case') : ('SHIFT', 25),
+        (65, 'string') : ('SHIFT', 30),
+        (65, 'isvoid') : ('SHIFT', 27),
+        (65, 'while') : ('SHIFT', 20),
+        (65, '(') : ('SHIFT', 13),
+        (65, 'false') : ('SHIFT', 29),
+        (65, 'int') : ('SHIFT', 21),
+        (65, 'not') : ('SHIFT', 26),
+        (66, ')') : ('SHIFT', 67),
+        (67, 'fi') : ('REDUCE', 55),
+        (67, '=') : ('REDUCE', 55),
+        (67, '+') : ('REDUCE', 55),
+        (67, '-') : ('REDUCE', 55),
+        (67, 'of') : ('REDUCE', 55),
+        (67, '*') : ('REDUCE', 55),
+        (67, '/') : ('REDUCE', 55),
+        (67, '<') : ('REDUCE', 55),
+        (67, '<=') : ('REDUCE', 55),
+        (67, '@') : ('REDUCE', 55),
+        (67, 'in') : ('REDUCE', 55),
+        (67, ';') : ('REDUCE', 55),
+        (67, 'loop') : ('REDUCE', 55),
+        (67, 'pool') : ('REDUCE', 55),
+        (67, ',') : ('REDUCE', 55),
+        (67, '.') : ('REDUCE', 55),
+        (67, ')') : ('REDUCE', 55),
+        (67, 'then') : ('REDUCE', 55),
+        (67, 'else') : ('REDUCE', 55),
+        (67, '}') : ('REDUCE', 55),
+        (68, '<=') : ('SHIFT', 54),
+        (68, '<') : ('SHIFT', 52),
+        (68, '=') : ('SHIFT', 39),
+        (68, '}') : ('REDUCE', 31),
+        (68, 'fi') : ('REDUCE', 31),
+        (68, 'in') : ('REDUCE', 31),
+        (68, ';') : ('REDUCE', 31),
+        (68, ')') : ('REDUCE', 31),
+        (68, 'then') : ('REDUCE', 31),
+        (68, 'of') : ('REDUCE', 31),
+        (68, 'loop') : ('REDUCE', 31),
+        (68, 'else') : ('REDUCE', 31),
+        (68, 'pool') : ('REDUCE', 31),
+        (68, ',') : ('REDUCE', 31),
+        (69, 'of') : ('SHIFT', 70),
+        (70, 'id') : ('SHIFT', 71),
+        (71, ':') : ('SHIFT', 72),
+        (72, 'type') : ('SHIFT', 73),
+        (73, '=>') : ('SHIFT', 74),
+        (74, 'isvoid') : ('SHIFT', 27),
+        (74, '{') : ('SHIFT', 14),
+        (74, '(') : ('SHIFT', 13),
+        (74, 'let') : ('SHIFT', 8),
+        (74, 'if') : ('SHIFT', 24),
+        (74, 'case') : ('SHIFT', 25),
+        (74, 'id') : ('SHIFT', 18),
+        (74, 'false') : ('SHIFT', 29),
+        (74, 'int') : ('SHIFT', 21),
+        (74, 'string') : ('SHIFT', 30),
+        (74, 'while') : ('SHIFT', 20),
+        (74, '~') : ('SHIFT', 15),
+        (74, 'new') : ('SHIFT', 22),
+        (74, 'true') : ('SHIFT', 28),
+        (74, 'not') : ('SHIFT', 26),
+        (75, ';') : ('SHIFT', 76),
+        (76, 'id') : ('SHIFT', 71),
+        (76, 'esac') : ('REDUCE', 27),
+        (77, 'esac') : ('REDUCE', 28),
+        (78, 'esac') : ('SHIFT', 79),
+        (79, '}') : ('REDUCE', 26),
+        (79, 'fi') : ('REDUCE', 26),
+        (79, 'in') : ('REDUCE', 26),
+        (79, ';') : ('REDUCE', 26),
+        (79, ')') : ('REDUCE', 26),
+        (79, 'then') : ('REDUCE', 26),
+        (79, 'loop') : ('REDUCE', 26),
+        (79, 'of') : ('REDUCE', 26),
+        (79, 'else') : ('REDUCE', 26),
+        (79, 'pool') : ('REDUCE', 26),
+        (79, ',') : ('REDUCE', 26),
+        (80, 'then') : ('SHIFT', 81),
+        (81, 'not') : ('SHIFT', 26),
+        (81, 'new') : ('SHIFT', 22),
+        (81, 'true') : ('SHIFT', 28),
+        (81, '{') : ('SHIFT', 14),
+        (81, 'id') : ('SHIFT', 18),
+        (81, 'let') : ('SHIFT', 8),
+        (81, 'case') : ('SHIFT', 25),
+        (81, 'if') : ('SHIFT', 24),
+        (81, '~') : ('SHIFT', 15),
+        (81, '(') : ('SHIFT', 13),
+        (81, 'while') : ('SHIFT', 20),
+        (81, 'false') : ('SHIFT', 29),
+        (81, 'isvoid') : ('SHIFT', 27),
+        (81, 'string') : ('SHIFT', 30),
+        (81, 'int') : ('SHIFT', 21),
+        (82, 'else') : ('SHIFT', 83),
+        (83, '(') : ('SHIFT', 13),
+        (83, 'isvoid') : ('SHIFT', 27),
+        (83, 'not') : ('SHIFT', 26),
+        (83, 'id') : ('SHIFT', 18),
+        (83, 'false') : ('SHIFT', 29),
+        (83, 'string') : ('SHIFT', 30),
+        (83, 'int') : ('SHIFT', 21),
+        (83, '{') : ('SHIFT', 14),
+        (83, 'let') : ('SHIFT', 8),
+        (83, 'case') : ('SHIFT', 25),
+        (83, 'if') : ('SHIFT', 24),
+        (83, 'new') : ('SHIFT', 22),
+        (83, 'true') : ('SHIFT', 28),
+        (83, '~') : ('SHIFT', 15),
+        (83, 'while') : ('SHIFT', 20),
+        (84, 'fi') : ('SHIFT', 85),
+        (85, '}') : ('REDUCE', 16),
+        (85, 'fi') : ('REDUCE', 16),
+        (85, 'in') : ('REDUCE', 16),
+        (85, ';') : ('REDUCE', 16),
+        (85, ')') : ('REDUCE', 16),
+        (85, 'then') : ('REDUCE', 16),
+        (85, 'loop') : ('REDUCE', 16),
+        (85, 'of') : ('REDUCE', 16),
+        (85, 'else') : ('REDUCE', 16),
+        (85, 'pool') : ('REDUCE', 16),
+        (85, ',') : ('REDUCE', 16),
+        (86, 'loop') : ('SHIFT', 87),
+        (87, 'true') : ('SHIFT', 28),
+        (87, 'not') : ('SHIFT', 26),
+        (87, '{') : ('SHIFT', 14),
+        (87, 'isvoid') : ('SHIFT', 27),
+        (87, '(') : ('SHIFT', 13),
+        (87, 'let') : ('SHIFT', 8),
+        (87, 'if') : ('SHIFT', 24),
+        (87, 'case') : ('SHIFT', 25),
+        (87, 'id') : ('SHIFT', 18),
+        (87, 'false') : ('SHIFT', 29),
+        (87, 'int') : ('SHIFT', 21),
+        (87, 'string') : ('SHIFT', 30),
+        (87, 'while') : ('SHIFT', 20),
+        (87, '~') : ('SHIFT', 15),
+        (87, 'new') : ('SHIFT', 22),
+        (88, 'pool') : ('SHIFT', 89),
+        (89, '}') : ('REDUCE', 17),
+        (89, 'fi') : ('REDUCE', 17),
+        (89, 'in') : ('REDUCE', 17),
+        (89, ';') : ('REDUCE', 17),
+        (89, ')') : ('REDUCE', 17),
+        (89, 'then') : ('REDUCE', 17),
+        (89, 'of') : ('REDUCE', 17),
+        (89, 'loop') : ('REDUCE', 17),
+        (89, 'else') : ('REDUCE', 17),
+        (89, 'pool') : ('REDUCE', 17),
+        (89, ',') : ('REDUCE', 17),
+        (90, '}') : ('REDUCE', 15),
+        (90, 'fi') : ('REDUCE', 15),
+        (90, 'in') : ('REDUCE', 15),
+        (90, ';') : ('REDUCE', 15),
+        (90, ')') : ('REDUCE', 15),
+        (90, 'then') : ('REDUCE', 15),
+        (90, 'loop') : ('REDUCE', 15),
+        (90, 'of') : ('REDUCE', 15),
+        (90, 'else') : ('REDUCE', 15),
+        (90, 'pool') : ('REDUCE', 15),
+        (90, ',') : ('REDUCE', 15),
+        (91, ')') : ('SHIFT', 92),
+        (92, 'fi') : ('REDUCE', 54),
+        (92, '=') : ('REDUCE', 54),
+        (92, '+') : ('REDUCE', 54),
+        (92, '-') : ('REDUCE', 54),
+        (92, 'of') : ('REDUCE', 54),
+        (92, '*') : ('REDUCE', 54),
+        (92, '/') : ('REDUCE', 54),
+        (92, '<') : ('REDUCE', 54),
+        (92, '<=') : ('REDUCE', 54),
+        (92, '@') : ('REDUCE', 54),
+        (92, 'in') : ('REDUCE', 54),
+        (92, ';') : ('REDUCE', 54),
+        (92, 'loop') : ('REDUCE', 54),
+        (92, 'pool') : ('REDUCE', 54),
+        (92, ',') : ('REDUCE', 54),
+        (92, '.') : ('REDUCE', 54),
+        (92, ')') : ('REDUCE', 54),
+        (92, 'then') : ('REDUCE', 54),
+        (92, 'else') : ('REDUCE', 54),
+        (92, '}') : ('REDUCE', 54),
+        (93, '/') : ('REDUCE', 43),
+        (93, '}') : ('REDUCE', 43),
+        (93, 'fi') : ('REDUCE', 43),
+        (93, 'in') : ('REDUCE', 43),
+        (93, '<') : ('REDUCE', 43),
+        (93, '=') : ('REDUCE', 43),
+        (93, ';') : ('REDUCE', 43),
+        (93, '<=') : ('REDUCE', 43),
+        (93, '+') : ('REDUCE', 43),
+        (93, 'else') : ('REDUCE', 43),
+        (93, ')') : ('REDUCE', 43),
+        (93, '-') : ('REDUCE', 43),
+        (93, 'then') : ('REDUCE', 43),
+        (93, 'of') : ('REDUCE', 43),
+        (93, 'loop') : ('REDUCE', 43),
+        (93, '*') : ('REDUCE', 43),
+        (93, 'pool') : ('REDUCE', 43),
+        (93, ',') : ('REDUCE', 43),
+        (94, '}') : ('SHIFT', 95),
+        (95, '}') : ('REDUCE', 18),
+        (95, 'fi') : ('REDUCE', 18),
+        (95, 'in') : ('REDUCE', 18),
+        (95, ';') : ('REDUCE', 18),
+        (95, ')') : ('REDUCE', 18),
+        (95, 'then') : ('REDUCE', 18),
+        (95, 'of') : ('REDUCE', 18),
+        (95, 'loop') : ('REDUCE', 18),
+        (95, 'else') : ('REDUCE', 18),
+        (95, 'pool') : ('REDUCE', 18),
+        (95, ',') : ('REDUCE', 18),
+        (96, ';') : ('SHIFT', 97),
+        (97, 'isvoid') : ('SHIFT', 27),
+        (97, '{') : ('SHIFT', 14),
+        (97, '(') : ('SHIFT', 13),
+        (97, 'let') : ('SHIFT', 8),
+        (97, 'if') : ('SHIFT', 24),
+        (97, 'case') : ('SHIFT', 25),
+        (97, 'id') : ('SHIFT', 18),
+        (97, 'false') : ('SHIFT', 29),
+        (97, 'int') : ('SHIFT', 21),
+        (97, 'string') : ('SHIFT', 30),
+        (97, 'while') : ('SHIFT', 20),
+        (97, '}') : ('REDUCE', 19),
+        (97, '~') : ('SHIFT', 15),
+        (97, 'new') : ('SHIFT', 22),
+        (97, 'true') : ('SHIFT', 28),
+        (97, 'not') : ('SHIFT', 26),
+        (98, '}') : ('REDUCE', 20),
+        (99, ')') : ('SHIFT', 100),
+        (100, 'fi') : ('REDUCE', 51),
+        (100, '=') : ('REDUCE', 51),
+        (100, '+') : ('REDUCE', 51),
+        (100, '-') : ('REDUCE', 51),
+        (100, 'of') : ('REDUCE', 51),
+        (100, '*') : ('REDUCE', 51),
+        (100, '/') : ('REDUCE', 51),
+        (100, '<') : ('REDUCE', 51),
+        (100, '<=') : ('REDUCE', 51),
+        (100, '@') : ('REDUCE', 51),
+        (100, 'in') : ('REDUCE', 51),
+        (100, ';') : ('REDUCE', 51),
+        (100, 'loop') : ('REDUCE', 51),
+        (100, 'pool') : ('REDUCE', 51),
+        (100, ',') : ('REDUCE', 51),
+        (100, '.') : ('REDUCE', 51),
+        (100, ')') : ('REDUCE', 51),
+        (100, 'then') : ('REDUCE', 51),
+        (100, 'else') : ('REDUCE', 51),
+        (100, '}') : ('REDUCE', 51),
+        (101, 'in') : ('REDUCE', 23),
+        (101, ',') : ('SHIFT', 102),
+        (102, 'id') : ('SHIFT', 9),
+        (103, 'in') : ('REDUCE', 25),
+        (104, 'id') : ('SHIFT', 9),
+        (105, 'in') : ('REDUCE', 24),
+        (106, 'in') : ('SHIFT', 107),
+        (107, 'false') : ('SHIFT', 29),
+        (107, '{') : ('SHIFT', 14),
+        (107, 'id') : ('SHIFT', 18),
+        (107, 'string') : ('SHIFT', 30),
+        (107, 'int') : ('SHIFT', 21),
+        (107, 'isvoid') : ('SHIFT', 27),
+        (107, 'let') : ('SHIFT', 8),
+        (107, 'if') : ('SHIFT', 24),
+        (107, 'case') : ('SHIFT', 25),
+        (107, 'new') : ('SHIFT', 22),
+        (107, 'true') : ('SHIFT', 28),
+        (107, 'while') : ('SHIFT', 20),
+        (107, '~') : ('SHIFT', 15),
+        (107, '(') : ('SHIFT', 13),
+        (107, 'not') : ('SHIFT', 26),
+        (108, '}') : ('REDUCE', 21),
+        (108, 'fi') : ('REDUCE', 21),
+        (108, 'in') : ('REDUCE', 21),
+        (108, ';') : ('REDUCE', 21),
+        (108, ')') : ('REDUCE', 21),
+        (108, 'then') : ('REDUCE', 21),
+        (108, 'of') : ('REDUCE', 21),
+        (108, 'loop') : ('REDUCE', 21),
+        (108, 'else') : ('REDUCE', 21),
+        (108, 'pool') : ('REDUCE', 21),
+        (108, ',') : ('REDUCE', 21),
+        (109, ';') : ('REDUCE', 9),
+        (110, 'id') : ('SHIFT', 111),
+        (110, ')') : ('REDUCE', 13),
+        (111, ':') : ('SHIFT', 112),
+        (112, 'type') : ('SHIFT', 113),
+        (113, ')') : ('REDUCE', 14),
+        (113, ',') : ('REDUCE', 14),
+        (114, ')') : ('SHIFT', 115),
+        (115, ':') : ('SHIFT', 116),
+        (116, 'type') : ('SHIFT', 117),
+        (117, '{') : ('SHIFT', 118),
+        (118, 'isvoid') : ('SHIFT', 27),
+        (118, 'id') : ('SHIFT', 18),
+        (118, 'let') : ('SHIFT', 8),
+        (118, 'new') : ('SHIFT', 22),
+        (118, 'true') : ('SHIFT', 28),
+        (118, 'while') : ('SHIFT', 20),
+        (118, '~') : ('SHIFT', 15),
+        (118, '(') : ('SHIFT', 13),
+        (118, 'not') : ('SHIFT', 26),
+        (118, 'int') : ('SHIFT', 21),
+        (118, '{') : ('SHIFT', 14),
+        (118, 'false') : ('SHIFT', 29),
+        (118, 'if') : ('SHIFT', 24),
+        (118, 'string') : ('SHIFT', 30),
+        (118, 'case') : ('SHIFT', 25),
+        (119, '}') : ('SHIFT', 120),
+        (120, ';') : ('REDUCE', 10),
+        (121, ')') : ('REDUCE', 11),
+        (121, ',') : ('SHIFT', 122),
+        (122, 'id') : ('SHIFT', 111),
+        (122, ')') : ('REDUCE', 13),
+        (123, ')') : ('REDUCE', 12),
+        (124, '}') : ('SHIFT', 125),
+        (125, ';') : ('REDUCE', 3),
+        (126, ';') : ('SHIFT', 127),
+        (127, 'id') : ('SHIFT', 4),
+        (127, '}') : ('REDUCE', 7),
+        (128, '}') : ('REDUCE', 5),
+        (129, ';') : ('SHIFT', 130),
+        (130, 'id') : ('SHIFT', 4),
+        (130, '}') : ('REDUCE', 7),
+        (131, '}') : ('REDUCE', 6),
+        (132, 'type') : ('SHIFT', 133),
+        (133, '{') : ('SHIFT', 134),
+        (134, '}') : ('REDUCE', 7),
+        (134, 'id') : ('SHIFT', 4),
+        (135, '}') : ('SHIFT', 136),
+        (136, ';') : ('REDUCE', 4),
+        (137, '$') : ('REDUCE', 0),
+        (141, '$') : ('OK', None),
+        (138, ';') : ('SHIFT', 139),
+        (139, '$') : ('REDUCE', 1),
+        (139, 'class') : ('SHIFT', 1),
+        (140, '$') : ('REDUCE', 2)
         }
 
 
 
 
         self.goto = {
-        (0, '<def-class>') : 137,
-        (0, '<program>'): 140,
-        (0, '<class-list>') : 136,
-        (3, '<feature-list>') : 123,
-        (3, '<def-attr>') : 125,
-        (3, '<def-meth>') : 128,
-        (7, '<arith>') : 59,
+        (0, '<class-list>') : 137,
+        (0, '<program>'): 141,
+        (0, '<def-class>') : 138,
+        (3, '<feature-list>') : 124,
+        (3, '<def-attr>') : 126,
+        (3, '<def-meth>') : 129,
         (7, '<comp>') : 38,
-        (7, '<factor>') : 48,
-        (7, '<term>') : 51,
         (7, '<atom>') : 32,
+        (7, '<term>') : 51,
+        (7, '<factor>') : 48,
+        (7, '<arith>') : 59,
+        (7, '<expr>') : 109,
         (7, '<dispatch>') : 45,
-        (7, '<expr>') : 108,
-        (8, '<id-list>') : 105,
-        (12, '<term>') : 51,
-        (12, '<factor>') : 48,
+        (7, '<boolean>') : 60,
+        (8, '<id-list>') : 106,
         (12, '<comp>') : 38,
-        (12, '<expr>') : 100,
+        (12, '<term>') : 51,
         (12, '<atom>') : 32,
-        (12, '<dispatch>') : 45,
+        (12, '<factor>') : 48,
         (12, '<arith>') : 59,
-        (13, '<term>') : 51,
+        (12, '<boolean>') : 60,
+        (12, '<expr>') : 101,
+        (12, '<dispatch>') : 45,
+        (13, '<expr>') : 99,
         (13, '<comp>') : 38,
-        (13, '<arith>') : 59,
+        (13, '<term>') : 51,
+        (13, '<boolean>') : 60,
         (13, '<atom>') : 32,
-        (13, '<dispatch>') : 45,
-        (13, '<expr>') : 98,
+        (13, '<arith>') : 59,
         (13, '<factor>') : 48,
-        (14, '<expr>') : 95,
-        (14, '<atom>') : 32,
-        (14, '<arith>') : 59,
+        (13, '<dispatch>') : 45,
         (14, '<comp>') : 38,
-        (14, '<factor>') : 48,
+        (14, '<atom>') : 32,
         (14, '<term>') : 51,
+        (14, '<factor>') : 48,
+        (14, '<arith>') : 59,
         (14, '<dispatch>') : 45,
-        (14, '<expr-list>') : 93,
-        (15, '<dispatch>') : 45,
-        (15, '<factor>') : 92,
+        (14, '<expr>') : 96,
+        (14, '<expr-list>') : 94,
+        (14, '<boolean>') : 60,
         (15, '<atom>') : 32,
-        (17, '<comp>') : 38,
-        (17, '<factor>') : 48,
+        (15, '<factor>') : 93,
+        (15, '<dispatch>') : 45,
         (17, '<term>') : 51,
-        (17, '<arith>') : 59,
+        (17, '<boolean>') : 60,
         (17, '<atom>') : 32,
-        (17, '<arg-list>') : 90,
-        (17, '<dispatch>') : 45,
+        (17, '<arg-list>') : 91,
+        (17, '<arith>') : 59,
+        (17, '<comp>') : 38,
         (17, '<expr>') : 56,
+        (17, '<factor>') : 48,
+        (17, '<dispatch>') : 45,
         (19, '<comp>') : 38,
         (19, '<term>') : 51,
-        (19, '<atom>') : 32,
+        (19, '<expr>') : 90,
         (19, '<arith>') : 59,
+        (19, '<atom>') : 32,
         (19, '<factor>') : 48,
-        (19, '<expr>') : 89,
+        (19, '<boolean>') : 60,
         (19, '<dispatch>') : 45,
-        (20, '<arith>') : 59,
-        (20, '<comp>') : 38,
         (20, '<atom>') : 32,
         (20, '<term>') : 51,
-        (20, '<factor>') : 48,
-        (20, '<expr>') : 85,
+        (20, '<comp>') : 38,
         (20, '<dispatch>') : 45,
+        (20, '<factor>') : 48,
+        (20, '<arith>') : 59,
+        (20, '<expr>') : 86,
+        (20, '<boolean>') : 60,
         (24, '<comp>') : 38,
-        (24, '<atom>') : 32,
         (24, '<term>') : 51,
-        (24, '<arith>') : 59,
-        (24, '<factor>') : 48,
-        (24, '<expr>') : 79,
+        (24, '<atom>') : 32,
+        (24, '<boolean>') : 60,
         (24, '<dispatch>') : 45,
+        (24, '<factor>') : 48,
+        (24, '<arith>') : 59,
+        (24, '<expr>') : 80,
+        (25, '<atom>') : 32,
         (25, '<arith>') : 59,
-        (25, '<term>') : 51,
+        (25, '<boolean>') : 60,
         (25, '<comp>') : 38,
-        (25, '<atom>') : 32,
-        (25, '<factor>') : 48,
+        (25, '<term>') : 51,
         (25, '<dispatch>') : 45,
-        (25, '<expr>') : 68,
-        (26, '<comp>') : 38,
+        (25, '<expr>') : 69,
+        (25, '<factor>') : 48,
+        (26, '<comp>') : 68,
         (26, '<term>') : 51,
-        (26, '<atom>') : 32,
-        (26, '<expr>') : 67,
         (26, '<arith>') : 59,
+        (26, '<atom>') : 32,
         (26, '<factor>') : 48,
         (26, '<dispatch>') : 45,
+        (27, '<atom>') : 32,
         (27, '<factor>') : 31,
         (27, '<dispatch>') : 45,
-        (27, '<atom>') : 32,
-        (35, '<comp>') : 38,
         (35, '<arg-list>') : 36,
-        (35, '<factor>') : 48,
         (35, '<term>') : 51,
-        (35, '<arith>') : 59,
+        (35, '<boolean>') : 60,
         (35, '<atom>') : 32,
-        (35, '<dispatch>') : 45,
+        (35, '<arith>') : 59,
+        (35, '<comp>') : 38,
         (35, '<expr>') : 56,
-        (39, '<arith>') : 40,
+        (35, '<factor>') : 48,
+        (35, '<dispatch>') : 45,
         (39, '<term>') : 51,
         (39, '<atom>') : 32,
         (39, '<factor>') : 48,
+        (39, '<arith>') : 40,
         (39, '<dispatch>') : 45,
         (41, '<term>') : 42,
         (41, '<atom>') : 32,
         (41, '<factor>') : 48,
         (41, '<dispatch>') : 45,
-        (43, '<dispatch>') : 45,
         (43, '<atom>') : 32,
         (43, '<factor>') : 44,
-        (46, '<dispatch>') : 45,
+        (43, '<dispatch>') : 45,
         (46, '<atom>') : 32,
         (46, '<factor>') : 47,
+        (46, '<dispatch>') : 45,
         (49, '<term>') : 50,
         (49, '<atom>') : 32,
         (49, '<factor>') : 48,
@@ -1193,91 +1210,100 @@ def __init__(self, G):
         (54, '<atom>') : 32,
         (54, '<factor>') : 48,
         (54, '<dispatch>') : 45,
-        (57, '<comp>') : 38,
-        (57, '<factor>') : 48,
         (57, '<term>') : 51,
-        (57, '<arith>') : 59,
+        (57, '<boolean>') : 60,
         (57, '<atom>') : 32,
+        (57, '<arith>') : 59,
+        (57, '<comp>') : 38,
+        (57, '<expr>') : 56,
+        (57, '<factor>') : 48,
         (57, '<arg-list>') : 58,
         (57, '<dispatch>') : 45,
-        (57, '<expr>') : 56,
-        (64, '<comp>') : 38,
-        (64, '<factor>') : 48,
-        (64, '<term>') : 51,
-        (64, '<arith>') : 59,
-        (64, '<atom>') : 32,
-        (64, '<dispatch>') : 45,
-        (64, '<expr>') : 56,
-        (64, '<arg-list>') : 65,
-        (69, '<case-list>') : 77,
-        (73, '<arith>') : 59,
-        (73, '<comp>') : 38,
-        (73, '<factor>') : 48,
-        (73, '<term>') : 51,
-        (73, '<atom>') : 32,
-        (73, '<expr>') : 74,
-        (73, '<dispatch>') : 45,
-        (75, '<case-list>') : 76,
-        (80, '<factor>') : 48,
-        (80, '<term>') : 51,
-        (80, '<arith>') : 59,
-        (80, '<atom>') : 32,
-        (80, '<comp>') : 38,
-        (80, '<dispatch>') : 45,
-        (80, '<expr>') : 81,
-        (82, '<atom>') : 32,
-        (82, '<comp>') : 38,
-        (82, '<arith>') : 59,
-        (82, '<term>') : 51,
-        (82, '<dispatch>') : 45,
-        (82, '<factor>') : 48,
-        (82, '<expr>') : 83,
-        (86, '<arith>') : 59,
-        (86, '<factor>') : 48,
-        (86, '<term>') : 51,
-        (86, '<comp>') : 38,
-        (86, '<atom>') : 32,
-        (86, '<dispatch>') : 45,
-        (86, '<expr>') : 87,
-        (96, '<expr>') : 95,
-        (96, '<arith>') : 59,
-        (96, '<comp>') : 38,
-        (96, '<factor>') : 48,
-        (96, '<term>') : 51,
-        (96, '<atom>') : 32,
-        (96, '<dispatch>') : 45,
-        (96, '<expr-list>') : 97,
-        (101, '<id-list>') : 102,
-        (103, '<id-list>') : 104,
-        (106, '<comp>') : 38,
-        (106, '<term>') : 51,
-        (106, '<atom>') : 32,
-        (106, '<arith>') : 59,
-        (106, '<factor>') : 48,
-        (106, '<dispatch>') : 45,
-        (106, '<expr>') : 107,
-        (109, '<param-list>') : 113,
-        (109, '<param>') : 120,
-        (117, '<term>') : 51,
-        (117, '<arith>') : 59,
-        (117, '<dispatch>') : 45,
-        (117, '<atom>') : 32,
-        (117, '<expr>') : 118,
-        (117, '<comp>') : 38,
-        (117, '<factor>') : 48,
-        (121, '<param>') : 120,
-        (121, '<param-list>') : 122,
-        (126, '<feature-list>') : 127,
-        (126, '<def-attr>') : 125,
-        (126, '<def-meth>') : 128,
-        (129, '<feature-list>') : 130,
-        (129, '<def-attr>') : 125,
-        (129, '<def-meth>') : 128,
-        (133, '<feature-list>') : 134,
-        (133, '<def-attr>') : 125,
-        (133, '<def-meth>') : 128,
-        (138, '<def-class>') : 137,
-        (138, '<class-list>') : 139
+        (65, '<term>') : 51,
+        (65, '<boolean>') : 60,
+        (65, '<atom>') : 32,
+        (65, '<arith>') : 59,
+        (65, '<comp>') : 38,
+        (65, '<arg-list>') : 66,
+        (65, '<expr>') : 56,
+        (65, '<factor>') : 48,
+        (65, '<dispatch>') : 45,
+        (70, '<case-list>') : 78,
+        (74, '<comp>') : 38,
+        (74, '<expr>') : 75,
+        (74, '<atom>') : 32,
+        (74, '<term>') : 51,
+        (74, '<factor>') : 48,
+        (74, '<arith>') : 59,
+        (74, '<dispatch>') : 45,
+        (74, '<boolean>') : 60,
+        (76, '<case-list>') : 77,
+        (81, '<term>') : 51,
+        (81, '<atom>') : 32,
+        (81, '<factor>') : 48,
+        (81, '<arith>') : 59,
+        (81, '<boolean>') : 60,
+        (81, '<comp>') : 38,
+        (81, '<expr>') : 82,
+        (81, '<dispatch>') : 45,
+        (83, '<arith>') : 59,
+        (83, '<atom>') : 32,
+        (83, '<comp>') : 38,
+        (83, '<term>') : 51,
+        (83, '<dispatch>') : 45,
+        (83, '<boolean>') : 60,
+        (83, '<factor>') : 48,
+        (83, '<expr>') : 84,
+        (87, '<expr>') : 88,
+        (87, '<comp>') : 38,
+        (87, '<arith>') : 59,
+        (87, '<boolean>') : 60,
+        (87, '<atom>') : 32,
+        (87, '<term>') : 51,
+        (87, '<factor>') : 48,
+        (87, '<dispatch>') : 45,
+        (97, '<comp>') : 38,
+        (97, '<atom>') : 32,
+        (97, '<term>') : 51,
+        (97, '<factor>') : 48,
+        (97, '<arith>') : 59,
+        (97, '<dispatch>') : 45,
+        (97, '<expr>') : 96,
+        (97, '<expr-list>') : 98,
+        (97, '<boolean>') : 60,
+        (102, '<id-list>') : 103,
+        (104, '<id-list>') : 105,
+        (107, '<comp>') : 38,
+        (107, '<term>') : 51,
+        (107, '<arith>') : 59,
+        (107, '<atom>') : 32,
+        (107, '<factor>') : 48,
+        (107, '<expr>') : 108,
+        (107, '<boolean>') : 60,
+        (107, '<dispatch>') : 45,
+        (110, '<param>') : 121,
+        (110, '<param-list>') : 114,
+        (118, '<arith>') : 59,
+        (118, '<atom>') : 32,
+        (118, '<term>') : 51,
+        (118, '<factor>') : 48,
+        (118, '<comp>') : 38,
+        (118, '<expr>') : 119,
+        (118, '<boolean>') : 60,
+        (118, '<dispatch>') : 45,
+        (122, '<param>') : 121,
+        (122, '<param-list>') : 123,
+        (127, '<def-attr>') : 126,
+        (127, '<feature-list>') : 128,
+        (127, '<def-meth>') : 129,
+        (130, '<def-attr>') : 126,
+        (130, '<feature-list>') : 131,
+        (130, '<def-meth>') : 129,
+        (134, '<def-attr>') : 126,
+        (134, '<def-meth>') : 129,
+        (134, '<feature-list>') : 135,
+        (139, '<def-class>') : 138,
+        (139, '<class-list>') : 140
         }
 
 
diff --git a/src/utils/parser/parser.py b/src/utils/parser/parser.py
index c94fbc8cc..40c08c4d2 100644
--- a/src/utils/parser/parser.py
+++ b/src/utils/parser/parser.py
@@ -1,7 +1,5 @@
 from cmp.utils import ContainerSet
-from cmp.pycompiler import Sentence
 from itertools import islice
-from collections import deque
 
 class Parser:
     def __init__(self,G):

From 32ca3c01c38ce57477ffdc9f4d1d6f0aaad7e9e4 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 22:26:40 -0800
Subject: [PATCH 31/83] updating

---
 src/main.py               |  8 ++++++--
 src/utils/COOL_Grammar.py | 10 ++++------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/main.py b/src/main.py
index afbd22b00..739e3dc5f 100644
--- a/src/main.py
+++ b/src/main.py
@@ -10,8 +10,10 @@
 from utils.semantic_check.type_builder import TypeBuilder
 from utils.semantic_check.type_checker import TypeChecker 
 
+from utils.parser.LALR_1 import LALR1_Parser
+
 if __name__ == "__main__":
-    add = "parser/operation3.cl"
+    add = "parser/mixed1.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -34,7 +36,9 @@
         raise Exception()
 
     # parser
-    parser = COOL_Parser(G)
+    #parser = COOL_Parser(G)
+
+    parser = LALR1_Parser(G)
         
     derivation, operations = parser(tokens)
     
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 3ce91bc26..0d8667ae8 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -11,7 +11,7 @@ def build_COOL_Grammar():
     feature_list, def_attr, def_meth, arg_list = G.NonTerminals('<feature-list> <def-attr> <def-meth> <arg-list>')
     expr, expr_list, id_list, case_list, comp = G.NonTerminals('<expr> <expr-list> <id-list> <case-list> <comp>')
     expr, arith, term, factor, atom, dispatch = G.NonTerminals('<expr> <arith> <term> <factor> <atom> <dispatch>')
-    boolean = G.NonTerminal('<boolean>')
+    not_empty = G.NonTerminal('<not_empty>')
 
     #terminales
     classx, let, inx = G.Terminals('class let in')
@@ -47,7 +47,6 @@ def build_COOL_Grammar():
     param %= idx + colon + typex, lambda h,s: [s[1],s[3]]
 
     expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3],s[2])
-    expr %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6],s[1])
     expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4],s[1])
     
 
@@ -68,10 +67,7 @@ def build_COOL_Grammar():
     case_list %= idx + colon + typex + darrow + expr + semi, lambda h,s: [(s[1],s[3],s[5])]
     case_list %= idx + colon + typex + darrow + expr + semi + case_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]
 
-    expr %= boolean, lambda h,s: s[1]
-
-    boolean %= comp, lambda h,s: s[1]
-    boolean %= notx + comp, lambda h,s: node.NotNode(s[2], s[1])
+    expr %= comp, lambda h,s: s[1]
 
     comp %= comp + less + arith, lambda h,s: node.LessThanNode(s[1],s[3],s[2])
     comp %= comp + lesse + arith, lambda h,s: node.LessEqualNode(s[1],s[3],s[2])
@@ -88,6 +84,7 @@ def build_COOL_Grammar():
 
     factor %= isvoid + factor, lambda h,s: node.IsVoidNode(s[2])
     factor %= tilde + factor, lambda h,s: node.ComplementNode(s[2], s[1])
+    factor %= notx + atom, lambda h,s: node.NotNode(s[2],s[1])
     factor %= atom, lambda h,s: s[1]
 
     atom %= true, lambda h,s: node.ConstantBoolNode(s[1])
@@ -96,6 +93,7 @@ def build_COOL_Grammar():
     atom %= num, lambda h,s: node.ConstantNumNode(s[1])
     atom %= idx, lambda h,s: node.VariableNode(s[1])
     atom %= new + typex, lambda h,s: node.InstantiateNode(s[2],s[1])
+    atom %= ifx + expr + then + expr + elsex + expr + fi, lambda h,s: node.IfThenElseNode(s[2],s[4],s[6],s[1])
     atom %= opar + expr + cpar, lambda h,s: s[2]
     atom %= dispatch, lambda h,s: s[1]
 

From 230b01ca13341207d258dfdd33b488d18abc51f0 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 22:59:57 -0800
Subject: [PATCH 32/83] lexer-parser ready

---
 src/main.py                     |    6 +-
 src/utils/COOL_Grammar.py       |    4 +-
 src/utils/parser/COOL_parser.py | 2394 ++++++++++++++++---------------
 3 files changed, 1203 insertions(+), 1201 deletions(-)

diff --git a/src/main.py b/src/main.py
index 739e3dc5f..c0d03122b 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "parser/mixed1.cl"
+    add = "parser/dispatch2.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -36,9 +36,7 @@
         raise Exception()
 
     # parser
-    #parser = COOL_Parser(G)
-
-    parser = LALR1_Parser(G)
+    parser = COOL_Parser(G)
         
     derivation, operations = parser(tokens)
     
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 0d8667ae8..93d3b7f18 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -41,7 +41,7 @@ def build_COOL_Grammar():
     def_meth %= idx + opar + param_list + cpar + colon + typex + ocur + expr + ccur, lambda h,s: node.MethDeclarationNode(s[1],s[3],s[6],s[8],s[7])
 
     param_list %= param, lambda h,s: [s[1]]
-    param_list %= param + comma + param_list, lambda h,s: [s[1]] + s[3]
+    param_list %= param_list + comma + param, lambda h,s: [s[1]] + s[3]
     param_list %= G.Epsilon, lambda h,s: []
 
     param %= idx + colon + typex, lambda h,s: [s[1],s[3]]
@@ -102,7 +102,7 @@ def build_COOL_Grammar():
     dispatch %= atom + at + typex + dot + idx + opar + arg_list + cpar, lambda h,s: node.CallNode(s[5],s[7],s[1],s[3])
 
     arg_list %= expr, lambda h,s: [s[1]]
-    arg_list %= expr + comma + arg_list, lambda h,s: [s[1]] + s[3]
+    arg_list %= arg_list + comma + expr, lambda h,s: [s[1]] + s[3]
     arg_list %= G.Epsilon, lambda h,s: []
 
     return G
\ No newline at end of file
diff --git a/src/utils/parser/COOL_parser.py b/src/utils/parser/COOL_parser.py
index c764f13da..418810cb8 100644
--- a/src/utils/parser/COOL_parser.py
+++ b/src/utils/parser/COOL_parser.py
@@ -23,1287 +23,1291 @@ def __init__(self, G):
         self.action = {
         (0, 'class') : ('SHIFT', 1),
         (1, 'type') : ('SHIFT', 2),
+        (2, 'inherits') : ('SHIFT', 131),
         (2, '{') : ('SHIFT', 3),
-        (2, 'inherits') : ('SHIFT', 132),
         (3, 'id') : ('SHIFT', 4),
         (3, '}') : ('REDUCE', 7),
+        (4, '(') : ('SHIFT', 109),
         (4, ':') : ('SHIFT', 5),
-        (4, '(') : ('SHIFT', 110),
         (5, 'type') : ('SHIFT', 6),
-        (6, ';') : ('REDUCE', 8),
         (6, '<-') : ('SHIFT', 7),
-        (7, 'isvoid') : ('SHIFT', 27),
-        (7, '{') : ('SHIFT', 14),
+        (6, ';') : ('REDUCE', 8),
+        (7, 'true') : ('SHIFT', 27),
+        (7, 'not') : ('SHIFT', 26),
+        (7, 'case') : ('SHIFT', 25),
         (7, '(') : ('SHIFT', 13),
         (7, 'let') : ('SHIFT', 8),
-        (7, 'if') : ('SHIFT', 24),
-        (7, 'case') : ('SHIFT', 25),
-        (7, 'id') : ('SHIFT', 18),
-        (7, 'false') : ('SHIFT', 29),
-        (7, 'int') : ('SHIFT', 21),
-        (7, 'string') : ('SHIFT', 30),
+        (7, 'string') : ('SHIFT', 29),
         (7, 'while') : ('SHIFT', 20),
+        (7, 'false') : ('SHIFT', 28),
+        (7, 'isvoid') : ('SHIFT', 34),
+        (7, 'id') : ('SHIFT', 18),
+        (7, 'if') : ('SHIFT', 24),
+        (7, '{') : ('SHIFT', 14),
         (7, '~') : ('SHIFT', 15),
         (7, 'new') : ('SHIFT', 22),
-        (7, 'true') : ('SHIFT', 28),
-        (7, 'not') : ('SHIFT', 26),
+        (7, 'int') : ('SHIFT', 21),
         (8, 'id') : ('SHIFT', 9),
         (9, ':') : ('SHIFT', 10),
         (10, 'type') : ('SHIFT', 11),
-        (11, 'in') : ('REDUCE', 22),
+        (11, ',') : ('SHIFT', 103),
         (11, '<-') : ('SHIFT', 12),
-        (11, ',') : ('SHIFT', 104),
-        (12, 'isvoid') : ('SHIFT', 27),
-        (12, '(') : ('SHIFT', 13),
-        (12, 'not') : ('SHIFT', 26),
-        (12, 'false') : ('SHIFT', 29),
+        (11, 'in') : ('REDUCE', 21),
         (12, 'id') : ('SHIFT', 18),
         (12, 'int') : ('SHIFT', 21),
+        (12, 'not') : ('SHIFT', 26),
+        (12, 'true') : ('SHIFT', 27),
+        (12, '(') : ('SHIFT', 13),
         (12, '{') : ('SHIFT', 14),
-        (12, 'string') : ('SHIFT', 30),
-        (12, 'if') : ('SHIFT', 24),
-        (12, 'let') : ('SHIFT', 8),
+        (12, 'string') : ('SHIFT', 29),
         (12, 'case') : ('SHIFT', 25),
+        (12, 'false') : ('SHIFT', 28),
+        (12, 'let') : ('SHIFT', 8),
+        (12, 'while') : ('SHIFT', 20),
+        (12, 'isvoid') : ('SHIFT', 34),
         (12, '~') : ('SHIFT', 15),
+        (12, 'if') : ('SHIFT', 24),
         (12, 'new') : ('SHIFT', 22),
-        (12, 'true') : ('SHIFT', 28),
-        (12, 'while') : ('SHIFT', 20),
-        (13, 'while') : ('SHIFT', 20),
+        (13, 'id') : ('SHIFT', 18),
+        (13, 'case') : ('SHIFT', 25),
+        (13, 'if') : ('SHIFT', 24),
+        (13, 'let') : ('SHIFT', 8),
         (13, '~') : ('SHIFT', 15),
+        (13, 'while') : ('SHIFT', 20),
         (13, 'new') : ('SHIFT', 22),
-        (13, 'true') : ('SHIFT', 28),
         (13, 'not') : ('SHIFT', 26),
-        (13, 'isvoid') : ('SHIFT', 27),
+        (13, 'int') : ('SHIFT', 21),
+        (13, 'true') : ('SHIFT', 27),
         (13, '(') : ('SHIFT', 13),
+        (13, 'string') : ('SHIFT', 29),
+        (13, 'false') : ('SHIFT', 28),
         (13, '{') : ('SHIFT', 14),
-        (13, 'let') : ('SHIFT', 8),
-        (13, 'if') : ('SHIFT', 24),
-        (13, 'id') : ('SHIFT', 18),
-        (13, 'case') : ('SHIFT', 25),
-        (13, 'false') : ('SHIFT', 29),
-        (13, 'string') : ('SHIFT', 30),
-        (13, 'int') : ('SHIFT', 21),
-        (14, 'isvoid') : ('SHIFT', 27),
-        (14, '{') : ('SHIFT', 14),
+        (13, 'isvoid') : ('SHIFT', 34),
+        (14, 'true') : ('SHIFT', 27),
+        (14, 'not') : ('SHIFT', 26),
+        (14, 'case') : ('SHIFT', 25),
         (14, '(') : ('SHIFT', 13),
         (14, 'let') : ('SHIFT', 8),
-        (14, 'if') : ('SHIFT', 24),
-        (14, 'case') : ('SHIFT', 25),
+        (14, 'while') : ('SHIFT', 20),
+        (14, 'string') : ('SHIFT', 29),
+        (14, 'false') : ('SHIFT', 28),
+        (14, 'isvoid') : ('SHIFT', 34),
         (14, 'id') : ('SHIFT', 18),
-        (14, 'false') : ('SHIFT', 29),
+        (14, 'if') : ('SHIFT', 24),
         (14, 'int') : ('SHIFT', 21),
-        (14, 'string') : ('SHIFT', 30),
-        (14, 'while') : ('SHIFT', 20),
+        (14, '{') : ('SHIFT', 14),
         (14, '~') : ('SHIFT', 15),
         (14, 'new') : ('SHIFT', 22),
-        (14, 'true') : ('SHIFT', 28),
-        (14, 'not') : ('SHIFT', 26),
-        (15, 'false') : ('SHIFT', 29),
         (15, 'id') : ('SHIFT', 16),
+        (15, 'string') : ('SHIFT', 29),
+        (15, 'if') : ('SHIFT', 24),
+        (15, '~') : ('SHIFT', 15),
+        (15, 'false') : ('SHIFT', 28),
         (15, 'new') : ('SHIFT', 22),
         (15, 'int') : ('SHIFT', 21),
-        (15, 'string') : ('SHIFT', 30),
-        (15, 'isvoid') : ('SHIFT', 27),
-        (15, 'true') : ('SHIFT', 28),
-        (15, '~') : ('SHIFT', 15),
+        (15, 'not') : ('SHIFT', 26),
+        (15, 'isvoid') : ('SHIFT', 34),
+        (15, 'true') : ('SHIFT', 27),
         (15, '(') : ('SHIFT', 13),
-        (16, 'fi') : ('REDUCE', 49),
-        (16, '=') : ('REDUCE', 49),
-        (16, '+') : ('REDUCE', 49),
-        (16, '-') : ('REDUCE', 49),
-        (16, 'of') : ('REDUCE', 49),
-        (16, '*') : ('REDUCE', 49),
-        (16, '/') : ('REDUCE', 49),
-        (16, '<') : ('REDUCE', 49),
-        (16, '<=') : ('REDUCE', 49),
-        (16, '@') : ('REDUCE', 49),
-        (16, 'in') : ('REDUCE', 49),
-        (16, ';') : ('REDUCE', 49),
-        (16, 'loop') : ('REDUCE', 49),
-        (16, 'pool') : ('REDUCE', 49),
-        (16, ',') : ('REDUCE', 49),
-        (16, '.') : ('REDUCE', 49),
-        (16, ')') : ('REDUCE', 49),
-        (16, 'then') : ('REDUCE', 49),
-        (16, 'else') : ('REDUCE', 49),
-        (16, '}') : ('REDUCE', 49),
+        (16, '/') : ('REDUCE', 47),
+        (16, '<') : ('REDUCE', 47),
+        (16, '<=') : ('REDUCE', 47),
+        (16, '@') : ('REDUCE', 47),
+        (16, 'in') : ('REDUCE', 47),
+        (16, ';') : ('REDUCE', 47),
+        (16, 'loop') : ('REDUCE', 47),
+        (16, 'pool') : ('REDUCE', 47),
+        (16, ',') : ('REDUCE', 47),
+        (16, '.') : ('REDUCE', 47),
+        (16, ')') : ('REDUCE', 47),
+        (16, 'then') : ('REDUCE', 47),
+        (16, 'else') : ('REDUCE', 47),
+        (16, '}') : ('REDUCE', 47),
+        (16, 'fi') : ('REDUCE', 47),
+        (16, '=') : ('REDUCE', 47),
+        (16, '+') : ('REDUCE', 47),
+        (16, 'of') : ('REDUCE', 47),
+        (16, '-') : ('REDUCE', 47),
+        (16, '*') : ('REDUCE', 47),
         (16, '(') : ('SHIFT', 17),
-        (17, ')') : ('REDUCE', 58),
-        (17, '~') : ('SHIFT', 15),
-        (17, 'id') : ('SHIFT', 18),
-        (17, 'new') : ('SHIFT', 22),
-        (17, '{') : ('SHIFT', 14),
-        (17, 'true') : ('SHIFT', 28),
-        (17, 'let') : ('SHIFT', 8),
         (17, 'if') : ('SHIFT', 24),
+        (17, '{') : ('SHIFT', 14),
+        (17, 'new') : ('SHIFT', 22),
+        (17, 'int') : ('SHIFT', 21),
+        (17, 'isvoid') : ('SHIFT', 34),
+        (17, 'true') : ('SHIFT', 27),
         (17, 'case') : ('SHIFT', 25),
-        (17, 'string') : ('SHIFT', 30),
-        (17, 'isvoid') : ('SHIFT', 27),
-        (17, 'while') : ('SHIFT', 20),
         (17, '(') : ('SHIFT', 13),
-        (17, 'false') : ('SHIFT', 29),
-        (17, 'int') : ('SHIFT', 21),
+        (17, 'string') : ('SHIFT', 29),
+        (17, 'let') : ('SHIFT', 8),
+        (17, 'while') : ('SHIFT', 20),
+        (17, ',') : ('REDUCE', 57),
+        (17, ')') : ('REDUCE', 57),
+        (17, '~') : ('SHIFT', 15),
+        (17, 'false') : ('SHIFT', 28),
         (17, 'not') : ('SHIFT', 26),
+        (17, 'id') : ('SHIFT', 18),
         (18, '<-') : ('SHIFT', 19),
-        (18, 'fi') : ('REDUCE', 49),
-        (18, '=') : ('REDUCE', 49),
-        (18, '+') : ('REDUCE', 49),
-        (18, '-') : ('REDUCE', 49),
-        (18, 'of') : ('REDUCE', 49),
-        (18, '*') : ('REDUCE', 49),
-        (18, '/') : ('REDUCE', 49),
-        (18, '<') : ('REDUCE', 49),
-        (18, '<=') : ('REDUCE', 49),
-        (18, '@') : ('REDUCE', 49),
-        (18, 'in') : ('REDUCE', 49),
-        (18, ';') : ('REDUCE', 49),
-        (18, 'loop') : ('REDUCE', 49),
-        (18, 'pool') : ('REDUCE', 49),
-        (18, ',') : ('REDUCE', 49),
-        (18, '.') : ('REDUCE', 49),
-        (18, ')') : ('REDUCE', 49),
-        (18, 'then') : ('REDUCE', 49),
-        (18, 'else') : ('REDUCE', 49),
-        (18, '}') : ('REDUCE', 49),
+        (18, '/') : ('REDUCE', 47),
+        (18, '<') : ('REDUCE', 47),
+        (18, '<=') : ('REDUCE', 47),
+        (18, '@') : ('REDUCE', 47),
+        (18, 'in') : ('REDUCE', 47),
+        (18, ';') : ('REDUCE', 47),
+        (18, 'loop') : ('REDUCE', 47),
+        (18, 'pool') : ('REDUCE', 47),
+        (18, ',') : ('REDUCE', 47),
+        (18, '.') : ('REDUCE', 47),
+        (18, ')') : ('REDUCE', 47),
+        (18, 'then') : ('REDUCE', 47),
+        (18, 'else') : ('REDUCE', 47),
+        (18, '}') : ('REDUCE', 47),
+        (18, 'fi') : ('REDUCE', 47),
+        (18, '=') : ('REDUCE', 47),
+        (18, '+') : ('REDUCE', 47),
+        (18, 'of') : ('REDUCE', 47),
+        (18, '-') : ('REDUCE', 47),
+        (18, '*') : ('REDUCE', 47),
         (18, '(') : ('SHIFT', 17),
-        (19, 'false') : ('SHIFT', 29),
-        (19, '{') : ('SHIFT', 14),
+        (19, 'string') : ('SHIFT', 29),
+        (19, 'false') : ('SHIFT', 28),
         (19, 'id') : ('SHIFT', 18),
-        (19, 'string') : ('SHIFT', 30),
-        (19, 'int') : ('SHIFT', 21),
-        (19, 'isvoid') : ('SHIFT', 27),
-        (19, 'let') : ('SHIFT', 8),
+        (19, 'isvoid') : ('SHIFT', 34),
+        (19, '{') : ('SHIFT', 14),
         (19, 'if') : ('SHIFT', 24),
+        (19, '~') : ('SHIFT', 15),
         (19, 'case') : ('SHIFT', 25),
         (19, 'new') : ('SHIFT', 22),
-        (19, 'true') : ('SHIFT', 28),
+        (19, 'let') : ('SHIFT', 8),
+        (19, 'int') : ('SHIFT', 21),
         (19, 'while') : ('SHIFT', 20),
-        (19, '~') : ('SHIFT', 15),
-        (19, '(') : ('SHIFT', 13),
         (19, 'not') : ('SHIFT', 26),
-        (20, 'isvoid') : ('SHIFT', 27),
-        (20, 'if') : ('SHIFT', 24),
-        (20, 'let') : ('SHIFT', 8),
-        (20, 'case') : ('SHIFT', 25),
+        (19, 'true') : ('SHIFT', 27),
+        (19, '(') : ('SHIFT', 13),
         (20, 'id') : ('SHIFT', 18),
-        (20, 'false') : ('SHIFT', 29),
-        (20, 'string') : ('SHIFT', 30),
+        (20, 'new') : ('SHIFT', 22),
+        (20, '{') : ('SHIFT', 14),
         (20, 'int') : ('SHIFT', 21),
+        (20, 'true') : ('SHIFT', 27),
+        (20, '(') : ('SHIFT', 13),
+        (20, 'string') : ('SHIFT', 29),
+        (20, 'if') : ('SHIFT', 24),
+        (20, 'case') : ('SHIFT', 25),
+        (20, 'let') : ('SHIFT', 8),
+        (20, 'isvoid') : ('SHIFT', 34),
         (20, 'while') : ('SHIFT', 20),
-        (20, 'new') : ('SHIFT', 22),
-        (20, 'true') : ('SHIFT', 28),
+        (20, 'false') : ('SHIFT', 28),
         (20, '~') : ('SHIFT', 15),
         (20, 'not') : ('SHIFT', 26),
-        (20, '(') : ('SHIFT', 13),
-        (20, '{') : ('SHIFT', 14),
-        (21, 'fi') : ('REDUCE', 48),
-        (21, '=') : ('REDUCE', 48),
-        (21, '+') : ('REDUCE', 48),
-        (21, '-') : ('REDUCE', 48),
-        (21, 'of') : ('REDUCE', 48),
-        (21, '*') : ('REDUCE', 48),
-        (21, '/') : ('REDUCE', 48),
-        (21, '<') : ('REDUCE', 48),
-        (21, '<=') : ('REDUCE', 48),
-        (21, '@') : ('REDUCE', 48),
-        (21, 'in') : ('REDUCE', 48),
-        (21, ';') : ('REDUCE', 48),
-        (21, 'loop') : ('REDUCE', 48),
-        (21, 'pool') : ('REDUCE', 48),
-        (21, ',') : ('REDUCE', 48),
-        (21, '.') : ('REDUCE', 48),
-        (21, ')') : ('REDUCE', 48),
-        (21, 'then') : ('REDUCE', 48),
-        (21, 'else') : ('REDUCE', 48),
-        (21, '}') : ('REDUCE', 48),
+        (21, '/') : ('REDUCE', 46),
+        (21, '<') : ('REDUCE', 46),
+        (21, '<=') : ('REDUCE', 46),
+        (21, '@') : ('REDUCE', 46),
+        (21, 'in') : ('REDUCE', 46),
+        (21, ';') : ('REDUCE', 46),
+        (21, 'loop') : ('REDUCE', 46),
+        (21, 'pool') : ('REDUCE', 46),
+        (21, ',') : ('REDUCE', 46),
+        (21, '.') : ('REDUCE', 46),
+        (21, ')') : ('REDUCE', 46),
+        (21, 'then') : ('REDUCE', 46),
+        (21, 'else') : ('REDUCE', 46),
+        (21, '}') : ('REDUCE', 46),
+        (21, 'fi') : ('REDUCE', 46),
+        (21, '=') : ('REDUCE', 46),
+        (21, '+') : ('REDUCE', 46),
+        (21, 'of') : ('REDUCE', 46),
+        (21, '-') : ('REDUCE', 46),
+        (21, '*') : ('REDUCE', 46),
         (22, 'type') : ('SHIFT', 23),
-        (23, 'fi') : ('REDUCE', 50),
-        (23, '=') : ('REDUCE', 50),
-        (23, '+') : ('REDUCE', 50),
-        (23, '-') : ('REDUCE', 50),
-        (23, 'of') : ('REDUCE', 50),
-        (23, '*') : ('REDUCE', 50),
-        (23, '/') : ('REDUCE', 50),
-        (23, '<') : ('REDUCE', 50),
-        (23, '<=') : ('REDUCE', 50),
-        (23, '@') : ('REDUCE', 50),
-        (23, 'in') : ('REDUCE', 50),
-        (23, ';') : ('REDUCE', 50),
-        (23, 'loop') : ('REDUCE', 50),
-        (23, 'pool') : ('REDUCE', 50),
-        (23, ',') : ('REDUCE', 50),
-        (23, '.') : ('REDUCE', 50),
-        (23, ')') : ('REDUCE', 50),
-        (23, 'then') : ('REDUCE', 50),
-        (23, 'else') : ('REDUCE', 50),
-        (23, '}') : ('REDUCE', 50),
-        (24, 'isvoid') : ('SHIFT', 27),
+        (23, '/') : ('REDUCE', 48),
+        (23, '<') : ('REDUCE', 48),
+        (23, '<=') : ('REDUCE', 48),
+        (23, '@') : ('REDUCE', 48),
+        (23, 'in') : ('REDUCE', 48),
+        (23, ';') : ('REDUCE', 48),
+        (23, 'loop') : ('REDUCE', 48),
+        (23, 'pool') : ('REDUCE', 48),
+        (23, ',') : ('REDUCE', 48),
+        (23, '.') : ('REDUCE', 48),
+        (23, ')') : ('REDUCE', 48),
+        (23, 'then') : ('REDUCE', 48),
+        (23, 'else') : ('REDUCE', 48),
+        (23, '}') : ('REDUCE', 48),
+        (23, 'fi') : ('REDUCE', 48),
+        (23, '=') : ('REDUCE', 48),
+        (23, '+') : ('REDUCE', 48),
+        (23, 'of') : ('REDUCE', 48),
+        (23, '-') : ('REDUCE', 48),
+        (23, '*') : ('REDUCE', 48),
         (24, '(') : ('SHIFT', 13),
-        (24, 'not') : ('SHIFT', 26),
-        (24, '{') : ('SHIFT', 14),
-        (24, 'false') : ('SHIFT', 29),
         (24, 'id') : ('SHIFT', 18),
-        (24, 'int') : ('SHIFT', 21),
-        (24, 'string') : ('SHIFT', 30),
-        (24, 'if') : ('SHIFT', 24),
-        (24, 'let') : ('SHIFT', 8),
-        (24, 'case') : ('SHIFT', 25),
-        (24, 'new') : ('SHIFT', 22),
-        (24, 'true') : ('SHIFT', 28),
+        (24, 'string') : ('SHIFT', 29),
         (24, '~') : ('SHIFT', 15),
+        (24, '{') : ('SHIFT', 14),
+        (24, 'not') : ('SHIFT', 26),
+        (24, 'false') : ('SHIFT', 28),
+        (24, 'case') : ('SHIFT', 25),
+        (24, 'let') : ('SHIFT', 8),
         (24, 'while') : ('SHIFT', 20),
-        (25, 'not') : ('SHIFT', 26),
-        (25, 'true') : ('SHIFT', 28),
-        (25, '{') : ('SHIFT', 14),
-        (25, '~') : ('SHIFT', 15),
+        (24, 'if') : ('SHIFT', 24),
+        (24, 'isvoid') : ('SHIFT', 34),
+        (24, 'new') : ('SHIFT', 22),
+        (24, 'int') : ('SHIFT', 21),
+        (24, 'true') : ('SHIFT', 27),
+        (25, 'isvoid') : ('SHIFT', 34),
+        (25, 'id') : ('SHIFT', 18),
+        (25, 'case') : ('SHIFT', 25),
         (25, 'let') : ('SHIFT', 8),
         (25, 'if') : ('SHIFT', 24),
-        (25, 'case') : ('SHIFT', 25),
-        (25, 'id') : ('SHIFT', 18),
-        (25, '(') : ('SHIFT', 13),
-        (25, 'new') : ('SHIFT', 22),
         (25, 'while') : ('SHIFT', 20),
-        (25, 'isvoid') : ('SHIFT', 27),
-        (25, 'false') : ('SHIFT', 29),
+        (25, '~') : ('SHIFT', 15),
+        (25, 'new') : ('SHIFT', 22),
         (25, 'int') : ('SHIFT', 21),
-        (25, 'string') : ('SHIFT', 30),
-        (26, 'false') : ('SHIFT', 29),
+        (25, 'not') : ('SHIFT', 26),
+        (25, 'true') : ('SHIFT', 27),
+        (25, '(') : ('SHIFT', 13),
+        (25, 'string') : ('SHIFT', 29),
+        (25, 'false') : ('SHIFT', 28),
+        (25, '{') : ('SHIFT', 14),
         (26, 'id') : ('SHIFT', 16),
+        (26, 'false') : ('SHIFT', 28),
+        (26, 'string') : ('SHIFT', 29),
+        (26, 'new') : ('SHIFT', 22),
         (26, 'int') : ('SHIFT', 21),
-        (26, 'string') : ('SHIFT', 30),
-        (26, 'isvoid') : ('SHIFT', 27),
-        (26, '~') : ('SHIFT', 15),
+        (26, 'if') : ('SHIFT', 24),
+        (26, 'true') : ('SHIFT', 27),
         (26, '(') : ('SHIFT', 13),
-        (26, 'new') : ('SHIFT', 22),
-        (26, 'true') : ('SHIFT', 28),
-        (27, 'false') : ('SHIFT', 29),
-        (27, 'id') : ('SHIFT', 16),
-        (27, 'new') : ('SHIFT', 22),
-        (27, 'int') : ('SHIFT', 21),
-        (27, 'string') : ('SHIFT', 30),
-        (27, 'isvoid') : ('SHIFT', 27),
-        (27, 'true') : ('SHIFT', 28),
-        (27, '~') : ('SHIFT', 15),
-        (27, '(') : ('SHIFT', 13),
-        (28, 'fi') : ('REDUCE', 45),
-        (28, '=') : ('REDUCE', 45),
-        (28, '+') : ('REDUCE', 45),
-        (28, '-') : ('REDUCE', 45),
-        (28, 'of') : ('REDUCE', 45),
-        (28, '*') : ('REDUCE', 45),
-        (28, '/') : ('REDUCE', 45),
-        (28, '<') : ('REDUCE', 45),
-        (28, '<=') : ('REDUCE', 45),
-        (28, '@') : ('REDUCE', 45),
-        (28, 'in') : ('REDUCE', 45),
-        (28, ';') : ('REDUCE', 45),
-        (28, 'loop') : ('REDUCE', 45),
-        (28, 'pool') : ('REDUCE', 45),
-        (28, ',') : ('REDUCE', 45),
-        (28, '.') : ('REDUCE', 45),
-        (28, ')') : ('REDUCE', 45),
-        (28, 'then') : ('REDUCE', 45),
-        (28, 'else') : ('REDUCE', 45),
-        (28, '}') : ('REDUCE', 45),
-        (29, 'fi') : ('REDUCE', 46),
-        (29, '=') : ('REDUCE', 46),
-        (29, '+') : ('REDUCE', 46),
-        (29, '-') : ('REDUCE', 46),
-        (29, 'of') : ('REDUCE', 46),
-        (29, '*') : ('REDUCE', 46),
-        (29, '/') : ('REDUCE', 46),
-        (29, '<') : ('REDUCE', 46),
-        (29, '<=') : ('REDUCE', 46),
-        (29, '@') : ('REDUCE', 46),
-        (29, 'in') : ('REDUCE', 46),
-        (29, ';') : ('REDUCE', 46),
-        (29, 'loop') : ('REDUCE', 46),
-        (29, 'pool') : ('REDUCE', 46),
-        (29, ',') : ('REDUCE', 46),
-        (29, '.') : ('REDUCE', 46),
-        (29, ')') : ('REDUCE', 46),
-        (29, 'then') : ('REDUCE', 46),
-        (29, 'else') : ('REDUCE', 46),
-        (29, '}') : ('REDUCE', 46),
-        (30, 'fi') : ('REDUCE', 47),
-        (30, '=') : ('REDUCE', 47),
-        (30, '+') : ('REDUCE', 47),
-        (30, '-') : ('REDUCE', 47),
-        (30, 'of') : ('REDUCE', 47),
-        (30, '*') : ('REDUCE', 47),
-        (30, '/') : ('REDUCE', 47),
-        (30, '<') : ('REDUCE', 47),
-        (30, '<=') : ('REDUCE', 47),
-        (30, '@') : ('REDUCE', 47),
-        (30, 'in') : ('REDUCE', 47),
-        (30, ';') : ('REDUCE', 47),
-        (30, 'loop') : ('REDUCE', 47),
-        (30, 'pool') : ('REDUCE', 47),
-        (30, ',') : ('REDUCE', 47),
-        (30, '.') : ('REDUCE', 47),
-        (30, ')') : ('REDUCE', 47),
-        (30, 'then') : ('REDUCE', 47),
-        (30, 'else') : ('REDUCE', 47),
-        (30, '}') : ('REDUCE', 47),
-        (31, '/') : ('REDUCE', 42),
-        (31, '}') : ('REDUCE', 42),
-        (31, 'fi') : ('REDUCE', 42),
-        (31, 'in') : ('REDUCE', 42),
-        (31, '<') : ('REDUCE', 42),
-        (31, '=') : ('REDUCE', 42),
-        (31, ';') : ('REDUCE', 42),
-        (31, '<=') : ('REDUCE', 42),
-        (31, '+') : ('REDUCE', 42),
-        (31, 'else') : ('REDUCE', 42),
-        (31, ')') : ('REDUCE', 42),
-        (31, '-') : ('REDUCE', 42),
-        (31, 'then') : ('REDUCE', 42),
-        (31, 'of') : ('REDUCE', 42),
-        (31, 'loop') : ('REDUCE', 42),
-        (31, '*') : ('REDUCE', 42),
-        (31, 'pool') : ('REDUCE', 42),
-        (31, ',') : ('REDUCE', 42),
-        (32, '@') : ('SHIFT', 61),
-        (32, '.') : ('SHIFT', 33),
-        (32, '/') : ('REDUCE', 44),
-        (32, '}') : ('REDUCE', 44),
-        (32, 'fi') : ('REDUCE', 44),
-        (32, 'in') : ('REDUCE', 44),
-        (32, '<') : ('REDUCE', 44),
-        (32, '=') : ('REDUCE', 44),
-        (32, ';') : ('REDUCE', 44),
-        (32, '<=') : ('REDUCE', 44),
-        (32, '+') : ('REDUCE', 44),
-        (32, 'else') : ('REDUCE', 44),
-        (32, ')') : ('REDUCE', 44),
-        (32, '-') : ('REDUCE', 44),
-        (32, 'then') : ('REDUCE', 44),
-        (32, 'of') : ('REDUCE', 44),
-        (32, 'loop') : ('REDUCE', 44),
-        (32, '*') : ('REDUCE', 44),
-        (32, 'pool') : ('REDUCE', 44),
-        (32, ',') : ('REDUCE', 44),
-        (33, 'id') : ('SHIFT', 34),
-        (34, '(') : ('SHIFT', 35),
-        (35, ')') : ('REDUCE', 58),
-        (35, '~') : ('SHIFT', 15),
-        (35, 'id') : ('SHIFT', 18),
-        (35, 'new') : ('SHIFT', 22),
-        (35, '{') : ('SHIFT', 14),
-        (35, 'true') : ('SHIFT', 28),
-        (35, 'let') : ('SHIFT', 8),
-        (35, 'if') : ('SHIFT', 24),
-        (35, 'case') : ('SHIFT', 25),
-        (35, 'string') : ('SHIFT', 30),
-        (35, 'isvoid') : ('SHIFT', 27),
-        (35, 'while') : ('SHIFT', 20),
-        (35, '(') : ('SHIFT', 13),
-        (35, 'false') : ('SHIFT', 29),
-        (35, 'int') : ('SHIFT', 21),
-        (35, 'not') : ('SHIFT', 26),
-        (36, ')') : ('SHIFT', 37),
-        (37, 'fi') : ('REDUCE', 53),
-        (37, '=') : ('REDUCE', 53),
-        (37, '+') : ('REDUCE', 53),
-        (37, '-') : ('REDUCE', 53),
-        (37, 'of') : ('REDUCE', 53),
-        (37, '*') : ('REDUCE', 53),
-        (37, '/') : ('REDUCE', 53),
-        (37, '<') : ('REDUCE', 53),
-        (37, '<=') : ('REDUCE', 53),
-        (37, '@') : ('REDUCE', 53),
-        (37, 'in') : ('REDUCE', 53),
-        (37, ';') : ('REDUCE', 53),
-        (37, 'loop') : ('REDUCE', 53),
-        (37, 'pool') : ('REDUCE', 53),
-        (37, ',') : ('REDUCE', 53),
-        (37, '.') : ('REDUCE', 53),
-        (37, ')') : ('REDUCE', 53),
-        (37, 'then') : ('REDUCE', 53),
-        (37, 'else') : ('REDUCE', 53),
-        (37, '}') : ('REDUCE', 53),
-        (38, 'pool') : ('REDUCE', 30),
-        (38, 'fi') : ('REDUCE', 30),
-        (38, 'in') : ('REDUCE', 30),
-        (38, ';') : ('REDUCE', 30),
-        (38, ')') : ('REDUCE', 30),
-        (38, 'then') : ('REDUCE', 30),
-        (38, 'of') : ('REDUCE', 30),
-        (38, 'loop') : ('REDUCE', 30),
-        (38, 'else') : ('REDUCE', 30),
-        (38, '}') : ('REDUCE', 30),
-        (38, ',') : ('REDUCE', 30),
-        (38, '<=') : ('SHIFT', 54),
-        (38, '<') : ('SHIFT', 52),
-        (38, '=') : ('SHIFT', 39),
-        (39, 'false') : ('SHIFT', 29),
-        (39, 'id') : ('SHIFT', 16),
-        (39, 'string') : ('SHIFT', 30),
-        (39, 'int') : ('SHIFT', 21),
-        (39, 'isvoid') : ('SHIFT', 27),
-        (39, '~') : ('SHIFT', 15),
-        (39, '(') : ('SHIFT', 13),
-        (39, 'new') : ('SHIFT', 22),
-        (39, 'true') : ('SHIFT', 28),
-        (40, '}') : ('REDUCE', 34),
-        (40, 'fi') : ('REDUCE', 34),
-        (40, 'in') : ('REDUCE', 34),
-        (40, '<') : ('REDUCE', 34),
-        (40, '=') : ('REDUCE', 34),
-        (40, ';') : ('REDUCE', 34),
-        (40, '<=') : ('REDUCE', 34),
-        (40, ')') : ('REDUCE', 34),
-        (40, 'then') : ('REDUCE', 34),
-        (40, 'loop') : ('REDUCE', 34),
-        (40, 'of') : ('REDUCE', 34),
-        (40, 'else') : ('REDUCE', 34),
-        (40, 'pool') : ('REDUCE', 34),
-        (40, ',') : ('REDUCE', 34),
-        (40, '-') : ('SHIFT', 49),
-        (40, '+') : ('SHIFT', 41),
-        (41, 'false') : ('SHIFT', 29),
-        (41, 'id') : ('SHIFT', 16),
+        (27, '/') : ('REDUCE', 43),
+        (27, '<') : ('REDUCE', 43),
+        (27, '<=') : ('REDUCE', 43),
+        (27, '@') : ('REDUCE', 43),
+        (27, 'in') : ('REDUCE', 43),
+        (27, ';') : ('REDUCE', 43),
+        (27, 'loop') : ('REDUCE', 43),
+        (27, 'pool') : ('REDUCE', 43),
+        (27, ',') : ('REDUCE', 43),
+        (27, '.') : ('REDUCE', 43),
+        (27, ')') : ('REDUCE', 43),
+        (27, 'then') : ('REDUCE', 43),
+        (27, 'else') : ('REDUCE', 43),
+        (27, '}') : ('REDUCE', 43),
+        (27, 'fi') : ('REDUCE', 43),
+        (27, '=') : ('REDUCE', 43),
+        (27, '+') : ('REDUCE', 43),
+        (27, 'of') : ('REDUCE', 43),
+        (27, '-') : ('REDUCE', 43),
+        (27, '*') : ('REDUCE', 43),
+        (28, '/') : ('REDUCE', 44),
+        (28, '<') : ('REDUCE', 44),
+        (28, '<=') : ('REDUCE', 44),
+        (28, '@') : ('REDUCE', 44),
+        (28, 'in') : ('REDUCE', 44),
+        (28, ';') : ('REDUCE', 44),
+        (28, 'loop') : ('REDUCE', 44),
+        (28, 'pool') : ('REDUCE', 44),
+        (28, ',') : ('REDUCE', 44),
+        (28, '.') : ('REDUCE', 44),
+        (28, ')') : ('REDUCE', 44),
+        (28, 'then') : ('REDUCE', 44),
+        (28, 'else') : ('REDUCE', 44),
+        (28, '}') : ('REDUCE', 44),
+        (28, 'fi') : ('REDUCE', 44),
+        (28, '=') : ('REDUCE', 44),
+        (28, '+') : ('REDUCE', 44),
+        (28, 'of') : ('REDUCE', 44),
+        (28, '-') : ('REDUCE', 44),
+        (28, '*') : ('REDUCE', 44),
+        (29, '/') : ('REDUCE', 45),
+        (29, '<') : ('REDUCE', 45),
+        (29, '<=') : ('REDUCE', 45),
+        (29, '@') : ('REDUCE', 45),
+        (29, 'in') : ('REDUCE', 45),
+        (29, ';') : ('REDUCE', 45),
+        (29, 'loop') : ('REDUCE', 45),
+        (29, 'pool') : ('REDUCE', 45),
+        (29, ',') : ('REDUCE', 45),
+        (29, '.') : ('REDUCE', 45),
+        (29, ')') : ('REDUCE', 45),
+        (29, 'then') : ('REDUCE', 45),
+        (29, 'else') : ('REDUCE', 45),
+        (29, '}') : ('REDUCE', 45),
+        (29, 'fi') : ('REDUCE', 45),
+        (29, '=') : ('REDUCE', 45),
+        (29, '+') : ('REDUCE', 45),
+        (29, 'of') : ('REDUCE', 45),
+        (29, '-') : ('REDUCE', 45),
+        (29, '*') : ('REDUCE', 45),
+        (30, ',') : ('REDUCE', 41),
+        (30, '/') : ('REDUCE', 41),
+        (30, 'fi') : ('REDUCE', 41),
+        (30, 'pool') : ('REDUCE', 41),
+        (30, '<') : ('REDUCE', 41),
+        (30, 'in') : ('REDUCE', 41),
+        (30, '=') : ('REDUCE', 41),
+        (30, '<=') : ('REDUCE', 41),
+        (30, ';') : ('REDUCE', 41),
+        (30, '+') : ('REDUCE', 41),
+        (30, '*') : ('REDUCE', 41),
+        (30, ')') : ('REDUCE', 41),
+        (30, 'of') : ('REDUCE', 41),
+        (30, 'then') : ('REDUCE', 41),
+        (30, '-') : ('REDUCE', 41),
+        (30, 'loop') : ('REDUCE', 41),
+        (30, 'else') : ('REDUCE', 41),
+        (30, '}') : ('REDUCE', 41),
+        (30, '.') : ('SHIFT', 31),
+        (30, '@') : ('SHIFT', 37),
+        (31, 'id') : ('SHIFT', 32),
+        (32, '(') : ('SHIFT', 33),
+        (33, 'if') : ('SHIFT', 24),
+        (33, '{') : ('SHIFT', 14),
+        (33, 'new') : ('SHIFT', 22),
+        (33, 'int') : ('SHIFT', 21),
+        (33, 'isvoid') : ('SHIFT', 34),
+        (33, 'true') : ('SHIFT', 27),
+        (33, 'case') : ('SHIFT', 25),
+        (33, '(') : ('SHIFT', 13),
+        (33, 'string') : ('SHIFT', 29),
+        (33, 'let') : ('SHIFT', 8),
+        (33, 'while') : ('SHIFT', 20),
+        (33, ',') : ('REDUCE', 57),
+        (33, ')') : ('REDUCE', 57),
+        (33, '~') : ('SHIFT', 15),
+        (33, 'false') : ('SHIFT', 28),
+        (33, 'not') : ('SHIFT', 26),
+        (33, 'id') : ('SHIFT', 18),
+        (34, 'id') : ('SHIFT', 16),
+        (34, 'string') : ('SHIFT', 29),
+        (34, 'if') : ('SHIFT', 24),
+        (34, '~') : ('SHIFT', 15),
+        (34, 'false') : ('SHIFT', 28),
+        (34, 'new') : ('SHIFT', 22),
+        (34, 'int') : ('SHIFT', 21),
+        (34, 'not') : ('SHIFT', 26),
+        (34, 'isvoid') : ('SHIFT', 34),
+        (34, 'true') : ('SHIFT', 27),
+        (34, '(') : ('SHIFT', 13),
+        (35, ',') : ('REDUCE', 39),
+        (35, '/') : ('REDUCE', 39),
+        (35, 'fi') : ('REDUCE', 39),
+        (35, 'pool') : ('REDUCE', 39),
+        (35, '<') : ('REDUCE', 39),
+        (35, 'in') : ('REDUCE', 39),
+        (35, '=') : ('REDUCE', 39),
+        (35, '<=') : ('REDUCE', 39),
+        (35, ';') : ('REDUCE', 39),
+        (35, '+') : ('REDUCE', 39),
+        (35, '*') : ('REDUCE', 39),
+        (35, ')') : ('REDUCE', 39),
+        (35, 'of') : ('REDUCE', 39),
+        (35, 'then') : ('REDUCE', 39),
+        (35, '-') : ('REDUCE', 39),
+        (35, 'loop') : ('REDUCE', 39),
+        (35, 'else') : ('REDUCE', 39),
+        (35, '}') : ('REDUCE', 39),
+        (36, ',') : ('REDUCE', 42),
+        (36, '/') : ('REDUCE', 42),
+        (36, 'fi') : ('REDUCE', 42),
+        (36, 'pool') : ('REDUCE', 42),
+        (36, '<') : ('REDUCE', 42),
+        (36, 'in') : ('REDUCE', 42),
+        (36, '=') : ('REDUCE', 42),
+        (36, '<=') : ('REDUCE', 42),
+        (36, ';') : ('REDUCE', 42),
+        (36, '+') : ('REDUCE', 42),
+        (36, '*') : ('REDUCE', 42),
+        (36, ')') : ('REDUCE', 42),
+        (36, 'of') : ('REDUCE', 42),
+        (36, 'then') : ('REDUCE', 42),
+        (36, '-') : ('REDUCE', 42),
+        (36, 'loop') : ('REDUCE', 42),
+        (36, 'else') : ('REDUCE', 42),
+        (36, '}') : ('REDUCE', 42),
+        (36, '.') : ('SHIFT', 31),
+        (36, '@') : ('SHIFT', 37),
+        (37, 'type') : ('SHIFT', 38),
+        (38, '.') : ('SHIFT', 39),
+        (39, 'id') : ('SHIFT', 40),
+        (40, '(') : ('SHIFT', 41),
+        (41, 'if') : ('SHIFT', 24),
+        (41, '{') : ('SHIFT', 14),
+        (41, 'new') : ('SHIFT', 22),
         (41, 'int') : ('SHIFT', 21),
-        (41, 'string') : ('SHIFT', 30),
-        (41, 'isvoid') : ('SHIFT', 27),
-        (41, '~') : ('SHIFT', 15),
+        (41, 'isvoid') : ('SHIFT', 34),
+        (41, 'true') : ('SHIFT', 27),
+        (41, 'case') : ('SHIFT', 25),
         (41, '(') : ('SHIFT', 13),
-        (41, 'new') : ('SHIFT', 22),
-        (41, 'true') : ('SHIFT', 28),
-        (42, '/') : ('SHIFT', 46),
-        (42, '*') : ('SHIFT', 43),
-        (42, '}') : ('REDUCE', 36),
-        (42, 'fi') : ('REDUCE', 36),
-        (42, 'in') : ('REDUCE', 36),
-        (42, '<') : ('REDUCE', 36),
-        (42, '=') : ('REDUCE', 36),
-        (42, ';') : ('REDUCE', 36),
-        (42, '<=') : ('REDUCE', 36),
-        (42, '+') : ('REDUCE', 36),
-        (42, ')') : ('REDUCE', 36),
-        (42, '-') : ('REDUCE', 36),
-        (42, 'then') : ('REDUCE', 36),
-        (42, 'of') : ('REDUCE', 36),
-        (42, 'loop') : ('REDUCE', 36),
-        (42, 'else') : ('REDUCE', 36),
-        (42, 'pool') : ('REDUCE', 36),
-        (42, ',') : ('REDUCE', 36),
-        (43, 'false') : ('SHIFT', 29),
-        (43, 'id') : ('SHIFT', 16),
+        (41, 'string') : ('SHIFT', 29),
+        (41, 'let') : ('SHIFT', 8),
+        (41, 'while') : ('SHIFT', 20),
+        (41, ',') : ('REDUCE', 57),
+        (41, ')') : ('REDUCE', 57),
+        (41, '~') : ('SHIFT', 15),
+        (41, 'false') : ('SHIFT', 28),
+        (41, 'not') : ('SHIFT', 26),
+        (41, 'id') : ('SHIFT', 18),
+        (42, ',') : ('SHIFT', 43),
+        (42, ')') : ('SHIFT', 64),
+        (43, 'if') : ('SHIFT', 24),
+        (43, '{') : ('SHIFT', 14),
         (43, 'new') : ('SHIFT', 22),
-        (43, 'string') : ('SHIFT', 30),
         (43, 'int') : ('SHIFT', 21),
-        (43, 'true') : ('SHIFT', 28),
-        (43, 'isvoid') : ('SHIFT', 27),
-        (43, '~') : ('SHIFT', 15),
+        (43, 'isvoid') : ('SHIFT', 34),
+        (43, 'true') : ('SHIFT', 27),
+        (43, 'case') : ('SHIFT', 25),
         (43, '(') : ('SHIFT', 13),
-        (44, '/') : ('REDUCE', 39),
-        (44, '}') : ('REDUCE', 39),
-        (44, 'fi') : ('REDUCE', 39),
-        (44, 'in') : ('REDUCE', 39),
-        (44, '<') : ('REDUCE', 39),
-        (44, '=') : ('REDUCE', 39),
-        (44, ';') : ('REDUCE', 39),
-        (44, '<=') : ('REDUCE', 39),
-        (44, '+') : ('REDUCE', 39),
-        (44, 'else') : ('REDUCE', 39),
-        (44, ')') : ('REDUCE', 39),
-        (44, '-') : ('REDUCE', 39),
-        (44, 'then') : ('REDUCE', 39),
-        (44, 'of') : ('REDUCE', 39),
-        (44, 'loop') : ('REDUCE', 39),
-        (44, '*') : ('REDUCE', 39),
-        (44, 'pool') : ('REDUCE', 39),
-        (44, ',') : ('REDUCE', 39),
-        (45, 'fi') : ('REDUCE', 52),
-        (45, '=') : ('REDUCE', 52),
-        (45, '+') : ('REDUCE', 52),
-        (45, '-') : ('REDUCE', 52),
-        (45, 'of') : ('REDUCE', 52),
-        (45, '*') : ('REDUCE', 52),
-        (45, '/') : ('REDUCE', 52),
-        (45, '<') : ('REDUCE', 52),
-        (45, '<=') : ('REDUCE', 52),
-        (45, '@') : ('REDUCE', 52),
-        (45, 'in') : ('REDUCE', 52),
-        (45, ';') : ('REDUCE', 52),
-        (45, 'loop') : ('REDUCE', 52),
-        (45, 'pool') : ('REDUCE', 52),
-        (45, ',') : ('REDUCE', 52),
-        (45, '.') : ('REDUCE', 52),
-        (45, ')') : ('REDUCE', 52),
-        (45, 'then') : ('REDUCE', 52),
-        (45, 'else') : ('REDUCE', 52),
-        (45, '}') : ('REDUCE', 52),
-        (46, 'false') : ('SHIFT', 29),
-        (46, 'id') : ('SHIFT', 16),
-        (46, 'new') : ('SHIFT', 22),
-        (46, 'string') : ('SHIFT', 30),
-        (46, 'int') : ('SHIFT', 21),
-        (46, 'true') : ('SHIFT', 28),
-        (46, 'isvoid') : ('SHIFT', 27),
-        (46, '~') : ('SHIFT', 15),
-        (46, '(') : ('SHIFT', 13),
-        (47, '/') : ('REDUCE', 40),
-        (47, '}') : ('REDUCE', 40),
-        (47, 'fi') : ('REDUCE', 40),
-        (47, 'in') : ('REDUCE', 40),
-        (47, '<') : ('REDUCE', 40),
-        (47, '=') : ('REDUCE', 40),
-        (47, ';') : ('REDUCE', 40),
-        (47, '<=') : ('REDUCE', 40),
-        (47, '+') : ('REDUCE', 40),
-        (47, 'else') : ('REDUCE', 40),
-        (47, ')') : ('REDUCE', 40),
-        (47, '-') : ('REDUCE', 40),
-        (47, 'then') : ('REDUCE', 40),
-        (47, 'of') : ('REDUCE', 40),
-        (47, 'loop') : ('REDUCE', 40),
-        (47, '*') : ('REDUCE', 40),
-        (47, 'pool') : ('REDUCE', 40),
-        (47, ',') : ('REDUCE', 40),
-        (48, '/') : ('REDUCE', 41),
-        (48, '}') : ('REDUCE', 41),
-        (48, 'fi') : ('REDUCE', 41),
-        (48, 'in') : ('REDUCE', 41),
-        (48, '<') : ('REDUCE', 41),
-        (48, '=') : ('REDUCE', 41),
-        (48, ';') : ('REDUCE', 41),
-        (48, '<=') : ('REDUCE', 41),
-        (48, '+') : ('REDUCE', 41),
-        (48, 'else') : ('REDUCE', 41),
-        (48, ')') : ('REDUCE', 41),
-        (48, '-') : ('REDUCE', 41),
-        (48, 'then') : ('REDUCE', 41),
-        (48, 'of') : ('REDUCE', 41),
-        (48, 'loop') : ('REDUCE', 41),
-        (48, '*') : ('REDUCE', 41),
-        (48, 'pool') : ('REDUCE', 41),
-        (48, ',') : ('REDUCE', 41),
-        (49, 'false') : ('SHIFT', 29),
+        (43, 'string') : ('SHIFT', 29),
+        (43, 'let') : ('SHIFT', 8),
+        (43, 'while') : ('SHIFT', 20),
+        (43, '~') : ('SHIFT', 15),
+        (43, 'false') : ('SHIFT', 28),
+        (43, 'not') : ('SHIFT', 26),
+        (43, 'id') : ('SHIFT', 18),
+        (44, '<') : ('SHIFT', 58),
+        (44, '<=') : ('SHIFT', 60),
+        (44, ',') : ('REDUCE', 28),
+        (44, 'fi') : ('REDUCE', 28),
+        (44, 'in') : ('REDUCE', 28),
+        (44, ';') : ('REDUCE', 28),
+        (44, ')') : ('REDUCE', 28),
+        (44, 'of') : ('REDUCE', 28),
+        (44, 'then') : ('REDUCE', 28),
+        (44, 'loop') : ('REDUCE', 28),
+        (44, '}') : ('REDUCE', 28),
+        (44, 'else') : ('REDUCE', 28),
+        (44, 'pool') : ('REDUCE', 28),
+        (44, '=') : ('SHIFT', 45),
+        (45, 'id') : ('SHIFT', 16),
+        (45, 'string') : ('SHIFT', 29),
+        (45, 'if') : ('SHIFT', 24),
+        (45, '~') : ('SHIFT', 15),
+        (45, 'false') : ('SHIFT', 28),
+        (45, 'new') : ('SHIFT', 22),
+        (45, 'int') : ('SHIFT', 21),
+        (45, 'not') : ('SHIFT', 26),
+        (45, 'isvoid') : ('SHIFT', 34),
+        (45, 'true') : ('SHIFT', 27),
+        (45, '(') : ('SHIFT', 13),
+        (46, '-') : ('SHIFT', 55),
+        (46, '+') : ('SHIFT', 47),
+        (46, ',') : ('REDUCE', 31),
+        (46, 'fi') : ('REDUCE', 31),
+        (46, 'pool') : ('REDUCE', 31),
+        (46, '<') : ('REDUCE', 31),
+        (46, 'in') : ('REDUCE', 31),
+        (46, '=') : ('REDUCE', 31),
+        (46, '<=') : ('REDUCE', 31),
+        (46, ';') : ('REDUCE', 31),
+        (46, ')') : ('REDUCE', 31),
+        (46, 'of') : ('REDUCE', 31),
+        (46, 'then') : ('REDUCE', 31),
+        (46, 'loop') : ('REDUCE', 31),
+        (46, 'else') : ('REDUCE', 31),
+        (46, '}') : ('REDUCE', 31),
+        (47, 'id') : ('SHIFT', 16),
+        (47, 'string') : ('SHIFT', 29),
+        (47, 'if') : ('SHIFT', 24),
+        (47, '~') : ('SHIFT', 15),
+        (47, 'false') : ('SHIFT', 28),
+        (47, 'new') : ('SHIFT', 22),
+        (47, 'int') : ('SHIFT', 21),
+        (47, 'not') : ('SHIFT', 26),
+        (47, 'isvoid') : ('SHIFT', 34),
+        (47, 'true') : ('SHIFT', 27),
+        (47, '(') : ('SHIFT', 13),
+        (48, '/') : ('SHIFT', 52),
+        (48, ',') : ('REDUCE', 33),
+        (48, 'fi') : ('REDUCE', 33),
+        (48, 'pool') : ('REDUCE', 33),
+        (48, '<') : ('REDUCE', 33),
+        (48, 'in') : ('REDUCE', 33),
+        (48, '=') : ('REDUCE', 33),
+        (48, '<=') : ('REDUCE', 33),
+        (48, ';') : ('REDUCE', 33),
+        (48, '+') : ('REDUCE', 33),
+        (48, ')') : ('REDUCE', 33),
+        (48, 'of') : ('REDUCE', 33),
+        (48, 'then') : ('REDUCE', 33),
+        (48, '-') : ('REDUCE', 33),
+        (48, 'loop') : ('REDUCE', 33),
+        (48, 'else') : ('REDUCE', 33),
+        (48, '}') : ('REDUCE', 33),
+        (48, '*') : ('SHIFT', 49),
         (49, 'id') : ('SHIFT', 16),
-        (49, 'int') : ('SHIFT', 21),
-        (49, 'string') : ('SHIFT', 30),
-        (49, 'isvoid') : ('SHIFT', 27),
+        (49, 'string') : ('SHIFT', 29),
+        (49, 'if') : ('SHIFT', 24),
         (49, '~') : ('SHIFT', 15),
-        (49, '(') : ('SHIFT', 13),
+        (49, 'false') : ('SHIFT', 28),
         (49, 'new') : ('SHIFT', 22),
-        (49, 'true') : ('SHIFT', 28),
-        (50, '/') : ('SHIFT', 46),
-        (50, '}') : ('REDUCE', 37),
-        (50, 'fi') : ('REDUCE', 37),
-        (50, 'in') : ('REDUCE', 37),
-        (50, '<') : ('REDUCE', 37),
-        (50, '=') : ('REDUCE', 37),
-        (50, ';') : ('REDUCE', 37),
-        (50, '<=') : ('REDUCE', 37),
-        (50, '+') : ('REDUCE', 37),
-        (50, ')') : ('REDUCE', 37),
-        (50, '-') : ('REDUCE', 37),
-        (50, 'then') : ('REDUCE', 37),
-        (50, 'of') : ('REDUCE', 37),
-        (50, 'loop') : ('REDUCE', 37),
-        (50, 'else') : ('REDUCE', 37),
-        (50, 'pool') : ('REDUCE', 37),
-        (50, ',') : ('REDUCE', 37),
-        (50, '*') : ('SHIFT', 43),
-        (51, '/') : ('SHIFT', 46),
-        (51, '*') : ('SHIFT', 43),
-        (51, '}') : ('REDUCE', 38),
-        (51, 'fi') : ('REDUCE', 38),
-        (51, 'in') : ('REDUCE', 38),
-        (51, '<') : ('REDUCE', 38),
-        (51, '=') : ('REDUCE', 38),
-        (51, ';') : ('REDUCE', 38),
-        (51, '<=') : ('REDUCE', 38),
-        (51, '+') : ('REDUCE', 38),
-        (51, ')') : ('REDUCE', 38),
-        (51, '-') : ('REDUCE', 38),
-        (51, 'then') : ('REDUCE', 38),
-        (51, 'of') : ('REDUCE', 38),
-        (51, 'loop') : ('REDUCE', 38),
-        (51, 'else') : ('REDUCE', 38),
-        (51, 'pool') : ('REDUCE', 38),
-        (51, ',') : ('REDUCE', 38),
-        (52, 'false') : ('SHIFT', 29),
+        (49, 'int') : ('SHIFT', 21),
+        (49, 'not') : ('SHIFT', 26),
+        (49, 'isvoid') : ('SHIFT', 34),
+        (49, 'true') : ('SHIFT', 27),
+        (49, '(') : ('SHIFT', 13),
+        (50, ',') : ('REDUCE', 36),
+        (50, '/') : ('REDUCE', 36),
+        (50, 'fi') : ('REDUCE', 36),
+        (50, 'pool') : ('REDUCE', 36),
+        (50, '<') : ('REDUCE', 36),
+        (50, 'in') : ('REDUCE', 36),
+        (50, '=') : ('REDUCE', 36),
+        (50, '<=') : ('REDUCE', 36),
+        (50, ';') : ('REDUCE', 36),
+        (50, '+') : ('REDUCE', 36),
+        (50, '*') : ('REDUCE', 36),
+        (50, ')') : ('REDUCE', 36),
+        (50, 'of') : ('REDUCE', 36),
+        (50, 'then') : ('REDUCE', 36),
+        (50, '-') : ('REDUCE', 36),
+        (50, 'loop') : ('REDUCE', 36),
+        (50, 'else') : ('REDUCE', 36),
+        (50, '}') : ('REDUCE', 36),
+        (51, '/') : ('REDUCE', 51),
+        (51, '<') : ('REDUCE', 51),
+        (51, '<=') : ('REDUCE', 51),
+        (51, '@') : ('REDUCE', 51),
+        (51, 'in') : ('REDUCE', 51),
+        (51, ';') : ('REDUCE', 51),
+        (51, 'loop') : ('REDUCE', 51),
+        (51, 'pool') : ('REDUCE', 51),
+        (51, ',') : ('REDUCE', 51),
+        (51, '.') : ('REDUCE', 51),
+        (51, ')') : ('REDUCE', 51),
+        (51, 'then') : ('REDUCE', 51),
+        (51, 'else') : ('REDUCE', 51),
+        (51, '}') : ('REDUCE', 51),
+        (51, 'fi') : ('REDUCE', 51),
+        (51, '=') : ('REDUCE', 51),
+        (51, '+') : ('REDUCE', 51),
+        (51, 'of') : ('REDUCE', 51),
+        (51, '-') : ('REDUCE', 51),
+        (51, '*') : ('REDUCE', 51),
         (52, 'id') : ('SHIFT', 16),
-        (52, 'string') : ('SHIFT', 30),
-        (52, 'int') : ('SHIFT', 21),
-        (52, 'isvoid') : ('SHIFT', 27),
+        (52, 'string') : ('SHIFT', 29),
+        (52, 'if') : ('SHIFT', 24),
         (52, '~') : ('SHIFT', 15),
-        (52, '(') : ('SHIFT', 13),
+        (52, 'false') : ('SHIFT', 28),
         (52, 'new') : ('SHIFT', 22),
-        (52, 'true') : ('SHIFT', 28),
-        (53, '}') : ('REDUCE', 32),
-        (53, 'fi') : ('REDUCE', 32),
-        (53, 'in') : ('REDUCE', 32),
-        (53, '<') : ('REDUCE', 32),
-        (53, '=') : ('REDUCE', 32),
-        (53, ';') : ('REDUCE', 32),
-        (53, '<=') : ('REDUCE', 32),
-        (53, ')') : ('REDUCE', 32),
-        (53, 'then') : ('REDUCE', 32),
-        (53, 'loop') : ('REDUCE', 32),
-        (53, 'of') : ('REDUCE', 32),
-        (53, 'else') : ('REDUCE', 32),
-        (53, 'pool') : ('REDUCE', 32),
-        (53, ',') : ('REDUCE', 32),
-        (53, '-') : ('SHIFT', 49),
-        (53, '+') : ('SHIFT', 41),
-        (54, 'false') : ('SHIFT', 29),
-        (54, 'id') : ('SHIFT', 16),
-        (54, 'string') : ('SHIFT', 30),
-        (54, 'int') : ('SHIFT', 21),
-        (54, 'isvoid') : ('SHIFT', 27),
-        (54, '~') : ('SHIFT', 15),
-        (54, '(') : ('SHIFT', 13),
-        (54, 'new') : ('SHIFT', 22),
-        (54, 'true') : ('SHIFT', 28),
-        (55, '-') : ('SHIFT', 49),
-        (55, '}') : ('REDUCE', 33),
-        (55, 'fi') : ('REDUCE', 33),
-        (55, 'in') : ('REDUCE', 33),
-        (55, '<') : ('REDUCE', 33),
-        (55, '=') : ('REDUCE', 33),
-        (55, ';') : ('REDUCE', 33),
-        (55, '<=') : ('REDUCE', 33),
-        (55, ')') : ('REDUCE', 33),
-        (55, 'then') : ('REDUCE', 33),
-        (55, 'loop') : ('REDUCE', 33),
-        (55, 'of') : ('REDUCE', 33),
-        (55, 'else') : ('REDUCE', 33),
-        (55, 'pool') : ('REDUCE', 33),
-        (55, ',') : ('REDUCE', 33),
-        (55, '+') : ('SHIFT', 41),
-        (56, ',') : ('SHIFT', 57),
-        (56, ')') : ('REDUCE', 56),
-        (57, ')') : ('REDUCE', 58),
-        (57, 'int') : ('SHIFT', 21),
-        (57, 'id') : ('SHIFT', 18),
-        (57, 'new') : ('SHIFT', 22),
-        (57, '{') : ('SHIFT', 14),
-        (57, 'true') : ('SHIFT', 28),
-        (57, 'let') : ('SHIFT', 8),
-        (57, 'if') : ('SHIFT', 24),
-        (57, 'case') : ('SHIFT', 25),
-        (57, 'not') : ('SHIFT', 26),
-        (57, 'isvoid') : ('SHIFT', 27),
-        (57, 'while') : ('SHIFT', 20),
-        (57, '(') : ('SHIFT', 13),
-        (57, 'false') : ('SHIFT', 29),
-        (57, 'string') : ('SHIFT', 30),
-        (57, '~') : ('SHIFT', 15),
-        (58, ')') : ('REDUCE', 57),
-        (59, '}') : ('REDUCE', 35),
-        (59, 'fi') : ('REDUCE', 35),
-        (59, 'in') : ('REDUCE', 35),
-        (59, '<') : ('REDUCE', 35),
-        (59, '=') : ('REDUCE', 35),
-        (59, ';') : ('REDUCE', 35),
-        (59, '<=') : ('REDUCE', 35),
-        (59, ')') : ('REDUCE', 35),
-        (59, 'then') : ('REDUCE', 35),
-        (59, 'loop') : ('REDUCE', 35),
-        (59, 'of') : ('REDUCE', 35),
-        (59, 'else') : ('REDUCE', 35),
-        (59, 'pool') : ('REDUCE', 35),
-        (59, ',') : ('REDUCE', 35),
-        (59, '-') : ('SHIFT', 49),
-        (59, '+') : ('SHIFT', 41),
-        (60, 'pool') : ('REDUCE', 29),
-        (60, 'fi') : ('REDUCE', 29),
-        (60, 'in') : ('REDUCE', 29),
-        (60, ';') : ('REDUCE', 29),
-        (60, ')') : ('REDUCE', 29),
-        (60, 'then') : ('REDUCE', 29),
-        (60, 'of') : ('REDUCE', 29),
-        (60, 'loop') : ('REDUCE', 29),
-        (60, 'else') : ('REDUCE', 29),
-        (60, '}') : ('REDUCE', 29),
-        (60, ',') : ('REDUCE', 29),
-        (61, 'type') : ('SHIFT', 62),
-        (62, '.') : ('SHIFT', 63),
-        (63, 'id') : ('SHIFT', 64),
-        (64, '(') : ('SHIFT', 65),
-        (65, ')') : ('REDUCE', 58),
-        (65, '~') : ('SHIFT', 15),
-        (65, 'id') : ('SHIFT', 18),
-        (65, 'new') : ('SHIFT', 22),
-        (65, '{') : ('SHIFT', 14),
-        (65, 'true') : ('SHIFT', 28),
-        (65, 'let') : ('SHIFT', 8),
-        (65, 'if') : ('SHIFT', 24),
-        (65, 'case') : ('SHIFT', 25),
-        (65, 'string') : ('SHIFT', 30),
-        (65, 'isvoid') : ('SHIFT', 27),
-        (65, 'while') : ('SHIFT', 20),
-        (65, '(') : ('SHIFT', 13),
-        (65, 'false') : ('SHIFT', 29),
-        (65, 'int') : ('SHIFT', 21),
-        (65, 'not') : ('SHIFT', 26),
+        (52, 'int') : ('SHIFT', 21),
+        (52, 'not') : ('SHIFT', 26),
+        (52, 'isvoid') : ('SHIFT', 34),
+        (52, 'true') : ('SHIFT', 27),
+        (52, '(') : ('SHIFT', 13),
+        (53, ',') : ('REDUCE', 37),
+        (53, '/') : ('REDUCE', 37),
+        (53, 'fi') : ('REDUCE', 37),
+        (53, 'pool') : ('REDUCE', 37),
+        (53, '<') : ('REDUCE', 37),
+        (53, 'in') : ('REDUCE', 37),
+        (53, '=') : ('REDUCE', 37),
+        (53, '<=') : ('REDUCE', 37),
+        (53, ';') : ('REDUCE', 37),
+        (53, '+') : ('REDUCE', 37),
+        (53, '*') : ('REDUCE', 37),
+        (53, ')') : ('REDUCE', 37),
+        (53, 'of') : ('REDUCE', 37),
+        (53, 'then') : ('REDUCE', 37),
+        (53, '-') : ('REDUCE', 37),
+        (53, 'loop') : ('REDUCE', 37),
+        (53, 'else') : ('REDUCE', 37),
+        (53, '}') : ('REDUCE', 37),
+        (54, ',') : ('REDUCE', 38),
+        (54, '/') : ('REDUCE', 38),
+        (54, 'fi') : ('REDUCE', 38),
+        (54, 'pool') : ('REDUCE', 38),
+        (54, '<') : ('REDUCE', 38),
+        (54, 'in') : ('REDUCE', 38),
+        (54, '=') : ('REDUCE', 38),
+        (54, '<=') : ('REDUCE', 38),
+        (54, ';') : ('REDUCE', 38),
+        (54, '+') : ('REDUCE', 38),
+        (54, '*') : ('REDUCE', 38),
+        (54, ')') : ('REDUCE', 38),
+        (54, 'of') : ('REDUCE', 38),
+        (54, 'then') : ('REDUCE', 38),
+        (54, '-') : ('REDUCE', 38),
+        (54, 'loop') : ('REDUCE', 38),
+        (54, 'else') : ('REDUCE', 38),
+        (54, '}') : ('REDUCE', 38),
+        (55, 'id') : ('SHIFT', 16),
+        (55, 'string') : ('SHIFT', 29),
+        (55, 'if') : ('SHIFT', 24),
+        (55, '~') : ('SHIFT', 15),
+        (55, 'false') : ('SHIFT', 28),
+        (55, 'new') : ('SHIFT', 22),
+        (55, 'int') : ('SHIFT', 21),
+        (55, 'not') : ('SHIFT', 26),
+        (55, 'isvoid') : ('SHIFT', 34),
+        (55, 'true') : ('SHIFT', 27),
+        (55, '(') : ('SHIFT', 13),
+        (56, '/') : ('SHIFT', 52),
+        (56, ',') : ('REDUCE', 34),
+        (56, 'fi') : ('REDUCE', 34),
+        (56, 'pool') : ('REDUCE', 34),
+        (56, '<') : ('REDUCE', 34),
+        (56, 'in') : ('REDUCE', 34),
+        (56, '=') : ('REDUCE', 34),
+        (56, '<=') : ('REDUCE', 34),
+        (56, ';') : ('REDUCE', 34),
+        (56, '+') : ('REDUCE', 34),
+        (56, ')') : ('REDUCE', 34),
+        (56, 'of') : ('REDUCE', 34),
+        (56, 'then') : ('REDUCE', 34),
+        (56, '-') : ('REDUCE', 34),
+        (56, 'loop') : ('REDUCE', 34),
+        (56, 'else') : ('REDUCE', 34),
+        (56, '}') : ('REDUCE', 34),
+        (56, '*') : ('SHIFT', 49),
+        (57, '*') : ('SHIFT', 49),
+        (57, ',') : ('REDUCE', 35),
+        (57, 'fi') : ('REDUCE', 35),
+        (57, 'pool') : ('REDUCE', 35),
+        (57, '<') : ('REDUCE', 35),
+        (57, 'in') : ('REDUCE', 35),
+        (57, '=') : ('REDUCE', 35),
+        (57, '<=') : ('REDUCE', 35),
+        (57, ';') : ('REDUCE', 35),
+        (57, '+') : ('REDUCE', 35),
+        (57, ')') : ('REDUCE', 35),
+        (57, 'of') : ('REDUCE', 35),
+        (57, 'then') : ('REDUCE', 35),
+        (57, '-') : ('REDUCE', 35),
+        (57, 'loop') : ('REDUCE', 35),
+        (57, 'else') : ('REDUCE', 35),
+        (57, '}') : ('REDUCE', 35),
+        (57, '/') : ('SHIFT', 52),
+        (58, 'id') : ('SHIFT', 16),
+        (58, '(') : ('SHIFT', 13),
+        (58, 'string') : ('SHIFT', 29),
+        (58, 'if') : ('SHIFT', 24),
+        (58, '~') : ('SHIFT', 15),
+        (58, 'false') : ('SHIFT', 28),
+        (58, 'new') : ('SHIFT', 22),
+        (58, 'int') : ('SHIFT', 21),
+        (58, 'not') : ('SHIFT', 26),
+        (58, 'isvoid') : ('SHIFT', 34),
+        (58, 'true') : ('SHIFT', 27),
+        (59, '-') : ('SHIFT', 55),
+        (59, '+') : ('SHIFT', 47),
+        (59, ',') : ('REDUCE', 29),
+        (59, 'fi') : ('REDUCE', 29),
+        (59, 'pool') : ('REDUCE', 29),
+        (59, '<') : ('REDUCE', 29),
+        (59, 'in') : ('REDUCE', 29),
+        (59, '=') : ('REDUCE', 29),
+        (59, '<=') : ('REDUCE', 29),
+        (59, ';') : ('REDUCE', 29),
+        (59, ')') : ('REDUCE', 29),
+        (59, 'of') : ('REDUCE', 29),
+        (59, 'then') : ('REDUCE', 29),
+        (59, 'loop') : ('REDUCE', 29),
+        (59, 'else') : ('REDUCE', 29),
+        (59, '}') : ('REDUCE', 29),
+        (60, 'id') : ('SHIFT', 16),
+        (60, 'string') : ('SHIFT', 29),
+        (60, 'if') : ('SHIFT', 24),
+        (60, '~') : ('SHIFT', 15),
+        (60, 'false') : ('SHIFT', 28),
+        (60, 'new') : ('SHIFT', 22),
+        (60, 'int') : ('SHIFT', 21),
+        (60, 'not') : ('SHIFT', 26),
+        (60, 'isvoid') : ('SHIFT', 34),
+        (60, 'true') : ('SHIFT', 27),
+        (60, '(') : ('SHIFT', 13),
+        (61, '-') : ('SHIFT', 55),
+        (61, '+') : ('SHIFT', 47),
+        (61, ',') : ('REDUCE', 30),
+        (61, 'fi') : ('REDUCE', 30),
+        (61, 'pool') : ('REDUCE', 30),
+        (61, '<') : ('REDUCE', 30),
+        (61, 'in') : ('REDUCE', 30),
+        (61, '=') : ('REDUCE', 30),
+        (61, '<=') : ('REDUCE', 30),
+        (61, ';') : ('REDUCE', 30),
+        (61, ')') : ('REDUCE', 30),
+        (61, 'of') : ('REDUCE', 30),
+        (61, 'then') : ('REDUCE', 30),
+        (61, 'loop') : ('REDUCE', 30),
+        (61, 'else') : ('REDUCE', 30),
+        (61, '}') : ('REDUCE', 30),
+        (62, ',') : ('REDUCE', 56),
+        (62, ')') : ('REDUCE', 56),
+        (63, '-') : ('SHIFT', 55),
+        (63, '+') : ('SHIFT', 47),
+        (63, ',') : ('REDUCE', 32),
+        (63, 'fi') : ('REDUCE', 32),
+        (63, 'in') : ('REDUCE', 32),
+        (63, '<') : ('REDUCE', 32),
+        (63, '=') : ('REDUCE', 32),
+        (63, '<=') : ('REDUCE', 32),
+        (63, ';') : ('REDUCE', 32),
+        (63, ')') : ('REDUCE', 32),
+        (63, 'of') : ('REDUCE', 32),
+        (63, 'then') : ('REDUCE', 32),
+        (63, 'loop') : ('REDUCE', 32),
+        (63, '}') : ('REDUCE', 32),
+        (63, 'else') : ('REDUCE', 32),
+        (63, 'pool') : ('REDUCE', 32),
+        (64, '/') : ('REDUCE', 54),
+        (64, '<') : ('REDUCE', 54),
+        (64, '<=') : ('REDUCE', 54),
+        (64, '@') : ('REDUCE', 54),
+        (64, 'in') : ('REDUCE', 54),
+        (64, ';') : ('REDUCE', 54),
+        (64, 'loop') : ('REDUCE', 54),
+        (64, 'pool') : ('REDUCE', 54),
+        (64, ',') : ('REDUCE', 54),
+        (64, '.') : ('REDUCE', 54),
+        (64, ')') : ('REDUCE', 54),
+        (64, 'then') : ('REDUCE', 54),
+        (64, 'else') : ('REDUCE', 54),
+        (64, '}') : ('REDUCE', 54),
+        (64, 'fi') : ('REDUCE', 54),
+        (64, '=') : ('REDUCE', 54),
+        (64, '+') : ('REDUCE', 54),
+        (64, 'of') : ('REDUCE', 54),
+        (64, '-') : ('REDUCE', 54),
+        (64, '*') : ('REDUCE', 54),
+        (65, ',') : ('REDUCE', 55),
+        (65, ')') : ('REDUCE', 55),
+        (66, ',') : ('SHIFT', 43),
         (66, ')') : ('SHIFT', 67),
-        (67, 'fi') : ('REDUCE', 55),
-        (67, '=') : ('REDUCE', 55),
-        (67, '+') : ('REDUCE', 55),
-        (67, '-') : ('REDUCE', 55),
-        (67, 'of') : ('REDUCE', 55),
-        (67, '*') : ('REDUCE', 55),
-        (67, '/') : ('REDUCE', 55),
-        (67, '<') : ('REDUCE', 55),
-        (67, '<=') : ('REDUCE', 55),
-        (67, '@') : ('REDUCE', 55),
-        (67, 'in') : ('REDUCE', 55),
-        (67, ';') : ('REDUCE', 55),
-        (67, 'loop') : ('REDUCE', 55),
-        (67, 'pool') : ('REDUCE', 55),
-        (67, ',') : ('REDUCE', 55),
-        (67, '.') : ('REDUCE', 55),
-        (67, ')') : ('REDUCE', 55),
-        (67, 'then') : ('REDUCE', 55),
-        (67, 'else') : ('REDUCE', 55),
-        (67, '}') : ('REDUCE', 55),
-        (68, '<=') : ('SHIFT', 54),
-        (68, '<') : ('SHIFT', 52),
-        (68, '=') : ('SHIFT', 39),
-        (68, '}') : ('REDUCE', 31),
-        (68, 'fi') : ('REDUCE', 31),
-        (68, 'in') : ('REDUCE', 31),
-        (68, ';') : ('REDUCE', 31),
-        (68, ')') : ('REDUCE', 31),
-        (68, 'then') : ('REDUCE', 31),
-        (68, 'of') : ('REDUCE', 31),
-        (68, 'loop') : ('REDUCE', 31),
-        (68, 'else') : ('REDUCE', 31),
-        (68, 'pool') : ('REDUCE', 31),
-        (68, ',') : ('REDUCE', 31),
-        (69, 'of') : ('SHIFT', 70),
-        (70, 'id') : ('SHIFT', 71),
-        (71, ':') : ('SHIFT', 72),
-        (72, 'type') : ('SHIFT', 73),
-        (73, '=>') : ('SHIFT', 74),
-        (74, 'isvoid') : ('SHIFT', 27),
-        (74, '{') : ('SHIFT', 14),
-        (74, '(') : ('SHIFT', 13),
-        (74, 'let') : ('SHIFT', 8),
-        (74, 'if') : ('SHIFT', 24),
-        (74, 'case') : ('SHIFT', 25),
-        (74, 'id') : ('SHIFT', 18),
-        (74, 'false') : ('SHIFT', 29),
-        (74, 'int') : ('SHIFT', 21),
-        (74, 'string') : ('SHIFT', 30),
-        (74, 'while') : ('SHIFT', 20),
-        (74, '~') : ('SHIFT', 15),
-        (74, 'new') : ('SHIFT', 22),
-        (74, 'true') : ('SHIFT', 28),
-        (74, 'not') : ('SHIFT', 26),
-        (75, ';') : ('SHIFT', 76),
-        (76, 'id') : ('SHIFT', 71),
+        (67, '/') : ('REDUCE', 52),
+        (67, '<') : ('REDUCE', 52),
+        (67, '<=') : ('REDUCE', 52),
+        (67, '@') : ('REDUCE', 52),
+        (67, 'in') : ('REDUCE', 52),
+        (67, ';') : ('REDUCE', 52),
+        (67, 'loop') : ('REDUCE', 52),
+        (67, 'pool') : ('REDUCE', 52),
+        (67, ',') : ('REDUCE', 52),
+        (67, '.') : ('REDUCE', 52),
+        (67, ')') : ('REDUCE', 52),
+        (67, 'then') : ('REDUCE', 52),
+        (67, 'else') : ('REDUCE', 52),
+        (67, '}') : ('REDUCE', 52),
+        (67, 'fi') : ('REDUCE', 52),
+        (67, '=') : ('REDUCE', 52),
+        (67, '+') : ('REDUCE', 52),
+        (67, 'of') : ('REDUCE', 52),
+        (67, '-') : ('REDUCE', 52),
+        (67, '*') : ('REDUCE', 52),
+        (68, 'of') : ('SHIFT', 69),
+        (69, 'id') : ('SHIFT', 70),
+        (70, ':') : ('SHIFT', 71),
+        (71, 'type') : ('SHIFT', 72),
+        (72, '=>') : ('SHIFT', 73),
+        (73, 'true') : ('SHIFT', 27),
+        (73, 'not') : ('SHIFT', 26),
+        (73, 'case') : ('SHIFT', 25),
+        (73, '(') : ('SHIFT', 13),
+        (73, 'let') : ('SHIFT', 8),
+        (73, 'string') : ('SHIFT', 29),
+        (73, 'while') : ('SHIFT', 20),
+        (73, 'false') : ('SHIFT', 28),
+        (73, 'isvoid') : ('SHIFT', 34),
+        (73, 'id') : ('SHIFT', 18),
+        (73, 'if') : ('SHIFT', 24),
+        (73, '{') : ('SHIFT', 14),
+        (73, '~') : ('SHIFT', 15),
+        (73, 'new') : ('SHIFT', 22),
+        (73, 'int') : ('SHIFT', 21),
+        (74, ';') : ('SHIFT', 75),
+        (75, 'id') : ('SHIFT', 70),
+        (75, 'esac') : ('REDUCE', 26),
         (76, 'esac') : ('REDUCE', 27),
-        (77, 'esac') : ('REDUCE', 28),
-        (78, 'esac') : ('SHIFT', 79),
-        (79, '}') : ('REDUCE', 26),
-        (79, 'fi') : ('REDUCE', 26),
-        (79, 'in') : ('REDUCE', 26),
-        (79, ';') : ('REDUCE', 26),
-        (79, ')') : ('REDUCE', 26),
-        (79, 'then') : ('REDUCE', 26),
-        (79, 'loop') : ('REDUCE', 26),
-        (79, 'of') : ('REDUCE', 26),
-        (79, 'else') : ('REDUCE', 26),
-        (79, 'pool') : ('REDUCE', 26),
-        (79, ',') : ('REDUCE', 26),
-        (80, 'then') : ('SHIFT', 81),
-        (81, 'not') : ('SHIFT', 26),
-        (81, 'new') : ('SHIFT', 22),
-        (81, 'true') : ('SHIFT', 28),
-        (81, '{') : ('SHIFT', 14),
-        (81, 'id') : ('SHIFT', 18),
-        (81, 'let') : ('SHIFT', 8),
-        (81, 'case') : ('SHIFT', 25),
-        (81, 'if') : ('SHIFT', 24),
-        (81, '~') : ('SHIFT', 15),
-        (81, '(') : ('SHIFT', 13),
-        (81, 'while') : ('SHIFT', 20),
-        (81, 'false') : ('SHIFT', 29),
-        (81, 'isvoid') : ('SHIFT', 27),
-        (81, 'string') : ('SHIFT', 30),
-        (81, 'int') : ('SHIFT', 21),
-        (82, 'else') : ('SHIFT', 83),
-        (83, '(') : ('SHIFT', 13),
-        (83, 'isvoid') : ('SHIFT', 27),
-        (83, 'not') : ('SHIFT', 26),
-        (83, 'id') : ('SHIFT', 18),
-        (83, 'false') : ('SHIFT', 29),
-        (83, 'string') : ('SHIFT', 30),
-        (83, 'int') : ('SHIFT', 21),
-        (83, '{') : ('SHIFT', 14),
-        (83, 'let') : ('SHIFT', 8),
-        (83, 'case') : ('SHIFT', 25),
-        (83, 'if') : ('SHIFT', 24),
-        (83, 'new') : ('SHIFT', 22),
-        (83, 'true') : ('SHIFT', 28),
-        (83, '~') : ('SHIFT', 15),
-        (83, 'while') : ('SHIFT', 20),
-        (84, 'fi') : ('SHIFT', 85),
-        (85, '}') : ('REDUCE', 16),
-        (85, 'fi') : ('REDUCE', 16),
-        (85, 'in') : ('REDUCE', 16),
-        (85, ';') : ('REDUCE', 16),
-        (85, ')') : ('REDUCE', 16),
-        (85, 'then') : ('REDUCE', 16),
-        (85, 'loop') : ('REDUCE', 16),
-        (85, 'of') : ('REDUCE', 16),
-        (85, 'else') : ('REDUCE', 16),
-        (85, 'pool') : ('REDUCE', 16),
-        (85, ',') : ('REDUCE', 16),
-        (86, 'loop') : ('SHIFT', 87),
-        (87, 'true') : ('SHIFT', 28),
-        (87, 'not') : ('SHIFT', 26),
-        (87, '{') : ('SHIFT', 14),
-        (87, 'isvoid') : ('SHIFT', 27),
-        (87, '(') : ('SHIFT', 13),
-        (87, 'let') : ('SHIFT', 8),
-        (87, 'if') : ('SHIFT', 24),
-        (87, 'case') : ('SHIFT', 25),
-        (87, 'id') : ('SHIFT', 18),
-        (87, 'false') : ('SHIFT', 29),
-        (87, 'int') : ('SHIFT', 21),
-        (87, 'string') : ('SHIFT', 30),
-        (87, 'while') : ('SHIFT', 20),
-        (87, '~') : ('SHIFT', 15),
-        (87, 'new') : ('SHIFT', 22),
-        (88, 'pool') : ('SHIFT', 89),
-        (89, '}') : ('REDUCE', 17),
-        (89, 'fi') : ('REDUCE', 17),
-        (89, 'in') : ('REDUCE', 17),
-        (89, ';') : ('REDUCE', 17),
-        (89, ')') : ('REDUCE', 17),
-        (89, 'then') : ('REDUCE', 17),
-        (89, 'of') : ('REDUCE', 17),
-        (89, 'loop') : ('REDUCE', 17),
-        (89, 'else') : ('REDUCE', 17),
-        (89, 'pool') : ('REDUCE', 17),
-        (89, ',') : ('REDUCE', 17),
-        (90, '}') : ('REDUCE', 15),
-        (90, 'fi') : ('REDUCE', 15),
-        (90, 'in') : ('REDUCE', 15),
-        (90, ';') : ('REDUCE', 15),
-        (90, ')') : ('REDUCE', 15),
-        (90, 'then') : ('REDUCE', 15),
-        (90, 'loop') : ('REDUCE', 15),
-        (90, 'of') : ('REDUCE', 15),
-        (90, 'else') : ('REDUCE', 15),
-        (90, 'pool') : ('REDUCE', 15),
-        (90, ',') : ('REDUCE', 15),
-        (91, ')') : ('SHIFT', 92),
-        (92, 'fi') : ('REDUCE', 54),
-        (92, '=') : ('REDUCE', 54),
-        (92, '+') : ('REDUCE', 54),
-        (92, '-') : ('REDUCE', 54),
-        (92, 'of') : ('REDUCE', 54),
-        (92, '*') : ('REDUCE', 54),
-        (92, '/') : ('REDUCE', 54),
-        (92, '<') : ('REDUCE', 54),
-        (92, '<=') : ('REDUCE', 54),
-        (92, '@') : ('REDUCE', 54),
-        (92, 'in') : ('REDUCE', 54),
-        (92, ';') : ('REDUCE', 54),
-        (92, 'loop') : ('REDUCE', 54),
-        (92, 'pool') : ('REDUCE', 54),
-        (92, ',') : ('REDUCE', 54),
-        (92, '.') : ('REDUCE', 54),
-        (92, ')') : ('REDUCE', 54),
-        (92, 'then') : ('REDUCE', 54),
-        (92, 'else') : ('REDUCE', 54),
-        (92, '}') : ('REDUCE', 54),
-        (93, '/') : ('REDUCE', 43),
-        (93, '}') : ('REDUCE', 43),
-        (93, 'fi') : ('REDUCE', 43),
-        (93, 'in') : ('REDUCE', 43),
-        (93, '<') : ('REDUCE', 43),
-        (93, '=') : ('REDUCE', 43),
-        (93, ';') : ('REDUCE', 43),
-        (93, '<=') : ('REDUCE', 43),
-        (93, '+') : ('REDUCE', 43),
-        (93, 'else') : ('REDUCE', 43),
-        (93, ')') : ('REDUCE', 43),
-        (93, '-') : ('REDUCE', 43),
-        (93, 'then') : ('REDUCE', 43),
-        (93, 'of') : ('REDUCE', 43),
-        (93, 'loop') : ('REDUCE', 43),
-        (93, '*') : ('REDUCE', 43),
-        (93, 'pool') : ('REDUCE', 43),
-        (93, ',') : ('REDUCE', 43),
-        (94, '}') : ('SHIFT', 95),
-        (95, '}') : ('REDUCE', 18),
-        (95, 'fi') : ('REDUCE', 18),
-        (95, 'in') : ('REDUCE', 18),
-        (95, ';') : ('REDUCE', 18),
-        (95, ')') : ('REDUCE', 18),
-        (95, 'then') : ('REDUCE', 18),
-        (95, 'of') : ('REDUCE', 18),
-        (95, 'loop') : ('REDUCE', 18),
-        (95, 'else') : ('REDUCE', 18),
-        (95, 'pool') : ('REDUCE', 18),
-        (95, ',') : ('REDUCE', 18),
-        (96, ';') : ('SHIFT', 97),
-        (97, 'isvoid') : ('SHIFT', 27),
-        (97, '{') : ('SHIFT', 14),
-        (97, '(') : ('SHIFT', 13),
-        (97, 'let') : ('SHIFT', 8),
-        (97, 'if') : ('SHIFT', 24),
-        (97, 'case') : ('SHIFT', 25),
-        (97, 'id') : ('SHIFT', 18),
-        (97, 'false') : ('SHIFT', 29),
-        (97, 'int') : ('SHIFT', 21),
-        (97, 'string') : ('SHIFT', 30),
-        (97, 'while') : ('SHIFT', 20),
+        (77, 'esac') : ('SHIFT', 78),
+        (78, ',') : ('REDUCE', 25),
+        (78, 'fi') : ('REDUCE', 25),
+        (78, 'pool') : ('REDUCE', 25),
+        (78, 'in') : ('REDUCE', 25),
+        (78, ';') : ('REDUCE', 25),
+        (78, ')') : ('REDUCE', 25),
+        (78, 'of') : ('REDUCE', 25),
+        (78, 'then') : ('REDUCE', 25),
+        (78, 'loop') : ('REDUCE', 25),
+        (78, 'else') : ('REDUCE', 25),
+        (78, '}') : ('REDUCE', 25),
+        (79, 'then') : ('SHIFT', 80),
+        (80, 'case') : ('SHIFT', 25),
+        (80, 'false') : ('SHIFT', 28),
+        (80, 'let') : ('SHIFT', 8),
+        (80, '~') : ('SHIFT', 15),
+        (80, 'while') : ('SHIFT', 20),
+        (80, 'id') : ('SHIFT', 18),
+        (80, 'not') : ('SHIFT', 26),
+        (80, 'if') : ('SHIFT', 24),
+        (80, 'new') : ('SHIFT', 22),
+        (80, 'int') : ('SHIFT', 21),
+        (80, 'true') : ('SHIFT', 27),
+        (80, '(') : ('SHIFT', 13),
+        (80, '{') : ('SHIFT', 14),
+        (80, 'string') : ('SHIFT', 29),
+        (80, 'isvoid') : ('SHIFT', 34),
+        (81, 'else') : ('SHIFT', 82),
+        (82, 'case') : ('SHIFT', 25),
+        (82, 'let') : ('SHIFT', 8),
+        (82, '~') : ('SHIFT', 15),
+        (82, 'while') : ('SHIFT', 20),
+        (82, 'false') : ('SHIFT', 28),
+        (82, 'not') : ('SHIFT', 26),
+        (82, 'id') : ('SHIFT', 18),
+        (82, 'if') : ('SHIFT', 24),
+        (82, 'new') : ('SHIFT', 22),
+        (82, 'int') : ('SHIFT', 21),
+        (82, '{') : ('SHIFT', 14),
+        (82, 'isvoid') : ('SHIFT', 34),
+        (82, 'true') : ('SHIFT', 27),
+        (82, '(') : ('SHIFT', 13),
+        (82, 'string') : ('SHIFT', 29),
+        (83, 'fi') : ('SHIFT', 84),
+        (84, '/') : ('REDUCE', 49),
+        (84, '<') : ('REDUCE', 49),
+        (84, '<=') : ('REDUCE', 49),
+        (84, '@') : ('REDUCE', 49),
+        (84, 'in') : ('REDUCE', 49),
+        (84, ';') : ('REDUCE', 49),
+        (84, 'loop') : ('REDUCE', 49),
+        (84, 'pool') : ('REDUCE', 49),
+        (84, ',') : ('REDUCE', 49),
+        (84, '.') : ('REDUCE', 49),
+        (84, ')') : ('REDUCE', 49),
+        (84, 'then') : ('REDUCE', 49),
+        (84, 'else') : ('REDUCE', 49),
+        (84, '}') : ('REDUCE', 49),
+        (84, 'fi') : ('REDUCE', 49),
+        (84, '=') : ('REDUCE', 49),
+        (84, '+') : ('REDUCE', 49),
+        (84, 'of') : ('REDUCE', 49),
+        (84, '-') : ('REDUCE', 49),
+        (84, '*') : ('REDUCE', 49),
+        (85, 'loop') : ('SHIFT', 86),
+        (86, 'id') : ('SHIFT', 18),
+        (86, 'case') : ('SHIFT', 25),
+        (86, 'let') : ('SHIFT', 8),
+        (86, 'if') : ('SHIFT', 24),
+        (86, 'while') : ('SHIFT', 20),
+        (86, 'new') : ('SHIFT', 22),
+        (86, 'isvoid') : ('SHIFT', 34),
+        (86, 'int') : ('SHIFT', 21),
+        (86, 'true') : ('SHIFT', 27),
+        (86, '(') : ('SHIFT', 13),
+        (86, 'string') : ('SHIFT', 29),
+        (86, '~') : ('SHIFT', 15),
+        (86, 'false') : ('SHIFT', 28),
+        (86, '{') : ('SHIFT', 14),
+        (86, 'not') : ('SHIFT', 26),
+        (87, 'pool') : ('SHIFT', 88),
+        (88, ',') : ('REDUCE', 16),
+        (88, 'fi') : ('REDUCE', 16),
+        (88, 'pool') : ('REDUCE', 16),
+        (88, 'in') : ('REDUCE', 16),
+        (88, ';') : ('REDUCE', 16),
+        (88, ')') : ('REDUCE', 16),
+        (88, 'of') : ('REDUCE', 16),
+        (88, 'then') : ('REDUCE', 16),
+        (88, 'loop') : ('REDUCE', 16),
+        (88, 'else') : ('REDUCE', 16),
+        (88, '}') : ('REDUCE', 16),
+        (89, ',') : ('REDUCE', 15),
+        (89, 'fi') : ('REDUCE', 15),
+        (89, 'pool') : ('REDUCE', 15),
+        (89, 'in') : ('REDUCE', 15),
+        (89, ';') : ('REDUCE', 15),
+        (89, ')') : ('REDUCE', 15),
+        (89, 'of') : ('REDUCE', 15),
+        (89, 'then') : ('REDUCE', 15),
+        (89, 'loop') : ('REDUCE', 15),
+        (89, 'else') : ('REDUCE', 15),
+        (89, '}') : ('REDUCE', 15),
+        (90, ')') : ('SHIFT', 91),
+        (90, ',') : ('SHIFT', 43),
+        (91, '/') : ('REDUCE', 53),
+        (91, '<') : ('REDUCE', 53),
+        (91, '<=') : ('REDUCE', 53),
+        (91, '@') : ('REDUCE', 53),
+        (91, 'in') : ('REDUCE', 53),
+        (91, ';') : ('REDUCE', 53),
+        (91, 'loop') : ('REDUCE', 53),
+        (91, 'pool') : ('REDUCE', 53),
+        (91, ',') : ('REDUCE', 53),
+        (91, '.') : ('REDUCE', 53),
+        (91, ')') : ('REDUCE', 53),
+        (91, 'then') : ('REDUCE', 53),
+        (91, 'else') : ('REDUCE', 53),
+        (91, '}') : ('REDUCE', 53),
+        (91, 'fi') : ('REDUCE', 53),
+        (91, '=') : ('REDUCE', 53),
+        (91, '+') : ('REDUCE', 53),
+        (91, 'of') : ('REDUCE', 53),
+        (91, '-') : ('REDUCE', 53),
+        (91, '*') : ('REDUCE', 53),
+        (92, ',') : ('REDUCE', 40),
+        (92, '/') : ('REDUCE', 40),
+        (92, 'fi') : ('REDUCE', 40),
+        (92, 'pool') : ('REDUCE', 40),
+        (92, '<') : ('REDUCE', 40),
+        (92, 'in') : ('REDUCE', 40),
+        (92, '=') : ('REDUCE', 40),
+        (92, '<=') : ('REDUCE', 40),
+        (92, ';') : ('REDUCE', 40),
+        (92, '+') : ('REDUCE', 40),
+        (92, '*') : ('REDUCE', 40),
+        (92, ')') : ('REDUCE', 40),
+        (92, 'of') : ('REDUCE', 40),
+        (92, 'then') : ('REDUCE', 40),
+        (92, '-') : ('REDUCE', 40),
+        (92, 'loop') : ('REDUCE', 40),
+        (92, 'else') : ('REDUCE', 40),
+        (92, '}') : ('REDUCE', 40),
+        (93, '}') : ('SHIFT', 94),
+        (94, ',') : ('REDUCE', 17),
+        (94, 'fi') : ('REDUCE', 17),
+        (94, 'pool') : ('REDUCE', 17),
+        (94, 'in') : ('REDUCE', 17),
+        (94, ';') : ('REDUCE', 17),
+        (94, ')') : ('REDUCE', 17),
+        (94, 'of') : ('REDUCE', 17),
+        (94, 'then') : ('REDUCE', 17),
+        (94, 'loop') : ('REDUCE', 17),
+        (94, 'else') : ('REDUCE', 17),
+        (94, '}') : ('REDUCE', 17),
+        (95, ';') : ('SHIFT', 96),
+        (96, 'true') : ('SHIFT', 27),
+        (96, 'not') : ('SHIFT', 26),
+        (96, 'case') : ('SHIFT', 25),
+        (96, '(') : ('SHIFT', 13),
+        (96, 'let') : ('SHIFT', 8),
+        (96, 'string') : ('SHIFT', 29),
+        (96, 'while') : ('SHIFT', 20),
+        (96, '}') : ('REDUCE', 18),
+        (96, 'false') : ('SHIFT', 28),
+        (96, 'isvoid') : ('SHIFT', 34),
+        (96, 'id') : ('SHIFT', 18),
+        (96, 'if') : ('SHIFT', 24),
+        (96, '{') : ('SHIFT', 14),
+        (96, '~') : ('SHIFT', 15),
+        (96, 'new') : ('SHIFT', 22),
+        (96, 'int') : ('SHIFT', 21),
         (97, '}') : ('REDUCE', 19),
-        (97, '~') : ('SHIFT', 15),
-        (97, 'new') : ('SHIFT', 22),
-        (97, 'true') : ('SHIFT', 28),
-        (97, 'not') : ('SHIFT', 26),
-        (98, '}') : ('REDUCE', 20),
-        (99, ')') : ('SHIFT', 100),
-        (100, 'fi') : ('REDUCE', 51),
-        (100, '=') : ('REDUCE', 51),
-        (100, '+') : ('REDUCE', 51),
-        (100, '-') : ('REDUCE', 51),
-        (100, 'of') : ('REDUCE', 51),
-        (100, '*') : ('REDUCE', 51),
-        (100, '/') : ('REDUCE', 51),
-        (100, '<') : ('REDUCE', 51),
-        (100, '<=') : ('REDUCE', 51),
-        (100, '@') : ('REDUCE', 51),
-        (100, 'in') : ('REDUCE', 51),
-        (100, ';') : ('REDUCE', 51),
-        (100, 'loop') : ('REDUCE', 51),
-        (100, 'pool') : ('REDUCE', 51),
-        (100, ',') : ('REDUCE', 51),
-        (100, '.') : ('REDUCE', 51),
-        (100, ')') : ('REDUCE', 51),
-        (100, 'then') : ('REDUCE', 51),
-        (100, 'else') : ('REDUCE', 51),
-        (100, '}') : ('REDUCE', 51),
-        (101, 'in') : ('REDUCE', 23),
-        (101, ',') : ('SHIFT', 102),
-        (102, 'id') : ('SHIFT', 9),
-        (103, 'in') : ('REDUCE', 25),
-        (104, 'id') : ('SHIFT', 9),
-        (105, 'in') : ('REDUCE', 24),
-        (106, 'in') : ('SHIFT', 107),
-        (107, 'false') : ('SHIFT', 29),
-        (107, '{') : ('SHIFT', 14),
-        (107, 'id') : ('SHIFT', 18),
-        (107, 'string') : ('SHIFT', 30),
-        (107, 'int') : ('SHIFT', 21),
-        (107, 'isvoid') : ('SHIFT', 27),
-        (107, 'let') : ('SHIFT', 8),
-        (107, 'if') : ('SHIFT', 24),
-        (107, 'case') : ('SHIFT', 25),
-        (107, 'new') : ('SHIFT', 22),
-        (107, 'true') : ('SHIFT', 28),
-        (107, 'while') : ('SHIFT', 20),
-        (107, '~') : ('SHIFT', 15),
-        (107, '(') : ('SHIFT', 13),
-        (107, 'not') : ('SHIFT', 26),
-        (108, '}') : ('REDUCE', 21),
-        (108, 'fi') : ('REDUCE', 21),
-        (108, 'in') : ('REDUCE', 21),
-        (108, ';') : ('REDUCE', 21),
-        (108, ')') : ('REDUCE', 21),
-        (108, 'then') : ('REDUCE', 21),
-        (108, 'of') : ('REDUCE', 21),
-        (108, 'loop') : ('REDUCE', 21),
-        (108, 'else') : ('REDUCE', 21),
-        (108, 'pool') : ('REDUCE', 21),
-        (108, ',') : ('REDUCE', 21),
-        (109, ';') : ('REDUCE', 9),
-        (110, 'id') : ('SHIFT', 111),
-        (110, ')') : ('REDUCE', 13),
-        (111, ':') : ('SHIFT', 112),
-        (112, 'type') : ('SHIFT', 113),
-        (113, ')') : ('REDUCE', 14),
-        (113, ',') : ('REDUCE', 14),
-        (114, ')') : ('SHIFT', 115),
-        (115, ':') : ('SHIFT', 116),
-        (116, 'type') : ('SHIFT', 117),
-        (117, '{') : ('SHIFT', 118),
-        (118, 'isvoid') : ('SHIFT', 27),
-        (118, 'id') : ('SHIFT', 18),
-        (118, 'let') : ('SHIFT', 8),
-        (118, 'new') : ('SHIFT', 22),
-        (118, 'true') : ('SHIFT', 28),
-        (118, 'while') : ('SHIFT', 20),
-        (118, '~') : ('SHIFT', 15),
-        (118, '(') : ('SHIFT', 13),
-        (118, 'not') : ('SHIFT', 26),
-        (118, 'int') : ('SHIFT', 21),
-        (118, '{') : ('SHIFT', 14),
-        (118, 'false') : ('SHIFT', 29),
-        (118, 'if') : ('SHIFT', 24),
-        (118, 'string') : ('SHIFT', 30),
-        (118, 'case') : ('SHIFT', 25),
-        (119, '}') : ('SHIFT', 120),
-        (120, ';') : ('REDUCE', 10),
-        (121, ')') : ('REDUCE', 11),
-        (121, ',') : ('SHIFT', 122),
-        (122, 'id') : ('SHIFT', 111),
-        (122, ')') : ('REDUCE', 13),
-        (123, ')') : ('REDUCE', 12),
-        (124, '}') : ('SHIFT', 125),
-        (125, ';') : ('REDUCE', 3),
-        (126, ';') : ('SHIFT', 127),
-        (127, 'id') : ('SHIFT', 4),
-        (127, '}') : ('REDUCE', 7),
-        (128, '}') : ('REDUCE', 5),
-        (129, ';') : ('SHIFT', 130),
-        (130, 'id') : ('SHIFT', 4),
-        (130, '}') : ('REDUCE', 7),
-        (131, '}') : ('REDUCE', 6),
-        (132, 'type') : ('SHIFT', 133),
-        (133, '{') : ('SHIFT', 134),
-        (134, '}') : ('REDUCE', 7),
-        (134, 'id') : ('SHIFT', 4),
-        (135, '}') : ('SHIFT', 136),
-        (136, ';') : ('REDUCE', 4),
-        (137, '$') : ('REDUCE', 0),
-        (141, '$') : ('OK', None),
-        (138, ';') : ('SHIFT', 139),
-        (139, '$') : ('REDUCE', 1),
-        (139, 'class') : ('SHIFT', 1),
-        (140, '$') : ('REDUCE', 2)
+        (98, ')') : ('SHIFT', 99),
+        (99, '/') : ('REDUCE', 50),
+        (99, '<') : ('REDUCE', 50),
+        (99, '<=') : ('REDUCE', 50),
+        (99, '@') : ('REDUCE', 50),
+        (99, 'in') : ('REDUCE', 50),
+        (99, ';') : ('REDUCE', 50),
+        (99, 'loop') : ('REDUCE', 50),
+        (99, 'pool') : ('REDUCE', 50),
+        (99, ',') : ('REDUCE', 50),
+        (99, '.') : ('REDUCE', 50),
+        (99, ')') : ('REDUCE', 50),
+        (99, 'then') : ('REDUCE', 50),
+        (99, 'else') : ('REDUCE', 50),
+        (99, '}') : ('REDUCE', 50),
+        (99, 'fi') : ('REDUCE', 50),
+        (99, '=') : ('REDUCE', 50),
+        (99, '+') : ('REDUCE', 50),
+        (99, 'of') : ('REDUCE', 50),
+        (99, '-') : ('REDUCE', 50),
+        (99, '*') : ('REDUCE', 50),
+        (100, 'in') : ('REDUCE', 22),
+        (100, ',') : ('SHIFT', 101),
+        (101, 'id') : ('SHIFT', 9),
+        (102, 'in') : ('REDUCE', 24),
+        (103, 'id') : ('SHIFT', 9),
+        (104, 'in') : ('REDUCE', 23),
+        (105, 'in') : ('SHIFT', 106),
+        (106, 'string') : ('SHIFT', 29),
+        (106, 'false') : ('SHIFT', 28),
+        (106, 'id') : ('SHIFT', 18),
+        (106, 'isvoid') : ('SHIFT', 34),
+        (106, '{') : ('SHIFT', 14),
+        (106, 'if') : ('SHIFT', 24),
+        (106, '~') : ('SHIFT', 15),
+        (106, 'case') : ('SHIFT', 25),
+        (106, 'new') : ('SHIFT', 22),
+        (106, 'let') : ('SHIFT', 8),
+        (106, 'int') : ('SHIFT', 21),
+        (106, 'while') : ('SHIFT', 20),
+        (106, 'not') : ('SHIFT', 26),
+        (106, 'true') : ('SHIFT', 27),
+        (106, '(') : ('SHIFT', 13),
+        (107, ',') : ('REDUCE', 20),
+        (107, 'fi') : ('REDUCE', 20),
+        (107, 'pool') : ('REDUCE', 20),
+        (107, 'in') : ('REDUCE', 20),
+        (107, ';') : ('REDUCE', 20),
+        (107, ')') : ('REDUCE', 20),
+        (107, 'of') : ('REDUCE', 20),
+        (107, 'then') : ('REDUCE', 20),
+        (107, 'loop') : ('REDUCE', 20),
+        (107, 'else') : ('REDUCE', 20),
+        (107, '}') : ('REDUCE', 20),
+        (108, ';') : ('REDUCE', 9),
+        (109, 'id') : ('SHIFT', 110),
+        (109, ',') : ('REDUCE', 13),
+        (109, ')') : ('REDUCE', 13),
+        (110, ':') : ('SHIFT', 111),
+        (111, 'type') : ('SHIFT', 112),
+        (112, ',') : ('REDUCE', 14),
+        (112, ')') : ('REDUCE', 14),
+        (113, ',') : ('SHIFT', 114),
+        (113, ')') : ('SHIFT', 116),
+        (114, 'id') : ('SHIFT', 110),
+        (115, ',') : ('REDUCE', 12),
+        (115, ')') : ('REDUCE', 12),
+        (116, ':') : ('SHIFT', 117),
+        (117, 'type') : ('SHIFT', 118),
+        (118, '{') : ('SHIFT', 119),
+        (119, 'not') : ('SHIFT', 26),
+        (119, 'case') : ('SHIFT', 25),
+        (119, 'let') : ('SHIFT', 8),
+        (119, 'new') : ('SHIFT', 22),
+        (119, 'int') : ('SHIFT', 21),
+        (119, 'while') : ('SHIFT', 20),
+        (119, 'true') : ('SHIFT', 27),
+        (119, '(') : ('SHIFT', 13),
+        (119, 'string') : ('SHIFT', 29),
+        (119, 'isvoid') : ('SHIFT', 34),
+        (119, 'false') : ('SHIFT', 28),
+        (119, 'id') : ('SHIFT', 18),
+        (119, '{') : ('SHIFT', 14),
+        (119, '~') : ('SHIFT', 15),
+        (119, 'if') : ('SHIFT', 24),
+        (120, '}') : ('SHIFT', 121),
+        (121, ';') : ('REDUCE', 10),
+        (122, ',') : ('REDUCE', 11),
+        (122, ')') : ('REDUCE', 11),
+        (123, '}') : ('SHIFT', 124),
+        (124, ';') : ('REDUCE', 3),
+        (125, ';') : ('SHIFT', 126),
+        (126, 'id') : ('SHIFT', 4),
+        (126, '}') : ('REDUCE', 7),
+        (127, '}') : ('REDUCE', 5),
+        (128, ';') : ('SHIFT', 129),
+        (129, 'id') : ('SHIFT', 4),
+        (129, '}') : ('REDUCE', 7),
+        (130, '}') : ('REDUCE', 6),
+        (131, 'type') : ('SHIFT', 132),
+        (132, '{') : ('SHIFT', 133),
+        (133, 'id') : ('SHIFT', 4),
+        (133, '}') : ('REDUCE', 7),
+        (134, '}') : ('SHIFT', 135),
+        (135, ';') : ('REDUCE', 4),
+        (136, '$') : ('REDUCE', 0),
+        (140, '$') : ('OK', None),
+        (137, ';') : ('SHIFT', 138),
+        (138, '$') : ('REDUCE', 1),
+        (138, 'class') : ('SHIFT', 1),
+        (139, '$') : ('REDUCE', 2)
         }
 
 
 
 
         self.goto = {
-        (0, '<class-list>') : 137,
-        (0, '<program>'): 141,
-        (0, '<def-class>') : 138,
-        (3, '<feature-list>') : 124,
-        (3, '<def-attr>') : 126,
-        (3, '<def-meth>') : 129,
-        (7, '<comp>') : 38,
-        (7, '<atom>') : 32,
-        (7, '<term>') : 51,
-        (7, '<factor>') : 48,
-        (7, '<arith>') : 59,
-        (7, '<expr>') : 109,
-        (7, '<dispatch>') : 45,
-        (7, '<boolean>') : 60,
-        (8, '<id-list>') : 106,
-        (12, '<comp>') : 38,
-        (12, '<term>') : 51,
-        (12, '<atom>') : 32,
-        (12, '<factor>') : 48,
-        (12, '<arith>') : 59,
-        (12, '<boolean>') : 60,
-        (12, '<expr>') : 101,
-        (12, '<dispatch>') : 45,
-        (13, '<expr>') : 99,
-        (13, '<comp>') : 38,
-        (13, '<term>') : 51,
-        (13, '<boolean>') : 60,
-        (13, '<atom>') : 32,
-        (13, '<arith>') : 59,
-        (13, '<factor>') : 48,
-        (13, '<dispatch>') : 45,
-        (14, '<comp>') : 38,
-        (14, '<atom>') : 32,
-        (14, '<term>') : 51,
-        (14, '<factor>') : 48,
-        (14, '<arith>') : 59,
-        (14, '<dispatch>') : 45,
-        (14, '<expr>') : 96,
-        (14, '<expr-list>') : 94,
-        (14, '<boolean>') : 60,
-        (15, '<atom>') : 32,
-        (15, '<factor>') : 93,
-        (15, '<dispatch>') : 45,
-        (17, '<term>') : 51,
-        (17, '<boolean>') : 60,
-        (17, '<atom>') : 32,
-        (17, '<arg-list>') : 91,
-        (17, '<arith>') : 59,
-        (17, '<comp>') : 38,
-        (17, '<expr>') : 56,
-        (17, '<factor>') : 48,
-        (17, '<dispatch>') : 45,
-        (19, '<comp>') : 38,
-        (19, '<term>') : 51,
-        (19, '<expr>') : 90,
-        (19, '<arith>') : 59,
-        (19, '<atom>') : 32,
-        (19, '<factor>') : 48,
-        (19, '<boolean>') : 60,
-        (19, '<dispatch>') : 45,
-        (20, '<atom>') : 32,
-        (20, '<term>') : 51,
-        (20, '<comp>') : 38,
-        (20, '<dispatch>') : 45,
-        (20, '<factor>') : 48,
-        (20, '<arith>') : 59,
-        (20, '<expr>') : 86,
-        (20, '<boolean>') : 60,
-        (24, '<comp>') : 38,
-        (24, '<term>') : 51,
-        (24, '<atom>') : 32,
-        (24, '<boolean>') : 60,
-        (24, '<dispatch>') : 45,
-        (24, '<factor>') : 48,
-        (24, '<arith>') : 59,
-        (24, '<expr>') : 80,
-        (25, '<atom>') : 32,
-        (25, '<arith>') : 59,
-        (25, '<boolean>') : 60,
-        (25, '<comp>') : 38,
-        (25, '<term>') : 51,
-        (25, '<dispatch>') : 45,
-        (25, '<expr>') : 69,
-        (25, '<factor>') : 48,
-        (26, '<comp>') : 68,
-        (26, '<term>') : 51,
-        (26, '<arith>') : 59,
-        (26, '<atom>') : 32,
-        (26, '<factor>') : 48,
-        (26, '<dispatch>') : 45,
-        (27, '<atom>') : 32,
-        (27, '<factor>') : 31,
-        (27, '<dispatch>') : 45,
-        (35, '<arg-list>') : 36,
-        (35, '<term>') : 51,
-        (35, '<boolean>') : 60,
-        (35, '<atom>') : 32,
-        (35, '<arith>') : 59,
-        (35, '<comp>') : 38,
-        (35, '<expr>') : 56,
-        (35, '<factor>') : 48,
-        (35, '<dispatch>') : 45,
-        (39, '<term>') : 51,
-        (39, '<atom>') : 32,
-        (39, '<factor>') : 48,
-        (39, '<arith>') : 40,
-        (39, '<dispatch>') : 45,
-        (41, '<term>') : 42,
-        (41, '<atom>') : 32,
-        (41, '<factor>') : 48,
-        (41, '<dispatch>') : 45,
-        (43, '<atom>') : 32,
-        (43, '<factor>') : 44,
-        (43, '<dispatch>') : 45,
-        (46, '<atom>') : 32,
-        (46, '<factor>') : 47,
-        (46, '<dispatch>') : 45,
-        (49, '<term>') : 50,
-        (49, '<atom>') : 32,
-        (49, '<factor>') : 48,
-        (49, '<dispatch>') : 45,
-        (52, '<arith>') : 53,
-        (52, '<term>') : 51,
-        (52, '<atom>') : 32,
-        (52, '<factor>') : 48,
-        (52, '<dispatch>') : 45,
-        (54, '<arith>') : 55,
-        (54, '<term>') : 51,
-        (54, '<atom>') : 32,
-        (54, '<factor>') : 48,
-        (54, '<dispatch>') : 45,
-        (57, '<term>') : 51,
-        (57, '<boolean>') : 60,
-        (57, '<atom>') : 32,
-        (57, '<arith>') : 59,
-        (57, '<comp>') : 38,
-        (57, '<expr>') : 56,
-        (57, '<factor>') : 48,
-        (57, '<arg-list>') : 58,
-        (57, '<dispatch>') : 45,
-        (65, '<term>') : 51,
-        (65, '<boolean>') : 60,
-        (65, '<atom>') : 32,
-        (65, '<arith>') : 59,
-        (65, '<comp>') : 38,
-        (65, '<arg-list>') : 66,
-        (65, '<expr>') : 56,
-        (65, '<factor>') : 48,
-        (65, '<dispatch>') : 45,
-        (70, '<case-list>') : 78,
-        (74, '<comp>') : 38,
-        (74, '<expr>') : 75,
-        (74, '<atom>') : 32,
-        (74, '<term>') : 51,
-        (74, '<factor>') : 48,
-        (74, '<arith>') : 59,
-        (74, '<dispatch>') : 45,
-        (74, '<boolean>') : 60,
-        (76, '<case-list>') : 77,
-        (81, '<term>') : 51,
-        (81, '<atom>') : 32,
-        (81, '<factor>') : 48,
-        (81, '<arith>') : 59,
-        (81, '<boolean>') : 60,
-        (81, '<comp>') : 38,
-        (81, '<expr>') : 82,
-        (81, '<dispatch>') : 45,
-        (83, '<arith>') : 59,
-        (83, '<atom>') : 32,
-        (83, '<comp>') : 38,
-        (83, '<term>') : 51,
-        (83, '<dispatch>') : 45,
-        (83, '<boolean>') : 60,
-        (83, '<factor>') : 48,
-        (83, '<expr>') : 84,
-        (87, '<expr>') : 88,
-        (87, '<comp>') : 38,
-        (87, '<arith>') : 59,
-        (87, '<boolean>') : 60,
-        (87, '<atom>') : 32,
-        (87, '<term>') : 51,
-        (87, '<factor>') : 48,
-        (87, '<dispatch>') : 45,
-        (97, '<comp>') : 38,
-        (97, '<atom>') : 32,
-        (97, '<term>') : 51,
-        (97, '<factor>') : 48,
-        (97, '<arith>') : 59,
-        (97, '<dispatch>') : 45,
-        (97, '<expr>') : 96,
-        (97, '<expr-list>') : 98,
-        (97, '<boolean>') : 60,
-        (102, '<id-list>') : 103,
-        (104, '<id-list>') : 105,
-        (107, '<comp>') : 38,
-        (107, '<term>') : 51,
-        (107, '<arith>') : 59,
-        (107, '<atom>') : 32,
-        (107, '<factor>') : 48,
-        (107, '<expr>') : 108,
-        (107, '<boolean>') : 60,
-        (107, '<dispatch>') : 45,
-        (110, '<param>') : 121,
-        (110, '<param-list>') : 114,
-        (118, '<arith>') : 59,
-        (118, '<atom>') : 32,
-        (118, '<term>') : 51,
-        (118, '<factor>') : 48,
-        (118, '<comp>') : 38,
-        (118, '<expr>') : 119,
-        (118, '<boolean>') : 60,
-        (118, '<dispatch>') : 45,
-        (122, '<param>') : 121,
-        (122, '<param-list>') : 123,
-        (127, '<def-attr>') : 126,
-        (127, '<feature-list>') : 128,
-        (127, '<def-meth>') : 129,
-        (130, '<def-attr>') : 126,
-        (130, '<feature-list>') : 131,
-        (130, '<def-meth>') : 129,
-        (134, '<def-attr>') : 126,
-        (134, '<def-meth>') : 129,
-        (134, '<feature-list>') : 135,
-        (139, '<def-class>') : 138,
-        (139, '<class-list>') : 140
+        (0, '<class-list>') : 136,
+        (0, '<program>') : 140,
+        (0, '<def-class>') : 137,
+        (3, '<def-attr>') : 125,
+        (3, '<feature-list>') : 123,
+        (3, '<def-meth>') : 128,
+        (7, '<atom>') : 36,
+        (7, '<factor>') : 54,
+        (7, '<arith>') : 63,
+        (7, '<comp>') : 44,
+        (7, '<dispatch>') : 51,
+        (7, '<term>') : 57,
+        (7, '<expr>') : 108,
+        (8, '<id-list>') : 105,
+        (12, '<arith>') : 63,
+        (12, '<factor>') : 54,
+        (12, '<atom>') : 36,
+        (12, '<comp>') : 44,
+        (12, '<term>') : 57,
+        (12, '<dispatch>') : 51,
+        (12, '<expr>') : 100,
+        (13, '<term>') : 57,
+        (13, '<atom>') : 36,
+        (13, '<dispatch>') : 51,
+        (13, '<arith>') : 63,
+        (13, '<comp>') : 44,
+        (13, '<factor>') : 54,
+        (13, '<expr>') : 98,
+        (14, '<atom>') : 36,
+        (14, '<expr-list>') : 93,
+        (14, '<factor>') : 54,
+        (14, '<expr>') : 95,
+        (14, '<arith>') : 63,
+        (14, '<comp>') : 44,
+        (14, '<dispatch>') : 51,
+        (14, '<term>') : 57,
+        (15, '<atom>') : 36,
+        (15, '<dispatch>') : 51,
+        (15, '<factor>') : 92,
+        (17, '<term>') : 57,
+        (17, '<comp>') : 44,
+        (17, '<expr>') : 65,
+        (17, '<atom>') : 36,
+        (17, '<arg-list>') : 90,
+        (17, '<arith>') : 63,
+        (17, '<factor>') : 54,
+        (17, '<dispatch>') : 51,
+        (19, '<comp>') : 44,
+        (19, '<arith>') : 63,
+        (19, '<atom>') : 36,
+        (19, '<term>') : 57,
+        (19, '<dispatch>') : 51,
+        (19, '<expr>') : 89,
+        (19, '<factor>') : 54,
+        (20, '<comp>') : 44,
+        (20, '<arith>') : 63,
+        (20, '<atom>') : 36,
+        (20, '<term>') : 57,
+        (20, '<expr>') : 85,
+        (20, '<dispatch>') : 51,
+        (20, '<factor>') : 54,
+        (24, '<term>') : 57,
+        (24, '<comp>') : 44,
+        (24, '<expr>') : 79,
+        (24, '<factor>') : 54,
+        (24, '<atom>') : 36,
+        (24, '<dispatch>') : 51,
+        (24, '<arith>') : 63,
+        (25, '<arith>') : 63,
+        (25, '<atom>') : 36,
+        (25, '<dispatch>') : 51,
+        (25, '<term>') : 57,
+        (25, '<expr>') : 68,
+        (25, '<comp>') : 44,
+        (25, '<factor>') : 54,
+        (26, '<atom>') : 30,
+        (26, '<dispatch>') : 51,
+        (33, '<term>') : 57,
+        (33, '<comp>') : 44,
+        (33, '<expr>') : 65,
+        (33, '<atom>') : 36,
+        (33, '<arg-list>') : 66,
+        (33, '<arith>') : 63,
+        (33, '<factor>') : 54,
+        (33, '<dispatch>') : 51,
+        (34, '<atom>') : 36,
+        (34, '<dispatch>') : 51,
+        (34, '<factor>') : 35,
+        (41, '<term>') : 57,
+        (41, '<comp>') : 44,
+        (41, '<expr>') : 65,
+        (41, '<atom>') : 36,
+        (41, '<arg-list>') : 42,
+        (41, '<arith>') : 63,
+        (41, '<factor>') : 54,
+        (41, '<dispatch>') : 51,
+        (43, '<term>') : 57,
+        (43, '<comp>') : 44,
+        (43, '<atom>') : 36,
+        (43, '<expr>') : 62,
+        (43, '<arith>') : 63,
+        (43, '<factor>') : 54,
+        (43, '<dispatch>') : 51,
+        (45, '<atom>') : 36,
+        (45, '<dispatch>') : 51,
+        (45, '<arith>') : 46,
+        (45, '<term>') : 57,
+        (45, '<factor>') : 54,
+        (47, '<atom>') : 36,
+        (47, '<dispatch>') : 51,
+        (47, '<term>') : 48,
+        (47, '<factor>') : 54,
+        (49, '<atom>') : 36,
+        (49, '<dispatch>') : 51,
+        (49, '<factor>') : 50,
+        (52, '<atom>') : 36,
+        (52, '<dispatch>') : 51,
+        (52, '<factor>') : 53,
+        (55, '<atom>') : 36,
+        (55, '<dispatch>') : 51,
+        (55, '<term>') : 56,
+        (55, '<factor>') : 54,
+        (58, '<atom>') : 36,
+        (58, '<dispatch>') : 51,
+        (58, '<term>') : 57,
+        (58, '<arith>') : 59,
+        (58, '<factor>') : 54,
+        (60, '<atom>') : 36,
+        (60, '<dispatch>') : 51,
+        (60, '<term>') : 57,
+        (60, '<arith>') : 61,
+        (60, '<factor>') : 54,
+        (69, '<case-list>') : 77,
+        (73, '<atom>') : 36,
+        (73, '<factor>') : 54,
+        (73, '<expr>') : 74,
+        (73, '<arith>') : 63,
+        (73, '<comp>') : 44,
+        (73, '<dispatch>') : 51,
+        (73, '<term>') : 57,
+        (75, '<case-list>') : 76,
+        (80, '<arith>') : 63,
+        (80, '<term>') : 57,
+        (80, '<comp>') : 44,
+        (80, '<expr>') : 81,
+        (80, '<atom>') : 36,
+        (80, '<dispatch>') : 51,
+        (80, '<factor>') : 54,
+        (82, '<arith>') : 63,
+        (82, '<term>') : 57,
+        (82, '<comp>') : 44,
+        (82, '<factor>') : 54,
+        (82, '<dispatch>') : 51,
+        (82, '<expr>') : 83,
+        (82, '<atom>') : 36,
+        (86, '<atom>') : 36,
+        (86, '<dispatch>') : 51,
+        (86, '<arith>') : 63,
+        (86, '<comp>') : 44,
+        (86, '<term>') : 57,
+        (86, '<expr>') : 87,
+        (86, '<factor>') : 54,
+        (96, '<atom>') : 36,
+        (96, '<factor>') : 54,
+        (96, '<expr>') : 95,
+        (96, '<arith>') : 63,
+        (96, '<comp>') : 44,
+        (96, '<expr-list>') : 97,
+        (96, '<dispatch>') : 51,
+        (96, '<term>') : 57,
+        (101, '<id-list>') : 102,
+        (103, '<id-list>') : 104,
+        (106, '<comp>') : 44,
+        (106, '<arith>') : 63,
+        (106, '<atom>') : 36,
+        (106, '<term>') : 57,
+        (106, '<dispatch>') : 51,
+        (106, '<expr>') : 107,
+        (106, '<factor>') : 54,
+        (109, '<param-list>') : 113,
+        (109, '<param>') : 122,
+        (114, '<param>') : 115,
+        (119, '<factor>') : 54,
+        (119, '<arith>') : 63,
+        (119, '<atom>') : 36,
+        (119, '<comp>') : 44,
+        (119, '<term>') : 57,
+        (119, '<dispatch>') : 51,
+        (119, '<expr>') : 120,
+        (126, '<def-attr>') : 125,
+        (126, '<feature-list>') : 127,
+        (126, '<def-meth>') : 128,
+        (129, '<def-attr>') : 125,
+        (129, '<def-meth>') : 128,
+        (129, '<feature-list>') : 130,
+        (133, '<feature-list>') : 134,
+        (133, '<def-attr>') : 125,
+        (133, '<def-meth>') : 128,
+        (138, '<class-list>') : 139,
+        (138, '<def-class>') : 137
         }
 
 

From b60c5e102b069203811ee88e3b00aefd9a4a77c8 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 23:29:31 -0800
Subject: [PATCH 33/83] parser ok

---
 src/main.py                     |    2 +-
 src/utils/COOL_Grammar.py       |   15 +-
 src/utils/parser/COOL_parser.py | 2086 +++++++++++++++----------------
 3 files changed, 1052 insertions(+), 1051 deletions(-)

diff --git a/src/main.py b/src/main.py
index c0d03122b..4983b1b1e 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "parser/dispatch2.cl"
+    add = "parser/dispatch8.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 93d3b7f18..25fe8b993 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -11,7 +11,7 @@ def build_COOL_Grammar():
     feature_list, def_attr, def_meth, arg_list = G.NonTerminals('<feature-list> <def-attr> <def-meth> <arg-list>')
     expr, expr_list, id_list, case_list, comp = G.NonTerminals('<expr> <expr-list> <id-list> <case-list> <comp>')
     expr, arith, term, factor, atom, dispatch = G.NonTerminals('<expr> <arith> <term> <factor> <atom> <dispatch>')
-    not_empty = G.NonTerminal('<not_empty>')
+    nonEmpty_argList, nonEmpty_paramList = G.NonTerminals('<nonEmpty-argList> <nonEmpty-paramList>')
 
     #terminales
     classx, let, inx = G.Terminals('class let in')
@@ -40,15 +40,16 @@ def build_COOL_Grammar():
 
     def_meth %= idx + opar + param_list + cpar + colon + typex + ocur + expr + ccur, lambda h,s: node.MethDeclarationNode(s[1],s[3],s[6],s[8],s[7])
 
-    param_list %= param, lambda h,s: [s[1]]
-    param_list %= param_list + comma + param, lambda h,s: [s[1]] + s[3]
     param_list %= G.Epsilon, lambda h,s: []
+    param_list %= nonEmpty_paramList, lambda h,s: s[1]
+
+    nonEmpty_paramList %= param, lambda h,s: [s[1]]
+    nonEmpty_paramList %= param + comma + nonEmpty_paramList, lambda h,s: [s[1]] + s[3]
 
     param %= idx + colon + typex, lambda h,s: [s[1],s[3]]
 
     expr %= idx + arrow + expr, lambda h,s: node.AssignNode(s[1],s[3],s[2])
     expr %= whilex + expr + loop + expr + pool, lambda h,s: node.WhileNode(s[2],s[4],s[1])
-    
 
     expr %= ocur + expr_list + ccur, lambda h,s: node.BlockNode(s[2],s[1])
 
@@ -101,8 +102,10 @@ def build_COOL_Grammar():
     dispatch %= idx + opar + arg_list + cpar, lambda h,s: node.CallNode(s[1],s[3])
     dispatch %= atom + at + typex + dot + idx + opar + arg_list + cpar, lambda h,s: node.CallNode(s[5],s[7],s[1],s[3])
 
-    arg_list %= expr, lambda h,s: [s[1]]
-    arg_list %= arg_list + comma + expr, lambda h,s: [s[1]] + s[3]
     arg_list %= G.Epsilon, lambda h,s: []
+    arg_list %= nonEmpty_argList, lambda h,s: s[1]
+
+    nonEmpty_argList %= expr, lambda h,s: [s[1]]
+    nonEmpty_argList %= expr + comma + nonEmpty_argList, lambda h,s: [s[1]] + s[3]
 
     return G
\ No newline at end of file
diff --git a/src/utils/parser/COOL_parser.py b/src/utils/parser/COOL_parser.py
index 418810cb8..edaa3ba96 100644
--- a/src/utils/parser/COOL_parser.py
+++ b/src/utils/parser/COOL_parser.py
@@ -23,1291 +23,1289 @@ def __init__(self, G):
         self.action = {
         (0, 'class') : ('SHIFT', 1),
         (1, 'type') : ('SHIFT', 2),
-        (2, 'inherits') : ('SHIFT', 131),
         (2, '{') : ('SHIFT', 3),
+        (2, 'inherits') : ('SHIFT', 133),
         (3, 'id') : ('SHIFT', 4),
         (3, '}') : ('REDUCE', 7),
-        (4, '(') : ('SHIFT', 109),
+        (4, '(') : ('SHIFT', 110),
         (4, ':') : ('SHIFT', 5),
         (5, 'type') : ('SHIFT', 6),
         (6, '<-') : ('SHIFT', 7),
         (6, ';') : ('REDUCE', 8),
+        (7, 'id') : ('SHIFT', 18),
         (7, 'true') : ('SHIFT', 27),
-        (7, 'not') : ('SHIFT', 26),
-        (7, 'case') : ('SHIFT', 25),
+        (7, 'new') : ('SHIFT', 22),
+        (7, 'if') : ('SHIFT', 24),
         (7, '(') : ('SHIFT', 13),
         (7, 'let') : ('SHIFT', 8),
+        (7, '~') : ('SHIFT', 15),
+        (7, 'int') : ('SHIFT', 21),
         (7, 'string') : ('SHIFT', 29),
+        (7, 'not') : ('SHIFT', 26),
         (7, 'while') : ('SHIFT', 20),
-        (7, 'false') : ('SHIFT', 28),
         (7, 'isvoid') : ('SHIFT', 34),
-        (7, 'id') : ('SHIFT', 18),
-        (7, 'if') : ('SHIFT', 24),
+        (7, 'case') : ('SHIFT', 25),
+        (7, 'false') : ('SHIFT', 28),
         (7, '{') : ('SHIFT', 14),
-        (7, '~') : ('SHIFT', 15),
-        (7, 'new') : ('SHIFT', 22),
-        (7, 'int') : ('SHIFT', 21),
         (8, 'id') : ('SHIFT', 9),
         (9, ':') : ('SHIFT', 10),
         (10, 'type') : ('SHIFT', 11),
-        (11, ',') : ('SHIFT', 103),
+        (11, ',') : ('SHIFT', 104),
         (11, '<-') : ('SHIFT', 12),
-        (11, 'in') : ('REDUCE', 21),
-        (12, 'id') : ('SHIFT', 18),
-        (12, 'int') : ('SHIFT', 21),
+        (11, 'in') : ('REDUCE', 22),
+        (12, 'false') : ('SHIFT', 28),
         (12, 'not') : ('SHIFT', 26),
+        (12, 'while') : ('SHIFT', 20),
+        (12, 'id') : ('SHIFT', 18),
+        (12, 'isvoid') : ('SHIFT', 34),
+        (12, 'case') : ('SHIFT', 25),
         (12, 'true') : ('SHIFT', 27),
+        (12, 'new') : ('SHIFT', 22),
+        (12, 'if') : ('SHIFT', 24),
         (12, '(') : ('SHIFT', 13),
         (12, '{') : ('SHIFT', 14),
+        (12, 'int') : ('SHIFT', 21),
         (12, 'string') : ('SHIFT', 29),
-        (12, 'case') : ('SHIFT', 25),
-        (12, 'false') : ('SHIFT', 28),
         (12, 'let') : ('SHIFT', 8),
-        (12, 'while') : ('SHIFT', 20),
-        (12, 'isvoid') : ('SHIFT', 34),
         (12, '~') : ('SHIFT', 15),
-        (12, 'if') : ('SHIFT', 24),
-        (12, 'new') : ('SHIFT', 22),
         (13, 'id') : ('SHIFT', 18),
-        (13, 'case') : ('SHIFT', 25),
-        (13, 'if') : ('SHIFT', 24),
         (13, 'let') : ('SHIFT', 8),
+        (13, 'false') : ('SHIFT', 28),
         (13, '~') : ('SHIFT', 15),
-        (13, 'while') : ('SHIFT', 20),
+        (13, 'true') : ('SHIFT', 27),
+        (13, 'if') : ('SHIFT', 24),
+        (13, '(') : ('SHIFT', 13),
         (13, 'new') : ('SHIFT', 22),
         (13, 'not') : ('SHIFT', 26),
+        (13, 'while') : ('SHIFT', 20),
+        (13, 'case') : ('SHIFT', 25),
+        (13, 'isvoid') : ('SHIFT', 34),
         (13, 'int') : ('SHIFT', 21),
-        (13, 'true') : ('SHIFT', 27),
-        (13, '(') : ('SHIFT', 13),
         (13, 'string') : ('SHIFT', 29),
-        (13, 'false') : ('SHIFT', 28),
         (13, '{') : ('SHIFT', 14),
-        (13, 'isvoid') : ('SHIFT', 34),
+        (14, 'id') : ('SHIFT', 18),
         (14, 'true') : ('SHIFT', 27),
-        (14, 'not') : ('SHIFT', 26),
-        (14, 'case') : ('SHIFT', 25),
+        (14, 'new') : ('SHIFT', 22),
+        (14, 'if') : ('SHIFT', 24),
         (14, '(') : ('SHIFT', 13),
         (14, 'let') : ('SHIFT', 8),
-        (14, 'while') : ('SHIFT', 20),
+        (14, '~') : ('SHIFT', 15),
+        (14, 'int') : ('SHIFT', 21),
         (14, 'string') : ('SHIFT', 29),
-        (14, 'false') : ('SHIFT', 28),
+        (14, 'not') : ('SHIFT', 26),
+        (14, 'while') : ('SHIFT', 20),
         (14, 'isvoid') : ('SHIFT', 34),
-        (14, 'id') : ('SHIFT', 18),
-        (14, 'if') : ('SHIFT', 24),
-        (14, 'int') : ('SHIFT', 21),
+        (14, 'case') : ('SHIFT', 25),
+        (14, 'false') : ('SHIFT', 28),
         (14, '{') : ('SHIFT', 14),
-        (14, '~') : ('SHIFT', 15),
-        (14, 'new') : ('SHIFT', 22),
+        (15, 'true') : ('SHIFT', 27),
         (15, 'id') : ('SHIFT', 16),
-        (15, 'string') : ('SHIFT', 29),
         (15, 'if') : ('SHIFT', 24),
+        (15, '(') : ('SHIFT', 13),
         (15, '~') : ('SHIFT', 15),
-        (15, 'false') : ('SHIFT', 28),
         (15, 'new') : ('SHIFT', 22),
+        (15, 'false') : ('SHIFT', 28),
         (15, 'int') : ('SHIFT', 21),
+        (15, 'string') : ('SHIFT', 29),
         (15, 'not') : ('SHIFT', 26),
         (15, 'isvoid') : ('SHIFT', 34),
-        (15, 'true') : ('SHIFT', 27),
-        (15, '(') : ('SHIFT', 13),
-        (16, '/') : ('REDUCE', 47),
-        (16, '<') : ('REDUCE', 47),
-        (16, '<=') : ('REDUCE', 47),
-        (16, '@') : ('REDUCE', 47),
-        (16, 'in') : ('REDUCE', 47),
-        (16, ';') : ('REDUCE', 47),
-        (16, 'loop') : ('REDUCE', 47),
-        (16, 'pool') : ('REDUCE', 47),
-        (16, ',') : ('REDUCE', 47),
-        (16, '.') : ('REDUCE', 47),
-        (16, ')') : ('REDUCE', 47),
-        (16, 'then') : ('REDUCE', 47),
-        (16, 'else') : ('REDUCE', 47),
-        (16, '}') : ('REDUCE', 47),
-        (16, 'fi') : ('REDUCE', 47),
-        (16, '=') : ('REDUCE', 47),
-        (16, '+') : ('REDUCE', 47),
-        (16, 'of') : ('REDUCE', 47),
-        (16, '-') : ('REDUCE', 47),
-        (16, '*') : ('REDUCE', 47),
         (16, '(') : ('SHIFT', 17),
-        (17, 'if') : ('SHIFT', 24),
-        (17, '{') : ('SHIFT', 14),
-        (17, 'new') : ('SHIFT', 22),
-        (17, 'int') : ('SHIFT', 21),
-        (17, 'isvoid') : ('SHIFT', 34),
-        (17, 'true') : ('SHIFT', 27),
-        (17, 'case') : ('SHIFT', 25),
-        (17, '(') : ('SHIFT', 13),
-        (17, 'string') : ('SHIFT', 29),
+        (16, '-') : ('REDUCE', 48),
+        (16, 'of') : ('REDUCE', 48),
+        (16, '*') : ('REDUCE', 48),
+        (16, '/') : ('REDUCE', 48),
+        (16, '<') : ('REDUCE', 48),
+        (16, '<=') : ('REDUCE', 48),
+        (16, '@') : ('REDUCE', 48),
+        (16, 'in') : ('REDUCE', 48),
+        (16, ';') : ('REDUCE', 48),
+        (16, 'loop') : ('REDUCE', 48),
+        (16, 'pool') : ('REDUCE', 48),
+        (16, ',') : ('REDUCE', 48),
+        (16, '.') : ('REDUCE', 48),
+        (16, ')') : ('REDUCE', 48),
+        (16, 'then') : ('REDUCE', 48),
+        (16, 'else') : ('REDUCE', 48),
+        (16, '}') : ('REDUCE', 48),
+        (16, 'fi') : ('REDUCE', 48),
+        (16, '=') : ('REDUCE', 48),
+        (16, '+') : ('REDUCE', 48),
         (17, 'let') : ('SHIFT', 8),
-        (17, 'while') : ('SHIFT', 20),
-        (17, ',') : ('REDUCE', 57),
-        (17, ')') : ('REDUCE', 57),
+        (17, 'int') : ('SHIFT', 21),
         (17, '~') : ('SHIFT', 15),
-        (17, 'false') : ('SHIFT', 28),
+        (17, 'string') : ('SHIFT', 29),
+        (17, 'new') : ('SHIFT', 22),
+        (17, ')') : ('REDUCE', 56),
         (17, 'not') : ('SHIFT', 26),
         (17, 'id') : ('SHIFT', 18),
+        (17, 'isvoid') : ('SHIFT', 34),
+        (17, 'while') : ('SHIFT', 20),
+        (17, 'false') : ('SHIFT', 28),
+        (17, 'case') : ('SHIFT', 25),
+        (17, '{') : ('SHIFT', 14),
+        (17, 'true') : ('SHIFT', 27),
+        (17, 'if') : ('SHIFT', 24),
+        (17, '(') : ('SHIFT', 13),
         (18, '<-') : ('SHIFT', 19),
-        (18, '/') : ('REDUCE', 47),
-        (18, '<') : ('REDUCE', 47),
-        (18, '<=') : ('REDUCE', 47),
-        (18, '@') : ('REDUCE', 47),
-        (18, 'in') : ('REDUCE', 47),
-        (18, ';') : ('REDUCE', 47),
-        (18, 'loop') : ('REDUCE', 47),
-        (18, 'pool') : ('REDUCE', 47),
-        (18, ',') : ('REDUCE', 47),
-        (18, '.') : ('REDUCE', 47),
-        (18, ')') : ('REDUCE', 47),
-        (18, 'then') : ('REDUCE', 47),
-        (18, 'else') : ('REDUCE', 47),
-        (18, '}') : ('REDUCE', 47),
-        (18, 'fi') : ('REDUCE', 47),
-        (18, '=') : ('REDUCE', 47),
-        (18, '+') : ('REDUCE', 47),
-        (18, 'of') : ('REDUCE', 47),
-        (18, '-') : ('REDUCE', 47),
-        (18, '*') : ('REDUCE', 47),
         (18, '(') : ('SHIFT', 17),
-        (19, 'string') : ('SHIFT', 29),
-        (19, 'false') : ('SHIFT', 28),
-        (19, 'id') : ('SHIFT', 18),
-        (19, 'isvoid') : ('SHIFT', 34),
-        (19, '{') : ('SHIFT', 14),
+        (18, '-') : ('REDUCE', 48),
+        (18, 'of') : ('REDUCE', 48),
+        (18, '*') : ('REDUCE', 48),
+        (18, '/') : ('REDUCE', 48),
+        (18, '<') : ('REDUCE', 48),
+        (18, '<=') : ('REDUCE', 48),
+        (18, '@') : ('REDUCE', 48),
+        (18, 'in') : ('REDUCE', 48),
+        (18, ';') : ('REDUCE', 48),
+        (18, 'loop') : ('REDUCE', 48),
+        (18, 'pool') : ('REDUCE', 48),
+        (18, ',') : ('REDUCE', 48),
+        (18, '.') : ('REDUCE', 48),
+        (18, ')') : ('REDUCE', 48),
+        (18, 'then') : ('REDUCE', 48),
+        (18, 'else') : ('REDUCE', 48),
+        (18, '}') : ('REDUCE', 48),
+        (18, 'fi') : ('REDUCE', 48),
+        (18, '=') : ('REDUCE', 48),
+        (18, '+') : ('REDUCE', 48),
+        (19, 'true') : ('SHIFT', 27),
         (19, 'if') : ('SHIFT', 24),
+        (19, 'id') : ('SHIFT', 18),
+        (19, '(') : ('SHIFT', 13),
         (19, '~') : ('SHIFT', 15),
-        (19, 'case') : ('SHIFT', 25),
         (19, 'new') : ('SHIFT', 22),
         (19, 'let') : ('SHIFT', 8),
         (19, 'int') : ('SHIFT', 21),
-        (19, 'while') : ('SHIFT', 20),
+        (19, 'string') : ('SHIFT', 29),
         (19, 'not') : ('SHIFT', 26),
-        (19, 'true') : ('SHIFT', 27),
-        (19, '(') : ('SHIFT', 13),
+        (19, 'isvoid') : ('SHIFT', 34),
+        (19, 'while') : ('SHIFT', 20),
+        (19, 'case') : ('SHIFT', 25),
+        (19, 'false') : ('SHIFT', 28),
+        (19, '{') : ('SHIFT', 14),
+        (20, 'isvoid') : ('SHIFT', 34),
         (20, 'id') : ('SHIFT', 18),
-        (20, 'new') : ('SHIFT', 22),
         (20, '{') : ('SHIFT', 14),
-        (20, 'int') : ('SHIFT', 21),
         (20, 'true') : ('SHIFT', 27),
+        (20, 'if') : ('SHIFT', 24),
+        (20, 'new') : ('SHIFT', 22),
         (20, '(') : ('SHIFT', 13),
+        (20, 'int') : ('SHIFT', 21),
         (20, 'string') : ('SHIFT', 29),
-        (20, 'if') : ('SHIFT', 24),
-        (20, 'case') : ('SHIFT', 25),
         (20, 'let') : ('SHIFT', 8),
-        (20, 'isvoid') : ('SHIFT', 34),
+        (20, '~') : ('SHIFT', 15),
         (20, 'while') : ('SHIFT', 20),
         (20, 'false') : ('SHIFT', 28),
-        (20, '~') : ('SHIFT', 15),
         (20, 'not') : ('SHIFT', 26),
-        (21, '/') : ('REDUCE', 46),
-        (21, '<') : ('REDUCE', 46),
-        (21, '<=') : ('REDUCE', 46),
-        (21, '@') : ('REDUCE', 46),
-        (21, 'in') : ('REDUCE', 46),
-        (21, ';') : ('REDUCE', 46),
-        (21, 'loop') : ('REDUCE', 46),
-        (21, 'pool') : ('REDUCE', 46),
-        (21, ',') : ('REDUCE', 46),
-        (21, '.') : ('REDUCE', 46),
-        (21, ')') : ('REDUCE', 46),
-        (21, 'then') : ('REDUCE', 46),
-        (21, 'else') : ('REDUCE', 46),
-        (21, '}') : ('REDUCE', 46),
-        (21, 'fi') : ('REDUCE', 46),
-        (21, '=') : ('REDUCE', 46),
-        (21, '+') : ('REDUCE', 46),
-        (21, 'of') : ('REDUCE', 46),
-        (21, '-') : ('REDUCE', 46),
-        (21, '*') : ('REDUCE', 46),
+        (20, 'case') : ('SHIFT', 25),
+        (21, '-') : ('REDUCE', 47),
+        (21, 'of') : ('REDUCE', 47),
+        (21, '*') : ('REDUCE', 47),
+        (21, '/') : ('REDUCE', 47),
+        (21, '<') : ('REDUCE', 47),
+        (21, '<=') : ('REDUCE', 47),
+        (21, '@') : ('REDUCE', 47),
+        (21, 'in') : ('REDUCE', 47),
+        (21, ';') : ('REDUCE', 47),
+        (21, 'loop') : ('REDUCE', 47),
+        (21, 'pool') : ('REDUCE', 47),
+        (21, ',') : ('REDUCE', 47),
+        (21, '.') : ('REDUCE', 47),
+        (21, ')') : ('REDUCE', 47),
+        (21, 'then') : ('REDUCE', 47),
+        (21, 'else') : ('REDUCE', 47),
+        (21, '}') : ('REDUCE', 47),
+        (21, 'fi') : ('REDUCE', 47),
+        (21, '=') : ('REDUCE', 47),
+        (21, '+') : ('REDUCE', 47),
         (22, 'type') : ('SHIFT', 23),
-        (23, '/') : ('REDUCE', 48),
-        (23, '<') : ('REDUCE', 48),
-        (23, '<=') : ('REDUCE', 48),
-        (23, '@') : ('REDUCE', 48),
-        (23, 'in') : ('REDUCE', 48),
-        (23, ';') : ('REDUCE', 48),
-        (23, 'loop') : ('REDUCE', 48),
-        (23, 'pool') : ('REDUCE', 48),
-        (23, ',') : ('REDUCE', 48),
-        (23, '.') : ('REDUCE', 48),
-        (23, ')') : ('REDUCE', 48),
-        (23, 'then') : ('REDUCE', 48),
-        (23, 'else') : ('REDUCE', 48),
-        (23, '}') : ('REDUCE', 48),
-        (23, 'fi') : ('REDUCE', 48),
-        (23, '=') : ('REDUCE', 48),
-        (23, '+') : ('REDUCE', 48),
-        (23, 'of') : ('REDUCE', 48),
-        (23, '-') : ('REDUCE', 48),
-        (23, '*') : ('REDUCE', 48),
-        (24, '(') : ('SHIFT', 13),
-        (24, 'id') : ('SHIFT', 18),
+        (23, '-') : ('REDUCE', 49),
+        (23, 'of') : ('REDUCE', 49),
+        (23, '*') : ('REDUCE', 49),
+        (23, '/') : ('REDUCE', 49),
+        (23, '<') : ('REDUCE', 49),
+        (23, '<=') : ('REDUCE', 49),
+        (23, '@') : ('REDUCE', 49),
+        (23, 'in') : ('REDUCE', 49),
+        (23, ';') : ('REDUCE', 49),
+        (23, 'loop') : ('REDUCE', 49),
+        (23, 'pool') : ('REDUCE', 49),
+        (23, ',') : ('REDUCE', 49),
+        (23, '.') : ('REDUCE', 49),
+        (23, ')') : ('REDUCE', 49),
+        (23, 'then') : ('REDUCE', 49),
+        (23, 'else') : ('REDUCE', 49),
+        (23, '}') : ('REDUCE', 49),
+        (23, 'fi') : ('REDUCE', 49),
+        (23, '=') : ('REDUCE', 49),
+        (23, '+') : ('REDUCE', 49),
+        (24, 'int') : ('SHIFT', 21),
+        (24, 'not') : ('SHIFT', 26),
         (24, 'string') : ('SHIFT', 29),
-        (24, '~') : ('SHIFT', 15),
+        (24, 'isvoid') : ('SHIFT', 34),
+        (24, 'while') : ('SHIFT', 20),
+        (24, 'id') : ('SHIFT', 18),
+        (24, 'case') : ('SHIFT', 25),
         (24, '{') : ('SHIFT', 14),
-        (24, 'not') : ('SHIFT', 26),
         (24, 'false') : ('SHIFT', 28),
-        (24, 'case') : ('SHIFT', 25),
         (24, 'let') : ('SHIFT', 8),
-        (24, 'while') : ('SHIFT', 20),
         (24, 'if') : ('SHIFT', 24),
-        (24, 'isvoid') : ('SHIFT', 34),
-        (24, 'new') : ('SHIFT', 22),
-        (24, 'int') : ('SHIFT', 21),
+        (24, '~') : ('SHIFT', 15),
         (24, 'true') : ('SHIFT', 27),
-        (25, 'isvoid') : ('SHIFT', 34),
-        (25, 'id') : ('SHIFT', 18),
-        (25, 'case') : ('SHIFT', 25),
+        (24, 'new') : ('SHIFT', 22),
+        (24, '(') : ('SHIFT', 13),
         (25, 'let') : ('SHIFT', 8),
-        (25, 'if') : ('SHIFT', 24),
-        (25, 'while') : ('SHIFT', 20),
+        (25, 'id') : ('SHIFT', 18),
         (25, '~') : ('SHIFT', 15),
-        (25, 'new') : ('SHIFT', 22),
-        (25, 'int') : ('SHIFT', 21),
+        (25, 'while') : ('SHIFT', 20),
+        (25, 'false') : ('SHIFT', 28),
+        (25, 'case') : ('SHIFT', 25),
         (25, 'not') : ('SHIFT', 26),
         (25, 'true') : ('SHIFT', 27),
+        (25, '{') : ('SHIFT', 14),
+        (25, 'new') : ('SHIFT', 22),
+        (25, 'if') : ('SHIFT', 24),
         (25, '(') : ('SHIFT', 13),
+        (25, 'isvoid') : ('SHIFT', 34),
+        (25, 'int') : ('SHIFT', 21),
         (25, 'string') : ('SHIFT', 29),
-        (25, 'false') : ('SHIFT', 28),
-        (25, '{') : ('SHIFT', 14),
+        (26, 'true') : ('SHIFT', 27),
+        (26, 'int') : ('SHIFT', 21),
         (26, 'id') : ('SHIFT', 16),
-        (26, 'false') : ('SHIFT', 28),
         (26, 'string') : ('SHIFT', 29),
-        (26, 'new') : ('SHIFT', 22),
-        (26, 'int') : ('SHIFT', 21),
         (26, 'if') : ('SHIFT', 24),
-        (26, 'true') : ('SHIFT', 27),
         (26, '(') : ('SHIFT', 13),
-        (27, '/') : ('REDUCE', 43),
-        (27, '<') : ('REDUCE', 43),
-        (27, '<=') : ('REDUCE', 43),
-        (27, '@') : ('REDUCE', 43),
-        (27, 'in') : ('REDUCE', 43),
-        (27, ';') : ('REDUCE', 43),
-        (27, 'loop') : ('REDUCE', 43),
-        (27, 'pool') : ('REDUCE', 43),
-        (27, ',') : ('REDUCE', 43),
-        (27, '.') : ('REDUCE', 43),
-        (27, ')') : ('REDUCE', 43),
-        (27, 'then') : ('REDUCE', 43),
-        (27, 'else') : ('REDUCE', 43),
-        (27, '}') : ('REDUCE', 43),
-        (27, 'fi') : ('REDUCE', 43),
-        (27, '=') : ('REDUCE', 43),
-        (27, '+') : ('REDUCE', 43),
-        (27, 'of') : ('REDUCE', 43),
-        (27, '-') : ('REDUCE', 43),
-        (27, '*') : ('REDUCE', 43),
-        (28, '/') : ('REDUCE', 44),
-        (28, '<') : ('REDUCE', 44),
-        (28, '<=') : ('REDUCE', 44),
-        (28, '@') : ('REDUCE', 44),
-        (28, 'in') : ('REDUCE', 44),
-        (28, ';') : ('REDUCE', 44),
-        (28, 'loop') : ('REDUCE', 44),
-        (28, 'pool') : ('REDUCE', 44),
-        (28, ',') : ('REDUCE', 44),
-        (28, '.') : ('REDUCE', 44),
-        (28, ')') : ('REDUCE', 44),
-        (28, 'then') : ('REDUCE', 44),
-        (28, 'else') : ('REDUCE', 44),
-        (28, '}') : ('REDUCE', 44),
-        (28, 'fi') : ('REDUCE', 44),
-        (28, '=') : ('REDUCE', 44),
-        (28, '+') : ('REDUCE', 44),
-        (28, 'of') : ('REDUCE', 44),
-        (28, '-') : ('REDUCE', 44),
-        (28, '*') : ('REDUCE', 44),
-        (29, '/') : ('REDUCE', 45),
-        (29, '<') : ('REDUCE', 45),
-        (29, '<=') : ('REDUCE', 45),
-        (29, '@') : ('REDUCE', 45),
-        (29, 'in') : ('REDUCE', 45),
-        (29, ';') : ('REDUCE', 45),
-        (29, 'loop') : ('REDUCE', 45),
-        (29, 'pool') : ('REDUCE', 45),
-        (29, ',') : ('REDUCE', 45),
-        (29, '.') : ('REDUCE', 45),
-        (29, ')') : ('REDUCE', 45),
-        (29, 'then') : ('REDUCE', 45),
-        (29, 'else') : ('REDUCE', 45),
-        (29, '}') : ('REDUCE', 45),
-        (29, 'fi') : ('REDUCE', 45),
-        (29, '=') : ('REDUCE', 45),
-        (29, '+') : ('REDUCE', 45),
-        (29, 'of') : ('REDUCE', 45),
-        (29, '-') : ('REDUCE', 45),
-        (29, '*') : ('REDUCE', 45),
-        (30, ',') : ('REDUCE', 41),
-        (30, '/') : ('REDUCE', 41),
-        (30, 'fi') : ('REDUCE', 41),
-        (30, 'pool') : ('REDUCE', 41),
-        (30, '<') : ('REDUCE', 41),
-        (30, 'in') : ('REDUCE', 41),
-        (30, '=') : ('REDUCE', 41),
-        (30, '<=') : ('REDUCE', 41),
-        (30, ';') : ('REDUCE', 41),
-        (30, '+') : ('REDUCE', 41),
-        (30, '*') : ('REDUCE', 41),
-        (30, ')') : ('REDUCE', 41),
-        (30, 'of') : ('REDUCE', 41),
-        (30, 'then') : ('REDUCE', 41),
-        (30, '-') : ('REDUCE', 41),
-        (30, 'loop') : ('REDUCE', 41),
-        (30, 'else') : ('REDUCE', 41),
-        (30, '}') : ('REDUCE', 41),
-        (30, '.') : ('SHIFT', 31),
+        (26, 'new') : ('SHIFT', 22),
+        (26, 'false') : ('SHIFT', 28),
+        (27, '-') : ('REDUCE', 44),
+        (27, 'of') : ('REDUCE', 44),
+        (27, '*') : ('REDUCE', 44),
+        (27, '/') : ('REDUCE', 44),
+        (27, '<') : ('REDUCE', 44),
+        (27, '<=') : ('REDUCE', 44),
+        (27, '@') : ('REDUCE', 44),
+        (27, 'in') : ('REDUCE', 44),
+        (27, ';') : ('REDUCE', 44),
+        (27, 'loop') : ('REDUCE', 44),
+        (27, 'pool') : ('REDUCE', 44),
+        (27, ',') : ('REDUCE', 44),
+        (27, '.') : ('REDUCE', 44),
+        (27, ')') : ('REDUCE', 44),
+        (27, 'then') : ('REDUCE', 44),
+        (27, 'else') : ('REDUCE', 44),
+        (27, '}') : ('REDUCE', 44),
+        (27, 'fi') : ('REDUCE', 44),
+        (27, '=') : ('REDUCE', 44),
+        (27, '+') : ('REDUCE', 44),
+        (28, '-') : ('REDUCE', 45),
+        (28, 'of') : ('REDUCE', 45),
+        (28, '*') : ('REDUCE', 45),
+        (28, '/') : ('REDUCE', 45),
+        (28, '<') : ('REDUCE', 45),
+        (28, '<=') : ('REDUCE', 45),
+        (28, '@') : ('REDUCE', 45),
+        (28, 'in') : ('REDUCE', 45),
+        (28, ';') : ('REDUCE', 45),
+        (28, 'loop') : ('REDUCE', 45),
+        (28, 'pool') : ('REDUCE', 45),
+        (28, ',') : ('REDUCE', 45),
+        (28, '.') : ('REDUCE', 45),
+        (28, ')') : ('REDUCE', 45),
+        (28, 'then') : ('REDUCE', 45),
+        (28, 'else') : ('REDUCE', 45),
+        (28, '}') : ('REDUCE', 45),
+        (28, 'fi') : ('REDUCE', 45),
+        (28, '=') : ('REDUCE', 45),
+        (28, '+') : ('REDUCE', 45),
+        (29, '-') : ('REDUCE', 46),
+        (29, 'of') : ('REDUCE', 46),
+        (29, '*') : ('REDUCE', 46),
+        (29, '/') : ('REDUCE', 46),
+        (29, '<') : ('REDUCE', 46),
+        (29, '<=') : ('REDUCE', 46),
+        (29, '@') : ('REDUCE', 46),
+        (29, 'in') : ('REDUCE', 46),
+        (29, ';') : ('REDUCE', 46),
+        (29, 'loop') : ('REDUCE', 46),
+        (29, 'pool') : ('REDUCE', 46),
+        (29, ',') : ('REDUCE', 46),
+        (29, '.') : ('REDUCE', 46),
+        (29, ')') : ('REDUCE', 46),
+        (29, 'then') : ('REDUCE', 46),
+        (29, 'else') : ('REDUCE', 46),
+        (29, '}') : ('REDUCE', 46),
+        (29, 'fi') : ('REDUCE', 46),
+        (29, '=') : ('REDUCE', 46),
+        (29, '+') : ('REDUCE', 46),
         (30, '@') : ('SHIFT', 37),
+        (30, '.') : ('SHIFT', 31),
+        (30, '-') : ('REDUCE', 42),
+        (30, 'then') : ('REDUCE', 42),
+        (30, 'loop') : ('REDUCE', 42),
+        (30, 'of') : ('REDUCE', 42),
+        (30, ';') : ('REDUCE', 42),
+        (30, '*') : ('REDUCE', 42),
+        (30, 'else') : ('REDUCE', 42),
+        (30, 'pool') : ('REDUCE', 42),
+        (30, '}') : ('REDUCE', 42),
+        (30, ',') : ('REDUCE', 42),
+        (30, '/') : ('REDUCE', 42),
+        (30, 'fi') : ('REDUCE', 42),
+        (30, '<') : ('REDUCE', 42),
+        (30, 'in') : ('REDUCE', 42),
+        (30, '=') : ('REDUCE', 42),
+        (30, '<=') : ('REDUCE', 42),
+        (30, '+') : ('REDUCE', 42),
+        (30, ')') : ('REDUCE', 42),
         (31, 'id') : ('SHIFT', 32),
         (32, '(') : ('SHIFT', 33),
-        (33, 'if') : ('SHIFT', 24),
-        (33, '{') : ('SHIFT', 14),
-        (33, 'new') : ('SHIFT', 22),
-        (33, 'int') : ('SHIFT', 21),
-        (33, 'isvoid') : ('SHIFT', 34),
-        (33, 'true') : ('SHIFT', 27),
-        (33, 'case') : ('SHIFT', 25),
-        (33, '(') : ('SHIFT', 13),
-        (33, 'string') : ('SHIFT', 29),
         (33, 'let') : ('SHIFT', 8),
-        (33, 'while') : ('SHIFT', 20),
-        (33, ',') : ('REDUCE', 57),
-        (33, ')') : ('REDUCE', 57),
+        (33, 'int') : ('SHIFT', 21),
         (33, '~') : ('SHIFT', 15),
-        (33, 'false') : ('SHIFT', 28),
+        (33, 'string') : ('SHIFT', 29),
+        (33, 'new') : ('SHIFT', 22),
+        (33, ')') : ('REDUCE', 56),
         (33, 'not') : ('SHIFT', 26),
         (33, 'id') : ('SHIFT', 18),
+        (33, 'isvoid') : ('SHIFT', 34),
+        (33, 'while') : ('SHIFT', 20),
+        (33, 'false') : ('SHIFT', 28),
+        (33, 'case') : ('SHIFT', 25),
+        (33, '{') : ('SHIFT', 14),
+        (33, 'true') : ('SHIFT', 27),
+        (33, 'if') : ('SHIFT', 24),
+        (33, '(') : ('SHIFT', 13),
+        (34, 'true') : ('SHIFT', 27),
         (34, 'id') : ('SHIFT', 16),
-        (34, 'string') : ('SHIFT', 29),
         (34, 'if') : ('SHIFT', 24),
+        (34, '(') : ('SHIFT', 13),
         (34, '~') : ('SHIFT', 15),
-        (34, 'false') : ('SHIFT', 28),
         (34, 'new') : ('SHIFT', 22),
+        (34, 'false') : ('SHIFT', 28),
         (34, 'int') : ('SHIFT', 21),
+        (34, 'string') : ('SHIFT', 29),
         (34, 'not') : ('SHIFT', 26),
         (34, 'isvoid') : ('SHIFT', 34),
-        (34, 'true') : ('SHIFT', 27),
-        (34, '(') : ('SHIFT', 13),
-        (35, ',') : ('REDUCE', 39),
-        (35, '/') : ('REDUCE', 39),
-        (35, 'fi') : ('REDUCE', 39),
-        (35, 'pool') : ('REDUCE', 39),
-        (35, '<') : ('REDUCE', 39),
-        (35, 'in') : ('REDUCE', 39),
-        (35, '=') : ('REDUCE', 39),
-        (35, '<=') : ('REDUCE', 39),
-        (35, ';') : ('REDUCE', 39),
-        (35, '+') : ('REDUCE', 39),
-        (35, '*') : ('REDUCE', 39),
-        (35, ')') : ('REDUCE', 39),
-        (35, 'of') : ('REDUCE', 39),
-        (35, 'then') : ('REDUCE', 39),
-        (35, '-') : ('REDUCE', 39),
-        (35, 'loop') : ('REDUCE', 39),
-        (35, 'else') : ('REDUCE', 39),
-        (35, '}') : ('REDUCE', 39),
-        (36, ',') : ('REDUCE', 42),
-        (36, '/') : ('REDUCE', 42),
-        (36, 'fi') : ('REDUCE', 42),
-        (36, 'pool') : ('REDUCE', 42),
-        (36, '<') : ('REDUCE', 42),
-        (36, 'in') : ('REDUCE', 42),
-        (36, '=') : ('REDUCE', 42),
-        (36, '<=') : ('REDUCE', 42),
-        (36, ';') : ('REDUCE', 42),
-        (36, '+') : ('REDUCE', 42),
-        (36, '*') : ('REDUCE', 42),
-        (36, ')') : ('REDUCE', 42),
-        (36, 'of') : ('REDUCE', 42),
-        (36, 'then') : ('REDUCE', 42),
-        (36, '-') : ('REDUCE', 42),
-        (36, 'loop') : ('REDUCE', 42),
-        (36, 'else') : ('REDUCE', 42),
-        (36, '}') : ('REDUCE', 42),
-        (36, '.') : ('SHIFT', 31),
+        (35, '-') : ('REDUCE', 40),
+        (35, 'then') : ('REDUCE', 40),
+        (35, 'loop') : ('REDUCE', 40),
+        (35, 'of') : ('REDUCE', 40),
+        (35, ';') : ('REDUCE', 40),
+        (35, '*') : ('REDUCE', 40),
+        (35, 'else') : ('REDUCE', 40),
+        (35, 'pool') : ('REDUCE', 40),
+        (35, '}') : ('REDUCE', 40),
+        (35, ',') : ('REDUCE', 40),
+        (35, '/') : ('REDUCE', 40),
+        (35, 'fi') : ('REDUCE', 40),
+        (35, '<') : ('REDUCE', 40),
+        (35, 'in') : ('REDUCE', 40),
+        (35, '=') : ('REDUCE', 40),
+        (35, '<=') : ('REDUCE', 40),
+        (35, '+') : ('REDUCE', 40),
+        (35, ')') : ('REDUCE', 40),
         (36, '@') : ('SHIFT', 37),
+        (36, '.') : ('SHIFT', 31),
+        (36, '-') : ('REDUCE', 43),
+        (36, 'then') : ('REDUCE', 43),
+        (36, 'loop') : ('REDUCE', 43),
+        (36, 'of') : ('REDUCE', 43),
+        (36, ';') : ('REDUCE', 43),
+        (36, '*') : ('REDUCE', 43),
+        (36, 'else') : ('REDUCE', 43),
+        (36, 'pool') : ('REDUCE', 43),
+        (36, '}') : ('REDUCE', 43),
+        (36, ',') : ('REDUCE', 43),
+        (36, '/') : ('REDUCE', 43),
+        (36, 'fi') : ('REDUCE', 43),
+        (36, '<') : ('REDUCE', 43),
+        (36, 'in') : ('REDUCE', 43),
+        (36, '=') : ('REDUCE', 43),
+        (36, '<=') : ('REDUCE', 43),
+        (36, '+') : ('REDUCE', 43),
+        (36, ')') : ('REDUCE', 43),
         (37, 'type') : ('SHIFT', 38),
         (38, '.') : ('SHIFT', 39),
         (39, 'id') : ('SHIFT', 40),
         (40, '(') : ('SHIFT', 41),
-        (41, 'if') : ('SHIFT', 24),
-        (41, '{') : ('SHIFT', 14),
-        (41, 'new') : ('SHIFT', 22),
-        (41, 'int') : ('SHIFT', 21),
-        (41, 'isvoid') : ('SHIFT', 34),
-        (41, 'true') : ('SHIFT', 27),
-        (41, 'case') : ('SHIFT', 25),
-        (41, '(') : ('SHIFT', 13),
-        (41, 'string') : ('SHIFT', 29),
         (41, 'let') : ('SHIFT', 8),
-        (41, 'while') : ('SHIFT', 20),
-        (41, ',') : ('REDUCE', 57),
-        (41, ')') : ('REDUCE', 57),
+        (41, 'int') : ('SHIFT', 21),
         (41, '~') : ('SHIFT', 15),
-        (41, 'false') : ('SHIFT', 28),
+        (41, 'string') : ('SHIFT', 29),
+        (41, 'new') : ('SHIFT', 22),
+        (41, ')') : ('REDUCE', 56),
         (41, 'not') : ('SHIFT', 26),
         (41, 'id') : ('SHIFT', 18),
-        (42, ',') : ('SHIFT', 43),
-        (42, ')') : ('SHIFT', 64),
-        (43, 'if') : ('SHIFT', 24),
-        (43, '{') : ('SHIFT', 14),
-        (43, 'new') : ('SHIFT', 22),
-        (43, 'int') : ('SHIFT', 21),
-        (43, 'isvoid') : ('SHIFT', 34),
-        (43, 'true') : ('SHIFT', 27),
-        (43, 'case') : ('SHIFT', 25),
-        (43, '(') : ('SHIFT', 13),
-        (43, 'string') : ('SHIFT', 29),
-        (43, 'let') : ('SHIFT', 8),
-        (43, 'while') : ('SHIFT', 20),
-        (43, '~') : ('SHIFT', 15),
-        (43, 'false') : ('SHIFT', 28),
-        (43, 'not') : ('SHIFT', 26),
-        (43, 'id') : ('SHIFT', 18),
-        (44, '<') : ('SHIFT', 58),
+        (41, 'isvoid') : ('SHIFT', 34),
+        (41, 'while') : ('SHIFT', 20),
+        (41, 'false') : ('SHIFT', 28),
+        (41, 'case') : ('SHIFT', 25),
+        (41, '{') : ('SHIFT', 14),
+        (41, 'true') : ('SHIFT', 27),
+        (41, 'if') : ('SHIFT', 24),
+        (41, '(') : ('SHIFT', 13),
+        (42, ')') : ('SHIFT', 43),
+        (43, '-') : ('REDUCE', 55),
+        (43, 'of') : ('REDUCE', 55),
+        (43, '*') : ('REDUCE', 55),
+        (43, '/') : ('REDUCE', 55),
+        (43, '<') : ('REDUCE', 55),
+        (43, '<=') : ('REDUCE', 55),
+        (43, '@') : ('REDUCE', 55),
+        (43, 'in') : ('REDUCE', 55),
+        (43, ';') : ('REDUCE', 55),
+        (43, 'loop') : ('REDUCE', 55),
+        (43, 'pool') : ('REDUCE', 55),
+        (43, ',') : ('REDUCE', 55),
+        (43, '.') : ('REDUCE', 55),
+        (43, ')') : ('REDUCE', 55),
+        (43, 'then') : ('REDUCE', 55),
+        (43, 'else') : ('REDUCE', 55),
+        (43, '}') : ('REDUCE', 55),
+        (43, 'fi') : ('REDUCE', 55),
+        (43, '=') : ('REDUCE', 55),
+        (43, '+') : ('REDUCE', 55),
         (44, '<=') : ('SHIFT', 60),
-        (44, ',') : ('REDUCE', 28),
-        (44, 'fi') : ('REDUCE', 28),
-        (44, 'in') : ('REDUCE', 28),
-        (44, ';') : ('REDUCE', 28),
-        (44, ')') : ('REDUCE', 28),
-        (44, 'of') : ('REDUCE', 28),
-        (44, 'then') : ('REDUCE', 28),
-        (44, 'loop') : ('REDUCE', 28),
-        (44, '}') : ('REDUCE', 28),
-        (44, 'else') : ('REDUCE', 28),
-        (44, 'pool') : ('REDUCE', 28),
+        (44, 'then') : ('REDUCE', 29),
+        (44, 'loop') : ('REDUCE', 29),
+        (44, 'of') : ('REDUCE', 29),
+        (44, 'else') : ('REDUCE', 29),
+        (44, 'pool') : ('REDUCE', 29),
+        (44, '}') : ('REDUCE', 29),
+        (44, ',') : ('REDUCE', 29),
+        (44, 'fi') : ('REDUCE', 29),
+        (44, 'in') : ('REDUCE', 29),
+        (44, ';') : ('REDUCE', 29),
+        (44, ')') : ('REDUCE', 29),
+        (44, '<') : ('SHIFT', 58),
         (44, '=') : ('SHIFT', 45),
+        (45, 'true') : ('SHIFT', 27),
         (45, 'id') : ('SHIFT', 16),
-        (45, 'string') : ('SHIFT', 29),
         (45, 'if') : ('SHIFT', 24),
+        (45, '(') : ('SHIFT', 13),
         (45, '~') : ('SHIFT', 15),
-        (45, 'false') : ('SHIFT', 28),
         (45, 'new') : ('SHIFT', 22),
+        (45, 'false') : ('SHIFT', 28),
         (45, 'int') : ('SHIFT', 21),
+        (45, 'string') : ('SHIFT', 29),
         (45, 'not') : ('SHIFT', 26),
         (45, 'isvoid') : ('SHIFT', 34),
-        (45, 'true') : ('SHIFT', 27),
-        (45, '(') : ('SHIFT', 13),
         (46, '-') : ('SHIFT', 55),
         (46, '+') : ('SHIFT', 47),
-        (46, ',') : ('REDUCE', 31),
-        (46, 'fi') : ('REDUCE', 31),
-        (46, 'pool') : ('REDUCE', 31),
-        (46, '<') : ('REDUCE', 31),
-        (46, 'in') : ('REDUCE', 31),
-        (46, '=') : ('REDUCE', 31),
-        (46, '<=') : ('REDUCE', 31),
-        (46, ';') : ('REDUCE', 31),
-        (46, ')') : ('REDUCE', 31),
-        (46, 'of') : ('REDUCE', 31),
-        (46, 'then') : ('REDUCE', 31),
-        (46, 'loop') : ('REDUCE', 31),
-        (46, 'else') : ('REDUCE', 31),
-        (46, '}') : ('REDUCE', 31),
+        (46, 'then') : ('REDUCE', 32),
+        (46, 'loop') : ('REDUCE', 32),
+        (46, 'of') : ('REDUCE', 32),
+        (46, ';') : ('REDUCE', 32),
+        (46, 'else') : ('REDUCE', 32),
+        (46, 'pool') : ('REDUCE', 32),
+        (46, '}') : ('REDUCE', 32),
+        (46, ',') : ('REDUCE', 32),
+        (46, 'fi') : ('REDUCE', 32),
+        (46, '<') : ('REDUCE', 32),
+        (46, 'in') : ('REDUCE', 32),
+        (46, '=') : ('REDUCE', 32),
+        (46, '<=') : ('REDUCE', 32),
+        (46, ')') : ('REDUCE', 32),
+        (47, 'true') : ('SHIFT', 27),
         (47, 'id') : ('SHIFT', 16),
-        (47, 'string') : ('SHIFT', 29),
         (47, 'if') : ('SHIFT', 24),
+        (47, '(') : ('SHIFT', 13),
         (47, '~') : ('SHIFT', 15),
-        (47, 'false') : ('SHIFT', 28),
         (47, 'new') : ('SHIFT', 22),
+        (47, 'false') : ('SHIFT', 28),
         (47, 'int') : ('SHIFT', 21),
+        (47, 'string') : ('SHIFT', 29),
         (47, 'not') : ('SHIFT', 26),
         (47, 'isvoid') : ('SHIFT', 34),
-        (47, 'true') : ('SHIFT', 27),
-        (47, '(') : ('SHIFT', 13),
-        (48, '/') : ('SHIFT', 52),
-        (48, ',') : ('REDUCE', 33),
-        (48, 'fi') : ('REDUCE', 33),
-        (48, 'pool') : ('REDUCE', 33),
-        (48, '<') : ('REDUCE', 33),
-        (48, 'in') : ('REDUCE', 33),
-        (48, '=') : ('REDUCE', 33),
-        (48, '<=') : ('REDUCE', 33),
-        (48, ';') : ('REDUCE', 33),
-        (48, '+') : ('REDUCE', 33),
-        (48, ')') : ('REDUCE', 33),
-        (48, 'of') : ('REDUCE', 33),
-        (48, 'then') : ('REDUCE', 33),
-        (48, '-') : ('REDUCE', 33),
-        (48, 'loop') : ('REDUCE', 33),
-        (48, 'else') : ('REDUCE', 33),
-        (48, '}') : ('REDUCE', 33),
+        (48, '-') : ('REDUCE', 34),
+        (48, 'then') : ('REDUCE', 34),
+        (48, 'loop') : ('REDUCE', 34),
+        (48, 'of') : ('REDUCE', 34),
+        (48, ';') : ('REDUCE', 34),
+        (48, 'else') : ('REDUCE', 34),
+        (48, 'pool') : ('REDUCE', 34),
+        (48, '}') : ('REDUCE', 34),
+        (48, ',') : ('REDUCE', 34),
+        (48, 'fi') : ('REDUCE', 34),
+        (48, '<') : ('REDUCE', 34),
+        (48, 'in') : ('REDUCE', 34),
+        (48, '=') : ('REDUCE', 34),
+        (48, '<=') : ('REDUCE', 34),
+        (48, '+') : ('REDUCE', 34),
+        (48, ')') : ('REDUCE', 34),
         (48, '*') : ('SHIFT', 49),
+        (48, '/') : ('SHIFT', 52),
+        (49, 'true') : ('SHIFT', 27),
         (49, 'id') : ('SHIFT', 16),
-        (49, 'string') : ('SHIFT', 29),
         (49, 'if') : ('SHIFT', 24),
+        (49, '(') : ('SHIFT', 13),
         (49, '~') : ('SHIFT', 15),
-        (49, 'false') : ('SHIFT', 28),
         (49, 'new') : ('SHIFT', 22),
+        (49, 'false') : ('SHIFT', 28),
         (49, 'int') : ('SHIFT', 21),
+        (49, 'string') : ('SHIFT', 29),
         (49, 'not') : ('SHIFT', 26),
         (49, 'isvoid') : ('SHIFT', 34),
-        (49, 'true') : ('SHIFT', 27),
-        (49, '(') : ('SHIFT', 13),
-        (50, ',') : ('REDUCE', 36),
-        (50, '/') : ('REDUCE', 36),
-        (50, 'fi') : ('REDUCE', 36),
-        (50, 'pool') : ('REDUCE', 36),
-        (50, '<') : ('REDUCE', 36),
-        (50, 'in') : ('REDUCE', 36),
-        (50, '=') : ('REDUCE', 36),
-        (50, '<=') : ('REDUCE', 36),
-        (50, ';') : ('REDUCE', 36),
-        (50, '+') : ('REDUCE', 36),
-        (50, '*') : ('REDUCE', 36),
-        (50, ')') : ('REDUCE', 36),
-        (50, 'of') : ('REDUCE', 36),
-        (50, 'then') : ('REDUCE', 36),
-        (50, '-') : ('REDUCE', 36),
-        (50, 'loop') : ('REDUCE', 36),
-        (50, 'else') : ('REDUCE', 36),
-        (50, '}') : ('REDUCE', 36),
-        (51, '/') : ('REDUCE', 51),
-        (51, '<') : ('REDUCE', 51),
-        (51, '<=') : ('REDUCE', 51),
-        (51, '@') : ('REDUCE', 51),
-        (51, 'in') : ('REDUCE', 51),
-        (51, ';') : ('REDUCE', 51),
-        (51, 'loop') : ('REDUCE', 51),
-        (51, 'pool') : ('REDUCE', 51),
-        (51, ',') : ('REDUCE', 51),
-        (51, '.') : ('REDUCE', 51),
-        (51, ')') : ('REDUCE', 51),
-        (51, 'then') : ('REDUCE', 51),
-        (51, 'else') : ('REDUCE', 51),
-        (51, '}') : ('REDUCE', 51),
-        (51, 'fi') : ('REDUCE', 51),
-        (51, '=') : ('REDUCE', 51),
-        (51, '+') : ('REDUCE', 51),
-        (51, 'of') : ('REDUCE', 51),
-        (51, '-') : ('REDUCE', 51),
-        (51, '*') : ('REDUCE', 51),
+        (50, '-') : ('REDUCE', 37),
+        (50, 'then') : ('REDUCE', 37),
+        (50, 'loop') : ('REDUCE', 37),
+        (50, 'of') : ('REDUCE', 37),
+        (50, ';') : ('REDUCE', 37),
+        (50, '*') : ('REDUCE', 37),
+        (50, 'else') : ('REDUCE', 37),
+        (50, 'pool') : ('REDUCE', 37),
+        (50, '}') : ('REDUCE', 37),
+        (50, ',') : ('REDUCE', 37),
+        (50, '/') : ('REDUCE', 37),
+        (50, 'fi') : ('REDUCE', 37),
+        (50, '<') : ('REDUCE', 37),
+        (50, 'in') : ('REDUCE', 37),
+        (50, '=') : ('REDUCE', 37),
+        (50, '<=') : ('REDUCE', 37),
+        (50, '+') : ('REDUCE', 37),
+        (50, ')') : ('REDUCE', 37),
+        (51, '-') : ('REDUCE', 52),
+        (51, 'of') : ('REDUCE', 52),
+        (51, '*') : ('REDUCE', 52),
+        (51, '/') : ('REDUCE', 52),
+        (51, '<') : ('REDUCE', 52),
+        (51, '<=') : ('REDUCE', 52),
+        (51, '@') : ('REDUCE', 52),
+        (51, 'in') : ('REDUCE', 52),
+        (51, ';') : ('REDUCE', 52),
+        (51, 'loop') : ('REDUCE', 52),
+        (51, 'pool') : ('REDUCE', 52),
+        (51, ',') : ('REDUCE', 52),
+        (51, '.') : ('REDUCE', 52),
+        (51, ')') : ('REDUCE', 52),
+        (51, 'then') : ('REDUCE', 52),
+        (51, 'else') : ('REDUCE', 52),
+        (51, '}') : ('REDUCE', 52),
+        (51, 'fi') : ('REDUCE', 52),
+        (51, '=') : ('REDUCE', 52),
+        (51, '+') : ('REDUCE', 52),
+        (52, 'true') : ('SHIFT', 27),
         (52, 'id') : ('SHIFT', 16),
-        (52, 'string') : ('SHIFT', 29),
         (52, 'if') : ('SHIFT', 24),
+        (52, '(') : ('SHIFT', 13),
         (52, '~') : ('SHIFT', 15),
-        (52, 'false') : ('SHIFT', 28),
         (52, 'new') : ('SHIFT', 22),
+        (52, 'false') : ('SHIFT', 28),
         (52, 'int') : ('SHIFT', 21),
+        (52, 'string') : ('SHIFT', 29),
         (52, 'not') : ('SHIFT', 26),
         (52, 'isvoid') : ('SHIFT', 34),
-        (52, 'true') : ('SHIFT', 27),
-        (52, '(') : ('SHIFT', 13),
-        (53, ',') : ('REDUCE', 37),
-        (53, '/') : ('REDUCE', 37),
-        (53, 'fi') : ('REDUCE', 37),
-        (53, 'pool') : ('REDUCE', 37),
-        (53, '<') : ('REDUCE', 37),
-        (53, 'in') : ('REDUCE', 37),
-        (53, '=') : ('REDUCE', 37),
-        (53, '<=') : ('REDUCE', 37),
-        (53, ';') : ('REDUCE', 37),
-        (53, '+') : ('REDUCE', 37),
-        (53, '*') : ('REDUCE', 37),
-        (53, ')') : ('REDUCE', 37),
-        (53, 'of') : ('REDUCE', 37),
-        (53, 'then') : ('REDUCE', 37),
-        (53, '-') : ('REDUCE', 37),
-        (53, 'loop') : ('REDUCE', 37),
-        (53, 'else') : ('REDUCE', 37),
-        (53, '}') : ('REDUCE', 37),
-        (54, ',') : ('REDUCE', 38),
-        (54, '/') : ('REDUCE', 38),
-        (54, 'fi') : ('REDUCE', 38),
-        (54, 'pool') : ('REDUCE', 38),
-        (54, '<') : ('REDUCE', 38),
-        (54, 'in') : ('REDUCE', 38),
-        (54, '=') : ('REDUCE', 38),
-        (54, '<=') : ('REDUCE', 38),
-        (54, ';') : ('REDUCE', 38),
-        (54, '+') : ('REDUCE', 38),
-        (54, '*') : ('REDUCE', 38),
-        (54, ')') : ('REDUCE', 38),
-        (54, 'of') : ('REDUCE', 38),
-        (54, 'then') : ('REDUCE', 38),
-        (54, '-') : ('REDUCE', 38),
-        (54, 'loop') : ('REDUCE', 38),
-        (54, 'else') : ('REDUCE', 38),
-        (54, '}') : ('REDUCE', 38),
+        (53, '-') : ('REDUCE', 38),
+        (53, 'then') : ('REDUCE', 38),
+        (53, 'loop') : ('REDUCE', 38),
+        (53, 'of') : ('REDUCE', 38),
+        (53, ';') : ('REDUCE', 38),
+        (53, '*') : ('REDUCE', 38),
+        (53, 'else') : ('REDUCE', 38),
+        (53, 'pool') : ('REDUCE', 38),
+        (53, '}') : ('REDUCE', 38),
+        (53, ',') : ('REDUCE', 38),
+        (53, '/') : ('REDUCE', 38),
+        (53, 'fi') : ('REDUCE', 38),
+        (53, '<') : ('REDUCE', 38),
+        (53, 'in') : ('REDUCE', 38),
+        (53, '=') : ('REDUCE', 38),
+        (53, '<=') : ('REDUCE', 38),
+        (53, '+') : ('REDUCE', 38),
+        (53, ')') : ('REDUCE', 38),
+        (54, '-') : ('REDUCE', 39),
+        (54, 'then') : ('REDUCE', 39),
+        (54, 'loop') : ('REDUCE', 39),
+        (54, 'of') : ('REDUCE', 39),
+        (54, ';') : ('REDUCE', 39),
+        (54, '*') : ('REDUCE', 39),
+        (54, 'else') : ('REDUCE', 39),
+        (54, 'pool') : ('REDUCE', 39),
+        (54, '}') : ('REDUCE', 39),
+        (54, ',') : ('REDUCE', 39),
+        (54, '/') : ('REDUCE', 39),
+        (54, 'fi') : ('REDUCE', 39),
+        (54, '<') : ('REDUCE', 39),
+        (54, 'in') : ('REDUCE', 39),
+        (54, '=') : ('REDUCE', 39),
+        (54, '<=') : ('REDUCE', 39),
+        (54, '+') : ('REDUCE', 39),
+        (54, ')') : ('REDUCE', 39),
+        (55, 'true') : ('SHIFT', 27),
         (55, 'id') : ('SHIFT', 16),
-        (55, 'string') : ('SHIFT', 29),
         (55, 'if') : ('SHIFT', 24),
+        (55, '(') : ('SHIFT', 13),
         (55, '~') : ('SHIFT', 15),
-        (55, 'false') : ('SHIFT', 28),
         (55, 'new') : ('SHIFT', 22),
+        (55, 'false') : ('SHIFT', 28),
         (55, 'int') : ('SHIFT', 21),
+        (55, 'string') : ('SHIFT', 29),
         (55, 'not') : ('SHIFT', 26),
         (55, 'isvoid') : ('SHIFT', 34),
-        (55, 'true') : ('SHIFT', 27),
-        (55, '(') : ('SHIFT', 13),
-        (56, '/') : ('SHIFT', 52),
-        (56, ',') : ('REDUCE', 34),
-        (56, 'fi') : ('REDUCE', 34),
-        (56, 'pool') : ('REDUCE', 34),
-        (56, '<') : ('REDUCE', 34),
-        (56, 'in') : ('REDUCE', 34),
-        (56, '=') : ('REDUCE', 34),
-        (56, '<=') : ('REDUCE', 34),
-        (56, ';') : ('REDUCE', 34),
-        (56, '+') : ('REDUCE', 34),
-        (56, ')') : ('REDUCE', 34),
-        (56, 'of') : ('REDUCE', 34),
-        (56, 'then') : ('REDUCE', 34),
-        (56, '-') : ('REDUCE', 34),
-        (56, 'loop') : ('REDUCE', 34),
-        (56, 'else') : ('REDUCE', 34),
-        (56, '}') : ('REDUCE', 34),
+        (56, '-') : ('REDUCE', 35),
+        (56, 'then') : ('REDUCE', 35),
+        (56, 'loop') : ('REDUCE', 35),
+        (56, 'of') : ('REDUCE', 35),
+        (56, ';') : ('REDUCE', 35),
+        (56, 'else') : ('REDUCE', 35),
+        (56, 'pool') : ('REDUCE', 35),
+        (56, '}') : ('REDUCE', 35),
+        (56, ',') : ('REDUCE', 35),
+        (56, 'fi') : ('REDUCE', 35),
+        (56, '<') : ('REDUCE', 35),
+        (56, 'in') : ('REDUCE', 35),
+        (56, '=') : ('REDUCE', 35),
+        (56, '<=') : ('REDUCE', 35),
+        (56, '+') : ('REDUCE', 35),
+        (56, ')') : ('REDUCE', 35),
         (56, '*') : ('SHIFT', 49),
+        (56, '/') : ('SHIFT', 52),
         (57, '*') : ('SHIFT', 49),
-        (57, ',') : ('REDUCE', 35),
-        (57, 'fi') : ('REDUCE', 35),
-        (57, 'pool') : ('REDUCE', 35),
-        (57, '<') : ('REDUCE', 35),
-        (57, 'in') : ('REDUCE', 35),
-        (57, '=') : ('REDUCE', 35),
-        (57, '<=') : ('REDUCE', 35),
-        (57, ';') : ('REDUCE', 35),
-        (57, '+') : ('REDUCE', 35),
-        (57, ')') : ('REDUCE', 35),
-        (57, 'of') : ('REDUCE', 35),
-        (57, 'then') : ('REDUCE', 35),
-        (57, '-') : ('REDUCE', 35),
-        (57, 'loop') : ('REDUCE', 35),
-        (57, 'else') : ('REDUCE', 35),
-        (57, '}') : ('REDUCE', 35),
         (57, '/') : ('SHIFT', 52),
+        (57, '-') : ('REDUCE', 36),
+        (57, 'then') : ('REDUCE', 36),
+        (57, 'loop') : ('REDUCE', 36),
+        (57, 'of') : ('REDUCE', 36),
+        (57, ';') : ('REDUCE', 36),
+        (57, 'else') : ('REDUCE', 36),
+        (57, 'pool') : ('REDUCE', 36),
+        (57, '}') : ('REDUCE', 36),
+        (57, ',') : ('REDUCE', 36),
+        (57, 'fi') : ('REDUCE', 36),
+        (57, '<') : ('REDUCE', 36),
+        (57, 'in') : ('REDUCE', 36),
+        (57, '=') : ('REDUCE', 36),
+        (57, '<=') : ('REDUCE', 36),
+        (57, '+') : ('REDUCE', 36),
+        (57, ')') : ('REDUCE', 36),
+        (58, 'true') : ('SHIFT', 27),
         (58, 'id') : ('SHIFT', 16),
-        (58, '(') : ('SHIFT', 13),
-        (58, 'string') : ('SHIFT', 29),
         (58, 'if') : ('SHIFT', 24),
+        (58, '(') : ('SHIFT', 13),
         (58, '~') : ('SHIFT', 15),
-        (58, 'false') : ('SHIFT', 28),
         (58, 'new') : ('SHIFT', 22),
+        (58, 'false') : ('SHIFT', 28),
         (58, 'int') : ('SHIFT', 21),
+        (58, 'string') : ('SHIFT', 29),
         (58, 'not') : ('SHIFT', 26),
         (58, 'isvoid') : ('SHIFT', 34),
-        (58, 'true') : ('SHIFT', 27),
         (59, '-') : ('SHIFT', 55),
         (59, '+') : ('SHIFT', 47),
-        (59, ',') : ('REDUCE', 29),
-        (59, 'fi') : ('REDUCE', 29),
-        (59, 'pool') : ('REDUCE', 29),
-        (59, '<') : ('REDUCE', 29),
-        (59, 'in') : ('REDUCE', 29),
-        (59, '=') : ('REDUCE', 29),
-        (59, '<=') : ('REDUCE', 29),
-        (59, ';') : ('REDUCE', 29),
-        (59, ')') : ('REDUCE', 29),
-        (59, 'of') : ('REDUCE', 29),
-        (59, 'then') : ('REDUCE', 29),
-        (59, 'loop') : ('REDUCE', 29),
-        (59, 'else') : ('REDUCE', 29),
-        (59, '}') : ('REDUCE', 29),
+        (59, 'then') : ('REDUCE', 30),
+        (59, 'loop') : ('REDUCE', 30),
+        (59, 'of') : ('REDUCE', 30),
+        (59, ';') : ('REDUCE', 30),
+        (59, 'else') : ('REDUCE', 30),
+        (59, 'pool') : ('REDUCE', 30),
+        (59, '}') : ('REDUCE', 30),
+        (59, ',') : ('REDUCE', 30),
+        (59, 'fi') : ('REDUCE', 30),
+        (59, '<') : ('REDUCE', 30),
+        (59, 'in') : ('REDUCE', 30),
+        (59, '=') : ('REDUCE', 30),
+        (59, '<=') : ('REDUCE', 30),
+        (59, ')') : ('REDUCE', 30),
+        (60, 'true') : ('SHIFT', 27),
         (60, 'id') : ('SHIFT', 16),
-        (60, 'string') : ('SHIFT', 29),
         (60, 'if') : ('SHIFT', 24),
+        (60, '(') : ('SHIFT', 13),
         (60, '~') : ('SHIFT', 15),
-        (60, 'false') : ('SHIFT', 28),
         (60, 'new') : ('SHIFT', 22),
+        (60, 'false') : ('SHIFT', 28),
         (60, 'int') : ('SHIFT', 21),
+        (60, 'string') : ('SHIFT', 29),
         (60, 'not') : ('SHIFT', 26),
         (60, 'isvoid') : ('SHIFT', 34),
-        (60, 'true') : ('SHIFT', 27),
-        (60, '(') : ('SHIFT', 13),
         (61, '-') : ('SHIFT', 55),
         (61, '+') : ('SHIFT', 47),
-        (61, ',') : ('REDUCE', 30),
-        (61, 'fi') : ('REDUCE', 30),
-        (61, 'pool') : ('REDUCE', 30),
-        (61, '<') : ('REDUCE', 30),
-        (61, 'in') : ('REDUCE', 30),
-        (61, '=') : ('REDUCE', 30),
-        (61, '<=') : ('REDUCE', 30),
-        (61, ';') : ('REDUCE', 30),
-        (61, ')') : ('REDUCE', 30),
-        (61, 'of') : ('REDUCE', 30),
-        (61, 'then') : ('REDUCE', 30),
-        (61, 'loop') : ('REDUCE', 30),
-        (61, 'else') : ('REDUCE', 30),
-        (61, '}') : ('REDUCE', 30),
-        (62, ',') : ('REDUCE', 56),
-        (62, ')') : ('REDUCE', 56),
-        (63, '-') : ('SHIFT', 55),
-        (63, '+') : ('SHIFT', 47),
-        (63, ',') : ('REDUCE', 32),
-        (63, 'fi') : ('REDUCE', 32),
-        (63, 'in') : ('REDUCE', 32),
-        (63, '<') : ('REDUCE', 32),
-        (63, '=') : ('REDUCE', 32),
-        (63, '<=') : ('REDUCE', 32),
-        (63, ';') : ('REDUCE', 32),
-        (63, ')') : ('REDUCE', 32),
-        (63, 'of') : ('REDUCE', 32),
-        (63, 'then') : ('REDUCE', 32),
-        (63, 'loop') : ('REDUCE', 32),
-        (63, '}') : ('REDUCE', 32),
-        (63, 'else') : ('REDUCE', 32),
-        (63, 'pool') : ('REDUCE', 32),
-        (64, '/') : ('REDUCE', 54),
-        (64, '<') : ('REDUCE', 54),
-        (64, '<=') : ('REDUCE', 54),
-        (64, '@') : ('REDUCE', 54),
-        (64, 'in') : ('REDUCE', 54),
-        (64, ';') : ('REDUCE', 54),
-        (64, 'loop') : ('REDUCE', 54),
-        (64, 'pool') : ('REDUCE', 54),
-        (64, ',') : ('REDUCE', 54),
-        (64, '.') : ('REDUCE', 54),
-        (64, ')') : ('REDUCE', 54),
-        (64, 'then') : ('REDUCE', 54),
-        (64, 'else') : ('REDUCE', 54),
-        (64, '}') : ('REDUCE', 54),
-        (64, 'fi') : ('REDUCE', 54),
-        (64, '=') : ('REDUCE', 54),
-        (64, '+') : ('REDUCE', 54),
-        (64, 'of') : ('REDUCE', 54),
-        (64, '-') : ('REDUCE', 54),
-        (64, '*') : ('REDUCE', 54),
-        (65, ',') : ('REDUCE', 55),
-        (65, ')') : ('REDUCE', 55),
-        (66, ',') : ('SHIFT', 43),
-        (66, ')') : ('SHIFT', 67),
-        (67, '/') : ('REDUCE', 52),
-        (67, '<') : ('REDUCE', 52),
-        (67, '<=') : ('REDUCE', 52),
-        (67, '@') : ('REDUCE', 52),
-        (67, 'in') : ('REDUCE', 52),
-        (67, ';') : ('REDUCE', 52),
-        (67, 'loop') : ('REDUCE', 52),
-        (67, 'pool') : ('REDUCE', 52),
-        (67, ',') : ('REDUCE', 52),
-        (67, '.') : ('REDUCE', 52),
-        (67, ')') : ('REDUCE', 52),
-        (67, 'then') : ('REDUCE', 52),
-        (67, 'else') : ('REDUCE', 52),
-        (67, '}') : ('REDUCE', 52),
-        (67, 'fi') : ('REDUCE', 52),
-        (67, '=') : ('REDUCE', 52),
-        (67, '+') : ('REDUCE', 52),
-        (67, 'of') : ('REDUCE', 52),
-        (67, '-') : ('REDUCE', 52),
-        (67, '*') : ('REDUCE', 52),
-        (68, 'of') : ('SHIFT', 69),
-        (69, 'id') : ('SHIFT', 70),
-        (70, ':') : ('SHIFT', 71),
-        (71, 'type') : ('SHIFT', 72),
-        (72, '=>') : ('SHIFT', 73),
-        (73, 'true') : ('SHIFT', 27),
-        (73, 'not') : ('SHIFT', 26),
-        (73, 'case') : ('SHIFT', 25),
-        (73, '(') : ('SHIFT', 13),
-        (73, 'let') : ('SHIFT', 8),
-        (73, 'string') : ('SHIFT', 29),
-        (73, 'while') : ('SHIFT', 20),
-        (73, 'false') : ('SHIFT', 28),
-        (73, 'isvoid') : ('SHIFT', 34),
-        (73, 'id') : ('SHIFT', 18),
-        (73, 'if') : ('SHIFT', 24),
-        (73, '{') : ('SHIFT', 14),
-        (73, '~') : ('SHIFT', 15),
-        (73, 'new') : ('SHIFT', 22),
-        (73, 'int') : ('SHIFT', 21),
-        (74, ';') : ('SHIFT', 75),
-        (75, 'id') : ('SHIFT', 70),
-        (75, 'esac') : ('REDUCE', 26),
+        (61, 'then') : ('REDUCE', 31),
+        (61, 'loop') : ('REDUCE', 31),
+        (61, 'of') : ('REDUCE', 31),
+        (61, ';') : ('REDUCE', 31),
+        (61, 'else') : ('REDUCE', 31),
+        (61, 'pool') : ('REDUCE', 31),
+        (61, '}') : ('REDUCE', 31),
+        (61, ',') : ('REDUCE', 31),
+        (61, 'fi') : ('REDUCE', 31),
+        (61, '<') : ('REDUCE', 31),
+        (61, 'in') : ('REDUCE', 31),
+        (61, '=') : ('REDUCE', 31),
+        (61, '<=') : ('REDUCE', 31),
+        (61, ')') : ('REDUCE', 31),
+        (62, ',') : ('SHIFT', 63),
+        (62, ')') : ('REDUCE', 58),
+        (63, 'let') : ('SHIFT', 8),
+        (63, 'int') : ('SHIFT', 21),
+        (63, '~') : ('SHIFT', 15),
+        (63, 'string') : ('SHIFT', 29),
+        (63, 'not') : ('SHIFT', 26),
+        (63, 'id') : ('SHIFT', 18),
+        (63, 'isvoid') : ('SHIFT', 34),
+        (63, 'while') : ('SHIFT', 20),
+        (63, 'false') : ('SHIFT', 28),
+        (63, 'case') : ('SHIFT', 25),
+        (63, 'if') : ('SHIFT', 24),
+        (63, '{') : ('SHIFT', 14),
+        (63, 'true') : ('SHIFT', 27),
+        (63, 'new') : ('SHIFT', 22),
+        (63, '(') : ('SHIFT', 13),
+        (64, 'then') : ('REDUCE', 33),
+        (64, 'loop') : ('REDUCE', 33),
+        (64, 'of') : ('REDUCE', 33),
+        (64, '<=') : ('REDUCE', 33),
+        (64, 'else') : ('REDUCE', 33),
+        (64, 'pool') : ('REDUCE', 33),
+        (64, '}') : ('REDUCE', 33),
+        (64, ',') : ('REDUCE', 33),
+        (64, 'fi') : ('REDUCE', 33),
+        (64, '<') : ('REDUCE', 33),
+        (64, 'in') : ('REDUCE', 33),
+        (64, '=') : ('REDUCE', 33),
+        (64, ';') : ('REDUCE', 33),
+        (64, ')') : ('REDUCE', 33),
+        (64, '-') : ('SHIFT', 55),
+        (64, '+') : ('SHIFT', 47),
+        (65, ')') : ('REDUCE', 59),
+        (66, ')') : ('REDUCE', 57),
+        (67, ')') : ('SHIFT', 68),
+        (68, '-') : ('REDUCE', 53),
+        (68, 'of') : ('REDUCE', 53),
+        (68, '*') : ('REDUCE', 53),
+        (68, '/') : ('REDUCE', 53),
+        (68, '<') : ('REDUCE', 53),
+        (68, '<=') : ('REDUCE', 53),
+        (68, '@') : ('REDUCE', 53),
+        (68, 'in') : ('REDUCE', 53),
+        (68, ';') : ('REDUCE', 53),
+        (68, 'loop') : ('REDUCE', 53),
+        (68, 'pool') : ('REDUCE', 53),
+        (68, ',') : ('REDUCE', 53),
+        (68, '.') : ('REDUCE', 53),
+        (68, ')') : ('REDUCE', 53),
+        (68, 'then') : ('REDUCE', 53),
+        (68, 'else') : ('REDUCE', 53),
+        (68, '}') : ('REDUCE', 53),
+        (68, 'fi') : ('REDUCE', 53),
+        (68, '=') : ('REDUCE', 53),
+        (68, '+') : ('REDUCE', 53),
+        (69, 'of') : ('SHIFT', 70),
+        (70, 'id') : ('SHIFT', 71),
+        (71, ':') : ('SHIFT', 72),
+        (72, 'type') : ('SHIFT', 73),
+        (73, '=>') : ('SHIFT', 74),
+        (74, 'id') : ('SHIFT', 18),
+        (74, 'true') : ('SHIFT', 27),
+        (74, 'new') : ('SHIFT', 22),
+        (74, 'if') : ('SHIFT', 24),
+        (74, '(') : ('SHIFT', 13),
+        (74, 'let') : ('SHIFT', 8),
+        (74, '~') : ('SHIFT', 15),
+        (74, 'int') : ('SHIFT', 21),
+        (74, 'string') : ('SHIFT', 29),
+        (74, 'not') : ('SHIFT', 26),
+        (74, 'while') : ('SHIFT', 20),
+        (74, 'isvoid') : ('SHIFT', 34),
+        (74, 'case') : ('SHIFT', 25),
+        (74, 'false') : ('SHIFT', 28),
+        (74, '{') : ('SHIFT', 14),
+        (75, ';') : ('SHIFT', 76),
+        (76, 'id') : ('SHIFT', 71),
         (76, 'esac') : ('REDUCE', 27),
-        (77, 'esac') : ('SHIFT', 78),
-        (78, ',') : ('REDUCE', 25),
-        (78, 'fi') : ('REDUCE', 25),
-        (78, 'pool') : ('REDUCE', 25),
-        (78, 'in') : ('REDUCE', 25),
-        (78, ';') : ('REDUCE', 25),
-        (78, ')') : ('REDUCE', 25),
-        (78, 'of') : ('REDUCE', 25),
-        (78, 'then') : ('REDUCE', 25),
-        (78, 'loop') : ('REDUCE', 25),
-        (78, 'else') : ('REDUCE', 25),
-        (78, '}') : ('REDUCE', 25),
-        (79, 'then') : ('SHIFT', 80),
-        (80, 'case') : ('SHIFT', 25),
-        (80, 'false') : ('SHIFT', 28),
-        (80, 'let') : ('SHIFT', 8),
-        (80, '~') : ('SHIFT', 15),
-        (80, 'while') : ('SHIFT', 20),
-        (80, 'id') : ('SHIFT', 18),
-        (80, 'not') : ('SHIFT', 26),
-        (80, 'if') : ('SHIFT', 24),
-        (80, 'new') : ('SHIFT', 22),
-        (80, 'int') : ('SHIFT', 21),
-        (80, 'true') : ('SHIFT', 27),
-        (80, '(') : ('SHIFT', 13),
-        (80, '{') : ('SHIFT', 14),
-        (80, 'string') : ('SHIFT', 29),
-        (80, 'isvoid') : ('SHIFT', 34),
-        (81, 'else') : ('SHIFT', 82),
-        (82, 'case') : ('SHIFT', 25),
-        (82, 'let') : ('SHIFT', 8),
-        (82, '~') : ('SHIFT', 15),
-        (82, 'while') : ('SHIFT', 20),
-        (82, 'false') : ('SHIFT', 28),
-        (82, 'not') : ('SHIFT', 26),
-        (82, 'id') : ('SHIFT', 18),
-        (82, 'if') : ('SHIFT', 24),
-        (82, 'new') : ('SHIFT', 22),
-        (82, 'int') : ('SHIFT', 21),
-        (82, '{') : ('SHIFT', 14),
-        (82, 'isvoid') : ('SHIFT', 34),
-        (82, 'true') : ('SHIFT', 27),
-        (82, '(') : ('SHIFT', 13),
-        (82, 'string') : ('SHIFT', 29),
-        (83, 'fi') : ('SHIFT', 84),
-        (84, '/') : ('REDUCE', 49),
-        (84, '<') : ('REDUCE', 49),
-        (84, '<=') : ('REDUCE', 49),
-        (84, '@') : ('REDUCE', 49),
-        (84, 'in') : ('REDUCE', 49),
-        (84, ';') : ('REDUCE', 49),
-        (84, 'loop') : ('REDUCE', 49),
-        (84, 'pool') : ('REDUCE', 49),
-        (84, ',') : ('REDUCE', 49),
-        (84, '.') : ('REDUCE', 49),
-        (84, ')') : ('REDUCE', 49),
-        (84, 'then') : ('REDUCE', 49),
-        (84, 'else') : ('REDUCE', 49),
-        (84, '}') : ('REDUCE', 49),
-        (84, 'fi') : ('REDUCE', 49),
-        (84, '=') : ('REDUCE', 49),
-        (84, '+') : ('REDUCE', 49),
-        (84, 'of') : ('REDUCE', 49),
-        (84, '-') : ('REDUCE', 49),
-        (84, '*') : ('REDUCE', 49),
-        (85, 'loop') : ('SHIFT', 86),
-        (86, 'id') : ('SHIFT', 18),
-        (86, 'case') : ('SHIFT', 25),
-        (86, 'let') : ('SHIFT', 8),
-        (86, 'if') : ('SHIFT', 24),
-        (86, 'while') : ('SHIFT', 20),
-        (86, 'new') : ('SHIFT', 22),
-        (86, 'isvoid') : ('SHIFT', 34),
-        (86, 'int') : ('SHIFT', 21),
-        (86, 'true') : ('SHIFT', 27),
-        (86, '(') : ('SHIFT', 13),
-        (86, 'string') : ('SHIFT', 29),
-        (86, '~') : ('SHIFT', 15),
-        (86, 'false') : ('SHIFT', 28),
-        (86, '{') : ('SHIFT', 14),
-        (86, 'not') : ('SHIFT', 26),
-        (87, 'pool') : ('SHIFT', 88),
-        (88, ',') : ('REDUCE', 16),
-        (88, 'fi') : ('REDUCE', 16),
-        (88, 'pool') : ('REDUCE', 16),
-        (88, 'in') : ('REDUCE', 16),
-        (88, ';') : ('REDUCE', 16),
-        (88, ')') : ('REDUCE', 16),
-        (88, 'of') : ('REDUCE', 16),
-        (88, 'then') : ('REDUCE', 16),
-        (88, 'loop') : ('REDUCE', 16),
-        (88, 'else') : ('REDUCE', 16),
-        (88, '}') : ('REDUCE', 16),
-        (89, ',') : ('REDUCE', 15),
-        (89, 'fi') : ('REDUCE', 15),
-        (89, 'pool') : ('REDUCE', 15),
-        (89, 'in') : ('REDUCE', 15),
-        (89, ';') : ('REDUCE', 15),
-        (89, ')') : ('REDUCE', 15),
-        (89, 'of') : ('REDUCE', 15),
-        (89, 'then') : ('REDUCE', 15),
-        (89, 'loop') : ('REDUCE', 15),
-        (89, 'else') : ('REDUCE', 15),
-        (89, '}') : ('REDUCE', 15),
-        (90, ')') : ('SHIFT', 91),
-        (90, ',') : ('SHIFT', 43),
-        (91, '/') : ('REDUCE', 53),
-        (91, '<') : ('REDUCE', 53),
-        (91, '<=') : ('REDUCE', 53),
-        (91, '@') : ('REDUCE', 53),
-        (91, 'in') : ('REDUCE', 53),
-        (91, ';') : ('REDUCE', 53),
-        (91, 'loop') : ('REDUCE', 53),
-        (91, 'pool') : ('REDUCE', 53),
-        (91, ',') : ('REDUCE', 53),
-        (91, '.') : ('REDUCE', 53),
-        (91, ')') : ('REDUCE', 53),
-        (91, 'then') : ('REDUCE', 53),
-        (91, 'else') : ('REDUCE', 53),
-        (91, '}') : ('REDUCE', 53),
-        (91, 'fi') : ('REDUCE', 53),
-        (91, '=') : ('REDUCE', 53),
-        (91, '+') : ('REDUCE', 53),
-        (91, 'of') : ('REDUCE', 53),
-        (91, '-') : ('REDUCE', 53),
-        (91, '*') : ('REDUCE', 53),
-        (92, ',') : ('REDUCE', 40),
-        (92, '/') : ('REDUCE', 40),
-        (92, 'fi') : ('REDUCE', 40),
-        (92, 'pool') : ('REDUCE', 40),
-        (92, '<') : ('REDUCE', 40),
-        (92, 'in') : ('REDUCE', 40),
-        (92, '=') : ('REDUCE', 40),
-        (92, '<=') : ('REDUCE', 40),
-        (92, ';') : ('REDUCE', 40),
-        (92, '+') : ('REDUCE', 40),
-        (92, '*') : ('REDUCE', 40),
-        (92, ')') : ('REDUCE', 40),
-        (92, 'of') : ('REDUCE', 40),
-        (92, 'then') : ('REDUCE', 40),
-        (92, '-') : ('REDUCE', 40),
-        (92, 'loop') : ('REDUCE', 40),
-        (92, 'else') : ('REDUCE', 40),
-        (92, '}') : ('REDUCE', 40),
-        (93, '}') : ('SHIFT', 94),
-        (94, ',') : ('REDUCE', 17),
-        (94, 'fi') : ('REDUCE', 17),
-        (94, 'pool') : ('REDUCE', 17),
-        (94, 'in') : ('REDUCE', 17),
-        (94, ';') : ('REDUCE', 17),
-        (94, ')') : ('REDUCE', 17),
-        (94, 'of') : ('REDUCE', 17),
-        (94, 'then') : ('REDUCE', 17),
-        (94, 'loop') : ('REDUCE', 17),
-        (94, 'else') : ('REDUCE', 17),
-        (94, '}') : ('REDUCE', 17),
-        (95, ';') : ('SHIFT', 96),
-        (96, 'true') : ('SHIFT', 27),
-        (96, 'not') : ('SHIFT', 26),
-        (96, 'case') : ('SHIFT', 25),
-        (96, '(') : ('SHIFT', 13),
-        (96, 'let') : ('SHIFT', 8),
-        (96, 'string') : ('SHIFT', 29),
-        (96, 'while') : ('SHIFT', 20),
-        (96, '}') : ('REDUCE', 18),
-        (96, 'false') : ('SHIFT', 28),
-        (96, 'isvoid') : ('SHIFT', 34),
-        (96, 'id') : ('SHIFT', 18),
-        (96, 'if') : ('SHIFT', 24),
-        (96, '{') : ('SHIFT', 14),
-        (96, '~') : ('SHIFT', 15),
-        (96, 'new') : ('SHIFT', 22),
-        (96, 'int') : ('SHIFT', 21),
+        (77, 'esac') : ('REDUCE', 28),
+        (78, 'esac') : ('SHIFT', 79),
+        (79, 'then') : ('REDUCE', 26),
+        (79, 'loop') : ('REDUCE', 26),
+        (79, 'of') : ('REDUCE', 26),
+        (79, 'else') : ('REDUCE', 26),
+        (79, 'pool') : ('REDUCE', 26),
+        (79, '}') : ('REDUCE', 26),
+        (79, ',') : ('REDUCE', 26),
+        (79, 'fi') : ('REDUCE', 26),
+        (79, 'in') : ('REDUCE', 26),
+        (79, ';') : ('REDUCE', 26),
+        (79, ')') : ('REDUCE', 26),
+        (80, 'then') : ('SHIFT', 81),
+        (81, 'id') : ('SHIFT', 18),
+        (81, 'false') : ('SHIFT', 28),
+        (81, 'while') : ('SHIFT', 20),
+        (81, 'case') : ('SHIFT', 25),
+        (81, '~') : ('SHIFT', 15),
+        (81, '{') : ('SHIFT', 14),
+        (81, 'true') : ('SHIFT', 27),
+        (81, 'if') : ('SHIFT', 24),
+        (81, '(') : ('SHIFT', 13),
+        (81, 'new') : ('SHIFT', 22),
+        (81, 'not') : ('SHIFT', 26),
+        (81, 'int') : ('SHIFT', 21),
+        (81, 'string') : ('SHIFT', 29),
+        (81, 'let') : ('SHIFT', 8),
+        (81, 'isvoid') : ('SHIFT', 34),
+        (82, 'else') : ('SHIFT', 83),
+        (83, 'while') : ('SHIFT', 20),
+        (83, 'id') : ('SHIFT', 18),
+        (83, 'case') : ('SHIFT', 25),
+        (83, '{') : ('SHIFT', 14),
+        (83, 'false') : ('SHIFT', 28),
+        (83, '~') : ('SHIFT', 15),
+        (83, 'true') : ('SHIFT', 27),
+        (83, 'let') : ('SHIFT', 8),
+        (83, 'new') : ('SHIFT', 22),
+        (83, 'if') : ('SHIFT', 24),
+        (83, '(') : ('SHIFT', 13),
+        (83, 'not') : ('SHIFT', 26),
+        (83, 'isvoid') : ('SHIFT', 34),
+        (83, 'int') : ('SHIFT', 21),
+        (83, 'string') : ('SHIFT', 29),
+        (84, 'fi') : ('SHIFT', 85),
+        (85, '-') : ('REDUCE', 50),
+        (85, 'of') : ('REDUCE', 50),
+        (85, '*') : ('REDUCE', 50),
+        (85, '/') : ('REDUCE', 50),
+        (85, '<') : ('REDUCE', 50),
+        (85, '<=') : ('REDUCE', 50),
+        (85, '@') : ('REDUCE', 50),
+        (85, 'in') : ('REDUCE', 50),
+        (85, ';') : ('REDUCE', 50),
+        (85, 'loop') : ('REDUCE', 50),
+        (85, 'pool') : ('REDUCE', 50),
+        (85, ',') : ('REDUCE', 50),
+        (85, '.') : ('REDUCE', 50),
+        (85, ')') : ('REDUCE', 50),
+        (85, 'then') : ('REDUCE', 50),
+        (85, 'else') : ('REDUCE', 50),
+        (85, '}') : ('REDUCE', 50),
+        (85, 'fi') : ('REDUCE', 50),
+        (85, '=') : ('REDUCE', 50),
+        (85, '+') : ('REDUCE', 50),
+        (86, 'loop') : ('SHIFT', 87),
+        (87, 'id') : ('SHIFT', 18),
+        (87, 'new') : ('SHIFT', 22),
+        (87, 'if') : ('SHIFT', 24),
+        (87, '(') : ('SHIFT', 13),
+        (87, 'let') : ('SHIFT', 8),
+        (87, 'int') : ('SHIFT', 21),
+        (87, 'string') : ('SHIFT', 29),
+        (87, '~') : ('SHIFT', 15),
+        (87, 'while') : ('SHIFT', 20),
+        (87, 'false') : ('SHIFT', 28),
+        (87, 'case') : ('SHIFT', 25),
+        (87, 'not') : ('SHIFT', 26),
+        (87, 'isvoid') : ('SHIFT', 34),
+        (87, '{') : ('SHIFT', 14),
+        (87, 'true') : ('SHIFT', 27),
+        (88, 'pool') : ('SHIFT', 89),
+        (89, 'then') : ('REDUCE', 17),
+        (89, 'loop') : ('REDUCE', 17),
+        (89, 'of') : ('REDUCE', 17),
+        (89, 'else') : ('REDUCE', 17),
+        (89, 'pool') : ('REDUCE', 17),
+        (89, '}') : ('REDUCE', 17),
+        (89, ',') : ('REDUCE', 17),
+        (89, 'fi') : ('REDUCE', 17),
+        (89, 'in') : ('REDUCE', 17),
+        (89, ';') : ('REDUCE', 17),
+        (89, ')') : ('REDUCE', 17),
+        (90, 'then') : ('REDUCE', 16),
+        (90, 'loop') : ('REDUCE', 16),
+        (90, 'of') : ('REDUCE', 16),
+        (90, 'else') : ('REDUCE', 16),
+        (90, 'pool') : ('REDUCE', 16),
+        (90, '}') : ('REDUCE', 16),
+        (90, ',') : ('REDUCE', 16),
+        (90, 'fi') : ('REDUCE', 16),
+        (90, 'in') : ('REDUCE', 16),
+        (90, ';') : ('REDUCE', 16),
+        (90, ')') : ('REDUCE', 16),
+        (91, ')') : ('SHIFT', 92),
+        (92, '-') : ('REDUCE', 54),
+        (92, 'of') : ('REDUCE', 54),
+        (92, '*') : ('REDUCE', 54),
+        (92, '/') : ('REDUCE', 54),
+        (92, '<') : ('REDUCE', 54),
+        (92, '<=') : ('REDUCE', 54),
+        (92, '@') : ('REDUCE', 54),
+        (92, 'in') : ('REDUCE', 54),
+        (92, ';') : ('REDUCE', 54),
+        (92, 'loop') : ('REDUCE', 54),
+        (92, 'pool') : ('REDUCE', 54),
+        (92, ',') : ('REDUCE', 54),
+        (92, '.') : ('REDUCE', 54),
+        (92, ')') : ('REDUCE', 54),
+        (92, 'then') : ('REDUCE', 54),
+        (92, 'else') : ('REDUCE', 54),
+        (92, '}') : ('REDUCE', 54),
+        (92, 'fi') : ('REDUCE', 54),
+        (92, '=') : ('REDUCE', 54),
+        (92, '+') : ('REDUCE', 54),
+        (93, '-') : ('REDUCE', 41),
+        (93, 'then') : ('REDUCE', 41),
+        (93, 'loop') : ('REDUCE', 41),
+        (93, 'of') : ('REDUCE', 41),
+        (93, ';') : ('REDUCE', 41),
+        (93, '*') : ('REDUCE', 41),
+        (93, 'else') : ('REDUCE', 41),
+        (93, 'pool') : ('REDUCE', 41),
+        (93, '}') : ('REDUCE', 41),
+        (93, ',') : ('REDUCE', 41),
+        (93, '/') : ('REDUCE', 41),
+        (93, 'fi') : ('REDUCE', 41),
+        (93, '<') : ('REDUCE', 41),
+        (93, 'in') : ('REDUCE', 41),
+        (93, '=') : ('REDUCE', 41),
+        (93, '<=') : ('REDUCE', 41),
+        (93, '+') : ('REDUCE', 41),
+        (93, ')') : ('REDUCE', 41),
+        (94, '}') : ('SHIFT', 95),
+        (95, 'then') : ('REDUCE', 18),
+        (95, 'loop') : ('REDUCE', 18),
+        (95, 'of') : ('REDUCE', 18),
+        (95, 'else') : ('REDUCE', 18),
+        (95, 'pool') : ('REDUCE', 18),
+        (95, '}') : ('REDUCE', 18),
+        (95, ',') : ('REDUCE', 18),
+        (95, 'fi') : ('REDUCE', 18),
+        (95, 'in') : ('REDUCE', 18),
+        (95, ';') : ('REDUCE', 18),
+        (95, ')') : ('REDUCE', 18),
+        (96, ';') : ('SHIFT', 97),
+        (97, 'id') : ('SHIFT', 18),
+        (97, 'true') : ('SHIFT', 27),
+        (97, 'new') : ('SHIFT', 22),
+        (97, 'if') : ('SHIFT', 24),
         (97, '}') : ('REDUCE', 19),
-        (98, ')') : ('SHIFT', 99),
-        (99, '/') : ('REDUCE', 50),
-        (99, '<') : ('REDUCE', 50),
-        (99, '<=') : ('REDUCE', 50),
-        (99, '@') : ('REDUCE', 50),
-        (99, 'in') : ('REDUCE', 50),
-        (99, ';') : ('REDUCE', 50),
-        (99, 'loop') : ('REDUCE', 50),
-        (99, 'pool') : ('REDUCE', 50),
-        (99, ',') : ('REDUCE', 50),
-        (99, '.') : ('REDUCE', 50),
-        (99, ')') : ('REDUCE', 50),
-        (99, 'then') : ('REDUCE', 50),
-        (99, 'else') : ('REDUCE', 50),
-        (99, '}') : ('REDUCE', 50),
-        (99, 'fi') : ('REDUCE', 50),
-        (99, '=') : ('REDUCE', 50),
-        (99, '+') : ('REDUCE', 50),
-        (99, 'of') : ('REDUCE', 50),
-        (99, '-') : ('REDUCE', 50),
-        (99, '*') : ('REDUCE', 50),
-        (100, 'in') : ('REDUCE', 22),
-        (100, ',') : ('SHIFT', 101),
-        (101, 'id') : ('SHIFT', 9),
-        (102, 'in') : ('REDUCE', 24),
-        (103, 'id') : ('SHIFT', 9),
-        (104, 'in') : ('REDUCE', 23),
-        (105, 'in') : ('SHIFT', 106),
-        (106, 'string') : ('SHIFT', 29),
-        (106, 'false') : ('SHIFT', 28),
-        (106, 'id') : ('SHIFT', 18),
-        (106, 'isvoid') : ('SHIFT', 34),
-        (106, '{') : ('SHIFT', 14),
-        (106, 'if') : ('SHIFT', 24),
-        (106, '~') : ('SHIFT', 15),
-        (106, 'case') : ('SHIFT', 25),
-        (106, 'new') : ('SHIFT', 22),
-        (106, 'let') : ('SHIFT', 8),
-        (106, 'int') : ('SHIFT', 21),
-        (106, 'while') : ('SHIFT', 20),
-        (106, 'not') : ('SHIFT', 26),
-        (106, 'true') : ('SHIFT', 27),
-        (106, '(') : ('SHIFT', 13),
-        (107, ',') : ('REDUCE', 20),
-        (107, 'fi') : ('REDUCE', 20),
-        (107, 'pool') : ('REDUCE', 20),
-        (107, 'in') : ('REDUCE', 20),
-        (107, ';') : ('REDUCE', 20),
-        (107, ')') : ('REDUCE', 20),
-        (107, 'of') : ('REDUCE', 20),
-        (107, 'then') : ('REDUCE', 20),
-        (107, 'loop') : ('REDUCE', 20),
-        (107, 'else') : ('REDUCE', 20),
-        (107, '}') : ('REDUCE', 20),
-        (108, ';') : ('REDUCE', 9),
-        (109, 'id') : ('SHIFT', 110),
-        (109, ',') : ('REDUCE', 13),
-        (109, ')') : ('REDUCE', 13),
-        (110, ':') : ('SHIFT', 111),
-        (111, 'type') : ('SHIFT', 112),
-        (112, ',') : ('REDUCE', 14),
-        (112, ')') : ('REDUCE', 14),
-        (113, ',') : ('SHIFT', 114),
-        (113, ')') : ('SHIFT', 116),
-        (114, 'id') : ('SHIFT', 110),
-        (115, ',') : ('REDUCE', 12),
-        (115, ')') : ('REDUCE', 12),
-        (116, ':') : ('SHIFT', 117),
-        (117, 'type') : ('SHIFT', 118),
-        (118, '{') : ('SHIFT', 119),
-        (119, 'not') : ('SHIFT', 26),
-        (119, 'case') : ('SHIFT', 25),
-        (119, 'let') : ('SHIFT', 8),
-        (119, 'new') : ('SHIFT', 22),
-        (119, 'int') : ('SHIFT', 21),
-        (119, 'while') : ('SHIFT', 20),
-        (119, 'true') : ('SHIFT', 27),
-        (119, '(') : ('SHIFT', 13),
-        (119, 'string') : ('SHIFT', 29),
-        (119, 'isvoid') : ('SHIFT', 34),
-        (119, 'false') : ('SHIFT', 28),
-        (119, 'id') : ('SHIFT', 18),
-        (119, '{') : ('SHIFT', 14),
-        (119, '~') : ('SHIFT', 15),
-        (119, 'if') : ('SHIFT', 24),
-        (120, '}') : ('SHIFT', 121),
-        (121, ';') : ('REDUCE', 10),
-        (122, ',') : ('REDUCE', 11),
-        (122, ')') : ('REDUCE', 11),
-        (123, '}') : ('SHIFT', 124),
-        (124, ';') : ('REDUCE', 3),
-        (125, ';') : ('SHIFT', 126),
-        (126, 'id') : ('SHIFT', 4),
-        (126, '}') : ('REDUCE', 7),
-        (127, '}') : ('REDUCE', 5),
-        (128, ';') : ('SHIFT', 129),
-        (129, 'id') : ('SHIFT', 4),
-        (129, '}') : ('REDUCE', 7),
-        (130, '}') : ('REDUCE', 6),
-        (131, 'type') : ('SHIFT', 132),
-        (132, '{') : ('SHIFT', 133),
-        (133, 'id') : ('SHIFT', 4),
-        (133, '}') : ('REDUCE', 7),
-        (134, '}') : ('SHIFT', 135),
-        (135, ';') : ('REDUCE', 4),
-        (136, '$') : ('REDUCE', 0),
-        (140, '$') : ('OK', None),
-        (137, ';') : ('SHIFT', 138),
-        (138, '$') : ('REDUCE', 1),
-        (138, 'class') : ('SHIFT', 1),
-        (139, '$') : ('REDUCE', 2)
+        (97, '(') : ('SHIFT', 13),
+        (97, 'let') : ('SHIFT', 8),
+        (97, '~') : ('SHIFT', 15),
+        (97, 'int') : ('SHIFT', 21),
+        (97, 'string') : ('SHIFT', 29),
+        (97, 'not') : ('SHIFT', 26),
+        (97, 'while') : ('SHIFT', 20),
+        (97, 'isvoid') : ('SHIFT', 34),
+        (97, 'case') : ('SHIFT', 25),
+        (97, 'false') : ('SHIFT', 28),
+        (97, '{') : ('SHIFT', 14),
+        (98, '}') : ('REDUCE', 20),
+        (99, ')') : ('SHIFT', 100),
+        (100, '-') : ('REDUCE', 51),
+        (100, 'of') : ('REDUCE', 51),
+        (100, '*') : ('REDUCE', 51),
+        (100, '/') : ('REDUCE', 51),
+        (100, '<') : ('REDUCE', 51),
+        (100, '<=') : ('REDUCE', 51),
+        (100, '@') : ('REDUCE', 51),
+        (100, 'in') : ('REDUCE', 51),
+        (100, ';') : ('REDUCE', 51),
+        (100, 'loop') : ('REDUCE', 51),
+        (100, 'pool') : ('REDUCE', 51),
+        (100, ',') : ('REDUCE', 51),
+        (100, '.') : ('REDUCE', 51),
+        (100, ')') : ('REDUCE', 51),
+        (100, 'then') : ('REDUCE', 51),
+        (100, 'else') : ('REDUCE', 51),
+        (100, '}') : ('REDUCE', 51),
+        (100, 'fi') : ('REDUCE', 51),
+        (100, '=') : ('REDUCE', 51),
+        (100, '+') : ('REDUCE', 51),
+        (101, 'in') : ('REDUCE', 23),
+        (101, ',') : ('SHIFT', 102),
+        (102, 'id') : ('SHIFT', 9),
+        (103, 'in') : ('REDUCE', 25),
+        (104, 'id') : ('SHIFT', 9),
+        (105, 'in') : ('REDUCE', 24),
+        (106, 'in') : ('SHIFT', 107),
+        (107, 'true') : ('SHIFT', 27),
+        (107, 'if') : ('SHIFT', 24),
+        (107, 'id') : ('SHIFT', 18),
+        (107, '(') : ('SHIFT', 13),
+        (107, '~') : ('SHIFT', 15),
+        (107, 'new') : ('SHIFT', 22),
+        (107, 'let') : ('SHIFT', 8),
+        (107, 'int') : ('SHIFT', 21),
+        (107, 'string') : ('SHIFT', 29),
+        (107, 'not') : ('SHIFT', 26),
+        (107, 'isvoid') : ('SHIFT', 34),
+        (107, 'while') : ('SHIFT', 20),
+        (107, 'case') : ('SHIFT', 25),
+        (107, 'false') : ('SHIFT', 28),
+        (107, '{') : ('SHIFT', 14),
+        (108, 'then') : ('REDUCE', 21),
+        (108, 'loop') : ('REDUCE', 21),
+        (108, 'of') : ('REDUCE', 21),
+        (108, 'else') : ('REDUCE', 21),
+        (108, 'pool') : ('REDUCE', 21),
+        (108, '}') : ('REDUCE', 21),
+        (108, ',') : ('REDUCE', 21),
+        (108, 'fi') : ('REDUCE', 21),
+        (108, 'in') : ('REDUCE', 21),
+        (108, ';') : ('REDUCE', 21),
+        (108, ')') : ('REDUCE', 21),
+        (109, ';') : ('REDUCE', 9),
+        (110, 'id') : ('SHIFT', 111),
+        (110, ')') : ('REDUCE', 11),
+        (111, ':') : ('SHIFT', 112),
+        (112, 'type') : ('SHIFT', 113),
+        (113, ',') : ('REDUCE', 15),
+        (113, ')') : ('REDUCE', 15),
+        (114, ')') : ('SHIFT', 115),
+        (115, ':') : ('SHIFT', 116),
+        (116, 'type') : ('SHIFT', 117),
+        (117, '{') : ('SHIFT', 118),
+        (118, 'let') : ('SHIFT', 8),
+        (118, 'new') : ('SHIFT', 22),
+        (118, 'if') : ('SHIFT', 24),
+        (118, '(') : ('SHIFT', 13),
+        (118, '~') : ('SHIFT', 15),
+        (118, 'int') : ('SHIFT', 21),
+        (118, 'string') : ('SHIFT', 29),
+        (118, 'not') : ('SHIFT', 26),
+        (118, 'while') : ('SHIFT', 20),
+        (118, 'id') : ('SHIFT', 18),
+        (118, 'isvoid') : ('SHIFT', 34),
+        (118, 'case') : ('SHIFT', 25),
+        (118, 'false') : ('SHIFT', 28),
+        (118, '{') : ('SHIFT', 14),
+        (118, 'true') : ('SHIFT', 27),
+        (119, '}') : ('SHIFT', 120),
+        (120, ';') : ('REDUCE', 10),
+        (121, ',') : ('SHIFT', 122),
+        (121, ')') : ('REDUCE', 13),
+        (122, 'id') : ('SHIFT', 111),
+        (123, ')') : ('REDUCE', 14),
+        (124, ')') : ('REDUCE', 12),
+        (125, '}') : ('SHIFT', 126),
+        (126, ';') : ('REDUCE', 3),
+        (127, ';') : ('SHIFT', 128),
+        (128, 'id') : ('SHIFT', 4),
+        (128, '}') : ('REDUCE', 7),
+        (129, '}') : ('REDUCE', 5),
+        (130, ';') : ('SHIFT', 131),
+        (131, 'id') : ('SHIFT', 4),
+        (131, '}') : ('REDUCE', 7),
+        (132, '}') : ('REDUCE', 6),
+        (133, 'type') : ('SHIFT', 134),
+        (134, '{') : ('SHIFT', 135),
+        (135, 'id') : ('SHIFT', 4),
+        (135, '}') : ('REDUCE', 7),
+        (136, '}') : ('SHIFT', 137),
+        (137, ';') : ('REDUCE', 4),
+        (138, '$') : ('REDUCE', 0),
+        (139, ';') : ('SHIFT', 140),
+        (140, '$') : ('REDUCE', 1),
+        (140, 'class') : ('SHIFT', 1),
+        (141, '$') : ('REDUCE', 2),
+        (142, '$') : ('OK', None)
         }
 
 
 
 
         self.goto = {
-        (0, '<class-list>') : 136,
-        (0, '<program>') : 140,
-        (0, '<def-class>') : 137,
-        (3, '<def-attr>') : 125,
-        (3, '<feature-list>') : 123,
-        (3, '<def-meth>') : 128,
+        (0, '<def-class>') : 139,
+        (0, '<program>') : 142,
+        (0, '<class-list>') : 138,
+        (3, '<def-meth>') : 130,
+        (3, '<def-attr>') : 127,
+        (3, '<feature-list>') : 125,
         (7, '<atom>') : 36,
-        (7, '<factor>') : 54,
-        (7, '<arith>') : 63,
+        (7, '<term>') : 57,
         (7, '<comp>') : 44,
+        (7, '<factor>') : 54,
+        (7, '<arith>') : 64,
+        (7, '<expr>') : 109,
         (7, '<dispatch>') : 51,
-        (7, '<term>') : 57,
-        (7, '<expr>') : 108,
-        (8, '<id-list>') : 105,
-        (12, '<arith>') : 63,
+        (8, '<id-list>') : 106,
+        (12, '<expr>') : 101,
+        (12, '<term>') : 57,
         (12, '<factor>') : 54,
-        (12, '<atom>') : 36,
         (12, '<comp>') : 44,
-        (12, '<term>') : 57,
         (12, '<dispatch>') : 51,
-        (12, '<expr>') : 100,
-        (13, '<term>') : 57,
+        (12, '<atom>') : 36,
+        (12, '<arith>') : 64,
+        (13, '<arith>') : 64,
         (13, '<atom>') : 36,
         (13, '<dispatch>') : 51,
-        (13, '<arith>') : 63,
+        (13, '<term>') : 57,
         (13, '<comp>') : 44,
         (13, '<factor>') : 54,
-        (13, '<expr>') : 98,
+        (13, '<expr>') : 99,
+        (14, '<expr>') : 96,
         (14, '<atom>') : 36,
-        (14, '<expr-list>') : 93,
-        (14, '<factor>') : 54,
-        (14, '<expr>') : 95,
-        (14, '<arith>') : 63,
+        (14, '<term>') : 57,
+        (14, '<expr-list>') : 94,
         (14, '<comp>') : 44,
+        (14, '<factor>') : 54,
+        (14, '<arith>') : 64,
         (14, '<dispatch>') : 51,
-        (14, '<term>') : 57,
         (15, '<atom>') : 36,
+        (15, '<factor>') : 93,
         (15, '<dispatch>') : 51,
-        (15, '<factor>') : 92,
-        (17, '<term>') : 57,
-        (17, '<comp>') : 44,
-        (17, '<expr>') : 65,
+        (17, '<arg-list>') : 91,
         (17, '<atom>') : 36,
-        (17, '<arg-list>') : 90,
-        (17, '<arith>') : 63,
+        (17, '<arith>') : 64,
+        (17, '<expr>') : 62,
+        (17, '<nonEmpty-argList>') : 66,
+        (17, '<term>') : 57,
         (17, '<factor>') : 54,
+        (17, '<comp>') : 44,
         (17, '<dispatch>') : 51,
-        (19, '<comp>') : 44,
-        (19, '<arith>') : 63,
         (19, '<atom>') : 36,
+        (19, '<expr>') : 90,
+        (19, '<arith>') : 64,
         (19, '<term>') : 57,
-        (19, '<dispatch>') : 51,
-        (19, '<expr>') : 89,
         (19, '<factor>') : 54,
-        (20, '<comp>') : 44,
-        (20, '<arith>') : 63,
+        (19, '<comp>') : 44,
+        (19, '<dispatch>') : 51,
+        (20, '<arith>') : 64,
+        (20, '<dispatch>') : 51,
+        (20, '<expr>') : 86,
         (20, '<atom>') : 36,
+        (20, '<comp>') : 44,
         (20, '<term>') : 57,
-        (20, '<expr>') : 85,
-        (20, '<dispatch>') : 51,
         (20, '<factor>') : 54,
         (24, '<term>') : 57,
         (24, '<comp>') : 44,
-        (24, '<expr>') : 79,
         (24, '<factor>') : 54,
+        (24, '<arith>') : 64,
         (24, '<atom>') : 36,
+        (24, '<expr>') : 80,
         (24, '<dispatch>') : 51,
-        (24, '<arith>') : 63,
-        (25, '<arith>') : 63,
         (25, '<atom>') : 36,
-        (25, '<dispatch>') : 51,
+        (25, '<expr>') : 69,
+        (25, '<arith>') : 64,
         (25, '<term>') : 57,
-        (25, '<expr>') : 68,
         (25, '<comp>') : 44,
+        (25, '<dispatch>') : 51,
         (25, '<factor>') : 54,
-        (26, '<atom>') : 30,
         (26, '<dispatch>') : 51,
-        (33, '<term>') : 57,
-        (33, '<comp>') : 44,
-        (33, '<expr>') : 65,
+        (26, '<atom>') : 30,
+        (33, '<arg-list>') : 67,
         (33, '<atom>') : 36,
-        (33, '<arg-list>') : 66,
-        (33, '<arith>') : 63,
+        (33, '<arith>') : 64,
+        (33, '<expr>') : 62,
+        (33, '<nonEmpty-argList>') : 66,
+        (33, '<term>') : 57,
         (33, '<factor>') : 54,
+        (33, '<comp>') : 44,
         (33, '<dispatch>') : 51,
         (34, '<atom>') : 36,
         (34, '<dispatch>') : 51,
         (34, '<factor>') : 35,
-        (41, '<term>') : 57,
-        (41, '<comp>') : 44,
-        (41, '<expr>') : 65,
         (41, '<atom>') : 36,
-        (41, '<arg-list>') : 42,
-        (41, '<arith>') : 63,
+        (41, '<arith>') : 64,
+        (41, '<expr>') : 62,
+        (41, '<nonEmpty-argList>') : 66,
+        (41, '<term>') : 57,
         (41, '<factor>') : 54,
+        (41, '<comp>') : 44,
         (41, '<dispatch>') : 51,
-        (43, '<term>') : 57,
-        (43, '<comp>') : 44,
-        (43, '<atom>') : 36,
-        (43, '<expr>') : 62,
-        (43, '<arith>') : 63,
-        (43, '<factor>') : 54,
-        (43, '<dispatch>') : 51,
+        (41, '<arg-list>') : 42,
         (45, '<atom>') : 36,
-        (45, '<dispatch>') : 51,
         (45, '<arith>') : 46,
         (45, '<term>') : 57,
         (45, '<factor>') : 54,
+        (45, '<dispatch>') : 51,
         (47, '<atom>') : 36,
-        (47, '<dispatch>') : 51,
         (47, '<term>') : 48,
         (47, '<factor>') : 54,
+        (47, '<dispatch>') : 51,
         (49, '<atom>') : 36,
         (49, '<dispatch>') : 51,
         (49, '<factor>') : 50,
         (52, '<atom>') : 36,
-        (52, '<dispatch>') : 51,
         (52, '<factor>') : 53,
+        (52, '<dispatch>') : 51,
         (55, '<atom>') : 36,
-        (55, '<dispatch>') : 51,
         (55, '<term>') : 56,
         (55, '<factor>') : 54,
+        (55, '<dispatch>') : 51,
         (58, '<atom>') : 36,
-        (58, '<dispatch>') : 51,
-        (58, '<term>') : 57,
         (58, '<arith>') : 59,
+        (58, '<term>') : 57,
         (58, '<factor>') : 54,
+        (58, '<dispatch>') : 51,
         (60, '<atom>') : 36,
-        (60, '<dispatch>') : 51,
-        (60, '<term>') : 57,
         (60, '<arith>') : 61,
+        (60, '<term>') : 57,
         (60, '<factor>') : 54,
-        (69, '<case-list>') : 77,
-        (73, '<atom>') : 36,
-        (73, '<factor>') : 54,
-        (73, '<expr>') : 74,
-        (73, '<arith>') : 63,
-        (73, '<comp>') : 44,
-        (73, '<dispatch>') : 51,
-        (73, '<term>') : 57,
-        (75, '<case-list>') : 76,
-        (80, '<arith>') : 63,
-        (80, '<term>') : 57,
-        (80, '<comp>') : 44,
-        (80, '<expr>') : 81,
-        (80, '<atom>') : 36,
-        (80, '<dispatch>') : 51,
-        (80, '<factor>') : 54,
-        (82, '<arith>') : 63,
-        (82, '<term>') : 57,
-        (82, '<comp>') : 44,
-        (82, '<factor>') : 54,
-        (82, '<dispatch>') : 51,
-        (82, '<expr>') : 83,
-        (82, '<atom>') : 36,
-        (86, '<atom>') : 36,
-        (86, '<dispatch>') : 51,
-        (86, '<arith>') : 63,
-        (86, '<comp>') : 44,
-        (86, '<term>') : 57,
-        (86, '<expr>') : 87,
-        (86, '<factor>') : 54,
-        (96, '<atom>') : 36,
-        (96, '<factor>') : 54,
-        (96, '<expr>') : 95,
-        (96, '<arith>') : 63,
-        (96, '<comp>') : 44,
-        (96, '<expr-list>') : 97,
-        (96, '<dispatch>') : 51,
-        (96, '<term>') : 57,
-        (101, '<id-list>') : 102,
-        (103, '<id-list>') : 104,
-        (106, '<comp>') : 44,
-        (106, '<arith>') : 63,
-        (106, '<atom>') : 36,
-        (106, '<term>') : 57,
-        (106, '<dispatch>') : 51,
-        (106, '<expr>') : 107,
-        (106, '<factor>') : 54,
-        (109, '<param-list>') : 113,
-        (109, '<param>') : 122,
-        (114, '<param>') : 115,
-        (119, '<factor>') : 54,
-        (119, '<arith>') : 63,
-        (119, '<atom>') : 36,
-        (119, '<comp>') : 44,
-        (119, '<term>') : 57,
-        (119, '<dispatch>') : 51,
-        (119, '<expr>') : 120,
-        (126, '<def-attr>') : 125,
-        (126, '<feature-list>') : 127,
-        (126, '<def-meth>') : 128,
-        (129, '<def-attr>') : 125,
-        (129, '<def-meth>') : 128,
-        (129, '<feature-list>') : 130,
-        (133, '<feature-list>') : 134,
-        (133, '<def-attr>') : 125,
-        (133, '<def-meth>') : 128,
-        (138, '<class-list>') : 139,
-        (138, '<def-class>') : 137
+        (60, '<dispatch>') : 51,
+        (63, '<atom>') : 36,
+        (63, '<arith>') : 64,
+        (63, '<expr>') : 62,
+        (63, '<term>') : 57,
+        (63, '<factor>') : 54,
+        (63, '<nonEmpty-argList>') : 65,
+        (63, '<comp>') : 44,
+        (63, '<dispatch>') : 51,
+        (70, '<case-list>') : 78,
+        (74, '<atom>') : 36,
+        (74, '<term>') : 57,
+        (74, '<comp>') : 44,
+        (74, '<expr>') : 75,
+        (74, '<factor>') : 54,
+        (74, '<arith>') : 64,
+        (74, '<dispatch>') : 51,
+        (76, '<case-list>') : 77,
+        (81, '<comp>') : 44,
+        (81, '<arith>') : 64,
+        (81, '<atom>') : 36,
+        (81, '<dispatch>') : 51,
+        (81, '<term>') : 57,
+        (81, '<expr>') : 82,
+        (81, '<factor>') : 54,
+        (83, '<comp>') : 44,
+        (83, '<atom>') : 36,
+        (83, '<arith>') : 64,
+        (83, '<term>') : 57,
+        (83, '<expr>') : 84,
+        (83, '<dispatch>') : 51,
+        (83, '<factor>') : 54,
+        (87, '<expr>') : 88,
+        (87, '<atom>') : 36,
+        (87, '<arith>') : 64,
+        (87, '<comp>') : 44,
+        (87, '<term>') : 57,
+        (87, '<factor>') : 54,
+        (87, '<dispatch>') : 51,
+        (97, '<expr>') : 96,
+        (97, '<expr-list>') : 98,
+        (97, '<atom>') : 36,
+        (97, '<term>') : 57,
+        (97, '<comp>') : 44,
+        (97, '<factor>') : 54,
+        (97, '<arith>') : 64,
+        (97, '<dispatch>') : 51,
+        (102, '<id-list>') : 103,
+        (104, '<id-list>') : 105,
+        (107, '<atom>') : 36,
+        (107, '<arith>') : 64,
+        (107, '<term>') : 57,
+        (107, '<factor>') : 54,
+        (107, '<comp>') : 44,
+        (107, '<expr>') : 108,
+        (107, '<dispatch>') : 51,
+        (110, '<nonEmpty-paramList>') : 124,
+        (110, '<param>') : 121,
+        (110, '<param-list>') : 114,
+        (118, '<atom>') : 36,
+        (118, '<arith>') : 64,
+        (118, '<term>') : 57,
+        (118, '<comp>') : 44,
+        (118, '<factor>') : 54,
+        (118, '<expr>') : 119,
+        (118, '<dispatch>') : 51,
+        (122, '<param>') : 121,
+        (122, '<nonEmpty-paramList>') : 123,
+        (128, '<def-meth>') : 130,
+        (128, '<feature-list>') : 129,
+        (128, '<def-attr>') : 127,
+        (131, '<def-meth>') : 130,
+        (131, '<feature-list>') : 132,
+        (131, '<def-attr>') : 127,
+        (135, '<def-meth>') : 130,
+        (135, '<feature-list>') : 136,
+        (135, '<def-attr>') : 127,
+        (140, '<def-class>') : 139,
+        (140, '<class-list>') : 141
         }
 
 

From 9768b4f621a8dc65031a0c4b5f2aa89b1a9cc9da Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 23:53:05 -0800
Subject: [PATCH 34/83] writing errors like test

---
 src/main.py                              | 2 +-
 src/utils/semantic_check/type_builder.py | 8 +++++---
 src/utils/semantic_check/type_checker.py | 8 +++++---
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/src/main.py b/src/main.py
index 4983b1b1e..699bb79c5 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "parser/dispatch8.cl"
+    add = "semantic/self4.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index 556c12060..829d10388 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -2,7 +2,9 @@
 from utils.ast.AST_Nodes import ast_nodes as nodes
 from cmp.semantic import SemanticError, ErrorType
 
-NOT_INHERIT_FROM_BASICS_TYPES = '(%s, %s) - SemanticError: Class %s cannot inherit class %s. '
+NOT_INHERIT_FROM_BASICS_TYPES = '(%s, %s) - SemanticError: Class %s cannot inherit class %s.'
+MULTIDEFINED_METHOD = '(%s, %s) - SemanticError: Method %s is multiply defined.'
+INHERIT_ERROR = '(%s, %s) - TypeError: Class %s inherits from an undefined class %s.'
 
 
 class TypeBuilder:
@@ -36,7 +38,7 @@ def visit(self,node):
                     parent_type = self.context.get_type(node.parent)
                 except SemanticError as se:
                     parent_type = ErrorType()
-                    self.errors.append(se.text)
+                    self.errors.append(INHERIT_ERROR % (node.line, node.parent_column, node.id, node.parent))
                     
                 try:
                     self.current_type.set_parent(parent_type)
@@ -87,6 +89,6 @@ def visit(self,node):
         try:
             self.current_type.define_method(node.id, param_names, param_types, returnType)
         except SemanticError as se:
-            self.errors.append(se.text)
+            self.errors.append(MULTIDEFINED_METHOD % (node.line, node.column, node.id))
 
         return
\ No newline at end of file
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index b910b92cc..6a80c3d5a 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -6,7 +6,7 @@
 MAIN_METHOD_DONT_EXISTS = '(%s, %s) - TypeError: Main class must have a method main()'
 MAIN_METHOD_DONT_HAVE_PARAMS = '(%s, %s) - TypeError: main method must not have params'
 
-SELF_ERROR = '(%s, %s) - TypeError: self cannot be used as an attribute name'
+SELF_ERROR = '(%s, %s) - SemanticError: \'self\' cannot be the name of an attribute.'
 SELF_IS_READONLY = '(%s, %s) - TypeError: Variable "self" is read-only.'
 SELF_TYPE_ERROR = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a parameter type in method %s'
 SELF_TYPE_IN_DISPATCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a dispatch'
@@ -101,14 +101,16 @@ def visit(self, node, scope):
     def visit(self, node, scope):
         attr_type = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
 
+        if node.id == 'self':
+            self.errors.append(SELF_ERROR % (node.line, node.column))
+            
         if node.expr:
             type_expr = self.visit(node.expr, scope.create_child())
 
             if not type_expr.conforms_to(attr_type):
                 self.errors.append(INCOMPATIBLE_TYPES_ATTR % (node.line, node.column, type_expr.name, node.id, attr_type.name))
 
-        if node.id == 'self':
-            self.errors.append(SELF_ERROR % (node.line, node.column))
+        
 
         scope.define_variable(node.id, attr_type)
 

From e677043e646418aa0b81776c4e6984ae849d7960 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Tue, 15 Feb 2022 23:58:01 -0800
Subject: [PATCH 35/83] updating semantic

---
 src/main.py                              | 2 +-
 src/utils/semantic_check/type_checker.py | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main.py b/src/main.py
index 699bb79c5..314f2bcb3 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/self4.cl"
+    add = "semantic/methods1.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 6a80c3d5a..dc4bebfba 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -18,7 +18,7 @@
 INCOMPATIBLE_TYPES_IF = '(%s, %s) - TypeError: Predicate of \'%s\' does not have type %s.'
 INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
 WRONG_SIGNATURE = '(%s, %s) - TypeError: Method %s already defined in %s with a different signature.'
-LOCAL_ALREADY_DEFINED = '(%s, %s) - TypeError: Variable %s is already defined in method %s.'
+LOCAL_ALREADY_DEFINED = '(%s, %s) - SemanticError: Variable %s is already defined in method %s.'
 INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
 VARIABLE_NOT_DEFINED = '(%s, %s) - NameError: Undeclared identifier %s.'
 INHERIT_ERROR = '(%s, %s) - TypeError: Class %s cannot inherit from class %s because they form a cycle.'
@@ -103,7 +103,7 @@ def visit(self, node, scope):
 
         if node.id == 'self':
             self.errors.append(SELF_ERROR % (node.line, node.column))
-            
+
         if node.expr:
             type_expr = self.visit(node.expr, scope.create_child())
 

From 4c2642e43fe6a82107d2ac806497b3a01dc0ec63 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 00:41:07 -0800
Subject: [PATCH 36/83] acopling errors

---
 src/main.py                              |  2 +-
 src/utils/semantic_check/type_builder.py |  7 ++++---
 src/utils/semantic_check/type_checker.py | 10 ++++++----
 3 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/main.py b/src/main.py
index 314f2bcb3..117982218 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/methods1.cl"
+    add = "semantic/let1.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index 829d10388..41eada589 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -5,6 +5,8 @@
 NOT_INHERIT_FROM_BASICS_TYPES = '(%s, %s) - SemanticError: Class %s cannot inherit class %s.'
 MULTIDEFINED_METHOD = '(%s, %s) - SemanticError: Method %s is multiply defined.'
 INHERIT_ERROR = '(%s, %s) - TypeError: Class %s inherits from an undefined class %s.'
+PARAMETER_TYPE_UNDEFINED = '(%s, %s) - TypeError: Class %s of formal parameter %s is undefined.'
+REDEFINED_ATTRIBUTES = '(%s, %s) - SemanticError: Attribute %s is an attribute of an inherited class.'
 
 
 class TypeBuilder:
@@ -60,8 +62,7 @@ def visit(self,node):
             attrType = self.context.get_type(node.type)
             self.current_type.define_attribute(node.id, attrType)
         except SemanticError as se:
-            self.errors.append(se.text)
-            self.current_type.define_attribute(node.id, ErrorType())
+            self.errors.append(REDEFINED_ATTRIBUTES % (node.line, node.column, node.id))
 
         return
 
@@ -77,7 +78,7 @@ def visit(self,node):
             try:
                 param_types.append(self.context.get_type(typex))
             except SemanticError as se:
-                self.errors.append(se.text)
+                self.errors.append(PARAMETER_TYPE_UNDEFINED % (node.line, node.column, typex, name))
                 param_types.append(ErrorType())
 
         try:       
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index dc4bebfba..e0b2ac437 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -16,8 +16,9 @@
 INCOMPATIBLE_TYPES_ARG = '(%s, %s) - TypeError: Argument of \'%s\' has type %s instead of %s.'
 INCOMPATIBLE_TYPES_METH = '(%s, %s) - TypeError: Inferred return type %s of method %s does not conform to declared return type %s.'
 INCOMPATIBLE_TYPES_IF = '(%s, %s) - TypeError: Predicate of \'%s\' does not have type %s.'
+INCOMPATIBLE_TYPES_LET = '(%s, %s) - TypeError: Inferred type %s of initialization of %s does not conform to identifier\'s declared type %s.'
 INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
-WRONG_SIGNATURE = '(%s, %s) - TypeError: Method %s already defined in %s with a different signature.'
+WRONG_SIGNATURE = '(%s, %s) - SemanticError: Incompatible number of formal parameters in redefined method %s.'
 LOCAL_ALREADY_DEFINED = '(%s, %s) - SemanticError: Variable %s is already defined in method %s.'
 INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
 VARIABLE_NOT_DEFINED = '(%s, %s) - NameError: Undeclared identifier %s.'
@@ -132,7 +133,7 @@ def visit(self, node, scope):
             try:
                 parent_method = current_parent.get_method(node.id)
                 if parent_method != self.current_method:
-                    self.errors.append(WRONG_SIGNATURE % (node.line, node.column, self.current_method.name, self.current_type.name))
+                    self.errors.append(WRONG_SIGNATURE % (node.line, node.column, self.current_method.name))
                     break
             except:
                 pass
@@ -271,14 +272,15 @@ def visit(self, node, scope):
                 self.errors.append(se.text)
             
             if scope.is_local(idx):
-                self.errors.append(LOCAL_ALREADY_DEFINED % (node.line, node.column, idx, self.current_method.name))
+                scope = scope.create_child()
+                scope.define_variable(idx, id_type)
             else:
                 scope.define_variable(idx, id_type)
             
             if id_expr is not None:
                 id_expr_type = self.visit(id_expr, scope.create_child())
                 if not id_expr_type.conforms_to(id_type):
-                    self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, id_expr_type.name, id_type.name))
+                    self.errors.append(INCOMPATIBLE_TYPES_LET % (node.line, node.column, id_expr_type.name, idx, id_type.name))
             
         body_type = self.visit(node.in_expr, scope.create_child())
 

From 87c4a6642c2c70817cc155b9cf0e6d9950e278ac Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 01:34:23 -0800
Subject: [PATCH 37/83] update semantic errors

---
 src/cmp/semantic.py                      | 9 ++++++---
 src/main.py                              | 2 +-
 src/utils/semantic_check/type_builder.py | 3 ++-
 src/utils/semantic_check/type_checker.py | 3 +--
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
index 3cf8c49a6..dc72bc7fc 100644
--- a/src/cmp/semantic.py
+++ b/src/cmp/semantic.py
@@ -48,20 +48,23 @@ def set_parent(self, parent):
             raise SemanticError(f'Parent type is already set for {self.name}.')
         self.parent = parent
 
-    def get_attribute(self, name:str):
+    def get_attribute(self, name:str, typex:str):
         try:
             return next(attr for attr in self.attributes if attr.name == name)
         except StopIteration:
             if self.parent is None:
                 raise SemanticError(f'Attribute "{name}" is not defined in {self.name}.')
             try:
-                return self.parent.get_attribute(name)
+                if self.parent.name != typex:
+                    return self.parent.get_attribute(name, typex)
+                raise SemanticError()
+
             except SemanticError:
                 raise SemanticError(f'Attribute "{name}" is not defined in {self.name}.')
 
     def define_attribute(self, name:str, typex):
         try:
-            self.get_attribute(name)
+            self.get_attribute(name, self.name)
         except SemanticError:
             attribute = Attribute(name, typex)
             self.attributes.append(attribute)
diff --git a/src/main.py b/src/main.py
index 117982218..c7c12d654 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/let1.cl"
+    add = "semantic/inheritance4.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index 41eada589..c10325368 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -7,6 +7,7 @@
 INHERIT_ERROR = '(%s, %s) - TypeError: Class %s inherits from an undefined class %s.'
 PARAMETER_TYPE_UNDEFINED = '(%s, %s) - TypeError: Class %s of formal parameter %s is undefined.'
 REDEFINED_ATTRIBUTES = '(%s, %s) - SemanticError: Attribute %s is an attribute of an inherited class.'
+RETURN_TYPE_UNDEFINED = '(%s, %s) - TypeError: Undefined return type %s in method %s.'
 
 
 class TypeBuilder:
@@ -84,7 +85,7 @@ def visit(self,node):
         try:       
             returnType = self.context.get_type(node.type)
         except SemanticError as se:
-            self.errors.append(se.text)
+            self.errors.append(RETURN_TYPE_UNDEFINED % (node.line, node.column, node.type, node.id))
             returnType = ErrorType()
         
         try:
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index e0b2ac437..9dec5bd63 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -22,7 +22,7 @@
 LOCAL_ALREADY_DEFINED = '(%s, %s) - SemanticError: Variable %s is already defined in method %s.'
 INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
 VARIABLE_NOT_DEFINED = '(%s, %s) - NameError: Undeclared identifier %s.'
-INHERIT_ERROR = '(%s, %s) - TypeError: Class %s cannot inherit from class %s because they form a cycle.'
+INHERIT_ERROR = '(%s, %s) - SemanticError: Class %s cannot inherit from class %s because they form a cycle.'
 METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
 
 DUPLICATE_BRANCH = '(%s, %s) - SemanticError: Duplicate branch %s in case statement.'
@@ -157,7 +157,6 @@ def visit(self, node, scope):
         try:
             returnType = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
         except SemanticError as se:
-            self.errors.append(se.text)
             returnType = ErrorType()
 
         if not body_type.conforms_to(returnType):

From f3e581895a79ac844d547125a767e1ea8f718974 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 14:51:05 -0800
Subject: [PATCH 38/83] updating code

---
 src/main.py                                |    7 +-
 src/utils/COOL_Grammar.py                  |    5 +-
 src/utils/parser/COOL_parser.py            | 1895 ++++++++++----------
 src/utils/semantic_check/type_checker.py   |   24 +-
 src/utils/semantic_check/type_collector.py |    4 +-
 5 files changed, 972 insertions(+), 963 deletions(-)

diff --git a/src/main.py b/src/main.py
index c7c12d654..3714e9728 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/inheritance4.cl"
+    add = "semantic/arithmetic12.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -23,6 +23,11 @@
     with open(_in) as file:
         code = file.read()
 
+    code = '''class Main {
+    main(): Object {
+        if true = not false then 4 else 5 fi
+    };
+};'''
 
     G = build_COOL_Grammar()
 
diff --git a/src/utils/COOL_Grammar.py b/src/utils/COOL_Grammar.py
index 25fe8b993..0cae24564 100644
--- a/src/utils/COOL_Grammar.py
+++ b/src/utils/COOL_Grammar.py
@@ -68,11 +68,13 @@ def build_COOL_Grammar():
     case_list %= idx + colon + typex + darrow + expr + semi, lambda h,s: [(s[1],s[3],s[5])]
     case_list %= idx + colon + typex + darrow + expr + semi + case_list, lambda h,s: [(s[1],s[3],s[5])] + s[7]
 
+    expr %= notx + expr, lambda h,s: node.NotNode(s[2],s[1])
+    expr %= comp + equal + expr, lambda h,s: node.EqualNode(s[1],s[3],s[2])
+
     expr %= comp, lambda h,s: s[1]
 
     comp %= comp + less + arith, lambda h,s: node.LessThanNode(s[1],s[3],s[2])
     comp %= comp + lesse + arith, lambda h,s: node.LessEqualNode(s[1],s[3],s[2])
-    comp %= comp + equal + arith, lambda h,s: node.EqualNode(s[1],s[3],s[2])
     comp %= arith, lambda h,s: s[1]
 
     arith %= arith + plus + term, lambda h,s: node.PlusNode(s[1],s[3],s[2])
@@ -85,7 +87,6 @@ def build_COOL_Grammar():
 
     factor %= isvoid + factor, lambda h,s: node.IsVoidNode(s[2])
     factor %= tilde + factor, lambda h,s: node.ComplementNode(s[2], s[1])
-    factor %= notx + atom, lambda h,s: node.NotNode(s[2],s[1])
     factor %= atom, lambda h,s: s[1]
 
     atom %= true, lambda h,s: node.ConstantBoolNode(s[1])
diff --git a/src/utils/parser/COOL_parser.py b/src/utils/parser/COOL_parser.py
index edaa3ba96..6f2958843 100644
--- a/src/utils/parser/COOL_parser.py
+++ b/src/utils/parser/COOL_parser.py
@@ -30,93 +30,85 @@ def __init__(self, G):
         (4, '(') : ('SHIFT', 110),
         (4, ':') : ('SHIFT', 5),
         (5, 'type') : ('SHIFT', 6),
-        (6, '<-') : ('SHIFT', 7),
         (6, ';') : ('REDUCE', 8),
+        (6, '<-') : ('SHIFT', 7),
         (7, 'id') : ('SHIFT', 18),
-        (7, 'true') : ('SHIFT', 27),
-        (7, 'new') : ('SHIFT', 22),
+        (7, 'isvoid') : ('SHIFT', 27),
+        (7, 'false') : ('SHIFT', 29),
         (7, 'if') : ('SHIFT', 24),
-        (7, '(') : ('SHIFT', 13),
-        (7, 'let') : ('SHIFT', 8),
         (7, '~') : ('SHIFT', 15),
+        (7, 'string') : ('SHIFT', 30),
+        (7, '{') : ('SHIFT', 14),
+        (7, 'case') : ('SHIFT', 25),
+        (7, 'new') : ('SHIFT', 22),
+        (7, 'true') : ('SHIFT', 28),
         (7, 'int') : ('SHIFT', 21),
-        (7, 'string') : ('SHIFT', 29),
+        (7, '(') : ('SHIFT', 13),
         (7, 'not') : ('SHIFT', 26),
+        (7, 'let') : ('SHIFT', 8),
         (7, 'while') : ('SHIFT', 20),
-        (7, 'isvoid') : ('SHIFT', 34),
-        (7, 'case') : ('SHIFT', 25),
-        (7, 'false') : ('SHIFT', 28),
-        (7, '{') : ('SHIFT', 14),
         (8, 'id') : ('SHIFT', 9),
         (9, ':') : ('SHIFT', 10),
         (10, 'type') : ('SHIFT', 11),
-        (11, ',') : ('SHIFT', 104),
         (11, '<-') : ('SHIFT', 12),
+        (11, ',') : ('SHIFT', 104),
         (11, 'in') : ('REDUCE', 22),
-        (12, 'false') : ('SHIFT', 28),
-        (12, 'not') : ('SHIFT', 26),
-        (12, 'while') : ('SHIFT', 20),
         (12, 'id') : ('SHIFT', 18),
-        (12, 'isvoid') : ('SHIFT', 34),
+        (12, '{') : ('SHIFT', 14),
+        (12, 'false') : ('SHIFT', 29),
         (12, 'case') : ('SHIFT', 25),
-        (12, 'true') : ('SHIFT', 27),
-        (12, 'new') : ('SHIFT', 22),
         (12, 'if') : ('SHIFT', 24),
-        (12, '(') : ('SHIFT', 13),
-        (12, '{') : ('SHIFT', 14),
-        (12, 'int') : ('SHIFT', 21),
-        (12, 'string') : ('SHIFT', 29),
+        (12, 'string') : ('SHIFT', 30),
+        (12, 'isvoid') : ('SHIFT', 27),
+        (12, 'new') : ('SHIFT', 22),
+        (12, 'not') : ('SHIFT', 26),
         (12, 'let') : ('SHIFT', 8),
         (12, '~') : ('SHIFT', 15),
+        (12, 'true') : ('SHIFT', 28),
+        (12, 'while') : ('SHIFT', 20),
+        (12, 'int') : ('SHIFT', 21),
+        (12, '(') : ('SHIFT', 13),
         (13, 'id') : ('SHIFT', 18),
         (13, 'let') : ('SHIFT', 8),
-        (13, 'false') : ('SHIFT', 28),
-        (13, '~') : ('SHIFT', 15),
-        (13, 'true') : ('SHIFT', 27),
-        (13, 'if') : ('SHIFT', 24),
-        (13, '(') : ('SHIFT', 13),
-        (13, 'new') : ('SHIFT', 22),
         (13, 'not') : ('SHIFT', 26),
+        (13, 'false') : ('SHIFT', 29),
+        (13, 'isvoid') : ('SHIFT', 27),
+        (13, 'if') : ('SHIFT', 24),
         (13, 'while') : ('SHIFT', 20),
-        (13, 'case') : ('SHIFT', 25),
-        (13, 'isvoid') : ('SHIFT', 34),
+        (13, '~') : ('SHIFT', 15),
+        (13, 'string') : ('SHIFT', 30),
+        (13, 'new') : ('SHIFT', 22),
+        (13, 'true') : ('SHIFT', 28),
         (13, 'int') : ('SHIFT', 21),
-        (13, 'string') : ('SHIFT', 29),
+        (13, '(') : ('SHIFT', 13),
         (13, '{') : ('SHIFT', 14),
+        (13, 'case') : ('SHIFT', 25),
         (14, 'id') : ('SHIFT', 18),
-        (14, 'true') : ('SHIFT', 27),
-        (14, 'new') : ('SHIFT', 22),
+        (14, 'isvoid') : ('SHIFT', 27),
+        (14, 'false') : ('SHIFT', 29),
         (14, 'if') : ('SHIFT', 24),
-        (14, '(') : ('SHIFT', 13),
-        (14, 'let') : ('SHIFT', 8),
         (14, '~') : ('SHIFT', 15),
+        (14, 'string') : ('SHIFT', 30),
+        (14, '{') : ('SHIFT', 14),
+        (14, 'case') : ('SHIFT', 25),
+        (14, 'new') : ('SHIFT', 22),
+        (14, 'true') : ('SHIFT', 28),
         (14, 'int') : ('SHIFT', 21),
-        (14, 'string') : ('SHIFT', 29),
+        (14, '(') : ('SHIFT', 13),
         (14, 'not') : ('SHIFT', 26),
+        (14, 'let') : ('SHIFT', 8),
         (14, 'while') : ('SHIFT', 20),
-        (14, 'isvoid') : ('SHIFT', 34),
-        (14, 'case') : ('SHIFT', 25),
-        (14, 'false') : ('SHIFT', 28),
-        (14, '{') : ('SHIFT', 14),
-        (15, 'true') : ('SHIFT', 27),
+        (15, 'string') : ('SHIFT', 30),
         (15, 'id') : ('SHIFT', 16),
-        (15, 'if') : ('SHIFT', 24),
-        (15, '(') : ('SHIFT', 13),
-        (15, '~') : ('SHIFT', 15),
         (15, 'new') : ('SHIFT', 22),
-        (15, 'false') : ('SHIFT', 28),
+        (15, 'isvoid') : ('SHIFT', 27),
+        (15, 'true') : ('SHIFT', 28),
+        (15, '~') : ('SHIFT', 15),
         (15, 'int') : ('SHIFT', 21),
-        (15, 'string') : ('SHIFT', 29),
-        (15, 'not') : ('SHIFT', 26),
-        (15, 'isvoid') : ('SHIFT', 34),
+        (15, 'false') : ('SHIFT', 29),
+        (15, '(') : ('SHIFT', 13),
+        (15, 'if') : ('SHIFT', 24),
         (16, '(') : ('SHIFT', 17),
-        (16, '-') : ('REDUCE', 48),
-        (16, 'of') : ('REDUCE', 48),
-        (16, '*') : ('REDUCE', 48),
-        (16, '/') : ('REDUCE', 48),
-        (16, '<') : ('REDUCE', 48),
-        (16, '<=') : ('REDUCE', 48),
-        (16, '@') : ('REDUCE', 48),
         (16, 'in') : ('REDUCE', 48),
         (16, ';') : ('REDUCE', 48),
         (16, 'loop') : ('REDUCE', 48),
@@ -130,31 +122,30 @@ def __init__(self, G):
         (16, 'fi') : ('REDUCE', 48),
         (16, '=') : ('REDUCE', 48),
         (16, '+') : ('REDUCE', 48),
+        (16, 'of') : ('REDUCE', 48),
+        (16, '-') : ('REDUCE', 48),
+        (16, '*') : ('REDUCE', 48),
+        (16, '/') : ('REDUCE', 48),
+        (16, '<') : ('REDUCE', 48),
+        (16, '<=') : ('REDUCE', 48),
+        (16, '@') : ('REDUCE', 48),
+        (17, 'not') : ('SHIFT', 26),
         (17, 'let') : ('SHIFT', 8),
-        (17, 'int') : ('SHIFT', 21),
+        (17, 'string') : ('SHIFT', 30),
         (17, '~') : ('SHIFT', 15),
-        (17, 'string') : ('SHIFT', 29),
-        (17, 'new') : ('SHIFT', 22),
+        (17, 'while') : ('SHIFT', 20),
         (17, ')') : ('REDUCE', 56),
-        (17, 'not') : ('SHIFT', 26),
         (17, 'id') : ('SHIFT', 18),
-        (17, 'isvoid') : ('SHIFT', 34),
-        (17, 'while') : ('SHIFT', 20),
-        (17, 'false') : ('SHIFT', 28),
-        (17, 'case') : ('SHIFT', 25),
+        (17, 'new') : ('SHIFT', 22),
+        (17, 'true') : ('SHIFT', 28),
+        (17, '(') : ('SHIFT', 13),
+        (17, 'int') : ('SHIFT', 21),
         (17, '{') : ('SHIFT', 14),
-        (17, 'true') : ('SHIFT', 27),
+        (17, 'isvoid') : ('SHIFT', 27),
+        (17, 'case') : ('SHIFT', 25),
+        (17, 'false') : ('SHIFT', 29),
         (17, 'if') : ('SHIFT', 24),
-        (17, '(') : ('SHIFT', 13),
-        (18, '<-') : ('SHIFT', 19),
         (18, '(') : ('SHIFT', 17),
-        (18, '-') : ('REDUCE', 48),
-        (18, 'of') : ('REDUCE', 48),
-        (18, '*') : ('REDUCE', 48),
-        (18, '/') : ('REDUCE', 48),
-        (18, '<') : ('REDUCE', 48),
-        (18, '<=') : ('REDUCE', 48),
-        (18, '@') : ('REDUCE', 48),
         (18, 'in') : ('REDUCE', 48),
         (18, ';') : ('REDUCE', 48),
         (18, 'loop') : ('REDUCE', 48),
@@ -168,43 +159,44 @@ def __init__(self, G):
         (18, 'fi') : ('REDUCE', 48),
         (18, '=') : ('REDUCE', 48),
         (18, '+') : ('REDUCE', 48),
-        (19, 'true') : ('SHIFT', 27),
-        (19, 'if') : ('SHIFT', 24),
-        (19, 'id') : ('SHIFT', 18),
-        (19, '(') : ('SHIFT', 13),
-        (19, '~') : ('SHIFT', 15),
-        (19, 'new') : ('SHIFT', 22),
-        (19, 'let') : ('SHIFT', 8),
-        (19, 'int') : ('SHIFT', 21),
-        (19, 'string') : ('SHIFT', 29),
+        (18, 'of') : ('REDUCE', 48),
+        (18, '-') : ('REDUCE', 48),
+        (18, '*') : ('REDUCE', 48),
+        (18, '/') : ('REDUCE', 48),
+        (18, '<') : ('REDUCE', 48),
+        (18, '<=') : ('REDUCE', 48),
+        (18, '@') : ('REDUCE', 48),
+        (18, '<-') : ('SHIFT', 19),
+        (19, 'string') : ('SHIFT', 30),
         (19, 'not') : ('SHIFT', 26),
-        (19, 'isvoid') : ('SHIFT', 34),
+        (19, 'let') : ('SHIFT', 8),
         (19, 'while') : ('SHIFT', 20),
-        (19, 'case') : ('SHIFT', 25),
-        (19, 'false') : ('SHIFT', 28),
+        (19, 'new') : ('SHIFT', 22),
+        (19, 'id') : ('SHIFT', 18),
+        (19, 'true') : ('SHIFT', 28),
+        (19, 'int') : ('SHIFT', 21),
+        (19, '(') : ('SHIFT', 13),
         (19, '{') : ('SHIFT', 14),
-        (20, 'isvoid') : ('SHIFT', 34),
-        (20, 'id') : ('SHIFT', 18),
-        (20, '{') : ('SHIFT', 14),
-        (20, 'true') : ('SHIFT', 27),
-        (20, 'if') : ('SHIFT', 24),
-        (20, 'new') : ('SHIFT', 22),
-        (20, '(') : ('SHIFT', 13),
+        (19, 'isvoid') : ('SHIFT', 27),
+        (19, 'case') : ('SHIFT', 25),
+        (19, '~') : ('SHIFT', 15),
+        (19, 'false') : ('SHIFT', 29),
+        (19, 'if') : ('SHIFT', 24),
         (20, 'int') : ('SHIFT', 21),
-        (20, 'string') : ('SHIFT', 29),
+        (20, '(') : ('SHIFT', 13),
+        (20, 'not') : ('SHIFT', 26),
+        (20, 'isvoid') : ('SHIFT', 27),
         (20, 'let') : ('SHIFT', 8),
-        (20, '~') : ('SHIFT', 15),
         (20, 'while') : ('SHIFT', 20),
-        (20, 'false') : ('SHIFT', 28),
-        (20, 'not') : ('SHIFT', 26),
+        (20, '~') : ('SHIFT', 15),
+        (20, 'id') : ('SHIFT', 18),
+        (20, 'false') : ('SHIFT', 29),
+        (20, 'if') : ('SHIFT', 24),
+        (20, 'string') : ('SHIFT', 30),
+        (20, '{') : ('SHIFT', 14),
+        (20, 'new') : ('SHIFT', 22),
         (20, 'case') : ('SHIFT', 25),
-        (21, '-') : ('REDUCE', 47),
-        (21, 'of') : ('REDUCE', 47),
-        (21, '*') : ('REDUCE', 47),
-        (21, '/') : ('REDUCE', 47),
-        (21, '<') : ('REDUCE', 47),
-        (21, '<=') : ('REDUCE', 47),
-        (21, '@') : ('REDUCE', 47),
+        (20, 'true') : ('SHIFT', 28),
         (21, 'in') : ('REDUCE', 47),
         (21, ';') : ('REDUCE', 47),
         (21, 'loop') : ('REDUCE', 47),
@@ -218,14 +210,14 @@ def __init__(self, G):
         (21, 'fi') : ('REDUCE', 47),
         (21, '=') : ('REDUCE', 47),
         (21, '+') : ('REDUCE', 47),
+        (21, 'of') : ('REDUCE', 47),
+        (21, '-') : ('REDUCE', 47),
+        (21, '*') : ('REDUCE', 47),
+        (21, '/') : ('REDUCE', 47),
+        (21, '<') : ('REDUCE', 47),
+        (21, '<=') : ('REDUCE', 47),
+        (21, '@') : ('REDUCE', 47),
         (22, 'type') : ('SHIFT', 23),
-        (23, '-') : ('REDUCE', 49),
-        (23, 'of') : ('REDUCE', 49),
-        (23, '*') : ('REDUCE', 49),
-        (23, '/') : ('REDUCE', 49),
-        (23, '<') : ('REDUCE', 49),
-        (23, '<=') : ('REDUCE', 49),
-        (23, '@') : ('REDUCE', 49),
         (23, 'in') : ('REDUCE', 49),
         (23, ';') : ('REDUCE', 49),
         (23, 'loop') : ('REDUCE', 49),
@@ -239,631 +231,621 @@ def __init__(self, G):
         (23, 'fi') : ('REDUCE', 49),
         (23, '=') : ('REDUCE', 49),
         (23, '+') : ('REDUCE', 49),
+        (23, 'of') : ('REDUCE', 49),
+        (23, '-') : ('REDUCE', 49),
+        (23, '*') : ('REDUCE', 49),
+        (23, '/') : ('REDUCE', 49),
+        (23, '<') : ('REDUCE', 49),
+        (23, '<=') : ('REDUCE', 49),
+        (23, '@') : ('REDUCE', 49),
+        (24, 'true') : ('SHIFT', 28),
+        (24, '(') : ('SHIFT', 13),
         (24, 'int') : ('SHIFT', 21),
-        (24, 'not') : ('SHIFT', 26),
-        (24, 'string') : ('SHIFT', 29),
-        (24, 'isvoid') : ('SHIFT', 34),
-        (24, 'while') : ('SHIFT', 20),
+        (24, '{') : ('SHIFT', 14),
         (24, 'id') : ('SHIFT', 18),
         (24, 'case') : ('SHIFT', 25),
-        (24, '{') : ('SHIFT', 14),
-        (24, 'false') : ('SHIFT', 28),
-        (24, 'let') : ('SHIFT', 8),
+        (24, 'false') : ('SHIFT', 29),
         (24, 'if') : ('SHIFT', 24),
+        (24, 'string') : ('SHIFT', 30),
+        (24, 'not') : ('SHIFT', 26),
+        (24, 'let') : ('SHIFT', 8),
+        (24, 'isvoid') : ('SHIFT', 27),
+        (24, 'while') : ('SHIFT', 20),
         (24, '~') : ('SHIFT', 15),
-        (24, 'true') : ('SHIFT', 27),
         (24, 'new') : ('SHIFT', 22),
-        (24, '(') : ('SHIFT', 13),
-        (25, 'let') : ('SHIFT', 8),
-        (25, 'id') : ('SHIFT', 18),
-        (25, '~') : ('SHIFT', 15),
-        (25, 'while') : ('SHIFT', 20),
-        (25, 'false') : ('SHIFT', 28),
-        (25, 'case') : ('SHIFT', 25),
-        (25, 'not') : ('SHIFT', 26),
-        (25, 'true') : ('SHIFT', 27),
         (25, '{') : ('SHIFT', 14),
-        (25, 'new') : ('SHIFT', 22),
+        (25, 'false') : ('SHIFT', 29),
+        (25, 'case') : ('SHIFT', 25),
         (25, 'if') : ('SHIFT', 24),
-        (25, '(') : ('SHIFT', 13),
-        (25, 'isvoid') : ('SHIFT', 34),
+        (25, 'string') : ('SHIFT', 30),
+        (25, 'new') : ('SHIFT', 22),
+        (25, 'id') : ('SHIFT', 18),
+        (25, 'not') : ('SHIFT', 26),
+        (25, 'let') : ('SHIFT', 8),
+        (25, 'while') : ('SHIFT', 20),
+        (25, 'true') : ('SHIFT', 28),
         (25, 'int') : ('SHIFT', 21),
-        (25, 'string') : ('SHIFT', 29),
-        (26, 'true') : ('SHIFT', 27),
+        (25, '(') : ('SHIFT', 13),
+        (25, 'isvoid') : ('SHIFT', 27),
+        (25, '~') : ('SHIFT', 15),
+        (26, 'string') : ('SHIFT', 30),
+        (26, 'not') : ('SHIFT', 26),
+        (26, 'let') : ('SHIFT', 8),
+        (26, 'while') : ('SHIFT', 20),
+        (26, 'new') : ('SHIFT', 22),
+        (26, 'id') : ('SHIFT', 18),
+        (26, 'true') : ('SHIFT', 28),
         (26, 'int') : ('SHIFT', 21),
-        (26, 'id') : ('SHIFT', 16),
-        (26, 'string') : ('SHIFT', 29),
-        (26, 'if') : ('SHIFT', 24),
         (26, '(') : ('SHIFT', 13),
-        (26, 'new') : ('SHIFT', 22),
-        (26, 'false') : ('SHIFT', 28),
-        (27, '-') : ('REDUCE', 44),
-        (27, 'of') : ('REDUCE', 44),
-        (27, '*') : ('REDUCE', 44),
-        (27, '/') : ('REDUCE', 44),
-        (27, '<') : ('REDUCE', 44),
-        (27, '<=') : ('REDUCE', 44),
-        (27, '@') : ('REDUCE', 44),
-        (27, 'in') : ('REDUCE', 44),
-        (27, ';') : ('REDUCE', 44),
-        (27, 'loop') : ('REDUCE', 44),
-        (27, 'pool') : ('REDUCE', 44),
-        (27, ',') : ('REDUCE', 44),
-        (27, '.') : ('REDUCE', 44),
-        (27, ')') : ('REDUCE', 44),
-        (27, 'then') : ('REDUCE', 44),
-        (27, 'else') : ('REDUCE', 44),
-        (27, '}') : ('REDUCE', 44),
-        (27, 'fi') : ('REDUCE', 44),
-        (27, '=') : ('REDUCE', 44),
-        (27, '+') : ('REDUCE', 44),
-        (28, '-') : ('REDUCE', 45),
-        (28, 'of') : ('REDUCE', 45),
-        (28, '*') : ('REDUCE', 45),
-        (28, '/') : ('REDUCE', 45),
-        (28, '<') : ('REDUCE', 45),
-        (28, '<=') : ('REDUCE', 45),
-        (28, '@') : ('REDUCE', 45),
-        (28, 'in') : ('REDUCE', 45),
-        (28, ';') : ('REDUCE', 45),
-        (28, 'loop') : ('REDUCE', 45),
-        (28, 'pool') : ('REDUCE', 45),
-        (28, ',') : ('REDUCE', 45),
-        (28, '.') : ('REDUCE', 45),
-        (28, ')') : ('REDUCE', 45),
-        (28, 'then') : ('REDUCE', 45),
-        (28, 'else') : ('REDUCE', 45),
-        (28, '}') : ('REDUCE', 45),
-        (28, 'fi') : ('REDUCE', 45),
-        (28, '=') : ('REDUCE', 45),
-        (28, '+') : ('REDUCE', 45),
-        (29, '-') : ('REDUCE', 46),
-        (29, 'of') : ('REDUCE', 46),
-        (29, '*') : ('REDUCE', 46),
-        (29, '/') : ('REDUCE', 46),
-        (29, '<') : ('REDUCE', 46),
-        (29, '<=') : ('REDUCE', 46),
-        (29, '@') : ('REDUCE', 46),
-        (29, 'in') : ('REDUCE', 46),
-        (29, ';') : ('REDUCE', 46),
-        (29, 'loop') : ('REDUCE', 46),
-        (29, 'pool') : ('REDUCE', 46),
-        (29, ',') : ('REDUCE', 46),
-        (29, '.') : ('REDUCE', 46),
-        (29, ')') : ('REDUCE', 46),
-        (29, 'then') : ('REDUCE', 46),
-        (29, 'else') : ('REDUCE', 46),
-        (29, '}') : ('REDUCE', 46),
-        (29, 'fi') : ('REDUCE', 46),
-        (29, '=') : ('REDUCE', 46),
-        (29, '+') : ('REDUCE', 46),
-        (30, '@') : ('SHIFT', 37),
-        (30, '.') : ('SHIFT', 31),
-        (30, '-') : ('REDUCE', 42),
-        (30, 'then') : ('REDUCE', 42),
-        (30, 'loop') : ('REDUCE', 42),
-        (30, 'of') : ('REDUCE', 42),
-        (30, ';') : ('REDUCE', 42),
-        (30, '*') : ('REDUCE', 42),
-        (30, 'else') : ('REDUCE', 42),
-        (30, 'pool') : ('REDUCE', 42),
-        (30, '}') : ('REDUCE', 42),
-        (30, ',') : ('REDUCE', 42),
-        (30, '/') : ('REDUCE', 42),
-        (30, 'fi') : ('REDUCE', 42),
-        (30, '<') : ('REDUCE', 42),
-        (30, 'in') : ('REDUCE', 42),
-        (30, '=') : ('REDUCE', 42),
-        (30, '<=') : ('REDUCE', 42),
-        (30, '+') : ('REDUCE', 42),
-        (30, ')') : ('REDUCE', 42),
-        (31, 'id') : ('SHIFT', 32),
-        (32, '(') : ('SHIFT', 33),
-        (33, 'let') : ('SHIFT', 8),
-        (33, 'int') : ('SHIFT', 21),
-        (33, '~') : ('SHIFT', 15),
-        (33, 'string') : ('SHIFT', 29),
-        (33, 'new') : ('SHIFT', 22),
-        (33, ')') : ('REDUCE', 56),
-        (33, 'not') : ('SHIFT', 26),
-        (33, 'id') : ('SHIFT', 18),
-        (33, 'isvoid') : ('SHIFT', 34),
-        (33, 'while') : ('SHIFT', 20),
-        (33, 'false') : ('SHIFT', 28),
-        (33, 'case') : ('SHIFT', 25),
-        (33, '{') : ('SHIFT', 14),
-        (33, 'true') : ('SHIFT', 27),
-        (33, 'if') : ('SHIFT', 24),
-        (33, '(') : ('SHIFT', 13),
-        (34, 'true') : ('SHIFT', 27),
-        (34, 'id') : ('SHIFT', 16),
-        (34, 'if') : ('SHIFT', 24),
-        (34, '(') : ('SHIFT', 13),
-        (34, '~') : ('SHIFT', 15),
-        (34, 'new') : ('SHIFT', 22),
-        (34, 'false') : ('SHIFT', 28),
-        (34, 'int') : ('SHIFT', 21),
-        (34, 'string') : ('SHIFT', 29),
-        (34, 'not') : ('SHIFT', 26),
-        (34, 'isvoid') : ('SHIFT', 34),
-        (35, '-') : ('REDUCE', 40),
-        (35, 'then') : ('REDUCE', 40),
-        (35, 'loop') : ('REDUCE', 40),
-        (35, 'of') : ('REDUCE', 40),
-        (35, ';') : ('REDUCE', 40),
-        (35, '*') : ('REDUCE', 40),
-        (35, 'else') : ('REDUCE', 40),
-        (35, 'pool') : ('REDUCE', 40),
-        (35, '}') : ('REDUCE', 40),
-        (35, ',') : ('REDUCE', 40),
-        (35, '/') : ('REDUCE', 40),
-        (35, 'fi') : ('REDUCE', 40),
-        (35, '<') : ('REDUCE', 40),
-        (35, 'in') : ('REDUCE', 40),
-        (35, '=') : ('REDUCE', 40),
-        (35, '<=') : ('REDUCE', 40),
-        (35, '+') : ('REDUCE', 40),
-        (35, ')') : ('REDUCE', 40),
-        (36, '@') : ('SHIFT', 37),
-        (36, '.') : ('SHIFT', 31),
-        (36, '-') : ('REDUCE', 43),
-        (36, 'then') : ('REDUCE', 43),
-        (36, 'loop') : ('REDUCE', 43),
-        (36, 'of') : ('REDUCE', 43),
-        (36, ';') : ('REDUCE', 43),
-        (36, '*') : ('REDUCE', 43),
-        (36, 'else') : ('REDUCE', 43),
-        (36, 'pool') : ('REDUCE', 43),
-        (36, '}') : ('REDUCE', 43),
-        (36, ',') : ('REDUCE', 43),
-        (36, '/') : ('REDUCE', 43),
-        (36, 'fi') : ('REDUCE', 43),
-        (36, '<') : ('REDUCE', 43),
-        (36, 'in') : ('REDUCE', 43),
-        (36, '=') : ('REDUCE', 43),
-        (36, '<=') : ('REDUCE', 43),
-        (36, '+') : ('REDUCE', 43),
-        (36, ')') : ('REDUCE', 43),
-        (37, 'type') : ('SHIFT', 38),
-        (38, '.') : ('SHIFT', 39),
-        (39, 'id') : ('SHIFT', 40),
-        (40, '(') : ('SHIFT', 41),
-        (41, 'let') : ('SHIFT', 8),
-        (41, 'int') : ('SHIFT', 21),
-        (41, '~') : ('SHIFT', 15),
-        (41, 'string') : ('SHIFT', 29),
-        (41, 'new') : ('SHIFT', 22),
-        (41, ')') : ('REDUCE', 56),
-        (41, 'not') : ('SHIFT', 26),
-        (41, 'id') : ('SHIFT', 18),
-        (41, 'isvoid') : ('SHIFT', 34),
-        (41, 'while') : ('SHIFT', 20),
-        (41, 'false') : ('SHIFT', 28),
-        (41, 'case') : ('SHIFT', 25),
-        (41, '{') : ('SHIFT', 14),
-        (41, 'true') : ('SHIFT', 27),
-        (41, 'if') : ('SHIFT', 24),
-        (41, '(') : ('SHIFT', 13),
-        (42, ')') : ('SHIFT', 43),
-        (43, '-') : ('REDUCE', 55),
-        (43, 'of') : ('REDUCE', 55),
-        (43, '*') : ('REDUCE', 55),
-        (43, '/') : ('REDUCE', 55),
-        (43, '<') : ('REDUCE', 55),
-        (43, '<=') : ('REDUCE', 55),
-        (43, '@') : ('REDUCE', 55),
-        (43, 'in') : ('REDUCE', 55),
-        (43, ';') : ('REDUCE', 55),
-        (43, 'loop') : ('REDUCE', 55),
-        (43, 'pool') : ('REDUCE', 55),
-        (43, ',') : ('REDUCE', 55),
-        (43, '.') : ('REDUCE', 55),
-        (43, ')') : ('REDUCE', 55),
-        (43, 'then') : ('REDUCE', 55),
-        (43, 'else') : ('REDUCE', 55),
-        (43, '}') : ('REDUCE', 55),
-        (43, 'fi') : ('REDUCE', 55),
-        (43, '=') : ('REDUCE', 55),
-        (43, '+') : ('REDUCE', 55),
-        (44, '<=') : ('SHIFT', 60),
-        (44, 'then') : ('REDUCE', 29),
-        (44, 'loop') : ('REDUCE', 29),
-        (44, 'of') : ('REDUCE', 29),
-        (44, 'else') : ('REDUCE', 29),
-        (44, 'pool') : ('REDUCE', 29),
-        (44, '}') : ('REDUCE', 29),
-        (44, ',') : ('REDUCE', 29),
-        (44, 'fi') : ('REDUCE', 29),
-        (44, 'in') : ('REDUCE', 29),
-        (44, ';') : ('REDUCE', 29),
-        (44, ')') : ('REDUCE', 29),
-        (44, '<') : ('SHIFT', 58),
-        (44, '=') : ('SHIFT', 45),
-        (45, 'true') : ('SHIFT', 27),
-        (45, 'id') : ('SHIFT', 16),
-        (45, 'if') : ('SHIFT', 24),
-        (45, '(') : ('SHIFT', 13),
-        (45, '~') : ('SHIFT', 15),
-        (45, 'new') : ('SHIFT', 22),
-        (45, 'false') : ('SHIFT', 28),
-        (45, 'int') : ('SHIFT', 21),
-        (45, 'string') : ('SHIFT', 29),
-        (45, 'not') : ('SHIFT', 26),
-        (45, 'isvoid') : ('SHIFT', 34),
-        (46, '-') : ('SHIFT', 55),
-        (46, '+') : ('SHIFT', 47),
-        (46, 'then') : ('REDUCE', 32),
-        (46, 'loop') : ('REDUCE', 32),
-        (46, 'of') : ('REDUCE', 32),
-        (46, ';') : ('REDUCE', 32),
-        (46, 'else') : ('REDUCE', 32),
-        (46, 'pool') : ('REDUCE', 32),
-        (46, '}') : ('REDUCE', 32),
-        (46, ',') : ('REDUCE', 32),
-        (46, 'fi') : ('REDUCE', 32),
-        (46, '<') : ('REDUCE', 32),
-        (46, 'in') : ('REDUCE', 32),
-        (46, '=') : ('REDUCE', 32),
-        (46, '<=') : ('REDUCE', 32),
-        (46, ')') : ('REDUCE', 32),
-        (47, 'true') : ('SHIFT', 27),
+        (26, '{') : ('SHIFT', 14),
+        (26, 'isvoid') : ('SHIFT', 27),
+        (26, 'case') : ('SHIFT', 25),
+        (26, '~') : ('SHIFT', 15),
+        (26, 'false') : ('SHIFT', 29),
+        (26, 'if') : ('SHIFT', 24),
+        (27, 'string') : ('SHIFT', 30),
+        (27, 'id') : ('SHIFT', 16),
+        (27, 'new') : ('SHIFT', 22),
+        (27, 'isvoid') : ('SHIFT', 27),
+        (27, 'true') : ('SHIFT', 28),
+        (27, '~') : ('SHIFT', 15),
+        (27, 'int') : ('SHIFT', 21),
+        (27, 'false') : ('SHIFT', 29),
+        (27, '(') : ('SHIFT', 13),
+        (27, 'if') : ('SHIFT', 24),
+        (28, 'in') : ('REDUCE', 44),
+        (28, ';') : ('REDUCE', 44),
+        (28, 'loop') : ('REDUCE', 44),
+        (28, 'pool') : ('REDUCE', 44),
+        (28, ',') : ('REDUCE', 44),
+        (28, '.') : ('REDUCE', 44),
+        (28, ')') : ('REDUCE', 44),
+        (28, 'then') : ('REDUCE', 44),
+        (28, 'else') : ('REDUCE', 44),
+        (28, '}') : ('REDUCE', 44),
+        (28, 'fi') : ('REDUCE', 44),
+        (28, '=') : ('REDUCE', 44),
+        (28, '+') : ('REDUCE', 44),
+        (28, 'of') : ('REDUCE', 44),
+        (28, '-') : ('REDUCE', 44),
+        (28, '*') : ('REDUCE', 44),
+        (28, '/') : ('REDUCE', 44),
+        (28, '<') : ('REDUCE', 44),
+        (28, '<=') : ('REDUCE', 44),
+        (28, '@') : ('REDUCE', 44),
+        (29, 'in') : ('REDUCE', 45),
+        (29, ';') : ('REDUCE', 45),
+        (29, 'loop') : ('REDUCE', 45),
+        (29, 'pool') : ('REDUCE', 45),
+        (29, ',') : ('REDUCE', 45),
+        (29, '.') : ('REDUCE', 45),
+        (29, ')') : ('REDUCE', 45),
+        (29, 'then') : ('REDUCE', 45),
+        (29, 'else') : ('REDUCE', 45),
+        (29, '}') : ('REDUCE', 45),
+        (29, 'fi') : ('REDUCE', 45),
+        (29, '=') : ('REDUCE', 45),
+        (29, '+') : ('REDUCE', 45),
+        (29, 'of') : ('REDUCE', 45),
+        (29, '-') : ('REDUCE', 45),
+        (29, '*') : ('REDUCE', 45),
+        (29, '/') : ('REDUCE', 45),
+        (29, '<') : ('REDUCE', 45),
+        (29, '<=') : ('REDUCE', 45),
+        (29, '@') : ('REDUCE', 45),
+        (30, 'in') : ('REDUCE', 46),
+        (30, ';') : ('REDUCE', 46),
+        (30, 'loop') : ('REDUCE', 46),
+        (30, 'pool') : ('REDUCE', 46),
+        (30, ',') : ('REDUCE', 46),
+        (30, '.') : ('REDUCE', 46),
+        (30, ')') : ('REDUCE', 46),
+        (30, 'then') : ('REDUCE', 46),
+        (30, 'else') : ('REDUCE', 46),
+        (30, '}') : ('REDUCE', 46),
+        (30, 'fi') : ('REDUCE', 46),
+        (30, '=') : ('REDUCE', 46),
+        (30, '+') : ('REDUCE', 46),
+        (30, 'of') : ('REDUCE', 46),
+        (30, '-') : ('REDUCE', 46),
+        (30, '*') : ('REDUCE', 46),
+        (30, '/') : ('REDUCE', 46),
+        (30, '<') : ('REDUCE', 46),
+        (30, '<=') : ('REDUCE', 46),
+        (30, '@') : ('REDUCE', 46),
+        (31, 'fi') : ('REDUCE', 41),
+        (31, '/') : ('REDUCE', 41),
+        (31, '}') : ('REDUCE', 41),
+        (31, 'else') : ('REDUCE', 41),
+        (31, 'in') : ('REDUCE', 41),
+        (31, '<') : ('REDUCE', 41),
+        (31, '=') : ('REDUCE', 41),
+        (31, ';') : ('REDUCE', 41),
+        (31, '<=') : ('REDUCE', 41),
+        (31, '+') : ('REDUCE', 41),
+        (31, ')') : ('REDUCE', 41),
+        (31, 'of') : ('REDUCE', 41),
+        (31, '-') : ('REDUCE', 41),
+        (31, 'then') : ('REDUCE', 41),
+        (31, 'loop') : ('REDUCE', 41),
+        (31, '*') : ('REDUCE', 41),
+        (31, 'pool') : ('REDUCE', 41),
+        (31, ',') : ('REDUCE', 41),
+        (32, 'fi') : ('REDUCE', 43),
+        (32, '/') : ('REDUCE', 43),
+        (32, '}') : ('REDUCE', 43),
+        (32, 'else') : ('REDUCE', 43),
+        (32, 'in') : ('REDUCE', 43),
+        (32, '<') : ('REDUCE', 43),
+        (32, '=') : ('REDUCE', 43),
+        (32, ';') : ('REDUCE', 43),
+        (32, '<=') : ('REDUCE', 43),
+        (32, '+') : ('REDUCE', 43),
+        (32, ')') : ('REDUCE', 43),
+        (32, 'of') : ('REDUCE', 43),
+        (32, '-') : ('REDUCE', 43),
+        (32, 'then') : ('REDUCE', 43),
+        (32, 'loop') : ('REDUCE', 43),
+        (32, '*') : ('REDUCE', 43),
+        (32, 'pool') : ('REDUCE', 43),
+        (32, ',') : ('REDUCE', 43),
+        (32, '@') : ('SHIFT', 61),
+        (32, '.') : ('SHIFT', 33),
+        (33, 'id') : ('SHIFT', 34),
+        (34, '(') : ('SHIFT', 35),
+        (35, 'not') : ('SHIFT', 26),
+        (35, 'let') : ('SHIFT', 8),
+        (35, 'string') : ('SHIFT', 30),
+        (35, '~') : ('SHIFT', 15),
+        (35, 'while') : ('SHIFT', 20),
+        (35, ')') : ('REDUCE', 56),
+        (35, 'id') : ('SHIFT', 18),
+        (35, 'new') : ('SHIFT', 22),
+        (35, 'true') : ('SHIFT', 28),
+        (35, '(') : ('SHIFT', 13),
+        (35, 'int') : ('SHIFT', 21),
+        (35, '{') : ('SHIFT', 14),
+        (35, 'isvoid') : ('SHIFT', 27),
+        (35, 'case') : ('SHIFT', 25),
+        (35, 'false') : ('SHIFT', 29),
+        (35, 'if') : ('SHIFT', 24),
+        (36, ')') : ('SHIFT', 37),
+        (37, 'in') : ('REDUCE', 53),
+        (37, ';') : ('REDUCE', 53),
+        (37, 'loop') : ('REDUCE', 53),
+        (37, 'pool') : ('REDUCE', 53),
+        (37, ',') : ('REDUCE', 53),
+        (37, '.') : ('REDUCE', 53),
+        (37, ')') : ('REDUCE', 53),
+        (37, 'then') : ('REDUCE', 53),
+        (37, 'else') : ('REDUCE', 53),
+        (37, '}') : ('REDUCE', 53),
+        (37, 'fi') : ('REDUCE', 53),
+        (37, '=') : ('REDUCE', 53),
+        (37, '+') : ('REDUCE', 53),
+        (37, 'of') : ('REDUCE', 53),
+        (37, '-') : ('REDUCE', 53),
+        (37, '*') : ('REDUCE', 53),
+        (37, '/') : ('REDUCE', 53),
+        (37, '<') : ('REDUCE', 53),
+        (37, '<=') : ('REDUCE', 53),
+        (37, '@') : ('REDUCE', 53),
+        (38, '<=') : ('SHIFT', 55),
+        (38, 'fi') : ('REDUCE', 31),
+        (38, '}') : ('REDUCE', 31),
+        (38, 'in') : ('REDUCE', 31),
+        (38, ';') : ('REDUCE', 31),
+        (38, ')') : ('REDUCE', 31),
+        (38, 'of') : ('REDUCE', 31),
+        (38, 'then') : ('REDUCE', 31),
+        (38, 'loop') : ('REDUCE', 31),
+        (38, 'else') : ('REDUCE', 31),
+        (38, 'pool') : ('REDUCE', 31),
+        (38, ',') : ('REDUCE', 31),
+        (38, '=') : ('SHIFT', 39),
+        (38, '<') : ('SHIFT', 53),
+        (39, 'string') : ('SHIFT', 30),
+        (39, 'not') : ('SHIFT', 26),
+        (39, 'let') : ('SHIFT', 8),
+        (39, 'while') : ('SHIFT', 20),
+        (39, 'new') : ('SHIFT', 22),
+        (39, 'id') : ('SHIFT', 18),
+        (39, 'true') : ('SHIFT', 28),
+        (39, 'int') : ('SHIFT', 21),
+        (39, '(') : ('SHIFT', 13),
+        (39, '{') : ('SHIFT', 14),
+        (39, 'isvoid') : ('SHIFT', 27),
+        (39, 'case') : ('SHIFT', 25),
+        (39, '~') : ('SHIFT', 15),
+        (39, 'false') : ('SHIFT', 29),
+        (39, 'if') : ('SHIFT', 24),
+        (40, 'fi') : ('REDUCE', 30),
+        (40, '}') : ('REDUCE', 30),
+        (40, 'in') : ('REDUCE', 30),
+        (40, ';') : ('REDUCE', 30),
+        (40, ')') : ('REDUCE', 30),
+        (40, 'of') : ('REDUCE', 30),
+        (40, 'then') : ('REDUCE', 30),
+        (40, 'loop') : ('REDUCE', 30),
+        (40, 'else') : ('REDUCE', 30),
+        (40, 'pool') : ('REDUCE', 30),
+        (40, ',') : ('REDUCE', 30),
+        (41, '+') : ('SHIFT', 42),
+        (41, '-') : ('SHIFT', 50),
+        (41, 'fi') : ('REDUCE', 34),
+        (41, '}') : ('REDUCE', 34),
+        (41, 'in') : ('REDUCE', 34),
+        (41, '<') : ('REDUCE', 34),
+        (41, '=') : ('REDUCE', 34),
+        (41, ';') : ('REDUCE', 34),
+        (41, '<=') : ('REDUCE', 34),
+        (41, ')') : ('REDUCE', 34),
+        (41, 'of') : ('REDUCE', 34),
+        (41, 'then') : ('REDUCE', 34),
+        (41, 'loop') : ('REDUCE', 34),
+        (41, 'else') : ('REDUCE', 34),
+        (41, 'pool') : ('REDUCE', 34),
+        (41, ',') : ('REDUCE', 34),
+        (42, 'string') : ('SHIFT', 30),
+        (42, 'id') : ('SHIFT', 16),
+        (42, 'new') : ('SHIFT', 22),
+        (42, 'isvoid') : ('SHIFT', 27),
+        (42, 'true') : ('SHIFT', 28),
+        (42, '~') : ('SHIFT', 15),
+        (42, 'int') : ('SHIFT', 21),
+        (42, 'false') : ('SHIFT', 29),
+        (42, '(') : ('SHIFT', 13),
+        (42, 'if') : ('SHIFT', 24),
+        (43, '*') : ('SHIFT', 44),
+        (43, '/') : ('SHIFT', 47),
+        (43, 'fi') : ('REDUCE', 35),
+        (43, '}') : ('REDUCE', 35),
+        (43, 'in') : ('REDUCE', 35),
+        (43, '<') : ('REDUCE', 35),
+        (43, '=') : ('REDUCE', 35),
+        (43, ';') : ('REDUCE', 35),
+        (43, '<=') : ('REDUCE', 35),
+        (43, '+') : ('REDUCE', 35),
+        (43, ')') : ('REDUCE', 35),
+        (43, 'of') : ('REDUCE', 35),
+        (43, '-') : ('REDUCE', 35),
+        (43, 'then') : ('REDUCE', 35),
+        (43, 'loop') : ('REDUCE', 35),
+        (43, 'else') : ('REDUCE', 35),
+        (43, 'pool') : ('REDUCE', 35),
+        (43, ',') : ('REDUCE', 35),
+        (44, 'string') : ('SHIFT', 30),
+        (44, 'id') : ('SHIFT', 16),
+        (44, 'new') : ('SHIFT', 22),
+        (44, 'isvoid') : ('SHIFT', 27),
+        (44, 'true') : ('SHIFT', 28),
+        (44, '~') : ('SHIFT', 15),
+        (44, 'int') : ('SHIFT', 21),
+        (44, 'false') : ('SHIFT', 29),
+        (44, '(') : ('SHIFT', 13),
+        (44, 'if') : ('SHIFT', 24),
+        (45, 'fi') : ('REDUCE', 38),
+        (45, '/') : ('REDUCE', 38),
+        (45, '}') : ('REDUCE', 38),
+        (45, 'else') : ('REDUCE', 38),
+        (45, 'in') : ('REDUCE', 38),
+        (45, '<') : ('REDUCE', 38),
+        (45, '=') : ('REDUCE', 38),
+        (45, ';') : ('REDUCE', 38),
+        (45, '<=') : ('REDUCE', 38),
+        (45, '+') : ('REDUCE', 38),
+        (45, ')') : ('REDUCE', 38),
+        (45, 'of') : ('REDUCE', 38),
+        (45, '-') : ('REDUCE', 38),
+        (45, 'then') : ('REDUCE', 38),
+        (45, 'loop') : ('REDUCE', 38),
+        (45, '*') : ('REDUCE', 38),
+        (45, 'pool') : ('REDUCE', 38),
+        (45, ',') : ('REDUCE', 38),
+        (46, 'in') : ('REDUCE', 52),
+        (46, ';') : ('REDUCE', 52),
+        (46, 'loop') : ('REDUCE', 52),
+        (46, 'pool') : ('REDUCE', 52),
+        (46, ',') : ('REDUCE', 52),
+        (46, '.') : ('REDUCE', 52),
+        (46, ')') : ('REDUCE', 52),
+        (46, 'then') : ('REDUCE', 52),
+        (46, 'else') : ('REDUCE', 52),
+        (46, '}') : ('REDUCE', 52),
+        (46, 'fi') : ('REDUCE', 52),
+        (46, '=') : ('REDUCE', 52),
+        (46, '+') : ('REDUCE', 52),
+        (46, 'of') : ('REDUCE', 52),
+        (46, '-') : ('REDUCE', 52),
+        (46, '*') : ('REDUCE', 52),
+        (46, '/') : ('REDUCE', 52),
+        (46, '<') : ('REDUCE', 52),
+        (46, '<=') : ('REDUCE', 52),
+        (46, '@') : ('REDUCE', 52),
+        (47, 'string') : ('SHIFT', 30),
         (47, 'id') : ('SHIFT', 16),
-        (47, 'if') : ('SHIFT', 24),
-        (47, '(') : ('SHIFT', 13),
-        (47, '~') : ('SHIFT', 15),
         (47, 'new') : ('SHIFT', 22),
-        (47, 'false') : ('SHIFT', 28),
+        (47, 'isvoid') : ('SHIFT', 27),
+        (47, 'true') : ('SHIFT', 28),
+        (47, '~') : ('SHIFT', 15),
         (47, 'int') : ('SHIFT', 21),
-        (47, 'string') : ('SHIFT', 29),
-        (47, 'not') : ('SHIFT', 26),
-        (47, 'isvoid') : ('SHIFT', 34),
-        (48, '-') : ('REDUCE', 34),
-        (48, 'then') : ('REDUCE', 34),
-        (48, 'loop') : ('REDUCE', 34),
-        (48, 'of') : ('REDUCE', 34),
-        (48, ';') : ('REDUCE', 34),
-        (48, 'else') : ('REDUCE', 34),
-        (48, 'pool') : ('REDUCE', 34),
-        (48, '}') : ('REDUCE', 34),
-        (48, ',') : ('REDUCE', 34),
-        (48, 'fi') : ('REDUCE', 34),
-        (48, '<') : ('REDUCE', 34),
-        (48, 'in') : ('REDUCE', 34),
-        (48, '=') : ('REDUCE', 34),
-        (48, '<=') : ('REDUCE', 34),
-        (48, '+') : ('REDUCE', 34),
-        (48, ')') : ('REDUCE', 34),
-        (48, '*') : ('SHIFT', 49),
-        (48, '/') : ('SHIFT', 52),
-        (49, 'true') : ('SHIFT', 27),
-        (49, 'id') : ('SHIFT', 16),
-        (49, 'if') : ('SHIFT', 24),
-        (49, '(') : ('SHIFT', 13),
-        (49, '~') : ('SHIFT', 15),
-        (49, 'new') : ('SHIFT', 22),
-        (49, 'false') : ('SHIFT', 28),
-        (49, 'int') : ('SHIFT', 21),
-        (49, 'string') : ('SHIFT', 29),
-        (49, 'not') : ('SHIFT', 26),
-        (49, 'isvoid') : ('SHIFT', 34),
-        (50, '-') : ('REDUCE', 37),
-        (50, 'then') : ('REDUCE', 37),
-        (50, 'loop') : ('REDUCE', 37),
-        (50, 'of') : ('REDUCE', 37),
-        (50, ';') : ('REDUCE', 37),
-        (50, '*') : ('REDUCE', 37),
-        (50, 'else') : ('REDUCE', 37),
-        (50, 'pool') : ('REDUCE', 37),
-        (50, '}') : ('REDUCE', 37),
-        (50, ',') : ('REDUCE', 37),
-        (50, '/') : ('REDUCE', 37),
-        (50, 'fi') : ('REDUCE', 37),
-        (50, '<') : ('REDUCE', 37),
-        (50, 'in') : ('REDUCE', 37),
-        (50, '=') : ('REDUCE', 37),
-        (50, '<=') : ('REDUCE', 37),
-        (50, '+') : ('REDUCE', 37),
-        (50, ')') : ('REDUCE', 37),
-        (51, '-') : ('REDUCE', 52),
-        (51, 'of') : ('REDUCE', 52),
-        (51, '*') : ('REDUCE', 52),
-        (51, '/') : ('REDUCE', 52),
-        (51, '<') : ('REDUCE', 52),
-        (51, '<=') : ('REDUCE', 52),
-        (51, '@') : ('REDUCE', 52),
-        (51, 'in') : ('REDUCE', 52),
-        (51, ';') : ('REDUCE', 52),
-        (51, 'loop') : ('REDUCE', 52),
-        (51, 'pool') : ('REDUCE', 52),
-        (51, ',') : ('REDUCE', 52),
-        (51, '.') : ('REDUCE', 52),
-        (51, ')') : ('REDUCE', 52),
-        (51, 'then') : ('REDUCE', 52),
-        (51, 'else') : ('REDUCE', 52),
-        (51, '}') : ('REDUCE', 52),
-        (51, 'fi') : ('REDUCE', 52),
-        (51, '=') : ('REDUCE', 52),
-        (51, '+') : ('REDUCE', 52),
-        (52, 'true') : ('SHIFT', 27),
-        (52, 'id') : ('SHIFT', 16),
-        (52, 'if') : ('SHIFT', 24),
-        (52, '(') : ('SHIFT', 13),
-        (52, '~') : ('SHIFT', 15),
-        (52, 'new') : ('SHIFT', 22),
-        (52, 'false') : ('SHIFT', 28),
-        (52, 'int') : ('SHIFT', 21),
-        (52, 'string') : ('SHIFT', 29),
-        (52, 'not') : ('SHIFT', 26),
-        (52, 'isvoid') : ('SHIFT', 34),
-        (53, '-') : ('REDUCE', 38),
-        (53, 'then') : ('REDUCE', 38),
-        (53, 'loop') : ('REDUCE', 38),
-        (53, 'of') : ('REDUCE', 38),
-        (53, ';') : ('REDUCE', 38),
-        (53, '*') : ('REDUCE', 38),
-        (53, 'else') : ('REDUCE', 38),
-        (53, 'pool') : ('REDUCE', 38),
-        (53, '}') : ('REDUCE', 38),
-        (53, ',') : ('REDUCE', 38),
-        (53, '/') : ('REDUCE', 38),
-        (53, 'fi') : ('REDUCE', 38),
-        (53, '<') : ('REDUCE', 38),
-        (53, 'in') : ('REDUCE', 38),
-        (53, '=') : ('REDUCE', 38),
-        (53, '<=') : ('REDUCE', 38),
-        (53, '+') : ('REDUCE', 38),
-        (53, ')') : ('REDUCE', 38),
-        (54, '-') : ('REDUCE', 39),
-        (54, 'then') : ('REDUCE', 39),
-        (54, 'loop') : ('REDUCE', 39),
-        (54, 'of') : ('REDUCE', 39),
-        (54, ';') : ('REDUCE', 39),
-        (54, '*') : ('REDUCE', 39),
-        (54, 'else') : ('REDUCE', 39),
-        (54, 'pool') : ('REDUCE', 39),
-        (54, '}') : ('REDUCE', 39),
-        (54, ',') : ('REDUCE', 39),
-        (54, '/') : ('REDUCE', 39),
-        (54, 'fi') : ('REDUCE', 39),
-        (54, '<') : ('REDUCE', 39),
-        (54, 'in') : ('REDUCE', 39),
-        (54, '=') : ('REDUCE', 39),
-        (54, '<=') : ('REDUCE', 39),
-        (54, '+') : ('REDUCE', 39),
-        (54, ')') : ('REDUCE', 39),
-        (55, 'true') : ('SHIFT', 27),
+        (47, 'false') : ('SHIFT', 29),
+        (47, '(') : ('SHIFT', 13),
+        (47, 'if') : ('SHIFT', 24),
+        (48, 'fi') : ('REDUCE', 39),
+        (48, '/') : ('REDUCE', 39),
+        (48, '}') : ('REDUCE', 39),
+        (48, 'else') : ('REDUCE', 39),
+        (48, 'in') : ('REDUCE', 39),
+        (48, '<') : ('REDUCE', 39),
+        (48, '=') : ('REDUCE', 39),
+        (48, ';') : ('REDUCE', 39),
+        (48, '<=') : ('REDUCE', 39),
+        (48, '+') : ('REDUCE', 39),
+        (48, ')') : ('REDUCE', 39),
+        (48, 'of') : ('REDUCE', 39),
+        (48, '-') : ('REDUCE', 39),
+        (48, 'then') : ('REDUCE', 39),
+        (48, 'loop') : ('REDUCE', 39),
+        (48, '*') : ('REDUCE', 39),
+        (48, 'pool') : ('REDUCE', 39),
+        (48, ',') : ('REDUCE', 39),
+        (49, 'fi') : ('REDUCE', 40),
+        (49, '/') : ('REDUCE', 40),
+        (49, '}') : ('REDUCE', 40),
+        (49, 'else') : ('REDUCE', 40),
+        (49, 'in') : ('REDUCE', 40),
+        (49, '<') : ('REDUCE', 40),
+        (49, '=') : ('REDUCE', 40),
+        (49, ';') : ('REDUCE', 40),
+        (49, '<=') : ('REDUCE', 40),
+        (49, '+') : ('REDUCE', 40),
+        (49, ')') : ('REDUCE', 40),
+        (49, 'of') : ('REDUCE', 40),
+        (49, '-') : ('REDUCE', 40),
+        (49, 'then') : ('REDUCE', 40),
+        (49, 'loop') : ('REDUCE', 40),
+        (49, '*') : ('REDUCE', 40),
+        (49, 'pool') : ('REDUCE', 40),
+        (49, ',') : ('REDUCE', 40),
+        (50, 'string') : ('SHIFT', 30),
+        (50, 'id') : ('SHIFT', 16),
+        (50, 'new') : ('SHIFT', 22),
+        (50, 'isvoid') : ('SHIFT', 27),
+        (50, 'true') : ('SHIFT', 28),
+        (50, '~') : ('SHIFT', 15),
+        (50, 'int') : ('SHIFT', 21),
+        (50, 'false') : ('SHIFT', 29),
+        (50, '(') : ('SHIFT', 13),
+        (50, 'if') : ('SHIFT', 24),
+        (51, '*') : ('SHIFT', 44),
+        (51, 'fi') : ('REDUCE', 36),
+        (51, '}') : ('REDUCE', 36),
+        (51, 'in') : ('REDUCE', 36),
+        (51, '<') : ('REDUCE', 36),
+        (51, '=') : ('REDUCE', 36),
+        (51, ';') : ('REDUCE', 36),
+        (51, '<=') : ('REDUCE', 36),
+        (51, '+') : ('REDUCE', 36),
+        (51, ')') : ('REDUCE', 36),
+        (51, 'of') : ('REDUCE', 36),
+        (51, '-') : ('REDUCE', 36),
+        (51, 'then') : ('REDUCE', 36),
+        (51, 'loop') : ('REDUCE', 36),
+        (51, 'else') : ('REDUCE', 36),
+        (51, 'pool') : ('REDUCE', 36),
+        (51, ',') : ('REDUCE', 36),
+        (51, '/') : ('SHIFT', 47),
+        (52, '*') : ('SHIFT', 44),
+        (52, 'fi') : ('REDUCE', 37),
+        (52, '}') : ('REDUCE', 37),
+        (52, 'in') : ('REDUCE', 37),
+        (52, '<') : ('REDUCE', 37),
+        (52, '=') : ('REDUCE', 37),
+        (52, ';') : ('REDUCE', 37),
+        (52, '<=') : ('REDUCE', 37),
+        (52, '+') : ('REDUCE', 37),
+        (52, ')') : ('REDUCE', 37),
+        (52, 'of') : ('REDUCE', 37),
+        (52, '-') : ('REDUCE', 37),
+        (52, 'then') : ('REDUCE', 37),
+        (52, 'loop') : ('REDUCE', 37),
+        (52, 'else') : ('REDUCE', 37),
+        (52, 'pool') : ('REDUCE', 37),
+        (52, ',') : ('REDUCE', 37),
+        (52, '/') : ('SHIFT', 47),
+        (53, 'string') : ('SHIFT', 30),
+        (53, 'id') : ('SHIFT', 16),
+        (53, 'new') : ('SHIFT', 22),
+        (53, 'isvoid') : ('SHIFT', 27),
+        (53, 'true') : ('SHIFT', 28),
+        (53, '~') : ('SHIFT', 15),
+        (53, 'int') : ('SHIFT', 21),
+        (53, 'false') : ('SHIFT', 29),
+        (53, '(') : ('SHIFT', 13),
+        (53, 'if') : ('SHIFT', 24),
+        (54, '+') : ('SHIFT', 42),
+        (54, '-') : ('SHIFT', 50),
+        (54, 'fi') : ('REDUCE', 32),
+        (54, '}') : ('REDUCE', 32),
+        (54, 'in') : ('REDUCE', 32),
+        (54, '<') : ('REDUCE', 32),
+        (54, '=') : ('REDUCE', 32),
+        (54, ';') : ('REDUCE', 32),
+        (54, '<=') : ('REDUCE', 32),
+        (54, ')') : ('REDUCE', 32),
+        (54, 'of') : ('REDUCE', 32),
+        (54, 'then') : ('REDUCE', 32),
+        (54, 'loop') : ('REDUCE', 32),
+        (54, 'else') : ('REDUCE', 32),
+        (54, 'pool') : ('REDUCE', 32),
+        (54, ',') : ('REDUCE', 32),
+        (55, 'string') : ('SHIFT', 30),
         (55, 'id') : ('SHIFT', 16),
-        (55, 'if') : ('SHIFT', 24),
-        (55, '(') : ('SHIFT', 13),
-        (55, '~') : ('SHIFT', 15),
         (55, 'new') : ('SHIFT', 22),
-        (55, 'false') : ('SHIFT', 28),
+        (55, 'isvoid') : ('SHIFT', 27),
+        (55, 'true') : ('SHIFT', 28),
+        (55, '~') : ('SHIFT', 15),
         (55, 'int') : ('SHIFT', 21),
-        (55, 'string') : ('SHIFT', 29),
-        (55, 'not') : ('SHIFT', 26),
-        (55, 'isvoid') : ('SHIFT', 34),
-        (56, '-') : ('REDUCE', 35),
-        (56, 'then') : ('REDUCE', 35),
-        (56, 'loop') : ('REDUCE', 35),
-        (56, 'of') : ('REDUCE', 35),
-        (56, ';') : ('REDUCE', 35),
-        (56, 'else') : ('REDUCE', 35),
-        (56, 'pool') : ('REDUCE', 35),
-        (56, '}') : ('REDUCE', 35),
-        (56, ',') : ('REDUCE', 35),
-        (56, 'fi') : ('REDUCE', 35),
-        (56, '<') : ('REDUCE', 35),
-        (56, 'in') : ('REDUCE', 35),
-        (56, '=') : ('REDUCE', 35),
-        (56, '<=') : ('REDUCE', 35),
-        (56, '+') : ('REDUCE', 35),
-        (56, ')') : ('REDUCE', 35),
-        (56, '*') : ('SHIFT', 49),
-        (56, '/') : ('SHIFT', 52),
-        (57, '*') : ('SHIFT', 49),
-        (57, '/') : ('SHIFT', 52),
-        (57, '-') : ('REDUCE', 36),
-        (57, 'then') : ('REDUCE', 36),
-        (57, 'loop') : ('REDUCE', 36),
-        (57, 'of') : ('REDUCE', 36),
-        (57, ';') : ('REDUCE', 36),
-        (57, 'else') : ('REDUCE', 36),
-        (57, 'pool') : ('REDUCE', 36),
-        (57, '}') : ('REDUCE', 36),
-        (57, ',') : ('REDUCE', 36),
-        (57, 'fi') : ('REDUCE', 36),
-        (57, '<') : ('REDUCE', 36),
-        (57, 'in') : ('REDUCE', 36),
-        (57, '=') : ('REDUCE', 36),
-        (57, '<=') : ('REDUCE', 36),
-        (57, '+') : ('REDUCE', 36),
-        (57, ')') : ('REDUCE', 36),
-        (58, 'true') : ('SHIFT', 27),
-        (58, 'id') : ('SHIFT', 16),
-        (58, 'if') : ('SHIFT', 24),
-        (58, '(') : ('SHIFT', 13),
+        (55, 'false') : ('SHIFT', 29),
+        (55, '(') : ('SHIFT', 13),
+        (55, 'if') : ('SHIFT', 24),
+        (56, '+') : ('SHIFT', 42),
+        (56, '-') : ('SHIFT', 50),
+        (56, 'fi') : ('REDUCE', 33),
+        (56, '}') : ('REDUCE', 33),
+        (56, 'in') : ('REDUCE', 33),
+        (56, '<') : ('REDUCE', 33),
+        (56, '=') : ('REDUCE', 33),
+        (56, ';') : ('REDUCE', 33),
+        (56, '<=') : ('REDUCE', 33),
+        (56, ')') : ('REDUCE', 33),
+        (56, 'of') : ('REDUCE', 33),
+        (56, 'then') : ('REDUCE', 33),
+        (56, 'loop') : ('REDUCE', 33),
+        (56, 'else') : ('REDUCE', 33),
+        (56, 'pool') : ('REDUCE', 33),
+        (56, ',') : ('REDUCE', 33),
+        (57, ',') : ('SHIFT', 58),
+        (57, ')') : ('REDUCE', 58),
+        (58, 'not') : ('SHIFT', 26),
+        (58, 'let') : ('SHIFT', 8),
+        (58, 'string') : ('SHIFT', 30),
         (58, '~') : ('SHIFT', 15),
+        (58, 'while') : ('SHIFT', 20),
         (58, 'new') : ('SHIFT', 22),
-        (58, 'false') : ('SHIFT', 28),
+        (58, 'id') : ('SHIFT', 18),
+        (58, 'true') : ('SHIFT', 28),
+        (58, '(') : ('SHIFT', 13),
         (58, 'int') : ('SHIFT', 21),
-        (58, 'string') : ('SHIFT', 29),
-        (58, 'not') : ('SHIFT', 26),
-        (58, 'isvoid') : ('SHIFT', 34),
-        (59, '-') : ('SHIFT', 55),
-        (59, '+') : ('SHIFT', 47),
-        (59, 'then') : ('REDUCE', 30),
-        (59, 'loop') : ('REDUCE', 30),
-        (59, 'of') : ('REDUCE', 30),
-        (59, ';') : ('REDUCE', 30),
-        (59, 'else') : ('REDUCE', 30),
-        (59, 'pool') : ('REDUCE', 30),
-        (59, '}') : ('REDUCE', 30),
-        (59, ',') : ('REDUCE', 30),
-        (59, 'fi') : ('REDUCE', 30),
-        (59, '<') : ('REDUCE', 30),
-        (59, 'in') : ('REDUCE', 30),
-        (59, '=') : ('REDUCE', 30),
-        (59, '<=') : ('REDUCE', 30),
-        (59, ')') : ('REDUCE', 30),
-        (60, 'true') : ('SHIFT', 27),
-        (60, 'id') : ('SHIFT', 16),
-        (60, 'if') : ('SHIFT', 24),
-        (60, '(') : ('SHIFT', 13),
-        (60, '~') : ('SHIFT', 15),
-        (60, 'new') : ('SHIFT', 22),
-        (60, 'false') : ('SHIFT', 28),
-        (60, 'int') : ('SHIFT', 21),
-        (60, 'string') : ('SHIFT', 29),
-        (60, 'not') : ('SHIFT', 26),
-        (60, 'isvoid') : ('SHIFT', 34),
-        (61, '-') : ('SHIFT', 55),
-        (61, '+') : ('SHIFT', 47),
-        (61, 'then') : ('REDUCE', 31),
-        (61, 'loop') : ('REDUCE', 31),
-        (61, 'of') : ('REDUCE', 31),
-        (61, ';') : ('REDUCE', 31),
-        (61, 'else') : ('REDUCE', 31),
-        (61, 'pool') : ('REDUCE', 31),
-        (61, '}') : ('REDUCE', 31),
-        (61, ',') : ('REDUCE', 31),
-        (61, 'fi') : ('REDUCE', 31),
-        (61, '<') : ('REDUCE', 31),
-        (61, 'in') : ('REDUCE', 31),
-        (61, '=') : ('REDUCE', 31),
-        (61, '<=') : ('REDUCE', 31),
-        (61, ')') : ('REDUCE', 31),
-        (62, ',') : ('SHIFT', 63),
-        (62, ')') : ('REDUCE', 58),
-        (63, 'let') : ('SHIFT', 8),
-        (63, 'int') : ('SHIFT', 21),
-        (63, '~') : ('SHIFT', 15),
-        (63, 'string') : ('SHIFT', 29),
-        (63, 'not') : ('SHIFT', 26),
-        (63, 'id') : ('SHIFT', 18),
-        (63, 'isvoid') : ('SHIFT', 34),
-        (63, 'while') : ('SHIFT', 20),
-        (63, 'false') : ('SHIFT', 28),
-        (63, 'case') : ('SHIFT', 25),
-        (63, 'if') : ('SHIFT', 24),
-        (63, '{') : ('SHIFT', 14),
-        (63, 'true') : ('SHIFT', 27),
-        (63, 'new') : ('SHIFT', 22),
-        (63, '(') : ('SHIFT', 13),
-        (64, 'then') : ('REDUCE', 33),
-        (64, 'loop') : ('REDUCE', 33),
-        (64, 'of') : ('REDUCE', 33),
-        (64, '<=') : ('REDUCE', 33),
-        (64, 'else') : ('REDUCE', 33),
-        (64, 'pool') : ('REDUCE', 33),
-        (64, '}') : ('REDUCE', 33),
-        (64, ',') : ('REDUCE', 33),
-        (64, 'fi') : ('REDUCE', 33),
-        (64, '<') : ('REDUCE', 33),
-        (64, 'in') : ('REDUCE', 33),
-        (64, '=') : ('REDUCE', 33),
-        (64, ';') : ('REDUCE', 33),
-        (64, ')') : ('REDUCE', 33),
-        (64, '-') : ('SHIFT', 55),
-        (64, '+') : ('SHIFT', 47),
-        (65, ')') : ('REDUCE', 59),
-        (66, ')') : ('REDUCE', 57),
-        (67, ')') : ('SHIFT', 68),
-        (68, '-') : ('REDUCE', 53),
-        (68, 'of') : ('REDUCE', 53),
-        (68, '*') : ('REDUCE', 53),
-        (68, '/') : ('REDUCE', 53),
-        (68, '<') : ('REDUCE', 53),
-        (68, '<=') : ('REDUCE', 53),
-        (68, '@') : ('REDUCE', 53),
-        (68, 'in') : ('REDUCE', 53),
-        (68, ';') : ('REDUCE', 53),
-        (68, 'loop') : ('REDUCE', 53),
-        (68, 'pool') : ('REDUCE', 53),
-        (68, ',') : ('REDUCE', 53),
-        (68, '.') : ('REDUCE', 53),
-        (68, ')') : ('REDUCE', 53),
-        (68, 'then') : ('REDUCE', 53),
-        (68, 'else') : ('REDUCE', 53),
-        (68, '}') : ('REDUCE', 53),
-        (68, 'fi') : ('REDUCE', 53),
-        (68, '=') : ('REDUCE', 53),
-        (68, '+') : ('REDUCE', 53),
+        (58, '{') : ('SHIFT', 14),
+        (58, 'case') : ('SHIFT', 25),
+        (58, 'false') : ('SHIFT', 29),
+        (58, 'isvoid') : ('SHIFT', 27),
+        (58, 'if') : ('SHIFT', 24),
+        (59, ')') : ('REDUCE', 59),
+        (60, ')') : ('REDUCE', 57),
+        (61, 'type') : ('SHIFT', 62),
+        (62, '.') : ('SHIFT', 63),
+        (63, 'id') : ('SHIFT', 64),
+        (64, '(') : ('SHIFT', 65),
+        (65, 'not') : ('SHIFT', 26),
+        (65, 'let') : ('SHIFT', 8),
+        (65, 'string') : ('SHIFT', 30),
+        (65, '~') : ('SHIFT', 15),
+        (65, 'while') : ('SHIFT', 20),
+        (65, ')') : ('REDUCE', 56),
+        (65, 'id') : ('SHIFT', 18),
+        (65, 'new') : ('SHIFT', 22),
+        (65, 'true') : ('SHIFT', 28),
+        (65, '(') : ('SHIFT', 13),
+        (65, 'int') : ('SHIFT', 21),
+        (65, '{') : ('SHIFT', 14),
+        (65, 'isvoid') : ('SHIFT', 27),
+        (65, 'case') : ('SHIFT', 25),
+        (65, 'false') : ('SHIFT', 29),
+        (65, 'if') : ('SHIFT', 24),
+        (66, ')') : ('SHIFT', 67),
+        (67, 'in') : ('REDUCE', 55),
+        (67, ';') : ('REDUCE', 55),
+        (67, 'loop') : ('REDUCE', 55),
+        (67, 'pool') : ('REDUCE', 55),
+        (67, ',') : ('REDUCE', 55),
+        (67, '.') : ('REDUCE', 55),
+        (67, ')') : ('REDUCE', 55),
+        (67, 'then') : ('REDUCE', 55),
+        (67, 'else') : ('REDUCE', 55),
+        (67, '}') : ('REDUCE', 55),
+        (67, 'fi') : ('REDUCE', 55),
+        (67, '=') : ('REDUCE', 55),
+        (67, '+') : ('REDUCE', 55),
+        (67, 'of') : ('REDUCE', 55),
+        (67, '-') : ('REDUCE', 55),
+        (67, '*') : ('REDUCE', 55),
+        (67, '/') : ('REDUCE', 55),
+        (67, '<') : ('REDUCE', 55),
+        (67, '<=') : ('REDUCE', 55),
+        (67, '@') : ('REDUCE', 55),
+        (68, 'fi') : ('REDUCE', 29),
+        (68, '}') : ('REDUCE', 29),
+        (68, 'in') : ('REDUCE', 29),
+        (68, ';') : ('REDUCE', 29),
+        (68, ')') : ('REDUCE', 29),
+        (68, 'of') : ('REDUCE', 29),
+        (68, 'then') : ('REDUCE', 29),
+        (68, 'loop') : ('REDUCE', 29),
+        (68, 'else') : ('REDUCE', 29),
+        (68, 'pool') : ('REDUCE', 29),
+        (68, ',') : ('REDUCE', 29),
         (69, 'of') : ('SHIFT', 70),
         (70, 'id') : ('SHIFT', 71),
         (71, ':') : ('SHIFT', 72),
         (72, 'type') : ('SHIFT', 73),
         (73, '=>') : ('SHIFT', 74),
         (74, 'id') : ('SHIFT', 18),
-        (74, 'true') : ('SHIFT', 27),
-        (74, 'new') : ('SHIFT', 22),
+        (74, 'isvoid') : ('SHIFT', 27),
+        (74, 'false') : ('SHIFT', 29),
         (74, 'if') : ('SHIFT', 24),
-        (74, '(') : ('SHIFT', 13),
-        (74, 'let') : ('SHIFT', 8),
         (74, '~') : ('SHIFT', 15),
+        (74, 'string') : ('SHIFT', 30),
+        (74, '{') : ('SHIFT', 14),
+        (74, 'case') : ('SHIFT', 25),
+        (74, 'new') : ('SHIFT', 22),
+        (74, 'true') : ('SHIFT', 28),
         (74, 'int') : ('SHIFT', 21),
-        (74, 'string') : ('SHIFT', 29),
+        (74, '(') : ('SHIFT', 13),
         (74, 'not') : ('SHIFT', 26),
+        (74, 'let') : ('SHIFT', 8),
         (74, 'while') : ('SHIFT', 20),
-        (74, 'isvoid') : ('SHIFT', 34),
-        (74, 'case') : ('SHIFT', 25),
-        (74, 'false') : ('SHIFT', 28),
-        (74, '{') : ('SHIFT', 14),
         (75, ';') : ('SHIFT', 76),
         (76, 'id') : ('SHIFT', 71),
         (76, 'esac') : ('REDUCE', 27),
         (77, 'esac') : ('REDUCE', 28),
         (78, 'esac') : ('SHIFT', 79),
+        (79, 'fi') : ('REDUCE', 26),
+        (79, '}') : ('REDUCE', 26),
+        (79, 'in') : ('REDUCE', 26),
+        (79, ';') : ('REDUCE', 26),
+        (79, ')') : ('REDUCE', 26),
+        (79, 'of') : ('REDUCE', 26),
         (79, 'then') : ('REDUCE', 26),
         (79, 'loop') : ('REDUCE', 26),
-        (79, 'of') : ('REDUCE', 26),
         (79, 'else') : ('REDUCE', 26),
         (79, 'pool') : ('REDUCE', 26),
-        (79, '}') : ('REDUCE', 26),
         (79, ',') : ('REDUCE', 26),
-        (79, 'fi') : ('REDUCE', 26),
-        (79, 'in') : ('REDUCE', 26),
-        (79, ';') : ('REDUCE', 26),
-        (79, ')') : ('REDUCE', 26),
         (80, 'then') : ('SHIFT', 81),
-        (81, 'id') : ('SHIFT', 18),
-        (81, 'false') : ('SHIFT', 28),
-        (81, 'while') : ('SHIFT', 20),
+        (81, 'isvoid') : ('SHIFT', 27),
+        (81, 'false') : ('SHIFT', 29),
         (81, 'case') : ('SHIFT', 25),
-        (81, '~') : ('SHIFT', 15),
-        (81, '{') : ('SHIFT', 14),
-        (81, 'true') : ('SHIFT', 27),
         (81, 'if') : ('SHIFT', 24),
-        (81, '(') : ('SHIFT', 13),
-        (81, 'new') : ('SHIFT', 22),
+        (81, '~') : ('SHIFT', 15),
+        (81, 'string') : ('SHIFT', 30),
         (81, 'not') : ('SHIFT', 26),
-        (81, 'int') : ('SHIFT', 21),
-        (81, 'string') : ('SHIFT', 29),
+        (81, 'new') : ('SHIFT', 22),
+        (81, 'id') : ('SHIFT', 18),
         (81, 'let') : ('SHIFT', 8),
-        (81, 'isvoid') : ('SHIFT', 34),
+        (81, 'while') : ('SHIFT', 20),
+        (81, 'true') : ('SHIFT', 28),
+        (81, 'int') : ('SHIFT', 21),
+        (81, '(') : ('SHIFT', 13),
+        (81, '{') : ('SHIFT', 14),
         (82, 'else') : ('SHIFT', 83),
         (83, 'while') : ('SHIFT', 20),
         (83, 'id') : ('SHIFT', 18),
-        (83, 'case') : ('SHIFT', 25),
+        (83, 'new') : ('SHIFT', 22),
+        (83, 'true') : ('SHIFT', 28),
+        (83, '(') : ('SHIFT', 13),
+        (83, 'int') : ('SHIFT', 21),
         (83, '{') : ('SHIFT', 14),
-        (83, 'false') : ('SHIFT', 28),
+        (83, 'isvoid') : ('SHIFT', 27),
+        (83, 'case') : ('SHIFT', 25),
         (83, '~') : ('SHIFT', 15),
-        (83, 'true') : ('SHIFT', 27),
-        (83, 'let') : ('SHIFT', 8),
-        (83, 'new') : ('SHIFT', 22),
+        (83, 'false') : ('SHIFT', 29),
         (83, 'if') : ('SHIFT', 24),
-        (83, '(') : ('SHIFT', 13),
+        (83, 'string') : ('SHIFT', 30),
         (83, 'not') : ('SHIFT', 26),
-        (83, 'isvoid') : ('SHIFT', 34),
-        (83, 'int') : ('SHIFT', 21),
-        (83, 'string') : ('SHIFT', 29),
+        (83, 'let') : ('SHIFT', 8),
         (84, 'fi') : ('SHIFT', 85),
-        (85, '-') : ('REDUCE', 50),
-        (85, 'of') : ('REDUCE', 50),
-        (85, '*') : ('REDUCE', 50),
-        (85, '/') : ('REDUCE', 50),
-        (85, '<') : ('REDUCE', 50),
-        (85, '<=') : ('REDUCE', 50),
-        (85, '@') : ('REDUCE', 50),
         (85, 'in') : ('REDUCE', 50),
         (85, ';') : ('REDUCE', 50),
         (85, 'loop') : ('REDUCE', 50),
@@ -877,53 +859,53 @@ def __init__(self, G):
         (85, 'fi') : ('REDUCE', 50),
         (85, '=') : ('REDUCE', 50),
         (85, '+') : ('REDUCE', 50),
+        (85, 'of') : ('REDUCE', 50),
+        (85, '-') : ('REDUCE', 50),
+        (85, '*') : ('REDUCE', 50),
+        (85, '/') : ('REDUCE', 50),
+        (85, '<') : ('REDUCE', 50),
+        (85, '<=') : ('REDUCE', 50),
+        (85, '@') : ('REDUCE', 50),
         (86, 'loop') : ('SHIFT', 87),
-        (87, 'id') : ('SHIFT', 18),
-        (87, 'new') : ('SHIFT', 22),
-        (87, 'if') : ('SHIFT', 24),
+        (87, 'true') : ('SHIFT', 28),
+        (87, 'int') : ('SHIFT', 21),
         (87, '(') : ('SHIFT', 13),
+        (87, 'not') : ('SHIFT', 26),
         (87, 'let') : ('SHIFT', 8),
-        (87, 'int') : ('SHIFT', 21),
-        (87, 'string') : ('SHIFT', 29),
-        (87, '~') : ('SHIFT', 15),
+        (87, 'id') : ('SHIFT', 18),
         (87, 'while') : ('SHIFT', 20),
-        (87, 'false') : ('SHIFT', 28),
-        (87, 'case') : ('SHIFT', 25),
-        (87, 'not') : ('SHIFT', 26),
-        (87, 'isvoid') : ('SHIFT', 34),
+        (87, 'false') : ('SHIFT', 29),
+        (87, 'isvoid') : ('SHIFT', 27),
+        (87, 'if') : ('SHIFT', 24),
+        (87, '~') : ('SHIFT', 15),
+        (87, 'string') : ('SHIFT', 30),
+        (87, 'new') : ('SHIFT', 22),
         (87, '{') : ('SHIFT', 14),
-        (87, 'true') : ('SHIFT', 27),
+        (87, 'case') : ('SHIFT', 25),
         (88, 'pool') : ('SHIFT', 89),
+        (89, 'fi') : ('REDUCE', 17),
+        (89, '}') : ('REDUCE', 17),
+        (89, 'in') : ('REDUCE', 17),
+        (89, ';') : ('REDUCE', 17),
+        (89, ')') : ('REDUCE', 17),
+        (89, 'of') : ('REDUCE', 17),
         (89, 'then') : ('REDUCE', 17),
         (89, 'loop') : ('REDUCE', 17),
-        (89, 'of') : ('REDUCE', 17),
         (89, 'else') : ('REDUCE', 17),
         (89, 'pool') : ('REDUCE', 17),
-        (89, '}') : ('REDUCE', 17),
         (89, ',') : ('REDUCE', 17),
-        (89, 'fi') : ('REDUCE', 17),
-        (89, 'in') : ('REDUCE', 17),
-        (89, ';') : ('REDUCE', 17),
-        (89, ')') : ('REDUCE', 17),
+        (90, 'fi') : ('REDUCE', 16),
+        (90, '}') : ('REDUCE', 16),
+        (90, 'in') : ('REDUCE', 16),
+        (90, ';') : ('REDUCE', 16),
+        (90, ')') : ('REDUCE', 16),
+        (90, 'of') : ('REDUCE', 16),
         (90, 'then') : ('REDUCE', 16),
         (90, 'loop') : ('REDUCE', 16),
-        (90, 'of') : ('REDUCE', 16),
         (90, 'else') : ('REDUCE', 16),
         (90, 'pool') : ('REDUCE', 16),
-        (90, '}') : ('REDUCE', 16),
         (90, ',') : ('REDUCE', 16),
-        (90, 'fi') : ('REDUCE', 16),
-        (90, 'in') : ('REDUCE', 16),
-        (90, ';') : ('REDUCE', 16),
-        (90, ')') : ('REDUCE', 16),
         (91, ')') : ('SHIFT', 92),
-        (92, '-') : ('REDUCE', 54),
-        (92, 'of') : ('REDUCE', 54),
-        (92, '*') : ('REDUCE', 54),
-        (92, '/') : ('REDUCE', 54),
-        (92, '<') : ('REDUCE', 54),
-        (92, '<=') : ('REDUCE', 54),
-        (92, '@') : ('REDUCE', 54),
         (92, 'in') : ('REDUCE', 54),
         (92, ';') : ('REDUCE', 54),
         (92, 'loop') : ('REDUCE', 54),
@@ -937,62 +919,62 @@ def __init__(self, G):
         (92, 'fi') : ('REDUCE', 54),
         (92, '=') : ('REDUCE', 54),
         (92, '+') : ('REDUCE', 54),
-        (93, '-') : ('REDUCE', 41),
-        (93, 'then') : ('REDUCE', 41),
-        (93, 'loop') : ('REDUCE', 41),
-        (93, 'of') : ('REDUCE', 41),
-        (93, ';') : ('REDUCE', 41),
-        (93, '*') : ('REDUCE', 41),
-        (93, 'else') : ('REDUCE', 41),
-        (93, 'pool') : ('REDUCE', 41),
-        (93, '}') : ('REDUCE', 41),
-        (93, ',') : ('REDUCE', 41),
-        (93, '/') : ('REDUCE', 41),
-        (93, 'fi') : ('REDUCE', 41),
-        (93, '<') : ('REDUCE', 41),
-        (93, 'in') : ('REDUCE', 41),
-        (93, '=') : ('REDUCE', 41),
-        (93, '<=') : ('REDUCE', 41),
-        (93, '+') : ('REDUCE', 41),
-        (93, ')') : ('REDUCE', 41),
+        (92, 'of') : ('REDUCE', 54),
+        (92, '-') : ('REDUCE', 54),
+        (92, '*') : ('REDUCE', 54),
+        (92, '/') : ('REDUCE', 54),
+        (92, '<') : ('REDUCE', 54),
+        (92, '<=') : ('REDUCE', 54),
+        (92, '@') : ('REDUCE', 54),
+        (93, 'fi') : ('REDUCE', 42),
+        (93, '/') : ('REDUCE', 42),
+        (93, '}') : ('REDUCE', 42),
+        (93, 'else') : ('REDUCE', 42),
+        (93, 'in') : ('REDUCE', 42),
+        (93, '<') : ('REDUCE', 42),
+        (93, '=') : ('REDUCE', 42),
+        (93, ';') : ('REDUCE', 42),
+        (93, '<=') : ('REDUCE', 42),
+        (93, '+') : ('REDUCE', 42),
+        (93, ')') : ('REDUCE', 42),
+        (93, 'of') : ('REDUCE', 42),
+        (93, '-') : ('REDUCE', 42),
+        (93, 'then') : ('REDUCE', 42),
+        (93, 'loop') : ('REDUCE', 42),
+        (93, '*') : ('REDUCE', 42),
+        (93, 'pool') : ('REDUCE', 42),
+        (93, ',') : ('REDUCE', 42),
         (94, '}') : ('SHIFT', 95),
+        (95, 'fi') : ('REDUCE', 18),
+        (95, '}') : ('REDUCE', 18),
+        (95, 'in') : ('REDUCE', 18),
+        (95, ';') : ('REDUCE', 18),
+        (95, ')') : ('REDUCE', 18),
+        (95, 'of') : ('REDUCE', 18),
         (95, 'then') : ('REDUCE', 18),
         (95, 'loop') : ('REDUCE', 18),
-        (95, 'of') : ('REDUCE', 18),
         (95, 'else') : ('REDUCE', 18),
         (95, 'pool') : ('REDUCE', 18),
-        (95, '}') : ('REDUCE', 18),
         (95, ',') : ('REDUCE', 18),
-        (95, 'fi') : ('REDUCE', 18),
-        (95, 'in') : ('REDUCE', 18),
-        (95, ';') : ('REDUCE', 18),
-        (95, ')') : ('REDUCE', 18),
         (96, ';') : ('SHIFT', 97),
         (97, 'id') : ('SHIFT', 18),
-        (97, 'true') : ('SHIFT', 27),
-        (97, 'new') : ('SHIFT', 22),
+        (97, 'isvoid') : ('SHIFT', 27),
+        (97, 'false') : ('SHIFT', 29),
         (97, 'if') : ('SHIFT', 24),
-        (97, '}') : ('REDUCE', 19),
-        (97, '(') : ('SHIFT', 13),
-        (97, 'let') : ('SHIFT', 8),
         (97, '~') : ('SHIFT', 15),
+        (97, 'string') : ('SHIFT', 30),
+        (97, '{') : ('SHIFT', 14),
+        (97, 'case') : ('SHIFT', 25),
+        (97, 'new') : ('SHIFT', 22),
+        (97, '}') : ('REDUCE', 19),
+        (97, 'true') : ('SHIFT', 28),
         (97, 'int') : ('SHIFT', 21),
-        (97, 'string') : ('SHIFT', 29),
+        (97, '(') : ('SHIFT', 13),
         (97, 'not') : ('SHIFT', 26),
+        (97, 'let') : ('SHIFT', 8),
         (97, 'while') : ('SHIFT', 20),
-        (97, 'isvoid') : ('SHIFT', 34),
-        (97, 'case') : ('SHIFT', 25),
-        (97, 'false') : ('SHIFT', 28),
-        (97, '{') : ('SHIFT', 14),
         (98, '}') : ('REDUCE', 20),
         (99, ')') : ('SHIFT', 100),
-        (100, '-') : ('REDUCE', 51),
-        (100, 'of') : ('REDUCE', 51),
-        (100, '*') : ('REDUCE', 51),
-        (100, '/') : ('REDUCE', 51),
-        (100, '<') : ('REDUCE', 51),
-        (100, '<=') : ('REDUCE', 51),
-        (100, '@') : ('REDUCE', 51),
         (100, 'in') : ('REDUCE', 51),
         (100, ';') : ('REDUCE', 51),
         (100, 'loop') : ('REDUCE', 51),
@@ -1006,6 +988,13 @@ def __init__(self, G):
         (100, 'fi') : ('REDUCE', 51),
         (100, '=') : ('REDUCE', 51),
         (100, '+') : ('REDUCE', 51),
+        (100, 'of') : ('REDUCE', 51),
+        (100, '-') : ('REDUCE', 51),
+        (100, '*') : ('REDUCE', 51),
+        (100, '/') : ('REDUCE', 51),
+        (100, '<') : ('REDUCE', 51),
+        (100, '<=') : ('REDUCE', 51),
+        (100, '@') : ('REDUCE', 51),
         (101, 'in') : ('REDUCE', 23),
         (101, ',') : ('SHIFT', 102),
         (102, 'id') : ('SHIFT', 9),
@@ -1013,58 +1002,58 @@ def __init__(self, G):
         (104, 'id') : ('SHIFT', 9),
         (105, 'in') : ('REDUCE', 24),
         (106, 'in') : ('SHIFT', 107),
-        (107, 'true') : ('SHIFT', 27),
-        (107, 'if') : ('SHIFT', 24),
-        (107, 'id') : ('SHIFT', 18),
-        (107, '(') : ('SHIFT', 13),
-        (107, '~') : ('SHIFT', 15),
-        (107, 'new') : ('SHIFT', 22),
-        (107, 'let') : ('SHIFT', 8),
-        (107, 'int') : ('SHIFT', 21),
-        (107, 'string') : ('SHIFT', 29),
+        (107, 'string') : ('SHIFT', 30),
         (107, 'not') : ('SHIFT', 26),
-        (107, 'isvoid') : ('SHIFT', 34),
+        (107, 'let') : ('SHIFT', 8),
         (107, 'while') : ('SHIFT', 20),
-        (107, 'case') : ('SHIFT', 25),
-        (107, 'false') : ('SHIFT', 28),
+        (107, 'new') : ('SHIFT', 22),
+        (107, 'id') : ('SHIFT', 18),
+        (107, 'true') : ('SHIFT', 28),
+        (107, 'int') : ('SHIFT', 21),
+        (107, '(') : ('SHIFT', 13),
         (107, '{') : ('SHIFT', 14),
+        (107, 'isvoid') : ('SHIFT', 27),
+        (107, 'case') : ('SHIFT', 25),
+        (107, '~') : ('SHIFT', 15),
+        (107, 'false') : ('SHIFT', 29),
+        (107, 'if') : ('SHIFT', 24),
+        (108, 'fi') : ('REDUCE', 21),
+        (108, '}') : ('REDUCE', 21),
+        (108, 'in') : ('REDUCE', 21),
+        (108, ';') : ('REDUCE', 21),
+        (108, ')') : ('REDUCE', 21),
+        (108, 'of') : ('REDUCE', 21),
         (108, 'then') : ('REDUCE', 21),
         (108, 'loop') : ('REDUCE', 21),
-        (108, 'of') : ('REDUCE', 21),
         (108, 'else') : ('REDUCE', 21),
         (108, 'pool') : ('REDUCE', 21),
-        (108, '}') : ('REDUCE', 21),
         (108, ',') : ('REDUCE', 21),
-        (108, 'fi') : ('REDUCE', 21),
-        (108, 'in') : ('REDUCE', 21),
-        (108, ';') : ('REDUCE', 21),
-        (108, ')') : ('REDUCE', 21),
         (109, ';') : ('REDUCE', 9),
-        (110, 'id') : ('SHIFT', 111),
         (110, ')') : ('REDUCE', 11),
+        (110, 'id') : ('SHIFT', 111),
         (111, ':') : ('SHIFT', 112),
         (112, 'type') : ('SHIFT', 113),
-        (113, ',') : ('REDUCE', 15),
         (113, ')') : ('REDUCE', 15),
+        (113, ',') : ('REDUCE', 15),
         (114, ')') : ('SHIFT', 115),
         (115, ':') : ('SHIFT', 116),
         (116, 'type') : ('SHIFT', 117),
         (117, '{') : ('SHIFT', 118),
-        (118, 'let') : ('SHIFT', 8),
+        (118, 'id') : ('SHIFT', 18),
         (118, 'new') : ('SHIFT', 22),
-        (118, 'if') : ('SHIFT', 24),
+        (118, 'true') : ('SHIFT', 28),
+        (118, 'int') : ('SHIFT', 21),
         (118, '(') : ('SHIFT', 13),
+        (118, 'isvoid') : ('SHIFT', 27),
         (118, '~') : ('SHIFT', 15),
-        (118, 'int') : ('SHIFT', 21),
-        (118, 'string') : ('SHIFT', 29),
+        (118, '{') : ('SHIFT', 14),
+        (118, 'case') : ('SHIFT', 25),
+        (118, 'false') : ('SHIFT', 29),
+        (118, 'if') : ('SHIFT', 24),
         (118, 'not') : ('SHIFT', 26),
+        (118, 'let') : ('SHIFT', 8),
+        (118, 'string') : ('SHIFT', 30),
         (118, 'while') : ('SHIFT', 20),
-        (118, 'id') : ('SHIFT', 18),
-        (118, 'isvoid') : ('SHIFT', 34),
-        (118, 'case') : ('SHIFT', 25),
-        (118, 'false') : ('SHIFT', 28),
-        (118, '{') : ('SHIFT', 14),
-        (118, 'true') : ('SHIFT', 27),
         (119, '}') : ('SHIFT', 120),
         (120, ';') : ('REDUCE', 10),
         (121, ',') : ('SHIFT', 122),
@@ -1090,220 +1079,224 @@ def __init__(self, G):
         (137, ';') : ('REDUCE', 4),
         (138, '$') : ('REDUCE', 0),
         (139, ';') : ('SHIFT', 140),
-        (140, '$') : ('REDUCE', 1),
         (140, 'class') : ('SHIFT', 1),
+        (140, '$') : ('REDUCE', 1),
         (141, '$') : ('REDUCE', 2),
         (142, '$') : ('OK', None)
         }
 
-
-
-
         self.goto = {
-        (0, '<def-class>') : 139,
-        (0, '<program>') : 142,
         (0, '<class-list>') : 138,
+        (0, '<program>') : 142,
+        (0, '<def-class>') : 139,
         (3, '<def-meth>') : 130,
         (3, '<def-attr>') : 127,
         (3, '<feature-list>') : 125,
-        (7, '<atom>') : 36,
-        (7, '<term>') : 57,
-        (7, '<comp>') : 44,
-        (7, '<factor>') : 54,
-        (7, '<arith>') : 64,
+        (7, '<comp>') : 38,
+        (7, '<factor>') : 49,
+        (7, '<term>') : 52,
+        (7, '<arith>') : 41,
         (7, '<expr>') : 109,
-        (7, '<dispatch>') : 51,
+        (7, '<dispatch>') : 46,
+        (7, '<atom>') : 32,
         (8, '<id-list>') : 106,
+        (12, '<comp>') : 38,
         (12, '<expr>') : 101,
-        (12, '<term>') : 57,
-        (12, '<factor>') : 54,
-        (12, '<comp>') : 44,
-        (12, '<dispatch>') : 51,
-        (12, '<atom>') : 36,
-        (12, '<arith>') : 64,
-        (13, '<arith>') : 64,
-        (13, '<atom>') : 36,
-        (13, '<dispatch>') : 51,
-        (13, '<term>') : 57,
-        (13, '<comp>') : 44,
-        (13, '<factor>') : 54,
+        (12, '<atom>') : 32,
+        (12, '<arith>') : 41,
+        (12, '<dispatch>') : 46,
+        (12, '<factor>') : 49,
+        (12, '<term>') : 52,
+        (13, '<comp>') : 38,
         (13, '<expr>') : 99,
-        (14, '<expr>') : 96,
-        (14, '<atom>') : 36,
-        (14, '<term>') : 57,
+        (13, '<factor>') : 49,
+        (13, '<arith>') : 41,
+        (13, '<term>') : 52,
+        (13, '<dispatch>') : 46,
+        (13, '<atom>') : 32,
+        (14, '<comp>') : 38,
+        (14, '<factor>') : 49,
         (14, '<expr-list>') : 94,
-        (14, '<comp>') : 44,
-        (14, '<factor>') : 54,
-        (14, '<arith>') : 64,
-        (14, '<dispatch>') : 51,
-        (15, '<atom>') : 36,
+        (14, '<term>') : 52,
+        (14, '<arith>') : 41,
+        (14, '<dispatch>') : 46,
+        (14, '<expr>') : 96,
+        (14, '<atom>') : 32,
+        (15, '<atom>') : 32,
+        (15, '<dispatch>') : 46,
         (15, '<factor>') : 93,
-        (15, '<dispatch>') : 51,
+        (17, '<arith>') : 41,
+        (17, '<term>') : 52,
+        (17, '<dispatch>') : 46,
+        (17, '<comp>') : 38,
+        (17, '<expr>') : 57,
+        (17, '<nonEmpty-argList>') : 60,
+        (17, '<atom>') : 32,
         (17, '<arg-list>') : 91,
-        (17, '<atom>') : 36,
-        (17, '<arith>') : 64,
-        (17, '<expr>') : 62,
-        (17, '<nonEmpty-argList>') : 66,
-        (17, '<term>') : 57,
-        (17, '<factor>') : 54,
-        (17, '<comp>') : 44,
-        (17, '<dispatch>') : 51,
-        (19, '<atom>') : 36,
+        (17, '<factor>') : 49,
+        (19, '<arith>') : 41,
+        (19, '<term>') : 52,
+        (19, '<dispatch>') : 46,
+        (19, '<comp>') : 38,
+        (19, '<atom>') : 32,
         (19, '<expr>') : 90,
-        (19, '<arith>') : 64,
-        (19, '<term>') : 57,
-        (19, '<factor>') : 54,
-        (19, '<comp>') : 44,
-        (19, '<dispatch>') : 51,
-        (20, '<arith>') : 64,
-        (20, '<dispatch>') : 51,
+        (19, '<factor>') : 49,
+        (20, '<comp>') : 38,
+        (20, '<atom>') : 32,
+        (20, '<factor>') : 49,
+        (20, '<arith>') : 41,
+        (20, '<term>') : 52,
+        (20, '<dispatch>') : 46,
         (20, '<expr>') : 86,
-        (20, '<atom>') : 36,
-        (20, '<comp>') : 44,
-        (20, '<term>') : 57,
-        (20, '<factor>') : 54,
-        (24, '<term>') : 57,
-        (24, '<comp>') : 44,
-        (24, '<factor>') : 54,
-        (24, '<arith>') : 64,
-        (24, '<atom>') : 36,
+        (24, '<arith>') : 41,
+        (24, '<atom>') : 32,
+        (24, '<comp>') : 38,
         (24, '<expr>') : 80,
-        (24, '<dispatch>') : 51,
-        (25, '<atom>') : 36,
+        (24, '<factor>') : 49,
+        (24, '<term>') : 52,
+        (24, '<dispatch>') : 46,
+        (25, '<term>') : 52,
+        (25, '<dispatch>') : 46,
         (25, '<expr>') : 69,
-        (25, '<arith>') : 64,
-        (25, '<term>') : 57,
-        (25, '<comp>') : 44,
-        (25, '<dispatch>') : 51,
-        (25, '<factor>') : 54,
-        (26, '<dispatch>') : 51,
-        (26, '<atom>') : 30,
-        (33, '<arg-list>') : 67,
-        (33, '<atom>') : 36,
-        (33, '<arith>') : 64,
-        (33, '<expr>') : 62,
-        (33, '<nonEmpty-argList>') : 66,
-        (33, '<term>') : 57,
-        (33, '<factor>') : 54,
-        (33, '<comp>') : 44,
-        (33, '<dispatch>') : 51,
-        (34, '<atom>') : 36,
-        (34, '<dispatch>') : 51,
-        (34, '<factor>') : 35,
-        (41, '<atom>') : 36,
-        (41, '<arith>') : 64,
-        (41, '<expr>') : 62,
-        (41, '<nonEmpty-argList>') : 66,
-        (41, '<term>') : 57,
-        (41, '<factor>') : 54,
-        (41, '<comp>') : 44,
-        (41, '<dispatch>') : 51,
-        (41, '<arg-list>') : 42,
-        (45, '<atom>') : 36,
-        (45, '<arith>') : 46,
-        (45, '<term>') : 57,
-        (45, '<factor>') : 54,
-        (45, '<dispatch>') : 51,
-        (47, '<atom>') : 36,
-        (47, '<term>') : 48,
-        (47, '<factor>') : 54,
-        (47, '<dispatch>') : 51,
-        (49, '<atom>') : 36,
-        (49, '<dispatch>') : 51,
-        (49, '<factor>') : 50,
-        (52, '<atom>') : 36,
-        (52, '<factor>') : 53,
-        (52, '<dispatch>') : 51,
-        (55, '<atom>') : 36,
-        (55, '<term>') : 56,
-        (55, '<factor>') : 54,
-        (55, '<dispatch>') : 51,
-        (58, '<atom>') : 36,
-        (58, '<arith>') : 59,
-        (58, '<term>') : 57,
-        (58, '<factor>') : 54,
-        (58, '<dispatch>') : 51,
-        (60, '<atom>') : 36,
-        (60, '<arith>') : 61,
-        (60, '<term>') : 57,
-        (60, '<factor>') : 54,
-        (60, '<dispatch>') : 51,
-        (63, '<atom>') : 36,
-        (63, '<arith>') : 64,
-        (63, '<expr>') : 62,
-        (63, '<term>') : 57,
-        (63, '<factor>') : 54,
-        (63, '<nonEmpty-argList>') : 65,
-        (63, '<comp>') : 44,
-        (63, '<dispatch>') : 51,
+        (25, '<comp>') : 38,
+        (25, '<arith>') : 41,
+        (25, '<atom>') : 32,
+        (25, '<factor>') : 49,
+        (26, '<arith>') : 41,
+        (26, '<term>') : 52,
+        (26, '<dispatch>') : 46,
+        (26, '<comp>') : 38,
+        (26, '<atom>') : 32,
+        (26, '<expr>') : 68,
+        (26, '<factor>') : 49,
+        (27, '<atom>') : 32,
+        (27, '<dispatch>') : 46,
+        (27, '<factor>') : 31,
+        (35, '<arith>') : 41,
+        (35, '<term>') : 52,
+        (35, '<dispatch>') : 46,
+        (35, '<comp>') : 38,
+        (35, '<expr>') : 57,
+        (35, '<nonEmpty-argList>') : 60,
+        (35, '<atom>') : 32,
+        (35, '<arg-list>') : 36,
+        (35, '<factor>') : 49,
+        (39, '<arith>') : 41,
+        (39, '<term>') : 52,
+        (39, '<expr>') : 40,
+        (39, '<dispatch>') : 46,
+        (39, '<comp>') : 38,
+        (39, '<atom>') : 32,
+        (39, '<factor>') : 49,
+        (42, '<atom>') : 32,
+        (42, '<term>') : 43,
+        (42, '<dispatch>') : 46,
+        (42, '<factor>') : 49,
+        (44, '<atom>') : 32,
+        (44, '<factor>') : 45,
+        (44, '<dispatch>') : 46,
+        (47, '<atom>') : 32,
+        (47, '<factor>') : 48,
+        (47, '<dispatch>') : 46,
+        (50, '<atom>') : 32,
+        (50, '<term>') : 51,
+        (50, '<dispatch>') : 46,
+        (50, '<factor>') : 49,
+        (53, '<arith>') : 54,
+        (53, '<atom>') : 32,
+        (53, '<term>') : 52,
+        (53, '<dispatch>') : 46,
+        (53, '<factor>') : 49,
+        (55, '<arith>') : 56,
+        (55, '<atom>') : 32,
+        (55, '<term>') : 52,
+        (55, '<dispatch>') : 46,
+        (55, '<factor>') : 49,
+        (58, '<arith>') : 41,
+        (58, '<term>') : 52,
+        (58, '<dispatch>') : 46,
+        (58, '<comp>') : 38,
+        (58, '<expr>') : 57,
+        (58, '<atom>') : 32,
+        (58, '<nonEmpty-argList>') : 59,
+        (58, '<factor>') : 49,
+        (65, '<arith>') : 41,
+        (65, '<term>') : 52,
+        (65, '<dispatch>') : 46,
+        (65, '<comp>') : 38,
+        (65, '<expr>') : 57,
+        (65, '<nonEmpty-argList>') : 60,
+        (65, '<atom>') : 32,
+        (65, '<arg-list>') : 66,
+        (65, '<factor>') : 49,
         (70, '<case-list>') : 78,
-        (74, '<atom>') : 36,
-        (74, '<term>') : 57,
-        (74, '<comp>') : 44,
+        (74, '<comp>') : 38,
         (74, '<expr>') : 75,
-        (74, '<factor>') : 54,
-        (74, '<arith>') : 64,
-        (74, '<dispatch>') : 51,
+        (74, '<factor>') : 49,
+        (74, '<term>') : 52,
+        (74, '<arith>') : 41,
+        (74, '<dispatch>') : 46,
+        (74, '<atom>') : 32,
         (76, '<case-list>') : 77,
-        (81, '<comp>') : 44,
-        (81, '<arith>') : 64,
-        (81, '<atom>') : 36,
-        (81, '<dispatch>') : 51,
-        (81, '<term>') : 57,
+        (81, '<term>') : 52,
+        (81, '<arith>') : 41,
+        (81, '<dispatch>') : 46,
+        (81, '<comp>') : 38,
+        (81, '<atom>') : 32,
         (81, '<expr>') : 82,
-        (81, '<factor>') : 54,
-        (83, '<comp>') : 44,
-        (83, '<atom>') : 36,
-        (83, '<arith>') : 64,
-        (83, '<term>') : 57,
+        (81, '<factor>') : 49,
+        (83, '<comp>') : 38,
+        (83, '<atom>') : 32,
+        (83, '<arith>') : 41,
+        (83, '<factor>') : 49,
+        (83, '<term>') : 52,
         (83, '<expr>') : 84,
-        (83, '<dispatch>') : 51,
-        (83, '<factor>') : 54,
+        (83, '<dispatch>') : 46,
+        (87, '<arith>') : 41,
         (87, '<expr>') : 88,
-        (87, '<atom>') : 36,
-        (87, '<arith>') : 64,
-        (87, '<comp>') : 44,
-        (87, '<term>') : 57,
-        (87, '<factor>') : 54,
-        (87, '<dispatch>') : 51,
+        (87, '<atom>') : 32,
+        (87, '<comp>') : 38,
+        (87, '<term>') : 52,
+        (87, '<factor>') : 49,
+        (87, '<dispatch>') : 46,
+        (97, '<comp>') : 38,
+        (97, '<factor>') : 49,
+        (97, '<term>') : 52,
+        (97, '<arith>') : 41,
+        (97, '<dispatch>') : 46,
         (97, '<expr>') : 96,
         (97, '<expr-list>') : 98,
-        (97, '<atom>') : 36,
-        (97, '<term>') : 57,
-        (97, '<comp>') : 44,
-        (97, '<factor>') : 54,
-        (97, '<arith>') : 64,
-        (97, '<dispatch>') : 51,
+        (97, '<atom>') : 32,
         (102, '<id-list>') : 103,
         (104, '<id-list>') : 105,
-        (107, '<atom>') : 36,
-        (107, '<arith>') : 64,
-        (107, '<term>') : 57,
-        (107, '<factor>') : 54,
-        (107, '<comp>') : 44,
+        (107, '<arith>') : 41,
+        (107, '<term>') : 52,
+        (107, '<dispatch>') : 46,
+        (107, '<comp>') : 38,
+        (107, '<atom>') : 32,
         (107, '<expr>') : 108,
-        (107, '<dispatch>') : 51,
-        (110, '<nonEmpty-paramList>') : 124,
+        (107, '<factor>') : 49,
         (110, '<param>') : 121,
         (110, '<param-list>') : 114,
-        (118, '<atom>') : 36,
-        (118, '<arith>') : 64,
-        (118, '<term>') : 57,
-        (118, '<comp>') : 44,
-        (118, '<factor>') : 54,
+        (110, '<nonEmpty-paramList>') : 124,
+        (118, '<term>') : 52,
+        (118, '<comp>') : 38,
+        (118, '<factor>') : 49,
+        (118, '<atom>') : 32,
+        (118, '<arith>') : 41,
         (118, '<expr>') : 119,
-        (118, '<dispatch>') : 51,
+        (118, '<dispatch>') : 46,
         (122, '<param>') : 121,
         (122, '<nonEmpty-paramList>') : 123,
-        (128, '<def-meth>') : 130,
         (128, '<feature-list>') : 129,
+        (128, '<def-meth>') : 130,
         (128, '<def-attr>') : 127,
         (131, '<def-meth>') : 130,
         (131, '<feature-list>') : 132,
         (131, '<def-attr>') : 127,
         (135, '<def-meth>') : 130,
-        (135, '<feature-list>') : 136,
         (135, '<def-attr>') : 127,
+        (135, '<feature-list>') : 136,
         (140, '<def-class>') : 139,
         (140, '<class-list>') : 141
         }
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 9dec5bd63..4c28beb34 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -6,7 +6,8 @@
 MAIN_METHOD_DONT_EXISTS = '(%s, %s) - TypeError: Main class must have a method main()'
 MAIN_METHOD_DONT_HAVE_PARAMS = '(%s, %s) - TypeError: main method must not have params'
 
-SELF_ERROR = '(%s, %s) - SemanticError: \'self\' cannot be the name of an attribute.'
+SELF_ERROR_ATTR = '(%s, %s) - SemanticError: \'self\' cannot be the name of an attribute.'
+SELF_ERROR_LET = '(%s, %s) - SemanticError: \'self\' cannot be bound in a \'let\' expression.'
 SELF_IS_READONLY = '(%s, %s) - TypeError: Variable "self" is read-only.'
 SELF_TYPE_ERROR = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a parameter type in method %s'
 SELF_TYPE_IN_DISPATCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a dispatch'
@@ -17,16 +18,20 @@
 INCOMPATIBLE_TYPES_METH = '(%s, %s) - TypeError: Inferred return type %s of method %s does not conform to declared return type %s.'
 INCOMPATIBLE_TYPES_IF = '(%s, %s) - TypeError: Predicate of \'%s\' does not have type %s.'
 INCOMPATIBLE_TYPES_LET = '(%s, %s) - TypeError: Inferred type %s of initialization of %s does not conform to identifier\'s declared type %s.'
+INCOMPATIBLE_TYPES_CALL = '(%s, %s) - TypeError: Expression type %s does not conform to declared static dispatch type %s.'
 INCOMPATIBLE_TYPES = '(%s, %s) - TypeError: Cannot convert %s into %s.'
+
 WRONG_SIGNATURE = '(%s, %s) - SemanticError: Incompatible number of formal parameters in redefined method %s.'
 LOCAL_ALREADY_DEFINED = '(%s, %s) - SemanticError: Variable %s is already defined in method %s.'
 INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
 VARIABLE_NOT_DEFINED = '(%s, %s) - NameError: Undeclared identifier %s.'
-INHERIT_ERROR = '(%s, %s) - SemanticError: Class %s cannot inherit from class %s because they form a cycle.'
+INHERIT_ERROR = '(%s, %s) - SemanticError: Class %s, or an ancestor of %s, is involved in an inheritance cycle.'
 METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
 
 DUPLICATE_BRANCH = '(%s, %s) - SemanticError: Duplicate branch %s in case statement.'
 UNDEFINED_TYPE_BRANCH = '(%s, %s) - TypeError: Class %s of case branch is undefined.'
+UNDEFINED_TYPE_NEW = '(%s, %s) - TypeError: \'new\' used with undefined class %s.'
+UNDEFINED_METHOD = '(%s, %s) - AttributeError: Dispatch to undefined method %s. '
 
 
 
@@ -79,7 +84,7 @@ def visit(self, node, scope):
 
         while current_parent != self.context.get_type('Object') and current_parent != None:
             if current_parent == self.current_type:
-                self.errors.append(INHERIT_ERROR % (node.line, node.column, self.current_type.name, self.current_type.parent.name))
+                self.errors.append(INHERIT_ERROR % (self.current_type.parent.line, self.current_type.parent.column, self.current_type.parent.name, self.current_type.parent.name))
                 self.current_type.parent = ErrorType()
                 break
 
@@ -103,7 +108,7 @@ def visit(self, node, scope):
         attr_type = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
 
         if node.id == 'self':
-            self.errors.append(SELF_ERROR % (node.line, node.column))
+            self.errors.append(SELF_ERROR_ATTR % (node.line, node.column))
 
         if node.expr:
             type_expr = self.visit(node.expr, scope.create_child())
@@ -197,20 +202,20 @@ def visit(self, node, scope):
 
             else:
                 try:
-                    typex = self.context.get_type(node.type)
+                    typex = self.context.get_type(node.type.lex)
                 except SemanticError as se:
                     self.errors.append(se.text)
                     typex = ErrorType()
 
                 if not obj_type.conforms_to(typex):
-                    self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, obj_type.name, typex.name))
+                    self.errors.append(INCOMPATIBLE_TYPES_CALL % (node.line, node.column, obj_type.name, typex.name))
 
             obj_type = typex
 
         try:
             meth = obj_type.get_method(node.id)
         except SemanticError as se:
-            if se.text: self.errors.append(se.text)
+            if se.text: self.errors.append(UNDEFINED_METHOD % (node.line, node.column, node.id))
             for arg in node.args:
                 self.visit(arg, scope)
             return ErrorType()
@@ -270,6 +275,9 @@ def visit(self, node, scope):
                 id_type = ErrorType()
                 self.errors.append(se.text)
             
+            if idx == 'self':
+                self.errors.append(SELF_ERROR_LET % (node.line, node.column))
+            
             if scope.is_local(idx):
                 scope = scope.create_child()
                 scope.define_variable(idx, id_type)
@@ -361,7 +369,7 @@ def visit(self, node, scope):
         try:
             return self.context.get_type(node.lex)
         except SemanticError as se:
-            self.errors.append(se.text)
+            self.errors.append(UNDEFINED_TYPE_NEW % (node.line, node.column, node.lex))
             return ErrorType()
 
     
diff --git a/src/utils/semantic_check/type_collector.py b/src/utils/semantic_check/type_collector.py
index dc160530f..18e247a3e 100644
--- a/src/utils/semantic_check/type_collector.py
+++ b/src/utils/semantic_check/type_collector.py
@@ -56,7 +56,9 @@ def visit(self,node):
             if node.id in ["Object", "Int", "String", "Bool", "IO"]:
                 self.errors.append(NOT_REDEFINE_BASIC_TYPES % (node.line, node.column, node.id))
                 node.id = 'error_type'
-            self.context.create_type(node.id)
+            typex = self.context.create_type(node.id)
+            typex.line = node.line
+            typex.column = node.column
         except SemanticError as se:
             self.errors.append(NOT_REDEFINE_CLASSES % (node.classt_line, node.classt_column))
         return
\ No newline at end of file

From 99b575a8ae5dd68ef04329b122a2d5fa98e526f6 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 14:55:14 -0800
Subject: [PATCH 39/83] darian is anormal

---
 src/main.py | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/main.py b/src/main.py
index 3714e9728..ec1bd6b90 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/arithmetic12.cl"
+    add = "lexer/iis5.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -23,12 +23,6 @@
     with open(_in) as file:
         code = file.read()
 
-    code = '''class Main {
-    main(): Object {
-        if true = not false then 4 else 5 fi
-    };
-};'''
-
     G = build_COOL_Grammar()
 
     # lexer

From 22079ac5afc2192112e2f87bd046eaf5db1784e9 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 15:08:20 -0800
Subject: [PATCH 40/83] changing semantic errors format

---
 src/main.py                              | 2 +-
 src/utils/semantic_check/type_checker.py | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/main.py b/src/main.py
index ec1bd6b90..df7eaa6cc 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "lexer/iis5.cl"
+    add = "lexer/let3.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 4c28beb34..9b6d6e15c 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -8,7 +8,7 @@
 
 SELF_ERROR_ATTR = '(%s, %s) - SemanticError: \'self\' cannot be the name of an attribute.'
 SELF_ERROR_LET = '(%s, %s) - SemanticError: \'self\' cannot be bound in a \'let\' expression.'
-SELF_IS_READONLY = '(%s, %s) - TypeError: Variable "self" is read-only.'
+SELF_IS_READONLY = '(%s, %s) - SemanticError: Variable "self" is read-only.'
 SELF_TYPE_ERROR = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a parameter type in method %s'
 SELF_TYPE_IN_DISPATCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a dispatch'
 SELF_TYPE_IN_CASE_BRANCH = '(%s, %s) - TypeError: SELF_TYPE cannot be used as a type of a case branch'
@@ -31,6 +31,7 @@
 DUPLICATE_BRANCH = '(%s, %s) - SemanticError: Duplicate branch %s in case statement.'
 UNDEFINED_TYPE_BRANCH = '(%s, %s) - TypeError: Class %s of case branch is undefined.'
 UNDEFINED_TYPE_NEW = '(%s, %s) - TypeError: \'new\' used with undefined class %s.'
+UNDEFINED_TYPE_LET = '(%s, %s) - TypeError: Class %s of let-bound identifier %s is undefined.'
 UNDEFINED_METHOD = '(%s, %s) - AttributeError: Dispatch to undefined method %s. '
 
 
@@ -273,7 +274,7 @@ def visit(self, node, scope):
                 id_type = self.context.get_type(typex) if typex != 'SELF_TYPE' else self.current_type
             except SemanticError as se:
                 id_type = ErrorType()
-                self.errors.append(se.text)
+                self.errors.append(UNDEFINED_TYPE_LET % (node.line, node.column, typex, idx))
             
             if idx == 'self':
                 self.errors.append(SELF_ERROR_LET % (node.line, node.column))

From 5ee11cf0afa811196cadd8c6cdbbf60b3f5ab6ec Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 15:24:17 -0800
Subject: [PATCH 41/83] errors like test

---
 src/main.py                              | 2 +-
 src/utils/semantic_check/type_builder.py | 6 ++++++
 src/utils/semantic_check/type_checker.py | 7 +++++--
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/main.py b/src/main.py
index df7eaa6cc..92e2f9742 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "lexer/let3.cl"
+    add = "semantic/features3.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index c10325368..02e49e936 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -8,6 +8,7 @@
 PARAMETER_TYPE_UNDEFINED = '(%s, %s) - TypeError: Class %s of formal parameter %s is undefined.'
 REDEFINED_ATTRIBUTES = '(%s, %s) - SemanticError: Attribute %s is an attribute of an inherited class.'
 RETURN_TYPE_UNDEFINED = '(%s, %s) - TypeError: Undefined return type %s in method %s.'
+TYPE_NOT_DEFINED_ATTR = '(%s, %s) - TypeError: Class %s of attribute %s is undefined.'
 
 
 class TypeBuilder:
@@ -61,6 +62,11 @@ def visit(self,node):
     def visit(self,node):
         try:
             attrType = self.context.get_type(node.type)
+        except SemanticError as se:
+            self.errors.append(TYPE_NOT_DEFINED_ATTR % (node.line, node.column, node.type, node.id))
+            attrType = ErrorType()
+
+        try:
             self.current_type.define_attribute(node.id, attrType)
         except SemanticError as se:
             self.errors.append(REDEFINED_ATTRIBUTES % (node.line, node.column, node.id))
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 9b6d6e15c..1dc821a75 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -26,7 +26,7 @@
 INVALID_OPERATION = '(%s, %s) - TypeError: non-Int arguments: %s %s %s'
 VARIABLE_NOT_DEFINED = '(%s, %s) - NameError: Undeclared identifier %s.'
 INHERIT_ERROR = '(%s, %s) - SemanticError: Class %s, or an ancestor of %s, is involved in an inheritance cycle.'
-METHOD_PARAMETERS = '(%s, %s) - TypeError: Method %s defined in %s receive %d parameters'
+METHOD_PARAMETERS = '(%s, %s) - SemanticError: Method %s defined in %s receive %d parameters'
 
 DUPLICATE_BRANCH = '(%s, %s) - SemanticError: Duplicate branch %s in case statement.'
 UNDEFINED_TYPE_BRANCH = '(%s, %s) - TypeError: Class %s of case branch is undefined.'
@@ -106,7 +106,10 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.AttrDeclarationNode)
     def visit(self, node, scope):
-        attr_type = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
+        try:
+            attr_type = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
+        except SemanticError:
+            attr_type = ErrorType()
 
         if node.id == 'self':
             self.errors.append(SELF_ERROR_ATTR % (node.line, node.column))

From f65bdfce839b40cdf67d0cfd226cf26108788051 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Wed, 16 Feb 2022 15:34:35 -0800
Subject: [PATCH 42/83] semantic ok

---
 src/cmp/semantic.py                      | 2 ++
 src/main.py                              | 2 +-
 src/utils/semantic_check/type_checker.py | 2 +-
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
index dc72bc7fc..1476d66d4 100644
--- a/src/cmp/semantic.py
+++ b/src/cmp/semantic.py
@@ -42,11 +42,13 @@ def __init__(self, name:str):
         self.attributes = []
         self.methods = []
         self.parent = None
+        self.child = None
 
     def set_parent(self, parent):
         if self.parent is not None:
             raise SemanticError(f'Parent type is already set for {self.name}.')
         self.parent = parent
+        parent.child = self
 
     def get_attribute(self, name:str, typex:str):
         try:
diff --git a/src/main.py b/src/main.py
index 92e2f9742..35a9394b6 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/features3.cl"
+    add = "semantic/inheritance4.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 1dc821a75..7801a937c 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -85,7 +85,7 @@ def visit(self, node, scope):
 
         while current_parent != self.context.get_type('Object') and current_parent != None:
             if current_parent == self.current_type:
-                self.errors.append(INHERIT_ERROR % (self.current_type.parent.line, self.current_type.parent.column, self.current_type.parent.name, self.current_type.parent.name))
+                self.errors.append(INHERIT_ERROR % (self.current_type.child.line, self.current_type.child.column, self.current_type.child.name, self.current_type.child.name))
                 self.current_type.parent = ErrorType()
                 break
 

From 0aad48025c8d1d1ed8053f7aac5e2e3bb2f5143d Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Fri, 18 Feb 2022 07:58:20 -0800
Subject: [PATCH 43/83] Update requirements.txt

---
 requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/requirements.txt b/requirements.txt
index 9eb0cad1a..152d5bf37 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,3 @@
 pytest
 pytest-ordering
+

From cf1f2f792311af7cc8bdf3a652d4255ee63e2cdd Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Fri, 18 Feb 2022 07:59:56 -0800
Subject: [PATCH 44/83] Update requirements.txt

---
 requirements.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 152d5bf37..9eb0cad1a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,2 @@
 pytest
 pytest-ordering
-

From eab9984ca18ac4c17a05cb55b6d2fabb2a194bdf Mon Sep 17 00:00:00 2001
From: darian10 <dariandominguezalayon@gmail.com>
Date: Fri, 18 Feb 2022 18:51:04 -0500
Subject: [PATCH 45/83] Creating Cool_to_Cil visitor template

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 134 +++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 src/utils/code_generation/cil/COOL_to_CIL.py

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
new file mode 100644
index 000000000..830506792
--- /dev/null
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -0,0 +1,134 @@
+import cmp.visitor as visitor
+from utils.ast.AST_Nodes import ast_nodes as nodes
+
+class COOL_to_CIL:
+    def __init__(self, context, scope):
+        self.context = context
+        self.scope = scope
+
+
+    @visitor.on('node')
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.ProgramNode)
+    def visit(self, node, scope=None):
+        pass
+    
+
+    @visitor.when(nodes.ClassDeclarationNode)
+    def visit(self, node, scope):
+        pass
+
+    @visitor.when(nodes.AttrDeclarationNode)
+    def visit(self, node, scope):
+        pass
+    
+
+    @visitor.when(nodes.MethDeclarationNode)
+    def visit(self, node, scope):
+        pass
+
+    @visitor.when(nodes.AssignNode)
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.IfThenElseNode)
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.WhileNode)
+    def visit(self, node, scope):
+        pass
+    
+
+    @visitor.when(nodes.BlockNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.LetNode)
+    def visit(self, node, scope):
+        pass
+            
+
+    @visitor.when(nodes.CaseNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.NotNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.ConstantNumNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.ConstantBoolNode)
+    def visit(self, node, scope):
+       pass
+
+
+    @visitor.when(nodes.ConstantStringNode)
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.VariableNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.InstantiateNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.IsVoidNode)
+    def visit(self, node, scope):
+        pass
+
+    @visitor.when(nodes.ComplementNode)
+    def visit(self, node, scope):
+        pass
+
+
+    @visitor.when(nodes.PlusNode)
+    def visit(self, node, scope):
+        pass
+    
+
+    @visitor.when(nodes.MinusNode)
+    def visit(self, node, scope):
+       pass
+
+    
+    @visitor.when(nodes.StarNode)
+    def visit(self, node, scope):
+       pass
+
+
+    @visitor.when(nodes.DivNode)
+    def visit(self, node, scope):
+       pass
+    
+
+    @visitor.when(nodes.LessThanNode)
+    def visit(self, node, scope):
+        pass
+
+    
+    @visitor.when(nodes.LessEqualNode)
+    def visit(self, node, scope):
+        pass
+    
+
+    @visitor.when(nodes.EqualNode)
+    def visit(self, node, scope):
+        pass
\ No newline at end of file

From 1175eeeff26e2eb74155dcabac4dece2f980e325 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Fri, 18 Feb 2022 18:30:55 -0800
Subject: [PATCH 46/83] creating cil ast

---
 src/utils/code_generation/cil/AST_CIL.py | 218 +++++++++++++++++++++++
 1 file changed, 218 insertions(+)
 create mode 100644 src/utils/code_generation/cil/AST_CIL.py

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
new file mode 100644
index 000000000..542cb3805
--- /dev/null
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -0,0 +1,218 @@
+class cil_ast:
+
+    class Node:
+        pass
+
+    class ProgramNode(Node):
+        def __init__(self, dottypes, dotdata, dotcode):
+            self.dottypes = dottypes
+            self.dotdata = dotdata
+            self.dotcode = dotcode
+
+    class TypeNode(Node):
+        def __init__(self, idx):
+            self.id = idx
+            self.attributes = []
+            self.methods = []
+
+    class DataNode(Node):
+        def __init__(self, vname, value):
+            self.name = vname
+            self.value = value
+
+    class FunctionNode(Node):
+        def __init__(self, idx, params, localvars, instructions):
+            self.id = idx
+            self.params = params
+            self.localvars = localvars
+            self.instructions = instructions
+            self.ids = dict()
+            self.labels_count = 0
+
+    class ParamNode(Node):
+        def __init__(self, idx):
+            self.id = idx
+
+    class LocalNode(Node):
+        def __init__(self, idx):
+            self.id = idx
+
+    class InstructionNode(Node):
+        def __init__(self):
+            self.leader = False
+
+    class AssignNode(InstructionNode):
+        def __init__(self, left, right):
+            self.left = left
+            self.right = right
+        
+        def __repr__(self):
+            return f"{self.left} = {self.right}"
+
+    class ArithmeticNode(InstructionNode):
+        def __init__(self, dest, op_l, op_r):
+            self.dest = dest
+            self.op_l = op_l
+            self.op_r = op_r
+
+    class PlusNode(ArithmeticNode):
+        pass
+
+    class MinusNode(ArithmeticNode):
+        pass
+
+    class StarNode(ArithmeticNode):
+        pass
+
+    class DivNode(ArithmeticNode):
+        pass
+
+    class LessThanNode(ArithmeticNode):
+        pass
+
+    class LessEqualNode(ArithmeticNode):
+        pass
+
+    class EqualNode(ArithmeticNode):
+        def __repr__(self):
+            return f"{self.dest} = {self.op_l} == {self.op_r}"
+
+    # class EqualStrNode(ArithmeticNode):
+    #     pass
+
+    class GetAttrNode(InstructionNode):
+        def __init__(self, dest, idx, attr, computed_type):
+            self.dest = dest
+            self.idx = idx
+            self.attr = attr
+            self.computed_type = computed_type
+        
+        def __repr__(self):
+            return f"{self.dest} = GETATTR {self.idx} {self.attr}"
+
+    class SetAttrNode(InstructionNode):
+        def __init__(self, idx, attr, value, computed_type):
+            self.idx = idx
+            self.attr = attr
+            self.value = value
+            self.computed_type = computed_type
+    
+        def __repr__(self):
+            return f"SETATTR {self.idx} {self.attr} {self.value}"
+
+    # class GetIndexNode(InstructionNode):
+    #     pass
+
+    # class SetIndexNode(InstructionNode):
+    #     pass
+
+    class AllocateNode(InstructionNode):
+        def __init__(self, dest, typex):
+            self.dest = dest
+            self.type = typex
+        
+        def __repr__(self):
+            return f"{self.dest} = ALLOCATE {self.type}"
+
+    # class ArrayNode(InstructionNode):
+    #     pass
+
+    class TypeOfNode(InstructionNode):
+        def __init__(self, idx, dest):
+            self.id = idx
+            self.dest = dest
+
+        def __repr__(self):
+            return f"{self.dest} = TYPEOF {self.id}"
+
+    class StaticCallNode(InstructionNode):
+        def __init__(self, function, dest):
+            self.function = function
+            self.dest = dest
+        
+        def __repr__(self):
+            return f"{self.dest} = CALL {self.function}"
+
+    class DynamicCallNode(InstructionNode):
+        def __init__(self, typex, function, dest, computed_type):
+            self.type = typex
+            self.function = function
+            self.dest = dest
+            self.computed_type = computed_type
+        
+        def __repr__(self):
+            return f"{self.dest} = VCALL {self.type} {self.function}"
+
+    class ArgNode(InstructionNode):
+        def __init__(self, idx):
+            self.id = idx
+
+        def __repr__(self):
+            return f"ARG {self.id}"
+    
+    class IfGotoNode(InstructionNode):
+        def __init__(self, if_cond, label):
+            self.if_cond = if_cond
+            self.label = label
+        
+        def __repr__(self):
+            return f"GOTO {self.label} if {self.if_cond}"
+
+    class LabelNode(InstructionNode):
+        def __init__(self, label):
+            self.label = label
+        
+        def __repr__(self):
+            return f"LABEL {self.label}:"
+    
+    class GotoNode(InstructionNode):
+        def __init__(self, label):
+            self.label = label
+        
+        def __repr__(self):
+            return f"GOTO {self.label}"
+
+    class ReturnNode(InstructionNode):
+        def __init__(self, idx=None):
+            self.id = idx
+        
+        def __repr__(self):
+            return f"RETURN {self.id}"
+
+    class LoadNode(InstructionNode):
+        def __init__(self, dest, msg):
+            self.dest = dest
+            self.msg = msg
+
+        def __repr__(self):
+            return f"{self.dest} LOAD {self.msg}"
+
+    class LengthNode(InstructionNode):
+        def __init__(self, dest, idx):
+            self.dest = dest
+            self.id = idx
+    
+    class ConcatNode(InstructionNode):
+        def __init__(self, dest, s1, s2, length):
+            self.dest = dest
+            self.s1 = s1
+            self.s2 = s2
+            self.length = length
+
+    class SubstringNode(InstructionNode):
+        def __init__(self, dest, s, i, length):
+            self.dest = dest
+            self.s = s
+            self.i = i
+            self.length = length
+
+    class ReadStrNode(InstructionNode):
+        def __init__(self, dest):
+            self.dest = dest
+
+    class PrintStrNode(InstructionNode):
+        def __init__(self, value):
+            self.value = value
+        
+        def __repr__(self):
+            return f"PRINTSTR {self.value}"
\ No newline at end of file

From f5c123739c0f742450631e6a7943aa7c9cf515ed Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Fri, 18 Feb 2022 18:36:47 -0800
Subject: [PATCH 47/83] modifying cil ast

---
 src/utils/code_generation/cil/AST_CIL.py | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 542cb3805..2804ae26c 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -77,9 +77,6 @@ class EqualNode(ArithmeticNode):
         def __repr__(self):
             return f"{self.dest} = {self.op_l} == {self.op_r}"
 
-    # class EqualStrNode(ArithmeticNode):
-    #     pass
-
     class GetAttrNode(InstructionNode):
         def __init__(self, dest, idx, attr, computed_type):
             self.dest = dest
@@ -100,12 +97,6 @@ def __init__(self, idx, attr, value, computed_type):
         def __repr__(self):
             return f"SETATTR {self.idx} {self.attr} {self.value}"
 
-    # class GetIndexNode(InstructionNode):
-    #     pass
-
-    # class SetIndexNode(InstructionNode):
-    #     pass
-
     class AllocateNode(InstructionNode):
         def __init__(self, dest, typex):
             self.dest = dest
@@ -114,9 +105,6 @@ def __init__(self, dest, typex):
         def __repr__(self):
             return f"{self.dest} = ALLOCATE {self.type}"
 
-    # class ArrayNode(InstructionNode):
-    #     pass
-
     class TypeOfNode(InstructionNode):
         def __init__(self, idx, dest):
             self.id = idx

From d672e86b0a25e9c72ba8ccebe45c5c63759ca359 Mon Sep 17 00:00:00 2001
From: darian10 <dariandominguezalayon@gmail.com>
Date: Sat, 19 Feb 2022 10:26:52 -0500
Subject: [PATCH 48/83] Creating print_cil_ast

---
 .../code_generation/cil/print_CIL_AST.py      | 148 ++++++++++++++++++
 1 file changed, 148 insertions(+)
 create mode 100644 src/utils/code_generation/cil/print_CIL_AST.py

diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
new file mode 100644
index 000000000..58f5d48dd
--- /dev/null
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -0,0 +1,148 @@
+from utils.code_generation.cil.AST_CIL import cil_ast as nodes
+import cmp.visitor as visitor
+
+def get_formatter():
+
+    class PrintVisitor(object):
+        @visitor.on('node')
+        def visit(self, node):
+            pass
+
+        @visitor.when(nodes.ProgramNode)
+        def visit(self, node):
+            dottypes = '\n'.join(self.visit(t) for t in node.dottypes)
+            dotdata = '\n'.join(self.visit(t) for t in node.dotdata)
+            dotcode = '\n'.join(self.visit(t) for t in node.dotcode)
+
+            return f'.TYPES\n{dottypes}\n\n.DATA\n{dotdata}\n\n.CODE\n{dotcode}'
+
+        @visitor.when(nodes.TypeNode)
+        def visit(self, node):
+            attributes = '\n\t'.join(f'attribute {x}' for x in node.attributes)
+            methods = '\n\t'.join(f'method {x}: {y}' for x,y in node.methods)
+
+            return f'type {node.name} {{\n\t{attributes}\n\n\t{methods}\n}}'
+
+        @visitor.when(nodes.DataNode)
+        def visit(self, node):
+            return f'{node.idx} = {node.value}'
+
+        @visitor.when(nodes.FunctionNode)
+        def visit(self, node):
+            params = '\n\t'.join(self.visit(x) for x in node.params)
+            localvars = '\n\t'.join(self.visit(x) for x in node.localvars)
+            instructions = '\n\t'.join(self.visit(x) for x in node.instructions if self.visit(x) != [])
+
+            return f'function {node.id} {{\n\t{params}\n\n\t{localvars}\n\n\t{instructions}\n}}'
+
+        @visitor.when(nodes.ParamNode)
+        def visit(self, node):
+            return f'PARAM {node.id}'
+
+        @visitor.when(nodes.LocalNode)
+        def visit(self, node):
+            return f'LOCAL {node.id}'
+
+        @visitor.when(nodes.AssignNode)
+        def visit(self, node):
+            return f'{node.left} = {node.right}'
+
+        @visitor.when(nodes.PlusNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} + {node.op_r}'
+
+        @visitor.when(nodes.MinusNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} - {node.op_r}'
+
+        @visitor.when(nodes.StarNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} * {node.op_r}'
+
+        @visitor.when(nodes.DivNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} / {node.op_r}'
+
+        @visitor.when(nodes.LessEqualNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} <= {node.op_r}'
+
+        @visitor.when(nodes.LessNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} < {node.op_r}'
+
+        @visitor.when(nodes.EqualNode)
+        def visit(self, node):
+            return f'{node.dest} = {node.op_l} == {node.op_r}'
+
+        @visitor.when(nodes.GetAttrNode)
+        def visit(self, node):
+            return f'{node.dest} = GETATTR {node.id} {node.attr}'
+
+        @visitor.when(nodes.SetAttrNode)
+        def visit(self, node):
+            return f'SETATTR {node.idx} {node.attr} {node.value}'
+
+        @visitor.when(nodes.AllocateNode)
+        def visit(self, node):
+            return f'{node.dest} = ALLOCATE {node.type}'
+
+        @visitor.when(nodes.TypeOfNode)
+        def visit(self, node):
+            return f'{node.dest} = TYPEOF {node.id}'
+
+        @visitor.when(nodes.StaticCallNode)
+        def visit(self, node):
+            return f'{node.dest} = CALL {node.function}'
+
+        @visitor.when(nodes.DynamicCallNode)
+        def visit(self, node):
+            return f'{node.dest} = VCALL {node.type} {node.function}'
+
+        @visitor.when(nodes.ArgNode)
+        def visit(self, node):
+            return f'ARG {node.id}'
+        
+        @visitor.when(nodes.IfGotoNode)
+        def visit(self, node):
+            return f'IF {node.if_cond} GOTO {node.label}'
+
+        @visitor.when(nodes.LabelNode)
+        def visit(self, node):
+            return f'LABEL {node.label}'
+        
+        @visitor.when(nodes.GotoNode)
+        def visit(self, node):
+            return f'GOTO {node.label}'
+
+        @visitor.when(nodes.ReturnNode)
+        def visit(self, node):
+            return f'RETURN {node.id if node.id is not None else ""}'
+
+        @visitor.when(nodes.LoadNode)
+        def visit(self, node):
+            return f'{node.dest} = LOAD {node.msg}'
+
+        @visitor.when(nodes.LengthNode)
+        def visit(self, node):
+            return f'{node.dest} = LENGTH {node.id}'
+
+        @visitor.when(nodes.ConcatNode)
+        def visit(self, node):
+            return f'{node.dest} = CONCAT {node.s1} {node.s2}'
+
+        @visitor.when(nodes.SubstringNode)
+        def visit(self, node):
+            return f'{node.dest} = SUBSTRING {node.s} {node.i} {node.length}'
+
+        @visitor.when(nodes.ReadStrNode)
+        def visit(self, node):
+            return f'{node.dest} = READSTR'
+        
+        @visitor.when(nodes.PrintStrNode)
+        def visit(self, node):
+            return f'PRINT {node.value}'
+        
+    printer = PrintVisitor()
+    return (lambda ast: printer.visit(ast))
+    
\ No newline at end of file

From 8380748c5b1d23e1c23836b7eab33da29a43245f Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 10:21:21 -0800
Subject: [PATCH 49/83] updating cil ast

---
 src/utils/code_generation/cil/AST_CIL.py | 45 ++----------------------
 1 file changed, 3 insertions(+), 42 deletions(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 2804ae26c..128b8d597 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -16,8 +16,8 @@ def __init__(self, idx):
             self.methods = []
 
     class DataNode(Node):
-        def __init__(self, vname, value):
-            self.name = vname
+        def __init__(self, idx, value):
+            self.id = idx
             self.value = value
 
     class FunctionNode(Node):
@@ -83,9 +83,6 @@ def __init__(self, dest, idx, attr, computed_type):
             self.idx = idx
             self.attr = attr
             self.computed_type = computed_type
-        
-        def __repr__(self):
-            return f"{self.dest} = GETATTR {self.idx} {self.attr}"
 
     class SetAttrNode(InstructionNode):
         def __init__(self, idx, attr, value, computed_type):
@@ -93,33 +90,21 @@ def __init__(self, idx, attr, value, computed_type):
             self.attr = attr
             self.value = value
             self.computed_type = computed_type
-    
-        def __repr__(self):
-            return f"SETATTR {self.idx} {self.attr} {self.value}"
 
     class AllocateNode(InstructionNode):
         def __init__(self, dest, typex):
             self.dest = dest
             self.type = typex
-        
-        def __repr__(self):
-            return f"{self.dest} = ALLOCATE {self.type}"
 
     class TypeOfNode(InstructionNode):
         def __init__(self, idx, dest):
             self.id = idx
             self.dest = dest
 
-        def __repr__(self):
-            return f"{self.dest} = TYPEOF {self.id}"
-
     class StaticCallNode(InstructionNode):
         def __init__(self, function, dest):
             self.function = function
             self.dest = dest
-        
-        def __repr__(self):
-            return f"{self.dest} = CALL {self.function}"
 
     class DynamicCallNode(InstructionNode):
         def __init__(self, typex, function, dest, computed_type):
@@ -127,54 +112,33 @@ def __init__(self, typex, function, dest, computed_type):
             self.function = function
             self.dest = dest
             self.computed_type = computed_type
-        
-        def __repr__(self):
-            return f"{self.dest} = VCALL {self.type} {self.function}"
 
     class ArgNode(InstructionNode):
         def __init__(self, idx):
             self.id = idx
-
-        def __repr__(self):
-            return f"ARG {self.id}"
     
     class IfGotoNode(InstructionNode):
         def __init__(self, if_cond, label):
             self.if_cond = if_cond
             self.label = label
-        
-        def __repr__(self):
-            return f"GOTO {self.label} if {self.if_cond}"
 
     class LabelNode(InstructionNode):
         def __init__(self, label):
             self.label = label
-        
-        def __repr__(self):
-            return f"LABEL {self.label}:"
     
     class GotoNode(InstructionNode):
         def __init__(self, label):
             self.label = label
-        
-        def __repr__(self):
-            return f"GOTO {self.label}"
 
     class ReturnNode(InstructionNode):
         def __init__(self, idx=None):
             self.id = idx
-        
-        def __repr__(self):
-            return f"RETURN {self.id}"
 
     class LoadNode(InstructionNode):
         def __init__(self, dest, msg):
             self.dest = dest
             self.msg = msg
 
-        def __repr__(self):
-            return f"{self.dest} LOAD {self.msg}"
-
     class LengthNode(InstructionNode):
         def __init__(self, dest, idx):
             self.dest = dest
@@ -200,7 +164,4 @@ def __init__(self, dest):
 
     class PrintStrNode(InstructionNode):
         def __init__(self, value):
-            self.value = value
-        
-        def __repr__(self):
-            return f"PRINTSTR {self.value}"
\ No newline at end of file
+            self.value = value
\ No newline at end of file

From f5a6749fde2be151b97231762a8f241c42c1697f Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 10:46:39 -0800
Subject: [PATCH 50/83] uodating visitor to cil

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 830506792..f0d6cf089 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -1,10 +1,9 @@
 import cmp.visitor as visitor
 from utils.ast.AST_Nodes import ast_nodes as nodes
 
-class COOL_to_CIL:
-    def __init__(self, context, scope):
+class COOLtoCIL:
+    def __init__(self, context):
         self.context = context
-        self.scope = scope
 
 
     @visitor.on('node')

From 3b0dd3b8b0dbd9b3c271526ece8a99f2cd23efe0 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 11:15:13 -0800
Subject: [PATCH 51/83] adding ErrorNode

---
 src/utils/code_generation/cil/AST_CIL.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 128b8d597..6bc7fdfe6 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -164,4 +164,8 @@ def __init__(self, dest):
 
     class PrintStrNode(InstructionNode):
         def __init__(self, value):
-            self.value = value
\ No newline at end of file
+            self.value = value
+        
+    class ErrorNode(InstructionNode):
+        def __init__(self, data_node):
+            self.data_node = data_node
\ No newline at end of file

From 629ffa26fe8ad35d81820aa815d0f65e85f1a48d Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 11:15:57 -0800
Subject: [PATCH 52/83] adding ErrorNode

---
 src/utils/code_generation/cil/print_CIL_AST.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index 58f5d48dd..8a660fbd6 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -143,6 +143,10 @@ def visit(self, node):
         def visit(self, node):
             return f'PRINT {node.value}'
         
+        @visitor.when(nodes.ErrorNode)
+        def visit(self, node):
+            return f'ERROR {node.data_node}'
+        
     printer = PrintVisitor()
     return (lambda ast: printer.visit(ast))
     
\ No newline at end of file

From 3fea7a2ae4695e1243ca22cab80cdf350e74a0f9 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 11:17:35 -0800
Subject: [PATCH 53/83] base cool to cil

---
 .../code_generation/cil/Base_COOL_to_CIL.py   | 99 +++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 src/utils/code_generation/cil/Base_COOL_to_CIL.py

diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
new file mode 100644
index 000000000..ef2ede452
--- /dev/null
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -0,0 +1,99 @@
+from utils.code_generation.cil.AST_CIL import cil_ast as nodes
+from cmp.semantic import VariableInfo
+
+
+class BaseCOOLToCIL:
+    def __init__(self, context):
+        self.dottypes = []
+        self.dotdata = []
+        self.dotcode = []
+
+        self.current_type = None
+        self.current_method = None
+        self.current_function = None
+
+        self.context = context
+        self.vself = VariableInfo('self', None)
+    
+    @property
+    def params(self):
+        return self.current_function.params
+    
+    @property
+    def localvars(self):
+        return self.current_function.localvars
+
+    @property
+    def ids(self):
+        return self.current_function.ids
+    
+    @property
+    def instructions(self):
+        return self.current_function.instructions
+    
+    def register_param(self, vinfo):
+        param_node = nodes.ParamNode(vinfo.name)
+        self.params.append(param_node)
+        return vinfo.name
+    
+    def register_local(self, vinfo, id=False):
+        if len(self.current_function.name) >= 8 and self.current_function.name[:8] == 'function':
+            name = f'local_{self.current_function.name[9:]}_{vinfo.name}_{len(self.localvars)}'
+        else:
+            name = f'local_{self.current_function.name[5:]}_{vinfo.name}_{len(self.localvars)}'
+        
+        new_vinfo = VariableInfo(name, None)
+        local_node = nodes.LocalNode(new_vinfo.name)
+
+        if id:
+            self.ids[vinfo.name] = new_vinfo.name
+
+        self.localvars.append(local_node)
+        return new_vinfo.name
+
+    def define_internal_local(self):
+        vinfo = VariableInfo('internal', None)
+        return self.register_local(vinfo)
+
+    def register_instruction(self, instruction):
+        self.instructions.append(instruction)
+        return instruction
+    
+    def to_function_name(self, method_name, type_name):
+        return f'function_{method_name}_at_{type_name}'
+
+    def init_name(self, type_name, attr=False):
+        if attr:
+            return f'init_attr_at_{type_name}'
+        return f'init_at_{type_name}'
+    
+    def register_function(self, function_name):
+        function_node = nodes.FunctionNode(function_name, [], [], [])
+        self.dotcode.append(function_node)
+        return function_node
+    
+    def register_type(self, name):
+        type_node = nodes.TypeNode(name)
+        self.dottypes.append(type_node)
+        return type_node
+
+    def register_data(self, value):
+        vname = f'data_{len(self.dotdata)}'
+        data_node = nodes.DataNode(vname, value)
+        self.dotdata.append(data_node)
+        return data_node
+
+    def register_label(self, label):
+        lname = f'{label}_{self.current_function.labels_count}'
+        self.current_function.labels_count += 1
+        return nodes.LabelNode(lname)
+    
+    def register_runtime_error(self, condition, msg):
+        error_node = self.register_label('error_label')
+        continue_node = self.register_label('continue_label')
+        self.register_instruction(nodes.IfGotoNode(condition, error_node.label))
+        self.register_instruction(nodes.GotoNode(continue_node.label))
+        self.register_instruction(error_node)
+        data_node = self.register_data(msg)
+        self.register_instruction(nodes.ErrorNode(data_node))
+        self.register_instruction(continue_node)
\ No newline at end of file

From 107bcc51f6d1909062868965bee8a3f91adc471b Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 11:42:58 -0800
Subject: [PATCH 54/83] type name and name nodes

---
 src/utils/code_generation/cil/AST_CIL.py       | 12 +++++++++++-
 src/utils/code_generation/cil/print_CIL_AST.py |  8 ++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 6bc7fdfe6..754237139 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -168,4 +168,14 @@ def __init__(self, value):
         
     class ErrorNode(InstructionNode):
         def __init__(self, data_node):
-            self.data_node = data_node
\ No newline at end of file
+            self.data_node = data_node
+
+    class TypeNameNode(InstructionNode):
+        def __init__(self, dest, typex):
+            self.dest = dest
+            self.type = typex
+    
+    class NameNode(InstructionNode):
+        def __init__(self, dest, idx):
+            self.dest = dest
+            self.id = idx
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index 8a660fbd6..1ffcc2535 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -147,6 +147,14 @@ def visit(self, node):
         def visit(self, node):
             return f'ERROR {node.data_node}'
         
+        @visitor.when(nodes.TypeNameNode)
+        def visit(self, node):
+            return f'{node.dest} = TYPENAME {node.type}'
+
+        @visitor.when(nodes.NameNode)
+        def visit(self, node):
+            return f'{node.dest} = NAME {node.id}'
+        
     printer = PrintVisitor()
     return (lambda ast: printer.visit(ast))
     
\ No newline at end of file

From 071c25a989d31f34b9d35c7980f2efa0ef4ad649 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 11:55:41 -0800
Subject: [PATCH 55/83] modifying cil ast and register Object type

---
 src/main.py                                   |  7 ++-
 src/utils/code_generation/cil/AST_CIL.py      | 10 +++-
 .../code_generation/cil/Base_COOL_to_CIL.py   | 48 ++++++++++++++++++-
 .../code_generation/cil/print_CIL_AST.py      |  8 ++++
 4 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/src/main.py b/src/main.py
index 35a9394b6..234d59e5e 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.parser.LALR_1 import LALR1_Parser
 
 if __name__ == "__main__":
-    add = "semantic/inheritance4.cl"
+    add = "codegen/arith.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -46,6 +46,7 @@
     # ast       
     ast = evaluate_reverse_parse(G, derivation, operations, lexer.fixed_tokens(tokens))
             
+    # chequeo semantico
     context = Context()
     semantic_errors = []
 
@@ -61,4 +62,6 @@
     if semantic_errors:
         for error in semantic_errors:
             print(error)                          
-        raise Exception()
\ No newline at end of file
+        raise Exception()
+
+# generacion de codigo
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 754237139..807fc7345 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -178,4 +178,12 @@ def __init__(self, dest, typex):
     class NameNode(InstructionNode):
         def __init__(self, dest, idx):
             self.dest = dest
-            self.id = idx
\ No newline at end of file
+            self.id = idx
+    
+    class AbortNode(InstructionNode):
+        pass
+
+    class CopyNode(InstructionNode):
+        def __init__(self, dest, copy):
+            self.dest = dest
+            self.copy = copy
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
index ef2ede452..4b61d97e9 100644
--- a/src/utils/code_generation/cil/Base_COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -96,4 +96,50 @@ def register_runtime_error(self, condition, msg):
         self.register_instruction(error_node)
         data_node = self.register_data(msg)
         self.register_instruction(nodes.ErrorNode(data_node))
-        self.register_instruction(continue_node)
\ No newline at end of file
+        self.register_instruction(continue_node)
+
+
+    # tipos y funciones integrados en COOL
+    def _register_Object(self):
+        type_node = self.register_type('Object')
+
+        self.current_function = self.register_function(self.init_name('Object'))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.AllocateNode('Object', instance))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        self.current_function = self.register_function(self.to_function_name('abort', 'Object'))
+        self.register_param(self.vself)
+        vname = self.define_internal_local()
+        data_node = [dn for dn in self.dotdata if dn.value == 'Abort called from class '][0]
+        self.register_instruction(nodes.LoadNode(vname, data_node))
+        self.register_instruction(nodes.PrintStrNode(vname))
+        self.register_instruction(nodes.TypeNameNode(vname, self.vself.name))
+        self.register_instruction(nodes.PrintStrNode(vname))
+        data_node = self.register_data('\n')
+        self.register_instruction(nodes.LoadNode(vname, data_node))
+        self.register_instruction(nodes.PrintStrNode(vname))
+        self.register_instruction(nodes.AbortNode())
+
+        self.current_function = self.register_function(self.to_function_name('type_name', 'Object'))
+        self.register_param(self.vself)
+        result = self.define_internal_local()
+        self.register_instruction(nodes.TypeNameNode(result, self.vself.name))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.ArgNode(result))
+        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        self.current_function = self.register_function(self.to_function_name('copy', 'Object'))
+        self.register_param(self.vself)
+        result = self.define_internal_local()
+        self.register_instruction(nodes.CopyNode(result, self.vself.name))
+        self.register_instruction(nodes.ReturnNode(result))
+
+        type_node.methods = [(name, self.to_function_name(name, 'Object')) for name in ['abort', 'type_name', 'copy']]
+        type_node.methods += [('init', self.init_name('Object'))]
+        return ['abort', 'type_name', 'copy']
+
+    def register_built_in(self):
+        obj_methods = self._register_Object()
+        
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index 1ffcc2535..b48e20b7d 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -154,6 +154,14 @@ def visit(self, node):
         @visitor.when(nodes.NameNode)
         def visit(self, node):
             return f'{node.dest} = NAME {node.id}'
+
+        @visitor.when(nodes.AbortNode)
+        def visit(self, node):
+            return f'ABORT'
+        
+        @visitor.when(nodes.CopyNode)
+        def visit(self, node):
+            return f'{node.dest} = COPY {node.copy}'
         
     printer = PrintVisitor()
     return (lambda ast: printer.visit(ast))

From 1f0fc9e5d28b1c8da31af4f0454fcfbbbae167eb Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 19 Feb 2022 14:45:41 -0800
Subject: [PATCH 56/83] adding nodes cil ast - register IO

---
 src/utils/code_generation/cil/AST_CIL.py      | 10 +++-
 .../code_generation/cil/Base_COOL_to_CIL.py   | 55 +++++++++++++++++--
 .../code_generation/cil/print_CIL_AST.py      |  8 +++
 3 files changed, 68 insertions(+), 5 deletions(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 807fc7345..d0cd8fe3b 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -186,4 +186,12 @@ class AbortNode(InstructionNode):
     class CopyNode(InstructionNode):
         def __init__(self, dest, copy):
             self.dest = dest
-            self.copy = copy
\ No newline at end of file
+            self.copy = copy
+    
+    class ReadIntNode(InstructionNode):
+        def __init__(self, dest):
+            self.dest = dest 
+
+    class PrintIntNode(InstructionNode):
+        def __init__(self, value):
+            self.value = value
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
index 4b61d97e9..66d0e6daa 100644
--- a/src/utils/code_generation/cil/Base_COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -97,6 +97,12 @@ def register_runtime_error(self, condition, msg):
         data_node = self.register_data(msg)
         self.register_instruction(nodes.ErrorNode(data_node))
         self.register_instruction(continue_node)
+    
+    def register_built_in(self):
+        self._register_Object()
+        self._register_IO()
+
+
 
 
     # tipos y funciones integrados en COOL
@@ -138,8 +144,49 @@ def _register_Object(self):
 
         type_node.methods = [(name, self.to_function_name(name, 'Object')) for name in ['abort', 'type_name', 'copy']]
         type_node.methods += [('init', self.init_name('Object'))]
-        return ['abort', 'type_name', 'copy']
+    
+    def _register_IO(self):
+        type_node = self.register_type('IO')
 
-    def register_built_in(self):
-        obj_methods = self._register_Object()
-        
\ No newline at end of file
+        self.current_function = self.register_function(self.init_name('IO'))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.AllocateNode('IO', instance))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        self.current_function = self.register_function(self.to_function_name('out_string', 'IO'))
+        self.register_param(self.vself)
+        self.register_param(VariableInfo('x', None))
+        vname = self.define_internal_local()
+        self.register_instruction(nodes.GetAttrNode(vname, 'x', 'value', 'String'))
+        self.register_instruction(nodes.PrintStrNode(vname))
+        self.register_instruction(nodes.ReturnNode(self.vself.name))
+
+        self.current_function = self.register_function(self.to_function_name('out_int', 'IO'))
+        self.register_param(self.vself)
+        self.register_param(VariableInfo('x', None))
+        vname = self.define_internal_local()
+        self.register_instruction(nodes.GetAttrNode(vname, 'x', 'value', 'Int'))
+        self.register_instruction(nodes.PrintIntNode(vname))
+        self.register_instruction(nodes.ReturnNode(self.vself.name)) 
+
+        self.current_function = self.register_function(self.to_function_name('in_string', 'IO'))
+        self.register_param(self.vself)
+        result = self.define_internal_local()
+        self.register_instruction(nodes.ReadStrNode(result))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.ArgNode(result))
+        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        self.current_function = self.register_function(self.to_function_name('in_int', 'IO'))
+        self.register_param(self.vself)
+        result = self.define_internal_local()
+        self.register_instruction(nodes.ReadIntNode(result))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.ArgNode(result))
+        self.register_instruction(nodes.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes.ReturnNode(instance))  
+
+        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
+        type_node.methods += [(name, self.to_function_name(name, 'IO')) for name in ['out_string', 'out_int', 'in_string', 'in_int']]
+        type_node.methods += [('init', self.init_name('IO'))]
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index b48e20b7d..7af87b1f5 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -163,6 +163,14 @@ def visit(self, node):
         def visit(self, node):
             return f'{node.dest} = COPY {node.copy}'
         
+        @visitor.when(nodes.ReadIntNode)
+        def visit(self, node):
+            return f'{node.dest} = READINT'
+
+        @visitor.when(nodes.PrintIntNode)
+        def visit(self, node):
+            return f'PRINT {node.value}'
+        
     printer = PrintVisitor()
     return (lambda ast: printer.visit(ast))
     
\ No newline at end of file

From ac0b0e2a3d3330124dfaa706cf52df2d18486b4e Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 10:34:07 -0800
Subject: [PATCH 57/83] fixing issues on register COOL built-in

---
 .../code_generation/cil/Base_COOL_to_CIL.py   | 121 +++++++++++++++++-
 1 file changed, 114 insertions(+), 7 deletions(-)

diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
index 66d0e6daa..b270eb4a0 100644
--- a/src/utils/code_generation/cil/Base_COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -99,14 +99,19 @@ def register_runtime_error(self, condition, msg):
         self.register_instruction(continue_node)
     
     def register_built_in(self):
-        self._register_Object()
-        self._register_IO()
+        self.__register_Object()
+        self.__register_IO()
+        self.__register_Int()
+        self.__register_String()
+        self.__register_Bool()
 
 
 
 
-    # tipos y funciones integrados en COOL
-    def _register_Object(self):
+
+
+    # convirtiendo tipos y funciones integrados en COOL en CIL
+    def __register_Object(self):
         type_node = self.register_type('Object')
 
         self.current_function = self.register_function(self.init_name('Object'))
@@ -117,7 +122,7 @@ def _register_Object(self):
         self.current_function = self.register_function(self.to_function_name('abort', 'Object'))
         self.register_param(self.vself)
         vname = self.define_internal_local()
-        data_node = [dn for dn in self.dotdata if dn.value == 'Abort called from class '][0]
+        data_node = [dn for dn in self.dotdata if dn.value == 'Aborting... in class '][0]
         self.register_instruction(nodes.LoadNode(vname, data_node))
         self.register_instruction(nodes.PrintStrNode(vname))
         self.register_instruction(nodes.TypeNameNode(vname, self.vself.name))
@@ -145,7 +150,7 @@ def _register_Object(self):
         type_node.methods = [(name, self.to_function_name(name, 'Object')) for name in ['abort', 'type_name', 'copy']]
         type_node.methods += [('init', self.init_name('Object'))]
     
-    def _register_IO(self):
+    def __register_IO(self):
         type_node = self.register_type('IO')
 
         self.current_function = self.register_function(self.init_name('IO'))
@@ -189,4 +194,106 @@ def _register_IO(self):
 
         type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
         type_node.methods += [(name, self.to_function_name(name, 'IO')) for name in ['out_string', 'out_int', 'in_string', 'in_int']]
-        type_node.methods += [('init', self.init_name('IO'))]
\ No newline at end of file
+        type_node.methods += [('init', self.init_name('IO'))]
+    
+    def __register_Int(self):
+        type_node = self.register_type('Int')
+        type_node.attributes = ['value']
+
+        self.current_function = self.register_function(self.init_name('Int'))
+        self.register_param(VariableInfo('val', None))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.AllocateNode('Int', instance))
+        self.register_instruction(nodes.SetAttrNode(instance, 'value', 'val', 'Int'))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
+        type_node.methods += [('init', self.init_name('Int'))]
+    
+    def __register_String(self):
+        type_node = self.register_type('String')
+        type_node.attributes = ['value', 'length']
+
+        self.current_function = self.register_function(self.init_name('String'))
+        self.register_param(VariableInfo('val', None))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.AllocateNode('String', instance))
+        self.register_instruction(nodes.SetAttrNode(instance, 'value', 'val', 'String'))
+        result = self.define_internal_local()
+        self.register_instruction(nodes.LengthNode(result, 'val'))
+        attr = self.define_internal_local()
+        self.register_instruction(nodes.ArgNode(result))
+        self.register_instruction(nodes.StaticCallNode(self.init_name('Int'), attr))
+        self.register_instruction(nodes.SetAttrNode(instance, 'length', attr, 'String'))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        self.current_function = self.register_function(self.to_function_name('length', 'String'))
+        self.register_param(self.vself)
+        result = self.define_internal_local()
+        self.register_instruction(nodes.GetAttrNode(result, self.vself.name, 'length', 'String'))
+        self.register_instruction(nodes.ReturnNode(result))
+
+        self.current_function = self.register_function(self.to_function_name('concat', 'String'))
+        self.register_param(self.vself)
+        self.register_param(VariableInfo('s', None))
+        str_1 = self.define_internal_local()
+        str_2 = self.define_internal_local()
+        length_1 = self.define_internal_local()
+        length_2 = self.define_internal_local()
+        self.register_instruction(nodes.GetAttrNode(str_1, self.vself.name, 'value', 'String'))
+        self.register_instruction(nodes.GetAttrNode(str_2, 's', 'value', 'String'))
+        self.register_instruction(nodes.GetAttrNode(length_1, self.vself.name, 'length', 'String'))
+        self.register_instruction(nodes.GetAttrNode(length_2, 's', 'length', 'String'))
+        self.register_instruction(nodes.GetAttrNode(length_1, length_1, 'value', 'Int'))
+        self.register_instruction(nodes.GetAttrNode(length_2, length_2, 'value', 'Int'))
+        self.register_instruction(nodes.PlusNode(length_1, length_1, length_2))
+
+        result = self.define_internal_local()
+        self.register_instruction(nodes.ConcatNode(result, str_1, str_2, length_1))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.ArgNode(result))
+        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        self.current_function = self.register_function(self.to_function_name('substr', 'String'))
+        self.register_param(self.vself)
+        self.register_param(VariableInfo('i', None))
+        self.register_param(VariableInfo('l', None))
+        result = self.define_internal_local()
+        index_value = self.define_internal_local()
+        length_value = self.define_internal_local()
+        length_attr = self.define_internal_local()
+        length_substr = self.define_internal_local()
+        less_value = self.define_internal_local()
+        str_value = self.define_internal_local()
+        self.register_instruction(nodes.GetAttrNode(str_value, self.vself.name, 'value', 'String'))
+        self.register_instruction(nodes.GetAttrNode(index_value, 'i', 'value', 'Int'))
+        self.register_instruction(nodes.GetAttrNode(length_value, 'l', 'value', 'Int'))
+      
+        self.register_instruction(nodes.GetAttrNode(length_attr, self.vself.name, 'length', 'String'))
+        self.register_instruction(nodes.PlusNode(length_substr, length_value, index_value))
+        self.register_instruction(nodes.LessThanNode(less_value, length_attr, length_substr))
+        self.register_runtime_error(less_value, 'Substring out of range')
+        self.register_instruction(nodes.SubstringNode(result, str_value, index_value, length_value))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.ArgNode(result))
+        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
+        type_node.methods += [(name, self.to_function_name(name, 'String')) for name in ['length', 'concat', 'substr']]
+        type_node.methods += [('init', self.init_name('String'))]
+    
+    def __register_Bool(self):
+        type_node = self.register_type('Bool')
+        type_node.attributes = ['value']
+
+        self.current_function = self.register_function(self.init_name('Bool'))
+        self.register_param(VariableInfo('val', None))
+        instance = self.define_internal_local()
+        self.register_instruction(nodes.AllocateNode('Bool', instance))
+        self.register_instruction(nodes.SetAttrNode(instance, 'value', 'val', 'Bool'))
+        self.register_instruction(nodes.ReturnNode(instance))
+
+        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
+        type_node.methods += [('init', self.init_name('Bool'))]
\ No newline at end of file

From 0b14d596801c4fb764081a5993832fbcc0ab65e8 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 11:16:17 -0800
Subject: [PATCH 58/83] programNode - classDecNode

---
 src/main.py                                   | 10 +++-
 src/utils/code_generation/cil/AST_CIL.py      |  4 +-
 .../code_generation/cil/Base_COOL_to_CIL.py   |  6 +-
 src/utils/code_generation/cil/COOL_to_CIL.py  | 60 +++++++++++++++++--
 .../code_generation/cil/print_CIL_AST.py      | 13 ++--
 5 files changed, 75 insertions(+), 18 deletions(-)

diff --git a/src/main.py b/src/main.py
index 234d59e5e..1253c3984 100644
--- a/src/main.py
+++ b/src/main.py
@@ -9,8 +9,8 @@
 from utils.semantic_check.type_collector import TypeCollector
 from utils.semantic_check.type_builder import TypeBuilder
 from utils.semantic_check.type_checker import TypeChecker 
-
-from utils.parser.LALR_1 import LALR1_Parser
+from utils.code_generation.cil.COOL_to_CIL import COOLtoCIL
+from utils.code_generation.cil.print_CIL_AST import get_formatter
 
 if __name__ == "__main__":
     add = "codegen/arith.cl"
@@ -64,4 +64,8 @@
             print(error)                          
         raise Exception()
 
-# generacion de codigo
\ No newline at end of file
+# generacion de codigo
+cil_visitor = COOLtoCIL(context)
+cil_ast = cil_visitor.visit(ast, scope)
+
+print(get_formatter()(cil_ast))
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index d0cd8fe3b..d0e9ca608 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -80,13 +80,13 @@ def __repr__(self):
     class GetAttrNode(InstructionNode):
         def __init__(self, dest, idx, attr, computed_type):
             self.dest = dest
-            self.idx = idx
+            self.id = idx
             self.attr = attr
             self.computed_type = computed_type
 
     class SetAttrNode(InstructionNode):
         def __init__(self, idx, attr, value, computed_type):
-            self.idx = idx
+            self.id = idx
             self.attr = attr
             self.value = value
             self.computed_type = computed_type
diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
index b270eb4a0..74a037557 100644
--- a/src/utils/code_generation/cil/Base_COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -37,10 +37,10 @@ def register_param(self, vinfo):
         return vinfo.name
     
     def register_local(self, vinfo, id=False):
-        if len(self.current_function.name) >= 8 and self.current_function.name[:8] == 'function':
-            name = f'local_{self.current_function.name[9:]}_{vinfo.name}_{len(self.localvars)}'
+        if len(self.current_function.id) >= 8 and self.current_function.id[:8] == 'function':
+            name = f'local_{self.current_function.id[9:]}_{vinfo.name}_{len(self.localvars)}'
         else:
-            name = f'local_{self.current_function.name[5:]}_{vinfo.name}_{len(self.localvars)}'
+            name = f'local_{self.current_function.id[5:]}_{vinfo.name}_{len(self.localvars)}'
         
         new_vinfo = VariableInfo(name, None)
         local_node = nodes.LocalNode(new_vinfo.name)
diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index f0d6cf089..343ad42d4 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -1,9 +1,12 @@
 import cmp.visitor as visitor
+from cmp.semantic import VariableInfo
 from utils.ast.AST_Nodes import ast_nodes as nodes
+from utils.code_generation.cil.AST_CIL import cil_ast as nodes_cil
+from utils.code_generation.cil.Base_COOL_to_CIL import BaseCOOLToCIL
 
-class COOLtoCIL:
+class COOLtoCIL(BaseCOOLToCIL):
     def __init__(self, context):
-        self.context = context
+        BaseCOOLToCIL.__init__(self, context)
 
 
     @visitor.on('node')
@@ -13,12 +16,61 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.ProgramNode)
     def visit(self, node, scope=None):
-        pass
+        self.current_function = self.register_function('entry')
+        result = self.define_internal_local()
+        instance = self.register_local(VariableInfo('instance', None))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Main'), instance))
+        self.register_instruction(nodes_cil.ArgNode(instance))
+        self.register_instruction(nodes_cil.StaticCallNode(self.to_function_name('main', 'Main'), result))
+        self.register_instruction(nodes_cil.ReturnNode(0))
+       
+        self.register_data('Aborting... in class ')
+        self.register_built_in()
+        self.current_function = None
+        
+        for declaration, child_scope in zip(node.declarations, scope.children):
+            self.visit(declaration, child_scope)
+
+        return nodes_cil.ProgramNode(self.dottypes, self.dotdata, self.dotcode)
     
 
     @visitor.when(nodes.ClassDeclarationNode)
     def visit(self, node, scope):
-        pass
+        self.current_type = self.context.get_type(node.id)
+        
+        type_node = self.register_type(node.id)
+        type_node.attributes = [attr.name for attr, _ in self.current_type.all_attributes()]
+        type_node.methods = [(method.name, self.to_function_name(method.name, xtype.name)) for method, xtype in self.current_type.all_methods()]
+
+        func_declarations = (f for f in node.features if isinstance(f, nodes.MethDeclarationNode))
+        for feature, child_scope in zip(func_declarations, scope.children):
+            self.visit(feature, child_scope)
+
+        self.current_function = self.register_function(self.init_name(node.id))
+        
+        instance = self.register_local(VariableInfo('instance', None))
+        self.register_instruction(nodes_cil.AllocateNode(node.id, instance))  
+
+        func = self.current_function
+        vtemp = self.define_internal_local()
+
+        self.current_function = self.register_function(self.init_name(node.id, attr=True))
+        self.register_param(self.vself)
+        if node.parent != 'Object' and node.parent != 'IO':
+            self.register_instruction(nodes_cil.ArgNode(self.vself.name))
+            self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.parent, attr=True), vtemp))
+        attr_declarations = (f for f in node.features if isinstance(f, nodes.AttrDeclarationNode))
+        for feature in attr_declarations:
+            self.visit(feature, scope)
+        
+        self.current_function = func
+        self.register_instruction(nodes_cil.ArgNode(instance))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.id, attr=True), vtemp))
+
+        self.register_instruction(nodes_cil.ReturnNode(instance))
+        self.current_function = None
+                
+        self.current_type = None
 
     @visitor.when(nodes.AttrDeclarationNode)
     def visit(self, node, scope):
diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index 7af87b1f5..d4909ef39 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -3,7 +3,8 @@
 
 def get_formatter():
 
-    class PrintVisitor(object):
+    class PrintCIL(object):
+        
         @visitor.on('node')
         def visit(self, node):
             pass
@@ -21,11 +22,11 @@ def visit(self, node):
             attributes = '\n\t'.join(f'attribute {x}' for x in node.attributes)
             methods = '\n\t'.join(f'method {x}: {y}' for x,y in node.methods)
 
-            return f'type {node.name} {{\n\t{attributes}\n\n\t{methods}\n}}'
+            return f'type {node.id} {{\n\t{attributes}\n\n\t{methods}\n}}'
 
         @visitor.when(nodes.DataNode)
         def visit(self, node):
-            return f'{node.idx} = {node.value}'
+            return f'{node.id} = {node.value}'
 
         @visitor.when(nodes.FunctionNode)
         def visit(self, node):
@@ -67,7 +68,7 @@ def visit(self, node):
         def visit(self, node):
             return f'{node.dest} = {node.op_l} <= {node.op_r}'
 
-        @visitor.when(nodes.LessNode)
+        @visitor.when(nodes.LessThanNode)
         def visit(self, node):
             return f'{node.dest} = {node.op_l} < {node.op_r}'
 
@@ -81,7 +82,7 @@ def visit(self, node):
 
         @visitor.when(nodes.SetAttrNode)
         def visit(self, node):
-            return f'SETATTR {node.idx} {node.attr} {node.value}'
+            return f'SETATTR {node.id} {node.attr} {node.value}'
 
         @visitor.when(nodes.AllocateNode)
         def visit(self, node):
@@ -171,6 +172,6 @@ def visit(self, node):
         def visit(self, node):
             return f'PRINT {node.value}'
         
-    printer = PrintVisitor()
+    printer = PrintCIL()
     return (lambda ast: printer.visit(ast))
     
\ No newline at end of file

From e6f4852237003adfebc893d15e7cb39f1b9cf8aa Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 11:59:21 -0800
Subject: [PATCH 59/83] working on cool to cil visitor

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 60 +++++++++++++++++---
 1 file changed, 53 insertions(+), 7 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 343ad42d4..84c49ef7a 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -51,7 +51,7 @@ def visit(self, node, scope):
         instance = self.register_local(VariableInfo('instance', None))
         self.register_instruction(nodes_cil.AllocateNode(node.id, instance))  
 
-        func = self.current_function
+        temp_f = self.current_function
         vtemp = self.define_internal_local()
 
         self.current_function = self.register_function(self.init_name(node.id, attr=True))
@@ -63,23 +63,46 @@ def visit(self, node, scope):
         for feature in attr_declarations:
             self.visit(feature, scope)
         
-        self.current_function = func
+        self.current_function = temp_f
         self.register_instruction(nodes_cil.ArgNode(instance))
         self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.id, attr=True), vtemp))
-
         self.register_instruction(nodes_cil.ReturnNode(instance))
         self.current_function = None
-                
         self.current_type = None
 
+
     @visitor.when(nodes.AttrDeclarationNode)
     def visit(self, node, scope):
-        pass
+        if node.expr:
+            self.visit(node.expr, scope)
+            self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, scope._return, self.current_type))
+        elif node.type in self.value_types:
+            vtemp = self.define_internal_local()
+            self.register_instruction(nodes_cil.AllocateNode(node.type, vtemp))
+            self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, vtemp, self.current_type))
     
 
     @visitor.when(nodes.MethDeclarationNode)
     def visit(self, node, scope):
-        pass
+        self.current_method = self.current_type.get_method(node.id)
+        self.current_function = self.register_function(self.to_function_name(self.current_method.name, self.current_type.name))
+        
+        self.register_param(self.vself)
+        for param_name, _ in node.params:
+            self.register_param(VariableInfo(param_name, None))
+        
+        scope._return = None
+        self.visit(node.body, scope)
+
+        if scope._return is None:
+            self.register_instruction(nodes_cil.ReturnNode(''))
+        elif self.current_function.name == 'entry':
+            self.register_instruction(nodes_cil.ReturnNode(0))
+        else:
+            self.register_instruction(nodes_cil.ReturnNode(scope._return))
+        
+        self.current_method = None
+
 
     @visitor.when(nodes.AssignNode)
     def visit(self, node, scope):
@@ -88,7 +111,30 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.IfThenElseNode)
     def visit(self, node, scope):
-        pass
+        vresult = self.register_local(VariableInfo('if_then_else_value', None))
+        vcondition = self.define_internal_local()
+
+        then_label_node = self.register_label('then_label')
+        else_label_node = self.register_label('else_label')
+        continue_label_node = self.register_label('continue_label')
+
+        self.visit(node.if_expr, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(vcondition, scope._return, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.IfGotoNode(vcondition, then_label_node.label))
+        
+        self.register_instruction(nodes_cil.GotoNode(else_label_node.label))
+        
+        self.register_instruction(then_label_node)
+        self.visit(node.then_expr, scope)
+        self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
+        self.register_instruction(nodes_cil.GotoNode(continue_label_node.label))
+        
+        self.register_instruction(else_label_node)
+        self.visit(node.else_expr, scope)
+        self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
+
+        self.register_instruction(continue_label_node)
+        scope._return = vresult
 
 
     @visitor.when(nodes.WhileNode)

From 29872f4deb0fb02bbd7a7d92f50a823c34178fc1 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 12:23:37 -0800
Subject: [PATCH 60/83] modifying cil ast

---
 src/cmp/semantic.py                            | 2 ++
 src/utils/code_generation/cil/AST_CIL.py       | 5 ++++-
 src/utils/code_generation/cil/print_CIL_AST.py | 4 ++++
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/cmp/semantic.py b/src/cmp/semantic.py
index 1476d66d4..41b90fa85 100644
--- a/src/cmp/semantic.py
+++ b/src/cmp/semantic.py
@@ -210,6 +210,8 @@ def __init__(self, parent=None):
         self.children = []
         self.index = 0 if parent is None else len(parent)
 
+        self._return = None
+
     def __len__(self):
         return len(self.locals)
 
diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index d0e9ca608..21c5e3d21 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -194,4 +194,7 @@ def __init__(self, dest):
 
     class PrintIntNode(InstructionNode):
         def __init__(self, value):
-            self.value = value
\ No newline at end of file
+            self.value = value
+    
+    class VoidNode(InstructionNode):
+        pass
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index d4909ef39..275b206fc 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -172,6 +172,10 @@ def visit(self, node):
         def visit(self, node):
             return f'PRINT {node.value}'
         
+        @visitor.when(nodes.VoidNode)
+        def visit(self, node):
+            return 'VOID'
+        
     printer = PrintCIL()
     return (lambda ast: printer.visit(ast))
     
\ No newline at end of file

From 182b96a9b50377a0e4648feb0a2cc2dd19c44b58 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 12:29:25 -0800
Subject: [PATCH 61/83] working on cil visitor

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 23 +++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 84c49ef7a..17fb4c99c 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -76,7 +76,7 @@ def visit(self, node, scope):
         if node.expr:
             self.visit(node.expr, scope)
             self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, scope._return, self.current_type))
-        elif node.type in self.value_types:
+        elif node.type in ['String', 'Int', 'Bool']:
             vtemp = self.define_internal_local()
             self.register_instruction(nodes_cil.AllocateNode(node.type, vtemp))
             self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, vtemp, self.current_type))
@@ -96,7 +96,7 @@ def visit(self, node, scope):
 
         if scope._return is None:
             self.register_instruction(nodes_cil.ReturnNode(''))
-        elif self.current_function.name == 'entry':
+        elif self.current_function.id == 'entry':
             self.register_instruction(nodes_cil.ReturnNode(0))
         else:
             self.register_instruction(nodes_cil.ReturnNode(scope._return))
@@ -139,7 +139,24 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.WhileNode)
     def visit(self, node, scope):
-        pass
+        vcondition = self.define_internal_local()
+        while_label_node = self.register_label('while_label')
+        loop_label_node = self.register_label('loop_label')
+        pool_label_node = self.register_label('pool_label')
+        
+        self.register_instruction(while_label_node)
+        self.visit(node.conditional_expr, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(vcondition, scope.ret_expr, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.IfGotoNode(vcondition, loop_label_node.label))
+        
+        self.register_instruction(nodes_cil.GotoNode(pool_label_node.label))
+        self.register_instruction(loop_label_node)
+        self.visit(node.loop_expr, scope)
+        
+        self.register_instruction(nodes_cil.GotoNode(while_label_node.label))
+        self.register_instruction(pool_label_node)
+
+        scope.ret_expr = nodes_cil.VoidNode()
     
 
     @visitor.when(nodes.BlockNode)

From 0d06518e7d89a839e1211cb475f992bdbaf05da2 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 14:55:25 -0800
Subject: [PATCH 62/83] working on cil visitor

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 58 ++++++++++++++++++--
 1 file changed, 52 insertions(+), 6 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 17fb4c99c..8721030c6 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -106,7 +106,26 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.AssignNode)
     def visit(self, node, scope):
-        pass
+        self.visit(node.expr, scope)
+
+        try:
+            self.current_type.get_attribute(node.id)
+            self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, scope._return, self.current_type.name))
+        
+        except AttributeError:
+            vname = None
+            param_names = [pn.name for pn in self.current_function.params]
+            if node.id in param_names:
+                for n in param_names:
+                    if node.id in n.split("_"):
+                        vname = n
+                        break
+            else:
+                for n in [lv.name for lv in self.current_function.localvars]:
+                    if node.id in n.split("_"):
+                        vname = n
+                        break
+            self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
 
 
     @visitor.when(nodes.IfThenElseNode)
@@ -146,7 +165,7 @@ def visit(self, node, scope):
         
         self.register_instruction(while_label_node)
         self.visit(node.conditional_expr, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(vcondition, scope.ret_expr, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.GetAttrNode(vcondition, scope._return, 'value', 'Bool'))
         self.register_instruction(nodes_cil.IfGotoNode(vcondition, loop_label_node.label))
         
         self.register_instruction(nodes_cil.GotoNode(pool_label_node.label))
@@ -156,17 +175,34 @@ def visit(self, node, scope):
         self.register_instruction(nodes_cil.GotoNode(while_label_node.label))
         self.register_instruction(pool_label_node)
 
-        scope.ret_expr = nodes_cil.VoidNode()
+        scope._return = nodes_cil.VoidNode()
     
 
     @visitor.when(nodes.BlockNode)
     def visit(self, node, scope):
-        pass
+        for expr in node.exprs:
+            self.visit(node.expr_list, scope)
 
     
     @visitor.when(nodes.LetNode)
     def visit(self, node, scope):
-        pass
+        vresult = self.register_local(VariableInfo('let_in_value', None))
+
+        for idx, typex, id_expr in node.identifiers:
+            if idx in self.ids:
+                vname = self.ids[idx]
+            else:
+                vname = self.register_local(VariableInfo(idx, typex), id=True)
+
+            if id_expr:
+                self.visit(id_expr, scope)
+                self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
+            elif typex in self.value_types:
+                self.register_instruction(nodes_cil.AllocateNode(typex, vname))
+
+        self.visit(node.in_expr, scope)
+        self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
+        scope._return = vresult
             
 
     @visitor.when(nodes.CaseNode)
@@ -176,7 +212,17 @@ def visit(self, node, scope):
     
     @visitor.when(nodes.NotNode)
     def visit(self, node, scope):
-        pass
+        vname = self.define_internal_local()
+        value = self.define_internal_local()
+        instance = self.define_internal_local()
+
+        self.visit(node.expr, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(value, scope._return, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.MinusNode(vname, 1, value))
+
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        scope._return = instance
 
     
     @visitor.when(nodes.ConstantNumNode)

From 3aa7c4dc64a2256db5b2b186f7446d23d5b79acc Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 15:21:52 -0800
Subject: [PATCH 63/83] modifying cil ast - begin with aritmectic

---
 src/utils/code_generation/cil/AST_CIL.py     |  9 +-
 src/utils/code_generation/cil/COOL_to_CIL.py | 92 +++++++++++++++++++-
 2 files changed, 93 insertions(+), 8 deletions(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 21c5e3d21..eb5f5cf55 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -45,9 +45,6 @@ class AssignNode(InstructionNode):
         def __init__(self, left, right):
             self.left = left
             self.right = right
-        
-        def __repr__(self):
-            return f"{self.left} = {self.right}"
 
     class ArithmeticNode(InstructionNode):
         def __init__(self, dest, op_l, op_r):
@@ -74,8 +71,10 @@ class LessEqualNode(ArithmeticNode):
         pass
 
     class EqualNode(ArithmeticNode):
-        def __repr__(self):
-            return f"{self.dest} = {self.op_l} == {self.op_r}"
+        pass
+    
+    class EqualStrNode(EqualNode):
+        pass
 
     class GetAttrNode(InstructionNode):
         def __init__(self, dest, idx, attr, computed_type):
diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 8721030c6..db242a7db 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -281,14 +281,100 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.LessThanNode)
     def visit(self, node, scope):
-        pass
+        vname = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+        instance = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        left = scope._return
+
+        self.visit(node.right, scope)
+        right = scope._return
+
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.LessThanNode(vname, left_value, right_value))
+
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        scope._return = instance
 
     
     @visitor.when(nodes.LessEqualNode)
     def visit(self, node, scope):
-        pass
+        vname = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+        instance = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        left = scope._return
+
+        self.visit(node.right, scope)
+        right = scope._return
+
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.LessEqualNode(vname, left_value, right_value))
+        
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        scope._return = instance
     
 
     @visitor.when(nodes.EqualNode)
     def visit(self, node, scope):
-        pass
\ No newline at end of file
+        vname = self.define_internal_local()
+        type_left = self.define_internal_local()
+        _bool = self.define_internal_local()
+        _string = self.define_internal_local()
+        _int = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+        vresult = self.define_internal_local()
+        instance = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        left = scope._return
+
+        self.visit(node.right, scope)
+        right = scope._return
+
+        self.register_instruction(nodes_cil.TypeNameNode(type_left, left))
+        self.register_instruction(nodes_cil.NameNode(_int, 'Int'))
+        self.register_instruction(nodes_cil.NameNode(_bool, 'Bool'))
+        self.register_instruction(nodes_cil.NameNode(_string, 'String'))
+
+        string_node = self.register_label('string_label')
+        int_node = self.register_label('int_label')
+        reference_node = self.register_label('reference_label')
+        continue_node = self.register_label('continue_label')
+
+        self.register_instruction(nodes_cil.EqualNode(vresult, type_left, _int))
+        self.register_instruction(nodes_cil.IfGotoNode(vresult, int_node.label))
+        self.register_instruction(nodes_cil.EqualNode(vresult, type_left, _bool))
+        self.register_instruction(nodes_cil.IfGotoNode(vresult, int_node.label))
+        self.register_instruction(nodes_cil.EqualNode(vresult, type_left, _string))
+        self.register_instruction(nodes_cil.IfGotoNode(vresult, string_node.label))
+        self.register_instruction(nodes_cil.GotoNode(reference_node.label))
+
+        self.register_instruction(int_node)
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'Int'))
+        self.register_instruction(nodes_cil.EqualNode(vname, left_value, right_value))
+        self.register_instruction(nodes_cil.GotoNode(continue_node.label))
+
+        self.register_instruction(string_node)
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'String'))
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'String'))
+        self.register_instruction(nodes_cil.EqualStrNode(vname, left_value, right_value))
+        self.register_instruction(nodes_cil.GotoNode(continue_node.label))
+
+        self.register_instruction(reference_node)
+        self.register_instruction(nodes_cil.EqualNode(vname, left, right))
+
+        self.register_instruction(continue_node)
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        scope._return = instance
\ No newline at end of file

From 0eeacedb91f5709cfeebaaf21e6962cd51a48e47 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 15:57:26 -0800
Subject: [PATCH 64/83] arith to cil

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 68 ++++++++++++++++++--
 1 file changed, 64 insertions(+), 4 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index db242a7db..4a9dcd084 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -261,22 +261,82 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.PlusNode)
     def visit(self, node, scope):
-        pass
+        vname = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.visit(node.right, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+
+        self.register_instruction(nodes_cil.PlusNode(vname, left_value, right_value))
+        instance = self.define_internal_local()
+
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        scope._return = instance
     
 
     @visitor.when(nodes.MinusNode)
     def visit(self, node, scope):
-       pass
+        vname = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.visit(node.right, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+
+        self.register_instruction(nodes_cil.MinusNode(vname, left_value, right_value))
+        instance = self.define_internal_local()
+
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        scope._return = instance
 
     
     @visitor.when(nodes.StarNode)
     def visit(self, node, scope):
-       pass
+        vname = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.visit(node.right, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+
+        self.register_instruction(nodes_cil.StarNode(vname, left_value, right_value))
+        instance = self.define_internal_local()
+
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        scope._return = instance
 
 
     @visitor.when(nodes.DivNode)
     def visit(self, node, scope):
-       pass
+        vname = self.define_internal_local()
+        left_value = self.define_internal_local()
+        right_value = self.define_internal_local()
+
+        self.visit(node.left, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.visit(node.right, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+
+        vresult = self.define_internal_local()
+        self.register_instruction(nodes_cil.EqualNode(vresult, right_value, 0))
+        self.register_runtime_error(vresult, f'({node.line},{node.column}) - RuntimeError: Division by zero\n')
+
+        self.register_instruction(nodes_cil.DivNode(vname, left_value, right_value))
+        instance = self.define_internal_local()
+        
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        scope._return = instance
     
 
     @visitor.when(nodes.LessThanNode)

From 8653e933a638b3fc20aa8d6a4595f65871170ecd Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 16:04:42 -0800
Subject: [PATCH 65/83] adding complNode to cil ast

---
 src/utils/code_generation/cil/AST_CIL.py       | 7 ++++++-
 src/utils/code_generation/cil/print_CIL_AST.py | 4 ++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index eb5f5cf55..24f439d6b 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -196,4 +196,9 @@ def __init__(self, value):
             self.value = value
     
     class VoidNode(InstructionNode):
-        pass
\ No newline at end of file
+        pass
+
+    class ComplementNode(InstructionNode):
+        def __init__(self, dest, idx):
+            self.dest = dest
+            self.id = idx
\ No newline at end of file
diff --git a/src/utils/code_generation/cil/print_CIL_AST.py b/src/utils/code_generation/cil/print_CIL_AST.py
index 275b206fc..ac54779de 100644
--- a/src/utils/code_generation/cil/print_CIL_AST.py
+++ b/src/utils/code_generation/cil/print_CIL_AST.py
@@ -176,6 +176,10 @@ def visit(self, node):
         def visit(self, node):
             return 'VOID'
         
+        @visitor.when(nodes.ComplementNode)
+        def visit(self, node):
+            return f'{node.dest} = COMPLEMENT {node.id}'
+        
     printer = PrintCIL()
     return (lambda ast: printer.visit(ast))
     
\ No newline at end of file

From bf6beba27e46bc6d3bda5259be0c7f2e26d4bbbb Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 16:26:01 -0800
Subject: [PATCH 66/83] atomic nodes to cil

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 95 ++++++++++++++++++--
 1 file changed, 87 insertions(+), 8 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 4a9dcd084..262cdfdca 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -126,6 +126,11 @@ def visit(self, node, scope):
                         vname = n
                         break
             self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
+    
+
+    @visitor.when(nodes.CallNode)
+    def visit(self, node, scope):
+        pass
 
 
     @visitor.when(nodes.IfThenElseNode)
@@ -227,36 +232,110 @@ def visit(self, node, scope):
     
     @visitor.when(nodes.ConstantNumNode)
     def visit(self, node, scope):
-        pass
+        instance = self.define_internal_local()
+        self.register_instruction(nodes_cil.ArgNode(int(node.lex)))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        scope._return = instance
 
     
     @visitor.when(nodes.ConstantBoolNode)
     def visit(self, node, scope):
-       pass
+        if node.lex == 'true':
+            value = 1
+
+        else:
+            value = 0
+
+        instance = self.define_internal_local()
+        self.register_instruction(nodes_cil.ArgNode(value))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        scope._return = instance
 
 
     @visitor.when(nodes.ConstantStringNode)
     def visit(self, node, scope):
-        pass
+        try:
+            data_node = [dn for dn in self.dotdata if dn.value == node.lex][0]
+
+        except IndexError:
+            data_node = self.register_data(node.lex)
+        vmsg = self.register_local(VariableInfo('msg', None))
+        instance = self.define_internal_local()
+
+        self.register_instruction(nodes_cil.LoadNode(vmsg, data_node))
+        self.register_instruction(nodes_cil.ArgNode(vmsg))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('String'), instance))
+        scope._return = instance
 
 
     @visitor.when(nodes.VariableNode)
     def visit(self, node, scope):
-        pass
+        try:
+            self.current_type.get_attribute(node.lex)
+            attr = self.register_local(VariableInfo(node.lex, None), id=True)
+            self.register_instruction(nodes_cil.GetAttrNode(attr, self.vself.name, node.lex, self.current_type.name))
+            scope._return = attr
+
+        except AttributeError:
+            param_names = [pn.name for pn in self.current_function.params]
+            if node.lex in param_names:
+                for n in param_names:
+                    if node.lex == n:
+                        scope._return = n
+                        break
+            else:
+                scope._return = self.ids[node.lex]
 
     
     @visitor.when(nodes.InstantiateNode)
     def visit(self, node, scope):
-        pass
+        instance = self.define_internal_local()
+        
+        if node.lex == 'SELF_TYPE':
+            vtype = self.define_internal_local()
+            self.register_instruction(nodes_cil.TypeOfNode(self.vself.name, vtype))
+            self.register_instruction(nodes_cil.AllocateNode(vtype, instance))
+
+        elif node.lex == 'Int' or node.lex == 'Bool':
+            self.register_instruction(nodes_cil.ArgNode(0))
+
+        elif node.lex == 'String':
+            data_node = [dn for dn in self.dotdata if dn.value == ''][0]
+            vmsg = self.register_local(VariableInfo('msg', None))
+            self.register_instruction(nodes_cil.LoadNode(vmsg, data_node))
+            self.register_instruction(nodes_cil.ArgNode(vmsg))
+
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.lex), instance))
+        scope._return = instance
 
     
     @visitor.when(nodes.IsVoidNode)
     def visit(self, node, scope):
-        pass
+        void = nodes_cil.VoidNode()
+        value = self.define_internal_local()
+
+        self.visit(node.lex, scope)
+        self.register_instruction(nodes_cil.AssignNode(value, scope._return))
+        vresult = self.define_internal_local()
+
+        self.register_instruction(nodes_cil.EqualNode(vresult, value, void))
+        self.register_instruction(nodes_cil.ArgNode(vresult))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name("Bool"), vresult))
+        scope._return = vresult
+
 
     @visitor.when(nodes.ComplementNode)
     def visit(self, node, scope):
-        pass
+        vname = self.define_internal_local()
+        value = self.define_internal_local()
+        instance = self.define_internal_local()
+
+        self.visit(node.lex, scope)
+        self.register_instruction(nodes_cil.GetAttrNode(value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.ComplementNode(vname, value))
+        self.register_instruction(nodes_cil.ArgNode(vname))
+        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        scope._return = instance
 
 
     @visitor.when(nodes.PlusNode)
@@ -333,7 +412,7 @@ def visit(self, node, scope):
 
         self.register_instruction(nodes_cil.DivNode(vname, left_value, right_value))
         instance = self.define_internal_local()
-        
+
         self.register_instruction(nodes_cil.ArgNode(vname))
         self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
         scope._return = instance

From f8d1fe3b3f7e9be2df624fd50ea781c14d0d9938 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 21:34:35 -0800
Subject: [PATCH 67/83] call node to cil

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 21 +++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 262cdfdca..4522da024 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -130,7 +130,26 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.CallNode)
     def visit(self, node, scope):
-        pass
+        if node.obj == None and node.type == None:
+            args = []
+            for arg in node.args:
+                vname = self.register_local(VariableInfo(f'{node.id}_arg', None), id=True)
+                self.visit(arg, scope)
+                self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
+                args.append(nodes_cil.ArgNode(vname))
+            result = self.register_local(VariableInfo(f'return_value_of_{node.id}', None), id=True)
+
+            self.register_instruction(nodes_cil.ArgNode(self.vself.name))
+            for arg in args:
+                self.register_instruction(arg)
+            
+            type_of_node = self.register_local(VariableInfo(f'{self.vself.name}_type', None))
+            self.register_instruction(nodes_cil.TypeOfNode(self.vself.name, type_of_node))
+            self.register_instruction(nodes_cil.DynamicCallNode(type_of_node, node.id, result, self.current_type.name))
+            scope._return = result
+
+        else:
+            pass
 
 
     @visitor.when(nodes.IfThenElseNode)

From 2d03d23e2c84af8a2177ad371e1ea43e7ebc0d6e Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 22:38:24 -0800
Subject: [PATCH 68/83] cool to cil

---
 src/main.py                                  |   2 +-
 src/utils/code_generation/cil/COOL_to_CIL.py | 122 +++++++++++++++++--
 src/utils/semantic_check/type_checker.py     |   1 +
 3 files changed, 111 insertions(+), 14 deletions(-)

diff --git a/src/main.py b/src/main.py
index 1253c3984..2f244acb5 100644
--- a/src/main.py
+++ b/src/main.py
@@ -13,7 +13,7 @@
 from utils.code_generation.cil.print_CIL_AST import get_formatter
 
 if __name__ == "__main__":
-    add = "codegen/arith.cl"
+    add = "codegen/graph.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 4522da024..7c8dd1d3a 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -1,5 +1,5 @@
 import cmp.visitor as visitor
-from cmp.semantic import VariableInfo
+from cmp.semantic import SemanticError, VariableInfo
 from utils.ast.AST_Nodes import ast_nodes as nodes
 from utils.code_generation.cil.AST_CIL import cil_ast as nodes_cil
 from utils.code_generation.cil.Base_COOL_to_CIL import BaseCOOLToCIL
@@ -109,19 +109,19 @@ def visit(self, node, scope):
         self.visit(node.expr, scope)
 
         try:
-            self.current_type.get_attribute(node.id)
+            self.current_type.get_attribute(node.id, None)
             self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, scope._return, self.current_type.name))
         
-        except AttributeError:
+        except SemanticError:
             vname = None
-            param_names = [pn.name for pn in self.current_function.params]
+            param_names = [pn.id for pn in self.current_function.params]
             if node.id in param_names:
                 for n in param_names:
                     if node.id in n.split("_"):
                         vname = n
                         break
             else:
-                for n in [lv.name for lv in self.current_function.localvars]:
+                for n in [lv.id for lv in self.current_function.localvars]:
                     if node.id in n.split("_"):
                         vname = n
                         break
@@ -149,7 +149,40 @@ def visit(self, node, scope):
             scope._return = result
 
         else:
-            pass
+            args = []
+            for arg in node.args:
+                vname = self.register_local(VariableInfo(f'{node.id}_arg', None), id=True)
+                self.visit(arg, scope)
+                self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
+                args.append(nodes_cil.ArgNode(vname))
+
+            result = self.register_local(VariableInfo(f'return_value_of_{node.id}', None), id=True)
+            
+            vobj = self.define_internal_local()
+            self.visit(node.obj, scope)
+            self.register_instruction(nodes_cil.AssignNode(vobj, scope._return))
+
+            void = nodes_cil.VoidNode()
+            equal_result = self.define_internal_local()
+            self.register_instruction(nodes_cil.EqualNode(equal_result, vobj, void))
+
+            self.register_runtime_error(equal_result, f'({node.line},{node.column}) - RuntimeError: Dispatch on void\n')
+            
+            self.register_instruction(nodes_cil.ArgNode(vobj))
+            for arg in args:
+                self.register_instruction(arg)
+
+            if node.type:
+                self.register_instruction(nodes_cil.StaticCallNode(self.to_function_name(node.id, node.type), result))
+            else:
+                type_of_node = self.register_local(VariableInfo(f'{node.id}_type', None), id=True)
+                self.register_instruction(nodes_cil.TypeOfNode(vobj, type_of_node))
+                typex = node.obj.computed_type
+                if typex.name == 'SELF_TYPE':
+                    typex = self.current_type
+                self.register_instruction(nodes_cil.DynamicCallNode(type_of_node, node.id, result, typex.name))
+
+            scope._return = result
 
 
     @visitor.when(nodes.IfThenElseNode)
@@ -204,8 +237,8 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.BlockNode)
     def visit(self, node, scope):
-        for expr in node.exprs:
-            self.visit(node.expr_list, scope)
+        for expr in node.expr_list:
+            self.visit(expr, scope)
 
     
     @visitor.when(nodes.LetNode)
@@ -221,7 +254,7 @@ def visit(self, node, scope):
             if id_expr:
                 self.visit(id_expr, scope)
                 self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
-            elif typex in self.value_types:
+            elif typex in ['String','Int','Bool']:
                 self.register_instruction(nodes_cil.AllocateNode(typex, vname))
 
         self.visit(node.in_expr, scope)
@@ -231,7 +264,70 @@ def visit(self, node, scope):
 
     @visitor.when(nodes.CaseNode)
     def visit(self, node, scope):
-        pass
+        _condition  = self.register_local(VariableInfo('equal_value', None))
+        _type  = self.register_local(VariableInfo('typeName_value', None))
+        _expr  = self.register_local(VariableInfo('case_expr_value', None))
+        vresult   = self.register_local(VariableInfo('case_value', None))
+
+        self.visit(node.predicate, scope)
+        self.register_instruction(nodes_cil.AssignNode(_expr, scope._return))
+        self.register_instruction(nodes_cil.TypeNameNode(_type, scope._return))
+
+        void = nodes_cil.VoidNode()
+        equal_result = self.define_internal_local()
+        self.register_instruction(nodes_cil.EqualNode(equal_result, _expr, void))
+
+        self.register_runtime_error(equal_result,  f'({node.line},{node.column}) - RuntimeError: Case on void\n')
+
+        end_label = self.register_label('end_label')
+        labels = []
+
+        order = []
+        for branch in node.branches:
+            (_,typex,_) = branch
+            count = 0
+            t1 = self.context.get_type(typex)
+
+            for other_branch in node.branches:
+                (_,other_typex,_) = other_branch
+                t2 = self.context.get_type(other_typex)
+                count += t2.conforms_to(t1)
+
+            order.append((count, branch))
+        order.sort(key=lambda x: x[0])
+
+        for i, (_, branch) in enumerate(order):
+            (_,typex,_) = branch
+            labels.append(self.register_label(f'{i}_label'))
+            h = {x.name for x in self.context.types.values() if x.name != 'AUTO_TYPE' and 
+                            x.conforms_to(self.context.get_type(typex))} if typex != 'Object' else None
+            if not h:
+                self.register_instruction(nodes_cil.GotoNode(labels[-1].label))
+                break
+            h.add(typex)
+            for t in h:
+                vbranch_type_name = self.register_local(VariableInfo('branch_type_name', None))
+                self.register_instruction(nodes_cil.NameNode(vbranch_type_name, t))
+                self.register_instruction(nodes_cil.EqualNode(_condition, _type, vbranch_type_name))
+                self.register_instruction(nodes_cil.IfGotoNode(_condition, labels[-1].label))
+
+        (line,column) = node.branchesPos[i]
+        data_node = self.register_data(f'({line},{column}) - RuntimeError: Execution of a case statement without a matching branch\n')
+        self.register_instruction(nodes_cil.ErrorNode(data_node))
+
+        for i, l in enumerate(labels):
+            self.register_instruction(l)
+
+            (idx, typex, expr) = order[i][1]
+            vid = self.register_local(VariableInfo(idx, None), id=True)
+            self.register_instruction(nodes_cil.AssignNode(vid, _expr))
+
+            self.visit(expr, scope)
+            self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
+            self.register_instruction(nodes_cil.GotoNode(end_label.label))
+
+        scope._return = vresult
+        self.register_instruction(end_label)
 
     
     @visitor.when(nodes.NotNode)
@@ -290,13 +386,13 @@ def visit(self, node, scope):
     @visitor.when(nodes.VariableNode)
     def visit(self, node, scope):
         try:
-            self.current_type.get_attribute(node.lex)
+            self.current_type.get_attribute(node.lex, None)
             attr = self.register_local(VariableInfo(node.lex, None), id=True)
             self.register_instruction(nodes_cil.GetAttrNode(attr, self.vself.name, node.lex, self.current_type.name))
             scope._return = attr
 
-        except AttributeError:
-            param_names = [pn.name for pn in self.current_function.params]
+        except SemanticError:
+            param_names = [pn.id for pn in self.current_function.params]
             if node.lex in param_names:
                 for n in param_names:
                     if node.lex == n:
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 7801a937c..bc5d32857 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -198,6 +198,7 @@ def visit(self, node, scope):
             obj_type = self.current_type
         else:
             obj_type = self.visit(node.obj, scope)
+            node.obj.computed_type = obj_type
 
         if node.type is not None:
             if node.type == 'SELF_TYPE':

From c114563dced1fc24449453781256e9ce9603efeb Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sun, 20 Feb 2022 22:41:32 -0800
Subject: [PATCH 69/83] fixing some issues

---
 src/utils/code_generation/cil/COOL_to_CIL.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 7c8dd1d3a..140146854 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -299,8 +299,7 @@ def visit(self, node, scope):
         for i, (_, branch) in enumerate(order):
             (_,typex,_) = branch
             labels.append(self.register_label(f'{i}_label'))
-            h = {x.name for x in self.context.types.values() if x.name != 'AUTO_TYPE' and 
-                            x.conforms_to(self.context.get_type(typex))} if typex != 'Object' else None
+            h = {x.name for x in self.context.types.values() if x.conforms_to(self.context.get_type(typex))} if typex != 'Object' else None
             if not h:
                 self.register_instruction(nodes_cil.GotoNode(labels[-1].label))
                 break

From f99bcd8135d910ec1f89bb77736c2f2cec3e7869 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 21 Feb 2022 17:38:15 -0800
Subject: [PATCH 70/83] modifying code to generate cil

---
 src/main.py                              | 13 +++++++++++--
 src/utils/ast/AST_Nodes.py               |  2 +-
 src/utils/code_generation/cil/AST_CIL.py |  2 +-
 src/utils/semantic_check/type_builder.py |  1 +
 src/utils/semantic_check/type_checker.py |  2 +-
 5 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/main.py b/src/main.py
index 2f244acb5..076cfd445 100644
--- a/src/main.py
+++ b/src/main.py
@@ -3,6 +3,8 @@
 from pathlib import Path
 from utils.COOL_Grammar import build_COOL_Grammar
 from utils.COOL_Lexer import COOL_Lexer
+from utils.code_generation.mips.CIL_to_MIPS import CILToMIPS
+from utils.code_generation.mips.print_MIPS_AST import PrintMIPS
 from utils.parser.COOL_parser import COOL_Parser
 from cmp.evaluation import evaluate_reverse_parse
 from cmp.semantic import Context
@@ -13,7 +15,7 @@
 from utils.code_generation.cil.print_CIL_AST import get_formatter
 
 if __name__ == "__main__":
-    add = "codegen/graph.cl"
+    add = "lexer/mixed1.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
@@ -68,4 +70,11 @@
 cil_visitor = COOLtoCIL(context)
 cil_ast = cil_visitor.visit(ast, scope)
 
-print(get_formatter()(cil_ast))
\ No newline at end of file
+print(get_formatter()(cil_ast))
+
+mips_visitor = CILToMIPS()
+mips_ast = mips_visitor.visit(cil_ast)
+
+print_mips = PrintMIPS()
+mips = print_mips.visit(mips_ast)
+print(mips)
\ No newline at end of file
diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index 41f76e6a3..9678c3939 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -58,7 +58,7 @@ def __init__(self, token, expr, token_pos):
     class CallNode(ExpressionNode):
         def __init__(self, token, args, obj = None, typex = None):
             self.obj = obj.lex if isinstance(obj, Token) else obj
-            self.type = typex
+            self.type = typex.lex if typex else typex
             self.id = token.lex
             self.line = obj.line if obj else token.line
             self.column = obj.column if obj else token.column
diff --git a/src/utils/code_generation/cil/AST_CIL.py b/src/utils/code_generation/cil/AST_CIL.py
index 24f439d6b..446efe0cb 100644
--- a/src/utils/code_generation/cil/AST_CIL.py
+++ b/src/utils/code_generation/cil/AST_CIL.py
@@ -91,7 +91,7 @@ def __init__(self, idx, attr, value, computed_type):
             self.computed_type = computed_type
 
     class AllocateNode(InstructionNode):
-        def __init__(self, dest, typex):
+        def __init__(self, typex, dest):
             self.dest = dest
             self.type = typex
 
diff --git a/src/utils/semantic_check/type_builder.py b/src/utils/semantic_check/type_builder.py
index 02e49e936..d480a92cc 100644
--- a/src/utils/semantic_check/type_builder.py
+++ b/src/utils/semantic_check/type_builder.py
@@ -51,6 +51,7 @@ def visit(self,node):
 
         elif not self.current_type.parent:
             self.current_type.set_parent(self.context.get_type('Object'))
+            node.parent = 'Object'
         
         for feat in node.features:
             self.visit(feat)
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index bc5d32857..6ce52c263 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -207,7 +207,7 @@ def visit(self, node, scope):
 
             else:
                 try:
-                    typex = self.context.get_type(node.type.lex)
+                    typex = self.context.get_type(node.type)
                 except SemanticError as se:
                     self.errors.append(se.text)
                     typex = ErrorType()

From b73b34c74a42493a542686f8857407727200d055 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Mon, 21 Feb 2022 17:41:24 -0800
Subject: [PATCH 71/83] fixing main

---
 src/main.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/main.py b/src/main.py
index 076cfd445..5fdd5621d 100644
--- a/src/main.py
+++ b/src/main.py
@@ -3,8 +3,8 @@
 from pathlib import Path
 from utils.COOL_Grammar import build_COOL_Grammar
 from utils.COOL_Lexer import COOL_Lexer
-from utils.code_generation.mips.CIL_to_MIPS import CILToMIPS
-from utils.code_generation.mips.print_MIPS_AST import PrintMIPS
+# from utils.code_generation.mips.CIL_to_MIPS import CILToMIPS
+# from utils.code_generation.mips.print_MIPS_AST import PrintMIPS
 from utils.parser.COOL_parser import COOL_Parser
 from cmp.evaluation import evaluate_reverse_parse
 from cmp.semantic import Context
@@ -72,9 +72,9 @@
 
 print(get_formatter()(cil_ast))
 
-mips_visitor = CILToMIPS()
-mips_ast = mips_visitor.visit(cil_ast)
+# mips_visitor = CILToMIPS()
+# mips_ast = mips_visitor.visit(cil_ast)
 
-print_mips = PrintMIPS()
-mips = print_mips.visit(mips_ast)
-print(mips)
\ No newline at end of file
+# print_mips = PrintMIPS()
+# mips = print_mips.visit(mips_ast)
+# print(mips)
\ No newline at end of file

From a68e4bec314b01021bdfa5a00f58341a9e31902a Mon Sep 17 00:00:00 2001
From: darian10 <dariandominguezalayon@gmail.com>
Date: Wed, 23 Feb 2022 16:00:08 -0500
Subject: [PATCH 72/83] Adding instruction to code_generation

---
 src/utils/COOL_Lexer.py                  | 206 ++++++++++++-----------
 src/utils/ast/AST_Nodes.py               |  54 +++---
 src/utils/semantic_check/type_checker.py | 193 +++++++++++----------
 3 files changed, 244 insertions(+), 209 deletions(-)

diff --git a/src/utils/COOL_Lexer.py b/src/utils/COOL_Lexer.py
index 7f7f4e860..8aabc5f11 100644
--- a/src/utils/COOL_Lexer.py
+++ b/src/utils/COOL_Lexer.py
@@ -3,24 +3,29 @@
 '''
 Recibe como parametros el lexema, tipo, linea y columna donde se encuentra
 '''
+
+
 class Token:
- 
-    def __init__(self, lex, ttype, line, column): 
-        
-        self.lex = lex 
+
+    def __init__(self, lex, ttype, line, column):
+
+        self.lex = lex
         self.token_type = ttype
         self.line = line
         self.column = column
         self.next_token = None
- 
-    def __str__(self): 
+
+    def __str__(self):
         return f'({self.line}, {self.column}) - {self.token_type}: {self.lex}'
- 
+
+
 '''
 El lexer es el resultado de la union de todas las expresiones regulares que forman
 el lenguaje
 '''
-class Lexer: 
+
+
+class Lexer:
 
     def __init__(self, table, keywords, ignored_tokens, tokens_toFix, eof):
         self.line = 1
@@ -32,23 +37,26 @@ def __init__(self, table, keywords, ignored_tokens, tokens_toFix, eof):
         self.regex = self._build_regex(table)
         self.errors = []
         self.eof = eof
- 
-    def tokenize(self,text):    
+
+    def tokenize(self, text):
         while len(text) > 0:
 
             match = self.regex.match(text)
             error_token = ''
- 
+
             while not match:
                 error_token += text[0]
                 text = text[1:]
-                if len(text) <= 0: break
+                if len(text) <= 0:
+                    break
                 match = self.regex.match(text)
 
             if error_token:
-                self.errors.append(f'({self.line}, {self.column + 1}) - LexicographicError: ERROR "{error_token}"')
+                self.errors.append(
+                    f'({self.line}, {self.column + 1}) - LexicographicError: ERROR "{error_token}"')
                 self.column += len(error_token)
-                if len(text) <= 0: continue
+                if len(text) <= 0:
+                    continue
 
             lexeme = match.group()
             self.column += len(lexeme) if lexeme != '\t' else 4
@@ -80,7 +88,8 @@ def tokenize(self,text):
                             break
 
                 else:
-                    self.errors.append(f'({self.line}, {self.column + 1}) - LexicographicError: EOF in comment')
+                    self.errors.append(
+                        f'({self.line}, {self.column + 1}) - LexicographicError: EOF in comment')
 
             # STRINGS
             elif lexeme == '"':
@@ -97,123 +106,128 @@ def tokenize(self,text):
                             self.column = 0
 
                         elif text[0] == 'b':
-                            lexeme += '\\b'
+                            lexeme += '\b'
 
                         elif text[0] == 't':
-                            lexeme += '\\t'
+                            lexeme += '\t'
 
                         elif text[0] == 'n':
-                            lexeme += '\\n'
+                            lexeme += '\n'
 
                         elif text[0] == 'f':
-                            lexeme += '\\f'
-                        
+                            lexeme += '\f'
+
                         else:
                             lexeme += text[0]
 
                         text = text[1:]
                         self.column += 1
-                    
+
                     elif c == '\n':
-                        self.errors.append(f'({self.line}, {self.column}) - LexicographicError: Unterminated string constant')
+                        self.errors.append(
+                            f'({self.line}, {self.column}) - LexicographicError: Unterminated string constant')
                         self.line += 1
                         self.column = 0
                         break
-                    
+
                     elif c == '\0':
-                        self.errors.append(f'({self.line}, {self.column}) - LexicographicError: String contains null character')
-                    
+                        self.errors.append(
+                            f'({self.line}, {self.column}) - LexicographicError: String contains null character')
+
                     else:
                         lexeme += c
                         if c == '"':
                             break
-                
-                else:
-                    self.errors.append(f'({self.line}, {self.column}) - LexicographicError: EOF in string constant')
-
 
+                else:
+                    self.errors.append(
+                        f'({self.line}, {self.column}) - LexicographicError: EOF in string constant')
 
-            token_type = match.lastgroup if lexeme.lower() not in self.keywords and match.lastgroup is not None else match.group().lower()
+            token_type = match.lastgroup if lexeme.lower(
+            ) not in self.keywords and match.lastgroup is not None else match.group().lower()
 
             yield lexeme, token_type, self.line, self.column - len(lexeme) + 1
- 
-            text = text[match.end():] if lexeme[:2] != '(*' and lexeme[0] != '"' else text
+
+            text = text[match.end(
+            ):] if lexeme[:2] != '(*' and lexeme[0] != '"' else text
 
         yield '$', self.eof, 0, 0
- 
-    def _build_regex(sef,table):
-        return re.compile('|'.join([f'(?P<{name}>{regex})' if name != regex else f'({name})' for name,regex in table.items()]))
-    
-    def __call__(self, text): 
+
+    def _build_regex(sef, table):
+        return re.compile('|'.join([f'(?P<{name}>{regex})' if name != regex else f'({name})' for name, regex in table.items()]))
+
+    def __call__(self, text):
         return [Token(lex, ttype, line, column) for lex, ttype, line, column in self.tokenize(text) if ttype not in self.ignored_tokens]
 
     def fixed_tokens(self, tokens):
         for i, token in enumerate(tokens[:(len(tokens) - 1)]):
-                token.next_token = tokens[i+1]
+            token.next_token = tokens[i+1]
         return tokens
 
 
-    
-
 '''
 Esta clase guarda las propiedades sintacticas de COOL
 '''
+
+
 class COOL_Lexer(Lexer):
     def __init__(self):
         self.regexs = {
-        'id'        : r'[a-z][a-zA-Z0-9_]*'         ,
-        'type'      : r'[A-Z][a-zA-Z0-9_]*'         ,
-        'string'    : r'\"'                         ,
-        'int'       : r'\d+'                         ,
-        'comment'   : r'(\(\*)|--.*'                ,
-        'newline'   : r'\n'                         ,
-        'whitespace': r' +'                         ,
-        'tabulation': r'\t'                         ,
-        'inherits'  : r'inherits'                   ,
-        'isvoid'    : r'isvoid'                     ,
-        'class'     : r'class'                      ,
-        'while'     : r'while'                      , 
-        'false'     : r'false'                      , 
-        'then'      : r'then'                       , 
-        'else'      : r'else'                       , 
-        'loop'      : r'loop'                       ,
-        'pool'      : r'pool'                       , 
-        'case'      : r'case'                       , 
-        'esac'      : r'esac'                       ,
-        'true'      : r'true'                       , 
-        '<\-'       : r'<\-'                        ,
-        'let'       : r'let'                        , 
-        'new'       : r'new'                        ,
-        'not'       : r'not'                        ,
-        '\{'        : r'\{'                         ,
-        '\}'        : r'\}'                         ,
-        '\('        : r'\('                         ,
-        '\)'        : r'\)'                         ,
-        '\.'        : r'\.'                         , 
-        '=>'        : r'=>'                         ,
-        'if'        : r'if'                         ,
-        'fi'        : r'fi'                         , 
-        'in'        : r'in'                         ,
-        'of'        : r'of'                         , 
-        '\+'        : r'\+'                         , 
-        '\-'        : r'\-'                         , 
-        '\*'        : r'\*'                         , 
-        '<='        : r'<='                         , 
-        '\~'        : r'\~'                         ,
-        ','         : r','                          , 
-        ':'         : r':'                          , 
-        ';'         : r';'                          , 
-        '@'         : r'@'                          ,
-        '/'         : r'/'                          , 
-        '<'         : r'<'                          , 
-        '='         : r'='                          }
-
-        self.keywords = ['inherits','isvoid','class','while','false','then','else','loop',
-        'pool','case','esac','true','let','new','not','if','fi','in','of']
-
-        self.ignored_tokens = ['newline','whitespace','tabulation','comment']
-
-        self.tokens_toFix = ['inherits','isvoid','class','while','then','else','loop','case',
-        'let','new','not','if','in','of', '<-']
-
-        Lexer.__init__(self, self.regexs, self.keywords, self.ignored_tokens, self.tokens_toFix, 'eof')
\ No newline at end of file
+            'id': r'[a-z][a-zA-Z0-9_]*',
+            'type': r'[A-Z][a-zA-Z0-9_]*',
+            'string': r'\"',
+            'int': r'\d+',
+            'comment': r'(\(\*)|--.*',
+            'newline': r'\n',
+            'whitespace': r' +',
+            'tabulation': r'\t',
+            'inherits': r'inherits',
+            'isvoid': r'isvoid',
+            'class': r'class',
+            'while': r'while',
+            'false': r'false',
+            'then': r'then',
+            'else': r'else',
+            'loop': r'loop',
+            'pool': r'pool',
+            'case': r'case',
+            'esac': r'esac',
+            'true': r'true',
+            '<\-': r'<\-',
+            'let': r'let',
+            'new': r'new',
+            'not': r'not',
+            '\{': r'\{',
+            '\}': r'\}',
+            '\(': r'\(',
+            '\)': r'\)',
+            '\.': r'\.',
+            '=>': r'=>',
+            'if': r'if',
+            'fi': r'fi',
+            'in': r'in',
+            'of': r'of',
+            '\+': r'\+',
+            '\-': r'\-',
+            '\*': r'\*',
+            '<=': r'<=',
+            '\~': r'\~',
+            ',': r',',
+            ':': r':',
+            ';': r';',
+            '@': r'@',
+            '/': r'/',
+            '<': r'<',
+            '=': r'='}
+
+        self.keywords = ['inherits', 'isvoid', 'class', 'while', 'false', 'then', 'else', 'loop',
+                         'pool', 'case', 'esac', 'true', 'let', 'new', 'not', 'if', 'fi', 'in', 'of']
+
+        self.ignored_tokens = ['newline',
+                               'whitespace', 'tabulation', 'comment']
+
+        self.tokens_toFix = ['inherits', 'isvoid', 'class', 'while', 'then', 'else', 'loop', 'case',
+                             'let', 'new', 'not', 'if', 'in', 'of', '<-']
+
+        Lexer.__init__(self, self.regexs, self.keywords,
+                       self.ignored_tokens, self.tokens_toFix, 'eof')
diff --git a/src/utils/ast/AST_Nodes.py b/src/utils/ast/AST_Nodes.py
index 9678c3939..bdc6d1925 100644
--- a/src/utils/ast/AST_Nodes.py
+++ b/src/utils/ast/AST_Nodes.py
@@ -7,17 +7,16 @@ class Node:
         line = 0
         column = 0
 
-
     class ProgramNode(Node):
         def __init__(self, declarations):
             self.declarations = declarations
 
     class DeclarationNode(Node):
         pass
+
     class ExpressionNode(Node):
         pass
 
-
     class ClassDeclarationNode(DeclarationNode):
         def __init__(self, idx, features, token, parent=None):
             self.id = idx.lex
@@ -36,12 +35,13 @@ def __init__(self, idx, params, return_type, body, ocurToken):
             self.column = idx.column
             self.body_line = ocurToken.next_token.line
             self.body_column = ocurToken.next_token.column
-            self.params = [[item.lex if isinstance(item, Token) else item for item in _list] for _list in params]
+            self.params = [[item.lex if isinstance(
+                item, Token) else item for item in _list] for _list in params]
             self.type = return_type.lex
             self.body = body
 
     class AttrDeclarationNode(DeclarationNode):
-        def __init__(self, idx, typex, arrowToken = None, expr = None):
+        def __init__(self, idx, typex, arrowToken=None, expr=None):
             self.id = idx.lex
             self.line = arrowToken.next_token.line if expr else typex.line
             self.column = arrowToken.next_token.column if expr else typex.column
@@ -56,22 +56,22 @@ def __init__(self, token, expr, token_pos):
             self.expr = expr
 
     class CallNode(ExpressionNode):
-        def __init__(self, token, args, obj = None, typex = None):
+        def __init__(self, token, args, obj=None, typex=None):
             self.obj = obj.lex if isinstance(obj, Token) else obj
             self.type = typex.lex if typex else typex
             self.id = token.lex
             self.line = obj.line if obj else token.line
             self.column = obj.column if obj else token.column
             self.args = args
-    
+
     class IfThenElseNode(ExpressionNode):
-        def __init__(self, if_expr, then_expr, else_expr,token):
+        def __init__(self, if_expr, then_expr, else_expr, token):
             self.if_expr = if_expr
             self.then_expr = then_expr
             self.else_expr = else_expr
             self.line = token.next_token.line
             self.column = token.next_token.column
-    
+
     class WhileNode(ExpressionNode):
         def __init__(self, conditional_expr, loop_expr, token):
             self.conditional_expr = conditional_expr
@@ -84,10 +84,11 @@ def __init__(self, expr_list, token):
             self.expr_list = expr_list
             self.line = token.line
             self.column = token.column
-    
+
     class LetNode(ExpressionNode):
         def __init__(self, identifiers, in_expr, token):
-            self.identifiers = [tuple([item.lex if isinstance(item, Token) else item for item in _list]) for _list in identifiers]
+            self.identifiers = [tuple([item.lex if isinstance(
+                item, Token) else item for item in _list]) for _list in identifiers]
             self.in_expr = in_expr
             self.line = token.line
             self.column = token.column
@@ -98,12 +99,13 @@ def __init__(self, predicate, branches, token):
             self.branches = []
             self.branchesPos = []
             for branch in branches:
-                self.branches.append(tuple([item.lex if isinstance(item, Token) else item for item in branch]))
-                _,typex,_ = branch
-                self.branchesPos.append((typex.line,typex.column))
+                self.branches.append(
+                    tuple([item.lex if isinstance(item, Token) else item for item in branch]))
+                _, typex, _ = branch
+                self.branchesPos.append((typex.line, typex.column))
             self.line = token.line
             self.column = token.column
-    
+
     class NotNode(ExpressionNode):
         def __init__(self, expr, token):
             self.expr = expr
@@ -121,42 +123,54 @@ def __init__(self, left, right, token):
             self.left = left
             self.right = right
             self.line = token.line
-            self.column = token.column 
-
+            self.column = token.column
 
     class ConstantNumNode(AtomicNode):
         pass
+
     class ConstantBoolNode(AtomicNode):
         pass
+
     class ConstantStringNode(AtomicNode):
-        pass
+        def __init__(self, expr):
+            expr.lex = expr.lex[1:-1]
+            super().__init__(expr)
+
     class VariableNode(AtomicNode):
         pass
+
     class InstantiateNode(AtomicNode):
         def __init__(self, typex, token):
-            self.lex =  typex.lex
+            self.lex = typex.lex
             self.line = token.next_token.line
             self.column = token.next_token.column
+
     class IsVoidNode(AtomicNode):
         pass
+
     class ComplementNode(AtomicNode):
         def __init__(self, expr, token):
             self.lex = expr.lex if isinstance(expr, Token) else expr
             self.line = token.next_token.line
             self.column = token.next_token.column
 
-
     class PlusNode(BinaryNode):
         pass
+
     class MinusNode(BinaryNode):
         pass
+
     class StarNode(BinaryNode):
         pass
+
     class DivNode(BinaryNode):
         pass
+
     class LessThanNode(BinaryNode):
         pass
+
     class LessEqualNode(BinaryNode):
         pass
+
     class EqualNode(BinaryNode):
-        pass
\ No newline at end of file
+        pass
diff --git a/src/utils/semantic_check/type_checker.py b/src/utils/semantic_check/type_checker.py
index 6ce52c263..dd57367e9 100644
--- a/src/utils/semantic_check/type_checker.py
+++ b/src/utils/semantic_check/type_checker.py
@@ -35,7 +35,6 @@
 UNDEFINED_METHOD = '(%s, %s) - AttributeError: Dispatch to undefined method %s. '
 
 
-
 class TypeChecker:
     def __init__(self, context, errors):
         self.context = context
@@ -47,28 +46,26 @@ def __init__(self, context, errors):
     def visit(self, node, scope):
         pass
 
-
     @visitor.when(nodes.ProgramNode)
     def visit(self, node, scope=None):
         # verificando que el programa tenga una clase Main
         try:
             self.context.get_type('Main')
-            
-        except SemanticError:
-                self.errors.append(MAIN_DONT_EXISTS)
 
+        except SemanticError:
+            self.errors.append(MAIN_DONT_EXISTS)
 
         scope = Scope() if scope == None else scope
 
         for dec in node.declarations:
             self.visit(dec, scope.create_child())
-        
+
         return scope
-    
 
     @visitor.when(nodes.ClassDeclarationNode)
     def visit(self, node, scope):
         self.current_type = self.context.get_type(node.id)
+        scope.define_variable('self', self.current_type)
 
         # verificando la existencia del metodo main
         if self.current_type.name == 'Main':
@@ -76,16 +73,16 @@ def visit(self, node, scope):
                 self.current_type.get_method('main')
 
             except SemanticError:
-                self.errors.append(MAIN_METHOD_DONT_EXISTS % (node.line, node.column))
-
-
+                self.errors.append(MAIN_METHOD_DONT_EXISTS %
+                                   (node.line, node.column))
 
         # verficando herencia circular en los ancestros de current_type (deben llegar a object sin pasar por el nuevamente)
         current_parent = self.current_type.parent
 
         while current_parent != self.context.get_type('Object') and current_parent != None:
             if current_parent == self.current_type:
-                self.errors.append(INHERIT_ERROR % (self.current_type.child.line, self.current_type.child.column, self.current_type.child.name, self.current_type.child.name))
+                self.errors.append(INHERIT_ERROR % (self.current_type.child.line, self.current_type.child.column,
+                                   self.current_type.child.name, self.current_type.child.name))
                 self.current_type.parent = ErrorType()
                 break
 
@@ -93,12 +90,14 @@ def visit(self, node, scope):
                 scope.define_variable(attr.name, attr.type)
 
             current_parent = current_parent.parent
-        
-        attrs = [feat for feat in node.features if isinstance(feat, nodes.AttrDeclarationNode)]
+
+        attrs = [feat for feat in node.features if isinstance(
+            feat, nodes.AttrDeclarationNode)]
         for attr in attrs:
             self.visit(attr, scope)
 
-        meths = [feat for feat in node.features if isinstance(feat, nodes.MethDeclarationNode)]
+        meths = [feat for feat in node.features if isinstance(
+            feat, nodes.MethDeclarationNode)]
         for meth in meths:
             self.visit(meth, scope.create_child())
 
@@ -107,7 +106,8 @@ def visit(self, node, scope):
     @visitor.when(nodes.AttrDeclarationNode)
     def visit(self, node, scope):
         try:
-            attr_type = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
+            attr_type = self.context.get_type(
+                node.type) if node.type != 'SELF_TYPE' else self.current_type
         except SemanticError:
             attr_type = ErrorType()
 
@@ -118,14 +118,12 @@ def visit(self, node, scope):
             type_expr = self.visit(node.expr, scope.create_child())
 
             if not type_expr.conforms_to(attr_type):
-                self.errors.append(INCOMPATIBLE_TYPES_ATTR % (node.line, node.column, type_expr.name, node.id, attr_type.name))
-
-        
+                self.errors.append(INCOMPATIBLE_TYPES_ATTR % (
+                    node.line, node.column, type_expr.name, node.id, attr_type.name))
 
         scope.define_variable(node.id, attr_type)
 
-        return 
-    
+        return
 
     @visitor.when(nodes.MethDeclarationNode)
     def visit(self, node, scope):
@@ -133,7 +131,8 @@ def visit(self, node, scope):
 
         # verificando que el metodo main no tenga parametros
         if self.current_method.name == 'main' and self.current_method.param_names:
-            self.errors.append(MAIN_METHOD_DONT_HAVE_PARAMS % (node.line, node.column))
+            self.errors.append(MAIN_METHOD_DONT_HAVE_PARAMS %
+                               (node.line, node.column))
 
         # verificabdo redefinicion de metodos
         current_parent = self.current_type.parent
@@ -142,38 +141,41 @@ def visit(self, node, scope):
             try:
                 parent_method = current_parent.get_method(node.id)
                 if parent_method != self.current_method:
-                    self.errors.append(WRONG_SIGNATURE % (node.line, node.column, self.current_method.name))
+                    self.errors.append(WRONG_SIGNATURE % (
+                        node.line, node.column, self.current_method.name))
                     break
             except:
                 pass
-            current_parent = current_parent.parent 
-
+            current_parent = current_parent.parent
 
         scope.define_variable('self', self.current_type)
 
         for name, typex in zip(self.current_method.param_names, self.current_method.param_types):
             if scope.is_local(name):
-                self.errors.append(LOCAL_ALREADY_DEFINED % (node.line, node.column, name,self.current_method.name))
+                self.errors.append(LOCAL_ALREADY_DEFINED % (
+                    node.line, node.column, name, self.current_method.name))
 
             elif typex == 'SELF_TYPE':
-                self.errors.append(SELF_TYPE_ERROR % (node.line, node.column, self.current_method.name))
+                self.errors.append(SELF_TYPE_ERROR % (
+                    node.line, node.column, self.current_method.name))
                 scope.define_variable(name, ErrorType())
 
             else:
                 scope.define_variable(name, self.context.get_type(typex.name))
-        
+
         body_type = self.visit(node.body, scope)
         try:
-            returnType = self.context.get_type(node.type) if node.type != 'SELF_TYPE' else self.current_type
+            returnType = self.context.get_type(
+                node.type) if node.type != 'SELF_TYPE' else self.current_type
         except SemanticError as se:
             returnType = ErrorType()
 
         if not body_type.conforms_to(returnType):
-            self.errors.append(INCOMPATIBLE_TYPES_METH % (node.body_line, node.body_column, body_type.name , node.id, returnType.name ))
+            self.errors.append(INCOMPATIBLE_TYPES_METH % (
+                node.body_line, node.body_column, body_type.name, node.id, returnType.name))
 
         return
 
-
     @visitor.when(nodes.AssignNode)
     def visit(self, node, scope):
         var = scope.find_variable(node.id)
@@ -181,17 +183,18 @@ def visit(self, node, scope):
         type_expr = self.visit(node.expr, scope.create_child())
 
         if var is None:
-            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.id))
+            self.errors.append(VARIABLE_NOT_DEFINED %
+                               (node.line, node.column, node.id))
 
         elif var.name == 'self':
             self.errors.append(SELF_IS_READONLY % (node.line, node.column))
 
         elif not type_expr.conforms_to(var.type):
-            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_expr.name, var.type.name))
+            self.errors.append(INCOMPATIBLE_TYPES % (
+                node.line, node.column, type_expr.name, var.type.name))
 
         return type_expr
 
-
     @visitor.when(nodes.CallNode)
     def visit(self, node, scope):
         if node.obj is None:
@@ -202,7 +205,8 @@ def visit(self, node, scope):
 
         if node.type is not None:
             if node.type == 'SELF_TYPE':
-                self.errors.append(SELF_TYPE_IN_DISPATCH % (node.line, node.column))
+                self.errors.append(SELF_TYPE_IN_DISPATCH %
+                                   (node.line, node.column))
                 typex = ErrorType()
 
             else:
@@ -213,53 +217,57 @@ def visit(self, node, scope):
                     typex = ErrorType()
 
                 if not obj_type.conforms_to(typex):
-                    self.errors.append(INCOMPATIBLE_TYPES_CALL % (node.line, node.column, obj_type.name, typex.name))
+                    self.errors.append(INCOMPATIBLE_TYPES_CALL % (
+                        node.line, node.column, obj_type.name, typex.name))
 
             obj_type = typex
 
         try:
             meth = obj_type.get_method(node.id)
         except SemanticError as se:
-            if se.text: self.errors.append(UNDEFINED_METHOD % (node.line, node.column, node.id))
+            if se.text:
+                self.errors.append(UNDEFINED_METHOD %
+                                   (node.line, node.column, node.id))
             for arg in node.args:
                 self.visit(arg, scope)
             return ErrorType()
-        
+
         if len(node.args) != len(meth.param_names):
-            self.errors.append(METHOD_PARAMETERS % (node.line, node.column, meth.name, obj_type.name, len(meth.param_names)))
+            self.errors.append(METHOD_PARAMETERS % (
+                node.line, node.column, meth.name, obj_type.name, len(meth.param_names)))
 
-        for i,arg in enumerate(node.args):
+        for i, arg in enumerate(node.args):
             type_arg = self.visit(arg, scope)
-            if i< len(meth.param_types) and not type_arg.conforms_to(meth.param_types[i]):
-                self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_arg.name, meth.param_types[i].name))
-        
-        return meth.return_type if meth.return_type.name != 'SELF_TYPE' else obj_type
+            if i < len(meth.param_types) and not type_arg.conforms_to(meth.param_types[i]):
+                self.errors.append(INCOMPATIBLE_TYPES % (
+                    node.line, node.column, type_arg.name, meth.param_types[i].name))
 
+        return meth.return_type if meth.return_type.name != 'SELF_TYPE' else obj_type
 
     @visitor.when(nodes.IfThenElseNode)
     def visit(self, node, scope):
         if_type = self.visit(node.if_expr, scope.create_child())
 
         if not if_type.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES_IF % (node.line, node.column,'if','Bool'))
-        
+            self.errors.append(INCOMPATIBLE_TYPES_IF %
+                               (node.line, node.column, 'if', 'Bool'))
+
         then_type = self.visit(node.then_expr, scope.create_child())
         else_type = self.visit(node.else_expr, scope.create_child())
 
         return then_type.join(else_type)
 
-
     @visitor.when(nodes.WhileNode)
     def visit(self, node, scope):
         type_conditional = self.visit(node.conditional_expr, scope)
 
         if not type_conditional.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES % (node.line, node.column, type_conditional.name, 'Bool'))
-        
+            self.errors.append(INCOMPATIBLE_TYPES % (
+                node.line, node.column, type_conditional.name, 'Bool'))
+
         self.visit(node.loop_expr, scope.create_child())
 
         return self.context.get_type('Object')
-    
 
     @visitor.when(nodes.BlockNode)
     def visit(self, node, scope):
@@ -270,143 +278,141 @@ def visit(self, node, scope):
 
         return type_expr
 
-    
     @visitor.when(nodes.LetNode)
     def visit(self, node, scope):
         for idx, typex, id_expr in node.identifiers:
             try:
-                id_type = self.context.get_type(typex) if typex != 'SELF_TYPE' else self.current_type
+                id_type = self.context.get_type(
+                    typex) if typex != 'SELF_TYPE' else self.current_type
             except SemanticError as se:
                 id_type = ErrorType()
-                self.errors.append(UNDEFINED_TYPE_LET % (node.line, node.column, typex, idx))
-            
+                self.errors.append(UNDEFINED_TYPE_LET %
+                                   (node.line, node.column, typex, idx))
+
             if idx == 'self':
                 self.errors.append(SELF_ERROR_LET % (node.line, node.column))
-            
+
             if scope.is_local(idx):
                 scope = scope.create_child()
                 scope.define_variable(idx, id_type)
             else:
                 scope.define_variable(idx, id_type)
-            
+
             if id_expr is not None:
                 id_expr_type = self.visit(id_expr, scope.create_child())
                 if not id_expr_type.conforms_to(id_type):
-                    self.errors.append(INCOMPATIBLE_TYPES_LET % (node.line, node.column, id_expr_type.name, idx, id_type.name))
-            
+                    self.errors.append(INCOMPATIBLE_TYPES_LET % (
+                        node.line, node.column, id_expr_type.name, idx, id_type.name))
+
         body_type = self.visit(node.in_expr, scope.create_child())
 
         return body_type
-            
 
     @visitor.when(nodes.CaseNode)
     def visit(self, node, scope):
         self.visit(node.predicate, scope)
         case_type = None
 
-        for i,branch in enumerate(node.branches):
+        for i, branch in enumerate(node.branches):
             (idx, typex, expr) = branch
-            (line,column) = node.branchesPos[i]
+            (line, column) = node.branchesPos[i]
             if typex in [b[1] for b in node.branches[:i]]:
                 self.errors.append(DUPLICATE_BRANCH % (line, column, typex))
             if typex == 'SELF_TYPE':
                 self.errors.append(SELF_TYPE_IN_CASE_BRANCH % (line, column))
                 id_type = ErrorType()
-                
+
             else:
                 try:
                     id_type = self.context.get_type(typex)
                 except SemanticError as se:
                     id_type = ErrorType()
-                    self.errors.append(UNDEFINED_TYPE_BRANCH % (line, column, typex))
-            
+                    self.errors.append(UNDEFINED_TYPE_BRANCH %
+                                       (line, column, typex))
+
             inner_scope = scope.create_child()
             inner_scope.define_variable(idx, id_type)
 
             type_expr = self.visit(expr, inner_scope)
-            case_type = case_type.join(type_expr) if case_type is not None else type_expr
+            case_type = case_type.join(
+                type_expr) if case_type is not None else type_expr
 
         return case_type
 
-    
     @visitor.when(nodes.NotNode)
     def visit(self, node, scope):
         typex = self.visit(node.expr, scope)
 
         if not typex.conforms_to(self.context.get_type('Bool')):
-            self.errors.append(INCOMPATIBLE_TYPES_ARG % (node.line, node.column, 'not' ,typex.name, 'Bool'))
+            self.errors.append(INCOMPATIBLE_TYPES_ARG % (
+                node.line, node.column, 'not', typex.name, 'Bool'))
             return ErrorType()
 
         return typex
 
-    
     @visitor.when(nodes.ConstantNumNode)
     def visit(self, node, scope):
         return self.context.get_type('Int')
 
-    
     @visitor.when(nodes.ConstantBoolNode)
     def visit(self, node, scope):
         return self.context.get_type('Bool')
 
-
     @visitor.when(nodes.ConstantStringNode)
     def visit(self, node, scope):
         return self.context.get_type('String')
 
-
     @visitor.when(nodes.VariableNode)
     def visit(self, node, scope):
         var = scope.find_variable(node.lex)
 
         if var is None:
-            self.errors.append(VARIABLE_NOT_DEFINED % (node.line, node.column, node.lex))
+            self.errors.append(VARIABLE_NOT_DEFINED %
+                               (node.line, node.column, node.lex))
             return ErrorType()
 
         return var.type
 
-    
     @visitor.when(nodes.InstantiateNode)
     def visit(self, node, scope):
         if node.lex == 'SELF_TYPE':
             return self.current_type
-        
+
         try:
             return self.context.get_type(node.lex)
         except SemanticError as se:
-            self.errors.append(UNDEFINED_TYPE_NEW % (node.line, node.column, node.lex))
+            self.errors.append(UNDEFINED_TYPE_NEW %
+                               (node.line, node.column, node.lex))
             return ErrorType()
 
-    
     @visitor.when(nodes.IsVoidNode)
     def visit(self, node, scope):
         self.visit(node.lex, scope)
         return self.context.get_type('Bool')
 
-
     @visitor.when(nodes.ComplementNode)
     def visit(self, node, scope):
         typex = self.visit(node.lex, scope)
 
         if not typex.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INCOMPATIBLE_TYPES_ARG % (node.line, node.column, '~' ,typex.name, 'Int'))
+            self.errors.append(INCOMPATIBLE_TYPES_ARG % (
+                node.line, node.column, '~', typex.name, 'Int'))
             return ErrorType()
 
         return typex
 
-
     @visitor.when(nodes.PlusNode)
     def visit(self, node, scope):
         type_left = self.visit(node.left, scope)
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '+', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '+', type_right.name))
             return ErrorType()
 
         else:
             return self.context.get_type('Int')
-    
 
     @visitor.when(nodes.MinusNode)
     def visit(self, node, scope):
@@ -414,38 +420,38 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '-', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '-', type_right.name))
             return ErrorType()
 
         else:
             return self.context.get_type('Int')
 
-    
     @visitor.when(nodes.StarNode)
     def visit(self, node, scope):
         type_left = self.visit(node.left, scope)
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '*', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '*', type_right.name))
             return ErrorType()
 
         else:
             return self.context.get_type('Int')
 
-
     @visitor.when(nodes.DivNode)
     def visit(self, node, scope):
         type_left = self.visit(node.left, scope)
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '/', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '/', type_right.name))
             return ErrorType()
 
         else:
             return self.context.get_type('Int')
-    
 
     @visitor.when(nodes.LessThanNode)
     def visit(self, node, scope):
@@ -453,25 +459,25 @@ def visit(self, node, scope):
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '<', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '<', type_right.name))
             return ErrorType()
 
         else:
             return self.context.get_type('Bool')
 
-    
     @visitor.when(nodes.LessEqualNode)
     def visit(self, node, scope):
         type_left = self.visit(node.left, scope)
         type_right = self.visit(node.right, scope)
 
         if not type_left.conforms_to(self.context.get_type('Int')) or not type_right.conforms_to(self.context.get_type('Int')):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '<=', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '<=', type_right.name))
             return ErrorType()
 
         else:
             return self.context.get_type('Bool')
-    
 
     @visitor.when(nodes.EqualNode)
     def visit(self, node, scope):
@@ -481,11 +487,12 @@ def visit(self, node, scope):
         int_type = self.context.get_type('Int')
         bool_type = self.context.get_type('Bool')
         string_type = self.context.get_type('String')
-        
+
         if type_left.name == 'AUTO_TYPE' or type_right.name == 'AUTO_TYPE':
             pass
         elif (type_left == int_type and not type_right.conforms_to(int_type)) or (type_right == int_type and not type_left.conforms_to(int_type)) or (type_left == bool_type and not type_right.conforms_to(bool_type)) or (type_right == bool_type and not type_left.conforms_to(bool_type)) or (type_left == string_type and not type_right.conforms_to(string_type)) or (type_right == string_type and not type_left.conforms_to(string_type)):
-            self.errors.append(INVALID_OPERATION % (node.line, node.column, type_left.name, '=', type_right.name))
+            self.errors.append(INVALID_OPERATION % (
+                node.line, node.column, type_left.name, '=', type_right.name))
             return ErrorType()
 
-        return bool_type
\ No newline at end of file
+        return bool_type

From 0b0e40a7a42fc7814c212abefaa220b150ac1a61 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Thu, 24 Feb 2022 16:57:38 -0800
Subject: [PATCH 73/83] files

---
 doc/Informe/files/SPIM_Manual.pdf              | Bin 0 -> 518753 bytes
 doc/Informe/files/compilers.pdf                | Bin 0 -> 864789 bytes
 doc/{ => Informe/files}/cool-manual.pdf        | Bin
 .../files}/github-git-cheat-sheet.pdf          | Bin
 4 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 doc/Informe/files/SPIM_Manual.pdf
 create mode 100644 doc/Informe/files/compilers.pdf
 rename doc/{ => Informe/files}/cool-manual.pdf (100%)
 rename doc/{ => Informe/files}/github-git-cheat-sheet.pdf (100%)

diff --git a/doc/Informe/files/SPIM_Manual.pdf b/doc/Informe/files/SPIM_Manual.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..b785613c8afa1a36aceadee59326205abd729b94
GIT binary patch
literal 518753
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%0ArJsqDsS-a(ycL6XYT2C5W?zBw0$M
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
P{mtL}=YROS&p-Qr<0tGq

literal 0
HcmV?d00001

diff --git a/doc/Informe/files/compilers.pdf b/doc/Informe/files/compilers.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..4f7c80494a473a21217b88fa90bbe6453c7e3d83
GIT binary patch
literal 864789
zcma&NV~lX!vbNi{ZQHhO+qP}H`)S*@ZQHhur)_`lKH2+ZeOWu_tof@l=SW5}W^!Lu
zb=M$O5D}wgq+^95onIbVhhidNAh0*Gg5u$UqF3>BFeRXuH?mT8v4x_SBVc4;fT9<(
zbaHkf;9%l_qL(qXGk38dU}R%sA^3lu|N3g<V(LUdFJ@!tVk%;4Y;R%;#m5Kb?BZl<
zXba`Bd99^uzr}{)`&zeetlbRT#~)BAkZQLRW<Z-+E$^pjOZt2|oO@k-(YIH?rCchy
z;9}EE53D7bTH-y&dzRSU4M&_zL4>goq9}@EIH-?!BOl~o3y~zEA(u{w<ep9{#XN|q
z7z@uquBA1Ix-fcRX@p9?jc5&un9LFC4(f<TE{XA2Y7j5k-dqoFoOn=uE-)AzgzGbs
z97O-NriBbCu{l5)YHgr^2V^(MWbW`soU;i6h#~|O&LC+ThQ+}GqyTlcKG=U7N}R<&
zYbc@s0K#SzctjX%zI}ffBfEuU6o|914aWQo%s_x*7y?~LIh$2zK=uj&>d>kFteq6@
zC0pz~Q39%Hc1ettqkn@CV>0462o~c+1nT9FJ0(Jtzl@YT%wK895Ev<m5&_8cv`Mz@
zKrH(3wIPN%DjMy6vw0D&OE8#93NRWNAF9%?P_ig%f520aP}B0F;yz%wWUCtq3TZ)l
z5+$vE%6y6|)^LeQDMkYYNltheCd()Y43|Yblwh(=e<KAcXn$}e%Z2TPctJsnh!Rw#
zA>+kSFUtha)L__iQ>=15XfU<{K1Qel0Y9C7uwY|j4x&(tQ40Tq&<D<_H$!-^f-FY@
z><J+nRG0p42^1$r33Fa;7<?L$QBW6@UCJ-b3P6|#!mh8-kYPPs2n*j>W{eg%5=RP)
zoYi3Uy7386PEYQx?1Uut<B4-;R{fP|bNYAXhmYs|2?dNlzh)AY-!u4j--ajf(EjP~
zL+kiAUxp}f$o?2mw3%tSZaB183sy{BzAs8HxIK_ysXq$8=24*G!c>+H+djNI-M(md
zG(icPU_pO{-k66w*|^|$#W8WNxbuz>)DBWa-wG!QlypVP02NWSyWhp)ln%Q5G~9FQ
zXN|ZY0qn7+|7hP~j(0+LwCtG4;_}I9ZDBT*TECe4x5M9+64qCef3h8YcfK1UBG{U`
zSbHFqR~!jcek<?X6kDKxH^ZE6iDO|*mH86Cl1`P(DoCJ(x5m`1PG^Iw!yg2)-PQqX
zTL-Ia%bRLA=mwk(IDr(--1iv+roPkk!Gf&bL+H4O-LSCv;GQk&&$MM|U|bu1(!J@B
zkIM46RLSA=fk15?G)N&olFe>$4Z9`PH*7y-K!-nDGzAyH^}`>yefn@0&^UQ+2OaPV
z{}RfmM6Y{0731Khu5(7+0;h}a`ynlH+?W{oYFI=s&a>%Pa^d48w5h*$&nRYSc<h0K
zZC3AQS~;^UM`D%iy7%+vZtK)ndhBM|)t<96R=5s)vCpJ`#}?G77Y}pz;cIJ*Qo7{i
zUZoPkwvH<1P%y66!B<$#rUfREb?AXC&GgV?y9OC?qCN`_G$YSbC>F^L9y4;s2kL;F
z=0og`HO3ve`agdUN}wp)A7LJuH3?{r2voU@IQM2SRg>Uv$I0CAbCIBvYy3K(f{VI%
z-AQ~?g0x84xafuKY;+6Y$xQ`S9K~5npx>+AQ0;pnI`^~y&YsZ9Cu?XIwp?w|=)F0e
z4Al`<z64q>3=Y2wvf8lt@!3F0N`r9GY~fv~;2l2^U3Zvt?q7}{pmDB*bMx}{_gq+#
zw!nt7DZXx4qPqm0ZZzO6WkM5nIrm9=aG6bP*2>H=TfTMED<b*E*-Cz*1A8Xh4T@IZ
ze)Mb&4`yHC+zlIXqwFQt7hEgvdueG=>knt_k!=feB`@upSJfzth$_@}k)JDi<$lZd
zEFo-|!igDCex#rK{Xv$NZi`g9-sF1XX`z|>V>KowjN3uN^9MB-<l^>F1rwcB9b|8V
zV_mAEi^0K}`nTu=y+ewGd}B>+i$H$yFT#Sm8)C@xNJC6n$Y-HZC9d(K4dRyEovK-7
zq*}3}zWi4~2{n2(m3Cw+6U&-&)V^)Yig`{;WBZmuHhPD}bMMY?t^j^Y@sS6(s_6?I
zZ^{@E-C-M2W8R{trz;!ZWvy2FFXWz}hbv31E&LikNwuO8QpPAhvxyg2q@!2ES?4bP
zh^dE{9-DQ0Zf9xi<2_YiA$g9vw@|!GoW3yrB)P~$Y(p9q9mx%}CU#mas`ul#^yv8K
za7@xRsh^CEidu($+uFOW7u6Kk?i%gOUaeT)P+gvFSLGV_uUo<GSvjA!Cr05?PWEug
zSGkYzC!Jij3YlAy!)n7F<&SHj`L%{S$?RY}2mQJ1xXAUJx6thAWgdeB)bD1Y`QZmT
zcU=u7l&PJ`f1~K1=)W+>#K8O?0*~V#_Wcj=SU5QUQ{c^LPT66zqwHK!x644WoPH{T
z04^5G293(j7wdW!Ni<doEVeh|kbHmSQVZiK4jot=J0^ru!i76~-f*U+!AsL&nkQ<P
zlK9~?<w_1@>|3A)K^oszW!x>>rNb=WEMV`58f;pSDX#6t7OPBygqlxPi|AjZBgaaP
zWGn&p1$oB(NHq}{sAI+yRSXmzmXk6No+HyLE*O%u7zttdRMS!k<{zfd;|yW+FV_>o
z9)Ms#G7RoZVrjG<M+KUS_x6W4pc!jwxB*(w(s&118*(D(MF*A$L=S;06^%d&K~Kdh
za8+Um0hGs9JELr=#SThel8Y@4g^+XOee-PG*W(m-7176Y--$R9v09XdY_k;!r2;QV
zrwR*<NV*K?9eNe-v+X-H3osC0q!>>YHU(KsTA?V&ZUnr>%W_KA8EiOXfy3)9P;0!*
z+M22ah9?BMWd`$u-m|=-z{gq|;Sv`CxuZTUVcAeXl(&p=80cfm*YPZ&=}}OW<7$Qm
zZDJaP1%(OQfog|YyMzUSRrUkV#*m!lXDFspVWAd+Kw&{!p`x(F`T$vv2IF6v1HBT1
zf*x>nL<b-f=m-jWpRtRF_6rMIN6=DOz#33dShO|wlU~sn7+{P6N(l;%;jRY+$zkmS
zBA!=8(hf5WK%h+DNeT+Sfm;EtVG<!jaY1>2g5rvH2L;jXOAblSq2lxUPR{bxH>t0T
zMdkFE#Mzl8&2(#h--%?6{oQC<D1ttr`Pl|N`yxd(reaf3QQ799Td$YJ?o)D<9*K&A
zM18cd-D10HzRGmVv*(Xmtu1VE<eCOmiMpk0KfQ35rmC&buqjAZcq5B)zkjSjzJdu5
z=6`jJITC*ye|UgvL2NL^gN^0RfTER=HBu}p$5KcPmxa1fMtNvAVDRCfxJur(&oPcZ
zT|c{jRDHVO`e^20b16l9t2M>cPF+aJY;}YzwHfq57XL!3k-dSWi!7yb`<tr3dhZ*d
zfyQej$PW9B*kGr$srDzpqH`rvm57#<<rL4dGNwwc(y#3j2AJE!XhUqFYcV||`GYT3
zWh7Y(zPlP(AtU&D=*&fF8MBotaMEOb4RNk80ee<?p)}`(dE;KSatUy&%B7Kn=~l=#
zlTL^ffGr96*Jk=q6zYP?i&HLR=ebXAL$d^WjA(AhHB)B{7C>@JHKAlz^TOnZ$@3eX
zs#h#+^&;dvo6>%X<;gfFIE#bKKdz3w=^1%1$jA{NRe#K2UFf4mB-kf{q0%*dccMsi
z`O*MiiS_jJ#xS>Z-Zc}<%+hC<mY7srRa$8M$kP8w{<Gg6jv;MyqFNq*NmpnkBKy!l
zm%5NOSp0zowI}DU=w+L&iQ+qDqbZgcReTfIh+e;OkB!rQvD&>pmMuevwV6+%L3}R6
zG7E{97n-(fB>TH&Wor7uFw?G;>)GkcaMpz`X;QzKt(5XB7}0CEF^SfAWfWa}Mk{SX
z+<vK<li%uAftBd5^rdpj1VC49Us+kI5|C?W^GufcEcFtL(&pNos2@MaRo<}Fo9xtT
zJDAV$uobU?nxmipY_<f~gHW94)}zwsUh#{4Y#$#7XcPye)ZmHyr!hbON&L-8KgDiw
z_@^WnF8clbo}QzV!%4%o{<HHM^ELBnaTQD*UQCH>XG))p<wbUu9(+u-^O);K&&`tt
zYBwgvucSM~vr+;^E_&=X`gV4v)gz=2rt-cEeas(<1aok*+kbu>o1c3Ye-R!oG%5M^
zD*_<6`PGi;PUqQ5-77G+axZ3v+qIILBG+7TCLQ$2JoK;oZpY=E2%!Hy@KN7cM?;!>
zjv>bIYj5SNW_sLuJ3I~!d>dt_%)tzkWu-B2(}ZktBD3(VE}T5y{pbx@VV?~9{hria
z*lvGz8DTqLY;i#wA%9u;xIdBkOhw-`Ae|wu*NT7MyS;JWZ~HV@JBzlf(;{V|bq8rh
z*^g6tHtQYkqkn|Wdg{LugoT;&UkLKwgkWO+?}~`v|Gy-1jhB@lVt@&|{YK?04G-hM
zw|2s@ARvn;OU6Dy$h5muL0Vn}{_@%^L565vx>}Fj8#8kN0CUIe%3ova>P*3^FUCm$
z=>k8Nc$W%TPLvuN@bVygJt&$}OgbOyw4-i7BBXCO8YaC!>xnc>=VE<dI?ZzazV5ls
zjw`dAiSJvt1ro4IK4cC+P_cjvWm2g$>AT4+g61PEmh4)6N8ugy<430&ePbw-l5H*0
z&UU|PiRO1Oc0Na6b=8x4xFCCi1d3;@To4Eh!qOz$E7MRHs(AceGSa`ep9g!jj`UC4
zS^taex~w<zzZ@Mq`@bI@BLf@je+t*@OzEU74urAWM@o)ORlzFu^YdvLJndQ=tHbO=
zUWI&)&4A-W#w?#tRJ8Tcq5(NNZR5`n#6oDlo$uRJ1{gI!nBCp}n>R1V$FVF7@bn;x
zScUpGECLL093lY)9Gb@cDHBPAr3|SPmSGq<HKi%0i86ospY3g`fc^9~_d$YV6a=wt
z-&<GR%xX#H7Lx4qm#_c`5CSB(OEV}}HH&U@QW8XP1|z`;1caE54EM^!RT!olLZ*x^
z{5Dz5jfV6G$n-FnL1-=oLN{}?<JGExGz4L8sqi9)h^Hnuh&8euCD$?g%1YS^B<rjZ
z^?dI9ZTMvFeCC|xQVpchM8dgJVqfd1mdT{)<RyiA=AqLg)HtyHnuV5SD(gq|v9z?l
zG2?mssB&CUljQ4f<3x5z`kt)w&kMK{lo4c2dpNQQRYKREtZ`7TIS-fl^@aeM$5JJ+
zDJv`_np#Fr6?ELS0tUP%P{Kk11+0+u#+xoE6Id}e9CI&8ib>THD)c<(ci|E<)z%?t
zi2G6wQH&(WD4uH}d+)tCXJyxG$!30Lu=K*-=kgi%3hFpP9L?bByjAITJCl`@80_&9
zJ=O{S7p9Zr?l0f-gVpcYZ@cwgRslwQr#x0yYGP3(@*L(piW;k>ob3s%)KJ_Cwlz<Y
zIYnazoRxG>bavb%@D8hoVarBbq<CG>lF$fo?wU{hD>%)v6};pGg0$epsXL1XZxz#;
z;#n@qB)&>J6M<IT8?NnR$<emNofDq3bN?mkX>t9Zx)$A`Qtvv;EP_`*VOM`Vp{GK%
z?7l#Y-6^--S_>%ESB8(obbE4~P*DudIHm~yo`nJ3qDMwb>JoKd%4(%754KB_JT{n4
zGm-x9Tu{dV!t1Vt5fnle#;d#8uPR<{1{R?BB)`^{$ZA)Z>qDqdFY?cBMuK!0Tz-#v
z@C>$>rv;DPte#^aKOMdi3ojT7Uzdd3isqN1!k8RJDyCjEUu`nct(i5d>#AX&T`(Re
zM69H%(;V<h4BNobljC5|#NK2v^A@6lCl|_C9OlEM!;K0lm_Xfzr_GPe<rd1pIqNtm
zW(W|(aH<%P9EBToLpTm}`EP3JJ+4%R{=?mmGW$zwT)y#Y$&xX)Xn^Qe&;y}Y`tAki
zc-?}2fQDcxi>5J)q)xQ=iabuxWE<Xlx&=)-Uv4NA;NHh|QRB7>hT+(JTg~CePYB%(
z4~r(GP8FlHhWgK*%7MeBu2ewPfm)Tg>kelZu5I~PyS2l4=$~FkCS4z|A?5&Y*d65k
zMg95E4FGz<r>IxXT132)k6w*4r?*hsyVua?(y1%s&hOKZIe%lOLvc1T=x9?LcRN1+
z7Ss)OZVzvK&MgEx%TfAT;i&LD_|`N<7{DVM2ueT%*G!IT@z?0AUjWZa!K!~(9#*FR
zO?j9&{_{RornLJe2S(WIJ1UJKU_)(cYR0w{xvdvgrtF2#I##Sx%*;9&`THyJ2Gcqm
zN2$5fqJbJwl)cxJAG&YiQr2ts?(>9xQqmH2thdiFWpU30Kkt5hF7#al@^02!Pu@2r
z(DBvC+m{nV$nb@}zF*ImpBwWV>${IvsOE*-@W42r4nKPre5SM<&S&8gHJJ1oTy%8!
z{7Mc*A7~tyuzKGSO*Rn>P)a$8|3!{YdM<;iUa>dEX!G2BsyzdKtfM_d03HA(*nWTq
z8t5Y5blOV+mCT6peN>ZX;^?4s=nqKD$A@&p5srj%Zp7{!VSn~(hW52v<vg7VQCUP#
z`J@f1mX>?c0KyXR(Q+x{U$-FEo^4AIZ~pyydZ3f&`8Ee&LskrUfUBwZk6ROB@1;;q
zE(9O#jsvl9MGdxP8o(({q$~Pb<AlJ*Y^K1{hRhnJgEQQiU_J){={QHc&`nGj4gY7F
zwI-E>-YHG@VZA(B@!zGvZOX@6QcV7{KjUR2UX*rAqVQuGEQ&*Q3etu9inbzWQzbvb
zVYx_G=cvd0-4rq>%9Zpkn7;vv5!O=u1zVo;g9zx-w!_vqBkTC02qP=wC@7s&6EVtn
zjzuoBWt>v_RtQzFxtXEwRT>t5R2FEP2#`IsEUg1F)J^O*sG0bj7-^k4N+OU^XWK}9
z9flV^xb(^NO4T3LZu;8-fvgbSAP8|3ap`_6*a|~NNA6@zfjy{&ykWC~5Q%*D6umct
zfGxXGz`q!lE@C)9W;UXS#1ZbTK7?#Pl(cptDwVTfATFv*$+Xfe?ZFJTROh|{0Or#g
zGP&TM*xcez<BoPD3|_`}n%-a}i~4xm7}uu3%XWa*vFwPCPSg3>;EW5ti#-y&_-jx8
zt_}62uo6EForcA;k9l3y^j%1ls-KQCb<F9A6e<aWT<wW}UjxPL?^4UOX&6o_j1DT3
z-i1EQ%I4Lbid7{GsP~Q8cFof4Xn7G$W<jT{0rSX<8Y*^o{z+l{GstA)%<Ub2wQP2Y
zaOUGvgl%ADdXtArp-5Y_5(x>;N|(oaW%Kv9wlpGsM-Y+wpGw8AB!-+xQ^6%h$y<za
z7;8YUW^j;(Q%pRzZ|a^#@v;6=1KE@bVCI=uca2+{)m|pSE=`kRQv?*TN~MlaLJ`mu
zz&%}wkk-Db5S2a(U>sBz9{2Mo+W0<uA{vKz5)Gm+LV;F&;HBG<5M8l4L~_$I9P`i6
z*!Y$p#iK<+o~c)etGHUbC-l7>NCq@<3~p2BcVmLCiDkoYVcLSBEoW+pms)Q6VeJPO
z%qH2esYmXesl}`c!K*~I)L&6F_TH6(XN!uh1K2iHsNNH9^hXUE5m}E1!AsK+Hd8Uf
zv8H6MNm~+r(LmXU-s;BAD?%JLPiW0Sw8rVG(5r`*Hp<6>;0=&Z|B6De(9QL)A+zv6
zm^12ogBc&p2nJO_!rhVxQO9yB`?D_Uwi3^Q<Q{F&X1+JConOkmyc9`FmF;mCj@6+9
z5VzH;gj3+sn+Qa;np0-&8TwYGN~Mpdqf>ij263}I)TLC`uj|IA6#G^eUT=ey;i7KE
zg0wla)}fNVU`9U-?)`MO$@Rq*2(vJm#NdPDb{ESlVr`r3<T>bM$t*8)KD)QJ{LRsK
zsV@GU9E!5x>;4YWX{@!G_kvT6NX=Q04smb4mE0<ctLu~FV}3=^AK`x&RTc)8e@W;5
zKg<J82G;+#m%_xx_#caIi?+5sZX2Q>e_v3XB%TL{@N7It3_v6>tDrJLy>5QZUvP0g
z*Of}HAi99h+fUduy`AczVpRO*?WQgqKW3cSKPpfQplL#G2@5FVI=Vzo#UZJ<=GG%4
z@$;2Q0do~xkqe}7a-#EMWhFL9<myp}?rx}iBw#%RBP9?)1wlw+gj6pg3@BU3t|*Yh
zMx(Mqw<tIzA?j~MDjrEh=MZ3$nE29SugN&7qw|tD;6qWlGOR~r+_7PFsAH0V#HwRh
zcMTwS#>t^LY1!<O7}*KDk#tC%WReJ?fK3K8WWp4eg&0{tl$N2{{Yo@s6cu!8pk}NU
z=@u|h;tFbPsRH6ff5OMC_yMRWElz^QR+}21ClP4I$!X=vH^XIz&r^bty|Wn*f#}#M
zo075x_{7Oc)rn7844jnEwgY18xkwvsCMv*ubk;4yVw4*um<$Y<zz5Gob--@3LOP~&
z{vQ2poN*ddIT`h?pkv>)cIYrLLM~-iHwKl5-augO97OEt7qIMBcLeRWS5j5Sx=k-g
zjDDu7RcX~*SqZ~D3|<ZB5U3T4P#0*<j0e%u8X&Ywtirqmu<U@MV?)YE8YorBA4ai(
z8+qbbCy^>|Z_-3zfYL=ts-r9d$`t6ML^&@O04&HSa|tp->>b8cN#?j0BhV^Lzos1}
z_@oVClqg_Jr{6Y}kYY$#URGit5~LTzq(MSK_ATfKnQ3loo!#VVqy>)Y^}HXn)$h8-
zf3bhD`wafPv~qXy?d1O*U3+NxeA${&w>MV%I%y*eS##rTnd;E3y?)rG%UeZPck{$n
zs(%UAb#u@AvPk3KIx+A1y1xPjxI_lP8t`YYWL)rNfgPHNy0Ro_)7M`&-K)nJ2=4HM
zIa`r>Dbk%?b-a~4F!J?zhgjbzB5ynV{*?N5>fzRZ=gt`<;mw<Vy=w3J?A{yPs|(qT
zZVH}%V{Fb-Q$ep{uur(@%`ZQz%71Zh*sZ?h<M-_FbC&*n`ia>|?C@bLDMP?-djCgS
zYSn1){fb=N<6It&d;xj$9jV8MHWTrTd9^;-GkzWu%Jb$Iw+8%mZ&PQ%5tqq}UAv%O
z`v$0Vt0C-G-JxT|gYmVy5w@w@c)5D~%!B(p8a8_0=SF62{XKsj+ctW)^Ym|L>+1Hy
zs(d>(dN*~i?djy*Udn0WewsfWK7KyG$=z}81P&0KPTaBM+eP$4;2M0_CiZY&=>5O3
zb-=zz%=HggX6<KZcX_`Fd0bTW5gE2W?;r?r8r)1~5#@F|_jg{>roJbxc3QZ>xcPB9
zuCsQ^tlQi^nesUK50L=}ZV#M4ci!Leiet4yOf_iwwY08nZ)`7Yb+sUSN_L&>jqSO4
zFP@5*lH}yM{t23wmgMBQd9VNPfZpA!V`(Z!Pw$);!8U2g?DOMv?ds+8Z0XV8wsr58
zp8qdh7Q|53b=+27D}7wWH$y?5L2EuDAAv*yMQ?!V;$PHiDI|HN`yKb2117HbvCrtM
zofCGyhU&TC;E6R8Ldhr00r2pB$a_p9sk!9d2xHw@N1#{*UTqw?0cjaD0#837JnGn|
zFAfBMFENj(^r<W>OuAyWaK~{F98fi2r+geAs{@A@#*`rr7ob=iUlFl>sofw0gZqZj
zA&v(SoJ^m3fR6gQ?){(yzL+8&;@Doh18SZJoG}gdkq2qU4jir4Trvq@zL7>cwC9BO
z0;H6o#d2f^g}@a6xSD#sii0RY_@jIVK#2%F+Lf|nQq52y12u4<0!U_L>i1ealL;1w
z6Tm1)HQb8wISG=Y$}t>P6;9Y{3|WRN#2Z>-`ctg^8xKG=FtZ%8^=FE^w(ROk;LloE
zjY#6i@ki`<48w5=T=RQ1vY@>>`RepJFq5z#4Qo+4(>lz)gO{pB0UYEn=@9>#ba=IO
z<(5S(VHsj*rhx$mT86(3ph7w|>*zl52_lmq1fsqar352siP-fD;z$*9brmpa&<FrP
zI|jhT3V}`vs^sYiXkanxM8ZrR7&KTS1Uv&{4o2$?0EVHDvd|2;8t%FK#_7~XgpPOJ
z5gC~ML85@b1jyA8$b<05-YQ6?U`PjtMKL5y!s0?gDw6<82e(SVse=+k$lEZgFSbR8
zO(Fm=nD+qVAzy(}C$RAmn()+&*!5hA;~>EB(FdW1qaX<Zs$<cl9>C6{$S^#FYG@>{
zGe;Dx2HE1u&U5|RD`Z!<m7D8klC?buu4N&??5!(EA8}S)G*7=M?lPnBQQWPbcl>DX
zPV~9SdLWcN<w|_~x1uSF(Nrbqs#5fo$$Bak|Ge~8EOGN{S*ps>yMD4NQ|Ip4yjTg%
zwFRW5eNOep_RjL6?pfJA-A&zf^IE=8EECVcbN#=Au^c>iukDNbWTHeO%(ib8G7{X#
z{OBNweFrwKfpbcr5F|tysi(zOFF@iro~IBOl@y-=Al52uhLKFjBN!`9WFk;miC|4F
z1#4-Mk`D~<4U6J4_yZKU4L3bbrbgYbSWG`ge3f{}SqVrdffsX4$AAh2v^<ynn8T0&
zQDDy|TAB#-_Jc$Q2S7)$7G%dLjbpWh(7{tox`YG)G8)|pOic<9rTFjppsH99CP875
z5o>NkAwDBeY&wl*z<9`msQxfY0FiX1M=n?m%n)ivp?0E3A2a4kHH<Pany~~CG8LYK
zrEXjm10fL0a15dtn+R~*@t8=!>_wu#L6D6}Xs8?O`2aZP%RGSn#|HOBInqo9O5)t8
z%vQOeo}M%_5f0oA#4kPoCSt5y<o4mU5C!#0dI5i4AduuKW}%S`sUHUVOt?WyVOCOt
zE4hs8hz75S76ee@w+QR^#Wy^?<j9i}>D@YGR+4Oy@<&`~>Rl8bWGsOYOpY)S`Ajts
zxUa|59&tj1CCLB;bu|7O5Xe;JXa;}Q5o3IOF&M#0&{$KarPoOYB9_L|NaO;L426u8
zB&tea*DvUqQz1L_C$HLEt+H`i4zO;LO1J_c42QZ&q)1lVEWOB!m54ziJCIbP&`PUr
z!)0UD@-SQrAqNbf*Gvvn5Ga&@!BFl3K*$3CZAl?z!8V}KkM4_#BV`z<*7$^A496n0
zJ@}B&92UgN)K|`2mq8E!AW#Pke8vJ1{j;Q_ehq7@5OHg=LM;ZjS}y~E$O&#&j)6HV
z&$9iY{Dlg6x-usv0+Yk$5j{{~h_$k3GNz`uxL4zvHJy{0J5Cknzcy0mES!lhU<cj{
zNC^~i2{L3|DNkObMFB1)_AW)HV#fLFlXR^^;0>|aSfvG@`}<%z$_99Bkf~_HuYp}n
z5R4!|u3|=^e!LMe6VF|L3aWvd<DO}-2MNhPvc4K4I+xs3#<Ca>`GUJUn`GOkRZ~gR
zJ}E(fJk6ah?qE?Fv`<6VzW)U#@HEgH`8_o8rt$Z>SF&YrDD74D=B9jmLxi*2{z2b1
z==JO0(^OVAwtq=e|Hsl}WMcl$yN**%hhivUuYORphJx~Y^i7W(>yC#U%FNSN<As7j
zR%!7O@k+TozFO==nRpBtDr69K$5zq`KHquHKh9bV8ek0VU0&=RUd~k(`2mON;7OtZ
z`7j`b0*t6KgZqyLQV8B(2R~*!IEG;0?nh(y;aA}Y_DOlW+e#ari4-6NN-xe;XA+)M
zs5ZS67>Hs3hZGowhWLcfvTN8)GEdtwkmM5%BAECA2N8lEg6NgYyN7U{bHpImRE1XV
zxM0K~f5jRyPdu7hNtR@L<Q0|l%^T!SEt}NzWst-qf7o4TS1|9L<|(A%89m~sec!!j
zP=t8a3^QR9a756M2_KY9Pgm9uquNA`PEwMOQApF!%YM<uvREKxC6&fVrDxBnd+2zN
z%f_(1%<$4UW2xL4kiNp7kE~6wb@|fg&q-{oMtE$Y#__p!OQ$Q(sTU|eq5wl2v>)-K
zIbJw`rvXW?dB5{-YJ}Dscp!-XF(F32_?Rutgm70qhDs^MI%&7(uE5-rY$%D(=;Zov
z?gcr2GBa?~lo}VFNppBbJFH#&zMk%yW=bJmMPzFIM=>ZwaHn3g#U-nfuoO^zk=zU8
zj0HHXhwA>BL%0PpDE&Y!+G_{g-T)W~6wv!g5!zejcE~aPh~9w}+bBVI@~e;cUf&^K
zMZZ}8x)AYAD666@pkR0InaOOK?`na7grX>}iE!;f&UGpV7<lNi-l66?5aT5gK=4s<
zdzHj9h32J44pex07$$>%9sL|86CMRK+eu9j-Pu{r%~sf$ORSPBS+@MBRFJ9k&s4oq
zD~%UiYw#damLxb{B^&i(g>Io|D)~lkY1^0+J86sf<%8qguIdGXur`Xj?~HV9pk%s^
zn3R&b_p^*FvR__gYBVyUXp-!)2`0UT#_+M)>55LIxRNW~9B1-$?}-JUu=G#w=HR8*
z6*;8&ULh1YRuM67Q{DzFp(gL2Ljd7L9ai@#+9OHzMM)l$Ed+?N>p6DAYAh25I&pW7
z-nLal2o`8eYabC+`31^Kc)lSZstb;FUT%6jBp<iZXIB9tGIgJ4-8>gf_P@6ny9pwA
z0Lrwiqri=`R0nL-iA5dIf9g&&q2yb9bnZX;hT-3+=!;(3i*ALg)=FQcH&{W|(^EJ!
zF~8S4W6iRiu~F7PrY^tsaa>s_OMLT3vOOd<9^7KlexEenj>#=D(L66J=N3;1dXgcZ
zH5nPZD3Wygw!u+d7NAH%&rQ?`lGA@=tTc0(n2oQ!q9`6jkG^qW`$eE_8{@a$frB^N
z>8*9#t`>BCx%b3a=<Qr=VLiNd5q&b>^y|#*=KS?*i7is~3~J?Fq|F@mPpVxdtIbT`
z;j8er3c&zZ!sTWi44`m?6I;{f){Siy2M~$xSz~1*vuSSKGF5Lfnsm(jPT_e_QqbWk
zk&~NzlHpgKP3r4ibc!(il#1Rhjy<dAQ-O=JFmuLDcuFx6bzHmXTDw2Kr0<Yv`1oHm
zi~V266#mC#Vr2V|#}IrmrtFT{{`TrKjzKcqe|(>p2sCXJ_B0DPTYD+kn5sc*XSV#!
zpIA#nq12QE<JBahl=4ZEgFh4YdV5x$+|$S7^ZnU84eyr8Y@L9Ep9`n4g?G&)6<x){
z3me)S+k0ZlGQ9SF)>sbheLp*RoztIsnJ3lFS-X))EM>iuhR@*EOA%E<JvlH8I(l_W
zU~lu>zyV*XOInUDxGpR<ld&fQ%PhNfQlz(A!=rzcUBxR26*eLR;$&hrCG93Zat3zR
zVs+Lr?-Fhq<7U>iYb?SFO$)g}XcEX!h~hyj98avgkbtmEb5#(cU)<eB6TM15e1!`+
zPwAIM4k$7p*>0!%=?n=dh95It0=HxJ|3+0pR=+oyY4@sBeZ;+-pd8cj^<E`)odt7v
zSQ~Ln_~lv|N)#yZrnm`JHK$E=J>})|DI*WyEmf^V%`xtxQSv@jn=JxNq#=yzD?WoE
zT6`Frj9yqz|KpjuT3-P9b7?y1CR8G;w6+G5n8u2MlQX>04CKEE@=O&gtA{(1?`7JI
z5jpM|AiN*k51yyaTh9K_KDhxnalSFU^JJxD!F83JNv4b4)BLxxctYdb3g{;qD+YAM
zMAx}nI}{J5re@f_$Ju4DS_@%v62TLWQQ~8eTHv?;Rm7znB1Aq;G-E?R7&-=vWOI<(
zEVRv?aJu{ED1vT_$dYQc#~aJ)xSJ16bp+dboRHMkpMcJI>#dBbB>VnPGvp=by`RoC
zQ__t!ocVlQ!=<IksuDl8Q|Y*e1JXnCBl)<hRj*YVne=A!e!apsyAOiI>}~L|z#PCl
zwXa|G<)1yM>=A+<H^d2b;zIW1{P>K-M<N=+e(GzWTC(?uX7r7sMZ6`JTV7O1VfY5C
z_@?yrhIu$$8o?D(+T&f?`USy+3L<+t#R4$A08L85ub#Ll)fj^K>_~)K@)Gqd>po~|
zhy_(RrB49?(HTBEG)7)ZmPYa5pQjcZl~mb9H&F;38UJU#?}1d}{U9vi5dxX{@S>yc
z%K*&uNZtFb{QHHf%IRE)f(+VYxuZA@f2g4WM!okBG6o+-hi`Gp%wowVVNDfD_4*I`
zc)I&<4~9^uu(nsN=dhP_`aOP}e#P|t)gF>Rg_zD1%2YGeMzTk{(nvY4iN!RKKJ1bN
zFr8#<5_$p#^@3y_=>sw8hO;;Ko+*0XK6<8I7~oXud;niIr;^zaW)M#Y4j=dRJwlh#
z5C}dAA>#f7<0Q@5!4kHQyIh)ZWYDXIV>Oe+SddhxAGWFi{d+Sq5%I+azKjSvbZ`M-
z)X3*xmzmL^`TKOBYEoOE-M+nnUfcA&9yvV9lF-zVn4@J=C;-?P<YNor9yaMLvWsMA
z5(^}*ajWdryXqe>)x)v@$<+c=vK|Uu=eom#i_dc9;xb0Rm63mD274u>A`rcy)LtR}
zmLXk!=j%^T7E@f|Wc58cXeUeVt}fI1MSd`iMc#Hh!)~nXGR~rcHpg0a+2d{zH9Ob)
z=wY663otUAO8U50B~qj0GIyq>)w}^ym^h3H9oZ@IE-_oD$%??IEOtD1DM#?m8MSY+
zq0O_IajHvQ3SVZj!0W%DTn<^?3|Ym3f>3N#O_eu0?1CV$c<9=`uC3GTgXyh7lL7rY
z{efN(I$RH&c)Ul=gvc(7u|f#uzdg^7Sg$#%YGs3wI^|o0I;U?6t2yrCu*nP{MGKD2
zDox#bwp(LHBt!WLq4+r#x<P75kG$YeYPsm9CZc`{O~OZ5CK1LGtL|M*ystWdR!!CC
zHA+E7xyL3y73SrUgP+H&lLB+duJ${0upn}et)*S$vaE7n<2#jgZY%tzs7cl+XzpA5
zI3T^m0tl>hWr}i$_{>XfJo@BG6b6R+!=l?^eM5*ea>eyV>g#jC$|o7d156o5Dz-eQ
ze#q{cLekl3i4*|{x1Z3c%d#@U8ISDUu~a$cI4i2UzYKQ$VN*iBr@2$2oHvYH#!>gV
zrFPA!L=~xEx7`5?yC#?9nt~!Ldl(WK;k`0X{!WNY+^HU%`CA5l3j8TIud#>a%_g5n
zu37TwC<;5xF6$@*@n(MRRS|#ZOi;dexXUOfqY#<MWIoj1N(i2&J%?c+x|<+Q2(#H3
zZO}}h^H&HW{BW>`?EriZz9>q~JhH{>>5aE9_ek3g2D0JL65zSqd&I7%RtBl5Zi2w4
z;-^UHYsxhDM<ri5I^-z)2@l>8jv&R3QrzLp^Bll8(q;SWtb$ea4h4@bx}#+#f0)@W
zsp=_sMR~heNd`8VzWMaZB7da%&_E}h)$wxliO!n@zUVThji>|lJA-EzCkG)YzFia8
z$5uAgJMWSbqieX%`u#H$^?qd1<C`GD?=*ZLQoT3{Jn`vpAZ|jPr(zLL6@lkpJI334
zE6`c4ulE62m19dt(rNzvgsuEdoW8o%G!lHLAM!<$(i%NjvCll2B6_T?b`ZeHdV8Ty
zea)@;t`%f^HVvciB=sh_)x)}2GQ7vl>($p-=u2-WyCN_7#^+lw9*fPB8n@ruYH0L`
zdmFQs0CeUYe5iK1KBRY&?Dkn@bTPMWn*Cx#`EAW$e<3G+$F1BVQG-1H!k-`3=J#>M
zrP&Vgn=z~q7#_GM3zQGeqYI|&=^YcR@9F#t9}FfpQdSt;(?Xs=^ILPQyvSNkjX(Ut
zL{})7IYYN&{(b=6?is-9T{2Lg=pT@m3Qr9RL0MlOg*oQ8exC#GOy>&iS~^amXb-mX
z&Wyb4;S<@v!OXb}((>vf6?b(KH_|vS?VmAuZMMt5ZrXYe5@p;1{R9&Tawz~?iDFxc
zW8@(Y7bUQNbg@evK@#iQu5ZFYx_Q6a;W%3)qKl=vguyDHbux=7+?!wF^L~Kks=09f
zw@ilP->WZX2KN8h1Sr9pa@uacudPczYPUj@M%t(5<ZN`KuBf3kKguq|VIUz{IxtR!
zw;k2bvvUCk5jU1b#U%*<z&c0&2#s`$>#}%#oYCjo`Fc~Xa4Vr`BH8lwS|3qtm@+1v
zY~J>*bpPGlo8tI>9@4kJ-TjU)Uidld(!cfd{+;Ub_y5?6<F6nJNH(P@Y!C6J)rpd}
zBjU3FcZPf_)U}BlkCI6y?RTwj#`-8=;>9C)T`?-{!1Q81Xxm&18|^xg0q)EJ$GXfS
zU&1TrzgiVk5gvoSG-G;YiVlzNarxwknb}@w-+r8RxO=Nzr(fxg$t(i^Irj+j%Z-v4
z3Gu5rGX!EWDSm0f9QDp9&E&fmu+jbjTb7%uj+5P5?ksJ1d?c-TZ=7Y80p(es#dlr|
zu+;e*DSIH9dwgbbMkIfzn<|NjI_>H01|}eHmJQaW3Y8VtX@|$ndtY7fA|lQg+X-y5
zkFbGnAto=uEQtK-=yJj8N(F6EIr`M(Sf!<WPqwA3wZu>N0X;tgBBD9|#)8)15+m+d
z`GsY~Q!v(1k*bCal+=G<^xMm})1z`PQl<7B9A{U-2hXF3Jx`@X{V95_=#N=`_6+|a
z_iNxi6=*F*ERA?J?MZzDqOwr<^0_!YT8aBd%S>QPD?=b$vU<As3h;wd!Fit*W+?+M
zSqr}x@<MDDox0R46IK$tH!KPBd7Gy|iWo70B04^T1YL3vNW&B~<ndW40Fnt^Lg@YI
zEdy&wzLUFE1RyF{?a_vPxfIu<?9XghXn7jTj?>n@>V-g6_d4yCu*;DOi6+)L^g4sI
z(TS}Lh!B7=02NMfs|6nOt73BeWYDe-qPf<okd&nM9?+m{msMW!!VhEstSc*P5@yBH
zLqKlkm|oMiDU4S?K&kz+x*mwxL=;qK%ax0?e$v7KDD7P5Qg!HX?vldxr%y@*5h~MM
zBt#dyb>~wiT}~<Vr9Y0?W%g((Gn(_82a|q<uvLkI;8}?s%R}56J(yeUE3dELDk=sp
zUz81~OXj9UxaigFJ(f>Ohz?W=$!to#l*U7J%m!qRWrfVl_omFUtRxHr2wFZ<nW_h9
zR?#3P<2i#-7Nu1Wdx7k`O|L3=c)#j$lSX+=N1b;!n=Np_YH2Zq$(F)Qp#N@viTBX;
zU`<#2lj!S$w+u#uQ}K;&vKY??$cH?8oO^)qof<P1yn*@*{?J?Ag*G3lYKg?r@Fz+L
z7u#4XW`AX%bHrl$E7#}ejQO1K4DV9wb{57j<`)7)Y@|oVB1=6_c>hy1cP4!)P}gC)
zI%`fZ6?#TA%ZzYU!u$k^N_JR<AhIN~onUB?VAse3xD~2qrzb-5G4KW6?BKIO`_kfE
zRt-sdtYs@n|9XjK1A*D!eq#<`-7q>PS)~L~ni#NJ{I`(=8>|iWbB(k$7mJ<k_#V4;
z!y_3A(OrwySq7kQRcEWfu_ZUqev3=bDFgm~$gHUz3|QVl%M-j+Jd5M6?X&u*5hatT
z9CGbdk&$Aw`XtOqDGVaksPmVjen=hY5if?#Rs_;JsZMCbM&ue_=^}A#Y!*~|;h4aC
zZ4-1bu2tqYO}=Er4%gf%De3uR+&o(^`Uak44V36=lRPLoa~B^UjM3Q}ZLidwDIUwS
z(j`Fg>t<)u-J-jIqEX+xwohA;=LfqF$ya^X8uc`caCC80rQ>u?0#bJzC0Z14lmX3i
zypNJ5yLHe+HUn)^RgE3cEcVVj=#5?WulEhm1-eTv@By9t4VI^&7VX*x4HQIf2Y+Qx
zZnfN?TNnmVUG?)thrc1ENIcT=d0t$s)nOyKk$ABJp$Cjw8tqj<RXpLG9N*;hoOFKo
z=*9_ESP`1FNQtS10Xoy9%B#-+Hl^nR7V;>}e00<EF)&mtB6<2u*;wrLj{6*UpFxaB
z&(xdq*YbZS8Nhh3CIdXg9v6IVM``6!A=kzgJ1C@5r^5J|6hB|3<?V1kNSJrrvNie@
z_!YQ|BF`)0gc|K|KK_mtsJD0>+s*W^80j*A4zk$<3Sx)t7vIPUx9c&5hf!xhVbYQ+
zD@viotWktxS;1hSo7@GuhGupK;tbC`PV+PlYGgU&Z&-35L1)iuy{|8Kj}H~|^~+XD
z3^!~ZqDftQn)LzBF?$cO?`I0JP#^Il)8*~((k;xv@qRqmpB7Uk7~GqVm&tI=$k3r8
zGNDPaH(X^v`abR<lPIQlTZHjg%{Ta+!qyD$paEX(KYCX?uUA5ZEt#*gg+=zwa>Cb;
znAB?T$J^gNn9xID#?;sCL~{fJn!Pt?*DEmPlN~QUdKAlJR|$A8=j*Wr1?>!|sYSOQ
zq=u$n7(JM{H~$U8Z0^c7!onLgKpeUE{Ta@nQ0f?I(zj6s1%A5#1uK#2-$VP7IqUOr
z(-R=6q4RX{yHL3D8VI%BXV80gl)%ucpg>a0t#%J9WX)O)B|LQaGScy(s3{0N4cVAI
z0)nHFf5n0KJ2rs+&aM-)gd-Qsm+cD)%rnuC>Jo(TveBiHM39}kfd6MEu76O>aF{R}
zC`JHdzft*+8rx%SXcRy7YJ_h6OAR=z>^XE`FnjPC%<4GNw%M*5@v7HVQhA?AS_Fiq
zwd*0=T#|P)pTn3j-OIAda5#N<taX`i#d#=OG&j>ANA?4uiQhIV#XZl?ukRjwFjO_)
z4Jq3O220JAor6#`aqP>Vr7JwE&)Y#;Wrr$TMg;Q!FH{1FuKLHU{Eo%$4miUNP8i!J
zmjIy$qPfZ(6EM^jqHz_U9k7jhIYJ!)>V`dXvJJ742|z*QoVM$Nahg8jr5>dj={^E5
zsW<(zPXdq}6#c-qSc24KnyG6jzS)h)8FOi9aZ3tSG)LPd&5xLwgi8H$Z6D4S$Z|f*
zK^}>a8EuIFX@O8KgUXnTvD7*xP|?my9Uk7=G?qa<EKbMq+%)P?L*iM?ayS8iUk1f@
zU#m^tKG?}5z>?QRb`OS5G8Ds5_E0a-O(_-V?@87?m|&27Qpn5Lfc5;OGrIxvw1>$N
zhyHeqKy<ARY?-y7?Jyd99IP1FOjQJ}Q^E0;Nis@?LVkz3os5Erhl8Q=$~kQUa<M%^
z#rrW_$?6=RRu_@QoipsIcO4;vJSYgXJu!nikt)rMc01O}R}hq*PAasx>pPeOU^iNe
zp0GZdXeNn$5xumCRz1L8IAf)|wBt%0DQLLGorL2Iirq?LV&{vMC9k5C38nh=Ed@<r
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%0Da!S|g`G1@3lDIF}1~0hU$9OK?+WcYqr6aX9
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%0DVo9HOQsSU
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
GsQ(YR^^Hvc

literal 0
HcmV?d00001

diff --git a/doc/cool-manual.pdf b/doc/Informe/files/cool-manual.pdf
similarity index 100%
rename from doc/cool-manual.pdf
rename to doc/Informe/files/cool-manual.pdf
diff --git a/doc/github-git-cheat-sheet.pdf b/doc/Informe/files/github-git-cheat-sheet.pdf
similarity index 100%
rename from doc/github-git-cheat-sheet.pdf
rename to doc/Informe/files/github-git-cheat-sheet.pdf

From 4d060804fdd6a14800ebb8d3d0b6447252e56a22 Mon Sep 17 00:00:00 2001
From: darian10 <dariandominguezalayon@gmail.com>
Date: Fri, 25 Feb 2022 15:14:20 -0500
Subject: [PATCH 74/83] Adding mips

---
 src/main.py                                   |   62 +-
 src/utils/code_generation/mips/AST_MIPS.py    |  234 +++
 src/utils/code_generation/mips/CIL_to_MIPS.py | 1076 +++++++++++++
 .../code_generation/mips/print_MIPS_AST.py    | 1396 +++++++++++++++++
 src/utils/code_generation/mips/utils_mips.py  |  547 +++++++
 5 files changed, 3291 insertions(+), 24 deletions(-)
 create mode 100644 src/utils/code_generation/mips/AST_MIPS.py
 create mode 100644 src/utils/code_generation/mips/CIL_to_MIPS.py
 create mode 100644 src/utils/code_generation/mips/print_MIPS_AST.py
 create mode 100644 src/utils/code_generation/mips/utils_mips.py

diff --git a/src/main.py b/src/main.py
index 5fdd5621d..3b9bbd73b 100644
--- a/src/main.py
+++ b/src/main.py
@@ -3,32 +3,33 @@
 from pathlib import Path
 from utils.COOL_Grammar import build_COOL_Grammar
 from utils.COOL_Lexer import COOL_Lexer
-# from utils.code_generation.mips.CIL_to_MIPS import CILToMIPS
-# from utils.code_generation.mips.print_MIPS_AST import PrintMIPS
+from utils.code_generation.mips.CIL_to_MIPS import CILToMIPS
+from utils.code_generation.mips.print_MIPS_AST import PrintMIPS
 from utils.parser.COOL_parser import COOL_Parser
 from cmp.evaluation import evaluate_reverse_parse
 from cmp.semantic import Context
 from utils.semantic_check.type_collector import TypeCollector
 from utils.semantic_check.type_builder import TypeBuilder
-from utils.semantic_check.type_checker import TypeChecker 
+from utils.semantic_check.type_checker import TypeChecker
 from utils.code_generation.cil.COOL_to_CIL import COOLtoCIL
 from utils.code_generation.cil.print_CIL_AST import get_formatter
 
 if __name__ == "__main__":
-    add = "lexer/mixed1.cl"
+    add = "codegen/"
+    _file = "cells.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
-        f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}"
+        f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}{_file}"
 
     _in = sys.argv[1] if len(sys.argv) > 1 else path
-    
+
     with open(_in) as file:
         code = file.read()
 
     G = build_COOL_Grammar()
 
     # lexer
-    lexer = COOL_Lexer() 
+    lexer = COOL_Lexer()
     tokens = lexer(code)
 
     if lexer.errors:
@@ -38,16 +39,17 @@
 
     # parser
     parser = COOL_Parser(G)
-        
+
     derivation, operations = parser(tokens)
-    
+
     if parser.error:
         print(parser.error)
         raise Exception()
-        
-    # ast       
-    ast = evaluate_reverse_parse(G, derivation, operations, lexer.fixed_tokens(tokens))
-            
+
+    # ast
+    ast = evaluate_reverse_parse(
+        G, derivation, operations, lexer.fixed_tokens(tokens))
+
     # chequeo semantico
     context = Context()
     semantic_errors = []
@@ -60,21 +62,33 @@
 
     checker = TypeChecker(context, semantic_errors)
     scope = checker.visit(ast)
-            
+
     if semantic_errors:
         for error in semantic_errors:
-            print(error)                          
+            print(error)
         raise Exception()
 
-# generacion de codigo
-cil_visitor = COOLtoCIL(context)
-cil_ast = cil_visitor.visit(ast, scope)
+    # generacion de codigo
+    cil_visitor = COOLtoCIL(context)
+    cil_ast = cil_visitor.visit(ast, scope)
+
+    # print(get_formatter()(cil_ast))
+
+    mips_visitor = CILToMIPS()
+    mips_ast = mips_visitor.visit(cil_ast)
+
+    print_mips = PrintMIPS()
+    mips = print_mips.visit(mips_ast)
+
+    # print(mips)
+
+    _file = sys.argv[1] if len(sys.argv) > 1 else _file
 
-print(get_formatter()(cil_ast))
+    output = _file.split(".")
+    output[-1] = "mips"
+    output = ".".join(output)
 
-# mips_visitor = CILToMIPS()
-# mips_ast = mips_visitor.visit(cil_ast)
+    with open(output, 'w') as f:
+        f.write(mips)
 
-# print_mips = PrintMIPS()
-# mips = print_mips.visit(mips_ast)
-# print(mips)
\ No newline at end of file
+    exit(0)
diff --git a/src/utils/code_generation/mips/AST_MIPS.py b/src/utils/code_generation/mips/AST_MIPS.py
new file mode 100644
index 000000000..02ec14ec1
--- /dev/null
+++ b/src/utils/code_generation/mips/AST_MIPS.py
@@ -0,0 +1,234 @@
+
+class mips_ast:
+    class Node:
+        pass
+
+    class ProgramNode(Node):
+        def __init__(self, data, types, functions):
+            self._data = data
+            self._types = types
+            self._functions = functions
+
+        @property
+        def data(self):
+            return self._data
+
+        @property
+        def types(self):
+            return self._types
+
+        @property
+        def functions(self):
+            return self._functions
+
+    class DataNode(Node):
+        def __init__(self, label):
+            self._label = label
+
+        @property
+        def label(self):
+            return self._label
+
+    class FunctionNode(Node):
+        def __init__(self, label, params, localvars):
+            self._label = label
+            self._instructions = []
+            self._params = params
+            self._localvars = localvars
+
+        @property
+        def label(self):
+            return self._label
+
+        @property
+        def instructions(self):
+            return self._instructions
+
+        def add_instructions(self, instructions):
+            self._instructions.extend(instructions)
+
+        def get_param_stack_location(self, name):
+            index = self._params.index(name)
+            offset = ((len(self._params) - 1) - index) * 4
+            return RegisterRelativeLocation(Register('fp'), offset)
+
+        def get_local_stack_location(self, name):
+            index = self._localvars.index(name)
+            offset = (index + 2) * -4
+            return RegisterRelativeLocation(Register('fp'), offset)
+
+        def get_var_location(self, name):
+            try:
+                return self.get_param_stack_location(name)
+            except ValueError:
+                return self.get_local_stack_location(name)
+
+    class InstructionNode(Node):
+        pass
+
+    class AddNode(InstructionNode):
+        def __init__(self, reg1, reg2, reg3):
+            self.reg1 = reg1
+            self.reg2 = reg2
+            self.reg3 = reg3
+
+    class SubNode(InstructionNode):
+        def __init__(self, reg1, reg2, reg3):
+            self.reg1 = reg1
+            self.reg2 = reg2
+            self.reg3 = reg3
+
+    class MultiplyNode(InstructionNode):
+        def __init__(self, reg1, reg2, reg3):
+            self.reg1 = reg1
+            self.reg2 = reg2
+            self.reg3 = reg3
+
+    class DivideNode(InstructionNode):
+        def __init__(self, reg1, reg2):
+            self.reg1 = reg1
+            self.reg2 = reg2
+
+    class LabelNode(InstructionNode):
+        def __init__(self, name):
+            self.name = name
+
+    class ComplementNode(InstructionNode):
+        def __init__(self, reg1, reg2):
+            self.reg1 = reg1
+            self.reg2 = reg2
+
+    class StringConst(DataNode):
+        def __init__(self, label, string):
+            super().__init__(label)
+            self._string = string
+
+        @property
+        def string(self):
+            return self._string
+
+    class MoveNode(InstructionNode):
+        def __init__(self, reg1, reg2):
+            self.reg1 = reg1
+            self.reg2 = reg2
+
+    class LoadInmediateNode(InstructionNode):
+        def __init__(self, reg, value):
+            self.reg = reg
+            self.value = value
+
+    class LoadWordNode(InstructionNode):
+        def __init__(self, reg, addr):
+            self.reg = reg
+            self.addr = addr
+
+    class SyscallNode(InstructionNode):
+        pass
+
+    class LoadAddressNode(InstructionNode):
+        def __init__(self, reg, label):
+            self.reg = reg
+            self.label = label
+
+    class StoreWordNode(InstructionNode):
+        def __init__(self, reg, addr):
+            self.reg = reg
+            self.addr = addr
+
+    class JumpAndLinkNode(InstructionNode):
+        def __init__(self, label):
+            self.label = label
+
+    class JumpRegisterAndLinkNode(InstructionNode):
+        def __init__(self, reg):
+            self.reg = reg
+
+    class JumpRegisterNode(InstructionNode):
+        def __init__(self, reg):
+            self.reg = reg
+
+    class AddInmediateNode(InstructionNode):
+        def __init__(self, dest, src, value):
+            self.dest = dest
+            self.src = src
+            self.value = value
+
+    class AddInmediateUnsignedNode(InstructionNode):
+        def __init__(self, dest, src, value):
+            self.dest = dest
+            self.src = src
+            self.value = value
+
+    class AddUnsignedNode(InstructionNode):
+        def __init__(self, dest, sum1, sum2):
+            self.dest = dest
+            self.sum1 = sum1
+            self.sum2 = sum2
+
+    class ShiftLeftLogicalNode(InstructionNode):
+        def __init__(self, dest, src, bits):
+            self.dest = dest
+            self.src = src
+            self.bits = bits
+
+    class BranchOnNotEqualNode(InstructionNode):
+        def __init__(self, reg1, reg2, label):
+            self.reg1 = reg1
+            self.reg2 = reg2
+            self.label = label
+
+    class JumpNode(InstructionNode):
+        def __init__(self, label):
+            self.label = label
+
+    class MoveFromLowNode(InstructionNode):
+        def __init__(self, reg):
+            self.reg = reg
+
+
+class Register():
+    def __init__(self, name):
+        self.name = name
+
+
+ARG_REGISTERS = [Register(name) for name in ['a0', 'a1', 'a2', 'a3']]
+
+
+SP_REG = Register('sp')
+RA_REG = Register('ra')
+V0_REG = Register('v0')
+V1_REG = Register('v1')
+ZERO_REG = Register('zero')
+LOW_REG = Register('low')
+
+
+class MemoryLocation:
+    pass
+
+
+class RegisterRelativeLocation(MemoryLocation):
+    def __init__(self, register, offset):
+        self._register = register
+        self._offset = offset
+
+    @property
+    def register(self):
+        return self._register
+
+    @property
+    def offset(self):
+        return self._offset
+
+
+class LabelRelativeLocation(MemoryLocation):
+    def __init__(self, label, offset):
+        self._label = label
+        self._offset = offset
+
+    @property
+    def label(self):
+        return self._label
+
+    @property
+    def offset(self):
+        return self._offset
diff --git a/src/utils/code_generation/mips/CIL_to_MIPS.py b/src/utils/code_generation/mips/CIL_to_MIPS.py
new file mode 100644
index 000000000..5019a305b
--- /dev/null
+++ b/src/utils/code_generation/mips/CIL_to_MIPS.py
@@ -0,0 +1,1076 @@
+import itertools as itt
+import cmp.visitor as visitor
+from utils.code_generation.cil.AST_CIL import cil_ast as cil
+from utils.code_generation.mips.AST_MIPS import mips_ast as mips
+from utils.code_generation.mips.AST_MIPS import *
+from utils.code_generation.mips.utils_mips import *
+
+
+class CILToMIPS:
+    def __init__(self, label_generator=LabelGenerator()):
+        self._label_generator = label_generator
+        self.memory_manager = None
+        self._types = {}
+        self._data_section = {}
+        self._functions = {}
+        self._actual_function = None
+        self._name_func_map = {}
+        self._pushed_args = 0
+        self._labels_map = {}
+
+    def generate_type_label(self):
+        return self._label_generator.generate_type_label()
+
+    def generate_data_label(self):
+        return self._label_generator.generate_data_label()
+
+    def generate_code_label(self):
+        return self._label_generator.generate_code_label()
+
+    def get_var_location(self, name):
+        return self._actual_function.get_var_location(name)
+
+    def register_function(self, name, function):
+        self._functions[name] = function
+
+    def init_function(self, function):
+        self._actual_function = function
+        self._labels_map = {}
+
+    def finish_functions(self):
+        self._actual_function = None
+
+    def push_arg(self):
+        self._pushed_args += 1
+
+    def clean_pushed_args(self):
+        self._pushed_args = 0
+
+    def get_free_reg(self):
+        return self._registers_manager.get_free_reg()
+
+    def free_reg(self, reg):
+        self._registers_manager.free_reg(reg)
+
+    def in_entry_function(self):
+        return self._actual_function.label == 'main'
+
+    def register_label(self, cil_label, mips_label):
+        self._labels_map[cil_label] = mips_label
+
+    def get_mips_label(self, label):
+        return self._labels_map[label]
+
+    @visitor.on('node')
+    def collect_func_names(self, node):
+        pass
+
+    @visitor.when(cil.ProgramNode)
+    def collect_func_names(self, node):
+        for func in node.dotcode:
+            self.collect_func_names(func)
+
+    @visitor.when(cil.FunctionNode)
+    def collect_func_names(self, node):
+        if node.id == "entry":
+            self._name_func_map[node.id] = 'main'
+        else:
+            self._name_func_map[node.id] = self.generate_code_label()
+
+    @visitor.on('node')
+    def collect_labels_in_func(self, node):
+        pass
+
+    @visitor.when(cil.LabelNode)
+    def collect_labels_in_func(self, node):
+        mips_label = self.generate_code_label()
+        self.register_label(node.label, mips_label)
+
+    @visitor.on('node')
+    def visit(self, node):
+        pass
+
+    @visitor.when(cil.ProgramNode)
+    def visit(self, node):
+
+        self.collect_func_names(node)
+
+        self._data_section["default_str"] = mips.StringConst("default_str", "")
+        for tp in node.dottypes:
+            self.visit(tp)
+
+        for data in node.dotdata:
+            self.visit(data)
+
+        for func in node.dotcode:
+            self.visit(func)
+
+        return mips.ProgramNode([data for data in self._data_section.values()], [tp for tp in self._types.values()], [func for func in self._functions.values()])
+
+    @visitor.when(cil.TypeNode)
+    def visit(self, node):
+        name_label = self.generate_data_label()
+        self._data_section[node.id] = mips.StringConst(name_label, node.id)
+
+        type_label = self.generate_type_label()
+        methods = {key: self._name_func_map[value]
+                   for key, value in node.methods}
+        defaults = []
+        if node.id == "String":
+            defaults = [('value', 'default_str'), ('length', 'type_4_proto')]
+        new_type = MIPSType(type_label, name_label, node.attributes, methods, len(
+            self._types), default=defaults)
+
+        self._types[node.id] = new_type
+
+    @visitor.when(cil.DataNode)
+    def visit(self, node):
+        label = self.generate_data_label()
+        self._data_section[node.id] = mips.StringConst(label, node.value)
+
+    @visitor.when(cil.FunctionNode)
+    def visit(self, node):
+        used_regs_finder = UsedRegisterFinder()
+
+        label = self._name_func_map[node.id]
+        params = [param.id for param in node.params]
+        localvars = [local.id for local in node.localvars]
+        size_for_locals = len(localvars) * 4
+
+        new_func = mips.FunctionNode(label, params, localvars)
+        self.register_function(node.id, new_func)
+        self.init_function(new_func)
+
+        ra = RegistersAllocator()
+
+        if len(node.instructions):
+            reg_for_var = ra.get_registers_for_variables(
+                node.instructions, node.params, 10)
+            self.memory_manager = MemoryManager(
+                [Register(name) for name in ['t0', 't1', 't2',
+                                             't3', 't4', 't5', 't6', 't7', 't8', 't9']], lambda x: reg_for_var[x])
+
+        for instruction in node.instructions:
+            self.collect_labels_in_func(instruction)
+
+        initial_instructions = []
+        if self.in_entry_function():
+            initial_instructions.append(
+                mips.JumpAndLinkNode("mem_manager_init"))
+
+        initial_instructions.extend(push_register(Register('fp')))
+        initial_instructions.append(
+            mips.AddInmediateNode(Register('fp'), SP_REG, 4))
+        initial_instructions.append(mips.AddInmediateNode(
+            SP_REG, SP_REG, -size_for_locals))
+
+        code_instructions = []
+
+        code_instructions = list(itt.chain.from_iterable(
+            [self.visit(instruction) for instruction in node.instructions]))
+
+        final_instructions = []
+
+        for param in params:
+            reg = self.memory_manager.get_reg_for_var(param)
+            if reg is not None:
+                code_instructions.insert(0, mips.LoadWordNode(
+                    reg, self.get_var_location(param)))
+
+        if not self.in_entry_function():
+            used_regs = used_regs_finder.get_used_registers(code_instructions)
+            for reg in used_regs:
+                initial_instructions.extend(push_register(reg))
+
+            for reg in used_regs[::-1]:
+                final_instructions.extend(pop_register(reg))
+
+        final_instructions.append(mips.AddInmediateNode(
+            SP_REG, SP_REG, size_for_locals))
+        final_instructions.extend(pop_register(Register('fp')))
+
+        if not self.in_entry_function():
+            final_instructions.append(mips.JumpRegisterNode(RA_REG))
+        else:
+            final_instructions.extend(exit_program())
+
+        func_instructions = list(
+            itt.chain(initial_instructions, code_instructions, final_instructions))
+        new_func.add_instructions(func_instructions)
+
+        self.finish_functions()
+
+    @visitor.when(cil.InstructionNode)
+    def visit(self, node):
+        print(type(node))
+
+    @visitor.when(cil.AssignNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1 = None
+        if type(node.right) == cil.VoidNode:
+            reg1 = ZERO_REG
+        elif node.right.isnumeric():
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadInmediateNode(reg1, int(node.right)))
+        else:
+            reg1 = self.memory_manager.get_reg_for_var(node.right)
+            if reg1 is None:
+                reg1 = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg1, self.get_var_location(node.right)))
+
+        reg2 = self.memory_manager.get_reg_for_var(node.left)
+        if reg2 is None:
+            instructions.append(mips.StoreWordNode(
+                reg1, self.get_var_location(node.left)))
+        else:
+            instructions.append(mips.MoveNode(reg2, reg1))
+
+        return instructions
+
+    @visitor.when(cil.PlusNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1, reg2 = None, None
+        if type(node.op_l) == int:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadInmediateNode(reg1, node.op_l))
+        else:
+            reg1 = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg1 is None:
+                reg1 = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg1, self.get_var_location(node.op_l)))
+
+        if type(node.op_r) == int:
+            reg2 = ARG_REGISTERS[1]
+            instructions.append(mips.LoadInmediateNode(reg2, node.op_r))
+        else:
+            reg2 = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg2 is None:
+                reg2 = ARG_REGISTERS[1]
+                instructions.append(mips.LoadWordNode(
+                    reg2, self.get_var_location(node.op_r)))
+
+        reg3 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg3 is None:
+            instructions.append(mips.AddNode(
+                ARG_REGISTERS[0], reg1, reg2))
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.AddNode(reg3, reg1, reg2))
+
+        return instructions
+
+    @visitor.when(cil.MinusNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1, reg2 = None, None
+        if type(node.op_l) == int:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadInmediateNode(reg1, node.op_l))
+        else:
+            reg1 = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg1 is None:
+                reg1 = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg1, self.get_var_location(node.op_l)))
+
+        if type(node.op_r) == int:
+            instructions.append(mips.LoadInmediateNode(reg2, node.op_r))
+        else:
+            reg2 = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg2 is None:
+                reg2 = ARG_REGISTERS[1]
+                instructions.append(mips.LoadWordNode(
+                    reg2, self.get_var_location(node.op_r)))
+
+        reg3 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg3 is None:
+            instructions.append(mips.SubNode(
+                ARG_REGISTERS[0], reg1, reg2))
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.SubNode(reg3, reg1, reg2))
+
+        return instructions
+
+    @visitor.when(cil.StarNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1, reg2 = None, None
+        if type(node.op_l) == int:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadInmediateNode(reg1, node.op_l))
+        else:
+            reg1 = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg1 is None:
+                reg1 = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg1, self.get_var_location(node.op_l)))
+
+        if type(node.op_r) == int:
+            reg2 = ARG_REGISTERS[1]
+            instructions.append(mips.LoadInmediateNode(reg2, node.op_r))
+        else:
+            reg2 = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg2 is None:
+                reg2 = ARG_REGISTERS[1]
+                instructions.append(mips.LoadWordNode(
+                    reg2, self.get_var_location(node.op_r)))
+
+        reg3 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg3 is None:
+            instructions.append(mips.MultiplyNode(
+                ARG_REGISTERS[0], reg1, reg2))
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MultiplyNode(reg3, reg1, reg2))
+
+        return instructions
+
+    @visitor.when(cil.DivNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1, reg2 = None, None
+        if type(node.op_l) == int:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadInmediateNode(reg1, node.op_l))
+        else:
+            reg1 = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg1 is None:
+                reg1 = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg1, self.get_var_location(node.op_l)))
+
+        if type(node.op_r) == int:
+            reg2 = ARG_REGISTERS[1]
+            instructions.append(mips.LoadInmediateNode(reg2, node.op_r))
+        else:
+            reg2 = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg2 is None:
+                reg2 = ARG_REGISTERS[1]
+                instructions.append(mips.LoadWordNode(
+                    reg2, self.get_var_location(node.op_r)))
+
+        instructions.append(mips.DivideNode(reg1, reg2))
+        reg3 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg3 is None:
+            instructions.append(mips.MoveFromLowNode(ARG_REGISTERS[0]))
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveFromLowNode(reg3))
+
+        return instructions
+
+    @visitor.when(cil.LessThanNode)
+    def visit(self, node):
+        instructions = []
+
+        if type(node.op_l) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[0], node.op_l))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[0], self.get_var_location(node.op_l)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        if type(node.op_r) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[1], node.op_r))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[1], self.get_var_location(node.op_r)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[1], reg))
+
+        instructions.append(mips.JumpAndLinkNode('less'))
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.LessEqualNode)
+    def visit(self, node):
+        instructions = []
+
+        if type(node.op_l) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[0], node.op_l))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[0], self.get_var_location(node.op_l)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        if type(node.op_r) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[1], node.op_r))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[1], self.get_var_location(node.op_r)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[1], reg))
+
+        instructions.append(mips.JumpAndLinkNode('less_eq'))
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.EqualNode)
+    def visit(self, node):
+        instructions = []
+
+        if type(node.op_l) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[0], node.op_l))
+        elif type(node.op_l) == cil.VoidNode:
+            instructions.append(
+                mips.LoadInmediateNode(ARG_REGISTERS[0], 0))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.op_l)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[0], self.get_var_location(node.op_l)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        if type(node.op_r) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[1], node.op_r))
+        elif type(node.op_r) == cil.VoidNode:
+            instructions.append(
+                mips.LoadInmediateNode(ARG_REGISTERS[1], 0))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.op_r)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[1], self.get_var_location(node.op_r)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[1], reg))
+
+        instructions.append(mips.JumpAndLinkNode("eqs"))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.EqualStrNode)
+    def visit(self, node):
+        instructions = []
+
+        reg = self.memory_manager.get_reg_for_var(node.op_l)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.op_l)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        reg = self.memory_manager.get_reg_for_var(node.op_r)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[1], self.get_var_location(node.op_r)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[1], reg))
+
+        instructions.append(mips.JumpAndLinkNode("eq_string"))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.GetAttrNode)
+    def visit(self, node):
+        instructions = []
+
+        dest = node.dest if type(node.dest) == str else node.dest.id
+        idx = node.id if type(node.id) == str else node.id.id
+        comp_type = node.computed_type if type(
+            node.computed_type) == str else node.computed_type.id
+
+        reg = self.memory_manager.get_reg_for_var(idx)
+        if reg is None:
+            reg = ARG_REGISTERS[0]
+            instructions.append(mips.LoadWordNode(
+                reg, self.get_var_location(idx)))
+
+        tp = self._types[comp_type]
+        offset = (tp.attributes.index(node.attr) + 3) * 4
+        instructions.append(mips.LoadWordNode(
+            ARG_REGISTERS[1], RegisterRelativeLocation(reg, offset)))
+
+        reg = self.memory_manager.get_reg_for_var(dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[1], self.get_var_location(dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, ARG_REGISTERS[1]))
+
+        return instructions
+
+    @visitor.when(cil.SetAttrNode)
+    def visit(self, node):
+        instructions = []
+
+        idx = node.id if type(node.id) == str else node.id.id
+        comp_type = node.computed_type if type(
+            node.computed_type) == str else node.computed_type.name
+
+        tp = self._types[comp_type]
+        offset = (tp.attributes.index(node.attr) + 3) * 4
+
+        reg1 = self.memory_manager.get_reg_for_var(idx)
+        if reg1 is None:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0], self.get_var_location(idx)))
+
+        reg2 = None
+        if type(node.value) == int:
+            reg2 = instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[1], node.value))
+        else:
+            reg2 = self.memory_manager.get_reg_for_var(node.value)
+            if reg2 is None:
+                reg2 = ARG_REGISTERS[1]
+                instructions.append(mips.LoadWordNode(
+                    reg2, self.get_var_location(node.value)))
+
+        instructions.append(mips.StoreWordNode(
+            reg2, RegisterRelativeLocation(reg1, offset)))
+
+        return instructions
+
+    @visitor.when(cil.AllocateNode)
+    def visit(self, node):
+        instructions = []
+
+        tp = 0
+        if node.type.isnumeric():
+            tp = node.type
+        else:
+            tp = self._types[node.type].index
+
+        reg1 = self.memory_manager.get_reg_unusued()
+        reg2 = self.memory_manager.get_reg_unusued([reg1])
+        instructions.extend(push_register(reg1))
+        instructions.extend(push_register(reg2))
+
+        instructions.append(mips.LoadInmediateNode(reg1, tp))
+
+        instructions.extend(create_object(reg1, reg2))
+
+        instructions.extend(pop_register(reg2))
+        instructions.extend(pop_register(reg1))
+
+        reg3 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg3 is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg3, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.TypeOfNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1 = self.memory_manager.get_reg_for_var(node.id)
+        if reg1 is None:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadWordNode(
+                reg1, self.get_var_location(node.id)))
+
+        reg2 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg2 is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[1], RegisterRelativeLocation(reg1, 0)))
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[1], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.LoadWordNode(
+                reg2, RegisterRelativeLocation(reg1, 0)))
+
+        return instructions
+
+    @visitor.when(cil.StaticCallNode)
+    def visit(self, node):
+        instructions = []
+        label = self._name_func_map[node.function]
+        instructions.append(mips.JumpAndLinkNode(label))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        if self._pushed_args > 0:
+            instructions.append(mips.AddInmediateNode(
+                SP_REG, SP_REG, self._pushed_args * 4))
+            self.clean_pushed_args()
+        return instructions
+
+    @visitor.when(cil.DynamicCallNode)
+    def visit(self, node):
+        instructions = []
+
+        comp_tp = self._types[node.computed_type]
+        method_index = list(comp_tp.methods).index(node.function)
+        reg = self.memory_manager.get_reg_for_var(node.type)
+        if reg is None:
+            reg = ARG_REGISTERS[0]
+            instructions.append(mips.LoadWordNode(
+                reg, self.get_var_location(node.type)))
+
+        instructions.append(mips.LoadAddressNode(
+            ARG_REGISTERS[1], "proto_table"))
+        instructions.append(mips.ShiftLeftLogicalNode(
+            ARG_REGISTERS[2], reg, 2))
+        instructions.append(mips.AddUnsignedNode(
+            ARG_REGISTERS[1], ARG_REGISTERS[1], ARG_REGISTERS[2]))
+        instructions.append(mips.LoadWordNode(
+            ARG_REGISTERS[1], RegisterRelativeLocation(ARG_REGISTERS[1], 0)))
+        instructions.append(mips.LoadWordNode(
+            ARG_REGISTERS[1], RegisterRelativeLocation(ARG_REGISTERS[1], 8)))
+        instructions.append(mips.AddInmediateUnsignedNode(
+            ARG_REGISTERS[1], ARG_REGISTERS[1], method_index * 4))
+        instructions.append(mips.LoadWordNode(
+            ARG_REGISTERS[1], RegisterRelativeLocation(ARG_REGISTERS[1], 0)))
+        instructions.append(
+            mips.JumpRegisterAndLinkNode(ARG_REGISTERS[1]))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        if self._pushed_args > 0:
+            instructions.append(mips.AddInmediateNode(
+                SP_REG, SP_REG, self._pushed_args * 4))
+            self.clean_pushed_args()
+
+        return instructions
+
+    @visitor.when(cil.ArgNode)
+    def visit(self, node):
+        self.push_arg()
+        instructions = []
+        if type(node.id) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[0], node.id))
+            instructions.extend(push_register(ARG_REGISTERS[0]))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.id)
+            if reg is None:
+                reg = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg, self.get_var_location(node.id)))
+            instructions.extend(push_register(reg))
+        return instructions
+
+    @visitor.when(cil.IfGotoNode)
+    def visit(self, node):
+        instructions = []
+
+        mips_label = self.get_mips_label(node.label)
+
+        reg = self.memory_manager.get_reg_for_var(node.if_cond)
+        if reg is None:
+            reg = ARG_REGISTERS[0]
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.if_cond)))
+
+        instructions.append(mips.BranchOnNotEqualNode(
+            reg, ZERO_REG, mips_label))
+
+        return instructions
+
+    @visitor.when(cil.LabelNode)
+    def visit(self, node):
+        return [mips.LabelNode(self.get_mips_label(node.label))]
+
+    @visitor.when(cil.GotoNode)
+    def visit(self, node):
+        mips_label = self.get_mips_label(node.label)
+        return [mips.JumpNode(mips_label)]
+
+    @visitor.when(cil.ReturnNode)
+    def visit(self, node):
+        instructions = []
+
+        if node.id is None:
+            instructions.append(mips.LoadInmediateNode(V0_REG, 0))
+        elif isinstance(node.id, int):
+            instructions.append(
+                mips.LoadInmediateNode(V0_REG, node.id))
+        elif isinstance(node.id, cil.VoidNode):
+            instructions.append(mips.LoadInmediateNode(V0_REG, 0))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.id)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    V0_REG, self.get_var_location(node.id)))
+            else:
+                instructions.append(mips.MoveNode(V0_REG, reg))
+        return instructions
+
+    @visitor.when(cil.LoadNode)
+    def visit(self, node):
+        instructions = []
+
+        string_location = LabelRelativeLocation(
+            self._data_section[node.msg.id].label, 0)
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.LoadAddressNode(
+                ARG_REGISTERS[0], string_location))
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.LoadAddressNode(reg, string_location))
+
+        return instructions
+
+    @visitor.when(cil.LengthNode)
+    def visit(self, node):
+        instructions = []
+
+        reg = self.memory_manager.get_reg_for_var(node.id)
+        if reg is None:
+            reg = ARG_REGISTERS[0]
+            instructions.append(mips.LoadWordNode(
+                reg, self.get_var_location(node.id)))
+
+        instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+        instructions.append(mips.JumpAndLinkNode("len"))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.ConcatNode)
+    def visit(self, node):
+        instructions = []
+
+        reg = self.memory_manager.get_reg_for_var(node.s1)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.s1)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        reg = self.memory_manager.get_reg_for_var(node.s2)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[1], self.get_var_location(node.s2)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[1], reg))
+
+        reg = self.memory_manager.get_reg_for_var(node.length)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[2], self.get_var_location(node.lenght)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[2], reg))
+
+        instructions.append(mips.JumpAndLinkNode("concat"))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.SubstringNode)
+    def visit(self, node):
+        instructions = []
+
+        reg = self.memory_manager.get_reg_for_var(node.s)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.s)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        if type(node.i) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[1], node.i))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.i)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[1], self.get_var_location(node.i)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[1], reg))
+
+        if type(node.length) == int:
+            instructions.append(mips.LoadInmediateNode(
+                ARG_REGISTERS[2], node.length))
+        else:
+            reg = self.memory_manager.get_reg_for_var(node.length)
+            if reg is None:
+                instructions.append(mips.LoadWordNode(
+                    ARG_REGISTERS[2], self.get_var_location(node.length)))
+            else:
+                instructions.append(mips.MoveNode(ARG_REGISTERS[2], reg))
+
+        instructions.append(mips.JumpAndLinkNode("sub_string"))
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+        return instructions
+
+    @visitor.when(cil.ReadStrNode)
+    def visit(self, node):
+        instructions = []
+        instructions.append(mips.JumpAndLinkNode("get_string"))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.PrintStrNode)
+    def visit(self, node):
+        instructions = []
+        instructions.append(mips.LoadInmediateNode(V0_REG, 4))
+
+        reg = self.memory_manager.get_reg_for_var(node.value)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0]. self.get_var_location(node.value)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+        instructions.append(mips.SyscallNode())
+
+        return instructions
+
+    @visitor.when(cil.ErrorNode)
+    def visit(self, node):
+        instructions = []
+
+        mips_label = self._data_section[node.data_node.id].label
+
+        instructions.append(mips.LoadInmediateNode(V0_REG, 4))
+        instructions.append(mips.LoadAddressNode(
+            ARG_REGISTERS[0], mips_label))
+        instructions.append(mips.SyscallNode())
+        instructions.append(mips.LoadInmediateNode(V0_REG, 10))
+        instructions.append(mips.SyscallNode())
+
+        return instructions
+
+    @visitor.when(cil.TypeNameNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1 = self.memory_manager.get_reg_for_var(node.type)
+        pushed = False
+        if reg1 is None:
+            reg1 = self.memory_manager.get_reg_unusued()
+            instructions.extend(push_register(reg1))
+            instructions.append(mips.LoadWordNode(
+                reg1, self.get_var_location(node.type)))
+            pushed = True
+
+        instructions.append(mips.LoadWordNode(
+            ARG_REGISTERS[0], RegisterRelativeLocation(reg1, 0)))
+
+        if pushed:
+            instructions.extend(pop_register(reg1))
+
+        instructions.append(mips.ShiftLeftLogicalNode(
+            ARG_REGISTERS[0], ARG_REGISTERS[0], 2))
+        instructions.append(mips.LoadAddressNode(
+            ARG_REGISTERS[1], "type_name_table"))
+        instructions.append(mips.AddUnsignedNode(
+            ARG_REGISTERS[0], ARG_REGISTERS[0], ARG_REGISTERS[1]))
+        instructions.append(mips.LoadWordNode(
+            ARG_REGISTERS[0], RegisterRelativeLocation(ARG_REGISTERS[0], 0)))
+
+        reg2 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg2 is None:
+            instructions.append(mips.StoreWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg2, ARG_REGISTERS[0]))
+
+        return instructions
+
+    @visitor.when(cil.NameNode)
+    def visit(self, node):
+        instructions = []
+
+        save = False
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            reg = ARG_REGISTERS[0]
+            save = True
+
+        instructions.append(mips.LoadAddressNode(
+            reg, "type_name_table"))
+
+        tp_number = self._types[node.id].index
+        instructions.append(
+            mips.AddInmediateUnsignedNode(reg, reg, tp_number*4))
+        instructions.append(mips.LoadWordNode(
+            reg, RegisterRelativeLocation(reg, 0)))
+
+        if save:
+            instructions.append(mips.StoreWordNode(
+                reg, self.get_var_location(node.dest)))
+
+        return instructions
+
+    @visitor.when(cil.AbortNode)
+    def visit(self, node):
+        instructions = []
+        instructions.append(mips.LoadInmediateNode(V0_REG, 10))
+        instructions.append(mips.SyscallNode())
+
+        return instructions
+
+    @visitor.when(cil.CopyNode)
+    def visit(self, node):
+        instructions = []
+
+        pushed = False
+        reg = self.memory_manager.get_reg_for_var(node.copy)
+        if reg is None:
+            reg = self.memory_manager.get_reg_unusued()
+            instructions.extend(push_register(reg))
+            instructions.append(mips.LoadWordNode(
+                reg, self.get_var_location(node.copy)))
+            pushed = True
+
+        instructions.extend(copy_object(reg, ARG_REGISTERS[3]))
+
+        if pushed:
+            instructions.extend(pop_register(reg))
+
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.ReadIntNode)
+    def visit(self, node):
+        instructions = []
+
+        instructions.append(mips.LoadInmediateNode(V0_REG, 5))
+        instructions.append(mips.SyscallNode())
+        reg = self.memory_manager.get_reg_for_var(node.dest)
+        if reg is None:
+            instructions.append(mips.StoreWordNode(
+                V0_REG, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.MoveNode(reg, V0_REG))
+
+        return instructions
+
+    @visitor.when(cil.PrintIntNode)
+    def visit(self, node):
+        instructions = []
+        instructions.append(mips.LoadInmediateNode(V0_REG, 1))
+
+        reg = self.memory_manager.get_reg_for_var(node.value)
+        if reg is None:
+            instructions.append(mips.LoadWordNode(
+                ARG_REGISTERS[0], self.get_var_location(node.value)))
+        else:
+            instructions.append(mips.MoveNode(ARG_REGISTERS[0], reg))
+
+        instructions.append(mips.SyscallNode())
+
+        return instructions
+
+    @visitor.when(cil.ComplementNode)
+    def visit(self, node):
+        instructions = []
+
+        reg1 = None
+
+        if type(node.id) == int:
+            reg1 = ARG_REGISTERS[0]
+            instructions.append(mips.LoadInmediateNode(reg1, node.id))
+        else:
+            reg1 = self.memory_manager.get_reg_for_var(node.id)
+            if reg1 is None:
+                reg1 = ARG_REGISTERS[0]
+                instructions.append(mips.LoadWordNode(
+                    reg1, self.get_var_location(node.id)))
+
+        reg2 = self.memory_manager.get_reg_for_var(node.dest)
+        if reg2 is None:
+            reg2 = ARG_REGISTERS[1]
+            instructions.append(mips.ComplementNode(reg2, reg1))
+            instructions.append(mips.AddInmediateNode(reg2, reg2, 1))
+            instructions.append(mips.StoreWordNode(
+                reg2, self.get_var_location(node.dest)))
+        else:
+            instructions.append(mips.ComplementNode(reg2, reg1))
+            instructions.append(mips.AddInmediateNode(reg2, reg2, 1))
+
+        return instructions
diff --git a/src/utils/code_generation/mips/print_MIPS_AST.py b/src/utils/code_generation/mips/print_MIPS_AST.py
new file mode 100644
index 000000000..4c807ad54
--- /dev/null
+++ b/src/utils/code_generation/mips/print_MIPS_AST.py
@@ -0,0 +1,1396 @@
+from utils.code_generation.mips.AST_MIPS import *
+import cmp.visitor as visitor
+from utils.code_generation.mips.AST_MIPS import mips_ast as nodes
+from utils.code_generation.mips.utils_mips import *
+
+
+class PrintMIPS:
+
+    @visitor.on('node')
+    def visit(self, node):
+        pass
+
+    @visitor.when(nodes.ProgramNode)
+    def visit(self, node):
+        data_section_header = "\t.data"
+        static_strings = '\n'.join([self.visit(string_const)
+                                   for string_const in node.data])
+
+        names_table = f'{"type_name_table"}:\n' + \
+            "\n".join(
+                [f"\t.word\t{tp.string_name_label}" for tp in node.types])
+        proto_table = f'{"proto_table"}:\n' + \
+            "\n".join([f"\t.word\t{tp.label}_proto" for tp in node.types])
+
+        types = "\n\n".join([self.visit(tp) for tp in node.types])
+
+        code = "\n".join([self.visit(func) for func in node.functions])
+        return f'{data_section_header}\n{static_strings}\n\n{names_table}\n\n{proto_table}\n\n{types}\n\t.text\n\t.globl main\n{code}\n\n{mips_static_code()}'
+
+    @visitor.when(nodes.FunctionNode)
+    def visit(self, node):
+        instr = [self.visit(instruction) for instruction in node.instructions]
+        instr2 = [inst for inst in instr if type(inst) == str]
+        instructions = "\n\t".join(instr2)
+        return f'{node.label}:\n\t{instructions}'
+
+    @visitor.when(nodes.AddNode)
+    def visit(self, node):
+        return f"add {self.visit(node.reg1)} {self.visit(node.reg2)} {self.visit(node.reg3)}"
+
+    @visitor.when(nodes.SubNode)
+    def visit(self, node):
+        return f"sub {self.visit(node.reg1)} {self.visit(node.reg2)} {self.visit(node.reg3)}"
+
+    @visitor.when(nodes.MultiplyNode)
+    def visit(self, node):
+        return f"mul {self.visit(node.reg1)} {self.visit(node.reg2)} {self.visit(node.reg3)}"
+
+    @visitor.when(nodes.DivideNode)
+    def visit(self, node):
+        return f"div {self.visit(node.reg1)} {self.visit(node.reg2)}"
+
+    @visitor.when(nodes.LabelNode)
+    def visit(self, node):
+        return f"{node.name}:"
+
+    @visitor.when(nodes.ComplementNode)
+    def visit(self, node):
+        return f"not {self.visit(node.reg1)} {self.visit(node.reg2)}"
+
+    @visitor.when(nodes.StringConst)
+    def visit(self, node):
+        return f'{node.label}: .asciiz "{node.string}"'
+
+    @visitor.when(nodes.MoveNode)
+    def visit(self, node):
+        return f'move {self.visit(node.reg1)} {self.visit(node.reg2 )}'
+
+    @visitor.when(nodes.LoadInmediateNode)
+    def visit(self, node):
+        return f'li {self.visit(node.reg)}, {self.visit(node.value)}'
+
+    @visitor.when(nodes.LoadWordNode)
+    def visit(self, node):
+        return f'lw {self.visit(node.reg)}, {self.visit(node.addr)}'
+
+    @visitor.when(nodes.SyscallNode)
+    def visit(self, node):
+        return 'syscall'
+
+    @visitor.when(nodes.LoadAddressNode)
+    def visit(self, node):
+        return f'la {self.visit(node.reg)}, {self.visit(node.label)}'
+
+    @visitor.when(nodes.StoreWordNode)
+    def visit(self, node):
+        return f'sw {self.visit(node.reg)}, {self.visit(node.addr)}'
+
+    @visitor.when(nodes.JumpAndLinkNode)
+    def visit(self, node):
+        return f'jal {node.label}'
+
+    @visitor.when(nodes.JumpRegisterAndLinkNode)
+    def visit(self, node):
+        return f'jal {self.visit(node.reg)}'
+
+    @visitor.when(nodes.JumpRegisterNode)
+    def visit(self, node):
+        return f'jr {self.visit(node.reg)}'
+
+    @visitor.when(nodes.AddInmediateNode)
+    def visit(self, node):
+        return f'addi {self.visit(node.dest)}, {self.visit(node.src)}, {self.visit(node.value)}'
+
+    @visitor.when(nodes.AddInmediateUnsignedNode)
+    def visit(self, node):
+        return f"addiu {self.visit(node.dest)} {self.visit(node.src)} {self.visit(node.value)}"
+
+    @visitor.when(nodes.AddUnsignedNode)
+    def visit(self, node):
+        return f"addu {self.visit(node.dest)} {self.visit(node.sum1)} {self.visit(node.sum2)}"
+
+    @visitor.when(nodes.ShiftLeftLogicalNode)
+    def visit(self, node):
+        return f"sll {self.visit(node.dest)} {self.visit(node.src)} {node.bits}"
+
+    @visitor.when(nodes.BranchOnNotEqualNode)
+    def visit(self, node):
+        return f"bne {self.visit(node.reg1)} {self.visit(node.reg2)} {node.label}"
+
+    @visitor.when(nodes.JumpNode)
+    def visit(self, node):
+        return f"j {node.label}"
+
+    @visitor.when(nodes.MoveFromLowNode)
+    def visit(self, node):
+        return f"mflo {self.visit(node.reg)}"
+
+    @visitor.when(Register)
+    def visit(self, node):
+        return f'${node.name}'
+
+    @visitor.when(LabelRelativeLocation)
+    def visit(self, node):
+        return f'{node.label} + {node.offset}'
+
+    @visitor.when(RegisterRelativeLocation)
+    def visit(self, node):
+        return f'{node.offset}({self.visit(node.register)})'
+
+    @visitor.when(MIPSType)
+    def visit(self, node):
+        methods = "\n".join(
+            [f"\t.word\t {node.methods[k]}" for k in node.methods])
+        dispatch_table = f"{node.label}_dispatch:\n{methods}"
+        proto_begin = f"{node.label}_proto:\n\t.word\t{node.index}\n\t.word\t{node.size}\n\t.word\t{node.label}_dispatch"
+        proto_attr = "\n".join(
+            [f'\t.word\t{node._default_attributes.get(attr, "0")}' for attr in node.attributes])
+        proto_finish = f"\t.word\t{-1}"
+        proto = f"{proto_begin}\n{proto_attr}\n{proto_finish}" if proto_attr != "" else f"{proto_begin}\n{proto_finish}"
+
+        return f'{dispatch_table}\n\n{proto}'
+
+    @visitor.when(int)
+    def visit(self, node):
+        return str(node)
+
+    @visitor.when(str)
+    def visit(self, node):
+        return node
+
+
+def mips_static_code():
+    return \
+        local_vars() +\
+        verify_obj() +\
+        verify_obj_not_obj() +\
+        verify_obj_is_obj() +\
+        verify_obj_finish() +\
+        concat() +\
+        concat_size_alligned() +\
+        concat_allign_size() +\
+        concat_copy_first_cycle() +\
+        concat_copy_second_cycle() +\
+        concat_finish() +\
+        copy() +\
+        copy_cycle() +\
+        copy_finish() +\
+        eqs() +\
+        eqs_eq() +\
+        eqs_finish() +\
+        eq_string() +\
+        eq_string_cycle() +\
+        eq_string_not_eq() +\
+        eq_string_eq() +\
+        eq_string_finish() +\
+        extend_block() +\
+        extend_block_extend() +\
+        extend_block_finish() +\
+        extend_heap() +\
+        free_block() +\
+        free_block_cycle_used_list() +\
+        free_block_cycle_free_list() +\
+        free_block_founded_prev() +\
+        free_block_finish() +\
+        get_gc() +\
+        get_gc_cycle() +\
+        get_gc_dfs() +\
+        get_gc_outer_cycle() +\
+        get_gc_extend() +\
+        get_gc_free() +\
+        get_gc_free_cycle() +\
+        get_gc_free_cycle_free() +\
+        get_gc_finish() +\
+        get_gc_rec_extend() +\
+        get_gc_rec_extend_attr_cycle() +\
+        get_gc_rec_extend_string_obj() +\
+        get_gc_rec_extend_finish() +\
+        less_eq() +\
+        less_eq_true() +\
+        less_eq_finish() +\
+        less() +\
+        less_true() +\
+        less_finish() +\
+        lenx() +\
+        len_cycle() +\
+        len_finish() +\
+        malloc() +\
+        malloc_finish() +\
+        malloc_cycle() +\
+        malloc_search_finish() +\
+        malloc_alloc_new_block() +\
+        malloc_big_block() +\
+        malloc_verify_valid_block() +\
+        malloc_valid_block() +\
+        malloc_first_valid_block() +\
+        mem_manager_init() + \
+        get_string() +\
+        get_string_larger_block_cycle() +\
+        get_string_reading() +\
+        get_string_look_nl() +\
+        get_string_zero_founded() +\
+        get_string_nl_founded() +\
+        get_string_nl_founded_alligned() +\
+        get_string_no_nl() +\
+        get_string_dup() +\
+        get_string_extend_heap() +\
+        get_string_last_block_cycle() +\
+        get_string_last_block_founded() +\
+        get_string_copy_prev() +\
+        get_string_copy_cycle() +\
+        get_string_copy_finish() +\
+        get_string_finish() +\
+        get_string_new_block() +\
+        get_string_new_block_search_last() +\
+        get_string_new_block_create() +\
+        get_string_new_block_extended() +\
+        divide_block() +\
+        divide_block_same_size() +\
+        divide_block_error_small() +\
+        divide_block_finish() +\
+        sub_string() +\
+        sub_string_allign_size() +\
+        sub_string_new_block() +\
+        sub_string_copy_cycle() +\
+        sub_string_finish() +\
+        use_block() +\
+        use_block_cycle() +\
+        use_block_founded() +\
+        use_block_finish()
+
+
+# Mips labels
+
+def local_vars():
+    return '''
+    
+    alloc_size       = 2048
+    free_list = 0
+    header_size = 12
+    header_size_slot = 0
+    header_next_slot = 4
+    header_reachable_slot = 8
+    init_alloc_size = 28
+    int_type = 0
+    meta_data_obj_size = 4
+    neg_header_size = -12
+    new_line = 10
+    obj_mark = -1
+    obj_extended = -2
+    reachable = 1
+    state_size = 4
+    stack_base = -4
+    string_size_treshold = 1024
+    string_type = 0
+    total_alloc_size =  2060
+    num_type = 0
+    used_list = header_size\n\n'''
+
+
+def verify_obj():
+    return '''verify_obj:
+                addiu $sp $sp -20
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+
+                move $t0 $a0
+
+                li $v0 9
+                move $a0 $zero
+                syscall
+
+                addiu $t1 $v0 -4    
+
+                
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)
+                blt $t2 $zero verify_obj_not_obj
+                la $t3 num_type
+                lw $t3 0($t3)
+                bge $t2 $t3 verify_obj_not_obj
+
+                addiu $t0 $t0 4
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)   
+
+                addiu $t0 $t0 8
+                
+
+                li $t3 meta_data_obj_size
+                sub $t2 $t2 $t3 
+                sll $t2 $t2 2
+                addu $t0 $t0 $t2
+                
+                
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)
+                beq $t2 obj_mark verify_obj_is_obj
+                beq $t2 obj_extended verify_obj_is_obj\n\n'''
+
+
+def verify_obj_not_obj():
+    return '''verify_obj_not_obj:
+                li $v0 0
+                j verify_obj_finish\n\n'''
+
+
+def verify_obj_is_obj():
+    return '''verify_obj_is_obj:
+                li $v0 1\n\n'''
+
+
+def verify_obj_finish():
+    return '''verify_obj_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                addiu $sp $sp 20
+
+                jr $ra\n\n'''
+
+
+def concat():
+    return '''concat:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $a0 12($sp)
+                sw $a1 16($sp)
+                sw $ra 20($sp)
+
+                move $t0 $a0
+                move $t1 $a1
+
+
+                addiu $a0 $a2 1
+                li $t2 4
+                div $a0 $t2
+                mfhi $a0
+                bne $a0 $zero concat_allign_size
+                addiu $a0 $a2 1\n\n'''
+
+
+def concat_size_alligned():
+    return '''concat_size_alligned:
+                jal malloc
+                move $t2 $v0
+                j concat_copy_first_cycle\n\n'''
+
+
+def concat_allign_size():
+    return '''concat_allign_size:
+                sub $t2 $t2 $a0
+                add $a0 $a2 $t2
+                addiu $a0 $a0 1
+                j concat_size_alligned\n\n'''
+
+
+def concat_copy_first_cycle():
+    return '''concat_copy_first_cycle:
+                lb $a0 0($t0)
+                beq $a0 $zero concat_copy_second_cycle
+                sb $a0 0($t2)
+                addiu $t0 $t0 1
+                addiu $t2 $t2 1
+                j concat_copy_first_cycle\n\n'''
+
+
+def concat_copy_second_cycle():
+    return '''concat_copy_second_cycle:
+                lb $a0 0($t1)
+                beq $a0 $zero concat_finish
+                sb $a0 0($t2)
+                addiu $t1 $t1 1
+                addiu $t2 $t2 1
+                j concat_copy_second_cycle\n\n'''
+
+
+def concat_finish():
+    return '''concat_finish:
+                sb $zero 0($t2)
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $a0 12($sp)
+                lw $a1 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra\n\n'''
+
+
+def copy():
+    return '''copy:
+                addiu $sp $sp -16
+                sw $a0 0($sp)
+                sw $a1 4($sp)
+                sw $a2 8($sp)
+                sw $t0 12($sp)\n\n'''
+
+
+def copy_cycle():
+    return '''copy_cycle:
+                beq $a2 $zero copy_finish
+                lw $t0 0($a0)
+                sw $t0 0($a1)
+                addiu $a0 $a0 4
+                addiu $a1 $a1 4
+                addi $a2 $a2 -4
+                j copy_cycle\n\n'''
+
+
+def copy_finish():
+    return '''copy_finish:
+                lw $a0 0($sp)
+                lw $a1 4($sp)
+                lw $a2 8($sp)
+                lw $t0 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra\n\n'''
+
+
+def eqs():
+    return '''eqs:
+                beq $a0 $a1 eqs_eq
+                li $v0 0
+                j eqs_finish\n\n'''
+
+
+def eqs_eq():
+    return '''eqs_eq:
+                li $v0 1\n\n'''
+
+
+def eqs_finish():
+    return '''eqs_finish:
+                jr $ra\n\n'''
+
+
+def eq_string():
+    return '''eq_string:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+
+                move $t0 $a0
+                move $t1 $a1\n\n'''
+
+
+def eq_string_cycle():
+    return '''eq_string_cycle:
+                lb $t2 0($t0)
+                lb $t3 0($t1)
+                bne $t2 $t3 eq_string_not_eq
+                beq $t2 $zero eq_string_eq
+
+                addiu $t0 $t0 1
+                addiu $t1 $t1 1
+                j eq_string_cycle\n\n'''
+
+
+def eq_string_not_eq():
+    return '''eq_string_not_eq:
+                move $v0 $zero
+                j eq_string_finish\n\n'''
+
+
+def eq_string_eq():
+    return '''eq_string_eq:
+                li $v0 1\n\n'''
+
+
+def eq_string_finish():
+    return '''eq_string_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra\n\n'''
+
+
+def extend_block():
+    return '''extend_block:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+
+                
+                addiu $t0 $gp free_list     
+
+                beq $t0 $a0 extend_block_finish  
+                move $t0 $a0
+
+                lw $t1 header_next_slot($t0)
+                lw $t2 header_size_slot($t0)
+                move $t3 $t2
+                addiu $t2 $t2 header_size
+                addu $t2 $t2 $t0
+                beq $t2 $t1 extend_block_extend
+                j extend_block_finish\n\n'''
+
+
+def extend_block_extend():
+    return '''extend_block_extend:
+                lw $t2 header_size_slot($t1)
+                addi $t2 $t2 header_size
+                add $t2 $t2 $t3
+                sw $t2 header_size_slot($t0)
+                lw $t1 header_next_slot($t1)
+                sw $t1 header_next_slot($t0)\n\n'''
+
+
+def extend_block_finish():
+    return '''extend_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra\n\n'''
+
+
+def extend_heap():
+    return '''extend_heap:
+                addiu $sp $sp -12
+                sw $a0 0($sp)
+                sw $a1 4($sp)
+                sw $t0 8($sp)
+
+                
+                li $v0 9
+                addiu $a0 $a1 header_size
+                syscall
+                
+                
+                move $t0 $a1 
+                sw $t0 header_size_slot($v0)
+                sw $zero header_next_slot($v0)
+                sw $zero header_reachable_slot($v0)
+
+               
+                lw $t0, 0($sp)
+                sw $v0 header_next_slot($t0)
+
+                move $a0 $t0
+                lw $a1 4($sp)
+                lw $t0 8($sp)
+                addiu $sp $sp 12
+
+                jr $ra\n\n'''
+
+
+def free_block():
+    return '''free_block:
+                addiu $sp $sp -28
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $a0 12($sp)
+                sw $ra 16($sp)
+                sw $t3 20($sp)
+                sw $t4 24($sp)
+
+                move $t0 $a0
+
+                addiu $t1 $gp free_list
+
+                addiu $t3 $gp used_list\n\n'''
+
+
+def free_block_cycle_used_list():
+    return '''free_block_cycle_used_list:
+                lw $t4 header_next_slot($t3)
+                beq $t4 $t0 free_block_cycle_free_list
+                move $t3 $t4
+                j free_block_cycle_used_list\n\n'''
+
+
+def free_block_cycle_free_list():
+    return '''free_block_cycle_free_list:
+                lw $t2 header_next_slot($t1)
+                beq $t2 $zero free_block_founded_prev
+                bge $t2 $t0 free_block_founded_prev
+                move $t1 $t2
+                j free_block_cycle_free_list\n\n'''
+
+
+def free_block_founded_prev():
+    return '''free_block_founded_prev:  
+                lw $t4 header_next_slot($t0)
+                sw $t4 header_next_slot($t3)
+                
+                
+                sw $t2 header_next_slot($t0)
+                sw $t0 header_next_slot($t1)\n\n'''
+
+
+def free_block_finish():
+    return '''free_block_finish:
+    
+                move $a0 $t0
+                jal extend_block
+                move $a0 $t1
+                jal extend_block
+
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $a0 12($sp)
+                lw $ra 16($sp)
+                lw $t3 20($sp)
+                lw $t4 24($sp)
+                addiu $sp $sp 28
+
+                jr $ra\n\n'''
+
+
+def get_gc():
+    return '''get_gc:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+                sw $ra 20($sp)
+
+                li $t3 reachable    
+                addiu $t0 $sp 20    
+                lw $t1 stack_base($gp)  
+
+                li $t2 1\n\n'''
+
+
+def get_gc_cycle():
+    return '''get_gc_cycle:
+
+                addiu $t0 $t0 4
+                beq $t0 $t1 get_gc_dfs      
+                
+                lw $a0 0($t0)
+                jal verify_obj
+                
+                bne $v0 $t2 get_gc_cycle
+
+                addiu $a0 $a0 neg_header_size
+                sw $t3 header_reachable_slot($a0)
+                
+                j get_gc_cycle\n\n'''
+
+
+def get_gc_dfs():
+    return '''get_gc_dfs:
+                addiu $t1 $gp used_list\n\n'''
+
+
+def get_gc_outer_cycle():
+    return '''get_gc_outer_cycle:
+                lw $t1 header_next_slot($t1)
+                beq $t1 $zero get_gc_free
+                lw $t2 header_reachable_slot($t1)
+                beq $t2 reachable get_gc_extend
+                j get_gc_outer_cycle\n\n'''
+
+
+def get_gc_extend():
+    return '''get_gc_extend:
+                addiu $a0 $t1 header_size    
+                jal get_gc_rec_extend
+                j get_gc_outer_cycle\n\n'''
+
+
+def get_gc_free():
+    return '''get_gc_free:
+                addiu $t0 $gp used_list
+                lw $t0 header_next_slot($t0)\n\n'''
+
+
+def get_gc_free_cycle():
+    return '''get_gc_free_cycle:
+                beq $t0 $zero get_gc_finish
+                lw $t1 header_reachable_slot($t0)
+                bne $t1 reachable get_gc_free_cycle_free
+                sw $zero header_reachable_slot($t0)
+                move $a0 $t0
+                jal verify_obj
+                beq $v0 $zero get_gc_free_cycle
+                li $t1 obj_mark
+                addiu $t2 $t0 header_size
+                lw $t3 4($t2)
+                sll $t3 $t3 2
+                addu $t2 $t2 $t3
+                sw $t1 -4($t2)
+                lw $t0 header_next_slot($t0)
+                j get_gc_free_cycle\n\n'''
+
+
+def get_gc_free_cycle_free():
+    return '''get_gc_free_cycle_free:
+                move $a0 $t0
+                lw $t0 header_next_slot($t0)
+                jal free_block
+                j get_gc_free_cycle\n\n'''
+
+
+def get_gc_finish():
+    return '''get_gc_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra\n\n'''
+
+
+def get_gc_rec_extend():
+    return '''get_gc_rec_extend:
+                addiu $sp $sp -16
+                sw $a0 0($sp)
+                sw $t0 4($sp)
+                sw $t1 8($sp)
+                sw $ra 12($sp)
+                
+                jal verify_obj 
+                beq $v0 $zero get_gc_rec_extend_finish
+
+                lw $t0 4($a0)
+                sll $t0 $t0 2
+                addiu $t0 $t0 -4
+                addu $t0 $a0 $t0
+                lw $t1 0($t0)   
+                beq $t1 obj_extended get_gc_rec_extend_finish
+                
+                
+                li $t1 reachable
+                addiu $a0 $a0 neg_header_size
+                sw $t1 header_reachable_slot($a0)
+                addiu $a0 $a0 header_size 
+
+                
+                li $t1 obj_extended
+                sw $t1 0($t0)
+
+                lw $t0 0($a0)   
+                
+                
+                la $t1 int_type
+                lw $t1 0($t1)
+                beq $t0 $t1 get_gc_rec_extend_finish
+
+                la $t1 string_type
+                lw $t1 0($t1)
+                beq $t0 $t1 get_gc_rec_extend_string_obj
+
+                lw $t0 4($a0)
+                li $t1 meta_data_obj_size
+                sub $t0 $t0 $t1
+                
+                addiu $t1 $a0 12\n\n'''
+
+
+def get_gc_rec_extend_attr_cycle():
+    return '''get_gc_rec_extend_attr_cycle:
+                beq $t0 $zero get_gc_rec_extend_finish
+                lw $a0 0($t1)
+                jal get_gc_rec_extend
+                addiu $t1 $t1 4
+                sub $t0 $t0 1
+                j get_gc_rec_extend_attr_cycle\n\n'''
+
+
+def get_gc_rec_extend_string_obj():
+    return '''get_gc_rec_extend_string_obj:
+                lw $t0 8($a0)
+                addiu $t0 $t0 neg_header_size
+                li $t1 reachable
+                sw $t1 header_reachable_slot($t0)\n\n'''
+
+
+def get_gc_rec_extend_finish():
+    return '''get_gc_rec_extend_finish:
+                lw $a0 0($sp)
+                lw $t0 4($sp)
+                lw $t1 8($sp)
+                lw $ra 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra\n\n'''
+
+
+def less_eq():
+    return '''less_eq:
+                ble $a0 $a1 less_eq_true
+                li $v0 0
+                j less_eq_finish\n\n'''
+
+
+def less_eq_true():
+    return '''less_eq_true:
+                li $v0 1\n\n'''
+
+
+def less_eq_finish():
+    return '''less_eq_finish:
+                jr $ra\n\n'''
+
+
+def less():
+    return '''less:
+                blt $a0 $a1 less_true
+                li $v0 0
+                j less_finish\n\n'''
+
+
+def less_true():
+    return '''less_true:
+                li $v0 1\n\n'''
+
+
+def less_finish():
+    return '''less_finish:
+                jr $ra\n\n'''
+
+
+def lenx():
+    return '''len:
+                addiu $sp $sp -8
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+
+                move $t0 $a0
+                move $v0 $zero\n\n'''
+
+
+def len_cycle():
+    return '''len_cycle:
+                lb $t1 0($t0)
+                beq $t1 $zero len_finish
+                addi $v0 $v0 1
+                addiu $t0 $t0 1
+                j len_cycle\n\n'''
+
+
+def len_finish():
+    return '''len_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                addiu $sp $sp 8
+
+                jr $ra\n\n'''
+
+
+def malloc():
+    return '''malloc:
+                move $v0 $zero
+                addiu $sp $sp -28
+                sw $t1 0($sp)
+                sw $t0 4($sp)
+                sw $a0 8($sp)
+                sw $a1 12($sp)
+                sw $ra 16($sp)
+                sw $t2 20($sp)
+                sw $t3 24($sp)
+                
+                addiu $t0 $gp free_list
+                j malloc_cycle\n\n'''
+
+
+def malloc_finish():
+    return '''malloc_finish:
+                move $a0 $v0
+                lw $a1 8($sp)                  
+                jal divide_block
+
+                lw $t1 header_next_slot($v0)
+                sw $t1 header_next_slot($t3)
+
+                addiu $t1 $gp used_list
+                lw $a0 header_next_slot($t1)
+
+                sw $a0 header_next_slot($v0)
+                sw $v0 header_next_slot($t1)
+                
+                addiu $v0 $v0 header_size
+
+                lw $t3 24($sp)
+                lw $t2 20($sp)
+                lw $ra 16($sp)
+                lw $a1 12($sp)
+                lw $a0 8($sp)
+                lw $t0 4($sp)
+                lw $t1 0($sp)
+                addiu $sp $sp 28
+
+                jr $ra\n\n'''
+
+
+def malloc_cycle():
+    return '''malloc_cycle:
+                move $t2 $t0                        
+                lw $t0 header_next_slot($t0)        
+                beq $t0 $zero malloc_search_finish     
+                j malloc_verify_valid_block\n\n'''
+
+
+def malloc_search_finish():
+    return '''malloc_search_finish:
+                beq $v0 $zero malloc_alloc_new_block 
+                j malloc_finish\n\n'''
+
+
+def malloc_alloc_new_block():
+    return '''malloc_alloc_new_block:
+                li $t1 alloc_size               
+                move $t3 $t2
+                move $a1 $a0                    
+                move $a0 $t2                    
+                bge $a1 $t1 malloc_big_block    
+                li $a1 alloc_size        
+                jal extend_heap
+                
+                j malloc_finish\n\n'''
+
+
+def malloc_big_block():
+    return '''malloc_big_block:
+                jal extend_heap
+                j malloc_finish\n\n'''
+
+
+def malloc_verify_valid_block():
+    return '''malloc_verify_valid_block:
+                lw $t1 header_size_slot($t0)             
+                bge $t1 $a0 malloc_valid_block    
+                j malloc_cycle\n\n'''
+
+
+def malloc_valid_block():
+    return '''malloc_valid_block:
+                beq $v0 $zero malloc_first_valid_block    
+                bge $t1 $v1 malloc_cycle                    
+                move $v0 $t0                        
+                move $v1 $t1  
+                move $t3 $t2
+                j malloc_cycle\n\n'''
+
+
+def malloc_first_valid_block():
+    return '''malloc_first_valid_block:
+                move $v0 $t0                        
+                move $v1 $t1                        
+                move $t3 $t2 
+                j malloc_cycle\n\n'''
+
+
+def mem_manager_init():
+    return '''mem_manager_init:
+                addiu $sp $sp -16
+                sw $v0 0($sp)
+                sw $a0 4($sp)
+                sw $a1 8($sp)
+                sw $ra 12($sp)
+                li $v0 9
+                li $a0 init_alloc_size
+                syscall
+                move $gp $v0
+                addiu $gp $gp state_size
+
+                sw $zero header_size_slot($gp)
+                sw $zero header_reachable_slot($gp)
+
+                move $a0 $gp
+                li $a1 alloc_size
+                jal extend_heap
+
+                addiu $a0 $a0 header_size
+                sw $zero header_size_slot($a0)
+                sw $zero header_next_slot($a0)
+                sw $zero header_reachable_slot($a0)
+
+
+
+                lw $v0 0($sp)
+                lw $a0 4($sp)
+                lw $a1 8($sp)
+                lw $ra 12($sp)
+                addiu $sp $sp 16
+
+                sw $sp stack_base($gp)
+
+                jr $ra\n\n'''
+
+
+def get_string():
+    return '''get_string:
+                addiu $sp $sp -36
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $t4 16($sp)
+                sw $t5 20($sp)
+                sw $a0 24($sp)
+                sw $a1 28($sp)
+                sw $ra 32($sp)
+                
+                addiu $t0 $gp free_list
+                move $t1 $zero
+                move $t2 $t0\n\n'''
+
+
+def get_string_larger_block_cycle():
+    return '''get_string_larger_block_cycle:
+                lw $t0 header_next_slot($t0)
+                beq $t0 $zero get_string_reading
+                lw $t3 header_size_slot($t0)
+                bge $t1 $t3 get_string_larger_block_cycle
+                move $t1 $t3
+                move $t2 $t0
+                j get_string_larger_block_cycle\n\n'''
+
+
+def get_string_reading():
+    return '''get_string_reading:
+                beq $t1 $zero get_string_new_block
+                move $a1 $t1
+                li $v0 8
+                addiu $a0 $t2 header_size
+                syscall
+                move $t0 $a0
+                move $t1 $zero\n\n'''
+
+
+def get_string_look_nl():
+    return '''get_string_look_nl:
+                lb $t2 0($t0)
+                beq $t2 new_line get_string_nl_founded
+                beq $t2 $zero get_string_zero_founded
+                addi $t1 $t1 1
+                addi $t0 $t0 1
+                j get_string_look_nl\n\n'''
+
+
+def get_string_zero_founded():
+    return '''get_string_zero_founded:
+                blt $t1 $t3 get_string_nl_founded
+                j get_string_no_nl\n\n'''
+
+
+def get_string_nl_founded():
+    return '''get_string_nl_founded:
+                sb $zero 0($t0)
+                addi $t1 $t1 1
+                li $t2 4
+                div $t1 $t2
+                mfhi $t3
+                beq $t3 $zero get_string_nl_founded_alligned
+                sub $t2 $t2 $t3
+                add $t1 $t1 $t2\n\n'''
+
+
+def get_string_nl_founded_alligned():
+    return '''get_string_nl_founded_alligned:
+                move $a1 $t1
+                addiu $a0 $a0 neg_header_size
+                jal divide_block
+                jal use_block
+
+                addiu $v0 $a0 header_size
+                j get_string_finish\n\n'''
+
+
+def get_string_no_nl():
+    return '''get_string_no_nl:
+                addi $t1 $t1 1
+                blt $t1 string_size_treshold get_string_dup
+                addi $t1 $t1 alloc_size
+                j get_string_extend_heap\n\n'''
+
+
+def get_string_dup():
+    return '''get_string_dup:
+	            sll $t1 $t1 1\n\n'''
+
+
+def get_string_extend_heap():
+    return '''get_string_extend_heap:
+                move $a1 $t1
+                move $t0 $a0
+                addiu $a0 $gp free_list\n\n'''
+
+
+def get_string_last_block_cycle():
+    return '''get_string_last_block_cycle:
+                lw $t1 header_next_slot($a0)
+                beq $t1 $zero get_string_last_block_founded
+                lw $a0 header_next_slot($a0)
+                j get_string_last_block_cycle\n\n'''
+
+
+def get_string_last_block_founded():
+    return '''get_string_last_block_founded:
+                jal extend_heap
+                jal extend_block
+                lw $t1 header_next_slot($a0)
+                bne $t1 $zero get_string_copy_prev
+                move $t1 $a0\n\n'''
+
+
+def get_string_copy_prev():
+    return '''get_string_copy_prev:
+                lw $t3 header_size_slot($t1)
+                move $t2 $zero
+                move $t5 $t1
+                addiu $t1 $t1 header_size\n\n'''
+
+
+def get_string_copy_cycle():
+    return '''get_string_copy_cycle:
+                lb $t4 0($t0)
+                beq $t4 $zero get_string_copy_finish
+                sb $t4 0($t1)
+                addi $t2 $t2 1
+                addi $t0 $t0 1
+                addi $t1 $t1 1
+                j get_string_copy_cycle\n\n'''
+
+
+def get_string_copy_finish():
+    return '''get_string_copy_finish:
+                sub $t3 $t3 $t2
+                move $a0 $t1
+                move $a1 $t3
+                li $v0 8
+                syscall
+                move $t0 $a0
+                move $t1 $t2
+                addiu $a0 $t5 header_size
+                j get_string_look_nl\n\n'''
+
+
+def get_string_finish():
+    return '''get_string_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $t4 16($sp)
+                lw $t5 20($sp)
+                lw $a0 24($sp)
+                lw $a1 28($sp)
+                lw $ra 32($sp)
+                addiu $sp $sp 36
+
+                jr $ra\n\n'''
+
+
+def get_string_new_block():
+    return '''get_string_new_block:
+    addiu $t0 $gp free_list\n\n'''
+
+
+def get_string_new_block_search_last():
+    return '''get_string_new_block_search_last:
+                lw $t1 header_next_slot($t0)
+                beq $t1 $zero get_string_new_block_create
+                move $t0 $t1
+                j get_string_new_block_search_last\n\n'''
+
+
+def get_string_new_block_create():
+    return '''get_string_new_block_create:
+                move $a0 $t0
+                li $a1 alloc_size
+                jal extend_heap
+                jal extend_block
+                lw $t2 header_next_slot($a0)
+                beq $t2 $zero get_string_new_block_extended
+                lw $t1 header_size_slot($t2)
+                j get_string_reading\n\n'''
+
+
+def get_string_new_block_extended():
+    return '''get_string_new_block_extended:
+                move $t2 $a0
+                lw $t1 header_size_slot($a0)
+                j get_string_reading\n\n'''
+
+
+def divide_block():
+    return '''divide_block:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $a0 8($sp)
+                sw $a1 12($sp)
+
+                
+                lw $t0 header_size_slot($a0)
+                bgt $a1 $t0 divide_block_error_small
+                
+    
+                sub $t0 $t0 $a1
+                li $t1 header_size
+                ble $t0 $t1 divide_block_same_size
+
+               
+                addu $t0 $a0 $a1
+                addiu $t0 $t0 header_size     
+
+                
+                lw $t1 header_next_slot($a0)    
+                sw $t1 header_next_slot($t0)
+                sw $t0 header_next_slot($a0)
+
+                lw $t1 header_size_slot($a0)    
+                sub $t1 $t1 $a1
+
+                addi $t1 $t1 neg_header_size
+                sw $t1 header_size_slot($t0)
+                sw $a1 header_size_slot($a0)
+                move $v0 $a0
+                j divide_block_finish\n\n'''
+
+
+def divide_block_same_size():
+    return '''divide_block_same_size:
+                move $v0 $a0
+                j divide_block_finish\n\n'''
+
+
+def divide_block_error_small():
+    return '''divide_block_error_small:
+                j divide_block_finish\n\n'''
+
+
+def divide_block_finish():
+    return '''divide_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $a0 8($sp)
+                lw $a1 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra\n\n'''
+
+
+def sub_string():
+    return '''sub_string:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+                sw $ra 20($sp)
+
+                move $t0 $a0
+                li $t1 4
+                addiu $t3 $a2 1
+                div $t3 $t1
+            
+                mfhi $t2
+                bne $t2 $zero sub_string_allign_size
+                move $t1 $t3
+                j sub_string_new_block\n\n'''
+
+
+def sub_string_allign_size():
+    return '''sub_string_allign_size:
+                sub $t1 $t1 $t2
+                add $t1 $t1 $t3\n\n'''
+
+
+def sub_string_new_block():
+    return '''sub_string_new_block:
+                move $a0 $t1
+                jal malloc
+                move $t3 $v0
+                move $t1 $zero
+                addu $t0 $t0 $a1\n\n'''
+
+
+def sub_string_copy_cycle():
+    return '''sub_string_copy_cycle:
+                beq $t1 $a2 sub_string_finish
+                lb $t2 0($t0)
+                sb $t2 0($t3)
+                addiu $t0 $t0 1
+                addiu $t3 $t3 1
+                addiu $t1 $t1 1
+                j sub_string_copy_cycle\n\n'''
+
+
+def sub_string_finish():
+    return '''sub_string_finish:
+                sb $zero 0($t3)
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra\n\n'''
+
+
+def use_block():
+    return '''use_block:
+    addiu $sp $sp -12
+    sw $t0 0($sp)
+    sw $t1 4($sp)
+    sw $t2 8($sp)
+
+    addiu $t0 $gp free_list\n\n'''
+
+
+def use_block_cycle():
+    return '''use_block_cycle:
+                move $t1 $t0
+                lw $t0 header_next_slot($t0)
+                beq $t0 $zero use_block_finish
+                beq $t0 $a0 use_block_founded
+                j use_block_cycle\n\n'''
+
+
+def use_block_founded():
+    return '''use_block_founded:
+                lw $t2 header_next_slot($t0)
+                sw $t2 header_next_slot($t1)
+
+                addiu $t1 $gp used_list
+                lw $t2 header_next_slot($t1)
+                sw $t0 header_next_slot($t1)
+                sw $t2 header_next_slot($t0)\n\n'''
+
+
+def use_block_finish():
+    return '''use_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                addiu $sp $sp 12
+
+                jr $ra\n\n'''
diff --git a/src/utils/code_generation/mips/utils_mips.py b/src/utils/code_generation/mips/utils_mips.py
new file mode 100644
index 000000000..1f2106e59
--- /dev/null
+++ b/src/utils/code_generation/mips/utils_mips.py
@@ -0,0 +1,547 @@
+from collections import defaultdict
+import cmp.visitor as visitor
+from utils.code_generation.cil.AST_CIL import cil_ast as cil
+from utils.code_generation.mips.AST_MIPS import mips_ast as mips
+from utils.code_generation.mips.AST_MIPS import mips_ast as nodes
+from utils.code_generation.mips.AST_MIPS import *
+from random import choice
+
+
+def push_register(reg):
+    move_stack = nodes.AddInmediateNode(SP_REG, SP_REG, -4)
+    save_location = RegisterRelativeLocation(SP_REG, 0)
+    save_register = nodes.StoreWordNode(reg, save_location)
+    return [move_stack, save_register]
+
+
+def pop_register(reg):
+    load_value = nodes.LoadWordNode(reg, RegisterRelativeLocation(SP_REG, 0))
+    move_stack = nodes.AddInmediateNode(SP_REG, SP_REG, 4)
+    return [load_value, move_stack]
+
+
+def alloc_memory(size):
+    instructions = []
+    instructions.append(nodes.LoadInmediateNode(V0_REG, 9))
+    instructions.append(nodes.LoadInmediateNode(ARG_REGISTERS[0], size))
+    instructions.append(nodes.SyscallNode())
+    return instructions
+
+
+def exit_program():
+    instructions = []
+    instructions.append(nodes.LoadInmediateNode(V0_REG, 10))
+    instructions.append(nodes.SyscallNode())
+    return instructions
+
+
+def create_object(reg1, reg2):
+    instructions = []
+
+    instructions.append(nodes.ShiftLeftLogicalNode(reg1, reg1, 2))
+    instructions.append(nodes.LoadAddressNode(reg2, "proto_table"))
+    instructions.append(nodes.AddUnsignedNode(reg2, reg2, reg1))
+    instructions.append(nodes.LoadWordNode(
+        reg2, RegisterRelativeLocation(reg2, 0)))
+    instructions.append(nodes.LoadWordNode(
+        ARG_REGISTERS[0], RegisterRelativeLocation(reg2, 4)))
+    instructions.append(nodes.ShiftLeftLogicalNode(
+        ARG_REGISTERS[0], ARG_REGISTERS[0], 2))
+    instructions.append(nodes.JumpAndLinkNode("malloc"))
+    instructions.append(nodes.MoveNode(ARG_REGISTERS[2], ARG_REGISTERS[0]))
+    instructions.append(nodes.MoveNode(ARG_REGISTERS[0], reg2))
+    instructions.append(nodes.MoveNode(ARG_REGISTERS[1], V0_REG))
+    instructions.append(nodes.JumpAndLinkNode("copy"))
+
+    return instructions
+
+
+def copy_object(reg1, reg2):
+    instructions = []
+
+    instructions.append(nodes.LoadWordNode(
+        ARG_REGISTERS[0], RegisterRelativeLocation(reg1, 4)))
+    instructions.append(nodes.ShiftLeftLogicalNode(
+        ARG_REGISTERS[0], ARG_REGISTERS[0], 2))
+    instructions.append(nodes.JumpAndLinkNode("malloc"))
+    instructions.append(nodes.MoveNode(ARG_REGISTERS[2], ARG_REGISTERS[0]))
+    instructions.append(nodes.MoveNode(ARG_REGISTERS[0], reg1))
+    instructions.append(nodes.MoveNode(ARG_REGISTERS[1], V0_REG))
+    instructions.append(nodes.JumpAndLinkNode("copy"))
+
+    return instructions
+
+
+class MemoryManager:
+    def __init__(self, registers, function_for_assign):
+        self.registers = registers
+        self.func = function_for_assign
+
+    def get_reg_for_var(self, var):
+        index = self.func(var)
+        if index == -1:
+            return None
+        return self.registers[index]
+
+    def get_reg_unusued(self, used=[]):
+        possibles = list(set(self.registers).difference(set(used)))
+        return choice(possibles)
+
+
+class LabelGenerator:
+    def __init__(self):
+        self.data_count = 0
+        self.type_count = 0
+        self.code_count = 0
+
+    def generate_type_label(self):
+        self.type_count += 1
+        return f'type_{self.type_count}'
+
+    def generate_data_label(self):
+        self.data_count += 1
+        return f'data_{self.data_count}'
+
+    def generate_code_label(self):
+        self.code_count += 1
+        return f'L_{self.code_count}'
+
+
+class UsedRegisterFinder:
+    def __init__(self):
+        self.used_registers = set()
+
+    def get_used_registers(self, instructions):
+        self.used_registers = set()
+
+        for inst in instructions:
+            self.visit(inst)
+        self.used_registers = set.difference(
+            self.used_registers, set([SP_REG, Register('fp'), V0_REG]))
+        return [reg for reg in self.used_registers]
+
+    @visitor.on('node')
+    def visit(self, node):
+        pass
+
+    @visitor.when(mips.LoadInmediateNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg)
+
+    @visitor.when(mips.LoadAddressNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg)
+
+    @visitor.when(mips.AddInmediateNode)
+    def visit(self, node):
+        self.used_registers.add(node.dest)
+
+    @visitor.when(mips.MoveNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg1)
+
+    @visitor.when(mips.LoadWordNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg)
+
+    @visitor.when(mips.JumpAndLinkNode)
+    def visit(self, node):
+        self.used_registers.add(RA_REG)
+
+    @visitor.when(mips.JumpRegisterAndLinkNode)
+    def visit(self, node):
+        self.used_registers.add(RA_REG)
+
+    @visitor.when(mips.AddUnsignedNode)
+    def visit(self, node):
+        self.used_registers.add(node.dest)
+
+    @visitor.when(mips.ShiftLeftLogicalNode)
+    def visit(self, node):
+        self.used_registers.add(node.dest)
+
+    @visitor.when(mips.AddNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg1)
+
+    @visitor.when(mips.SubNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg1)
+
+    @visitor.when(mips.MultiplyNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg1)
+
+    @visitor.when(mips.ComplementNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg1)
+
+    @visitor.when(mips.MoveFromLowNode)
+    def visit(self, node):
+        self.used_registers.add(node.reg)
+
+
+class RegistersAllocator:
+    def __init__(self):
+        self.mark = False
+
+    def get_registers_for_variables(self, instructions, params, n):
+        self.numbered_instructions(instructions)
+        basic_blocks = self.divide_basics_blocks(instructions)
+        flow_graph = RegistersAllocator.create_flow_graph(basic_blocks)
+        gk, io = self.liveness_analysis((basic_blocks, flow_graph), params)
+        interference = RegistersAllocator.interference_compute(gk, io)
+        return RegistersAllocator.assign_registers(interference, n)
+
+    def divide_basics_blocks(self, instructions):
+        self.mark = True
+        for instruction in instructions:
+            self.mark_leaders(instruction)
+
+        blocks = []
+
+        for instruction in instructions:
+            if instruction.leader:
+                blocks.append([instruction])
+            else:
+                blocks[-1].append(instruction)
+
+        return blocks
+
+    def liveness_analysis(self, graph, params):
+        blocks, ady_list = graph
+
+        instructions = []
+        for block in blocks:
+            instructions.extend(block)
+        instructions_total = len(instructions)
+
+        suc = [0 for _ in range(instructions_total)]
+        for block_index, block in enumerate(blocks):
+            for ins_index, instruction in enumerate(block):
+                if ins_index == len(block) - 1:
+                    ady = [i for i in range(len(blocks))
+                           if ady_list[block_index][i] == 1]
+                    suc[instruction.number] = [
+                        blocks[b][0].number for b in ady]
+                else:
+                    suc[instruction.number] = [block[ins_index + 1].number]
+
+        gk = [self.gen_kill(inst) for inst in instructions]
+        io = RegistersAllocator.out_in_compute(suc, gk)
+        gk = [([], [param.id for param in params])] + gk
+        io = [([], io[0][0])] + io
+
+        return gk, io
+
+    @staticmethod
+    def interference_compute(gk, in_out):
+        neigs = {}
+        for g, k in gk:
+            for v in g:
+                neigs[v] = set()
+            for v in k:
+                neigs[v] = set()
+
+        for i, (_, k) in enumerate(gk):
+            for v in k:
+                neigs[v].update(in_out[i][1])
+
+        for k, v in neigs.items():
+            for n in v:
+                neigs[n].add(k)
+
+        for k, v in neigs.items():
+            neigs[k] = list(v.difference([k]))
+
+        return neigs
+
+    @staticmethod
+    def assign_registers(interference_graph, n):
+        stack = []
+        var_registers = defaultdict(lambda: -1)
+        nodes = set(interference_graph.keys())
+
+        def myLen(l):
+            count = 0
+            for v in l:
+                if v in nodes:
+                    count += 1
+            return count
+
+        while nodes:
+            to_remove = None
+            for node in nodes:
+                if myLen(interference_graph[node]) < n:
+                    stack.append((node, interference_graph[node]))
+                    to_remove = node
+                    break
+
+            if to_remove:
+                nodes.remove(to_remove)
+            else:
+                selection = choice(list(nodes))
+                stack.append((selection, interference_graph[selection]))
+                nodes.remove(selection)
+
+        while stack:
+            node, ady = stack.pop()
+            regs = set(range(n))
+            for neig in ady:
+                reg = var_registers[neig]
+                if reg != -1:
+                    try:
+                        regs.remove(reg)
+                    except:
+                        pass
+            if regs:
+                var_registers[node] = min(regs)
+            else:
+                var_registers[node] = -1
+
+        return var_registers
+
+    @staticmethod
+    def out_in_compute(suc, gk):
+        n_instructions = len(gk)
+        in_out = [[set(), set()] for _ in range(n_instructions)]
+        next_in_out = [[set(), set()] for _ in range(n_instructions)]
+
+        def add(set1, set2):
+            return not set2.issubset(set1)
+
+        changed = True
+        while changed:
+            changed = False
+            for i in range(n_instructions)[::-1]:
+                for i_suc in suc[i]:
+                    if i_suc < i:
+                        changed |= add(next_in_out[i][1], in_out[i_suc][0])
+                        next_in_out[i][1] = next_in_out[i][1].union(
+                            in_out[i_suc][0])
+                    else:
+                        changed |= add(
+                            next_in_out[i][1], next_in_out[i_suc][0])
+                        next_in_out[i][1] = next_in_out[i][1].union(
+                            next_in_out[i_suc][0])
+
+                g_i = set(gk[i][0])
+                k_i = set(gk[i][1])
+                new = g_i.union(next_in_out[i][1].difference(k_i))
+                changed |= add(next_in_out[i][0], new)
+                next_in_out[i][0] = next_in_out[i][0].union(new)
+
+            in_out = next_in_out
+
+        return in_out
+
+    @staticmethod
+    def create_flow_graph(blocks):
+        graph = [[-1 for _ in range(len(blocks))] for _ in range(len(blocks))]
+        labels = {b[0].label: i for i, b in enumerate(
+            blocks) if isinstance(b[0], cil.LabelNode)}
+
+        for i, block in enumerate(blocks):
+            if isinstance(block[-1], cil.GotoNode):
+                graph[i][labels[block[-1].label]] = 1
+            elif isinstance(block[-1], cil.IfGotoNode):
+                graph[i][labels[block[-1].label]] = 1
+                graph[i][i + 1] = 1 if i + 1 < len(blocks) else -1
+            elif i != len(blocks) - 1:
+                graph[i][i + 1] = 1
+
+        return graph
+
+    @staticmethod
+    def numbered_instructions(instructions):
+        for i, instr in enumerate(instructions):
+            instr.number = i
+
+    @visitor.on('instruction')
+    def gen_kill(self, instruction):
+        pass
+
+    @visitor.when(cil.ArgNode)
+    def gen_kill(self, instruction):
+        if isinstance(instruction.id, int):
+            return ([], [])
+        return ([instruction.id], [])
+
+    @visitor.when(cil.StaticCallNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.AssignNode)
+    def gen_kill(self, instruction):
+        gen = []
+        if isinstance(instruction.right, str):
+            if not instruction.right.isnumeric():
+                gen = [instruction.right]
+        return (gen, [instruction.left])
+
+    @visitor.when(cil.AllocateNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.ReturnNode)
+    def gen_kill(self, instruction):
+        gen = [instruction.id] if isinstance(instruction.id, str) else []
+        return (gen, [])
+
+    @visitor.when(cil.LoadNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.PrintIntNode)
+    def gen_kill(self, instruction):
+        return ([instruction.value], [])
+
+    @visitor.when(cil.PrintStrNode)
+    def gen_kill(self, instruction):
+        return ([instruction.value], [])
+
+    @visitor.when(cil.TypeNameNode)
+    def gen_kill(self, instruction):
+        return ([instruction.type], [instruction.dest])
+
+    @visitor.when(cil.AbortNode)
+    def gen_kill(self, instruction):
+        return ([], [])
+
+    @visitor.when(cil.GetAttrNode)
+    def gen_kill(self, instruction):
+        return ([instruction.id], [instruction.dest])
+
+    @visitor.when(cil.SetAttrNode)
+    def gen_kill(self, instruction):
+        gen = [instruction.id]
+        if not isinstance(instruction.value, int):
+            gen.append(instruction.value)
+        return (gen, [])
+
+    @visitor.when(cil.CopyNode)
+    def gen_kill(self, instruction):
+        return ([instruction.copy], [instruction.dest])
+
+    @visitor.when(cil.ArithmeticNode)
+    def gen_kill(self, instruction):
+        gen = [x for x in [instruction.op_l,
+                           instruction.op_r] if isinstance(x, str)]
+        return (gen, [instruction.dest])
+
+    @visitor.when(cil.IfGotoNode)
+    def gen_kill(self, instruction):
+        return ([instruction.if_cond], [])
+
+    @visitor.when(cil.GotoNode)
+    def gen_kill(self, instruction):
+        return ([], [])
+
+    @visitor.when(cil.TypeOfNode)
+    def gen_kill(self, instruction):
+        return ([instruction.id], [instruction.dest])
+
+    @visitor.when(cil.DynamicCallNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.NameNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.ComplementNode)
+    def gen_kill(self, instruction):
+        gen = [instruction.id] if isinstance(instruction.id, str) else []
+        return (gen, [instruction.dest])
+
+    @visitor.when(cil.ReadStrNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.LengthNode)
+    def gen_kill(self, instruction):
+        return ([instruction.id], [instruction.dest])
+
+    @visitor.when(cil.ReadIntNode)
+    def gen_kill(self, instruction):
+        return ([], [instruction.dest])
+
+    @visitor.when(cil.ConcatNode)
+    def gen_kill(self, instruction):
+        return ([instruction.s1, instruction.s2], [instruction.dest])
+
+    @visitor.when(cil.SubstringNode)
+    def gen_kill(self, instruction):
+        gen = [instruction.s]
+        if isinstance(instruction.i, str):
+            gen.append(instruction.i)
+        if isinstance(instruction.length, str):
+            gen.append(instruction.length)
+
+        return (gen, [instruction.dest])
+
+    @visitor.when(cil.LabelNode)
+    def gen_kill(self, instruction):
+        return ([], [])
+
+    @visitor.when(cil.ErrorNode)
+    def gen_kill(self, instruction):
+        return ([], [])
+
+    @visitor.on('instruction')
+    def mark_leaders(self, instruction):
+        pass
+
+    @visitor.when(cil.LabelNode)
+    def mark_leaders(self, instruction):
+        instruction.leader = True
+        self.mark = False
+
+    @visitor.when(cil.GotoNode)
+    def mark_leaders(self, instruction):
+        instruction.leader = self.mark
+        self.mark = True
+
+    @visitor.when(cil.IfGotoNode)
+    def mark_leaders(self, instruction):
+        instruction.leader = self.mark
+        self.mark = True
+
+    @visitor.when(cil.InstructionNode)
+    def mark_leaders(self, instruction):
+        instruction.leader = self.mark
+        self.mark = False
+
+
+class MIPSType:
+    def __init__(self, label, name_addr, attributes, methods, index, default=[]):
+        self._label = label
+        self._name = name_addr
+        self._attributes = attributes
+        self._default_attributes = dict(default)
+        self._methods = methods
+        self._index = index
+
+    @property
+    def size(self):
+        return len(self.attributes) + 4
+
+    @property
+    def label(self):
+        return self._label
+
+    @property
+    def string_name_label(self):
+        return self._name
+
+    @property
+    def methods(self):
+        return self._methods
+
+    @property
+    def attributes(self):
+        return self._attributes
+
+    @property
+    def index(self):
+        return self._index
\ No newline at end of file

From 08b60927c6ccffcd19f3ec87d0882138a6c057f0 Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Fri, 25 Feb 2022 12:15:43 -0800
Subject: [PATCH 75/83] Update Readme.md

---
 Readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Readme.md b/Readme.md
index a47d48b9e..73af6506c 100644
--- a/Readme.md
+++ b/Readme.md
@@ -123,7 +123,7 @@ Verá la indicación **Some checks haven't completed yet**.
 
 ![](img/img8.png)
 
-Es posible que tenga que actualizar los cambios que se hayan hecho en el repositorio original, por ejemplo, si se han agregado nuevos tests. En este caso obtendrá el siguiente mensaje:
+Es posible que tenga que actualizar los cambios que se hayan hecho en el repositorio original, por ejemplo, si se han agregado nuevos tests. En este caso obtendrá el siguiente mensaje: 
 
 > **This branch is out-of-date with base branch**
 

From a35cc671ad3faf6ab90201218d44cbc72123c5de Mon Sep 17 00:00:00 2001
From: darian10 <dariandominguezalayon@gmail.com>
Date: Fri, 25 Feb 2022 15:33:30 -0500
Subject: [PATCH 76/83] Fixing size ldata issue

---
 src/cells.mips                                | 3661 +++++++++++++++++
 .../code_generation/cil/Base_COOL_to_CIL.py   |  190 +-
 src/utils/code_generation/cil/COOL_to_CIL.py  |  375 +-
 3 files changed, 4000 insertions(+), 226 deletions(-)
 create mode 100644 src/cells.mips

diff --git a/src/cells.mips b/src/cells.mips
new file mode 100644
index 000000000..bf951bd30
--- /dev/null
+++ b/src/cells.mips
@@ -0,0 +1,3661 @@
+	.data
+default_str: .asciiz ""
+data_1: .asciiz "Object"
+data_2: .asciiz "IO"
+data_3: .asciiz "String"
+data_4: .asciiz "Int"
+data_5: .asciiz "Bool"
+data_6: .asciiz "CellularAutomaton"
+data_7: .asciiz "Main"
+data_8: .asciiz "Aborting... in class "
+data_9: .asciiz "
+"
+data_10: .asciiz "Substring out of range"
+data_11: .asciiz "(17,24) - RuntimeError: Dispatch on void
+"
+data_12: .asciiz "(23,9) - RuntimeError: Dispatch on void
+"
+data_13: .asciiz "(27,9) - RuntimeError: Dispatch on void
+"
+data_14: .asciiz "X"
+data_15: .asciiz "."
+data_16: .asciiz "(67,33) - RuntimeError: Dispatch on void
+"
+data_17: .asciiz "         X         "
+data_18: .asciiz "(83,27) - RuntimeError: Dispatch on void
+"
+data_19: .asciiz "(84,13) - RuntimeError: Dispatch on void
+"
+data_20: .asciiz "(88,25) - RuntimeError: Dispatch on void
+"
+data_21: .asciiz "(89,25) - RuntimeError: Dispatch on void
+"
+
+type_name_table:
+	.word	data_1
+	.word	data_2
+	.word	data_3
+	.word	data_4
+	.word	data_5
+	.word	data_6
+	.word	data_7
+
+proto_table:
+	.word	type_1_proto
+	.word	type_2_proto
+	.word	type_3_proto
+	.word	type_4_proto
+	.word	type_5_proto
+	.word	type_6_proto
+	.word	type_7_proto
+
+type_1_dispatch:
+	.word	 L_2
+	.word	 L_3
+	.word	 L_4
+	.word	 L_1
+
+type_1_proto:
+	.word	0
+	.word	4
+	.word	type_1_dispatch
+	.word	-1
+
+type_2_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_6
+	.word	 L_7
+	.word	 L_8
+	.word	 L_9
+	.word	 L_5
+
+type_2_proto:
+	.word	1
+	.word	4
+	.word	type_2_dispatch
+	.word	-1
+
+type_3_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_11
+	.word	 L_12
+	.word	 L_13
+	.word	 L_10
+
+type_3_proto:
+	.word	2
+	.word	6
+	.word	type_3_dispatch
+	.word	default_str
+	.word	type_4_proto
+	.word	-1
+
+type_4_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_14
+
+type_4_proto:
+	.word	3
+	.word	5
+	.word	type_4_dispatch
+	.word	0
+	.word	-1
+
+type_5_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_15
+
+type_5_proto:
+	.word	4
+	.word	5
+	.word	type_5_dispatch
+	.word	0
+	.word	-1
+
+type_6_dispatch:
+	.word	 L_2
+	.word	 L_3
+	.word	 L_4
+	.word	 L_6
+	.word	 L_7
+	.word	 L_8
+	.word	 L_9
+	.word	 L_16
+	.word	 L_17
+	.word	 L_18
+	.word	 L_19
+	.word	 L_20
+	.word	 L_21
+	.word	 L_22
+	.word	 L_23
+
+type_6_proto:
+	.word	5
+	.word	5
+	.word	type_6_dispatch
+	.word	0
+	.word	-1
+
+type_7_dispatch:
+	.word	 L_2
+	.word	 L_3
+	.word	 L_4
+	.word	 L_26
+
+type_7_proto:
+	.word	6
+	.word	5
+	.word	type_7_dispatch
+	.word	0
+	.word	-1
+	.text
+	.globl main
+main:
+	jal mem_manager_init
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	jal L_27
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_26
+	move $t0 $v0
+	addi $sp, $sp, 4
+	li $v0, 0
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	li $v0, 10
+	syscall
+L_1:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	li $t5, 0
+	sll $t5 $t5 2
+	la $t1, proto_table
+	addu $t1 $t1 $t5
+	lw $t1, 0($t1)
+	lw $a0, 4($t1)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t1
+	move $a1 $v0
+	jal copy
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_2:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	lw $t1, 0($fp)
+	la $t0, data_8 + 0
+	li $v0, 4
+	move $a0 $t0
+	syscall
+	lw $a0, 0($t1)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t0 $a0
+	li $v0, 4
+	move $a0 $t0
+	syscall
+	la $t0, data_9 + 0
+	li $v0, 4
+	move $a0 $t0
+	syscall
+	li $v0, 10
+	syscall
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_3:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $a0, 0($t0)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t0 $a0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_4:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t0, 0($fp)
+	lw $a0, 4($t0)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t0
+	move $a1 $v0
+	jal copy
+	move $t0 $v0
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_5:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	li $t1, 1
+	sll $t1 $t1 2
+	la $t5, proto_table
+	addu $t5 $t5 $t1
+	lw $t5, 0($t5)
+	lw $a0, 4($t5)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t5
+	move $a1 $v0
+	jal copy
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_6:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $t1, 4($fp)
+	lw $a1, 12($t0)
+	move $t0 $a1
+	li $v0, 4
+	move $a0 $t0
+	syscall
+	move $v0 $t1
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_7:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $t1, 4($fp)
+	lw $a1, 12($t0)
+	move $t0 $a1
+	li $v0, 1
+	move $a0 $t0
+	syscall
+	move $v0 $t1
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_8:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	lw $t0, 0($fp)
+	jal get_string
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_9:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	lw $t0, 0($fp)
+	li $v0, 5
+	syscall
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_10:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -12
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t1, 0($fp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	li $t1, 2
+	sll $t1 $t1 2
+	la $t7, proto_table
+	addu $t7 $t7 $t1
+	lw $t7, 0($t7)
+	lw $a0, 4($t7)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t7
+	move $a1 $v0
+	jal copy
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	sw $t1, 12($t0)
+	move $a0 $t1
+	jal len
+	move $t1 $v0
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	jal L_14
+	move $t1 $v0
+	addi $sp, $sp, 4
+	sw $t1, 16($t0)
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 12
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_11:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($fp)
+	lw $a1, 16($t0)
+	move $t0 $a1
+	move $v0 $t0
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_12:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -24
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t0, 0($fp)
+	lw $t1, 4($fp)
+	lw $a1, 12($t1)
+	move $t3 $a1
+	lw $a1, 12($t0)
+	move $t2 $a1
+	lw $a1, 16($t1)
+	move $t1 $a1
+	lw $a1, 16($t0)
+	move $t0 $a1
+	lw $a1, 12($t1)
+	move $t1 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t1 $t1 $t0
+	move $a0 $t3
+	move $a1 $t2
+	move $a2 $t1
+	jal concat
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 24
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_13:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -32
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $t2, 4($fp)
+	lw $t1, 8($fp)
+	lw $a1, 12($t1)
+	move $t3 $a1
+	lw $a1, 12($t2)
+	move $t4 $a1
+	lw $a1, 12($t0)
+	move $t2 $a1
+	lw $a1, 16($t1)
+	move $t0 $a1
+	add $t1 $t2 $t4
+	move $a0 $t0
+	move $a1 $t1
+	jal less
+	move $t0 $v0
+	bne $t0 $zero L_29
+	j L_30
+	L_29:
+	li $v0, 4
+	la $a0, data_10
+	syscall
+	li $v0, 10
+	syscall
+	L_30:
+	move $a0 $t3
+	move $a1 $t4
+	move $a2 $t2
+	jal sub_string
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 32
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_14:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $t8, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t1, 0($fp)
+	addi $sp, $sp, -4
+	sw $t8, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	li $t8, 3
+	sll $t8 $t8 2
+	la $t4, proto_table
+	addu $t4 $t4 $t8
+	lw $t4, 0($t4)
+	lw $a0, 4($t4)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t4
+	move $a1 $v0
+	jal copy
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $t8, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	sw $t1, 12($t0)
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t8, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_15:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t1, 0($fp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	li $t3, 4
+	sll $t3 $t3 2
+	la $t5, proto_table
+	addu $t5 $t5 $t3
+	lw $t5, 0($t5)
+	lw $a0, 4($t5)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t5
+	move $a1 $v0
+	jal copy
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	sw $t1, 12($t0)
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_16:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t1, 0($fp)
+	lw $t0, 4($fp)
+	sw $t1, 12($t0)
+	move $v0 $t0
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 0
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_17:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -44
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t1, 0($fp)
+	la $t0, data_9 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t2 $t0
+	lw $a1, 12($t1)
+	move $t0 $a1
+	move $t0 $t0
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t3 $v0
+	bne $t3 $zero L_31
+	j L_32
+	L_31:
+	li $v0, 4
+	la $a0, data_11
+	syscall
+	li $v0, 10
+	syscall
+	L_32:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	lw $t0, 0($t0)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 16
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t1)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 12
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $v0 $t1
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 44
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_18:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -20
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t0, 0($fp)
+	lw $a1, 12($t0)
+	move $t0 $a1
+	move $t1 $t0
+	move $a0 $t1
+	li $a1, 0
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_33
+	j L_34
+	L_33:
+	li $v0, 4
+	la $a0, data_12
+	syscall
+	li $v0, 10
+	syscall
+	L_34:
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t0, 0($t1)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 12
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 20
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_19:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -32
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	lw $t0, 0($fp)
+	lw $t1, 4($fp)
+	move $t3 $t0
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t2 $t0
+	lw $a1, 12($t1)
+	move $t0 $a1
+	move $t0 $t0
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t1 $v0
+	bne $t1 $zero L_35
+	j L_36
+	L_35:
+	li $v0, 4
+	la $a0, data_13
+	syscall
+	li $v0, 10
+	syscall
+	L_36:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	lw $t0, 0($t0)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 20
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 12
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 32
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_20:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -120
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t1, 0($fp)
+	lw $t4, 4($fp)
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t5 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t1)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t2 $a0
+	la $t0, type_name_table
+	addiu $t0 $t0 12
+	lw $t0, 0($t0)
+	la $t3, type_name_table
+	addiu $t3 $t3 16
+	lw $t3, 0($t3)
+	la $t6, type_name_table
+	addiu $t6 $t6 8
+	lw $t6, 0($t6)
+	move $a0 $t2
+	move $a1 $t0
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_37
+	move $a0 $t2
+	move $a1 $t3
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_37
+	move $a0 $t2
+	move $a1 $t6
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_38
+	j L_39
+	L_37:
+	lw $a1, 12($t1)
+	move $t0 $a1
+	lw $a1, 12($t5)
+	move $t2 $a1
+	move $a0 $t0
+	move $a1 $t2
+	jal eqs
+	move $t0 $v0
+	j L_40
+	L_38:
+	lw $a1, 12($t1)
+	move $t0 $a1
+	lw $a1, 12($t5)
+	move $t2 $a1
+	move $a0 $t0
+	move $a1 $t2
+	jal eq_string
+	move $t0 $v0
+	j L_40
+	L_39:
+	move $a0 $t1
+	move $a1 $t5
+	jal eqs
+	move $t0 $v0
+	L_40:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_41
+	j L_42
+	L_41:
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	lw $t0, 0($t4)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 36
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t1 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	sub $t0 $t1 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t4)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 40
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t0 $t0
+	j L_43
+	L_42:
+	lw $a1, 12($t1)
+	move $t1 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	sub $t0 $t1 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t4)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 40
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t0 $t0
+	L_43:
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 120
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_21:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -120
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $t3, 4($fp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	lw $t1, 0($t3)
+	la $a1, proto_table
+	sll $a2 $t1 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 36
+	lw $a1, 0($a1)
+	jal $a1
+	move $t1 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t1)
+	move $t1 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t2 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t2)
+	move $t2 $a1
+	sub $t1 $t1 $t2
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	jal L_14
+	move $t5 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t0)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t2 $a0
+	la $t4, type_name_table
+	addiu $t4 $t4 12
+	lw $t4, 0($t4)
+	la $t6, type_name_table
+	addiu $t6 $t6 16
+	lw $t6, 0($t6)
+	la $t1, type_name_table
+	addiu $t1 $t1 8
+	lw $t1, 0($t1)
+	move $a0 $t2
+	move $a1 $t4
+	jal eqs
+	move $t4 $v0
+	bne $t4 $zero L_44
+	move $a0 $t2
+	move $a1 $t6
+	jal eqs
+	move $t4 $v0
+	bne $t4 $zero L_44
+	move $a0 $t2
+	move $a1 $t1
+	jal eqs
+	move $t4 $v0
+	bne $t4 $zero L_45
+	j L_46
+	L_44:
+	lw $a1, 12($t0)
+	move $t1 $a1
+	lw $a1, 12($t5)
+	move $t2 $a1
+	move $a0 $t1
+	move $a1 $t2
+	jal eqs
+	move $t1 $v0
+	j L_47
+	L_45:
+	lw $a1, 12($t0)
+	move $t1 $a1
+	lw $a1, 12($t5)
+	move $t2 $a1
+	move $a0 $t1
+	move $a1 $t2
+	jal eq_string
+	move $t1 $v0
+	j L_47
+	L_46:
+	move $a0 $t0
+	move $a1 $t5
+	jal eqs
+	move $t1 $v0
+	L_47:
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	jal L_15
+	move $t1 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t1)
+	move $t1 $a1
+	bne $t1 $zero L_48
+	j L_49
+	L_48:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t3)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 40
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t0 $t0
+	j L_50
+	L_49:
+	lw $a1, 12($t0)
+	move $t1 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t0 $t1 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t3)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 40
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t0 $t0
+	L_50:
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 120
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_22:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -312
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t8, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t3, 0($fp)
+	lw $t2, 4($fp)
+	move $t0 $t3
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t2)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 40
+	lw $a1, 0($a1)
+	jal $a1
+	move $t7 $v0
+	addi $sp, $sp, 8
+	la $t0, data_14 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t1 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t7)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t0 $a0
+	la $t5, type_name_table
+	addiu $t5 $t5 12
+	lw $t5, 0($t5)
+	la $t6, type_name_table
+	addiu $t6 $t6 16
+	lw $t6, 0($t6)
+	la $t4, type_name_table
+	addiu $t4 $t4 8
+	lw $t4, 0($t4)
+	move $a0 $t0
+	move $a1 $t5
+	jal eqs
+	move $t5 $v0
+	bne $t5 $zero L_51
+	move $a0 $t0
+	move $a1 $t6
+	jal eqs
+	move $t5 $v0
+	bne $t5 $zero L_51
+	move $a0 $t0
+	move $a1 $t4
+	jal eqs
+	move $t5 $v0
+	bne $t5 $zero L_52
+	j L_53
+	L_51:
+	lw $a1, 12($t7)
+	move $t4 $a1
+	lw $a1, 12($t1)
+	move $t0 $a1
+	move $a0 $t4
+	move $a1 $t0
+	jal eqs
+	move $t0 $v0
+	j L_54
+	L_52:
+	lw $a1, 12($t7)
+	move $t4 $a1
+	lw $a1, 12($t1)
+	move $t0 $a1
+	move $a0 $t4
+	move $a1 $t0
+	jal eq_string
+	move $t0 $v0
+	j L_54
+	L_53:
+	move $a0 $t7
+	move $a1 $t1
+	jal eqs
+	move $t0 $v0
+	L_54:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_55
+	j L_56
+	L_55:
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_57
+	L_56:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_57:
+	lw $a1, 12($t0)
+	move $t1 $a1
+	move $t0 $t3
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t2)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 44
+	lw $a1, 0($a1)
+	jal $a1
+	move $t5 $v0
+	addi $sp, $sp, 8
+	la $t0, data_14 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t7 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t5)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t8 $a0
+	la $t6, type_name_table
+	addiu $t6 $t6 12
+	lw $t6, 0($t6)
+	la $t4, type_name_table
+	addiu $t4 $t4 16
+	lw $t4, 0($t4)
+	la $t0, type_name_table
+	addiu $t0 $t0 8
+	lw $t0, 0($t0)
+	move $a0 $t8
+	move $a1 $t6
+	jal eqs
+	move $t6 $v0
+	bne $t6 $zero L_58
+	move $a0 $t8
+	move $a1 $t4
+	jal eqs
+	move $t6 $v0
+	bne $t6 $zero L_58
+	move $a0 $t8
+	move $a1 $t0
+	jal eqs
+	move $t6 $v0
+	bne $t6 $zero L_59
+	j L_60
+	L_58:
+	lw $a1, 12($t5)
+	move $t0 $a1
+	lw $a1, 12($t7)
+	move $t4 $a1
+	move $a0 $t0
+	move $a1 $t4
+	jal eqs
+	move $t0 $v0
+	j L_61
+	L_59:
+	lw $a1, 12($t5)
+	move $t0 $a1
+	lw $a1, 12($t7)
+	move $t4 $a1
+	move $a0 $t0
+	move $a1 $t4
+	jal eq_string
+	move $t0 $v0
+	j L_61
+	L_60:
+	move $a0 $t5
+	move $a1 $t7
+	jal eqs
+	move $t0 $v0
+	L_61:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_62
+	j L_63
+	L_62:
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_64
+	L_63:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_64:
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t0 $t1 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t1 $a1
+	move $t0 $t3
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t2)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 48
+	lw $a1, 0($a1)
+	jal $a1
+	move $t6 $v0
+	addi $sp, $sp, 8
+	la $t0, data_14 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t3 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t6)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t5 $a0
+	la $t0, type_name_table
+	addiu $t0 $t0 12
+	lw $t0, 0($t0)
+	la $t4, type_name_table
+	addiu $t4 $t4 16
+	lw $t4, 0($t4)
+	la $t2, type_name_table
+	addiu $t2 $t2 8
+	lw $t2, 0($t2)
+	move $a0 $t5
+	move $a1 $t0
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_65
+	move $a0 $t5
+	move $a1 $t4
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_65
+	move $a0 $t5
+	move $a1 $t2
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_66
+	j L_67
+	L_65:
+	lw $a1, 12($t6)
+	move $t2 $a1
+	lw $a1, 12($t3)
+	move $t0 $a1
+	move $a0 $t2
+	move $a1 $t0
+	jal eqs
+	move $t0 $v0
+	j L_68
+	L_66:
+	lw $a1, 12($t6)
+	move $t2 $a1
+	lw $a1, 12($t3)
+	move $t0 $a1
+	move $a0 $t2
+	move $a1 $t0
+	jal eq_string
+	move $t0 $v0
+	j L_68
+	L_67:
+	move $a0 $t6
+	move $a1 $t3
+	jal eqs
+	move $t0 $v0
+	L_68:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_69
+	j L_70
+	L_69:
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_71
+	L_70:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_71:
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t0 $t1 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t3 $v0
+	addi $sp, $sp, 4
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t1 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t3)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t0 $a0
+	la $t4, type_name_table
+	addiu $t4 $t4 12
+	lw $t4, 0($t4)
+	la $t2, type_name_table
+	addiu $t2 $t2 16
+	lw $t2, 0($t2)
+	la $t5, type_name_table
+	addiu $t5 $t5 8
+	lw $t5, 0($t5)
+	move $a0 $t0
+	move $a1 $t4
+	jal eqs
+	move $t4 $v0
+	bne $t4 $zero L_72
+	move $a0 $t0
+	move $a1 $t2
+	jal eqs
+	move $t4 $v0
+	bne $t4 $zero L_72
+	move $a0 $t0
+	move $a1 $t5
+	jal eqs
+	move $t4 $v0
+	bne $t4 $zero L_73
+	j L_74
+	L_72:
+	lw $a1, 12($t3)
+	move $t0 $a1
+	lw $a1, 12($t1)
+	move $t1 $a1
+	move $a0 $t0
+	move $a1 $t1
+	jal eqs
+	move $t0 $v0
+	j L_75
+	L_73:
+	lw $a1, 12($t3)
+	move $t0 $a1
+	lw $a1, 12($t1)
+	move $t1 $a1
+	move $a0 $t0
+	move $a1 $t1
+	jal eq_string
+	move $t0 $v0
+	j L_75
+	L_74:
+	move $a0 $t3
+	move $a1 $t1
+	jal eqs
+	move $t0 $v0
+	L_75:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_76
+	j L_77
+	L_76:
+	la $t0, data_14 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_78
+	L_77:
+	la $t0, data_15 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_78:
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t8, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 312
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_23:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -104
+	addi $sp, $sp, -4
+	sw $t9, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t5, 0($fp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	li $t7, 3
+	sll $t7 $t7 2
+	la $t6, proto_table
+	addu $t6 $t6 $t7
+	lw $t6, 0($t6)
+	lw $a0, 4($t6)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t6
+	move $a1 $v0
+	jal copy
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	move $t4 $v0
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	lw $t0, 0($t5)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 36
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t2 $t0
+	addi $sp, $sp, -4
+	sw $t9, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	li $t9, 2
+	sll $t9 $t9 2
+	la $t4, proto_table
+	addu $t4 $t4 $t9
+	lw $t4, 0($t4)
+	lw $a0, 4($t4)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t4
+	move $a1 $v0
+	jal copy
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $t9, 0($sp)
+	addi $sp, $sp, 4
+	move $t3 $v0
+	L_79:
+	lw $a1, 12($t4)
+	move $t0 $a1
+	lw $a1, 12($t2)
+	move $t1 $a1
+	move $a0 $t0
+	move $a1 $t1
+	jal less
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_80
+	j L_83
+	L_80:
+	move $t0 $t4
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t5)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 52
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t1 $t0
+	move $t3 $t3
+	move $a0 $t3
+	li $a1, 0
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_81
+	j L_82
+	L_81:
+	li $v0, 4
+	la $a0, data_16
+	syscall
+	li $v0, 10
+	syscall
+	L_82:
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t0, 0($t3)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 16
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t3 $t0
+	lw $a1, 12($t4)
+	move $t1 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t0 $t1 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t4 $t0
+	j L_79
+	L_83:
+	sw $t3, 12($t5)
+	move $t0 $t5
+	move $t0 $t0
+	move $t0 $t0
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t9, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 104
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_24:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	li $t1, 5
+	sll $t1 $t1 2
+	la $t0, proto_table
+	addu $t0 $t0 $t1
+	lw $t0, 0($t0)
+	lw $a0, 4($t0)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t0
+	move $a1 $v0
+	jal copy
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_25
+	move $t1 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_25:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t1, 0($fp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	li $t6, 2
+	sll $t6 $t6 2
+	la $t3, proto_table
+	addu $t3 $t3 $t6
+	lw $t3, 0($t3)
+	lw $a0, 4($t3)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t3
+	move $a1 $v0
+	jal copy
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	sw $t0, 12($t1)
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_26:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -148
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t2, 0($fp)
+	la $t0, data_17 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t1 $t0
+	jal L_24
+	move $t0 $v0
+	move $t0 $t0
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t3 $v0
+	bne $t3 $zero L_84
+	j L_85
+	L_84:
+	li $v0, 4
+	la $a0, data_18
+	syscall
+	li $v0, 10
+	syscall
+	L_85:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t0, 0($t0)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 28
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	sw $t0, 12($t2)
+	lw $a1, 12($t2)
+	move $t0 $a1
+	move $t0 $t0
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t1 $v0
+	bne $t1 $zero L_86
+	j L_87
+	L_86:
+	li $v0, 4
+	la $a0, data_19
+	syscall
+	li $v0, 10
+	syscall
+	L_87:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t0)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 32
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	li $a0, 20
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t3 $t0
+	L_88:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	lw $a1, 12($t3)
+	move $t1 $a1
+	move $a0 $t0
+	move $a1 $t1
+	jal less
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_89
+	j L_94
+	L_89:
+	lw $a1, 12($t2)
+	move $t0 $a1
+	move $t0 $t0
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t1 $v0
+	bne $t1 $zero L_90
+	j L_91
+	L_90:
+	li $v0, 4
+	la $a0, data_20
+	syscall
+	li $v0, 10
+	syscall
+	L_91:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t0)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 56
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t2)
+	move $t0 $a1
+	move $t0 $t0
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t1 $v0
+	bne $t1 $zero L_92
+	j L_93
+	L_92:
+	li $v0, 4
+	la $a0, data_21
+	syscall
+	li $v0, 10
+	syscall
+	L_93:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t0)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 32
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t3)
+	move $t0 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t1 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t1)
+	move $t1 $a1
+	sub $t0 $t0 $t1
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t3 $t0
+	j L_88
+	L_94:
+	move $t0 $zero
+	move $v0 $t2
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 148
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_27:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t8, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t8, 0($sp)
+	li $t7, 6
+	sll $t7 $t7 2
+	la $t8, proto_table
+	addu $t8 $t8 $t7
+	lw $t8, 0($t8)
+	lw $a0, 4($t8)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t8
+	move $a1 $v0
+	jal copy
+	lw $t8, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	move $t1 $v0
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	jal L_28
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t1
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t8, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_28:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, 0
+	addi $sp, $sp, 0
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+
+
+    
+    alloc_size       = 2048
+    free_list = 0
+    header_size = 12
+    header_size_slot = 0
+    header_next_slot = 4
+    header_reachable_slot = 8
+    init_alloc_size = 28
+    int_type = 0
+    meta_data_obj_size = 4
+    neg_header_size = -12
+    new_line = 10
+    obj_mark = -1
+    obj_extended = -2
+    reachable = 1
+    state_size = 4
+    stack_base = -4
+    string_size_treshold = 1024
+    string_type = 0
+    total_alloc_size =  2060
+    num_type = 0
+    used_list = header_size
+
+verify_obj:
+                addiu $sp $sp -20
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+
+                move $t0 $a0
+
+                li $v0 9
+                move $a0 $zero
+                syscall
+
+                addiu $t1 $v0 -4    
+
+                
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)
+                blt $t2 $zero verify_obj_not_obj
+                la $t3 num_type
+                lw $t3 0($t3)
+                bge $t2 $t3 verify_obj_not_obj
+
+                addiu $t0 $t0 4
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)   
+
+                addiu $t0 $t0 8
+                
+
+                li $t3 meta_data_obj_size
+                sub $t2 $t2 $t3 
+                sll $t2 $t2 2
+                addu $t0 $t0 $t2
+                
+                
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)
+                beq $t2 obj_mark verify_obj_is_obj
+                beq $t2 obj_extended verify_obj_is_obj
+
+verify_obj_not_obj:
+                li $v0 0
+                j verify_obj_finish
+
+verify_obj_is_obj:
+                li $v0 1
+
+verify_obj_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                addiu $sp $sp 20
+
+                jr $ra
+
+concat:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $a0 12($sp)
+                sw $a1 16($sp)
+                sw $ra 20($sp)
+
+                move $t0 $a0
+                move $t1 $a1
+
+
+                addiu $a0 $a2 1
+                li $t2 4
+                div $a0 $t2
+                mfhi $a0
+                bne $a0 $zero concat_allign_size
+                addiu $a0 $a2 1
+
+concat_size_alligned:
+                jal malloc
+                move $t2 $v0
+                j concat_copy_first_cycle
+
+concat_allign_size:
+                sub $t2 $t2 $a0
+                add $a0 $a2 $t2
+                addiu $a0 $a0 1
+                j concat_size_alligned
+
+concat_copy_first_cycle:
+                lb $a0 0($t0)
+                beq $a0 $zero concat_copy_second_cycle
+                sb $a0 0($t2)
+                addiu $t0 $t0 1
+                addiu $t2 $t2 1
+                j concat_copy_first_cycle
+
+concat_copy_second_cycle:
+                lb $a0 0($t1)
+                beq $a0 $zero concat_finish
+                sb $a0 0($t2)
+                addiu $t1 $t1 1
+                addiu $t2 $t2 1
+                j concat_copy_second_cycle
+
+concat_finish:
+                sb $zero 0($t2)
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $a0 12($sp)
+                lw $a1 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra
+
+copy:
+                addiu $sp $sp -16
+                sw $a0 0($sp)
+                sw $a1 4($sp)
+                sw $a2 8($sp)
+                sw $t0 12($sp)
+
+copy_cycle:
+                beq $a2 $zero copy_finish
+                lw $t0 0($a0)
+                sw $t0 0($a1)
+                addiu $a0 $a0 4
+                addiu $a1 $a1 4
+                addi $a2 $a2 -4
+                j copy_cycle
+
+copy_finish:
+                lw $a0 0($sp)
+                lw $a1 4($sp)
+                lw $a2 8($sp)
+                lw $t0 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+eqs:
+                beq $a0 $a1 eqs_eq
+                li $v0 0
+                j eqs_finish
+
+eqs_eq:
+                li $v0 1
+
+eqs_finish:
+                jr $ra
+
+eq_string:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+
+                move $t0 $a0
+                move $t1 $a1
+
+eq_string_cycle:
+                lb $t2 0($t0)
+                lb $t3 0($t1)
+                bne $t2 $t3 eq_string_not_eq
+                beq $t2 $zero eq_string_eq
+
+                addiu $t0 $t0 1
+                addiu $t1 $t1 1
+                j eq_string_cycle
+
+eq_string_not_eq:
+                move $v0 $zero
+                j eq_string_finish
+
+eq_string_eq:
+                li $v0 1
+
+eq_string_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+extend_block:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+
+                
+                addiu $t0 $gp free_list     
+
+                beq $t0 $a0 extend_block_finish  
+                move $t0 $a0
+
+                lw $t1 header_next_slot($t0)
+                lw $t2 header_size_slot($t0)
+                move $t3 $t2
+                addiu $t2 $t2 header_size
+                addu $t2 $t2 $t0
+                beq $t2 $t1 extend_block_extend
+                j extend_block_finish
+
+extend_block_extend:
+                lw $t2 header_size_slot($t1)
+                addi $t2 $t2 header_size
+                add $t2 $t2 $t3
+                sw $t2 header_size_slot($t0)
+                lw $t1 header_next_slot($t1)
+                sw $t1 header_next_slot($t0)
+
+extend_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+extend_heap:
+                addiu $sp $sp -12
+                sw $a0 0($sp)
+                sw $a1 4($sp)
+                sw $t0 8($sp)
+
+                
+                li $v0 9
+                addiu $a0 $a1 header_size
+                syscall
+                
+                
+                move $t0 $a1 
+                sw $t0 header_size_slot($v0)
+                sw $zero header_next_slot($v0)
+                sw $zero header_reachable_slot($v0)
+
+               
+                lw $t0, 0($sp)
+                sw $v0 header_next_slot($t0)
+
+                move $a0 $t0
+                lw $a1 4($sp)
+                lw $t0 8($sp)
+                addiu $sp $sp 12
+
+                jr $ra
+
+free_block:
+                addiu $sp $sp -28
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $a0 12($sp)
+                sw $ra 16($sp)
+                sw $t3 20($sp)
+                sw $t4 24($sp)
+
+                move $t0 $a0
+
+                addiu $t1 $gp free_list
+
+                addiu $t3 $gp used_list
+
+free_block_cycle_used_list:
+                lw $t4 header_next_slot($t3)
+                beq $t4 $t0 free_block_cycle_free_list
+                move $t3 $t4
+                j free_block_cycle_used_list
+
+free_block_cycle_free_list:
+                lw $t2 header_next_slot($t1)
+                beq $t2 $zero free_block_founded_prev
+                bge $t2 $t0 free_block_founded_prev
+                move $t1 $t2
+                j free_block_cycle_free_list
+
+free_block_founded_prev:  
+                lw $t4 header_next_slot($t0)
+                sw $t4 header_next_slot($t3)
+                
+                
+                sw $t2 header_next_slot($t0)
+                sw $t0 header_next_slot($t1)
+
+free_block_finish:
+    
+                move $a0 $t0
+                jal extend_block
+                move $a0 $t1
+                jal extend_block
+
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $a0 12($sp)
+                lw $ra 16($sp)
+                lw $t3 20($sp)
+                lw $t4 24($sp)
+                addiu $sp $sp 28
+
+                jr $ra
+
+get_gc:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+                sw $ra 20($sp)
+
+                li $t3 reachable    
+                addiu $t0 $sp 20    
+                lw $t1 stack_base($gp)  
+
+                li $t2 1
+
+get_gc_cycle:
+
+                addiu $t0 $t0 4
+                beq $t0 $t1 get_gc_dfs      
+                
+                lw $a0 0($t0)
+                jal verify_obj
+                
+                bne $v0 $t2 get_gc_cycle
+
+                addiu $a0 $a0 neg_header_size
+                sw $t3 header_reachable_slot($a0)
+                
+                j get_gc_cycle
+
+get_gc_dfs:
+                addiu $t1 $gp used_list
+
+get_gc_outer_cycle:
+                lw $t1 header_next_slot($t1)
+                beq $t1 $zero get_gc_free
+                lw $t2 header_reachable_slot($t1)
+                beq $t2 reachable get_gc_extend
+                j get_gc_outer_cycle
+
+get_gc_extend:
+                addiu $a0 $t1 header_size    
+                jal get_gc_rec_extend
+                j get_gc_outer_cycle
+
+get_gc_free:
+                addiu $t0 $gp used_list
+                lw $t0 header_next_slot($t0)
+
+get_gc_free_cycle:
+                beq $t0 $zero get_gc_finish
+                lw $t1 header_reachable_slot($t0)
+                bne $t1 reachable get_gc_free_cycle_free
+                sw $zero header_reachable_slot($t0)
+                move $a0 $t0
+                jal verify_obj
+                beq $v0 $zero get_gc_free_cycle
+                li $t1 obj_mark
+                addiu $t2 $t0 header_size
+                lw $t3 4($t2)
+                sll $t3 $t3 2
+                addu $t2 $t2 $t3
+                sw $t1 -4($t2)
+                lw $t0 header_next_slot($t0)
+                j get_gc_free_cycle
+
+get_gc_free_cycle_free:
+                move $a0 $t0
+                lw $t0 header_next_slot($t0)
+                jal free_block
+                j get_gc_free_cycle
+
+get_gc_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra
+
+get_gc_rec_extend:
+                addiu $sp $sp -16
+                sw $a0 0($sp)
+                sw $t0 4($sp)
+                sw $t1 8($sp)
+                sw $ra 12($sp)
+                
+                jal verify_obj 
+                beq $v0 $zero get_gc_rec_extend_finish
+
+                lw $t0 4($a0)
+                sll $t0 $t0 2
+                addiu $t0 $t0 -4
+                addu $t0 $a0 $t0
+                lw $t1 0($t0)   
+                beq $t1 obj_extended get_gc_rec_extend_finish
+                
+                
+                li $t1 reachable
+                addiu $a0 $a0 neg_header_size
+                sw $t1 header_reachable_slot($a0)
+                addiu $a0 $a0 header_size 
+
+                
+                li $t1 obj_extended
+                sw $t1 0($t0)
+
+                lw $t0 0($a0)   
+                
+                
+                la $t1 int_type
+                lw $t1 0($t1)
+                beq $t0 $t1 get_gc_rec_extend_finish
+
+                la $t1 string_type
+                lw $t1 0($t1)
+                beq $t0 $t1 get_gc_rec_extend_string_obj
+
+                lw $t0 4($a0)
+                li $t1 meta_data_obj_size
+                sub $t0 $t0 $t1
+                
+                addiu $t1 $a0 12
+
+get_gc_rec_extend_attr_cycle:
+                beq $t0 $zero get_gc_rec_extend_finish
+                lw $a0 0($t1)
+                jal get_gc_rec_extend
+                addiu $t1 $t1 4
+                sub $t0 $t0 1
+                j get_gc_rec_extend_attr_cycle
+
+get_gc_rec_extend_string_obj:
+                lw $t0 8($a0)
+                addiu $t0 $t0 neg_header_size
+                li $t1 reachable
+                sw $t1 header_reachable_slot($t0)
+
+get_gc_rec_extend_finish:
+                lw $a0 0($sp)
+                lw $t0 4($sp)
+                lw $t1 8($sp)
+                lw $ra 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+less_eq:
+                ble $a0 $a1 less_eq_true
+                li $v0 0
+                j less_eq_finish
+
+less_eq_true:
+                li $v0 1
+
+less_eq_finish:
+                jr $ra
+
+less:
+                blt $a0 $a1 less_true
+                li $v0 0
+                j less_finish
+
+less_true:
+                li $v0 1
+
+less_finish:
+                jr $ra
+
+len:
+                addiu $sp $sp -8
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+
+                move $t0 $a0
+                move $v0 $zero
+
+len_cycle:
+                lb $t1 0($t0)
+                beq $t1 $zero len_finish
+                addi $v0 $v0 1
+                addiu $t0 $t0 1
+                j len_cycle
+
+len_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                addiu $sp $sp 8
+
+                jr $ra
+
+malloc:
+                move $v0 $zero
+                addiu $sp $sp -28
+                sw $t1 0($sp)
+                sw $t0 4($sp)
+                sw $a0 8($sp)
+                sw $a1 12($sp)
+                sw $ra 16($sp)
+                sw $t2 20($sp)
+                sw $t3 24($sp)
+                
+                addiu $t0 $gp free_list
+                j malloc_cycle
+
+malloc_finish:
+                move $a0 $v0
+                lw $a1 8($sp)                  
+                jal divide_block
+
+                lw $t1 header_next_slot($v0)
+                sw $t1 header_next_slot($t3)
+
+                addiu $t1 $gp used_list
+                lw $a0 header_next_slot($t1)
+
+                sw $a0 header_next_slot($v0)
+                sw $v0 header_next_slot($t1)
+                
+                addiu $v0 $v0 header_size
+
+                lw $t3 24($sp)
+                lw $t2 20($sp)
+                lw $ra 16($sp)
+                lw $a1 12($sp)
+                lw $a0 8($sp)
+                lw $t0 4($sp)
+                lw $t1 0($sp)
+                addiu $sp $sp 28
+
+                jr $ra
+
+malloc_cycle:
+                move $t2 $t0                        
+                lw $t0 header_next_slot($t0)        
+                beq $t0 $zero malloc_search_finish     
+                j malloc_verify_valid_block
+
+malloc_search_finish:
+                beq $v0 $zero malloc_alloc_new_block 
+                j malloc_finish
+
+malloc_alloc_new_block:
+                li $t1 alloc_size               
+                move $t3 $t2
+                move $a1 $a0                    
+                move $a0 $t2                    
+                bge $a1 $t1 malloc_big_block    
+                li $a1 alloc_size        
+                jal extend_heap
+                
+                j malloc_finish
+
+malloc_big_block:
+                jal extend_heap
+                j malloc_finish
+
+malloc_verify_valid_block:
+                lw $t1 header_size_slot($t0)             
+                bge $t1 $a0 malloc_valid_block    
+                j malloc_cycle
+
+malloc_valid_block:
+                beq $v0 $zero malloc_first_valid_block    
+                bge $t1 $v1 malloc_cycle                    
+                move $v0 $t0                        
+                move $v1 $t1  
+                move $t3 $t2
+                j malloc_cycle
+
+malloc_first_valid_block:
+                move $v0 $t0                        
+                move $v1 $t1                        
+                move $t3 $t2 
+                j malloc_cycle
+
+mem_manager_init:
+                addiu $sp $sp -16
+                sw $v0 0($sp)
+                sw $a0 4($sp)
+                sw $a1 8($sp)
+                sw $ra 12($sp)
+                li $v0 9
+                li $a0 init_alloc_size
+                syscall
+                move $gp $v0
+                addiu $gp $gp state_size
+
+                sw $zero header_size_slot($gp)
+                sw $zero header_reachable_slot($gp)
+
+                move $a0 $gp
+                li $a1 alloc_size
+                jal extend_heap
+
+                addiu $a0 $a0 header_size
+                sw $zero header_size_slot($a0)
+                sw $zero header_next_slot($a0)
+                sw $zero header_reachable_slot($a0)
+
+
+
+                lw $v0 0($sp)
+                lw $a0 4($sp)
+                lw $a1 8($sp)
+                lw $ra 12($sp)
+                addiu $sp $sp 16
+
+                sw $sp stack_base($gp)
+
+                jr $ra
+
+get_string:
+                addiu $sp $sp -36
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $t4 16($sp)
+                sw $t5 20($sp)
+                sw $a0 24($sp)
+                sw $a1 28($sp)
+                sw $ra 32($sp)
+                
+                addiu $t0 $gp free_list
+                move $t1 $zero
+                move $t2 $t0
+
+get_string_larger_block_cycle:
+                lw $t0 header_next_slot($t0)
+                beq $t0 $zero get_string_reading
+                lw $t3 header_size_slot($t0)
+                bge $t1 $t3 get_string_larger_block_cycle
+                move $t1 $t3
+                move $t2 $t0
+                j get_string_larger_block_cycle
+
+get_string_reading:
+                beq $t1 $zero get_string_new_block
+                move $a1 $t1
+                li $v0 8
+                addiu $a0 $t2 header_size
+                syscall
+                move $t0 $a0
+                move $t1 $zero
+
+get_string_look_nl:
+                lb $t2 0($t0)
+                beq $t2 new_line get_string_nl_founded
+                beq $t2 $zero get_string_zero_founded
+                addi $t1 $t1 1
+                addi $t0 $t0 1
+                j get_string_look_nl
+
+get_string_zero_founded:
+                blt $t1 $t3 get_string_nl_founded
+                j get_string_no_nl
+
+get_string_nl_founded:
+                sb $zero 0($t0)
+                addi $t1 $t1 1
+                li $t2 4
+                div $t1 $t2
+                mfhi $t3
+                beq $t3 $zero get_string_nl_founded_alligned
+                sub $t2 $t2 $t3
+                add $t1 $t1 $t2
+
+get_string_nl_founded_alligned:
+                move $a1 $t1
+                addiu $a0 $a0 neg_header_size
+                jal divide_block
+                jal use_block
+
+                addiu $v0 $a0 header_size
+                j get_string_finish
+
+get_string_no_nl:
+                addi $t1 $t1 1
+                blt $t1 string_size_treshold get_string_dup
+                addi $t1 $t1 alloc_size
+                j get_string_extend_heap
+
+get_string_dup:
+	            sll $t1 $t1 1
+
+get_string_extend_heap:
+                move $a1 $t1
+                move $t0 $a0
+                addiu $a0 $gp free_list
+
+get_string_last_block_cycle:
+                lw $t1 header_next_slot($a0)
+                beq $t1 $zero get_string_last_block_founded
+                lw $a0 header_next_slot($a0)
+                j get_string_last_block_cycle
+
+get_string_last_block_founded:
+                jal extend_heap
+                jal extend_block
+                lw $t1 header_next_slot($a0)
+                bne $t1 $zero get_string_copy_prev
+                move $t1 $a0
+
+get_string_copy_prev:
+                lw $t3 header_size_slot($t1)
+                move $t2 $zero
+                move $t5 $t1
+                addiu $t1 $t1 header_size
+
+get_string_copy_cycle:
+                lb $t4 0($t0)
+                beq $t4 $zero get_string_copy_finish
+                sb $t4 0($t1)
+                addi $t2 $t2 1
+                addi $t0 $t0 1
+                addi $t1 $t1 1
+                j get_string_copy_cycle
+
+get_string_copy_finish:
+                sub $t3 $t3 $t2
+                move $a0 $t1
+                move $a1 $t3
+                li $v0 8
+                syscall
+                move $t0 $a0
+                move $t1 $t2
+                addiu $a0 $t5 header_size
+                j get_string_look_nl
+
+get_string_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $t4 16($sp)
+                lw $t5 20($sp)
+                lw $a0 24($sp)
+                lw $a1 28($sp)
+                lw $ra 32($sp)
+                addiu $sp $sp 36
+
+                jr $ra
+
+get_string_new_block:
+    addiu $t0 $gp free_list
+
+get_string_new_block_search_last:
+                lw $t1 header_next_slot($t0)
+                beq $t1 $zero get_string_new_block_create
+                move $t0 $t1
+                j get_string_new_block_search_last
+
+get_string_new_block_create:
+                move $a0 $t0
+                li $a1 alloc_size
+                jal extend_heap
+                jal extend_block
+                lw $t2 header_next_slot($a0)
+                beq $t2 $zero get_string_new_block_extended
+                lw $t1 header_size_slot($t2)
+                j get_string_reading
+
+get_string_new_block_extended:
+                move $t2 $a0
+                lw $t1 header_size_slot($a0)
+                j get_string_reading
+
+divide_block:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $a0 8($sp)
+                sw $a1 12($sp)
+
+                
+                lw $t0 header_size_slot($a0)
+                bgt $a1 $t0 divide_block_error_small
+                
+    
+                sub $t0 $t0 $a1
+                li $t1 header_size
+                ble $t0 $t1 divide_block_same_size
+
+               
+                addu $t0 $a0 $a1
+                addiu $t0 $t0 header_size     
+
+                
+                lw $t1 header_next_slot($a0)    
+                sw $t1 header_next_slot($t0)
+                sw $t0 header_next_slot($a0)
+
+                lw $t1 header_size_slot($a0)    
+                sub $t1 $t1 $a1
+
+                addi $t1 $t1 neg_header_size
+                sw $t1 header_size_slot($t0)
+                sw $a1 header_size_slot($a0)
+                move $v0 $a0
+                j divide_block_finish
+
+divide_block_same_size:
+                move $v0 $a0
+                j divide_block_finish
+
+divide_block_error_small:
+                j divide_block_finish
+
+divide_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $a0 8($sp)
+                lw $a1 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+sub_string:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+                sw $ra 20($sp)
+
+                move $t0 $a0
+                li $t1 4
+                addiu $t3 $a2 1
+                div $t3 $t1
+            
+                mfhi $t2
+                bne $t2 $zero sub_string_allign_size
+                move $t1 $t3
+                j sub_string_new_block
+
+sub_string_allign_size:
+                sub $t1 $t1 $t2
+                add $t1 $t1 $t3
+
+sub_string_new_block:
+                move $a0 $t1
+                jal malloc
+                move $t3 $v0
+                move $t1 $zero
+                addu $t0 $t0 $a1
+
+sub_string_copy_cycle:
+                beq $t1 $a2 sub_string_finish
+                lb $t2 0($t0)
+                sb $t2 0($t3)
+                addiu $t0 $t0 1
+                addiu $t3 $t3 1
+                addiu $t1 $t1 1
+                j sub_string_copy_cycle
+
+sub_string_finish:
+                sb $zero 0($t3)
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra
+
+use_block:
+    addiu $sp $sp -12
+    sw $t0 0($sp)
+    sw $t1 4($sp)
+    sw $t2 8($sp)
+
+    addiu $t0 $gp free_list
+
+use_block_cycle:
+                move $t1 $t0
+                lw $t0 header_next_slot($t0)
+                beq $t0 $zero use_block_finish
+                beq $t0 $a0 use_block_founded
+                j use_block_cycle
+
+use_block_founded:
+                lw $t2 header_next_slot($t0)
+                sw $t2 header_next_slot($t1)
+
+                addiu $t1 $gp used_list
+                lw $t2 header_next_slot($t1)
+                sw $t0 header_next_slot($t1)
+                sw $t2 header_next_slot($t0)
+
+use_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                addiu $sp $sp 12
+
+                jr $ra
+
diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
index 74a037557..5b96ca925 100644
--- a/src/utils/code_generation/cil/Base_COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -14,11 +14,11 @@ def __init__(self, context):
 
         self.context = context
         self.vself = VariableInfo('self', None)
-    
+
     @property
     def params(self):
         return self.current_function.params
-    
+
     @property
     def localvars(self):
         return self.current_function.localvars
@@ -26,22 +26,22 @@ def localvars(self):
     @property
     def ids(self):
         return self.current_function.ids
-    
+
     @property
     def instructions(self):
         return self.current_function.instructions
-    
+
     def register_param(self, vinfo):
         param_node = nodes.ParamNode(vinfo.name)
         self.params.append(param_node)
         return vinfo.name
-    
+
     def register_local(self, vinfo, id=False):
         if len(self.current_function.id) >= 8 and self.current_function.id[:8] == 'function':
             name = f'local_{self.current_function.id[9:]}_{vinfo.name}_{len(self.localvars)}'
         else:
             name = f'local_{self.current_function.id[5:]}_{vinfo.name}_{len(self.localvars)}'
-        
+
         new_vinfo = VariableInfo(name, None)
         local_node = nodes.LocalNode(new_vinfo.name)
 
@@ -58,7 +58,7 @@ def define_internal_local(self):
     def register_instruction(self, instruction):
         self.instructions.append(instruction)
         return instruction
-    
+
     def to_function_name(self, method_name, type_name):
         return f'function_{method_name}_at_{type_name}'
 
@@ -66,12 +66,12 @@ def init_name(self, type_name, attr=False):
         if attr:
             return f'init_attr_at_{type_name}'
         return f'init_at_{type_name}'
-    
+
     def register_function(self, function_name):
         function_node = nodes.FunctionNode(function_name, [], [], [])
         self.dotcode.append(function_node)
         return function_node
-    
+
     def register_type(self, name):
         type_node = nodes.TypeNode(name)
         self.dottypes.append(type_node)
@@ -87,42 +87,42 @@ def register_label(self, label):
         lname = f'{label}_{self.current_function.labels_count}'
         self.current_function.labels_count += 1
         return nodes.LabelNode(lname)
-    
+
     def register_runtime_error(self, condition, msg):
         error_node = self.register_label('error_label')
         continue_node = self.register_label('continue_label')
-        self.register_instruction(nodes.IfGotoNode(condition, error_node.label))
+        self.register_instruction(
+            nodes.IfGotoNode(condition, error_node.label))
         self.register_instruction(nodes.GotoNode(continue_node.label))
         self.register_instruction(error_node)
         data_node = self.register_data(msg)
         self.register_instruction(nodes.ErrorNode(data_node))
         self.register_instruction(continue_node)
-    
+
     def register_built_in(self):
         self.__register_Object()
         self.__register_IO()
-        self.__register_Int()
         self.__register_String()
+        self.__register_Int()
         self.__register_Bool()
 
-
-
-
-
-
     # convirtiendo tipos y funciones integrados en COOL en CIL
+
     def __register_Object(self):
         type_node = self.register_type('Object')
 
-        self.current_function = self.register_function(self.init_name('Object'))
+        self.current_function = self.register_function(
+            self.init_name('Object'))
         instance = self.define_internal_local()
         self.register_instruction(nodes.AllocateNode('Object', instance))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        self.current_function = self.register_function(self.to_function_name('abort', 'Object'))
+        self.current_function = self.register_function(
+            self.to_function_name('abort', 'Object'))
         self.register_param(self.vself)
         vname = self.define_internal_local()
-        data_node = [dn for dn in self.dotdata if dn.value == 'Aborting... in class '][0]
+        data_node = [dn for dn in self.dotdata if dn.value ==
+                     'Aborting... in class '][0]
         self.register_instruction(nodes.LoadNode(vname, data_node))
         self.register_instruction(nodes.PrintStrNode(vname))
         self.register_instruction(nodes.TypeNameNode(vname, self.vself.name))
@@ -132,24 +132,28 @@ def __register_Object(self):
         self.register_instruction(nodes.PrintStrNode(vname))
         self.register_instruction(nodes.AbortNode())
 
-        self.current_function = self.register_function(self.to_function_name('type_name', 'Object'))
+        self.current_function = self.register_function(
+            self.to_function_name('type_name', 'Object'))
         self.register_param(self.vself)
         result = self.define_internal_local()
         self.register_instruction(nodes.TypeNameNode(result, self.vself.name))
         instance = self.define_internal_local()
         self.register_instruction(nodes.ArgNode(result))
-        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.StaticCallNode(
+            self.init_name('String'), instance))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        self.current_function = self.register_function(self.to_function_name('copy', 'Object'))
+        self.current_function = self.register_function(
+            self.to_function_name('copy', 'Object'))
         self.register_param(self.vself)
         result = self.define_internal_local()
         self.register_instruction(nodes.CopyNode(result, self.vself.name))
         self.register_instruction(nodes.ReturnNode(result))
 
-        type_node.methods = [(name, self.to_function_name(name, 'Object')) for name in ['abort', 'type_name', 'copy']]
+        type_node.methods = [(name, self.to_function_name(name, 'Object'))
+                             for name in ['abort', 'type_name', 'copy']]
         type_node.methods += [('init', self.init_name('Object'))]
-    
+
     def __register_IO(self):
         type_node = self.register_type('IO')
 
@@ -158,44 +162,54 @@ def __register_IO(self):
         self.register_instruction(nodes.AllocateNode('IO', instance))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        self.current_function = self.register_function(self.to_function_name('out_string', 'IO'))
+        self.current_function = self.register_function(
+            self.to_function_name('out_string', 'IO'))
         self.register_param(self.vself)
         self.register_param(VariableInfo('x', None))
         vname = self.define_internal_local()
-        self.register_instruction(nodes.GetAttrNode(vname, 'x', 'value', 'String'))
+        self.register_instruction(
+            nodes.GetAttrNode(vname, 'x', 'value', 'String'))
         self.register_instruction(nodes.PrintStrNode(vname))
         self.register_instruction(nodes.ReturnNode(self.vself.name))
 
-        self.current_function = self.register_function(self.to_function_name('out_int', 'IO'))
+        self.current_function = self.register_function(
+            self.to_function_name('out_int', 'IO'))
         self.register_param(self.vself)
         self.register_param(VariableInfo('x', None))
         vname = self.define_internal_local()
-        self.register_instruction(nodes.GetAttrNode(vname, 'x', 'value', 'Int'))
+        self.register_instruction(
+            nodes.GetAttrNode(vname, 'x', 'value', 'Int'))
         self.register_instruction(nodes.PrintIntNode(vname))
-        self.register_instruction(nodes.ReturnNode(self.vself.name)) 
+        self.register_instruction(nodes.ReturnNode(self.vself.name))
 
-        self.current_function = self.register_function(self.to_function_name('in_string', 'IO'))
+        self.current_function = self.register_function(
+            self.to_function_name('in_string', 'IO'))
         self.register_param(self.vself)
         result = self.define_internal_local()
         self.register_instruction(nodes.ReadStrNode(result))
         instance = self.define_internal_local()
         self.register_instruction(nodes.ArgNode(result))
-        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.StaticCallNode(
+            self.init_name('String'), instance))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        self.current_function = self.register_function(self.to_function_name('in_int', 'IO'))
+        self.current_function = self.register_function(
+            self.to_function_name('in_int', 'IO'))
         self.register_param(self.vself)
         result = self.define_internal_local()
         self.register_instruction(nodes.ReadIntNode(result))
         instance = self.define_internal_local()
         self.register_instruction(nodes.ArgNode(result))
-        self.register_instruction(nodes.StaticCallNode(self.init_name('Int'), instance))
-        self.register_instruction(nodes.ReturnNode(instance))  
+        self.register_instruction(nodes.StaticCallNode(
+            self.init_name('Int'), instance))
+        self.register_instruction(nodes.ReturnNode(instance))
 
-        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
-        type_node.methods += [(name, self.to_function_name(name, 'IO')) for name in ['out_string', 'out_int', 'in_string', 'in_int']]
+        type_node.methods = [(method, self.to_function_name(
+            method, 'Object')) for method in ['type_name', 'abort', 'copy']]
+        type_node.methods += [(name, self.to_function_name(name, 'IO'))
+                              for name in ['out_string', 'out_int', 'in_string', 'in_int']]
         type_node.methods += [('init', self.init_name('IO'))]
-    
+
     def __register_Int(self):
         type_node = self.register_type('Int')
         type_node.attributes = ['value']
@@ -204,58 +218,76 @@ def __register_Int(self):
         self.register_param(VariableInfo('val', None))
         instance = self.define_internal_local()
         self.register_instruction(nodes.AllocateNode('Int', instance))
-        self.register_instruction(nodes.SetAttrNode(instance, 'value', 'val', 'Int'))
+        self.register_instruction(nodes.SetAttrNode(
+            instance, 'value', 'val', 'Int'))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
+        type_node.methods = [(method, self.to_function_name(
+            method, 'Object')) for method in ['type_name', 'abort', 'copy']]
         type_node.methods += [('init', self.init_name('Int'))]
-    
+
     def __register_String(self):
         type_node = self.register_type('String')
         type_node.attributes = ['value', 'length']
 
-        self.current_function = self.register_function(self.init_name('String'))
+        self.current_function = self.register_function(
+            self.init_name('String'))
         self.register_param(VariableInfo('val', None))
         instance = self.define_internal_local()
         self.register_instruction(nodes.AllocateNode('String', instance))
-        self.register_instruction(nodes.SetAttrNode(instance, 'value', 'val', 'String'))
+        self.register_instruction(nodes.SetAttrNode(
+            instance, 'value', 'val', 'String'))
         result = self.define_internal_local()
         self.register_instruction(nodes.LengthNode(result, 'val'))
         attr = self.define_internal_local()
         self.register_instruction(nodes.ArgNode(result))
-        self.register_instruction(nodes.StaticCallNode(self.init_name('Int'), attr))
-        self.register_instruction(nodes.SetAttrNode(instance, 'length', attr, 'String'))
+        self.register_instruction(
+            nodes.StaticCallNode(self.init_name('Int'), attr))
+        self.register_instruction(nodes.SetAttrNode(
+            instance, 'length', attr, 'String'))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        self.current_function = self.register_function(self.to_function_name('length', 'String'))
+        self.current_function = self.register_function(
+            self.to_function_name('length', 'String'))
         self.register_param(self.vself)
         result = self.define_internal_local()
-        self.register_instruction(nodes.GetAttrNode(result, self.vself.name, 'length', 'String'))
+        self.register_instruction(nodes.GetAttrNode(
+            result, self.vself.name, 'length', 'String'))
         self.register_instruction(nodes.ReturnNode(result))
 
-        self.current_function = self.register_function(self.to_function_name('concat', 'String'))
+        self.current_function = self.register_function(
+            self.to_function_name('concat', 'String'))
         self.register_param(self.vself)
         self.register_param(VariableInfo('s', None))
         str_1 = self.define_internal_local()
         str_2 = self.define_internal_local()
         length_1 = self.define_internal_local()
         length_2 = self.define_internal_local()
-        self.register_instruction(nodes.GetAttrNode(str_1, self.vself.name, 'value', 'String'))
-        self.register_instruction(nodes.GetAttrNode(str_2, 's', 'value', 'String'))
-        self.register_instruction(nodes.GetAttrNode(length_1, self.vself.name, 'length', 'String'))
-        self.register_instruction(nodes.GetAttrNode(length_2, 's', 'length', 'String'))
-        self.register_instruction(nodes.GetAttrNode(length_1, length_1, 'value', 'Int'))
-        self.register_instruction(nodes.GetAttrNode(length_2, length_2, 'value', 'Int'))
+        self.register_instruction(nodes.GetAttrNode(
+            str_1, self.vself.name, 'value', 'String'))
+        self.register_instruction(
+            nodes.GetAttrNode(str_2, 's', 'value', 'String'))
+        self.register_instruction(nodes.GetAttrNode(
+            length_1, self.vself.name, 'length', 'String'))
+        self.register_instruction(nodes.GetAttrNode(
+            length_2, 's', 'length', 'String'))
+        self.register_instruction(nodes.GetAttrNode(
+            length_1, length_1, 'value', 'Int'))
+        self.register_instruction(nodes.GetAttrNode(
+            length_2, length_2, 'value', 'Int'))
         self.register_instruction(nodes.PlusNode(length_1, length_1, length_2))
 
         result = self.define_internal_local()
-        self.register_instruction(nodes.ConcatNode(result, str_1, str_2, length_1))
+        self.register_instruction(
+            nodes.ConcatNode(result, str_1, str_2, length_1))
         instance = self.define_internal_local()
         self.register_instruction(nodes.ArgNode(result))
-        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.StaticCallNode(
+            self.init_name('String'), instance))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        self.current_function = self.register_function(self.to_function_name('substr', 'String'))
+        self.current_function = self.register_function(
+            self.to_function_name('substr', 'String'))
         self.register_param(self.vself)
         self.register_param(VariableInfo('i', None))
         self.register_param(VariableInfo('l', None))
@@ -266,24 +298,34 @@ def __register_String(self):
         length_substr = self.define_internal_local()
         less_value = self.define_internal_local()
         str_value = self.define_internal_local()
-        self.register_instruction(nodes.GetAttrNode(str_value, self.vself.name, 'value', 'String'))
-        self.register_instruction(nodes.GetAttrNode(index_value, 'i', 'value', 'Int'))
-        self.register_instruction(nodes.GetAttrNode(length_value, 'l', 'value', 'Int'))
-      
-        self.register_instruction(nodes.GetAttrNode(length_attr, self.vself.name, 'length', 'String'))
-        self.register_instruction(nodes.PlusNode(length_substr, length_value, index_value))
-        self.register_instruction(nodes.LessThanNode(less_value, length_attr, length_substr))
+        self.register_instruction(nodes.GetAttrNode(
+            str_value, self.vself.name, 'value', 'String'))
+        self.register_instruction(nodes.GetAttrNode(
+            index_value, 'i', 'value', 'Int'))
+        self.register_instruction(nodes.GetAttrNode(
+            length_value, 'l', 'value', 'Int'))
+
+        self.register_instruction(nodes.GetAttrNode(
+            length_attr, self.vself.name, 'length', 'String'))
+        self.register_instruction(nodes.PlusNode(
+            length_substr, length_value, index_value))
+        self.register_instruction(nodes.LessThanNode(
+            less_value, length_attr, length_substr))
         self.register_runtime_error(less_value, 'Substring out of range')
-        self.register_instruction(nodes.SubstringNode(result, str_value, index_value, length_value))
+        self.register_instruction(nodes.SubstringNode(
+            result, str_value, index_value, length_value))
         instance = self.define_internal_local()
         self.register_instruction(nodes.ArgNode(result))
-        self.register_instruction(nodes.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes.StaticCallNode(
+            self.init_name('String'), instance))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
-        type_node.methods += [(name, self.to_function_name(name, 'String')) for name in ['length', 'concat', 'substr']]
+        type_node.methods = [(method, self.to_function_name(
+            method, 'Object')) for method in ['type_name', 'abort', 'copy']]
+        type_node.methods += [(name, self.to_function_name(name, 'String'))
+                              for name in ['length', 'concat', 'substr']]
         type_node.methods += [('init', self.init_name('String'))]
-    
+
     def __register_Bool(self):
         type_node = self.register_type('Bool')
         type_node.attributes = ['value']
@@ -292,8 +334,10 @@ def __register_Bool(self):
         self.register_param(VariableInfo('val', None))
         instance = self.define_internal_local()
         self.register_instruction(nodes.AllocateNode('Bool', instance))
-        self.register_instruction(nodes.SetAttrNode(instance, 'value', 'val', 'Bool'))
+        self.register_instruction(nodes.SetAttrNode(
+            instance, 'value', 'val', 'Bool'))
         self.register_instruction(nodes.ReturnNode(instance))
 
-        type_node.methods = [(method, self.to_function_name(method, 'Object')) for method in ['type_name','abort','copy']]
-        type_node.methods += [('init', self.init_name('Bool'))]
\ No newline at end of file
+        type_node.methods = [(method, self.to_function_name(
+            method, 'Object')) for method in ['type_name', 'abort', 'copy']]
+        type_node.methods += [('init', self.init_name('Bool'))]
diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 140146854..220bd2ba5 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -4,93 +4,101 @@
 from utils.code_generation.cil.AST_CIL import cil_ast as nodes_cil
 from utils.code_generation.cil.Base_COOL_to_CIL import BaseCOOLToCIL
 
+
 class COOLtoCIL(BaseCOOLToCIL):
     def __init__(self, context):
         BaseCOOLToCIL.__init__(self, context)
 
-
     @visitor.on('node')
     def visit(self, node, scope):
         pass
 
-
     @visitor.when(nodes.ProgramNode)
     def visit(self, node, scope=None):
         self.current_function = self.register_function('entry')
         result = self.define_internal_local()
         instance = self.register_local(VariableInfo('instance', None))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Main'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Main'), instance))
         self.register_instruction(nodes_cil.ArgNode(instance))
-        self.register_instruction(nodes_cil.StaticCallNode(self.to_function_name('main', 'Main'), result))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.to_function_name('main', 'Main'), result))
         self.register_instruction(nodes_cil.ReturnNode(0))
-       
+
         self.register_data('Aborting... in class ')
         self.register_built_in()
         self.current_function = None
-        
+
         for declaration, child_scope in zip(node.declarations, scope.children):
             self.visit(declaration, child_scope)
 
         return nodes_cil.ProgramNode(self.dottypes, self.dotdata, self.dotcode)
-    
 
     @visitor.when(nodes.ClassDeclarationNode)
     def visit(self, node, scope):
         self.current_type = self.context.get_type(node.id)
-        
+
         type_node = self.register_type(node.id)
-        type_node.attributes = [attr.name for attr, _ in self.current_type.all_attributes()]
-        type_node.methods = [(method.name, self.to_function_name(method.name, xtype.name)) for method, xtype in self.current_type.all_methods()]
+        type_node.attributes = [attr.name for attr,
+                                _ in self.current_type.all_attributes()]
+        type_node.methods = [(method.name, self.to_function_name(
+            method.name, xtype.name)) for method, xtype in self.current_type.all_methods()]
 
-        func_declarations = (f for f in node.features if isinstance(f, nodes.MethDeclarationNode))
+        func_declarations = (f for f in node.features if isinstance(
+            f, nodes.MethDeclarationNode))
         for feature, child_scope in zip(func_declarations, scope.children):
             self.visit(feature, child_scope)
 
         self.current_function = self.register_function(self.init_name(node.id))
-        
+
         instance = self.register_local(VariableInfo('instance', None))
-        self.register_instruction(nodes_cil.AllocateNode(node.id, instance))  
+        self.register_instruction(nodes_cil.AllocateNode(node.id, instance))
 
         temp_f = self.current_function
         vtemp = self.define_internal_local()
 
-        self.current_function = self.register_function(self.init_name(node.id, attr=True))
+        self.current_function = self.register_function(
+            self.init_name(node.id, attr=True))
         self.register_param(self.vself)
         if node.parent != 'Object' and node.parent != 'IO':
             self.register_instruction(nodes_cil.ArgNode(self.vself.name))
-            self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.parent, attr=True), vtemp))
-        attr_declarations = (f for f in node.features if isinstance(f, nodes.AttrDeclarationNode))
+            self.register_instruction(nodes_cil.StaticCallNode(
+                self.init_name(node.parent, attr=True), vtemp))
+        attr_declarations = (f for f in node.features if isinstance(
+            f, nodes.AttrDeclarationNode))
         for feature in attr_declarations:
             self.visit(feature, scope)
-        
+
         self.current_function = temp_f
         self.register_instruction(nodes_cil.ArgNode(instance))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.id, attr=True), vtemp))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name(node.id, attr=True), vtemp))
         self.register_instruction(nodes_cil.ReturnNode(instance))
         self.current_function = None
         self.current_type = None
 
-
     @visitor.when(nodes.AttrDeclarationNode)
     def visit(self, node, scope):
         if node.expr:
             self.visit(node.expr, scope)
-            self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, scope._return, self.current_type))
+            self.register_instruction(nodes_cil.SetAttrNode(
+                self.vself.name, node.id, scope._return, self.current_type))
         elif node.type in ['String', 'Int', 'Bool']:
             vtemp = self.define_internal_local()
             self.register_instruction(nodes_cil.AllocateNode(node.type, vtemp))
-            self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, vtemp, self.current_type))
-    
+            self.register_instruction(nodes_cil.SetAttrNode(
+                self.vself.name, node.id, vtemp, self.current_type))
 
     @visitor.when(nodes.MethDeclarationNode)
     def visit(self, node, scope):
         self.current_method = self.current_type.get_method(node.id)
-        self.current_function = self.register_function(self.to_function_name(self.current_method.name, self.current_type.name))
-        
+        self.current_function = self.register_function(
+            self.to_function_name(self.current_method.name, self.current_type.name))
+
         self.register_param(self.vself)
         for param_name, _ in node.params:
             self.register_param(VariableInfo(param_name, None))
-        
+
         scope._return = None
         self.visit(node.body, scope)
 
@@ -100,9 +108,8 @@ def visit(self, node, scope):
             self.register_instruction(nodes_cil.ReturnNode(0))
         else:
             self.register_instruction(nodes_cil.ReturnNode(scope._return))
-        
-        self.current_method = None
 
+        self.current_method = None
 
     @visitor.when(nodes.AssignNode)
     def visit(self, node, scope):
@@ -110,8 +117,9 @@ def visit(self, node, scope):
 
         try:
             self.current_type.get_attribute(node.id, None)
-            self.register_instruction(nodes_cil.SetAttrNode(self.vself.name, node.id, scope._return, self.current_type.name))
-        
+            self.register_instruction(nodes_cil.SetAttrNode(
+                self.vself.name, node.id, scope._return, self.current_type.name))
+
         except SemanticError:
             vname = None
             param_names = [pn.id for pn in self.current_function.params]
@@ -125,66 +133,81 @@ def visit(self, node, scope):
                     if node.id in n.split("_"):
                         vname = n
                         break
-            self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
-    
+            self.register_instruction(
+                nodes_cil.AssignNode(vname, scope._return))
 
     @visitor.when(nodes.CallNode)
     def visit(self, node, scope):
         if node.obj == None and node.type == None:
             args = []
             for arg in node.args:
-                vname = self.register_local(VariableInfo(f'{node.id}_arg', None), id=True)
+                vname = self.register_local(
+                    VariableInfo(f'{node.id}_arg', None), id=True)
                 self.visit(arg, scope)
-                self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
+                self.register_instruction(
+                    nodes_cil.AssignNode(vname, scope._return))
                 args.append(nodes_cil.ArgNode(vname))
-            result = self.register_local(VariableInfo(f'return_value_of_{node.id}', None), id=True)
+            result = self.register_local(VariableInfo(
+                f'return_value_of_{node.id}', None), id=True)
 
             self.register_instruction(nodes_cil.ArgNode(self.vself.name))
             for arg in args:
                 self.register_instruction(arg)
-            
-            type_of_node = self.register_local(VariableInfo(f'{self.vself.name}_type', None))
-            self.register_instruction(nodes_cil.TypeOfNode(self.vself.name, type_of_node))
-            self.register_instruction(nodes_cil.DynamicCallNode(type_of_node, node.id, result, self.current_type.name))
+
+            type_of_node = self.register_local(
+                VariableInfo(f'{self.vself.name}_type', None))
+            self.register_instruction(
+                nodes_cil.TypeOfNode(self.vself.name, type_of_node))
+            self.register_instruction(nodes_cil.DynamicCallNode(
+                type_of_node, node.id, result, self.current_type.name))
             scope._return = result
 
         else:
             args = []
             for arg in node.args:
-                vname = self.register_local(VariableInfo(f'{node.id}_arg', None), id=True)
+                vname = self.register_local(
+                    VariableInfo(f'{node.id}_arg', None), id=True)
                 self.visit(arg, scope)
-                self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
+                self.register_instruction(
+                    nodes_cil.AssignNode(vname, scope._return))
                 args.append(nodes_cil.ArgNode(vname))
 
-            result = self.register_local(VariableInfo(f'return_value_of_{node.id}', None), id=True)
-            
+            result = self.register_local(VariableInfo(
+                f'return_value_of_{node.id}', None), id=True)
+
             vobj = self.define_internal_local()
             self.visit(node.obj, scope)
-            self.register_instruction(nodes_cil.AssignNode(vobj, scope._return))
+            self.register_instruction(
+                nodes_cil.AssignNode(vobj, scope._return))
 
             void = nodes_cil.VoidNode()
             equal_result = self.define_internal_local()
-            self.register_instruction(nodes_cil.EqualNode(equal_result, vobj, void))
+            self.register_instruction(
+                nodes_cil.EqualNode(equal_result, vobj, void))
+
+            self.register_runtime_error(
+                equal_result, f'({node.line},{node.column}) - RuntimeError: Dispatch on void\n')
 
-            self.register_runtime_error(equal_result, f'({node.line},{node.column}) - RuntimeError: Dispatch on void\n')
-            
             self.register_instruction(nodes_cil.ArgNode(vobj))
             for arg in args:
                 self.register_instruction(arg)
 
             if node.type:
-                self.register_instruction(nodes_cil.StaticCallNode(self.to_function_name(node.id, node.type), result))
+                self.register_instruction(nodes_cil.StaticCallNode(
+                    self.to_function_name(node.id, node.type), result))
             else:
-                type_of_node = self.register_local(VariableInfo(f'{node.id}_type', None), id=True)
-                self.register_instruction(nodes_cil.TypeOfNode(vobj, type_of_node))
+                type_of_node = self.register_local(
+                    VariableInfo(f'{node.id}_type', None), id=True)
+                self.register_instruction(
+                    nodes_cil.TypeOfNode(vobj, type_of_node))
                 typex = node.obj.computed_type
                 if typex.name == 'SELF_TYPE':
                     typex = self.current_type
-                self.register_instruction(nodes_cil.DynamicCallNode(type_of_node, node.id, result, typex.name))
+                self.register_instruction(nodes_cil.DynamicCallNode(
+                    type_of_node, node.id, result, typex.name))
 
             scope._return = result
 
-
     @visitor.when(nodes.IfThenElseNode)
     def visit(self, node, scope):
         vresult = self.register_local(VariableInfo('if_then_else_value', None))
@@ -195,16 +218,19 @@ def visit(self, node, scope):
         continue_label_node = self.register_label('continue_label')
 
         self.visit(node.if_expr, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(vcondition, scope._return, 'value', 'Bool'))
-        self.register_instruction(nodes_cil.IfGotoNode(vcondition, then_label_node.label))
-        
+        self.register_instruction(nodes_cil.GetAttrNode(
+            vcondition, scope._return, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.IfGotoNode(
+            vcondition, then_label_node.label))
+
         self.register_instruction(nodes_cil.GotoNode(else_label_node.label))
-        
+
         self.register_instruction(then_label_node)
         self.visit(node.then_expr, scope)
         self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
-        self.register_instruction(nodes_cil.GotoNode(continue_label_node.label))
-        
+        self.register_instruction(
+            nodes_cil.GotoNode(continue_label_node.label))
+
         self.register_instruction(else_label_node)
         self.visit(node.else_expr, scope)
         self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
@@ -212,35 +238,34 @@ def visit(self, node, scope):
         self.register_instruction(continue_label_node)
         scope._return = vresult
 
-
     @visitor.when(nodes.WhileNode)
     def visit(self, node, scope):
         vcondition = self.define_internal_local()
         while_label_node = self.register_label('while_label')
         loop_label_node = self.register_label('loop_label')
         pool_label_node = self.register_label('pool_label')
-        
+
         self.register_instruction(while_label_node)
         self.visit(node.conditional_expr, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(vcondition, scope._return, 'value', 'Bool'))
-        self.register_instruction(nodes_cil.IfGotoNode(vcondition, loop_label_node.label))
-        
+        self.register_instruction(nodes_cil.GetAttrNode(
+            vcondition, scope._return, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.IfGotoNode(
+            vcondition, loop_label_node.label))
+
         self.register_instruction(nodes_cil.GotoNode(pool_label_node.label))
         self.register_instruction(loop_label_node)
         self.visit(node.loop_expr, scope)
-        
+
         self.register_instruction(nodes_cil.GotoNode(while_label_node.label))
         self.register_instruction(pool_label_node)
 
         scope._return = nodes_cil.VoidNode()
-    
 
     @visitor.when(nodes.BlockNode)
     def visit(self, node, scope):
         for expr in node.expr_list:
             self.visit(expr, scope)
 
-    
     @visitor.when(nodes.LetNode)
     def visit(self, node, scope):
         vresult = self.register_local(VariableInfo('let_in_value', None))
@@ -253,21 +278,22 @@ def visit(self, node, scope):
 
             if id_expr:
                 self.visit(id_expr, scope)
-                self.register_instruction(nodes_cil.AssignNode(vname, scope._return))
-            elif typex in ['String','Int','Bool']:
+                self.register_instruction(
+                    nodes_cil.AssignNode(vname, scope._return))
+            elif typex in ['String', 'Int', 'Bool']:
                 self.register_instruction(nodes_cil.AllocateNode(typex, vname))
 
         self.visit(node.in_expr, scope)
         self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
         scope._return = vresult
-            
 
     @visitor.when(nodes.CaseNode)
     def visit(self, node, scope):
-        _condition  = self.register_local(VariableInfo('equal_value', None))
-        _type  = self.register_local(VariableInfo('typeName_value', None))
-        _expr  = self.register_local(VariableInfo('case_expr_value', None))
-        vresult   = self.register_local(VariableInfo('case_value', None))
+        _expr = self.register_local(VariableInfo('case_expr_value', None))
+        _type = self.register_local(VariableInfo('typeName_value', None))
+        _condition = self.register_local(VariableInfo('equal_value', None))
+
+        vresult = self.register_local(VariableInfo('case_value', None))
 
         self.visit(node.predicate, scope)
         self.register_instruction(nodes_cil.AssignNode(_expr, scope._return))
@@ -275,21 +301,23 @@ def visit(self, node, scope):
 
         void = nodes_cil.VoidNode()
         equal_result = self.define_internal_local()
-        self.register_instruction(nodes_cil.EqualNode(equal_result, _expr, void))
+        self.register_instruction(
+            nodes_cil.EqualNode(equal_result, _expr, void))
 
-        self.register_runtime_error(equal_result,  f'({node.line},{node.column}) - RuntimeError: Case on void\n')
+        self.register_runtime_error(
+            equal_result,  f'({node.line},{node.column}) - RuntimeError: Case on void\n')
 
         end_label = self.register_label('end_label')
         labels = []
 
         order = []
         for branch in node.branches:
-            (_,typex,_) = branch
+            (_, typex, _) = branch
             count = 0
             t1 = self.context.get_type(typex)
 
             for other_branch in node.branches:
-                (_,other_typex,_) = other_branch
+                (_, other_typex, _) = other_branch
                 t2 = self.context.get_type(other_typex)
                 count += t2.conforms_to(t1)
 
@@ -297,21 +325,27 @@ def visit(self, node, scope):
         order.sort(key=lambda x: x[0])
 
         for i, (_, branch) in enumerate(order):
-            (_,typex,_) = branch
+            (_, typex, _) = branch
             labels.append(self.register_label(f'{i}_label'))
-            h = {x.name for x in self.context.types.values() if x.conforms_to(self.context.get_type(typex))} if typex != 'Object' else None
+            h = {x.name for x in self.context.types.values() if x.conforms_to(
+                self.context.get_type(typex))} if typex != 'Object' else None
             if not h:
                 self.register_instruction(nodes_cil.GotoNode(labels[-1].label))
                 break
             h.add(typex)
             for t in h:
-                vbranch_type_name = self.register_local(VariableInfo('branch_type_name', None))
-                self.register_instruction(nodes_cil.NameNode(vbranch_type_name, t))
-                self.register_instruction(nodes_cil.EqualNode(_condition, _type, vbranch_type_name))
-                self.register_instruction(nodes_cil.IfGotoNode(_condition, labels[-1].label))
-
-        (line,column) = node.branchesPos[i]
-        data_node = self.register_data(f'({line},{column}) - RuntimeError: Execution of a case statement without a matching branch\n')
+                vbranch_type_name = self.register_local(
+                    VariableInfo('branch_type_name', None))
+                self.register_instruction(
+                    nodes_cil.NameNode(vbranch_type_name, t))
+                self.register_instruction(nodes_cil.EqualNode(
+                    _condition, _type, vbranch_type_name))
+                self.register_instruction(
+                    nodes_cil.IfGotoNode(_condition, labels[-1].label))
+
+        (line, column) = node.branchesPos[i]
+        data_node = self.register_data(
+            f'({line},{column}) - RuntimeError: Execution of a case statement without a matching branch\n')
         self.register_instruction(nodes_cil.ErrorNode(data_node))
 
         for i, l in enumerate(labels):
@@ -322,13 +356,13 @@ def visit(self, node, scope):
             self.register_instruction(nodes_cil.AssignNode(vid, _expr))
 
             self.visit(expr, scope)
-            self.register_instruction(nodes_cil.AssignNode(vresult, scope._return))
+            self.register_instruction(
+                nodes_cil.AssignNode(vresult, scope._return))
             self.register_instruction(nodes_cil.GotoNode(end_label.label))
 
         scope._return = vresult
         self.register_instruction(end_label)
 
-    
     @visitor.when(nodes.NotNode)
     def visit(self, node, scope):
         vname = self.define_internal_local()
@@ -336,22 +370,23 @@ def visit(self, node, scope):
         instance = self.define_internal_local()
 
         self.visit(node.expr, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(value, scope._return, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            value, scope._return, 'value', 'Bool'))
         self.register_instruction(nodes_cil.MinusNode(vname, 1, value))
 
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Bool'), instance))
         scope._return = instance
 
-    
     @visitor.when(nodes.ConstantNumNode)
     def visit(self, node, scope):
         instance = self.define_internal_local()
         self.register_instruction(nodes_cil.ArgNode(int(node.lex)))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Int'), instance))
         scope._return = instance
 
-    
     @visitor.when(nodes.ConstantBoolNode)
     def visit(self, node, scope):
         if node.lex == 'true':
@@ -362,10 +397,10 @@ def visit(self, node, scope):
 
         instance = self.define_internal_local()
         self.register_instruction(nodes_cil.ArgNode(value))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Bool'), instance))
         scope._return = instance
 
-
     @visitor.when(nodes.ConstantStringNode)
     def visit(self, node, scope):
         try:
@@ -378,16 +413,17 @@ def visit(self, node, scope):
 
         self.register_instruction(nodes_cil.LoadNode(vmsg, data_node))
         self.register_instruction(nodes_cil.ArgNode(vmsg))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('String'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('String'), instance))
         scope._return = instance
 
-
     @visitor.when(nodes.VariableNode)
     def visit(self, node, scope):
         try:
             self.current_type.get_attribute(node.lex, None)
             attr = self.register_local(VariableInfo(node.lex, None), id=True)
-            self.register_instruction(nodes_cil.GetAttrNode(attr, self.vself.name, node.lex, self.current_type.name))
+            self.register_instruction(nodes_cil.GetAttrNode(
+                attr, self.vself.name, node.lex, self.current_type.name))
             scope._return = attr
 
         except SemanticError:
@@ -400,14 +436,14 @@ def visit(self, node, scope):
             else:
                 scope._return = self.ids[node.lex]
 
-    
     @visitor.when(nodes.InstantiateNode)
     def visit(self, node, scope):
         instance = self.define_internal_local()
-        
+
         if node.lex == 'SELF_TYPE':
             vtype = self.define_internal_local()
-            self.register_instruction(nodes_cil.TypeOfNode(self.vself.name, vtype))
+            self.register_instruction(
+                nodes_cil.TypeOfNode(self.vself.name, vtype))
             self.register_instruction(nodes_cil.AllocateNode(vtype, instance))
 
         elif node.lex == 'Int' or node.lex == 'Bool':
@@ -419,10 +455,10 @@ def visit(self, node, scope):
             self.register_instruction(nodes_cil.LoadNode(vmsg, data_node))
             self.register_instruction(nodes_cil.ArgNode(vmsg))
 
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name(node.lex), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name(node.lex), instance))
         scope._return = instance
 
-    
     @visitor.when(nodes.IsVoidNode)
     def visit(self, node, scope):
         void = nodes_cil.VoidNode()
@@ -434,10 +470,10 @@ def visit(self, node, scope):
 
         self.register_instruction(nodes_cil.EqualNode(vresult, value, void))
         self.register_instruction(nodes_cil.ArgNode(vresult))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name("Bool"), vresult))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name("Bool"), vresult))
         scope._return = vresult
 
-
     @visitor.when(nodes.ComplementNode)
     def visit(self, node, scope):
         vname = self.define_internal_local()
@@ -445,13 +481,14 @@ def visit(self, node, scope):
         instance = self.define_internal_local()
 
         self.visit(node.lex, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            value, scope._return, 'value', 'Int'))
         self.register_instruction(nodes_cil.ComplementNode(vname, value))
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Int'), instance))
         scope._return = instance
 
-
     @visitor.when(nodes.PlusNode)
     def visit(self, node, scope):
         vname = self.define_internal_local()
@@ -459,17 +496,20 @@ def visit(self, node, scope):
         right_value = self.define_internal_local()
 
         self.visit(node.left, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, scope._return, 'value', 'Int'))
         self.visit(node.right, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, scope._return, 'value', 'Int'))
 
-        self.register_instruction(nodes_cil.PlusNode(vname, left_value, right_value))
+        self.register_instruction(
+            nodes_cil.PlusNode(vname, left_value, right_value))
         instance = self.define_internal_local()
 
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Int'), instance))
         scope._return = instance
-    
 
     @visitor.when(nodes.MinusNode)
     def visit(self, node, scope):
@@ -478,18 +518,21 @@ def visit(self, node, scope):
         right_value = self.define_internal_local()
 
         self.visit(node.left, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, scope._return, 'value', 'Int'))
         self.visit(node.right, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, scope._return, 'value', 'Int'))
 
-        self.register_instruction(nodes_cil.MinusNode(vname, left_value, right_value))
+        self.register_instruction(
+            nodes_cil.MinusNode(vname, left_value, right_value))
         instance = self.define_internal_local()
 
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Int'), instance))
         scope._return = instance
 
-    
     @visitor.when(nodes.StarNode)
     def visit(self, node, scope):
         vname = self.define_internal_local()
@@ -497,18 +540,21 @@ def visit(self, node, scope):
         right_value = self.define_internal_local()
 
         self.visit(node.left, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, scope._return, 'value', 'Int'))
         self.visit(node.right, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, scope._return, 'value', 'Int'))
 
-        self.register_instruction(nodes_cil.StarNode(vname, left_value, right_value))
+        self.register_instruction(
+            nodes_cil.StarNode(vname, left_value, right_value))
         instance = self.define_internal_local()
 
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Int'), instance))
         scope._return = instance
 
-
     @visitor.when(nodes.DivNode)
     def visit(self, node, scope):
         vname = self.define_internal_local()
@@ -516,21 +562,25 @@ def visit(self, node, scope):
         right_value = self.define_internal_local()
 
         self.visit(node.left, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, scope._return, 'value', 'Int'))
         self.visit(node.right, scope)
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, scope._return, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, scope._return, 'value', 'Int'))
 
         vresult = self.define_internal_local()
         self.register_instruction(nodes_cil.EqualNode(vresult, right_value, 0))
-        self.register_runtime_error(vresult, f'({node.line},{node.column}) - RuntimeError: Division by zero\n')
+        self.register_runtime_error(
+            vresult, f'({node.line},{node.column}) - RuntimeError: Division by zero\n')
 
-        self.register_instruction(nodes_cil.DivNode(vname, left_value, right_value))
+        self.register_instruction(
+            nodes_cil.DivNode(vname, left_value, right_value))
         instance = self.define_internal_local()
 
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Int'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Int'), instance))
         scope._return = instance
-    
 
     @visitor.when(nodes.LessThanNode)
     def visit(self, node, scope):
@@ -545,15 +595,18 @@ def visit(self, node, scope):
         self.visit(node.right, scope)
         right = scope._return
 
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'Bool'))
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'Bool'))
-        self.register_instruction(nodes_cil.LessThanNode(vname, left_value, right_value))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, left, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, right, 'value', 'Bool'))
+        self.register_instruction(
+            nodes_cil.LessThanNode(vname, left_value, right_value))
 
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Bool'), instance))
         scope._return = instance
 
-    
     @visitor.when(nodes.LessEqualNode)
     def visit(self, node, scope):
         vname = self.define_internal_local()
@@ -567,14 +620,17 @@ def visit(self, node, scope):
         self.visit(node.right, scope)
         right = scope._return
 
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'Bool'))
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'Bool'))
-        self.register_instruction(nodes_cil.LessEqualNode(vname, left_value, right_value))
-        
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, left, 'value', 'Bool'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, right, 'value', 'Bool'))
+        self.register_instruction(
+            nodes_cil.LessEqualNode(vname, left_value, right_value))
+
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Bool'), instance))
         scope._return = instance
-    
 
     @visitor.when(nodes.EqualNode)
     def visit(self, node, scope):
@@ -604,24 +660,36 @@ def visit(self, node, scope):
         reference_node = self.register_label('reference_label')
         continue_node = self.register_label('continue_label')
 
-        self.register_instruction(nodes_cil.EqualNode(vresult, type_left, _int))
-        self.register_instruction(nodes_cil.IfGotoNode(vresult, int_node.label))
-        self.register_instruction(nodes_cil.EqualNode(vresult, type_left, _bool))
-        self.register_instruction(nodes_cil.IfGotoNode(vresult, int_node.label))
-        self.register_instruction(nodes_cil.EqualNode(vresult, type_left, _string))
-        self.register_instruction(nodes_cil.IfGotoNode(vresult, string_node.label))
+        self.register_instruction(
+            nodes_cil.EqualNode(vresult, type_left, _int))
+        self.register_instruction(
+            nodes_cil.IfGotoNode(vresult, int_node.label))
+        self.register_instruction(
+            nodes_cil.EqualNode(vresult, type_left, _bool))
+        self.register_instruction(
+            nodes_cil.IfGotoNode(vresult, int_node.label))
+        self.register_instruction(
+            nodes_cil.EqualNode(vresult, type_left, _string))
+        self.register_instruction(
+            nodes_cil.IfGotoNode(vresult, string_node.label))
         self.register_instruction(nodes_cil.GotoNode(reference_node.label))
 
         self.register_instruction(int_node)
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'Int'))
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'Int'))
-        self.register_instruction(nodes_cil.EqualNode(vname, left_value, right_value))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, left, 'value', 'Int'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, right, 'value', 'Int'))
+        self.register_instruction(
+            nodes_cil.EqualNode(vname, left_value, right_value))
         self.register_instruction(nodes_cil.GotoNode(continue_node.label))
 
         self.register_instruction(string_node)
-        self.register_instruction(nodes_cil.GetAttrNode(left_value, left, 'value', 'String'))
-        self.register_instruction(nodes_cil.GetAttrNode(right_value, right, 'value', 'String'))
-        self.register_instruction(nodes_cil.EqualStrNode(vname, left_value, right_value))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            left_value, left, 'value', 'String'))
+        self.register_instruction(nodes_cil.GetAttrNode(
+            right_value, right, 'value', 'String'))
+        self.register_instruction(
+            nodes_cil.EqualStrNode(vname, left_value, right_value))
         self.register_instruction(nodes_cil.GotoNode(continue_node.label))
 
         self.register_instruction(reference_node)
@@ -629,5 +697,6 @@ def visit(self, node, scope):
 
         self.register_instruction(continue_node)
         self.register_instruction(nodes_cil.ArgNode(vname))
-        self.register_instruction(nodes_cil.StaticCallNode(self.init_name('Bool'), instance))
-        scope._return = instance
\ No newline at end of file
+        self.register_instruction(nodes_cil.StaticCallNode(
+            self.init_name('Bool'), instance))
+        scope._return = instance

From 1a04129e8747d9f7a2f8f5c0c3f3872930236ee5 Mon Sep 17 00:00:00 2001
From: darian10 <dariandominguezalayon@gmail.com>
Date: Fri, 25 Feb 2022 15:40:22 -0500
Subject: [PATCH 77/83] Change abort msg like tests

---
 src/main.py                                   |    2 +-
 src/primes.mips                               | 2443 +++++++++++++++++
 .../code_generation/cil/Base_COOL_to_CIL.py   |    2 +-
 src/utils/code_generation/cil/COOL_to_CIL.py  |    2 +-
 4 files changed, 2446 insertions(+), 3 deletions(-)
 create mode 100644 src/primes.mips

diff --git a/src/main.py b/src/main.py
index 3b9bbd73b..b479553fe 100644
--- a/src/main.py
+++ b/src/main.py
@@ -16,7 +16,7 @@
 
 if __name__ == "__main__":
     add = "codegen/"
-    _file = "cells.cl"
+    _file = "primes.cl"
 
     path: str = f"{Path.cwd()}/tests/{add}" if os.path.exists(
         f"{Path.cwd()}/tests/{add}") else f"{Path.cwd()}/../tests/{add}{_file}"
diff --git a/src/primes.mips b/src/primes.mips
new file mode 100644
index 000000000..e4e48967c
--- /dev/null
+++ b/src/primes.mips
@@ -0,0 +1,2443 @@
+	.data
+default_str: .asciiz ""
+data_1: .asciiz "Object"
+data_2: .asciiz "IO"
+data_3: .asciiz "String"
+data_4: .asciiz "Int"
+data_5: .asciiz "Bool"
+data_6: .asciiz "Main"
+data_7: .asciiz "Abort called from class "
+data_8: .asciiz "
+"
+data_9: .asciiz "Substring out of range"
+data_10: .asciiz "2 is trivially prime.
+"
+data_11: .asciiz "(55,39) - RuntimeError: Division by zero
+"
+data_12: .asciiz " is prime.
+"
+data_13: .asciiz "halt"
+data_14: .asciiz "(75,11) - RuntimeError: Dispatch on void
+"
+data_15: .asciiz "continue"
+
+type_name_table:
+	.word	data_1
+	.word	data_2
+	.word	data_3
+	.word	data_4
+	.word	data_5
+	.word	data_6
+
+proto_table:
+	.word	type_1_proto
+	.word	type_2_proto
+	.word	type_3_proto
+	.word	type_4_proto
+	.word	type_5_proto
+	.word	type_6_proto
+
+type_1_dispatch:
+	.word	 L_2
+	.word	 L_3
+	.word	 L_4
+	.word	 L_1
+
+type_1_proto:
+	.word	0
+	.word	4
+	.word	type_1_dispatch
+	.word	-1
+
+type_2_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_6
+	.word	 L_7
+	.word	 L_8
+	.word	 L_9
+	.word	 L_5
+
+type_2_proto:
+	.word	1
+	.word	4
+	.word	type_2_dispatch
+	.word	-1
+
+type_3_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_11
+	.word	 L_12
+	.word	 L_13
+	.word	 L_10
+
+type_3_proto:
+	.word	2
+	.word	6
+	.word	type_3_dispatch
+	.word	default_str
+	.word	type_4_proto
+	.word	-1
+
+type_4_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_14
+
+type_4_proto:
+	.word	3
+	.word	5
+	.word	type_4_dispatch
+	.word	0
+	.word	-1
+
+type_5_dispatch:
+	.word	 L_3
+	.word	 L_2
+	.word	 L_4
+	.word	 L_15
+
+type_5_proto:
+	.word	4
+	.word	5
+	.word	type_5_dispatch
+	.word	0
+	.word	-1
+
+type_6_dispatch:
+	.word	 L_2
+	.word	 L_3
+	.word	 L_4
+	.word	 L_6
+	.word	 L_7
+	.word	 L_8
+	.word	 L_9
+	.word	 L_16
+
+type_6_proto:
+	.word	5
+	.word	9
+	.word	type_6_dispatch
+	.word	0
+	.word	0
+	.word	0
+	.word	0
+	.word	0
+	.word	-1
+	.text
+	.globl main
+main:
+	jal mem_manager_init
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	jal L_17
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_16
+	move $t0 $v0
+	addi $sp, $sp, 4
+	li $v0, 0
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	li $v0, 10
+	syscall
+L_1:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	li $t2, 0
+	sll $t2 $t2 2
+	la $t3, proto_table
+	addu $t3 $t3 $t2
+	lw $t3, 0($t3)
+	lw $a0, 4($t3)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t3
+	move $a1 $v0
+	jal copy
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_2:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($fp)
+	la $t1, data_7 + 0
+	li $v0, 4
+	move $a0 $t1
+	syscall
+	lw $a0, 0($t0)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t1 $a0
+	li $v0, 4
+	move $a0 $t1
+	syscall
+	la $t1, data_8 + 0
+	li $v0, 4
+	move $a0 $t1
+	syscall
+	li $v0, 10
+	syscall
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_3:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	lw $t0, 0($fp)
+	lw $a0, 0($t0)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t0 $a0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_4:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $a0, 4($t0)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t0
+	move $a1 $v0
+	jal copy
+	move $t0 $v0
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_5:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t9, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t9, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	li $t9, 1
+	sll $t9 $t9 2
+	la $t5, proto_table
+	addu $t5 $t5 $t9
+	lw $t5, 0($t5)
+	lw $a0, 4($t5)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t5
+	move $a1 $v0
+	jal copy
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t9, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t9, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_6:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t1, 0($fp)
+	lw $t0, 4($fp)
+	lw $a1, 12($t1)
+	move $t1 $a1
+	li $v0, 4
+	move $a0 $t1
+	syscall
+	move $v0 $t0
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_7:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t1, 0($fp)
+	lw $t0, 4($fp)
+	lw $a1, 12($t1)
+	move $t1 $a1
+	li $v0, 1
+	move $a0 $t1
+	syscall
+	move $v0 $t0
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_8:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($fp)
+	jal get_string
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_9:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($fp)
+	li $v0, 5
+	syscall
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_10:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -12
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t1, 0($fp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	li $t5, 2
+	sll $t5 $t5 2
+	la $t3, proto_table
+	addu $t3 $t3 $t5
+	lw $t3, 0($t3)
+	lw $a0, 4($t3)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t3
+	move $a1 $v0
+	jal copy
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	sw $t1, 12($t0)
+	move $a0 $t1
+	jal len
+	move $t1 $v0
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	jal L_14
+	move $t1 $v0
+	addi $sp, $sp, 4
+	sw $t1, 16($t0)
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 12
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_11:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	lw $a1, 16($t0)
+	move $t0 $a1
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_12:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -24
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	lw $t4, 0($fp)
+	lw $t0, 4($fp)
+	lw $a1, 12($t0)
+	move $t1 $a1
+	lw $a1, 12($t4)
+	move $t3 $a1
+	lw $a1, 16($t0)
+	move $t2 $a1
+	lw $a1, 16($t4)
+	move $t0 $a1
+	lw $a1, 12($t2)
+	move $t2 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t2 $t2 $t0
+	move $a0 $t1
+	move $a1 $t3
+	move $a2 $t2
+	jal concat
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 24
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_13:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -32
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t3, 0($fp)
+	lw $t2, 4($fp)
+	lw $t1, 8($fp)
+	lw $a1, 12($t1)
+	move $t0 $a1
+	lw $a1, 12($t2)
+	move $t4 $a1
+	lw $a1, 12($t3)
+	move $t2 $a1
+	lw $a1, 16($t1)
+	move $t1 $a1
+	add $t3 $t2 $t4
+	move $a0 $t1
+	move $a1 $t3
+	jal less
+	move $t1 $v0
+	bne $t1 $zero L_19
+	j L_20
+	L_19:
+	li $v0, 4
+	la $a0, data_9
+	syscall
+	li $v0, 10
+	syscall
+	L_20:
+	move $a0 $t0
+	move $a1 $t4
+	move $a2 $t2
+	jal sub_string
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 32
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_14:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	li $t6, 3
+	sll $t6 $t6 2
+	la $t3, proto_table
+	addu $t3 $t3 $t6
+	lw $t3, 0($t3)
+	lw $a0, 4($t3)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t3
+	move $a1 $v0
+	jal copy
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	move $t1 $v0
+	sw $t0, 12($t1)
+	move $v0 $t1
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_15:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	lw $t0, 0($fp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	li $t3, 4
+	sll $t3 $t3 2
+	la $t2, proto_table
+	addu $t2 $t2 $t3
+	lw $t2, 0($t2)
+	lw $a0, 4($t2)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t2
+	move $a1 $v0
+	jal copy
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	move $t1 $v0
+	sw $t0, 12($t1)
+	move $v0 $t1
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_16:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -4
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	lw $t0, 0($fp)
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t0
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 4
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_17:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -8
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	li $t1, 5
+	sll $t1 $t1 2
+	la $t0, proto_table
+	addu $t0 $t0 $t1
+	lw $t0, 0($t0)
+	lw $a0, 4($t0)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t0
+	move $a1 $v0
+	jal copy
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	move $t1 $v0
+	addi $sp, $sp, -4
+	sw $t1, 0($sp)
+	jal L_18
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $v0 $t1
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t1, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 8
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+L_18:
+	addi $sp, $sp, -4
+	sw $fp, 0($sp)
+	addi $fp, $sp, 4
+	addi $sp, $sp, -440
+	addi $sp, $sp, -4
+	sw $a2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t5, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	addi $sp, $sp, -4
+	sw $ra, 0($sp)
+	addi $sp, $sp, -4
+	sw $t4, 0($sp)
+	addi $sp, $sp, -4
+	sw $a1, 0($sp)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	addi $sp, $sp, -4
+	sw $t7, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	lw $t2, 0($fp)
+	la $t0, data_10 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t2)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 12
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	li $a0, 2
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	sw $t0, 12($t2)
+	lw $a1, 12($t2)
+	move $t0 $a1
+	sw $t0, 16($t2)
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	addi $sp, $sp, -4
+	sw $t6, 0($sp)
+	li $t3, 3
+	sll $t3 $t3 2
+	la $t6, proto_table
+	addu $t6 $t6 $t3
+	lw $t6, 0($t6)
+	lw $a0, 4($t6)
+	sll $a0 $a0 2
+	jal malloc
+	move $a2 $a0
+	move $a0 $t6
+	move $a1 $v0
+	jal copy
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	move $t0 $v0
+	sw $t0, 20($t2)
+	li $a0, 500
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	sw $t0, 24($t2)
+	L_21:
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_22
+	j L_46
+	L_22:
+	lw $a1, 16($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t3 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t0 $t3 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	sw $t0, 16($t2)
+	li $a0, 2
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	sw $t0, 20($t2)
+	L_23:
+	lw $a1, 16($t2)
+	move $t4 $a1
+	lw $a1, 20($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	lw $a1, 20($t2)
+	move $t3 $a1
+	lw $a1, 12($t3)
+	move $t3 $a1
+	mul $t0 $t0 $t3
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t4)
+	move $t3 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	move $a0 $t3
+	move $a1 $t0
+	jal less
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_24
+	j L_25
+	L_24:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_35
+	L_25:
+	lw $a1, 16($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t3 $a1
+	lw $a1, 20($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t4 $a1
+	lw $a1, 16($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t6 $a1
+	lw $a1, 20($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	move $a0 $t0
+	li $a1, 0
+	jal eqs
+	move $t5 $v0
+	bne $t5 $zero L_26
+	j L_27
+	L_26:
+	li $v0, 4
+	la $a0, data_11
+	syscall
+	li $v0, 10
+	syscall
+	L_27:
+	div $t6 $t0
+	mflo $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	mul $t0 $t4 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	sub $t0 $t3 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t3 $v0
+	addi $sp, $sp, 4
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t6 $v0
+	addi $sp, $sp, 4
+	lw $a0, 0($t3)
+	sll $a0 $a0 2
+	la $a1, type_name_table
+	addu $a0 $a0 $a1
+	lw $a0, 0($a0)
+	move $t7 $a0
+	la $t0, type_name_table
+	addiu $t0 $t0 12
+	lw $t0, 0($t0)
+	la $t5, type_name_table
+	addiu $t5 $t5 16
+	lw $t5, 0($t5)
+	la $t4, type_name_table
+	addiu $t4 $t4 8
+	lw $t4, 0($t4)
+	move $a0 $t7
+	move $a1 $t0
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_28
+	move $a0 $t7
+	move $a1 $t5
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_28
+	move $a0 $t7
+	move $a1 $t4
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_29
+	j L_30
+	L_28:
+	lw $a1, 12($t3)
+	move $t0 $a1
+	lw $a1, 12($t6)
+	move $t3 $a1
+	move $a0 $t0
+	move $a1 $t3
+	jal eqs
+	move $t0 $v0
+	j L_31
+	L_29:
+	lw $a1, 12($t3)
+	move $t0 $a1
+	lw $a1, 12($t6)
+	move $t3 $a1
+	move $a0 $t0
+	move $a1 $t3
+	jal eq_string
+	move $t0 $v0
+	j L_31
+	L_30:
+	move $a0 $t3
+	move $a1 $t6
+	jal eqs
+	move $t0 $v0
+	L_31:
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_32
+	j L_33
+	L_32:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_34
+	L_33:
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_34:
+	move $t0 $t0
+	L_35:
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_36
+	j L_37
+	L_36:
+	lw $a1, 20($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t3 $a1
+	li $a0, 1
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	add $t0 $t3 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	sw $t0, 20($t2)
+	j L_23
+	L_37:
+	lw $a1, 16($t2)
+	move $t4 $a1
+	lw $a1, 20($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t3 $a1
+	lw $a1, 20($t2)
+	move $t0 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	mul $t0 $t3 $t0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_14
+	move $t3 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t4)
+	move $t0 $a1
+	lw $a1, 12($t3)
+	move $t3 $a1
+	move $a0 $t0
+	move $a1 $t3
+	jal less
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_38
+	j L_39
+	L_38:
+	lw $a1, 16($t2)
+	move $t0 $a1
+	sw $t0, 12($t2)
+	lw $a1, 12($t2)
+	move $t0 $a1
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t2)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 16
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	la $t0, data_12 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	addi $sp, $sp, -4
+	sw $t2, 0($sp)
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	lw $t0, 0($t2)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 12
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 8
+	move $t0 $t0
+	j L_40
+	L_39:
+	li $a0, 0
+	addi $sp, $sp, -4
+	sw $a0, 0($sp)
+	jal L_14
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_40:
+	lw $a1, 24($t2)
+	move $t3 $a1
+	lw $a1, 16($t2)
+	move $t0 $a1
+	lw $a1, 12($t3)
+	move $t3 $a1
+	lw $a1, 12($t0)
+	move $t0 $a1
+	move $a0 $t3
+	move $a1 $t0
+	jal less_eq
+	move $t0 $v0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_15
+	move $t0 $v0
+	addi $sp, $sp, 4
+	lw $a1, 12($t0)
+	move $t0 $a1
+	bne $t0 $zero L_41
+	j L_44
+	L_41:
+	la $t0, data_13 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t3 $t0
+	move $a0 $t3
+	li $a1, 0
+	jal eqs
+	move $t0 $v0
+	bne $t0 $zero L_42
+	j L_43
+	L_42:
+	li $v0, 4
+	la $a0, data_14
+	syscall
+	li $v0, 10
+	syscall
+	L_43:
+	addi $sp, $sp, -4
+	sw $t3, 0($sp)
+	lw $t0, 0($t3)
+	la $a1, proto_table
+	sll $a2 $t0 2
+	addu $a1 $a1 $a2
+	lw $a1, 0($a1)
+	lw $a1, 8($a1)
+	addiu $a1 $a1 4
+	lw $a1, 0($a1)
+	jal $a1
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	j L_45
+	L_44:
+	la $t0, data_15 + 0
+	addi $sp, $sp, -4
+	sw $t0, 0($sp)
+	jal L_10
+	move $t0 $v0
+	addi $sp, $sp, 4
+	move $t0 $t0
+	L_45:
+	j L_21
+	L_46:
+	sw $t1, 28($t2)
+	lw $t6, 0($sp)
+	addi $sp, $sp, 4
+	lw $t7, 0($sp)
+	addi $sp, $sp, 4
+	lw $a0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t2, 0($sp)
+	addi $sp, $sp, 4
+	lw $t3, 0($sp)
+	addi $sp, $sp, 4
+	lw $a1, 0($sp)
+	addi $sp, $sp, 4
+	lw $t4, 0($sp)
+	addi $sp, $sp, 4
+	lw $ra, 0($sp)
+	addi $sp, $sp, 4
+	lw $t0, 0($sp)
+	addi $sp, $sp, 4
+	lw $t5, 0($sp)
+	addi $sp, $sp, 4
+	lw $a2, 0($sp)
+	addi $sp, $sp, 4
+	addi $sp, $sp, 440
+	lw $fp, 0($sp)
+	addi $sp, $sp, 4
+	jr $ra
+
+
+    
+    alloc_size       = 2048
+    free_list = 0
+    header_size = 12
+    header_size_slot = 0
+    header_next_slot = 4
+    header_reachable_slot = 8
+    init_alloc_size = 28
+    int_type = 0
+    meta_data_obj_size = 4
+    neg_header_size = -12
+    new_line = 10
+    obj_mark = -1
+    obj_extended = -2
+    reachable = 1
+    state_size = 4
+    stack_base = -4
+    string_size_treshold = 1024
+    string_type = 0
+    total_alloc_size =  2060
+    num_type = 0
+    used_list = header_size
+
+verify_obj:
+                addiu $sp $sp -20
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+
+                move $t0 $a0
+
+                li $v0 9
+                move $a0 $zero
+                syscall
+
+                addiu $t1 $v0 -4    
+
+                
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)
+                blt $t2 $zero verify_obj_not_obj
+                la $t3 num_type
+                lw $t3 0($t3)
+                bge $t2 $t3 verify_obj_not_obj
+
+                addiu $t0 $t0 4
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)   
+
+                addiu $t0 $t0 8
+                
+
+                li $t3 meta_data_obj_size
+                sub $t2 $t2 $t3 
+                sll $t2 $t2 2
+                addu $t0 $t0 $t2
+                
+                
+                blt $t0 $gp verify_obj_not_obj
+                bgt $t0 $t1 verify_obj_not_obj
+                lw $t2 0($t0)
+                beq $t2 obj_mark verify_obj_is_obj
+                beq $t2 obj_extended verify_obj_is_obj
+
+verify_obj_not_obj:
+                li $v0 0
+                j verify_obj_finish
+
+verify_obj_is_obj:
+                li $v0 1
+
+verify_obj_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                addiu $sp $sp 20
+
+                jr $ra
+
+concat:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $a0 12($sp)
+                sw $a1 16($sp)
+                sw $ra 20($sp)
+
+                move $t0 $a0
+                move $t1 $a1
+
+
+                addiu $a0 $a2 1
+                li $t2 4
+                div $a0 $t2
+                mfhi $a0
+                bne $a0 $zero concat_allign_size
+                addiu $a0 $a2 1
+
+concat_size_alligned:
+                jal malloc
+                move $t2 $v0
+                j concat_copy_first_cycle
+
+concat_allign_size:
+                sub $t2 $t2 $a0
+                add $a0 $a2 $t2
+                addiu $a0 $a0 1
+                j concat_size_alligned
+
+concat_copy_first_cycle:
+                lb $a0 0($t0)
+                beq $a0 $zero concat_copy_second_cycle
+                sb $a0 0($t2)
+                addiu $t0 $t0 1
+                addiu $t2 $t2 1
+                j concat_copy_first_cycle
+
+concat_copy_second_cycle:
+                lb $a0 0($t1)
+                beq $a0 $zero concat_finish
+                sb $a0 0($t2)
+                addiu $t1 $t1 1
+                addiu $t2 $t2 1
+                j concat_copy_second_cycle
+
+concat_finish:
+                sb $zero 0($t2)
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $a0 12($sp)
+                lw $a1 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra
+
+copy:
+                addiu $sp $sp -16
+                sw $a0 0($sp)
+                sw $a1 4($sp)
+                sw $a2 8($sp)
+                sw $t0 12($sp)
+
+copy_cycle:
+                beq $a2 $zero copy_finish
+                lw $t0 0($a0)
+                sw $t0 0($a1)
+                addiu $a0 $a0 4
+                addiu $a1 $a1 4
+                addi $a2 $a2 -4
+                j copy_cycle
+
+copy_finish:
+                lw $a0 0($sp)
+                lw $a1 4($sp)
+                lw $a2 8($sp)
+                lw $t0 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+eqs:
+                beq $a0 $a1 eqs_eq
+                li $v0 0
+                j eqs_finish
+
+eqs_eq:
+                li $v0 1
+
+eqs_finish:
+                jr $ra
+
+eq_string:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+
+                move $t0 $a0
+                move $t1 $a1
+
+eq_string_cycle:
+                lb $t2 0($t0)
+                lb $t3 0($t1)
+                bne $t2 $t3 eq_string_not_eq
+                beq $t2 $zero eq_string_eq
+
+                addiu $t0 $t0 1
+                addiu $t1 $t1 1
+                j eq_string_cycle
+
+eq_string_not_eq:
+                move $v0 $zero
+                j eq_string_finish
+
+eq_string_eq:
+                li $v0 1
+
+eq_string_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+extend_block:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+
+                
+                addiu $t0 $gp free_list     
+
+                beq $t0 $a0 extend_block_finish  
+                move $t0 $a0
+
+                lw $t1 header_next_slot($t0)
+                lw $t2 header_size_slot($t0)
+                move $t3 $t2
+                addiu $t2 $t2 header_size
+                addu $t2 $t2 $t0
+                beq $t2 $t1 extend_block_extend
+                j extend_block_finish
+
+extend_block_extend:
+                lw $t2 header_size_slot($t1)
+                addi $t2 $t2 header_size
+                add $t2 $t2 $t3
+                sw $t2 header_size_slot($t0)
+                lw $t1 header_next_slot($t1)
+                sw $t1 header_next_slot($t0)
+
+extend_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+extend_heap:
+                addiu $sp $sp -12
+                sw $a0 0($sp)
+                sw $a1 4($sp)
+                sw $t0 8($sp)
+
+                
+                li $v0 9
+                addiu $a0 $a1 header_size
+                syscall
+                
+                
+                move $t0 $a1 
+                sw $t0 header_size_slot($v0)
+                sw $zero header_next_slot($v0)
+                sw $zero header_reachable_slot($v0)
+
+               
+                lw $t0, 0($sp)
+                sw $v0 header_next_slot($t0)
+
+                move $a0 $t0
+                lw $a1 4($sp)
+                lw $t0 8($sp)
+                addiu $sp $sp 12
+
+                jr $ra
+
+free_block:
+                addiu $sp $sp -28
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $a0 12($sp)
+                sw $ra 16($sp)
+                sw $t3 20($sp)
+                sw $t4 24($sp)
+
+                move $t0 $a0
+
+                addiu $t1 $gp free_list
+
+                addiu $t3 $gp used_list
+
+free_block_cycle_used_list:
+                lw $t4 header_next_slot($t3)
+                beq $t4 $t0 free_block_cycle_free_list
+                move $t3 $t4
+                j free_block_cycle_used_list
+
+free_block_cycle_free_list:
+                lw $t2 header_next_slot($t1)
+                beq $t2 $zero free_block_founded_prev
+                bge $t2 $t0 free_block_founded_prev
+                move $t1 $t2
+                j free_block_cycle_free_list
+
+free_block_founded_prev:  
+                lw $t4 header_next_slot($t0)
+                sw $t4 header_next_slot($t3)
+                
+                
+                sw $t2 header_next_slot($t0)
+                sw $t0 header_next_slot($t1)
+
+free_block_finish:
+    
+                move $a0 $t0
+                jal extend_block
+                move $a0 $t1
+                jal extend_block
+
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $a0 12($sp)
+                lw $ra 16($sp)
+                lw $t3 20($sp)
+                lw $t4 24($sp)
+                addiu $sp $sp 28
+
+                jr $ra
+
+get_gc:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+                sw $ra 20($sp)
+
+                li $t3 reachable    
+                addiu $t0 $sp 20    
+                lw $t1 stack_base($gp)  
+
+                li $t2 1
+
+get_gc_cycle:
+
+                addiu $t0 $t0 4
+                beq $t0 $t1 get_gc_dfs      
+                
+                lw $a0 0($t0)
+                jal verify_obj
+                
+                bne $v0 $t2 get_gc_cycle
+
+                addiu $a0 $a0 neg_header_size
+                sw $t3 header_reachable_slot($a0)
+                
+                j get_gc_cycle
+
+get_gc_dfs:
+                addiu $t1 $gp used_list
+
+get_gc_outer_cycle:
+                lw $t1 header_next_slot($t1)
+                beq $t1 $zero get_gc_free
+                lw $t2 header_reachable_slot($t1)
+                beq $t2 reachable get_gc_extend
+                j get_gc_outer_cycle
+
+get_gc_extend:
+                addiu $a0 $t1 header_size    
+                jal get_gc_rec_extend
+                j get_gc_outer_cycle
+
+get_gc_free:
+                addiu $t0 $gp used_list
+                lw $t0 header_next_slot($t0)
+
+get_gc_free_cycle:
+                beq $t0 $zero get_gc_finish
+                lw $t1 header_reachable_slot($t0)
+                bne $t1 reachable get_gc_free_cycle_free
+                sw $zero header_reachable_slot($t0)
+                move $a0 $t0
+                jal verify_obj
+                beq $v0 $zero get_gc_free_cycle
+                li $t1 obj_mark
+                addiu $t2 $t0 header_size
+                lw $t3 4($t2)
+                sll $t3 $t3 2
+                addu $t2 $t2 $t3
+                sw $t1 -4($t2)
+                lw $t0 header_next_slot($t0)
+                j get_gc_free_cycle
+
+get_gc_free_cycle_free:
+                move $a0 $t0
+                lw $t0 header_next_slot($t0)
+                jal free_block
+                j get_gc_free_cycle
+
+get_gc_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra
+
+get_gc_rec_extend:
+                addiu $sp $sp -16
+                sw $a0 0($sp)
+                sw $t0 4($sp)
+                sw $t1 8($sp)
+                sw $ra 12($sp)
+                
+                jal verify_obj 
+                beq $v0 $zero get_gc_rec_extend_finish
+
+                lw $t0 4($a0)
+                sll $t0 $t0 2
+                addiu $t0 $t0 -4
+                addu $t0 $a0 $t0
+                lw $t1 0($t0)   
+                beq $t1 obj_extended get_gc_rec_extend_finish
+                
+                
+                li $t1 reachable
+                addiu $a0 $a0 neg_header_size
+                sw $t1 header_reachable_slot($a0)
+                addiu $a0 $a0 header_size 
+
+                
+                li $t1 obj_extended
+                sw $t1 0($t0)
+
+                lw $t0 0($a0)   
+                
+                
+                la $t1 int_type
+                lw $t1 0($t1)
+                beq $t0 $t1 get_gc_rec_extend_finish
+
+                la $t1 string_type
+                lw $t1 0($t1)
+                beq $t0 $t1 get_gc_rec_extend_string_obj
+
+                lw $t0 4($a0)
+                li $t1 meta_data_obj_size
+                sub $t0 $t0 $t1
+                
+                addiu $t1 $a0 12
+
+get_gc_rec_extend_attr_cycle:
+                beq $t0 $zero get_gc_rec_extend_finish
+                lw $a0 0($t1)
+                jal get_gc_rec_extend
+                addiu $t1 $t1 4
+                sub $t0 $t0 1
+                j get_gc_rec_extend_attr_cycle
+
+get_gc_rec_extend_string_obj:
+                lw $t0 8($a0)
+                addiu $t0 $t0 neg_header_size
+                li $t1 reachable
+                sw $t1 header_reachable_slot($t0)
+
+get_gc_rec_extend_finish:
+                lw $a0 0($sp)
+                lw $t0 4($sp)
+                lw $t1 8($sp)
+                lw $ra 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+less_eq:
+                ble $a0 $a1 less_eq_true
+                li $v0 0
+                j less_eq_finish
+
+less_eq_true:
+                li $v0 1
+
+less_eq_finish:
+                jr $ra
+
+less:
+                blt $a0 $a1 less_true
+                li $v0 0
+                j less_finish
+
+less_true:
+                li $v0 1
+
+less_finish:
+                jr $ra
+
+len:
+                addiu $sp $sp -8
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+
+                move $t0 $a0
+                move $v0 $zero
+
+len_cycle:
+                lb $t1 0($t0)
+                beq $t1 $zero len_finish
+                addi $v0 $v0 1
+                addiu $t0 $t0 1
+                j len_cycle
+
+len_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                addiu $sp $sp 8
+
+                jr $ra
+
+malloc:
+                move $v0 $zero
+                addiu $sp $sp -28
+                sw $t1 0($sp)
+                sw $t0 4($sp)
+                sw $a0 8($sp)
+                sw $a1 12($sp)
+                sw $ra 16($sp)
+                sw $t2 20($sp)
+                sw $t3 24($sp)
+                
+                addiu $t0 $gp free_list
+                j malloc_cycle
+
+malloc_finish:
+                move $a0 $v0
+                lw $a1 8($sp)                  
+                jal divide_block
+
+                lw $t1 header_next_slot($v0)
+                sw $t1 header_next_slot($t3)
+
+                addiu $t1 $gp used_list
+                lw $a0 header_next_slot($t1)
+
+                sw $a0 header_next_slot($v0)
+                sw $v0 header_next_slot($t1)
+                
+                addiu $v0 $v0 header_size
+
+                lw $t3 24($sp)
+                lw $t2 20($sp)
+                lw $ra 16($sp)
+                lw $a1 12($sp)
+                lw $a0 8($sp)
+                lw $t0 4($sp)
+                lw $t1 0($sp)
+                addiu $sp $sp 28
+
+                jr $ra
+
+malloc_cycle:
+                move $t2 $t0                        
+                lw $t0 header_next_slot($t0)        
+                beq $t0 $zero malloc_search_finish     
+                j malloc_verify_valid_block
+
+malloc_search_finish:
+                beq $v0 $zero malloc_alloc_new_block 
+                j malloc_finish
+
+malloc_alloc_new_block:
+                li $t1 alloc_size               
+                move $t3 $t2
+                move $a1 $a0                    
+                move $a0 $t2                    
+                bge $a1 $t1 malloc_big_block    
+                li $a1 alloc_size        
+                jal extend_heap
+                
+                j malloc_finish
+
+malloc_big_block:
+                jal extend_heap
+                j malloc_finish
+
+malloc_verify_valid_block:
+                lw $t1 header_size_slot($t0)             
+                bge $t1 $a0 malloc_valid_block    
+                j malloc_cycle
+
+malloc_valid_block:
+                beq $v0 $zero malloc_first_valid_block    
+                bge $t1 $v1 malloc_cycle                    
+                move $v0 $t0                        
+                move $v1 $t1  
+                move $t3 $t2
+                j malloc_cycle
+
+malloc_first_valid_block:
+                move $v0 $t0                        
+                move $v1 $t1                        
+                move $t3 $t2 
+                j malloc_cycle
+
+mem_manager_init:
+                addiu $sp $sp -16
+                sw $v0 0($sp)
+                sw $a0 4($sp)
+                sw $a1 8($sp)
+                sw $ra 12($sp)
+                li $v0 9
+                li $a0 init_alloc_size
+                syscall
+                move $gp $v0
+                addiu $gp $gp state_size
+
+                sw $zero header_size_slot($gp)
+                sw $zero header_reachable_slot($gp)
+
+                move $a0 $gp
+                li $a1 alloc_size
+                jal extend_heap
+
+                addiu $a0 $a0 header_size
+                sw $zero header_size_slot($a0)
+                sw $zero header_next_slot($a0)
+                sw $zero header_reachable_slot($a0)
+
+
+
+                lw $v0 0($sp)
+                lw $a0 4($sp)
+                lw $a1 8($sp)
+                lw $ra 12($sp)
+                addiu $sp $sp 16
+
+                sw $sp stack_base($gp)
+
+                jr $ra
+
+get_string:
+                addiu $sp $sp -36
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $t4 16($sp)
+                sw $t5 20($sp)
+                sw $a0 24($sp)
+                sw $a1 28($sp)
+                sw $ra 32($sp)
+                
+                addiu $t0 $gp free_list
+                move $t1 $zero
+                move $t2 $t0
+
+get_string_larger_block_cycle:
+                lw $t0 header_next_slot($t0)
+                beq $t0 $zero get_string_reading
+                lw $t3 header_size_slot($t0)
+                bge $t1 $t3 get_string_larger_block_cycle
+                move $t1 $t3
+                move $t2 $t0
+                j get_string_larger_block_cycle
+
+get_string_reading:
+                beq $t1 $zero get_string_new_block
+                move $a1 $t1
+                li $v0 8
+                addiu $a0 $t2 header_size
+                syscall
+                move $t0 $a0
+                move $t1 $zero
+
+get_string_look_nl:
+                lb $t2 0($t0)
+                beq $t2 new_line get_string_nl_founded
+                beq $t2 $zero get_string_zero_founded
+                addi $t1 $t1 1
+                addi $t0 $t0 1
+                j get_string_look_nl
+
+get_string_zero_founded:
+                blt $t1 $t3 get_string_nl_founded
+                j get_string_no_nl
+
+get_string_nl_founded:
+                sb $zero 0($t0)
+                addi $t1 $t1 1
+                li $t2 4
+                div $t1 $t2
+                mfhi $t3
+                beq $t3 $zero get_string_nl_founded_alligned
+                sub $t2 $t2 $t3
+                add $t1 $t1 $t2
+
+get_string_nl_founded_alligned:
+                move $a1 $t1
+                addiu $a0 $a0 neg_header_size
+                jal divide_block
+                jal use_block
+
+                addiu $v0 $a0 header_size
+                j get_string_finish
+
+get_string_no_nl:
+                addi $t1 $t1 1
+                blt $t1 string_size_treshold get_string_dup
+                addi $t1 $t1 alloc_size
+                j get_string_extend_heap
+
+get_string_dup:
+	            sll $t1 $t1 1
+
+get_string_extend_heap:
+                move $a1 $t1
+                move $t0 $a0
+                addiu $a0 $gp free_list
+
+get_string_last_block_cycle:
+                lw $t1 header_next_slot($a0)
+                beq $t1 $zero get_string_last_block_founded
+                lw $a0 header_next_slot($a0)
+                j get_string_last_block_cycle
+
+get_string_last_block_founded:
+                jal extend_heap
+                jal extend_block
+                lw $t1 header_next_slot($a0)
+                bne $t1 $zero get_string_copy_prev
+                move $t1 $a0
+
+get_string_copy_prev:
+                lw $t3 header_size_slot($t1)
+                move $t2 $zero
+                move $t5 $t1
+                addiu $t1 $t1 header_size
+
+get_string_copy_cycle:
+                lb $t4 0($t0)
+                beq $t4 $zero get_string_copy_finish
+                sb $t4 0($t1)
+                addi $t2 $t2 1
+                addi $t0 $t0 1
+                addi $t1 $t1 1
+                j get_string_copy_cycle
+
+get_string_copy_finish:
+                sub $t3 $t3 $t2
+                move $a0 $t1
+                move $a1 $t3
+                li $v0 8
+                syscall
+                move $t0 $a0
+                move $t1 $t2
+                addiu $a0 $t5 header_size
+                j get_string_look_nl
+
+get_string_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $t4 16($sp)
+                lw $t5 20($sp)
+                lw $a0 24($sp)
+                lw $a1 28($sp)
+                lw $ra 32($sp)
+                addiu $sp $sp 36
+
+                jr $ra
+
+get_string_new_block:
+    addiu $t0 $gp free_list
+
+get_string_new_block_search_last:
+                lw $t1 header_next_slot($t0)
+                beq $t1 $zero get_string_new_block_create
+                move $t0 $t1
+                j get_string_new_block_search_last
+
+get_string_new_block_create:
+                move $a0 $t0
+                li $a1 alloc_size
+                jal extend_heap
+                jal extend_block
+                lw $t2 header_next_slot($a0)
+                beq $t2 $zero get_string_new_block_extended
+                lw $t1 header_size_slot($t2)
+                j get_string_reading
+
+get_string_new_block_extended:
+                move $t2 $a0
+                lw $t1 header_size_slot($a0)
+                j get_string_reading
+
+divide_block:
+                addiu $sp $sp -16
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $a0 8($sp)
+                sw $a1 12($sp)
+
+                
+                lw $t0 header_size_slot($a0)
+                bgt $a1 $t0 divide_block_error_small
+                
+    
+                sub $t0 $t0 $a1
+                li $t1 header_size
+                ble $t0 $t1 divide_block_same_size
+
+               
+                addu $t0 $a0 $a1
+                addiu $t0 $t0 header_size     
+
+                
+                lw $t1 header_next_slot($a0)    
+                sw $t1 header_next_slot($t0)
+                sw $t0 header_next_slot($a0)
+
+                lw $t1 header_size_slot($a0)    
+                sub $t1 $t1 $a1
+
+                addi $t1 $t1 neg_header_size
+                sw $t1 header_size_slot($t0)
+                sw $a1 header_size_slot($a0)
+                move $v0 $a0
+                j divide_block_finish
+
+divide_block_same_size:
+                move $v0 $a0
+                j divide_block_finish
+
+divide_block_error_small:
+                j divide_block_finish
+
+divide_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $a0 8($sp)
+                lw $a1 12($sp)
+                addiu $sp $sp 16
+
+                jr $ra
+
+sub_string:
+                addiu $sp $sp -24
+                sw $t0 0($sp)
+                sw $t1 4($sp)
+                sw $t2 8($sp)
+                sw $t3 12($sp)
+                sw $a0 16($sp)
+                sw $ra 20($sp)
+
+                move $t0 $a0
+                li $t1 4
+                addiu $t3 $a2 1
+                div $t3 $t1
+            
+                mfhi $t2
+                bne $t2 $zero sub_string_allign_size
+                move $t1 $t3
+                j sub_string_new_block
+
+sub_string_allign_size:
+                sub $t1 $t1 $t2
+                add $t1 $t1 $t3
+
+sub_string_new_block:
+                move $a0 $t1
+                jal malloc
+                move $t3 $v0
+                move $t1 $zero
+                addu $t0 $t0 $a1
+
+sub_string_copy_cycle:
+                beq $t1 $a2 sub_string_finish
+                lb $t2 0($t0)
+                sb $t2 0($t3)
+                addiu $t0 $t0 1
+                addiu $t3 $t3 1
+                addiu $t1 $t1 1
+                j sub_string_copy_cycle
+
+sub_string_finish:
+                sb $zero 0($t3)
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                lw $t3 12($sp)
+                lw $a0 16($sp)
+                lw $ra 20($sp)
+                addiu $sp $sp 24
+
+                jr $ra
+
+use_block:
+    addiu $sp $sp -12
+    sw $t0 0($sp)
+    sw $t1 4($sp)
+    sw $t2 8($sp)
+
+    addiu $t0 $gp free_list
+
+use_block_cycle:
+                move $t1 $t0
+                lw $t0 header_next_slot($t0)
+                beq $t0 $zero use_block_finish
+                beq $t0 $a0 use_block_founded
+                j use_block_cycle
+
+use_block_founded:
+                lw $t2 header_next_slot($t0)
+                sw $t2 header_next_slot($t1)
+
+                addiu $t1 $gp used_list
+                lw $t2 header_next_slot($t1)
+                sw $t0 header_next_slot($t1)
+                sw $t2 header_next_slot($t0)
+
+use_block_finish:
+                lw $t0 0($sp)
+                lw $t1 4($sp)
+                lw $t2 8($sp)
+                addiu $sp $sp 12
+
+                jr $ra
+
diff --git a/src/utils/code_generation/cil/Base_COOL_to_CIL.py b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
index 5b96ca925..164c42ca6 100644
--- a/src/utils/code_generation/cil/Base_COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/Base_COOL_to_CIL.py
@@ -122,7 +122,7 @@ def __register_Object(self):
         self.register_param(self.vself)
         vname = self.define_internal_local()
         data_node = [dn for dn in self.dotdata if dn.value ==
-                     'Aborting... in class '][0]
+                     'Abort called from class '][0]
         self.register_instruction(nodes.LoadNode(vname, data_node))
         self.register_instruction(nodes.PrintStrNode(vname))
         self.register_instruction(nodes.TypeNameNode(vname, self.vself.name))
diff --git a/src/utils/code_generation/cil/COOL_to_CIL.py b/src/utils/code_generation/cil/COOL_to_CIL.py
index 220bd2ba5..c62a7630f 100644
--- a/src/utils/code_generation/cil/COOL_to_CIL.py
+++ b/src/utils/code_generation/cil/COOL_to_CIL.py
@@ -25,7 +25,7 @@ def visit(self, node, scope=None):
             self.to_function_name('main', 'Main'), result))
         self.register_instruction(nodes_cil.ReturnNode(0))
 
-        self.register_data('Aborting... in class ')
+        self.register_data('Abort called from class ')
         self.register_built_in()
         self.current_function = None
 

From 03cb1336f2540d394bcc8e6ce29b6d982ee857cb Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Fri, 25 Feb 2022 12:45:10 -0800
Subject: [PATCH 78/83] Update team.yml

---
 doc/team.yml | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/doc/team.yml b/doc/team.yml
index c16162532..af017d6ba 100644
--- a/doc/team.yml
+++ b/doc/team.yml
@@ -1,10 +1,8 @@
 members:
-  - name: Nombre Apellido1 Apellido2
-    github: github_id
-    group: CXXX
-  - name: Nombre Apellido1 Apellido2
-    github: github_id
-    group: CXXX
-  - name: Nombre Apellido1 Apellido2
-    github: github_id
-    group: CXXX
+  - name: Alejandro Campos Matanzas
+    github: Alexx-4
+    group: C-411
+    
+  - name: Darian Dominguez Alayón
+    github: Darian10
+    group: C-411

From 492ddec059685785a3a787828643e3390cdfa181 Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Fri, 25 Feb 2022 13:17:27 -0800
Subject: [PATCH 79/83] Delete cells.mips

---
 src/cells.mips | 3661 ------------------------------------------------
 1 file changed, 3661 deletions(-)
 delete mode 100644 src/cells.mips

diff --git a/src/cells.mips b/src/cells.mips
deleted file mode 100644
index bf951bd30..000000000
--- a/src/cells.mips
+++ /dev/null
@@ -1,3661 +0,0 @@
-	.data
-default_str: .asciiz ""
-data_1: .asciiz "Object"
-data_2: .asciiz "IO"
-data_3: .asciiz "String"
-data_4: .asciiz "Int"
-data_5: .asciiz "Bool"
-data_6: .asciiz "CellularAutomaton"
-data_7: .asciiz "Main"
-data_8: .asciiz "Aborting... in class "
-data_9: .asciiz "
-"
-data_10: .asciiz "Substring out of range"
-data_11: .asciiz "(17,24) - RuntimeError: Dispatch on void
-"
-data_12: .asciiz "(23,9) - RuntimeError: Dispatch on void
-"
-data_13: .asciiz "(27,9) - RuntimeError: Dispatch on void
-"
-data_14: .asciiz "X"
-data_15: .asciiz "."
-data_16: .asciiz "(67,33) - RuntimeError: Dispatch on void
-"
-data_17: .asciiz "         X         "
-data_18: .asciiz "(83,27) - RuntimeError: Dispatch on void
-"
-data_19: .asciiz "(84,13) - RuntimeError: Dispatch on void
-"
-data_20: .asciiz "(88,25) - RuntimeError: Dispatch on void
-"
-data_21: .asciiz "(89,25) - RuntimeError: Dispatch on void
-"
-
-type_name_table:
-	.word	data_1
-	.word	data_2
-	.word	data_3
-	.word	data_4
-	.word	data_5
-	.word	data_6
-	.word	data_7
-
-proto_table:
-	.word	type_1_proto
-	.word	type_2_proto
-	.word	type_3_proto
-	.word	type_4_proto
-	.word	type_5_proto
-	.word	type_6_proto
-	.word	type_7_proto
-
-type_1_dispatch:
-	.word	 L_2
-	.word	 L_3
-	.word	 L_4
-	.word	 L_1
-
-type_1_proto:
-	.word	0
-	.word	4
-	.word	type_1_dispatch
-	.word	-1
-
-type_2_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_6
-	.word	 L_7
-	.word	 L_8
-	.word	 L_9
-	.word	 L_5
-
-type_2_proto:
-	.word	1
-	.word	4
-	.word	type_2_dispatch
-	.word	-1
-
-type_3_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_11
-	.word	 L_12
-	.word	 L_13
-	.word	 L_10
-
-type_3_proto:
-	.word	2
-	.word	6
-	.word	type_3_dispatch
-	.word	default_str
-	.word	type_4_proto
-	.word	-1
-
-type_4_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_14
-
-type_4_proto:
-	.word	3
-	.word	5
-	.word	type_4_dispatch
-	.word	0
-	.word	-1
-
-type_5_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_15
-
-type_5_proto:
-	.word	4
-	.word	5
-	.word	type_5_dispatch
-	.word	0
-	.word	-1
-
-type_6_dispatch:
-	.word	 L_2
-	.word	 L_3
-	.word	 L_4
-	.word	 L_6
-	.word	 L_7
-	.word	 L_8
-	.word	 L_9
-	.word	 L_16
-	.word	 L_17
-	.word	 L_18
-	.word	 L_19
-	.word	 L_20
-	.word	 L_21
-	.word	 L_22
-	.word	 L_23
-
-type_6_proto:
-	.word	5
-	.word	5
-	.word	type_6_dispatch
-	.word	0
-	.word	-1
-
-type_7_dispatch:
-	.word	 L_2
-	.word	 L_3
-	.word	 L_4
-	.word	 L_26
-
-type_7_proto:
-	.word	6
-	.word	5
-	.word	type_7_dispatch
-	.word	0
-	.word	-1
-	.text
-	.globl main
-main:
-	jal mem_manager_init
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	jal L_27
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_26
-	move $t0 $v0
-	addi $sp, $sp, 4
-	li $v0, 0
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	li $v0, 10
-	syscall
-L_1:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	li $t5, 0
-	sll $t5 $t5 2
-	la $t1, proto_table
-	addu $t1 $t1 $t5
-	lw $t1, 0($t1)
-	lw $a0, 4($t1)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t1
-	move $a1 $v0
-	jal copy
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_2:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	lw $t1, 0($fp)
-	la $t0, data_8 + 0
-	li $v0, 4
-	move $a0 $t0
-	syscall
-	lw $a0, 0($t1)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t0 $a0
-	li $v0, 4
-	move $a0 $t0
-	syscall
-	la $t0, data_9 + 0
-	li $v0, 4
-	move $a0 $t0
-	syscall
-	li $v0, 10
-	syscall
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_3:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $a0, 0($t0)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t0 $a0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_4:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t0, 0($fp)
-	lw $a0, 4($t0)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t0
-	move $a1 $v0
-	jal copy
-	move $t0 $v0
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_5:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	li $t1, 1
-	sll $t1 $t1 2
-	la $t5, proto_table
-	addu $t5 $t5 $t1
-	lw $t5, 0($t5)
-	lw $a0, 4($t5)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t5
-	move $a1 $v0
-	jal copy
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_6:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $t1, 4($fp)
-	lw $a1, 12($t0)
-	move $t0 $a1
-	li $v0, 4
-	move $a0 $t0
-	syscall
-	move $v0 $t1
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_7:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $t1, 4($fp)
-	lw $a1, 12($t0)
-	move $t0 $a1
-	li $v0, 1
-	move $a0 $t0
-	syscall
-	move $v0 $t1
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_8:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	lw $t0, 0($fp)
-	jal get_string
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_9:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	lw $t0, 0($fp)
-	li $v0, 5
-	syscall
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_10:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -12
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t1, 0($fp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	li $t1, 2
-	sll $t1 $t1 2
-	la $t7, proto_table
-	addu $t7 $t7 $t1
-	lw $t7, 0($t7)
-	lw $a0, 4($t7)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t7
-	move $a1 $v0
-	jal copy
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	sw $t1, 12($t0)
-	move $a0 $t1
-	jal len
-	move $t1 $v0
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	jal L_14
-	move $t1 $v0
-	addi $sp, $sp, 4
-	sw $t1, 16($t0)
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 12
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_11:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($fp)
-	lw $a1, 16($t0)
-	move $t0 $a1
-	move $v0 $t0
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_12:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -24
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t0, 0($fp)
-	lw $t1, 4($fp)
-	lw $a1, 12($t1)
-	move $t3 $a1
-	lw $a1, 12($t0)
-	move $t2 $a1
-	lw $a1, 16($t1)
-	move $t1 $a1
-	lw $a1, 16($t0)
-	move $t0 $a1
-	lw $a1, 12($t1)
-	move $t1 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t1 $t1 $t0
-	move $a0 $t3
-	move $a1 $t2
-	move $a2 $t1
-	jal concat
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 24
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_13:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -32
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $t2, 4($fp)
-	lw $t1, 8($fp)
-	lw $a1, 12($t1)
-	move $t3 $a1
-	lw $a1, 12($t2)
-	move $t4 $a1
-	lw $a1, 12($t0)
-	move $t2 $a1
-	lw $a1, 16($t1)
-	move $t0 $a1
-	add $t1 $t2 $t4
-	move $a0 $t0
-	move $a1 $t1
-	jal less
-	move $t0 $v0
-	bne $t0 $zero L_29
-	j L_30
-	L_29:
-	li $v0, 4
-	la $a0, data_10
-	syscall
-	li $v0, 10
-	syscall
-	L_30:
-	move $a0 $t3
-	move $a1 $t4
-	move $a2 $t2
-	jal sub_string
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 32
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_14:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $t8, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t1, 0($fp)
-	addi $sp, $sp, -4
-	sw $t8, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	li $t8, 3
-	sll $t8 $t8 2
-	la $t4, proto_table
-	addu $t4 $t4 $t8
-	lw $t4, 0($t4)
-	lw $a0, 4($t4)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t4
-	move $a1 $v0
-	jal copy
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $t8, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	sw $t1, 12($t0)
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t8, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_15:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t1, 0($fp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	li $t3, 4
-	sll $t3 $t3 2
-	la $t5, proto_table
-	addu $t5 $t5 $t3
-	lw $t5, 0($t5)
-	lw $a0, 4($t5)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t5
-	move $a1 $v0
-	jal copy
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	sw $t1, 12($t0)
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_16:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t1, 0($fp)
-	lw $t0, 4($fp)
-	sw $t1, 12($t0)
-	move $v0 $t0
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 0
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_17:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -44
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t1, 0($fp)
-	la $t0, data_9 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t2 $t0
-	lw $a1, 12($t1)
-	move $t0 $a1
-	move $t0 $t0
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t3 $v0
-	bne $t3 $zero L_31
-	j L_32
-	L_31:
-	li $v0, 4
-	la $a0, data_11
-	syscall
-	li $v0, 10
-	syscall
-	L_32:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	lw $t0, 0($t0)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 16
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t1)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 12
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $v0 $t1
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 44
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_18:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -20
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t0, 0($fp)
-	lw $a1, 12($t0)
-	move $t0 $a1
-	move $t1 $t0
-	move $a0 $t1
-	li $a1, 0
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_33
-	j L_34
-	L_33:
-	li $v0, 4
-	la $a0, data_12
-	syscall
-	li $v0, 10
-	syscall
-	L_34:
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t0, 0($t1)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 12
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 20
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_19:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -32
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	lw $t0, 0($fp)
-	lw $t1, 4($fp)
-	move $t3 $t0
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t2 $t0
-	lw $a1, 12($t1)
-	move $t0 $a1
-	move $t0 $t0
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t1 $v0
-	bne $t1 $zero L_35
-	j L_36
-	L_35:
-	li $v0, 4
-	la $a0, data_13
-	syscall
-	li $v0, 10
-	syscall
-	L_36:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	lw $t0, 0($t0)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 20
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 12
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 32
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_20:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -120
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t1, 0($fp)
-	lw $t4, 4($fp)
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t5 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t1)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t2 $a0
-	la $t0, type_name_table
-	addiu $t0 $t0 12
-	lw $t0, 0($t0)
-	la $t3, type_name_table
-	addiu $t3 $t3 16
-	lw $t3, 0($t3)
-	la $t6, type_name_table
-	addiu $t6 $t6 8
-	lw $t6, 0($t6)
-	move $a0 $t2
-	move $a1 $t0
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_37
-	move $a0 $t2
-	move $a1 $t3
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_37
-	move $a0 $t2
-	move $a1 $t6
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_38
-	j L_39
-	L_37:
-	lw $a1, 12($t1)
-	move $t0 $a1
-	lw $a1, 12($t5)
-	move $t2 $a1
-	move $a0 $t0
-	move $a1 $t2
-	jal eqs
-	move $t0 $v0
-	j L_40
-	L_38:
-	lw $a1, 12($t1)
-	move $t0 $a1
-	lw $a1, 12($t5)
-	move $t2 $a1
-	move $a0 $t0
-	move $a1 $t2
-	jal eq_string
-	move $t0 $v0
-	j L_40
-	L_39:
-	move $a0 $t1
-	move $a1 $t5
-	jal eqs
-	move $t0 $v0
-	L_40:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_41
-	j L_42
-	L_41:
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	lw $t0, 0($t4)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 36
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t1 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	sub $t0 $t1 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t4)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 40
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t0 $t0
-	j L_43
-	L_42:
-	lw $a1, 12($t1)
-	move $t1 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	sub $t0 $t1 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t4)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 40
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t0 $t0
-	L_43:
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 120
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_21:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -120
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $t3, 4($fp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	lw $t1, 0($t3)
-	la $a1, proto_table
-	sll $a2 $t1 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 36
-	lw $a1, 0($a1)
-	jal $a1
-	move $t1 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t1)
-	move $t1 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t2 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t2)
-	move $t2 $a1
-	sub $t1 $t1 $t2
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	jal L_14
-	move $t5 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t0)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t2 $a0
-	la $t4, type_name_table
-	addiu $t4 $t4 12
-	lw $t4, 0($t4)
-	la $t6, type_name_table
-	addiu $t6 $t6 16
-	lw $t6, 0($t6)
-	la $t1, type_name_table
-	addiu $t1 $t1 8
-	lw $t1, 0($t1)
-	move $a0 $t2
-	move $a1 $t4
-	jal eqs
-	move $t4 $v0
-	bne $t4 $zero L_44
-	move $a0 $t2
-	move $a1 $t6
-	jal eqs
-	move $t4 $v0
-	bne $t4 $zero L_44
-	move $a0 $t2
-	move $a1 $t1
-	jal eqs
-	move $t4 $v0
-	bne $t4 $zero L_45
-	j L_46
-	L_44:
-	lw $a1, 12($t0)
-	move $t1 $a1
-	lw $a1, 12($t5)
-	move $t2 $a1
-	move $a0 $t1
-	move $a1 $t2
-	jal eqs
-	move $t1 $v0
-	j L_47
-	L_45:
-	lw $a1, 12($t0)
-	move $t1 $a1
-	lw $a1, 12($t5)
-	move $t2 $a1
-	move $a0 $t1
-	move $a1 $t2
-	jal eq_string
-	move $t1 $v0
-	j L_47
-	L_46:
-	move $a0 $t0
-	move $a1 $t5
-	jal eqs
-	move $t1 $v0
-	L_47:
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	jal L_15
-	move $t1 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t1)
-	move $t1 $a1
-	bne $t1 $zero L_48
-	j L_49
-	L_48:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t3)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 40
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t0 $t0
-	j L_50
-	L_49:
-	lw $a1, 12($t0)
-	move $t1 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t0 $t1 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t3)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 40
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t0 $t0
-	L_50:
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 120
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_22:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -312
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t8, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t3, 0($fp)
-	lw $t2, 4($fp)
-	move $t0 $t3
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t2)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 40
-	lw $a1, 0($a1)
-	jal $a1
-	move $t7 $v0
-	addi $sp, $sp, 8
-	la $t0, data_14 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t1 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t7)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t0 $a0
-	la $t5, type_name_table
-	addiu $t5 $t5 12
-	lw $t5, 0($t5)
-	la $t6, type_name_table
-	addiu $t6 $t6 16
-	lw $t6, 0($t6)
-	la $t4, type_name_table
-	addiu $t4 $t4 8
-	lw $t4, 0($t4)
-	move $a0 $t0
-	move $a1 $t5
-	jal eqs
-	move $t5 $v0
-	bne $t5 $zero L_51
-	move $a0 $t0
-	move $a1 $t6
-	jal eqs
-	move $t5 $v0
-	bne $t5 $zero L_51
-	move $a0 $t0
-	move $a1 $t4
-	jal eqs
-	move $t5 $v0
-	bne $t5 $zero L_52
-	j L_53
-	L_51:
-	lw $a1, 12($t7)
-	move $t4 $a1
-	lw $a1, 12($t1)
-	move $t0 $a1
-	move $a0 $t4
-	move $a1 $t0
-	jal eqs
-	move $t0 $v0
-	j L_54
-	L_52:
-	lw $a1, 12($t7)
-	move $t4 $a1
-	lw $a1, 12($t1)
-	move $t0 $a1
-	move $a0 $t4
-	move $a1 $t0
-	jal eq_string
-	move $t0 $v0
-	j L_54
-	L_53:
-	move $a0 $t7
-	move $a1 $t1
-	jal eqs
-	move $t0 $v0
-	L_54:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_55
-	j L_56
-	L_55:
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_57
-	L_56:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_57:
-	lw $a1, 12($t0)
-	move $t1 $a1
-	move $t0 $t3
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t2)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 44
-	lw $a1, 0($a1)
-	jal $a1
-	move $t5 $v0
-	addi $sp, $sp, 8
-	la $t0, data_14 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t7 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t5)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t8 $a0
-	la $t6, type_name_table
-	addiu $t6 $t6 12
-	lw $t6, 0($t6)
-	la $t4, type_name_table
-	addiu $t4 $t4 16
-	lw $t4, 0($t4)
-	la $t0, type_name_table
-	addiu $t0 $t0 8
-	lw $t0, 0($t0)
-	move $a0 $t8
-	move $a1 $t6
-	jal eqs
-	move $t6 $v0
-	bne $t6 $zero L_58
-	move $a0 $t8
-	move $a1 $t4
-	jal eqs
-	move $t6 $v0
-	bne $t6 $zero L_58
-	move $a0 $t8
-	move $a1 $t0
-	jal eqs
-	move $t6 $v0
-	bne $t6 $zero L_59
-	j L_60
-	L_58:
-	lw $a1, 12($t5)
-	move $t0 $a1
-	lw $a1, 12($t7)
-	move $t4 $a1
-	move $a0 $t0
-	move $a1 $t4
-	jal eqs
-	move $t0 $v0
-	j L_61
-	L_59:
-	lw $a1, 12($t5)
-	move $t0 $a1
-	lw $a1, 12($t7)
-	move $t4 $a1
-	move $a0 $t0
-	move $a1 $t4
-	jal eq_string
-	move $t0 $v0
-	j L_61
-	L_60:
-	move $a0 $t5
-	move $a1 $t7
-	jal eqs
-	move $t0 $v0
-	L_61:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_62
-	j L_63
-	L_62:
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_64
-	L_63:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_64:
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t0 $t1 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t1 $a1
-	move $t0 $t3
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t2)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 48
-	lw $a1, 0($a1)
-	jal $a1
-	move $t6 $v0
-	addi $sp, $sp, 8
-	la $t0, data_14 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t3 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t6)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t5 $a0
-	la $t0, type_name_table
-	addiu $t0 $t0 12
-	lw $t0, 0($t0)
-	la $t4, type_name_table
-	addiu $t4 $t4 16
-	lw $t4, 0($t4)
-	la $t2, type_name_table
-	addiu $t2 $t2 8
-	lw $t2, 0($t2)
-	move $a0 $t5
-	move $a1 $t0
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_65
-	move $a0 $t5
-	move $a1 $t4
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_65
-	move $a0 $t5
-	move $a1 $t2
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_66
-	j L_67
-	L_65:
-	lw $a1, 12($t6)
-	move $t2 $a1
-	lw $a1, 12($t3)
-	move $t0 $a1
-	move $a0 $t2
-	move $a1 $t0
-	jal eqs
-	move $t0 $v0
-	j L_68
-	L_66:
-	lw $a1, 12($t6)
-	move $t2 $a1
-	lw $a1, 12($t3)
-	move $t0 $a1
-	move $a0 $t2
-	move $a1 $t0
-	jal eq_string
-	move $t0 $v0
-	j L_68
-	L_67:
-	move $a0 $t6
-	move $a1 $t3
-	jal eqs
-	move $t0 $v0
-	L_68:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_69
-	j L_70
-	L_69:
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_71
-	L_70:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_71:
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t0 $t1 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t3 $v0
-	addi $sp, $sp, 4
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t1 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t3)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t0 $a0
-	la $t4, type_name_table
-	addiu $t4 $t4 12
-	lw $t4, 0($t4)
-	la $t2, type_name_table
-	addiu $t2 $t2 16
-	lw $t2, 0($t2)
-	la $t5, type_name_table
-	addiu $t5 $t5 8
-	lw $t5, 0($t5)
-	move $a0 $t0
-	move $a1 $t4
-	jal eqs
-	move $t4 $v0
-	bne $t4 $zero L_72
-	move $a0 $t0
-	move $a1 $t2
-	jal eqs
-	move $t4 $v0
-	bne $t4 $zero L_72
-	move $a0 $t0
-	move $a1 $t5
-	jal eqs
-	move $t4 $v0
-	bne $t4 $zero L_73
-	j L_74
-	L_72:
-	lw $a1, 12($t3)
-	move $t0 $a1
-	lw $a1, 12($t1)
-	move $t1 $a1
-	move $a0 $t0
-	move $a1 $t1
-	jal eqs
-	move $t0 $v0
-	j L_75
-	L_73:
-	lw $a1, 12($t3)
-	move $t0 $a1
-	lw $a1, 12($t1)
-	move $t1 $a1
-	move $a0 $t0
-	move $a1 $t1
-	jal eq_string
-	move $t0 $v0
-	j L_75
-	L_74:
-	move $a0 $t3
-	move $a1 $t1
-	jal eqs
-	move $t0 $v0
-	L_75:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_76
-	j L_77
-	L_76:
-	la $t0, data_14 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_78
-	L_77:
-	la $t0, data_15 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_78:
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t8, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 312
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_23:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -104
-	addi $sp, $sp, -4
-	sw $t9, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t5, 0($fp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	li $t7, 3
-	sll $t7 $t7 2
-	la $t6, proto_table
-	addu $t6 $t6 $t7
-	lw $t6, 0($t6)
-	lw $a0, 4($t6)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t6
-	move $a1 $v0
-	jal copy
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	move $t4 $v0
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	lw $t0, 0($t5)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 36
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t2 $t0
-	addi $sp, $sp, -4
-	sw $t9, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	li $t9, 2
-	sll $t9 $t9 2
-	la $t4, proto_table
-	addu $t4 $t4 $t9
-	lw $t4, 0($t4)
-	lw $a0, 4($t4)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t4
-	move $a1 $v0
-	jal copy
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $t9, 0($sp)
-	addi $sp, $sp, 4
-	move $t3 $v0
-	L_79:
-	lw $a1, 12($t4)
-	move $t0 $a1
-	lw $a1, 12($t2)
-	move $t1 $a1
-	move $a0 $t0
-	move $a1 $t1
-	jal less
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_80
-	j L_83
-	L_80:
-	move $t0 $t4
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t5)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 52
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t1 $t0
-	move $t3 $t3
-	move $a0 $t3
-	li $a1, 0
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_81
-	j L_82
-	L_81:
-	li $v0, 4
-	la $a0, data_16
-	syscall
-	li $v0, 10
-	syscall
-	L_82:
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t0, 0($t3)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 16
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t3 $t0
-	lw $a1, 12($t4)
-	move $t1 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t0 $t1 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t4 $t0
-	j L_79
-	L_83:
-	sw $t3, 12($t5)
-	move $t0 $t5
-	move $t0 $t0
-	move $t0 $t0
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t9, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 104
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_24:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	li $t1, 5
-	sll $t1 $t1 2
-	la $t0, proto_table
-	addu $t0 $t0 $t1
-	lw $t0, 0($t0)
-	lw $a0, 4($t0)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t0
-	move $a1 $v0
-	jal copy
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_25
-	move $t1 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_25:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t1, 0($fp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	li $t6, 2
-	sll $t6 $t6 2
-	la $t3, proto_table
-	addu $t3 $t3 $t6
-	lw $t3, 0($t3)
-	lw $a0, 4($t3)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t3
-	move $a1 $v0
-	jal copy
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	sw $t0, 12($t1)
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_26:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -148
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t2, 0($fp)
-	la $t0, data_17 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t1 $t0
-	jal L_24
-	move $t0 $v0
-	move $t0 $t0
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t3 $v0
-	bne $t3 $zero L_84
-	j L_85
-	L_84:
-	li $v0, 4
-	la $a0, data_18
-	syscall
-	li $v0, 10
-	syscall
-	L_85:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t0, 0($t0)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 28
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	sw $t0, 12($t2)
-	lw $a1, 12($t2)
-	move $t0 $a1
-	move $t0 $t0
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t1 $v0
-	bne $t1 $zero L_86
-	j L_87
-	L_86:
-	li $v0, 4
-	la $a0, data_19
-	syscall
-	li $v0, 10
-	syscall
-	L_87:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t0)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 32
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	li $a0, 20
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t3 $t0
-	L_88:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	lw $a1, 12($t3)
-	move $t1 $a1
-	move $a0 $t0
-	move $a1 $t1
-	jal less
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_89
-	j L_94
-	L_89:
-	lw $a1, 12($t2)
-	move $t0 $a1
-	move $t0 $t0
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t1 $v0
-	bne $t1 $zero L_90
-	j L_91
-	L_90:
-	li $v0, 4
-	la $a0, data_20
-	syscall
-	li $v0, 10
-	syscall
-	L_91:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t0)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 56
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t2)
-	move $t0 $a1
-	move $t0 $t0
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t1 $v0
-	bne $t1 $zero L_92
-	j L_93
-	L_92:
-	li $v0, 4
-	la $a0, data_21
-	syscall
-	li $v0, 10
-	syscall
-	L_93:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t0)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 32
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t3)
-	move $t0 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t1 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t1)
-	move $t1 $a1
-	sub $t0 $t0 $t1
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t3 $t0
-	j L_88
-	L_94:
-	move $t0 $zero
-	move $v0 $t2
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 148
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_27:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t8, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t8, 0($sp)
-	li $t7, 6
-	sll $t7 $t7 2
-	la $t8, proto_table
-	addu $t8 $t8 $t7
-	lw $t8, 0($t8)
-	lw $a0, 4($t8)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t8
-	move $a1 $v0
-	jal copy
-	lw $t8, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	move $t1 $v0
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	jal L_28
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t1
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t8, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_28:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, 0
-	addi $sp, $sp, 0
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-
-
-    
-    alloc_size       = 2048
-    free_list = 0
-    header_size = 12
-    header_size_slot = 0
-    header_next_slot = 4
-    header_reachable_slot = 8
-    init_alloc_size = 28
-    int_type = 0
-    meta_data_obj_size = 4
-    neg_header_size = -12
-    new_line = 10
-    obj_mark = -1
-    obj_extended = -2
-    reachable = 1
-    state_size = 4
-    stack_base = -4
-    string_size_treshold = 1024
-    string_type = 0
-    total_alloc_size =  2060
-    num_type = 0
-    used_list = header_size
-
-verify_obj:
-                addiu $sp $sp -20
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $a0 16($sp)
-
-                move $t0 $a0
-
-                li $v0 9
-                move $a0 $zero
-                syscall
-
-                addiu $t1 $v0 -4    
-
-                
-                blt $t0 $gp verify_obj_not_obj
-                bgt $t0 $t1 verify_obj_not_obj
-                lw $t2 0($t0)
-                blt $t2 $zero verify_obj_not_obj
-                la $t3 num_type
-                lw $t3 0($t3)
-                bge $t2 $t3 verify_obj_not_obj
-
-                addiu $t0 $t0 4
-                blt $t0 $gp verify_obj_not_obj
-                bgt $t0 $t1 verify_obj_not_obj
-                lw $t2 0($t0)   
-
-                addiu $t0 $t0 8
-                
-
-                li $t3 meta_data_obj_size
-                sub $t2 $t2 $t3 
-                sll $t2 $t2 2
-                addu $t0 $t0 $t2
-                
-                
-                blt $t0 $gp verify_obj_not_obj
-                bgt $t0 $t1 verify_obj_not_obj
-                lw $t2 0($t0)
-                beq $t2 obj_mark verify_obj_is_obj
-                beq $t2 obj_extended verify_obj_is_obj
-
-verify_obj_not_obj:
-                li $v0 0
-                j verify_obj_finish
-
-verify_obj_is_obj:
-                li $v0 1
-
-verify_obj_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $a0 16($sp)
-                addiu $sp $sp 20
-
-                jr $ra
-
-concat:
-                addiu $sp $sp -24
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $a0 12($sp)
-                sw $a1 16($sp)
-                sw $ra 20($sp)
-
-                move $t0 $a0
-                move $t1 $a1
-
-
-                addiu $a0 $a2 1
-                li $t2 4
-                div $a0 $t2
-                mfhi $a0
-                bne $a0 $zero concat_allign_size
-                addiu $a0 $a2 1
-
-concat_size_alligned:
-                jal malloc
-                move $t2 $v0
-                j concat_copy_first_cycle
-
-concat_allign_size:
-                sub $t2 $t2 $a0
-                add $a0 $a2 $t2
-                addiu $a0 $a0 1
-                j concat_size_alligned
-
-concat_copy_first_cycle:
-                lb $a0 0($t0)
-                beq $a0 $zero concat_copy_second_cycle
-                sb $a0 0($t2)
-                addiu $t0 $t0 1
-                addiu $t2 $t2 1
-                j concat_copy_first_cycle
-
-concat_copy_second_cycle:
-                lb $a0 0($t1)
-                beq $a0 $zero concat_finish
-                sb $a0 0($t2)
-                addiu $t1 $t1 1
-                addiu $t2 $t2 1
-                j concat_copy_second_cycle
-
-concat_finish:
-                sb $zero 0($t2)
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $a0 12($sp)
-                lw $a1 16($sp)
-                lw $ra 20($sp)
-                addiu $sp $sp 24
-
-                jr $ra
-
-copy:
-                addiu $sp $sp -16
-                sw $a0 0($sp)
-                sw $a1 4($sp)
-                sw $a2 8($sp)
-                sw $t0 12($sp)
-
-copy_cycle:
-                beq $a2 $zero copy_finish
-                lw $t0 0($a0)
-                sw $t0 0($a1)
-                addiu $a0 $a0 4
-                addiu $a1 $a1 4
-                addi $a2 $a2 -4
-                j copy_cycle
-
-copy_finish:
-                lw $a0 0($sp)
-                lw $a1 4($sp)
-                lw $a2 8($sp)
-                lw $t0 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-eqs:
-                beq $a0 $a1 eqs_eq
-                li $v0 0
-                j eqs_finish
-
-eqs_eq:
-                li $v0 1
-
-eqs_finish:
-                jr $ra
-
-eq_string:
-                addiu $sp $sp -16
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-
-                move $t0 $a0
-                move $t1 $a1
-
-eq_string_cycle:
-                lb $t2 0($t0)
-                lb $t3 0($t1)
-                bne $t2 $t3 eq_string_not_eq
-                beq $t2 $zero eq_string_eq
-
-                addiu $t0 $t0 1
-                addiu $t1 $t1 1
-                j eq_string_cycle
-
-eq_string_not_eq:
-                move $v0 $zero
-                j eq_string_finish
-
-eq_string_eq:
-                li $v0 1
-
-eq_string_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-extend_block:
-                addiu $sp $sp -16
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-
-                
-                addiu $t0 $gp free_list     
-
-                beq $t0 $a0 extend_block_finish  
-                move $t0 $a0
-
-                lw $t1 header_next_slot($t0)
-                lw $t2 header_size_slot($t0)
-                move $t3 $t2
-                addiu $t2 $t2 header_size
-                addu $t2 $t2 $t0
-                beq $t2 $t1 extend_block_extend
-                j extend_block_finish
-
-extend_block_extend:
-                lw $t2 header_size_slot($t1)
-                addi $t2 $t2 header_size
-                add $t2 $t2 $t3
-                sw $t2 header_size_slot($t0)
-                lw $t1 header_next_slot($t1)
-                sw $t1 header_next_slot($t0)
-
-extend_block_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-extend_heap:
-                addiu $sp $sp -12
-                sw $a0 0($sp)
-                sw $a1 4($sp)
-                sw $t0 8($sp)
-
-                
-                li $v0 9
-                addiu $a0 $a1 header_size
-                syscall
-                
-                
-                move $t0 $a1 
-                sw $t0 header_size_slot($v0)
-                sw $zero header_next_slot($v0)
-                sw $zero header_reachable_slot($v0)
-
-               
-                lw $t0, 0($sp)
-                sw $v0 header_next_slot($t0)
-
-                move $a0 $t0
-                lw $a1 4($sp)
-                lw $t0 8($sp)
-                addiu $sp $sp 12
-
-                jr $ra
-
-free_block:
-                addiu $sp $sp -28
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $a0 12($sp)
-                sw $ra 16($sp)
-                sw $t3 20($sp)
-                sw $t4 24($sp)
-
-                move $t0 $a0
-
-                addiu $t1 $gp free_list
-
-                addiu $t3 $gp used_list
-
-free_block_cycle_used_list:
-                lw $t4 header_next_slot($t3)
-                beq $t4 $t0 free_block_cycle_free_list
-                move $t3 $t4
-                j free_block_cycle_used_list
-
-free_block_cycle_free_list:
-                lw $t2 header_next_slot($t1)
-                beq $t2 $zero free_block_founded_prev
-                bge $t2 $t0 free_block_founded_prev
-                move $t1 $t2
-                j free_block_cycle_free_list
-
-free_block_founded_prev:  
-                lw $t4 header_next_slot($t0)
-                sw $t4 header_next_slot($t3)
-                
-                
-                sw $t2 header_next_slot($t0)
-                sw $t0 header_next_slot($t1)
-
-free_block_finish:
-    
-                move $a0 $t0
-                jal extend_block
-                move $a0 $t1
-                jal extend_block
-
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $a0 12($sp)
-                lw $ra 16($sp)
-                lw $t3 20($sp)
-                lw $t4 24($sp)
-                addiu $sp $sp 28
-
-                jr $ra
-
-get_gc:
-                addiu $sp $sp -24
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $a0 16($sp)
-                sw $ra 20($sp)
-
-                li $t3 reachable    
-                addiu $t0 $sp 20    
-                lw $t1 stack_base($gp)  
-
-                li $t2 1
-
-get_gc_cycle:
-
-                addiu $t0 $t0 4
-                beq $t0 $t1 get_gc_dfs      
-                
-                lw $a0 0($t0)
-                jal verify_obj
-                
-                bne $v0 $t2 get_gc_cycle
-
-                addiu $a0 $a0 neg_header_size
-                sw $t3 header_reachable_slot($a0)
-                
-                j get_gc_cycle
-
-get_gc_dfs:
-                addiu $t1 $gp used_list
-
-get_gc_outer_cycle:
-                lw $t1 header_next_slot($t1)
-                beq $t1 $zero get_gc_free
-                lw $t2 header_reachable_slot($t1)
-                beq $t2 reachable get_gc_extend
-                j get_gc_outer_cycle
-
-get_gc_extend:
-                addiu $a0 $t1 header_size    
-                jal get_gc_rec_extend
-                j get_gc_outer_cycle
-
-get_gc_free:
-                addiu $t0 $gp used_list
-                lw $t0 header_next_slot($t0)
-
-get_gc_free_cycle:
-                beq $t0 $zero get_gc_finish
-                lw $t1 header_reachable_slot($t0)
-                bne $t1 reachable get_gc_free_cycle_free
-                sw $zero header_reachable_slot($t0)
-                move $a0 $t0
-                jal verify_obj
-                beq $v0 $zero get_gc_free_cycle
-                li $t1 obj_mark
-                addiu $t2 $t0 header_size
-                lw $t3 4($t2)
-                sll $t3 $t3 2
-                addu $t2 $t2 $t3
-                sw $t1 -4($t2)
-                lw $t0 header_next_slot($t0)
-                j get_gc_free_cycle
-
-get_gc_free_cycle_free:
-                move $a0 $t0
-                lw $t0 header_next_slot($t0)
-                jal free_block
-                j get_gc_free_cycle
-
-get_gc_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $a0 16($sp)
-                lw $ra 20($sp)
-                addiu $sp $sp 24
-
-                jr $ra
-
-get_gc_rec_extend:
-                addiu $sp $sp -16
-                sw $a0 0($sp)
-                sw $t0 4($sp)
-                sw $t1 8($sp)
-                sw $ra 12($sp)
-                
-                jal verify_obj 
-                beq $v0 $zero get_gc_rec_extend_finish
-
-                lw $t0 4($a0)
-                sll $t0 $t0 2
-                addiu $t0 $t0 -4
-                addu $t0 $a0 $t0
-                lw $t1 0($t0)   
-                beq $t1 obj_extended get_gc_rec_extend_finish
-                
-                
-                li $t1 reachable
-                addiu $a0 $a0 neg_header_size
-                sw $t1 header_reachable_slot($a0)
-                addiu $a0 $a0 header_size 
-
-                
-                li $t1 obj_extended
-                sw $t1 0($t0)
-
-                lw $t0 0($a0)   
-                
-                
-                la $t1 int_type
-                lw $t1 0($t1)
-                beq $t0 $t1 get_gc_rec_extend_finish
-
-                la $t1 string_type
-                lw $t1 0($t1)
-                beq $t0 $t1 get_gc_rec_extend_string_obj
-
-                lw $t0 4($a0)
-                li $t1 meta_data_obj_size
-                sub $t0 $t0 $t1
-                
-                addiu $t1 $a0 12
-
-get_gc_rec_extend_attr_cycle:
-                beq $t0 $zero get_gc_rec_extend_finish
-                lw $a0 0($t1)
-                jal get_gc_rec_extend
-                addiu $t1 $t1 4
-                sub $t0 $t0 1
-                j get_gc_rec_extend_attr_cycle
-
-get_gc_rec_extend_string_obj:
-                lw $t0 8($a0)
-                addiu $t0 $t0 neg_header_size
-                li $t1 reachable
-                sw $t1 header_reachable_slot($t0)
-
-get_gc_rec_extend_finish:
-                lw $a0 0($sp)
-                lw $t0 4($sp)
-                lw $t1 8($sp)
-                lw $ra 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-less_eq:
-                ble $a0 $a1 less_eq_true
-                li $v0 0
-                j less_eq_finish
-
-less_eq_true:
-                li $v0 1
-
-less_eq_finish:
-                jr $ra
-
-less:
-                blt $a0 $a1 less_true
-                li $v0 0
-                j less_finish
-
-less_true:
-                li $v0 1
-
-less_finish:
-                jr $ra
-
-len:
-                addiu $sp $sp -8
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-
-                move $t0 $a0
-                move $v0 $zero
-
-len_cycle:
-                lb $t1 0($t0)
-                beq $t1 $zero len_finish
-                addi $v0 $v0 1
-                addiu $t0 $t0 1
-                j len_cycle
-
-len_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                addiu $sp $sp 8
-
-                jr $ra
-
-malloc:
-                move $v0 $zero
-                addiu $sp $sp -28
-                sw $t1 0($sp)
-                sw $t0 4($sp)
-                sw $a0 8($sp)
-                sw $a1 12($sp)
-                sw $ra 16($sp)
-                sw $t2 20($sp)
-                sw $t3 24($sp)
-                
-                addiu $t0 $gp free_list
-                j malloc_cycle
-
-malloc_finish:
-                move $a0 $v0
-                lw $a1 8($sp)                  
-                jal divide_block
-
-                lw $t1 header_next_slot($v0)
-                sw $t1 header_next_slot($t3)
-
-                addiu $t1 $gp used_list
-                lw $a0 header_next_slot($t1)
-
-                sw $a0 header_next_slot($v0)
-                sw $v0 header_next_slot($t1)
-                
-                addiu $v0 $v0 header_size
-
-                lw $t3 24($sp)
-                lw $t2 20($sp)
-                lw $ra 16($sp)
-                lw $a1 12($sp)
-                lw $a0 8($sp)
-                lw $t0 4($sp)
-                lw $t1 0($sp)
-                addiu $sp $sp 28
-
-                jr $ra
-
-malloc_cycle:
-                move $t2 $t0                        
-                lw $t0 header_next_slot($t0)        
-                beq $t0 $zero malloc_search_finish     
-                j malloc_verify_valid_block
-
-malloc_search_finish:
-                beq $v0 $zero malloc_alloc_new_block 
-                j malloc_finish
-
-malloc_alloc_new_block:
-                li $t1 alloc_size               
-                move $t3 $t2
-                move $a1 $a0                    
-                move $a0 $t2                    
-                bge $a1 $t1 malloc_big_block    
-                li $a1 alloc_size        
-                jal extend_heap
-                
-                j malloc_finish
-
-malloc_big_block:
-                jal extend_heap
-                j malloc_finish
-
-malloc_verify_valid_block:
-                lw $t1 header_size_slot($t0)             
-                bge $t1 $a0 malloc_valid_block    
-                j malloc_cycle
-
-malloc_valid_block:
-                beq $v0 $zero malloc_first_valid_block    
-                bge $t1 $v1 malloc_cycle                    
-                move $v0 $t0                        
-                move $v1 $t1  
-                move $t3 $t2
-                j malloc_cycle
-
-malloc_first_valid_block:
-                move $v0 $t0                        
-                move $v1 $t1                        
-                move $t3 $t2 
-                j malloc_cycle
-
-mem_manager_init:
-                addiu $sp $sp -16
-                sw $v0 0($sp)
-                sw $a0 4($sp)
-                sw $a1 8($sp)
-                sw $ra 12($sp)
-                li $v0 9
-                li $a0 init_alloc_size
-                syscall
-                move $gp $v0
-                addiu $gp $gp state_size
-
-                sw $zero header_size_slot($gp)
-                sw $zero header_reachable_slot($gp)
-
-                move $a0 $gp
-                li $a1 alloc_size
-                jal extend_heap
-
-                addiu $a0 $a0 header_size
-                sw $zero header_size_slot($a0)
-                sw $zero header_next_slot($a0)
-                sw $zero header_reachable_slot($a0)
-
-
-
-                lw $v0 0($sp)
-                lw $a0 4($sp)
-                lw $a1 8($sp)
-                lw $ra 12($sp)
-                addiu $sp $sp 16
-
-                sw $sp stack_base($gp)
-
-                jr $ra
-
-get_string:
-                addiu $sp $sp -36
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $t4 16($sp)
-                sw $t5 20($sp)
-                sw $a0 24($sp)
-                sw $a1 28($sp)
-                sw $ra 32($sp)
-                
-                addiu $t0 $gp free_list
-                move $t1 $zero
-                move $t2 $t0
-
-get_string_larger_block_cycle:
-                lw $t0 header_next_slot($t0)
-                beq $t0 $zero get_string_reading
-                lw $t3 header_size_slot($t0)
-                bge $t1 $t3 get_string_larger_block_cycle
-                move $t1 $t3
-                move $t2 $t0
-                j get_string_larger_block_cycle
-
-get_string_reading:
-                beq $t1 $zero get_string_new_block
-                move $a1 $t1
-                li $v0 8
-                addiu $a0 $t2 header_size
-                syscall
-                move $t0 $a0
-                move $t1 $zero
-
-get_string_look_nl:
-                lb $t2 0($t0)
-                beq $t2 new_line get_string_nl_founded
-                beq $t2 $zero get_string_zero_founded
-                addi $t1 $t1 1
-                addi $t0 $t0 1
-                j get_string_look_nl
-
-get_string_zero_founded:
-                blt $t1 $t3 get_string_nl_founded
-                j get_string_no_nl
-
-get_string_nl_founded:
-                sb $zero 0($t0)
-                addi $t1 $t1 1
-                li $t2 4
-                div $t1 $t2
-                mfhi $t3
-                beq $t3 $zero get_string_nl_founded_alligned
-                sub $t2 $t2 $t3
-                add $t1 $t1 $t2
-
-get_string_nl_founded_alligned:
-                move $a1 $t1
-                addiu $a0 $a0 neg_header_size
-                jal divide_block
-                jal use_block
-
-                addiu $v0 $a0 header_size
-                j get_string_finish
-
-get_string_no_nl:
-                addi $t1 $t1 1
-                blt $t1 string_size_treshold get_string_dup
-                addi $t1 $t1 alloc_size
-                j get_string_extend_heap
-
-get_string_dup:
-	            sll $t1 $t1 1
-
-get_string_extend_heap:
-                move $a1 $t1
-                move $t0 $a0
-                addiu $a0 $gp free_list
-
-get_string_last_block_cycle:
-                lw $t1 header_next_slot($a0)
-                beq $t1 $zero get_string_last_block_founded
-                lw $a0 header_next_slot($a0)
-                j get_string_last_block_cycle
-
-get_string_last_block_founded:
-                jal extend_heap
-                jal extend_block
-                lw $t1 header_next_slot($a0)
-                bne $t1 $zero get_string_copy_prev
-                move $t1 $a0
-
-get_string_copy_prev:
-                lw $t3 header_size_slot($t1)
-                move $t2 $zero
-                move $t5 $t1
-                addiu $t1 $t1 header_size
-
-get_string_copy_cycle:
-                lb $t4 0($t0)
-                beq $t4 $zero get_string_copy_finish
-                sb $t4 0($t1)
-                addi $t2 $t2 1
-                addi $t0 $t0 1
-                addi $t1 $t1 1
-                j get_string_copy_cycle
-
-get_string_copy_finish:
-                sub $t3 $t3 $t2
-                move $a0 $t1
-                move $a1 $t3
-                li $v0 8
-                syscall
-                move $t0 $a0
-                move $t1 $t2
-                addiu $a0 $t5 header_size
-                j get_string_look_nl
-
-get_string_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $t4 16($sp)
-                lw $t5 20($sp)
-                lw $a0 24($sp)
-                lw $a1 28($sp)
-                lw $ra 32($sp)
-                addiu $sp $sp 36
-
-                jr $ra
-
-get_string_new_block:
-    addiu $t0 $gp free_list
-
-get_string_new_block_search_last:
-                lw $t1 header_next_slot($t0)
-                beq $t1 $zero get_string_new_block_create
-                move $t0 $t1
-                j get_string_new_block_search_last
-
-get_string_new_block_create:
-                move $a0 $t0
-                li $a1 alloc_size
-                jal extend_heap
-                jal extend_block
-                lw $t2 header_next_slot($a0)
-                beq $t2 $zero get_string_new_block_extended
-                lw $t1 header_size_slot($t2)
-                j get_string_reading
-
-get_string_new_block_extended:
-                move $t2 $a0
-                lw $t1 header_size_slot($a0)
-                j get_string_reading
-
-divide_block:
-                addiu $sp $sp -16
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $a0 8($sp)
-                sw $a1 12($sp)
-
-                
-                lw $t0 header_size_slot($a0)
-                bgt $a1 $t0 divide_block_error_small
-                
-    
-                sub $t0 $t0 $a1
-                li $t1 header_size
-                ble $t0 $t1 divide_block_same_size
-
-               
-                addu $t0 $a0 $a1
-                addiu $t0 $t0 header_size     
-
-                
-                lw $t1 header_next_slot($a0)    
-                sw $t1 header_next_slot($t0)
-                sw $t0 header_next_slot($a0)
-
-                lw $t1 header_size_slot($a0)    
-                sub $t1 $t1 $a1
-
-                addi $t1 $t1 neg_header_size
-                sw $t1 header_size_slot($t0)
-                sw $a1 header_size_slot($a0)
-                move $v0 $a0
-                j divide_block_finish
-
-divide_block_same_size:
-                move $v0 $a0
-                j divide_block_finish
-
-divide_block_error_small:
-                j divide_block_finish
-
-divide_block_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $a0 8($sp)
-                lw $a1 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-sub_string:
-                addiu $sp $sp -24
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $a0 16($sp)
-                sw $ra 20($sp)
-
-                move $t0 $a0
-                li $t1 4
-                addiu $t3 $a2 1
-                div $t3 $t1
-            
-                mfhi $t2
-                bne $t2 $zero sub_string_allign_size
-                move $t1 $t3
-                j sub_string_new_block
-
-sub_string_allign_size:
-                sub $t1 $t1 $t2
-                add $t1 $t1 $t3
-
-sub_string_new_block:
-                move $a0 $t1
-                jal malloc
-                move $t3 $v0
-                move $t1 $zero
-                addu $t0 $t0 $a1
-
-sub_string_copy_cycle:
-                beq $t1 $a2 sub_string_finish
-                lb $t2 0($t0)
-                sb $t2 0($t3)
-                addiu $t0 $t0 1
-                addiu $t3 $t3 1
-                addiu $t1 $t1 1
-                j sub_string_copy_cycle
-
-sub_string_finish:
-                sb $zero 0($t3)
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $a0 16($sp)
-                lw $ra 20($sp)
-                addiu $sp $sp 24
-
-                jr $ra
-
-use_block:
-    addiu $sp $sp -12
-    sw $t0 0($sp)
-    sw $t1 4($sp)
-    sw $t2 8($sp)
-
-    addiu $t0 $gp free_list
-
-use_block_cycle:
-                move $t1 $t0
-                lw $t0 header_next_slot($t0)
-                beq $t0 $zero use_block_finish
-                beq $t0 $a0 use_block_founded
-                j use_block_cycle
-
-use_block_founded:
-                lw $t2 header_next_slot($t0)
-                sw $t2 header_next_slot($t1)
-
-                addiu $t1 $gp used_list
-                lw $t2 header_next_slot($t1)
-                sw $t0 header_next_slot($t1)
-                sw $t2 header_next_slot($t0)
-
-use_block_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                addiu $sp $sp 12
-
-                jr $ra
-

From 2551b3a4626239ca5ffe9aa3aa245c9a3bbd684e Mon Sep 17 00:00:00 2001
From: Alejandro Campos Matanzas <74170015+Alexx-4@users.noreply.github.com>
Date: Fri, 25 Feb 2022 13:17:36 -0800
Subject: [PATCH 80/83] Delete primes.mips

---
 src/primes.mips | 2443 -----------------------------------------------
 1 file changed, 2443 deletions(-)
 delete mode 100644 src/primes.mips

diff --git a/src/primes.mips b/src/primes.mips
deleted file mode 100644
index e4e48967c..000000000
--- a/src/primes.mips
+++ /dev/null
@@ -1,2443 +0,0 @@
-	.data
-default_str: .asciiz ""
-data_1: .asciiz "Object"
-data_2: .asciiz "IO"
-data_3: .asciiz "String"
-data_4: .asciiz "Int"
-data_5: .asciiz "Bool"
-data_6: .asciiz "Main"
-data_7: .asciiz "Abort called from class "
-data_8: .asciiz "
-"
-data_9: .asciiz "Substring out of range"
-data_10: .asciiz "2 is trivially prime.
-"
-data_11: .asciiz "(55,39) - RuntimeError: Division by zero
-"
-data_12: .asciiz " is prime.
-"
-data_13: .asciiz "halt"
-data_14: .asciiz "(75,11) - RuntimeError: Dispatch on void
-"
-data_15: .asciiz "continue"
-
-type_name_table:
-	.word	data_1
-	.word	data_2
-	.word	data_3
-	.word	data_4
-	.word	data_5
-	.word	data_6
-
-proto_table:
-	.word	type_1_proto
-	.word	type_2_proto
-	.word	type_3_proto
-	.word	type_4_proto
-	.word	type_5_proto
-	.word	type_6_proto
-
-type_1_dispatch:
-	.word	 L_2
-	.word	 L_3
-	.word	 L_4
-	.word	 L_1
-
-type_1_proto:
-	.word	0
-	.word	4
-	.word	type_1_dispatch
-	.word	-1
-
-type_2_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_6
-	.word	 L_7
-	.word	 L_8
-	.word	 L_9
-	.word	 L_5
-
-type_2_proto:
-	.word	1
-	.word	4
-	.word	type_2_dispatch
-	.word	-1
-
-type_3_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_11
-	.word	 L_12
-	.word	 L_13
-	.word	 L_10
-
-type_3_proto:
-	.word	2
-	.word	6
-	.word	type_3_dispatch
-	.word	default_str
-	.word	type_4_proto
-	.word	-1
-
-type_4_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_14
-
-type_4_proto:
-	.word	3
-	.word	5
-	.word	type_4_dispatch
-	.word	0
-	.word	-1
-
-type_5_dispatch:
-	.word	 L_3
-	.word	 L_2
-	.word	 L_4
-	.word	 L_15
-
-type_5_proto:
-	.word	4
-	.word	5
-	.word	type_5_dispatch
-	.word	0
-	.word	-1
-
-type_6_dispatch:
-	.word	 L_2
-	.word	 L_3
-	.word	 L_4
-	.word	 L_6
-	.word	 L_7
-	.word	 L_8
-	.word	 L_9
-	.word	 L_16
-
-type_6_proto:
-	.word	5
-	.word	9
-	.word	type_6_dispatch
-	.word	0
-	.word	0
-	.word	0
-	.word	0
-	.word	0
-	.word	-1
-	.text
-	.globl main
-main:
-	jal mem_manager_init
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	jal L_17
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_16
-	move $t0 $v0
-	addi $sp, $sp, 4
-	li $v0, 0
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	li $v0, 10
-	syscall
-L_1:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	li $t2, 0
-	sll $t2 $t2 2
-	la $t3, proto_table
-	addu $t3 $t3 $t2
-	lw $t3, 0($t3)
-	lw $a0, 4($t3)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t3
-	move $a1 $v0
-	jal copy
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_2:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($fp)
-	la $t1, data_7 + 0
-	li $v0, 4
-	move $a0 $t1
-	syscall
-	lw $a0, 0($t0)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t1 $a0
-	li $v0, 4
-	move $a0 $t1
-	syscall
-	la $t1, data_8 + 0
-	li $v0, 4
-	move $a0 $t1
-	syscall
-	li $v0, 10
-	syscall
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_3:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	lw $t0, 0($fp)
-	lw $a0, 0($t0)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t0 $a0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_4:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $a0, 4($t0)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t0
-	move $a1 $v0
-	jal copy
-	move $t0 $v0
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_5:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t9, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t9, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	li $t9, 1
-	sll $t9 $t9 2
-	la $t5, proto_table
-	addu $t5 $t5 $t9
-	lw $t5, 0($t5)
-	lw $a0, 4($t5)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t5
-	move $a1 $v0
-	jal copy
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t9, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t9, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_6:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t1, 0($fp)
-	lw $t0, 4($fp)
-	lw $a1, 12($t1)
-	move $t1 $a1
-	li $v0, 4
-	move $a0 $t1
-	syscall
-	move $v0 $t0
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_7:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t1, 0($fp)
-	lw $t0, 4($fp)
-	lw $a1, 12($t1)
-	move $t1 $a1
-	li $v0, 1
-	move $a0 $t1
-	syscall
-	move $v0 $t0
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_8:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($fp)
-	jal get_string
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_9:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($fp)
-	li $v0, 5
-	syscall
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_10:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -12
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t1, 0($fp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	li $t5, 2
-	sll $t5 $t5 2
-	la $t3, proto_table
-	addu $t3 $t3 $t5
-	lw $t3, 0($t3)
-	lw $a0, 4($t3)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t3
-	move $a1 $v0
-	jal copy
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	sw $t1, 12($t0)
-	move $a0 $t1
-	jal len
-	move $t1 $v0
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	jal L_14
-	move $t1 $v0
-	addi $sp, $sp, 4
-	sw $t1, 16($t0)
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 12
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_11:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	lw $a1, 16($t0)
-	move $t0 $a1
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_12:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -24
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	lw $t4, 0($fp)
-	lw $t0, 4($fp)
-	lw $a1, 12($t0)
-	move $t1 $a1
-	lw $a1, 12($t4)
-	move $t3 $a1
-	lw $a1, 16($t0)
-	move $t2 $a1
-	lw $a1, 16($t4)
-	move $t0 $a1
-	lw $a1, 12($t2)
-	move $t2 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t2 $t2 $t0
-	move $a0 $t1
-	move $a1 $t3
-	move $a2 $t2
-	jal concat
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 24
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_13:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -32
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t3, 0($fp)
-	lw $t2, 4($fp)
-	lw $t1, 8($fp)
-	lw $a1, 12($t1)
-	move $t0 $a1
-	lw $a1, 12($t2)
-	move $t4 $a1
-	lw $a1, 12($t3)
-	move $t2 $a1
-	lw $a1, 16($t1)
-	move $t1 $a1
-	add $t3 $t2 $t4
-	move $a0 $t1
-	move $a1 $t3
-	jal less
-	move $t1 $v0
-	bne $t1 $zero L_19
-	j L_20
-	L_19:
-	li $v0, 4
-	la $a0, data_9
-	syscall
-	li $v0, 10
-	syscall
-	L_20:
-	move $a0 $t0
-	move $a1 $t4
-	move $a2 $t2
-	jal sub_string
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 32
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_14:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	li $t6, 3
-	sll $t6 $t6 2
-	la $t3, proto_table
-	addu $t3 $t3 $t6
-	lw $t3, 0($t3)
-	lw $a0, 4($t3)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t3
-	move $a1 $v0
-	jal copy
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	move $t1 $v0
-	sw $t0, 12($t1)
-	move $v0 $t1
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_15:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	lw $t0, 0($fp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	li $t3, 4
-	sll $t3 $t3 2
-	la $t2, proto_table
-	addu $t2 $t2 $t3
-	lw $t2, 0($t2)
-	lw $a0, 4($t2)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t2
-	move $a1 $v0
-	jal copy
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	move $t1 $v0
-	sw $t0, 12($t1)
-	move $v0 $t1
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_16:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -4
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	lw $t0, 0($fp)
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t0
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 4
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_17:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -8
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	li $t1, 5
-	sll $t1 $t1 2
-	la $t0, proto_table
-	addu $t0 $t0 $t1
-	lw $t0, 0($t0)
-	lw $a0, 4($t0)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t0
-	move $a1 $v0
-	jal copy
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	move $t1 $v0
-	addi $sp, $sp, -4
-	sw $t1, 0($sp)
-	jal L_18
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $v0 $t1
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t1, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 8
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-L_18:
-	addi $sp, $sp, -4
-	sw $fp, 0($sp)
-	addi $fp, $sp, 4
-	addi $sp, $sp, -440
-	addi $sp, $sp, -4
-	sw $a2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t5, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	addi $sp, $sp, -4
-	sw $ra, 0($sp)
-	addi $sp, $sp, -4
-	sw $t4, 0($sp)
-	addi $sp, $sp, -4
-	sw $a1, 0($sp)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	addi $sp, $sp, -4
-	sw $t7, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	lw $t2, 0($fp)
-	la $t0, data_10 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t2)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 12
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	li $a0, 2
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	sw $t0, 12($t2)
-	lw $a1, 12($t2)
-	move $t0 $a1
-	sw $t0, 16($t2)
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	addi $sp, $sp, -4
-	sw $t6, 0($sp)
-	li $t3, 3
-	sll $t3 $t3 2
-	la $t6, proto_table
-	addu $t6 $t6 $t3
-	lw $t6, 0($t6)
-	lw $a0, 4($t6)
-	sll $a0 $a0 2
-	jal malloc
-	move $a2 $a0
-	move $a0 $t6
-	move $a1 $v0
-	jal copy
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	move $t0 $v0
-	sw $t0, 20($t2)
-	li $a0, 500
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	sw $t0, 24($t2)
-	L_21:
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_22
-	j L_46
-	L_22:
-	lw $a1, 16($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t3 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t0 $t3 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	sw $t0, 16($t2)
-	li $a0, 2
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	sw $t0, 20($t2)
-	L_23:
-	lw $a1, 16($t2)
-	move $t4 $a1
-	lw $a1, 20($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	lw $a1, 20($t2)
-	move $t3 $a1
-	lw $a1, 12($t3)
-	move $t3 $a1
-	mul $t0 $t0 $t3
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t4)
-	move $t3 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	move $a0 $t3
-	move $a1 $t0
-	jal less
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_24
-	j L_25
-	L_24:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_35
-	L_25:
-	lw $a1, 16($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t3 $a1
-	lw $a1, 20($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t4 $a1
-	lw $a1, 16($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t6 $a1
-	lw $a1, 20($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	move $a0 $t0
-	li $a1, 0
-	jal eqs
-	move $t5 $v0
-	bne $t5 $zero L_26
-	j L_27
-	L_26:
-	li $v0, 4
-	la $a0, data_11
-	syscall
-	li $v0, 10
-	syscall
-	L_27:
-	div $t6 $t0
-	mflo $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	mul $t0 $t4 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	sub $t0 $t3 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t3 $v0
-	addi $sp, $sp, 4
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t6 $v0
-	addi $sp, $sp, 4
-	lw $a0, 0($t3)
-	sll $a0 $a0 2
-	la $a1, type_name_table
-	addu $a0 $a0 $a1
-	lw $a0, 0($a0)
-	move $t7 $a0
-	la $t0, type_name_table
-	addiu $t0 $t0 12
-	lw $t0, 0($t0)
-	la $t5, type_name_table
-	addiu $t5 $t5 16
-	lw $t5, 0($t5)
-	la $t4, type_name_table
-	addiu $t4 $t4 8
-	lw $t4, 0($t4)
-	move $a0 $t7
-	move $a1 $t0
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_28
-	move $a0 $t7
-	move $a1 $t5
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_28
-	move $a0 $t7
-	move $a1 $t4
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_29
-	j L_30
-	L_28:
-	lw $a1, 12($t3)
-	move $t0 $a1
-	lw $a1, 12($t6)
-	move $t3 $a1
-	move $a0 $t0
-	move $a1 $t3
-	jal eqs
-	move $t0 $v0
-	j L_31
-	L_29:
-	lw $a1, 12($t3)
-	move $t0 $a1
-	lw $a1, 12($t6)
-	move $t3 $a1
-	move $a0 $t0
-	move $a1 $t3
-	jal eq_string
-	move $t0 $v0
-	j L_31
-	L_30:
-	move $a0 $t3
-	move $a1 $t6
-	jal eqs
-	move $t0 $v0
-	L_31:
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_32
-	j L_33
-	L_32:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_34
-	L_33:
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_34:
-	move $t0 $t0
-	L_35:
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_36
-	j L_37
-	L_36:
-	lw $a1, 20($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t3 $a1
-	li $a0, 1
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	add $t0 $t3 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	sw $t0, 20($t2)
-	j L_23
-	L_37:
-	lw $a1, 16($t2)
-	move $t4 $a1
-	lw $a1, 20($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t3 $a1
-	lw $a1, 20($t2)
-	move $t0 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	mul $t0 $t3 $t0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_14
-	move $t3 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t4)
-	move $t0 $a1
-	lw $a1, 12($t3)
-	move $t3 $a1
-	move $a0 $t0
-	move $a1 $t3
-	jal less
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_38
-	j L_39
-	L_38:
-	lw $a1, 16($t2)
-	move $t0 $a1
-	sw $t0, 12($t2)
-	lw $a1, 12($t2)
-	move $t0 $a1
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t2)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 16
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	la $t0, data_12 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	addi $sp, $sp, -4
-	sw $t2, 0($sp)
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	lw $t0, 0($t2)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 12
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 8
-	move $t0 $t0
-	j L_40
-	L_39:
-	li $a0, 0
-	addi $sp, $sp, -4
-	sw $a0, 0($sp)
-	jal L_14
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_40:
-	lw $a1, 24($t2)
-	move $t3 $a1
-	lw $a1, 16($t2)
-	move $t0 $a1
-	lw $a1, 12($t3)
-	move $t3 $a1
-	lw $a1, 12($t0)
-	move $t0 $a1
-	move $a0 $t3
-	move $a1 $t0
-	jal less_eq
-	move $t0 $v0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_15
-	move $t0 $v0
-	addi $sp, $sp, 4
-	lw $a1, 12($t0)
-	move $t0 $a1
-	bne $t0 $zero L_41
-	j L_44
-	L_41:
-	la $t0, data_13 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t3 $t0
-	move $a0 $t3
-	li $a1, 0
-	jal eqs
-	move $t0 $v0
-	bne $t0 $zero L_42
-	j L_43
-	L_42:
-	li $v0, 4
-	la $a0, data_14
-	syscall
-	li $v0, 10
-	syscall
-	L_43:
-	addi $sp, $sp, -4
-	sw $t3, 0($sp)
-	lw $t0, 0($t3)
-	la $a1, proto_table
-	sll $a2 $t0 2
-	addu $a1 $a1 $a2
-	lw $a1, 0($a1)
-	lw $a1, 8($a1)
-	addiu $a1 $a1 4
-	lw $a1, 0($a1)
-	jal $a1
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	j L_45
-	L_44:
-	la $t0, data_15 + 0
-	addi $sp, $sp, -4
-	sw $t0, 0($sp)
-	jal L_10
-	move $t0 $v0
-	addi $sp, $sp, 4
-	move $t0 $t0
-	L_45:
-	j L_21
-	L_46:
-	sw $t1, 28($t2)
-	lw $t6, 0($sp)
-	addi $sp, $sp, 4
-	lw $t7, 0($sp)
-	addi $sp, $sp, 4
-	lw $a0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t2, 0($sp)
-	addi $sp, $sp, 4
-	lw $t3, 0($sp)
-	addi $sp, $sp, 4
-	lw $a1, 0($sp)
-	addi $sp, $sp, 4
-	lw $t4, 0($sp)
-	addi $sp, $sp, 4
-	lw $ra, 0($sp)
-	addi $sp, $sp, 4
-	lw $t0, 0($sp)
-	addi $sp, $sp, 4
-	lw $t5, 0($sp)
-	addi $sp, $sp, 4
-	lw $a2, 0($sp)
-	addi $sp, $sp, 4
-	addi $sp, $sp, 440
-	lw $fp, 0($sp)
-	addi $sp, $sp, 4
-	jr $ra
-
-
-    
-    alloc_size       = 2048
-    free_list = 0
-    header_size = 12
-    header_size_slot = 0
-    header_next_slot = 4
-    header_reachable_slot = 8
-    init_alloc_size = 28
-    int_type = 0
-    meta_data_obj_size = 4
-    neg_header_size = -12
-    new_line = 10
-    obj_mark = -1
-    obj_extended = -2
-    reachable = 1
-    state_size = 4
-    stack_base = -4
-    string_size_treshold = 1024
-    string_type = 0
-    total_alloc_size =  2060
-    num_type = 0
-    used_list = header_size
-
-verify_obj:
-                addiu $sp $sp -20
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $a0 16($sp)
-
-                move $t0 $a0
-
-                li $v0 9
-                move $a0 $zero
-                syscall
-
-                addiu $t1 $v0 -4    
-
-                
-                blt $t0 $gp verify_obj_not_obj
-                bgt $t0 $t1 verify_obj_not_obj
-                lw $t2 0($t0)
-                blt $t2 $zero verify_obj_not_obj
-                la $t3 num_type
-                lw $t3 0($t3)
-                bge $t2 $t3 verify_obj_not_obj
-
-                addiu $t0 $t0 4
-                blt $t0 $gp verify_obj_not_obj
-                bgt $t0 $t1 verify_obj_not_obj
-                lw $t2 0($t0)   
-
-                addiu $t0 $t0 8
-                
-
-                li $t3 meta_data_obj_size
-                sub $t2 $t2 $t3 
-                sll $t2 $t2 2
-                addu $t0 $t0 $t2
-                
-                
-                blt $t0 $gp verify_obj_not_obj
-                bgt $t0 $t1 verify_obj_not_obj
-                lw $t2 0($t0)
-                beq $t2 obj_mark verify_obj_is_obj
-                beq $t2 obj_extended verify_obj_is_obj
-
-verify_obj_not_obj:
-                li $v0 0
-                j verify_obj_finish
-
-verify_obj_is_obj:
-                li $v0 1
-
-verify_obj_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $a0 16($sp)
-                addiu $sp $sp 20
-
-                jr $ra
-
-concat:
-                addiu $sp $sp -24
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $a0 12($sp)
-                sw $a1 16($sp)
-                sw $ra 20($sp)
-
-                move $t0 $a0
-                move $t1 $a1
-
-
-                addiu $a0 $a2 1
-                li $t2 4
-                div $a0 $t2
-                mfhi $a0
-                bne $a0 $zero concat_allign_size
-                addiu $a0 $a2 1
-
-concat_size_alligned:
-                jal malloc
-                move $t2 $v0
-                j concat_copy_first_cycle
-
-concat_allign_size:
-                sub $t2 $t2 $a0
-                add $a0 $a2 $t2
-                addiu $a0 $a0 1
-                j concat_size_alligned
-
-concat_copy_first_cycle:
-                lb $a0 0($t0)
-                beq $a0 $zero concat_copy_second_cycle
-                sb $a0 0($t2)
-                addiu $t0 $t0 1
-                addiu $t2 $t2 1
-                j concat_copy_first_cycle
-
-concat_copy_second_cycle:
-                lb $a0 0($t1)
-                beq $a0 $zero concat_finish
-                sb $a0 0($t2)
-                addiu $t1 $t1 1
-                addiu $t2 $t2 1
-                j concat_copy_second_cycle
-
-concat_finish:
-                sb $zero 0($t2)
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $a0 12($sp)
-                lw $a1 16($sp)
-                lw $ra 20($sp)
-                addiu $sp $sp 24
-
-                jr $ra
-
-copy:
-                addiu $sp $sp -16
-                sw $a0 0($sp)
-                sw $a1 4($sp)
-                sw $a2 8($sp)
-                sw $t0 12($sp)
-
-copy_cycle:
-                beq $a2 $zero copy_finish
-                lw $t0 0($a0)
-                sw $t0 0($a1)
-                addiu $a0 $a0 4
-                addiu $a1 $a1 4
-                addi $a2 $a2 -4
-                j copy_cycle
-
-copy_finish:
-                lw $a0 0($sp)
-                lw $a1 4($sp)
-                lw $a2 8($sp)
-                lw $t0 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-eqs:
-                beq $a0 $a1 eqs_eq
-                li $v0 0
-                j eqs_finish
-
-eqs_eq:
-                li $v0 1
-
-eqs_finish:
-                jr $ra
-
-eq_string:
-                addiu $sp $sp -16
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-
-                move $t0 $a0
-                move $t1 $a1
-
-eq_string_cycle:
-                lb $t2 0($t0)
-                lb $t3 0($t1)
-                bne $t2 $t3 eq_string_not_eq
-                beq $t2 $zero eq_string_eq
-
-                addiu $t0 $t0 1
-                addiu $t1 $t1 1
-                j eq_string_cycle
-
-eq_string_not_eq:
-                move $v0 $zero
-                j eq_string_finish
-
-eq_string_eq:
-                li $v0 1
-
-eq_string_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-extend_block:
-                addiu $sp $sp -16
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-
-                
-                addiu $t0 $gp free_list     
-
-                beq $t0 $a0 extend_block_finish  
-                move $t0 $a0
-
-                lw $t1 header_next_slot($t0)
-                lw $t2 header_size_slot($t0)
-                move $t3 $t2
-                addiu $t2 $t2 header_size
-                addu $t2 $t2 $t0
-                beq $t2 $t1 extend_block_extend
-                j extend_block_finish
-
-extend_block_extend:
-                lw $t2 header_size_slot($t1)
-                addi $t2 $t2 header_size
-                add $t2 $t2 $t3
-                sw $t2 header_size_slot($t0)
-                lw $t1 header_next_slot($t1)
-                sw $t1 header_next_slot($t0)
-
-extend_block_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-extend_heap:
-                addiu $sp $sp -12
-                sw $a0 0($sp)
-                sw $a1 4($sp)
-                sw $t0 8($sp)
-
-                
-                li $v0 9
-                addiu $a0 $a1 header_size
-                syscall
-                
-                
-                move $t0 $a1 
-                sw $t0 header_size_slot($v0)
-                sw $zero header_next_slot($v0)
-                sw $zero header_reachable_slot($v0)
-
-               
-                lw $t0, 0($sp)
-                sw $v0 header_next_slot($t0)
-
-                move $a0 $t0
-                lw $a1 4($sp)
-                lw $t0 8($sp)
-                addiu $sp $sp 12
-
-                jr $ra
-
-free_block:
-                addiu $sp $sp -28
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $a0 12($sp)
-                sw $ra 16($sp)
-                sw $t3 20($sp)
-                sw $t4 24($sp)
-
-                move $t0 $a0
-
-                addiu $t1 $gp free_list
-
-                addiu $t3 $gp used_list
-
-free_block_cycle_used_list:
-                lw $t4 header_next_slot($t3)
-                beq $t4 $t0 free_block_cycle_free_list
-                move $t3 $t4
-                j free_block_cycle_used_list
-
-free_block_cycle_free_list:
-                lw $t2 header_next_slot($t1)
-                beq $t2 $zero free_block_founded_prev
-                bge $t2 $t0 free_block_founded_prev
-                move $t1 $t2
-                j free_block_cycle_free_list
-
-free_block_founded_prev:  
-                lw $t4 header_next_slot($t0)
-                sw $t4 header_next_slot($t3)
-                
-                
-                sw $t2 header_next_slot($t0)
-                sw $t0 header_next_slot($t1)
-
-free_block_finish:
-    
-                move $a0 $t0
-                jal extend_block
-                move $a0 $t1
-                jal extend_block
-
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $a0 12($sp)
-                lw $ra 16($sp)
-                lw $t3 20($sp)
-                lw $t4 24($sp)
-                addiu $sp $sp 28
-
-                jr $ra
-
-get_gc:
-                addiu $sp $sp -24
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $a0 16($sp)
-                sw $ra 20($sp)
-
-                li $t3 reachable    
-                addiu $t0 $sp 20    
-                lw $t1 stack_base($gp)  
-
-                li $t2 1
-
-get_gc_cycle:
-
-                addiu $t0 $t0 4
-                beq $t0 $t1 get_gc_dfs      
-                
-                lw $a0 0($t0)
-                jal verify_obj
-                
-                bne $v0 $t2 get_gc_cycle
-
-                addiu $a0 $a0 neg_header_size
-                sw $t3 header_reachable_slot($a0)
-                
-                j get_gc_cycle
-
-get_gc_dfs:
-                addiu $t1 $gp used_list
-
-get_gc_outer_cycle:
-                lw $t1 header_next_slot($t1)
-                beq $t1 $zero get_gc_free
-                lw $t2 header_reachable_slot($t1)
-                beq $t2 reachable get_gc_extend
-                j get_gc_outer_cycle
-
-get_gc_extend:
-                addiu $a0 $t1 header_size    
-                jal get_gc_rec_extend
-                j get_gc_outer_cycle
-
-get_gc_free:
-                addiu $t0 $gp used_list
-                lw $t0 header_next_slot($t0)
-
-get_gc_free_cycle:
-                beq $t0 $zero get_gc_finish
-                lw $t1 header_reachable_slot($t0)
-                bne $t1 reachable get_gc_free_cycle_free
-                sw $zero header_reachable_slot($t0)
-                move $a0 $t0
-                jal verify_obj
-                beq $v0 $zero get_gc_free_cycle
-                li $t1 obj_mark
-                addiu $t2 $t0 header_size
-                lw $t3 4($t2)
-                sll $t3 $t3 2
-                addu $t2 $t2 $t3
-                sw $t1 -4($t2)
-                lw $t0 header_next_slot($t0)
-                j get_gc_free_cycle
-
-get_gc_free_cycle_free:
-                move $a0 $t0
-                lw $t0 header_next_slot($t0)
-                jal free_block
-                j get_gc_free_cycle
-
-get_gc_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $a0 16($sp)
-                lw $ra 20($sp)
-                addiu $sp $sp 24
-
-                jr $ra
-
-get_gc_rec_extend:
-                addiu $sp $sp -16
-                sw $a0 0($sp)
-                sw $t0 4($sp)
-                sw $t1 8($sp)
-                sw $ra 12($sp)
-                
-                jal verify_obj 
-                beq $v0 $zero get_gc_rec_extend_finish
-
-                lw $t0 4($a0)
-                sll $t0 $t0 2
-                addiu $t0 $t0 -4
-                addu $t0 $a0 $t0
-                lw $t1 0($t0)   
-                beq $t1 obj_extended get_gc_rec_extend_finish
-                
-                
-                li $t1 reachable
-                addiu $a0 $a0 neg_header_size
-                sw $t1 header_reachable_slot($a0)
-                addiu $a0 $a0 header_size 
-
-                
-                li $t1 obj_extended
-                sw $t1 0($t0)
-
-                lw $t0 0($a0)   
-                
-                
-                la $t1 int_type
-                lw $t1 0($t1)
-                beq $t0 $t1 get_gc_rec_extend_finish
-
-                la $t1 string_type
-                lw $t1 0($t1)
-                beq $t0 $t1 get_gc_rec_extend_string_obj
-
-                lw $t0 4($a0)
-                li $t1 meta_data_obj_size
-                sub $t0 $t0 $t1
-                
-                addiu $t1 $a0 12
-
-get_gc_rec_extend_attr_cycle:
-                beq $t0 $zero get_gc_rec_extend_finish
-                lw $a0 0($t1)
-                jal get_gc_rec_extend
-                addiu $t1 $t1 4
-                sub $t0 $t0 1
-                j get_gc_rec_extend_attr_cycle
-
-get_gc_rec_extend_string_obj:
-                lw $t0 8($a0)
-                addiu $t0 $t0 neg_header_size
-                li $t1 reachable
-                sw $t1 header_reachable_slot($t0)
-
-get_gc_rec_extend_finish:
-                lw $a0 0($sp)
-                lw $t0 4($sp)
-                lw $t1 8($sp)
-                lw $ra 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-less_eq:
-                ble $a0 $a1 less_eq_true
-                li $v0 0
-                j less_eq_finish
-
-less_eq_true:
-                li $v0 1
-
-less_eq_finish:
-                jr $ra
-
-less:
-                blt $a0 $a1 less_true
-                li $v0 0
-                j less_finish
-
-less_true:
-                li $v0 1
-
-less_finish:
-                jr $ra
-
-len:
-                addiu $sp $sp -8
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-
-                move $t0 $a0
-                move $v0 $zero
-
-len_cycle:
-                lb $t1 0($t0)
-                beq $t1 $zero len_finish
-                addi $v0 $v0 1
-                addiu $t0 $t0 1
-                j len_cycle
-
-len_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                addiu $sp $sp 8
-
-                jr $ra
-
-malloc:
-                move $v0 $zero
-                addiu $sp $sp -28
-                sw $t1 0($sp)
-                sw $t0 4($sp)
-                sw $a0 8($sp)
-                sw $a1 12($sp)
-                sw $ra 16($sp)
-                sw $t2 20($sp)
-                sw $t3 24($sp)
-                
-                addiu $t0 $gp free_list
-                j malloc_cycle
-
-malloc_finish:
-                move $a0 $v0
-                lw $a1 8($sp)                  
-                jal divide_block
-
-                lw $t1 header_next_slot($v0)
-                sw $t1 header_next_slot($t3)
-
-                addiu $t1 $gp used_list
-                lw $a0 header_next_slot($t1)
-
-                sw $a0 header_next_slot($v0)
-                sw $v0 header_next_slot($t1)
-                
-                addiu $v0 $v0 header_size
-
-                lw $t3 24($sp)
-                lw $t2 20($sp)
-                lw $ra 16($sp)
-                lw $a1 12($sp)
-                lw $a0 8($sp)
-                lw $t0 4($sp)
-                lw $t1 0($sp)
-                addiu $sp $sp 28
-
-                jr $ra
-
-malloc_cycle:
-                move $t2 $t0                        
-                lw $t0 header_next_slot($t0)        
-                beq $t0 $zero malloc_search_finish     
-                j malloc_verify_valid_block
-
-malloc_search_finish:
-                beq $v0 $zero malloc_alloc_new_block 
-                j malloc_finish
-
-malloc_alloc_new_block:
-                li $t1 alloc_size               
-                move $t3 $t2
-                move $a1 $a0                    
-                move $a0 $t2                    
-                bge $a1 $t1 malloc_big_block    
-                li $a1 alloc_size        
-                jal extend_heap
-                
-                j malloc_finish
-
-malloc_big_block:
-                jal extend_heap
-                j malloc_finish
-
-malloc_verify_valid_block:
-                lw $t1 header_size_slot($t0)             
-                bge $t1 $a0 malloc_valid_block    
-                j malloc_cycle
-
-malloc_valid_block:
-                beq $v0 $zero malloc_first_valid_block    
-                bge $t1 $v1 malloc_cycle                    
-                move $v0 $t0                        
-                move $v1 $t1  
-                move $t3 $t2
-                j malloc_cycle
-
-malloc_first_valid_block:
-                move $v0 $t0                        
-                move $v1 $t1                        
-                move $t3 $t2 
-                j malloc_cycle
-
-mem_manager_init:
-                addiu $sp $sp -16
-                sw $v0 0($sp)
-                sw $a0 4($sp)
-                sw $a1 8($sp)
-                sw $ra 12($sp)
-                li $v0 9
-                li $a0 init_alloc_size
-                syscall
-                move $gp $v0
-                addiu $gp $gp state_size
-
-                sw $zero header_size_slot($gp)
-                sw $zero header_reachable_slot($gp)
-
-                move $a0 $gp
-                li $a1 alloc_size
-                jal extend_heap
-
-                addiu $a0 $a0 header_size
-                sw $zero header_size_slot($a0)
-                sw $zero header_next_slot($a0)
-                sw $zero header_reachable_slot($a0)
-
-
-
-                lw $v0 0($sp)
-                lw $a0 4($sp)
-                lw $a1 8($sp)
-                lw $ra 12($sp)
-                addiu $sp $sp 16
-
-                sw $sp stack_base($gp)
-
-                jr $ra
-
-get_string:
-                addiu $sp $sp -36
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $t4 16($sp)
-                sw $t5 20($sp)
-                sw $a0 24($sp)
-                sw $a1 28($sp)
-                sw $ra 32($sp)
-                
-                addiu $t0 $gp free_list
-                move $t1 $zero
-                move $t2 $t0
-
-get_string_larger_block_cycle:
-                lw $t0 header_next_slot($t0)
-                beq $t0 $zero get_string_reading
-                lw $t3 header_size_slot($t0)
-                bge $t1 $t3 get_string_larger_block_cycle
-                move $t1 $t3
-                move $t2 $t0
-                j get_string_larger_block_cycle
-
-get_string_reading:
-                beq $t1 $zero get_string_new_block
-                move $a1 $t1
-                li $v0 8
-                addiu $a0 $t2 header_size
-                syscall
-                move $t0 $a0
-                move $t1 $zero
-
-get_string_look_nl:
-                lb $t2 0($t0)
-                beq $t2 new_line get_string_nl_founded
-                beq $t2 $zero get_string_zero_founded
-                addi $t1 $t1 1
-                addi $t0 $t0 1
-                j get_string_look_nl
-
-get_string_zero_founded:
-                blt $t1 $t3 get_string_nl_founded
-                j get_string_no_nl
-
-get_string_nl_founded:
-                sb $zero 0($t0)
-                addi $t1 $t1 1
-                li $t2 4
-                div $t1 $t2
-                mfhi $t3
-                beq $t3 $zero get_string_nl_founded_alligned
-                sub $t2 $t2 $t3
-                add $t1 $t1 $t2
-
-get_string_nl_founded_alligned:
-                move $a1 $t1
-                addiu $a0 $a0 neg_header_size
-                jal divide_block
-                jal use_block
-
-                addiu $v0 $a0 header_size
-                j get_string_finish
-
-get_string_no_nl:
-                addi $t1 $t1 1
-                blt $t1 string_size_treshold get_string_dup
-                addi $t1 $t1 alloc_size
-                j get_string_extend_heap
-
-get_string_dup:
-	            sll $t1 $t1 1
-
-get_string_extend_heap:
-                move $a1 $t1
-                move $t0 $a0
-                addiu $a0 $gp free_list
-
-get_string_last_block_cycle:
-                lw $t1 header_next_slot($a0)
-                beq $t1 $zero get_string_last_block_founded
-                lw $a0 header_next_slot($a0)
-                j get_string_last_block_cycle
-
-get_string_last_block_founded:
-                jal extend_heap
-                jal extend_block
-                lw $t1 header_next_slot($a0)
-                bne $t1 $zero get_string_copy_prev
-                move $t1 $a0
-
-get_string_copy_prev:
-                lw $t3 header_size_slot($t1)
-                move $t2 $zero
-                move $t5 $t1
-                addiu $t1 $t1 header_size
-
-get_string_copy_cycle:
-                lb $t4 0($t0)
-                beq $t4 $zero get_string_copy_finish
-                sb $t4 0($t1)
-                addi $t2 $t2 1
-                addi $t0 $t0 1
-                addi $t1 $t1 1
-                j get_string_copy_cycle
-
-get_string_copy_finish:
-                sub $t3 $t3 $t2
-                move $a0 $t1
-                move $a1 $t3
-                li $v0 8
-                syscall
-                move $t0 $a0
-                move $t1 $t2
-                addiu $a0 $t5 header_size
-                j get_string_look_nl
-
-get_string_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $t4 16($sp)
-                lw $t5 20($sp)
-                lw $a0 24($sp)
-                lw $a1 28($sp)
-                lw $ra 32($sp)
-                addiu $sp $sp 36
-
-                jr $ra
-
-get_string_new_block:
-    addiu $t0 $gp free_list
-
-get_string_new_block_search_last:
-                lw $t1 header_next_slot($t0)
-                beq $t1 $zero get_string_new_block_create
-                move $t0 $t1
-                j get_string_new_block_search_last
-
-get_string_new_block_create:
-                move $a0 $t0
-                li $a1 alloc_size
-                jal extend_heap
-                jal extend_block
-                lw $t2 header_next_slot($a0)
-                beq $t2 $zero get_string_new_block_extended
-                lw $t1 header_size_slot($t2)
-                j get_string_reading
-
-get_string_new_block_extended:
-                move $t2 $a0
-                lw $t1 header_size_slot($a0)
-                j get_string_reading
-
-divide_block:
-                addiu $sp $sp -16
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $a0 8($sp)
-                sw $a1 12($sp)
-
-                
-                lw $t0 header_size_slot($a0)
-                bgt $a1 $t0 divide_block_error_small
-                
-    
-                sub $t0 $t0 $a1
-                li $t1 header_size
-                ble $t0 $t1 divide_block_same_size
-
-               
-                addu $t0 $a0 $a1
-                addiu $t0 $t0 header_size     
-
-                
-                lw $t1 header_next_slot($a0)    
-                sw $t1 header_next_slot($t0)
-                sw $t0 header_next_slot($a0)
-
-                lw $t1 header_size_slot($a0)    
-                sub $t1 $t1 $a1
-
-                addi $t1 $t1 neg_header_size
-                sw $t1 header_size_slot($t0)
-                sw $a1 header_size_slot($a0)
-                move $v0 $a0
-                j divide_block_finish
-
-divide_block_same_size:
-                move $v0 $a0
-                j divide_block_finish
-
-divide_block_error_small:
-                j divide_block_finish
-
-divide_block_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $a0 8($sp)
-                lw $a1 12($sp)
-                addiu $sp $sp 16
-
-                jr $ra
-
-sub_string:
-                addiu $sp $sp -24
-                sw $t0 0($sp)
-                sw $t1 4($sp)
-                sw $t2 8($sp)
-                sw $t3 12($sp)
-                sw $a0 16($sp)
-                sw $ra 20($sp)
-
-                move $t0 $a0
-                li $t1 4
-                addiu $t3 $a2 1
-                div $t3 $t1
-            
-                mfhi $t2
-                bne $t2 $zero sub_string_allign_size
-                move $t1 $t3
-                j sub_string_new_block
-
-sub_string_allign_size:
-                sub $t1 $t1 $t2
-                add $t1 $t1 $t3
-
-sub_string_new_block:
-                move $a0 $t1
-                jal malloc
-                move $t3 $v0
-                move $t1 $zero
-                addu $t0 $t0 $a1
-
-sub_string_copy_cycle:
-                beq $t1 $a2 sub_string_finish
-                lb $t2 0($t0)
-                sb $t2 0($t3)
-                addiu $t0 $t0 1
-                addiu $t3 $t3 1
-                addiu $t1 $t1 1
-                j sub_string_copy_cycle
-
-sub_string_finish:
-                sb $zero 0($t3)
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                lw $t3 12($sp)
-                lw $a0 16($sp)
-                lw $ra 20($sp)
-                addiu $sp $sp 24
-
-                jr $ra
-
-use_block:
-    addiu $sp $sp -12
-    sw $t0 0($sp)
-    sw $t1 4($sp)
-    sw $t2 8($sp)
-
-    addiu $t0 $gp free_list
-
-use_block_cycle:
-                move $t1 $t0
-                lw $t0 header_next_slot($t0)
-                beq $t0 $zero use_block_finish
-                beq $t0 $a0 use_block_founded
-                j use_block_cycle
-
-use_block_founded:
-                lw $t2 header_next_slot($t0)
-                sw $t2 header_next_slot($t1)
-
-                addiu $t1 $gp used_list
-                lw $t2 header_next_slot($t1)
-                sw $t0 header_next_slot($t1)
-                sw $t2 header_next_slot($t0)
-
-use_block_finish:
-                lw $t0 0($sp)
-                lw $t1 4($sp)
-                lw $t2 8($sp)
-                addiu $sp $sp 12
-
-                jr $ra
-

From acbe11eee528a50b1eb98a51f8c1b4bf25d51261 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Fri, 25 Feb 2022 21:00:05 -0800
Subject: [PATCH 81/83] rename to report

---
 doc/{Informe => Report}/files/SPIM_Manual.pdf       | Bin
 doc/{Informe => Report}/files/compilers.pdf         | Bin
 doc/{Informe => Report}/files/cool-manual.pdf       | Bin
 .../files/github-git-cheat-sheet.pdf                | Bin
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename doc/{Informe => Report}/files/SPIM_Manual.pdf (100%)
 rename doc/{Informe => Report}/files/compilers.pdf (100%)
 rename doc/{Informe => Report}/files/cool-manual.pdf (100%)
 rename doc/{Informe => Report}/files/github-git-cheat-sheet.pdf (100%)

diff --git a/doc/Informe/files/SPIM_Manual.pdf b/doc/Report/files/SPIM_Manual.pdf
similarity index 100%
rename from doc/Informe/files/SPIM_Manual.pdf
rename to doc/Report/files/SPIM_Manual.pdf
diff --git a/doc/Informe/files/compilers.pdf b/doc/Report/files/compilers.pdf
similarity index 100%
rename from doc/Informe/files/compilers.pdf
rename to doc/Report/files/compilers.pdf
diff --git a/doc/Informe/files/cool-manual.pdf b/doc/Report/files/cool-manual.pdf
similarity index 100%
rename from doc/Informe/files/cool-manual.pdf
rename to doc/Report/files/cool-manual.pdf
diff --git a/doc/Informe/files/github-git-cheat-sheet.pdf b/doc/Report/files/github-git-cheat-sheet.pdf
similarity index 100%
rename from doc/Informe/files/github-git-cheat-sheet.pdf
rename to doc/Report/files/github-git-cheat-sheet.pdf

From 66e4e4a78dd692cd1fd27003fe65c605464eb9e2 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Fri, 25 Feb 2022 22:21:32 -0800
Subject: [PATCH 82/83] report

---
 doc/Report/report.pdf | Bin 0 -> 138498 bytes
 doc/Report/report.tex | 215 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 215 insertions(+)
 create mode 100644 doc/Report/report.pdf
 create mode 100644 doc/Report/report.tex

diff --git a/doc/Report/report.pdf b/doc/Report/report.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..0d4b4907b1a3e1d442e60e4f142ef6642225cc61
GIT binary patch
literal 138498
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

literal 0
HcmV?d00001

diff --git a/doc/Report/report.tex b/doc/Report/report.tex
new file mode 100644
index 000000000..46fe42451
--- /dev/null
+++ b/doc/Report/report.tex
@@ -0,0 +1,215 @@
+\documentclass[twoside]{article}
+
+\usepackage{lipsum}
+\usepackage[none]{hyphenat} 
+
+\usepackage[sc]{mathpazo} 
+\usepackage{amsmath}
+\usepackage[T1]{fontenc} 
+\linespread{1.05}
+\usepackage{microtype}
+
+\usepackage[hmarginratio=1:1,top=32mm,columnsep=20pt]{geometry}
+\usepackage{multicol} 
+\usepackage[hang, small,labelfont=bf,up,textfont=it,up]{caption} 
+\usepackage{booktabs} 
+\usepackage{float} 
+\usepackage[hidelinks]{hyperref} 
+\usepackage[usenames]{color}
+
+\usepackage{lettrine} 
+\usepackage{paralist}
+
+\usepackage{abstract} 
+\renewcommand{\abstractnamefont}{\normalfont\bfseries}
+\renewcommand{\abstracttextfont}{\normalfont\small\itshape} 
+
+\usepackage{titlesec} 
+\renewcommand\thesection{\Roman{section}} 
+\renewcommand\thesubsection{\Roman{subsection}} 
+\titleformat{\section}[block]{\large\scshape\centering}{\thesection.}{1em}{} 
+\titleformat{\subsection}[block]{\large}{\thesubsection.}{1em}{}
+
+\usepackage{fancyhdr} 
+\pagestyle{fancy} 
+\fancyhead{} 
+\fancyfoot{}
+
+\fancyhead[C]{ Compilaci\'on $\bullet$ COOL $\bullet$ C-411}
+\fancyfoot[RO,LE]{\thepage}
+
+\title{\vspace{-15mm}\fontsize{20pt}{10pt}\selectfont\textbf{Proyecto de Complementos de Compilaci\'on}}
+
+\author{
+\large
+\textbf{\large Compilador para el lenguaje COOL} \\[1.5cm]
+\textsc{Alejandro Campos, Darian Dominguez}\\\\[2mm]
+\normalsize Facultad de Matem\'atica y Computaci\'on \\
+\normalsize Universidad de la Habana \\
+\normalsize 2022 \\[2cm]
+\vspace{-5mm}
+}
+\date{}
+
+
+\usepackage{graphicx}
+\begin{document}
+
+\maketitle
+
+\thispagestyle{fancy} 
+
+\begin{center}
+\textbf{Resumen}
+\end{center}
+\noindent \textit{Este reporte contiene las principales ideas seguidas en la implementaci\'on de un compilador completamente funcional para el lenguaje COOL. El cual es un peque\~no lenguaje que mantiene muchas de las caracter\'isticas de los lenguajes de programaci\'on modernos, incluyendo orientaci\'on a objetos, tipado est\'atico y manejo autom\'atico de memoria. A lo largo de este informe se explicar\'an, adem\'as, cada una de las etapas o fases seguidas en la implementaci\'on del compilador. Por \'ultimo, daremos, a groso modo, una peque\~na ojeada al c\'odigo con el objetivo de que el lector entienda el funcionamiento de los m\'etodos que consideramos fundamentales para el desarrollo del compilador.}\\[0.5cm]
+
+\section{Introducci\'on}
+Un compilador es un programa que traduce c\'odigo escrito en un lenguaje de programaci\'on, llamado fuente, a otro lenguaje. En este tipo de traductor, el lenguaje fuente es generalmente un lenguaje de alto nivel, y el otro, un lenguaje de bajo nivel. Un compilador es uno de los pilares de la programaci\'on y de c\'omo entender la comunicaci\'on entre un lenguaje de alto nivel y una m\'aquina. Al poder conocer el funcionamiento de este paso intermedio nos permitir\'a desarrollar y programar de una forma m\'as precisa en los lenguajes de alto nivel. El proceso de compilaci\'on es aquel por el cual se traducen las instrucciones escritas en un determinado lenguaje de programaci\'on a lenguaje de m\'aquina, es decir, a algo que la computadora entiende.
+
+En nuestro caso, el lenguaje fuente es COOL. Un programa en COOL son conjuntos de clases. Una clase encapsula las variables y procedimientos de un tipo de datos. Las instancias de una clase son objetos. En COOL se identifican clases y tipos; es decir, cada clase define un tipo. Las clases permiten a los programadores definir nuevos tipos y procedimientos asociados (o m\'etodos) espec\'ificos para esos tipos. La herencia permite que los nuevos tipos ampl\'ien el comportamiento de los tipos existentes. COOL es un lenguaje de expresi\'on. La mayor\'ia de las construcciones son expresiones, y cada expresi\'on tiene un valor y un tipo. Este lenguaje es type safe, es decir, se garantiza que los procedimientos se aplicar\'an a los datos del tipo correcto. Si bien el tipeo est\'atico impone una fuerte disciplina en la programaci\'on, garantiza que no puedan surgir errores de tipo en la ejecuci\'on de los programas en COOL.
+
+Una vez se tiene una idea acerca del funcionamiento de un compilador y del lenguaje COOL, podemos decir que el objetivo de este informe es presentar la soluci\'on al proceso de compilaci\'on del lenguaje COOL a lenguaje ensamblador, implementado en el lenguaje de pogramaci\'on python. Cuyo c\'odigo se encuentra en este \href{https://github.com/BeginnerCompilers/cool-compiler-2021}{\textcolor{red}{\underline{repositorio}}} de Github.\\\\
+
+\section{Gram\'atica y AST de COOL}
+La gram\'atica de este lenguaje responde al manual de COOL \cite{cool}. Se encuentra definida en \texttt{src/utils/COOL\_Grammar.py} y su estructura se presenta a continuaci\'on:\\
+
+\begin{align*}
+\textit{program} &\rightarrow \textit{class-list}\\
+\textit{class-list} &\rightarrow \textit{def-class ;}\\
+					 &\rightarrow \textit{def\_class ; class-list}\\
+\textit{def\_class} &\rightarrow \textit{class type  \{ feature-list \} }\\	
+&\rightarrow \textit{class type inherits type \{ feature-list \} }\\
+\textit{feature-list} &\rightarrow \textit{def-attr ; feature-list}\\
+&\rightarrow \textit{def-meth ; feature-list}\\
+&\rightarrow \epsilon\\
+\textit{def-attr} &\rightarrow \textit{id : type}\\
+&\rightarrow \textit{id : type <- expr}\\
+\textit{def-meth} &\rightarrow \textit{id ( param-list ) : type \{ expr \} }\\
+\textit{param-list} &\rightarrow \textit{non-empty-param-list}\\
+&\rightarrow \epsilon\\
+\textit{non-empty-param-list} &\rightarrow \textit{param}\\
+&\rightarrow \textit{param , non-empty-param-list}\\
+\textit{param} &\rightarrow \textit{id : type}\\
+\textit{expr} &\rightarrow \textit{id <- expr}\\
+&\rightarrow \textit{while expr loop expr pool}\\
+&\rightarrow \textit{ \{ expr-list \} }\\
+\textit{expr-list} &\rightarrow \textit{expr ;}\\
+&\rightarrow \textit{expr ; expr-list}\\
+\textit{expr} &\rightarrow \textit{let id-list in expr}\\
+\end{align*}
+\begin{align*}
+\textit{id-list} &\rightarrow \textit{id : type}\\
+&\rightarrow \textit{id : type <- expr}\\
+&\rightarrow \textit{id : type, id-list}\\
+&\rightarrow \textit{id : type <- expr , id-list}\\
+\textit{expr} &\rightarrow \textit{case expr of case-list esac}\\
+\textit{case-list} &\rightarrow \textit{id : type <- expr ;}\\
+&\rightarrow \textit{id : type <- expr ; case-list}\\
+\textit{expr} &\rightarrow \textit{not expr}\\
+&\rightarrow \textit{comp = expr}\\
+&\rightarrow \textit{comp}\\
+\textit{comp} &\rightarrow \textit{comp $<$ artih}\\
+&\rightarrow \textit{comp $\leq$ arith}\\
+&\rightarrow \textit{arith}\\
+\textit{arith} &\rightarrow \textit{arith + term}\\
+&\rightarrow \textit{arith - term}\\
+&\rightarrow \textit{term}\\
+\textit{term} &\rightarrow \textit{term * factor}\\
+&\rightarrow \textit{term / factor}\\
+&\rightarrow \textit{factor}\\
+\textit{factor} &\rightarrow \textit{isvoid factor}\\
+&\rightarrow \textit{$\sim$ factor}\\
+&\rightarrow \textit{atom}\\
+\textit{atom} &\rightarrow \textit{true}\\
+&\rightarrow \textit{false}\\
+&\rightarrow \textit{string}\\
+&\rightarrow \textit{num}\\
+&\rightarrow \textit{id}\\
+&\rightarrow \textit{new type}\\
+&\rightarrow \textit{if expr then expr else expr fi}\\
+&\rightarrow \textit{( expr )}\\
+&\rightarrow \textit{dispatch}\\
+\textit{dispatch} &\rightarrow \textit{atom . id ( arg-list )}\\
+&\rightarrow \textit{id ( arg-list )}\\
+&\rightarrow \textit{atom @ type . id ( arg-list )}\\
+\textit{arg-list} &\rightarrow \textit{non-empty-arg-list}\\
+&\rightarrow \epsilon\\
+\textit{non-empty-arg-list} &\rightarrow \textit{expr}\\
+&\rightarrow \textit{expr , non-empty-arg-list}\\
+\end{align*}
+
+El \'arbol de sint\'axis abstracta de COOL se encuentra definido en \texttt{src/utils/ast/AST\_Nodes.py}. Se defini\'o teniendo en cuenta la gram\'atica que definimos anteriormente. Esta gram\'atica es atributada y cada producci\'on contiene como computar cada uno de los atributos que la conforman que, en la mayor\'ia de los casos son argumentos que se pasan como par\'ametros para la creaci\'on de los nodos del ast de nuestro lenguaje.\\\\
+
+
+\section{An\'alisis lexicogr\'afico.}
+El an\'alisis lexicogr\'afico es la primera fase del proceso de compilaci\'on, es donde transformamos la entrada del usuario en tokens v\'alidos del lenguaje. Esta fase se encuentra implementada en \texttt{src/utils/COOL\_Lexer.py}. 
+
+El lexer en nuestro proyecto se apoya en el m\'odulo \textbf{re} de python para expresiones regulares. La clase \texttt{COOL\_Lexer} contiene las expresiones regulares que conforman el lenguaje COOL, esta clase hereda de \texttt{Lexer}, que implementa el m\'etodo \texttt{tokenize}, el cual recibe un texto como entrada y devuelve los tokens del lenguaje. Tambi\'en se detectan los errores lexicogr\'aficos que pueden existir y, en caso de que hayan, se reportan y se detiene la ejecuci\'on del programa. Los errores que se detectan en esta etapa son token inv\'alido, y los errores relacionados con los comentarios y la definici\'on de cadenas de texto, es decir, variables de tipo String. Estos \'ultimos se analizan de forma independiente al m\'odulo \textbf{re} de pyhton para clasificar cada uno de los errores que pueden surgir.\\\\
+
+
+\section{An\'alisis sint\'actico}
+El proceso de parsing b\'asicamente de lo que se encarga es en convertir cadenas de texto escritas en el lenguaje origen a una estructura arb\'orea que captura la sem\'antica del programa. Nuestro parser consiste en analizar la secuencia de tokens calculada en el lexer, y produce un \'arbol de derivaci\'on. 
+
+La implementaci\'on del parser se enuentra en \texttt{src/utils/parser}. 
+
+Primeramente tenemos la clase \texttt{parser}, que contiene las caracter\'isticas comunes a todos los parsers, en esta clase es donde se calculan los conjuntos firsts y follows, y contiene los m\'etodos que deben implementar los parsers que heredan de esta. El parser utilizado es un parser ShiftReduce, la clase \texttt{ShiftReduceParser} devuelve el \'arbol de derivaci\'on de la cadena de texto analizada y las operaciones (shift o reduce) que, posteriormente, se utilizan para generar el ast correspondiente. Adem\'as esta clase es la encargada de devolver los errores sint\'acticos o de parser, en caso de que ocurra alg\'un conflicto. La clase \texttt{LR1\_Parser} implementa los m\'etodos que calculan la tabla de parsing y su respectivo aut\'omata. Finalmente, el parser utilizado fue el LALR 1, que es un parser LR 1, solo que reduce los estados del aut\'omata antes mencionado.
+
+En \texttt{COOL\_Parser} se encuentran los valores precalculados de las tablas action y goto, que se guardan para acelerar la ejecuci\'on del programa, ya que de otra forma demora un poco en calcularlas desde 0. De esta forma \texttt{ShiftReduceParser} ejecuta el proceso de parsing con estas tablas ya calculadas. Si se detecta alg\'un error se reporta y se detiene la ejecuci\'on del algoritmo.\\\\
+
+
+\section{An\'alisis Sem\'antico}
+Llegados a esta fase, no existen errores lexicogr\'aficos ni de parsing, por lo que el texto est\'a sint\'acticamente correcto y podemos pasar al chequeo de tipos sin problemas. Podemos encontrar la implementaci\'on de esta fase en \texttt{src/utils/semantic\_check}.
+
+Para verificar la consistencia de tipos se realizan tres recorridos por el ast. El primero de estos recorridos, \texttt{TypeCollector} a\~nade al contexto todos los tipos declarados en el lenguaje, no sin antes a\~nadir los tipos predeterminados de COOL con sus respectivos m\'etodos. Verifica las redefiniciones de clases.
+
+Luego, antes de pasar al cuerpo de los m\'etodos y despu\'es de recolectar todos los tipos, se hace necesario otro recorrido que verifique declaraci\'on de atributos, par\'ametros, valores de retorno y otras referencias a tipos, y esto precisamnte es lo que hace \texttt{TypeBuilder}. 
+
+El tercer y \'ultimo recorrido, \texttt{TypeChecker}, verifica que el programa haga un uso correcto de los tipos definidos, seg\'un las especificaciones del manual de COOL. En este recorrido tambi\'en se chequea la herencia circular, la redefinici\'on de m\'etodos y que el programa contenga una clase Main con un m\'etodo main sin par\'ametros. 
+
+Al principio de cada recorrido aparecen los errores e incosistencias que se detectan en cada uno. Los recorridos del ast fueron implementados con ayuda del patr\'on visitor.\\\\
+
+
+\section{Generaci\'on de c\'odigo}
+Para la generaci\'on de c\'odigo intermedio de COOL a MIPS vamos a dise\~nar un lenguaje de m\'aquina con capacidades orientadas a objeto. Este lenguaje nos va a permitir generar c\'odigo de MIPS de forma m\'as sencilla, ya que el salto directamente desde COOL a MIPS es demasiado complejo. Este lenguaje se denomina CIL, 3-address object-oriented.
+
+En esta fase no hay incosistencia de tipos, es decir el c\'odigo de COOL est\'a lexicogr\'afica, sint\'actica y sem\'anticamente correcto, listo para la ejecuci\'on. Esta fase se encuentra implementada en \texttt{src/utils/code\_generation}
+
+\subsection{CIL}
+Como ya se dijo, primeramente, pasaremos de COOL para un lenguaje intermedio, CIL. El ast de este lenguaje se implement\'o seg\'un la definici\'on brindada en \cite{compilers} Cap\'itulo 7. Donde, adem\'as de las funciones que ah\'i se describen, se a\~naden otras para realizar la ejecuci\'on de las funciones predefinidas en COOL, y que son necesarias para el retorno de valores de m\'etodos de este lenguaje.
+
+Con ayuda del patr\'on visitor se recorre el ast de COOL y, primeramente se a\~naden todas las funciones y tipos built-in, es decir, que est\'an definidas por defecto en COOL. Posteriormente, por cada nodo del ast de COOL se crean las instrucciones correspondientes en CIL de acuerdo a su definici\'on.
+
+Contamos con una clase auxiliar, \texttt{BaseCOOLToCIL}, que contiene funciones \'utiles para el registro de par\'ametros, funciones, instrucciones, variables locales y otras declaraciones en CIL. Esta clase contiene, adem\'as, la definici\'on de los me\'etodos built-in de COOL.\\
+
+\subsection{MIPS}
+Despu\'es de tener el ast de CIL, el siguiente paso es, finalmente, generar el c\'odigo ensamblador correspondiente a la entrada de COOL. Para ello, primeramente definimos el ast de MIPS, con ayuda de \cite{mips}, en el cual cada nodo representa una instrucci\'on v\'alida en MIPS. Siguiendo la misma idea de generaci\'on de c\'odigo anterior, se recorre cada nodo del ast de CIL y se va creando el correspondiente ast v\'alido en MIPS. Una vez m\'as, los recorridos de cada ast se realizan con ayuda del patr\'on visitor, mediante el cual tambi\'en, se genera el c\'odigo ensamblador en la clase \texttt{PrintMIPS}, que tranforma cada nodo del ast en el c\'odigo de MIPS correspondiente.
+
+Los objetos en memoria est\'an ubicados de la siguiente forma: tipo, espacio que ocupa, direcci\'on de tabla de dispatch, atributos y un valor que indica que hay un objeto en esta zona de memoria. 
+
+El valor que se encuentra en la secci\'on que guarda el tipo se interpreta, como su nombre lo indica, como el tipo del objeto. 
+
+La segunda secci\'on de este segmento se interpreta como el tama\~no en palabras del objeto. 
+
+La tabla de dispatch es una direcci\'on que indica el inicio del segmento de la memoria donde esta se encuentra. Las secciones de dicho segmento se interpretan como la direcci\'on a cada uno de los m\'etodos del objeto. 
+
+Cada una de las subsecciones de la secci\'on de los atributos representa el valor de un atributo del objeto. 
+
+La \'ultima secci\'on nos dice que esta zona de la memoria corresponde a un objeto.
+
+Los tipos est\'an representados en memoria mediante tres estructuras. Primeramente est\'a definida una direcci\'on a un segmento de memoria que representa el nombre del tipo. Luego se representa una estructura que es utilizada en la creaci\'on de los objetos, por lo tanto se representa como se dijo anteriormente. Este segmento de memoria es asignado al objeto una vez que se crea y contiene los valores por defecto de estos. Por \'ultimo, tambi\'en se encuentra una tabla de dispatch, y existe una tabla de nombres, donde se puede encontrar el nombre de un tipo espec\'ifico.
+
+\section{Ejecuci\'on}
+Este proyecto no usa ninguna librer\'ia de python fuera de la librer\'ia est\'andar. Por lo que para ejecutarlo solo debe tener instalado python 3 o superior. Desde el directorio del proyecto ejecutar \texttt{python3 main.py file} donde file debe ser un archivo ubicado en el mismo directorio del proyecto. El compilador generar\'a como salida un archivo con extensi\'on \texttt{.mips} que puede ejecutar con cualquier simulador de spim. Sugerimos el uso de QtSpim.\\\\
+
+
+\begin{thebibliography}{99}
+	\bibitem{cool} Cool-manual \href{https://github.com/BeginnerCompilers/cool-compiler-2021/tree/master/doc/Report/files/cool-manual.pdf}{(\textcolor{red}{\underline{abrir}})}
+	
+	\bibitem{compilers} Compilers \href{https://github.com/BeginnerCompilers/cool-compiler-2021/tree/master/doc/Report/files/compilers.pdf}{(\textcolor{red}{\underline{abrir}})}
+	
+	\bibitem{mips} Spim Manual \href{https://github.com/BeginnerCompilers/cool-compiler-2021/tree/master/doc/Report/files/SPIM\_Manual.pdf}{(\textcolor{red}{\underline{abrir}})}
+\end{thebibliography}
+
+
+\end{document}
\ No newline at end of file

From fe8c4dbbbaff9dc855322c2df2892dcfc5d449f9 Mon Sep 17 00:00:00 2001
From: Ale <Ale@DESKTOP-KQJNTSU>
Date: Sat, 26 Feb 2022 22:38:19 -0800
Subject: [PATCH 83/83] update report

---
 doc/Report/report.pdf | Bin 138498 -> 138493 bytes
 doc/Report/report.tex |  14 +++++++-------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/doc/Report/report.pdf b/doc/Report/report.pdf
index 0d4b4907b1a3e1d442e60e4f142ef6642225cc61..ec0da7e3ec699247ce15c3a524aa36ee56526474 100644
GIT binary patch
delta 11425
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
VT`a9|9$kaOfjDezvTAZT{|_w@@st1n

delta 11568
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
B`fLCI

diff --git a/doc/Report/report.tex b/doc/Report/report.tex
index 46fe42451..43af13d3e 100644
--- a/doc/Report/report.tex
+++ b/doc/Report/report.tex
@@ -62,14 +62,14 @@
 \begin{center}
 \textbf{Resumen}
 \end{center}
-\noindent \textit{Este reporte contiene las principales ideas seguidas en la implementaci\'on de un compilador completamente funcional para el lenguaje COOL. El cual es un peque\~no lenguaje que mantiene muchas de las caracter\'isticas de los lenguajes de programaci\'on modernos, incluyendo orientaci\'on a objetos, tipado est\'atico y manejo autom\'atico de memoria. A lo largo de este informe se explicar\'an, adem\'as, cada una de las etapas o fases seguidas en la implementaci\'on del compilador. Por \'ultimo, daremos, a groso modo, una peque\~na ojeada al c\'odigo con el objetivo de que el lector entienda el funcionamiento de los m\'etodos que consideramos fundamentales para el desarrollo del compilador.}\\[0.5cm]
+\noindent \textit{Este reporte contiene las principales ideas seguidas en la implementaci\'on de un compilador completamente funcional para el lenguaje COOL, el cual es un peque\~no lenguaje que mantiene muchas de las caracter\'isticas de los lenguajes de programaci\'on modernos, incluyendo orientaci\'on a objetos, tipado est\'atico y manejo autom\'atico de memoria. A lo largo de este informe se explicar\'an, adem\'as, cada una de las etapas o fases seguidas en la implementaci\'on del compilador. Por \'ultimo, daremos, a groso modo, una peque\~na ojeada al c\'odigo con el objetivo de que el lector entienda el funcionamiento de los m\'etodos que consideramos fundamentales para el desarrollo del compilador.}\\[0.5cm]
 
 \section{Introducci\'on}
 Un compilador es un programa que traduce c\'odigo escrito en un lenguaje de programaci\'on, llamado fuente, a otro lenguaje. En este tipo de traductor, el lenguaje fuente es generalmente un lenguaje de alto nivel, y el otro, un lenguaje de bajo nivel. Un compilador es uno de los pilares de la programaci\'on y de c\'omo entender la comunicaci\'on entre un lenguaje de alto nivel y una m\'aquina. Al poder conocer el funcionamiento de este paso intermedio nos permitir\'a desarrollar y programar de una forma m\'as precisa en los lenguajes de alto nivel. El proceso de compilaci\'on es aquel por el cual se traducen las instrucciones escritas en un determinado lenguaje de programaci\'on a lenguaje de m\'aquina, es decir, a algo que la computadora entiende.
 
 En nuestro caso, el lenguaje fuente es COOL. Un programa en COOL son conjuntos de clases. Una clase encapsula las variables y procedimientos de un tipo de datos. Las instancias de una clase son objetos. En COOL se identifican clases y tipos; es decir, cada clase define un tipo. Las clases permiten a los programadores definir nuevos tipos y procedimientos asociados (o m\'etodos) espec\'ificos para esos tipos. La herencia permite que los nuevos tipos ampl\'ien el comportamiento de los tipos existentes. COOL es un lenguaje de expresi\'on. La mayor\'ia de las construcciones son expresiones, y cada expresi\'on tiene un valor y un tipo. Este lenguaje es type safe, es decir, se garantiza que los procedimientos se aplicar\'an a los datos del tipo correcto. Si bien el tipeo est\'atico impone una fuerte disciplina en la programaci\'on, garantiza que no puedan surgir errores de tipo en la ejecuci\'on de los programas en COOL.
 
-Una vez se tiene una idea acerca del funcionamiento de un compilador y del lenguaje COOL, podemos decir que el objetivo de este informe es presentar la soluci\'on al proceso de compilaci\'on del lenguaje COOL a lenguaje ensamblador, implementado en el lenguaje de pogramaci\'on python. Cuyo c\'odigo se encuentra en este \href{https://github.com/BeginnerCompilers/cool-compiler-2021}{\textcolor{red}{\underline{repositorio}}} de Github.\\\\
+Una vez se tiene una idea acerca del funcionamiento de un compilador y del lenguaje COOL, podemos decir que el objetivo de este informe es presentar la soluci\'on al proceso de compilaci\'on del lenguaje COOL a lenguaje ensamblador, implementado en el lenguaje de pogramaci\'on python, cuyo c\'odigo se encuentra en este \href{https://github.com/BeginnerCompilers/cool-compiler-2021}{\textcolor{red}{\underline{repositorio}}} de Github.\\\\
 
 \section{Gram\'atica y AST de COOL}
 La gram\'atica de este lenguaje responde al manual de COOL \cite{cool}. Se encuentra definida en \texttt{src/utils/COOL\_Grammar.py} y su estructura se presenta a continuaci\'on:\\
@@ -139,7 +139,7 @@ \section{Gram\'atica y AST de COOL}
 &\rightarrow \textit{expr , non-empty-arg-list}\\
 \end{align*}
 
-El \'arbol de sint\'axis abstracta de COOL se encuentra definido en \texttt{src/utils/ast/AST\_Nodes.py}. Se defini\'o teniendo en cuenta la gram\'atica que definimos anteriormente. Esta gram\'atica es atributada y cada producci\'on contiene como computar cada uno de los atributos que la conforman que, en la mayor\'ia de los casos son argumentos que se pasan como par\'ametros para la creaci\'on de los nodos del ast de nuestro lenguaje.\\\\
+El \'arbol de sint\'axis abstracta de COOL se encuentra definido en \texttt{src/utils/ast/AST\_Nodes.py}. Se defini\'o teniendo en cuenta la gram\'atica que mostramos anteriormente. Esta gram\'atica es atributada y cada producci\'on contiene como computar cada uno de los atributos que la conforman que, en la mayor\'ia de los casos, son argumentos que se pasan como par\'ametros para la creaci\'on de los nodos del ast de nuestro lenguaje.\\\\
 
 
 \section{An\'alisis lexicogr\'afico.}
@@ -171,16 +171,16 @@ \section{An\'alisis Sem\'antico}
 
 
 \section{Generaci\'on de c\'odigo}
-Para la generaci\'on de c\'odigo intermedio de COOL a MIPS vamos a dise\~nar un lenguaje de m\'aquina con capacidades orientadas a objeto. Este lenguaje nos va a permitir generar c\'odigo de MIPS de forma m\'as sencilla, ya que el salto directamente desde COOL a MIPS es demasiado complejo. Este lenguaje se denomina CIL, 3-address object-oriented.
+Para la generaci\'on de c\'odigo intermedio de COOL a MIPS vamos a dise\~nar un lenguaje de m\'aquina con capacidades orientadas a objetos. Este lenguaje nos va a permitir generar c\'odigo de MIPS de forma m\'as sencilla, ya que el salto directamente desde COOL a MIPS es demasiado complejo. Este lenguaje se denomina CIL, 3-address object-oriented.
 
 En esta fase no hay incosistencia de tipos, es decir el c\'odigo de COOL est\'a lexicogr\'afica, sint\'actica y sem\'anticamente correcto, listo para la ejecuci\'on. Esta fase se encuentra implementada en \texttt{src/utils/code\_generation}
 
 \subsection{CIL}
-Como ya se dijo, primeramente, pasaremos de COOL para un lenguaje intermedio, CIL. El ast de este lenguaje se implement\'o seg\'un la definici\'on brindada en \cite{compilers} Cap\'itulo 7. Donde, adem\'as de las funciones que ah\'i se describen, se a\~naden otras para realizar la ejecuci\'on de las funciones predefinidas en COOL, y que son necesarias para el retorno de valores de m\'etodos de este lenguaje.
+Como ya se dijo, primeramente, pasaremos de COOL para un lenguaje intermedio, CIL. El ast de este lenguaje se implement\'o seg\'un la definici\'on brindada en \cite{compilers} Cap\'itulo 7, donde, adem\'as de las funciones que ah\'i se describen, se a\~naden otras para realizar la ejecuci\'on de las funciones predefinidas en COOL, y que son necesarias para el retorno de valores de m\'etodos de este lenguaje.
 
-Con ayuda del patr\'on visitor se recorre el ast de COOL y, primeramente se a\~naden todas las funciones y tipos built-in, es decir, que est\'an definidas por defecto en COOL. Posteriormente, por cada nodo del ast de COOL se crean las instrucciones correspondientes en CIL de acuerdo a su definici\'on.
+Con ayuda del patr\'on visitor se recorre el ast de COOL y, primeramente, se a\~naden todas las funciones y tipos built-in, es decir, que est\'an definidas por defecto en COOL. Posteriormente, por cada nodo del ast de COOL se crean las instrucciones correspondientes en CIL de acuerdo a su definici\'on.
 
-Contamos con una clase auxiliar, \texttt{BaseCOOLToCIL}, que contiene funciones \'utiles para el registro de par\'ametros, funciones, instrucciones, variables locales y otras declaraciones en CIL. Esta clase contiene, adem\'as, la definici\'on de los me\'etodos built-in de COOL.\\
+Contamos con una clase auxiliar, \texttt{BaseCOOLToCIL}, que contiene funciones \'utiles para el registro de par\'ametros, funciones, instrucciones, variables locales y otras declaraciones en CIL. Esta clase contiene, adem\'as, la definici\'on de los m\'etodos built-in de COOL.\\
 
 \subsection{MIPS}
 Despu\'es de tener el ast de CIL, el siguiente paso es, finalmente, generar el c\'odigo ensamblador correspondiente a la entrada de COOL. Para ello, primeramente definimos el ast de MIPS, con ayuda de \cite{mips}, en el cual cada nodo representa una instrucci\'on v\'alida en MIPS. Siguiendo la misma idea de generaci\'on de c\'odigo anterior, se recorre cada nodo del ast de CIL y se va creando el correspondiente ast v\'alido en MIPS. Una vez m\'as, los recorridos de cada ast se realizan con ayuda del patr\'on visitor, mediante el cual tambi\'en, se genera el c\'odigo ensamblador en la clase \texttt{PrintMIPS}, que tranforma cada nodo del ast en el c\'odigo de MIPS correspondiente.