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 getint() {
  int s = 0, o = 1;
  char c;
  for (c = getchar(); c < '0' || c > '9'; c = getchar())
    if (c == '-') o = -1;
  for (; c >= '0' && c <= '9'; c = getchar()) s *= 10, s += c - '0';
  return s * o;
}
const int maxn = 2010;
int vis[maxn], dfn[maxn], low[maxn], col[maxn], n, m, cnt, sum[maxn], val[maxn],
    timer;
std::vector<int> st, e[maxn];
void dfs(int u, int F) {
  int v;
  vis[u] = 1;
  low[u] = dfn[u] = ++timer;
  st.push_back(u);
  for (int i = 0; i < e[u].size(); i++) {
    v = e[u][i];
    if (v != F) {
      if (vis[v]) {
        low[u] = min(low[u], dfn[v]);
      } else {
        dfs(v, u);
        low[u] = min(low[u], low[v]);
      }
    }
  }
  if (low[u] == dfn[u]) {
    for (;;) {
      v = st.back();
      st.pop_back();
      col[v] = cnt;
      ++sum[cnt];
      if (v == u) break;
    }
    ++cnt;
  }
}
int hav[maxn][maxn], inside[maxn];
std::vector<int> E[maxn];
void getval(int u, int F) {
  int v;
  val[u] = sum[u];
  inside[u] = 0;
  for (int i = 0; i < E[u].size(); i++) {
    v = E[u][i];
    if (v != F) {
      getval(v, u);
      val[u] += val[v];
      inside[u] += inside[v] + sum[u] * val[v];
    }
  }
}
bitset<2001> dp;
int xx[2000 * 1000], yy[2000 * 1000];
int main(int argc, char const *argv[]) {
  int x, y;
  n = getint(), m = getint();
  for (int mm = 0; mm < m; mm++) {
    x = getint(), y = getint();
    xx[mm] = x, yy[mm] = y;
    e[x].push_back(y), e[y].push_back(x);
  }
  dfs(1, 0);
  for (int mm = 0; mm < m; mm++) {
    x = xx[mm], y = yy[mm];
    if (col[x] != col[y]) {
      int u = col[x], v = col[y];
      if (!hav[u][v]) {
        E[u].push_back(v), E[v].push_back(u);
        hav[u][v] = hav[v][u] = 1;
      }
    }
  }
  int now = 0, final = 0;
  for (int i = 0; i < cnt; i++) now += sum[i] * sum[i];
  for (int i = 0; i < cnt; i++) {
    getval(i, -1);
    dp.reset();
    dp[0] = 1;
    for (int j = 0; j < E[i].size(); j++) {
      dp |= dp << val[E[i][j]];
    }
    int rest = n - sum[i];
    int j, res = 0;
    for (int j = 0; j < rest; ++j)
      if (dp[j] || dp[rest - j])
        res = max(res, (sum[i] + j) * (sum[i] + rest - j));
    res -= sum[i] * sum[i];
    for (int j = 0; j < E[i].size(); j++) res += inside[E[i][j]];
    final = max(final, res);
  }
  printf("%d\n", final + now);
  return 0;
}
