#include<bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
struct ios{
    inline char read(){
        static const int IN_LEN=1<<18|1;
        static char buf[IN_LEN],*s,*t;
        return (s==t)&&(t=(s=buf)+fread(buf,1,IN_LEN,stdin)),s==t?-1:*s++;
    }
    template <typename _Tp> inline ios & operator >> (_Tp&x){
        static char c11,boo;
        for(c11=read(),boo=0;!isdigit(c11);c11=read()){
            if(c11==-1)return *this;
            boo|=c11=='-';
        }
        for(x=0;isdigit(c11);c11=read())x=x*10+(c11^'0');
        boo&&(x=-x);
        return *this;
    }
}io;
using namespace std;
int read(){
	int x = 0,f = 0;char ch=getchar();
	while(!isdigit(ch)){if(ch=='0')f=1;ch=getchar();}
	while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
	return f?-x:x;
}
const int N = 2e6+10;
int n,m,Ans = 0;
vector<int> t[N<<2];
int fa[N],si[N],h[N],top,limit;
struct Stack{int x,y,add;}st[N];
struct Edge{int x,y,w;}e[N];
void update(int u,int l,int r,int L,int R,int x){
	if(l > R || r < L) return;
	if(L <= l && r <= R) {t[u].push_back(x);return;}
	int mid = l + r >> 1;
	update(u<<1,l,mid,L,R,x);
	update(u<<1|1,mid+1,r,L,R,x);
}
int find(int x){
	while(x^fa[x]) x = fa[x];
	return x;
}
void merge(int a,int b){
	a = find(a);b = find(b);
	if(h[a] > h[b]) swap(a,b);
	st[++top] = (Stack){a,b,h[a] == h[b]};
	si[b] += si[a];fa[a] = b;
	if(h[a] == h[b]) h[b]++;
}
void solve(int u,int l,int r)
{
	if(Ans) return;
	int lasttop = top;
	for(int i = 0;i < t[u].size();i++){
		int id = t[u].at(i);
		int x = e[id].x,y = e[id].y;
		x = find(x);y = find(y);
		if(x == y) continue;
		merge(x,y); 
	}
	if(l == r){
		int rt = find(1);
		if(si[rt] == n){
			printf("%d\n",l-1);
			Ans = 1;
			exit(0);
		}
	}
	else{
		int mid = l + r >> 1;
		solve(u<<1,l,mid);
		solve(u<<1|1,mid+1,r);
	}
	while(top > lasttop){
		h[st[top].y] -= st[top].add;
		fa[st[top].x] = st[top].x;
		si[st[top].y] -= si[st[top].x];
		top--;
	}
}
int main()
{
	io>>n>>m;
//	n = read();m = read();
	for(int i = 1;i <= m;i++)
	{
		io>>e[i].x>>e[i].y>>e[i].w;
		e[i].w++;
//		e[i].x = read();e[i].y = read();e[i].w = read() + 1;
		limit = max(e[i].w,limit);
	}
	for(int i = 1;i <= m;i++)
	{
		if(e[i].w < limit) update(1,1,limit,e[i].w+1,limit,i);
		if(e[i].w > 1) update(1,1,limit,1,e[i].w - 1,i);
	}
	for(int i = 1;i <= n;i++)
	{
		fa[i] = i;h[i] = 1;si[i] = 1;
	}
	solve(1,1,limit);
	return 0;
}