A tree is a connected graph that doesn't contain any cycles.

The distance between two vertices of a tree is the length (in edges) of the shortest path between these vertices.

You are given a tree with *n* vertices and a positive number *k*. Find the number of distinct pairs of the vertices which have a distance of exactly *k* between them. Note that pairs (*v*, *u*) and (*u*, *v*) are considered to be the same pair.
The first line contains two integers *n* and *k* (1 ≤ *n* ≤ 50000, 1 ≤ *k* ≤ 500) — the number of vertices and the required distance between the vertices.

Next *n* - 1 lines describe the edges as "*a*<sub class="lower-index">*i*</sub> *b*<sub class="lower-index">*i*</sub>" (without the quotes) (1 ≤ *a*<sub class="lower-index">*i*</sub>, *b*<sub class="lower-index">*i*</sub> ≤ *n*, *a*<sub class="lower-index">*i*</sub> ≠ *b*<sub class="lower-index">*i*</sub>), where *a*<sub class="lower-index">*i*</sub> and *b*<sub class="lower-index">*i*</sub> are the vertices connected by the *i*-th edge. All given edges are different.
5 2
1 2
2 3
3 4
2 5
4
5 3
1 2
2 3
3 4
4 5
2
10 1
2 1
3 1
4 3
5 4
6 5
7 1
8 6
9 2
10 6
9
10 2
2 1
3 1
4 3
5 4
6 5
7 1
8 6
9 2
10 6
10
10 3
2 1
3 1
4 3
5 4
6 5
7 1
8 6
9 2
10 6
8
50 3
2 1
3 2
4 3
5 4
6 5
7 6
8 7
9 8
10 9
11 10
12 11
13 12
14 13
15 14
16 15
17 16
18 17
19 18
20 19
21 20
22 21
23 22
24 23
25 24
26 25
27 26
28 27
29 28
30 29
31 30
32 31
33 32
34 33
35 34
36 35
37 36
38 37
39 38
40 39
41 40
42 41
43 42
44 43
45 44
46 45
47 46
48 47
49 48
50 49
47
50 4
2 1
3 1
4 2
5 2
6 3
7 3
8 4
9 4
10 5
11 5
12 6
13 6
14 7
15 7
16 8
17 8
18 9
19 9
20 10
21 10
22 11
23 11
24 12
25 12
26 13
27 13
28 14
29 14
30 15
31 15
32 16
33 16
34 17
35 17
36 18
37 18
38 19
39 19
40 20
41 20
42 21
43 21
44 22
45 22
46 23
47 23
48 24
49 24
50 25
124
50 5
2 1
3 1
4 2
5 2
6 4
7 4
8 6
9 6
10 8
11 8
12 10
13 10
14 12
15 12
16 14
17 14
18 16
19 16
20 18
21 18
22 20
23 20
24 22
25 22
26 24
27 24
28 26
29 26
30 28
31 28
32 30
33 30
34 32
35 32
36 34
37 34
38 36
39 36
40 38
41 38
42 40
43 40
44 42
45 42
46 44
47 44
48 46
49 46
50 48
84
10 20
2 1
3 2
4 1
5 3
6 4
7 1
8 2
9 7
10 2
0
# ﷽
import collections
import sys
input = lambda: sys.stdin.readline().strip()
mod=7+10**9
sys.setrecursionlimit(10**8) 


def inlst():return [int(i) for i in input().split()]
class Graphs:
    def __init__(self):
        self.graph = collections.defaultdict(list)
    def add_edge(self, m):
        for _ in range(m):
            u,v=[int(i)-1 for i in input().split()]
            
            self.graph[u].append(v)
            self.graph[v].append(u)

    def count_dis(self,k,n):
        dp = [[0] * (k + 1) for _ in range(n)]
        def dfs(i, fa):
            dp[i][0] = 1
            for j in self.graph[i]:
                if j != fa:
                    dfs(j, i)
                    for s in range(1, k + 1):
                        dp[i][s] += dp[j][s - 1]
        
        dfs(0, -1)

        return dp

    # def count_dis(self,k,n):
    #     # dfs
    #     dp = [[0] * (k + 1) for _ in range(n)]
    #     for i in range(n): dp[i][0] = 1
    #     stack = [[0, 0]]
    #     while stack:
    #         p, index = stack[-1]
    #         if len(self.graph[p]) <= index:
    #             stack.pop()
    #             if stack:
    #                 stack[-1][1] += 1
    #                 q = stack[-1][0]
    #                 for i in range(1, k + 1):
    #                     dp[q][i] += dp[p][i - 1]
    #         else:
    #             if len(stack) > 1 and self.graph[p][index] == stack[-2][0]:
    #                 stack.pop()
    #                 stack.append([p, index + 1])
    #             else:
    #                 stack.append([self.graph[p][index], 0])
    #     return dp
    
    
    def count_num(self,n,dp,k):
        res=0
        stack = [0]
        visited = [False] * n
        while stack:
            temp = []
            while stack:
                p = stack.pop()
                visited[p] = True
                res += dp[p][-1]
                temp_res = 0
                for q in self.graph[p]:
                    if visited[q]:
                        continue
                    temp.append(q)
                    for x in range(1, k):
                        temp_res += dp[q][x - 1] * (dp[p][k - x] - dp[q][k - x - 1])
                temp_res //= 2
                res += temp_res
            stack = temp
        return res


def solve():
    n,k=[int(i) for i in input().split()]
    g=Graphs()
    g.add_edge(n-1)
    dp=g.count_dis(k,n)
    c=g.count_num(n,dp,k)
    print(c)
    

if __name__ == "__main__":
    # for i in range(int(input())):
        solve()



