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 Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int k=input.nextInt();
            ArrayList<Integer> adj[]=new ArrayList[n+1];
            for(int i=1;i<=n;i++)
            {
                adj[i]=new ArrayList<>();
            }
            for(int i=0;i<n-1;i++)
            {
                int u=input.nextInt();
                int v=input.nextInt();
                adj[u].add(v);
                adj[v].add(u);
            }
            if(n==1)
            {
                out.println("NO");
            }
            else
            {
                HashMap<Integer,Integer> map=new HashMap<>();
                int visit[]=new int[n+1];
                for(int i=1;i<=n;i++)
                {
                    if(adj[i].size()==1)
                    {
                        map.put(i,3);
                        visit[i]=1;
                    }
                }
                int c=0;
                int flag=0;
                while(true)
                {
                    Iterator it=map.entrySet().iterator();
                    int count=0;
                    HashMap<Integer,Integer> map1=new HashMap<>();
                    while(it.hasNext())
                    {
                        Map.Entry e=(Map.Entry)it.next();
                        int v=(int)e.getKey();
                        int r=(int)e.getValue();
                        if(r<3)
                        {
                            flag=1;
                            break;
                        }
                        else
                        {
                            int co=0;
                            for(int i=0;i<adj[v].size();i++)
                            {
                                if(visit[adj[v].get(i)]==0)
                                {
                                    int ver=adj[v].get(i);
                                    if(map1.containsKey(ver))
                                    {
                                        map1.put(ver,map1.get(ver)+1);
                                    }
                                    else
                                    {
                                        map1.put(ver,1);
                                    }
                                    co++;
                                }
                            }
                            if(co==0)
                            {
                                count++;
                            }
                            else if(co>1)
                            {
                                flag=1;
                                break;
                            }
                        }
                    }
                    if(flag==1)
                    {
                        break;
                    }
                    map=new HashMap<>();
                    it=map1.entrySet().iterator();
                    while(it.hasNext())
                    {
                        Map.Entry e=(Map.Entry)it.next();
                        int ver=(int)e.getKey();
                        int r=(int)e.getValue();
                        visit[ver]=1;
                        map.put(ver,r);
                    }
                    c++;
                    if(count==1)
                    {
                        break;
                    }
                    else if(count>1)
                    {
                        flag=1;
                        break;
                    }
                }
                if(flag==1)
                {
                    out.println("NO");
                }
                else
                {
                    c--;
                    if(c==k)
                    {
                        out.println("YES");
                    }
                    else
                    {
                        out.println("NO");
                    }
                }
            }
        }
        out.close();
    }
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
        public FastReader()
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt()
        {
            return Integer.parseInt(next());
        }
        long nextLong()
        {
            return Long.parseLong(next());
        }
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}