// Original C++ solution (slower):
#include <algorithm>

#include <iostream>

#include <vector>

using namespace std;



const int MAXN = 100000 + 5;



int N, M;

vector<int> Adj[MAXN];

int fa[MAXN], col[MAXN], dep[MAXN];



bool hasCircle;

int circA, circB;



inline void addEdge(int u, int v)

{

	Adj[u].push_back(v);

	Adj[v].push_back(u);

}



void DFS(int cur)

{

	dep[cur] = dep[fa[cur]] + 1;

	col[cur] = (dep[cur] & 1 ? 1 : -1);



	for (int to : Adj[cur])

	{

		if (to == fa[cur])

			continue;

		if (dep[to])

		{

			if (!hasCircle)

				circA = cur, circB = to, hasCircle = true;

		}

		else

			fa[to] = cur, DFS(to), col[cur] += col[to];

	}

}



int solveAcyclic()

{

	if (col[1])

		return -1;



	int ret = 0;

	for (int i = 1; i <= N; i++)

		ret += abs(col[i]);

	return ret;

}



int solveOddCircle()

{

	if (col[1] & 1)

		return -1;



	int delta = -col[1] / 2, ret = abs(delta), cur;

	cur = circA;

	while (cur)

		col[cur] += delta, cur = fa[cur];

	cur = circB;

	while (cur)

		col[cur] += delta, cur = fa[cur];



	for (int i = 1; i <= N; i++)

		ret += abs(col[i]);

	return ret;

}



int solveEvenCircle()

{

	if (col[1])

		return -1;



	int circle[MAXN] =

	{ 0 }, top = 0;

	for (int cur = circA; cur != circB; cur = fa[cur])

		circle[++top] = col[cur], dep[cur] = 0;



	int mid = (top + 1) >> 1, delta, ret;

	nth_element(&circle[1], &circle[mid], &circle[top + 1]);

	delta = (circle[mid]), ret = abs(delta);



	for (int i = 1; i <= N; i++)

		if (dep[i])

			ret += abs(col[i]);

	for (int i = 1; i <= top; i++)

		ret += abs(circle[i] - delta);

	return ret;

}



int main()

{

	//printf("%d %d\n", 1 & 1, -1 & 1);

	fflush(stdout);



	scanf("%d%d", &N, &M);

	for (int i = 1; i <= M; i++)

	{

		int u, v;

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

		addEdge(u, v);

	}



	DFS(1);



	if (!hasCircle)

		printf("%d\n", solveAcyclic());

	else

	{

		if ((dep[circA] - dep[circB] + 1) & 1)

			printf("%d\n", solveOddCircle());

		else

			printf("%d\n", solveEvenCircle());

	}



	return 0;

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

// #define int long long

void read(int &x)

{

    int r = 0, ne = 1;

    char c;

    while (c < '0' || c > '9')

    {

        if (c == '-')

            ne = -1;

        c = getchar();

    }

    while (c >= '0' && c <= '9')

    {

        r = r * 10 + c - '0';

        c = getchar();

    }

    x = r * ne;

}

struct  Edge

{

    /* data */

    int i,nxt;

};

/* 链表 */

int h[100002],tot;

Edge e[200002];

inline void _add(int x,int y){

    e[++tot].i=y;

    e[tot].nxt=h[x];

    h[x]=tot;

    e[++tot].i=x;

    e[tot].nxt=h[y];

    h[y]=tot;

}

/* 输入 */

int n,m,x,y;

/* 偶环-求解 */

int s[100002],top,mid;

/* dfs */

bool odd;/* 奇环 */

int A,B;/* 环两个连接点 */

int w[100002];/* 点绿色权值(1,-1) */ /* 第二遍扫时存的是子树总权值 */

int k[100002];/* 偶环时标记多余边到LCA的点 */

int sum;/* 权值总和 */

long long ans;/* 答案 */

void dfs(int x,int fa){/* 染色 */

    for(int i=h[x];i;i=e[i].nxt){      

        int o=e[i].i;

        if(o==fa)continue;

        if(w[o]){

            if(w[o]==w[x])

                odd=true;

            A=x,B=o;

        }else{

            w[o]=-w[x];

            // sum+=w[o];

            dfs(o,x);

        }

    }

}

void Dfs(int x,int fa){/* 求解 */

    for(int i=h[x];i!=0;i=e[i].nxt){

        int o=e[i].i;

        if(o==fa||(o==A&&x==B)||(o==B&&x==A))continue;/* 排除基环树的干扰 */

        Dfs(o,x);

        w[x]+=w[o];

        k[x]+=k[o];

    }

}

signed main(){

    read(n),read(m);

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

        read(x),read(y);

        _add(x,y);

    }

    // if(n%2){

    //     puts("-1");

    //     return 0;

    // }

    w[1]=1;

    // sum=1;

    dfs(1,0);

    for(int i=1;i<=n;++i)sum+=w[i];    

    if(m+1==n)/* 树 */{

        if(sum){

            puts("-1");

           return 0;

        }

    }else{

        if(odd)/* 奇环 */{

            if(sum&1){

                puts("-1");

                return 0;

            }

            ans+=abs(sum>>1);

            w[A]-=sum>>1,w[B]-=sum>>1;

        }else/* 偶环 */{

            if(sum){

                puts("-1");

                return 0;

            }else 

                k[A]=1,k[B]=-1;

        }

    }

    Dfs(1,0);

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

        if(k[i])

            s[++top]=k[i]*w[i];

        else

            ans+=abs(w[i]);

    }

    s[++top]=0;

    sort(s+1,s+top+1);

    mid=s[(top+1)>>1];

    for(register int i=1;i<=top;++i)

        ans+=abs(s[i]-mid);

    printf("%lld\n",ans);

    return 0;

}

// Fastest known solution for this problem: