#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MOD = 998244353;

int add(int a, int b) {
    if (a + b < MOD)
        return a + b;
    return a + b - MOD;
}

int sub(int a, int b) {
    if (a >= b)
        return a - b;
    return a + MOD - b;
}

int mul(int a, int b) {
    return a * 1ll * b % MOD;
}

struct SuperMap {
    map<int, int> dp;
    int to_add;
    void insert(int x, int delta) {
        x -= to_add;
        dp[x] = add(dp[x], delta);
    }
    void add_all(int x) {
        to_add += x;
    }
    void clear() {
        dp.clear();
        to_add = 0;
    }
    void swap_other(SuperMap& other) {
        swap(dp, other.dp);
        swap(to_add, other.to_add);
    }
};


int k;

const int MAXN = 100100;
vector<int> G[MAXN];
int sz[MAXN];
int cnt[MAXN];

void dfs_sz(int v, int p) {
    sz[v] = 1;
    for (int u : G[v]) {
        if (u == p)
            continue;
        dfs_sz(u, v);
        sz[v] += sz[u];
    }
    cnt[v] = 1;
    for (int i = 0; i < G[v].size(); ++i) {
        if (G[v][i] == p) {
            swap(G[v][i], G[v].back());
            G[v].pop_back();
            --i;
        } else if (sz[G[v][i]] < k) {
            cnt[v] += sz[G[v][i]];
            swap(G[v][i], G[v].back());
            G[v].pop_back();
            --i;
        }
    }
    sort(G[v].begin(), G[v].end(), [](int a, int b) {
        return sz[a] > sz[b];
    });
}

const int K = 20;
SuperMap maps[K + 1];


void dfs_dp(int v, int w) {
    maps[w].clear();
    if (G[v].empty()) {
        maps[w].insert(cnt[v], 1);
    } else {
        dfs_dp(G[v][0], w);
        maps[w].add_all(cnt[v]);
        for (int i = 1; i < G[v].size(); ++i) {
            maps[K].clear();
            dfs_dp(G[v][i], w + 1);
            for (auto [x, cnt1] : maps[w].dp) {
                for (auto [y, cnt2] : maps[w + 1].dp) {
                    int total_cnt = x + y + maps[w].to_add + maps[w + 1].to_add;
                    if (total_cnt <= k + 1)
                        maps[K].insert(total_cnt, mul(cnt1, cnt2));
                }
            }
            maps[w].swap_other(maps[K]);
        }
    }
    auto& cur_dp = maps[w];
    int new_zero = 0;
    auto tmp = cur_dp.dp.find(k + 1 - cur_dp.to_add);
    if (tmp != cur_dp.dp.end()) {
        new_zero = add(new_zero, tmp->second);
    }
    tmp = cur_dp.dp.find(k - cur_dp.to_add);
    if (tmp != cur_dp.dp.end()) {
        new_zero = add(new_zero, tmp->second);
    }
    if (new_zero)
        cur_dp.insert(0, new_zero);
    while (!cur_dp.dp.empty()) {
        auto tmp = --cur_dp.dp.end();
        if (tmp->first + cur_dp.to_add > k)
            cur_dp.dp.erase(tmp);
        else
            break;
    }
}

void solve() {
    int n;
    cin >> n >> k;
    for (int i = 1; i < n; ++i) {
        int a, b;
        cin >> a >> b;

        //a = i + 1;
        //b = rand() % i + 1;

        --a;
        --b;
        G[a].emplace_back(b);
        G[b].emplace_back(a);
    }
    dfs_sz(0, -1);
    for (int i = 0; i < n; ++i) {
        if (cnt[i] > k + 1) {
            cout << 0 << '\n';
            return;
        }
    }
    dfs_dp(0, 0);
    auto& res = maps[0];
    cout << res.dp[-res.to_add] << '\n';
    for (int i = 0; i < n; ++i)
        G[i].clear();
}


int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}