// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

vector<int> G[N];

int delv, delu;

int n, m, x, y, d[N], fa[N], dp[N], q[N];

void dfs(int x, int fx) {

    d[x] = d[fx] + 1;

    fa[x] = fx;

    dp[x] = d[x] % 2 ? 1 : -1;

    for (int y : G[x]) {

        if (y == fx) continue;

        if (d[y]) {

            delv = y;

            delu = x;

            continue;

        }

        dfs(y, x);

        dp[x] += dp[y];

    }

}

void SolveTree() {

    if (dp[1]) {

        puts("-1");

        return;

    }

    int ans = 0;

    for (int i = 1; i <= n; i++) ans += abs(dp[i]);

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

}

void SolveOdd() {

    if (dp[1] % 2) {

        puts("-1");

        return;

    }

    int ans = 0, t = -dp[1] / 2;

    ans = abs(t);

    for (; delu; delu = fa[delu]) dp[delu] += t;

    for (; delv; delv = fa[delv]) dp[delv] += t;

    for (int i = 1; i <= n; i++) ans += abs(dp[i]);

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

}

void SolveEven() {

    if (dp[1]) {

        puts("-1");

        return;

    }

    int ans, top = 0, mid;

    for (; delv != delu; delv = fa[delv]) {

        q[++top] = dp[delv];

        d[delv] = 0;

    }

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

    mid = q[(top + 1) / 2];

    ans = abs(mid);

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

        if (d[i]) ans += abs(dp[i]);

    for (int i = 1; i <= top; i++) ans += abs(q[i] - mid);

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

}

int main() {

    scanf("%d%d", &n, &m);

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

        scanf("%d%d", &x, &y);

        G[x].push_back(y);

        G[y].push_back(x);

    }

    dfs(1, 0);

    if (m == n - 1)

        SolveTree();

    else if ((d[delv] - d[delu]) % 2)

        SolveEven();

    else

        SolveOdd(); 

}

// Faster C++ solution for the same problem (measured speedup: 1.3550206791188197x):
#include <bits/stdc++.h>

#define int long long

using namespace std;



int n,m,head[100005],nxt[200005],pnt[200005],E = 0,sz[100005],s,t,ans = 0,k[100005];

bool odd = 0;

std::vector<int> v;



void add_edge(int u,int v)

{

	pnt[E] = v;

	nxt[E] = head[u];

	head[u] = E++;

}



void dfs1(int u,int fa)

{

	for (int i = head[u]; i != -1; i = nxt[i])

	{

		int v = pnt[i];

		if (v == fa) continue;

		if (sz[v])

		{

			if (sz[v] == sz[u]) odd = 1;

			s = u;

			t = v;

		}

		else

		{

			sz[v] = -sz[u];

			dfs1(v,u);

		}

	}

}



void dfs2(int u,int fa)

{

	for (int i = head[u]; i != -1; i = nxt[i])

	{

		int v = pnt[i];

		if (v == fa) continue;

		if (v == s && u == t) continue;

		if (v == t && u == s) continue;

		dfs2(v,u);

		sz[u] += sz[v];

		k[u] += k[v];

	}

}



signed main()

{

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

	memset(sz,0,sizeof(sz));

	scanf("%lld%lld",&n,&m);

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

	{

		int u,v;

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

		add_edge(u,v);

		add_edge(v,u);

	}

	sz[1] = 1;

	dfs1(1,0);

	int sum = 0;

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

	{

		sum += sz[i];

	}

	if (m == n - 1)

	{

		if (sum)

		{

			puts("-1");

			return 0;

		}

	}

	else

	{

		if (odd)

		{

			if (sum & 1)

			{

				puts("-1");

				return 0;

			}

			ans += abs(sum >> 1);

			sz[s] -= sum >> 1;

			sz[t] -= sum >> 1;

		}

		else

		{

			if (sum)

			{

				puts("-1");

				return 0;

			}

			k[s] = 1;

			k[t] = -1;

		}

	}

	dfs2(1,0);

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

	{

		if (k[i]) v.push_back(k[i] * sz[i]);

		else ans += abs(sz[i]);

	}

	v.push_back(0);

	sort(v.begin(),v.end());

	int len = v.size();

	int mid = v[(len + 1) >> 1];

	for (int i = 0; i < len; i++)

	{

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

	}

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

	return 0;

}