7 9 999999999 0 3
0 1 0
1 2 0
2 3 0
0 4 1
4 1 1
1 5 499999999
5 2 499999999
2 6 1
6 3 1
 7 9 320 0 3
0 1 0
1 2 0
2 3 0
0 4 1
4 1 1
1 5 100
5 2 100
2 6 59
6 3 61
 4 5 7 0 3
0 1 0
1 2 3
2 3 0
0 2 5
1 3 5
 8 9 10 1 0
1 2 1
2 4 1
1 3 0
3 4 0
4 5 0
5 6 1
6 0 1
5 7 0
7 0 0
 4 4 14 1 3
1 3 13
2 3 0
2 0 0
1 0 12
 5 6 1000000000 0 4
0 1 1
2 0 2
3 0 3
4 1 0
4 2 0
3 4 0
 4 5 10 1 2
0 1 3
1 2 0
1 3 4
2 3 4
2 0 6
 4 4 2 1 3
1 3 13
2 3 0
2 0 0
1 0 0
 5 5 2 0 2
0 1 1
1 2 1
0 4 0
4 3 0
3 2 0
 5 5 3 0 2
0 1 1
1 2 1
0 4 0
4 3 0
3 2 0
 4 4 8 1 3
1 3 13
2 3 0
2 0 0
1 0 6
 1000 1 1000000000 998 0
0 999 0
 5 5 1 0 2
0 1 1
1 2 1
0 4 0
4 3 0
3 2 0
 100 1 123456 99 0
0 99 123456
 4 4 13 1 3
1 3 13
2 3 0
2 0 0
1 0 12
 7 9 319 0 3
0 1 0
1 2 0
2 3 0
0 4 1
4 1 1
1 5 100
5 2 100
2 6 59
6 3 61
 1000 1 5 999 0
0 999 0

YES
0 1 1
1 2 999999996
2 3 999999997
0 4 1
4 1 1
1 5 499999999
5 2 499999999
2 6 1
6 3 1
 YES
0 1 1
1 2 199
2 3 318
0 4 1
4 1 1
1 5 100
5 2 100
2 6 59
6 3 61
 YES
0 1 3
1 2 3
2 3 2
0 2 5
1 3 5
 YES
1 2 1
2 4 1
1 3 1
3 4 1
4 5 6
5 6 1
6 0 1
5 7 1
7 0 1
 NO YES
0 1 1
2 0 2
3 0 3
4 1 999999999
4 2 999999998
3 4 999999997
 NO NO YES
0 1 1
1 2 1
0 4 1
4 3 1
3 2 1
 NO YES
1 3 13
2 3 1
2 0 1
1 0 6
 NO NO YES
0 99 123456
 YES
1 3 13
2 3 1
2 0 1
1 0 12
 YES
0 1 1
1 2 198
2 3 317
0 4 1
4 1 1
1 5 100
5 2 100
2 6 59
6 3 61
 YES
0 999 5

import java.io.*;
import java.util.*;

public class D_372_div2
{
    public static final Random RANDOM = new Random(System.currentTimeMillis());
    private static BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer stringTokenizer = null;
    private static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

    private static String next() throws IOException
    {
        while ((stringTokenizer == null) || (!stringTokenizer.hasMoreTokens()))
        {
            stringTokenizer = new StringTokenizer(bufferedReader.readLine());
        }
        return stringTokenizer.nextToken();
    }

