/* a.cpp */
#include <bits/stdc++.h>

using i64 = long long;

int exgcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int g = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return g;
}

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::vector<std::vector<int>> adj(n);
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        std::cin >> u >> v;
        --u, --v;
        adj[u].push_back(v), adj[v].push_back(u);
    }

    std::vector<int> dep(n), fa(n, -1);
    auto dfs = [&](auto self, int u) -> void {
        for (auto v : adj[u]) if (v != fa[u]) {
            dep[v] = dep[u] + 1;
            fa[v] = u;
            self(self, v);
        }
    };
    dfs(dfs, 0);

    auto apply = [&](auto &f, int s, int t) {
        std::fill(f.begin(), f.end(), std::array{-1, -1});
        int x = s, y = t, l = 0;
        while (x != y) {
            if (dep[x] >= dep[y]) {
                x = fa[x];
            } else {
                y = fa[y];
            }
            l += 1;
        }

        int p = 0, q = 0;
        while (s != t) {
            if (dep[s] >= dep[t]) {
                f[s] = {p, 2 * l - p};
                s = fa[s];
                p += 1;
            } else {
                f[t] = {l - q, l + q};
                t = fa[t];
                q += 1;
            }
        }
        f[s] = {p, 2 * l - p};

        return 2 * l;
    };

    std::vector<std::array<int, 2>> f(n), g(n);
    while (m--) {
        int sa, ta, sb, tb;
        std::cin >> sa >> ta >> sb >> tb;
        --sa, --ta, --sb, --tb;

        int la = apply(f, sa, ta), lb = apply(g, sb, tb);
        int x, y, z = exgcd(la, lb, x, y);

        std::pair<int, int> ans{1e9, -2};
        for (int i = 0; i < n; ++i) {
            if (f[i][0] == -1 || g[i][0] == -1) {
                continue;
            }
            for (auto a : f[i]) {
                for (auto b : g[i]) {
                    a %= la, b %= lb;
                    if ((a - b) % z) {
                        continue;
                    }
                    int res = (b - a) / z * x % (lb / z) * la + a;
                    res %= lb / z * la;
                    if (res < 0) {
                        res += lb / z * la;
                    }
                    ans = std::min(ans, {res, i});
                }
            }
        }

        std::cout << ans.second + 1 << '\n';
    }
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}