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 n, m, a, b, il, ile, res, pom_res, akt_res, best_res, stale_res, pomile;
int ojc[2007], czas[2007], low[2007], f[2007], wartosc[2007], t[2007];
vector<int> v[2007], v2[2007];
bool most[2007], mozna[2007];
queue<int> kolej;
void dfs(int x) {
  czas[x] = low[x] = ++il;
  for (__typeof((v[x]).begin()) it = ((v[x]).begin()); it != (v[x]).end(); it++)
    if (!czas[*it]) {
      ojc[*it] = x;
      dfs(*it);
      low[x] = min(low[x], low[*it]);
    }
  for (__typeof((v[x]).begin()) it = ((v[x]).begin()); it != (v[x]).end(); it++)
    if (ojc[*it] != x && ojc[x] != *it) low[x] = min(low[x], czas[*it]);
  for (__typeof((v[x]).begin()) it = ((v[x]).begin()); it != (v[x]).end(); it++)
    if (ojc[*it] == x && low[*it] > czas[x]) most[*it] = true;
}
bool mosty(int a, int b) {
  return (ojc[a] == b && most[a]) || (ojc[b] == a && most[b]);
}
void dfs2(int x, int nazwa) {
  f[x] = nazwa;
  ++wartosc[nazwa];
  for (__typeof((v[x]).begin()) it = ((v[x]).begin()); it != (v[x]).end(); it++)
    if (!f[*it] && !mosty(x, *it)) dfs2(*it, nazwa);
}
int jazda_biala_gwiazda(int x, int f) {
  int pomix = wartosc[x];
  for (__typeof((v2[x]).begin()) it = ((v2[x]).begin()); it != (v2[x]).end();
       it++)
    if (*it != f) {
      int pomix2 = jazda_biala_gwiazda(*it, x);
      pomix += pomix2;
      pom_res += wartosc[x] * pomix2;
    }
  return pomix;
}
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 0; i < (m); i++) {
    scanf("%d%d", &a, &b);
    v[a].push_back(b);
    v[b].push_back(a);
  }
  ojc[1] = -1;
  dfs(1);
  for (int i = 1; i <= (n); i++)
    if (!f[i]) {
      ile++;
      dfs2(i, ile);
    }
  for (int i = 1; i <= (n); i++)
    if (most[i] && ojc[i] != -1) {
      v2[f[i]].push_back(f[ojc[i]]);
      v2[f[ojc[i]]].push_back(f[i]);
    }
  for (int i = 1; i <= (ile); i++) stale_res += wartosc[i] * wartosc[i];
  mozna[0] = true;
  for (int i = 1; i <= (ile); i++) {
    akt_res = pomile = pom_res = 0;
    for (__typeof((v2[i]).begin()) it = ((v2[i]).begin()); it != (v2[i]).end();
         it++) {
      t[pomile++] = jazda_biala_gwiazda(*it, i);
    }
    pom_res += wartosc[i] * (n - wartosc[i]);
    sort(t, t + pomile);
    if (t[pomile - 1] * 2 >= (n - wartosc[i])) {
      akt_res = max(akt_res, t[pomile - 1] * (n - wartosc[i] - t[pomile - 1]));
    } else {
      for (int j = 1; j <= (n - wartosc[i]); j++) mozna[j] = false;
      for (int j = 0; j < (pomile); j++) {
        for (int k = n - wartosc[i] - t[j]; k >= (0); k--)
          if (mozna[k]) mozna[k + t[j]] = true;
      }
      for (int j = 0; j <= (n - wartosc[i]); j++)
        if (mozna[j]) {
          akt_res = max(akt_res, j * (n - wartosc[i] - j));
        }
    }
    best_res = max(best_res, pom_res + akt_res);
  }
  printf("%d\n", best_res + stale_res);
  return 0;
}
