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

public class Main {
	public static void solve(FastIO io) {
		int N = io.nextInt();
		int K = io.nextInt();

		Node[] nodes = new Node[N + 1];
		for (int i = 1; i <= N; ++i) {
			nodes[i] = new Node();
			nodes[i].id = i;
		}

		for (int i = 1; i < N; ++i) {
			int U = io.nextInt();
			int V = io.nextInt();

			nodes[U].next.add(nodes[V]);
			nodes[V].next.add(nodes[U]);
		}

		HashSet<Node> layer = new HashSet<>();
		HashSet<Node> seen = new HashSet<>();
		for (int i = 1; i <= N; ++i) {
			if (nodes[i].next.size() == 1) {
				// System.out.format("starting with %d\n", nodes[i].id);
				nodes[i].straighten(seen);
				layer.add(nodes[i]);
			}
		}

		for (int i = 0; i < K; ++i) {
			if (layer.isEmpty()) {
				io.println("No");
				return;
			}
			HashSet<Node> next = new HashSet<>();
			for (Node u : layer) {
				// System.out.format("layer %d: u = %d\n", i, u.id);
				if (u.straighten(seen) != Node.StraightenResult.OK) {
					io.println("No");
					return;
				}
				if (seen.contains(u.parent)) {
					io.println("No");
					return;
				}
				next.add(u.parent);
				// io.printf("adding parent: %d -> %d\n", u.id, u.parent.id);
			}
			seen.addAll(layer);
			layer = next;
		}

		if (layer.size() != 1) {
			io.println("No");
			return;
		}

		if (layer.iterator().next().straighten(seen) != Node.StraightenResult.NO_PARENT) {
			io.println("No");
			return;
		}

		for (int i = 1; i <= N; ++i) {
			int cs = nodes[i].children.size();
			// System.out.format("node %d: children count = %d\n", i, cs);
			if (0 < cs && cs < 3) {
				io.println("No");
				return;
			}
		}

		io.println("Yes");
	}

	private static class Node {
		public enum StraightenResult {
			OK,
			NO_PARENT,
			MULTIPLE_PARENT,
		}

		int id;
		public ArrayList<Node> next = new ArrayList<>();
		
		public Node parent;
		public ArrayList<Node> children = new ArrayList<>();

		private StraightenResult straighten(HashSet<Node> seen) {
			Node p = null;
			for (Node v : next) {
				if (!seen.contains(v)) {
					if (p == null) {
						p = v;
					} else {
						return StraightenResult.MULTIPLE_PARENT;
					}
				} else {
					children.add(v);
				}
			}
			if (p == null) {
				return StraightenResult.NO_PARENT;
			}
			parent = p;
			return StraightenResult.OK;
		}
	}

	public static class FastIO {
		private InputStream reader;
		private PrintWriter writer;

		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public FastIO(InputStream r, OutputStream w) {
			reader = r;
			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(w)));
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = reader.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			return nextIntArray(n, 0);
		}

		public int[] nextIntArray(int n, int off) {
			int[] arr = new int[n + off];
			for (int i = 0; i < n; i++) {
				arr[i + off] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			return nextLongArray(n, 0);
		}

		public long[] nextLongArray(int n, int off) {
			long[] arr = new long[n + off];
			for (int i = 0; i < n; i++) {
				arr[i + off] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		public void print(Object... objects) {
			for (int i = 0; i < objects.length; i++) {
				if (i != 0) {
					writer.print(' ');
				}
				writer.print(objects[i]);
			}
		}

		public void println(Object... objects) {
			print(objects);
			writer.println();
		}

		public void printArray(int[] arr) {
			for (int i = 0; i < arr.length; i++) {
				if (i != 0) {
					writer.print(' ');
				}
				writer.print(arr[i]);
			}
		}

		public void printArray(long[] arr) {
			for (int i = 0; i < arr.length; i++) {
				if (i != 0) {
					writer.print(' ');
				}
				writer.print(arr[i]);
			}
		}

		public void printlnArray(int[] arr) {
			printArray(arr);
			writer.println();
		}

		public void printlnArray(long[] arr) {
			printArray(arr);
			writer.println();
		}

		public void printf(String format, Object... args) {
			print(String.format(format, args));
		}

		public void flush() {
			writer.flush();
		}
	}

	public static void main(String[] args) {
		FastIO io = new FastIO(System.in, System.out);
		solve(io);
		io.flush();
	}
}