#include <iostream>
#include <vector>
#include <queue>
#include <stdio.h>
//#include <algorithm>
#define maxN 100001
#define Infi 200000001
using namespace std;

// A-ból B-be vezető legrövidebb út kiszámítása Dijkstra algoritmussal

// TODO: megérteni, átírni az én nyelvemre max nélkül vectorokkal, implementálni a legnagyobb lehetséges teherbírás koncepcióját!!!
// Note: él structhoz hozzáadni elemként, (minden út teherbírása az összes él teherbírása közötti minimum) -> ezt minden útra eltárolni,
// valamint a súlyegyenlőség esetén nagyobb teherbírású utat választani; nehéz rész: eltárolni a teljes út teherbírását és azt
// összehasonlítani, nem csak a jelenlegi élét, valamint a teljes elmentett út cseréje.

struct El
{
    int pont, suly;
    El(int u, int s)
    {
        pont = u; suly = s;
    };
    bool operator<(const El& jobb) const
    {
        return suly > jobb.suly || (suly == jobb.suly && pont > jobb.pont);
    }
};

vector<El> G[maxN];
priority_queue<El> S;
int n, A, B;

int Apa[maxN];
int Tav[maxN];
bool Kesz[maxN];

void Dijkstra(int r)
{
    //Globális: G,Kesz,Tav,Apa
    int ujtav;
    El e = El(0, 0); El u = El(0, 0);
    for (int v = 1; v <= n; ++v)
    {//inicializálás
        Kesz[v] = false; Tav[v] = Infi;
    }
    Tav[r] = 0; Apa[r] = 0;
    S.push(El(r, Tav[r]));
    while (S.size() > 0)
    {
        u = S.top(); S.pop();
        if (Kesz[u.pont]) continue;
        Kesz[u.pont] = true;
        for (El uv : G[u.pont])
        {
            ujtav = Tav[u.pont] + uv.suly;
            if (!Kesz[uv.pont] && ujtav < Tav[uv.pont])
            {
                e.pont = uv.pont; e.suly = ujtav;
                S.push(e);
                Tav[uv.pont] = ujtav;
                Apa[uv.pont] = u.pont;
            }
        }
    }
}

void Beolvas()
{
    int m, u, v, s;
    cin >> n >> m;
    cin >> A >> B;
    for (int i = 0; i < m; i++)
    {
        cin >> u >> v >> s;
        G[u].push_back(El(v, s));
        G[v].push_back(El(u, s));
    }
}

int main()
{
    Beolvas();
    Dijkstra(A);
    vector<int> Ut;
    int x = B;
    while (x != A)
    {
        Ut.push_back(x);
        x = Apa[x];
    }
    cout << Tav[B] << endl;
    cout << A;
    for (int i = Ut.size() - 1; i >= 0; i--)
        cout << " " << Ut[i];
    cout << endl;
}

/*
6 9
1 6
1 2 3
1 4 7
1 5 6
2 3 4
2 5 3
4 5 8
3 5 5
3 6 2
5 6 3

*/