import sys


class DSU:
    def __init__(self, n):
        self.dsu = [-1] * n

    def find(self, u):
        if self.dsu[u] < 0:
            return u
        self.dsu[u] = self.find(self.dsu[u])
        return self.dsu[u]

    def merge(self, u, v):
        u, v = self.find(u), self.find(v)
        if u == v:
            return
        if self.dsu[u] > self.dsu[v]:
            u, v = v, u
        self.dsu[u] += self.dsu[v]
        self.dsu[v] = u


def main():
    n, q = map(int, input().split())
    graph = [[] for _ in range(n)]
    ds = DSU(n)
    for i in range(n - 3):
        x, y = map(int, input().split())
        graph[x - 1].append(y - 1)
        graph[y - 1].append(x - 1)
        ds.merge(x - 1, y - 1)
    up, down = [0] * n, [0] * n
    roots = []

    def dfs1(curr, par):
        for neighbor in graph[curr]:
            if neighbor == par:
                continue
            dfs1(neighbor, curr)
            down[curr] = max(down[curr], down[neighbor] + 1)

    def dfs2(curr, par):
        candidates = []
        for neighbor in graph[curr]:
            if neighbor == par:
                continue
            up[neighbor] = max(up[neighbor], up[curr] + 1)
            candidates.append(down[neighbor])
        candidates = sorted(candidates)
        if len(candidates) >= 2:
            candidates = candidates[-2:]
            for neighbor in graph[curr]:
                if neighbor == par:
                    continue
                best = (
                    candidates[-2]
                    if candidates[-1] == down[neighbor]
                    else candidates[-1]
                )
                up[neighbor] = max(up[neighbor], best + 2)
        for neighbor in graph[curr]:
            if neighbor != par:
                dfs2(neighbor, curr)

    for i in range(n):
        if ds.dsu[i] < 0:
            roots.append(i)
            dfs1(i, -1)

    for i in roots:
        dfs2(i, -1)

    assert len(roots) == 3
    best_in_root = [0] * 3

    for i in range(n):
        rep = ds.find(i)
        for j in range(3):
            if roots[j] == rep:
                best_in_root[j] = max(best_in_root[j], max(up[i], down[i]))
                break

    while q:
        a, b = map(int, input().split())
        a -= 1
        b -= 1
        ra, rb = ds.find(a), ds.find(b)
        # do some query here
        ret = max(up[a], down[a]) + max(up[b], down[b]) + 2
        for i in range(3):
            if roots[i] != ra and roots[i] != rb:
                ret += best_in_root[i] + 1
                break
        print(ret)
        q -= 1


if __name__ == "__main__":
    sys.setrecursionlimit(300000)
    main()