Problem: You are given a tree $T$ and an integer $K$. You can choose arbitrary distinct two vertices $u$ and $v$ on $T$. Let $P$ be the simple path between $u$ and $v$. Then, remove vertices in $P$, and edges such that one or both of its end vertices is in $P$ from $T$. Your task is to choose $u$ and $v$ to maximize the number of connected components with $K$ or more vertices of $T$ after that operation.



Input

The input consists of a single test case formatted as follows.


$N$ $K$
$u_1$ $v_1$
:
$u_{N-1}$ $v_{N-1}$


The first line consists of two integers $N, K$ ($2 \leq N \leq 100,000, 1 \leq K \leq N$). The following $N-1$ lines represent the information of edges. The ($i+1$)-th line consists of two integers $u_i, v_i$ ($1 \leq u_i, v_i \leq N$ and $u_i \ne v_i $ for each $i$). Each $\\{u_i, v_i\\}$ is an edge of $T$. It's guaranteed that these edges form a tree.

Output

Print the maximum number of connected components with $K$ or more vertices in one line.

Examples

Input

2 1
1 2


Output

0


Input

7 3
1 2
2 3
3 4
4 5
5 6
6 7


Output

1


Input

12 2
1 2
2 3
3 4
4 5
3 6
6 7
7 8
8 9
6 10
10 11
11 12


Output

4


Input

3 1
1 2
2 3


Output

1


Input

3 2
1 2
2 3


Output

0


Input

9 3
1 2
1 3
1 4
4 5
4 6
4 7
7 8
7 9


Output

2

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
 
using namespace std;
 
using int64 = long long;
const double INF = 1e18;
 
int N, K;
vector< int > g[100000];
int subtree_size[100000];
int dp[100000];
 
int dfs(int idx, int par)
{
  subtree_size[idx] = 1;
  int add = 0, ret = 0;
  vector< int > vs;
  for(auto &to : g[idx]) {
    if(to == par) continue;
    ret = max(ret, dfs(to, idx));
    subtree_size[idx] += subtree_size[to];
    add += subtree_size[to] >= K;
    vs.emplace_back(dp[to]);
  }
  if(vs.empty()) return (0);
  sort(vs.rbegin(), vs.rend());
  dp[idx] = max(add, vs[0] + add - 1);
 
  if(N - subtree_size[idx] >= K) ++add;
  ret = max(ret, vs[0] + add - 1);
  if(g[idx].size() > add) ret = max(ret, add);
  if(vs.size() >= 2) ret = max(ret, vs[0] + vs[1] + add - 2);
  return (ret);
}
 
int main()
{
  cin >> N >> K;
  for(int i = 1; i < N; i++) {
    int a, b;
    cin >> a >> b;
    --a, --b;
    g[a].emplace_back(b);
    g[b].emplace_back(a);
  }
  cout << dfs(0, -1) << endl;
}