Problem: On the Berland Dependence Day it was decided to organize a great marathon. Berland consists of n cities, some of which are linked by two-way roads. Each road has a certain length. The cities are numbered from 1 to n. It is known that one can get from any city to any other one by the roads.

n runners take part in the competition, one from each city. But Berland runners are talkative by nature and that's why the juries took measures to avoid large crowds of marathon participants. The jury decided that every runner should start the marathon from their hometown. Before the start every sportsman will get a piece of paper containing the name of the city where the sportsman's finishing line is. The finish is chosen randomly for every sportsman but it can't coincide with the sportsman's starting point. Several sportsmen are allowed to finish in one and the same city. All the sportsmen start simultaneously and everyone runs the shortest route from the starting point to the finishing one. All the sportsmen run at one speed which equals to 1.

After the competition a follow-up table of the results will be composed where the sportsmen will be sorted according to the nondecrease of time they spent to cover the distance. The first g sportsmen in the table will get golden medals, the next s sportsmen will get silver medals and the rest will get bronze medals. Besides, if two or more sportsmen spend the same amount of time to cover the distance, they are sorted according to the number of the city where a sportsman started to run in the ascending order. That means no two sportsmen share one and the same place.

According to the rules of the competition the number of gold medals g must satisfy the inequation g1 ≤ g ≤ g2, where g1 and g2 are values formed historically. In a similar way, the number of silver medals s must satisfy the inequation s1 ≤ s ≤ s2, where s1 and s2 are also values formed historically.

At present, before the start of the competition, the destination points of every sportsman are unknown. However, the press demands details and that's why you are given the task of counting the number of the ways to distribute the medals. Two ways to distribute the medals are considered different if at least one sportsman could have received during those distributions different kinds of medals.

Input

The first input line contains given integers n and m (3 ≤ n ≤ 50, n - 1 ≤ m ≤ 1000), where n is the number of Berland towns and m is the number of roads.

Next in m lines road descriptions are given as groups of three integers v, u, c, which are the numbers of linked towns and its length (1 ≤ v, u ≤ n, v ≠ u, 1 ≤ c ≤ 1000). Every pair of cities have no more than one road between them.

The last line contains integers g1, g2, s1, s2 (1 ≤ g1 ≤ g2, 1 ≤ s1 ≤ s2, g2 + s2 < n). The input data numbers, located on one line, are space-separated.

Output

Print the single number — the number of ways to distribute the medals. It is guaranteed that the number fits in the standard 64-bit signed data type.

Examples

Input

3 2
1 2 1
2 3 1
1 1 1 1


Output

3


Input

4 5
1 2 2
2 3 1
3 4 2
4 1 2
1 3 3
1 2 1 1


Output

19


Input

3 3
1 2 2
2 3 1
3 1 2
1 1 1 1


Output

4

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int numberOfTowns, numberOfRoads, g_1, g_2, s_1, s_2;
vector<vector<int>> distances;
vector<vector<vector<long long>>> dp;
void floyd() {
  for (auto i = 0; i < numberOfTowns; i++) {
    for (auto j = 0; j < numberOfTowns; j++) {
      for (auto k = 0; k < numberOfTowns; k++) {
        distances[j][k] =
            min(distances[j][k], distances[j][i] + distances[i][k]);
        cout << endl;
      }
    }
  }
}
void makeList() {
  for (auto& v : distances) {
    sort(v.begin(), v.end());
  }
}
bool canUp(int x, int y) {
  return distances[x][1] < distances[y][1] ||
         distances[x][1] == distances[y][1] && x <= y;
}
bool canDown(int x, int y) {
  return distances[x][numberOfTowns - 1] > distances[y][numberOfTowns - 1] ||
         distances[x][numberOfTowns - 1] == distances[y][numberOfTowns - 1] &&
             x >= y;
}
bool between(int z, int x, int y) {
  int it;
  if (z > x) {
    it = lower_bound(distances[z].begin() + 1, distances[z].end(),
                     distances[x][1]) -
         distances[z].begin();
  } else {
    it = upper_bound(distances[z].begin() + 1, distances[z].end(),
                     distances[x][1]) -
         distances[z].begin();
  }
  if (it == distances[z].size()) {
    return false;
  }
  return distances[z][it] < distances[y][numberOfTowns - 1] ||
         (distances[z][it] == distances[y][numberOfTowns - 1] && z < y);
}
long long count(int gl, int bf) {
  if (distances[gl][1] > distances[bf][numberOfTowns - 1] ||
      (distances[gl][1] == distances[bf][numberOfTowns - 1] && gl > bf)) {
    return 0;
  }
  dp[0][0][0] = 1;
  for (auto i = 1; i <= numberOfTowns; i++) {
    for (auto g = 0; g <= i; g++) {
      for (auto s = 0; s <= i - g; s++) {
        dp[i][g][s] = 0;
        if (i - 1 != bf && g > 0 && canUp(i - 1, gl)) {
          dp[i][g][s] += dp[i - 1][g - 1][s];
        }
        if (i - 1 != gl && g + s < i && canDown(i - 1, bf)) {
          dp[i][g][s] += dp[i - 1][g][s];
        }
        if (s > 0 && (i - 1 != bf && i - 1 != gl) && between(i - 1, gl, bf)) {
          dp[i][g][s] += dp[i - 1][g][s - 1];
        }
      }
    }
  }
  auto res = 0ll;
  for (auto g = g_1; g <= g_2; g++)
    for (auto s = s_1; s <= s_2; s++) res += dp[numberOfTowns][g][s];
  return res;
}
int main() {
  ios::sync_with_stdio(false);
  cin >> numberOfTowns >> numberOfRoads;
  const long long max = 1000 * 1000 + 1;
  distances =
      vector<vector<int>>(numberOfTowns, vector<int>(numberOfTowns, max));
  for (auto i = 0; i < numberOfTowns; i++) {
    distances[i][i] = 0;
  }
  for (int i = 0; i < numberOfRoads; i++) {
    int a, b, c;
    cin >> a >> b >> c;
    a--;
    b--;
    distances[a][b] = distances[b][a] = c;
  }
  floyd();
  makeList();
  cin >> g_1 >> g_2 >> s_1 >> s_2;
  dp = vector<vector<vector<long long>>>(
      numberOfTowns + 1,
      vector<vector<long long>>(numberOfTowns + 1,
                                vector<long long>(numberOfTowns + 1, 0)));
  auto ans = 0ll;
  for (auto gl = 0; gl < numberOfTowns; gl++) {
    for (auto bf = 0; bf < numberOfTowns; bf++) {
      if (gl != bf) {
        ans += count(gl, bf);
      }
    }
  }
  cout << ans << endl;
  return 0;
}