#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <climits>

using namespace std;

struct Edge
{
    int from, to;
    double u;
    Edge() {}
    Edge(int from, int to, double u) : from(from), to(to), u(u) {}
};

struct Node
{
    int x;
    vector<Edge> edges;

    Node(int x) : x(x) {}
};

static vector<double> distances;
static double minWeight = INFINITY;

int cmp(const int& a, const int& b)
{
    return distances[a] - distances[b];
}

double bfs(vector<Node>& nodes, int start, int end)
{
    vector<int> vertices;
    vertices.push_back(start);

    distances = vector<double>(nodes.size(), INFINITY);
    distances[start] = 0.0;

    vector<bool> visited(nodes.size(), false);

    while (!vertices.empty())
    {
        int current = vertices[vertices.size() - 1];
        vertices.erase(vertices.end() - 1);
        Node& node = nodes[current];

        if (visited[current])
        {
            continue;
        }

        visited[current] = true;

        for (size_t i = 0; i < node.edges.size(); i++)
        {
            int target = node.edges[i].to;
            if (distances[current] + (node.edges[i].u + minWeight) < distances[target])
            {
                distances[target] = distances[current] + node.edges[i].u;
            }

            vertices.push_back(target);
        }

        sort(vertices.begin(), vertices.end(), cmp);
    }

    return distances[end];
}

int main()
{
    int t, f, fu, fn;

    while (cin >> t >> f >> fu >> fn)
    {
        if (t == 0 && f == 0 && fu == 0 && fn == 0) break;

        vector<Node> nodes;
        minWeight = INFINITY;

        for (int i = 0; i < f; i++)
        {
            nodes.push_back(Node(i));
        }

        for (int i = 0; i < t; i++)
        {
            int from, to;
            double u;

            cin >> from >> to >> u;
            minWeight = min(minWeight, u);
            nodes[from - 1].edges.push_back(Edge(from - 1, to - 1, u));
        }

        minWeight = -minWeight + 1;

        //cout << minWeight << endl;
        //cout << bfs(nodes, fu - 1, fn - 1) << endl;

        if (bfs(nodes, fu - 1, fn - 1) < 0)
        {
            cout << "FALSE" << endl;
        }
        else cout << "TRUE" << endl;
    }

    return 0;
}