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")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
const auto start_time = std::chrono::high_resolution_clock::now();
void aryanc403() {}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
  return uniform_int_distribution<long long int>(l, r)(rng);
}
class CMP {
 public:
  bool operator()(pair<long long int, long long int> a,
                  pair<long long int, long long int> b) {
    return !(a.first < b.first || (a.first == b.first && a.second <= b.second));
  }
};
void add(map<long long int, long long int> &m, long long int x,
         long long int cnt = 1) {
  auto jt = m.find(x);
  if (jt == m.end())
    m.insert({x, cnt});
  else
    jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
         long long int cnt = 1) {
  auto jt = m.find(x);
  if (jt->second <= cnt)
    m.erase(jt);
  else
    jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
         const pair<long long int, long long int> &b) {
  return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int mod = 1000000007L;
long long int T, n, i, j, k, in, cnt, l, r, u, v, x, y;
long long int m;
string s;
vector<vector<long long int> > e;
vector<pair<long long int, long long int> > edges;
unsigned long long int ans, a, b, c;
unsigned long long int C2(long long int n) {
  if (n <= 0) return 0;
  return n * (n + 1) / 2;
}
unsigned long long int solve1() {
  unsigned long long int ans = 0;
  for (auto x : edges) {
    const long long int u = x.first, v = x.second;
    ans += (a * u + b * v) * (n - 1 - v);
    ans += c * (C2(n - 1) - C2(v));
    ans += (b * u + c * v) * (u);
    ans += a * C2(u - 1);
    ans += (a * u + c * v) * (v - u - 1);
    ans += b * (C2(v - 1) - C2(u));
  };
  return ans;
}
unsigned long long int solveMid(unsigned long long int cst,
                                const vector<long long int> &sm,
                                const vector<long long int> &lr) {
  unsigned long long int ans = 0;
  ans += cst * (((long long int)(sm).size())) * (((long long int)(lr).size()));
  for (auto x : sm) ans += a * x * ((long long int)(lr).size());
  for (auto x : lr) ans += c * x * ((long long int)(sm).size());
  return ans;
}
unsigned long long int solveCorner(unsigned long long int cst,
                                   unsigned long long int a,
                                   unsigned long long int b,
                                   const vector<long long int> &e) {
  unsigned long long int ans = 0;
  unsigned long long int n = ((long long int)(e).size()), m = 0;
  ans += cst * ((n) * (n - 1) / 2);
  for (auto x : e) {
    n--;
    ans += (x * a) * n;
    ans += (x * b) * m;
    m++;
  }
  return ans;
}
unsigned long long int solve2() {
  unsigned long long int ans = 0;
  for (long long int i = 0; i < n; ++i) {
    vector<long long int> dd, ee;
    for (auto x : e[i]) {
      if (i < x)
        ee.push_back(x);
      else
        dd.push_back(x);
    }
    ans += solveMid(b * i, dd, ee);
    reverse(begin(ee), end(ee));
    ans += solveCorner(a * i, c, b, ee);
    ans += solveCorner(c * i, a, b, dd);
  };
  return ans;
}
bool chk(const vector<long long int> &a, long long int x) {
  auto it = lower_bound(begin(a), end(a), x);
  return it != a.end() && *it == x;
}
const long long int MM = 200000;
const long long int KK = 400;
bitset<MM> edgHeavy[1 + 2 * MM / KK];
unsigned long long int solve3() {
  unsigned long long int ans = 0;
  vector<long long int> bb, edg;
  for (auto x : edges) edg.push_back(x.first * n + x.second);
  sort(begin(edg), end(edg));
  vector<pair<long long int, long long int> > qur;
  for (long long int i = 0; i < n; ++i) {
    if (((long long int)(e[i]).size()) > KK) {
      bb.push_back(i);
      continue;
    }
    for (auto x : e[i]) {
      if (x > i) break;
      for (auto y : e[i]) {
        if (y < i) continue;
        if (chk(edg, x * n + y)) ans += x * a + i * b + c * y;
      }
    }
  }
  const long long int mm = ((long long int)(bb).size());
  assert(mm < 2 * MM / KK + 1);
  for (long long int i = 0; i < mm; ++i) {
    for (auto x : e[bb[i]]) edgHeavy[i][x] = 1;
  }
  for (auto x : edges) {
    const long long int u = x.first, v = x.second;
    auto it = lower_bound(begin(bb), end(bb), u + 1) - bb.begin();
    while (it < mm && bb[it] < v) {
      if (edgHeavy[it][u] && edgHeavy[it][v]) ans += a * u + bb[it] * b + c * v;
      ++it;
    }
  };
  return ans;
}
int main(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  {
    cin >> n >> m;
    cin >> a >> b >> c;
    e.resize(n);
    for (i = 0; i < (m); ++i) {
      cin >> u >> v;
      e[u].push_back(v);
      e[v].push_back(u);
      if (u > v) swap(u, v);
      edges.push_back({u, v});
    }
    for (i = 0; i < (n); ++i) {
      sort(begin(e[i]), end(e[i]));
      ans += (c * i) * (i * (i - 1) / 2);
      ans += (b * i) * i * (n - i - 1);
      ans += (a * i) * ((n - i - 2) * (n - i - 1) / 2);
    };
    ;
    unsigned long long int ans1 = solve1();
    unsigned long long int ans2 = solve2();
    unsigned long long int ans3 = solve3();
    ;
    ans += -ans1 + ans2 - ans3;
    ;
    ;
    cout << ans << "\n";
  }
  aryanc403();
  return 0;
}