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>
#pragma GCC optimize(3)
using namespace std;
int n, m;
unsigned long long a, b, c;
vector<int> adj[200006];
vector<int> g[200006];
unsigned long long tot = 0;
inline void push_tri(int u, int v, int w) {
  int aa = min({u, v, w}), bb, cc = max({u, v, w});
  bb = u + v + w - aa - cc;
  ((void)0);
  tot -= a * aa + b * bb + c * cc;
}
inline void chk_arr(int u, int v, vector<int>& a1, vector<int>& a2) {
  vector<int> a(a1.size() + a2.size());
  merge((a1).begin(), (a1).end(), (a2).begin(), (a2).end(), a.begin());
  for (int i = 1; i < a.size(); i++) {
    if (a[i] == a[i - 1]) {
      push_tri(u, v, a[i]);
    }
  }
}
unsigned long long c2(unsigned long long n) {
  unsigned long long nn = n - 1;
  if (nn & 1)
    n >>= 1;
  else
    nn >>= 1;
  return n * nn;
}
int main() {
  scanf("%d%d", &n, &m);
  {
    int aa, bb, cc;
    scanf("%d%d%d", &aa, &bb, &cc);
    a = aa;
    b = bb;
    c = cc;
  }
  for (int i = 0; i < (m); i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  for (int i = 0; i < (n); i++)
    tot += a * i * c2(n - i - 1) + b * i * i * (n - i - 1) + c * i * c2(i);
  for (int u = 0; u < (n); u++) {
    for (int v : adj[u]) {
      if (v <= u) continue;
      tot -= a * c2(u) + b * u * u + c * v * u;
      tot -=
          a * u * (v - u - 1) + b * (c2(v) - c2(u + 1)) + c * v * (v - u - 1);
      tot -=
          a * u * (n - v - 1) + b * v * (n - v - 1) + c * (c2(n) - c2(v + 1));
    }
  }
  for (int i = 0; i < (n); i++) {
    sort((adj[i]).begin(), (adj[i]).end());
    int pos = lower_bound((adj[i]).begin(), (adj[i]).end(), i) - adj[i].begin();
    for (int j = 0; j < pos; j++)
      tot += (a * (adj[i].size() - j - 1) + b * j) * adj[i][j];
    for (int j = pos; j < adj[i].size(); j++)
      tot += (b * (adj[i].size() - j - 1) + c * j) * adj[i][j];
    int sz1 = pos, sz2 = adj[i].size() - pos;
    tot += (a * c2(sz2) + b * sz1 * sz2 + c * c2(sz1)) * i;
  }
  for (int u = 0; u < (n); u++) {
    for (int v : adj[u]) {
      if (make_pair(adj[u].size(), u) > make_pair(adj[v].size(), v)) {
        g[v].push_back(u);
      }
    }
  }
  for (int u = 0; u < (n); u++) {
    for (int v : g[u]) {
      chk_arr(u, v, g[u], g[v]);
    }
  }
  cout << tot << endl;
  return 0;
}