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;
int i, j, m, n, p, k, deg[200005], fox[200005], A, B, C;
int x, y, z, k1, col[200005], ucol[200005], bcol[200005], Q[200005];
struct Node {
  int x, y, col, Sum;
} Bian[200005];
struct B {
  int ed, col, before;
} s[200005 * 2];
vector<int> v[200005], vec[200005];
unsigned long long ans;
inline int read() {
  int x;
  char c;
  while (c = getchar(), c < '0' || c > '9')
    ;
  x = c - '0';
  while (c = getchar(), c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0';
  return x;
}
void add(int x, int y, int z) {
  s[++k1].ed = y;
  s[k1].before = fox[x];
  fox[x] = k1;
  s[k1].col = z;
}
inline bool cmp(int a, int b) { return Bian[a].Sum < Bian[b].Sum; }
inline int check(int A, int B) {
  if (Bian[A].x == Bian[B].x) return Bian[A].x;
  if (Bian[A].x == Bian[B].y) return Bian[A].x;
  return Bian[A].y;
}
unsigned long long Cal(int a, int b, int c) {
  --a;
  --b;
  --c;
  unsigned long long T[3];
  T[0] = a;
  T[1] = b;
  T[2] = c;
  sort(T, T + 3);
  return A * T[0] + B * T[1] + C * T[2];
}
unsigned long long cal(int x, int y) {
  return (unsigned long long)(x + y) * (y - x + 1) / 2;
}
int main() {
  memset(deg, 0, sizeof(deg));
  memset(fox, 0, sizeof(fox));
  k1 = 0;
  for (i = 1; i <= n; ++i) v[i].clear();
  scanf("%d%d", &n, &m);
  scanf("%d%d%d", &A, &B, &C);
  for (i = 1; i <= m; ++i) {
    x = read();
    y = read();
    x++;
    y++;
    vec[x - 1].push_back(y - 1);
    vec[y - 1].push_back(x - 1);
    add(x, y, 0);
    add(y, x, 0);
    deg[x]++;
    deg[y]++;
    Bian[i] = (Node){x, y, 0};
  }
  for (i = 1; i <= m; ++i) {
    if (Bian[i].x > Bian[i].y) swap(Bian[i].x, Bian[i].y);
    Bian[i].Sum = deg[Bian[i].x] < deg[Bian[i].y] ? Bian[i].y : Bian[i].x;
  }
  for (i = 1; i <= m; ++i)
    if (deg[Bian[i].x] < deg[Bian[i].y])
      v[Bian[i].x].push_back(i);
    else
      v[Bian[i].y].push_back(i);
  for (i = 1; i <= n; ++i) sort(v[i].begin(), v[i].end(), cmp);
  for (i = 1; i <= m; ++i) {
    x = Bian[i].x, y = Bian[i].y;
    int l = 0, L = 0, r = v[x].size(), Rx = v[y].size();
    while (l < r && L < Rx) {
      if (Bian[v[x][l]].Sum < Bian[v[y][L]].Sum)
        ++l;
      else if (Bian[v[x][l]].Sum > Bian[v[y][L]].Sum)
        ++L;
      else {
        int A = x, B = y, C = Bian[v[x][l]].Sum;
        ans -= Cal(A, B, C);
        l++;
        L++;
      }
    }
  }
  for (i = 1; i <= n; ++i)
    ans += (unsigned long long)A * (n - i) * (n - i - 1) / 2 * (i - 1),
        ans += (unsigned long long)B * (i - 1) * (i - 1) * (n - i),
        ans += (unsigned long long)C * (i - 1) * (i - 2) / 2 * (i - 1);
  for (i = 1; i <= m; ++i) {
    int x = Bian[i].x, y = Bian[i].y;
    if (x > y) swap(x, y);
    ans -=
        (unsigned long long)((unsigned long long)A * (x - 1) +
                             (unsigned long long)B * (y - 1)) *
            (n - y) +
        (unsigned long long)C * (cal(y + 1, n) - (unsigned long long)(n - y));
    ans -= (unsigned long long)((unsigned long long)A * (x - 1) +
                                (unsigned long long)C * (y - 1)) *
               (y - x - 1) +
           (unsigned long long)B *
               (cal(x + 1, y - 1) - (unsigned long long)(y - x - 1));
    ans -=
        (unsigned long long)((unsigned long long)B * (x - 1) +
                             (unsigned long long)C * (y - 1)) *
            (x - 1) +
        (unsigned long long)A * (cal(1, x - 1) - (unsigned long long)(x - 1));
  }
  for (i = 0; i < n; ++i)
    if (vec[i].size() > 1) {
      unsigned long long xx = 0, gg = 0, yy = 0, pp = 0, xxs = 0, yys = 0,
                         ggs = 0, pps = 0, sk1 = 0, sk2 = 0;
      sort(vec[i].begin(), vec[i].end());
      for (j = 0; j < (int)vec[i].size(); ++j)
        if (vec[i][j] < i)
          sk1 += xx + xxs * B * vec[i][j],
              xx += (unsigned long long)A * vec[i][j], xxs++,
              gg += (unsigned long long)B * vec[i][j], ggs++;
        else
          sk2 += yy + yys * C * vec[i][j],
              yy += (unsigned long long)B * vec[i][j], yys++,
              pp += (unsigned long long)C * vec[i][j], pps++;
      ans += sk1 + ggs * (ggs - 1) / 2 * C * i;
      ans += xx * pps + pp * xxs + pps * xxs * B * i;
      ans += sk2 + yys * (yys - 1) / 2 * A * i;
    }
  cout << ans << endl;
}