#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#include <vector>

#pragma GCC optimize("O2")
// #define int long long
#define PII pair<int,int>
#define x first
#define y second
#define For(i, l, r) for(int i = l; i <= r; i ++)

void in(int &x)
{
    char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    for(x = 0; c >= '0' && c <= '9'; c = getchar())
        x = x * 10 + c - '0';
}

using namespace std;

const int N = 5e5 + 50, M = N * 21;

int n, m;
vector<int> G[N];
int g[N], siz[N], son[N];
int rt[N], tot;
signed lc[M], rc[M], sz[M], tag[M], val[M], key[M];

int New(int v)
{
    tot ++; lc[tot] = rc[tot] = 0; tag[tot] = 0; sz[tot] = 1; val[tot] = v; key[tot] = rand(); return tot;
}

int Rt;

void Add(int u, int v)
{
    tag[u] += v; val[u] += v;
}

void down(int u)
{
    if(!tag[u] || !u) return ;
    if(lc[u]) Add(lc[u], tag[u]);
    if(rc[u]) Add(rc[u], tag[u]);
    tag[u] = 0;
}

void debug(int u)
{
    if(!u) return ; down(u);
    debug(lc[u]); g[++ g[0]] = val[u]; debug(rc[u]);
}

void up(int u) {sz[u] = sz[lc[u]] + sz[rc[u]] + 1;}

int Rank(int u, int x)
{
    if(!u) return 0; down(u);
    if(x <= val[u]) return Rank(lc[u], x);
    return Rank(rc[u], x) + 1 + sz[lc[u]];
}

void split(int u, int &x, int &y, int k)
{
    // if(!k) {x = 0; y = u; return ;}
    if(!u) {x = y = 0; return ;}
    down(u);
    if(k <= sz[lc[u]]) y = u, split(lc[u], x, lc[y], k);
    else x = u, split(rc[u], rc[x], y, k - 1 - sz[lc[u]]);
    up(u);
}

void merge(int &u, int x, int y)
{
    if(!x || !y) {u = x + y; return ;}
    down(x); down(y);
    if(key[x] > key[y]) u = x, merge(rc[u], rc[x], y);
    else u = y, merge(lc[u], x, lc[y]);
    up(u);
}

void ins(int &rt, int v)
{
    int rk = Rank(rt, v), x, y, z = New(v);
    split(rt, x, y, rk); merge(y, z, y); merge(rt, x, y);
}

void Dfs(int u, int pa)
{
    siz[u] = 1;
    if(G[u].size() == 1 && u > 1)
    {
        rt[u] = New(abs(m - 2) - m);
        return ;
    }
    For(ii, 0, (int)G[u].size() - 1)
    // for(int v : G[u])
    {
        int v = G[u][ii];
        if(v == pa) continue;
        Dfs(v, u);
        if(siz[v] > siz[son[u]]) son[u] = v;
        siz[u] += siz[v];
    }
    rt[u] = rt[son[u]];
    ins(rt[u], 0);
    For(i, 0, (int)G[u].size() - 1)
    {
        int v = G[u][i];
        if(v == pa || v == son[u]) continue;
        Rt = rt[u];
        g[0] = 0;
        debug(rt[v]);
        For(j, 1, g[0]) ins(rt[u], g[j]);
     }
    if(u == 1) return ;
    if(siz[u] <= m / 2)
    {
        Add(rt[u], -2);
    }
    else 
    {
        int x, y, z;
        if(m & 1)
        {
            split(rt[u], x, y, m / 2);
            Add(x, -2); split(y, z, y, 1);
            Add(y, 2); merge(y, z, y);
            merge(rt[u], x, y);
        }
        else
        {
            split(rt[u], x, y, m / 2);
            Add(x, -2); Add(y, 2);
            merge(rt[u], x, y);
        }
    }
}

signed main()
{
    // freopen("pub.in", "r", stdin);
    // freopen("pub.out", "w", stdout);
    in(n); in(m);
    For(i, 1, n - 1) 
    {
        int u, v; in(u); in(v);
        G[u].push_back(v); G[v].push_back(u);
    }
    Dfs(1, 0);
    long long ans = 1ll * (n - 1) * m;
    g[0]=  0; debug(rt[1]);
    For(i, 1, m) ans += g[i];
    printf("%lld\n", ans);
    return 0;
}