#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

ifstream fin ("radiatie.in");
ofstream fout ("radiatie.out");

struct pl	 {
	int nod, cost;
} t[15005][20];

int n, m, k, ans;
int tata[15005], adancime[15005];

vector <pl> v[15005];

struct idk	{
	int x, y, c;
} a[30005];

bool cmp(idk _x, idk _y)	 {
	return _x.c < _y.c;
}

inline int find_tata(int nod)	{
	while (tata[nod] > 0)
		nod = tata[nod];
	return nod;
}

inline bool same_tree(int x, int y)	{
  int tx = find_tata(x);
  int ty = find_tata(y);
  return (tx == ty);
}

inline void set_tata(int nod, int tx)	{
	while (nod > 0)	 {
		int aux = tata[nod];
		tata[nod] = tx;
		nod = aux;
	}
}

inline void Union(int x, int y)	{
	int tx = find_tata(tx);
	int ty = find_tata(ty);
  if (tata[tx] > tata[ty])
		swap(tx, ty), swap(x, y);
	tata[tx] += tata[ty];
	set_tata(y, tx);
}

inline void dfs(int nod, int A)	 {
	adancime[nod] = A;
	for (int i = 0; i < v[nod].size(); ++i)	{
    if (v[nod][i].nod == t[nod][1].nod)
			continue;
		t[v[nod][i].nod][1].cost = v[nod][i].cost;
		t[v[nod][i].nod][1].nod = nod;
		dfs(v[nod][i].nod, A + 1);
	}
}

inline int TATA(int x, int sus)	{
  for (int i = 1 << 14, j = 15; i; i >>= 1, --j)	 {
    if (sus < i)
			continue;
    sus -= i;
		ans = max(ans, t[x][j].cost);
    x = t[x][j].nod;
  }
  return x;
}

inline void lca(int x, int y)	{
  ans = 0;
  if (adancime[x] > adancime[y])
		x = TATA(x, adancime[x] - adancime[y]);
  if (adancime[y] > adancime[x])
		y = TATA(y, adancime[y] - adancime[x]);
	int ans1 = 2e9;
  for (int i = 1 << 14, j = 15; i; i >>= 1, --j)	{
		if (t[x][j].nod == t[y][j].nod)	 {
			ans1 = min(ans1, max(t[x][j].cost, t[y][j].cost));
		}
  }
  fout << max(ans1, ans) << '\n';
}

int main()	{
  fin >> n >> m >> k;
  for (int i = 1; i <= n; ++i)
		tata[i] = -1;
  for (int i = 1; i <= m; ++i)
		fin >> a[i].x >> a[i].y >> a[i].c;
	sort (a + 1, a + m + 1, cmp);
	for (int i = 1; i <= m; ++i)	{
		if (same_tree(a[i].x, a[i].y))
			continue;
//		Union(a[i].x, a[i].y);
//		v[a[i].x].push_back({a[i].y, a[i].c});
//		v[a[i].y].push_back({a[i].x, a[i].c});
	}
//  dfs(1, 1);
//  for (int i = 1; i <= 14; ++i)	 {
//		for (int j = 1; j <= n; ++j)	{
//      if (!t[j][i].nod || !t[t[j][i].nod][i].nod)
//				continue;
//			t[j][i + 1].nod = t[t[j][i].nod][i].nod;
//			t[j][i + 1].cost = max(t[t[j][i].nod][i].cost, t[j][i].cost);
//		}
//  }
//  int x, y;
//  while (k--)	 {
//		fin >> x >> y;
//		lca(x, y);
//  }
	return 0;
}