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;
const int N = 2e5 + 2;
int n, m;
unsigned long long a, b, c, sqr;
unsigned long long total;
vector<int> g[N];
pair<int, int> e[N];
int id_spec[N];
bitset<N> are[2000];
unsigned long long comb2(unsigned long long x) { return 1LL * x * (x - 1) / 2; }
unsigned long long gaussum(unsigned long long x) { return x * (x + 1) / 2; }
vector<int> gin[N];
unsigned long long gaussum(int i, int j) {
  if (i > j) return 0;
  return gaussum(j) - gaussum(i - 1);
}
int main() {
  cin >> n >> m >> a >> b >> c;
  sqr = 1000;
  for (int i = 0; i < m; ++i) {
    int na, nb;
    cin >> na >> nb;
    if (na > nb) swap(na, nb);
    g[na].push_back(nb);
    gin[nb].push_back(na);
    assert(na < nb);
    e[i] = make_pair(na, nb);
  }
  for (int i = 0; i < n; ++i)
    sort(g[i].begin(), g[i].end()), sort(gin[i].begin(), gin[i].end());
  for (int i = 0; i < n; ++i) {
    total += i * a * comb2(n - i - 1);
    total += b * (n - i - 1) * i * i;
    total += comb2(i) * i * c;
  }
  for (int i = 0; i < n; ++i) {
    unsigned long long sumj = 0, am = 0;
    for (int k : g[i]) {
      if (am) {
        total += sumj * b;
        total += am * (i * a + k * c);
      }
      ++am;
      sumj += k;
    }
  }
  for (int i = 0; i < n; ++i) {
    for (auto j : g[i]) {
      if (j == n - 1) continue;
      total -= (a * i + b * j) * (n - j - 1);
      total -= gaussum(j + 1, n - 1) * c;
    }
    unsigned long long s2 = 0;
    for (auto k : g[i]) {
      if (k != i + 1) {
        total -= (a * i + c * k) * (k - i - 1);
        total -= gaussum(i + 1, k - 1) * b;
      }
    }
  }
  for (int j = 0; j < n; ++j) {
    for (auto k : g[j]) {
      if (!j) continue;
      total -= (b * j + c * k) * j;
      total -= gaussum(0, j - 1) * a;
    }
  }
  for (int j = 0; j < n; ++j) {
    unsigned long long sum_gout = 0;
    for (int k : g[j]) sum_gout += k;
    for (int i : gin[j]) {
      total += (1LL * i * a + 1ULL * j * b) * g[j].size();
      total += sum_gout * c;
    }
  }
  for (int k = 0; k < n; ++k) {
    long long sum_i = 0, am = 0;
    for (int j : gin[k]) {
      if (am) {
        total += (1ULL * k * c + 1ULL * b * j) * am;
        total += sum_i * a;
      }
      ++am;
      sum_i += j;
    }
  }
  sqr = sqrt(m) + 1;
  int am_spec = 0;
  for (int i = 0; i < n; ++i)
    if (g[i].size() >= sqr) {
      id_spec[i] = am_spec, ++am_spec;
    } else
      id_spec[i] = -1;
  for (int i = 0; i < m; ++i) {
    int ea, eb;
    tie(ea, eb) = e[i];
    int id_ea = id_spec[ea], id_eb = id_spec[eb];
    assert(ea < eb);
    if (g[ea].size() >= sqr) {
      are[id_ea][eb] = 1;
    }
  }
  for (int i = 0; i < n; ++i) {
    if (g[i].size() >= sqr) {
      int id_i = id_spec[i];
      for (int j = 0; j < m; ++j) {
        int ea, eb;
        tie(ea, eb) = e[j];
        if (are[id_i][ea] && are[id_i][eb]) {
          total -= 1ULL * a * i + 1ULL * b * ea + 1ULL * c * eb;
        }
      }
    } else {
      for (int j : g[i]) {
        int ptr_j = 0;
        for (int k : g[i]) {
          if (j > k) continue;
          if (g[j].size() < sqr) {
            while (ptr_j < (int)g[j].size() && g[j][ptr_j] < k) ++ptr_j;
            if (ptr_j != (int)g[j].size() && g[j][ptr_j] == k)
              total -= 1ULL * a * i + b * j + c * k;
          } else {
            int id_j = id_spec[j];
            if (are[id_j][k]) total -= a * i + b * j + c * k;
          }
        }
      }
    }
  }
  cout << total;
}