Problem: There are n players numbered from 0 to n-1 with ranks. The i-th player has rank i.

Players can form teams: the team should consist of three players and no pair of players in the team should have a conflict. The rank of the team is calculated using the following algorithm: let i, j, k be the ranks of players in the team and i < j < k, then the rank of the team is equal to A ⋅ i + B ⋅ j + C ⋅ k.

You are given information about the pairs of players who have a conflict. Calculate the total sum of ranks over all possible valid teams modulo 2^{64}.

Input

The first line contains two space-separated integers n and m (3 ≤ n ≤ 2 ⋅ 10^5, 0 ≤ m ≤ 2 ⋅ 10^5) — the number of players and the number of conflicting pairs.

The second line contains three space-separated integers A, B and C (1 ≤ A, B, C ≤ 10^6) — coefficients for team rank calculation.

Each of the next m lines contains two space-separated integers u_i and v_i (0 ≤ u_i, v_i < n, u_i ≠ v_i) — pair of conflicting players.

It's guaranteed that each unordered pair of players appears in the input file no more than once.

Output

Print single integer — the total sum of ranks over all possible teams modulo 2^{64}.

Examples

Input

4 0
2 3 4


Output

64


Input

4 1
2 3 4
1 0


Output

38


Input

6 4
1 5 3
0 3
3 5
5 4
4 3


Output

164

Note

In the first example all 4 teams are valid, i.e. triples: {0, 1, 2}, {0, 1, 3}, {0, 2, 3} {1, 2, 3}.

In the second example teams are following: {0, 2, 3}, {1, 2, 3}.

In the third example teams are following: {0, 1, 2}, {0, 1, 4}, {0, 1, 5}, {0, 2, 4}, {0, 2, 5}, {1, 2, 3}, {1, 2, 4}, {1, 2, 5}.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, m, tmp[5], h[N], nxt[N], adj[N], x[N], y[N], t, w[N], d[N];
unsigned long long A, B, C, ans;
vector<int> g[N];
inline void add(const int u, const int v) {
  nxt[++t] = h[u], h[u] = t, adj[t] = v;
}
int main() {
  scanf("%d%d%llu%llu%llu", &n, &m, &A, &B, &C);
  register int i;
  for (i = 1; i <= n; ++i)
    ans += (unsigned long long)A * (n - i) * (n - i - 1) / 2 * (i - 1);
  for (i = 1; i <= n; ++i)
    ans += (unsigned long long)B * (i - 1) * (n - i) * (i - 1);
  for (i = 1; i <= n; ++i)
    ans += (unsigned long long)C * (i - 1) * (i - 2) / 2 * (i - 1);
  for (i = 1; i <= m; ++i)
    scanf("%d%d", &x[i], &y[i]), ++x[i], ++y[i], ++d[x[i]], ++d[y[i]],
        x[i] > y[i] ? std::swap(x[i], y[i]), 0 : 0, g[x[i]].push_back(y[i] - 1),
        g[y[i]].push_back(x[i] - 1),
        ans -= ((A * (x[i] - 1) + B * (y[i] - 1)) * (n - y[i]) +
                C * (n - y[i]) * (n + y[i] - 1) / 2),
        ans -= ((A * (x[i] - 1) + C * (y[i] - 1)) * (y[i] - x[i] - 1) +
                B * (y[i] - x[i] - 1) * (x[i] + y[i] - 2) / 2),
        ans -= ((B * (x[i] - 1) + C * (y[i] - 1)) * (x[i] - 1) +
                A * (x[i] - 1) * (x[i] - 2) / 2);
  for (i = 1; i <= n; ++i) {
    std::sort(g[i].begin(), g[i].end());
    register unsigned long long cn1, cn2, s1, s2;
    cn1 = cn2 = s1 = s2 = 0;
    for (const int &j : g[i])
      j + 1 < i   ? ans += A * s1 + B * j * cn1, ++cn1,
          s1 += j : (ans += B * s2 + C * j * cn2, ++cn2, s2 += j);
    --i, ans += (unsigned long long)A * s1 * cn2 + C * s2 * cn1,
        ans += (unsigned long long)B * cn1 * cn2 * i,
        ans += (unsigned long long)C * cn1 * (cn1 - 1) / 2 * i,
        ans += (unsigned long long)A * cn2 * (cn2 - 1) / 2 * i, ++i;
  }
  for (i = 1; i <= m; ++i)
    d[x[i]] < d[y[i]] || (d[x[i]] == d[y[i]] && x[i] < y[i]) ? add(x[i], y[i])
                                                             : add(y[i], x[i]);
  for (i = 1; i <= n; ++i) {
    for (register int j = h[i]; j; j = nxt[j]) w[adj[j]] = i;
    for (register int j = h[i]; j; j = nxt[j])
      for (register int k = h[adj[j]]; k; k = nxt[k])
        if (w[adj[k]] == i)
          tmp[1] = i - 1, tmp[2] = adj[j] - 1, tmp[3] = adj[k] - 1,
          std::sort(tmp + 1, tmp + 1 + 3),
          ans = ans - A * tmp[1] - B * tmp[2] - C * tmp[3];
  }
  printf("%llu", ans);
  return 0;
}