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.*;
import java.util.*;
 
public class p1067b {
	public static PrintWriter out;
	static class Graph
	{
		public ArrayList adjacency[];
		public int root,size;
		public Graph(int nodes)
		{
			this.root = -1;
			this.size = nodes;
			adjacency = new ArrayList[nodes];
			for(int i=0;i<nodes;i++)
			{
				adjacency[i] = new ArrayList<Integer>();
			}
		}
		@Override
		public String toString()
		{
			String ret = "";
			for (ArrayList temp : adjacency) {
				ret+=(temp.toString()+"\n");
			}
			return ret;
		}
		public void add(int from, int to)
		{
			adjacency[from].add(to);
			adjacency[to].add(from);
		}
		public int getRoot(int k)
		{
			boolean vis[] = new boolean[size];
			Arrays.fill(vis,false);
			LinkedList<Integer> list = new LinkedList<Integer>();
 			for(int i=0;i<size;i++)
			{
				ArrayList<Integer> adj = (ArrayList<Integer>)adjacency[i];
				if(adj.size()==1){
					vis[i]=true;
					list.addLast(i);
				}
			}
			// out.println(list);
			while(true)
			{
				if(list.size()==1)
					break;
				int u = list.pop();
				// out.println(u);
				boolean check = false;
				for (int nei : (ArrayList<Integer>)adjacency[u]) {
					if(!vis[nei])
					{
						check=true; vis[nei]=true;
						list.addLast(nei);
					}
				}
				// out.println(list);
				// if(!check)
				// 	return -1;
			}
			root = list.pop();
			return root;
		}
		public void calcDist(int u, int d, int dist[], boolean[] vis)
		{
			dist[u] = d;
			vis[u] = true;
			if(adjacency[u].size()>1 && adjacency[u].size()<4 && u!=root)
				dist[u]=-1;
			for (int neigh : (ArrayList<Integer>)adjacency[u]) {
				if(!vis[neigh])
					calcDist(neigh,d+1,dist,vis);
			}
		}
		public int checkLeaves(int k)
		{
			int ct = 0;
			int dist[] = new int[size];
			boolean vis[] = new boolean[size];
			Arrays.fill(vis,false);
			Arrays.fill(dist,0); 
			if(root==-1){
				// out.println("root==-1");
				return -1;
			}
			calcDist(root,0,dist,vis);
			for(int i=0;i<size;i++)
			{
				ArrayList<Integer> list = (ArrayList<Integer>) adjacency[i];
				if(list.size()==1)
				{
					if(dist[i]==k)
						ct++;
					else
						return -1;
				}
				if(dist[i]==-1)
					return -1;
			}
			return ct;
		}
	}
	// public static int ct,k;
	// public static int checkLeaves(Graph g, int r, int k)
	// {
	// 	ArrayList<Integer> list = (ArrayList<Integer>)g.adjacency[r];
	// 	if(list.size()==0)
	// 	{
	// 		if()
	// 	}
	// }
	public static long N = 1000000007L;
	public static long exponentiation(long base, long exp) 
    { 
        if (exp == 0) 
            return 1; 
  
        if (exp == 1) 
            return base % N; 
  
        long t = exponentiation(base, exp / 2); 
        t = (t * t) % N; 
  
        // if exponent is even value 
        if (exp % 2 == 0) 
            return t; 
  
        // if exponent is odd value 
        else
            return ((base % N) * t) % N; 
    } 
	public static void main(String[] args)throws IOException {
        InputReader in = new InputReader(System.in);
        out = new PrintWriter(System.out);
        
		int n = in.nextInt();
		int k = in.nextInt();
		if(n==1)
		{
			out.println("No");
			out.close();
			return;
		}
		Graph g = new Graph(n);
		for(int t = 0; t < n-1; t++)
		{
			int u = in.nextInt()-1;
			int v = in.nextInt()-1;
			g.add(u,v);
		}
		int maxk = (int)(Math.log(n)/(double)Math.log(3d)) + 5;
		if(k>=maxk){
			out.println("No");
			out.close();
			return;
		}
		int root = g.getRoot(k);
		if(g.adjacency[root].size()<3)
		{
			out.println("No");
			out.close();
			return;
		}
		// out.println("root "+root);
		long ct = (long)g.checkLeaves(k);
		if(ct>=exponentiation(3l,(long)k))
			out.println("Yes");
		else
			out.println("No");

        out.close();
	}
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }

}