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>
#pragma GCC optimize( \
    "Ofast,unroll-loops,no-stack-protector,unsafe-math-optimizations")
#pragma GCC target( \
    "sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const int INF = 1 << 30;
template <typename T>
inline bool chkmax(T &aa, T bb) {
  return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
  return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
const int mn = 200000 + 1;
vector<int> g[mn];
int bins(vector<int> &v, int key) {
  int imin = 0, imax = v.size();
  while (imin < imax) {
    int imid = (imin + imax) >> 1;
    if (v[imid] < key)
      imin = imid + 1;
    else
      imax = imid;
  }
  return imin;
}
bool binf(vector<int> &v, int key) {
  int imin = bins(v, key);
  return (imin < v.size()) && (v[imin] == key);
}
unsigned long long C2(unsigned long long x) {
  unsigned long long a = x, b = x - 1;
  if (a & 1)
    b /= 2;
  else
    a /= 2;
  return a * b;
}
const int L = 0, M = 1, R = 2;
unsigned int tri[mn][3];
unsigned int C[3];
unsigned int vlo[mn], vhi[mn];
unsigned int tl[mn], tmm[mn], tr[mn];
unsigned long long ans[3];
const int ms = 4000;
int x2s[mn];
bitset<mn> b[ms];
pair<int, int> vs[mn];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n = rint(), m = rint();
  for (int i = 0; i < 3; i++) C[i] = rint();
  for (int i = 0; i < m; i++) {
    int x = rint(), y = rint();
    g[x].push_back(y);
    g[y].push_back(x);
    vlo[max(x, y)]++;
    vhi[min(x, y)]++;
  }
  for (int x = 0; x < n; x++) vs[x] = make_pair(g[x].size(), x);
  sort(vs, vs + n, greater<pair<int, int> >());
  int slim = min(n, ms);
  memset(x2s, -1, sizeof x2s);
  for (int s = 0; s < slim; s++) {
    int x = vs[s].second;
    x2s[x] = s;
    for (auto &y : g[x]) b[s][y] = true;
  }
  for (int x = 0; x < n; x++) sort(g[x].begin(), g[x].end());
  for (int x = 0; x < n; x++) {
    for (auto &y : g[x]) {
      unsigned int lt = bins(g[y], x);
      unsigned int gt = g[y].size() - lt - 1;
      if (y < x) {
        tl[x] += lt;
        tmm[x] += gt;
      } else {
        tr[x] += gt;
        tmm[x] += lt;
      }
    }
  }
  for (int xx = 0; xx < n; xx++) {
    for (auto &yy : g[xx]) {
      if (xx > yy) continue;
      int x = xx, y = yy;
      if (g[x].size() > g[y].size()) swap(x, y);
      int s = x2s[y];
      if (s == -1) {
        for (auto &z : g[x]) {
          if (binf(g[y], z)) {
            int state;
            if (z > x && z > y)
              state = R;
            else if (z < x && z < y)
              state = L;
            else
              state = M;
            ++tri[z][state];
          }
        }
      } else {
        for (auto &z : g[x]) {
          if (b[s][z]) {
            int state;
            if (z > x && z > y)
              state = R;
            else if (z < x && z < y)
              state = L;
            else
              state = M;
            ++tri[z][state];
          }
        }
      }
    }
  }
  int el = 0, er = m;
  for (int x = 0; x < n; x++) {
    er -= vhi[x];
    unsigned long long em = m - el - er - g[x].size();
    unsigned long long al = x, ar = n - x - 1;
    unsigned long long bl = vlo[x], br = vhi[x];
    unsigned long long gl = al - bl, gr = ar - br;
    {
      unsigned long long one = br * gr + C2(br) + er;
      unsigned long long two = tr[x];
      unsigned long long three = tri[x][L];
      unsigned long long contrib = one - two + three;
      unsigned long long all = C2(ar);
      ans[L] += (all - contrib) * x;
    }
    {
      unsigned long long one = bl * gl + C2(bl) + el;
      unsigned long long two = tl[x];
      unsigned long long three = tri[x][R];
      unsigned long long contrib = one - two + three;
      unsigned long long all = C2(al);
      ans[R] += (all - contrib) * x;
    }
    {
      unsigned long long one = bl * gr + gl * br + bl * br + em;
      unsigned long long two = tmm[x];
      unsigned long long three = tri[x][M];
      unsigned long long contrib = one - two + three;
      unsigned long long all = al * ar;
      ans[M] += (all - contrib) * x;
    }
    el += vlo[x];
  }
  unsigned long long final = 0;
  for (int i = 0; i < 3; i++) final += ans[i] * C[i];
  printf("%llu\n", final);
}
static char stdinBuffer[1024];
static char *stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char *stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
  size_t remaining = stdinDataEnd - stdinPos;
  if (remaining < amount) {
    memmove(stdinBuffer, stdinPos, remaining);
    size_t sz = fread(stdinBuffer + remaining, 1,
                      sizeof(stdinBuffer) - remaining, stdin);
    stdinPos = stdinBuffer;
    stdinDataEnd = stdinBuffer + remaining + sz;
    if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
  }
}
int rint() {
  readAhead(16);
  int x = 0;
  bool neg = false;
  while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
  if (*stdinPos == '-') {
    ++stdinPos;
    neg = true;
  }
  while (*stdinPos >= '0' && *stdinPos <= '9') {
    x *= 10;
    x += *stdinPos - '0';
    ++stdinPos;
  }
  return neg ? -x : x;
}
char rch() {
  readAhead(16);
  while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
  char ans = *stdinPos;
  ++stdinPos;
  return ans;
}
long long rlong() {
  readAhead(32);
  long long x = 0;
  bool neg = false;
  while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
  if (*stdinPos == '-') {
    ++stdinPos;
    neg = true;
  }
  while (*stdinPos >= '0' && *stdinPos <= '9') {
    x *= 10;
    x += *stdinPos - '0';
    ++stdinPos;
  }
  return neg ? -x : x;
}