class UnionFind():

  def __init__(self, n):

    self.n = n

    self.parents = [-1] * n



  def find(self, x):

    if self.parents[x] < 0:

      return x

    else:

      self.parents[x] = self.find(self.parents[x])

      return self.parents[x]



  def union(self, x, y):

    x = self.find(x)

    y = self.find(y)



    if x == y:

      return



    if self.parents[x] > self.parents[y]:

      x, y = y, x



    self.parents[x] += self.parents[y]

    self.parents[y] = x



  def size(self, x):

    return -self.parents[self.find(x)]



  def same(self, x, y):

    return self.find(x) == self.find(y)



  def members(self, x):

    root = self.find(x)

    return [i for i in range(self.n) if self.find(i) == root]



  def roots(self):

    return [i for i, x in enumerate(self.parents) if x < 0]



  def group_count(self):

    return len(self.roots())



  def all_group_members(self):

    return {r: self.members(r) for r in self.roots()}



  def __str__(self):

    return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())



N, M = list(map(int, input().split()))



edges = [list(map(int, input().split())) for _ in range(M)]



rlt = 0



for i in range(M):

  uf = UnionFind(N+1)

  for j in range(M):

    if i == j:

      continue

    e = edges[j]

    uf.union(e[0],e[1])

  if min(uf.parents) > -N:

    rlt += 1

    

print(rlt)
from collections import deque



N, M = list(map(int, input().split()))



edges = [list(map(int, input().split())) for _ in range(M)]

od = [-1]*(N+1)

low = [-1]*(N+1)

pa = [0]*(N+1)

od[1] = 0

low[1] = 0

pa[1] = 1

ni = {i:[] for i in range(1,N+1)}



for i in range(M):

  ni[edges[i][0]].append(edges[i][1])

  ni[edges[i][1]].append(edges[i][0])



rlt = 0

h = deque([])

for i in ni[1]:

  h.append([1,i])



i = 0

while h:

  a = h.pop()

  if od[a[1]] > -1:

    if od[a[1]] < od[a[0]]:

      low[a[0]] = od[a[1]]

      c = a[0]

      while low[pa[c]] > od[a[1]]:

        low[pa[c]] = od[a[1]]

        c = pa[c]

  else:

    i += 1

    od[a[1]] = i

    low[a[1]] = i

    pa[a[1]] = a[0]

    for b in ni[a[1]]:

      if b == a[0]:

        continue

      h.append([a[1],b])

          

for i in range(2,N+1):

  if od[pa[i]] < low[i]:

    rlt += 1



print(rlt)

class UnionFind:
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())


N, M = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(M)]
rlt = 0
for i in range(M):
    uf = UnionFind(N + 1)
    for j in range(M):
        if i == j:
            continue
        e = edges[j]
        uf.union(e[0], e[1])
    if min(uf.parents) > -N:
        rlt += 1
print(rlt)

from collections import deque

N, M = list(map(int, input().split()))
edges = [list(map(int, input().split())) for _ in range(M)]
od = [-1] * (N + 1)
low = [-1] * (N + 1)
pa = [0] * (N + 1)
od[1] = 0
low[1] = 0
pa[1] = 1
ni = {i: [] for i in range(1, N + 1)}
for i in range(M):
    ni[edges[i][0]].append(edges[i][1])
    ni[edges[i][1]].append(edges[i][0])
rlt = 0
h = deque([])
for i in ni[1]:
    h.append([1, i])
i = 0
while h:
    a = h.pop()
    if od[a[1]] > -1:
        if od[a[1]] < od[a[0]]:
            low[a[0]] = od[a[1]]
            c = a[0]
            while low[pa[c]] > od[a[1]]:
                low[pa[c]] = od[a[1]]
                c = pa[c]
    else:
        i += 1
        od[a[1]] = i
        low[a[1]] = i
        pa[a[1]] = a[0]
        for b in ni[a[1]]:
            if b == a[0]:
                continue
            h.append([a[1], b])
for i in range(2, N + 1):
    if od[pa[i]] < low[i]:
        rlt += 1
print(rlt)

-class UnionFind: -    def __init__(self, n): -        self.n = n -        self.parents = [-1] * n - -    def find(self, x): -        if self.parents[x] < 0: -            return x -        else: -            self.parents[x] = self.find(self.parents[x]) -            return self.parents[x] - -    def union(self, x, y): -        x = self.find(x) -        y = self.find(y) -        if x == y: -            return -        if self.parents[x] > self.parents[y]: -            x, y = y, x -        self.parents[x] += self.parents[y] -        self.parents[y] = x - -    def size(self, x): -        return -self.parents[self.find(x)] - -    def same(self, x, y): -        return self.find(x) == self.find(y) - -    def members(self, x): -        root = self.find(x) -        return [i for i in range(self.n) if self.find(i) == root] - -    def roots(self): -        return [i for i, x in enumerate(self.parents) if x < 0] - -    def group_count(self): -        return len(self.roots()) - -    def all_group_members(self): -        return {r: self.members(r) for r in self.roots()} - -    def __str__(self): -        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots()) - +from collections import deque +od = [-1] * (N + 1) +low = [-1] * (N + 1) +pa = [0] * (N + 1) +od[1] = 0 +low[1] = 0 +pa[1] = 1 +ni = {i: [] for i in range(1, N + 1)} +for i in range(M): +    ni[edges[i][0]].append(edges[i][1]) +    ni[edges[i][1]].append(edges[i][0]) -for i in range(M): -    uf = UnionFind(N + 1) -    for j in range(M): -        if i == j: -            continue -        e = edges[j] -        uf.union(e[0], e[1]) -    if min(uf.parents) > -N: +h = deque([]) +for i in ni[1]: +    h.append([1, i]) +i = 0 +while h: +    a = h.pop() +    if od[a[1]] > -1: +        if od[a[1]] < od[a[0]]: +            low[a[0]] = od[a[1]] +            c = a[0] +            while low[pa[c]] > od[a[1]]: +                low[pa[c]] = od[a[1]] +                c = pa[c] +    else: +        i += 1 +        od[a[1]] = i +        low[a[1]] = i +        pa[a[1]] = a[0] +        for b in ni[a[1]]: +            if b == a[0]: +                continue +            h.append([a[1], b]) +for i in range(2, N + 1): +    if od[pa[i]] < low[i]: