#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;

#define Pair pair<long long, Node*>
const int MAX_NODE = 200010, MAX_EDGE = 400010;
const long long INF = 1e17;

struct Node;
struct Edge;

struct Node
{
    Edge *HeadS, *HeadT, *Head;
    long long Dist, DistT;
    bool Done;
    int Low, DfsN;
}_nodes[MAX_NODE], *Start, *Target;
int TotNode;

struct Edge
{
    Node *To;
    Edge *Next, *Rev;
    long long Weight;
    bool InSubG;//InSubGraph
    bool IsCut;
}_edges[MAX_EDGE];
int TotEdge;

void AddEdge(int uId, int vId, int eId, int w)
{
    Node *from = _nodes + uId, *to = _nodes + vId;
    Edge *e = _edges + eId, *revE = _edges + eId + TotEdge;
    
    e->To = to;
    e->Weight = w;
    e->Next = from->HeadS;
    from->HeadS = e;

    revE->To = from;
    revE->Weight = w;
    revE->Next = to->HeadT;
    to->HeadT = revE;

    e->Rev = revE;
    revE->Rev = e;
}

struct HeapNode
{
    long long Dist;
    Node *CurNode;

    HeapNode(long long dist, Node *curNode):Dist(dist), CurNode(curNode){}

    bool operator < (const HeapNode& a) const
    {
        return Dist > a.Dist;
    }
};

void Dijkstra(Node *start)
{
    for (int i = 1; i <= TotNode; i++)
    {
        _nodes[i].Dist = INF;
        _nodes[i].Done = false;
    }
    start->Dist = 0;
    static priority_queue<HeapNode> q;
    q.push(HeapNode(0, start));
    while (!q.empty())
    {
        HeapNode temp = q.top();
        q.pop();
        Node *cur = temp.CurNode;
        if (cur->Done)
            continue;
        cur->Done = true;
        for (Edge *e = cur->Head; e; e = e->Next)
        {
            if (cur->Dist + e->Weight < e->To->Dist)
            {
                e->To->Dist = cur->Dist + e->Weight;
                q.push(HeapNode(e->To->Dist, e->To));
            }
        }
    }
}

void MinDist_T()//getMinDistFromTargetNode
{
    for (int i = 1; i <= TotNode; i++)
        _nodes[i].Head = _nodes[i].HeadT;
    Dijkstra(Target);
}

void MinDist_S()//getMinDistFromStartNode
{
    for (int i = 1; i <= TotNode; i++)
    {
        _nodes[i].DistT = _nodes[i].Dist;
        _nodes[i].Head = _nodes[i].HeadS;
    }
    Dijkstra(Start);
}

void GetSubGraph()
{
    for (int i = 1; i <= TotEdge; i++)
        if (_edges[i].Rev->To->Dist + _edges[i].Weight + _edges[i].To->DistT == Target->Dist)
            _edges[i].InSubG = _edges[i].Rev->InSubG = true;
}

void CombineGraph()
{
    for (int i = 1; i <= TotNode; i++)
    {
        _nodes[i].Head = _nodes[i].HeadS;
        Edge **e = &_nodes[i].Head;
        while (*e)
            e = &(*e)->Next;
        *e = _nodes[i].HeadT;
    }
}

int DfsCnt;
void Dfs(Node *cur, Edge *from)
{
    cur->Low = cur->DfsN = ++DfsCnt;
    for (Edge *e = cur->Head; e; e = e->Next)
    {
        if (!e->InSubG)
            continue;
        if (!e->To->DfsN)
        {
            Dfs(e->To, e);
            cur->Low = min(cur->Low, e->To->Low);
            if (cur->DfsN < e->To->Low)
                e->IsCut = e->Rev->IsCut = true;
        }
        else if (e->Rev != from)
            cur->Low = min(cur->Low, e->To->DfsN);
    }
}

void SolveEdge(Edge *e)
{
    if (e->IsCut)
    {
        printf("YES\n");
        return;
    }
    if (e->Rev->To->Dist == INF || e->To->DistT == INF)
    {
        printf("NO\n");
        return;
    }
    long long delta = e->Rev->To->Dist - Target->Dist + e->Weight + e->To->DistT + 1;
    if (delta >= e->Weight)
        printf("NO\n");
    else
        printf("CAN %lld\n", delta);
}

int main()
{
    int s, t;
    scanf("%d%d%d%d", &TotNode, &TotEdge, &s, &t);
    Start = _nodes + s;
    Target = _nodes + t;
    for (int i = 1; i <= TotEdge; i++)
    {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        AddEdge(u, v, i, w);
    }
    MinDist_T();
    MinDist_S();
    GetSubGraph();
    CombineGraph();
    Dfs(Start, NULL);
    for (int i = 1; i <= TotEdge; i++)
        SolveEdge(_edges + i);
    return 0;
}