qyliang/CodeNanoFix huggingface dataset:
# Buggy code:
x,y=map(int,input().split())
import bisect as bi
ans=1
for i in range(80):
    if x*2<=y:
        ans+=1
print(ans)

# Fixed code:
x,y=map(int,input().split())
import bisect as bi
ans=1
for i in range(80):
    if x*2<=y:
        ans+=1
        x*=2
print(ans)
# Buggy code:
x, y = (int(i) for i in input().split())
tmpx = x
count = 0
while tmpx<=y:
    tmpx = tmpx * 2^count
    count = count + 1

print(count)


# Fixed code:
x, y = (int(i) for i in input().split())
tmpx = x
count = 0
while tmpx<=y:
    tmpx = tmpx * 2
    count = count + 1

print(count)
# Buggy code:
import math
import itertools
import heapq
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_I(): return map(int, stdin)
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))

##### main #####



def main():
	x,y = LI()
	ans=0
	
	while x<y:
		
		x*=2
		ans+=1
		
	print(ans)

if __name__ == '__main__':
	main()

# Fixed code:
import math
import itertools
import heapq
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_I(): return map(int, stdin)
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))

##### main #####



def main():
	x,y = LI()

	ans=0
	while x<=y:
		x*=2
		ans+=1
		
	print(ans)

if __name__ == '__main__':
	main()
# Buggy code:
x, y = map(int, input().split())
ans = 0
while x < y:
    x *= 2
    ans += 1
print(ans)


# Fixed code:
x,y=map(int,input().split())

ans=0
while(x<=y):
    ans+=1
    x*=2
print(ans)
# Buggy code:
X, Y = map(int,input().split())
length = 1
P = X
while(P <= Y):
    P = 2*P
    print(P)
    length += 1

length = length -1
print(length)

# Fixed code:
X, Y = map(int,input().split())
length = 1
P = X
while(P <= Y):
    P = 2*P
    length += 1

length = length -1
print(length)
# Buggy code:
A, Y = map(int, input().split())
ans = 0
while A<=Y:
  ans+=1
  A*=2
print(A)

# Fixed code:
A, Y = map(int, input().split())
ans = 0
while A<=Y:
  ans+=1
  A*=2
print(ans)
# Buggy code:
X,Y=map(int,input().split())
ans=0
for i in range(1,10**18):
    if X*i<Y:
        ans+=1
    else:
        print(ans)
        break

# Fixed code:
X,Y=map(int,input().split())
ans=1
for i in range(1,10**18):
    if X*2<=Y:
        X*=2
        ans+=1
    else:
        print(ans)
        break
# Buggy code:
a = list(map(int,input().split()))

k = a[1]
i = 1
l = a[0]
while True:
  l *= i
  if k <= l:
    break
  i += 1
print(i-1)

# Fixed code:
a = list(map(int,input().split()))

k = a[1]
i = 2
l = a[0]
while True:
  l *= 2
  if k < l:
    break
  i += 1
print(i-1)
# Buggy code:
x,y=map(int,input().split())
i=0
while x*(2**i)<y+1:
  x=x*(2**i)
  i+=1
print(i+1)


# Fixed code:
x,y=map(int,input().split())
i=0
while x*(2**i)<y+1:
  i+=1
print(i)
# Buggy code:
X, Y = map(int, input().split())
count = 0
while True:
  count++
  X = X * 2
  if X > Y:
    break
print(count)

# Fixed code:
X, Y = map(int, input().split())
count = 0
while True:
  count = count + 1
  X = X * 2
  if X > Y:
    break
print(count)
# Buggy code:

def main():
    f, t = [int(v) for v in input().split(' ')]
    count = 0
    d = 1
    while True:
        tmp = f * 2
        if tmp > t:
            break
        count += 1
        print(tmp)
        d += 1
        f = tmp
    print(count + 1)
    print(read_val.get_file_value("ans"))



if __name__ == '__main__':
    main()

# Fixed code:
def main():
    f, t = [int(v) for v in input().split(' ')]
    count = 0
    d = 1
    tmp = f
    while True:
        tmp = tmp * 2
        if tmp > t:
            break
        count += 1

    print(count + 1)



if __name__ == '__main__':
    main()
# Buggy code:
X, Y = map(int, input().split())

a = X
count = 1
while a <= Y:
    count += 1
    a *= 2

