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 builtins
from collections import *
from ensurepip import bootstrap

import sys
from types import GeneratorType

input = sys.stdin.readline
sys.setrecursionlimit(50000)

import sys
from io import BytesIO, IOBase

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        import os
        self.os = os
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            self.os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")


class Input:
    @staticmethod
    def str():
        return input().strip()

    @staticmethod
    def int():
        return int(input())

    @staticmethod
    def float():
        return float(input())

    @staticmethod
    def list(type_: builtins):
        return list(map(type_, input().split()))


def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc


class Solution:
    def solve(self):
        n, k = Input.list(int)
        if k == 1:
            print(n - 1)
            return
        graph = defaultdict(set)
        for _ in range(n - 1):
            u, v = Input.list(int)
            graph[u].add(v)
            graph[v].add(u)

        queue = deque([(1, -1)])
        while queue:
            u, p = queue.popleft()
            graph[u].discard(p)
            for v in graph[u]:
                queue.append((v, u))

        @bootstrap
        def dfs(i: int) -> Counter:
            counter = Counter([0])
            for j in graph[i]:
                sub = dfs(j)
                for key, val in sub.items():
                    if key >= k: continue
                    counter[key + 1] += val
            return counter

        def pass_through(i: int) -> int:
            acc = Counter()
            res = 0
            for j in graph[i]:
                sub = dfs(j)
                for key, val in sub.items():
                    res += acc[k - key - 2] * val
                for key, val in sub.items():
                    acc[key] += val
            return res

        print(sum(dfs(i)[k] + pass_through(i) for i in range(n, 0, -1)))

    def main(self):
        self.solve()


Solution().main()
