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("Ofast")
using namespace std;
unsigned long long a, b, c, s[200005], ans = 0, pf[200005];
int head[200005], nxt[400005], v[400005], tot = 0, n, m;
int deg[200005], w[200005], ai[200005], bi[200005];
int vis[200005], ou[200005], cot[200005], cnt = 0;
vector<int> vec[200005];
inline void add(int a, int b) {
  tot++;
  nxt[tot] = head[a];
  head[a] = tot;
  v[tot] = b;
}
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
inline bool chk(int a, int b) {
  if (deg[a] != deg[b]) return deg[a] > deg[b];
  return a > b;
}
int main() {
  int i, j, k;
  scanf("%d%d", &n, &m);
  scanf("%llu%llu%llu", &a, &b, &c);
  for (i = 1; i <= m; i++) {
    scanf("%d%d", &ai[i], &bi[i]);
    add(ai[i], bi[i]);
    add(bi[i], ai[i]);
    deg[ai[i]]++;
    deg[bi[i]]++;
  }
  for (i = 1; i < n; i++) s[i] = s[i - 1] + i;
  for (i = 0; i < n; i++) {
    unsigned long long t = 1ll * (n - i - 1) * (n - i - 2);
    t >>= 1ll;
    unsigned long long o = 1ll * t * i;
    ans += a * o;
    t = 1ll * i * (n - 1 - i);
    o = 1ll * t * i;
    ans += b * o;
    t = 1ll * i * (i - 1);
    t >>= 1ll;
    o = 1ll * t * i;
    ans += c * o;
  }
  for (i = 0; i < n; i++) {
    for (j = head[i]; j; j = nxt[j]) {
      if (v[j] < i) continue;
      unsigned long long c1 = 1ll * i * a, c2 = 1ll * v[j] * b;
      unsigned long long o = 1ll * (c1 + c2) * (n - 1 - v[j]);
      unsigned long long c3 = 1ll * (s[n - 1] - s[v[j]]) * c;
      ans -= (o + c3);
    }
  }
  for (i = 0; i < n; i++) {
    for (j = head[i]; j; j = nxt[j]) {
      if (v[j] < i) continue;
      unsigned long long c1 = 1ll * i * a, c2 = 1ll * v[j] * c;
      unsigned long long o = 1ll * (c1 + c2) * (v[j] - i - 1);
      unsigned long long c3 = 1ll * (s[v[j] - 1] - s[i]) * b;
      ans -= (o + c3);
    }
  }
  for (i = 1; i < n; i++) {
    for (j = head[i]; j; j = nxt[j]) {
      if (v[j] < i) continue;
      unsigned long long c1 = 1ll * i * b, c2 = 1ll * v[j] * c;
      unsigned long long o = 1ll * (c1 + c2) * i;
      unsigned long long c3 = 1ll * s[i - 1] * a;
      ans -= (o + c3);
    }
  }
  for (i = 0; i < n; i++) {
    cnt = 0;
    for (j = head[i]; j; j = nxt[j]) {
      if (v[j] > i) w[++cnt] = v[j];
    }
    if (!cnt) continue;
    sort(w + 1, w + cnt + 1);
    pf[cnt + 1] = 0;
    for (j = cnt; j >= 1; j--) {
      pf[j] = pf[j + 1] + 1ll * c * w[j];
    }
    for (j = 1; j < cnt; j++) {
      unsigned long long c1 = 1ll * i * a, c2 = 1ll * w[j] * b;
      unsigned long long o = 1ll * (c1 + c2) * (cnt - j) + pf[j + 1];
      ans += o;
    }
  }
  for (i = 0; i < n; i++) {
    cnt = 0;
    for (j = head[i]; j; j = nxt[j]) {
      if (v[j] < i) w[++cnt] = v[j];
    }
    if (!cnt) continue;
    sort(w + 1, w + cnt + 1);
    pf[0] = 0;
    for (j = 1; j <= cnt; j++) {
      pf[j] = pf[j - 1] + 1ll * a * w[j];
    }
    for (j = 2; j <= cnt; j++) {
      unsigned long long c1 = 1ll * i * c, c2 = 1ll * w[j] * b;
      unsigned long long o = 1ll * (c1 + c2) * (j - 1) + pf[j - 1];
      ans += o;
    }
  }
  for (i = 0; i < n; i++) {
    unsigned long long p1 = 0, p2 = 0;
    int c1 = 0, c2 = 0;
    for (j = head[i]; j; j = nxt[j]) {
      if (v[j] < i) {
        p1 += 1ll * a * v[j];
        c1++;
      } else {
        p2 += 1ll * c * v[j];
        c2++;
      }
    }
    unsigned long long o = 1ll * i * b;
    o *= ((unsigned long long)c1);
    o *= ((unsigned long long)c2);
    o += p1 * ((unsigned long long)c2);
    o += p2 * ((unsigned long long)c1);
    ans += o;
  }
  for (i = 1; i <= m; i++) {
    if (chk(ai[i], bi[i])) swap(ai[i], bi[i]);
    ou[ai[i]]++;
  }
  for (i = 0; i < n; i++) vec[i].resize(ou[i] + 1);
  for (i = 1; i <= m; i++) vec[ai[i]][++cot[ai[i]]] = bi[i];
  memset(vis, -1, sizeof(vis));
  for (i = 0; i < n; i++) {
    for (j = 1; j <= ou[i]; j++) vis[vec[i][j]] = i;
    for (j = 1; j <= ou[i]; j++) {
      int t1 = i, t2 = vec[i][j], t3;
      for (k = 1; k <= ou[t2]; k++) {
        if (vis[vec[t2][k]] != i) continue;
        t3 = vec[t2][k];
        int p1 = min(min(t1, t2), t3);
        int p3 = max(max(t1, t2), t3);
        int p2 = t1 + t2 + t3 - p1 - p3;
        unsigned long long t = 1ll * p1 * a + 1ll * p2 * b + 1ll * p3 * c;
        ans -= t;
      }
    }
  }
  printf("%llu\n", ans);
  return 0;
}