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;
template <typename T>
void maxtt(T& t1, T t2) {
  t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
  t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
  puts(f ? "Yes" : "No");
  exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
  assert(y >= 0);
  x += y;
  if (x >= mod) x -= mod;
  assert(x >= 0 && x < mod);
}
void et() {
  puts("-1");
  exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
  long long ans = 1;
  while (y > 0) {
    if (y & 1) ans = (x * ans) % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
unsigned long long A, B, C, all, sub1, sub2;
int SZ;
vector<int> mp[200105];
vector<pair<int, int> > es;
bitset<200105> bs[900];
int hid[200105], hd;
bool curHas[200105];
unsigned long long calTriangle() {
  unsigned long long S = 0;
  for (int(v) = 0; (v) < (int)(n); (v)++)
    if (mp[v].size() >= SZ) {
      hid[v] = ++hd;
      for (int x : mp[v]) bs[hd][x] = 1;
    }
  for (int(i) = 0; (i) < (int)(n); (i)++) {
    if (hid[i]) {
      for (auto pp : es)
        if (bs[hid[i]][pp.first] && bs[hid[i]][pp.second]) {
          int u = pp.first, v = pp.second;
          if (v < u) swap(u, v);
          if (v > i) continue;
          S += A * u + B * v + C * i;
        }
    } else {
      int N = mp[i].size() - 1;
      while (N >= 0 && mp[i][N] > i) N--;
      for (; N > 0; N--) {
        unsigned long long k = mp[i][N];
        if (hid[k] == 0) {
          for (int z : mp[k])
            if (z < k)
              curHas[z] = 1;
            else
              break;
        }
        for (int z = N - 1; z >= 0; z--) {
          unsigned long long j = mp[i][z];
          if (hid[k]) {
            if (bs[hid[k]][j]) S += A * j + B * k + C * i;
          } else {
            if (curHas[j]) S += A * j + B * k + C * i;
          }
        }
        if (hid[k] == 0) {
          for (int z : mp[k])
            if (z < k)
              curHas[z] = 0;
            else
              break;
        }
      }
    }
  }
  return S;
}
void cal() {
  unsigned long long aa = 0;
  for (int(k) = 0; (k) < (int)(n); (k)++) {
    for (int j : mp[k]) {
      if (k < j) break;
      unsigned long long len = n - 1 - k;
      aa += (A * j + B * k) * len +
            C * (((unsigned long long)k + 1 + n - 1) * len / 2);
    }
  }
  sub2 += aa;
  aa = 0;
  for (int(j) = 0; (j) < (int)(n); (j)++) {
    int N = mp[j].size();
    unsigned long long pre = 0, cc = 0;
    for (int z = N - 1; ~z; z--) {
      unsigned long long k = mp[j][z];
      if (k < j) break;
      aa += (A * j + B * k) * cc + C * pre;
      pre += k;
      cc++;
    }
  }
  sub2 -= aa;
  aa = 0;
  for (int(k) = 0; (k) < (int)(n); (k)++) {
    int N = mp[k].size();
    if (N == 0) continue;
    int j = 0;
    unsigned long long pre = 0;
    while (j < N && mp[k][j] < k) {
      pre += mp[k][j];
      j++;
    }
    unsigned long long cc = j;
    for (; j < N; j++) {
      aa += A * pre + (B * k + C * mp[k][j]) * cc;
    }
  }
  sub2 -= aa;
  aa = 0;
  sub2 += calTriangle();
}
void fmain(int ID) {
  scanf("%d%d", &n, &m);
  scanf("%lld%lld%lld", &A, &B, &C);
  SZ = sqrt(m);
  for (int i = 0, u, v; i < m; i++) {
    scanf("%d%d", &u, &v);
    mp[u].push_back(v);
    mp[v].push_back(u);
    es.push_back({u, v});
  }
  for (int(i) = 0; (i) < (int)(n); (i)++) {
    all += (unsigned long long)i * (i - 1) / 2 * C * i;
    all += (unsigned long long)i * (n - 1 - i) * B * i;
    all += (unsigned long long)(n - 1 - i) * (n - 2 - i) / 2 * A * i;
  }
  for (int(i) = 0; (i) < (int)(n); (i)++) {
    sort(mp[i].begin(), mp[i].end());
    unsigned long long pre = 0, cc = 0;
    for (int x : mp[i]) {
      if (i < x) break;
      int len = i - x - 1;
      sub1 += (A * x + C * i) * len +
              B * (((unsigned long long)(x + 1 + i - 1)) * len / 2);
      len = x;
      sub1 +=
          (B * x + C * i) * len + A * ((unsigned long long)(x - 1) * len / 2);
      sub1 -= A * pre + (B * x + C * i) * cc;
      pre += x;
      cc++;
    }
  }
  cal();
  unsigned long long ans = all - sub1 - sub2;
  cout << ans << endl;
}
int main() {
  int t = 1;
  for (int(i) = 1; (i) <= (int)(t); (i)++) {
    fmain(i);
  }
  return 0;
}