#include <bits/stdc++.h>
using namespace std;
struct hopcroftKarp {
  vector<vector<int>> g;
  int n;
  vector<int> p;
  vector<int> mat;
  vector<int> mat_rev;
  unordered_set<int> leftSet;
  unordered_set<int> matchedSet2;
  hopcroftKarp(vector<vector<int>> g_, int n_, unordered_set<int> l) {
    g = g_;
    n = n_;
    leftSet = l;
    mat.resize(n + 1, -1);
    mat_rev.resize(n + 1, -1);
  }
  vector<int> bfs() {
    p.clear();
    p.resize(n + 1, -1);
    vector<int> ans;
    queue<int> q;
    unordered_set<int> vis;
    for (int i : leftSet) {
      if (mat[i] == -1) {
        q.push(i);
        vis.insert(i);
      }
    }
    while (q.size()) {
      int last = q.front();
      q.pop();
      for (int next : g[last]) {
        if (vis.count(next)) continue;
        vis.insert(next);
        p[next] = last;
        if (matchedSet2.count(next)) {
          q.push(mat_rev[next]);
          p[mat_rev[next]] = next;
        } else {
          ans.push_back(next);
          break;
        }
      }
    }
    return ans;
  }
  void makeboth(int a, int b) {
    if (mat[a] != -1) {
      mat_rev[mat[a]] = -1;
      mat[a] = -1;
      matchedSet2.erase(mat[a]);
    }
    if (mat_rev[b] != -1) {
      mat[mat_rev[b]] = -1;
      mat_rev[b] = -1;
    }
    mat[a] = b;
    mat_rev[b] = a;
    matchedSet2.insert(b);
  }
  vector<pair<int, int>> match() {
    vector<int> augmentedPath = bfs();
    while (augmentedPath.size()) {
      for (int endNode : augmentedPath) {
        vector<int> path;
        path.push_back(endNode);
        while (p[endNode] != -1) {
          int lastNode = p[endNode];
          path.push_back(lastNode);
          p[endNode] = -1;
          endNode = lastNode;
        }
        if (leftSet.count(endNode) && mat[endNode] == -1) {
          assert(path.size() % 2 == 0);
          for (int i = path.size() - 1; i >= 0; i -= 2) {
            makeboth(path[i], path[i - 1]);
          }
        }
      }
      augmentedPath = bfs();
    }
    vector<pair<int, int>> ans;
    for (int i = 1; i <= n; i++) {
      if (mat[i] != -1) {
        ans.push_back({i, mat[i]});
      }
    }
    return ans;
  }
};
int n, m;
vector<array<int, 3>> all;
bool can(int t) {
  vector<vector<int>> ans(2 * n + 1);
  unordered_set<int> l;
  for (auto it : all) {
    if (it[2] <= t) {
      ans[it[0]].push_back(it[1] + n);
      ans[it[1] + n].push_back(it[0]);
      l.insert(it[0]);
    }
  }
  hopcroftKarp hopcroftKarp(ans, n * 2, l);
  return hopcroftKarp.match().size() == n;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> m;
  all.resize(m);
  for (int i = 0; i < m; i++) {
    cin >> all[i][0] >> all[i][1] >> all[i][2];
  }
  int l = 1, r = 1e9;
  int ans = -1;
  while (l <= r) {
    int mid = l + (r - l) / 2;
    if (can(mid)) {
      r = mid - 1;
      ans = mid;
    } else {
      l = mid + 1;
    }
  }
  cout << ans << endl;
}
