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;
vector<int> g[200010];
int n, m;
unsigned long long A, B, C;
unsigned long long C2(unsigned long long n) { return n * (n - 1) / 2; }
unsigned long long S(unsigned long long l, unsigned long long r) {
  return l <= r ? (l + r) * (r - l + 1) / 2 : 0;
}
unsigned long long all() {
  int i;
  unsigned long long s = 0;
  for (i = 0; i < n; i++)
    s += A * i * C2(n - 1 - i) + B * i * i * (n - 1 - i) + C * i * C2(i);
  return s;
}
int t[200010];
unsigned long long sub1() {
  int i, j, M;
  unsigned long long s = 0, cnt;
  for (i = 0; i < n; i++) {
    M = 0;
    for (int x : g[i]) {
      if (x < i) {
        M++;
        t[M] = x;
        s += (i - x - 1) * (A * x + C * i) + B * S(x + 1, i - 1) +
             x * (B * x + C * i) + A * S(0, x - 1);
      }
    }
    cnt = 0;
    for (j = 2; j <= M; j++) {
      cnt += t[j - 1];
      s -= (j - 1) * (B * t[j] + C * i) + A * cnt;
    }
  }
  return s;
}
struct edge {
  int x, y;
  edge(int a = 0, int b = 0) {
    x = a;
    y = b;
  }
} e[200010];
bool operator<(edge a, edge b) { return a.y < b.y; }
vector<unsigned long long> sum[200010];
int h[200010];
struct pr {
  int l, r;
  pr(int a = 0, int b = 0) {
    l = a;
    r = b;
  }
} p;
pr query(int i, int l, int r) {
  if (g[i].empty() || l > r) return 0;
  r = upper_bound(g[i].begin(), g[i].end(), r) - g[i].begin() - 1;
  if (r < 0) return 0;
  l = lower_bound(g[i].begin(), g[i].end(), l) - g[i].begin() - 1;
  if (l < 0) return pr(r + 1, sum[i][r]);
  return pr(r - l, sum[i][r] - sum[i][l]);
}
int he[200010];
bool cur[200010];
bitset<200000> cn[1000];
const int bl = 450;
unsigned long long sub2() {
  unsigned long long ts, s0, s1, s2, s3, sab;
  int i, j, N;
  sort(e + 1, e + m + 1);
  sab = s0 = ts = 0;
  j = 1;
  for (i = 0; i < n; i++) {
    s0 += sab + i * ts * C;
    while (j <= m && e[j].y == i) {
      sab += e[j].x * A + e[j].y * B;
      ts++;
      j++;
    }
  }
  s1 = 0;
  for (i = 1; i <= m; i++) {
    p = query(e[i].x, e[i].x + 1, e[i].y - 1);
    s1 += p.l * (A * e[i].x + C * e[i].y) + B * p.r;
  }
  s2 = 0;
  for (i = 1; i <= m; i++) {
    p = query(e[i].x, 0, e[i].x - 1);
    s2 += p.l * (B * e[i].x + C * e[i].y) + A * p.r;
  }
  N = 0;
  for (i = 0; i < n; i++) {
    if (g[i].size() >= bl) {
      he[i] = ++N;
      for (int x : g[i]) cn[N][x] = 1;
    }
  }
  s3 = 0;
  for (i = 0; i < n; i++) {
    if (he[i]) {
      for (j = 1; j <= m && e[j].y < i; j++) {
        if (cn[he[i]][e[j].x] && cn[he[i]][e[j].y])
          s3 += A * e[j].x + B * e[j].y + C * i;
      }
    } else {
      for (int k : g[i]) {
        if (k >= i) break;
        if (he[k]) {
          for (int j : g[i]) {
            if (j >= k) break;
            if (cn[he[k]][j]) s3 += A * j + B * k + C * i;
          }
        } else {
          for (int j : g[k]) cur[j] = 1;
          for (int j : g[i]) {
            if (j >= k) break;
            if (cur[j]) s3 += A * j + B * k + C * i;
          }
          for (int j : g[k]) cur[j] = 0;
        }
      }
    }
  }
  return s0 - s1 - s2 + s3;
}
int main() {
  int i, j, x, y;
  scanf("%d%d%I64u%I64u%I64u", &n, &m, &A, &B, &C);
  for (i = 1; i <= m; i++) {
    scanf("%d%d", &x, &y);
    g[x].push_back(y);
    g[y].push_back(x);
    if (x > y) swap(x, y);
    e[i] = edge(x, y);
  }
  for (i = 0; i < n; i++) {
    if (!g[i].empty()) {
      sort(g[i].begin(), g[i].end());
      sum[i].push_back(g[i][0]);
      for (j = 1; j < (int)g[i].size(); j++)
        sum[i].push_back(sum[i][j - 1] + g[i][j]);
    }
  }
  printf("%I64u", all() - sub1() - sub2());
}