import java.util.*;

/**
 * Start by constructing a tree on all nodes and rooting the tree at some node.
 * There will be two edges left over, A and B.
 * For each query there will be at least one path and at most 4 paths.
 * The possibilities for this path are:
 *      1. Use neither edge A nor edge B. Such a path always exists.
 *      2. Use edge A but not edge B.
 *      3. Use edge B but not edge A.
 *      4. Use edge A and edge B.
 *  For each of these possibilities we need to check if there is a simple path.
 *  For a query between nodes u and v and case (2) we check if the path
 *  from u to an endpoint of A is node disjoint with the path from the other
 *  endpoint of A to v. Do this for both choices endpoints of A. Case (3) is
 *  similar. Case (4) requires checking each possible traversal order of edges
 *  A and B. There are 8 such orders.
 *  To determine if a path from u to v is vertex disjoint from a path from x to y,
 *  it suffices to check if lca(u, v) is on the path from x to y and if lca(x, y)
 *  is on the path from u to v. Use binary lifting to compute LCA in log(n) time.
 *  Time Complexity: O((n+q)(log n))
 *
 * @author Finn Lidbetter
 */

public class tree_finn {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int q = sc.nextInt();
        Node[] nodes = new Node[n];
        for (int i=0; i<n; i++) {
            nodes[i] = new Node(i);
        }
        UnionFind uf = new UnionFind(n);
        Edge[] edges = new Edge[n+1];
        Edge a = null;
        Edge b = null;
        for (int i=0; i<n+1; i++) {
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;
            edges[i] = new Edge(u, v);
            if (uf.connected(u, v)) {
                if (a == null) {
                    a = edges[i];
                } else {
                    b = edges[i];
                }
            } else {
                uf.union(u, v);
                nodes[u].adj.add(v);
                nodes[v].adj.add(u);
            }
        }
        ArrayList<Integer> order = new ArrayList<>();
        rootTreeDFS(nodes, 0, order);
        int maxDepth = 0;
        for (int i=0; i<n; i++) {
            if (nodes[i].depth > maxDepth) {
                maxDepth = nodes[i].depth;
            }
        }
        int skip = 1;
        int skipPow = 0;
        while (skip < maxDepth) {
            skip *= 2;
            skipPow++;
        }
        int[][] ancestor = new int[n][skipPow+1];
        for (int nodeId: order) {
            ancestor[nodeId][0] = nodes[nodeId].parent;
        }
        for (int i=1; i<ancestor[0].length; i++) {
            for (int nodeId: order) {
                int skipGrandparent = ancestor[nodeId][i-1];
                if (skipGrandparent == -1) {
                    ancestor[nodeId][i] = -1;
                } else {
                    ancestor[nodeId][i] = ancestor[skipGrandparent][i-1];
                }
            }
        }
        for (int i=0; i<q; i++) {
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;
            // There is at least one path in the tree.
            int paths = 1;
            // Check if there is a path through the tree and edge A.
            if (hasNodeDisjointPaths(u, a.u, a.v, v, nodes, ancestor) || hasNodeDisjointPaths(u, a.v, a.u, v, nodes, ancestor)) {
                paths++;
            }
            // Check if there is a path through the tree and edge B.
            if (hasNodeDisjointPaths(u, b.u, b.v, v, nodes, ancestor) || hasNodeDisjointPaths(u, b.v, b.u, v, nodes, ancestor)) {
                paths++;
            }

            // Check if there is a path through the tree and edge A and edge B.
            if (
                    (
                        hasNodeDisjointPaths(u, a.u, a.v, b.u, nodes, ancestor) &&
                        hasNodeDisjointPaths(a.v, b.u, b.v, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, a.u, b.v, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, a.u, a.v, b.v, nodes, ancestor)  &&
                        hasNodeDisjointPaths(a.v, b.v, b.u, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, a.u, b.u, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, a.v, a.u, b.u, nodes, ancestor)  &&
                        hasNodeDisjointPaths(a.u, b.u, b.v, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, a.v, b.v, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, a.v, a.u, b.v, nodes, ancestor)  &&
                        hasNodeDisjointPaths(a.u, b.v, b.u, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, a.v, b.u, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, b.u, b.v, a.u, nodes, ancestor) &&
                        hasNodeDisjointPaths(b.v, a.u, a.v, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, b.u, a.v, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, b.u, b.v, a.v, nodes, ancestor) &&
                        hasNodeDisjointPaths(b.v, a.v, a.u, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, b.u, a.u, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, b.v, b.u, a.u, nodes, ancestor) &&
                        hasNodeDisjointPaths(b.u, a.u, a.v, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, b.v, a.v, v, nodes, ancestor)
                    ) ||
                    (
                        hasNodeDisjointPaths(u, b.v, b.u, a.v, nodes, ancestor) &&
                        hasNodeDisjointPaths(b.u, a.v, a.u, v, nodes, ancestor) &&
                        hasNodeDisjointPaths(u, b.v, a.u, v, nodes, ancestor)
                    )
            ) {
                paths++;
            }
            System.out.println(paths);
        }
    }

    static boolean hasNodeDisjointPaths(int a, int b, int c, int d, Node[] nodes, int[][] ancestor) {
        int lca1 = lca(a, b, nodes, ancestor);
        int lca2 = lca(c, d, nodes, ancestor);
        if (!nodeOnPath(a,b,lca2, nodes, ancestor) && !nodeOnPath(c,d,lca1, nodes, ancestor)) {
            return true;
        }
        return false;
    }

    static int lca(int u, int v, Node[] nodes, int[][] ancestor) {
        if (nodes[u].depth!=nodes[v].depth) {
            if (nodes[u].depth < nodes[v].depth) {
                v = nthParent(v, nodes[v].depth - nodes[u].depth, ancestor);
            } else {
                u = nthParent(u, nodes[u].depth - nodes[v].depth, ancestor);
            }
        }

        if (u==v) {
            return u;
        }
        int shiftIndex = ancestor[0].length - 1;
        while (shiftIndex>=0) {
            if (ancestor[u][shiftIndex]==ancestor[v][shiftIndex]) {
                shiftIndex--;
            } else {
                u = ancestor[u][shiftIndex];
                v = ancestor[v][shiftIndex];
            }
        }
        if (u==v) {
            return u;
        }
        return nodes[u].parent;
    }

    static int nthParent(int u, int n, int[][] ancestor) {
        int mask = 1;
        int shifted = 0;
        int curr = u;
        while (mask<=n) {
            if (curr == -1) {
                return -1;
            }
            if ((n&mask) > 0) {
                curr = ancestor[curr][shifted];
            }
            mask = mask << 1;
            shifted++;
        }
        return curr;
    }

    /**
     * Return True iff x is on the path between u and v.
     */
    static boolean nodeOnPath(int u, int v, int x, Node[] nodes, int[][] ancestor) {
        int lca = lca(u, v, nodes, ancestor);
        if (u==x || v==x || lca == x) {
            return true;
        }
        if (nodes[u].depth >= nodes[x].depth && nodes[x].depth >= nodes[lca].depth) {
            if (nthParent(u, nodes[u].depth - nodes[x].depth, ancestor) == x) {
                return true;
            }
        }
        if (nodes[v].depth >= nodes[x].depth && nodes[x].depth >= nodes[lca].depth) {
            if (nthParent(v, nodes[v].depth - nodes[x].depth, ancestor) == x) {
                return true;
            }
        }
        return false;
    }

    static void rootTreeDFS(Node[] nodes, int curr, ArrayList<Integer> order) {
        order.add(curr);
        for (int nbr: nodes[curr].adj) {
            if (nbr != nodes[curr].parent) {
                nodes[nbr].depth = nodes[curr].depth + 1;
                nodes[nbr].parent = curr;
                nodes[curr].children.add(nbr);
                rootTreeDFS(nodes, nbr, order);
            }
        }
    }
}
class Edge {
    int u,v;
    public Edge(int uu, int vv) {
        u = uu;
        v = vv;
    }
}
class Node {
    int id;
    int depth;
    int parent;
    ArrayList<Integer> adj;
    ArrayList<Integer> children;
    public Node(int idd) {
        id = idd;
        depth = 0;
        parent = -1;
        adj = new ArrayList<>();
        children = new ArrayList<>();
    }
}
class UnionFind {
    int[] id;
    public UnionFind(int n) {
        id = new int[n];
        for (int i = 0; i < n; i++) {
            id[i] = i;
        }
    }
    int find(int p) {
        int rt = p;
        while (rt != id[rt]) {
            rt = id[rt];
        }
        while (p != rt) {
            int next = id[p];
            id[p] = rt;
            p = next;
        }
        return rt;
    }
    boolean connected(int p, int q) {
        return find(p) == find(q);
    }

    void union(int p, int q) {
        int r1 = find(p);
        int r2 = find(q);
        if (r1 == r2) {
            return;
        }
        id[r1] = r2;
    }
}