#include <iostream>

 #include <cstdio>

 #include <algorithm>

 #include <queue>

 #include <vector>

 using namespace std;

 #define pb push_back

 const int N = (int)2e5+;

 const int M = (int)1e6+;

 int n,m,bridge,tot,tim,top,scc;

 int head[N],dfn[N],low[N],s[N],scc_no[N],vis[N];

 struct node{

     int to;

     int nxt;

 }e[M << ];

 vector<int> g[N];//新图

 vector<int> poi;//存单个连通图包含的点

 void init(){

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

         head[i] = -;

         dfn[i] = ;

         g[i].clear();

     }

     bridge = tot = tim = top = scc = ;

 }

 inline void add(int u,int v){

     e[tot].to = v;

     e[tot].nxt = head[u];

     head[u] = tot++;

 }

 //tarjan缩点

 void tarjan(int now,int pre){

     poi.pb(now);//存下这个连通图包含的点

     dfn[now] = low[now] = ++tim;

     s[top++] = now;

     int to,pre_cnt = ;

     for(int o = head[now]; ~o; o = e[o].nxt){

         to = e[o].to;

         if(to == pre && pre_cnt == ) { pre_cnt = ; continue; }

         if(!dfn[to]){

             tarjan(to,now);

             low[now] = min(low[now],low[to]);

             if(dfn[now] < low[to]) ++bridge;

         }else low[now] = min(low[now],dfn[to]);

     }

     if(dfn[now] == low[now]){

         int x;

         ++scc;

         do{

             x = s[--top];

             scc_no[x] = scc;

         }while(now != x);

     }

 }

 //对poi中的那些点新建一个图

 void rebuild(){

     int to,now;

     for(int i = ; i < (int)poi.size(); ++i){

         now = poi[i];

         for(int o = head[now]; ~o; o = e[o].nxt){

            to = e[o].to;

            if(scc_no[now] == scc_no[to]) continue;

            g[scc_no[now]].pb(scc_no[to]);  g[scc_no[to]].pb(scc_no[now]);

         }

     }

 }

 void dfs(int now,int pre,int deep){

     vis[now] = deep;

     int to;

     for(int i = ; i < (int)g[now].size(); ++i){

         to = g[now][i];

         if(to == pre || to == now || vis[to]) continue;

         dfs(to,now,deep+);

     }

 }

 void test01(){

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

         printf("%d 属于scc = %d\n",i,scc_no[i]);

 }

 void solve(){

     int max_deep = ,_deep = ;

     int u;

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

         if(!dfn[i]){

             poi.clear();//清空上个连通图中的点

             tarjan(i,i);

             rebuild();//poi中的点重建图

             dfs(poi[],poi[],);

             _deep = ;

             for(int i = ; i < poi.size(); ++i){

                 if(_deep < vis[poi[i]]){ _deep = vis[poi[i]]; u = poi[i]; }

                 vis[poi[i]] = ; //这里别忘了初始化  不然下次dfs会出错

             }

             dfs(u,u,);

             for(int i = ; i < poi.size(); ++i){

                 _deep = max(_deep,vis[poi[i]]);

                 vis[poi[i]] = ;//这里别忘了初始化  不然下组数据的dfs会出错

             }

             max_deep = max(max_deep,_deep);//对每个连通图跑两次dfs求树的直径，取max

         }

     }

 //    cout << bridge << "   " << max_deep << endl;

     printf("%d\n",bridge - max_deep +);

 }

 int main(){

     int u,v;

     while(~scanf("%d%d",&n,&m) && (n+m)){

         init();

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

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

             add(u,v); add(v,u);

         }

         solve();

     }

     return ;

 }

4 4
1 2
1 3
1 4
2 3

11 12
1 2
1 3
3 2
3 4
4 5
4 6
6 7
7 8
7 9
8 9
8 11
9 10

6 7
1 2
1 3
2 3
3 4
4 5
4 6
5 6

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