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.
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class x1067B
   {
      static ArrayDeque<Integer>[] edges;
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int K = Integer.parseInt(st.nextToken());
         edges = new ArrayDeque[N+1];
         for(int i=1; i <= N; i++)
            edges[i] = new ArrayDeque<Integer>();
         for(int i=1; i < N; i++)
         {
            st = new StringTokenizer(infile.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            edges[a].add(b);  edges[b].add(a);
         }
         int[] par = new int[N+1];
         int[] cnt = new int[N+1];
         int leaf = 1;
         for(int v=1; v <= N; v++)
            if(edges[v].size() == 1)
               leaf = v;
         Queue<Integer> q = new LinkedList<Integer>();
         q.add(leaf);   par[leaf] = -1;
         int max = 0;
         while(q.size() > 0)
         {
            int curr = q.poll();
            for(int next: edges[curr])
               if(par[next] == 0)
               {
                  par[next] = curr;
                  cnt[next] = cnt[curr]+1;
                  q.add(next);
                  max = Math.max(max, cnt[next]);
               }  
         }
         int center = 0;
         for(int v=1; v <= N; v++)
            if(cnt[v] == max)
            {
               ArrayList<Integer> path = new ArrayList<Integer>();
               int temp = v;
               while(temp != leaf)
               {
                  path.add(temp);
                  temp = par[temp];
               }
               path.add(leaf);
               if(path.size()%2 == 0)
               {
                  System.out.println("No");
                  return;
               }
               center = path.get(path.size()/2);
               break;
            }
         if(works(center, K) && N+K != 2)
            System.out.println("Yes");
         else
            System.out.println("No");
      }
      public static boolean works(int root, int K)
      {
         ArrayDeque<Integer> q = new ArrayDeque<Integer>();
         boolean[] seen = new boolean[edges.length];
         q.add(root);   seen[root] = true;
         q.add(0);
         while(q.size() > 0)
         {
            int curr = q.poll();
            int layer = q.poll();
            if(curr != root && edges[curr].size() == 3 || edges[curr].size() == 2)
               return false;
            for(int next: edges[curr])
               if(!seen[next])
               {
                  seen[next] = true;
                  q.add(next); 
                  q.add(layer+1);
               }
            if(edges[curr].size() == 1 && layer != K)
               return false;
         }
         return true;
      }
   }