def dfs(node, visited, adj_list):
    visited[node] = True
    
    k = 0
    cuts = 0
    for neigh in adj_list[node]:
        if not visited[neigh]:
            count, child_cuts = dfs(neigh, visited, adj_list)
            cuts += child_cuts
            if count % 2 == 0:
                cuts += 1
            else:
                k += count
            
    return (k + 1, cuts)
    

def evenForest(t_nodes, t_edges, t_from, t_to):
    adj_list = [[] for _ in range(t_nodes + 1)]
    
    for i in range(t_edges):
        adj_list[t_from[i]].append(t_to[i])
        adj_list[t_to[i]].append(t_from[i])

        
    visited = [False] * (t_nodes + 1)

    count, cuts = dfs(1, visited, adj_list)
    
    return cuts

def evenForest(t_nodes, t_edges, t_from, t_to):
    kq = 0
    d = {}
    r = {}
    p = []

    for i in range(t_edges):
        if t_to[i] not in d:
            d[t_to[i]] = [t_from[i]]
            r[t_to[i]] = 1
        else:
            d[t_to[i]].append(t_from[i])

    for i in d:
        j = 0
        while j < len(d[i]):
            if d[i][j] not in d:
                d[i].remove(d[i][j])
                r[i] += 1
            else:
                j += 1
        if not d[i]:
            p.append(i)

    for i in p:
        del d[i]

    def dfs(node, visited, graph):
        visited.add(node)
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                dfs(neighbor, visited, graph)
        return visited

    for i in d:
        for j in d[i]:
            vi = set()
            vi = dfs(j, vi, d)
            t = 0
            for j in vi:
                t += r[j]
            if not 1 & t:
                kq += 1

    return kq

int descendents(int current, const vector<vector<int>>& edges, int& components, vector<bool>& visited, vector<int>& size) {
    visited[current] = true;
    for (auto e : edges[current]) {
        if (!visited[e]) {
            size[current] = size[current] + descendents(e, edges, components, visited, size);;
        }
    }
    ++size[current];
    if (current != 1 and size[current] % 2 == 0) {
        ++components;
        return 0;
    }
    else return size[current];
}

int evenForest(int N, int E, const vector<vector<int>>& edges) {
    int components = 0;
    vector<bool> visited(N+1);
    vector<int> size(N+1);
    descendents(1, edges, components, visited, size);    
    return components;
}

def treeLength(tree, node, count):
    if tree.get(node):
        for n in tree[node]:
            count = treeLength(tree, n, count + 1)
    return count

def evenForest(t_nodes, t_edges, t_from, t_to):
    graph = {}
    for i in range(t_edges):
        if t_to[i] in graph:
            graph[t_to[i]].append(t_from[i])
        else:
            graph[t_to[i]] = [t_from[i]]
    count = 0
    for e in graph:
        for n in graph[e]:
            length = treeLength(graph, n, 1)
            if not length % 2:
                count += 1
    return count

#!/bin/python3

import math
import os
import random
import re
import sys


from collections import defaultdict


def _compute_edges_and_n_nodes(visit_node: int, children: dict, visited: set) -> (int, int):
    """
    Returns how many edges can remove this subtree and how many nodes it contains
    """
    # As children dict is bidirectional, we have to add nodes to visit in order to
    # avoid eternal loop
    visited.add(visit_node)
    
    # Exit case: Node is leaf, so it can not be a forest for its own
    if not len(children[visit_node]):
        return (0, 1)
        
    # We start counting nodes at 1 as we are assuming current node
    edges_to_remove, n_nodes = 0, 1
    for child in children[visit_node]:
        if child in visited:
            continue
        child_edges_to_remove, child_n_nodes = _compute_edges_and_n_nodes(child, children, visited)
        edges_to_remove += child_edges_to_remove
        n_nodes += child_n_nodes
        
    # If subtree is even, we add 1 edge to remove
    if not n_nodes % 2:
        edges_to_remove += 1
    return edges_to_remove, n_nodes


# Complete the evenForest function below.
def evenForest(t_nodes, t_edges, t_from, t_to):
    chldren = defaultdict(list)
    for n_from, n_to in zip(t_from, t_to):
        chldren[n_from].append(n_to)
        chldren[n_to].append(n_from)
    
    # We substract 1 to number of edges to remove because we don't want to count root
    return _compute_edges_and_n_nodes(1, chldren, set())[0] - 1


if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    t_nodes, t_edges = map(int, input().rstrip().split())

    t_from = [0] * t_edges
    t_to = [0] * t_edges

    for i in range(t_edges):
        t_from[i], t_to[i] = map(int, input().rstrip().split())

    res = evenForest(t_nodes, t_edges, t_from, t_to)

    fptr.write(str(res) + '\n')

    fptr.close()