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 double pi = acos(-1);
int nn, n, m, tim;
int ans, f[2100], size[2100], dfn[2100], low[2100], q[2100], a[2100], bo[2100],
    be[2100];
bool edge[2100][2100];
vector<int> E[2100], E2[2100];
void tarjan(int x, int ff) {
  dfn[x] = low[x] = ++tim;
  q[++q[0]] = x;
  for (int y : E[x])
    if (y != ff) {
      if (!dfn[y]) {
        tarjan(y, x);
        low[x] = min(low[x], low[y]);
      } else
        low[x] = min(low[x], dfn[y]);
    }
  if (low[x] == dfn[x]) {
    ++n;
    for (;;) {
      be[q[q[0]]] = n;
      a[n]++;
      q[0]--;
      if (q[q[0] + 1] == x) break;
    }
  }
}
void dfs(int x, int ff) {
  size[x] = a[x];
  f[x] = 0;
  for (int y : E2[x])
    if (y != ff) {
      dfs(y, x);
      size[x] += size[y];
      f[x] += f[y];
    }
  f[x] += a[x] * size[x];
}
void work(int x) {
  dfs(x, 0);
  int tmp = a[x] * nn, maxx = 0;
  int tot = 0;
  for (int y : E2[x]) {
    tmp += f[y];
    q[++tot] = size[y];
    maxx = max(maxx, size[y]);
  }
  if (maxx >= nn - a[x] - maxx) {
    tmp += maxx * (nn - a[x] - maxx);
  } else {
    memset(bo, 0, sizeof(bo));
    bo[0] = 1;
    for (int i = 1; i <= tot; ++i)
      for (int j = nn - a[x]; j >= 0; --j)
        if (bo[j]) bo[j + q[i]] = 1;
    for (int j = (nn - a[x]) / 2; j >= 0; --j)
      if (bo[j]) {
        tmp += j * (nn - a[x] - j);
        break;
      }
  }
  ans = max(ans, tmp);
}
int main() {
  scanf("%d%d", &nn, &m);
  for (int i = 1; i <= m; ++i) {
    int x, y;
    scanf("%d%d", &x, &y);
    E[x].push_back(y);
    E[y].push_back(x);
  }
  tarjan(1, 0);
  for (int i = 1; i <= nn; ++i)
    for (int y : E[i])
      if (be[i] != be[y]) {
        if (edge[be[i]][be[y]]) continue;
        edge[be[i]][be[y]] = 1;
        E2[be[i]].push_back(be[y]);
      }
  ans = 0;
  for (int i = 1; i <= n; ++i) work(i);
  printf("%d\n", ans);
}
