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.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;

public class MultihedgehogA {
	IO io = new IO();
	int N, K;
	List<Integer>[] edges;
	int[] degrees;
	boolean[] isRemoved;
	Queue<Integer> removalQ = new LinkedList<>();
	
	void begin() {
		N = io.nextInt();
		K = io.nextInt();
		edges = new ArrayList[N];
		isRemoved = new boolean[N];
		degrees = new int[N];
		
		for(int i=0; i<N; i++) {
			edges[i] = new ArrayList<>();
		}
		
		for(int i=0; i<N-1; i++) {
			int a = io.nextInt() - 1;
			int b = io.nextInt() - 1;
			
			edges[a].add(b);
			edges[b].add(a);
			degrees[a]++;
			degrees[b]++;
		}
		
		for(int i=0; i<N; i++) {
			if(edges[i].size() == 1) {
				removalQ.add(i);
			}
		}
		
		int root = FindRoot();
		boolean result = Recurse(root, -1, 0);
		//System.out.println(root);
		
		if(result) io.out("Yes\n");
		else io.out("No\n");
		io.done();
	}
	
	int FindRoot() {
		while(!removalQ.isEmpty()) {
			int r = removalQ.remove();
			isRemoved[r] = true;
			
			if(degrees[r] == 0) {
				return r;
			}
			
			for(int e : edges[r]) {
				if(isRemoved[e]) continue;
				degrees[e]--;
				if(degrees[e] == 1) {
					removalQ.add(e);
				}
			}
		}
		
		assert(false);
		return 0;
	}
	
	boolean Recurse(int from, int prev, int lv) {
		//System.out.printf("rec %d %d %d\n", from, prev, lv);
		if(edges[from].size() == 1) {
			if(lv != K) return false;
			return true;
		}
		
		if(lv == 0) {
			if(edges[from].size() < 3) return false;
		} else {
			if(edges[from].size() < 4) return false;
		}
		
		for(int e : edges[from]) {
			if(e == prev) continue;
			boolean res = Recurse(e, from, lv+1);
			if(!res) return false;
		}
		return true;
	}
	
	public static void main(String[] args) {
		(new MultihedgehogA()).begin();
	}
	
	static class IO {
		BufferedReader reader;
		StringTokenizer tokenizer;
		BufferedWriter writer;
		boolean isAutoFlush;
		
		public IO() {
			this(false, null, null);
		}
		
		public IO(boolean isAutoFlush, String fileFrom, String fileTo) {
			if(fileFrom == null) {
				reader = new BufferedReader(new InputStreamReader(System.in));
			} else {
				try {
					reader = new BufferedReader(new FileReader(new File(fileFrom)));
				} catch(IOException e) {
					throw new RuntimeException(e);
				}
			}
			
			if(fileTo == null) {
				writer = new BufferedWriter(new OutputStreamWriter(System.out));
			} else {
				try {
					writer = new BufferedWriter(new FileWriter(new File(fileTo)));
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			
			tokenizer = new StringTokenizer("");
		}
		
		private String next() {
			while (!tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) { //EOF
					e.printStackTrace();
				}
			}
			return tokenizer.nextToken();
		}
		
		public int nextInt() {
			return Integer.parseInt(next());
		}
		public long nextLong() {
			return Long.parseLong(next());
		}
		public String nextString() {
			return next();
		}
		public double nextDouble() {
			return Double.parseDouble(next());
		}
		
		public void out(String format, Object... args) {
			try {
				String string = String.format(format, args);
				writer.write(string);
				if(isAutoFlush) writer.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		public void done() {
			try {
				writer.flush();
				reader.close();
				writer.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}
