#include <stdio.h>
#include <ctype.h>

#define Smerenie 500001
#define Nadejde 250001
#define Dragoste 65536
#define MAX_K 1001
#define Mask 31

typedef struct {
  int v, k, next;
} cell;

int N;
int M;
int X;
int Y;
char c;
int mid;
int adj[Nadejde];   /// capetele listelor de adiacenta.
cell l[Smerenie];   /// listele de adiacenta alocate static.
int pos = Dragoste;
char buff[Dragoste];
int seen[MAX_K][Nadejde];

/** Returneaza urmatorul caracter din "f". **/
char getChar(FILE *f) {
  if (pos == Dragoste) {
    fread(buff, 1, Dragoste, f);
    pos = 0;
  }
  return buff[pos++];
}

/** Citeste urmatorul numar. **/
void read(FILE *f, int *result) {
  *result = 0;
  do {
    c = getChar(f);
  } while (!isdigit(c));
  do {
    *result = (*result << 3) + (*result << 1) + c - '0';
    c = getChar(f);
  } while (isdigit(c));
}

/** Inlocuim fscanf()-ul. **/
void freef(FILE *f, const char *arg, int *u, int *v, int *k) {
  read(f, &*u), read(f, &*v), read(f, &*k);
}

void setBit(int k, int u) {
  seen[k][u >> 5] |= (1 << (Mask - (u & Mask)));
}

int getBit(int k, int u) {
  return (seen[k][u >> 5] >> (Mask - (u & Mask))) & 1;
}

/** Adauga-l pe "v" la lista de adiacenta a lui "u". **/
void addEdge(int u, int v, int k, int pos) {
  l[pos].v = v;
  l[pos].k = k;
  l[pos].next = adj[u];
  adj[u] = pos;
}

/** Parcurge recursiv graful, cu capacitatea "mid". **/
void dfs(int u) {
  int pos;
  if (!getBit(mid, u)) {
    setBit(mid, u);
    for (pos = adj[u]; pos; pos = l[pos].next) {
      if (mid >= l[pos].k) {
        dfs(l[pos].v);
      }
    }
  }
}

/** Determina daca putem ajunge in "Y" cu capacitatea "mid". **/
void step(int lo, int hi) {
  mid = (lo + hi) >> 1;
  dfs(X);
}

/** Cauta binar capacitatea minima. **/
int bSearch(int lo, int hi) {
  while (lo <= hi) {
    step(lo, hi);
    if (getBit(mid, Y)) {
      hi = mid - 1;
    } else {
      lo = mid + 1;
    }
  }
  return lo;
}

int main(void) {
  int i, u, v, k;
  FILE *f = fopen("pscnv.in", "r");

  freef(f, "%d %d %d", &N, &M, &X), read(f, &Y);
  for (i = 1; i <= M; i++) {
    freef(f, "%d %d %d", &u, &v, &k);
    addEdge(u, v, k, i);
  }
  fclose(f);

  f = fopen("pscnv.out", "w");
  fprintf(f, "%d\n", bSearch(0, MAX_K + 1));
  fclose(f);

  /** Multumim Doamne! **/
  puts("Doamne ajuta!");
  return 0;
}