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

#include<map>

#include<queue>

#include<stack>

#include<cmath>

#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#define INF 1000000001

#define ll __int64

#define lson l,m,rt<<1

#define rson m+1,r,rt<<1|1

using namespace std;

const int MAXN = ;

struct node

{

    int to;

    int next;

    int vis;

}edge[ * ],a[ * ];

struct fnode

{

    int x;

    int val;

};

int n,m,ind,pre[MAXN],ins[MAXN],low[MAXN],dfn[MAXN],vis[MAXN],num[MAXN],fpre[MAXN];

int fp,len,p;

stack<int>s;

void Init()

{

    fp = ;

    ind = ;

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

    memset(num,,sizeof(num));

    memset(ins,,sizeof(ins));

    memset(pre,-,sizeof(pre));

    memset(vis,,sizeof(vis));

    memset(dfn,,sizeof(dfn));

    memset(low,,sizeof(low));

}

void add(int x,int y)

{

    edge[ind].to = y;

    edge[ind].vis = ;

    edge[ind].next = pre[x];

    pre[x] = ind ++;

}

void dfs(int rt,int k,int fa)

{

    s.push(rt);

    vis[rt] = ins[rt] = ;

    low[rt] = dfn[rt] = k;

    for(int i = pre[rt]; i != -; i = edge[i].next){

        int t = edge[i].to;

        if(edge[i].vis)continue;

        edge[i].vis = edge[i^].vis = ;

        //原来判断 fa != t 但是有重边的情况这种标记不行。

        if(!dfn[t]){

            dfs(t,k+,rt);

            low[rt] = min(low[rt],low[t]);

        }

        else{

            low[rt] = min(dfn[t],low[rt]);

        }

    }

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

        while(!s.empty()){

            int temp = s.top();

            s.pop();

            num[temp] = fp;

            if(temp == rt)break;

        }

        fp ++;

    }

}

void add_b(int x,int y)

{

    a[ind].to = y;

    a[ind].next = fpre[x];

    fpre[x] = ind ++;

}

void build(int rt)

{

    vis[rt] = ;

    for(int i = pre[rt]; i != -; i=edge[i].next){

        int t = edge[i].to;

        if(!vis[t]){

            if(num[t] != num[rt]){

                add_b(num[t],num[rt]);

                add_b(num[rt],num[t]);

            }

            build(t);

        }

    }

}

void bfs(int rt)

{

    queue<fnode>q;

    fnode temp;

    temp.val = ;

    temp.x = rt;

    vis[rt] = ;

    q.push(temp);

    while(!q.empty()){

        temp = q.front();

        q.pop();

        for(int i = fpre[temp.x]; i != -; i = a[i].next){

            int t = a[i].to;

            if(!vis[t]){

                fnode ft;

                ft.val = temp.val + ;

                ft.x = t;

                vis[t] = ;

                q.push(ft);

                if(ft.val > len){

                    len = ft.val;

                    p = ft.x;

                }

            }

        }

    }

}

int main()

{

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

        if(!n && !m)break;

        Init();

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

            int x,y;

            scanf("%d%d",&x,&y);

            add(x,y);

            add(y,x);

        }

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

            if(!dfn[i]){

                dfs(i,,-);

            }

        }

        memset(vis,,sizeof(vis));

        ind = ;

        memset(fpre,-,sizeof(fpre));

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

            if(!vis[i]){

                build(i);

            }

        }

        len = ;

        p = ;

        memset(vis,,sizeof(vis));

        bfs();

        len = ;

        memset(vis,,sizeof(vis));

        bfs(p);

        fp -= ;

        int ans = fp -  - len;

        //cout<<"fp = "<<fp<<" len = "<<len<<endl;

        cout<<(ans >  ? ans : )<<endl;

    }

    return ;

}