class TreeNode:
    def __init__(self, k):
        self.key = k
        self.left = None
        self.right = None
        self._x = 0
        self._y = 0

    def __str__(self):
        return str(self.key)
    __repr__ = __str__

    def insert(self, k):
        if self.key > k:
            if self.left is None:
                self.left = TreeNode(k)
            else:
                self.left.insert(k)
        elif self.key <= k:
            if self.right is None:
                self.right = TreeNode(k)
            else:
                self.right.insert(k)

class Tree:
    def __init__(self):
        self.root = None

    def insert(self, k):
        if self.root is None:
            self.root = TreeNode(k)
        else:
            self.root.insert(k)

    def from_list(self, keys):
        [self.insert(k) for k in keys]

    def nodes_layout(self, root, depth=0, counter=1):
        res = []
        if root.left:
            res, counter = self.nodes_layout(root.left, depth+1, counter)
        root._x = counter
        root._y = depth
        res.append(root)
        counter += len(str(root))
        if root.right:
            r, counter = self.nodes_layout(root.right, depth+1, counter)
            res += r
        return (res, counter)

    def pretty_print(self):
        nodes_list = self.nodes_layout(self.root)[0]
        nodes_list.sort(key=lambda node:node._y, reverse=True)

        levels_list = [""]
        branches = ""
        left = True
        current_level = nodes_list[0]._y
        previous_x = 0
        previous_len = 0
        branch_offset = 0

        for node in nodes_list:

            if node._y != current_level:
                levels_list.append(branches)
                levels_list.append("")
                previous_x = 0
                previous_len = 0
                branch_offset = 0
                current_level -= 1
                branches = ""

            label = str(node)
            current_len = len(str(node))
            current_dist = node._x - previous_x - previous_len
            branch_dist = current_dist + len(str(node)) // 2 + branch_offset

            previous_x = node._x
            previous_len = current_len
            branch_offset = current_len // 2
            if current_len % 2 == 0:
                branch_offset -= 1

            if node.left and node.right:
                left_under = node._x - node.left._x - len(str(node.left)) // 2 - 1
                right_under = node.right._x + len(str(node.right)) // 2 - node._x - current_len
                if len(str(node.right)) == 2:
                    right_under -= 1
                label = "_" * left_under + label + "_" * right_under
                current_dist -= left_under
                previous_len += right_under
                branch_offset += right_under

            if left:
                branches += " " * branch_dist + "/"
                left = False
            else:
                if current_len == 2:
                    branch_dist -= 1
                branches += " " * branch_dist + "\\"
                left = True

            levels_list[-1] += " " * current_dist + label

        levels_list = levels_list[::-1]
        print("\n".join(levels_list))

keys = [8,4,10,2,6,9,11,5,7]
tree = Tree()
tree.from_list(keys)
tree.pretty_print()