package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

const MOD int64 = 998244353

var (
	n, k int
	g    [][]int
	data []byte
	pos  int
)

func nextInt() int {
	for pos < len(data) && (data[pos] < '0' || data[pos] > '9') {
		pos++
	}
	val := 0
	for pos < len(data) && data[pos] >= '0' && data[pos] <= '9' {
		val = val*10 + int(data[pos]-'0')
		pos++
	}
	return val
}

func dfs(v, p int) ([]int64, int64) {
	cur := make([]int64, k+1)
	cur[0] = 1

	for _, u := range g[v] {
		if u == p {
			continue
		}

		child, childSum := dfs(u, v)

		prefChild := make([]int64, k+1)
		for d := 1; d <= k; d++ {
			x := prefChild[d-1] + child[d-1]
			if x >= MOD {
				x -= MOD
			}
			prefChild[d] = x
		}

		prefCur := make([]int64, k+1)
		prefCur[0] = cur[0]
		for i := 1; i <= k; i++ {
			x := prefCur[i-1] + cur[i]
			if x >= MOD {
				x -= MOD
			}
			prefCur[i] = x
		}

		next := make([]int64, k+1)
		for h := 0; h <= k; h++ {
			val := cur[h] * childSum % MOD

			a := h
			if k-h < a {
				a = k - h
			}
			if a > 0 {
				val += cur[h] * prefChild[a] % MOD
				if val >= MOD {
					val -= MOD
				}
			}

			if h > 0 {
				b := h - 1
				if k-h < b {
					b = k - h
				}
				if b >= 0 {
					val += child[h-1] * prefCur[b] % MOD
					if val >= MOD {
						val -= MOD
					}
				}
			}

			next[h] = val
		}

		cur = next
	}

	var sum int64
	for i := 0; i <= k; i++ {
		sum += cur[i]
		if sum >= MOD {
			sum -= MOD
		}
	}

	return cur, sum
}

func main() {
	data, _ = io.ReadAll(os.Stdin)
	n = nextInt()
	k = nextInt()

	g = make([][]int, n)
	for i := 0; i < n-1; i++ {
		v := nextInt() - 1
		u := nextInt() - 1
		g[v] = append(g[v], u)
		g[u] = append(g[u], v)
	}

	_, ans := dfs(0, -1)

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(w, ans)
	w.Flush()
}