#include <iostream>

#define MAX_N   10240        // massimo numero di incroci che potrebbero capitarmi
#define MAX_DEG 1024         // massimo grado per ogni nodo
#define MAX_PER 1024000      // massimo pericolo

using namespace std;

int Adiacenti[MAX_N][MAX_DEG];
int Pericolo[MAX_N][MAX_DEG];
int Grado[MAX_N];
int Visitato[MAX_N];         // vettore che segna se il nodo e' stato visitato
int OrdineNodi[MAX_N];       // vettore con i nodi in ordine dalla sorgente 1 al pozzo N
int PericoloTotale[MAX_N];   // vettore che segna il pericolo minore per i percorsi 1->n
int N, temp;


int min( int x, int y )      // funzione che calcola il minimo
{
    return x < y ? x : y;
}

int max( int x, int y )      // funzione che calcola il massimo
{
    return x > y ? x : y;
}

void leggi()
{
    int M, a, b, p;

    cin >> N >> M;
    for (int i=0; i<M; i++) {         // leggo il grafo, facendo attenzione che questa volta gli archi hanno un verso solo
        cin >> a >> b >> p;
        a--, b--;
        Pericolo[ a][Grado[a]] = p;
        Adiacenti[a][Grado[a]] = b;
        Grado[a]++;
    }
}

void visita(int nodo)                 // procedura che visita (in profondita' ricorsiva) segnandosi i nodi man mano che chiude
{
    if (Visitato[nodo] > 0) {         // se ho gia' visitato il nodo, esco
        return;
    }
    Visitato[nodo] = 1;               // visito il nodo
    for (int i=0; i<Grado[nodo]; i++) // visito i nodi adiacenti
        visita(Adiacenti[nodo][i]);
    OrdineNodi[temp++] = nodo;        // accodo il nodo alla lista ordinata dei nodi
}

void calcola()                        // procedura che calcola la pericolosita' minima dei percorsi 1->n per ogni nodo n
{
    int a, b;

    PericoloTotale[0] = 0;            // all'inizio il nodo 1 ha pericolo 0, gli altri infinito
    for (int i=1; i<N; i++) PericoloTotale[i] = MAX_PER;
    for (int i=N-1; i>0; i--) {       // prendo a tra i nodi in ordine topologico
        a = OrdineNodi[i];            // (il primo che scelgo e' sicuramente il nodo 1)
        for (int j=0; j<Grado[a]; j++) {
            b = Adiacenti[a][j];      // per ogni nodo adiacente b,
            PericoloTotale[b] = min( PericoloTotale[b], max(PericoloTotale[a],Pericolo[a][j]) );
        }                             // se migliora, mi segno la pericolosita' 1->b passando per a (che quindi e' il max del pericolo 1->a e a->b)
    }
}

int main()
{
    leggi();

    temp=0;
    for (int i=0; i<N; i++) Visitato[i] = 0;
    visita(0);                           // calcolo l'ordine topologico del grafo.

    calcola();                           // calcolo le pericolosita' di tutti i percorsi.

    cout << PericoloTotale[N-1] << endl; // stampo il risultato ottenuto.
    return 0;
}