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 MAXN = 2000 + 10;
int n, m, N, Tohka, cur, f[MAXN], st[MAXN], size[MAXN], cnt[MAXN], h[MAXN],
    DFN[MAXN], Low[MAXN];
struct Graph {
  int id, next, flag;
} g[MAXN * MAXN];
vector<int> e[MAXN];
int idx, stk[MAXN], top, s, t;
void Add(int tot, int first, int second) {
  g[tot].id = second, g[tot].next = st[first], st[first] = tot, g[tot].flag = 1;
}
void Tarjan(int first, int fa) {
  DFN[first] = Low[first] = ++idx;
  stk[++top] = first;
  for (int i = st[first]; i != -1; i = g[i].next)
    if (i != fa)
      if (!DFN[g[i].id])
        Tarjan(g[i].id, i ^ 1), Low[first] = min(Low[first], Low[g[i].id]);
      else
        Low[first] = min(Low[first], DFN[g[i].id]);
  if (Low[first] >= DFN[first]) {
    for (++N; stk[top] != first; f[stk[top]] = N, ++cnt[N], --top)
      ;
    f[first] = N;
    --top, ++cnt[N];
    cur += ((cnt[N]) * (cnt[N]));
  }
}
void DFS(int first, int fa) {
  size[first] = cnt[first];
  for (int i = 0; i < ((int)(e[first]).size()); ++i)
    if (e[first][i] != fa)
      DFS(e[first][i], first), size[first] += size[e[first][i]];
  s += (size[first] - cnt[first]) * cnt[first];
}
int main() {
  scanf("%d%d", &n, &m);
  memset(st, -1, sizeof(st));
  for (int i = 1; i <= m; ++i) {
    int first, second;
    scanf("%d%d", &first, &second);
    Add(i * 2, first, second);
    Add(i * 2 + 1, second, first);
  }
  Tarjan(1, 0);
  for (int i = 1; i <= n; ++i)
    for (int j = st[i]; j != -1; j = g[j].next)
      if (f[i] != f[g[j].id]) e[f[i]].push_back(f[g[j].id]);
  for (int i = 1; i <= N; ++i) {
    s = 0, t = 0;
    DFS(i, 0);
    memset(h, 0, sizeof(h));
    h[0] = 1;
    for (int j = 0; j < ((int)(e[i]).size()); ++j) {
      for (int k = n - cnt[i]; k >= size[e[i][j]]; --k)
        h[k] |= h[k - size[e[i][j]]];
    }
    for (int k = 1; k <= n - cnt[i]; ++k)
      t = max(t, h[k] * k * (n - cnt[i] - k));
    Tohka = max(Tohka, cur + s + t);
  }
  cout << Tohka << endl;
  fclose(stdin);
  fclose(stdout);
  return 0;
}
