#include <bits/stdc++.h>

using namespace std;

template<class F, class S>
ostream &operator<<(ostream &s, const pair<F, S> &v) {
	s << "(" << v.first << ", " << v.second << ")";
	return s;
}
template<ranges::range T> requires (!is_convertible_v<T, string_view>)
istream &operator>>(istream &s, T &&v) { 
	for (auto &&x : v) s >> x; 
	return s; 
}
template<ranges::range T> requires (!is_convertible_v<T, string_view>)
ostream &operator<<(ostream &s, T &&v) { 
	for (auto &&x : v) s << x << ' '; 
	return s; 
}

#ifdef LOCAL
template<class... T> void dbg(T... x) {
	char e{};
	((cerr << e << x, e = ' '), ...);
}
#define debug(x...) dbg(#x, '=', x, '\n')
#else
#define debug(...) ((void)0)
#endif

#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

template<class T> inline constexpr T inf = numeric_limits<T>::max() / 2;
bool chmin(auto &a, auto b) { return (b < a and (a = b, true)); }
bool chmax(auto &a, auto b) { return (a < b and (a = b, true)); }

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;

constexpr i64 mod = 998244353;

struct Tree {
    int n, lgN;
    vector<vector<int>> G;
    vector<vector<int>> st;
    vector<int> in, out, dep, pa, seq;
    Tree(int n) : n(n), G(n), in(n), out(n), dep(n), pa(n, -1) {}
    int cmp(int a, int b) {
        return dep[a] < dep[b] ? a : b;
    }
    void dfs(int u) {
        erase(G[u], pa[u]);
        in[u] = seq.size();
        seq.push_back(u);
        for (int v : G[u]) {
            dep[v] = dep[u] + 1;
            pa[v] = u;
            dfs(v);
        }
        out[u] = seq.size();
    }
    void build() {
        seq.reserve(n);
        dfs(0);
        lgN = __lg(n);
        st.assign(lgN + 1, vector<int>(n));
        st[0] = seq;
        for (int i = 0; i < lgN; i++)
            for (int j = 0; j + (2 << i) <= n; j++)
                st[i + 1][j] = cmp(st[i][j], st[i][j + (1 << i)]);
    }
    int inside(int x, int y) {
        return in[x] <= in[y] and in[y] < out[x];
    }
    int lca(int x, int y) {
        if (x == y) return x;
        if ((x = in[x] + 1) > (y = in[y] + 1))
            swap(x, y);
        int h = __lg(y - x);
        return pa[cmp(st[h][x], st[h][y - (1 << h)])];
    }
    int dist(int x, int y) {
        return dep[x] + dep[y] - 2 * dep[lca(x, y)];
    }
    int rootPar(int r, int x) {
        if (r == x) return -1;
        if (!inside(x, r)) return pa[x];
        return *--upper_bound(all(G[x]), r,
            [&](int a, int b) -> bool {
                return in[a] < in[b];
            });
    }
    int size(int x) { return out[x] - in[x]; }
    int rootSiz(int r, int x) {
        if (r == x) return n;
        if (!inside(x, r)) return size(x);
        return n - size(rootPar(r, x));
    }
    int rootLca(int a, int b, int c) {
        return lca(a, b) ^ lca(b, c) ^ lca(c, a);
    }
};

void solve() {
	int n, q;
	cin >> n >> q;

	vector G(n, vector<int>{});
	for (int i = 1; i < n; i++) {
		int p;
		cin >> p;
		p--;
		G[p].push_back(i);
	}

	Tree tree(n);
	tree.G = G;
	tree.build();

	vector dp(n, array<i64, 2>{});
	auto dfs = [&](auto &&self, int u) -> void {
		dp[u][1] = 1;
		for (int v : G[u]) {
			self(self, v);
			(dp[u][0] += dp[v][0] + dp[v][1]) %= mod;
			(dp[u][1] *= (1 + dp[v][1])) %= mod;
		}
	};
	dfs(dfs, 0);

	vector<i64> up(n);
	auto dfs2 = [&](auto &&self, int u) -> void {
		const int siz = G[u].size();
		vector<i64> pre(siz), suf(siz);
		for (int i = 0; i < siz; i++) {
			int v = G[u][i];
			pre[i] = (dp[v][1] + 1);
			if (i) {
				(pre[i] *= pre[i - 1]) %= mod;
			}
		}
		for (int i = siz - 1; i >= 0; i--) {
			int v = G[u][i];
			suf[i] = (dp[v][1] + 1);
			if (i + 1 < siz) {
				(suf[i] *= suf[i + 1]) %= mod;
			}
		}
		for (int i = 0; i < siz; i++) {
			int v = G[u][i];
			up[v] = up[u] * (i == 0 ? 1 : pre[i - 1]) % mod * (i == siz - 1 ? 1 : suf[i + 1]) % mod;
			(up[v] += 1) %= mod;
		}
	};
	up[0] = 1;
	dfs2(dfs2, 0);

	vector<i64> val(n), sum(n);
	auto dfs3 = [&](auto &&self, int u) -> void {
		val[u] = (mod * 2 - dp[u][0] - dp[u][1]) % mod;
		for (int v : G[u]) {
			(val[u] += dp[v][0] + dp[v][1]) %= mod;
		}
		(sum[u] += val[u]) %= mod;
		for (int v : G[u]) {
			sum[v] = sum[u];
			self(self, v);
		}
	};
	dfs3(dfs3, 0);

	while (q--) {
		int x, y;
		cin >> x >> y;
		x--, y--;
		int l = tree.lca(x, y);
		i64 ans = 0;
		ans = sum[x] + sum[y] - 2 * sum[l] + val[l];
		((ans %= mod) += mod) %= mod;
		(ans += dp[0][0] + dp[0][1]) %= mod;
		ans -= (up[l] - 1) * dp[l][1] % mod;
		((ans %= mod) += mod) %= mod;
		ans = dp[0][0] + dp[0][1] - ans;
		((ans %= mod) += mod) %= mod;
		cout << ans << '\n';
	}
}

signed main() {
	cin.tie(0)->sync_with_stdio(0);
	cin.exceptions(cin.failbit);

	int t = 1;
	cin >> t;

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

	return 0;
}