    public static int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }

    public static double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }

    public static long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }

    public static String nextLine() throws IOException
    {
        return bufferedReader.readLine();
    }

    public static void close()
    {
        out.close();
    }

    public static void main(String[] args)
    {
        try
        {
            solve();
        } catch (IOException exception)
        {
            exception.printStackTrace();
        }
        close();
    }

    public static final long INFINITE = 2000000000L;

    public static class Edge
    {
        public final Node nodeA;
        public final Node nodeB;
        public int weight;

        public Edge(Node nodeA, Node nodeB, int weight)
        {
            this.nodeA = nodeA;
            this.nodeB = nodeB;
            this.weight = weight;
        }
    }

    public static class Node implements Comparable<Node>
    {
        public final Integer number;
        public Node next = null;
        public long distanceMinimal = INFINITE;
        public long distanceMaximal = INFINITE;
        public Map<Node, Edge> edges = new TreeMap<>();
        public boolean visited = false;

        public Node(int number)
        {
            this.number = number;
        }

        public boolean processT(Node next, long distanceMinimal, long distanceMaximal)
        {
            boolean result = false;
            if (!this.visited)
            {
                this.visited = true;
                if (distanceMinimal < this.distanceMinimal)
                {
                    result = true;
                    this.next = next;
                    this.distanceMinimal = distanceMinimal;
                }
                if (distanceMaximal < this.distanceMaximal)
                {
                    result = true;
                    this.distanceMaximal = distanceMaximal;
                }
                for (Map.Entry<Node, Edge> entry : this.edges.entrySet())
                {
                    Node node = entry.getKey();
                    Integer weight = entry.getValue().weight;
                    if (weight == 0)
                    {
                        result |= node.processT(this, this.distanceMinimal + 1, this.distanceMaximal + INFINITE);
                    }
                    else
                    {
                        result |= node.processT(this, this.distanceMinimal + weight, this.distanceMaximal + weight);
                    }
                }
            }
            return result;
        }


        public boolean processS(int L, long distance)
        {
            boolean result;
            if (next == null)
            {
                result = false;
            }
            else
            {
                Edge edge = edges.get(next);
                if (edge.weight == 0)
                {
                    edge.weight = (int) Math.max(1, L - distance - next.distanceMaximal);
                    result = true;
                }
                else
                {
                    result = next.processS(L, distance + edge.weight);
                }
            }
            return result;
        }

        @Override
        public int compareTo(Node that)
        {
            return this.number.compareTo(that.number);
        }
    }

    public static void processT(Node[] nodes, Node nodeT)
    {
        for (Node node : nodes)
        {
            node.next = null;
            node.distanceMinimal = INFINITE;
            node.distanceMaximal = INFINITE;
            node.visited = false;
        }
        while (nodeT.processT(null, 0, 0))
        {
        }
    }


    public static void processS(Node[] nodes, Node nodeS, Node nodeT, int L)
    {
        processT(nodes, nodeT);
        while (nodeS.processS(L, 0))
        {
            processT(nodes, nodeT);
        }
    }

    public static void solve() throws IOException
    {
        int n = nextInt();
        int m = nextInt();
        int L = nextInt();
        int s = nextInt();
        int t = nextInt();
        Node[] nodes = new Node[n];
        for (int index = 0; index < n; index++)
        {
            nodes[index] = new Node(index);
        }
        Edge[] edges = new Edge[m];
        for (int index = 0; index < m; index++)
        {
            int u = nextInt();
            int v = nextInt();
            int w = nextInt();

            Node nodeU = nodes[u];
            Node nodeV = nodes[v];
            Edge edge = new Edge(nodeU, nodeV, w);
            edges[index] = edge;
            nodeU.edges.put(nodeV, edge);
            nodeV.edges.put(nodeU, edge);
        }
        Node nodeS = nodes[s];
        Node nodeT = nodes[t];
        processS(nodes, nodeS, nodeT, L);
        if (nodeS.distanceMinimal == L)
        {
            out.println("YES");
            for (int index = 0; index < m; index++)
            {
                Edge edge = edges[index];
                out.print(edge.nodeA.number);
                out.print(" ");
                out.print(edge.nodeB.number);
                out.print(" ");
                out.print(edge.weight == 0 ? INFINITE : edge.weight);
                out.println();
            }
        }
        else
        {
            out.println("NO");
        }
    }
}