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;
namespace mine {
void chmax(int &x, const long long y) { x = (x > y ? x : y); }
void chmin(int &x, const long long y) { x = (x < y ? x : y); }
long long qread() {
  long long ans = 0, f = 1;
  char c = getchar();
  while (c < '0' or c > '9') {
    if (c == '-') f = -1;
    c = getchar();
  }
  while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
  return ans * f;
}
void write(long long num) {
  if (num < 0) putchar('-'), num = -num;
  if (num >= 10) write(num / 10);
  putchar('0' + num % 10);
}
void write1(long long num) {
  write(num);
  putchar(' ');
}
void write2(long long num) {
  write(num);
  putchar('\n');
}
const int INF = 0x3f3f3f3f;
const int MOD = 19930726;
void add(long long &a, long long b) {
  a += b;
  if (a >= MOD) a -= MOD;
  if (a <= -MOD) a += MOD;
}
long long qpower(long long x, int e) {
  long long ans = 1;
  while (e) {
    if (e & 1) ans = ans * x % MOD;
    x = x * x % MOD;
    e >>= 1;
  }
  return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int N = 2e5 + 10;
bitset<N> hash[1000];
int id[N];
vector<unsigned long long> AA;
bool v[N];
unsigned long long GG(unsigned long long n) {
  return (n & 1) ? ((n - 1) / 2 * n) : (n / 2 * (n - 1));
}
unsigned long long sm[2][N], bg[2][N];
vector<unsigned long long> smm[N], bgg[N], go[N];
void writegg(unsigned long long num) {
  if (num >= 10) writegg(num / 10);
  putchar('0' + num % 10);
}
void main() {
  unsigned long long n, m, A, B, C;
  scanf("%lld%lld%lld%lld%lld", &n, &m, &A, &B, &C);
  unsigned long long ans = 0;
  for (unsigned long long i = 0; i < n; i++)
    ans += i * (GG(n - 1 - i) * A + i * (n - 1 - i) * B + GG(i) * C);
  for (unsigned long long i = 1; i <= m; i++) {
    unsigned long long x = qread(), y = qread();
    if (x > y) swap(x, y);
    bg[0][x]++;
    bg[1][x] += y;
    sm[0][y]++;
    sm[1][y] += x;
    bgg[x].push_back(y);
    smm[y].push_back(x);
    go[x].push_back(y);
    go[y].push_back(x);
    unsigned long long ss = x;
    ans -= A * GG(ss) + ss * (B * x + C * y);
    unsigned long long mm = y - x - 1;
    ans -= B * (GG(mm) + (x + 1) * mm) + mm * (A * x + C * y);
    unsigned long long bb = n - y - 1;
    ans -= C * (GG(bb) + (y + 1) * bb) + bb * (A * x + B * y);
  }
  for (unsigned long long i = 0; i < n; i++) {
    sort(smm[i].begin(), smm[i].end());
    sort(bgg[i].begin(), bgg[i].end());
    unsigned long long s = sm[0][i];
    ans += GG(s) * C * i;
    for (unsigned long long a = 0; a < s; a++)
      ans += smm[i][a] * (A * (s - 1 - a) + B * a);
    unsigned long long b = bg[0][i];
    ans += GG(b) * A * i;
    for (unsigned long long a = 0; a < b; a++)
      ans += bgg[i][a] * (B * (b - 1 - a) + C * a);
    ans += s * b * B * i + sm[1][i] * A * b + bg[1][i] * C * s;
  }
  unsigned long long T = 2 * sqrt(m);
  for (unsigned long long i = 0; i < n; i++)
    if (sm[0][i] + bg[0][i] > T) {
      AA.push_back(i);
      id[i] = AA.size();
      for (int t = 0; t < (int)go[i].size(); t++) hash[id[i]][go[i][t]] = 1;
    }
  for (int i = 0; i < (int)AA.size(); i++)
    for (int j = i + 1; j < (int)AA.size(); j++)
      for (int k = j + 1; k < (int)AA.size(); k++)
        ans -= A * AA[i] + B * AA[j] + C * AA[k];
  for (unsigned long long x = 0; x < n; x++)
    if (!id[x]) {
      sort(go[x].begin(), go[x].end());
      for (int i = 0; i < (int)go[x].size(); i++) {
        unsigned long long y = go[x][i];
        if (!id[y])
          for (int j = 0; j < (int)go[y].size(); j++) v[go[y][j]] = 1;
        for (int j = i + 1; j < (int)go[x].size(); j++) {
          unsigned long long z = go[x][j];
          if (!id[y] and id[z] and (!(x < y) or !hash[id[z]][y])) continue;
          if (id[y] and !id[z] and (!(x < z) or !hash[id[y]][z])) continue;
          if (!id[y] and !id[z] and (!(z < x) or !v[z])) continue;
          if (id[y] and id[z] and !hash[id[y]][z]) continue;
          if (x < y)
            ans -= A * x + B * y + C * z;
          else if (x < z)
            ans -= A * y + B * x + C * z;
          else
            ans -= A * y + B * z + C * x;
        }
        if (!id[y])
          for (int j = 0; j < (int)go[y].size(); j++) v[go[y][j]] = 0;
      }
    }
  writegg(ans);
}
};  // namespace mine
int main() {
  srand(time(0));
  mine::main();
}