import copy
import random

adj_list = {}
my_list = []
back_edge = {}
bi_con = []
articulation_node = []


def add_node(node):
    if node not in my_list:
        my_list.append(node)


def add_edge(node1, node2, edge):
    temp = []
    if node1 in my_list and node2 in my_list:
        if node1 not in edge:
            temp.append(node2)
            edge[node1] = temp
        elif node1 in edge:
            temp.extend(edge[node1])
            temp.append(node2)
            edge[node1] = sorted(temp)


def original_dfs(my_graph, starting_node):
    stack, result = [starting_node], []
    while stack:
        node = stack.pop()
        if node in result:
            continue
        result.append(node)
        if node in my_graph:
            for n in my_graph[node]:
                stack.append(n)
    return result


# def bi_dfs(my_graph, starting_node):
#     stack, result = [starting_node], []
#     while stack:
#         node = stack.pop()
#         if node in result:
#             continue
#         result.append(node)
#         if node in my_graph:
#             for n in reversed(my_graph[node]):
#                 stack.append(n)
#     return result


def find_dfs_edges():
    idx = 0
    while idx < len(res) - 1:
        nod1 = res[idx]
        nod2 = res[idx + 1]
        if nod2 in adj_list[nod1]:
            add_edge(nod1, nod2, dfs_edge)
            # add_edge(nod2, nod1, dfs_edge)
        else:
            for nod3 in res[0:idx]:
                if nod2 in adj_list[nod3]:
                    add_edge(nod3, nod2, dfs_edge)
                    # add_edge(nod2, nod3, dfs_edge)
        idx += 1


# def find_back_edges():
#     for nod in adj_list:
#         for edge in adj_list[nod]:
#             if edge not in dfs_edge[nod]:
#                 add_edge(nod, edge, back_edge)


def graph():
    for node in adj_list:
        print(node, " ---> ", [i for i in adj_list[node]])


def graph1():
    for node in dfs_edge:
        print(node, " ---> ", dfs_edge[node])


def graph2():
    for node in back_edge:
        print(node, " ---> ", back_edge[node])


def read():
    n, m = [int(x) for x in f.readline().split()]
    for i in range(1, n + 1):
        add_node(i)
    for i in range(m):
        x, y = [int(z) for z in f.readline().split()]
        add_edge(x, y, adj_list)
        add_edge(y, x, adj_list)
    return n, m


def remove_key(dic, delete_value):
    new_dic = copy.deepcopy(dic)
    for nodes in dic.keys():
        if nodes == delete_value:
            del new_dic[nodes]
    for edges in new_dic.values():
        if delete_value in edges:
            edges.remove(delete_value)
    return new_dic


def find_articulation_node():
    visit = []
    connected = 0
    for nod in my_list:
        if nod not in visit:
            connected += 1
            result_dfs = original_dfs(adj_list, nod)
            for each_node in result_dfs:
                visit.append(each_node)
        visit_new = []
        connected_new = 0
        new_list = copy.deepcopy(my_list)
        new_list.remove(nod)
        new_adj_list = remove_key(adj_list, nod)
        for nod2 in new_list:
            if nod2 not in visit_new:
                connected_new += 1
                result_dfs = original_dfs(new_adj_list, nod2)
                for each_node in result_dfs:
                    visit_new.append(each_node)
        if connected != connected_new:
            articulation_node.append(nod)


f = open("biconex.in", "r")
f_out = open("biconex.out", "w")
N, M = read()
dfs_edge = {}
start = random.randint(1, N)
# print(start)
res = original_dfs(adj_list, 1)


find_dfs_edges()
# find_back_edges()
find_articulation_node()
print(len(articulation_node)+1)

# find_bi_comp = set()
# art_count = 0

# for current in articulation_node:
#
#     next = dfs_edge[current]
#     find_bi_comp.add(start_node)
#     find_bi_comp.add(end_node[0])
#     if end_node[0] in articulation_node:
#         bi_con.append(sorted(list(find_bi_comp)))
#         find_bi_comp = set()
#     elif end_node[0] not in dfs_edge:
#         bi_con.append(sorted(list(find_bi_comp)))
#         find_bi_comp = set()
#
# print(len(bi_con))
# for comp in bi_con:
#     print(comp)