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;
inline int read() {
  int neg = 1, num = 0;
  char c = getchar();
  for (; !isdigit(c); c = getchar())
    if (c == '-') neg = -1;
  for (; isdigit(c); c = getchar()) num = (num << 1) + (num << 3) + c - '0';
  return neg * num;
}
int n, m, cnt, deg[200010], vis[200010], rt[200010], ls[200010 * 50],
    rs[200010 * 50];
unsigned long long A, B, C, S1, S2, S3, S4, S5, u[200010], v[200010],
    s1[200010], s2[200010], num[200010], sum1[200010 * 50], sum2[200010 * 50];
vector<int> G[200010];
inline unsigned long long Calc(unsigned long long x, unsigned long long y,
                               unsigned long long z) {
  if (x > y) swap(x, y);
  if (y > z) swap(y, z);
  if (x > y) swap(x, y);
  return A * x + B * y + C * z;
}
inline void Calc1() {
  for (int i = n - 1; i >= 0; i--) s1[i] = s1[i + 1] + C * i;
  for (int i = n - 2; i >= 0; i--)
    s2[i] = s2[i + 1] + s1[i + 1] + B * i * (n - i - 1),
    num[i] = num[i + 1] + n - i - 1;
  for (int i = n - 3; i >= 0; i--) S1 += s2[i + 1] + A * i * num[i + 1];
}
inline void Calc2() {
  for (int i = 1; i <= m; i++) {
    if (u[i] > v[i]) swap(u[i], v[i]);
    S2 += u[i] * (u[i] - 1) / 2 * A;
    S2 += (v[i] - u[i] - 1) * (u[i] + v[i]) / 2 * B;
    S2 += (v[i] + n) * (n - v[i] - 1) / 2 * C;
    S2 += u[i] * (B * u[i] + A * (n - u[i] - 2));
    S2 += v[i] * (C * (v[i] - 1) + B * (n - v[i] - 1));
  }
}
inline void Update(int &x, int l, int r, int p) {
  if (!x) x = ++cnt;
  sum1[x] += p;
  sum2[x] += 1;
  if (l == r) return;
  int mid = l + r >> 1;
  if (p <= mid)
    Update(ls[x], l, mid, p);
  else
    Update(rs[x], mid + 1, r, p);
}
inline unsigned long long Query1(int x, int l, int r, int L, int R) {
  if (!x || L > R) return 0;
  if (l >= L && r <= R) return sum1[x];
  int mid = l + r >> 1;
  unsigned long long ans = 0;
  if (L <= mid) ans += Query1(ls[x], l, mid, L, R);
  if (R > mid) ans += Query1(rs[x], mid + 1, r, L, R);
  return ans;
}
inline unsigned long long Query2(int x, int l, int r, int L, int R) {
  if (!x || L > R) return 0;
  if (l >= L && r <= R) return sum2[x];
  int mid = l + r >> 1;
  unsigned long long ans = 0;
  if (L <= mid) ans += Query2(ls[x], l, mid, L, R);
  if (R > mid) ans += Query2(rs[x], mid + 1, r, L, R);
  return ans;
}
inline unsigned long long Q1(int x, int y, int l, int r) {
  return Query1(rt[x], 0, n - 1, l, r) + Query1(rt[y], 0, n - 1, l, r);
}
inline unsigned long long Q2(int x, int y, int l, int r) {
  return Query2(rt[x], 0, n - 1, l, r) + Query2(rt[y], 0, n - 1, l, r);
}
inline void Calc3() {
  unsigned long long pre;
  for (int i = 1; i <= m; i++)
    Update(rt[u[i]], 0, n - 1, v[i]), Update(rt[v[i]], 0, n - 1, u[i]);
  for (int i = 1; i <= m; i++) {
    pre = S3;
    if (u[i] > v[i]) swap(u[i], v[i]);
    S3 += A * Q1(u[i], v[i], 0, u[i] - 1);
    S3 += B * Q1(u[i], v[i], u[i] + 1, v[i] - 1);
    S3 += C * Q1(u[i], v[i], v[i] + 1, n - 1);
    S3 += u[i] * (B * Q2(u[i], v[i], 0, u[i] - 1) +
                  A * Q2(u[i], v[i], u[i] + 1, n - 1) - A);
    S3 += v[i] * (C * Q2(u[i], v[i], 0, v[i] - 1) +
                  B * Q2(u[i], v[i], v[i] + 1, n - 1) - C);
    if (pre > S3) S5++;
  }
}
inline void Calc4() {
  for (int i = 1; i <= m; i++) deg[u[i]]++, deg[v[i]]++;
  for (int i = 1; i <= m; i++) {
    int s = u[i], t = v[i];
    if (deg[s] > deg[t] || (deg[s] == deg[t] && s > t)) swap(u[i], v[i]);
    G[u[i]].push_back(v[i]);
  }
  for (int k = 1; k <= m; k++) {
    for (int i = 0; i < G[u[k]].size(); i++) vis[G[u[k]][i]] = k;
    for (int i = 0; i < G[v[k]].size(); i++)
      if (vis[G[v[k]][i]] == k)
        S4 += Calc((unsigned long long)u[k], (unsigned long long)v[k],
                   (unsigned long long)G[v[k]][i]);
  }
}
signed main() {
  n = read();
  m = read();
  A = read();
  B = read();
  C = read();
  for (int i = 1; i <= m; i++) u[i] = read(), v[i] = read();
  Calc1();
  Calc2();
  Calc3();
  Calc4();
  for (int i = 1; i <= 63; i++) S5 = S5 * 2;
  cout << S1 - S2 + (S3 / 2 + S5) - S4 << endl;
  return 0;
}