#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<cmath>
using namespace std;

const int maxn=1e5+10;
int n,m,fa[maxn];
vector<int> g[maxn];

namespace tree{
	int cnt[maxn][2];
	long long ans;
	void dfs(int pos){
		++cnt[pos][0];
		for(int i=0;i<g[pos].size();++i)
			if(g[pos][i]!=fa[pos]){
				fa[g[pos][i]]=pos;
				dfs(g[pos][i]);
				ans+=abs(cnt[g[pos][i]][0]-cnt[g[pos][i]][1]);
				cnt[pos][0]+=cnt[g[pos][i]][1];
				cnt[pos][1]+=cnt[g[pos][i]][0];
			}
	}
	int main(){
		for(int i=1,u,v;i<=m;++i){
			cin>>u>>v;
			g[u].push_back(v);
			g[v].push_back(u);
		}
		dfs(1);
		if(cnt[1][0]==cnt[1][1])
			cout<<ans<<endl;
		else
			cout<<-1<<endl;
	}
}
namespace cycle{
	int uu,vv,c[maxn];
	bool odd;
	int findfa(int x){
		if(fa[x]==x)
			return x;
		return fa[x]=findfa(fa[x]);
	}
	void dfs(int pos){
		for(int i=0;i<g[pos].size();++i)
			if(!c[g[pos][i]]){
				c[g[pos][i]]=3-c[pos];
				dfs(g[pos][i]);
			}
	}
	void init(){
		for(int i=1;i<=n;++i)
			fa[i]=i;
		for(int i=1,u,v;i<=m;++i){
			cin>>u>>v;
			if(findfa(u)!=findfa(v)){
				fa[findfa(u)]=findfa(v);
				g[u].push_back(v);
				g[v].push_back(u);
			}
			else
				uu=u,vv=v;
		}
		c[1]=1;
		dfs(1);
		if(c[uu]==c[vv])
			odd=true;
	}
}
namespace oddcycle{
#define uu cycle::uu
#define vv cycle::vv
	int cnt[maxn][2],type[maxn],cnt0,cnt1;
	long long ans;
	void dfs1(int pos){
		cnt[pos][type[pos]]=1;
		if(type[pos])++cnt1;
		else ++cnt0;
		for(int i=0;i<g[pos].size();++i)
			if(g[pos][i]!=fa[pos]){
				fa[g[pos][i]]=pos;
				type[g[pos][i]]=type[pos]^1;
				dfs1(g[pos][i]);
			}
	}
	void dfs2(int pos){
		for(int i=0;i<g[pos].size();++i)
			if(g[pos][i]!=fa[pos]){
				dfs2(g[pos][i]);
				cnt[pos][0]+=cnt[g[pos][i]][0];
				cnt[pos][1]+=cnt[g[pos][i]][1];
				ans+=abs(cnt[g[pos][i]][0]-cnt[g[pos][i]][1]);
			}
	}
	int main(){
		fa[1]=0;
		dfs1(1);
		if(cnt0%2!=cnt1%2){
			puts("-1");
			return 0;
		}
		cnt[uu][1]+=(cnt0-cnt1)/2;
		cnt[vv][1]+=(cnt0-cnt1)/2;
		ans=abs((cnt1-cnt0)/2);
		dfs2(1);
		printf("%lld\n",ans);
	}
}
namespace evencycle{
#define uu cycle::uu
#define vv cycle::vv
	long long cnt[maxn][2],res,ans=1e18;
	void dfs(int pos,int type){
		++cnt[pos][type];
		for(int i=0;i<g[pos].size();++i)
			if(g[pos][i]!=fa[pos]){
				fa[g[pos][i]]=pos;
				dfs(g[pos][i],type^1);
				cnt[pos][0]+=cnt[g[pos][i]][0];
				cnt[pos][1]+=cnt[g[pos][i]][1];
				res+=abs(cnt[g[pos][i]][0]-cnt[g[pos][i]][1]);
			}
	}
	int main(){
		fa[1]=0;
		memset(cnt,0,sizeof(cnt));
		dfs(1,0);
		if(cnt[1][0]!=cnt[1][1]){
			puts("-1");
			return 0;
		}
		int l=-1e6,r=1e6;
		while(l<r){
			int midl=floor((2*l+r)/3.0),midr=ceil((l+2*r)/3.0);
			long long resl,resr;
			res=abs(midl);
			memset(cnt,0,sizeof(cnt));
			cnt[uu][1]=midl;cnt[vv][1]=-midl;
			dfs(1,0);
			resl=res;
			res=abs(midr);
			memset(cnt,0,sizeof(cnt));
			cnt[uu][1]=midr;cnt[vv][1]=-midr;
			dfs(1,0);
			resr=res;
			if(resl<=resr){
				r=midr-1;
				if(ans>resl)
					ans=resl;
			}
			else{
				l=midl+1;
				if(ans>resr)
					ans=resr;
			}
		}
		printf("%lld\n",ans);
	}
}

int main(){
	ios::sync_with_stdio(false);
	cin>>n>>m;
	if(n>m)
		tree::main();
	else{
		cycle::init();
		if(cycle::odd)
			oddcycle::main();
		else
			evencycle::main();
	}
	return 0;
}

Measured memory_bytes: 16896