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

#define int long long
#define PII pair<int, int>
#define fi first
#define se second
const int N = 1e6 + 10, M = 1e6 + 10;
int fa[N];
int n, m;
int d1[N], d2[N];
int vis1[N], vis2[N];

struct edge
{
    int u, v, w;
};

vector<PII> gg[N];

int l, ls, tot = 0;
edge g[M], gs[M];

void add(int u, int v, int w)
{
    l++;
    g[l].u = u;
    g[l].v = v;
    g[l].w = w;
}

void adds(int u, int v, int w)
{
    ls++;
    gs[ls].u = u;
    gs[ls].v = v;
    gs[ls].w = w;
}

void addg(int u, int v, int w)
{
    gg[u].push_back({v, w});
    gg[v].push_back({u, w});
}

// 标准并查集
int findroot(int x) { return fa[x] == x ? x : fa[x] = findroot(fa[x]); }

void Merge(int x, int y)
{
    x = findroot(x);
    y = findroot(y);
    fa[x] = y;
}

bool cmp(edge A, edge B) { return A.w < B.w; }

// Kruskal 算法
void kruskal()
{
    int cnt = 0;
    for (int i = 1; i <= m; i++)
    {
        int xr = findroot(g[i].u), yr = findroot(g[i].v);
        if (xr != yr)
        {                  // 如果父亲不一样
            Merge(xr, yr); // 合并
            tot ++ ;         // 边数增加
            adds(g[i].u, g[i].v, g[i].w);
            // tot ++ ;
            // adds(g[i].v, g[i].u, g[i].w);

            addg(g[i].u, g[i].v, g[i].w);
        }
    }
}

void dfs1(int p, int u, int w)
{
    if(vis1[u]) return ;
    for(int i = 0; i < gg[u].size(); i ++ )
    {
        int v = gg[u][i].first, vw = gg[u][i].second;
        if(p == v) continue;
        if(vis1[v] == 1) continue;
        vw = max(vw, w);
        d1[v] = vw;
        dfs1(u, v, vw);
        vis1[v] = 1;
    }
}

void dfs2(int p, int u, int w)
{
    if(vis2[u]) return ;
    for(int i = 0; i < gg[u].size(); i ++ )
    {
        int v = gg[u][i].first, vw = gg[u][i].second;
        if(p == v) continue;
        if(vis2[v] == 1) continue;
        vw = max(vw, w);
        d2[v] = vw;
        dfs2(u, v, vw);
        vis2[v] = 1;
    }
}

void solve()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        fa[i] = i;
    }
    int ans = 1e16;
    // cout << ans << endl;
    for (int i = 1; i <= m; i++)
    {
        int u, v, w;
        cin >> u >> v >> w;
        if((u == 1 && v == n) || (u == n && v == 1)) ans = min(ans, w);
        add(u, v, w);
    }
    sort(g + 1, g + m + 1, cmp);
    kruskal();

    // for (int i = 1; i <= ls; i++)
    // {
    //     cout << gs[i].u << ' ' << gs[i].v << ' ' << gs[i].w << endl;
    // }

    // for(int i = 1; i <= n; i ++ )
    // {
    //     cout << i << ": ";
    //     for(int j = 0; j < gg[i].size(); j ++ )
    //     {
    //         cout << gg[i][j].first << ' ';
    //     }
    //     cout << endl;
    // }

    dfs1(-1, 1, 0);

    // for(int i = 1; i <= n; i ++ )
    // {
    //     cout << d1[i] << ' ';
    // }
    // cout << endl;

    dfs2(-1, n, 0);

    // for(int i = 1; i <= n; i ++ )
    // {
    //     cout << d2[i] << ' ';
    // }
    // cout << endl;

    // cout << ans << endl;
    // for(int i = 1; i <= ls; i ++ )
    // {
    //     // cout << gs[i].u << ' ' << gs[i].v << ' ' << gs[i].w << endl;

    //     int u = gs[i].u, v = gs[i].v, w = gs[i].w;

    //     int du1 = d1[u], dun = d2[u];
    //     int dv1 = d1[v], dvn = d2[v];

    //     int t = max(du1, dvn);
    //     if(t <= w)
    //     {
    //         ans = min(du1 + dvn + w, ans);
    //     }
    //     t = max(dun, dv1);
    //     if(t <= w)
    //     {
    //         ans = min(dun + dv1 + w, ans);
    //     }
    // }

    for(int i = 1; i <= ls; i ++ )
    {
        // cout << g[i].u << ' ' << g[i].v << ' ' << g[i].w << endl;

        int u = gs[i].u, v = gs[i].v, w = gs[i].w;

        int du1 = d1[u], dun = d2[u];
        int dv1 = d1[v], dvn = d2[v];

        int t = max(du1, dvn);
        if(t <= w)
        {
            ans = min(du1 + dvn + w, ans);
        }
        t = max(dun, dv1);
        if(t <= w)
        {
            ans = min(dun + dv1 + w, ans);
        }
    }
    cout << ans << endl;
}

signed main()
{
    solve();

    return 0;
}