### BUGGY CODE ###

from collections import defaultdict
from heapq import heappop, heappush


def get_patterns_func(s, ancestors):
    cache = {s: 1}

    def get_patterns(v):
        if v in cache:
            return cache[v]
        return sum(get_patterns(a) for a in ancestors[v])

    return get_patterns


def solve(s, t, links):
    MOD = 1000000007
    q = [(0, s, -1, 0), (0, t, -1, 1)]
    visited = [{}, {}]
    ancestors = [defaultdict(set), defaultdict(set)]
    limit = float('inf')
    collision_pair = set()
    while q:
        cost, v, a, is_bwd = heappop(q)
        if cost > limit:
            break
        visited_self = visited[is_bwd]
        # print(is_bwd, cost, v, a, visited_self)
        if v in visited_self and visited_self[v] < cost:
            continue

        visited_self[v] = cost
        ancestors[is_bwd][v].add(a)

        visited_opp = visited[is_bwd ^ 1]
        if v in visited_opp:
            cost_opp = visited_opp[v]
            if limit < cost + cost_opp:
                continue
            if (a, a) in collision_pair:
                continue
            limit = cost + cost_opp
            if cost == cost_opp:
                # print('add', v)
                collision_pair.add((v, v))
            else:
                # print('add', v, a)
                collision_pair.add((v, a) if is_bwd else (a, v))
            continue

        for du, u in links[v]:
            nc = cost + du
            if u in visited_self and visited_self[u] < nc:
                continue
            heappush(q, (nc, u, v, is_bwd))

    get_patterns_fwd = get_patterns_func(s, ancestors[0])
    get_patterns_bwd = get_patterns_func(t, ancestors[1])
    shortest_count = 0
    collision_count = 0

    for u, v in collision_pair:
        r1, r2 = get_patterns_fwd(u), get_patterns_bwd(v)
        shortest_count += r1 * r2
        shortest_count %= MOD
        collision_count += pow(r1 * r2, 2, MOD)
        collision_count %= MOD
    # print(limit)
    # print(visited)
    # print(ancestors)
    # print(collision_pair)
    # print(collision_count, shortest_count)

    return (pow(shortest_count, 2, MOD) - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [set() for _ in range(n)]
for _ in range(m):
    u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u].add((d, v))
    links[v].add((d, u))
print(solve(s, t, links))


### FIXED CODE ###

from heapq import heappop, heappush
import sys

MOD, INF = 1000000007, float('inf')


def count_routes(visited, s, links):
    counts = [0] * n
    counts[s] = 1
    for dv, v in sorted((d, v) for v, d in enumerate(visited) if d != INF):
        for u, du in links[v].items():
            if dv + du == visited[u]:
                counts[u] += counts[v]
                counts[u] %= MOD
    return counts


def solve(s, t, links):
    q = [(0, 0, s, -1, 0), (0, 0, t, -1, 1)]
    visited_fwd, visited_bwd = [INF] * n, [INF] * n
    collision_nodes, collision_links = set(), set()
    limit = 0
    while q:
        cost, cost_a, v, a, is_bwd = heappop(q)
        if is_bwd:
            visited_self = visited_bwd
            visited_opp = visited_fwd
        else:
            visited_self = visited_fwd
            visited_opp = visited_bwd

        relax_flag = False
        cost_preceding = visited_self[v]
        if cost_preceding == INF:
            visited_self[v] = cost
            relax_flag = True
        elif cost > cost_preceding:
            continue

        cost_opp = visited_opp[v]
        if cost_opp != INF:
            limit = cost + cost_opp
            if cost == cost_opp:
                collision_nodes.add(v)
            else:
                collision_links.add((v, a) if is_bwd else (a, v))
            break

        if relax_flag:
            for u, du in links[v].items():
                nc = cost + du
                if visited_self[u] < nc:
                    continue
                heappush(q, (nc, cost, u, v, is_bwd))

    collision_time = limit / 2
    while q:
        cost, cost_a, v, a, is_bwd = heappop(q)
        if cost > limit:
            break
        visited_self = visited_bwd if is_bwd else visited_fwd
        if visited_self[v] == INF:
            visited_self[v] = cost
        if is_bwd:
            continue
        if cost_a == collision_time:
            collision_nodes.add(a)
        elif cost == collision_time:
            collision_nodes.add(v)
        else:
            collision_links.add((v, a) if is_bwd else (a, v))

    counts_fwd = count_routes(visited_fwd, s, links)
    counts_bwd = count_routes(visited_bwd, t, links)
    shortest_count = 0
    collision_count = 0

    for v in collision_nodes:
        if visited_fwd[v] == visited_bwd[v]:
            r = counts_fwd[v] * counts_bwd[v]
            shortest_count += r
            shortest_count %= MOD
            collision_count += r * r
            collision_count %= MOD

    for u, v in collision_links:
        if visited_fwd[u] + visited_bwd[v] + links[u][v] == limit:
            r = counts_fwd[u] * counts_bwd[v]
            shortest_count += r
            shortest_count %= MOD
            collision_count += r * r
            collision_count %= MOD

    return (shortest_count ** 2 - collision_count) % MOD


n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
links = [{} for _ in range(n)]
for uvd in sys.stdin.readlines():
    u, v, d = map(int, uvd.split())
    # for _ in range(m):
    #     u, v, d = map(int, input().split())
    u -= 1
    v -= 1
    links[u][v] = d
    links[v][u] = d
print(solve(s, t, links))