diff --git a/old/src/Basic.py b/old/src/Basic.py
deleted file mode 100644
index 9745710..0000000
--- a/old/src/Basic.py
+++ /dev/null
@@ -1,223 +0,0 @@
-from sly import Lexer
-from sly import Parser
-
-
-class BasicLexer(Lexer):
-    tokens = {NAME, NUMBER, STRING, IF, THEN, ELSE, FOR, FUN, TO, ARROW, EQEQ}
-    ignore = '\t '
-
-    literals = {'=', '+', '-', '/', '*', '(', ')', ',', ';'}
-
-    # Define tokens
-    IF = r'IF'
-    THEN = r'THEN'
-    ELSE = r'ELSE'
-    FOR = r'FOR'
-    FUN = r'FUN'
-    TO = r'TO'
-    ARROW = r'->'
-    NAME = r'[a-zA-Z_][a-zA-Z0-9_]*'
-    STRING = r'\".*?\"'
-
-    EQEQ = r'=='
-
-    @_(r'\d+')
-    def NUMBER(self, t):
-        t.value = int(t.value)
-        return t
-
-    @_(r'#.*')
-    def COMMENT(self, t):
-        pass
-
-    @_(r'\n+')
-    def newline(self, t):
-        self.lineno = t.value.count('\n')
-
-
-class BasicParser(Parser):
-    tokens = BasicLexer.tokens
-
-    precedence = (
-        ('left', '+', '-'),
-        ('left', '*', '/'),
-        ('right', 'UMINUS'),
-    )
-
-    def __init__(self):
-        self.env = {}
-
-    @_('')
-    def statement(self, p):
-        pass
-
-    @_('FOR var_assign TO expr THEN statement')
-    def statement(self, p):
-        return ('for_loop', ('for_loop_setup', p.var_assign, p.expr), p.statement)
-
-    @_('IF condition THEN statement ELSE statement')
-    def statement(self, p):
-        return ('if_stmt', p.condition, ('branch', p.statement0, p.statement1))
-
-    @_('FUN NAME "(" ")" ARROW statement')
-    def statement(self, p):
-        return ('fun_def', p.NAME, p.statement)
-
-    @_('NAME "(" ")"')
-    def statement(self, p):
-        return ('fun_call', p.NAME)
-
-    @_('expr EQEQ expr')
-    def condition(self, p):
-        return ('condition_eqeq', p.expr0, p.expr1)
-
-    @_('var_assign')
-    def statement(self, p):
-        return p.var_assign
-
-    @_('NAME "=" expr')
-    def var_assign(self, p):
-        return ('var_assign', p.NAME, p.expr)
-
-    @_('NAME "=" STRING')
-    def var_assign(self, p):
-        return ('var_assign', p.NAME, p.STRING)
-
-    @_('expr')
-    def statement(self, p):
-        return (p.expr)
-
-    @_('expr "+" expr')
-    def expr(self, p):
-        return ('add', p.expr0, p.expr1)
-
-    @_('expr "-" expr')
-    def expr(self, p):
-        return ('sub', p.expr0, p.expr1)
-
-    @_('expr "*" expr')
-    def expr(self, p):
-        return ('mul', p.expr0, p.expr1)
-
-    @_('expr "/" expr')
-    def expr(self, p):
-        return ('div', p.expr0, p.expr1)
-
-    @_('"-" expr %prec UMINUS')
-    def expr(self, p):
-        return p.expr
-
-    @_('NAME')
-    def expr(self, p):
-        return ('var', p.NAME)
-
-    @_('NUMBER')
-    def expr(self, p):
-        return ('num', p.NUMBER)
-
-
-class BasicExecute:
-
-    def __init__(self, tree, env):
-        self.env = env
-        result = self.walkTree(tree)
-        if result is not None and isinstance(result, int):
-            print(result)
-        if isinstance(result, str) and result[0] == '"':
-            print(result)
-
-    def walkTree(self, node):
-
-        if isinstance(node, int):
-            return node
-        if isinstance(node, str):
-            return node
-
-        if node is None:
-            return None
-
-        if node[0] == 'program':
-            if node[1] == None:
-                self.walkTree(node[2])
-            else:
-                self.walkTree(node[1])
-                self.walkTree(node[2])
-
-        if node[0] == 'num':
-            return node[1]
-
-        if node[0] == 'str':
-            return node[1]
-
-        if node[0] == 'if_stmt':
-            result = self.walkTree(node[1])
-            if result:
-                return self.walkTree(node[2][1])
-            return self.walkTree(node[2][2])
-
-        if node[0] == 'condition_eqeq':
-            return self.walkTree(node[1]) == self.walkTree(node[2])
-
-        if node[0] == 'fun_def':
-            self.env[node[1]] = node[2]
-
-        if node[0] == 'fun_call':
-            try:
-                return self.walkTree(self.env[node[1]])
-            except LookupError:
-                print("Undefined function '%s'" % node[1])
-                return 0
-
-        if node[0] == 'add':
-            return self.walkTree(node[1]) + self.walkTree(node[2])
-        elif node[0] == 'sub':
-            return self.walkTree(node[1]) - self.walkTree(node[2])
-        elif node[0] == 'mul':
-            return self.walkTree(node[1]) * self.walkTree(node[2])
-        elif node[0] == 'div':
-            return self.walkTree(node[1]) / self.walkTree(node[2])
-
-        if node[0] == 'var_assign':
-            self.env[node[1]] = self.walkTree(node[2])
-            return node[1]
-
-        if node[0] == 'var':
-            try:
-                return self.env[node[1]]
-            except LookupError:
-                print("Undefined variable '" + node[1] + "' found!")
-                return 0
-
-        if node[0] == 'for_loop':
-            if node[1][0] == 'for_loop_setup':
-                loop_setup = self.walkTree(node[1])
-
-                loop_count = self.env[loop_setup[0]]
-                loop_limit = loop_setup[1]
-
-                for i in range(loop_count + 1, loop_limit + 1):
-                    res = self.walkTree(node[2])
-                    if res is not None:
-                        print(res)
-                    self.env[loop_setup[0]] = i
-                del self.env[loop_setup[0]]
-
-        if node[0] == 'for_loop_setup':
-            return (self.walkTree(node[1]), self.walkTree(node[2]))
-
-
-if __name__ == '__main__':
-    lexer = BasicLexer()
-    parser = BasicParser()
-    env = {}
-    while True:
-        try:
-            text = input('basic > ')
-        except EOFError:
-            break
-        if text:
-            tokens = lexer.tokenize(text)
-            tree = parser.parse(tokens)
-            for t in tree:
-                print(t)
-            # BasicExecute(tree, env)
diff --git a/old/src/First.cc b/old/src/First.cc
deleted file mode 100644
index cac1b3e..0000000
--- a/old/src/First.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-# hi1
-// hi2
-
-public lib Main {
-    class Program {
-        var test: bool = false;
-        var test2: Program2 = empty;
-        var test3: Program2 = Test(34);
-
-        func Main(): empty {
-        #func Main {
-            var hallo: any;
-            #output('Hello');
-            #output(this.isTrue(false));
-        }
-
-        func isTrue(value: bool): bool {
-        #func isTrue {
-            #return value;
-        }
-    }
-}
\ No newline at end of file
diff --git a/old/src/Interpreter/Interpreter.py b/old/src/Interpreter/Interpreter.py
deleted file mode 100644
index ce3a1d9..0000000
--- a/old/src/Interpreter/Interpreter.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from typing import Optional
-
-from Interpreter.Validator import Validator
-from Interpreter.Lexer import Lexer
-from Interpreter.Parser import Parser
-from Interpreter.Repo import Repo
-from Interpreter.Utils import Utils
-from Models.AbstractSyntaxTree.AbstractSyntaxTree import AbstractSyntaxTree
-
-
-class Interpreter:
-
-    def __init__(self, repo: Repo, utils: Utils) -> None:
-        self.__repo = repo
-        self.__utils = utils
-        self.__lexer = Lexer(repo, utils)
-        self.__parser = Parser(repo, utils)
-        self.__validator = Validator(repo, utils)
-
-    def interpret(self, line_str: str) -> None:
-        """
-        Interprets code line
-        :param line_str:
-        :return:
-        """
-        tokens = []
-        ast: Optional[AbstractSyntaxTree] = None
-
-        if self.__repo.error is None:
-            tokens = self.__lexer.tokenize(line_str)
-
-        if self.__repo.error is None:
-            ast = self.__parser.parse(tokens)
-
-        """ print('#####\n')
-            if ast is not None:
-            for lib in ast.libraries:
-                print('lib', lib.name)
-                for cl in lib.classes:
-                    print('class', cl.name)
-                    for var in cl.variables:
-                        print('cl var', var.name)
-
-                    for func in cl.functions:
-                        print('func', func.name)
-                        for arg in func.args:
-                            print('func arg', arg.name)
-
-                        for var in func.variables:
-                            print('func var', var.name)
-
-                        for ins in func.instructions:
-                            print('ins', ins)
-        """
-
-        # if self.__repo.is_error is None:
-        # self.__validator.validate(self.__repo.AST)
diff --git a/old/src/Interpreter/Lexer.py b/old/src/Interpreter/Lexer.py
deleted file mode 100644
index 21bc554..0000000
--- a/old/src/Interpreter/Lexer.py
+++ /dev/null
@@ -1,171 +0,0 @@
-from typing import List
-
-from Interpreter.Repo import Repo
-from Interpreter.Utils import Utils
-from Models.Token.Token import Token
-from Models.Token.TokenTypes import TokenTypes, UnresolvedTokenTypes
-
-
-class Lexer:
-
-    def __init__(self, repo: Repo, utils: Utils) -> None:
-        self.__repo = repo
-        self.__utils = utils
-
-        self.__is_ml_comment = False
-
-    def __add_tok(self, tokens: List[Token], value: str, input_token_type: UnresolvedTokenTypes) -> None:
-        """
-        Creates token object
-        :param value:
-        :param input_token_type:
-        :return:
-        """
-        token_type: TokenTypes = TokenTypes.Empty
-
-        if value != '':
-            if input_token_type == UnresolvedTokenTypes.Word:
-                if value in self.__repo.keywords:
-                    token_type = TokenTypes.Keyword
-
-                elif value in self.__repo.datatypes:
-                    token_type = TokenTypes.Type
-
-                elif value in self.__repo.bool_values:
-                    token_type = TokenTypes.Bool
-
-                elif value == UnresolvedTokenTypes.Empty:
-                    token_type = TokenTypes.Empty
-
-                else:
-                    token_type = TokenTypes.Name
-
-            elif input_token_type == UnresolvedTokenTypes.Number:
-                token_type = TokenTypes.Number
-
-            elif input_token_type == UnresolvedTokenTypes.String:
-                token_type = TokenTypes.String
-
-            elif input_token_type == UnresolvedTokenTypes.Expression_Character:
-                token_type = TokenTypes.Expression_Character
-
-            elif input_token_type == UnresolvedTokenTypes.Bool_Expression_Character:
-                token_type = TokenTypes.Bool_Expression_Character
-
-            elif input_token_type == UnresolvedTokenTypes.Format_Character:
-                token_type = TokenTypes.Format_Character
-
-            tokens.append(Token(token_type, value))
-
-    def tokenize(self, line: str) -> List[Token]:
-        """
-        Creates token list from code line
-        :param line:
-        :return:
-        """
-        tokens: List[Token] = []
-        word = ''
-        ol_comment = False
-        is_string1 = False  # 'hello'
-        is_string2 = False  # "hello"
-        is_number = False
-        is_expr_char = False
-
-        for i in range(0, len(line)):
-            c = line[i]
-            # ignore comments and spaces
-            if not ol_comment and not self.__is_ml_comment:
-                # comment filtering
-                if c == '#' and not is_string1 and not is_string2:
-                    ol_comment = True
-
-                elif line[i - 1] == '/' and c == '/':
-                    ol_comment = True
-
-                elif line[i - 1] == '/' and c == '*':
-                    self.__is_ml_comment = True
-                    i += 2
-
-                # end of number
-                elif not c.isdigit() and c != '.' and is_number:
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.Number)
-                    local_tokens = self.tokenize(c)
-                    for local_token in local_tokens:
-                        tokens.append(local_token)
-
-                    word = ''
-                    is_number = False
-
-                # end of expression char
-                elif c not in self.__repo.expr_chars and is_expr_char:
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.Expression_Character)
-                    word = ''
-                    is_expr_char = False
-
-                # begin of is_string1
-                elif c == '\'' and not is_string1:
-                    is_string1 = True
-                    word = ''
-
-                # end of is_string1
-                elif c == '\'' and is_string1:
-                    is_string1 = False
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.String)
-                    word = ''
-
-                # begin of is_string2
-                elif c == '\"' and not is_string2:
-                    is_string2 = True
-                    word = ''
-
-                # end of is_string2
-                elif c == '\"' and is_string2:
-                    is_string2 = False
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.String)
-                    word = ''
-
-                # format char
-                elif c in self.__repo.format_chars:
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
-                    self.__add_tok(tokens, c, UnresolvedTokenTypes.Format_Character)
-                    word = ''
-
-                # begin of number
-                elif c.isdigit() and not is_number and word == '':
-                    word += c
-                    is_number = True
-
-                # continue number
-                elif (c.isdigit() or c == '.') and is_number:
-                    word += c
-
-                # begin expression char
-                elif c in self.__repo.expr_chars and not is_expr_char:
-                    word += c
-                    is_expr_char = True
-
-                # continue expression char
-                elif c in self.__repo.expr_chars and is_expr_char:
-                    word += c
-
-                # bool expression char
-                elif c in self.__repo.bool_expr_chars:
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
-                    self.__add_tok(tokens, c, UnresolvedTokenTypes.Bool_Expression_Character)
-                    word = ''
-
-                # end of word
-                elif c == ' ' and not is_string1 and not is_string2 or c == '\n':
-                    self.__add_tok(tokens, word, UnresolvedTokenTypes.Word)
-                    word = ''
-
-                else:
-                    word += c
-
-            if c == '\n' and ol_comment:
-                ol_comment = False
-
-            if line[i - 1] == '*' and c == '/':
-                self.__is_ml_comment = False
-
-        return tokens
diff --git a/old/src/Interpreter/Parser.py b/old/src/Interpreter/Parser.py
deleted file mode 100644
index 7c9e4bb..0000000
--- a/old/src/Interpreter/Parser.py
+++ /dev/null
@@ -1,415 +0,0 @@
-from typing import List, Optional, Union
-
-from Interpreter.Repo import Repo
-from Interpreter.Utils import Utils
-from Models.AbstractSyntaxTree.AbstractSyntaxTree import LibraryDefinitionNode, ClassDefinitionNode, AbstractSyntaxTree, \
-    FunctionDefinitionNode, VariableDefinitionNode, CallDefinitionNode, ValueNode, ASTElement
-from Models.Interpreter.Datatypes import Datatypes
-from Models.Interpreter.Error import Error, ErrorCodes
-from Models.Token.Token import Token
-from Models.Token.TokenTypes import TokenTypes
-from Models.Token.TokenValueTypes import Keywords, FormatCharacters, ExpressionCharacters
-
-
-class Parser:
-
-    def __init__(self, repo: Repo, utils: Utils) -> None:
-        self.__repo = repo
-        self.__utils = utils
-
-        self.__ast: AbstractSyntaxTree = AbstractSyntaxTree()
-        self.__saved_tokens: List[Token] = []
-        self.__expected_tokens: List[Token] = []
-
-        # for validation if type is created
-        self.__is_saving_type = False
-        self.__is_saving_value = False
-        self.__is_saving_call = False
-        self.__is_end = False
-
-        self.__saved_ast_elements: List[ASTElement] = []
-
-    def parse(self, tokens: List[Token]) -> AbstractSyntaxTree:
-        self.__is_end = False
-
-        if len(tokens) > 0:
-            toks = []
-            for tok in tokens:
-                toks.append({tok.type.name, tok.value})
-
-            print(self.__repo.line_number, toks)
-
-        for i in range(0, len(tokens)):
-            token = tokens[i]
-
-            self.__check_for_expected_tokens(token)
-
-            # keywords
-            if token.type == TokenTypes.Keyword:
-                if token.value == Keywords.Public.value:
-                    self.__saved_tokens.append(token)
-                    print('save public')
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Library.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Class.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Function.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Variable.value)
-
-                elif token.value == Keywords.Library.value:
-                    self.__saved_tokens.append(token)
-                    print('save lib')
-                    self.__add_expected_token(TokenTypes.Name)
-
-                elif token.value == Keywords.Class.value:
-                    self.__saved_tokens.append(token)
-                    print('save class')
-                    self.__add_expected_token(TokenTypes.Name)
-
-                elif token.value == Keywords.Function.value:
-                    self.__saved_tokens.append(token)
-                    print('save function')
-                    self.__add_expected_token(TokenTypes.Name)
-
-                elif token.value == Keywords.Variable.value:
-                    self.__saved_tokens.append(token)
-                    print('save var')
-                    self.__add_expected_token(TokenTypes.Name)
-
-            # names
-            elif token.type == TokenTypes.Name:
-                if self.__is_saving_variable() and self.__is_saving_value:
-                    self.__save_name(token)
-                    if self.__is_saving_variable():
-                        self.__is_saving_call = True
-
-                # names could be variable types, validation check in evaluator
-                elif self.__is_saving_variable() and self.__is_saving_type:
-                    self.__save_type(token)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
-
-                elif self.__is_saving_variable():
-                    self.__save_name(token)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Colon.value)
-
-                elif self.__is_saving_function():
-                    self.__save_name(token)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
-
-                elif self.__is_saving_library() or self.__is_saving_class():
-                    self.__save_name(token)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Brace.value)
-
-            # format chars
-            elif token.type == TokenTypes.Format_Character:
-                if token.value == FormatCharacters.Left_Brace.value:
-                    if self.__is_saving_library():
-                        self.__save_library()
-
-                    elif self.__is_saving_class():
-                        self.__save_class()
-
-                elif token.value == FormatCharacters.Colon.value:
-                    if self.__is_saving_variable():
-                        self.__is_saving_type = True
-                        self.__add_expected_token(TokenTypes.Type)
-                        self.__add_expected_token(TokenTypes.Name)
-
-                elif token.value == FormatCharacters.Semicolon.value:
-                    self.__end_line()
-
-                elif token.value == FormatCharacters.Left_Parenthesis.value:
-                    self.__add_expected_token(TokenTypes.Name)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Right_Parenthesis.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.This.value)
-                    self.__add_expected_token(TokenTypes.Name)
-                    self.__add_expected_token(TokenTypes.Empty)
-                    self.__add_expected_token(TokenTypes.Number)
-                    self.__add_expected_token(TokenTypes.String)
-                    self.__add_expected_token(TokenTypes.Bool)
-
-                    if self.__is_saving_call:
-                        self.__saved_tokens.append(token)
-
-                elif token.value == FormatCharacters.Right_Parenthesis.value:
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Colon.value)
-
-                    if self.__is_saving_call:
-                        self.__saved_tokens.append(token)
-                        self.__save_call()
-                        self.__is_saving_call = False
-
-            # expr chars
-            elif token.type == TokenTypes.Expression_Character:
-                if token.value == ExpressionCharacters.Equal.value:
-                    self.__is_saving_value = True
-                    self.__add_expected_token(TokenTypes.Bool)
-                    self.__add_expected_token(TokenTypes.Number)
-                    self.__add_expected_token(TokenTypes.String)
-                    self.__add_expected_token(TokenTypes.Empty)
-                    self.__add_expected_token(TokenTypes.Name)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.This.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Input.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Range.value)
-                    self.__add_expected_token(TokenTypes.Keyword, Keywords.Length.value)
-                    self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
-                    self.__add_expected_token(TokenTypes.Type, Datatypes.Empty.value)
-
-            # types
-            elif token.type == TokenTypes.Type:
-                if self.__is_saving_variable() and self.__is_saving_value:
-                    self.__save_value(token)
-
-                elif self.__is_saving_variable():
-                    self.__save_type(token)
-
-            # values
-            elif token.type == TokenTypes.Bool or token.type == TokenTypes.Number or token.type == TokenTypes.String:
-                if self.__is_saving_call:
-                    self.__saved_tokens.append(token)
-
-                elif self.__is_saving_value:
-                    self.__save_value(token)
-
-        return self.__ast
-
-    """
-        Utils
-    """
-
-    def __save_name(self, token: Token):
-        self.__saved_tokens.append(token)
-        print('save name')
-
-    def __add_expected_token(self, token_type: TokenTypes, value: str = ''):
-        self.__expected_tokens.append(Token(token_type, value))
-
-    def __check_for_expected_tokens(self, token: Token):
-        error_token: Optional[Token] = None
-        is_error = True
-
-        for expected_token in self.__expected_tokens:
-            if self.__is_end or token.type != expected_token.type or expected_token.value != '' and token.value != expected_token.value:
-                error_token = token
-            else:
-                is_error = False
-
-        if error_token is not None and is_error:
-            self.__utils.error(Error(ErrorCodes.Unexpected, f'{error_token.type.name} {error_token.value}'))
-
-        self.__expected_tokens = []
-
-    def __end_line(self):
-        if self.__is_saving_variable():
-            self.__save_variable()
-
-        self.__is_end = True
-        self.__expected_tokens = []
-        self.__is_saving_type = False
-        self.__is_saving_value = False
-
-    """
-        Library
-    """
-
-    def __is_saving_library(self) -> bool:
-        found = False
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Keyword and token.value == Keywords.Library.value:
-                found = True
-
-        return found
-
-    def __save_library(self) -> None:
-        is_public = False
-        name_token: Optional[Token] = None
-
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Name:
-                name_token = token
-            elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
-                is_public = True
-
-        if name_token is not None:
-            self.__ast.libraries.append(LibraryDefinitionNode(is_public, name_token.value))
-            self.__saved_tokens = []
-            self.__add_expected_token(TokenTypes.Keyword, Keywords.Public.value)
-            self.__add_expected_token(TokenTypes.Keyword, Keywords.Class.value)
-            print('saved library')
-
-    """
-        Class
-    """
-
-    def __is_saving_class(self) -> bool:
-        found = False
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Keyword and token.value == Keywords.Class.value:
-                found = True
-
-        return found
-
-    def __save_class(self) -> None:
-        is_public = False
-        name_token: Optional[Token] = None
-
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Name:
-                name_token = token
-            elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
-                is_public = True
-
-        if name_token is not None:
-            self.__ast.libraries[len(self.__ast.libraries) - 1].classes.append(ClassDefinitionNode(is_public, name_token.value))
-            self.__saved_tokens = []
-            self.__add_expected_token(TokenTypes.Keyword, Keywords.Public.value)
-            self.__add_expected_token(TokenTypes.Keyword, Keywords.Variable.value)
-            self.__add_expected_token(TokenTypes.Keyword, Keywords.Function.value)
-            print('saved class')
-
-    """
-        Call
-    """
-    def __save_call(self) -> None:
-        name_token: Optional[Token] = None
-        args: List[ValueNode] = []
-        remove_tokens = []
-        is_call = False
-
-        for i in range(0, len(self.__saved_tokens)):
-            token = self.__saved_tokens[i]
-            last_token: Optional[Token] = None
-            if i-1 > 0:
-                last_token = self.__saved_tokens[i-1]
-
-            if token.type == TokenTypes.Name and last_token is not None and last_token.type == TokenTypes.Format_Character and last_token.value == FormatCharacters.Left_Parenthesis.value:
-                pass
-
-            if token.type == TokenTypes.Format_Character and token.value == FormatCharacters.Left_Parenthesis.value and last_token is not None and last_token.type == TokenTypes.Name:
-                name_token = last_token
-                remove_tokens.append(last_token)
-                remove_tokens.append(token)
-                is_call = True
-            elif is_call and token.type == TokenTypes.Format_Character and token.value == FormatCharacters.Right_Parenthesis.value:
-                remove_tokens.append(token)
-            elif is_call and token.type == TokenTypes.Bool or token.type == TokenTypes.Number or token.type == TokenTypes.String:
-                args.append(ValueNode(token.value, Datatypes[token.type.name]))
-                remove_tokens.append(token)
-
-        if name_token is not None:
-            call = CallDefinitionNode(name_token.value)
-            call.args = args
-            self.__saved_ast_elements.append(call)
-
-            for token in remove_tokens:
-                self.__saved_tokens.remove(token)
-
-            self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
-            print('saved call')
-
-    """
-        Function
-    """
-
-    def __is_saving_function(self) -> bool:
-        found = False
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Keyword and token.value == Keywords.Function.value:
-                found = True
-
-        return found
-
-    def __save_function(self) -> None:
-        is_public = False
-        name_token: Optional[Token] = None
-        return_type: Optional[Token] = None
-
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Name:
-                name_token = token
-            elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
-                is_public = True
-            elif token.type == TokenTypes.Type:
-                return_type = token
-
-        if name_token is not None and return_type is not None:
-            self.__ast.libraries[len(self.__ast.libraries) - 1].classes[len(self.__ast.libraries) - 1].functions.append(
-                FunctionDefinitionNode(is_public, name_token.value, Datatypes[return_type.value]))
-            self.__saved_tokens = []
-            print('saved function')
-
-    """
-        Variable
-    """
-
-    def __is_saving_variable(self) -> bool:
-        found = False
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Keyword and token.value == Keywords.Variable.value:
-                found = True
-
-        return found
-
-    def __save_type(self, token: Token) -> None:
-        self.__saved_tokens.append(token)
-        self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
-        self.__add_expected_token(TokenTypes.Expression_Character, ExpressionCharacters.Equal.value)
-        self.__is_saving_type = False
-        print('save type')
-
-    def __save_variable(self):
-        is_public = False
-        name_token: Optional[Token] = None
-        datatype: Optional[Token] = None
-        value: Optional[Union[str, Token, CallDefinitionNode]] = None
-
-        reset_saved_ast = False
-
-        for token in self.__saved_tokens:
-            if token.type == TokenTypes.Name and name_token is None:
-                name_token = token
-            elif token.type == TokenTypes.Keyword and token.value == Keywords.Public.value:
-                is_public = True
-            elif token.type == TokenTypes.Type or name_token is not None and token.type == TokenTypes.Name:
-                datatype = token
-
-            value = Token(TokenTypes.Empty, TokenTypes.Empty.value)
-
-        for saved_ast_element in self.__saved_ast_elements:
-            if isinstance(saved_ast_element, CallDefinitionNode):
-                value = saved_ast_element
-                reset_saved_ast = True
-
-        if reset_saved_ast:
-            self.__saved_ast_elements = []
-
-        if name_token is not None and datatype is not None and value is not None:
-            if not isinstance(value, CallDefinitionNode):
-                value = value.value
-
-            if datatype.type == TokenTypes.Name:
-                variable = VariableDefinitionNode(is_public, name_token.value, datatype.value, value)
-            else:
-                variable = VariableDefinitionNode(is_public, name_token.value, Datatypes[str(datatype.value).capitalize()], value)
-
-            if len(self.__ast.libraries) > 0:
-                lib = self.__ast.libraries[len(self.__ast.libraries) - 1]
-                if len(lib.classes) > 0:
-                    cl = lib.classes[len(lib.classes) - 1]
-                    if len(cl.functions) == 0:
-                        cl.variables.append(variable)
-                    else:
-                        cl.functions[len(cl.functions) - 1].variables.append(variable)
-
-                    self.__saved_tokens = []
-                    print('saved variable')
-
-    """
-        Value
-    """
-
-    def __save_value(self, token: Token):
-        self.__saved_tokens.append(token)
-        self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Left_Parenthesis.value)
-        self.__add_expected_token(TokenTypes.Format_Character, FormatCharacters.Semicolon.value)
-        self.__is_saving_value = False
-        print('save value')
diff --git a/old/src/Interpreter/Repo.py b/old/src/Interpreter/Repo.py
deleted file mode 100644
index 0e2b83c..0000000
--- a/old/src/Interpreter/Repo.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from Models.Interpreter.Datatypes import Datatypes
-from Models.Token.TokenValueTypes import FormatCharacters, Booleans, Keywords, ExpressionCharacters
-
-
-class Repo:
-
-    def __init__(self) -> None:
-        self.debug = True
-        self.line_number: int = 0
-
-        # interpreter
-        self.keywords = [
-            # define keywords
-            Keywords.Library.value,
-            Keywords.Class.value,
-            Keywords.Function.value,
-            Keywords.Variable.value,
-            Keywords.Use.value,
-            Keywords.From.value,
-            # builtin functions
-            Keywords.Output.value,
-            Keywords.Input.value,
-            Keywords.Length.value,
-            Keywords.Range.value,
-            Keywords.Exit.value,
-            # normal keywords
-            Keywords.If.value,
-            Keywords.ElseIf.value,
-            Keywords.Else.value,
-            Keywords.Continue.value,
-            Keywords.If.value,
-            Keywords.Return.value,
-            # loops
-            Keywords.While.value,
-            Keywords.For.value,
-            # access
-            Keywords.Public.value,
-            Keywords.This.value
-        ]
-        self.datatypes = [
-            Datatypes.Empty.value,
-            Datatypes.Any.value,
-            Datatypes.Number.value,
-            Datatypes.String.value,
-            Datatypes.Bool.value,
-            Datatypes.List.value,
-            Datatypes.Dict.value
-        ]
-        self.format_chars = [
-            FormatCharacters.Left_Brace.value,
-            FormatCharacters.Right_Brace.value,
-            FormatCharacters.Left_Parenthesis.value,
-            FormatCharacters.Right_Parenthesis.value,
-            FormatCharacters.Left_Bracket.value,
-            FormatCharacters.Right_Bracket.value,
-            FormatCharacters.Semicolon.value,
-            FormatCharacters.Colon.value,
-            FormatCharacters.Comma.value,
-            FormatCharacters.Point.value
-        ]
-        self.expr_chars = [
-            ExpressionCharacters.Plus.value,
-            ExpressionCharacters.Minus.value,
-            ExpressionCharacters.Asterisk.value,
-            ExpressionCharacters.Slash.value,
-            ExpressionCharacters.Equal.value,
-            ExpressionCharacters.Caret.value
-        ]
-        self.bool_expr_chars = ['<', '>', '!', '!=', '==', '>=', '<=', '&&', '||']
-        self.bool_values = [Booleans.Right.value, Booleans.Wrong.value]
-
-        # runtime
-        self.error = None
diff --git a/old/src/Interpreter/Utils.py b/old/src/Interpreter/Utils.py
deleted file mode 100644
index 2697291..0000000
--- a/old/src/Interpreter/Utils.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from termcolor import colored
-
-from Interpreter.Repo import Repo
-from Models.Interpreter.Error import Error
-
-
-class Utils:
-
-    def __init__(self, repo: Repo) -> None:
-        self.__repo = repo
-
-    def input(self, prefix: str) -> str:
-        return input(prefix)
-
-    def output(self, text: str) -> None:
-        print(f'-> {text}')
-
-    def error(self, error: Error) -> None:
-        self.__repo.error = error
-        print(colored(f'Error in line {self.__repo.line_number}\n{self.__repo.error.msg}', 'red'))
-        # exit()
-
-    def runtime_error(self, error: Error) -> None:
-        self.__repo.error = error
-        print(colored(f'{self.__repo.error.msg}', 'red'))
-        # exit()
diff --git a/old/src/Interpreter/Validator.py b/old/src/Interpreter/Validator.py
deleted file mode 100644
index cd798f4..0000000
--- a/old/src/Interpreter/Validator.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from Interpreter.Repo import Repo
-from Interpreter.Utils import Utils
-
-
-class Validator:
-
-    def __init__(self, repo: Repo, utils: Utils) -> None:
-        self.__repo = repo
-        self.__utils = utils
-
-    def validate(self, ast: []) -> None:
-        pass
diff --git a/old/src/Interpreter/__init__.py b/old/src/Interpreter/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/old/src/Models/AbstractSyntaxTree/AbstractSyntaxTree.py b/old/src/Models/AbstractSyntaxTree/AbstractSyntaxTree.py
deleted file mode 100644
index a3ce81c..0000000
--- a/old/src/Models/AbstractSyntaxTree/AbstractSyntaxTree.py
+++ /dev/null
@@ -1,92 +0,0 @@
-from typing import List, Union
-
-from Models.Interpreter.Datatypes import Datatypes
-from Models.Token.TokenValueTypes import ExpressionCharacters
-
-
-class AbstractSyntaxTree:
-
-    def __init__(self):
-        self.libraries: List[LibraryDefinitionNode] = []
-
-
-class ASTElement:
-
-    def __init__(self):
-        pass
-
-
-class ValueNode(ASTElement):
-    def __init__(self, value: str, datatype: Datatypes):
-        super().__init__()
-        self.value = value
-        self.type = datatype
-
-
-class BinaryOperationNode(ASTElement):
-    def __init__(self, left: str, op_token: str, right: str):
-        super().__init__()
-        self.left = left
-        self.op_token = op_token
-        self.right = right
-
-        self.operation_chars = [
-            ExpressionCharacters.Plus.value,
-            ExpressionCharacters.Minus.value,
-            ExpressionCharacters.Asterisk.value,
-            ExpressionCharacters.Slash.value,
-            ExpressionCharacters.Caret.value
-        ]
-
-    def eval(self):
-        if self.op_token in self.operation_chars:
-            return eval(f'{self.left} {self.op_token} {self.right}')
-
-
-class LibraryDefinitionNode(ASTElement):
-
-    def __init__(self, is_public: bool, name: str):
-        super().__init__()
-        self.is_public = is_public
-        self.name = name
-        self.classes: List[ClassDefinitionNode] = []
-
-
-class ClassDefinitionNode(ASTElement):
-
-    def __init__(self, is_public: bool, name: str):
-        super().__init__()
-        self.is_public = is_public
-        self.name = name
-        self.variables: [VariableDefinitionNode] = []
-        self.functions: List[FunctionDefinitionNode] = []
-
-
-class CallDefinitionNode(ASTElement):
-
-    def __init__(self, name: str):
-        super().__init__()
-        self.name = name
-        self.args: List[ValueNode] = []
-
-
-class FunctionDefinitionNode(ASTElement):
-
-    def __init__(self, is_public: bool, name: str, return_type: Datatypes):
-        super().__init__()
-        self.is_public = is_public
-        self.name = name
-        self.args: List[VariableDefinitionNode] = []
-        self.return_type = return_type
-        self.variables: [VariableDefinitionNode] = []
-        self.instructions: List[ASTElement] = []
-
-
-class VariableDefinitionNode(ASTElement):
-
-    def __init__(self, is_public: bool, name: str, datatype: Union[str, Datatypes], value: Union[str, CallDefinitionNode]):
-        super().__init__()
-        self.is_public = is_public
-        self.name = name
-        self.datatype = datatype
-        self.value = value
diff --git a/old/src/Models/AbstractSyntaxTree/__init__.py b/old/src/Models/AbstractSyntaxTree/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/old/src/Models/CCLang/TokenDefinition.py b/old/src/Models/CCLang/TokenDefinition.py
deleted file mode 100644
index 73ec004..0000000
--- a/old/src/Models/CCLang/TokenDefinition.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from enum import Enum
-
-
-class TokenDefinition(Enum):
-    """ Keywords """
-    # define keywords
-    Library = r'lib'
-    Class = r'class'
-    Function = r'func'
-    Variable = r'var'
-    Use = r'use'
-    From = r'from'
-    As = r'as'
-
-    # builtin functions
-    Output = r'output'
-    Input = r'input'
-    Length = r'length'
-    Range = r'range'
-    Round = r'round'
-    Exit = r'exit'
-
-    # normal keywords
-    If = r'if'
-    ElseIf = r'elseif'
-    Else = r'else'
-    Continue = r'continue'
-    Return = r'return'
-
-    # loops
-    While = r'while'
-    For = r'for'
-    In = r'in'
-
-    # access
-    Public = r'public'
-    This = r'this'
-
-    """ Chars """
-    # format
-    LeftBrace = r'\{'
-    RightBrace = r'\}'
-    LeftParenthesis = r'\('
-    RightParenthesis = r'\)'
-    LeftBracket = r'\['
-    RightBracket = r'\]'
-    Semicolon = r'\;'
-    Colon = r'\:'
-    Comma = r'\,'
-    Point = r'\.'
-    # expr
-    Plus = r'\+'
-    Minus = r'\-'
-    Asterisk = r'\*'
-    Slash = r'\/'
-    Equal = r'\='
-    Caret = r'\^'
-
-    """ Values """
-    ValueString = r'\".*?\"'
-    ValueNumber = r'\d+'
-
-    # bool
-    BoolTrue = r'true'
-    BoolFalse = r'false'
-
-    """ Datatypes """
-    Empty = r'empty'
-    Number = r'Number'
-    String = r'string'
-    Bool = r'bool'
-    List = r'list'
-    Dict = r'dict'
-    Void = r'void'
-
-    """ other """
-    Name = r'[a-zA-Z_][a-zA-Z0-9_]*'
diff --git a/old/src/Models/CCLang/__init__.py b/old/src/Models/CCLang/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/old/src/Models/Interpreter/Datatypes.py b/old/src/Models/Interpreter/Datatypes.py
deleted file mode 100644
index 65177be..0000000
--- a/old/src/Models/Interpreter/Datatypes.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from enum import Enum
-
-
-class Datatypes(Enum):
-
-    Empty = 'empty'
-    Any = 'any'
-    Number = 'number'
-    String = 'string'
-    Bool = 'bool'
-    List = 'list'
-    Dict = 'dict'
diff --git a/old/src/Models/Interpreter/Error.py b/old/src/Models/Interpreter/Error.py
deleted file mode 100644
index b72ee8b..0000000
--- a/old/src/Models/Interpreter/Error.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from enum import Enum
-
-
-class ErrorCodes(Enum):
-    StartFailed = 'Start failed'
-    FileNotFound = 'File not found'
-    WrongFileType = 'Wrong file type'
-
-    Unknown = 'Unknown {}'
-    Inaccessible = '{} inaccessible'
-    Unexpected = 'Unexpected {}'
-    Expected = 'Expected {}'
-
-    LibInLib = 'Lib in lib'
-    LibInClass = 'Lib in class'
-    LibInFunc = 'Lib in func'
-    ClassInClass = 'Class in class'
-    ClassInFunc = 'Class in func'
-    FuncInLib = 'Func in lib'
-    FuncInFunc = 'Func in func'
-
-
-class Error:
-
-    def __init__(self, code: ErrorCodes, msg: str = '') -> None:
-        self.code = code
-
-        self.msg = code.value.format(msg)
diff --git a/old/src/Models/Interpreter/__init__.py b/old/src/Models/Interpreter/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/old/src/Models/Token/Token.py b/old/src/Models/Token/Token.py
deleted file mode 100644
index 54e18e0..0000000
--- a/old/src/Models/Token/Token.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from Models.Token import TokenTypes
-
-
-class Token:
-
-    def __init__(self, token_type: TokenTypes, value: str) -> None:
-        self.type: TokenTypes = token_type
-        self.value: str = value
diff --git a/old/src/Models/Token/TokenTypes.py b/old/src/Models/Token/TokenTypes.py
deleted file mode 100644
index 94580b1..0000000
--- a/old/src/Models/Token/TokenTypes.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from enum import Enum
-
-
-class TokenTypes(Enum):
-    Empty = 0
-    Keyword = 1
-    Type = 2
-    Name = 3
-    Bool = 4
-    String = 5
-    Number = 6
-    Expression_Character = 7
-    Bool_Expression_Character = 8
-    Format_Character = 9
-
-
-class UnresolvedTokenTypes(Enum):
-    Empty = 0
-    Word = 1
-    Number = 2
-    String = 3
-    Expression_Character = 4
-    Bool_Expression_Character = 5
-    Format_Character = 6
diff --git a/old/src/Models/Token/TokenValueTypes.py b/old/src/Models/Token/TokenValueTypes.py
deleted file mode 100644
index 70dc45b..0000000
--- a/old/src/Models/Token/TokenValueTypes.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from enum import Enum
-
-
-class Keywords(Enum):
-    # define keywords
-    Library = 'lib'
-    Class = 'class'
-    Function = 'func'
-    Variable = 'var'
-    Use = 'use'
-    From = 'from'
-
-    # builtin functions
-    Output = 'output'
-    Input = 'input'
-    Length = 'length'
-    Range = 'range'
-    Exit = 'exit'
-
-    # normal keywords
-    If = 'if'
-    ElseIf = 'elseif'
-    Else = 'else'
-    Continue = 'continue'
-    In = 'in'
-    Return = 'return'
-
-    # loops
-    While = 'while'
-    For = 'for'
-
-    # access
-    Public = 'public'
-    This = 'this'
-
-
-class Booleans(Enum):
-    Right = 'true'
-    Wrong = 'false'
-
-
-class ExpressionCharacters(Enum):
-    Plus = '+'
-    Minus = '-'
-    Asterisk = '*'
-    Slash = '/'
-    Equal = '='
-    Caret = '^'
-
-
-class FormatCharacters(Enum):
-    Left_Brace = '{'
-    Right_Brace = '}'
-    Left_Parenthesis = '('
-    Right_Parenthesis = ')'
-    Left_Bracket = '['
-    Right_Bracket = ']'
-    Semicolon = ';'
-    Colon = ':'
-    Comma = ','
-    Point = '.'
-
diff --git a/old/src/Models/Token/__init__.py b/old/src/Models/Token/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/old/src/Models/__init__.py b/old/src/Models/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/old/src/ServiceInitializer.py b/old/src/ServiceInitializer.py
deleted file mode 100644
index becc5ff..0000000
--- a/old/src/ServiceInitializer.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from Interpreter.Interpreter import Interpreter
-# from CCLang_sly.Interpreter import Interpreter as SlyCCLangInterpreter
-from Interpreter.Utils import Utils
-from Interpreter.Repo import Repo
-
-
-class ServiceInitializer:
-
-    def __init__(self) -> None:
-        self.repo = Repo()
-        self.utils = Utils(self.repo)
-        self.interpreter = Interpreter(self.repo, self.utils)
-        # self.sly_cclang_interpreter = SlyCCLangInterpreter(self.repo, self.utils)
diff --git a/old/src/cclang.py b/old/src/cclang.py
deleted file mode 100644
index 5baf30f..0000000
--- a/old/src/cclang.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import os
-import sys
-
-from Models.Interpreter.Error import Error, ErrorCodes
-from ServiceInitializer import ServiceInitializer
-
-
-class Main:
-
-    def __init__(self) -> None:
-        self.__services = ServiceInitializer()
-        self.__utils = self.__services.utils
-        self.__repo = self.__services.repo
-        self.__interpreter = self.__services.interpreter
-
-    def console(self) -> None:
-        """
-        Getting code from console input
-        :return:
-        """
-        i = 0
-        while self.__repo.error is None:
-            self.__repo.line_number = i + 1
-            self.__interpreter.interpret(input('> '))
-            i += 1
-
-    def files(self, file: str) -> None:
-        """
-        Getting input from file
-        :param file:
-        :return:
-        """
-        if not os.path.isfile(file):
-            self.__utils.runtime_error(Error(ErrorCodes.FileNotFound))
-            return
-
-        if not file.endswith('.ccl'):
-            self.__utils.runtime_error(Error(ErrorCodes.WrongFileType))
-            return
-
-        f = open(file, 'r', encoding='utf-8').readlines()
-        for i in range(0, len(f)):
-            self.__repo.line_number = i + 1
-            self.__interpreter.interpret(f[i])
-
-
-if __name__ == '__main__':
-    main = Main()
-    print(sys.argv)
-    if len(sys.argv) == 2:
-        main.files(sys.argv[1])
-    else:
-        main.console()
diff --git a/old/src/test.cc b/old/src/test.cc
deleted file mode 100644
index e478a04..0000000
--- a/old/src/test.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-# olc test 1
-// olc test 2
-/* mlc Test 1 */
-/*
-    mlc Test 2
-*/
-
-
-public lib Main {
-    class Program {
-        var test: bool = false;
-        var test2: Program2 = empty;
-        var test3: Program2 = Test(34);
-
-        func Main(): void {
-        #func Main {
-            var hallo: any;
-            #output('Hello');
-            #output(this.isTrue(false));
-        }
-
-        func isTrue(value: bool): bool {
-        #func isTrue {
-            #return value;
-        }
-    }
-}
\ No newline at end of file
diff --git a/old/src/test.py b/old/src/test.py
deleted file mode 100644
index 3f3e514..0000000
--- a/old/src/test.py
+++ /dev/null
@@ -1,3 +0,0 @@
-test = 3 ** 2
-print(test)
-print(eval('3**2'))
\ No newline at end of file