Someone give a strange birthday present to Ivan. It is hedgehog — connected undirected graph in which one vertex has degree at least 3 (we will call it center) and all other vertices has degree 1. Ivan thought that hedgehog is too boring and decided to make himself k-multihedgehog.

Let us define k-multihedgehog as follows:

  * 1-multihedgehog is hedgehog: it has one vertex of degree at least 3 and some vertices of degree 1.
  * For all k ≥ 2, k-multihedgehog is (k-1)-multihedgehog in which the following changes has been made for each vertex v with degree 1: let u be its only neighbor; remove vertex v, create a new hedgehog with center at vertex w and connect vertices u and w with an edge. New hedgehogs can differ from each other and the initial gift. 



Thereby k-multihedgehog is a tree. Ivan made k-multihedgehog but he is not sure that he did not make any mistakes. That is why he asked you to check if his tree is indeed k-multihedgehog.

Input

First line of input contains 2 integers n, k (1 ≤ n ≤ 10^{5}, 1 ≤ k ≤ 10^{9}) — number of vertices and hedgehog parameter.

Next n-1 lines contains two integers u v (1 ≤ u,    v ≤ n;    u ≠ v) — indices of vertices connected by edge.

It is guaranteed that given graph is a tree.

Output

Print "Yes" (without quotes), if given graph is k-multihedgehog, and "No" (without quotes) otherwise.

Examples

Input

14 2
1 4
2 4
3 4
4 13
10 5
11 5
12 5
14 5
5 13
6 7
8 6
13 6
9 6


Output

Yes


Input

3 1
1 3
2 3


Output

No

Note

2-multihedgehog from the first example looks like this:

<image>

Its center is vertex 13. Hedgehogs created on last step are: [4 (center), 1, 2, 3], [6 (center), 7, 8, 9], [5 (center), 10, 11, 12, 13].

Tree from second example is not a hedgehog because degree of center should be at least 3.
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class B {
	
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] parts = br.readLine().split(" ");
		int n = Integer.parseInt(parts[0]);
		int k = Integer.parseInt(parts[1]);
		List<List<Integer>> g = new ArrayList<>(n + 1);
		for (int i = 0; i < n + 1; i++) {
			g.add(new ArrayList<>());
		}
		for (int i = 0; i < n - 1; i++) {
			parts = br.readLine().split(" ");
			int u = Integer.parseInt(parts[0]);
			int v = Integer.parseInt(parts[1]);
			g.get(u).add(v);
			g.get(v).add(u);
		}
		int start = -1;
		for (int i = 1; i <= n && start == -1; i++) {
			if (g.get(i).size() == 1) start = i;
		}
		if (start == -1) {
			System.out.println("No");
			return;
		}
		List<Integer> st = new ArrayList<>();
		List<Integer> temp = new ArrayList<>();
//		System.out.println("start: " + start);
		dfs(g, start, st, temp, -1, -1);
//		System.out.println(st.toString());
		if (st.size() % 2 == 0 || st.size() / 2 != k) {
			System.out.println("No");
		} else {
			int center = st.get(st.size()/2);
//			System.out.println("center: " + center);
			boolean can = dfs(g, center, new ArrayList<>(), temp, -1, k);
			can = can && canDegree(g, center);
			System.out.println(can ? "Yes" : "No");
		}
	}
	
	private static boolean canDegree(List<List<Integer>> g, int center) {
		boolean can = true;
		for (int i = 1; i < g.size() && can; i++) {
			int size = g.get(i).size();
			if (i == center) {
				can = can && size >= 3;
			} else {
				can = can && (size >= 4 || size == 1);
			}
		}
		return can;
	}

	private static boolean dfs(List<List<Integer>> g, int curr, List<Integer> ans, List<Integer> temp, int p, int k) {
		temp.add(curr);
		List<Integer> children = g.get(curr);
		boolean can = true;
		
		if (children.size() == 1 && p != -1) {
			if (temp.size() > ans.size()) {
				ans.clear();
				ans.addAll(temp);
			}
			can = temp.size() - 1 == k;
		}
		for (int i = 0; i < children.size(); i++) {
			if (children.get(i) != p) {
				can = dfs(g, children.get(i), ans, temp, curr, k) && can;
			}
		}
		temp.remove(temp.size() - 1);
		return can;
	}

}
