#include <bits/stdc++.h>

const int N = 300100, M = 1000100;

int n, m;

int trClock;
struct edg {
    int x, y, z;

    bool operator < (const edg &rhs) const {
        return z < rhs.z;
    }
} e[M], tr[N];

int fa[N];
int get(int x) {
    return fa[x] == x ? x : fa[x] = get(fa[x]);
}

int tot, head[N], edge[N * 2], ver[N * 2], Next[N * 2];
void add_edge(int u, int v, int w) {
    ver[++ tot] = v;    edge[tot] = w;    Next[tot] = head[u];    head[u] = tot;
}

int max_w[2][N];
int dep[2][N];

void dfs(int u, int fu, int type) {
    dep[type][u] = dep[type][fu] + 1;
    for (int i = head[u]; i; i = Next[i]) {
        int v = ver[i], w = edge[i];
        if (v == fu) continue;
        max_w[type][v] = std::max(max_w[type][u], w);
        dfs(v, u, type);
    }
}

int main() {
    scanf("%d%d", &n, &m);

    for (int i = 1; i <= m; i ++)
        scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].z);

    std::sort(e + 1, e + 1 + m);

    for (int i = 1; i <= n; i ++) fa[i] = i;
    for (int i = 1; i <= m; i ++) {
        int x = e[i].x, y = e[i].y;
        int p = get(x), q = get(y);

        if (p == q) continue;

        tr[++ trClock] = e[i];
        fa[p] = q;
    }

    for (int i = 1; i < n; i ++) {
        int x = tr[i].x, y = tr[i].y, z = tr[i].z;
        add_edge(x, y, z), add_edge(y, x, z);
    }

    dfs(1, 0, 0);
    dfs(n, 0, 1);

    int ans = 0x7fffffff;
    for (int i = 1; i <= m; i ++) {
        int x = e[i].x, y = e[i].y, fir = e[i].z;
        if (dep[0][x] > dep[1][x]) std::swap(x, y);
        int sec = std::max(max_w[0][x], max_w[1][y]);
        if (sec > fir) continue;
        ans = std::min(ans, fir + sec);
    }

    printf("%d\n", ans);

    return 0;
}