Imagine a city with n junctions and m streets. Junctions are numbered from 1 to n.

In order to increase the traffic flow, mayor of the city has decided to make each street one-way. This means in the street between junctions u and v, the traffic moves only from u to v or only from v to u. 

The problem is to direct the traffic flow of streets in a way that maximizes the number of pairs (u, v) where 1 ≤ u, v ≤ n and it is possible to reach junction v from u by passing the streets in their specified direction. Your task is to find out maximal possible number of such pairs.

Input

The first line of input contains integers n and m, (<image>), denoting the number of junctions and streets of the city.

Each of the following m lines contains two integers u and v, (u ≠ v), denoting endpoints of a street in the city.

Between every two junctions there will be at most one street. It is guaranteed that before mayor decision (when all streets were two-way) it was possible to reach each junction from any other junction.

Output

Print the maximal number of pairs (u, v) such that that it is possible to reach junction v from u after directing the streets.

Examples

Input

5 4
1 2
1 3
1 4
1 5


Output

13


Input

4 5
1 2
2 3
3 4
4 1
1 3


Output

16


Input

2 1
1 2


Output

3


Input

6 7
1 2
2 3
1 3
1 4
4 5
5 6
6 4


Output

27

Note

In the first sample, if the mayor makes first and second streets one-way towards the junction 1 and third and fourth streets in opposite direction, there would be 13 pairs of reachable junctions: {(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (2, 1), (3, 1), (1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)}
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, child[N], m, w[N];
vector<int> G[N], g[N];
int cnt, low[N], num[N], scc, h[N], sam[N];
vector<int> ad;
int f[2][2 * N];
int ret = 0;
void dfs(int u, int par) {
  ad.push_back(u);
  low[u] = num[u] = ++cnt;
  for (int i = 0; i < G[u].size(); ++i) {
    int v = G[u][i];
    if (v == par) continue;
    if (!num[v]) {
      dfs(v, u);
      low[u] = min(low[u], low[v]);
    } else
      low[u] = min(low[u], num[v]);
  }
  if (low[u] == num[u]) {
    ++scc;
    w[scc] = 1;
    while (ad.back() != u) {
      int v = ad.back();
      w[scc]++;
      h[v] = scc;
      low[v] = num[v] = 1e9;
      ad.pop_back();
    }
    ad.pop_back();
    low[u] = num[u] = 1e9;
    h[u] = scc;
    ret += w[scc] * w[scc];
  }
}
int ccc = 0;
void prepare(int u, int v) {
  child[v] = w[v];
  for (int i = 0; i < g[v].size(); ++i) {
    int vv = g[v][i];
    if (vv == u) continue;
    prepare(v, vv);
    child[v] += child[vv];
  }
  if (u != v) ccc += (w[v] * (child[v] - w[v]));
}
int main() {
  scanf("%d%d", &n, &m);
  for (int i = (1); i <= (m); ++i) {
    int u, v;
    scanf("%d%d", &u, &v);
    G[u].push_back(v);
    G[v].push_back(u);
  }
  for (int i = (1); i <= (n); ++i)
    if (!num[i]) dfs(i, i);
  for (int u = (1); u <= (n); ++u) {
    for (int j = 0; j < G[u].size(); ++j) {
      int v = G[u][j];
      if (h[v] != h[u]) g[h[u]].push_back(h[v]);
    }
  }
  for (int i = (1); i <= (scc); ++i) {
    sort(g[i].begin(), g[i].end());
    g[i].resize(unique(g[i].begin(), g[i].end()) - g[i].begin());
  }
  cnt = 0;
  for (int u = (1); u <= (scc); ++u) {
    ccc = 0;
    prepare(u, u);
    memset(f, 0, sizeof(f));
    f[0][0] = 1;
    int swi = 0;
    for (int i = 0; i < g[u].size(); ++i) {
      int v = g[u][i];
      swi = 1 - swi;
      for (int j = 0; j <= n; ++j) {
        f[swi][j] = f[1 - swi][j];
        if (j >= child[v]) f[swi][j] |= f[1 - swi][j - child[v]];
      }
    }
    for (int i = 0; i <= n; ++i)
      if (f[swi][i]) cnt = max(cnt, i * (n - i) + w[u] * (n - i - w[u]) + ccc);
  }
  printf("%d\n", ret + cnt);
}
