#include <algorithm>
#include <array>
#include <cassert>
#include <functional>
#include <iostream>
#include <vector>

using namespace std;

template<class Fun>
class y_combinator_result {
  Fun fun_;
public:
  template<class T>
  explicit y_combinator_result(T &&fun): fun_(std::forward<T>(fun)) {}

  template<class ...Args>
  decltype(auto) operator()(Args &&...args) {
    return fun_(std::ref(*this), std::forward<Args>(args)...);
  }
};

template<class Fun>
decltype(auto) y_combinator(Fun &&fun) {
  return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

struct disjoint_set {
  vector<int> p;
  disjoint_set(int n) {
    p.assign(n, -1);
  }
  int find(int x) {
    if (p[x] < 0) return x;
    return p[x] = find(p[x]);
  }
  bool merge(int x, int y) {
    x = find(x);
    y = find(y);
    if(x == y) return false;
    p[x] = y;
    return true;
  }
};

struct LCA {
  vector<int> depth;
  vector<vector<int>> anc;
  int n;
  int d;
  vector<int> startt, treesz;
  LCA(const vector<vector<int>>& tree) {
    auto dfs = y_combinator([&](auto self, int curr, int par, int& id) -> void {
      startt[curr] = id++;
      for(int out: tree[curr]) {
        if(out == par) continue;
        anc[out][0] = curr;
        depth[out] = depth[curr] + 1;
        self(out, curr, id);
        treesz[curr] += treesz[out];
      }
    });
    n = tree.size();
    startt.assign(n, -1);
    treesz.assign(n, 1);
    depth.assign(n, 1e9);
    depth[0] = 0;
    d = 1;
    while((1<<d) <= n) d++;
    anc.resize(n);
    for(auto& x: anc) x.assign(d, -1);
    {
      int id = 0;
      dfs(0, -1, id);
    }
    for(int k = 1; k < d; k++) for(int i = 0; i < n; i++) {
      if(anc[i][k-1] == -1) anc[i][k] = -1;
      else anc[i][k] = anc[anc[i][k-1]][k-1];
    }
  }
  int getLCA(int a, int b) {
    if(depth[a] < depth[b]) swap(a, b);
    for(int k = d-1; k >= 0; k--) {
      if(depth[a] - depth[b] >= (1 << k)) a = anc[a][k];
    }
    assert(depth[a] == depth[b]);
    for(int k = d-1; k >= 0; k--) {
      if(anc[a][k] != anc[b][k]) {
        a = anc[a][k];
        b = anc[b][k];
      }
    }
    if(a != b) {
      return anc[a][0];
    }
    return a;
  }
  bool onPath(int x, int lhs, int rhs) {
    if(depth[lhs] > depth[rhs]) swap(lhs, rhs);
    return startt[lhs] <= startt[x] && startt[x] < startt[lhs] + treesz[lhs] && startt[x] <= startt[rhs] && startt[rhs] < startt[x] + treesz[x];
  }
  bool overlap(int a, int b, int c, int d) {
    int lhs = getLCA(a, b);
    int rhs = getLCA(c, d);
    return onPath(lhs, c, rhs) || onPath(lhs, d, rhs) || onPath(rhs, a, lhs) || onPath(rhs, lhs, b);
  }
};

int main() {
  int n, q;
  cin >> n >> q;
  vector<array<int, 2>> extra;
  disjoint_set dsu(n); 
  vector<vector<int>> tree(n);
  for(int i = 0; i < n+1; i++) {
    int a, b;
    cin >> a >> b;
    if(dsu.merge(--a, --b)) {
      tree[a].push_back(b);
      tree[b].push_back(a);
    }
    else extra.push_back({a, b});
  }
  assert(extra.size() == 2);
  LCA lca(tree);
  while(q--) {
    int x, y;
    cin >> x >> y;
    x--; y--;
    int ret = 1;
    for(int i = 0; i < 2; i++) {
      ret += !lca.overlap(x, extra[i][0], extra[i][1], y);
      ret += !lca.overlap(x, extra[i][1], extra[i][0], y);
    }
    for(int i = 0; i < 2; i++) {
      for(int a = 0; a < 2; a++) for(int b = 0; b < 2; b++) {
        vector<int> vertices;
        vertices.push_back(x);
        vertices.push_back(extra[i][a]);
        vertices.push_back(extra[i][a^1]);
        vertices.push_back(extra[i^1][b]);
        vertices.push_back(extra[i^1][b^1]);
        vertices.push_back(y);
        bool good = true;
        good = good && !lca.overlap(vertices[0], vertices[1], vertices[2], vertices[3]);
        good = good && !lca.overlap(vertices[0], vertices[1], vertices[4], vertices[5]);
        good = good && !lca.overlap(vertices[2], vertices[3], vertices[4], vertices[5]);
        ret += good;
      }
    }
    cout << ret << "\n";
  }
}