#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;
    }
};


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;
        }
    }
}

SuperMap maps[MAXN];
int map_id[MAXN];


void dfs_dp(int v) {
    map_id[v] = v;
    maps[v].clear();
    for (int u : G[v]) {
        dfs_dp(u);
    }
    if (G[v].empty()) {
        maps[map_id[v]].insert(cnt[v], 1);
    } else if (G[v].size() == 1) {
        map_id[v] = map_id[G[v][0]];
        maps[map_id[v]].add_all(cnt[v]);
    } else {
        int place_real = map_id[G[v][0]];
        maps[map_id[G[v][0]]].add_all(cnt[v]);
        int place_extra = v;
        for (int i = 1; i < G[v].size(); ++i) {
            maps[place_extra].clear();
            int cur = map_id[G[v][i]];
            for (auto [x, cnt1] : maps[place_real].dp) {
                for (auto [y, cnt2] : maps[cur].dp) {
                    int total_cnt = x + y + maps[place_real].to_add + maps[cur].to_add;
                    if (total_cnt <= k + 1)
                        maps[place_extra].insert(total_cnt, mul(cnt1, cnt2));
                }
            }
            swap(place_real, place_extra);
        }
        map_id[v] = place_real;
    }
    auto& cur_dp = maps[map_id[v]];
    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;
        --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);
    auto& res = maps[map_id[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;
}