#include <bits/stdc++.h>
using namespace std;

static const long long MOD = 1000000007LL;
static const long long INF = LLONG_MAX;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, M;
    cin >> N >> M;

    vector<vector<pair<int,long long>>> graph(N+1);

    for(int i = 0; i < M; i++) {
        int u, v;
        long long w;
        cin >> u >> v >> w;
        graph[u].push_back({v, w});
        graph[v].push_back({u, w});
    }

    int A, B;
    cin >> A >> B;

    auto dijkstra = [&](int start,
                        vector<long long>& dist,
                        vector<long long>& ways) {
        dist.assign(N+1, INF);
        ways.assign(N+1, 0);

        priority_queue<
            pair<long long,int>,
            vector<pair<long long,int>>,
            greater<pair<long long,int>>
        > pq;

        dist[start] = 0;
        ways[start] = 1;
        pq.push({0, start});

        while(!pq.empty()) {
            auto [cd, u] = pq.top();
            pq.pop();
            if(cd > dist[u]) continue;

            for(auto [v, w] : graph[u]) {
                long long nd = cd + w;
                if(nd < dist[v]) {
                    dist[v] = nd;
                    ways[v] = ways[u];
                    pq.push({nd, v});
                } else if(nd == dist[v]) {
                    ways[v] = (ways[v] + ways[u]) % MOD;
                }
            }
        }
    };

    vector<long long> distA, distB;
    vector<long long> waysA, waysB;

    dijkstra(A, distA, waysA);
    dijkstra(B, distB, waysB);

    long long D = distA[B];
    long long total = (waysA[B] * waysA[B]) % MOD;

    long long bad = 0;

    // ---- Csúcson történő találkozás ----
    for(int v = 1; v <= N; v++) {
        if(distA[v] + distB[v] == D && distA[v] * 2 == D) {
            long long cnt = (waysA[v] * waysB[v]) % MOD;
            bad = (bad + cnt * cnt) % MOD;
        }
    }

    // ---- Élen történő találkozás ----
    for(int u = 1; u <= N; u++) {
        for(auto [v, w] : graph[u]) {

            // irányítottként egyszer számoljuk
            if(distA[u] < distA[v]) {
                if(distA[u] + w + distB[v] == D) {

                    if(distA[u] * 2 < D &&
                       distA[v] * 2 > D) {

                        long long cnt =
                          (waysA[u] * waysB[v]) % MOD;

                        bad = (bad + cnt * cnt) % MOD;
                    }
                }
            }
        }
    }

    long long ans = (total - bad) % MOD;
    if(ans < 0) ans += MOD;

    cout << ans << "\n";

    return 0;
}