#include <cstdio>

#include <cstdlib>

#include <vector>

#include <queue>

#include <unordered_map>

#include <algorithm>

#include <climits>

#define CMB(ID1, ID2) (((ID1)<<9) | (ID2))

using namespace std;

class City {

public:

    vector<int> adj;

    int dist;

    City(int d = INT_MAX): dist(d){}

};

typedef pair<int, int> P;

// sparse table

unordered_map<int, int> dist;

unordered_map<int, int> cost;

void print_cities(vector<City> &cities) {

    int len = cities.size();

    for (int i=; i<len; i++) {

        printf("%d\n", i);

        int adj_len = cities[i].adj.size();

        for (int j=; j<adj_len; j++) {

            int cid = CMB(i, cities[i].adj[j]);

            printf("\t%d %d %d", cities[i].adj[j], dist[cid], cost[cid]);

        }

        printf("\n");

    }

}

void dfs(vector<int> &final, vector<int>& path, int path_cost, int &final_cost, vector<City>& cities, int idx) {

        if (cities[idx].dist == ) {

            // we reach the start point

            if (path_cost < final_cost) {

                final_cost = path_cost;

                final = path;

                final.push_back(idx);

            }

            return;

        }

        City& cur_city = cities[idx];

        int adj_len = cur_city.adj.size();

        for (int i=; i<adj_len; i++) {

            int adj_idx = cur_city.adj[i];

            int pdist = cities[adj_idx].dist + dist[CMB(idx, adj_idx)];

            if (pdist == cur_city.dist) {

                // adj city on the shortest path

                path.push_back(idx);

                path_cost += cost[CMB(idx, adj_idx)];

                // follow it

                dfs(final, path, path_cost, final_cost, cities, adj_idx);

                path_cost -= cost[CMB(idx, adj_idx)];

                path.pop_back();

            }

        }

}

int main() {

    int N, M, S, D;

    scanf("%d%d%d%d", &N, &M, &S, &D);

    vector<City> cities(N);

    int c1, c2, d, c;

    for (int i=; i<M; i++) {

        scanf("%d%d%d%d", &c1, &c2, &d, &c);

        dist.insert(make_pair(CMB(c1, c2), d));

        dist.insert(make_pair(CMB(c2, c1), d));

        cost.insert(make_pair(CMB(c1, c2), c));

        cost.insert(make_pair(CMB(c2, c1), c));

        cities[c1].adj.push_back(c2);

        cities[c2].adj.push_back(c1);

    }

    cities[S].dist = ;

    //print_cities(cities);

    priority_queue<P, vector<P>, greater<P> > nodes;

    nodes.push(make_pair(, S));

    bool updated = true;

    while (updated) {

        updated = false;

        P node = nodes.top();

        nodes.pop();

        int cur_idx = node.second;

        int cur_dst = node.first;

        if (cur_dst > cities[cur_idx].dist) {

            // there is another shorter path to the current selected city

            // so the node info is out of date, just drop it

            updated = true;

            continue;

        }

        City& cur_city = cities[cur_idx];

        int alen = cur_city.adj.size();

        // traverse adj cities of the current city

        for (int i=; i<alen; i++) {

            int adj_idx = cur_city.adj[i];

            City& adj_city = cities[adj_idx];

            int new_dist = cur_city.dist + dist[CMB(cur_idx, adj_idx)];

            if (new_dist < adj_city.dist) {

                adj_city.dist = new_dist;

                nodes.push(make_pair(new_dist, adj_idx));

                updated = true;

            }

        }

    }

    vector<int> final, path;

    int path_cost = , final_cost = INT_MAX;

    dfs(final, path, path_cost, final_cost, cities, D);

    int flen = final.size();

    if (flen < ) {

        return ;

    }

    reverse(final.begin(), final.end());

    printf("%d", final[]);

    for (int i=; i<flen; i++) {

        printf(" %d", final[i]);

    }

    printf(" %d %d", cities[D].dist, final_cost);

    return ;

}