#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cassert>
using namespace std;

const int MAX_NODE = 50010, MAX_EDGE = 200010, INF = 0x3f3f3f3f;
int TotNode, TotEdge, Ans;

struct Edge
{
	int From, To, Weight;
	bool InTree;

	bool operator < (const Edge& a) const
	{
		return Weight < a.Weight;
	}
}_edges[MAX_EDGE];
int MaxEdgeP, MinEdgeP;

struct LCT
{
private:
	static const int MAX_TREE_NODE = MAX_NODE + MAX_EDGE;

	struct Node
	{
		int Val, Id;
		bool Rev;
		Node *Father, *LeftSon, *RightSon, *MinValP;

		bool IsRoot()
		{
			return !Father || (Father->LeftSon != this && Father->RightSon != this);
		}

		bool IsLeftSon()
		{
			return Father->LeftSon == this;
		}

		void Refresh()
		{
			MinValP = this;
			if (LeftSon && LeftSon->MinValP->Val < MinValP->Val)
				MinValP = LeftSon->MinValP;
			if (RightSon && RightSon->MinValP->Val < MinValP->Val)
				MinValP = RightSon->MinValP;
		}

		void Reverse()
		{
			swap(LeftSon, RightSon);
			Rev = !Rev;
		}

		void PushDown()
		{
			if (Rev)
			{
				if (LeftSon)
					LeftSon->Reverse();
				if (RightSon)
					RightSon->Reverse();
				Rev = false;
			}
		}
	}_nodes[MAX_TREE_NODE];

	struct SplayTree
	{
	private:
		Node *InnerRoot;

		void PushDown(Node *cur)
		{
			if (!cur->IsRoot())
			{
				PushDown(cur->Father);
			}
			cur->PushDown();
		}

		void Rotate(Node *cur)
		{
			Node *gfa = cur->Father->Father;
			Node **gfaSon = cur->Father->IsRoot() ? &InnerRoot : cur->Father->IsLeftSon() ? &gfa->LeftSon : &gfa->RightSon;
			Node **faSon = cur->IsLeftSon() ? &cur->Father->LeftSon : &cur->Father->RightSon;
			Node **curSon = cur->IsLeftSon() ? &cur->RightSon : &cur->LeftSon;
			*faSon = *curSon;
			if (*faSon)
				(*faSon)->Father = cur->Father;
			*curSon = cur->Father;
			(*curSon)->Father = cur;
			*gfaSon = cur;
			(*gfaSon)->Father = gfa;
			(*curSon)->Refresh();
			cur->Refresh();
		}

	public:
		void Splay(Node *cur)
		{
			PushDown(cur);
			while (!cur->IsRoot())
			{
				if (!cur->Father->IsRoot())
					Rotate(cur->Father->IsLeftSon() == cur->IsLeftSon() ? cur->Father : cur);
				Rotate(cur);
			}
		}
	}t;

	void Access(Node *cur)
	{
		Node *prev = NULL;
		while (cur)
		{
			t.Splay(cur);
			cur->RightSon = prev;
			cur->Refresh();
			prev = cur;
			cur = cur->Father;
		}
	}

	void MakeRoot(Node *cur)
	{
		Access(cur);
		t.Splay(cur);
		cur->Reverse();
	}

	void MakePath(Node *u, Node *v)
	{
		MakeRoot(v);
		Access(u);
		t.Splay(u);
	}

	void Link(Node *u, Node *v)
	{
		MakeRoot(v);
		v->Father = u;
	}

	void Cut(Node *u, Node *v)
	{
		MakePath(u, v);
		assert(v->Father == u);
		assert(u->LeftSon == v);
		u->LeftSon = NULL;
		v->Father = NULL;
		u->Refresh();
	}

	Node *FindRoot(Node *cur)
	{
		while (cur->Father)
			cur = cur->Father;
		while (cur->LeftSon)
			cur = cur->LeftSon;
		return cur;
	}

	Node *GetMinNode(Node *u, Node *v)
	{
		if (FindRoot(u) != FindRoot(v))
			return NULL;
		MakePath(u, v);
		return u->MinValP;
	}

public:
	LCT()
	{
		for (int i = 1; i <= 100; i++)
			_nodes[i].Id = i;
	}

	void SetNode(int v, int val)
	{
		_nodes[v].Val = val;
	}

	void Link(int u, int v)
	{
		Link(_nodes + u, _nodes + v);
	}

	void Cut(int u, int v)
	{
		Cut(_nodes + u, _nodes + v);
	}

	int GetMinId(int u, int v)
	{
		Node *ans = GetMinNode(_nodes + u, _nodes + v);
		if (ans == NULL)
			return -1;
		else
			return ans - _nodes;
	}
}g;

void InitBuild()
{
	sort(_edges + 1, _edges + TotEdge + 1);
	for (int i = 1; i <= TotEdge; i++)
		g.SetNode(TotNode + i, _edges[i].Weight);
	for (int i = 1; i <= TotNode; i++)
		g.SetNode(i, INF);
	int cnt = 0, curEdge = 0;
	while (cnt < TotNode - 1)
	{
		curEdge++;
		int k = g.GetMinId(_edges[curEdge].From, _edges[curEdge].To);
		if (k == -1)
		{
			cnt++;
			g.Link(_edges[curEdge].To, curEdge + TotNode);
			g.Link(curEdge + TotNode, _edges[curEdge].From);
			_edges[curEdge].InTree = true;
			MaxEdgeP = curEdge;
		}
	}
	Ans = _edges[MaxEdgeP].Weight - _edges[1].Weight;
	MinEdgeP = 1;
}

int GetAns()
{
	for (int i = 1; i <= TotEdge; i++)
	{
		if (_edges[i].InTree)
			continue;

		_edges[i].InTree = true;
		if (_edges[i].Weight > _edges[MaxEdgeP].Weight)
			MaxEdgeP = i;

		int cutEdge = g.GetMinId(_edges[i].From, _edges[i].To);
		assert(cutEdge != -1);
		g.Cut(_edges[cutEdge - TotNode].To, cutEdge);
		g.Cut(cutEdge, _edges[cutEdge - TotNode].From);
		_edges[cutEdge - TotNode].InTree = false;
		if (MaxEdgeP == cutEdge - TotNode)
			while (!_edges[MaxEdgeP].InTree)
				MaxEdgeP--;
		if (MinEdgeP == cutEdge - TotNode)
			while (!_edges[MinEdgeP].InTree)
				MinEdgeP++;

		Ans = min(Ans, _edges[MaxEdgeP].Weight - _edges[MinEdgeP].Weight);
		g.Link(_edges[i].To, i + TotNode);
		g.Link(i + TotNode, _edges[i].From);
	}
	return Ans;
}


int main()
{
	scanf("%d%d", &TotNode, &TotEdge);
	for (int i = 1; i <= TotEdge; i++)
	{
		scanf("%d%d%d", &_edges[i].From, &_edges[i].To, &_edges[i].Weight);
		while (_edges[i].From == _edges[i].To)
		{
			TotEdge--;
			scanf("%d%d%d", &_edges[i].From, &_edges[i].To, &_edges[i].Weight);
		}
	}
	InitBuild();
	printf("%d\n", GetAns());
	return 0;
}