import sys

sys.setrecursionlimit(2000000)

MOD = 998244353
MAXN = 500005

fact = [1] * MAXN
invFact = [1] * MAXN

def power(a, b):
    res = 1
    a %= MOD
    while b > 0:
        if b % 2 == 1:
            res = (res * a) % MOD
        a = (a * a) % MOD
        b //= 2
    return res

def modInverse(n):
    return power(n, MOD - 2)

def precompute():
    for i in range(1, MAXN):
        fact[i] = (fact[i - 1] * i) % MOD
    invFact[MAXN - 1] = modInverse(fact[MAXN - 1])
    for i in range(MAXN - 2, -1, -1):
        invFact[i] = (invFact[i + 1] * (i + 1)) % MOD

def nCr(n, r):
    if r < 0 or r > n:
        return 0
    num = fact[n]
    den = (invFact[r] * invFact[n - r]) % MOD
    return (num * den) % MOD

def solve():
    n, c = map(int, sys.stdin.readline().split())

    adj = [[] for _ in range(n + 1)]
    for _ in range(n - 1):
        u, v = map(int, sys.stdin.readline().split())
        adj[u].append(v)
        adj[v].append(u)

    if c >= n:
        print(0)
        return

    dep = [0] * (n + 1)
    visited = [False] * (n + 1)
    q = [(1, 0)]
    visited[1] = True

    head = 0
    while head < len(q):
        u, d = q[head]
        head += 1
        dep[u] = d
        for v in adj[u]:
            if not visited[v]:
                visited[v] = True
                q.append((v, d + 1))

    M = n - 1

    W_c = 0
    for i in range(2, n + 1):
        W_c = (W_c + nCr(dep[i] - 1, c - 1)) % MOD
    N_c = (W_c * fact[c]) % MOD
    N_c = (N_c * fact[M - c]) % MOD

    N_c_plus_1 = 0
    if c + 1 <= M:
        W_c_plus_1 = 0
        for i in range(2, n + 1):
            W_c_plus_1 = (W_c_plus_1 + nCr(dep[i] - 1, c)) % MOD
        N_c_plus_1 = (W_c_plus_1 * fact[c + 1]) % MOD
        N_c_plus_1 = (N_c_plus_1 * fact[M - c - 1]) % MOD

    ans = (N_c - N_c_plus_1 + MOD) % MOD
    print(ans)

precompute()
line = sys.stdin.readline()
if line:
    t_cases = int(line)
    for _ in range(t_cases):
        solve()