output_description: Print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      S T
      U_1 V_1 D_1
      U_2 V_2 D_2
      :
      U_M V_M D_M
attempt: from heapq import heappush, heappop
  import sys
  
  input = sys.stdin.readline
  
  INF = float("inf")
  MOD = 10**9 + 7
  
  
  def Dijkstra(adjList, vSt):
      numV = len(adjList)
      numUsed = 0
      costs = [INF] * numV
      costs[vSt] = 0
      nums = [0] * numV
      nums[vSt] = 1
      PQ = []
      heappush(PQ, (0, vSt))
      while PQ:
          cNow, vNow = heappop(PQ)
          if cNow > costs[vNow]:
              continue
          numUsed += 1
          if numUsed == numV:
              break
          for v2, wt in adjList[vNow]:
              c2 = cNow + wt
              if c2 < costs[v2]:
                  costs[v2] = c2
                  nums[v2] = nums[vNow]
                  heappush(PQ, (c2, v2))
              elif c2 == costs[v2]:
                  nums[v2] = (nums[v2] + nums[vNow]) % MOD
      return (costs, nums)
  
  
  def solve():
      N, M = map(int, input().split())
      S, T = map(int, input().split())
      S, T = S - 1, T - 1
      edges = [tuple(map(int, input().split())) for _ in range(M)]
      adjL = [[] for _ in range(N)]
      for u, v, d in edges:
          adjL[u - 1].append((v - 1, d))
          adjL[v - 1].append((u - 1, d))
  
      costSs, numSs = Dijkstra(adjL, S)
      costTs, numTs = Dijkstra(adjL, T)
      minCost = costSs[T]
  
      ans = (numSs[T] ** 2) % MOD
      for v in range(N):
          if costSs[v] == costTs[v] == minCost / 2:
              k = (numSs[v] * numTs[v]) % MOD
              ans -= (k**2) % MOD
              ans %= MOD
      for u, v, d in edges:
          u, v = u - 1, v - 1
          if costSs[u] > costSs[v]:
              u, v = v, u
          if (
              costSs[u] < minCost / 2
              and costTs[v] < minCost / 2
              and costSs[u] + d + costTs[v] == minCost
          ):
              k = (numSs[u] * numTs[v]) % MOD
              ans -= (k**2) % MOD
              ans %= MOD
  
      print(ans)
  
  
  solve()
  
problem_description: Statement
  
  We have a graph with N vertices and M edges, and there are two people on the
  graph: Takahashi and Aoki.
  
  The i-th edge connects Vertex U_i and Vertex V_i. The time it takes to
  traverse this edge is D_i minutes, regardless of direction and who traverses
  the edge (Takahashi or Aoki).
  
  Takahashi departs Vertex S and Aoki departs Vertex T at the same time.
  Takahashi travels to Vertex T and Aoki travels to Vertex S, both in the
  shortest time possible. Find the number of the pairs of ways for Takahashi and
  Aoki to choose their shortest paths such that they never meet (at a vertex or
  on an edge) during the travel, modulo 10^9 + 7.
samples: [{"input": "4 4\n    1 3\n    1 2 1\n    2 3 1\n    3 4 1\n    4 1 1", "output": "2\n    \n\nThere are two ways to choose shortest paths that satisfies the condition:\n\n  * Takahashi chooses the path 1 \\rightarrow 2 \\rightarrow 3, and Aoki chooses the path 3 \\rightarrow 4 \\rightarrow 1.\n  * Takahashi chooses the path 1 \\rightarrow 4 \\rightarrow 3, and Aoki chooses the path 3 \\rightarrow 2 \\rightarrow 1.\n\n* * *"}, {"input": "3 3\n    1 3\n    1 2 1\n    2 3 1\n    3 1 2", "output": "2\n    \n\n* * *"}, {"input": "3 3\n    1 3\n    1 2 1\n    2 3 1\n    3 1 2", "output": "2\n    \n\n* * *"}, {"input": "8 13\n    4 2\n    7 3 9\n    6 2 3\n    1 6 4\n    7 6 9\n    3 8 9\n    1 2 2\n    2 8 12\n    8 6 9\n    2 5 5\n    4 2 18\n    5 3 7\n    5 1 515371567\n    4 8 6", "output": "6"}]