神仙题。

首先容易想到 Dijkstra 套二进制高精，可以压位，但是压位显然没有什么卵用。
注意到每条边的边权都是 $2^x$ 形式，即二进制下只有一位是 $1$。
所以考虑对每个点开一个线段树维护它的 dist，区间 $[l,r]$ 维护的是二进制下的 $[l,r]$ 位之和（带二进制权）。
对于单点加只要二分进位区域查询，全部清空为 $0$ 即可，再把进位后的那一位单点 $+1$。
线段树二分只要判这段区间是否均为 $1$ 即可，这是好解决的，容易想到 hash。

另外 Dijkstra 需要二进制高精比较大小，这个其实也能二分 + hash 解决，二分最长公共高位前缀，然后区间查询判断是否相等。
于是我们就用空间 $O(nm)$，时间 $O(n \log^3 n)$ 的复杂度解决了这题，非常优秀啊。

其实可以发现每次从 $u \to v$ 的更新只会修改线段树上一条链的信息，所以可以主席树维护。
而且单点加的时候，查询进位区域可以优化为线段树二分，对于比较两个数大小关系中二分最长公共高位前缀也可以线段树二分。

于是就变成了空间 $O(m \log n + n)$，时间 $O(n \log^2 n)$ 的复杂度，可以通过。

由于比较大小复杂度写假了，直接拍了个二分上去，所以复杂度变成了高贵的三只 $\log$，于是就有了 这篇帖子。

#include <bits/stdc++.h>
#define PII pair<int, int>
using namespace std;
const int N = 1e5 + 70, M = N << 1, mod = 1e9 + 7;

int n, m, Max;
long long val[N], val2[N];   //2^i % mod ;  (2^i)-1 % mod
int h[N], e[M], w[M], ne[M], idx = 0;
inline void add_edge(int a, int b, int c) { e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++; }
inline void addedge(int a, int b, int c) { add_edge(a, b, c), add_edge(b, a, c); }

int rt[N], tot = 0;
struct Tree {
    int ls, rs;
    long long hsh;
} tr[N << 8];
bool ask(int u, int l, int r, int x) {   //单点查询
    if (!u) return 0; if (l == r) return (tr[u].hsh > 0);
    int mid = l + r >> 1;
    return (x <= mid) ? ask(tr[u].ls, l, mid, x) : ask(tr[u].rs, mid + 1, r, x);
}
void change(int &u, int l, int r, int x, int d) {  //单点修改为 d
    tr[++tot] = tr[u], u = tot;
    if (l == r) return tr[u].hsh = val[x] * d, void();
    int mid = l + r >> 1;
    if (x <= mid) change(tr[u].ls, l, mid, x, d);
    else change(tr[u].rs, mid + 1, r, x, d);
    tr[u].hsh = (tr[tr[u].ls].hsh + tr[tr[u].rs].hsh) % mod;
}
void del(int &u, int l, int r, int ql, int qr) { //区间删除为 0
    if (ql > qr) return;
    tr[++tot] = tr[u], u = tot;
    if (l >= ql && r <= qr) return u = 0, void();
    int mid = l + r >> 1;
    if (ql <= mid) del(tr[u].ls, l, mid, ql, qr);
    if (qr > mid) del(tr[u].rs, mid + 1, r, ql, qr);
    tr[u].hsh = (tr[tr[u].ls].hsh + tr[tr[u].rs].hsh) % mod;
}
inline long long gethsh1(int l, int r) { return (val2[r] - val2[l - 1] + mod) % mod; }
inline bool check(int l, int r, long long hsh) { return hsh == gethsh1(l, r); } //是否全是 1
int query(int u, int l, int r, int x) { //求以 x 为左端点，能进位的极长右端点
    if (!u) return x; if (l == r) return (tr[u].hsh > 0) ? l : x;
    int mid = l + r >> 1;
    if (x > mid) return query(tr[u].rs, mid + 1, r, x);

    if (query(tr[u].ls, l, mid, x) == mid) return max(mid, query(tr[u].rs, mid + 1, r, x) );
    if ( check(l, mid, tr[tr[u].ls].hsh) ) return max(mid, query(tr[u].rs, mid + 1, r, x) );
    return query(tr[u].ls, l, mid, x);
}
void add(int &u, int x) {    // u（树上） x 位置 + 1
    if (!ask(u, 0, Max, x)) change(u, 0, Max, x, 1);
    else {
        int pos = query(u, 0, Max, x);
        del(u, 0, Max, x, pos), change(u, 0, Max, pos + 1, 1);
    }
}
int queryhsh(int u, int l, int r, int ql, int qr) {
    if (!u || ql > qr) return 0;
    if (l >= ql && r <= qr) return tr[u].hsh;
    int mid = l + r >> 1, res = 0;
    if (ql <= mid) res += queryhsh(tr[u].ls, l, mid, ql, qr);
    if (qr > mid) res += queryhsh(tr[u].rs, mid + 1, r, ql, qr);
    return res % mod;
}
bool findpos(int u, int v, int l, int r) {
    if (l == r) return (tr[u].hsh > 0);
    int mid = l + r >> 1;
    if (tr[tr[u].rs].hsh == tr[tr[v].rs].hsh) return findpos(tr[u].ls, tr[v].ls, l, mid);
    return findpos(tr[u].rs, tr[v].rs, mid + 1, r);
}
inline bool compare(int u, int v) {    // rt[u] 是否比 rt[v] 大
    return findpos(u, v, 0, Max);
}
inline int ADD(int u, int x) { int now = u; add(now, x); return now; }

