#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>
#include <tuple>
#include <ostream>
using namespace std;

template <typename T>
struct Edge { int src, dst; T cost;
    Edge(int dst, T cost) : src(-1), dst(dst), cost(cost) { }
    Edge(int src, int dst, T cost) : src(src), dst(dst), cost(cost) { }
};
template <typename T> using Edges = vector<Edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
template <typename T> using Matrix = vector<vector<T>>;

template <typename T>
struct Dijkstra {
    const T INF = numeric_limits<T>::max();
    const WeightedGraph<T> &g;
    int V, s; vector<T> dist; vector<int> prev; Matrix<T> mat;
    Dijkstra(const WeightedGraph<T> &g, int s) : g(g), V(g.size()), s(s) {
        mat.assign(V, vector<int>(V));  // MLE に注意
        for (int u = 0; u < V; u++) for (auto e: g[u]) mat[u][e.dst] = e.cost;
        dist.assign(V, INF); prev.assign(V, -1);
        using Pi = pair<T, int>;
        priority_queue<Pi, vector<Pi>, greater<Pi>> que;
        dist[s] = 0; que.emplace(dist[s], s);
        while (!que.empty()) {
            T cost; int u; tie(cost, u) = que.top(); que.pop();
            if (dist[u] < cost) continue;
            for (auto &e: g[u]) {
                int v = e.dst; T nc = e.cost;
                if (dist[v] < dist[u] + nc) continue;
                if (dist[v] == dist[u] + nc && prev[v] != -1) {
                    if (prev[v] > u) prev[v] = min(prev[v], u);
                    else continue;
                } else {
                    prev[v] = u;
                }
                dist[v] = dist[u] + nc;
                que.emplace(dist[v], v);
            }
        }
    }
    vector<int> build_path(int t) {
        vector<int> path;
        for (int u = t; u >= 0; u = prev[u]) path.emplace_back(u);
        //reverse(path.begin(), path.end());
        return path;
    }
    void dump_path(int t) { dump_path(build_path(t)); }
    void dump_path(const vector<int> &path) { int t = path.back();
        cerr << s << " -> " << t << " (d = ";
        if (dist[t] == INF) cerr << "∞): "; else cerr << dist[t] << "): ";
        for (auto it = path.begin(); it != path.end() - 1; it++)
            cerr << *it << " -[" << mat[*it][*(it + 1)] << "]-> ";
        if (s == path.front()) cerr << t; cerr << endl;
    }
};

int main() {
    int N, M, S, G; cin >> N >> M >> S >> G;
    WeightedGraph<int> g(N);
    while (M--) {
        int a, b, c; cin >> a >> b >> c;
        g[a].emplace_back(b, c);
        g[b].emplace_back(a, c);
    }
    Dijkstra<int> sssp(g, G);
    int i = 0;
    for (int x: sssp.build_path(S)) {
        if (i++) cout << " "; cout << x;
    }
    cout << endl;
    return 0;
}