#include<bits/stdc++.h>
#include<vector>
using namespace std;
const int maxn=505;
const int INF = 1e9+5;
int N,M,S,D,c1,c2,dist,cost;
int weights[maxn]; //点权值 
int G[maxn][maxn];   //邻接矩阵图 存两顶点间的距离 
int C[maxn][maxn];   //邻接矩阵图 存两顶点间的花费 
int d[maxn]; //d数组数最短路径 
bool vis[maxn]={false};
vector<int> pre[maxn];
void Dijkstra(int s){
	fill(d,d+N,INF); //初始化最短距离为无穷
	d[s] = 0;  //起点的最短路径为0
	for(int i=0;i<N;i++){
		int u = -1, Min=INF;
		for(int j=0;j<N;j++){
			if(vis[j]==false && d[j] < Min){ //没被访问过，且有最短路径，则挑选出来 
				Min = d[j];
				u = j;
			}
		}
		vis[u]=true;
		for(int v=0;v<N;v++){
			if(vis[v]==false && G[u][v]!=INF){
				if(d[u] + G[u][v] < d[v]){  //最短路径更新 
					d[v]=d[u] + G[u][v];    //路径最短 
					pre[v].clear();
					pre[v].push_back(u);  //有最优前驱，先清空 
				}else if(d[u] + G[u][v] == d[v]){
					pre[v].push_back(u);  //有重复最短路径，直接添加 
				} 
			}
		} 
	}  
	
}
int totalcost=INF;
vector<int> path,tempPath;
void DFS(int v){ //递归式+边界
	if(v==S){   //叶子节点 即起点 因为是倒着找回去的 最开始给的是终点 
		
		tempPath.push_back(v);
		int value=0;  //点权
		for(int i=tempPath.size()-1;i >0; i--){
			int x=tempPath[i];
			int y=tempPath[i-1];
			value += C[x][y];
		}
		if(value < totalcost) {
			totalcost = value;
			path.clear();
			for(int i=tempPath.size()-1;i >=0; i--){
				path.push_back(tempPath[i]);  //向量从尾部加入，所以输出的时候正序输出就是从开始到结尾的顺序 
			}
		}
		tempPath.pop_back();  
		return;   //终止条件 
	} 
	tempPath.push_back(v);
	for(int i=0;i<pre[v].size();i++){ //遍历pre[v]的所有结点并进行递归 
		DFS(pre[v][i]);
	} 
	tempPath.pop_back();
	
}
int main(){
	fill(G[0],G[0]+maxn*maxn,INF); //没有边的地方就为无穷大 
	scanf("%d%d%d%d",&N,&M,&S,&D);
	for(int i=0;i<M;i++){
	 	scanf("%d%d%d%d",&c1,&c2,&dist,&cost); //保存点权
		G[c1][c2]=dist;    //路为无向图 
		C[c1][c2]=cost; 
		G[c2][c1]=dist; 
		C[c2][c1]=cost; 
	 }
	Dijkstra(S);
	DFS(D);
	for(int i=0;i<path.size();i++){
		printf(i==0?"%d":" %d",path[i]);
	}
	printf(" %d %d\n",d[D],totalcost);
	return 0;
}