#pragma GCC optimize("")

#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 = 1e18;

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(n + 1, 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 i = 0; i < j.size(); ++i)
            for (int k = 0; k < m; ++k)
                if (!used[k]) {
                    if (color[e[k].c] == 0)
                        gr[j[i]].push_back(k);
                    else if (e[k].c == e[j[i]].c)
                        gr[j[i]].push_back(k);
                }
        for (int k = 0; k < m; ++k)
            if (!used[k])
                if (color[e[k].c] == 0)
                    x1.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 i = 0; i < j.size(); ++i) {
            for (int q = 0; q < n; ++q)
                trees[q].clear();
            for (int q = 0; q < j.size(); ++q)
                if (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])
                        gr[k].push_back(j[i]);
                    else if (cd[e[k].u] != cd[e[k].v])
                        gr[k].push_back(j[i]);
                }
        }
        for (int k = 0; k < m; ++k)
            if (!used[k])
                if (comp[e[k].u] != comp[e[k].v])
                    x2.push_back(k);
        if (x1.empty() || x2.empty()) {
            break;
        }
        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: gr[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();
}