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;
int pow(int a, int b, int c) {
  int ret = 1;
  for (; b; b >>= 1, a = 1LL * a * a % c)
    if (b & 1) ret = 1LL * ret * a % c;
  return ret;
}
const int N = 2e3 + 10, M = 4.05e6 + 10;
int h[N], g[N], p[M], n1[M], ee, low[N], dfn[N], dfntot, vis[N], n, m, st[N],
    top, id[N], tot, sz[N], ans, dp[N], ok[N];
pair<int, int> e[M];
void ae(int *A, int x, int y) {
  p[ee] = y;
  n1[ee] = A[x];
  A[x] = ee++;
}
void tarjan(int u, int fa) {
  vis[u] = 1;
  low[u] = dfn[u] = ++dfntot;
  st[++top] = u;
  for (int i = h[u]; ~i; i = n1[i])
    if (p[i] != fa) {
      if (!vis[p[i]])
        tarjan(p[i], u), low[u] = min(low[u], low[p[i]]);
      else
        low[u] = min(low[u], dfn[p[i]]);
      if (low[p[i]] > dfn[u]) {
        ++tot;
        while (st[top] != p[i]) id[st[top--]] = tot, sz[tot]++;
        id[st[top--]] = tot;
        sz[tot]++;
      }
    }
}
void dfs(int u, int fa) {
  dp[u] = sz[u];
  for (int i = g[u]; ~i; i = n1[i])
    if (p[i] != fa) {
      dfs(p[i], u);
      dp[u] += dp[p[i]];
    }
}
int main() {
  scanf("%d%d", &n, &m);
  memset(h, -1, sizeof(h));
  memset(g, -1, sizeof(g));
  int x, y;
  for (int i = 1; i <= m; i++) scanf("%d%d", &x, &y), ae(h, x, y), ae(h, y, x);
  for (int i = 1; i <= n; i++)
    if (!vis[i]) tarjan(i, 0);
  ++tot;
  while (top) id[st[top--]] = tot, sz[tot]++;
  for (int i = 1; i <= n; i++)
    for (int j = h[i]; ~j; j = n1[j])
      if (id[i] != id[p[j]]) ae(g, id[i], id[p[j]]);
  for (int i = 1; i <= tot; i++) ans += sz[i] * (sz[i] - 1);
  int ret = 0;
  for (int i = 1; i <= tot; i++) {
    int tmp = 0;
    dfs(i, 0);
    for (int j = 1; j <= tot; j++) tmp += (dp[j] - sz[j]) * sz[j];
    for (int j = 0; j <= n; j++) ok[j] = 0;
    ok[0] = 1;
    for (int k = g[i]; ~k; k = n1[k])
      for (int j = n; j >= dp[p[k]]; j--) ok[j] |= ok[j - dp[p[k]]];
    int mx = 0;
    for (int j = 0; j <= n; j++)
      if (ok[j]) mx = max(mx, j * (n - sz[i] - j));
    ret = max(ret, tmp + mx);
  }
  printf("%d\n", n + ans + ret);
  return 0;
}