void print(int u, int l, int r) {
    if (!u) return;
    if (l == r) return;
    int mid = l + r >> 1;
    print(tr[u].ls, l, mid), print(tr[u].rs, mid + 1, r);
}

bool st[N];
int pre[N];

struct cmp {
    bool operator ()(PII &a, PII &b) { return compare(a.first, b.first); }  // a < b
};
priority_queue< PII , vector<PII>, cmp > q;

int S, T;
vector<int> ans;
void dijkstra() {
    for (register int i = 0; i <= Max; i++) change(rt[S], 0, Max, i, 0);
    q.push({rt[S], S});
    while (q.size()) {
        int u = q.top().second; q.pop();
        if (st[u]) continue; st[u] = 1;
        for (register int i = h[u]; ~i; i = ne[i]) {
            int v = e[i];
            int now = ADD(rt[u], w[i]);
            if (!rt[v] || compare(rt[v], now)) rt[v] = now, q.push({rt[v], v}), pre[v] = u;
        }
    }
}

int Fa[N];
inline int find(int x) { return (x == Fa[x]) ? x : Fa[x] = find(Fa[x]); }
inline void Merge(int x, int y) { x = find(x), y = find(y); if (x ^ y) Fa[x] = y; }

int main() {
    scanf("%d%d", &n, &m);
    for (register int i = 1; i <= n; i++) h[i] = -1, Fa[i] = i;
    for (register int i = 1, a, b, c; i <= m; i++) scanf("%d%d%d", &a, &b, &c), addedge(a, b, c), Merge(a, b), Max = max(Max, c); Max += 20;
    val[0] = 1ll; for (register int i = 1; i <= Max + 1; i++) val[i] = (val[i - 1] << 1) % mod;
    for (int i = 0; i <= Max; i++) val2[i] = (val[i + 1] - 1 + mod) % mod;
    scanf("%d%d", &S, &T);
    if (find(S) ^ find(T)) return puts("-1"), 0;
    if (S == T) return printf("0\n1\n%d\n", S), 0;
    dijkstra();
    printf("%lld\n", tr[rt[T]].hsh);

    // for (register int i = 1; i <= n; i++) cout << pre[i] << ' '; puts("");
    int now = T; while (now != S) ans.push_back(now), now = pre[now]; ans.push_back(S);
    printf("%d\n", (int)ans.size());
    reverse(ans.begin(), ans.end());
    for (register int i : ans) printf("%d ", i);
    return 0;
}