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;
using int64 = long long int;
using uint64 = unsigned long long int;
int ReadInt() {
  int result;
  cin >> result;
  return result;
}
int64 cn2(int64 n) {
  if ((n & 1) == 0) {
    return (n >> 1) * (n - 1);
  } else {
    return n * ((n - 1) >> 1);
  }
}
int64 sum(int64 u, int64 v) {
  int s = u + v;
  if ((s & 1) == 0) {
    return (s >> 1) * (v - u + 1);
  } else {
    return s * ((v - u + 1) >> 1);
  }
}
int64 calc0(int n, int64 a, int64 b, int64 c) {
  int64 s1 = 0;
  for (int64 i = 0; i < n - 2; ++i) {
    s1 += i * cn2(n - i - 1);
  }
  s1 = s1 * a;
  int64 s2 = 0;
  for (int64 j = 1; j < n - 1; ++j) {
    s2 += j * j * (n - 1 - j);
  }
  s2 = s2 * b;
  int64 s3 = 0;
  for (int64 k = 2; k < n; ++k) {
    s3 += k * cn2(k);
  }
  s3 = s3 * c;
  return s1 + s2 + s3;
}
int64 calc1(int n, int64 a, int64 b, int64 c,
            const vector<set<int>>& conflicts) {
  int64 s = 0;
  for (int64 u = 0; u < n; ++u) {
    for (int64 v : conflicts[u]) {
      if (v < u) {
        continue;
      }
      if (v <= n - 2) {
        s += (a * u + b * v) * (n - v - 1) + c * sum(v + 1, n - 1);
      }
      if (u <= v - 2) {
        s += (a * u + c * v) * (v - u - 1) + b * sum(u + 1, v - 1);
      }
      if (u >= 1) {
        s += (b * u + c * v) * u + a * sum(0, u - 1);
      }
    }
  }
  return s;
}
int64 calc2(int n, int64 a, int64 b, int64 c,
            const vector<set<int>>& conflicts) {
  int64 s = 0;
  for (int64 i = 0; i < n; ++i) {
    int64 count = 0;
    int64 sum = 0;
    for (int64 j : conflicts[i]) {
      if (j < i) {
        continue;
      }
      s += count * j * c + sum;
      count += 1;
      sum += b * j;
    }
    s += a * i * cn2(count);
  }
  for (int64 j = 0; j < n; ++j) {
    int64 c1 = 0;
    int64 s1 = 0;
    int64 c2 = 0;
    int64 s2 = 0;
    for (int64 u : conflicts[j]) {
      if (u < j) {
        c1 += 1;
        s1 += a * u;
      } else {
        c2 += 1;
        s2 += c * u;
      }
    }
    s += b * j * c1 * c2;
    s += s1 * c2 + s2 * c1;
  }
  for (int64 k = 0; k < n; ++k) {
    int64 count = 0;
    int64 sum = 0;
    for (int64 j : conflicts[k]) {
      if (j > k) {
        continue;
      }
      s += count * j * b + sum;
      count += 1;
      sum += a * j;
    }
    s += c * k * cn2(count);
  }
  return s;
}
int64 calc3(int n, int64 a, int64 b, int64 c,
            const vector<set<int>>& conflicts) {
  int max_degree = sqrt(n);
  int64 s = 0;
  vector<int> nei;
  for (int64 u = 0; u < n; ++u) {
    if (conflicts[u].size() > max_degree) {
      continue;
    }
    nei.clear();
    for (int64 v : conflicts[u]) {
      if (conflicts[v].size() <= max_degree && v < u) {
        continue;
      }
      nei.push_back(v);
    }
    for (int x = 0; x < nei.size(); ++x) {
      int64 v = nei[x];
      for (int y = x + 1; y < nei.size(); ++y) {
        int64 q = nei[y];
        if (conflicts[v].find(q) == conflicts[v].end()) {
          continue;
        }
        int64 i = min(min(u, v), q);
        int64 k = max(max(u, v), q);
        int64 j = u + v + q - i - k;
        s += a * i + b * j + c * k;
      }
    }
  }
  vector<vector<int>> big_nei(n);
  for (int64 i = 0; i < n; ++i) {
    if (conflicts[i].size() <= max_degree) {
      continue;
    }
    for (int64 j : conflicts[i]) {
      if (j < i || conflicts[j].size() <= max_degree) {
        continue;
      }
      big_nei[i].push_back(j);
    }
  }
  for (int64 i = 0; i < n; ++i) {
    for (int64 j : big_nei[i]) {
      for (int64 k : big_nei[j]) {
        if (conflicts[i].find(k) == conflicts[i].end()) {
          continue;
        }
        s += a * i + b * j + c * k;
      }
    }
  }
  return s;
}
int main() {
  int n = ReadInt();
  int m = ReadInt();
  int64 a = ReadInt();
  int64 b = ReadInt();
  int64 c = ReadInt();
  vector<set<int>> conflicts(n);
  for (int i = 0; i < m; ++i) {
    int u = ReadInt();
    int v = ReadInt();
    conflicts[u].insert(v);
    conflicts[v].insert(u);
  }
  int64 s0 = calc0(n, a, b, c);
  int64 s1 = calc1(n, a, b, c, conflicts);
  int64 s2 = calc2(n, a, b, c, conflicts);
  int64 s3 = calc3(n, a, b, c, conflicts);
  cout << static_cast<uint64>(s0 - s1 + s2 - s3) << "\n";
  return 0;
}