print(count)


# Fixed code:
X, Y = map(int, input().split())
count = 0

while X <= Y:
    count += 1
    X *= 2

print(count)
# Buggy code:
x,y = map(int, input().split())
count = 0
while x*2 <= y:
    x = x*2
    count += 1
print(count)

# Fixed code:
x,y=map(int,input().split())
c=0
while x<=y:
    x=x*2
    c+=1
print(c)
# Buggy code:

X,Y=map(int,input().split())

count = 0

while X<Y:
    X *= 2
    count += 1

print(count)

# Fixed code:
X,Y=map(int,input().split())
cnt=0
while(X<=Y):
    X=X*2
    cnt+=1
print(cnt)
# Buggy code:
x, y = map(int, input().split())
 
num = 1
while x < y:
    x *= 2
    num += 1
 
print(num)

# Fixed code:
x, y = map(int, input().split())
 
num = 0
while x <= y:
    num += 1
    x *= 2
    
print(num)
# Buggy code:
x, y = map(int, input().split())
 
num = 0
while x < y:
    num += 1
    x *= 2
    
print(num)

# Fixed code:
x,y = map(int,input().split())

ans = 0

while x <= y:
    ans += 1
    x = x * 2

print(ans)
# Buggy code:
X,Y = map(int,input().split())

ans = 0
tmp = X

while tmp < Y:
    ans += 1
    tmp = tmp*2
    
print(ans)

# Fixed code:
X, Y = map(int, input().split())

ans = 0
while X <= Y:
    X = X*2
    ans += 1
print(ans)
# Buggy code:
x, y = map(int, input().split())
t = x
cnt = 0
while True:
    print(t)
    if t > y:
        print(cnt)
        exit()
    else:
        cnt += 1
        t *= 2


# Fixed code:
x, y = map(int, input().split())
t = x
cnt = 0
while True:
    if t > y:
        print(cnt)
        exit()
    else:
        cnt += 1
        t *= 2
# Buggy code:
x, y = map(int, input().split())

ans = 1
while x * 2 ** ans < y:
    ans += 1

print(ans)


# Fixed code:
x,y=map(int,input().split())

ans=0
while x<=y:
    x*=2
    ans+=1
print(ans)
# Buggy code:
a = input()
b = input()
a = int(a)
b = b.split()
b = [int(s) for s in b]
b.sort()
c = 0
while True:
    for i in range(a):
        b[i] = b[i] / 2
    if b[0] % 2  != 0:
        break
    c += 1
    
print(c)

# Fixed code:
a = input()
b = input()
a = int(a)
b = b.split()
b = [int(s) for s in b]
c = 0
flag = True
while True:
    
    for i in range(a):
        if b[i] % 2 != 0:
            flag = False
        b[i] = b[i] / 2
        
    if flag == False:
        break
    c += 1

    

    
print(c)
# Buggy code:
n = int(input())
l = [list(map(int,input().split()))]
j = 0
new = []
while True:
    for m,i in enumerate(l):
        if i % 2 == 0:
            l[i] = i/2
            if m == n:
                j +=1
        else:
            print(j)
            exit()
        

# Fixed code:
n = int(input())
l = list(map(int,input().split()))

j = 0
new = []
while True:
    for m,i in enumerate(l):
        if i % 2 == 0:
            l[m] = i/2
            
            if m+1 == n:
                j +=1
        else:
            print(j)
            break
    else:
        continue
    break
# Buggy code:
n = int(input())
a = list(map(int, input().split()))

while True:
 for i in range(n):
  if a[i] & 1:
    print(i)
    __import__("sys").exit(0)
  a[i] //= 2

# Fixed code:
n = int(input())
a = list(map(int, input().split()))
cnt = 0
while True:
 for i in range(n):
  if a[i] & 1:
    print(cnt)
    __import__("sys").exit(0)
  a[i] //= 2
 cnt += 1
# Buggy code:
n = int(input())
aList = list(map(int, input().split()))
count = 0

while True:
  flag = True
  for i in range(n):
    if aList[i] % 2 != 0:
      flag = False
    aList[i] /= 2
   
  if flag = False:
    break

  count += 1

# Fixed code:
n = int(input())
aList = list(map(int, input().split()))
count = 0

while True:
  flag = True
  for i in range(n):
    if aList[i] % 2 != 0:
      flag = False
    aList[i] /= 2
   
  if flag == False:
    break

  count += 1

