#include <cstdlib>
#include <map>
#include <set>
#include <string>
#include <stdio.h>
#include <ctype.h>
#include <iostream>
#include <fstream>
#include <math.h>
#include <sstream>
#include <vector>
#include <functional>
#include <algorithm> 
#include <stack>
#include <queue>
using namespace::std;
const int maxN = 1000 + 10;
const int maxM = 1000000 + 10;
bool edge[maxN][maxN], del[maxN], inSt[maxN];
int rEdge[maxN][maxN];
int N, M, ans, dfn[maxN], low[maxN], mCount, colour[maxN];


void mClear(){
	memset(edge, true, sizeof(edge));
	memset(rEdge, 0, sizeof(rEdge));
	memset(del, true, sizeof(del));
	memset(dfn,0,sizeof(dfn) );
}

struct ed{
	int u, v;
	ed(){

	}
	ed(int x, int y){
		u = x;
		v = y;
	}
};
stack<ed> mStack;

bool isOk(int index){
	int c = 0;
	queue<int> myQ;
	myQ.push(index);
	bool qVis[maxN];
	memset(qVis, false, sizeof(qVis));
	while (!myQ.empty()){
		int cur = myQ.front();
		myQ.pop();
		qVis[cur] = true;
		c= c^1;
		colour[cur]=c;
		for (size_t i = 1; i <= rEdge[cur][0]; i++)
		{
			int v = rEdge[cur][i];
			if (inSt[v]){
				if (colour[v] == colour[cur])return true;
				if (!qVis[v]){
					myQ.push(v);
				}
			}
		}
	}
	return false;
}

void check(int u, int v){
	memset(colour, -1, sizeof(colour));
	memset(inSt, false, sizeof(inSt));
	ed t;
	do{
		t=mStack.top();
		mStack.pop();
		inSt[t.u] = true; inSt[t.v] = true;
	} while (t.u!=u&&t.v!=v);
	if (isOk(t.u)){
		for (size_t i = 1; i <= N; i++)
		{
			if (inSt[i]){
				del[i] = false;
			}
		}
	};
}

void dfs(int fa, int index){
	dfn[index] = low[index] = mCount++;
	for (size_t i = 1; i <= rEdge[index][0]; i++)
	{
		int v = rEdge[index][i];
		if (v == fa)continue;
		mStack.push(ed(index,v));
		if (!dfn[v]){
			dfs(index,v);	
			low[index] = min(low[index], low[v]);
			if (low[v] >= dfn[index]){
				check(index,v);
			}
		}
		else if (dfn[v] < low[index]){
			low[index] = dfn[v];
		}
	}
}


int main(){
	while (scanf("%d%d", &N, &M) && N != 0){
		mCount = 1;
		mClear();
		for (size_t i = 0; i < M; i++)
		{
			int u, v;
			scanf("%d%d", &u, &v);
			edge[u][v] = false;
			edge[v][u] = false;	
		}
		for (size_t i = 1; i <= N; i++)
		{
			for (size_t j = 1; j <= N; j++){
				if (edge[i][j]&&i!=j){
					rEdge[i][0]++;
					int con = rEdge[i][0];
					rEdge[i][con] = j;
				}
			}
		}
		for (size_t i = 1; i <= N; i++)
		{
			if (!dfn[i])dfs(i,i);

		}
		int ans = 0;
		for (size_t i = 1; i <= N; i++)
		{
			if (del[i])ans++;
			while (!mStack.empty()){
				mStack.pop();
			}
		}
		cout << ans << endl;
	}
}