# include <stdio.h>
# include <stdlib.h>
# include <string.h>

//7:09

const long int MAXN=250000;
const long int MAXM=500000;

typedef struct MUCHIE
        {
        long int b,k;
        };

long int used[MAXN+1],pozh[MAXN+1],heap[MAXM+1],raza[MAXN+1],heaplen,n,m,source,sink;
MUCHIE muchie[MAXM+1];

typedef struct NOD
        {
        long int val;
        long int next;
        };

typedef struct LISTA
        {
        long int begin,end;
        };

LISTA ladiac[MAXN+1];

NOD space[MAXM+1]; long int spacelen;

void add(LISTA &l, long int val)
{
     spacelen++;
     space[spacelen].val=val;
     space[spacelen].next=0;
     if (l.begin)
        {
        space[l.end].next=spacelen;
        l.end=spacelen;
        }
     else
         {
         l.begin=spacelen;
         l.end=spacelen;
         }
}

void float_heap(long int i)
{
     long int aux;
     while (i/2 && raza[heap[i]]<raza[heap[i/2]])
           {
           aux=heap[i];
           heap[i]=heap[i/2];
           heap[i/2]=aux;
           pozh[heap[i]]=i;
           pozh[heap[i/2]]=i/2;
           i/=2;
           }
}

void submerge_heap(long int i)
{
     long int min,aux;
     do
       {
       min=i;
       if (2*i  <=heaplen && raza[heap[2*i  ]]<raza[heap[min]]) min=2*i;
       if (2*i+1<=heaplen && raza[heap[2*i+1]]<raza[heap[min]]) min=2*i+1;
       if (min==i) break;
       aux=heap[i];
       heap[i]=heap[min];
       heap[min]=aux;
       pozh[heap[i]]=i;
       pozh[heap[min]]=min;
       i=min;
       } while  (1);
}

void insert_heap(long int val)
{
     heap[++heaplen]=val;
     pozh[heap[heaplen]]=heaplen;
     float_heap(heaplen);
}

long int extract_heap()
{
     long int sol=heap[1];
     heap[1]=heap[heaplen];
     heaplen--;
     submerge_heap(1);
     return sol;
}

long int max(long int a, long int b) {if (a>b) return a; return b;}

void load(long int nod)
{
     long int p=ladiac[nod].begin;
     long int maxim;
     while (p)
           {
           if (!used[muchie[space[p].val].b])
              {
              if (raza[nod]>muchie[space[p].val].k) maxim=raza[nod];
              else maxim=muchie[space[p].val].k;
           
              if (!pozh[muchie[space[p].val].b]) 
                 {
                 raza[muchie[space[p].val].b]=maxim;
                 insert_heap(muchie[space[p].val].b);
                 }
              else if (raza[muchie[space[p].val].b]>maxim)
                 {
                 raza[muchie[space[p].val].b]=maxim;
                 float_heap(pozh[muchie[space[p].val].b]);
                 }
              }
           p=space[p].next;
           }
}

char buff[10000000];

void citire()
{
     FILE *f=fopen("pscnv.in","r");
     fscanf(f,"%ld%ld%ld%ld",&n,&m,&source,&sink);
     fread(buff,1,10000000,f);
     char *p=strtok(buff," \n");
     long int i,place;
     for (i=1;i<=m;i++)
         {
         //fscanf(f,"%ld%ld%ld",&muchie[i].a,&muchie[i].b,&muchie[i].k);
         place=atoi(p);
         p=strtok(NULL," \n");
         muchie[i].b=atoi(p);
         p=strtok(NULL," \n");
         muchie[i].k=atoi(p);
         p=strtok(NULL," \n");
         add(ladiac[place],i);
         }
     fclose(f);
}

void scrie(long int sol)
{
     FILE *g=fopen("pscnv.out","w");
     fprintf(g,"%ld\n",sol);
     fclose(g);
}

long int calculeaza()
{
     long int m;
     used[source]=1;
     load(source);
     while (!used[sink])
           {
           m=extract_heap();
           used[m]=1;
           load(m);
           }
     return raza[sink];
}

int main()
{
    citire();
    scrie(calculeaza());
    return 0;
}