n, q = map(int, input().split(' '))
graph = {}
for i in range(n):
    x, y = [int(i) for i in input().split(' ')]
    graph.setdefault(x, [])
    graph.setdefault(y, [])
    graph[x].append(y)
    graph[y].append(x)

visited = [False] * (n + 1)
parent = [None] * (n + 1)
cycle = []
is_on_cycle = [False] * (n + 1)
done = False

def compute_cycle(x):
    global done
    visited[x] = True
    for node in graph[x]:
        if done:
            return
        if parent[x] == node:
            continue
        if visited[node]:
            cycle.append(x)
            is_on_cycle[x] = True
            while x != node:
                x = parent[x]
                cycle.append(x)
                is_on_cycle[x] = True
            done = True
            return
        parent[node] = x
        compute_cycle(node)

compute_cycle(1)


position_on_cycle = [None] * (n + 1)

distance_to_cycle = [0] * (n + 1)
hits_node_in_cycle = [0] * (n + 1)

for i in range(len(cycle)):
    position_on_cycle[cycle[i]] = i

def max_distance_on_cycle(x, y):
    a = position_on_cycle[x]
    b = position_on_cycle[y]
    d = abs(a - b)
    return max(d, len(cycle) - d)

visited = [False] * (n + 1)
def compute_distance_to_cycle(cycle_node, current_node, distance):
    distance_to_cycle[current_node] = distance
    hits_node_in_cycle[current_node] = cycle_node
    visited[current_node] = True
    for node in graph[current_node]:
        if not visited[node] and not is_on_cycle[node]:
            compute_distance_to_cycle(cycle_node, node, distance + 1)


for x in cycle:
    for node in graph[x]:
        if not is_on_cycle[node]:
            compute_distance_to_cycle(x, node, 1)

def get_distance(a, b):
    if is_on_cycle[a] and is_on_cycle[b]:
        return max_distance_on_cycle(a, b)
    if hits_node_in_cycle[a] == hits_node_in_cycle[b]:
        return 'LCA'
    a_hit = a
    a_distance = 0
    if not is_on_cycle[a]:
        a_hit = hits_node_in_cycle[a]
        a_distance = distance_to_cycle[a]
    b_hit = b
    b_distance = 0
    if not is_on_cycle[b]:
        b_hit = hits_node_in_cycle[b]
        b_distance = distance_to_cycle[b]
    return a_distance + b_distance + max_distance_on_cycle(a_hit, b_hit)

for _ in range(q):
    a, b = [int(i) for i in input().split(' ')]
    print(get_distance(a, b))