#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <vector>
#include <queue>
#include <utility>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cctype>
 
const int MAX_N(250001);
const int MAX_K(1001);
 
int n, m, x, y;
int Dp [MAX_N];
std::vector<std::pair<int,int>> Graph [MAX_N];
char Buffer [10000000];
char *iterator(Buffer);
 
inline int Get (int &number)
{
    while (!std::isdigit(*iterator))
        ++iterator;
    number = 0;
    while (std::isdigit(*iterator))
    {
        number = number * 10 + *iterator - '0';
        ++iterator;
    }
}
 
inline void Read (void)
{
    int input(open("pscnv.in",O_RDONLY));
    read(input,Buffer,sizeof(Buffer));
    close(input);
    Get(n);
    Get(m);
    Get(x);
    Get(y);
    for (int i(1), a, b, c ; i <= m ; ++i)
    {
        Get(a);
        Get(b);
        Get(c);
        Graph[a].push_back(std::make_pair(b,c));
    }
}
 
inline void Print (void)
{
    std::ofstream output("pscnv.out");
    output << Dp[y] << '\n';
    output.close();
}
 
inline void Dynamic (void)
{
    int vertex(1), c;
    std::queue<int> queue [MAX_K];
    queue[0].push(x);
    std::memset(Dp + 1,0x3f3f3f3f,sizeof(*Dp) * n);
    Dp[x] = 0;
    int i(0), node;
    while (vertex)
    {
        while (i < MAX_K && queue[i].empty())
            ++i;
        if (i == MAX_K)
            break;
        node = queue[i].front();
        queue[i].pop();
        --vertex;
        for (auto it : Graph[node])
        {
            c = std::max(Dp[node],it.second);
            if (Dp[it.first] > c)
            {
                Dp[it.first] = c;
                ++vertex;
                queue[c].push(it.first);
            }
        }
    }
}
 
int main (void)
{
    Read();
    Dynamic();
    Print();
    return 0;
}