#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<stack>
#include<queue>
#include<cstdlib>

using namespace std;
const int N=200010;
struct node
{
    int next,to;
}edge[N*10],Edge[N*10];
int Stack[N],low[N],dfn[N],belong[N],sum,Time,top;
int Head[N],head[N],ans,Ans,Max,dis[N],vis[N],End;

void Inn()
{
    memset(Stack,0,sizeof(Stack));
    memset(low,0,sizeof(low));
    memset(dfn,0,sizeof(dfn));
    memset(Head,-1,sizeof(Head));
    memset(head,-1,sizeof(head));
    memset(belong,0,sizeof(belong));
    memset(dis,0,sizeof(dis));
    sum=Time=top=ans=Ans=Max=End=0;
}

void add(int from,int to)
{
    edge[ans].to=to;
    edge[ans].next=head[from];
    head[from]=ans++;
}

void Add(int from,int to)
{
    Edge[Ans].to=to;
    Edge[Ans].next=Head[from];
    Head[from]=Ans++;
}

void Tarjin(int u,int f)
{
    int k=0,v;
    low[u]=dfn[u]=++Time;
    Stack[top++]=u;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        v=edge[i].to;
        if(v==f && !k)
        {
            k++;
            continue;
        }
        if(!dfn[v])
        {
            Tarjin(v,u);
            low[u]=min(low[u],low[v]);
        }
        else 
            low[u]=min(low[u],dfn[v]);
    }
    if(dfn[u]==low[u])
    {
        sum++;
        do
        {
            v=Stack[--top];
            belong[v]=sum;
        }while(v!=u);
    }
}

void dfs(int s)
{
    queue<int>Q;
    int u,v;
    memset(vis,0,sizeof(vis));
    dis[s]=0;
    vis[s]=1;
    Q.push(s);
    while(Q.size())
    {
        u=Q.front();
        Q.pop();
        for(int i=Head[u];i!=-1;i=Edge[i].next)
        {
            v=Edge[i].to;
            if(!vis[v])
            {
                vis[v]=1;
                dis[v]=dis[u]+1;
                Q.push(v);
                if(Max<dis[v])
                {
                    Max=dis[v];
                    End=v;
                }
            }
        }
    }
}

void slove(int n)
{
    int SUM=0;
    Tarjin(1,0);
    for(int i=1;i<=n;i++)
    {
        for(int j=head[i];j!=-1;j=edge[j].next)
        {
            int u=belong[i];
            int v=belong[edge[j].to];
            if(u!=v)
            {
                Add(u,v);
                SUM++;
            }
        }
    }
    SUM/=2;
    dfs(1);
    dfs(End);
    printf("%d\n",SUM-Max);
}
int main()
{
    int n,m,a,b;
    while(scanf("%d %d",&n,&m),n+m)
    {
        Inn();
        while(m--)
        {
            scanf("%d %d",&a,&b);
            add(a,b);
            add(b,a);
        }
        slove(n);
    }
    return 0;
}