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.util.*;
import java.io.*;

public class E
{

	static FastIO f;

	public static void main(String args[]) throws IOException
	{
		f = new FastIO();

		int n = f.ni(), k = f.ni(), l[] = new int[n+1], c[] = new int[n+1], i;
		GraphNode g = new GraphNode(n);
		Node u, v = null;
		HashSet<Node> o = new HashSet<>(), m = new HashSet<>();
		Queue<Node> q = new LinkedList<>();
		boolean ans = true;
		HashSet<Node> h = new HashSet<>();

		for(i = 1; i < n; i++)
		{
			u = new Node(f.ni(), 0);
			v = new Node(f.ni(), 0);
			add(u, o, m);
			add(v, o, m);
			g.addEdge(u, v);
			g.addEdge(v, u);
		}

		if(n == 1)
		{
			f.out("No\n");
			f.flush();
			return;
		}

		// f.err(g.adj + "\n");

		for(Node node : o)
			q.add(node);

		while(!q.isEmpty())
		{
			// f.err(q + "\n");
			u = q.remove();
			if(g.adj.get(u).size() != 1 || c[u.i] == 1 || c[u.i] == 2)
			{
				if(c[u.i] != 1 && c[u.i] != 2 && h.size() == n-1 && l[u.i] == k)
					break;
				ans = false;
				// f.err("Here " + u + " " + g.adj.get(u).size());
				break;
			}

			for(Node node : g.adj.get(u))
				v = node;

			if(l[v.i] == 0)
			{
				l[v.i] = l[u.i]+1;
				q.add(v);
			}
			else if(l[v.i] != l[u.i] + 1)
			{
				ans = false;
				break;
			}

			g.removeEdge(u, v);
			// f.err("Removed " + u + " " + v + "\n\n");
			h.add(u);
			c[v.i]++;
		}
		// f.err(Arrays.toString(c));
		// f.err(Arrays.toString(l));

		f.out(ans ? "Yes\n" : "No\n");

		f.flush();
	}

	public static void add(Node n, HashSet<Node> o, HashSet<Node> m)
	{
		if(m.contains(n))
			return;

		if(o.contains(n))
		{
			o.remove(n);
			m.add(n);
		}
		else
			o.add(n);
	}

	static class Node
	{
		int i, l;
	
		Node(int x, int y)
		{
			i = x;
			l = y;
		}
	
		@Override
		public int hashCode()
		{
			return i;
		}
	
		@Override
		public boolean equals(Object obj)
		{
			Node that = (Node)obj;
	
			return i == that.i;
		}
	
		@Override
		public String toString()
		{
			return "[" + i + ", " + l + "]";
		}
	}

	static class EdgeNode
	{
		Node a, b;
	
		EdgeNode(Node x, Node y)
		{
			a = x;
			b = y;
		}
	
		@Override
		public int hashCode()
		{
			return a.hashCode()^b.hashCode();
		}
	
		@Override
		public boolean equals(Object obj)
		{
			EdgeNode that = (EdgeNode)obj;
	
			return a.equals(that.a) && b.equals(that.b);
		}
	
		@Override
		public String toString()
		{
			return "[" + a + " -> " + b + "]";
		}
	}

	static class GraphNode
	{
		int v;
		HashMap<Node, HashSet<Node>> adj;
		HashSet<Node> d;
	
		GraphNode(int x)
		{
			v = x;
			adj = new HashMap<>();
			d = new HashSet<>();
		}
	
		public void addEdge(Node a, Node b)
		{
			if(!adj.containsKey(a))
				adj.put(a, new HashSet<>());
			adj.get(a).add(b);
		}

		public void removeEdge(Node a, Node b)
		{
			adj.get(a).remove(b);
			adj.get(b).remove(a);
		}
	}

	public static class FastIO
	{
		BufferedReader br;
		BufferedWriter bw, be;
		StringTokenizer st;

		public FastIO()
		{
			br = new BufferedReader(new InputStreamReader(System.in));
			bw = new BufferedWriter(new OutputStreamWriter(System.out));
			be = new BufferedWriter(new OutputStreamWriter(System.err));
			st = new StringTokenizer("");
		}

		private void read() throws IOException
		{
			st = new StringTokenizer(br.readLine());
		}

		public String ns() throws IOException
		{
			while(!st.hasMoreTokens())
				read();
			return st.nextToken();
		}

		public int ni() throws IOException
		{
			return Integer.parseInt(ns());
		}

		public long nl() throws IOException
		{
			return Long.parseLong(ns());
		}

		public float nf() throws IOException
		{
			return Float.parseFloat(ns());
		}

		public double nd() throws IOException
		{
			return Double.parseDouble(ns());
		}

		public char nc() throws IOException
		{
			return ns().charAt(0);
		}

		public int[] nia(int n) throws IOException
		{
			int[] a = new int[n];
			for(int i = 0; i < n; i++)
				a[i] = ni();

			return a;
		}

		public long[] nla(int n) throws IOException
		{
			long[] a = new long[n];
			for(int i = 0; i < n; i++)
				a[i] = nl();

			return a;
		}

		public char[] nca() throws IOException
		{
			return ns().toCharArray();
		}

		public void out(String s) throws IOException
		{
			bw.write(s);
		}

		public void flush() throws IOException
		{
			bw.flush();
			be.flush();
		}

		public void err(String s) throws IOException
		{
			be.write(s);
		}
	}
}