You are given an undirected graph G. G has N vertices and M edges. The vertices are numbered from 1 through N, and the i-th edge (1 ≤ i ≤ M) connects Vertex a_i and b_i. G does not have self-loops and multiple edges.

You can repeatedly perform the operation of adding an edge between two vertices. However, G must not have self-loops or multiple edges as the result. Also, if Vertex 1 and 2 are connected directly or indirectly by edges, your body will be exposed to a voltage of 1000000007 volts. This must also be avoided.

Under these conditions, at most how many edges can you add? Note that Vertex 1 and 2 are never connected directly or indirectly in the beginning.

Constraints

* 2 ≤ N ≤ 10^5
* 0 ≤ M ≤ 10^5
* 1 ≤ a_i < b_i ≤ N
* All pairs (a_i, b_i) are distinct.
* Vertex 1 and 2 in G are not connected directly or indirectly by edges.

Input

Input is given from Standard Input in the following format:


N M
a_1 b_1
:
a_M b_M


Output

Print the maximum number of edges that can be added.

Examples

Input

4 1
1 3


Output

2


Input

2 0


Output

0


Input

9 6
1 4
1 8
2 5
3 6
4 8
5 7


Output

12
#include<bits/stdc++.h>
using namespace std;

//UnionFind
int n = 100000;
vector<int> par(n);
vector<int> Size(n);

void init(int n){
  for(int i=0; i<n; i++){
    par.at(i) = i;
    Size.at(i) = 1;
  }
}

int root(int x){
  if(par.at(x) == x){
    return x;
  }
  else{
    return par.at(x) = root(par.at(x));
  }
}

bool same(int x, int y){
  return root(x) == root(y);
}

void unite(int x, int y){
  x = root(x);
  y = root(y);
  if(x == y){
    return;
  }
  if (Size.at(x) < Size.at(y)){
    swap(x, y);
  }
  Size.at(x) += Size.at(y);
  par.at(y) = x;
}

int Size_x(int x){
  return Size.at(root(x));
}


int main(){
  int N, M;
  cin >> N >> M;
  init(N);
  for(int i=0; i<M; i++){
    int a, b;
    cin >> a >> b;
    a--; b--;
    unite(a,b);
  }
  int64_t ans = 0;
  int64_t A = Size_x(0);
  int64_t B = Size_x(1);
  if(A >= B){
    ans += (N-B)*(N-B-1)/2;
    ans += B*(B-1)/2;
    ans -= M;
  }
  else{
    ans += (N-A)*(N-A-1)/2;
    ans += A*(A-1)/2;
    ans -= M;
  }
  cout << ans << endl;
}
  