print(count)
# Buggy code:
#3
#8 12 40
n=int(input())
ai=list(map(int(),input.split()))
        
for a in ai:
  count =0
  while a%2==0 :
    count+=1
    a/=2
    b.append(count)
print(min(b))


# Fixed code:
#3
#8 12 40
n=int(input())
ai=list(map(int,input().split()))
b=[]
for a in ai:
  count =0
  while a%2==0 :
    count+=1
    a/=2
  b.append(count)
print(min(b))
# Buggy code:
N = int(input())
A= list(map(int,input().split()))

res = 0
while True:
    for i in range(N):
        if A[i] % 2 == 0:
            A[i] //= 2
        else:
            break
    else:
        res += 1
        print("#########")
        print(res)
        continue
    break

print(res)

# Fixed code:
N = int(input())
A= list(map(int,input().split()))

res = 0
while True:
    for i in range(N):
        if A[i] % 2 == 0:
            A[i] //= 2
        else:
            break
    else:
        res += 1
        continue
    break

print(res)
# Buggy code:
n=int(input())

a=list(map(int, input().split())) 

count=0

while all(x%2==0 for x in a):
    x=[x/2 for x in a]
    count+=1

print(count)

# Fixed code:
input()
a=list(map(int, input().split())) 
count=0
while all(x%2==0 for x in a):
    a=[x/2 for x in a]
    count+=1
print(count)
# Buggy code:
N=int(input())
A=list(map(int, input().split()))
B=A[:]
i=0
while i < N:
    if A[i] % 2 == 0:
        A[i] = A[i]//2
        print(A[i])
        if i == N-1:
            B = A[:]
            i = -1
        i =+ 1
    else:
        break
print(B)

# Fixed code:
N=int(input())
A=list(map(int, input().split()))
t=0
i=0
while i < N:
    if A[i] % 2 == 0:
        A[i] = A[i]//2
        if i == N - 1:
            t += 1
            i = -1
        i += 1
    else:
        break
print(t)
# Buggy code:
N = int(input())
A = list(map(int, input().split()))

count = 0
while True:
  A, mod = zip([divmod(a, 2) for a in A])
  if sum(mod) > 0:
    break
  count++
print(count)

# Fixed code:
N = int(input())
A = list(map(int, input().split()))
 
count = 0
while True:
  A, mod = zip(*[divmod(a, 2) for a in A])
  if sum(mod) > 0:
    break
  count += 1
print(count)
# Buggy code:
n = int(input())
a = list(map(int, input().split()))

i = 0
per = True
while per == True:
    for index in range(n):
        num = a[index]
        ans = divmod(num, 2)
        if num == 0 or ans[1] != 0:
            per = False
            break
        a[index] = ans[0]
    i += 1
print(i)

# Fixed code:
n = int(input())
a = list(map(int, input().split()))

i = 0
per = True
while per == True:
    for index in range(n):
        num = a[index]
        ans = divmod(num, 2)
        if num == 0 or ans[1] != 0:
            per = False
            break
        a[index] = ans[0]
    if per == True:
        i += 1
print(i)
# Buggy code:
# -*- coding: utf-8 -*-

N = int(input())
a = list(map(int, input().split(" ")))
c = []

for i in a:
  count = 0
  while not(a % 2):
    a = int(a / 2)
    count += 1
    c.append(count)
print(min(c))

# Fixed code:
# -*- coding: utf-8 -*-
 
N = int(input())
a = list(map(int, input().split(" ")))
c = []
 
for i in a:
  count = 0
  while not(i % 2):
    i = int(i / 2)
    count += 1
  c.append(count)
print(min(c))
# Buggy code:
dbflag=0
def debug(*args):
  if dbflag: print(*args)

result = 0

N =  input() 
N=int(N)

#A =  map(int,input() .split())
A = [int(i) for i in input().split(' ')]

flag= 1

while flag:
	for i in range(len(A)):
		debug(i, A[i])
		if A[i] %2 == 0:
			A[i] = A[i] //2
		else:
			flag = 0
			break
		
	if flag:
		result += 1

print(result

# Fixed code:
dbflag=0
def debug(*args):
	if dbflag: print(*args)

result = 0

N =  input() 
N=int(N)

#A =  map(int,input() .split())
A = [int(i) for i in input().split(' ')]

flag= 1

while flag:
	for i in range(len(A)):
		debug(i, A[i])
		if A[i] %2 == 0:
			A[i] = A[i] //2
		else:
			flag = 0
			break
		
	if flag:
		result += 1

print(result)
# Buggy code:
kazu = int(input())
numbers_list = list(map(int, input().split()))
count = 0
seisu = 0
while True:
    for index in range(kazu):
        if numbers_list(index) % 2 == 0:
            numbers_list[inedx] = numbers_list[index] / 2
            count += 1
        else:
            seisu = 1
            break
    if seisu == 1:
        break
print(count)

# Fixed code:
kazu = int(input())
numbers_list = list(map(int, input().split()))
count = 0
seisu = 0
while True:
    for index in range(kazu):
        if numbers_list[index] % 2 != 0:
            seisu = 1
            break
        else:
            numbers_list[index] = numbers_list[index] / 2
    if seisu == 1:
        break
    count += 1
print(count)
# Buggy code:
n=int(input())
l=list(map(int,input().split()))
ans=0
c=True

while c == True:
    for i in range(n):
        if l[i]%2==1:
            c = False
            break
    for i in range(n):
        l[i]/=2
    ans+=1
print(ans)

# Fixed code:
n=int(input())
l=list(map(int,input().split()))
ans=0
c=True

while c == True:
    for i in range(n):
        if l[i]%2==1:
            c = False
    if c == False:
        break
    else:
        for i in range(n):
            l[i]/=2
        ans+=1
print(ans)
# Buggy code:
N = int(input())
A = list(map(int,input().split()))

ans = 10 ** 6

for a in A:
  c = 0
  while a % 2 == 0:
    a //= 2
  ans = min(c,ans)
  
print(ans)

# Fixed code:
N = int(input())
A = list(map(int,input().split()))

ans = 10 ** 6

for a in A:
  c = 0
  while a % 2 == 0:
    a //= 2
    c += 1
  ans = min(c,ans)
  
print(ans)
# Buggy code:
def divide_count(n):
    cnt = 0
    while n % 2 == 0:
        n /= 2
        cnt += 1
    return cnt

n = int(input())
a = list(map(int, input().split()))
print(list(map(divide_count, a)))


# Fixed code:
def divide_count(n):
    cnt = 0
    while n % 2 == 0:
        n /= 2
        cnt += 1
    return cnt

n = int(input())
a = list(map(int, input().split()))
print(min(map(divide_count, a)))
# Buggy code:
# -*- coding: utf-8 -*-

numbers = list(map(int, input().split()))

count = 0
while(True):
	if sum(list(map(lambda x: x % 2, numbers))) == 0:
		numbers = list(map(lambda x: x / 2, numbers))
		count += 1
	else:
		break
print(count)

# Fixed code:
# -*- coding: utf-8 -*-
input()
numbers = list(map(int, input().split()))
 
count = 0
while(True):
	if sum(list(map(lambda x: x % 2, numbers))) == 0:
		numbers = list(map(lambda x: x / 2, numbers))
		count += 1
	else:
		break
print(count)
# Buggy code:
n=int(input())
l=list(map(int,input().split(" ")))
ans=0

while i <len(l):
    if l[i]%2!=0:
        break
    else:
        l[i]=int(l[i]/2)
        i+=1
    ans+=1
print(ans)

# Fixed code:
n=int(input())
l=list(map(int,input().split(" ")))
ans=0
j=0
while j==0:
    i=0
    while i <len(l):
        if l[i]%2!=0:
            j=1
        else:
            l[i]=int(l[i]/2)
        i+=1
    ans+=1
print(ans-1)
# Buggy code:
n = int(input())
List = list(map(int, input().split()))
ans = 0
while all(i%2 == 0 for i in List):
  a = [i/2 for i in List]
  ans += 1
print(ans)

# Fixed code:
n = int(input())
a = list(map(int, input().split()))
ans = 0
while all(i%2 == 0 for i in a):
  a = [i/2 for i in a]
  ans += 1
print(ans)
# Buggy code:
N=int(input())
ls=[int(s) for s in input().split()]
count=0
i=0
while(True):
  if ls[i]%2==1:
    break
  ls[i]=ls[i]//2
  if i<N:
    i+=1
  else:
    count+=1
    i=0    
print(count)


# Fixed code:
N=int(input())
ls=[int(s) for s in input().split()]
count=0
i=0
while(True):
  if ls[i]%2==1:
    break
  ls[i]=ls[i]//2
  i+=1
  if i==N:
    count+=1
    i=0    
print(count)
# Buggy code:
    n = input()
    a = list(map(int, input().split()))
    even = True
    count = 0
    while even:
        for ai in range(len(a)):
            if a[ai] % 2 != 0:
                even = False
                break

        if even:
            a = list(map(lambda num: num / 2, a))
            count += 1
        else:
            break
    print(count)

# Fixed code:
n = input()
a = list(map(int, input().split()))
even = True
count = 0
while even:
    for ai in range(len(a)):
        if a[ai] % 2 != 0:
            even = False
            break

    if even:
        a = list(map(lambda num: num / 2, a))
        count += 1
    else:
        break
print(count)
# Buggy code:
import numpy as np

n = int(input())
a = [int(x) for x in input().split()]

cnt = 0
while sum(a%2) == 0:
    cnt += 1
    a = a//2
print(cnt)

# Fixed code:
import numpy as np

n = int(input())
a = np.array([int(x) for x in input().split()])

cnt = 0
while sum(a%2) == 0:
    cnt += 1
    a = a//2
print(cnt)
# Buggy code:
n = int(input())
a = list(map(int, input().split()))
count = 0
while all[i%2==0 for i in a]:
  a = [i//2 for i in a]
  count += 1
print(count)

# Fixed code:
count = 0
n = int(input())
lst = list(map(int, input().split()))
while all([i%2 == 0 for i in lst]):
  lst = [i // 2 for i in lst]
  count += 1
print(count)
# Buggy code:
n = input()

A = list(map(int, input().split())

counts = 0
while all(a%2==0 for a in A):
	texts = [a/2 for a in A]
    counts += 1
print(counts)

# Fixed code:
n = input()
 
A = list(map(int, input().split()))
 
counts = 0
while all(a%2==0 for a in A):
  A = [a/2 for a in A]
  counts += 1
print(counts)
# Buggy code:
import numpy as np
input()
x = np.array(input().split(), dtype=np.int32)

ans = 0
while ( x % 2 == 0 ).all():
  	x //= 2
    ans += 1
print(ans)    

# Fixed code:
import numpy as np
input()
x = np.array(input().split(),dtype=np.int32)

ans = 0
while (x%2==0).all():
  x //= 2
  ans += 1
print(ans)
# Buggy code:
N = int(input())
A = list(map(int, input().split()))

cnt = 0
while True:
    for i in range(len(A)):
        if A[i] % 2 != 0:
            break
    else:
        A = [a/2 for a in A]
        cnt += 1

print(cnt)


# Fixed code:
N = int(input())
A = list(map(int, input().split()))

cnt = 0
while True:
    for i in range(len(A)):
        if A[i] % 2 != 0:
            break
    else:
        A = [a/2 for a in A]
        cnt += 1
        continue
    break

print(cnt)
# Buggy code:
input()
c = map(int,input().split())
count = 0
while all(w%2 == 0 for w in c):
    c = [w/2 for s in c]
    count =+ 1
print(count)

# Fixed code:
input()
c =list(map(int,input().split()))
count = 0
while all(w%2==0 for w in c):
    c=[w/2 for w in c]
    count+=1
print(count)
# Buggy code:
def main():
    n = int(input())
    a = list(map(int, input().split()))

    flag = True
    count = 0
    for i in a:
        if(i%2 == 1):
            flag = False

    while flag == True:
        count += 1
        a = list(map( lambda x: int(x/2), a))
        for i in a:
            if(i%2 != 0):
                False
    
    print(count)

if __name__ == '__main__':
    main()

# Fixed code:
def main():
    n = int(input())
    a = list(map(int, input().split()))

    flag = True
    count = 0
    for i in a:
        if(i%2 == 1):
            flag = False

    while flag == True:
        count += 1
        a = list(map( lambda x: int(x/2), a))
        for i in a:
            if(i%2 != 0):
                flag = False
    
    print(count)

if __name__ == '__main__':
    main()
# Buggy code:

N = int(input())

num_list = [int(i) for i in input().split()]

cnt = 0
flag = True

while flag:
    for i in range(N):
        if num_list[i] % 2 == 1:
            flag = False
            break
        else:
            num_list[i] = num_list[i] / 2
            
    cnt += 1

print(cnt)


# Fixed code:


N = int(input())

num_list = [int(i) for i in input().split()]

cnt = 0
flag = 0

while flag == 0:
    for i in range(N):
        if num_list[i] % 2 == 1:
            flag = 1
            break
        else:
            num_list[i] = num_list[i] / 2
            if i == N - 1:
                cnt += 1

print(cnt)
# Buggy code:

N = input()
vals = map(int, input().split())
count = 0
is_odd = False
while True:
    for val in vals:
        if val % 2 == 1:
            is_odd = True
    if is_odd:
        break
    for i in range(N):
        vals[i] /= 2
    count += 1
print (count)

# Fixed code:
N = int(input())
vals = list(map(int, input().split()))
count = 0
is_odd = False
while True:
    for i in range(0, N):
        if vals[i] % 2 == 1:
            is_odd = True
        vals[i] /= 2
    if is_odd:
        break
    count += 1
print (count)
# Buggy code:
from collections import deque
n,m = tuple(map(int,input().split()))

edge = []

for i in range(m):
  edge.append(tuple(map(lambda a:int(a)-1,input().split())))
  
matrix = [[0]*n for _ in range(n)]
  
for a,b in edge:
  matrix[a][b] = 1
  matrix[b][a] = 1
  
ans = 0

for a,b in edge:
  matrix[a][b] = 0
  matrix[a][b] = 0
  
  checked = [False]*n
  queue = deque([0])
  while(len(queue)>0):
    q = queue.pop()
    if checked[q]:
      continue
    else:
      checked[q] = True
      mat = matrix[q]
      for i in range(n):
        if matrix[i] == 1:
          queue.append(i)
          
  if not all(checked):
    ans+=1
  
  matrix[a][b] = 1
  matrix[b][a] = 1

print(ans)

# Fixed code:
from collections import deque
n,m = tuple(map(int,input().split()))

edge = []

for i in range(m):
  edge.append(tuple(map(lambda a:int(a)-1,input().split())))
  
matrix = [[0]*n for _ in range(n)]
  
for a,b in edge:
  matrix[a][b] = 1
  matrix[b][a] = 1
  
ans = 0

for a,b in edge:
  matrix[a][b] = 0
  matrix[b][a] = 0
  
  checked = [False]*n
  queue = deque([0])
  while(len(queue)>0):
    q = queue.popleft()
    if checked[q]:
      continue
    else:
      checked[q] = True
      mat = matrix[q]
      for i in range(n):
        if mat[i] == 1:
          queue.append(i)
  if not all(checked):
    ans+=1
  
  matrix[a][b] = 1
  matrix[b][a] = 1

print(ans)
# Buggy code:
N,Mmap(int,input())
e=[[] for i in range(N)]
tester=[None]*M
for i in range(M):
  a,b=map(int,input().split())
  a,b=a-1,b-1
  e[a].append(b)
  e[b].append(a)
  tester[i]=set(a,b)
  
ans=0
seen=[0 for i in range(N)]
for test in tester:
  stack=[]
  stack.append([0,-1])
  while stack:
    node=stack.pop()
    v=node[0]
    parent=node[1]
    if seen[v]==1:
      continue
    seen[v]=1
    childs=e[v]
    for child in childs:
      if child==parent:
        continue
      if len(test&set([v,child]))==2:
        continue
      stack.append([child,v])
      
  if sum(seen)!=N:
    ans+=1
print(ans)
    
    
      




# Fixed code:
N,M=map(int,input().split())
e=[[] for i in range(N)]
tester=[None]*M
for i in range(M):
  a,b=map(int,input().split())
  a,b=a-1,b-1
  e[a].append(b)
  e[b].append(a)
  tester[i]=set([a,b])
  
ans=0
for test in tester:
  stack=[]
  stack.append([0,-1])
  seen=[0 for i in range(N)]
  while stack:
    node=stack.pop()
    v=node[0]
    parent=node[1]
    if seen[v]==1:
      continue
    seen[v]=1
    childs=e[v]
    for child in childs:
      if child==parent:
        continue
      if test==set([v,child]):
        continue
      stack.append([child,v])
      
  if sum(seen)!=N:
    ans+=1
print(ans)