#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;

#define each(i,a) for (auto&& i : a)
#define FOR(i,a,b) for (ll i=(a),__last_##i=(b);i<__last_##i;i++)
#define RFOR(i,a,b) for (ll i=(b)-1,__last_##i=(a);i>=__last_##i;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
#define pb push_back
#define all(a) (a).begin(),(a).end()
#define chmin(x,v) x = min(x, v)
#define chmax(x,v) x = max(x, v)

const ll linf = 1e18;
const double eps = 1e-12;
const double pi = acos(-1);

template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
    each(x,vec) is >> x;
    return is;
}
template<typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
    rep(i,vec.size()) {
        if (i) os << " ";
        os << vec[i];
    }
    return os;
}
template<typename T>
ostream& operator<<(ostream& os, const vector< vector<T> >& vec) {
    rep(i,vec.size()) {
        if (i) os << endl;
        os << vec[i];
    }
    return os;
}
const ll mod = 1e9+7;
ll mul(ll a, ll b) {
    return a * b % mod;
}
ll mul(initializer_list<ll> t) {
    ll res = 1;
    each(v, t) res = mul(res, v);
    return res;
}
ll add(ll a, ll b) {
    return (a + b) % mod;
}
ll add(initializer_list<ll> t) {
    ll res = 0;
    each(v, t) res = add(res, v);
    return res;
}
ll sub(ll a, ll b) {
    return (a - b + mod) % mod;
}
ll sub(initializer_list<ll> t) {
    auto it = t.begin();
    ll res = *(it++);
    while (it != t.end()) {
        res = sub(res, *(it++));
    }
    return res;
}
ll power(ll x, ll n) {
    ll res = 1;
    for (ll i = 1; i <= n; i <<= 1) {
        if (i & n) res = mul(res, x);
        x = mul(x, x);
    }
    return res;
}
ll inv(ll n) {
    return power(n, mod-2);
}
ll divi(ll a, ll b) {
    return mul(a, inv(b));
}
ll divi(initializer_list<ll> t) {
    auto it = t.begin();
    ll res = *(it++);
    while (it != t.end()) {
        res = divi(res, *(it++));
    }
    return res;
}
vector<ll> fact;
void init_fact(ll n) {
    fact.assign(n+1, 1);
    FOR(i, 1, fact.size()) {
        fact[i] = mul(fact[i-1], i);
    }
}

ll comb(ll n, ll r) {
    if (r < 0) return 0;
    if (r > n) return 0;
    return divi(fact[n], mul(fact[r], fact[n-r]));
}

using Row = vector<ll>;
using Matrix = vector<Row>;
Matrix E(ll n) {
    Matrix res(n, Row(n, 0));
    rep(i, n) res[i][i] = 1;
    return res;
}
Matrix mul(const Matrix& A, const Matrix& B) {
    const ll n = A.size(), m = A[0].size(), l = B[0].size();
    assert(m == B.size());
    Matrix res(n, Row(l, 0));
    rep(i, n) rep(j, m) rep(k, l) {
        res[i][k] = add(res[i][k], mul(A[i][j], B[j][k]));
    }
    return res;
}
Matrix power(Matrix A, ll n) {
    assert(A.size() == A[0].size());
    Matrix res = E(A.size());
    for (ll i = 1; i <= n; i <<= 1) {
        if (i & n) res = mul(res, A);
        A = mul(A, A);
    }
    return res;
}
void gen_fact_result(ll d, ll num) {
    ll x = 1;
    cout << "#define FACT";
    cout << "vector<P> facts = {";
    rep(i, d*(num-1)+1) {
        if (i % d == 0) {
            cout << "{" << i << "," << x << "},";
        }
        x = mul(x, i+1);
    }
    cout << "};";
}
#define FACT
vector<P> facts = {{0,1},{10000000,682498929},{20000000,491101308},{30000000,76479948},{40000000,723816384},{50000000,67347853},{60000000,27368307},{70000000,625544428},{80000000,199888908},{90000000,888050723},{100000000,927880474},{110000000,281863274},{120000000,661224977},{130000000,623534362},{140000000,970055531},{150000000,261384175},{160000000,195888993},{170000000,66404266},{180000000,547665832},{190000000,109838563},{200000000,933245637},{210000000,724691727},{220000000,368925948},{230000000,268838846},{240000000,136026497},{250000000,112390913},{260000000,135498044},{270000000,217544623},{280000000,419363534},{290000000,500780548},{300000000,668123525},{310000000,128487469},{320000000,30977140},{330000000,522049725},{340000000,309058615},{350000000,386027524},{360000000,189239124},{370000000,148528617},{380000000,940567523},{390000000,917084264},{400000000,429277690},{410000000,996164327},{420000000,358655417},{430000000,568392357},{440000000,780072518},{450000000,462639908},{460000000,275105629},{470000000,909210595},{480000000,99199382},{490000000,703397904},{500000000,733333339},{510000000,97830135},{520000000,608823837},{530000000,256141983},{540000000,141827977},{550000000,696628828},{560000000,637939935},{570000000,811575797},{580000000,848924691},{590000000,131772368},{600000000,724464507},{610000000,272814771},{620000000,326159309},{630000000,456152084},{640000000,903466878},{650000000,92255682},{660000000,769795511},{670000000,373745190},{680000000,606241871},{690000000,825871994},{700000000,957939114},{710000000,435887178},{720000000,852304035},{730000000,663307737},{740000000,375297772},{750000000,217598709},{760000000,624148346},{770000000,671734977},{780000000,624500515},{790000000,748510389},{800000000,203191898},{810000000,423951674},{820000000,629786193},{830000000,672850561},{840000000,814362881},{850000000,823845496},{860000000,116667533},{870000000,256473217},{880000000,627655552},{890000000,245795606},{900000000,586445753},{910000000,172114298},{920000000,193781724},{930000000,778983779},{940000000,83868974},{950000000,315103615},{960000000,965785236},{970000000,492741665},{980000000,377329025},{990000000,847549272},};
#ifdef FACT
ll bigfact(ll n) {
    if (n >= mod) return 0;
    auto it = upper_bound(all(facts), P(n, linf));
    assert(it != facts.begin());
    --it;
    ll s = it->first;
    ll res = it->second;
    rep(i, s+1, n+1) {
        res = mul(res, i);
    }
    return res;
}
#endif

