import java.io.InputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.math.BigDecimal;
import java.math.BigInteger;
    
public class Main{
 
static PrintWriter out;
static InputReader ir;
static final int INF=1<<30;
static final long LINF=Long.MAX_VALUE;
 
static void solve(){
 int n=ir.nextInt();
 int m=ir.nextInt();
 int s=ir.nextInt();
 int g=ir.nextInt();
 list=new AdjacencyList[n];
 dist=new int[n];
 prev=new int[n];
 for(int i=0;i<n;i++){
  list[i]=new AdjacencyList();
 }
 for(int i=0;i<m;i++){
  int a=ir.nextInt();
  int b=ir.nextInt();
  int c=ir.nextInt();
  list[a].add(new Edge(b,c));
  list[b].add(new Edge(a,c));
 }
 dijkstra(s);
 ArrayList<Integer> path=get_path(g);
 StringBuilder sb=new StringBuilder();
 for(int ans : path){
  sb.append(ans);
  sb.append(" ");
 }
 sb.deleteCharAt(sb.length()-1);
 out.println(sb);
}

public static void main(String[] args) throws Exception{
 ir=new InputReader(System.in);
 out=new PrintWriter(System.out);
 solve();
 out.flush();
}

static class Edge{
 int from;
 int to;
 int cost;
 public Edge(int from,int to,int cost){
  this.from=from; this.to=to; this.cost=cost;
 }
 public Edge(int to,int cost){
  this.to=to; this.cost=cost;
 }
}

static class AdjacencyList extends ArrayList<Edge>{}

static int[] dist,prev;
static AdjacencyList[] list;

public static void dijkstra(int s){
 PriorityQueue<Pair> pque=new PriorityQueue<Pair>(19,Pair.X_ORDER);
 Arrays.fill(dist,INF);
 Arrays.fill(prev,-1);
 dist[s]=0;
 pque.offer(new Pair(0,s));
 while(!pque.isEmpty()){
  Pair p=pque.poll();
  int v=p.y;
  AdjacencyList array=list[v];
  if(dist[v]<p.x||array.size()==0) continue;
  for(int i=0;i<array.size();i++){
   Edge e=array.get(i);
   if(dist[e.to]>dist[v]+e.cost){
    dist[e.to]=dist[v]+e.cost;
    prev[e.to]=v;
    pque.offer(new Pair(dist[e.to],e.to));
   }
   else if(dist[e.to]==dist[v]+e.cost&&v<prev[e.to]) prev[e.to]=v;
  }
 }
}

public static ArrayList get_path(int g){
 ArrayList<Integer> ret=new ArrayList<>();
 int now=g;
 while(now!=-1){
  ret.add(now);
  now=prev[now];
 }
 Collections.reverse(ret);
 return ret;
}

static class Pair{
 int x;
 int y;
 public Pair(int x,int y){
  this.x=x; this.y=y;
 }
 public static Comparator<Pair> X_ORDER=new Comp1();
 public static Comparator<Pair> Y_ORDER=new Comp2();
 private static class Comp1 implements Comparator<Pair>{
  public int compare(Pair p1,Pair p2){
   return (p1.x>p2.x)?1:(p1.x<p2.x)?-1:0;
  }
 }
 private static class Comp2 implements Comparator<Pair>{
  public int compare(Pair p1,Pair p2){
   return (p1.y>p2.y)?1:(p1.y<p2.y)?-1:0;
  }
 }
}

static class InputReader {
 private InputStream in;
 private byte[] buffer=new byte[1024];
 private int curbuf;
 private int lenbuf;

 public InputReader(InputStream in) {this.in=in; this.curbuf=this.lenbuf=0;}
 
 public boolean hasNextByte() {
  if(curbuf>=lenbuf){
   curbuf= 0;
   try{
    lenbuf=in.read(buffer);
   }catch(IOException e) {
    throw new InputMismatchException();
   }
   if(lenbuf<=0) return false;
  }
  return true;
 }

 private int readByte(){if(hasNextByte()) return buffer[curbuf++]; else return -1;}
 
 private boolean isSpaceChar(int c){return !(c>=33&&c<=126);}
 
 private void skip(){while(hasNextByte()&&isSpaceChar(buffer[curbuf])) curbuf++;}
 
 public boolean hasNext(){skip(); return hasNextByte();}
 
 public String next(){
  if(!hasNext()) throw new NoSuchElementException();
  StringBuilder sb=new StringBuilder();
  int b=readByte();
  while(!isSpaceChar(b)){
   sb.appendCodePoint(b);
   b=readByte();
  }
  return sb.toString();
 }
 
 public int nextInt() {
  if(!hasNext()) throw new NoSuchElementException();
  int c=readByte();
  while (isSpaceChar(c)) c=readByte();
  boolean minus=false;
  if (c=='-') {
   minus=true;
   c=readByte();
  }
  int res=0;
  do{
   if(c<'0'||c>'9') throw new InputMismatchException();
   res=res*10+c-'0';
   c=readByte();
  }while(!isSpaceChar(c));
  return (minus)?-res:res;
 }
 
 public long nextLong() {
  if(!hasNext()) throw new NoSuchElementException();
  int c=readByte();
  while (isSpaceChar(c)) c=readByte();
  boolean minus=false;
  if (c=='-') {
   minus=true;
   c=readByte();
  }
  long res = 0;
  do{
   if(c<'0'||c>'9') throw new InputMismatchException();
   res=res*10+c-'0';
   c=readByte();
  }while(!isSpaceChar(c));
  return (minus)?-res:res;
 }

 public double nextDouble(){return Double.parseDouble(next());}

 public BigInteger nextBigInteger(){return new BigInteger(next());}

 public BigDecimal nextBigDecimal(){return new BigDecimal(next());}

 public int[] nextIntArray(int n){
  int[] a=new int[n];
  for(int i=0;i<n;i++) a[i]=nextInt();
  return a;
 }

 public long[] nextLongArray(int n){
  long[] a=new long[n];
  for(int i=0;i<n;i++) a[i]=nextLong();
  return a;
 }

 public char[][] nextCharMap(int n,int m){
  char[][] map=new char[n][m];
  for(int i=0;i<n;i++) map[i]=next().toCharArray();
  return map;
 }
}
}