Program Howl;
Const MaxN=1000;
      MaxM=100000;

Var N, M: LongInt;

{Во время поиска в массиве edge в позициях от index[i] 
 до index[i+1]-1 хранятся дуги, выходящие из вершины i}

    edge: Array [1..2*MaxM+1] of Record
                                   neigh: LongInt;
                                   weight: LongInt;
                                 End;
    index: Array [1..MaxN+1] of LongInt;


Function Attainable(treshold: LongInt): Boolean;
{Функция Attainable с помощью поиска в глубину определяет, 
 существует ли путь из вершины 1 в вершину N по дугам, 
 вес которых не превосходит treshold }

Var mark: Array [1..MaxN] of Boolean;

  Procedure DFS(v: LongInt);
  Var i: LongInt;
  Begin
    If (mark[v] or mark[N]) Then Exit;
    mark[v]:= true;
    For i:= index[v] To index[v+1]-1 Do Begin
      If edge[i].weight<treshold Then DFS(edge[i].neigh);
    End;
  End;

Begin
  FillChar(mark, SizeOf(mark), false);
  DFS(1);
  Attainable:= mark[N];
End;


Var e: Array [1..MaxM] of Record a,b,w: LongInt; End;
   {e - массив для временного хранения дуг заданного графа:
    в него считываются данные, одновременно подсчитывается
    количество дуг, инцидентных каждой из вершин; затем
    информация о дугах перемещается в массив edge, а
    массив e после этого больше не используется }
    left, right, median: LongInt;
    f: Text;
    i, j: LongInt;
Begin
{Чтение данныхю }
  Assign(f, 'howl.in'); Reset(f);
  Readln(f, N, M);
  For i:= 1 To N+1 Do index[i]:= 0;
  left:= MaxLongInt; right:= 0;
  For i:= 1 To M Do Begin
    Readln(f, e[i].a, e[i].b, e[i].w);
    Inc(index[e[i].a]);
    Inc(index[e[i].b]);
    If e[i].w>right Then right:= e[i].w;
    If e[i].w<left Then left:= e[i].w;
  End;
  Close(f);
  For i:= 2 To N+1 Do index[i]:= index[i-1]+index[i];
{left/right - минимальное/максимальное значение весов дуг}

{Перемещение данных из массива e в массив edge}
  For i:= 1 To M Do Begin
    j:= index[e[i].a];
    edge[j].neigh:= e[i].b;
    edge[j].weight:= e[i].w;
    Dec(index[e[i].a]);
    j:= index[e[i].b];
    edge[j].neigh:= e[i].a;
    edge[j].weight:= e[i].w;
    Dec(index[e[i].b]);
  End;
{Окончательная установка index'ов}
  For i:= 1 To N+1 Do Begin
    Inc(index[i]);
  End;

{ОСНОВНОЙ ЦИКЛ. Методом половинного деления находим
 наименьшее возможное значение громкости (веса дуги),
 при котором существует путь из вершины 1 в вершину N 
 по дугам, вес которых не превосходит этой громкости}
  While (right>left+1) Do Begin
    median:= (left+right) div 2;
    If Attainable(median) Then right:= median
                          Else left:= median;
  End;
{Замечание. Конечно, можно было бы предварительно отсортировать
 все имеющиеся в графе веса дуга, и потом исполнять поиск по 
 этому массиву весов, а не вообще по всем возможным значениям 
 от минимального до максимального. Это, безусловно, ускорило 
 бы процесс поиска. Правда пришлось бы потратить время на 
 сортировку... Какой вариант эффективнее - зависит от контекста.
 В данной программе сортировка не выполняется.}

{Вывод результата}
  Assign(f, 'howl.out'); Rewrite(f);
  Writeln(f, left);
  Close(f);
End.