#define _USE_MATH_DEFINES
 
#include <iostream>
#include <iomanip>
#include <sstream>
 
#include <algorithm>
#include <cmath>
 
#include <string>
//#include <array>
#include <list>
#include <queue>
#include <vector>
#include <complex>
#include <set>
#include <map>
 
/////////
#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i,n) REP(i,0,n)
#define P(p) cout<<(p)<<endl;
 
#define PII pair<int,int>
/////////
typedef long long LL;
typedef long double LD;
/////////
using namespace::std;
/////////
const int Vmax = 200;

int main(void){
    std::cin.tie(0); 
    std::ios::sync_with_stdio(false);
    std::cout << std::fixed;//
    //cout << setprecision(16);//
	
	int N,M,start,goal;
	cin>>N>>M>>start>>goal;
	int vvc[Vmax][Vmax];
	rep(i,200)rep(j,200)vvc[i][j] = -1;
	int a,b,c;
	rep(i,M){
		cin>>a>>b>>c;
		vvc[a][b] = c;
		vvc[b][a] = c;
	}

	//(cost,pos)
	priority_queue<vector<int>,vector<vector<int>>,greater<vector<int>>> q;
	vector<int> itq;
	bool use[Vmax];
	PII dist[Vmax];//cost,prev
	vector<int> bpath[Vmax];
	rep(i,N){
		use[i] = false;
		dist[i] = PII( -1,-1);
	}

	vector<int> vec(3);
	vec[0] = 0;
	vec[1] = start;
	vec[2] = start;
	//cost,prev,now
	q.push( vec );

	vector<int> path1(Vmax),path2(Vmax);

	while( !q.empty() ){
		itq = q.top();q.pop();
		if( use[ itq[2] ] == true ){
			if( dist[ itq[2] ].first == itq[0]){
				path1.clear();
				path2.clear();
				
				path1 = bpath[ itq[1] ];
				path1.push_back( itq[2] );
				path2 = bpath[ itq[2] ];

				vector<int>::iterator it1,it2;
				it1 = path1.begin();
				it2 = path2.begin();
				int pathCheck = -1;
				{
					int pathCount = 0;
					while( it1 != path1.end() && it2 != path2.end() ){
						if( *it1 > *it2 ){
							pathCheck = 2;
							break;
						}else if( *it1 < *it2 ){
							pathCheck = 1;
							break;
						}else{
							++pathCount;
						}
						++it1;
						++it2;
					}
					if( pathCheck == -1){
						if( path1.size() < path2.size() ){
							pathCheck = 1;
						}else if( path1.size() < path2.size() ){
							pathCheck = 2;
						}
					}
				}

				if( pathCheck == 1 ){
					dist[ itq[2] ] = PII( itq[0],itq[1]);
					bpath[ itq[2] ] = path1;
				}else{
					continue;
				}
			}
		}else{
			use[ itq[2] ] = true;
			dist[ itq[2] ] = PII( itq[0],itq[1]);
			bpath[ itq[2] ] = bpath[ itq[1] ]; 
			bpath[ itq[2] ].push_back( itq[2] ) ;
		}
		for(int i=0; i<N ;++i){//頂点数
			//if( use[i] == true || vvc[ itq[2] ][i] < 0 ) continue;
			if( vvc[ itq[2] ][i] < 0 ) continue;
			vec[0] = itq[0] + vvc[ itq[2] ][i];
			vec[1] = itq[2];
			vec[2] = i;
			if( use[i] == true && dist[ vec[2] ].first < vec[0] ) continue;
			q.push( vec );
		}
	}

	int path[Vmax];
	int pathCount = 0;
	int pathPrev = goal;
	while( pathPrev != start )
	{
		path[pathCount] = pathPrev;
		++pathCount;;

		pathPrev = dist[pathPrev].second;
	}
	path[pathCount] = start;
	while(pathCount > 0){
		cout << path[pathCount] << " ";
		--pathCount;
	}
	cout << path[pathCount] << endl;

	
	return 0;
}