#include <bits/stdc++.h>
using namespace std;


const int MAXN = 200005;
const int MAXK = 105;

vector<int> g[MAXN];
int dp[MAXN][MAXK], dp2[MAXN][MAXK];
int N, K;
int mx[MAXK], mx2[MAXK];
int cnt[MAXK];

void dfs(int u, int p) {
  for (int v : g[u]) {
    if (v == p) continue;
    dfs(v, u);
  }

  dp2[u][0] = 1;
  dp[u][0] = 1;
  for (int v : g[u]) {
    if (v == p) continue;
    dp[u][0] = max(dp[u][0], 1 + dp[v][0]);
  }

  for (int j = 1; j <= K; ++j) {
    dp2[u][j] = 1;
    dp[u][j] = 1;

    // dp2[u][j]: must end at u → single child + back
    for (int v : g[u]) {
      if (v == p) continue;
      dp2[u][j] = max(dp2[u][j], 1 + dp2[v][j - 1]);
    }

    // dp[u][j]: unconstrained
    dp[u][j] = max(dp[u][j], dp2[u][j]);
    for (int v : g[u]) {
      if (v == p) continue;
      dp[u][j] = max(dp[u][j], 1 + dp[v][j]);
    }

    // merge two children
    for (int r = 0; r < MAXK; ++r) {
      mx[r] = mx2[r] = 0;
      cnt[r] = 0;
    }

    for (int v : g[u]) {
      if (v == p) continue;
      for (int rem = 0; rem <= j - 1; ++rem) {
        int val = dp[v][rem];
        if (val > mx[rem]) {
          mx2[rem] = mx[rem];
          mx[rem] = val;
          cnt[rem] = 1;
        } else if (val == mx[rem]) {
          cnt[rem]++;
        } else if (val > mx2[rem]) {
          mx2[rem] = val;
        }
      }
    }

    for (int v : g[u]) {
      if (v == p) continue;
      for (int x = 0; x <= j - 1; ++x) {
        int left = dp2[v][x];
        int rem = j - 1 - x;
        if (rem < 0) continue;

        int take = 0;
        if (dp[v][rem] == mx[rem]) {
          if (cnt[rem] > 1) take = mx[rem];
          else take = mx2[rem];
        } else {
          take = mx[rem];
        }

        if (take > 0) {
          dp[u][j] = max(dp[u][j], 1 + left + take);
        }
      }
    }
  }
}

int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);

  cin >> N >> K;
  for (int i = 1; i < N; ++i) {
    int u, v;
    cin >> u >> v;
    g[u].push_back(v);
    g[v].push_back(u);
  }

  dfs(1, 0);

  int ans = 0;
  for (int j = 0; j <= K; ++j) {
    ans = max(ans, dp[1][j]);
  }

  cout << ans << '\n';
}