#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct Node
{
    int value;
    int dist;
    int index;
};

class hasonlit
{
public:
    bool operator()(Node a, Node b)
    {
        if(a.value == b.value){
            return (a.dist < b.dist);
        }
        else {
            return (a.value > b.value);
        }
    }

};

void dijkstra(vector<vector<pair<int, int>>> &adj, int N, int K, int H, vector<vector<int>> &dp)
{
    priority_queue<Node, vector<Node>, hasonlit> pq;
    pq.push({0, 0, K});
    while(!pq.empty()){
        Node currNode = pq.top();
        pq.pop();
        if(dp[currNode.index][currNode.dist] > currNode.value || currNode.dist >= H){
            continue;
        }
        for(int i = 0; i < adj[currNode.index].size(); i++){
            int newValue;
            if(currNode.value == 0){
                newValue = adj[currNode.index][i].second;
            }
            else {
                newValue = min(currNode.value, adj[currNode.index][i].second);
            }
            Node newNode = {newValue, currNode.dist+1, adj[currNode.index][i].first};
            if(newNode.value > dp[newNode.index][newNode.dist]){
                dp[newNode.index][newNode.dist] = newNode.value;
                pq.push(newNode);
            }
        }
    }
}

int main()
{
    int N, M, K, H;
    cin >> N >> M >> K >> H;
    vector<vector<pair<int, int>>> adj(N+1);
    for(int i = 0; i < M; i++){
        int a, b, c;
        cin >> a >> b >> c;
        adj[a].push_back({b, c});
        adj[b].push_back({a, c});
    }
    vector<vector<int>> dp(N+1, vector<int>(H+1, 0));
    dijkstra(adj, N, K, H, dp);

    for(int i = 1; i <= N; i++){
        if(i == K){
            cout << 0 << endl;
            continue;
        }
        int maxim = 0;
        for(int j = 0; j <= H; j++){
            maxim = max(maxim, dp[i][j]);
        }
        if(maxim != 0){
            cout << maxim << endl;
        }
        else{
            cout << -1 << endl;
        }
    }
    return 0;
}