struct Edge {
    ll to, cost;
};
vector<ll> dijkstra(const vector<vector<Edge>>& G, ll s) {
    const ll n = G.size();
    priority_queue<P, vector<P>, greater<P>> Q;
    vector<ll> res(n, linf);
    res[s] = 0; Q.push({0, s});
    while ( !Q.empty() ) {
        P p = Q.top(); Q.pop();
        ll v, c; tie(c, v) = p;
        if (c > res[v]) continue;
        each(e, G[v]) {
            if (res[v] + e.cost < res[e.to]) {
                res[e.to] = res[v] + e.cost;
                Q.push({res[e.to], e.to});
            }
        }
    }
    return res;
}
vector<ll> count(const vector<vector<ll>>& G, ll s) {
    const ll n = G.size();
    vector<ll> dp(n, 0), cnt(n, 0);
    rep(v, n) each(to, G[v]) cnt[to]++;
    dp[s] = 1;
    queue<ll> Q;
    rep(i, n) if (cnt[i] == 0) Q.push(i);
    while ( !Q.empty() ) {
        ll v = Q.front(); Q.pop();
        each(to, G[v]) {
            dp[to] = add(dp[to], dp[v]);
            if (--cnt[to] == 0) {
                Q.push(to);
            }
        }
    }
    return dp;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    ll n, m; cin >> n >> m;
    ll s, t; cin >> s >> t; --s, --t;
    vector<vector<Edge>> G(n);
    rep(i, m) {
        ll a, b, c; cin >> a >> b >> c; --a, --b;
        G[a].pb({b, c});
        G[b].pb({a, c});
    }
    vector<ll> dist = dijkstra(G, s);
    vector<vector<ll>> g(n), rg(n);
    rep(v, n) each(e, G[v]) {
        if (dist[v] + e.cost == dist[e.to]) {
            g[v].pb(e.to);
            rg[e.to].pb(v);
        }
    }
    // cout << dist << endl;
    ll T = dist[t];
    vector<ll> scnt = count(g, s);
    vector<ll> tcnt = count(rg, t);
    // cout << scnt << endl;
    // cout << tcnt << endl;
    assert(scnt[t] == tcnt[s]);
    ll ans = mul(scnt[t], tcnt[s]);
    // 辺で会う
    rep(v, n) each(to, g[v]) {
        assert(dist[v] < dist[to]);
        if (dist[v]*2 < T && dist[to]*2 > T) {
            ll x = mul(scnt[v], tcnt[to]);
            ans = sub(ans, mul(x, x));
        }
    }
    // 頂点で会う
    rep(v, n) {
        if (dist[v] * 2 == T) {
            ll x = mul(scnt[v], tcnt[v]);
            ans = sub(ans, mul(x, x));
        }
    }
    cout << ans << endl;
}


Measured memory_bytes: 27248