#pragma GCC optimize("O3,unroll-loops,inline")

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
//#define int ll
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()

constexpr int INF = 1e9;

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

int idi_naxui(vector<edge> &e, int n) {
    int m = e.size();
    vector<int> j;
    while (true) {
        vector<int> x1, x2, color(m, 0);
        for (int i : j)
            ++color[e[i].c];
        vector<bool> used(m, false);
        for (int i : j)
            used[i] = true;
        // vector<vector<int>> gr(m);
        for (int k = 0; k < m; ++k)
            if (!used[k])
                if (color[e[k].c] == 0)
                    x2.push_back(k);
        vector<int> comp(n, -1);
        int cnt = 0;
        vector<vector<int>> trees(n);
        auto dfs = [&](auto dfs, int v, int p, vector<int>& c) -> void {
            c[v] = cnt;
            for (int u : trees[v])
                if (u != p)
                    dfs(dfs, u, v, c);
        };
        for (int q = 0; q < j.size(); ++q) {
            trees[e[j[q]].u].push_back(e[j[q]].v);
            trees[e[j[q]].v].push_back(e[j[q]].u);
        }
        for (int i = 0; i < n; ++i)
            if (comp[i] == -1) {
                dfs(dfs, i, -1, comp);
                ++cnt;
            }
        for (int k = 0; k < m; ++k)
            if (!used[k])
                if (comp[e[k].u] != comp[e[k].v])
                    x1.push_back(k);
        auto calc = [&](int i) -> vector<int> {
            vector<int> res;
            if (used[i]) {
                for (int q = 0; q < n; ++q)
                    trees[q].clear();
                for (int q = 0; q < j.size(); ++q)
                    if (j[q] != i) {
                        trees[e[j[q]].u].push_back(e[j[q]].v);
                        trees[e[j[q]].v].push_back(e[j[q]].u);
                    }
                cnt = 0;
                vector<int> cd(n, -1);
                for (int k = 0; k < n; ++k)
                    if (cd[k] == -1) {
                        dfs(dfs, k, -1, cd);
                        ++cnt;
                    }
                for (int k = 0; k < m; ++k)
                    if (!used[k]) {
                        if (comp[e[k].u] != comp[e[k].v])
                            res.push_back(k);
                        else if (cd[e[k].u] != cd[e[k].v])
                            res.push_back(k);
                    }
            } else {
                for (int k = 0; k < j.size(); ++k)
                    if (color[e[i].c] == 0)
                        res.push_back(j[k]);
                    else if (e[i].c == e[j[k]].c)
                        res.push_back(j[k]);
            }
            return res;
        };
        if (x1.empty() || x2.empty()) {
            break;
        }
        vector<bool> inx1(m, false), inx2(m, false);
        for (int i = 0; i < x1.size(); ++i)
            inx1[x1[i]] = true;
        for (int i = 0; i < x2.size(); ++i)
            inx2[x2[i]] = true;
        bool fl = false;
        for (int i = 0; i < m; ++i)
            if (inx1[i] && inx2[i]) {
                j.push_back(i);
                fl = true;
                break;
            }
        if (fl)
            continue;
        // vector<bool> cgr(m, false);
        vector<int> dist(m, INF), prev(m, -1);
        deque<int> bfs;
        for (int i = 0; i < x1.size(); ++i)
            bfs.push_back(x1[i]), dist[x1[i]] = 0;
        while (!bfs.empty()) {
            int v = bfs.front();
            bfs.pop_front();
            for (int u : calc(v))
                if (dist[v] + 1 < dist[u]) {
                    dist[u] = dist[v] + 1;
                    bfs.push_back(u);
                    prev[u] = v;
                }
        }
        int ind = x2[0];
        for (int i = 1; i < x2.size(); ++i)
            if (dist[x2[i]] < dist[ind])
                ind = x2[i];
        if (dist[ind] == INF)
            break;
        vector<int> rebuild(m, 0);
        for (int i : j)
            rebuild[i] ^= 1;
        int last = ind;
        while (last != -1) {
            rebuild[last] ^= 1;
            last = prev[last];
        }
        vector<int> new_j;
        for (int i = 0; i < m; ++i)
            if (rebuild[i])
                new_j.push_back(i);
        j = new_j;
    }
    return j.size();
}

void solve() {
    int n, m;
    cin >> n >> m;
    vector<edge> e(m);
    for (auto &i: e)
        cin >> i.u >> i.v >> i.c, --i.u, --i.v;
    int l = 0, r = m + 1;
    while (r - l > 1) {
        int mid = (l + r) / 2;
        vector<edge> ee;
        for (auto i : e)
            if (i.c < mid)
                ee.push_back(i);
        if (idi_naxui(ee, n) == mid)
            l = mid;
        else
            r = mid;
    }
    cout << l;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int t = 1;
//    cin >> t;
    while (t--) solve();
}