#pragma comment(linker, "/STACK:1024000000,1024000000")

 #include <iostream>

 #include <vector>

 #include <queue>

 #include <string.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <stack>

 using namespace std;

 const int maxn = ;

 bool vis[];

 struct edge

 {

     int v,next;

     edge()

     {

         next = -;

     }

 }edges[maxn*-];

 struct ed

 {

     int u,v;

 }e[maxn*-];

 int dfn[],low[],belong[];

 bool inst[];

 int g[maxn];

 vector<int>ng[maxn];

 stack<int>st;

 int bcnt,cnt,time;

 void init(int n)

 {

     int i;

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

     g[i] = -;

     time = ;bcnt = cnt = ;

     return ;

 }

 void addedge(int u,int v,int val)

 {

     struct edge o;

     edges[cnt].v = v;

     edges[cnt].next = g[u];

     g[u] = cnt;

     cnt++;

     return ;

 }

 void tarjan(int i)

 {

     int j;

     dfn[i] = low[i] = ++time;

     inst[i] = ;

     st.push(i);

     for(j = g[i];j != -;j = edges[j].next)

     {

         if(vis[j]) continue;

         vis[j] = vis[j^] = ;

         int v;

         v = edges[j].v;

         if(!dfn[v])

         {

             tarjan(v);

             low[i] = min(low[i],low[v]);

         }

         else if(inst[v])

         low[i] = min(low[i],dfn[v]);

     }

     int k;

     if(dfn[i] == low[i])

     {

         bcnt++;

         do

         {

             k = st.top();

             st.pop();

             inst[k] = ;

             belong[k] = bcnt;

         }

         while(k != i);

     }

 }

 void tarjans(int n)

 {

     int i;

     bcnt = time = ;

     while(!st.empty())st.pop();

     memset(dfn,,sizeof(dfn));

     memset(inst,,sizeof(inst));

     memset(belong,,sizeof(belong));

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

     if(!dfn[i])tarjan(i);

 }

 struct node

 {

     int s,point;

 };

 struct node bfs(int s)

 {

     int i;

     for(i = ;i <= bcnt;i++)

     vis[i] = ;

     queue <struct node>q;

     struct node p;

     p.s = ;p.point = s;

     q.push(p);

     vis[s] = ;

     struct node max;

     max.s = ;

     while(!q.empty())

     {

         struct node now,temp;

         now = q.front();

         q.pop();

         for(i = ;i < ng[now.point].size();i++)

         {

             int v = ng[now.point][i];

             temp.s = now.s+;

             temp.point = v;

             if(!vis[v])

             {

                 vis[v] = ;

               //  cout<<v<<"***"<<endl;

                 if(max.s < temp.s)

                 max = temp;

                 q.push(temp);

             }

         }

     }

     return max;

 }

 int main()

 {

     int n,m;

     //freopen("in.txt","r",stdin);

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

     {

         int a,b,i;

         init(n);

         memset(vis,,sizeof(vis));

         for(i = ;i < m;i++)

         {

             scanf("%d %d",&e[i].u,&e[i].v);

             addedge(e[i].u,e[i].v,);

             addedge(e[i].v,e[i].u,);

         }

         tarjans(n);

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

         {

             ng[i].clear();

         }

         for(i = ;i < m;i++)

         {

             if(belong[e[i].u] == belong[e[i].v])

             continue;

             ng[belong[e[i].u]].push_back(belong[e[i].v]);

             ng[belong[e[i].v]].push_back(belong[e[i].u]);

         }

         struct node max;

         max = bfs();

         max = bfs(max.point);

         printf("%d\n",bcnt-max.s-);

     }

     return ;

 }