class ExpressionTree:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

    def evaluate(self):
        if isinstance(self.value, int):
            return self.value
        
        left_result = self.left.evaluate()
        right_result = self.right.evaluate()

        if self.value == '+':
            return left_result + right_result
        elif self.value == '-':
            return left_result - right_result
        elif self.value == '*':
            return left_result * right_result
        elif self.value == '/':
            if right_result == 0:
                return float('inf')
            return left_result / right_result

        return 0

def generate_trees(tokens):
    if not tokens:
        return []

    trees = []
    for i in range(len(tokens)):
        token = tokens[i]
        # If the token is an operator, we can build a tree with it as the root
        if token in ['+', '-', '*', '/']:
            left_subtrees = generate_trees(tokens[:i])
            right_subtrees = generate_trees(tokens[i+1:])

            # Combine all possible left and right subtrees to create new trees
            for left_subtree in left_subtrees:
                for right_subtree in right_subtrees:
                    tree = ExpressionTree(token, left_subtree, right_subtree)
                    trees.append(tree)

        # If the token is a number, create a leaf node tree
        else:
            try:
                number = int(token)
                trees.append(ExpressionTree(number))
            except ValueError:
                pass

    return trees

def evaluate_expression_brute_force(expression):
    tokens = expression.split()
    all_possible_trees = generate_trees(tokens)
    results = []

    #Evaluate all the possible trees
    for tree in all_possible_trees:
        results.append(tree.evaluate())

    # Return all results, which is necessary given the prompt
    return results

#Example usage
#expression = "3 + 2 * 5"
#results = evaluate_expression_brute_force(expression)
#print(results)

class ExpressionTreeNode:
    def __init__(self, value):
        self.value = value
        self.left_child = None
        self.right_child = None

    def evaluate(self):
        raise NotImplementedError

class NumberNode(ExpressionTreeNode):
    def __init__(self, value):
        super().__init__(value)

    def evaluate(self):
        return self.value

class OperationNode(ExpressionTreeNode):
    def __init__(self, value):
        super().__init__(value)

class AdditionNode(OperationNode):
    def __init__(self):
        super().__init__("+")

    def evaluate(self):
        # Recursively evaluate children and return the sum.
        return self.left_child.evaluate() + self.right_child.evaluate()

class SubtractionNode(OperationNode):
    def __init__(self):
        super().__init__("-")

    def evaluate(self):
        # Recursively evaluate children and return the difference.
        return self.left_child.evaluate() - self.right_child.evaluate()

class MultiplicationNode(OperationNode):
    def __init__(self):
        super().__init__("*")

    def evaluate(self):
        return self.left_child.evaluate() * self.right_child.evaluate()

class DivisionNode(OperationNode):
    def __init__(self):
        super().__init__("/")

    def evaluate(self):
        return self.left_child.evaluate() / self.right_child.evaluate()

# Example Usage:
if __name__ == '__main__':
    # Create nodes.
    number_five = NumberNode(5)
    number_ten = NumberNode(10)

    addition_operation = AdditionNode()
    addition_operation.left_child = number_five
    addition_operation.right_child = number_ten

    multiplication_operation = MultiplicationNode()
    multiplication_operation.left_child = addition_operation
    number_two = NumberNode(2)
    multiplication_operation.right_child = number_two

    # Evaluate the expression tree.
    result = multiplication_operation.evaluate()
    print(f"The result of the expression is: {result}")

    subtraction_operation = SubtractionNode()
    subtraction_operation.left_child = number_ten
    subtraction_operation.right_child = number_five

    division_operation = DivisionNode()
    division_operation.left_child = number_ten
    division_operation.right_child = number_two

    # Recursively calculate result
    division_result = division_operation.evaluate()
    print(f"The result of the division is: {division_result}")

    subtraction_result = subtraction_operation.evaluate()
    print(f"The result of the subtraction is: {subtraction_result}")