/*
_/_/_/_/    _/_/_/_/_/  _/_/_/
_/      _/      _/    _/      _/
_/      _/      _/    _/      _/
_/      _/      _/    _/      _/
_/      _/      _/    _/  _/  _/
_/      _/  _/  _/    _/    _/_/
_/_/_/_/      _/_/     _/_/_/_/_/

_/_/_/_/    _/    _/  _/      _/
_/      _/   _/  _/   _/_/  _/_/
_/      _/    _/_/    _/ _/_/ _/
_/      _/     _/     _/  _/  _/
_/      _/    _/_/    _/      _/
_/      _/   _/  _/   _/      _/
_/_/_/_/    _/    _/  _/      _/

_/_/_/_/_/ _/_/_/_/_/ _/_/_/_/_/
    _/         _/     _/
    _/         _/     _/
    _/         _/     _/_/_/_/
    _/         _/     _/
    _/         _/     _/
    _/     _/_/_/_/_/ _/_/_/_/_/

_/_/_/_/_/ _/_/_/_/_/ _/_/_/_/_/
    _/         _/     _/
    _/         _/     _/
    _/         _/     _/_/_/_/
    _/         _/     _/
    _/         _/     _/
    _/     _/_/_/_/_/ _/_/_/_/_/
*/
#include <cassert>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <iomanip>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<class T>
istream &operator>>(istream &is, vector<T> &v) {
  for (T &x : v)
    is >> x;
  return is;
}

template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

const int P = 998244353;

int norm(int x) { return x >= P ? (x - P) : x; }

void add(int &x, int y) { if ((x += y) >= P) x -= P; }

void sub(int &x, int y) { if ((x -= y) < 0) x += P; }

void exGcd(int a, int b, int &x, int &y) {
  if (!b) {
    x = 1;
    y = 0;
    return;
  }
  exGcd(b, a % b, y, x);
  y -= a / b * x;
}

int inv(int a) {
  int x, y;
  exGcd(a, P, x, y);
  return norm(x + P);
}

const int N = 3010, L = 15;

int A[L], B[L];
int f[L][N];
int ans[N], q[N];

int main() {
#ifdef ELEGIA
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, k;
  cin >> n >> k;

  for (int i = 1; i != L; ++i) {
    B[i] = (1 << i) - 1;
    A[i] = A[i - 1] + B[i];
  }

  f[0][0] = 1;
  for (int i = 0; i <= n; ++i) {
    for (int j = 1; A[j] <= i; ++j)
      sub(f[0][i], f[j][i - A[j]]);
    int j;
    for (j = 1; B[j] <= i; ++j)
      f[j][i] = norm(P - f[j - 1][i] + f[j][i - B[j]]);
    for (; B[j] <= n; ++j)
      f[j][i] = norm(P - f[j - 1][i]);
  }

  {
    int C = 0;
    for (int i = 0; C <= n; ++i, C = A[i]) {
      if (i)
        for (int j = B[i]; j <= n; ++j) add(f[0][j], f[0][j - B[i]]);
      memset(q, 0, sizeof(q));
      if (i & 1)
        for (int j = 0; j <= n - C; ++j) sub(q[j + C], f[0][j]);
      else for (int j = 0; j <= n - C; ++j) add(q[j + C], f[0][j]);
      for (int j = 1; j <= n >> i; ++j)
        add(ans[j], q[n - j * (1 << i)]);
    }
  }

  cout << ans[k] << '\n';

#ifdef ELEGIA
  LOG("Time: %dms\n", int ((clock()
      -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}

# include <bits/stdc++.h>
# define ll long long
# define db double
# define ld long double
# define pb push_back
# define fir first
# define sec second
# define rep(i, l, r) for (int i = l; i <= r; i++)
# define per(i, r, l) for (int i = r; i >= l; i--)
using namespace std;
const int N = 200010;
typedef pair <int, int> P;

struct node {
    int to, next;
} ed[N * 2];

int sz, head[N], n, k;
set <P, greater <P> > ss;

void addEdge(int from, int to) {
    ed[++sz].next = head[from];
    ed[sz].to = to;
    head[from] = sz;
}

int read() {
    int x = 0; char c = getchar(), flag = '+';
    while (!isdigit(c)) flag = c, c = getchar();
    while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
    return flag == '-' ? -x : x;
}
// void dfs2(int u, int dis) {
//     ss.erase(P(deep[u], u));
//     if (!dis) return;
//     for (int i = head[u]; i; i = ed[i].next) {
//         int v = ed[i].to;
//        // if (v == ff) continue;
//         dfs2(v, dis - 1);
//     }
// }
P dfs(int u, int ff, int x) {
    P ss = P(0, 0);
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].to;
        if (v == ff) continue;
        P tt = dfs(v, u, x);
        tt.sec++;
        ss.fir += tt.fir;

        if (ss.sec + tt.sec < 0) ss.sec = min(ss.sec, tt.sec);
        else ss.sec = max(ss.sec, tt.sec);

    }
    if (ss.sec == x || u == 1 && ss.sec >= 0) ss.fir++, ss.sec = -x - 1;
    return ss; 
}
bool check(int x){
    return dfs(1, 0, x).fir <= k;
}

// void dfs1(int u, int ff) {
//     deep[u] = deep[ff] + 1;
//     fa[u] = ff;
//     for (int i = head[u]; i; i = ed[i].next) {
//         int v = ed[i].to;
//         if (v == ff) continue;
//         dfs1(v, u);
//     }
// }
int main() {
    n = read(), k = read();
    rep (i, 1, n - 1) {
        int u = read(), v = read();
        addEdge(u, v);
        addEdge(v, u);
    }
    //dfs1(1, 0);

    int l = 0, r = n, ans = -1;
    while (l <= r) {
        int mid = l + r >> 1;
        if (check(mid)) ans = mid, r = mid - 1;
        else l = mid + 1;
    }
    cout << ans;
    return 0;
}
/* by DT_Kang */