const int Q = (int)6e5 + 7;

int n, m, cur;
pll cl[Q];
int was[MAXN];
int col[MAXN];
vector < pair <pii, ll> > e;
map <pii, ll> q;
map <pii, bool> us;
vi rg[MAXN], gs[MAXN];
vpll g[MAXN], p[MAXN];
vi order;
vll dpmnup, dpmxup, dpmndn, dpmxdn;

void dfs1(int u)
{
    was[u] = 1;
    for (auto to : gs[u])
    {
        if (!was[to])
            dfs1(to);
    }
    order.inb(u);
}

void dfs2(int u)
{
    col[u] = cur;
    for (auto to : rg[u])
    {
        if (col[to] == cur)
        {
            cl[cur].X = min(cl[cur].X, q[mk(to, u)]);
            cl[cur].Y = max(cl[cur].Y, q[mk(to, u)]);
        }
        if (!col[to])
            dfs2(to);
    }
}

void calcmnup(int u)
{
    if (cl[u].X >= 0 && cl[u].X <= 1000000000)
        dpmnup[u] = cl[u].X;
    else
        dpmnup[u] = INF;
    was[u] = 1;
    for (auto to : g[u])
    {
        if (!was[to.X])
            calcmnup(to.X);
        dpmnup[u] = min(dpmnup[u], dpmnup[to.X]);
        dpmnup[u] = min(dpmnup[u], to.Y);
    }
}

void calcmxup(int u)
{
    if (cl[u].Y >= 0 && cl[u].Y <= 1000000000)
        dpmxup[u] = cl[u].Y;
    else
        dpmxup[u] = -INF;
    was[u] = 1;
    for (auto to : g[u])
    {
        if (!was[to.X])
            calcmxup(to.X);
        dpmxup[u] = max(dpmxup[u], dpmxup[to.X]);
        dpmxup[u] = max(dpmxup[u], to.Y);
    }
}

void calcmndn(int u)
{
    if (cl[u].X >= 0 && cl[u].X <= 1000000000)
        dpmndn[u] = cl[u].X;
    else
        dpmndn[u] = INF;
    was[u] = 1;
    for (auto to : p[u])
    {
        if (!was[to.X])
            calcmndn(to.X);
        dpmndn[u] = min(dpmndn[u], dpmndn[to.X]);
        dpmndn[u] = min(dpmndn[u], to.Y);
    }
}

void calcmxdn(int u)
{
    if (cl[u].Y >= 0 && cl[u].Y <= 1000000000)
        dpmxdn[u] = cl[u].Y;
    else
        dpmxdn[u] = -INF;
    was[u] = 1;
    for (auto to : p[u])
    {
        if (!was[to.X])
            calcmxdn(to.X);
        dpmxdn[u] = max(dpmxdn[u], dpmxdn[to.X]);
        dpmxdn[u] = max(dpmxdn[u], to.Y);
    }
}

int solve()
{
    scanf("%d %d", &n, &m);
    dpmnup.resize(MAXN);
    dpmxup.resize(MAXN);
    dpmndn.resize(MAXN);
    dpmxdn.resize(MAXN);
    fill(cl, cl + MAXN, mk(INF, -INF));
    forn(i, m)
    {
        int x, y;
        ll c;
        scanf("%d %d %lld", &x, &y, &c);
        --x, --y;
        rg[y].inb(x);
        q[mk(x, y)] = c;
        gs[x].inb(y);
        e.inb(mk(mk(x, y), c));
    }
    forn(i, n)
    {
        if (!was[i])
            dfs1(i);
    }
    forn(i, order.size())
    {
        if (!col[order[n - i - 1]])
        {
            ++cur;
            dfs2(order[n - i - 1]);
        }
    }
    forn(i, m)
    {
        int a = e[i].X.X;
        int b = e[i].X.Y;
        ll cst = e[i].Y;
        g[a].inb(mk(b, cst));
        p[b].inb(mk(a, cst));
    }
    ll ans = 0;
    for (int i = 1; i <= cur; ++i)
    {
        if (cl[i].Y != -INF && cl[i].X != INF)
            ans = max(ans, (ll)cl[i].Y - cl[i].X);
    }
    memset(was, 0, sizeof(was));
    for1(i, cur)
    {
        if (!was[i])
            calcmndn(i);
    }
    memset(was, 0, sizeof(was));
    for1(i, cur)
    {
        if (!was[i])
            calcmxdn(i);
    }
    memset(was, 0, sizeof(was));
    for1(i, cur)
    {
        if (!was[i])
            calcmnup(i);
    }
    memset(was, 0, sizeof(was));
    for1(i, cur)
    {
        if (!was[i])
            calcmxup(i);
    }
    for (int i = 1; i <= cur; ++i)
    {
        ll mnup = dpmnup[i];
        ll mxup = dpmxup[i];
        ll mndn = dpmndn[i];
        ll mxdn = dpmxdn[i];
        if (mnup <= 1000000000 && mnup >= 0 && mxdn >= 0 && mxdn <= 1000000000)
            ans = max(ans, (ll)mxdn - mnup);
        if (mndn <= 1000000000 && mndn >= 0 && mxup >= 0 && mxup <= 1000000000)
            ans = max(ans, (ll)mxup - mndn);
    }
    cout << ans;
    return 0;
}