# строим граф из входных данных
def solve_graph(input_list):
    vertices_number = input_list[0][0]
    root_id = input_list[0][1]
    edges_number = vertices_number - 1

    vertices = []
    for i in range(0, vertices_number):
        vertices.append({ 'id': i, 'left': None, 'right': None })

    root_vertice = vertices[root_id]

    edges = []
    for i in range(1, edges_number + 1):
        edges.append(input_list[i])

    # распихаем потомков по слотам
    def arrange_children(vertice, vertice_parent_id):
        vertice_id = vertice['id']

        # добавляем потомка в незанятый слот
        def add_child(vertice, child):
            if vertice['left'] == None:
                vertice['left'] = child
            else:
                vertice['right'] = child

        for edge in edges:
            if edge[0] == vertice_id and edge[1] != vertice_parent_id:
                add_child(vertice, vertices[edge[1]])
            elif edge[1] == vertice_id and edge[0] != vertice_parent_id:
                add_child(vertice, vertices[edge[0]])

        if vertice['left'] != None:
            arrange_children(vertice['left'], vertice_id)
        if vertice['right'] != None:
            arrange_children(vertice['right'], vertice_id)

    arrange_children(root_vertice, -1)
    return root_vertice

# размер графа
def calculate_width(vertice):
    if vertice == None: return 0
    return 1 + calculate_width(vertice['left']) + calculate_width(vertice['right'])

def calculate_height(vertice):
    if vertice == None: return 0
    return 1 + max(calculate_height(vertice['left']), calculate_height(vertice['right']))

def calculate_size(vertice):
    return calculate_width(vertice), calculate_height(vertice)

# рекурсивный расчёт координат вершин
def calculate_positions(vertice, offset_x = 0, offset_y = -1):
    if vertice == None: return

    # зачем-то ось Y направлена вверх, «против» графа, так что начнём отсчёт с
    # высоты и пойдём наверх
    if offset_y == -1: offset_y = calculate_height(vertice) - 1

    vertice['x'] = offset_x + calculate_width(vertice['left'])
    vertice['y'] = offset_y

    calculate_positions(vertice['left'], offset_x, offset_y - 1)
    calculate_positions(vertice['right'], vertice['x'] + 1, offset_y - 1)

# красивенький вывод
def print_in_order(vertice):
    # если координаты ещё не были рассчитаны, рассчитаем
    if not 'x' in vertice: calculate_positions(vertice)

    # размер графа
    height = calculate_height(vertice)
    width = calculate_width(vertice)

    # создаём поле из «-1» размером с граф
    field = [ [ -1 for x in range(0, width) ] for x in
            list(range(0, calculate_height(vertice))) ]

    # рекурсивно отмечаем вершину на поле
    def mark_vertice(vertice):
        if vertice == None: return

        # опять же, переворачиваем ось Y
        field[height - 1 - vertice['y']][vertice['x']] = vertice['id']
        mark_vertice(vertice['left'])
        mark_vertice(vertice['right'])

    mark_vertice(vertice)

    # выводим поле (с пробелами вместо «-1»)
    print('\n'.join(''.join(
            ' ' if x == -1 else str(x) for x in y) for y in field))

# получаем координаты вершины
def get_position_of(vertice, id):
    if vertice == None: return None

    # если координаты ещё не были рассчитаны, рассчитаем
    if not 'x' in vertice: calculate_positions(vertice)

    if vertice['id'] == id: return vertice['x'], vertice['y']
    return get_position_of(vertice['left'], id) or get_position_of(vertice['right'], id)

root_vertice = solve_graph([
    [ 10, 5, 3 ],
    [ 2, 4 ],
    [ 4, 1 ],
    [ 0, 6 ],
    [ 7, 6 ],
    [ 8, 9 ],
    [ 4, 5 ],
    [ 6, 3 ],
    [ 3, 5 ],
    [ 3, 8 ]
])

print_in_order(root_vertice)
print(get_position_of(root_vertice, 1))
print(get_position_of(root_vertice, 3))
print(get_position_of(root_vertice, 9))