package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
)

type Edge struct {
	to     int
	weight int64
}

type IntPair struct {
	x, y int64
}

type Item struct {
	v    int
	dist int64
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].dist < pq[j].dist
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
	*pq = append(*pq, x.(*Item))
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[0 : n-1]
	return item
}

func dijkstra(start int, n int, adj [][]Edge) ([]int64, []IntPair) {
	dist := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		dist[i] = 1e18
	}
	ways := make([]IntPair, n+1)
	visited := make([]bool, n+1)

	dist[start] = 0
	ways[start] = IntPair{1, 1}

	pq := make(PriorityQueue, 0)
	heap.Push(&pq, &Item{v: start, dist: 0})

	for pq.Len() > 0 {
		top := heap.Pop(&pq).(*Item)
		u := top.v
		if visited[u] {
			continue
		}
		visited[u] = true

		for _, edge := range adj[u] {
			v := edge.to
			w := edge.weight

			if dist[u]+w < dist[v] {
				dist[v] = dist[u] + w
				ways[v] = ways[u]
				heap.Push(&pq, &Item{v: v, dist: dist[v]})
			} else if dist[u]+w == dist[v] {
				ways[v].x = (ways[v].x + ways[u].x) % 1000000007
				ways[v].y = (ways[v].y + ways[u].y) % 1000000009
			}
		}
	}
	return dist, ways
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, m, s, t int
	fmt.Fscanf(reader, "%d %d %d %d\n", &n, &m, &s, &t)

	adjS := make([][]Edge, n+1)
	adjT := make([][]Edge, n+1)

	edges := make([][3]int, m)

	for i := 0; i < m; i++ {
		var u, v int
		var w int64
		fmt.Fscanf(reader, "%d %d %d\n", &u, &v, &w)
		edges[i] = [3]int{u, v, int(w)}
		adjS[u] = append(adjS[u], Edge{v, w})
		adjT[v] = append(adjT[v], Edge{u, w})
	}

	distS, waysS := dijkstra(s, n, adjS)
	distT, waysT := dijkstra(t, n, adjT)

	L := distS[t]

	for i := 0; i < m; i++ {
		u := edges[i][0]
		v := edges[i][1]
		w := int64(edges[i][2])

		if distS[u]+w+distT[v] == L {
			if (waysS[u].x*waysT[v].x)%1000000007 == waysS[t].x &&
				(waysS[u].y*waysT[v].y)%1000000009 == waysS[t].y {
				fmt.Fprintln(writer, "YES")
				continue
			}
		}

		reqW := L - 1 - distS[u] - distT[v]
		if reqW >= 1 {
			fmt.Fprintf(writer, "CAN %d\n", w-reqW)
		} else {
			fmt.Fprintln(writer, "NO")
		}
	}
}