#include<iostream>

 #include<cstdio>

 #include<string.h>

 #include<algorithm>

 #include<queue>

 #include<vector>

 using namespace std;

 const int maxn=1e4+;

 struct node

 {

     int v,cut,nxt;

 }G[*maxn];

 int cnt;

 int head[maxn];

 int Stack[maxn];

 int instack[maxn];

 int low[maxn],dfn[maxn];

 int belong[maxn],du[maxn];

 int block,index;

 int bridge,top;

 void init()

 {

     cnt=;

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

 }

 void build(int u,int v)

 {

     G[cnt].v=v;G[cnt].nxt=head[u];G[cnt].cut=;head[u]=cnt++;

 }

 void tarjan(int u,int pre)

 {

     low[u]=dfn[u]=++index;

     Stack[top++]=u;

     instack[u]=;

     int v;

     for(int i=head[u];i!=-;i=G[i].nxt){

         v=G[i].v;

         if(pre==v) continue;

         if(!dfn[v]){

             tarjan(v,u);

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

             if(low[v]>dfn[u]){

                 bridge++;

                 G[i].cut=;

                 G[i^].cut=;

             }

         }

         else if(low[u]>dfn[v]&&instack[v]) low[u]=dfn[v];

     }

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

         block++;

         do{

             v=Stack[--top];

             instack[v]=;

             belong[v]=block;

         }while(v!=u);

     }

 }

 void solve(int n)

 {

     int i,j;

     int index=;

     bridge=;

     top=;

     block=;

     memset(low,,sizeof(low));

     memset(dfn,,sizeof(dfn));

     memset(belong,,sizeof(belong));

     memset(instack,,sizeof(instack));

     tarjan(,);

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

         for(j=;j!=-;j=G[j].nxt){

             if(G[j].cut)

             du[belong[i]]++;

         }

     }

     int ans=;

     for(i=;i<=block;i++){

         if(du[i]==)

         ans++;

     }

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

 }

 int main()

 {

     int n,m;

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

         init();

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

             int u,v;

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

             build(u,v);

             build(v,u);

         }

         solve(n);

     }

     return ;

 }