#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

const int maxn=;

const long long oo=1000000000000000LL;

int n;

long long c;

int nn;

long long k1[maxn];

int pla[maxn];

long long len[maxn];

long long l,r,mid,ans;

int cntedge=;

int head[maxn]={};

int to[maxn<<],nex[maxn<<],dist[maxn<<];

void Addedge(int x,int y,int z){

    nex[++cntedge]=head[x];

    to[cntedge]=y;

    dist[cntedge]=z;

    head[x]=cntedge;

}

int vis[maxn];

int p[maxn],cntn;

int lp,rp;

int father[maxn];

long long d[maxn];

long long tmpd[maxn];

void Dfs0(int now,int fa){

    father[now]=fa;

    for(int i=head[now];i;i=nex[i]){

        if(to[i]==fa)continue;

        d[to[i]]=d[now]+dist[i];

        Dfs0(to[i],now);

    }

}

void GetD(int x){

    vis[x]=;

    if(father[x])GetD(father[x]);

    p[++cntn]=x;

}

long long Getdist(int x,int fa){

    long long ret=;

    for(int i=head[x];i;i=nex[i]){

        if(to[i]==fa)continue;

        if(vis[to[i]])continue;

        ret=max(ret,dist[i]+Getdist(to[i],x));

    }

    return ret;

}

struct FenwickTree{

    long long c[maxn];

    void Addp(int x,long long val){

        while(x<=nn){

            c[x]=max(c[x],val);

            x+=(x&(-x));

        }

    }

    long long Querymax(int x){

        long long ret=-oo;

        while(x){

            ret=max(ret,c[x]);

            x-=(x&(-x));

        }

        return ret;

    }

    void Clea(){

        for(int i=;i<=nn;++i)c[i]=-oo;

    }

}T[];

int Isok(){

    long long lim1=-oo,lim2=-oo,lim3=-oo,lim4=-oo;

    T[].Clea();T[].Clea();

    for(int i=;i<=cntn;++i){

        int p=lower_bound(k1+,k1++nn,d[i]+len[i]-mid)-k1;

        long long mxsum=T[].Querymax(p-);

        long long mxdelt=T[].Querymax(p-);

        lim1=max(lim1,d[i]+len[i]+mxsum+c-mid);

        lim2=max(lim2,-d[i]+len[i]+mxsum+c-mid);

        lim3=max(lim3,d[i]+len[i]+mxdelt+c-mid);

        lim4=max(lim4,-d[i]+len[i]+mxdelt+c-mid);

        T[].Addp(pla[i],d[i]+len[i]);

        T[].Addp(pla[i],-d[i]+len[i]);

    }

    int p1=,p2=;

    int fla=;

    for(int i=;i<=cntn;++i){

        long long tl=max(lim1-d[i],lim2+d[i]);

        long long tr=min(-lim3+d[i],-lim4-d[i]);

        if(tl>tr)continue;

        while((d[p1]<tl)&&(p1<=cntn))++p1;

        while((d[p1-]>=tl)&&(p1>))--p1;

        while((d[p2+]<=tr)&&(p2<cntn))++p2;

        while((d[p2]>tr)&&(p2>=))--p2;

        if(p1<=p2){

            fla=;break;

        }

    }

    return fla;

}

void Minit(){

    cntn=lp=rp=cntedge=nn=;

    l=;r=oo;ans=oo;

    memset(len,,sizeof(len));

    memset(head,,sizeof(head));

    memset(vis,,sizeof(vis));

    memset(p,,sizeof(p));

    memset(father,,sizeof(father));

    memset(d,,sizeof(d));

}

int main(){

    scanf("%d%lld",&n,&c);

    while(n!=){

        Minit();

        for(int i=;i<=n-;++i){

            int x,y,z;

            scanf("%d%d%d",&x,&y,&z);

            Addedge(x,y,z);

            Addedge(y,x,z);

        }

        d[]=;

        Dfs0(,);

        for(int i=;i<=n;++i){

            if(d[i]>d[lp])lp=i;

        }

        d[lp]=;

        Dfs0(lp,);

        for(int i=;i<=n;++i){

            if(d[i]>d[rp])rp=i;

        }

        for(int i=;i<=n;++i)tmpd[i]=d[i];

        GetD(rp);

        for(int i=;i<=cntn;++i)len[i]=Getdist(p[i],);

        for(int i=;i<=cntn;++i)l=max(l,len[i]);

        for(int i=;i<=cntn;++i)d[i]=tmpd[p[i]];

        for(int i=;i<=cntn;++i)k1[i]=d[i]-len[i];

        sort(k1+,k1++cntn);

        nn=unique(k1+,k1++cntn)-k1-;

        for(int i=;i<=cntn;++i)pla[i]=lower_bound(k1+,k1++nn,d[i]-len[i])-k1;

        r=l*+d[cntn];

        while(l<=r){

            mid=(l+r)>>;

            if(Isok()){

                ans=mid;r=mid-;

            }else{

                l=mid+;

            }

        }

        cout<<ans<<endl;

        scanf("%d%lld",&n,&c);

    }

    return ;

}