         let expressionBuilder = InfixExpressionBuilder()
 
         let (numbers, _) = parseIntoNumbersAndOperators(from: expression)
+        var tokenStack = parseIntoTokens(from: expression)
         
         var numbersIndex = 0
         
-        for (index, char) in expression.unicodeScalars.enumerated() {
-            print("Char: \(char)")
-            
-            if char.isOperator() {
-                if let number = numbers[safe: numbersIndex] {
-                    _ = expressionBuilder.addOperand(operand: number)
-                    numbersIndex += 1
-                }
-                _ = expressionBuilder.addOperator(operatorType: OperatorType(rawValue: "\(char)")!)
-            }
-            if char.isParanthesis() {
-                if char == "(" {
-                    expressionBuilder.addOpenBracket()
-                    expressionBuilder.addOperand(operand: numbers[numbersIndex])
-                } else {
-                    expressionBuilder.addOperand(operand: numbers[numbersIndex])
-                    expressionBuilder.addCloseBracket()
-                }
-                numbersIndex += 1
-            }
-            if index == expression.unicodeScalars.count - 1 {
-                if let number = numbers[safe: numbersIndex] {
-                    _ = expressionBuilder.addOperand(operand: number)
-                }
-            }
-        }
+        for token in tokenStack {
+            switch token.tokenType {
+            case .openBracket:
+                expressionBuilder.addOpenBracket()
+            case .closeBracket:
+                expressionBuilder.addCloseBracket()
+            case .operand(let operand):
+                expressionBuilder.addOperand(operand: operand)
+            case .operatorToken(let operatorToken):
+                expressionBuilder.addOperator(operatorType: operatorToken.operatorType)
+            }
+        }
+//        for (index, char) in expression.unicodeScalars.enumerated() {
+//            print("Char: \(char)")
+//
+//            if char.isOperator() {
+//                if let number = numbers[safe: numbersIndex] {
+//                    _ = expressionBuilder.addOperand(operand: number)
+//                    numbersIndex += 1
+//                }
+//                _ = expressionBuilder.addOperator(operatorType: OperatorType(rawValue: "\(char)")!)
+//            }
+//
+//            if char.isParanthesis() {
+//                if char == "(" {
+//                    expressionBuilder.addOpenBracket()
+//                    expressionBuilder.addOperand(operand: numbers[numbersIndex])
+//                } else {
+//                    expressionBuilder.addOperand(operand: numbers[numbersIndex])
+//                    expressionBuilder.addCloseBracket()
+//                }
+//                numbersIndex += 1
+//            }
+//            if index == expression.unicodeScalars.count - 1 {
+//                if let number = numbers[safe: numbersIndex] {
+//                    _ = expressionBuilder.addOperand(operand: number)
+//                }
+//            }
+//        }
         
         print("Expression: \(expressionBuilder.build())")
         let (RPN, tokens) = reversePolishNotation(expression: expressionBuilder.build())

            return nil
        }
    }

    private func parseIntoNumbersAndOperators(from string: String) -> ([Double], [OperatorType]) {
        var numbers: [Double] = []
        var operators: [OperatorType] = []

        var stack = Stack<Token>()

        var tokenCounter = 0
        
        for token in tokens {
            if token.isOperand { stack.push(token) }
            else {
