Suppose that G is an undirected graph, and the value of  stab is defined as follows:

Among the expression, G_-i,-j  is the remainder after removing node i, node j and all edges that are directly relevant to the previous two nodes.cntCompent(X)  is the number of connected components of X independently.

Thus, given a certain undirected graph G, you are supposed to calculating the value of stab .

Input consists of multiple cases.

The input will contain the description of several graphs. For each graph, the description consist of an integer N for the number of nodes, an integer M for the number of edges, and M pairs of integers for edges (3<=N,M<=5000).

Please note that the endpoints of edge is marked in the range of [0,N-1], and input cases ends with EOF.

For each graph in the input, you should output the value of  stab.

4 5

0 1

1 2

2 3

3 0

0 2

2

#include <stdio.h>

#include <algorithm>

#include <string.h>

#include <iostream>

using namespace std;

const int MAXN = ;

const int MAXM = ;

struct Edge

{

    int to,next;

}edge[MAXM];

int head[MAXN],tot;

int Low[MAXN],DFN[MAXN],Stack[MAXN];

int Index,top;

bool Instack[MAXN];

bool cut[MAXN];

int add_block[MAXN];

void addedge(int u,int v)

{

    edge[tot].to = v;edge[tot].next = head[u];head[u] = tot++;

}

int subindex;

void Tarjan(int u,int pre)

{

    int v;

    DFN[u] = Low[u] = ++Index;

    Stack[top++] = u;

    Instack[u] = true;

    int son = ;

    for(int i = head[u];i != -;i = edge[i].next)

    {

        v = edge[i].to;

        if(v == pre)continue;

        if(v == subindex)continue;

        if(!DFN[v])

        {

            son++;

            Tarjan(v,u);

            if(Low[u] > Low[v])Low[u] = Low[v];

            if(u != pre && Low[v] >= DFN[u])

            {

                cut[u] = true;

                add_block[u]++;

            }

        }

        else if(Instack[v] && Low[u] > DFN[v])

            Low[u] = DFN[v];

    }

    if(u == pre && son > )cut[u] = true;

    if(u == pre )add_block[u] = son - ;

    Instack[u] = false;

    top--;

}

int solve(int N)

{

    memset(DFN,,sizeof(DFN));

    memset(Instack,false,sizeof(Instack));

    memset(add_block,,sizeof(add_block));

    memset(cut,false,sizeof(cut));

    Index = top = ;

    int cnt = ;

    int ans = ;

    for(int i = ;i < N;i++)

        if(i != subindex &&!DFN[i])

        {

             Tarjan(i,i);

             cnt++;

        }

    for(int i = ;i < N;i++)

        if(i != subindex)

            ans = max(ans,cnt + add_block[i]);

    return ans;

}

void init()

{

    tot = ;

    memset(head,-,sizeof(head));

}

int main()

{

    int n,m;

    while(scanf("%d%d",&n,&m)==)

    {

        init();

        int u,v;

        while(m--)

        {

            scanf("%d%d",&u,&v);

            addedge(u,v);

            addedge(v,u);

        }

        int ans = ;

        for(int i = ;i < n;i++)

        {

            subindex = i;

            ans = max(ans,solve(n));

        }

        printf("%d\n",ans);

    }

    return ;

}