#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>



typedef struct vertex{

	int id;

	struct arch* arches;

	struct arch* last;

	struct vertex* last_pop;

}vertexT;



typedef struct arch{

	struct vertex* connects;

	struct arch* next;

}archT;



typedef struct graph{

	struct vertex* vertices;

}graphT;



typedef struct stackElement{

	struct vertex* vertex;

}stackE;



typedef struct stackPile{

	int top;

	struct stackElement* contents;

}stackP;

typedef struct fluxTable{
	int** flux;
}fluxT;





void stack_init(stackP* stack, int size){

	stackE* contents = (stackE*)malloc(sizeof(stackE) * size);

	stack->contents=contents;

	stack->top=-1;

}



void push(stackP* stack, vertexT* v){

	stack->contents[++stack->top].vertex=v;

}



vertexT* pop(stackP* stack){

	return stack->contents[stack->top--].vertex;

}

void stack_clean(stackP* stack){
	stack->top=-1;
}

int is_empty(stackP* stack){
	if(stack->top==-1)
		return 1;
	return 0;
}



void graph_init(graphT* graph, int n){

	vertexT* vertices=(vertexT*)malloc(sizeof(vertexT) * n);

	graph->vertices=vertices;

}

void flux_init(int** flux, int n){
	flux=(int**)malloc(sizeof(int*) * n);
	int i, j;
	for(i=0; i<n; i++){
		flux[i]=(int*)malloc(sizeof(int) * n);
		for(j=0; j<n; j++)
			flux[i][j]=0;
	}
}



void add_adjacency(graphT* graph, int origin, int destination){

	archT* arch=(archT*)malloc(sizeof(archT));

	arch->next=NULL;

	arch->connects=&graph->vertices[destination];



	vertexT* v=&graph->vertices[origin];

	if(v->arches!=NULL){

		v->last->next=arch;

		v->last=arch;

	}

	else{

		v->arches=arch;

		v->last=arch;

	}

}


int bfs(graphT* graph, int s, int t, int** flux, int n_vertex, stackP* stack, int* parents){
	int i;
	for(i=0;i<n_vertex;i++)
		parents[i]=-1;
	parents[s]=-2;
	stack_clean(stack);
	push(stack, &graph->vertices[s]);
	archT* arch;
	vertexT *u, *v;
	while(!is_empty(stack)){
		u= pop(stack);
		arch= u->arches;
		while(arch!=NULL){
			v=arch->connects;
			if(flux[u->id][v->id]==0 || parents[v->id]==-1){
				parents[v->id]=u->id;
				if(v->id != t)
					push(stack, v);
				else
					return 1;
			}
		}
	}
	return 0;
}


int edmondsKarp(graphT* graph, int s, int t, int n_vertex, stackP* stack, int** flux){
	int flow=0;
	int* parents = malloc(sizeof(int)*n_vertex);
	int m;
	vertexT *v, *u;
	while(1){
		m=bfs(graph, s, t, flux, n_vertex, stack, parents);
		if(!m)
			break;
		flow++;
		v=&graph->vertices[t];
		while(v->id != s){
			u=&graph->vertices[parents[v->id]];
			flux[u->id][v->id]++;
			flux[v->id][u->id]--;
			v=u;
		}
	}
	return flow;
}



int main(int argc, char * argv[]) {

	int n_vertex, n_arch, h;

	stackP* stack=malloc(sizeof(stackP*));

	graphT* graph=malloc(sizeof(graphT*));
	int** flux=NULL;




	if(scanf("%d %d\n", &n_vertex, &n_arch) ==0)

		return 0;



	flux_init(flux, n_vertex);

	graph_init(graph, n_vertex);

	stack_init(stack, n_vertex);



	int i, x, y;

	for(i=0;i<n_arch;i++){



		if(scanf("%d %d\n", &x, &y)==0)

			return 0;



		add_adjacency(graph, x, y);
		add_adjacency(graph, y, x);

	}






	return 0;

}