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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Vadim
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskE {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.ni();
            int k = in.ni();
            int[][] g = new int[n][];

            int[] from = new int[n - 1];
            int[] to = new int[n - 1];
            int[] sizes = new int[n];
            for (int i = 0; i < n - 1; i++) {
                int u = in.ni() - 1;
                int v = in.ni() - 1;
                from[i] = u;
                to[i] = v;
                sizes[u]++;
                sizes[v]++;
            }
            for (int i = 0; i < n; i++) {
                g[i] = new int[sizes[i]];
            }
            for (int i = 0; i < n - 1; i++) {
                g[from[i]][--sizes[from[i]]] = to[i];
                g[to[i]][--sizes[to[i]]] = from[i];
            }
            boolean[] used = new boolean[n];
            int[] queue = new int[n];
            int qi = 0;
            int[] kval = new int[n];
            for (int i = 0; i < n; i++) {
                if (g[i].length == 1) {
                    queue[qi++] = i;
                    used[i] = true;
                }
            }
            boolean correct = true;
            for (int i = 0; i < qi; i++) {
                int v = queue[i];
                int cnt = 0;
                for (int u : g[v]) {
                    if (!used[u]) {
                        cnt++;
                        kval[u] = kval[v] + 1;
                        queue[qi++] = u;
                        used[u] = true;
                    }
                }
                if (cnt > 1) {
                    correct = false;
                    break;
                }
            }
            if (kval[queue[n - 1]] != k)
                correct = false;
            if (correct) {
                used = new boolean[n];
                int root = queue[n - 1];
                queue = new int[n];
                qi = 0;
                queue[qi++] = root;
                used[root] = true;
                for (int i = 0; i < qi; i++) {
                    if (!correct)
                        break;
                    int v = queue[i];
                    int cnt = 0;
                    for (int u : g[v]) {
                        if (!used[u]) {
                            cnt++;
                            if (kval[u] != kval[v] - 1) {
                                correct = false;
                                break;
                            }
                            queue[qi++] = u;
                            used[u] = true;
                        } else {
                            if (kval[u] != kval[v] + 1) {
                                correct = false;
                                break;
                            }
                        }
                    }
                    if (kval[v] != 0 && cnt < 3) {
                        correct = false;
                        break;
                    }
                }
            }
            out.println(correct ? "Yes" : "No");
        }

    }

    static class FastScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

        public String ns() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String rl = in.readLine();
                    if (rl == null) {
                        return null;
                    }
                    st = new StringTokenizer(rl);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

    }
}

