#!/usr/bin/env python3

import sys,threading
sys.setrecursionlimit(200200)
threading.stack_size(2**27)

class RMQ:
    def __init__(self, V):
        self.jmp = [V]
        pw, k = 1, 1
        while pw * 2 <= len(V):
            add = []
            for j in range(len(V) - pw * 2 + 1):
                add.append(min(self.jmp[k - 1][j], self.jmp[k - 1][j + pw]))
            self.jmp.append(add)
            pw *= 2
            k += 1

    def query(self, a, b):
        dep = (b - a).bit_length() - 1
        return min(self.jmp[dep][a], self.jmp[dep][b - (1 << dep)])

ss = []
class LCA:
    def __init__(self, C):
        self.T = 0
        self.time = [0] * len(C)
        self.vis = [False] * len(C)
        self.path, self.ret = [], []
        self.dfs(C, 0, -1)
        self.rmq = RMQ(self.ret)

    def dfs(self, C, v, par):
        self.time[v] = self.T
        self.vis[v] = True
        self.T += 1
        for y in C[v]:
            if y != par:
                if self.vis[y]:
                    if (y,v) not in ss:
                        ss.append((v,y))
                else:
                    self.path.append(v)
                    self.ret.append(self.time[v])
                    self.dfs(C, y, v)


    def lca(self, a, b):
        if a == b:
            return a
        return self.path[self.rmq.query(
            min(self.time[a], self.time[b]),
            max(self.time[a], self.time[b])
        )]

def solve():
    n,q = map(int, input().split())
    graph = [[] for _ in range(n)]
    for i in range(n + 1):
        a,b = map(int, input().split())
        a -= 1
        b -= 1
        graph[a].append(b)
        graph[b].append(a)

    lc = LCA(graph)

    def ok(paths):
        p = []
        for a,b in paths:
            x = lc.lca(a,b)
            p.append((x,a))
            p.append((x,b))

        for i in range(len(p)):
            for j in range(i-(i&1)):
                if not(lc.lca(p[i][1], p[j][0]) != p[j][0] or lc.lca(p[j][1], p[i][0]) != p[i][0]):
                    return False
        return True

    for i in range(q):
        a,b = map(int, input().split())
        a -= 1
        b -= 1

        print(1 + 
            ok([(a,ss[0][0]), (ss[0][1], b)]) + 
            ok([(a,ss[0][1]), (ss[0][0], b)]) + 
            ok([(a,ss[1][0]), (ss[1][1], b)]) + 
            ok([(a,ss[1][1]), (ss[1][0], b)]) + 
            ok([(a,ss[0][0]), (ss[0][1], ss[1][0]), (ss[1][1], b)]) + 
            ok([(a,ss[0][0]), (ss[0][1], ss[1][1]), (ss[1][0], b)]) + 
            ok([(a,ss[0][1]), (ss[0][0], ss[1][0]), (ss[1][1], b)]) + 
            ok([(a,ss[0][1]), (ss[0][0], ss[1][1]), (ss[1][0], b)]) + 
            ok([(a,ss[1][0]), (ss[1][1], ss[0][0]), (ss[0][1], b)]) + 
            ok([(a,ss[1][0]), (ss[1][1], ss[0][1]), (ss[0][0], b)]) + 
            ok([(a,ss[1][1]), (ss[1][0], ss[0][0]), (ss[0][1], b)]) + 
            ok([(a,ss[1][1]), (ss[1][0], ss[0][1]), (ss[0][0], b)]) 
        )

threading.Thread(target=solve).start()