class Spreadsheet:
    def __init__(self, data):
        self.data = data

    def get_cell_value(self, cell_name):
        cell_content = self.data.get(cell_name)

        if cell_content is None:
            return 0  # Or handle as an error

        try:
            # If the content is directly a number, return it
            return float(cell_content)
        except ValueError:
            # Content is not a number, so treat as a formula
            formula = cell_content
            referenced_cells = self._extract_cell_references(formula)
            cell_values = {}

            # Recursively get the values of referenced cells
            for referenced_cell in referenced_cells:
                cell_values[referenced_cell] = self.get_cell_value(referenced_cell)

            # Evaluate the formula with the cell values
            try:
                result = self._evaluate_formula(formula, cell_values)
                return result
            except Exception as evaluation_error:
                print(f"Error evaluating formula: {evaluation_error}")
                return None

    def _extract_cell_references(self, formula):
        # Simple extraction - improves with proper parsing
        return [part for part in formula.split() if part.isalpha()]

    def _evaluate_formula(self, formula, cell_values):
        # Replace cell references with their values
        for cell, value in cell_values.items():
            formula = formula.replace(cell, str(value))

        # Evaluate the expression.  Simple eval; improve with safer methods
        return eval(formula)

def two_sum_brute_force(numbers, target):
    # Go through every number and add every other number to it
    for first_index in range(len(numbers)):
        for second_index in range(first_index + 1, len(numbers)):
            if numbers[first_index] + numbers[second_index] == target:
                return [first_index, second_index]

    # If we've made it here, we couldn't find a match
    return []

class SpreadsheetCell:
    def __init__(self, content=""):
        self.content = content
        self.value = None
        self.formula = None
        self.dependencies = set()
        self.dependents = set()
        self.is_calculating = False

class Spreadsheet:
    def __init__(self, rows, cols):
        self.rows = rows
        self.cols = cols
        self.cells = [[SpreadsheetCell() for _ in range(cols)] for _ in range(rows)]

    def set_cell_content(self, row, col, content):
        cell = self.cells[row][col]
        cell.content = content
        cell.value = None
        self.update_formula(row, col, content)
        self.recalculate_dependents(row, col)

    def update_formula(self, row, col, content):
        cell = self.cells[row][col]

        # Clear old dependencies.
        for dependency_row, dependency_col in cell.dependencies:
            self.cells[dependency_row][dependency_col].dependents.remove((row, col))

        cell.dependencies = set()
        cell.formula = None

        if content.startswith("="):
            cell.formula = content[1:]
            dependencies = self.parse_formula_dependencies(cell.formula)
            cell.dependencies = dependencies

            # Update dependents of dependencies.
            for dependency_row, dependency_col in dependencies:
                self.cells[dependency_row][dependency_col].dependents.add((row, col))

    def parse_formula_dependencies(self, formula):
        dependencies = set()
        parts = formula.split("+")
        for part in parts:
            part = part.strip()
            if self.is_cell_reference(part):
                row, col = self.parse_cell_reference(part)
                dependencies.add((row, col))
        return dependencies

    def is_cell_reference(self, part):
        if len(part) < 2:
            return False
        if not part[0].isalpha() or not part[1:].isdigit():
            return False
        col_str = part[0].upper()
        row_str = part[1:]
        if not row_str.isdigit():
            return False
        row = int(row_str) - 1
        col = ord(col_str) - ord('A')
        return 0 <= row < self.rows and 0 <= col < self.cols

    def parse_cell_reference(self, reference):
        col_str = reference[0].upper()
        row_str = reference[1:]
        row = int(row_str) - 1
        col = ord(col_str) - ord('A')
        return row, col

    def get_cell_value(self, row, col):
        cell = self.cells[row][col]
        if cell.value is not None:
            return cell.value

        if cell.formula:
            return self.evaluate_formula(row, col)
        else:
            try:
                return float(cell.content)
            except ValueError:
                return cell.content

    def evaluate_formula(self, row, col):
        cell = self.cells[row][col]

        # Detect circular dependencies.
        if cell.is_calculating:
            return "#CIRCULAR"
        
        cell.is_calculating = True
        
        try:
            formula = cell.formula
            dependencies = cell.dependencies
            values = {}

            for dependency_row, dependency_col in dependencies:
                dependency_value = self.get_cell_value(dependency_row, dependency_col)

                # Non-numeric values in formula
                if isinstance(dependency_value, str):
                    values[(dependency_row, dependency_col)] = 0  # Treat as zero to proceed.
                else:
                    values[(dependency_row, dependency_col)] = dependency_value

            for dependency_row, dependency_col in dependencies:
                cell_reference = chr(dependency_col + ord('A')) + str(dependency_row + 1)
                formula = formula.replace(cell_reference, str(values[(dependency_row, dependency_col)]))

            try:
                cell.value = eval(formula)
            except (SyntaxError, NameError, TypeError, ZeroDivisionError):
                cell.value = "#ERROR"

        finally:
            cell.is_calculating = False

        return cell.value

    def recalculate_dependents(self, row, col):
        cell = self.cells[row][col]
        dependents = cell.dependents.copy()

        # Iterate over a copy to allow modification.
        for dependent_row, dependent_col in dependents:
            self.cells[dependent_row][dependent_col].value = None

            # Recalculate dependent's value
            self.get_cell_value(dependent_row, dependent_col)
            self.recalculate_dependents(dependent_row, dependent_col)

    def print_spreadsheet(self):
        for row in range(self.rows): 
            row_values = []
            for col in range(self.cols):
                row_values.append(str(self.get_cell_value(row, col)))
            print(", ".join(row_values))