# 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 a,b,k;
        };

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

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

typedef struct LISTA
        {
        NOD *begin,*end;
        };

LISTA ladiac[MAXN+1];

void add(LISTA &l, long int val)
{
     NOD *p=(NOD*) malloc(sizeof(NOD));
     p->val=val;
     p->next=NULL;
     if (l.begin)
        {
        l.end->next=p;
        l.end=p;
        }
     else
         {
         l.begin=p;
         l.end=p;
         }
}

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

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

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

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

void load(long int nod)
{
     NOD *p=ladiac[nod].begin;
     while (p)
           {
           if (!used[muchie[p->val].a] || !used[muchie[p->val].b]) insert_heap(p->val);
           p=p->next;
           }
}

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

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

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

long int calculeaza()
{
     long int m;
     used[source]=1;
     load(source);
     while (!used[sink])
           {
          m=extract_heap();
           if (!used[muchie[m].a] || !used[muchie[m].b])
              if (!used[muchie[m].a]) 
                 {
                 used[muchie[m].a]=max(used[muchie[m].b],muchie[m].k);
                 load(muchie[m].a);
                 }
              else 
                 {
                 used[muchie[m].b]=max(used[muchie[m].a],muchie[m].k);
                 load(muchie[m].b);
                 }
           }
     return used[sink];
}

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