#include<bits/stdc++.h>

using namespace std;
using ll = long long;
using pint = pair<int,int>;

template<class T> class ShortestPathDAG { private:
	using P = pair<int,T>;
	vector<vector<P>> DAG, Graph;
	vector<T> dist;
	T INF;
	int N, start;
 
	vector<T> dijkstra(){
		vector<T> dist(N, INF);
		dist[start] = 0;
		priority_queue<pair<T,int>, vector<pair<T,int>>, greater<pair<T,int>>> que;
		que.push({0, start});
		while(que.size()) {
			int ver = que.top().second;
			T cost = que.top().first; que.pop();
			if(cost != dist[ver])continue;
			for(auto i : Graph[ver]) {
				if(dist[i.first] > cost + i.second) {
					dist[i.first] = cost + i.second;
					que.push({dist[i.first], i.first});
				}
			}
		}
		return dist;
	}

public:
	ShortestPathDAG(){}
	ShortestPathDAG(vector<vector<P>> _Graph, int _start = 0, T _INF = numeric_limits<T>::max()): N(_Graph.size()), start(_start) {
		INF = _INF;
		Graph = _Graph;
		dist = dijkstra();
		DAG = vector<vector<P>>(N);
		for(int i = 0; i < N; i++) {
			for(auto [j, cost] : Graph[i]) {
				if(dist[j] - dist[i] == cost) {
					DAG[i].push_back({j, cost});
				}
			}
		}
		
	}
	vector<T>& dis() {return dist;}
	vector<vector<P>>& dag() {return DAG;}
};

class EraseVertex { private:

	vector<vector<int>> Graph, ReversedGraph, ErasedGraph;
	vector<int> ok;
	int N;

	void dfs0(ll v) {
		if(ok[v] & 1)return;
		ok[v]++;
		for(auto i : Graph[v]) {
			dfs0(i);
		}
	}
	void dfs1(ll v) {
		if(ok[v] & 2)return;
		ok[v] += 2;
		for(auto i : ReversedGraph[v]) {
			dfs1(i);
		}
	}

public:

	EraseVertex(const vector<vector<int>>& edge, int s, int t) { 
		N = edge.size(); Graph = edge; ok = vector<int>(N);
		ReversedGraph = ErasedGraph = vector<vector<int>>(N);
		for(int i = 0; i < N; i++) {
			for(auto j : Graph[i]) ReversedGraph[j].push_back(i); 
		}
		dfs0(s), dfs1(t);
		for(int i = 0; i < N; i++) {
			for(auto j : Graph[i]) {
				if(ok[i] == 3 && ok[j] == 3) {
					ErasedGraph[i].push_back(j);
				}
			}
		}
	}
	auto& rg() {return ReversedGraph;}
	auto& eg() {return ErasedGraph;}

};

template<class T> ostream& operator<<(ostream& os, const vector<T> arr){ for(int i = 0; i < (int)arr.size(); i++)cout << arr[i] << (i == (int)arr.size() -1 ? "" : " "); return os;}

int main()
{
	int N, M, S, G;
	cin >> N >> M >> S >> G;
	vector<vector<pair<int,int>>> edges(N);
	for(int i = 0; i < M; i++) {
		int a, b, c; cin >> a >> b >> c;
		edges[a].push_back({b, c});
		edges[b].push_back({a, c});
	}

	ShortestPathDAG<int> SPD(edges, S, 1e9);
	vector<vector<int>> v(N);
	for(int i = 0; i < N; i++) {
		for(auto [j, c] : SPD.dag()[i])v[i].push_back(j);
	}
	EraseVertex EV(v, S, G);

	auto dag = EV.eg();

	vector<int> ans = {S};
	while(ans.back() != G) {
		int p = ans.back();
		sort(dag[p].begin(), dag[p].end());
		ans.push_back(dag[p][0]);
	}
	
	cout << ans << endl;


}