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

def print_binary_tree_brute_force(root):
    if not root:
        return

    # Determine tree height for grid size
    tree_height = get_tree_height(root)
    grid_width = 2**(tree_height - 1) * 2 - 1
    grid_height = tree_height

    # Initialize the grid with empty strings
    grid = [['' for _ in range(grid_width)] for _ in range(grid_height)]

    all_arrangements = []
    
    def explore_arrangements(node, row, col, current_arrangement):
        if not node:
            return

        # Try placing the node at the current position
        current_arrangement[row][col] = str(node.value)

        #Explore subtrees
        left_col = col - 2**(tree_height - row - 2) if node.left else None
        right_col = col + 2**(tree_height - row - 2) if node.right else None

        if node.left:
            explore_arrangements(node.left, row + 1, left_col, current_arrangement)
        if node.right:
            explore_arrangements(node.right, row + 1, right_col, current_arrangement)

    def is_valid(arrangement):
        # Check for overlaps in arrangement
        for row in arrangement:
            last_col = -1
            for col_index, cell in enumerate(row):
                if cell:
                    if last_col != -1 and col_index - last_col < 2:
                        return False
                    last_col = col_index
        return True

    def generate_arrangements(node, row):
        if not node:
            return []

        valid_arrangements = []
        for col in range(grid_width):
            new_grid = [['' for _ in range(grid_width)] for _ in range(grid_height)]
            explore_arrangements(node, row, col, new_grid)
            if is_valid(new_grid):
                valid_arrangements.append(new_grid)

        return valid_arrangements

    # Generate all possible valid arrangements
    all_arrangements = generate_arrangements(root, 0)

    # Pick the 'best' arrangement
    best_arrangement = None
    if all_arrangements:
        best_arrangement = all_arrangements[0]

    # Print the 'best' arrangement
    if best_arrangement:
        for row in best_arrangement:
            print(''.join(['{:3}'.format(cell) for cell in row]))
    else:
        print("No valid arrangement found.")

def get_tree_height(node):
    if not node:
        return 0
    return 1 + max(get_tree_height(node.left), get_tree_height(node.right))

def print_binary_tree(root):
    def get_tree_height(node):
        if not node:
            return 0
        return 1 + max(get_tree_height(node.left), get_tree_height(node.right))

    def get_tree_width(height):
        return 2**height - 1

    height_of_tree = get_tree_height(root)

    width_of_tree = get_tree_width(height_of_tree)

    tree_grid = [[''] * width_of_tree for _ in range(height_of_tree)]

    def populate_grid(node, row, left, right):
        if not node:
            return

        mid = (left + right) // 2
        tree_grid[row][mid] = str(node.val)

        # Recursively populate the left subtree.

        populate_grid(node.left, row + 1, left, mid - 1)

        # Recursively populate the right subtree.

        populate_grid(node.right, row + 1, mid + 1, right)

    # Populate the grid starting from the root.
    populate_grid(root, 0, 0, width_of_tree - 1)

    for row in tree_grid:
        print(''.join(row))

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right