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

typedef long long LL;
typedef pair<int, int> PII;

const int N = 5e5 + 10, M = N * 2;

int n, s;
int h[N], e[M], w[M], ne[M], idx;
int q[N], dist[N], pre[N];
vector<PII> path;
bool st[N];

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c;
    ne[idx] = h[a], h[a] = idx ++;
}

void bfs(int start)
{
    int hh = 0, tt = 0;
    memset(dist, 0x3f, sizeof dist);
    memset(pre, -1, sizeof pre);
    dist[start] = 0;
    q[0] = start;

    while(hh <= tt)
    {
        int t = q[hh ++];
        for(int i = h[t]; ~i; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[t] + w[i])
            {
                pre[j] = t;
                dist[j] = dist[t] + w[i];
                q[++tt] = j;
            }
        }
    }
}

int get_max()
{
    int t = 1;
    for(int i = 1; i <= n; i++)
        if(dist[t] < dist[i])
            t = i;
    return t;
}

int bfs2(int start)
{
    int res = 0;
    int hh = 0, tt = 0;
    q[0] = start;

    while(hh <= tt)
    {
        int t = q[hh ++];
        res = max(res, dist[t]);

        for(int i = h[t]; ~i; i = ne[i])
        {
            int j = e[i];
            if(st[j] == false)
            {
                st[j] = true;
                dist[j] = dist[t] + w[i];
                q[ ++tt] = j;
            }
        }

    }
    return res;
}


bool check(int mid)
{
    int u = 0, v = path.size() - 1;
    while(u + 1 < path.size() && path[u + 1].second <= mid) u++;
    while(v - 1 >= 0 && path.back().second - path[v - 1].second <= mid) v--;
    if(u > v) return true;
    if(path[v].second - path[u].second > s) return false;

    memset(st, false, sizeof st);
    memset(dist, 0, sizeof dist);

    for(auto p : path) st[p.first] = true;

    for(int i = u; i <= v; i++)
        if(bfs2(path[i].first) > mid)
            return false;
    
    return true;
}

int main()
{
    cin >> n >> s;
    memset(h, -1, sizeof h);
    for(int i = 0; i < n - 1; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }

    bfs(1);
    int u = get_max();
    bfs(u);
    int v = get_max();

    while(v != -1)
    {
        path.push_back({v, dist[v]});
        v = pre[v];
    }

    reverse(path.begin(), path.end());//得到了树的直径的路径

    int l = 0, r = 2e9;
    while(l < r)
    {
        int mid = (LL)l + r >> 1;
        if(check(mid)) r = mid;
        else l = mid + 1;
    }
    
    cout << r << endl;
    return 0;
}

/*
A:
根据题意： 所有直径的中点是唯一的
偏心距也有类似的性质：不管从哪条直径来求最小偏心距，答案也是唯一的

B:
因此，我们可以找出任意一条直径。
用两次找最长路的方法：
1.任选一个点作为起点，找出距离起点最远的点u
2.再找出距离u最远的点v，则u和v之间的路径就是一条直径

C:
如果偏心距等于d是满足的，那么当偏心距大于d时也一定满足。
所以使用二分来枚举偏心距，判定该偏心距是否可以得到。

枚举偏心距x，判断在直径上是否存在一段长度不超过s的路径，
似的其余所有点到路径的距离小于等于偏心距x。

首先，我们在直径上找到与u的距离不超过x的前提下，距离u最远的点p。
同时，我们在直径上找到与v的距离不超过x的前提下，距离v最远的点q。

那么，任何从up直接分叉出去的离开直径的子树，其最远点与p的距离也不会
超过u。 所以p，q就是在满足直径两侧的那部分节点偏心距不超过x的前提下，
尽量靠近树网中心的节点。

D:
判断pq之间的距离是否不超过s，以及pq之间的所有点到其他点距离是否不超过x即可。
*/