Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.

Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.

Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.

After how many full years will Limak become strictly larger (strictly heavier) than Bob?


-----Input-----

The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.


-----Output-----

Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.


-----Examples-----
Input
4 7

Output
2

Input
4 9

Output
3

Input
1 1

Output
1



-----Note-----

In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.

In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.

In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then.

Difficulty: EASY

Solutions:
(a, b) = input().split(' ')
wofa = int(a)
wofb = int(b)
i = 0
while True:
	wofa = wofa * 3
	wofb = wofb * 2
	i += 1
	if wofa > wofb:
		break
print(i)


(a, b) = map(int, input().split())
count = 0
while a <= b:
	count += 1
	a *= 3
	b *= 2
print(count)


(a, b) = list(map(int, input().split()))
t = 0
while True:
	if a > b:
		print(t)
		break
	else:
		a = a * 3
		b = b * 2
		t += 1


s = input()
n = 0
(a, b) = (int(s.split()[0]), int(s.split()[1]))
while a <= b:
	a = a * 3
	b = b * 2
	n = n + 1
print(n)


(a, b) = map(eval, input().split())
n = 1
while True:
	a = a * 3
	b = b * 2
	if a > b:
		print(n)
		break
	n = n + 1


weights = input().split()
Limak = int(weights[0])
Bob = int(weights[1])
years = 0
while Bob >= Limak:
	Limak = Limak * 3
	Bob = Bob * 2
	years += 1
print(str(years))


def main():
	(a, b) = map(int, input().split(' '))
	i = 0
	while a <= b:
		i += 1
		a = a * 3
		b = b * 2
	print(i)
main()


(a, b) = list(map(int, input().split()))
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
else:
	print(year)


def biggest_brother(small, big):
	i = 0
	while True:
		if small > big:
			break
		small = small * 3
		big = big * 2
		i = i + 1
	return i
(a, b) = map(int, input().split(' '))
print(biggest_brother(a, b))


(limak, bob) = map(int, input().split())
years = 0
while limak <= bob:
	years += 1
	limak = limak * 3
	bob = bob * 2
print(years)


lb = input().split()
l = int(lb[0])
b = int(lb[1])
i = 1
while True:
	l = l * 3
	b = b * 2
	if l > b:
		print(i)
		break
	else:
		i = i + 1


import math
(a, b) = map(int, input().split())
print(math.trunc(math.log(b / a, 3 / 2)) + 1)


from typing import Tuple

def preprocess(wts: str) -> Tuple[int]:
	(lstr, bstr) = wts.split()
	(limark_wt, bob_wt) = (int(lstr), int(bstr))
	return (limark_wt, bob_wt)

def yearstobebigger(limak_weight: int, bob_weight: int) -> int:
	years = 0
	while limak_weight <= bob_weight:
		years += 1
		limak_weight = limak_weight * 3
		bob_weight = bob_weight * 2
	return years
wts = input()
(limak_wt, bob_wt) = preprocess(wts)
years = yearstobebigger(limak_wt, bob_wt)
print(years)


def bear_and_big_brother():
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	count = 0
	while b >= a:
		a *= 3
		b *= 2
		count += 1
	print(count)
bear_and_big_brother()


(a, b) = input().split()
a = int(a)
b = int(b)
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


(a, b) = [int(i) for i in input().split()]
import math
z = 3 / 2
j = b / a
r = math.log(j, z)
print(int(r) + 1)


(a, b) = map(int, input().split())
res = 0
while True:
	res += 1
	a *= 3
	b *= 2
	if a > b:
		print(res)
		break


import sys
import math
(a, b) = input().split()
a = int(a)
b = int(b)
for i in range(1, 100):
	a = a * 3
	b = b * 2
	if a > b:
		print(i)
		sys.exit()


local = False
if local:
	file = open('A.txt', 'r')

def inp():
	if local:
		return file.readline().rstrip()
	else:
		return input().rstrip()

def ints():
	return [int(_) for _ in inp().split()]
(a, b) = ints()
i = 1
while a * 3 <= b * 2:
	a *= 3
	b *= 2
	i += 1
print(i)


s = input().split()
n1 = int(s[0])
n2 = int(s[1])
count = 0
while n1 <= n2:
	count = count + 1
	n1 = n1 * 3
	n2 = n2 * 2
print(count)


y = [int(i) for i in input().split()]
x = y[0]
y = y[1]
z = -1

def xxx(x, y):
	global z
	z += 1
	if y >= x:
		y *= 2
		x *= 3
		xxx(x, y)
	else:
		print(z)
xxx(x, y)


weights = input().split()
l = int(weights[0])
b = int(weights[1])
year = 0
while True:
	l = 3 * l
	b = 2 * b
	year = year + 1
	if l > b:
		print(year)
		break


bear: str = input()
(a, b) = bear.split(' ')
(a, b) = (int(a), int(b))
year = 0
while a <= b:
	a = a * 3
	b = b * 2
	year = year + 1
print(year)


weight = input()
weight_list = weight.split()
a = int(weight_list[0])
b = int(weight_list[1])
year = 0
while b >= a:
	a = a * 3
	b = b * 2
	year += 1
print(year)


(a, b) = (int(x) for x in input().split())
n = 0
while True:
	if a > b:
		print(n)
		break
	else:
		a = a * 3
		b = b * 2
		n += 1


(m, n) = map(int, input().split())
c = 0
while m <= n:
	m = 3 * m
	n = 2 * n
	c = c + 1
print(c)


(first, second) = input().split()
first = int(first)
second = int(second)
total_years = 0
while first <= second:
	first = first * 3
	second = second * 2
	total_years = total_years + 1
print(total_years)


w = input().split(' ')
a = int(w[0])
b = int(w[1])
i = 1
while i >= 1:
	a = a * 3 * i
	b = b * 2 * i
	if a > b:
		i = i
		break
	else:
		i = i + 1
print(i)


(a, b) = list(map(int, input().split()))
cnt = 0
while a <= b:
	a *= 3
	b *= 2
	cnt += 1
print(cnt)


a = list(map(int, input().split()))
b = a[0]
c = a[1]
i = 0
while b <= c:
	i = i + 1
	b = 3 * b
	c = 2 * c
print(i)


ab = input().split(' ')
a = int(ab[0])
b = int(ab[1])
year = 0
while a * pow(3, year) <= b * pow(2, year):
	year += 1
print(year)


(ls, bs) = input().strip().split(' ')
l = int(ls)
b = int(bs)
n = 0
while True:
	n += 1
	l = l * 3
	b = b * 2
	if l > b:
		print(n)
		break


masukan = [int(y) for y in input().split()]
limak = 0
danik = 0
a = 0
while masukan[0] <= masukan[1]:
	masukan[0] *= 3
	masukan[1] *= 2
	a += 1
print(a)


import math
(a, b) = map(int, input().split())
print(math.ceil(math.log(b / a, 1.5) + 1e-09))


a = input().split()
a[0:] = [int(zahl) for zahl in a[0:]]
x = 0
while a[0] <= a[1]:
	a[0] = a[0] * 3
	a[1] = a[1] * 2
	x += 1
print(x)


(m, n) = map(int, input().strip().split())
y = 0
while True:
	if m > n:
		print(y)
		break
	else:
		m *= 3
		n *= 2
		y += 1


(n, m) = map(int, input().split())
x = 1
while 1:
	n = 3 * n
	m = 2 * m
	if n > m:
		print(x)
		break
	else:
		x += 1


(l, b) = map(int, input().split())
year = 0
while l <= b:
	(l, b) = (l * 3, b * 2)
	year += 1
print(year)


(l, b) = map(int, input().split())
c = 0
while True:
	if l > b:
		break
	l = l * 3
	b = b * 2
	c += 1
print(c)


(x, y) = map(int, input().split())
a = 0
while 1:
	x = x * 3
	y = y * 2
	a = a + 1
	if x > y:
		print(a)
		break


(a, b) = map(int, input().split())
c = 0
while True:
	if a <= b:
		a = 3 * a
		b = 2 * b
		c += 1
	else:
		break
print(c)


(a, b) = map(int, input().split())
c = 0
while a <= b:
	a = a * 3
	b = b << 1
	c += 1
print(c)


(a, b) = [int(_) for _ in input().split()]
c = 0
while True:
	if a > b:
		print(c)
		break
	a *= 3
	b *= 2
	c += 1


(a, b) = list(map(int, input().split()))
x = 3
y = 2
count = 0
while a <= b:
	count += 1
	a *= x
	b *= y
print(count)


(a, b) = [int(x) for x in input().split()]
i = 1
while 1:
	if a * 3 <= b * 2:
		i += 1
		a = a * 3
		b = b * 2
	else:
		break
print(i)


(a, b) = map(int, input().split())
n = 0
while a <= b:
	a *= 3
	b *= 2
	n += 1
else:
	print(n)


(a, b) = [int(c) for c in input().split()]
i = 1
c = 0
while i:
	a = a * 3
	b = b * 2
	c += 1
	if a > b:
		break
print(c)


def counter(weight_1, weight_2):
	count = 0
	if weight_1 > weight_2:
		print(count)
	else:
		for i in range(0, 100):
			weight_1 *= 3
			weight_2 *= 2
			count += 1
			if weight_1 > weight_2:
				print(count)
				break
			else:
				continue
(x, y) = [int(x) for x in input().split()]
counter(x, y)


(a, b) = input().split(' ')

def bigger_than_my_brother(a_weight, b_weight):
	if a_weight > b_weight:
		return 0
	return 1 + bigger_than_my_brother(a_weight * 3, b_weight * 2)
print(bigger_than_my_brother(int(a), int(b)))


import math
(a, b) = map(int, input().split())
n = math.floor(float(math.log10(b) - math.log10(a)) / float(math.log10(3) - math.log10(2))) + 1
print(n)


(a, b) = input().split()
a = int(a)
b = int(b)
i = 1
while 1:
	if a * 3 ** i > b * 2 ** i:
		print(i)
		break
	i += 1


list1 = list(map(int, input().split()))
a = list1[0]
b = list1[1]
counter = 0
while a <= b:
	counter += 1
	a *= 3
	b *= 2
print(counter)


def Bears(L, B):
	cnt = 0
	while L <= B:
		if L > B:
			break
		L *= 3
		B *= 2
		cnt += 1
	return cnt
(L, B) = map(int, input().split())
print(Bears(L, B))


(lemak, bob) = (int(a) for a in input().strip().split())
cnt = 0
while lemak <= bob:
	cnt += 1
	lemak *= 3
	bob *= 2
print(cnt)


weights = [int(n) for n in input().split(' ')]
a = weights[0]
b = weights[1]
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


def maxves(a, b):
	i = 0
	while a <= b:
		a = a * 3
		b = b * 2
		i += 1
	return i
(x, y) = map(int, input().split())
print(maxves(x, y))


s = input().split(' ')
n = int(s[0])
m = int(s[1])
k = 0
while n <= m:
	n *= 3
	m *= 2
	k += 1
print(k)


(a, b) = map(int, input().strip().split())
result = 0
while a <= b:
	a *= 3
	b *= 2
	result += 1
print(result)


import math
(a, b) = list(map(int, input().split()))
n = math.floor((math.log2(a) - math.log2(b)) / (1 - math.log2(3))) + 1
print(n)


poids = input().split(' ')
a = int(poids[0])
b = int(poids[1])
while a > b:
	print('il faut que le poids de Limak est inferieur au poids du Bob ')
	poids = input().split(' ')
	a = int(poids[0])
	b = int(poids[1])
c = 0
if a == 0:
	print('il faut que a soit different de 0')
elif a == b:
	print(1)
else:
	while a <= b:
		c = c + 1
		a = a * 3
		b = b * 2
	print(c)


c = input()
w = c.split(' ')
weight = [int(z) for z in w]
i = 1
lam = weight[0]
bob = weight[1]
while lam < bob:
	bob = bob * i * 2
	lam = lam * i * 3
	if lam > bob:
		break
	i += 1
print(i)


inp_lst = [int(x) for x in input().split()]
a = inp_lst[0]
b = inp_lst[1]
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


(l, b) = input().split()
new_l = int(l)
new_b = int(b)
i = 0
while new_l <= new_b:
	new_l *= 3
	new_b *= 2
	i += 1
print(i)


def main():
	weights = input(' ')
	a = weights.split()[0]
	b = weights.split()[1]
	a = int(a)
	b = int(b)
	years = 0
	while True:
		if a > b:
			break
		else:
			a *= 3
			b *= 2
			years += 1
	print(years)
main()


(a, b) = input().split()
i = 1
(a1, b1) = (int(a), int(b))
while True:
	a1 = a1 * 3
	b1 = b1 * 2
	if a1 > b1:
		break
	else:
		i += 1
print(i)


(a, b) = map(int, input().split())
for i in range(1, 1000):
	a *= 3
	b *= 2
	if a > b:
		print(i)
		exit(0)


k = [int(x) for x in input().strip().split()]
a = k[0]
b = k[1]
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


ages = [int(x) for x in input().split()]
counter = 0
while ages[0] <= ages[1]:
	ages[0] *= 3
	ages[1] *= 2
	counter += 1
print(counter)


s = input().split()
i = 0
while int(s[0]) <= int(s[1]):
	s[0] = int(s[0]) * 3
	s[1] = int(s[1]) * 2
	i += 1
print(i)


x = input()
y = x.split()
(a, b) = (int(y[0]), int(y[1]))
years = 0
while a <= b:
	years += 1
	a *= 3
	b *= 2
print(years)


(a, b) = [int(x) for x in input().split()]
n = 0
while a <= b:
	n += 1
	a = 3 * a
	b = 2 * b
print(n)


(a, b) = input().split()
a = int(a)
b = int(b)
c = 0
while a <= b:
	c = c + 1
	a = 3 * a
	b = 2 * b
print(c)


import math
(a, b) = map(int, input().split())
print(1 + int(math.log(b / a) / math.log(1.5)))


s = input().split()
a = int(s[0])
b = int(s[1])
count = 0
check = True
while check:
	a *= 3
	b *= 2
	count += 1
	if a > b:
		check = False
		print(count)


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


(a, b) = map(int, input().split())
x = 0
y = 0
years = 0
while a < b:
	a = a * 3
	b = b * 2
	years += 1
if a == b:
	years += 1
	print(years)
else:
	print(years)


(a, b) = list(map(int, input().split()))
flag = False
i = 0
while not flag:
	if 3 * a > 2 * b:
		flag = True
	i += 1
	a = 3 * a
	b = 2 * b
print(i)


(x, y) = map(int, input().split())
qtd = 0
while x <= y:
	x *= 3
	y *= 2
	qtd += 1
print(qtd)


(l, b) = map(int, input().split(' '))
k = 1
while k > 0:
	l = 3 * l
	b = b * 2
	if l > b:
		print(k)
		break
	k = k + 1


(lima, bob) = input().split()
lima = int(lima)
bob = int(bob)
year = 0
while lima <= bob:
	lima *= 3
	bob *= 2
	year += 1
print(year)


(a, b) = map(int, input().split())
if a <= b:
	year = 0
	while a <= b:
		a *= 3
		b *= 2
		year += 1
	print(year)


num = list(map(int, input().split()))
L = num[0]
K = num[1]
for i in range(1, 1000000):
	if int(L) > int(K):
		print(i - 1)
		break
	L = L * 3
	K = K * 2


temp = map(int, input().split(' '))
(a, b) = temp
k = a
k1 = b
t = 0
while a < b:
	a = a * 3
	b = b * 2
	t += 1
if a == b:
	t += 1
print(t)


(limak, bob) = [int(i) for i in input().split()]
yr = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	yr += 1
print(yr)


def solve():
	(a, b) = [int(x) for x in input().split()]
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	print(years)
solve()


def main():
	n = list(map(int, input().split()))
	(a, b) = [n[0], n[1]]
	count = 0
	while True:
		a *= 3
		b *= 2
		count += 1
		if a > b:
			break
	print(count)
main()


n = input()
n = n.split(' ')
x = int(n[0])
y = int(n[1])
c = 0
for i in range(1, 100):
	if 3 * x > 2 * y:
		print(i)
		break
	else:
		x = 3 * x
		y = 2 * y


import math
(a, b) = input().split()
a = int(a)
b = int(b)
ans = math.log(b / a, 3 / 2)
print(math.floor(ans) + 1)


import math
s = list(map(int, input().split()))
if s[1] < s[0]:
	print('0')
else:
	count = 0
	while s[0] <= s[1]:
		s[0] *= 3
		s[1] *= 2
		count += 1
	print(count)


(x, y) = input().split(' ')
(x, y) = (int(x), int(y))
counter = 0
while x <= y:
	counter += 1
	x *= 3
	y *= 2
print(counter)


string = input()
weights = string.split(' ')
a = int(weights[0])
b = int(weights[1])
years = 0
while not a > b:
	years += 1
	a *= 3
	b *= 2
print(years)


i = 0
(a, b) = input().split()
a = int(a)
b = int(b)
for i in range(0, 10):
	a *= 3
	b *= 2
	i += 1
	if a > b:
		break
print(i)


(a, b) = input().split()
year_count = 0
while int(a) <= int(b):
	a = 3 * int(a)
	b = 2 * int(b)
	year_count += 1
print(year_count)


(n, m) = input().split()
(n, m) = (int(n), int(m))
i = 0
while True:
	if n > m:
		break
	n = n * 3
	m = m * 2
	i += 1
print(i)


(a, b) = [int(c) for c in input().split(' ')]
years = 0
while a <= b:
	years += 1
	a *= 3
	b *= 2
print(years)


(a, b) = input().split()
(x, y) = (int(a), int(b))
k = 0
while True:
	if x <= y:
		x = x * 3
		y = y * 2
		k = k + 1
	else:
		print(k)
		break


x = input()
(a, b) = map(int, x.split())

def weight(a, b):
	c = 0
	while a <= b:
		a *= 3
		b *= 2
		c += 1
	print(c)
weight(a, b)


def bear_and_big_brother(a, b):
	year = 0
	while True:
		if a > b:
			return year
		a *= 3
		b *= 2
		year += 1
(a, b) = input().split()
(a, b) = [int(a), int(b)]
print(bear_and_big_brother(a, b))


def get():
	return [int(x) for x in input().split()]
(a, b) = get()
r = 0
while a <= b:
	a *= 3
	b *= 2
	r += 1
print(r)


(l, b) = map(int, input().split())
count = 0
while l <= b:
	if l <= b:
		count += 1
	l = 3 * l
	b = 2 * b
print(count)


weight = input().split()
Limak = int(weight[0])
Bob = int(weight[1])
years = 0
while True:
	Limak = Limak * 3
	Bob = Bob * 2
	years += 1
	if Limak > Bob:
		break
print(years)


c = 0
a = []
s = input()
x = s.split()
a = [int(y) for y in x]
while a[0] <= a[1]:
	c += 1
	a[0] *= 3
	a[1] *= 2
print(c)


[a, b] = [int(i) for i in input().split()]
answer = 0
while a <= b:
	a *= 3
	b *= 2
	answer += 1
print(answer)


s = input()
results = list(map(int, s.split()))
i = 0
while results[0] <= results[1]:
	results[0] *= 3
	results[1] *= 2
	i += 1
print(i)


from math import *
(a, b) = map(int, input().split())
n = log(b / a) / log(3 / 2)
if n == ceil(n):
	print(int(n + 1))
else:
	print(ceil(n))


(x, y) = map(int, input().split())
count = 0
while True:
	x = x * 3
	y = y * 2
	count += 1
	if x > y:
		break
print(count)


def max(a, b, x):
	if a > b:
		return x
	else:
		x += 1
		return max(a * 3, b * 2, x)
c = input()
c = c.split()
c.append(0)
c[0] = int(c[0])
c[1] = int(c[1])
print(max(c[0], c[1], c[2]))


(l, b) = list(map(int, input().split()))
c = 0
while l <= b:
	l = l * 3
	b = b * 2
	c += 1
print(c)


inp = lambda : map(int, input().split())
(a, b) = inp()
c = 0
while a <= b:
	a *= 3
	b *= 2
	c += 1
print(c)


(l, b) = [int(x) for x in input().split()]
i = 0
count = 0
while i >= 0:
	if l == b:
		count = count + 1
		break
	else:
		l = l * 3
		b = b * 2
		count = count + 1
		if l > b:
			break
	i = i + 1
print(count)


(lim, bob) = map(int, input().split())
j = 0
while bob >= lim:
	lim *= 3
	bob *= 2
	j += 1
print(j)


(bear, bigBrother) = [int(a) for a in input().split()]
count = 0
while bear <= bigBrother:
	bear *= 3
	bigBrother *= 2
	count += 1
print(count)


from typing import List

def parse_input() -> List[int]:
	return [int(x) for x in input().split()]

def solve(a: int, b: int) -> int:
	count = 0
	while a <= b:
		a *= 3
		b *= 2
		count += 1
	return count
(a, b) = parse_input()
print(solve(a, b))


from math import *
(n, m) = map(int, input().split())
res = 0
while n <= m:
	n *= 3
	m *= 2
	res += 1
print(res)


inp = list(input().split(' '))
a = int(inp[0])
b = int(inp[1])
flag = 0
counter = 1
while flag == 0:
	a *= 3
	b *= 2
	if a > b:
		print(counter)
		break
	counter += 1


(a, b) = map(int, input().split(' '))
years = 0
while b >= a:
	a = a * 3
	b = b * 2
	years += 1
	if a <= b:
		continue
	else:
		break
print(years)


str1 = input()
a = int(str1.split()[0])
b = int(str1.split()[1])
n = 0
if a == b:
	print('1')
else:
	while b >= a:
		b = 2 * b
		a = 3 * a
		n = n + 1
	print(n)


k = list(map(int, input().split()))
c = 0
while k[0] <= k[1]:
	k[0] = k[0] * 3
	k[1] = k[1] * 2
	c = c + 1
print(c)


class CodeforcesTask791ASolution:

	def __init__(self):
		self.result = ''
		self.a_b = []

	def read_input(self):
		self.a_b = [int(x) for x in input().split(' ')]

	def process_task(self):
		y = 0
		while self.a_b[0] <= self.a_b[1]:
			y += 1
			self.a_b[0] *= 3
			self.a_b[1] *= 2
		self.result = str(y)

	def get_result(self):
		return self.result
Solution = CodeforcesTask791ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(limak, bob) = map(int, input().split())
year = 0
while True:
	limak = limak * 3
	bob = bob * 2
	year = year + 1
	if limak > bob:
		break
print(year)


import sys
(a, b) = map(int, sys.stdin.readline().split(' '))
k = 0
while a <= b:
	a *= 3
	b *= 2
	k += 1
print(k)


(Limak, Bob) = list(map(int, input().split()))
Count = 0
while True:
	Count += 1
	Limak *= 3
	Bob *= 2
	if Limak > Bob:
		print(Count)
		break


n = [int(num) for num in input().split()]
a = n[0]
b = n[1]
count = 0
while True:
	a = a * 3
	b = b * 2
	count += 1
	if a > b:
		break
print(count)


def main():
	(x, y) = map(lambda x: int(x), input().split())
	count = 0
	while x <= y:
		x *= 3
		y *= 2
		count += 1
	return count
print(main())


(a, b) = input().split(' ')
a = int(a)
b = int(b)
inc = 0
while a <= b:
	a *= 3
	b *= 2
	inc += 1
print(inc)


import sys
input = sys.stdin.readline

def main():
	(a, b) = inlt()
	years = 0
	while a <= b:
		a = a * 3
		b = b * 2
		years = years + 1
	print(int(years))

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
main()


def main():
	raw = input()
	raw.split()
	(a, b) = (int(raw.split()[0]), int(raw.split()[1]))
	yrs = 0
	while a <= b:
		yrs += 1
		a *= 3
		b *= 2
	print(yrs)
main()


def main():
	(a, b) = map(int, input().split())
	anos = 0
	while a <= b:
		anos = anos + 1
		a = a * 3
		b = b * 2
	print(anos)
while True:
	try:
		main()
	except EOFError:
		break


(n, m) = map(int, input().split())
sum = 1
for i in range(100):
	n = n * 3
	m = m * 2
	if n > m:
		break
	else:
		sum = sum + 1
		continue
print(sum)


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

def func(lim, bob):
	lim *= 3
	bob *= 2
	return (lim, bob)
x = 0
while a <= b:
	(a, b) = func(a, b)
	x += 1
print(x)


(limak, bob) = [int(a) for a in input().split()]
result = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	result += 1
print(result)


(a, b) = map(int, input().split())
for i in range(1, 1000):
	a = 3 * a
	b = 2 * b
	if a > b:
		print(i)
		break


(a, b) = map(int, input().split())
ans = 0
for ans in range(1, 200):
	a = a * 3
	b = b * 2
	if a > b:
		break
print(ans)


s = input()
n = s.find(' ')
a = int(s[0:n])
b = int(s[n:len(s)])
y = 0
while a <= b:
	a = a * 3
	b = b * 2
	y = y + 1
print(y)


(a, b) = map(int, input().split())
if 1 <= a <= b <= 100:
	y = 1
	while a <= b:
		a = 3 * a
		b = 2 * b
		if a > b:
			break
		y += 1
print(y)


import sys
(a, b) = map(int, sys.stdin.readline().rstrip().split())
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(str(count) + '\n')


(a, b) = input().split()
a = int(a)
b = int(b)
x = 1
while a <= b:
	a = a * 3
	b = b * 2
	if a <= b:
		x = x + 1
print(int(x))


weight = list(map(int, input().split(' ')))
lim = weight[0]
bob = weight[1]
year = 0
while lim <= bob:
	lim = lim * 3
	bob = bob * 2
	year = year + 1
	if year > 50:
		break
print(year)


(a, l) = map(int, input().split())
i = 0
while a <= l:
	a *= 3
	l *= 2
	i += 1
print(i)


def Func():
	l = input().split()
	for i in range(20):
		if int(l[0]) * 3 ** i > int(l[1]) * 2 ** i:
			return i
print(Func())


(n, m) = input().split()
(n, m) = (int(n), int(m))
years = 0
while n <= m:
	years += 1
	n = 3 * n
	m = 2 * m
print(years)


(a, b) = map(int, input().split())
c = 0
while a <= b:
	a = 1.5 * a
	c += 1
print(c)


import sys
input = sys.stdin.readline()

def main():
	(k, v) = input.split()
	bob = int(k)
	lat = int(v)
	x = 1
	while x:
		bob = 3 * bob * x
		lat = 2 * lat * x
		if bob > lat:
			break
		else:
			x = x + 1
	print(x)
main()


(a, b) = map(int, input().split())
counter = 0
while a <= b:
	counter += 1
	a = a * 3
	b = b * 2
	if a > b:
		break
print(counter)


(p, q) = map(int, input().split())
t = 0
while p <= q:
	p *= 3
	q *= 2
	t += 1
print(t)


var = list(map(int, input().split()))
i = 0
while 1:
	i += 1
	var[0] *= 3
	var[1] *= 2
	if var[0] > var[1]:
		break
print(i)


i = input().split(' ')
a = int(i[0])
b = int(i[1])
y = 0
while True:
	if a > b:
		break
	else:
		a *= 3
		b *= 2
		y += 1
print(y)


import sys

def main(a, b):
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	return years
for (e, line) in enumerate(sys.stdin.readlines()):
	if e == 0:
		(a, b) = line.split()
print(main(int(a), int(b)))


(a, b) = input().split(' ')
a = int(a)
b = int(b)
k = 0
while a <= b:
	a = a * 3
	b = b * 2
	k += 1
print(k)


(a, b) = map(eval, input().split())
i = 1
while 3 * a <= 2 * b:
	i += 1
	a = 3 * a
	b = 2 * b
print(i)


(limak, bob) = input().split()
i = 0
limak = int(limak)
bob = int(bob)
cond = True
while cond:
	limak = limak * 3
	bob = bob * 2
	i = i + 1
	cond = limak <= bob
print(i)


l = list(map(int, input().split()))
x = l[0]
y = l[1]
c = 0
while x <= y:
	x = x * 3
	y = y * 2
	c = c + 1
print(c)


def counting_weight():
	(limak_weight, bob_weight) = map(int, input().split())
	year = 0
	while limak_weight <= bob_weight:
		limak_weight = limak_weight * 3
		bob_weight = bob_weight * 2
		year = year + 1
	print(year)
counting_weight()


(n, m) = [int(_) for _ in input().split()]
i = 1
while n <= m:
	n *= 3
	m *= 2
	i += 1
print(i - 1)


(a, b) = [int(x) for x in input().strip().split()]
cnt = 0
while a <= b:
	(a, b) = (a * 3, b * 2)
	cnt += 1
print(cnt)


a = list(map(int, input().rstrip().split()))
c = 0
while a[0] <= a[1]:
	a[0] = a[0] * 3
	a[1] = a[1] * 2
	c += 1
print(c)


from sys import stdin, stdout
import math, bisect
from collections import Counter, deque, defaultdict
L = lambda : list(map(int, stdin.readline().strip().split()))
I = lambda : int(stdin.readline().strip())
S = lambda : stdin.readline().strip()
C = lambda : stdin.readline().strip().split()
M = lambda : map(int, stdin.readline().strip().split())

def pr(a):
	print(' '.join(list(map(str, a))))
import math
from collections import defaultdict as dd

def solve(a):
	ans = 0
	c = 0
	for i in range(len(a)):
		if a[i] == '*':
			break
	for j in range(i + 1, len(a)):
		if a[j] == '*':
			c = c + 1
			ans = ans + (j - (i + c))
	return ans
(l, m) = M()
c = 0
while l <= m:
	l = l * 3
	m = m * 2
	c = c + 1
print(c)


(lim, bob) = list(map(int, input().split()))
c = 0
while lim <= bob:
	lim = lim * 3
	bob = bob * 2
	c = c + 1
print(c)


from math import log2

def main():
	(a, b) = tuple(map(int, input().strip().split()))
	print(f'{int(1 + (log2(b) - log2(a)) // (log2(3) - 1))}')
main()


(a, b) = [int(i) for i in input().split()]
sum = 0
while True:
	a *= 3
	b *= 2
	sum += 1
	if a > b:
		print(sum)
		break


li = list(map(int, input().split(' ')))
l = li[0]
b = li[1]
count = 0
while l <= b:
	count += 1
	l *= 3
	b *= 2
print(count)


input_1 = input('')

def Convert(string):
	global lista
	lista = list(string.split(' '))
	return lista
Convert(input_1)
x = int(lista[0])
y = int(lista[1])
if x <= y:
	count = 0
	while x <= y:
		x = x * 3
		y = y * 2
		count += 1
	if x > y:
		print(count)


n = input().split()
a = int(n[0])
b = int(n[1])

def wt(a, b):
	c = 0
	while a <= b:
		a = a * 3
		b = b * 2
		c = c + 1
	return c
print(wt(a, b))


(a, b) = map(int, input().strip().split()[:2])
c = 0
if a > b:
	print(0)
else:
	while b >= a:
		a = a * 3
		b = b * 2
		c = c + 1
print(c)


(limak, bob) = input().split()
(limak, bob) = (int(limak), int(bob))
yrs = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	yrs = yrs + 1
print(yrs)


(x, y) = list(map(int, input().split()))
c = 0
for i in range(1, 50):
	x = x * 3
	y = y * 2
	c = c + 1
	if x > y:
		print(c)
		break
	else:
		continue


def largestOfBears(limakAge, bobAge):
	years = 0
	while limakAge <= bobAge:
		limakAge *= 3
		bobAge *= 2
		years += 1
	return years
ages = [int(x) for x in input().split(' ')]
print(largestOfBears(ages[0], ages[1]))


s = str(input(''))
l = s.split(' ')
Limark = int(l[0])
Bob = int(l[1])
c = 1
while True:
	Limark = Limark * 3
	Bob = Bob * 2
	if Limark > Bob:
		break
	else:
		c = c + 1
print(c, end='')


[a, b] = [int(i) for i in input().strip().split(' ')]
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
res = 0
while a <= b:
	a = a * 3
	b = b * 2
	res += 1
print(res)


def year(x, y):
	n = 0
	while x <= y:
		x = x * 3
		y = y * 2
		n += 1
	return n
(x, y) = map(int, input().split())
print(year(x, y))


string = input()
n = len(string)
lis = []
result = 0
for i in range(n):
	if string[i] == ' ':
		lis.append(i)
a = int(string[0:lis[0]])
b = int(string[lis[0] + 1:])
while True:
	a = a * 3
	b = b * 2
	result = result + 1
	if a > b:
		break
print(result)


(a, b) = map(int, input().split(' '))
sum1 = a * 3
sum2 = b * 3
count = 0
while True:
	sum1 = sum1 * 3
	sum2 = sum2 * 2
	count = count + 1
	if sum1 > sum2:
		break
	else:
		continue
print(count)


(X, Y) = map(int, input().split())
d = 0
while X < Y or X == Y:
	X = X * 3
	Y = Y * 2
	d += 1
print(d)


(A, B) = input().split()
a = int(A)
b = int(B)
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


in_str = input().split()
lim = int(in_str[0])
bob = int(in_str[1])
count = 0
while True:
	if lim > bob:
		break
	else:
		lim *= 3
		bob *= 2
		count += 1
print(count)


(limak, bob) = list(map(int, input().split()))
god = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	god += 1
print(god)


(a, b) = map(int, input().split())
limak = a
bob = b
yr = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	yr += 1
print(yr)


try:
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	print(years)
except:
	pass


(a, b) = map(int, input().split())
year = 1
while a <= b:
	a = 3 * a
	b = 2 * b
	if a > b:
		print(year)
		quit()
	else:
		year = year + 1


(a, b) = input().strip().split()
a = int(a)
b = int(b)
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


(a, b) = map(lambda x: int(x), input().split())
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


x = 1
(a, b) = map(int, input().split())
while a * 3 ** (x - 1) <= b * 2 ** (x - 1):
	x += 1
print(x - 1)


(x, y) = input().split()
i = int(x)
j = int(y)
count = 0
while 1:
	if i > j:
		break
	else:
		count += 1
		i *= 3
		j *= 2
print(count)


n = list(map(int, input().rstrip().split()))
lim = n[0]
bob = n[1]
count = 0
while True:
	lim *= 3
	bob *= 2
	count += 1
	if lim > bob:
		print(count)
		quit()


(a, b) = [int(i) for i in input().split()]
yearCount = 0
while a <= b:
	a = a * 3
	b = b * 2
	yearCount += 1
if a > b:
	print(yearCount)


def read_array():
	x = []
	x1 = []
	x = input()
	x = x.split(' ')
	for r in range(len(x)):
		x1.append(int(x[r]))
	return x1

def what_is_larger(x, y):
	count = 0
	while x <= y:
		x *= 3
		y *= 2
		count += 1
	return count
x = read_array()
print(what_is_larger(x[0], x[1]))


(a, b) = [int(a) for a in input().split()]
count = 0
while a <= b:
	a = a * 3
	b = b * 2
	count += 1
print(count)


def main():
	years = 0
	(small_bear, big_bear) = map(int, input().split())
	while small_bear <= big_bear:
		small_bear = small_bear * 3
		big_bear = big_bear * 2
		years += 1
	print(years)
main()


l = []
x = 0
y = list(map(int, input().split()))
l.append(y)
for i in l:
	while i[0] <= i[1]:
		i[0] = i[0] * 3
		i[1] = i[1] * 2
		x += 1
print(x)


(a, b) = map(int, input().split())
time = 0
while True:
	time += 1
	a *= 3
	b *= 2
	if a > b:
		print(time)
		exit()


def bigBear(a, b):
	i = 0
	while a <= b:
		a = a * 3
		b = b * 2
		i += 1
	return i
ab = input().split()
a = int(ab[0])
b = int(ab[1])
result = bigBear(a, b)
print(result)


(a, b) = input().split()
a = int(a)
b = int(b)

def c(a, b):
	counter = 0
	while True:
		if a > b:
			return counter
		a = a * 3
		b = b * 2
		counter = counter + 1
print(c(a, b))


def bearBrother():
	count = 0
	(a, b) = map(int, input().split())
	while a <= b:
		a = a * 3
		b = b * 2
		count += 1
	return count
print(bearBrother())


def solve(a, b, cnt):
	if a > b:
		return cnt
	return solve(a * 3, b * 2, cnt + 1)
(a, b) = map(int, input().split())
print(solve(a, b, 0))


(a, b) = [int(x) for x in input().split()]
flag = True
i = 0
while pow(3, i) * a <= pow(2, i) * b:
	i += 1
print(i)


(limak, bob) = [int(x) for x in input().split(' ')]
year = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	year += 1
print(year)


import sys
array = input().split(' ')
for (i, val) in enumerate(array):
	array[i] = int(val)
Limak = array[0]
Bob = array[1]
count = 0
while Bob >= Limak:
	count += 1
	Limak *= 3
	Bob *= 2
print(count)


def fun():
	(a, b) = map(int, input().split())
	cnt = 0
	while a <= b:
		cnt += 1
		a = a * 3
		b = b * 2
	print(cnt)
fun()


x = input().split()
x[0] = int(x[0])
x[1] = int(x[1])
counter = 0
while True:
	if x[0] <= x[1]:
		x[0] = x[0] * 3
		x[1] = x[1] * 2
		counter += 1
	else:
		print(counter)
		break


(a, b) = tuple(map(int, input().split()))
step = 0
while a <= b:
	a *= 3
	b *= 2
	step += 1
print(step)


(a, b) = map(int, input().split())
years = 0
while a < b or a == b:
	a = a * 3
	b = b * 2
	years += 1
print(years)


(limak, bob) = input().split()
limak = int(limak)
bob = int(bob)
year = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	year += 1
print(year)


inp = input()
b1 = int(inp.split(' ')[0])
b2 = int(inp.split(' ')[1])
n = 0
while b1 <= b2:
	b1 *= 3
	b2 *= 2
	n += 1
print(n)


li = list(map(int, input().split(' ')))
lim = li[0]
bob = li[1]
count = 0
while lim <= bob:
	lim *= 3
	bob *= 2
	count += 1
print(count)


d = 0
x = input().split()
a = int(x[0])
b = int(x[1])
while a <= b:
	a *= 3
	b *= 2
	d += 1
print(d)


(a, b) = input().split()
c = 0
for i in range(100):
	a = int(a) * 3
	b = int(b) * 2
	c += 1
	if int(a) > int(b):
		break
print(c)


(a, b) = input().split()
a = int(a)
b = int(b)
l = 0
while a < b:
	l = l + 1
	a = a * 3
	b = b * 2
if a == b:
	print(l + 1)
else:
	print(l)


from sys import stdin, stdout
(a, b) = map(int, stdin.readline().rstrip().split())
i = 0
while a <= b:
	i += 1
	a *= 3
	b *= 2
stdout.write(str(i))


(a, b) = map(int, input().split())
print(next((i for i in range(200) if 3 ** i * a > 2 ** i * b)))


def get_values():
	(limak, brother) = list(map(int, input().split()))
	counter = 0
	if limak >= brother:
		return print(1)
	while limak <= brother:
		limak *= 3
		brother *= 2
		counter += 1
	return print(counter)
get_values()


(a, b) = map(int, input().split(' '))
n = b - a
if n == 0:
	n = 1
	print(n)
elif n <= 0:
	n = 0
	print(n)
else:
	c = int(n / 2)
	if a * 3 ** c - b * 2 ** c > 0:
		while a * 3 ** c - b * 2 ** c > 0:
			c -= 1
		print(c + 1)
	elif a * 3 ** c - b * 2 ** c == 0:
		print(c + 1)
	else:
		while a * 3 ** c - b * 2 ** c < 1:
			c += 1
		print(c)


x = [int(i) for i in input().split()]
weight1 = x[0]
weight2 = x[1]
years = 0
while weight2 >= weight1:
	years += 1
	weight2 *= 2
	weight1 *= 3
print(years)


(m, n) = input().split()
m = int(m)
n = int(n)
year = 0
while m <= n:
	m = 3 * m
	n = 2 * n
	year += 1
print(year)


x = input().split(' ')
flag = 0
temp1 = int(x[0])
temp2 = int(x[1])
while temp2 >= temp1:
	temp1 = temp1 * 3
	temp2 = temp2 * 2
	flag += 1
print(flag)


numbers = input().split()
A = int(numbers[0])
B = int(numbers[1])
count = 0
while A <= B:
	count += 1
	A *= 3
	B *= 2
print(count)


(n, m) = list(map(int, input().split()))
i = 0
while n <= m:
	n = 3 * n
	m = 2 * m
	i = i + 1
print(i)


(limaks_weight, bobs_weight) = map(int, input().split())
years = 0
while limaks_weight <= bobs_weight:
	limaks_weight *= 3
	bobs_weight *= 2
	years += 1
print(years)


m = input().split(' ')
(lim, bob, res) = (int(m[0]), int(m[1]), 0)
while lim <= bob:
	lim *= 3
	bob *= 2
	res += 1
print(res)


(a, b) = [int(k) for k in input().split(' ')]
year = 0
while a <= b:
	year += 1
	(a, b) = (3 * a, 2 * b)
print(year)


(l, b) = input().split()
(l, b) = (int(l), int(b))
years = 0
while l <= b:
	l *= 3
	b *= 2
	years += 1
print(years)


(b1, b2) = [int(p) for p in input().split()]
counter = 0
while b1 <= b2:
	b1 *= 3
	b2 *= 2
	counter += 1
print(counter)


(k, n) = map(int, input().strip().split())
count = 0
for i in range(100):
	if k > n:
		break
	else:
		k = k * 3
		n = n * 2
		count += 1
print(count)


def solve(a, b):
	l = a
	bo = b
	count = 0
	while l <= bo:
		l *= 3
		bo *= 2
		count += 1
	return count
(a, b) = tuple(map(int, input().split()))
print(solve(a, b))


(a, b) = map(int, input().split())
k = True
fin = 0
while k == True:
	a *= 3
	b *= 2
	fin += 1
	if a > b:
		k = False
print(fin)


x = [int(i) for i in input().split()]
a = x[0]
b = x[1]
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
	if a <= b:
		pass
	elif a > b:
		print(count)
		break


(limbark, bob) = map(int, input().split())
c = 0
while limbark <= bob:
	limbark *= 3
	bob *= 2
	c += 1
print(c)


weight = list(map(int, input().split()))
y = 0
while weight[0] <= weight[1]:
	weight[0] *= 3
	weight[1] *= 2
	y += 1
print(y)


str = input().split()
a = int(str[0])
b = int(str[1])
count = 0
if a == b:
	print('1')
else:
	while a <= b:
		a = a * 3
		b = b * 2
		count += 1
	print(count)


inp = str(input())
arr = inp.split()
a = int(arr[0])
b = int(arr[1])
count = 0
while a <= b:
	count += 1
	a = 3 * a
	b = 2 * b
print(count)


(limak, bob) = input().split()
limak = int(limak)
bob = int(bob)
year = 0
for i in range(0, 10):
	limak = limak * 3
	bob = bob * 2
	year += 1
	if limak > bob:
		break
print(int(year))


(limak, bob) = list(map(int, input().strip().split(' ')))
count = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	count += 1
print(count)


inp = input().split()
a = int(inp[0])
b = int(inp[1])
ile = 0
while b >= a:
	a = 3 * a
	b = 2 * b
	ile += 1
print(ile)


def fatBears(n, k):
	years = 1
	limak_weight = n
	bob_weight = k
	while True:
		if limak_weight * 3 > bob_weight * 2:
			return years
		else:
			years += 1
			limak_weight = limak_weight * 3
			bob_weight = bob_weight * 2
(n, k) = map(int, input().split())
print(int(fatBears(n, k)))


ab = list(map(lambda x: int(x), input().split()))
c = 0
while ab[0] <= ab[1]:
	ab[0] *= 3
	ab[1] *= 2
	c += 1
print(c)


na = input().split(' ')
k = int(na[0])
n = int(na[1])
count = 0
while k <= n:
	k *= 3
	n *= 2
	count += 1
print(count)


weight = [int(ele) for ele in input().split()]
limak = weight[0]
bob = weight[1]
count = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	count += 1
print(count)


(limak, bob) = map(int, input().split())
p = True
i = 0
while p:
	if limak > bob:
		p = False
	limak = 3 * limak
	bob = 2 * bob
	i += 1
print(i - 1)


(a, b) = map(int, input().split())
condition = True
count = 0
while condition:
	if a <= b:
		a = a * 3
		b = b * 2
		count += 1
	elif a > b:
		condition = False
print(count)


(a, b) = [int(s) for s in input().split(' ')]
cnt = 0
while a <= b:
	a *= 3
	b *= 2
	cnt += 1
print(cnt)


(a, b) = input().split(' ')
count = 0
while True:
	a = int(a) * 3
	b = int(b) * 2
	count += 1
	if a > b:
		break
print(count)


s = [int(x) for x in str(input()).split(' ')]
limak = s[0]
bob = s[1]
if limak == bob:
	print(1)
else:
	years = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		years += 1
	print(years)


(x, y) = map(int, input().split())
count = 0
if y == x:
	count = 1
else:
	while y >= x:
		count += 1
		y = y * 2
		x = x * 3
print(count)


n = input().split()
a = int(n[0])
b = int(n[1])
y = 0
while 1:
	if a <= b:
		a = a * 3
		b = b * 2
		y = y + 1
	else:
		break
print(y)


(l, n) = input().split()
l = int(l)
n = int(n)
for i in range(1, 100):
	l = l * 3
	n = n * 2
	if l > n:
		print(i)
		break


(a, b) = (0, 0)

def inp():
	global a, b
	st = input()
	a = int(st.split(' ')[0])
	b = int(st.split(' ')[1])

def solve():
	global a, b
	counter = 1
	while True:
		if 3 * a > 2 * b:
			break
		(a, b) = (3 * a, 2 * b)
		counter += 1
	return counter
inp()
print(solve())


def solve(a, b):
	i = 0
	while True:
		a = a * 3
		b = b * 2
		i = i + 1
		if a > b:
			return i
(a, b) = [int(i) for i in input().split()]
print(solve(a, b))


import math
import os
import random
import re
import sys
l = [int(i) for i in input().split(' ')]
a = l[0]
b = l[1]
c = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	c = c + 1
print(c)


n = list(map(int, input().split()))
for i in range(10):
	n[0] *= 3
	n[1] *= 2
	if n[0] > n[1]:
		break
print(i + 1)


def main():
	(a, b) = tuple(map(int, input().rstrip().split()))
	ans = 0
	while a <= b:
		(a, b) = (a * 3, b * 2)
		ans += 1
	print(ans)
main()


(ves_Limak, ves_Bob) = input().split()
ves_Limak = int(ves_Limak)
ves_Bob = int(ves_Bob)
let = 0
while ves_Limak <= ves_Bob:
	let = let + 1
	ves_Limak = ves_Limak * 3
	ves_Bob = ves_Bob * 2
print(let)


import sys
(a, b) = map(int, sys.stdin.readline().split())
ans = 0
while True:
	ans += 1
	a *= 3
	b *= 2
	if a > b:
		break
print(ans)


list_ = list(map(int, input().split()))
limak = list_[0]
bob = list_[1]
cnt = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	cnt += 1
print(cnt)


(a, b) = map(int, input().split())
count = 0
while 1:
	if a > b:
		break
	else:
		count = count + 1
		a = a * 3
		b = b * 2
print(count)


def bigger(a, b):
	i = 0
	while b >= a:
		a *= 3
		b *= 2
		i += 1
		if b < a:
			break
	return i
(A, B) = [int(i) for i in input().split()]
print(bigger(A, B))


(a, b) = map(int, input().split())
year = 1
while True:
	a = a * 3
	b = b * 2
	if a > b:
		print(year)
		break
	year += 1


(l, b) = [int(x) for x in input().split()]
c = 0
while l <= b:
	l = l * 3
	b = b * 2
	c += 1
print(c)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])
elems = inlt()
limak = elems[0]
bob = elems[1]
counter = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	counter += 1
print(counter)


(a, b) = list(map(int, input().split()))
rec_a = a
rec_b = b
i = 0
while not a > b:
	a = a * 3
	b = b * 2
	i += 1
print(i)


n = str(input())
c = n.split()
ac = c[0]
bc = c[1]
a = int(ac)
b = int(bc)
i = 0
while a <= b:
	i += 1
	a = a * 3
	b = b * 2
print(i)


numbers = list(map(int, input().split()))
limak = numbers[0]
bob = numbers[1]
i = 0
while True:
	limak *= 3
	bob *= 2
	i += 1
	if limak > bob:
		break
print(i)


lst = list(map(int, input().split()))
(a, b) = (lst[0], lst[1])
count = 0
while not a > b:
	a *= 3
	b *= 2
	count += 1
print(count)


(a, b) = map(int, input().split())
x = a / b * (3 / 2)
cnt = 1
while True:
	if x > 1:
		print(cnt)
		exit()
	else:
		x = x * (3 / 2)
		cnt += 1


from sys import stdin, stdout
(a, b) = map(int, stdin.readline().split())
c = 0
while a <= b:
	a = a * 3
	b = b * 2
	c = c + 1
print(c)


(a, b) = input().split()
a = int(a)
b = int(b)
cnt = 1
while True:
	a *= 3
	b *= 2
	if a > b:
		break
	else:
		cnt += 1
print(cnt)


def main():
	info = input().split()
	lim = int(info[0])
	bob = int(info[1])
	k = 1
	while lim <= bob:
		lim = lim * 3
		bob = bob * 2
		if lim <= bob:
			k += 1
	print(k)
main()


weight = input().split()
weight = [int(i) for i in weight]
count = 0
weight_limak = weight[0]
weight_bob = weight[1]
while weight_limak <= weight_bob:
	weight_limak *= 3
	weight_bob *= 2
	count += 1
print(count)


from itertools import count
(a, b) = [int(x) for x in input().split()]
years = 1
for i in count(start=1):
	newa = a * 3 ** i
	newb = b * 2 ** i
	if newa > newb:
		break
	else:
		years += 1
		continue
print(years)


inpt = input()
inpt = inpt.split()
a = int(inpt[0])
b = int(inpt[1])
cnt = 0
while a <= b:
	a = a * 3
	b = b * 2
	cnt += 1
print(cnt)


a = input().split()
l = int(a[0])
b = int(a[1])
t = 0

def years(x, y):
	x = x * 3
	y = y * 2
	global t
	t = t + 1
	if x > y:
		return t
	else:
		return years(x, y)
print(years(l, b))


(x, y) = list(map(int, input().split()))
n = 0
while 3 ** n * x - 2 ** n * y <= 0:
	n += 1
print(n)


(n, m) = input('').split()
n = int(n)
m = int(m)
a = 3
b = 2
for i in range(100):
	n = n * a
	m = m * b
	if n > m:
		print(i + 1)
		break
	else:
		continue


w = list(map(int, input().strip().split()))[:3]
a = w[0]
b = w[1]
flag = 0
i = 0
while flag == 0:
	if a <= b:
		a *= 3
		b *= 2
		i += 1
	else:
		flag = 1
print(i)


n = input().split()
misha = int(n[0])
brother = int(n[1])
i = 0
while misha <= brother:
	misha = misha * 3
	brother = brother * 2
	i += 1
print(i)


_input = input()
(a, b) = [int(x) for x in _input.split()]
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


(limak, bob) = map(int, input().split())
count = 0
while limak < bob or limak == bob:
	count += 1
	limak = limak * 3
	bob = bob * 2
print(count)


def calc(a, b, i):
	if a > b:
		return i
	else:
		return calc(a * 3, b * 2, i + 1)

def main():
	n = input()
	arr = [int(x) for x in n.split()]
	print(calc(arr[0], arr[1], 0))
main()


def check(limak, bob, years):
	years += 1
	limak *= 3
	bob *= 2
	if limak > bob:
		return years
	else:
		return check(limak, bob, years)
weights = input()
weights = weights.split()
limak = int(weights[0])
bob = int(weights[1])
print(check(limak, bob, 0))


(a, b) = [int(o) for o in input().split()]
t = 0
while a <= b:
	a *= 3
	b *= 2
	t += 1
print(t)


(w_limak, w_bob) = map(int, input().split())
year = 0
while w_limak <= w_bob:
	w_limak = 3 * w_limak
	w_bob = 2 * w_bob
	year += 1
	if w_limak > w_bob:
		break
print(year)


from math import log
(a, b) = map(int, input().split())
i = int(log(b / a) / log(3 / 2) + 1)
print(i)


import sys
local_launch = False
try:
	open('LOCAL').read()
	local_launch = True
except:
	pass
input_data = open('INPUT.txt').read() if local_launch else sys.stdin.read()
done = {'i': 0}
tokens = input_data.split()

def next_token():
	result = tokens[done['i']]
	done['i'] += 1
	return result

def next_int():
	return int(next_token())

def next_str():
	return next_token()
a = next_int()
b = next_int()
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


def readis():
	return map(int, input().strip().split())

def printlist(xs):
	print(' '.join(map(str, xs)))
(a, b) = readis()
years = 0
while a <= b:
	years += 1
	a *= 3
	b *= 2
print(years)


from sys import stdin
(a, b) = map(int, stdin.readline().split())
year = 0
while True:
	if a > b:
		print(year)
		break
	else:
		year += 1
		a = a * 3
		b = b * 2


(a, b) = map(int, input().split())
i = 1
while True:
	if a * pow(3, i) > b * pow(2, i):
		break
	else:
		i += 1
print(i)


(Limak, Bob) = list(map(int, input().split()))
i = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	i += 1
print(i)


def howManyYears(bears):
	if bears[0] == bears[1]:
		return 1
	else:
		years = 0
		while True:
			years = years + 1
			bears[0] = bears[0] * 3
			bears[1] = bears[1] * 2
			if bears[0] > bears[1]:
				return years
print(howManyYears(list(map(int, input().split()))))


numbers = input().split(' ')
a = int(numbers[0])
b = int(numbers[1])
counter = 0
while a <= b:
	a *= 3
	b *= 2
	counter += 1
print(counter)


x = list(map(int, input().split()))
a = x[0]
b = x[1]
k = 0
while a <= b:
	a = a * 3
	b = b * 2
	k = k + 1
print(k)


a = input().split()
a1 = int(a[0])
a2 = int(a[1])
x = 0
while a2 > a1 or a2 == a1:
	x += 1
	a2 *= 2
	a1 *= 3
print(x)


from sys import stdin
(l, b) = (int(x) for x in stdin.readline().rstrip().split())
c = 0
while l <= b:
	l *= 3
	b *= 2
	c += 1
print(c)


(a, b) = map(int, input().split())
(c, ans) = (10, 1)
while c > 0:
	(a, b) = (3 * a, 2 * b)
	if a > b:
		break
	ans += 1
print(ans)


li = [int(x) for x in input().split()]
a = li[0]
b = li[1]
i = 0
while a <= b:
	a = a * 3
	b = b * 2
	i += 1
print(i)


c = input()
l = c.split(' ')
a = int(l[0])
b = int(l[1])
x = a - b
n = 0
while x <= 0:
	a *= 3
	b *= 2
	x = a - b
	n += 1
print(n)


(x, y) = [int(x) for x in input().split()]
k = 0
while x <= y:
	x *= 3
	y *= 2
	k += 1
print(k)


num = 0
n = input().split()
a1 = n[0]
a2 = n[1]
a = int(a1)
b = int(a2)
while a <= b:
	a = a * 3
	b = b * 2
	num = num + 1
print(num)


(x, y) = [int(x) for x in input().split()]
i = 1
while i >= 1:
	x = 3 * x
	y = 2 * y
	if x > y:
		break
	else:
		i = i + 1
print(i)


def solution(a, b):
	limak_is_bigger = False
	years = 0
	while not limak_is_bigger:
		a = a * 3
		b = b * 2
		if a > b:
			limak_is_bigger = True
		years += 1
	return years
ab = input()
a = int(ab.split(' ')[0])
b = int(ab.split(' ')[1])
print(solution(a, b))


def main():
	num = list(input().split())
	(a, b) = (int(num[0]), int(num[1]))
	year = 0
	while a <= b:
		year += 1
		a *= 3
		b *= 2
	print(year)
main()


ages = list(map(int, input().split()))
count_years = 0
while ages[0] <= ages[1]:
	count_years += 1
	ages[0] = ages[0] * 3
	ages[1] = ages[1] * 2
print(count_years)


value = str(input(''))
l = value.split()
for i in range(0, 2):
	l[i] = int(l[i])
a = l[0]
b = l[1]
year = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	year = year + 1
print(year)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(a, b) = map(int, input().split())
ans = 1
while a * 3 ** ans <= b * 2 ** ans:
	ans += 1
print(ans)


(l, m) = map(int, input().split())
years = 0
while l <= m:
	years += 1
	l *= 3
	m *= 2
print(years)


from sys import exit
inp = input().split()
smol = int(inp[0])
big = int(inp[1])
if smol == big:
	print('1')
	exit()
count = 0
while True:
	smol *= 3
	big *= 2
	count += 1
	if smol > big:
		print(count)
		break


(x, y) = input().split(' ')
x = int(x)
y = int(y)
counter = 0
flag = True
while flag:
	x *= 3
	y *= 2
	counter += 1
	if x > y:
		flag = False
print(counter)


(a, b) = list(map(int, input().strip().split()))
i = 0
while True:
	if 3 ** i * a > 2 ** i * b:
		print(i)
		break
	i += 1


(a, b) = map(int, input().split())
cnt = 0
i = 1
while i:
	a *= 3
	b *= 2
	cnt += 1
	if a > b:
		print(cnt)
		break


a = list(map(int, input().split()))
c = 0
while 1 > 0:
	a[0] = 3 * a[0]
	a[1] = 2 * a[1]
	c += 1
	if a[0] > a[1]:
		break
	else:
		continue
print(c)


import math
[a, b] = input().split()
a = int(a)
b = int(b)
n = (math.log(b) - math.log(a)) / math.log(1.5)
n = int(n) + 1
print(n)


(a, b) = map(int, input().split())
y = 0
while True:
	a *= 3
	b *= 2
	if a <= b:
		y += 1
	elif a > b:
		y += 1
		break
print(y)


def log(M, a, error=1e-07):
	x = M / a
	while True:
		G = a ** x
		x = x - 1 + M / G
		if abs(M - G) <= error:
			return round(x, 6)
(a, b) = map(int, input().split())
print(int(log(b / a, 1.5)) + 1)


x = input().split()
L = int(x[0])
B = int(x[1])
years = 0
for i in range(999):
	if L > B:
		break
	L *= 3
	B *= 2
	years += 1
print(years)


import sys
input = sys.stdin.readline

def invr():
	return map(int, input().split())

def years_until_larger(a, b):
	years = 0
	while a <= b:
		(a, b) = (3 * a, 2 * b)
		years = years + 1
	return years
(a, b) = invr()
print(years_until_larger(a, b))


num = list(map(int, input().split()))
i = 0
while num[0] <= num[1]:
	num[0] *= 3
	num[1] *= 2
	i += 1
print(i)


x = input().split()
i = int(x[0])
o = int(x[1])
c = 0
if i == o:
	i = i * 3
	o = o * 2
	c = c + 1
while i < o:
	i = i * 3
	o = o * 2
	if i == o:
		i = i * 3
		o = o * 2
		c = c + 1
	c = c + 1
print(c)


(a, b) = list(map(int, input().split()))
cnt = 0
while True:
	cnt += 1
	a = a * 3
	b = b * 2
	if a > b:
		break
print(cnt)


(x, y) = input().split(' ')
x = int(x)
y = int(y)
c = 0
while x <= y:
	x = x * 3
	y = y * 2
	c = c + 1
print(c)


import math
import sys

def read_arr(dtype=int):
	return [dtype(c) for c in sys.stdin.readline().strip().split()]
(a, b) = read_arr()
n = int(math.log(b / a) / math.log(3 / 2)) + 1
print(n)


import math
(l, b) = [int(x) for x in input().split()]
x = int(math.log(b / l) / math.log(1.5))
print(x + 1)


def bigyears(a, b):
	n = 0
	while a <= b:
		a = a * 3
		b = b * 2
		n = n + 1
	return n
(a, b) = input('').split(' ')
a = int(a)
b = int(b)
print(bigyears(a, b))


import math
(l, b) = list(map(int, input().split()))
print(math.floor(math.log(b / l, 1.5)) + 1)


a = input()
(b, c) = a.split()
b = int(b)
c = int(c)
d = 1
e = 3 ** d * b
f = 2 ** d * c
while e <= f:
	d = d + 1
	e = 3 ** d * b
	f = 2 ** d * c
print(d)


input = input()
list = input.split()
limakkg = int(list[0])
bobkg = int(list[1])
count = 0
while limakkg <= bobkg:
	count += 1
	limakkg *= 3
	bobkg *= 2
print(count)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
res1 = 0
while a <= b:
	a = a * 3
	b = b * 2
	res1 += 1
print(res1)


w = input()
wgt = []
wgt = w.split()
l = int(wgt[0])
b = int(wgt[1])
y = 0
while l <= b:
	y = y + 1
	l = l * 3
	b = b * 2
print(y)


ab = input().split()
a = int(ab[0])
b = int(ab[1])
anni = 0
while a <= b:
	if a <= b:
		anni += 1
	a = 3 * a
	b = 2 * b
print(anni)


arr = [int(x) for x in input().split()]
x = arr[0]
y = arr[1]
count = 0
while x <= y:
	x = 3 * x
	y = 2 * y
	count = count + 1
print(count)


gewichte = input()
listgewichte = gewichte.split()
i = 0
for (anzahl, zahl) in enumerate(listgewichte):
	listgewichte[anzahl] = int(listgewichte[anzahl])
while listgewichte[0] <= listgewichte[1]:
	listgewichte[0] = listgewichte[0] * 3
	listgewichte[1] = listgewichte[1] * 2
	i += 1
print(i)


(n, m) = input().split()
n = int(n)
m = int(m)
count = 1
while 1 < 2:
	if n * 3 ** count > m * 2 ** count:
		print(count)
		break
	else:
		count += 1


def main():
	(a, b) = input().split(' ')
	(a, b) = (int(a), int(b))
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	print(years)
main()


input_params = input().split()
a = int(input_params[0])
b = int(input_params[1])
index = 1
while True:
	if a * 3 > b * 2:
		break
	else:
		a = a * 3
		b = b * 2
		index = index + 1
print(index)


n = list(map(int, input().split()))
t = 0
count = 1
while t == 0:
	n[0] = n[0] * 3
	n[1] = n[1] * 2
	if n[0] > n[1]:
		break
	count += 1
print(count)


import sys
(a, b) = [int(i) for i in sys.stdin.readline().split()]
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


(a, b) = input().split(' ')
a = float(a)
b = float(b)
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


(x, y) = map(int, input().split(' '))
c = 0
for i in range(10):
	if x > y:
		break
	else:
		x = x * 3
		y = y * 2
		c = c + 1
print(c)


(x, y) = [int(x) for x in input().split()]
count = 0
while True:
	x *= 3
	y *= 2
	count += 1
	if x > y:
		break
print(count)


weight = input()
lst = [int(i) for i in weight.split()]
limak = lst[0]
bob = lst[1]
time = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	time += 1
print(time)


(l, b) = [int(i) for i in input().split(' ')]
ctr = 0
while l <= b:
	ctr += 1
	l = l * 3
	b = b * 2
	if l > b:
		break
print(ctr)


def findYears(a, b):
	cnt = 0
	while a <= b:
		a = 3 * a
		b = 2 * b
		cnt += 1
	return cnt
(a, b) = map(int, input().rstrip().split())
print(findYears(a, b))


import sys
from math import log, ceil

def readlines(type=int):
	return list(map(type, sys.stdin.readline().split()))

def read(type=int):
	return type(sys.stdin.readline().strip())
joint = lambda it, sep=' ': sep.join([str(i) if type(i) != list else sep.join(map(str, i)) for i in it])

def solve(x, y):
	time = log(y / x, 1.5)
	if time - int(time) != 0.0:
		return ceil(time)
	return int(time + 1)

def main():
	(x, y) = readlines()
	print(solve(x, y))
main()


import math
ins = map(float, input().split())
(a, b) = (next(ins), next(ins))
print(int(math.log(b / a) / math.log(1.5)) + 1)


import math
(a, b) = map(int, input().split())
y = math.log(b / a) / math.log(3 / 2)
if y >= 0:
	print(int(y) + 1)


(a, b) = input().split()
a = int(a)
b = int(b)
f = 0
while a <= b:
	f = f + 1
	a = a * 3
	b = b * 2
print(f)


inp = input()
poids = inp.split(' ')
a = int(poids[0])
b = int(poids[1])
annee = 0
while a <= b:
	a *= 3
	b *= 2
	annee += 1
print(annee)


(Limak, Bob) = map(int, input().split())
Years = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	Years += 1
print(Years)


st = input()
l = st.split(' ')
a = int(l[0])
b = int(l[1])
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


greater = False
(a, b) = map(int, input().split())
counter = 0
while not greater:
	counter += 1
	a *= 3
	b *= 2
	if a > b:
		greater = True
print(counter)


def limbak(a, b):
	c = 1
	while 3 * a <= 2 * b:
		c += 1
		a = 3 * a
		b = 2 * b
	return c
(a, b) = map(int, input().split())
res = limbak(a, b)
print(res)


class bear:

	def __init__(self, weight):
		self.weight = weight

def main():
	data = list(map(int, input().split(' ')))
	limak = bear(data[0])
	bob = bear(data[1])
	years = 0
	while limak.weight <= bob.weight:
		limak.weight = limak.weight * 3
		bob.weight = bob.weight * 2
		years = years + 1
	print(years)
main()


n = list(input().split())
n1 = int(n[0])
n2 = int(n[1])
i = 0
while 1:
	i = i + 1
	n1 = n1 * 3
	n2 = n2 * 2
	if n1 > n2:
		print(i)
		break


i = lambda : map(int, input().split())
(a, b) = i()
y = 1
while True:
	if 3 * a > 2 * b:
		print(y)
		break
	else:
		y = y + 1
		a = 3 * a
		b = 2 * b


(s, b) = map(int, input().split())
i = 0
while b >= s:
	b = b * 2
	s = s * 3
	i = i + 1
print(i)


(n, m) = map(int, input().split())
k = True
c = 0
while k:
	if n > m:
		break
	n = n * 3
	m = m * 2
	c += 1
print(c)


(A, B) = input().split()
a = int(A)
b = int(B)
(wl, wb) = (a, b)
y = 0
while wl <= wb:
	wl = 3 * wl
	wb = 2 * wb
	y += 1
print(y)


weights = input().split()
small = int(weights[0])
big = int(weights[1])
current_weight_small = small
current_weight_big = big
years = 0
while current_weight_small <= current_weight_big:
	current_weight_small = current_weight_small * 3
	current_weight_big = current_weight_big * 2
	years += 1
print(years)


[m, n] = [int(x) for x in input().split()]
p = 0
while m <= n:
	m = 3 * m
	n = 2 * n
	p += 1
print(p)


text = input()
space = text.index(' ')
a = int(text[0:space])
b = int(text[space:])
ans = 0
while True:
	ans += 1
	a *= 3
	b *= 2
	if a > b:
		break
print(ans)


def main():
	year = 0
	(a, b) = [int(a) for a in input().split()]
	while a <= b:
		a *= 3
		b *= 2
		year += 1
	print(year)
main()


(limak_weight, bob_weight) = map(int, input().split())
year_needed = 0
while True:
	if limak_weight > bob_weight:
		break
	limak_weight = limak_weight * 3
	bob_weight = bob_weight * 2
	year_needed += 1
print(year_needed)


(m1, m2) = input().split()
m1 = int(m1)
m2 = int(m2)
y = 0
while m1 <= m2:
	y = y + 1
	m1 = m1 * 3
	m2 = m2 * 2
print(y)


s = input().split()
lima = int(s[0])
bob = int(s[1])
i = 0
while lima <= bob:
	lima = lima * 3
	bob = bob * 2
	i = i + 1
print(i)


a_b = input().split()
a = int(a_b[0])
b = int(a_b[1])
div = b / a
years = 0
while div >= 1:
	div /= 1.5
	years += 1
print(years)


(n, k) = map(int, input().split())
g = 0
while n <= k:
	n *= 3
	k *= 2
	g += 1
print(g)


x = [int(i) for i in input().split()]
n1 = x[0]
n2 = x[1]
count = 0
while n1 <= n2:
	n1 = n1 * 3
	n2 = n2 * 2
	count = count + 1
print(count)


w = list(map(int, input().split()))
a = 0
i = 0
while a < 10:
	if w[0] <= w[1]:
		w[0] = w[0] * 3
		w[1] = w[1] * 2
		a += 1
		i += 1
	else:
		break
print(a)


number_of_years = 0
(limak_weight, bob_weight) = map(int, input().split())
while limak_weight <= bob_weight:
	limak_weight = 3 * limak_weight
	bob_weight = 2 * bob_weight
	number_of_years += 1
print(number_of_years)


(a, b) = [int(x) for x in input().split()]
year = 1
while True:
	a = 3 * a
	b = 2 * b
	if a > b:
		print(year)
		break
	year += 1


from math import log, ceil
(a, b) = tuple(map(int, input().split()))
if a == b:
	c = 1
else:
	c = ceil(log(b / a) / log(3 / 2) + 1e-06)
print(c)


from sys import stdin

def get_required_years(weight_lima: int, weight_bob: int, passed_years=0) -> int:
	if weight_lima > weight_bob:
		return passed_years
	return get_required_years(weight_lima * 3, weight_bob * 2, passed_years + 1)
(weight_lima, weight_bob) = [int(w) for w in stdin.readline().split(' ')]
print(get_required_years(weight_lima, weight_bob))


(a, b) = input().split(' ')
a = int(a)
b = int(b)
t = 0
while a <= b:
	a = a * 3
	b = b * 2
	t = t + 1
else:
	print(t)


import math
EPS = 1e-06
(a, b) = list(map(int, input().split()))
x = math.log(a / b) / math.log(2 / 3)
if abs(math.ceil(x) - x) < EPS:
	print(math.ceil(x + 1))
else:
	print(math.ceil(x))


(limaka_ves, boba_ves) = map(int, input().split())
god = 0
while boba_ves >= limaka_ves:
	limaka_ves *= 3
	boba_ves *= 2
	god += 1
print(god)


(l, b) = list(map(int, input().split()))
count = 0
for i in range(100):
	l = 3 * l
	b = 2 * b
	count += 1
	if l > b:
		break
print(count)


from sys import stdin, stdout
input = stdin.readline

def write(n, sep='\n'):
	stdout.write(str(n))
	stdout.write(sep)

def gil():
	return list(map(int, input().split()))
(l, b) = map(int, input().split())
a = 0
while l <= b:
	l *= 3
	b *= 2
	a += 1
print(a)


(L, B) = map(int, input().split())
c = 0
while True:
	if L <= B:
		c += 1
		L = L * 3
		B = B * 2
	else:
		break
print(c)


a = input()
b = a.split(' ')
b = [int(x) for x in b]
o = b[0]
p = b[1]
counter = 0
while o <= p:
	o = o * 3
	p = p * 2
	counter = counter + 1
print(counter)


(l, b) = map(int, input().split())
i = 1
while True:
	l = 3 * l
	b = 2 * b
	if l > b:
		break
	else:
		i += 1
print(i)


(a, b) = map(int, input().split())
x = 0

def weight():
	global a, b, x
	while int(a) <= int(b):
		a = a * 3
		b = b * 2
		x += 1
	return x
print(weight())


(Linak, Bob) = map(int, input().split())
years = 0
while Bob >= Linak:
	Bob = Bob * 2
	Linak = Linak * 3
	years += 1
print(years)


import sys
(limak, bob) = sys.stdin.readline()[:-1].split()
(limak, bob) = (int(limak), int(bob))
count = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	count += 1
print(count)


__author__ = 'artyom'

def main():
	(a, b) = read(3)
	c = 0
	while a <= b:
		a += a << 1
		b <<= 1
		c += 1
	return c

def read(mode=1, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return int(input().strip())
	if mode == 2:
		return input().strip().split()
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
write(main())


from math import floor, log
(limak, bob) = map(int, input().split())

def method_2():
	n = floor(log(bob / limak) / log(3 / 2)) + 1
	print(n)
method_2()


a = list(map(int, input().split()))
x = a[0]
y = a[-1]
i = 0
c = 0
d = 0
count = 0
while i < 10000 and c != 1:
	x = x * 3
	y = y * 2
	count += 1
	if x > y:
		c = 1
print(count)


(x, y) = input().split()
x = int(x)
y = int(y)
gadi = 0
while x <= y:
	x *= 3
	y *= 2
	gadi += 1
print(gadi)


(Limak, Bob) = map(int, input().split())
cnt = 0
while True:
	cnt += 1
	Limak *= 3
	Bob *= 2
	if Limak > Bob:
		break
print(cnt)


def find_years(a, b):
	years = 0
	while a <= b:
		years += 1
		a *= 3
		b *= 2
		if a > b:
			return years
lineInput = [int(i) for i in input().split()]
a = lineInput[0]
b = lineInput[1]
print(find_years(a, b))


d = list(map(int, input().split()))
x = 0
while True:
	x += 1
	d[0] *= 3
	d[1] *= 2
	if d[0] > d[1]:
		break
print(x)


import sys, math
(a, b) = map(int, list(sys.stdin)[0].split())
print(math.ceil(math.log(a / b, 2 / 3) + 10 ** (-9)))


(L, B) = input().strip().split(' ')
year = 1
while True:
	L = int(L) * 3
	B = int(B) * 2
	if L > B:
		print(year)
		break
	year += 1


nl = input().split()
n = int(nl[0])
l = int(nl[1])
c = 0
for i in range(1, 1000):
	if n * 3 ** i > l * 2 ** i:
		print(c + 1)
		break
	else:
		c += 1


(a, b) = map(int, input().split())
if a > b:
	print("Bob's weight can not be less")
while a <= b:
	for i in range(1, 200):
		a *= 3
		b *= 2
		if a > b:
			print(i)
			break


(a, b) = list(map(int, input().split()))
y = 0
if a == b:
	print('1')
else:
	while a <= b:
		a = a * 3
		b = b * 2
		y = y + 1
	print(y)


import math
(a, b) = map(float, input().split(' '))
print(math.ceil(math.log(b / a) / math.log(1.5) + 0.0001))


try:
	(x, y) = map(int, input().split())
	c = 0
	while x <= y:
		x *= 3
		y *= 2
		c += 1
	print(c)
except:
	pass


from sys import stdout, stdin
(a, b) = map(int, stdin.readline().split(' '))
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
stdout.write(str(count) + '\n')


n = list(map(int, input().rstrip().split()))
a = n[0]
b = n[1]
i = 0
while a <= b:
	a = a * 3
	b = b * 2
	i += 1
print(i)


(x, y) = (int(v) for v in input().split())
year = 0
while x <= y:
	x *= 3
	y *= 2
	year += 1
print(year)


def inl():
	l = list(map(int, input().split()))
	return l
(x, y) = map(int, input().split())
l = 0
while 1:
	x *= 3
	y *= 2
	l += 1
	if x > y:
		print(l)
		break


s = input()
s = s.split()
s = list(map(int, s))
count = 0
while s[0] <= s[1]:
	s[0] *= 3
	s[1] *= 2
	count += 1
print(count)


(a, b) = map(int, input().split())
c = 0
if a >= 1 and b >= 1 and (a <= 100) and (b <= 100):
	while True:
		x = a * 3
		y = b * 2
		c += 1
		if x > y:
			print(c)
			break
		else:
			a = x
			b = y


def wgh(a, b):
	k = 0
	while a <= b:
		a = a * 3
		b = b * 2
		k += 1
	return k
arr = list(map(int, input().split()))
print(wgh(arr[0], arr[1]))


(n, k) = map(int, input().split())
year = 0
while True:
	year += 1
	n = n * 3
	k = k * 2
	if n > k:
		break
print(year)


count = 0
t = list(map(int, input().rstrip().split()))
while t[1] >= t[0]:
	t[0] = t[0] * 3
	t[1] = t[1] * 2
	count = count + 1
print(count)


user = input()
(a, b) = (0, 0)
ind = user.index(' ')
a = user[:ind]
b = user[ind + 1:]
a = int(a)
b = int(b)
count = 0
while True:
	if a > b:
		break
	else:
		a = a * 3
		b = b * 2
		count = count + 1
print(count)


def calc_weight(l, b, year):
	if l > b:
		return year
	return calc_weight(3 * l, 2 * b, year + 1)
(limak, bob) = list(map(lambda x: int(x), input().split(' ')))
print(calc_weight(3 * limak, 2 * bob, 1))


(weight_limak, weight_bob) = input().split()
weight_limak = int(weight_limak)
weight_bob = int(weight_bob)
years = 0
while weight_limak <= weight_bob:
	years += 1
	weight_limak *= 3
	weight_bob *= 2
print(years)


(m, n) = map(int, input().split())
for i in range(1000):
	m = m * 3
	n = n * 2
	if m > n:
		print(i + 1)
		break


(aLimak, bBob) = map(int, input().split())
e = 0
while aLimak <= bBob:
	aLimak = aLimak * 3
	bBob = bBob * 2
	e += 1
print(e)


(a, b) = map(int, input().split())
y = 0
while not a > b:
	a *= 3
	b *= 2
	y += 1
print(y)


(x, y) = input().split()
x = int(x)
y = int(y)
res = 0
while res >= 0:
	y *= 2
	x *= 3
	res += 1
	if x > y:
		print(res)
		break


import sys
inputs = [int(i) for i in input().split()]
multiple = 0
while inputs[0] <= inputs[1]:
	inputs[0] = 3 * inputs[0]
	inputs[1] = 2 * inputs[1]
	multiple += 1
print(multiple)


import math
(a, b) = (int(x) for x in input().split())
print(math.floor(math.log(b / a, 3 / 2) + 1))


(a, b) = list(map(int, input().split()))
for i in range(100):
	if a <= b:
		a = 3 * a
		b = 2 * b
		i = i + 1
		if a > b:
			print(i)


import math
(a, b) = (int(i) for i in input().split())
l = math.log(a / b, 2 / 3)
if math.ceil(l) - l < 0.001:
	l = math.ceil(l)
else:
	l = math.floor(l)
print(l + 1)


a = input()
a.strip()
w = a.split()
c = 0
while int(w[0]) <= int(w[1]):
	w[0] = int(w[0]) * 3
	w[1] = int(w[1]) * 2
	c = c + 1
print(c)


(l, b) = input().split()
l = int(l)
b = int(b)
k = 0
while True:
	if l > b:
		break
	else:
		k += 1
		l *= 3
		b *= 2
print(k)


all = [int(i) for i in input().split()]
a = all[0]
b = all[1]
count = 1
for i in range(100):
	a = a * 3
	b = b * 2
	if a <= b:
		count += 1
	else:
		break
print(count)


(a, b) = map(int, input().rstrip().split())
if a == b:
	print(1)
else:
	cn = 0
	while a <= b:
		a *= 3
		b *= 2
		cn += 1
	print(cn)


s = input()
c = []
c = s.split(' ')
a = int(c[0])
b = int(c[1])
j = 0
if a == b:
	print(1)
else:
	while a <= b:
		a *= 3
		b *= 2
		j += 1
	print(j)


import math

def main():
	(a, b) = list(map(int, input().split()))
	if a == b:
		print('1')
	else:
		print(math.floor(math.log(b / a, 1.5) + 1))
main()


h = input()
r = h.split()
x = int(r[0])
y = int(r[1])
year = 0
while y >= x:
	x *= 3
	y *= 2
	year += 1
print(year)


l1 = list(map(int, input().rstrip().split()))
a = l1[0]
b = l1[1]
c = 0
while True:
	a = a * 3
	b = b * 2
	c = c + 1
	if a > b:
		print(c)
		break


class Solution:

	def solve(self, a, b):
		count = 0
		while b >= a:
			b *= 2
			a *= 3
			count += 1
		return count
sol = Solution()
[a, b] = list(map(int, input().strip().split()))
print(sol.solve(a, b))


(x, y) = input().split(' ')
x = int(x)
y = int(y)
year = 1
while year:
	if x > y:
		break
	else:
		x = x * 3
		y = y * 2
		year += 1
print(year - 1)


prob = [int(weight) for weight in input().split()]
output = 0
while prob[0] <= prob[1]:
	(prob[0], prob[1]) = (prob[0] * 3, prob[1] * 2)
	output += 1
print(output)


(a, b) = input().split()
a = int(a)
b = int(b)
count = 0
for i in range(1000):
	count = count + 1
	a = a * 3
	b = b * 2
	if a > b:
		break
print(count)


one = input().split()
a = int(one[0])
b = int(one[1])
god = 1
while a * 3 <= b * 2:
	god += 1
	a = a * 3
	b = b * 2
print(god)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
if 1 <= a <= b <= 100:
	x = 1
	for i in range(1, 100):
		a = 3 * a * i
		b = 2 * b * i
		if a > b:
			print(x)
			break
		x = x + 1


poids = list(map(int, input().split()))
n = 0
while poids[0] <= poids[1]:
	poids[0] *= 3
	poids[1] *= 2
	n += 1
print(n)


ab = input().split(' ')
(a, b) = (int(ab[0]), int(ab[1]))
years = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	years += 1
print(years)


(l, b) = list(map(int, input().split()))
years = 0
while True:
	if l > b:
		break
	l *= 3
	b *= 2
	years += 1
print(years)


def check_weight(lim, bob):
	years = 0
	while bob >= lim:
		years += 1
		bob = 2 * bob
		lim = 3 * lim
	return years
(lim, bob) = map(int, input().split())
print(check_weight(lim, bob))


text_input = input()
(a, b) = text_input.split(' ')
a = int(a)
b = int(b)
lata = 0
while a <= b:
	a = a * 3
	b = b * 2
	lata += 1
print(lata)


x = input()
data = x.split(' ')
a = int(data[0])
b = int(data[1])
r = 0
while a <= b:
	a *= 3
	b *= 2
	r += 1
print(r)


(pesoLimak, pesoBob) = input().split()
(pesoLimak, pesoBob) = (int(pesoLimak), int(pesoBob))
cont = 0
while pesoLimak <= pesoBob:
	pesoLimak *= 3
	pesoBob *= 2
	cont += 1
print(cont)


(aa, bb) = map(int, input().split())
aaa = 1
while aa * 3 ** aaa <= bb * 2 ** aaa:
	aaa = aaa + 1
print(aaa)


import math
line = input()
(a, b) = (int(x) for x in line.split())
totYears = 0
while a <= b:
	a *= 3
	b *= 2
	totYears += 1
print(totYears)


y = input()
weight = y.split(' ')
b1 = int(weight[0])
b2 = int(weight[1])
year = 0
while b1 <= b2:
	b1 = b1 * 3
	b2 = b2 * 2
	year += 1
print(year)


import math
(a, b) = input().split()
c = math.ceil(math.log(int(b) / int(a)) / math.log(1.5))
if int(a) * math.pow(3, int(c)) > int(b) * math.pow(2, int(c)):
	print(c)
else:
	print(c + 1)


(a, b) = list(map(int, input().split()))
c = 1
while True:
	a *= 3
	b *= 2
	if a > b:
		break
	c += 1
print(c)


import math

def bigBear(a, b):
	yearWithFloat = math.log(b / a) / math.log(1.5)
	year = math.ceil(yearWithFloat)
	return year if year > yearWithFloat else year + 1
(a, b) = map(float, input().split())
print(bigBear(a, b))


(a, b) = map(int, input().split())
compteur = 0
for i in range(10):
	while b >= a:
		a = a * 3
		b = b * 2
		compteur = compteur + 1
print(compteur)


k = 0
i = 0
(a, b) = map(int, input().split(' '))
while i == 0:
	a *= 3
	b *= 2
	k += 1
	if a > b:
		i = 1
print(k)


(Limak, bob) = [int(x) for x in input().split()]
year = 0
for i in range(100):
	Limak = Limak * 3
	bob = bob * 2
	year += 1
	if Limak > bob:
		print(year)
		break


from math import log
(l, b) = (int(i) for i in input().strip().split(' '))
y = log(b / l, 10) / log(3 / 2, 10)
print(int(y) + 1)


(x3, x2) = map(int, input().split(' '))
end = False
if x3 == x2:
	print(1)
	end = True
year = 0
while not end:
	year += 1
	x3 *= 3
	x2 *= 2
	if x3 > x2:
		print(year)
		end = True


weights = input().split()
weights = [int(weight) for weight in weights]
years = 0
while True:
	if weights[0] > weights[1]:
		print(years)
		break
	else:
		weights[0] *= 3
		weights[1] *= 2
		years += 1


def function(limak, bob):
	i = 1
	while True:
		limak = limak * 3
		bob = bob * 2
		if limak > bob:
			return i
		else:
			i += 1
(limak, bob) = input().split()
limak = int(limak)
bob = int(bob)
print(function(limak, bob))


(n1, n2) = map(int, input().split())
n = 0
while n2 >= n1:
	n += 1
	n1 *= 3
	n2 *= 2
print(n)


from math import log, floor
(a, b) = [float(x) for x in input().split()]
print(int(floor(log(b / a, 1.5)) + 1))


x = list(map(int, input().split()))
i = 0
f = 5
a = x[0]
b = x[1]
if a < b:
	while f == 5:
		a = 3 * a
		b = 2 * b
		i += 1
		if a > b:
			print(i)
			exit()
if a >= b:
	i += 1
print(i)


def main():
	(a, b) = list(map(int, input().split()))
	if a > b:
		print(0)
	else:
		c = 0
		bearandbrother(a, b, c)

def bearandbrother(a, b, c):
	c += 1
	a = a * 3
	b = b * 2
	if a <= b:
		bearandbrother(a, b, c)
	elif a > b:
		print(c)
main()


(Limak, Bob) = [int(x) for x in input().split()]
num = 0
while Limak <= Bob:
	Limak = Limak * 3
	Bob = Bob * 2
	num += 1
	pass
print(num)


(a, b) = map(int, input().split())
c = 0
for i in range(20):
	a = a * 3
	b = b * 2
	if a <= b:
		c += 1
	else:
		break
print(c + 1)


a = input()
a = a.split(' ')
c = int(a[0])
k = int(a[1])
i = 0
while c <= k:
	c *= 3
	k *= 2
	i += 1
print(i)


xyz = []

def input1():
	global xyz
	if len(xyz) == 0:
		xyz = [i for i in input().split()]
		xyz = xyz[::-1]
	v = xyz[-1]
	del xyz[-1]
	return v
l = int(input1())
b = int(input1())
n = 0
for x in range(1000):
	if l > b:
		break
	l = l * 3
	b = b * 2
	n = n + 1
print(n)


str = input().split()
l = int(str[0])
b = int(str[1])
count = 0
while True:
	l = l * 3
	b = b * 2
	count += 1
	if l > b:
		break
print(count)


def main():
	(n, m) = map(int, input().split())
	counter = 1
	while n < m:
		n = n * 3
		m = m * 2
		if n > m:
			break
		counter += 1
	print(counter)
main()


(a, b) = map(int, input().split())
year = 0
while True and a <= b:
	a = 3 * a
	b = 2 * b
	year += 1
print(year)


a = [int(i) for i in input().split(' ')]
n = a[0]
m = a[1]
k = 0
while n <= m:
	k = k + 1
	n = n * 1.5
print(k)


(l, b) = input().split()
l = int(l)
b = int(b)
x = 0
while l <= b:
	l = l * 3
	b = b * 2
	x = x + 1
print(x)


def solution(a, b):
	t = 0
	while a <= b:
		a = 3 * a
		b = 2 * b
		t = t + 1
	return t
(a, b) = list(map(int, input().split()))
print(solution(a, b))


def year(l1, b1, n1):
	n = n1
	n = n + 1
	l = l1 * 3
	b = b1 * 2
	if int(l) <= int(b):
		return year(l, b, n)
	if int(l) > int(b):
		return n
inp = input().split(' ')
Limak = int(inp[0])
Bob = int(inp[1])
if Limak <= Bob:
	n = year(Limak, Bob, 0)
print(n)


import math
g = lambda x: map(x, input().split())

def main():
	(a, b) = g(int)
	n = math.log(b / a) // math.log(1.5)
	n += not a * 3 ** n > b * 2 ** n
	n = int(n)
	print(n)
main()


pesos = input()
pesos = pesos.split()
pesoLimak = int(pesos[0])
pesoBob = int(pesos[1])
anos = 0
while pesoLimak <= pesoBob:
	anos += 1
	pesoLimak = pesoLimak * 3
	pesoBob = pesoBob * 2
print(anos)


n = list(map(int, input().split(' ')))
a = n[0]
b = n[1]
y = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	y += 1
	if a > b:
		print(y)
		break
	else:
		continue


(liam, bob) = [int(element) for element in input().split()]
years = 0
while bob >= liam:
	liam = 3 * liam
	bob = 2 * bob
	years += 1
print(years)


a = [int(i) for i in input().split()]
key = 0
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	key += 1
print(key)


def main():
	(a, b) = [int(i) for i in input().split()]
	years = 0
	while a <= b:
		years += 1
		a = a * 3
		b = b * 2
	print(years)
main()


import math
import os
import random
import re
import sys
(lw, bw) = input().split(' ')

def bearandbigbrother(a, b):
	(x, y) = (int(a), int(b))
	count = 0
	while x <= y:
		x *= 3
		y *= 2
		count += 1
	print(count)
bearandbigbrother(lw, bw)


import math
input = input().split()
a = int(input[0])
b = int(input[1])
ret = math.log(b / a) / math.log(3 / 2)
ret = int(ret) + 1
print(ret)


def great(a, b):
	counter = 0
	while a <= b:
		a = 3 * a
		b = 2 * b
		counter = counter + 1
	print(counter)
n = input().split(' ')
great(int(n[0]), int(n[1]))


x = 0
(a1, b1) = map(int, input().split())
while b1 >= a1:
	a1 *= 3
	b1 *= 2
	x += 1
print(x)


(a, b) = input().split()
(a, b) = (int(a), int(b))
goda = 0
while a <= b:
	a *= 3
	b *= 2
	goda += 1
print(goda)


(limak, bob) = [int(x) for x in input().split(' ')]
year = 0
while 1:
	if limak > bob:
		break
	else:
		limak = limak * 3
		bob = bob * 2
		year = year + 1
print(year)


import math
(a, b) = input().split()
a = int(a)
b = int(b)
log1 = -math.log(a / b, 1.5)
if log1 % 1 == 0:
	print(int(log1 + 1))
else:
	print(math.ceil(log1))


def we(li, bo):
	y = 0
	while li <= bo:
		li = li * 3
		bo = bo * 2
		y += 1
	return y
i = list(map(int, input().split()))
li = i[0]
bo = i[1]
print(we(li, bo))


def solve(l, b):
	years = 0
	while l <= b:
		l *= 3
		b *= 2
		years += 1
	return years
(l, b) = [int(x) for x in input().split()]
print(solve(l, b))


i = str(input()).split(' ')
L = int(i[0])
B = int(i[1])
y = 0
while L <= B:
	L *= 3
	B *= 2
	y += 1
print(y)


def yearc(a, b):
	year = 0
	while 1:
		if a * 3 > b * 2:
			year += 1
			return year
		else:
			a *= 3
			b *= 2
			year += 1
(a, b) = input().split()
a = int(a)
b = int(b)
print(yearc(a, b))


(limak, brother) = map(int, input().split())
year = 0
while limak <= brother:
	limak *= 3
	brother *= 2
	year += 1
print(year)


import math
(x, y) = input('').split(' ')
a = int(x)
b = int(y)
n = math.log10(a / b) / math.log10(2 / 3)
print(math.floor(n + 1))


(limak, bob) = map(int, input().split())
year = 0
if limak == bob:
	print(1)
else:
	while limak < bob:
		limak = limak * 3
		bob = bob * 2
		year = year + 1
	if limak == bob:
		print(year + 1)
	else:
		print(year)


from sys import stdin, stdout
from math import gcd, sqrt, floor, ceil
input = stdin.readline

def list_inp(x):
	return list(map(x, input().split()))

def map_inp(x):
	return map(x, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
(a, b) = map(int, input().split())
if a == b:
	print(1)
else:
	cnt = 0
	while a <= b:
		if a > b:
			break
		a *= 3
		b *= 2
		cnt += 1
	print(cnt)


from typing import List

def solve(a: int, b: int) -> int:
	for i in range(100):
		if a > b:
			return i
		a *= 3
		b *= 2
	assert False

def compare(user_answer: int, jury_answer: int) -> bool:
	return user_answer == jury_answer
print(solve(*map(int, input().split())))


(small, big) = map(int, input().strip().split())
years = 0
while small <= big:
	small = 3 * small
	big = 2 * big
	years += 1
print(years)


(Limak, Bob) = input().split(' ')
(Limak, Bob) = (int(Limak), int(Bob))
year = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	year += 1
print(year)


from math import log, ceil
entre = list(map(int, input().split(' ')))
res = log(entre[1] / entre[0]) / log(3 / 2)
if int(res) == ceil(res):
	print(ceil(res + 1))
else:
	print(ceil(res))


line = input()
(limak, bob) = map(int, line.split())
res = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	res += 1
print(res)


(p1, p2) = input().split()
p1 = int(p1)
p2 = int(p2)
n = 0
while p1 <= p2:
	p1 = 3 * p1
	p2 = 2 * p2
	n += 1
	if p1 > p2:
		print(n)


from math import log, ceil
(a, b) = map(int, input().split())
if log(b / a, 1.5) == ceil(log(b / a, 1.5)):
	print(ceil(log(b / a, 1.5)) + 1)
else:
	print(ceil(log(b / a, 1.5)))


import math
(a, b) = [int(k) for k in input().split()]
n = math.log(b / a, 1.5)
if n == int(n):
	print(int(n + 1))
else:
	print(math.ceil(n))


(SA, SB) = input().split()
A = int(SA)
B = int(SB)
I = 0
while A <= B:
	A = A * 3
	B = B * 2
	I = I + 1
print(I)


def read():
	return [int(x) for x in input().split()]
(x, y) = read()
i = 0
while x <= y:
	x *= 3
	y *= 2
	i += 1
print(i)


phoon = input().split()
for i in range(len(phoon)):
	phoon[i] = int(phoon[i])
thay = 0
while phoon[0] <= phoon[1]:
	thay += 1
	phoon[0] = 3 * phoon[0]
	phoon[1] = 2 * phoon[1]
print(thay)


(A, B) = map(int, input().split())
SUM = 0
K = False
while K is False:
	A *= 3
	B *= 2
	SUM += 1
	K = A > B
print(SUM)


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

def solve(a, b):
	out = 0
	while a <= b:
		a = 3 * a
		b = 2 * b
		out = out + 1
	return out
print(solve(a, b))


(n, x) = map(int, input().split())
res = 0
while n <= x:
	n = n * 3
	x = x * 2
	res += 1
	if n > x:
		break
print(res)


(a, b) = map(int, input().split())
i = 1
while a * 3 ** i <= b * 2 ** i:
	i += 1
print(i)


from builtins import input
(a, b) = map(int, input().split())
n = 0
while a <= b:
	a = a * 3
	b = b * 2
	n = n + 1
print(n)


str = input()
pos = str.find(' ')
a = int(str[:pos])
b = int(str[pos + 1:])
y = 0
while a <= b:
	y = y + 1
	a = 3 * a
	b = 2 * b
print(y)


arrayInput = input().split()
limak = int(arrayInput[0])
bob = int(arrayInput[1])
answer = 0
while bob >= limak:
	limak *= 3
	bob *= 2
	answer += 1
print(answer)


inp = list(map(int, input().split()))
result = 0
while inp[0] <= inp[1]:
	result += 1
	inp[0] = inp[0] * 3
	inp[1] = inp[1] * 2
print(result)


def sum_year(a, b):
	year = 0
	while a <= b:
		year += 1
		a *= 3
		b *= 2
	return year
(a, b) = [int(x) for x in input().split()]
res = sum_year(a, b)
print(res)


(bear, b_brother) = map(int, input().split())
t = 0
while bear <= b_brother:
	bear *= 3
	b_brother *= 2
	t += 1
print(t)


array = input().split()
a = int(array[0])
b = int(array[1])
num = 0
while a <= b:
	a = a * 3
	b = b * 2
	num += 1
print(num)


(limak_age, bob_age) = [int(elem) for elem in input().split(' ')]
year = 0
while limak_age <= bob_age:
	limak_age = limak_age * 3
	bob_age = bob_age * 2
	year += 1
	if limak_age > bob_age:
		print(year)


limak_bob = list(map(int, input().split()))
year = 0
while limak_bob[0] <= limak_bob[1]:
	limak_bob[0] = int(limak_bob[0]) * 3
	limak_bob[1] = int(limak_bob[1]) * 2
	year += 1
print(year)


N = input()
string = N.split(' ')
(a, b) = (int(string[0]), int(string[1]))
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


import math
(a, b) = [int(x) for x in input().split()]
X = math.log(b / a) / math.log(1.5)
count = 0
if X % 1 == 0:
	count = 1
print(math.ceil(X) + count)


m = input().split()
m = [int(i) for i in m]
l = m[0]
b = m[1]
a = 0
while l <= b:
	l *= 3
	b *= 2
	a += 1
print(a)


a_b = input().split()
a = int(a_b[0])
b = int(a_b[1])
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


(a, b) = map(int, input().split())
if a == b:
	print('1')
else:
	cnt = 0
	while a <= b:
		a *= 3
		b *= 2
		cnt += 1
	print(cnt)


(x, y) = input().split(' ')
a = (x, y)
a = list(a)
for i in range(len(a)):
	a[i] = int(a[i])
count = 0
while a[0] <= a[1]:
	count += 1
	a[0] = a[0] * 3
	a[1] = a[1] * 2
print(count)


lst = list(map(int, input().split()))
cnt = 0
while lst[0] <= lst[1]:
	lst[0] = lst[0] * 3
	lst[1] = lst[1] * 2
	cnt = cnt + 1
print(cnt)


line = input().split()
l = int(line[0])
b = int(line[1])
t = 0
while l <= b:
	l = 3 * l
	b = 2 * b
	t = t + 1
print(t)


(l, b) = [int(i) for i in input().split()]
number_of_years = 0
while l <= b:
	l = l * 3
	b = b * 2
	number_of_years += 1
print(number_of_years)


a = input()
count = 0
(person1, person2) = a.split(' ')
(person1, person2) = (int(person1), int(person2))
while person1 <= person2:
	person2 = person2 * 2
	person1 = 3 * person1
	count += 1
print(count)


s = input().split()
c = 0
(s[0], s[1]) = (int(s[0]), int(s[1]))
while s[0] <= s[1]:
	c += 1
	s[0] = 3 * s[0]
	s[1] = 2 * s[1]
print(c)


(limak, bob) = [int(num) for num in input().split()]
counter = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	counter += 1
print(counter)


weights = input().split()
limak = int(weights[0])
bob = int(weights[1])
cont = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	cont += 1
print(cont)


list = input()
list = list.split()
bear = int(list[0])
bear1 = int(list[1])
num = 0
while bear <= bear1:
	bear *= 3
	bear1 *= 2
	num += 1
print(num)


def countLimakGrowth(a, b):
	leapYear = 0
	while a <= b:
		a *= 3
		b *= 2
		leapYear += 1
	return leapYear

def main():
	(a, b) = map(int, input().split())
	print(countLimakGrowth(a, b))
main()


weight = list(map(int, input().split()))
year = 0
while True:
	weight[0] = weight[0] * 3
	weight[1] = weight[1] * 2
	year = year + 1
	if weight[0] > weight[1]:
		break
print(year)


[x, y] = list(map(int, input().split()))
for i in range(1, 1000):
	if 3 ** i * x > 2 ** i * y:
		print(i)
		break


(wl, wb) = [int(x) for x in input().split()]
ans = 0
while wl <= wb:
	wl *= 3
	wb *= 2
	ans += 1
print(ans)


r = lambda : map(int, input().split())
(n, w) = r()
c = 0
while n <= w:
	n *= 3
	w *= 2
	c += 1
print(c)


list1 = list(map(int, input().split()))
a = list1[0]
b = list1[1]
years = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	years += 1
	if a > b:
		print(years)


(x, y) = [int(i) for i in input().split()]
for i in range(1, y + 1):
	x = x * 3
	y = y * 2
	if x > y:
		print(i)
		break


import sys
data = sys.stdin.readlines()
limak = int(data[0].split()[0])
bob = int(data[0].split()[1])
years = 0
while limak <= bob:
	limak = 3 * limak
	bob = 2 * bob
	years += 1
sys.stdout.write(str(years))


def f(a, b):
	c = 0
	while True:
		if a > b:
			return c
		else:
			a = a * 3
			b = b * 2
			c = c + 1
(a, b) = map(int, input().split())
print(f(a, b))


a = input().split()
count = 0
a = [int(a[i]) for i in range(len(a))]
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	count += 1
print(count)


def solution(a, b):
	count = 0
	while a <= b:
		a *= 3
		b *= 2
		count += 1
	print(count)
inputline = input().split()
solution(int(inputline[0]), int(inputline[1]))


inp = input().split(' ')
a = int(inp[0])
b = int(inp[1])
i = 0
if a == b:
	print(1)
else:
	while a < b:
		a = a * 3
		b = b * 2
		i = i + 1
	if a == b:
		i = i + 1
	print(i)


(a, b) = map(int, input().split())
c = 0
for _ in range(10010):
	if a > b:
		break
	a *= 3
	b *= 2
	c += 1
print(c)


a = input().split(' ')
y = 0
ll = int(a[0])
bb = int(a[1])
while True:
	if ll > bb:
		break
	ll = ll * 3
	bb = bb * 2
	y += 1
print(y)


(lim, bob) = map(int, input().split())
i = 1
while True:
	lim *= 3
	bob *= 2
	if lim > bob:
		print(i)
		break
	i += 1


import sys, math, string
input = sys.stdin.readline
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
(a, b) = M()
i = 1
while a * pow(3, i) <= b * pow(2, i):
	i += 1
print(i)


import time
input1 = list(input().split(' '))
val1 = int(input1[0])
val2 = int(input1[1])
counter = 0
if val1 <= val2:
	while val1 <= val2:
		val1 = val1 * 3
		val2 = val2 * 2
		counter += 1
print(counter)


(n, m) = input().split()
n = int(n)
m = int(m)
c = 0
for i in range(n * m):
	c = c + 1
	n = 3 * n
	m = 2 * m
	if n > m:
		break
print(c)


import math
(a, b) = map(int, input().split())
y = math.log(b / a) / math.log(1.5)
y_upper = math.ceil(y)
print(y_upper) if math.ceil(y) > y else print(math.ceil(y) + 1)


l = input().split()
lst = [int(each) for each in l]
a = lst[0]
b = lst[1]
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


(limak, bob) = map(int, input().strip().split())
counter = 0
while True:
	limak = limak * 3
	bob = bob * 2
	counter += 1
	if limak > bob:
		break
print(counter)


import math
(a, b) = input().split(' ')
a = int(a)
b = int(b)
y = math.floor(math.log(b / a, 1.5) + 1)
print(y)


(Limak, Bob) = map(int, input().split())
sayi = 0
for i in range(10):
	Limak = Limak * 3
	Bob = Bob * 2
	sayi = sayi + 1
	if Limak > Bob:
		print(sayi)
		break


x = input().split()
a = int(x[0])
b = int(x[1])
c = int(0)
while True:
	c = int(c) + 1
	a = int(a) * 3
	b = int(b) * 2
	if a > b:
		print(c)
		break


(a, b) = input().split()
A = int(a)
B = int(b)
if 1 <= A <= B <= 50:
	for i in range(9999999):
		if A * 3 ** i > B * 2 ** i:
			print(i)
			break


ip = input().split()
a = int(ip[0])
b = int(ip[1])
i = 0
while True:
	if a > b:
		print(i)
		break
	i = i + 1
	a = a * 3
	b = b * 2


(a, b) = input().split()
a = int(a, 10)
b = int(b, 10)
l = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	l += 1
print(l)


(x, y) = map(int, input().split())
c = 0
i = 1
while c < 1:
	x *= 3
	y *= 2
	if x > y:
		c = 1
		print(i)
		break
	i += 1


from math import floor, log2
print(int((lambda a, b: (log2(b) - log2(a)) // (log2(3) - 1))(*map(int, input().split()))) + 1)


ageInput = input()
ageList = ageInput.split(' ')
Limak = int(ageList[0])
Bob = int(ageList[1])
count = 0
while Limak <= Bob:
	count = count + 1
	Limak = Limak * 3
	Bob = Bob * 2
print(count)


wt = input()
l = wt.split()
a = int(l[0])
b = int(l[1])
(x, y) = (a, b)
(yrs, i) = (0, 0)
while i == 0:
	(a, b) = (x, y)
	if a > b:
		print(yrs)
		i += 1
	else:
		x = 3 * a
		y = 2 * b
		yrs += 1


a = input().split(' ')
w = int(a[0])
h = int(a[1])
p = 0
while h >= w:
	w *= 3
	h *= 2
	p += 1
print(p)


def iip():
	return int(input())

def sip():
	return input()

def mip():
	return map(int, input().split())

def lip():
	return list(map(int, input().split()))
(a, b) = mip()
count = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	count += 1
print(count)


weights = str(input())
weights_list = weights.split(' ')
a = int(weights_list[0])
b = int(weights_list[1])
years = 0
while a <= b:
	a = a * 3
	b = b * 2
	years += 1
print(years)


(n, m) = input().split()
nw = int(n)
mw = int(m)
y = 0
while nw <= mw:
	nw = nw * 3
	mw = mw * 2
	y = y + 1
print(y)


(a, b) = [int(x) for x in input().split()]
v = False
c = 0
while v == False:
	a *= 3
	b *= 2
	c += 1
	if a > b:
		v = True
print(c)


(a, b) = map(int, input().split())
i = 0
if a == b:
	print(1)
else:
	while 'true':
		a = 3 * a
		b = 2 * b
		i += 1
		if a > b:
			print(i)
			break


f = [int(x) for x in input().split()]
k = f[0]
n = f[1]
x = 0
while k <= n:
	k = k * 3
	n = n * 2
	x += 1
print(x)


(a, b) = [int(i) for i in input().split()]
i = a
j = b
h = 0
while a <= b:
	a = i * 3
	b = j * 2
	h += 1
	i = a
	j = b
print(h)


y = 0

def bigger(a, b, y):
	while a <= b:
		a = a * 3
		b = b * 2
		y = y + 1
	return y
(a, b) = input().split()
a = int(a)
b = int(b)
print(bigger(a, b, y))


import sys
(a, b) = map(int, input().split())
n = 1
while True:
	if a * 3 ** n > b * 2 ** n:
		print(n)
		sys.exit(0)
	else:
		n += 1


def solve(a, b):
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	return years

def main():
	(a, b) = map(int, input().split(' '))
	print(solve(a, b))
main()


l = list(map(int, input().split()))
limak = l[0]
bob = l[1]
c = 0
if limak == bob:
	print(1)
else:
	while limak <= bob:
		c += 1
		limak *= 3
		bob *= 2
	print(c)


inp = list(map(int, input().split()))
a = inp[0]
b = inp[1]
t = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	t = t + 1
print(t)


(bear_a, bear_b) = map(int, input().split())
count = 0
while bear_b >= bear_a:
	count += 1
	bear_a *= 3
	bear_b *= 2
print(count)


def check_wieght(limak, bob):
	if limak == bob:
		return 1
	count = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		count += 1
	if limak > bob:
		return count
	if limak == bob:
		return limak
(limak, bob) = [int(x) for x in input().split()]
print(check_wieght(limak, bob))


lst = list(map(int, input().split()))
l = lst[0]
b = lst[1]
i = 0
while l <= b:
	l = l * 3
	b = b * 2
	i += 1
print(i)


l = [int(e) for e in input().split(' ')]
i = 1
while i:
	if l[0] * 3 ** i > l[1] * 2 ** i:
		print(i)
		break
	i += 1


import sys

def getMultiLineInput() -> []:
	lines = []
	while True:
		try:
			lines.append(input())
		except EOFError:
			break
	return lines

def calculateYear(arg1: int, arg2: int) -> int:
	bearLimak = arg1
	bearBob = arg2
	yearToTake = 0
	while bearLimak <= bearBob:
		bearLimak *= 3
		bearBob *= 2
		yearToTake += 1
	return yearToTake
inputs = getMultiLineInput()
weights = inputs[0].split()
year = calculateYear(int(weights[0]), int(weights[1]))
print(str(year))


def main():
	(a, b) = map(int, input().split())
	cnt = 0
	while 1:
		cnt = cnt + 1
		a *= 3
		b *= 2
		if a > b:
			print(cnt)
			break
main()


i = input()
li = list(i.split(' '))
a = int(li[0])
b = int(li[1])
j = int(0)
while True:
	a = a * 3
	b = b * 2
	j += 1
	if a > b:
		break
print(j)


import math
(a, b) = input().split()
nyears = math.floor(math.log(float(b) / float(a)) / math.log(1.5)) + 1
print(nyears)


k = list(map(int, input().split()))
s = int(k[0])
d = int(k[1])
t = 0
while s <= d:
	s = s + s + s
	d = d + d
	t += 1
print(t)


li = [int(x) for x in input().split()]
(l, m) = (int(li[0]), int(li[1]))
count = 0
while l <= m:
	l = l * 3
	m = m * 2
	count = count + 1
print(count)


(a, b) = map(int, input().split())
k = 0
if a == b:
	print(1)
	exit()
while True:
	a = a * 3
	b = b * 2
	k = k + 1
	if a > b:
		print(k)
		break


(a, b) = map(int, input().split())
year = 0
while True:
	if not a > b:
		year = year + 1
		a = a * 3 * year
		b = b * 2 * year
	else:
		break
print(year)


x = input().split(' ')
d = []
count = 0
for i in x:
	d.append(int(i))
while d[0] <= d[1]:
	d[0] = d[0] * 3
	d[1] = d[1] * 2
	count = count + 1
print(count)


(limak, bob) = input().split()
count_year = 0
weight_limak = int(limak)
weight_bob = int(bob)
while weight_limak <= weight_bob:
	weight_limak *= 3
	weight_bob *= 2
	count_year += 1
print(count_year)


from sys import stdin, stdout

def get_ints():
	return map(int, stdin.readline().strip().split())
(a, b) = get_ints()
year = 0
while True:
	if a > b:
		break
	a = a * 3
	b = b * 2
	year += 1
stdout.write(str(year))


var = input()
limark_weight = int(var.split()[0])
bob_weight = int(var.split()[1])
years: int = 0
while limark_weight <= bob_weight:
	limark_weight = limark_weight * 3
	bob_weight = bob_weight * 2
	years += 1
print(years)


(a, b) = map(int, input().split())
c = 0
x = a
y = b
while a <= b:
	a += 2 * a
	b += b
	c += 1
print(c)


def bears(a, b):
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	return years
data = input()
(a, b) = map(int, data.split())
print(bears(a, b))


def l2i(s):
	return [int(i) for i in s.split()]
(a, b) = l2i(input())
t = 0
while a <= b:
	a *= 3
	b *= 2
	t += 1
print(t)


years = 0
(n, k) = map(int, input().split())
while True:
	if n > k:
		break
	else:
		n *= 3
		k *= 2
		years += 1
print(years)


(a, b) = map(int, input().split())
ans = 1
isTrue = True
while isTrue:
	a *= 3
	b *= 2
	if a > b:
		isTrue = False
		break
	ans += 1
print(ans)


from math import log, ceil
c = 0
(a, b) = map(int, input().split())
while a <= b:
	a *= 3
	b *= 2
	c += 1
print(c)


(a, b) = map(int, input().split())
c = 0
for i in range(11):
	if a <= b:
		a = a * 3
		b = b * 2
		c = c + 1
print(c)


(a1, b1) = input().split()
a = int(a1)
b = int(b1)
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


import math
(a, b) = [float(num) for num in input().split(' ')]
i = math.ceil(math.log(a / b, 2.0 / 3))
if a * 3 ** i == b * 2 ** i:
	print(i + 1)
else:
	print(i)


(a, b) = eval(input().replace(' ', ','))
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


(a, b) = list(map(int, input().split()))
for i in range(a + b):
	x = 3 ** i * a - 2 ** i * b
	if x > 0:
		c = i
		break
print(c)


(limik, bob) = input().split(' ')
limik = int(limik)
bob = int(bob)
years = 0
while True:
	years += 1
	limik = limik * 3
	bob = bob * 2
	if limik > bob:
		break
print(years)


(u, s) = map(int, input().split())
count = 0
while 1:
	count += 1
	u = u * 3
	s = s * 2
	if u > s:
		break
print(count)


_1 = '236a'
_2 = '339a'
_3 = '266a'
_4 = '96a'
_5 = '236a'
_6 = '281a'
_7 = '546a'
s = 0
(a, b) = map(int, input().split())
while a <= b:
	a *= 3
	b *= 2
	s += 1
print(s)


num = input()
arr = []
count = 0
for i in range(0, len(num)):
	if num[i] == ' ':
		arr.append(int(num[count:i]))
		count = i + 1
	elif i == len(num) - 1:
		arr.append(int(num[count:len(num)]))
over_weight = False
year = 0
while over_weight == False:
	if arr[0] > arr[1]:
		over_weight = True
	else:
		year += 1
		arr[0] = arr[0] * 3
		arr[1] = arr[1] * 2
print(year)


(a, b) = map(int, input().split())
import math as m
k = m.ceil(m.log(b / a) / m.log(3 / 2))
if a * 3 ** k == b * 2 ** k:
	k += 1
print(k)


(s1, b1) = input().split()
s = int(s1)
b = int(b1)
count = 0
while s <= b:
	s = s * 3
	b = b * 2
	count = count + 1
print(count)


import math
(n, k) = map(int, input().split())
ans = 0
while n <= k:
	n *= 3 / 2
	ans += 1
print(ans)


variables = input('')
lista = variables.split(' ')
a = int(lista[0])
b = int(lista[1])
i = 0
while i >= 0:
	a = a * 3
	b = b * 2
	i = i + 1
	if a > b:
		print(i)
		break


import sys

def main():
	(a, b) = map(int, sys.stdin.readline().split())
	r = 0
	while a <= b:
		r += 1
		a *= 3
		b *= 2
	print(r)
main()


lst = [int(x) for x in input().split()]
counter = 0
while True:
	if lst[0] > lst[1]:
		break
	else:
		counter = counter + 1
		lst[0] = lst[0] * 3
		lst[1] = lst[1] * 2
print(counter)


def sol(l, b):
	y = 0
	while l <= b:
		l *= 3
		b *= 2
		y = y + 1
	return y
(l, b) = map(int, input().split())
print(sol(l, b))


line = input().split(' ')
limak = int(line[0])
bob = int(line[1])
no_years = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	no_years += 1
print(no_years)


(L, B) = input().split(' ')
L = int(L)
B = int(B)
count = 0
while L <= B:
	L = 3 * L
	B = 2 * B
	count += 1
print(count)


(L, B) = map(int, input().split())
years = 0
while L <= B:
	L *= 3
	B *= 2
	years += 1
print(years)


(x, y) = [int(x) for x in input().split(' ')]
t = 0
for i in range(10000):
	if x > y:
		break
	else:
		x = x * 3
		y = y * 2
		t = t + 1
print(t)


import math
(a, b) = map(int, input().split(' '))
c = math.log(b / a, 1.5)
d = math.ceil(c)
if d == c:
	d += 1
else:
	d = d
print(d)


(Limak, Bob) = [int(i) for i in input().split()]
count = 0
while Limak <= Bob:
	Limak = 3 * Limak
	Bob = 2 * Bob
	count += 1
print(count)


lst = input().split()
a = int(lst[0])
b = int(lst[1])
year = 0
while a <= b:
	year += 1
	a *= 3
	b *= 2
print(year)


(s, b) = list(map(int, input().split()))
i = 0
while 1:
	if s > b:
		print(i)
		break
	else:
		s = 3 * s
		b = 2 * b
	i += 1


def limak(a, b):
	year = 0
	while True:
		if a > b:
			return year
		year += 1
		a = 3 * a
		b = 2 * b
i = input()
i = i.split()
a = int(i[0])
b = int(i[1])
print(limak(a, b))


import math
f = lambda a, b: 1 + math.floor(math.log10(b / a) / math.log10(1.5))
(a, b) = map(int, input().split())
print(f(a, b))


k = list(map(int, input().split()))
i = 0
while k[1] > k[0]:
	k[0] *= 3
	k[1] *= 2
	i += 1
if k[1] == k[0]:
	i += 1
print(i)


(a, b) = input('').split()
a = int(a)
b = int(b)
out = 0
while a <= b:
	a = a * 3
	b = b * 2
	out += 1
print(out)


(a_, b_) = input('').split()
count = 0
a = int(a_)
b = int(b_)
while a <= b:
	a = 3 * a
	b = 2 * b
	count += 1
print(count)


(a, b) = map(int, input().split())
count = 0
while True:
	if a > b:
		print(count)
		quit()
	else:
		a *= 3
		b *= 2
		count += 1


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

def calculateWhenLiBecomedLarger(liW, bobW):
	count = 0
	while liW <= bobW:
		count = count + 1
		liW = liW * 3
		bobW = bobW * 2
	print(count)
calculateWhenLiBecomedLarger(weight[0], weight[1])


a = list(map(int, input().split()))
limak = a[0]
bob = a[1]
s = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	s += 1
print(s)


(l, b) = [int(i) for i in input().split()]
c = 0
while True:
	l *= 3
	b *= 2
	c += 1
	if l > b:
		break
print(c)


(a, b) = map(int, input().split(' '))
for i in range(100):
	if a * 3 ** i > b * 2 ** i:
		print(i)
		break


(a, b) = input().split(' ')
(a, b) = (int(a), int(b))
t = 0
while a <= b:
	t += 1
	a += 2 * a
	b += b
print(t, flush=True)


ip = input()
l = ip.split(' ')
a = int(l[0])
b = int(l[1])
c = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	c += 1
if c == 0:
	c = 1
print(c)


(a, b) = input().split()
year = 0
a = int(a)
b = int(b)
for i in range(30):
	if a < b or a == b:
		a = 3 * a
		b = 2 * b
		year = year + 1
print(year)


s = input().split()
a = int(s[0])
b = int(s[1])
p = 0
while True:
	p += 1
	a *= 3
	b *= 2
	if a > b:
		break
print(p)


def bear_brother():
	(limak, bob) = [int(x) for x in input().split(' ')]
	years = 0
	while limak <= bob:
		years += 1
		limak *= 3
		bob *= 2
	return years
print(bear_brother())


s = input()
s = s.split(' ')
s = [int(x) for x in s]
count = 0
while s[0] <= s[1]:
	s[0] *= 3
	s[1] *= 2
	count += 1
print(count)


(l, m) = [int(x) for x in input().split()]
count = 0
a = 1
if l > m:
	print(count)
	a = 0
while a == 1:
	l = l * 3
	m = m * 2
	count += 1
	if l > m:
		print(count)
		break


(s, m) = map(int, input().split())
i = 1
while True:
	s *= 3
	m *= 2
	if s > m:
		break
	i += 1
print(i)


(w1, w2) = [int(i) for i in input().strip().split()]
year_count = 0
while w1 <= w2:
	w1 *= 3
	w2 *= 2
	year_count += 1
print(year_count)


weight = list(map(int, input().split()))
yearc = 0
while weight[0] < weight[1] or weight[0] == weight[1]:
	yearc = yearc + 1
	weight[0] = weight[0] * 3
	weight[1] = weight[1] * 2
print(yearc)


import math
(x, y) = map(float, input().split())
r = math.log(y / x) / math.log(1.5) + 1
r = int(math.floor(r))
print(r)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
sys.setrecursionlimit(100000000)
ii = lambda : int(input())
si = lambda : input()
jn = lambda x, l: x.join(map(str, l))
sl = lambda : list(map(str, input().strip()))
mi = lambda : map(int, input().split())
mif = lambda : map(float, input().split())
lii = lambda : list(map(int, input().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
(a, b) = mi()
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


t = input().split()
a = int(t[0])
b = int(t[1])
c = 0
while a < b or a >= b:
	if a > b:
		print(c)
		break
	else:
		a = 3 * a
		b = 2 * b
		c += 1


(lemakw, bobw) = map(int, input().split())
year = 0
while lemakw <= bobw:
	lemakw = lemakw * 3
	bobw = bobw * 2
	year += 1
print(year)


l = lambda : map(int, input().split())
(x, y) = l()
i = 0
while x <= y:
	x *= 3
	y *= 2
	i = i + 1
print(i)


ab = input()
ab = ab.split()
a = int(ab[0])
b = int(ab[1])
y = 0
while y >= 0:
	if a <= b:
		a = 3 * a
		b = 2 * b
		y += 1
	if a > b:
		print(y)
		break


xyz = []

def input1():
	global xyz
	if len(xyz) == 0:
		xyz = [i for i in input().split()]
		xyz = xyz[::-1]
	v = xyz[-1]
	del xyz[-1]
	return v
L = int(input1())
B = int(input1())
z = 0
while B >= L:
	L = L * 3
	B = B * 2
	z = z + 1
	if L > B:
		print(z)
		break


def banyak_tahun(a, b, count):
	c = a * 3
	d = b * 2
	if c <= d:
		banyak_tahun(c, d, count + 1)
	else:
		print(count)
(a, b) = list(map(int, input().split()))
banyak_tahun(a, b, 1)


x = input().split(' ')
lenght = len(x)
count = 0
a = int(x[0])
b = int(x[1])
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


(limak, Bob) = input().split()
limak = int(limak)
Bob = int(Bob)
year = 0
while limak <= Bob:
	year = year + 1
	limak = limak * 3
	Bob = Bob * 2
print(year)


(a, b) = input().split()
i = int(a)
j = int(b)
for c in range(1, 1000000):
	if i * 3 > j * 2:
		break
	else:
		i = i * 3
		j = j * 2
print(c)


def BearAndBigBrother():
	(a, b) = map(int, input().strip().split())
	y = 0
	while a <= b:
		a *= 3
		b *= 2
		y += 1
	return y
a = BearAndBigBrother()
print(a)


(a, b) = map(int, input().split())
c = 3 * a
d = 2 * b
n = 1
while True:
	if c > d:
		break
	else:
		c = 3 * c
		d = 2 * d
		n = n + 1
		continue
print(n)


lst = list(input().split())
x = [int(elem) for elem in lst]
count = 0
while x[0] <= x[1]:
	x[0] *= 3
	x[1] *= 2
	count += 1
print(count)


(m, n) = map(int, input().split())
i = 1
while i != 0:
	if m > n:
		print(i - 1)
		break
	else:
		m = m * 3
		n = n * 2
	i = i + 1


mylist = []
x = input().split()
for i in range(2):
	mylist.append(int(x[i]))
a = mylist[0]
b = mylist[1]
(k, m) = (0, 0)
while a <= b:
	a = a + a + a
	b = b + b
	k += 1
print(k)


(first, second) = [int(age) for age in input().split()]
k = 0
while first <= second:
	k += 1
	first *= 3
	second *= 2
print(k)


(a, b) = map(int, input().split())
n = 1
while n > 0:
	if a * pow(3, n) > b * pow(2, n):
		print(n)
		break
	n = n + 1


import os
(limak, bob) = list(map(int, input().rstrip().split()))
year = 0
while bob >= limak:
	year += 1
	bob *= 2
	limak *= 3
print(year)


i = list(input().split(' '))
limak = int(i[0])
bob = int(i[1])
year = 0
flag = 1
while flag:
	limak *= 3
	bob *= 2
	if limak > bob:
		flag = 0
	year += 1
print(year)


weight = input()
weight_list = weight.split(' ')
limak = int(weight_list[0])
bob = int(weight_list[1])
years = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	years += 1
print(years)


def calculate(a, b):
	i = 0
	while a <= b:
		a *= 3
		b *= 2
		i += 1
	return i
(a, b) = input().rstrip().split()
print(calculate(int(a), int(b)))


(a, b) = map(int, input().strip().split())
years = 0
if a > b:
	(a, b) = (b, a)
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


x = list(map(int, input().strip().split()))
(a, b) = (x[0], x[1])
c = 0
while 1:
	if a > b:
		print(c)
		break
	else:
		a = a * 3
		b = b * 2
	c = c + 1


l1 = list(map(int, input().split(' ')))
a = l1[0]
b = l1[1]
n = 0
while a <= b:
	a *= 3
	b *= 2
	n += 1
print(n)


(a, b) = map(int, input().split())
count = 0
for i in range(1, 1000000):
	if a > b:
		print(count)
		break
	else:
		a *= 3
		b *= 2
		count += 1
		continue


read = input()
read = read.split(' ')
i = 0
while int(read[0]) <= int(read[1]):
	read[0] = int(read[0]) * 3
	read[1] = int(read[1]) * 2
	i = i + 1
print(i)


inputs = input()
a = int(inputs.split(' ')[0])
b = int(inputs.split(' ')[1])
m = 0
while a <= b:
	a = a * 3
	b = b * 2
	m = m + 1
print(m)


import math
(a, b) = map(int, input().split())
answer = math.log(b / a, 3 / 2)
answer = int(answer) + 1 if round(answer, 1).is_integer() else math.ceil(answer)
if answer < 0:
	answer = 0
print(answer)


(n, k) = input().split()
n = int(n)
k = int(k)
i = 0
while k >= 3 * n / 2:
	n = 3 * n
	k = 2 * k
	i = i + 1
print(i + 1)


def check(a, b):
	if a == b:
		return 1
	c = 0
	while a < b:
		a = a * 3
		b = b * 2
		c += 1
		if a == b:
			c += 1
	return c
(a, b) = map(int, input().split())
ans = check(a, b)
print(ans)


(small, big) = [int(x) for x in input().split()]
year = 1
while small * 3 <= big * 2:
	year += 1
	small = small * 3
	big = big * 2
print(year)


n = list(map(int, input().split()))
years = 0
while True:
	years += 1
	n[0] = n[0] * 3
	n[1] = n[1] * 2
	if n[0] > n[1]:
		break
print(years)


line = input()
(small, big) = line.split()
(small, big) = (int(small), int(big))
years = 0
while small <= big:
	years = years + 1
	small = small * 3
	big = big * 2
print(years)


(limak, bob) = input().split()

def years(l, b, y):
	if l > b:
		print(y)
	else:
		return years(l * 3, b * 2, y + 1)
years(int(limak), int(bob), 0)


def Solution(Limak, Bob):
	year = 0
	while True:
		if Limak <= Bob:
			year += 1
			Limak *= 3
			Bob *= 2
		elif Limak >= Bob:
			return year
(l, b) = map(int, input().split())
print(Solution(l, b))


(wLima, wBob) = map(int, input().split())
year = 0
while wLima <= wBob:
	year += 1
	wLima = wLima * 3
	wBob = wBob * 2
print(year)


m = list(map(int, input().split()))
a = m[0]
b = m[1]
k = 0
while True:
	a *= 1.5
	k += 1
	if a > b:
		break
print(k)


import math
(a, b) = input().split()
a = int(a)
b = int(b)
year = 0
while a <= b:
	year += 1
	a = 3 * a
	b = 2 * b
print(year)


a = input() + ' '
b = ''
A = []
for j in range(len(a)):
	if a[j] == ' ':
		A.append(int(b))
		b = ''
	else:
		b += a[j]
i = 0
while A[1] >= A[0]:
	A[0] = A[0] * 3
	A[1] = A[1] * 2
	i += 1
print(i)


def read_tokens():
	return input().strip().split(' ')

def read_ints():
	return [int(s) for s in read_tokens()]
(a, b) = read_ints()

def solve(a, b) -> int:
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	return years
print(solve(a, b))


txt = [int(n) for n in input().split()]
i = 0
while True:
	i += 1
	txt[0] *= 3
	txt[1] *= 2
	if txt[0] > txt[1]:
		break
print(i)


(a, b) = map(int, input().split())
k = 0
for i in range(1, 500):
	a = a * 3
	b = b * 2
	k += 1
	if a > b:
		break
print(k)


ab = input().split(' ')
a = int(ab[0])
b = int(ab[1])
years = 0
while True:
	years += 1
	a = a * 3
	b = b * 2
	if a > b:
		break
print(years)


(n, m) = map(int, input().split())
cnt = 0
while True:
	cnt += 1
	n *= 3
	m *= 2
	if n > m:
		print(cnt)
		break


(LW, BW) = map(int, input().split())
y = 0
while LW <= BW:
	LW = 3 * LW
	BW = 2 * BW
	y += 1
print(y)


import math
(a, b) = map(int, input().split())
tmp = math.log(b / a) / math.log(3 / 2)
print(math.floor(tmp) + 1)


weight = list(map(int, input().split()))
small = weight[0]
big = weight[1]
num_years = 0
while small <= big:
	small = 3 * small
	big = 2 * big
	num_years += 1
print(num_years)


(a, b) = list(map(int, input().split()))
count = 0
r = True
while b >= a:
	a = 3 * a
	b = 2 * b
	count += 1
print(count)


from math import log2, ceil
(a, b) = map(int, input().split())
if a == b:
	print(1)
else:
	print(ceil(log2(b / a) / (log2(3) - 1)))


(a, b) = (int(val) for val in input().split(' '))
years_of_gluteny = 0
while a <= b:
	a *= 3
	b *= 2
	years_of_gluteny += 1
print(years_of_gluteny)


(a, b) = map(int, input().split())
ans = 1
while 3 * a <= 2 * b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


z = input()
(a, b) = list(map(int, z.split()))
x = 0
for i in range(0, 1000):
	while a <= b:
		a = a * 3
		b = b * 2
		x += 1
print(x)


(a, b) = input().split()
limak = int(a)
bob = int(b)
years = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	years += 1
print(years)


(a, b) = map(int, input().split())
count = 0
for i in range(b):
	if a <= b:
		a = a * 3
		b = b * 2
		count = count + 1
print(count)


import sys

def gets():
	return sys.stdin.readline().strip()

def get():
	return int(sys.stdin.readline().strip())

def geti():
	return map(int, sys.stdin.readline().strip().split())

def getli():
	return list(map(int, sys.stdin.readline().strip().split()))
(a, b) = geti()
c = 1
while a <= b:
	a *= 3
	b *= 2
	c += 1
if c != 1:
	print(c - 1)
else:
	print(c)


x = list(map(int, input().split()))
cont = 0
while x[0] <= x[1]:
	cont = cont + 1
	x[0] *= 3
	x[1] *= 2
print(cont)


(l, b) = [int(s) for s in input().split()]
count = 0
while l <= b:
	l = l * 3
	b = b * 2
	count += 1
print(count)


inpu = input().split(' ')
limak = int(inpu[0])
bob = int(inpu[1])
i = 0
if limak <= bob:
	while True:
		limak = limak * 3
		bob = bob * 2
		i += 1
		if limak > bob:
			break
print(i)


def large(lima, bro, count):
	if lima > bro:
		return count
	count = count + 1
	return large(lima * 3, bro * 2, count)
(lima, bro) = [int(i) for i in input().split()]
count = 0
count = large(lima, bro, 0)
print(count)


import math
(a, b) = [int(i) for i in input().split(' ')]
print(int(math.log(a / b, 2 / 3) + 1e-05) + 1)


def main():
	(a, b) = (int(x) for x in input().split())
	it = 0
	while a <= b:
		a = 3 * a
		b = 2 * b
		it = it + 1
	print(it)
main()


n = [int(x) for x in input().split()]
limak = n[0]
bob = n[1]
result = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	result += 1
print(result)


(n, k) = input().split()
k = int(k)
n = int(n)
output = 0
for i in range(k):
	n = n * 3
	k = k * 2
	if n > k:
		output += 0
	else:
		output += 1
print(output + 1)


from sys import stdin, stdout
(l, b) = [int(c) for c in stdin.readline().split()]
res = 0
while l <= b:
	l *= 3
	b *= 2
	res += 1
stdout.write(str(res))


from math import log, floor, ceil
(a, b) = list(map(int, input().strip().split()))
print(floor(log(b / a) / log(3 / 2) + 1))


a = [int(i) for i in input().split()]
for j in range(1, 100):
	a[0] *= 3
	a[1] *= 2
	if a[0] > a[1]:
		print(j)
		break


(a, b) = list(map(int, input().strip().split()))
lst = []
x = a
y = b
while x <= y:
	x = x + x * 2
	y = y + y
	lst.append(x)
print(len(lst))


size = input().split()
a = int(size[0])
b = int(size[1])
x = 1
r = True
while r:
	na = a * 3 ** x
	nb = b * 2 ** x
	if na > nb:
		print(x)
		r = False
	x += 1


(a_, b_) = map(int, input().split())
year = 0
while True:
	year += 1
	(a_, b_) = (3 * a_, 2 * b_)
	if a_ > b_:
		break
print(year)


def solve(b):
	years = 0
	while b[0] <= b[1]:
		b[0] *= 3
		b[1] *= 2
		years += 1
	return years

def main(b):
	b = b.split(' ')
	b = [int(b_str) for b_str in b]
	print(solve(b))
b = input()
main(b)


def BearAndBigBrother(a, b):
	a = int(a)
	b = int(b)
	result = 0
	while a <= b:
		a = a * 3
		b = b * 2
		result += 1
		if a > b:
			return result
		else:
			continue
(u, l) = [int(i) for i in input().split()]
print(BearAndBigBrother(u, l))


import math
(x, y) = map(int, input().split())
print(math.floor(math.log10(x / y) / math.log10(2 / 3)) + 1)


def limak(l, b):
	y = 0
	while l <= b:
		l *= 3
		b *= 2
		y += 1
	return y
inp = list(map(int, input().rstrip().split()))
l = inp[0]
b = inp[1]
print(limak(l, b))


(n, k) = [int(i) for i in input().split(' ')]
count = 0
while n <= k:
	n *= 3
	k *= 2
	count += 1
print(count)


import math
(a, b) = [int(x) for x in input().split()]
z = math.log(b) - math.log(a)
q = math.log(3) - math.log(2)
n = int(z / q) + 1
limax = a * 3 ** n
bob = b * 2 ** n
if limax > bob:
	print(n)
else:
	print(n + 1)


(a, b) = input().split()
(a, b) = (int(a), int(b))
counter_boi = 0
while b >= a:
	a *= 3
	b *= 2
	counter_boi += 1
print(counter_boi)


def bear():
	n = input()
	l = list()
	y = 0
	for i in n.split(' '):
		l.append(int(i))
	while l[0] <= l[1]:
		l[0] = l[0] * 3
		l[1] = l[1] * 2
		y = y + 1
	print(y)
bear()


(a, b) = list(map(int, input().split()))
(aa, bb) = (a, b)
years = 0
while aa <= bb:
	aa *= 3
	bb *= 2
	years += 1
print(years)


L = input()
L = L.split()
a = int(L[0])
b = int(L[1])
f = 0
i = 0
while f == 0:
	a *= 3
	b *= 2
	i += 1
	if a > b:
		f = 1
print(i)


x = input()
l = x.split()
a = int(l[0])
b = int(l[1])
count = 0
while b > a:
	a = a * 3
	b = b * 2
	count = count + 1
if a == b:
	count = count + 1
print(count)


(a, b) = map(int, input().split())
n = 100
for i in range(1, n + 1):
	a = 3 * a
	b = 2 * b
	if a > b:
		print(i)
		break
	else:
		pass


(lamak, bob) = map(int, input().split())
day = 0
while lamak <= bob:
	day += 1
	lamak *= 3
	bob *= 2
print(day)


list1 = input().split()
(limak, bob) = (int(list1[0]), int(list1[1]))
x = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	x += 1
print(x)


(a, b) = input().split(' ')
wl = int(a)
wb = int(b)
years = 0
while wl <= wb:
	wl = wl * 3
	wb = wb * 2
	years = years + 1
print(years)


(a, b) = list((int(x) for x in input().split()))
c = 0
while a <= b:
	a = a * 3
	b = b * 2
	c += 1
print(c)


(x, y) = list(map(int, input().split()))
years = 0
while x <= y:
	x *= 3
	y *= 2
	years += 1
	if x > y:
		break
print(years)


from sys import stdin, stdout

def read_line():
	return stdin.readline()

def print(value):
	stdout.write(str(value))
(a, b) = map(int, read_line().split(' '))
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


import sys
x = [int(i) for i in input().split()]
a = x[0]
b = x[1]
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


get = input()
get = [int(x) for x in get.split(' ')]
counter = 0
while True:
	if get[0] > get[1]:
		break
	get[0] = get[0] * 3
	get[1] = get[1] * 2
	counter += 1
print(counter)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
year = 0
while 1 == 1:
	if a > b:
		print(year)
		break
	else:
		a = a * 3
		b = b * 2
	year += 1


values = input()
ValuesSterl = values.split(' ')
values = [int(x.strip()) for x in ValuesSterl]
a = values[0]
b = values[1]
num_years = 1
while a < b:
	a = a * 3
	b = b * 2
	if a > b:
		break
	num_years += 1
print(num_years)


temp = 0
(x, y) = map(int, input().split())
greater = False
while x <= y:
	x *= 3
	y *= 2
	temp += 1
print(temp)


(a, b) = map(int, input().split())
result = 0
while True:
	a *= 3
	b *= 2
	result += 1
	if a > b and a != b:
		break
print(result)


s = input()
tempA = s[:s.find(' ')]
tempB = s[s.find(' '):]
a = int(tempA)
b = int(tempB)
year = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	year += 1
print(year)


(a, b) = [int(x) for x in input().split() if x.isdigit()]
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


weights = input().split(' ')
limak_weight = int(weights[0])
bob_weight = int(weights[1])
years = 0
while bob_weight >= limak_weight:
	limak_weight = limak_weight * 3
	bob_weight = bob_weight * 2
	years += 1
print(years)


(limak, bob) = [int(i) for i in input().split(' ')]
years = 0
while True:
	years = years + 1
	limak = limak * 3
	bob = bob * 2
	if limak > bob:
		break
print(years)


import math
(a, b) = [int(i) for i in input().split()]
i = 1
while a * 3 ** i <= b * 2 ** i:
	i += 1
print(i)


(a, b) = map(int, input().split())
r = 0
while 1:
	if a > b:
		print(r)
		exit()
	r += 1
	a *= 3
	b *= 2


(c, t) = map(int, input().split())
a = 0
while c <= t:
	c *= 3
	t *= 2
	a += 1
print(a)


(limak, bob) = map(int, input().split())
count = 1
while True:
	limak = limak * 3
	bob = bob * 2
	if limak > bob:
		years = count
		break
	count += 1
print(years)


n = input()
li = list(map(int, n.split(' ')))
i = 1
while i <= max(li[0], li[1]):
	if li[0] * 3 ** i > li[1] * 2 ** i:
		print(i)
		break
	i = i + 1


def main():
	(limakWeight, bobWeight) = input().split()
	limakWeight = int(limakWeight)
	bobWeight = int(bobWeight)
	i = 0
	while limakWeight * 3 ** i <= bobWeight * 2 ** i:
		i += 1
	print(i)
	return ()
main()


(x, y) = [int(z) for z in input().split()]
years = 0
while x <= y:
	years += 1
	x *= 3
	y *= 2
print(years)


lb = list(map(int, input().split()))
l = lb[0]
b = lb[1]
years = 0
while l <= b:
	l *= 3
	b *= 2
	years += 1
print(years)


import sys
(a, b) = sys.stdin.readline().split()
(a, b) = (int(a), int(b))
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
sys.stdout.write(str(years) + '\n')


a = list(map(int, input().split()))
year = 0
while True:
	if a[0] > a[1]:
		break
	else:
		year += 1
		a[0] *= 3
		a[1] *= 2
print(year)


(aori, bori) = map(int, input().split())
a = aori
b = bori
ans = 0
while True:
	a = 3 * a
	b = 2 * b
	ans += 1
	if a > b:
		print(ans)
		break


weights = input()
weights = weights.split()
Limak = int(weights[0])
Bob = int(weights[1])
c = 0
for i in range(10):
	Limak = Limak * 3
	Bob = Bob * 2
	c += 1
	if Limak > Bob:
		print(c)
		break


weightsList = input().split(' ')
limarksWeight = int(weightsList[0])
bobsWeight = int(weightsList[1])
noOfYears = 0
while limarksWeight <= bobsWeight:
	noOfYears += 1
	limarksWeight = 3 * limarksWeight
	bobsWeight = 2 * bobsWeight
print(noOfYears)


from math import log, ceil
(a, b) = map(int, input().split(' '))
n = 1
while 1.5 ** n <= b / a:
	n += 1
print(n)


def is_vowel(c):
	return c in 'aeiouy'

def main(sc):
	(a, b) = sc.next_ints(2)
	ans = 0
	while True:
		ans += 1
		a *= 3
		b *= 2
		if a > b:
			break
	print(ans)

class Scanner:

	def __init__(self):
		self.idx = 0
		self.tokens = []

	def next(self):
		while self.idx == len(self.tokens) or not len(self.tokens[self.idx]):
			if self.idx == len(self.tokens):
				self.idx = 0
				self.tokens = input().split()
			else:
				self.idx += 1
		self.idx += 1
		return self.tokens[self.idx - 1]

	def next_string(self):
		return self.next()

	def next_strings(self, n):
		return [self.next_string() for i in range(0, n)]

	def next_int(self):
		return int(self.next())

	def next_ints(self, n):
		return [self.next_int() for i in range(0, n)]
scanner = Scanner()
main(scanner)


(younger, older) = map(int, input().split(' '))
answer = 0
while younger <= older:
	younger *= 3
	older *= 2
	answer += 1
print(answer)


(bear, bigB) = map(int, input().split())
result = 1
n = 1
while result == 1:
	if bear * 3 ** n > bigB * 2 ** n:
		print(n)
		result = 0
	else:
		n += 1


a = input()
x = a.split(' ')
s = int(x[0]) * 3
r = int(x[1]) * 2
year = 1
while s <= r:
	s = s * 3
	r = r * 2
	year = year + 1
print(year)


n = input()
n = n.split()
l = int(n[0])
b = int(n[1])
i = 0
while l <= b:
	l = l * 3
	b = b * 2
	i = i + 1
print(i)


def main():
	(lw, bw) = map(int, input().split())
	y = 0
	while True:
		y += 1
		lw *= 3
		bw *= 2
		if lw > bw:
			print(y)
			return 0
main()


def main():
	(w1, w2) = map(int, input().split())
	y = 0
	while True:
		w1 *= 3
		w2 *= 2
		y += 1
		if w1 > w2:
			break
	print(y)
main()


years = 0
l_bob = list(map(int, input().split()))
while True:
	if l_bob[0] > l_bob[1]:
		print(years)
		break
	else:
		l_bob[0] *= 3
		l_bob[1] *= 2
		years += 1


inpu = input().split()
a = int(inpu[0])
b = int(inpu[1])
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
else:
	print(years)


(s, h) = map(int, input().split())
c = 0
while s <= h:
	s = s + s + s
	h = h + h
	c += 1
print(c)


def foo(n, a, i=0):
	if n > a:
		return i
	return foo(n * 3, a * 2, i + 1)
(n, a) = map(int, input().split())
print(foo(n, a))


(L, B) = list(map(int, input().split()))
i = 0
while True:
	i += 1
	(L, B) = (L * 3, B * 2)
	if L > B:
		break
print(i)


(limak, bob) = input().split()
count = 0
while True:
	if int(limak) > int(bob):
		break
	limak = int(limak) * 3
	bob = int(bob) * 2
	count += 1
print(count)


(a, q) = input().split()
a = int(a)
q = int(q)
years = 0
while a <= q:
	a = a * 3
	q = q * 2
	years += 1
print(years)


(w1, w2) = map(int, input().split())
y = 0
while True:
	if w1 > w2:
		break
	else:
		w1 = w1 * 3
		w2 = w2 * 2
		y += 1
print(y)


(a, b) = list(map(int, input().strip().split(' ')))
res = 0
while True:
	a *= 3
	b *= 2
	res += 1
	if a > b:
		print(res)
		break
	else:
		continue


(a, b) = map(int, input().rstrip().split())
if a > b:
	print(a)
elif a < b:
	c = 0
	while a < b or a == b:
		a = a * 3
		b = b * 2
		c += 1
	print(c)
else:
	print(1)


(x, y) = map(int, input().strip().split())
i = 0
while x <= y:
	x = x * 3
	y = y * 2
	i += 1
print(i)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
c = int(0)
while n < k + 1:
	n *= 3
	k *= 2
	c += 1
print(c)


(a, b) = map(int, input().split())
c = 1
f = 0
k = a
m = b
while f == 0:
	k = k * 3
	m = m * 2
	if k > m:
		break
	c += 1
print(c)


while 1:
	try:
		(a, b) = [int(e) for e in input().split()]
	except:
		break
	count = 0
	while not a > b:
		a *= 3
		b *= 2
		count += 1
	print(count)


i = 3
j = 2
count = 0
(a, b) = list(map(int, input().split()))
while a <= b:
	a = a * i
	b = b * j
	count += 1
print(count)


def is_greater(age1, age2, count):
	if age1 <= age2:
		count = count + 1
		return is_greater(age1 * 3, age2 * 2, count)
	elif age1 > age2:
		return count
(limak, bob) = map(int, input().split())
count = 0
print(is_greater(limak, bob, count))


(a, b) = [int(s) for s in input().split()]
count = 0
while True:
	if a > b:
		print(count)
		break
	else:
		a = a * 3
		b = b * 2
		count += 1


def main():
	(limak, bob) = list(map(int, input().split()))
	count = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		count += 1
	print('{}'.format(count))
main()


weights = [int(x) for x in input().split()]
(a, b) = (weights[0], weights[1])
t = 0
while a <= b:
	a *= 3
	b *= 2
	t += 1
print(t)


import sys
t = sys.stdin.readline().split(' ')
val1 = int(t[0])
val2 = int(t[1])
year = 0
while val1 <= val2:
	val1 *= 3
	val2 *= 2
	year += 1
print(year)


(Limak, Bob) = [int(x) for x in input().split()]
count = 0
v = True
while v:
	Limak = Limak * 3
	Bob *= 2
	count += 1
	if Limak > Bob:
		v = False
print(count)


def fun(a, b):
	if a > b:
		return 0
	else:
		return 1 + fun(3 * a, 2 * b)
(x, y) = map(int, input().split())
print(fun(x, y))


Weight = input().split()
bear = int(Weight[0])
brother = int(Weight[1])
years = 0
while bear <= brother:
	bear *= 3
	brother *= 2
	years += 1
print(years)


from math import *
(a, b) = [int(x) for x in input().split(' ')]
print(ceil(log10(b / a) / log10(1.5) + 0.01))


import math
(a, b) = list(map(int, input().split(' ')))
k = math.log(b / a) / math.log(1.5)
k += 1e-05
print(math.ceil(k))


(l, b) = [int(f) for f in input().split(' ')]
year = 1
c = False
while not c:
	l *= 3
	b *= 2
	if l > b:
		c = True
		print(year)
	year += 1


count = 1
(x, y) = input().split()
x = int(x)
y = int(y)
while True:
	x *= 3
	y *= 2
	if x > y:
		break
	else:
		count += 1
print(count)


(limak_weight, bob_weight) = input().split()
limak_weight = int(limak_weight)
bob_weight = int(bob_weight)
year = 0
while limak_weight <= bob_weight:
	year += 1
	limak_weight *= 3
	bob_weight *= 2
print(year)


str1 = input()
[triple, double] = [int(ch) for ch in str1.split()]
years = 0
while triple <= double:
	years += 1
	triple *= 3
	double *= 2
print(years)


lb = list(map(int, input().split(' ')))
count = 0
while True:
	if lb[0] > lb[-1]:
		print(str(count))
		break
	lb[0] *= 3
	lb[-1] *= 2
	count += 1


def func(a, b):
	i = 0
	while b >= a:
		b *= 2
		a *= 3
		i += 1
	return i
(a, b) = map(int, input().split())
print(func(a, b))


n = [int(i) for i in input().split(' ')]
(a, b) = (n[0], n[1])
yrs = 0
while a <= b:
	a *= 3
	b *= 2
	yrs += 1
print(yrs)


p = input().rstrip().split(' ')
b = int(p[0])
a = int(p[1])
X = 0
while 1:
	b = b * 3
	a = a * 2
	X += 1
	if b > a:
		break
print(X)


weights = input().split(' ')
limak = int(weights[0])
bob = int(weights[1])
no_of_years = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	no_of_years += 1
if no_of_years == 0:
	no_of_years = 1
print(no_of_years)


(l, b) = map(int, input().split())
res = False
yr = 0
while res == False:
	yr += 1
	l *= 3
	b *= 2
	if l > b:
		res = True
print(yr)


(n, m) = input().split()
n = int(n)
m = int(m)
c = 0
f = 0
k = 1
p = n * 3
q = m * 2
if p > q:
	f = 1
	print('1')
while p <= q:
	p = p * 3
	q = q * 2
	k = k + 1
if f == 0:
	print(k)


line = input().split()
imak = int(line[0])
bob = int(line[-1])
cont = 0
while imak <= bob:
	imak *= 3
	bob *= 2
	cont += 1
print(cont)


a = [int(val) for val in input().split()]
a[0] *= 3
a[1] *= 2
ans = 1
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	ans += 1
print(ans)


(limak_weight, bob_weight) = [int(x) for x in input().split()]
counter = 0
while limak_weight <= bob_weight:
	limak_weight *= 3
	bob_weight *= 2
	counter += 1
print(counter)


(a, b) = map(int, input().split())
c = 1
while 1:
	a1 = a * 3
	b1 = b * 2
	if a1 > b1:
		print(c)
		break
	else:
		a = a1
		b = b1
		c = c + 1


import math
[wt_limak, wt_bob] = [int(i) for i in input().split()]
log_val = math.log(wt_bob / wt_limak, 3 / 2)
if log_val == int(log_val):
	print(int(log_val + 1))
else:
	print(round(math.ceil(log_val)))


a = input().split()
count = 0
x = int(a[0])
y = int(a[1])
while x <= y:
	x *= 3
	y *= 2
	count += 1
print(count)


def solution():
	(Limak_weight, Bob_weight) = map(int, input('').split(' '))
	year = 0
	while Limak_weight <= Bob_weight:
		year += 1
		Limak_weight = Limak_weight * 3
		Bob_weight = Bob_weight * 2
	print(year)
solution()


g = input().split()
Limak_weight = int(g[0])
Bob_weight = int(g[1])
count = 0
while Bob_weight >= Limak_weight:
	Bob_weight = Bob_weight * 2
	Limak_weight = Limak_weight * 3
	count += 1
print(count)


import math
string = input().split()
(a, b) = (int(string[0]), int(string[1]))
years = math.floor(math.log(b / a) / math.log(3 / 2) + 1)
print(int(years))


(b1, b2) = map(int, input().split()[:2])
c = 0
while b1 <= b2:
	b1 = 3 * b1
	b2 = 2 * b2
	c += 1
	if b1 > b2:
		break
print(c)


def countNumberOfOccurrences(lists, a):
	numberofchar = 0
	for i in range(0, n):
		if lists[i] == a:
			numberofchar += 1
	return numberofchar
import sys
input = sys.stdin.readline
(limbak, bob) = [int(x) for x in input().split()]
counter = 0
while True:
	limbak *= 3
	bob *= 2
	counter += 1
	if limbak > bob:
		break
print(counter)


import os
import sys
import math
(a, b) = input().strip().split(' ')
(a, b) = [int(a), int(b)]
y = 0
while a <= b:
	y += 1
	a = 3 * a
	b = 2 * b
print(y)


(l, b) = map(int, input().strip().split())
count = 0
t = 1
while t:
	count += 1
	l = l * 3
	b = b * 2
	if l > b:
		t = 0
	else:
		t = 1
print(count)


s = str(input())
n = list(s.split(' '))
Limak = int(n[0])
Bob = int(n[1])
i = 1
while True:
	if Limak * 3 ** i <= Bob * 2 ** i:
		i += 1
	else:
		break
print(i)


bears = input().split()
bears.append(0)
while int(bears[0]) <= int(bears[1]):
	bears[0] = int(bears[0]) * 3
	bears[1] = int(bears[1]) * 2
	bears[2] = bears[2] + 1
print(bears[2])


(x, y) = [int(i) for i in input().split()]
c = 0
while x <= y:
	x *= 3
	y *= 2
	c += 1
print(c)


n = input()
n = n.split(' ')

def BobAndLimack(a, b):
	a = int(a)
	b = int(b)
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	return years
print(BobAndLimack(n[0], n[1]))


def bigger_bear(a, b):
	years = 0
	while True:
		if a > b:
			break
		a *= 3
		b *= 2
		years += 1
	return years
(a, b) = [int(n) for n in input().split()]
print(bigger_bear(a, b))


import sys
inf = sys.stdin

def main() -> None:
	(a, b) = map(int, inf.readline().split())
	yr = 0
	while a <= b:
		yr += 1
		a *= 3
		b *= 2
	print(yr)
	return None
main()


(a, b) = input().split()
a = int(a)
b = int(b)
c = 0
f = 0
while f == 0:
	a = a * 3
	b = b * 2
	c += 1
	if a > b:
		break
print(c)


aAndb = input().split(' ')
count = 0
aAndb[0] = int(aAndb[0])
aAndb[1] = int(aAndb[1])
while True:
	count = count + 1
	aAndb[0] = aAndb[0] * 3
	aAndb[1] = aAndb[1] * 2
	if aAndb[0] > aAndb[1]:
		break
print(count)


(n1, n2) = map(int, input().split())
count = 0
res1 = n1 * 3
res2 = n2 * 2
isMoreThan = False
while isMoreThan == False:
	if res1 > res2:
		isMoreThan = True
		count += 1
	else:
		res1 = res1 * 3
		res2 = res2 * 2
		count += 1
print(count)


def great_at_brother(Limak, Bob):
	x = 0
	while Limak <= Bob:
		Limak = 3 * Limak
		Bob = 2 * Bob
		x += 1
	return x
str1 = str(input())
local = str1.find(' ')
Limak = int(str1[:local])
Bob = int(str1[local + 1:])
print(great_at_brother(Limak, Bob))


n = list(map(int, input().split()))
year = 1
i = 1
while i:
	n[0] = n[0] * 3
	n[1] = n[1] * 2
	if n[0] > n[1]:
		break
	else:
		year += 1
print(year)


(L, B) = input().split()
limak = int(L)
bob = int(B)
year = 0
while True:
	limak *= 3
	bob *= 2
	year += 1
	if limak > bob:
		break
print(year)


def tripple_weight(a, b):
	count = 0
	while a <= b:
		b = b * 2
		a = a * 3
		count += 1
	return count
(abear, bbear) = map(int, input().split())
print(tripple_weight(abear, bbear))


(n1, n2) = input().split(' ')
n1 = int(n1)
n2 = int(n2)
number = 0
while True:
	number += 1
	n1 *= 3
	n2 *= 2
	if n1 > n2:
		break
print(number)


q = input()
l = q.split(' ')
a = int(l[0])
b = int(l[1])
m = 0
while a <= b:
	m += 1
	a = 3 * a
	b = 2 * b
print(str(m))


num = input()
arr = num.split(' ')
for i in range(len(arr)):
	arr[i] = int(arr[i])
a = arr[0]
b = arr[1]
sum = 0
while True:
	sum += 1
	a *= 3
	b *= 2
	if a > b:
		print(sum)
		break


(lim, bob) = map(int, input().split())
for i in range(100):
	lim = lim * 3
	bob = bob * 2
	if lim > bob:
		print(i + 1)
		break


import math
(a, b) = map(int, input().split())
if a == b:
	print(1)
else:
	yr = 0
	while True:
		a *= 3
		b *= 2
		yr += 1
		if a > b:
			print(yr)
			break


n = 2
lista = list(map(int, input().split()))
year = int()
while lista[1] >= lista[0]:
	lista[0] = lista[0] * 3
	lista[1] = lista[1] * 2
	year = year + 1
print(year)


n = input()
lst = n.split()
lim = int(lst[0])
bob = int(lst[1])
count = 1
while True:
	lim = lim * 3
	bob = bob * 2
	if lim > bob:
		break
	count += 1
print(count)


(limak, bob) = input().split()
limak = int(limak)
bob = int(bob)
n = 0
while bob >= limak:
	n += 1
	bob = bob * 2
	limak = limak * 3
print(n)


import math
b = [int(x) for x in input().split(' ')]
a1 = b[1] / b[0]
a2 = 0.4054651081081644
c = math.log(a1) // a2
print(int(c + 1))


(biba, boba) = list(map(int, input().split()))
years = 0
while True:
	biba = biba * 3
	boba = boba * 2
	years += 1
	if biba > boba:
		print(years)
		break


def main():
	(a, b) = map(int, input().split(' '))
	year_count = 0
	while True:
		a *= 3
		b *= 2
		year_count += 1
		if a > b:
			break
	print(year_count)
main()


zeile1 = input('')
l = []
zahl = ''
for i in range(len(zeile1)):
	if zeile1[i] != ' ':
		zahl = zahl + zeile1[i]
	else:
		l.append(int(zahl))
		zahl = ''
	if i == len(zeile1) - 1:
		l.append(int(zahl))
		zahl = ''
a = l[0]
b = l[1]
anzahl = 0
jahre = 1
while a <= b:
	anzahl += 1
	a = a * 3
	b = b * 2
	jahre += 1
print(anzahl)


(limac, bob) = map(int, input().split())
i = 0
while bob >= limac:
	limac *= 3
	bob *= 2
	i += 1
print(i)


(w1, w2) = input().split()
w1 = int(w1)
w2 = int(w2)
y = int(0)
while w2 >= w1:
	w1 *= 3
	w2 *= 2
	y += 1
print(y)


def years(limak, bob):
	counter = 0
	while limak <= bob:
		limak = limak * 3
		bob = bob * 2
		counter += 1
	return counter
inp = list(map(int, input().rstrip().split()))
print(years(inp[0], inp[1]))


(a, b) = input().split(' ')
(a, b) = (int(a), int(b))
count_year = 0
while a <= b:
	a *= 3
	b *= 2
	count_year += 1
print(count_year)


o = [int(s) for s in input().rstrip().split()]
(a, b) = (o[0], o[1])

def years_after(a, b):
	y = 0
	while a <= b:
		a *= 3
		b *= 2
		y += 1
	return y
print(years_after(a, b))


import sys

def F(a, b):
	i = 0
	while a <= b:
		a *= 3
		b *= 2
		i += 1
	return i

def readline():
	return list(map(int, input().split()))
(a, b) = readline()
print(F(a, b))
sys.exit(0)


(a, b) = map(int, input().strip().split())
for y in range(1, 200):
	a = a * 3
	b = b * 2
	if a > b:
		break
print(y)


(a, b) = map(int, input().split(' '))
s = a
s2 = b
c = 0
while True:
	s = s * 3
	s2 = s2 * 2
	c = c + 1
	if s > s2:
		print(c)
		break


import math
(l, b) = list(map(int, input().split()))
ans = math.log(b / l, 3 / 2)
if ans == math.ceil(ans):
	print(int(ans + 1))
else:
	print(math.ceil(ans))


(a, b) = map(int, input().split())
c = 0
if a > b:
	raise ValueError
while a <= b:
	a *= 3
	b *= 2
	c += 1
	if a > b:
		print(c)


import math
ab = input().split()
a = int(ab[0])
b = int(ab[1])
n = math.log(b / a, 1.5)
if int(n) == n:
	print(int(n) + 1)
else:
	print(math.ceil(n))


(A, B) = map(int, input().split())
ans = 0
while A <= B:
	A *= 3
	B *= 2
	ans += 1
print(ans)


entrada = str(input())
entrada = entrada.split()
a = int(entrada[0])
b = int(entrada[1])
year_counter = 0
security = 10 ** 6
limak_is_smaller = True
while limak_is_smaller:
	year_counter += 1
	a = 3 * a
	b = 2 * b
	if a > b:
		limak_is_smaller = False
print(year_counter)


weights = list(map(int, input().split()))
years = int(0)
while weights[0] <= weights[1]:
	weights[0] *= 3
	weights[1] *= 2
	years += 1
print(years)


import sys
fin = sys.stdin
fout = sys.stdout
lines = (line.strip() for line in fin)
(a, b) = map(int, next(lines).split())
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years, file=fout)


(a, b) = (int(e) for e in input().split())
for i in range(1, 11):
	a = a * i * 3
	b = b * i * 2
	if a > b:
		print(i)
		exit(0)


def Bear(a, b):
	c = 0
	while True:
		a *= 3
		b *= 2
		c += 1
		if a > b:
			return c
(a, b) = list(map(int, input().split()))
print(Bear(a, b))


(a, b) = input().split()
a = int(a)
b = int(b)
n = 1
while 3 ** n * a <= 2 ** n * b:
	n += 1
print(int(n))


(a, b) = input().split()
(a, b) = (int(a), int(b))
count = 0
no_of_years = 0
while True:
	count += 1
	a = 3 * a
	b = 2 * b
	if a > b:
		no_of_years = count
		break
	else:
		continue
print(no_of_years)


string = input()
a = int(string[:2])
b = int(string[-2:])
yr = 0
while a <= b:
	a = a * 3
	b = b * 2
	yr = yr + 1
print(yr)


(a, b) = [int(__) for __ in input().strip().split()]
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b <<= 1
print(ans)


weights = input().split()
count = 0
while int(weights[0]) <= int(weights[1]):
	weights[0] = 3 * int(weights[0])
	weights[1] = 2 * int(weights[1])
	count += 1
print(count)


(n, m) = [int(x) for x in input().split()]
i = 0
if n == m:
	print(1)
else:
	while n <= m:
		n = n * 3
		m = m * 2
		i += 1
	print(i)


nums = input().split()
nums[1] = int(nums[1])
nums[0] = int(nums[0])
years = 0
while nums[0] <= nums[1]:
	nums[0] = 3 * nums[0]
	nums[1] = 2 * nums[1]
	years = years + 1
print(years)


import math
c = 0
i = 0
j = 0
(a, b) = map(int, input().split())
while a <= b:
	c += 1
	b *= 2
	a *= 3
print(c)


numb = input()
numbers = numb.split()
a = int(numbers[0])
b = int(numbers[1])
x = 0
c = 0
while a <= b:
	a = a * 3
	b = b * 2
	c += 1
print(c)


userInput = [input()]
userInput = userInput[0].split()
limakIntial = int(userInput[0])
BobIntial = int(userInput[1])
limakweight = limakIntial
bobweight = BobIntial
i = 0
while True:
	limakweight = limakweight * 3
	bobweight = bobweight * 2
	i = i + 1
	if limakweight > bobweight:
		break
print(i)


import math
(a, b) = [int(x) for x in input().split()]

def ans(a, b):
	lg = math.log2(a / b)
	deno = 1 - math.log2(3)
	lhs = lg / deno
	return lhs
print(1 if a == b else math.ceil(ans(a, b)))


(l, b) = input().split()
l = int(l)
b = int(b)
sum = 0
while b >= l:
	l = l * 3
	b = b * 2
	sum = sum + 1
print(sum)


s = input().split()
s = [int(s[0]), int(s[1])]
f = False
i = 0
while not f:
	s[0] *= 3
	s[1] *= 2
	if s[0] > s[1]:
		f = True
	i += 1
print(i)


(a, b) = map(int, input().split())
j = 0
j = int(j)
for i in range(100):
	if a < b or a == b:
		a = a * 3
		b = b * 2
		j = j + 1
	else:
		break
print(j, end='')


(bear, brother) = input().split()
bear = int(bear)
brother = int(brother)
count = 0
while brother + 1 > bear:
	bear = 3 * bear
	brother = 2 * brother
	count += 1
print(count)


a = list(map(int, input().split()))
a1 = a[0]
a2 = a[1]
b = 0
while a1 <= a2:
	a1 *= 3
	a2 *= 2
	b += 1
print(b)


import math
w = input().split()
a = int(w[0])
b = int(w[1])
ans = int(math.log(b / a, 3 / 2)) + 1
print(ans)


(a, b) = input().split()
count = 0
aint = int(a)
bint = int(b)
while aint <= bint:
	aint *= 3
	bint *= 2
	count += 1
print(count)


def heavier(limak, bob):
	years = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		years += 1
	return years
(limak, bob) = map(int, input().strip().split())
print(heavier(limak, bob))


(a, b) = input().split(' ')
a = int(a)
b = int(b)
years = []
while a <= b:
	a *= 3
	b *= 2
	years.append('i')
	if a > b:
		print(len(years))


weight = list(map(int, input().split()))
bear = weight[0]
bob = weight[1]
result = 1
while 1:
	bear = bear * 3
	bob = bob * 2
	if bear > bob:
		break
	else:
		result += 1
print(result)


(a, b) = map(int, input().split())
year = 0
for i in range(10):
	while a <= b:
		a = a * 3
		b = b * 2
		year += 1
	else:
		break
print(year)


(li, bob) = input().split()
(li, bob) = (int(li), int(bob))
ans = 0
while li <= bob:
	li *= 3
	bob *= 2
	ans += 1
print(ans)


from math import log, ceil, floor

def years_2_heavier(line):
	num_list = list(map(int, line.split(' ')))
	base_weight_small = num_list[0]
	base_weight_large = num_list[1]
	numerator = log(base_weight_large / base_weight_small)
	denominator = log(3 / 2)
	print(floor(numerator / denominator) + 1)
input_str = input()
years_2_heavier(input_str)


R = lambda : [*map(int, input().split())]
(a, b) = R()
k = 0
while a <= b:
	a = a * 3
	b = b * 2
	k += 1
print(k)


(a, b) = input().split()
aa = int(a)
bb = int(b)
y = 0
while aa <= bb:
	aa *= 3
	bb *= 2
	y += 1
print(y)


(a, b) = input().split()
(a, b) = (int(a), int(b))
ano = 0
while a <= b:
	a = a * 3
	b = b * 2
	ano = ano + 1
print(ano)


(bear, brother) = input().split()
bear = int(bear)
brother = int(brother)
i = 1
while bear <= brother:
	bear = bear * 3
	brother = brother * 2
	if bear <= brother:
		i = i + 1
	else:
		break
print(i)


(a, b) = list(map(int, input().split()))
years = 0
while True:
	(a, b) = (3 * a, 2 * b)
	years += 1
	if a > b:
		print(years)
		exit()


(bob, lim) = map(int, input().split(' '))
years = 0
while lim >= bob:
	bob *= 3
	lim *= 2
	years += 1
else:
	print(years)


def ans(arr):
	(a, b) = (arr[0], arr[1])
	cnt = 0
	while a <= b:
		a *= 3
		b *= 2
		cnt += 1
	return cnt
ab = list(map(int, input().strip().split()))
print(ans(ab))


(linak, bob) = [int(i) for i in input().split(' ')]
count = 0
while linak <= bob:
	linak *= 3
	bob *= 2
	count += 1
print(count)


(w1, w2) = input().split()
a = int(w1)
b = int(w2)
sum1 = 0
while a <= b:
	sum1 += 1
	a *= 3
	b *= 2
print(sum1)


(x, y) = [int(x) for x in input('').split()]
year = 0
pro1 = x
pro2 = y
count = 0
while count < 1:
	if pro1 > pro2:
		count = 1
	else:
		pro1 = pro1 * 3
		pro2 = pro2 * 2
		year = year + 1
print(year)


from math import log
[a, b] = [int(_) for _ in input().split()]
print(int(log(b / a) / log(1.5)) + 1)


(a, b) = map(int, input().split())
g = True
t = 0
while g:
	a = 3 * a
	b = 2 * b
	t = t + 1
	if a > b:
		g = False
print(t)


def main():
	(n, k) = tuple(map(int, input().split(' ')))
	counter = 0
	while n <= k:
		n *= 3
		k *= 2
		counter += 1
	print(counter)
main()


(limak, bob) = map(int, input().split())
i = 1
while True:
	if limak * 3 > bob * 2:
		break
	else:
		limak *= 3
		bob *= 2
		i += 1
print(i)


def main():
	(a, b) = map(int, input().split())
	i = 1
	while True:
		a *= 3
		b *= 2
		if a > b:
			print(i)
			break
		i += 1
	pass
main()


(a, b) = (int(x) for x in input().strip().split())
i = 1
while True:
	a = a * 1.5
	if a > b:
		break
	i += 1
print(i)


L = input().split()
lim = int(L[0])
bob = int(L[1])
years = 0
while lim <= bob:
	lim = 3 * lim
	bob = 2 * bob
	years += 1
print(years)


import sys
input_ = input().split(' ')
limak = int(input_[0])
bob = int(input_[1])
ans = 0
while limak <= bob:
	ans += 1
	limak *= 3
	bob *= 2
print(ans)
sys.exit()


(a, b) = input().split()
a = int(a)
b = int(b)
guessFlag = 0
counter = 0
while guessFlag == 0:
	counter = counter + 1
	a = a * 3
	b = b * 2
	if a > b:
		guessFlag = 1
print(counter)


import math
(limark, bob) = map(int, input().split())
years = int(math.log(bob / limark) / math.log(3 / 2)) + 1
print(years)


X = input()
X = X.split()
X[0] = int(X[0])
X[1] = int(X[1])
for k in range(1000000):
	if X[0] > X[1]:
		print(k)
		break
	X[0] = X[0] * 3
	X[1] = X[1] * 2


(l, b) = input().split()
(limak, bob) = (int(l), int(b))
count = 0
while limak < bob + 1:
	bob *= 2
	limak *= 3
	count += 1
print(count)


weights = [int(x) for x in input().split()]
years = 0
while weights[0] <= weights[1]:
	weights[0] *= 3
	weights[1] *= 2
	years += 1
print(years)


x = list(input().split(' '))
i = 0
while int(x[0]) <= int(x[1]):
	x[0] = 3 * int(x[0])
	x[1] = 2 * int(x[1])
	i += 1
print(i)


from sys import stdin, stdout

def main():
	arr = [int(x) for x in stdin.readline().split()]
	lim = arr[0]
	bob = arr[1]
	year = 0
	while lim <= bob:
		lim *= 3
		bob *= 2
		year += 1
	stdout.write(str(year))
main()


import math
(a, b) = [int(i) for i in input().split()]
res = math.log(b / a) / math.log(1.5)
print(math.ceil(res) + (res == int(res)))


(a, b) = map(int, input().split())
x = 1
while True:
	a *= 3
	b *= 2
	if a > b:
		break
	else:
		x += 1
print(x)


pesos = list(map(int, input().split()))
contador = 0
while pesos[0] <= pesos[1]:
	contador += 1
	pesos[0] *= 3
	pesos[1] *= 2
print(contador)


(n, a) = input().split()
n = int(n)
a = int(a)
r = 0
while a >= n:
	n = n * 3
	a = a * 2
	r = r + 1
print(r)


A = input()
a = ''
b = ''
flag = 0
for i in range(0, len(A)):
	if flag == 0:
		if A[i] != ' ':
			a += A[i]
		else:
			flag == 1
			l = i
			break
b = A[i + 1:len(A)]
a = int(a)
b = int(b)
i = 0
while True:
	i += 1
	a = a * 3
	b = b * 2
	if a > b:
		break
print(i)


(a, b) = map(int, input().split())
count = 0
flag = 0
while flag == 0:
	a = a * 3
	b = b * 2
	count += 1
	if a > b:
		print(count)
		flag = 1
	else:
		continue


(m, s) = list(map(int, input().split()))
count = 0
while True:
	if m > s:
		print(count)
		break
	m = m * 3
	s = s * 2
	count += 1


def main():
	(a, b) = map(int, input().split())
	count = 0
	while not a > b:
		count += 1
		a *= 3
		b *= 2
	print(count)
main()


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

def bear(a, b):
	c = 0
	while a <= b:
		a *= 3
		b *= 2
		c += 1
	return c
print(bear(a, b))


(a, b) = map(int, input().split())
c = 0
t = 'y'
while t == 'y':
	c += 1
	a = 3 * a
	b = 2 * b
	if a > b:
		t = 'n'
print(c)


(w1, w2) = list(map(int, input().split()))
count = 0
while w1 <= w2:
	w1 = w1 * 3
	w2 = w2 * 2
	count += 1
print(count)


(a, b) = [int(i) for i in input().split(' ')]
c = 1
(i1, i2) = (3, 2)
while 1:
	a = a * i1
	b = b * i2
	if a > b:
		break
	else:
		c = c + 1
print(c)


(s, n) = [int(a) for a in input().split(' ')]
p = 0
while s <= n:
	p = p + 1
	s = s * 3
	n = n * 2
print(p)


import math

def main():
	(limak, bob) = (int(i) for i in input().split(' '))
	print(math.floor(math.log(bob / limak, 3 / 2)) + 1)
	pass
main()


(b, bro) = map(int, input().split())
count = 0
while 1:
	b = b * 3
	bro = bro * 2
	count += 1
	if b > bro:
		break
print(count)


(lm, bb) = input().split(' ')
lm = int(lm)
bb = int(bb)
if lm == bb:
	print(1)
	exit()
year = 0
while True:
	lm *= 3
	bb *= 2
	if lm > bb:
		print(year + 1)
		break
	year += 1


(k, r) = map(int, input().split())
res = 0
while 1:
	k = k * 3
	r = r * 2
	res = res + 1
	if k > r:
		break
print(res)


(limak, bob) = [int(e) for e in input().split()]
y = 0
while limak <= bob:
	y += 1
	limak *= 3
	bob *= 2
print(y)


(x, y) = [int(a) for a in input().split()]
if x == y:
	print(1)
else:
	for i in range(1, 100000):
		x = x * 3
		y = y * 2
		if x > y:
			print(i)
			quit()


inp = input()
spin = inp.split()
lin = int(spin[0])
bob = int(spin[1])
count = 0
while lin <= bob:
	lin *= 3
	bob *= 2
	count += 1
print(count)


(L, B) = [int(i) for i in input().split(' ')]
year = 0
while L <= B:
	L *= 3
	B *= 2
	year += 1
print(year)


(n, m) = map(int, input().split())
count = 0
if n > m:
	print(1)
while n <= m:
	n = 3 * n
	m = 2 * m
	count += 1
print(count)


x = input()
a = int(x.split(' ')[0])
b = int(x.split(' ')[1])
c = 0
while b > a or b == a:
	b = b * 2
	a = a * 3
	c = c + 1
if c > 0:
	print(c)
else:
	print(1)


weight = list(map(int, input().split()))
count = 0
i = 0
while i >= 0:
	if weight[0] * 3 ** i <= weight[1] * 2 ** i:
		count += 1
		i += 1
	else:
		break
print(count)


(lamak, bob) = list(map(int, input().split()))
count = 0
while lamak <= bob:
	lamak *= 3
	bob *= 2
	count += 1
print(count)


from sys import stdin
import sys
(l, b) = stdin.readline().split()
l = int(l)
b = int(b)
if l == b:
	print(1)
	exit()
ans = 0
while l <= b:
	l = l * 3
	b = b * 2
	ans = ans + 1
print(ans)


(l, b) = map(int, input().split())
temp = True
counter = 0
while temp:
	l *= 3
	b *= 2
	counter += 1
	if l > b:
		temp = False
print(counter)


(a, b) = map(int, input().split())
c = True
i = 0
while c:
	a *= 3
	b *= 2
	i += 1
	if a > b:
		c = False
		print(i)


(x, z) = map(int, input().split())
count = 0
while x <= z:
	x = x * 3
	z = z * 2
	count = count + 1
print(str(int(count)))


(mlimak, mbob) = [int(x) for x in input().split()]
year = 1
while 3 * mlimak <= 2 * mbob:
	mlimak += mlimak * 2
	mbob += mbob
	year += 1
print(year)


import sys
import math
from collections import *

def get_ints():
	return map(int, input().split())

def get_list():
	return list(get_ints())

def printspx(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0 + 7)
SEXYMOD = 998244353
MAXN = int(100000.0)
(a, b) = get_ints()
c = 0
while a <= b:
	a *= 3
	b *= 2
	c += 1
print(c)


from sys import stdin
inp = stdin.readline
(a, b) = [int(k) for k in inp().split()]
n = 0
while a <= b:
	a *= 3
	b *= 2
	n += 1
print(n)


(lim, bob) = [int(x) for x in input().split()]
ans = 0
while lim <= bob:
	lim *= 3
	bob *= 2
	ans += 1
print(ans)


um = input().split()
b = int(um[1])
um = int(um[0])
c = 0
while um <= b:
	um *= 3
	b *= 2
	c += 1
print(c)


(n, k) = list(map(int, input().split(' ')))
res = 0
while n <= k:
	n *= 3
	k *= 2
	res += 1
print(res)


def main():
	(l, b) = map(int, input().split())
	result = 0
	while l <= b:
		l *= 3
		b *= 2
		result += 1
	print(result)
main()


a = str(input())
a = a.split()
k = 0
lim = int(a[0])
bob = int(a[1])
while bob >= lim:
	k += 1
	lim = lim * 3
	bob = bob * 2
print(k)


n = input()
m = n.split()
l = int(m[0])
b = int(m[1])
c = 0
while l <= b:
	l *= 3
	b *= 2
	c += 1
print(c)


line = input()
inputs = line.split()
a = int(inputs[0])
b = int(inputs[1])
not_done = True
years = 0
while not_done:
	a = a * 3
	b = b * 2
	years = years + 1
	if a > b:
		not_done = False
print(years)


(a, b) = [int(x) for x in input().strip().split()]
k = 1
while True:
	if 3 ** k * a > 2 ** k * b:
		print(k)
		break
	else:
		k += 1


def Solution(a, b):
	year = 0
	while b >= a:
		b = 2 * b
		a = 3 * a
		year += 1
	return year
t = input().split(' ')
print(Solution(int(t[0]), int(t[1])))


l = list(map(int, input().strip().split()))
year = 0
while l[0] <= l[1]:
	year = year + 1
	l[0] = l[0] * 3
	l[1] = l[1] * 2
print(int(year))


from typing import Tuple

def solve(*, _input: Tuple[int, int], aggregation: int=0) -> int:
	return aggregation if _input[0] > _input[1] else solve(_input=(_input[0] * 3, _input[1] * 2), aggregation=aggregation + 1)
(a_weight, b_weight) = map(int, input().split())
solution = solve(_input=(a_weight, b_weight))
print(solution)


(l, b) = map(int, input().split())
i = 0
while l <= b:
	l *= 3
	b *= 2
	i += 1
print(str(i))


(s, r) = map(int, input().split())
g = 0
while s <= r:
	s *= 3
	r *= 2
	g += 1
print(g)


years = 0
(limak, bob) = map(int, input().split())
while True:
	if bob >= limak:
		limak *= 3
		bob *= 2
		years += 1
	elif limak > bob:
		break
print(years)


(l, b) = [int(x) for x in input().split()]
n = 0
if l == b:
	print(1)
else:
	while l <= b:
		l *= 3
		b *= 2
		n += 1
	print(n)


a = list(map(int, input().split()))
limak = a[0]
bob = a[1]
total = 0
bet = abs(bob - limak)
if limak == bob:
	total = 1
if total == 0:
	for i in range(bet + 1):
		if limak > bob:
			break
		limak *= 3
		bob *= 2
		total += 1
print(total)


import math
s = input()
(a, b) = map(int, s.split(' '))
if a == b:
	c = 1
else:
	c = math.log(b / a, 1.5) + 1
	c = int(c * 10 // 10)
print(c)


LB = list(map(int, input().strip().split()))
L = LB[0]
B = LB[1]
count = 0
while True:
	L = L * 3
	B = B * 2
	count += 1
	if L > B:
		break
print(count)


entrada = input().split()
a = int(entrada[0])
b = int(entrada[1])
anno = 0
while a <= b:
	anno += 1
	a = a * 3
	b = b * 2
print(anno)


def findAgeDifference(limark, bob):
	counter = 1
	diff = bob - limark
	for index in range(diff):
		limark *= 3
		bob *= 2
		if limark <= bob:
			counter += 1
		else:
			break
	return counter

def main():
	ageInput = input().split(' ')
	limark = int(ageInput[0])
	bob = int(ageInput[1])
	print(findAgeDifference(limark, bob))
main()


def main():
	from sys import stdout
	(a, b) = map(int, input().split())
	res = 0
	while a <= b:
		a *= 3
		b *= 2
		res += 1
	stdout.write(str(res))
main()


(i, j) = map(int, input().split())
m = 1
for k in range(0, 999):
	i *= 3
	j *= 2
	if i > j:
		print(m)
		break
	m += 1


sizes = input().split()
sizes = [int(x) for x in sizes]
l = sizes[0]
b = sizes[1]
cont = True
y = 1
while cont:
	if l * 3 ** y > b * 2 ** y:
		break
	y += 1
print(y)


(l, b) = input().split()
l = int(l)
b = int(b)
count = 0
for x in range(1000000):
	if l > b:
		print(count)
		break
	else:
		l = l * 3
		b = b * 2
		count = count + 1


(ma, la) = input().split()
ma = int(ma)
la = int(la)
co = 0
while ma <= la:
	ma *= 3
	la *= 2
	co += 1
print(co)


import sys
lines = sys.stdin.readlines()
(a, b) = map(int, lines[0].strip().split(' '))
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


import math
line = input().strip().split()
x = int(line[0])
y = int(line[1])
for i in range(1, y + 1):
	x *= 3
	y *= 2
	if x > y:
		print(i)
		break


(x, y) = [int(x) for x in input().split()]
cnt = 0
while y >= x:
	x = x + x * 2
	y = y + y
	cnt = cnt + 1
print(cnt)


I = [int(i) for i in input().split()]
(x, y) = (I[0], I[1])
count = 0
while x <= y:
	x *= 3
	y *= 2
	count += 1
print(count)


from collections import deque
import math
array = [1, 3, 6, 8, 9, 13, 17, 29, 33, 49, 50]

def binarySerh1(l, r, find):
	c = l + (r - l) // 2
	if array[c] == find:
		return c
	elif l == r or l > r:
		return -1
	elif array[c] > find:
		return binarySerh1(l, c - 1, find)
	else:
		return binarySerh1(c + 1, r, find)
l = 0
r = len(array) - 1
find = 34
while True:
	c = l + (r - l) // 2
	if array[c] == find:
		break
	elif l == r or l > r:
		break
	elif array[c] > find:
		r = c - 1
	else:
		l = c + 1
pass
(a, b) = map(int, input().split())
l = 1
r = 15
while True:
	c = l + (r - l) // 2
	valA = a * 3 ** c
	valB = b * 2 ** c
	if valA == valB:
		print(c + 1)
		break
	elif valA > valB and valA / 3 <= valB / 2:
		print(c)
		break
	if valA > valB:
		r = c - 1
	elif valA < valB:
		l = c + 1


x = input()
x = list(map(int, x.strip().split()))
Bear = x[0]
Bigger = x[1]
count = 0
while Bear <= Bigger:
	Bear *= 3
	Bigger *= 2
	count += 1
print(count)


from math import log, floor
(a, b) = map(int, input().split())
x = log(b / a, 3 / 2)
print(floor(x) + 1)


a = input()
b = a.split()
Limak = int(b[0])
Bob = int(b[1])
y = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	y += 1
print(y)


import array
arr = array.array('l', [])
arr = [int(i) for i in input().split()]
a = int(arr[0])
b = int(arr[1])
dd = 0
while a <= b:
	dd = dd + 1
	a = a * 3
	b = b * 2
print(dd)


(l, b) = [int(y) for y in input().split()]
years = 0
while l <= b:
	l *= 3
	b *= 2
	years += 1
print(years)


import math
(a, b) = map(int, input().strip().split())
s = math.log(b / a) // 0.40546
print(int(s + 1))


try:
	(a, b) = map(int, input().split())
	count = 0
	while a <= b:
		a *= 3
		b *= 2
		count += 1
		if a > b:
			print(count)
except:
	a >= b > 10


from math import ceil, log
(a, b) = map(int, input().split())
print(ceil(log(a / b) / log(2 / 3) + 5e-08))


def solve(l, b):
	years = 0
	while l <= b:
		l *= 3
		b *= 2
		years += 1
	return years
(l, b) = map(int, input().split(' '))
print(solve(l, b))


(l, b) = map(int, input().split())
y = 0
while True:
	l = l * 3
	b = b * 2
	y = y + 1
	if l > b:
		break
	else:
		continue
print(y)


input_nums = input()
(a, b) = map(int, input_nums.split())
w_limak = a
w_bob = b
for i in range(1, 31):
	w_limak *= 3
	w_bob *= 2
	if w_limak > w_bob:
		print(i)
		break


from math import log, ceil
(a, b) = map(int, input().split())
act = log(b / a) / log(3 / 2)
c = ceil(act)
if c - act != 0:
	print(c)
else:
	print(c + 1)


def solve_bear_and_big_brother(answer):
	limak = answer[0]
	bob = answer[1]
	counter = 0
	while limak <= bob:
		limak = limak * 3
		bob = bob * 2
		counter += 1
	print(counter)
weights = [int(x) for x in input().split(' ')]
solve_bear_and_big_brother(weights)


(weight_l, weight_b) = map(int, input().split(' '))
year = 0
while weight_l <= weight_b:
	year += 1
	weight_l *= 3
	weight_b *= 2
print(year)


import math
(a, b) = (int(x) for x in input().split())
years = int(math.log(a / b) / math.log(2 / 3)) + 1
if a * 3 ** years > b * 2 ** years:
	print(years)
else:
	print(years + 1)


ip = input().split()
weights = list(map(int, ip))
a = weights[0]
b = weights[1]
n = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	n = n + 1
print(n)


import math
(n, m) = map(int, input().split())
cnt = 0
while n <= m:
	n = 3 * n
	m = 2 * m
	cnt = cnt + 1
print(cnt)


t = input().split(' ')
a = int(t[0])
b = int(t[1])
cound = 0
while a <= b:
	a = a * 3
	b = b * 2
	cound += 1
	if cound > 1000:
		break
print(cound)


n = input()
i = 0
x = n.split()
s = int(x[0])
p = int(x[1])
while s <= p:
	s = s * 3
	p = p * 2
	i = i + 1
print(i)


from math import ceil, floor, log
tb = [float(i) for i in input().split()]
x = log(tb[1] / tb[0], 3 / 2)
if floor(x) == ceil(x):
	print(ceil(x) + 1)
else:
	print(ceil(x))


def big_bear(list1, n):
	while n >= 1:
		list1[0] = list1[0] * 3
		list1[1] = list1[1] * 2
		if list1[0] > list1[1]:
			break
		n += 1
	return n
n = 1
list1 = []
list1 = list(map(int, input().split(' ')))
print(big_bear(list1, n))


isDebug = False
(limak, bob) = input().split(' ')
limak = int(limak)
bob = int(bob)
year = 0
while True:
	if isDebug:
		print(f'year={year}')
		print(f'limak={limak}')
		print(f'bob={bob}')
	if limak > bob:
		print(year)
		break
	limak = limak * 3
	bob = bob * 2
	year = year + 1


(n1, n2) = list(map(int, input().split(' ')))
n = 1
p = 0
while n != 0:
	n1 = n1 * 3
	n2 = n2 * 2
	p += 1
	if n1 > n2:
		break
print(p)


(a, b) = [int(x) for x in input().split()]
y = 0
while a <= b:
	a = a * 3
	b = b * 2
	y += 1
else:
	print(y)


import math as m
[a, b] = [int(n) for n in input().split()]
x = m.log(b / a, 1.5)
print(m.ceil(x) if x - m.floor(x) != 0 else m.ceil(x) + 1)


x = input()
inputs = x.split(' ')
years = 0
while int(inputs[0]) <= int(inputs[1]):
	years += 1
	inputs[0] = int(inputs[0]) * 3
	inputs[1] = int(inputs[1]) * 2
print(years)


inp2 = input().split(' ')
inp2 = [int(i) for i in inp2]
a = inp2[0]
b = inp2[1]
Jahre = 1
while 3 ** Jahre * a <= 2 ** Jahre * b:
	Jahre += 1
print(Jahre)


b = list(map(int, input().split()))
counter = 0
x = 0
while True:
	if b[0] * 3 ** x - b[1] * 2 ** x > 0:
		break
	x += 1
	counter += 1
print(counter)


(limak, bob) = map(int, input().split())
contador = 0
if limak == bob:
	print('1')
	exit(0)
while True:
	if limak <= bob:
		limak *= 3
		bob *= 2
		contador += 1
	else:
		break
print(contador)


import sys
a = list(map(int, input().split()))
x = a[0]
y = a[1]
lich = 0
while 1 > 0:
	lich += 1
	x *= 3
	y *= 2
	if x > y:
		print(lich)
		sys.exit()


def main():
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	count = 0
	while True:
		count += 1
		a = 3 * a
		b = 2 * b
		if a > b:
			return print(count)
		else:
			continue
main()


(m, n) = input().split()
i = 1
while int(m) * 3 ** i <= int(n) * 2 ** i:
	i += 1
print(i)


import math
(x, y) = [int(x) for x in input().split()]
num = math.log10(int(y)) - math.log10(int(x))
den = math.log10(3) - math.log10(2)
print(int(num / den) + 1)


(a, b) = map(float, input().split())
from math import *
T = log(b / a, 1.5)
print(int(T) + 1)


str = [int(i) for i in input().split()]
k = 1
while 1:
	str[0] = str[0] * 3
	str[1] = str[1] * 2
	if str[0] <= str[1]:
		k += 1
	else:
		print(k)
		break


(limak, bob) = [int(x) for x in input().split()]
for i in range(max(limak, bob) + 1):
	limak = 3 * limak
	bob = 2 * bob
	if limak > bob:
		print(i + 1)
		exit()


(Bob, Limark) = input().split(' ')
Bob = int(Bob)
Limark = int(Limark)
i = 0
while Bob <= Limark:
	i += 1
	Bob *= 3
	Limark *= 2
print(i)


l = input().split(' ')
lim = int(l[0])
bob = int(l[1])
y = 0
while lim <= bob:
	lim = 3 * lim
	bob = 2 * bob
	y += 1
print(y)


import sys
parametrs = list(map(int, input().split()))
weitht_limak = parametrs[0]
weitht_boba = parametrs[1]
status = True
year = 0
while status:
	year += 1
	weitht_limak = weitht_limak * 3
	weitht_boba = weitht_boba * 2
	if weitht_limak > weitht_boba:
		status = False
print(year)


(n, m) = input('').split(' ')
n = int(n)
m = int(m)
year = 0
while True:
	if n > m:
		print(year)
		break
	else:
		n *= 3
		m *= 2
		year += 1


from sys import stdin
(a, b) = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	count += 1
print(count)


(bear_1, bear_2) = (int(x) for x in input().split())
cnt = 0
while bear_1 <= bear_2:
	bear_1 *= 3
	bear_2 *= 2
	cnt += 1
print(cnt)


l = [int(a) for a in input().split()]
wl = l[0]
wb = l[1]
y = 0
while wl <= wb:
	y += 1
	wl = wl * 3
	wb = wb * 2
print(y)


arr = list(map(int, input().strip().split()))
a = arr[0]
b = arr[1]
i1 = 1
i2 = 1
while a <= b:
	a = 3 * a
	b = 2 * b
	i1 += 1
if i1 == 1:
	print(i1)
if i1 > i2:
	print(i1 - i2)


def main():
	(n, t) = map(int, input().split())
	count = 0
	while n <= t:
		n *= 3
		t *= 2
		count += 1
	print(count)
main()


(lim, bob) = map(int, input().split())
cont = 0
if lim == bob and cont == 0:
	print(1)
else:
	while lim < bob:
		lim *= 3
		bob *= 2
		cont += 1
	if lim == bob and cont > 0:
		cont += 1
	print(cont)


n = 2
arr = input()
l = list(map(int, arr.split(' ')))
for i in range(2000):
	l[0] = l[0] * 3
	l[1] = l[1] * 2
	if l[0] > l[1]:
		break
print(i + 1)


def main(a, b):
	n = 0
	while True:
		n = n + 1
		a = 3 * a
		b = 2 * b
		if a > b:
			break
	return n
try:
	while True:
		(a, b) = list(map(int, input().split()))
		print(main(a, b))
except:
	pass


(num1, num2) = [int(x) for x in input().split()]
year = 0
while num1 <= num2:
	num1 *= 3
	num2 *= 2
	year += 1
print(year)


(s, p) = map(int, input().split())
i = 1
while s > 0:
	s = s * 3
	p = p * 2
	if s > p:
		print(i)
		break
	i += 1


(a, b) = map(int, input().split())
k = 1
while 3 ** k * a <= 2 ** k * b:
	k += 1
print(k)


(a, b) = list(map(int, input().split()))
for x in range(b + 1):
	if a > b:
		print(x)
		break
	else:
		(a, b) = (a * 3, b * 2)


(a, b) = [int(x) for x in input().split()]
f = False
i = 0
while f == False:
	a *= 3
	b *= 2
	i += 1
	if a > b:
		f = True
		print(i)


import sys

def solver(a, b):
	if a == b:
		return 1
	c = 0
	while a <= b:
		a = a * 3
		b = b * 2
		c += 1
	return c

def get_ints():
	return map(int, sys.stdin.readline().strip().split())
(a, b) = get_ints()
tmp = solver(a, b)
sys.stdout.write(str(tmp))


w = input().split()
w1 = int(w[0])
w2 = int(w[1])
num_y = 0
while w1 <= w2:
	w1 *= 3
	w2 *= 2
	num_y += 1
print(num_y)


(a, b) = map(int, input().split())
ans = 0
if a < b:
	while a < b:
		a = a * 3
		b = b * 2
		ans += 1
		if a == b:
			ans += 1
		else:
			pass
elif a == b:
	ans += 1
print(ans)


def string_list_to_int(string_list):
	int_list = []
	for i in range(0, len(string_list)):
		int_list.append(int(string_list[i]))
	return int_list
weight = input()
brothers_weight = []
brothers_weight = weight.split()
brothers_weight = string_list_to_int(brothers_weight)
limak_weight = brothers_weight[0]
bob_weight = brothers_weight[1]
yearly = 0
for i in range(0, 10):
	limak_weight = limak_weight * 3
	bob_weight = bob_weight * 2
	if limak_weight > bob_weight:
		yearly = i + 1
		break
print(yearly)


(k, w) = map(int, input().split())
z = 0
while k <= w:
	k *= 3
	w *= 2
	z += 1
print(z)


(l, b) = map(int, input().split())
count = 0
f = True
while f:
	if l <= b:
		l = l * 3
		b = b * 2
		count = count + 1
	else:
		f = False
print(count)


def R():
	return map(int, input().split())

def I():
	return int(input())

def S():
	return str(input())

def L():
	return list(R())
from collections import Counter
import math
import sys
from itertools import permutations
(a, b) = R()
for i in range(10 ** 30):
	if a > b:
		print(i)
		break
	a *= 3
	b *= 2


def bear_years(bear1, bear2):
	i = 0
	while bear1 <= bear2:
		bear1 = bear1 * 3
		bear2 = bear2 * 2
		i += 1
	return i
years = input().split(' ')
print(bear_years(int(years[0]), int(years[1])))


res = [int(n) for n in input().split()]
no_of_years = 0
while res[0] <= res[1]:
	res[0] = res[0] * 3
	res[1] = res[1] * 2
	no_of_years = no_of_years + 1
print(no_of_years)


(L, B) = input().split(' ')
el = int(L)
be = int(B)
yearCounter = 0
while el <= be:
	yearCounter = yearCounter + 1
	el = 3 * el
	be = 2 * be
print(yearCounter)


(a, b) = map(int, input().split())
y = 0
if a == b:
	print(y + 1)
else:
	while a - 1e-05 < b:
		a *= 3
		b *= 2
		y = y + 1
	print(y)


entry = input()
entry = [int(i) for i in entry.split()]
year = 0
while entry[0] <= entry[1]:
	entry[0] = entry[0] * 3
	entry[1] = entry[1] * 2
	year += 1
print(year)


(l, b) = map(int, input().split())
for i in range(b):
	l = 3 * l
	b = 2 * b
	if l > b:
		print(i + 1)
		break
	else:
		continue


def getResult(a, b, result):
	a = a * 3
	b = b * 2
	result = result + 1
	if a > b:
		return result
	return getResult(a, b, result)
(a, b) = map(int, input().split())
print(getResult(a, b, 0))


def heavy():
	global k
	global n
	global x
	k *= 3
	n *= 2
	x += 1
	if k > n:
		print(x)
		return 0
	else:
		heavy()
(k, n) = input().split()
k = int(k)
n = int(n)
x = 0
heavy()


data = input()
number = data.split()
a = int(number[0])
b = int(number[1])
count = 0
while True:
	count = count + 1
	limark1 = a * 3
	bob1 = b * 2
	if limark1 > bob1:
		break
	else:
		a = limark1
		b = bob1
print(count)


begin_string = input()
array = begin_string.split(' ')
limak = int(array[0])
bob = int(array[1])
count = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	count += 1
print(count)


def count_years():
	(a, b) = map(int, input().split())
	couner = 0
	while a <= b:
		a *= 3
		b *= 2
		couner += 1
	print(couner)
count_years()


li = [int(i) for i in input().split()]
count = 0
while li[0] <= li[1]:
	li[0] = li[0] * 3
	li[1] = li[1] * 2
	count += 1
print(count)


from math import log, ceil
(n, k) = map(int, input().split())
ans = ceil(log(k / n, 3 / 2))
if 3 ** ans * n > 2 ** ans * k:
	print(ans)
else:
	print(ans + 1)


weights = input().split()
(lim_weight, bob_weight) = [int(weight) for weight in weights]
count = 0
while bob_weight >= lim_weight:
	bob_weight *= 2
	lim_weight *= 3
	count += 1
print(count)


lista = input().split(' ')
a = int(lista[0])
b = int(lista[1])
cont = 0
while a <= b:
	cont += 1
	a *= 3
	b *= 2
print(cont)


(a, b) = [int(x) for x in input().split()]
limak_weight = a
bob_weight = b
i = 1
while True:
	limak_weight = limak_weight * 3
	bob_weight = bob_weight * 2
	if limak_weight > bob_weight:
		print(i)
		break
	i += 1


(a, b) = map(int, input().split())
i = 0
while a <= b:
	a = a + a * 2
	b = b + b
	i = i + 1
print(i)


(m, n) = map(int, input().split())
cnt = 0
while m < n:
	m = m * 3
	n = n * 2
	cnt += 1
if m == n:
	print(cnt + 1)
else:
	print(cnt)


(x, y) = map(int, input().split())
if x > y:
	print(0)
for c in range(100):
	x = x * 3
	y = y * 2
	if x > y:
		print(c + 1)
		break


(l, b) = input().split()
(l, b) = (int(l), int(b))
for n in range(1, 1000):
	l = 3 * l
	b = 2 * b
	if l > b:
		print(n)
		break


(a, b) = [int(x) for x in input().split()]
s = 0
while 1:
	a = a * 3
	b = b * 2
	s = s + 1
	if a > b:
		break
print(s)


(a, b) = map(int, input().split())
p = 0
c = True
z = 0
q = 0
while c == True:
	if a > b:
		break
	a = a * 3
	b = b * 2
	p += 1
print(p)


import sys
import io
import os
total = 0
failed = 0

def run(test, res):
	x = io.StringIO()
	with io.StringIO(test) as sys.stdin:
		with x as sys.stdout:
			work()
			z = x.getvalue().strip()
	sys.stdout = sys.__stdout__
	print('Passed?', z == res)
	print('Expected: ', res)
	print('Actual  : ', z)
	global total, failed
	total += 1
	failed += 1 if z != res else 0

def work():
	(a, b) = map(int, input().split())
	c = 0
	while a <= b:
		a *= 3
		b *= 2
		c += 1
	print(c)

def test():
	run('4 7', '2')
	run('4 9', '3')
	run('1 1', '1')
if 'LOCALTEST' in os.environ:
	test()
	print('\n Result: %s (%d total, %d failed)' % ('FAILED' if failed > 0 else 'PASSED', total, failed))
else:
	work()


(a, b) = [int(x) for x in input().split()]
for i in range(1, 100000000000000000000):
	a1 = 3 ** i
	b1 = 2 ** i
	if a * a1 > b * b1:
		print(i)
		break


emon = []
emon = input().split()
x = int(emon[0])
y = int(emon[1])
a = 0
for i in range(100):
	x = x * 3
	y = y * 2
	a += 1
	if x > y:
		break
print(a)


inp = input().split()
l = int(inp[0])
b = int(inp[1])
numOfYear = 0
while l <= b:
	l *= 3
	b *= 2
	numOfYear += 1
print(numOfYear)


(a, b) = map(int, input().split())
s = 0
for i in range(10):
	s = s + 1
	a = a * 3
	b = b * 2
	if a > b:
		print(s)
		break
	else:
		continue


z = str(input())
z = z.split(' ')
limak = int(z[0])
bro = int(z[1])
haha = 0
while limak <= bro:
	haha += 1
	limak = limak * 3
	bro = bro * 2
print(haha)


(a, b) = map(int, input().split())
L = 0
B = 0
count = 0
while True:
	if L > B:
		break
	else:
		L = a * 3
		B = b * 2
		a = L
		b = B
		count += 1
print(count)


(a, b) = input().split()
for i in range(0, 200):
	if int(a) * 3 ** i > int(b) * 2 ** i:
		print(i)
		break
	elif int(a) * 3 ** i == int(b) * 2 ** i:
		print(i + 1)
		break


def year(a, b):
	for i in range(1, 50):
		if a * 3 ** i > b * 2 ** i:
			return i
(a, b) = map(int, input().split())
output = year(a, b)
print(output)


(a, b) = map(int, input().split())
for i in range(0, 1000):
	if a > b:
		print(i)
		break
	else:
		a = a * 3
		b = b * 2


import math as mt
import sys as sy

class abc:

	def mkl(self):
		c = 0
		(a, b) = map(int, sy.stdin.readline().split())
		for i in range(b):
			c += 1
			a *= 3
			b *= 2
			if a > b:
				break
		print(c)
b = abc()
b.mkl()


from math import *
(a, b) = map(int, input().split())
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


datos = list(str(input()).split())
contador = 0
for j in range(len(datos)):
	datos[j] = int(datos[j])
while datos[0] <= datos[1]:
	datos[0] = datos[0] * 3
	datos[1] = datos[1] * 2
	contador += 1
print(contador)


import sys
(a, b) = map(int, sys.stdin.readline().rstrip().split(' '))
counter = 0
while True:
	if a > b:
		print(counter)
		break
	else:
		a = a * 3
		b = b * 2
		counter += 1


l = list(map(int, input().split()))
(lim, bob) = (l[0], l[1])
rezult = 0
while lim <= bob:
	lim *= 3
	bob *= 2
	rezult += 1
print(rezult)


(Limak, Bob) = map(int, input('').split())
n = 0
while True:
	if Limak <= Bob:
		Limak *= 3
		Bob *= 2
		n += 1
	else:
		break
print(n)


inp = list(map(int, input().split()))
l = inp[0]
b = inp[1]
y = 0
while l <= b:
	l = l * 3
	b = b * 2
	y = y + 1
print(y)


(m, n) = [int(i) for i in input().split()]
c = 0
while m <= n:
	c += 1
	m *= 3
	n *= 2
print(c)


import sys
input = lambda : sys.stdin.readline().rstrip()

def I():
	return [int(iI) for iI in input().split()]
(a, b) = I()
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


weights = str(input())
sepWeights = weights.split(' ')
limak = int(sepWeights[0])
bob = int(sepWeights[1])
years = 0
while limak <= bob:
	bob = bob * 2
	limak = limak * 3
	years = years + 1
print(years)


string_input = input()
string_list = string_input.split(' ')
first_bear = int(string_list[0])
second_bear = int(string_list[1])
i = 0

def check(first_bear, second_bear, i):
	while first_bear <= second_bear:
		first_bear *= 3
		second_bear *= 2
		i += 1
	return i
print(check(first_bear, second_bear, i))


def solve(arr):
	count = 0
	while arr[0] <= arr[1]:
		arr[0] *= 3
		arr[1] *= 2
		count += 1
	print(count)
arr = list(map(int, input().split()))
solve(arr)


(a, b) = input().split(' ')
i = 1
while int(a) * pow(3, i) <= int(b) * pow(2, i):
	i += 1
print(i)


import math
(a, b) = map(float, input().split())
print(int(math.log(b / a) * 2.47 + 1))


x = input().strip().split()
a = int(x[0])
b = int(x[1])
i = 0
while True:
	a *= 3
	b *= 2
	i += 1
	if a > b:
		break
print(i)


(lmak, bob) = map(int, input().split())
cont = 0
while lmak <= bob:
	lmak *= 3
	bob *= 2
	cont += 1
print(cont)


inp = [int(i) for i in input().split(' ')]
p_years = 0
while inp[0] <= inp[1]:
	inp[0] *= 3
	inp[1] *= 2
	p_years += 1
print(p_years)


def calculateYears(limak, bob):
	limakW = limak
	bobW = bob
	years = 0
	while limakW <= bobW:
		limakW = limakW * 3
		bobW = bobW * 2
		years += 1
	return years
line = input().split(' ')
LimakWeight = int(line[0])
BobWeight = int(line[1])
result = calculateYears(LimakWeight, BobWeight)
print(result)


(w1, w2) = map(int, input().split())
c = 0
while w1 <= w2:
	w1 = w1 * 3
	w2 = w2 * 2
	c += 1
print(c)


(a, b) = map(int, input().split())
i = 1
while i > 0:
	m = a * 3 ** i
	l = b * 2 ** i
	if m > l:
		print(i)
		break
	i = i + 1


def yearCalculation(a, b):
	c = 0
	while a <= b:
		a = a * 3
		b = b * 2
		c = c + 1
	return c
(x, y) = input().split()
print(yearCalculation(int(x), int(y)))


(lim, bob) = map(int, input().split())
year = 0
while not lim > bob:
	lim *= 3
	bob *= 2
	year += 1
print(year)


(x, y) = map(int, input().split())
c = 0
wx = x
wy = y
while not wx > wy:
	wx = wx * 3
	wy = wy * 2
	c += 1
print(c)


import unittest
import sys

class Brother:

	def __init__(self, test_inputs=None):
		it = iter(test_inputs.split('\n')) if test_inputs else None

		def uinput():
			return next(it) if it else sys.stdin.readline().rstrip()
		[self.a, self.b] = map(int, uinput().split())

	def calculate(self):
		n = 0
		a = self.a
		b = self.b
		while a <= b:
			a *= 3
			b *= 2
			n += 1
		result = n
		return str(result)

class unitTests(unittest.TestCase):

	def test_single_test(self):
		test = '4 7'
		d = Brother(test)
		self.assertEqual(d.a, 4)
		self.assertEqual(d.b, 7)
		self.assertEqual(Brother(test).calculate(), '2')
		test = '4 9\n'
		self.assertEqual(Brother(test).calculate(), '3')
		test = '1 1\n'
		self.assertEqual(Brother(test).calculate(), '1')
		test = ''

	def time_limit_test(self, nmax):
		import random
		import timeit
		test = str(nmax) + ' ' + str(nmax) + '\n'
		numnums = [str(i) + ' ' + str(i + 1) for i in range(nmax)]
		test += '\n'.join(numnums) + '\n'
		nums = [random.randint(1, 10000) for i in range(nmax)]
		test += ' '.join(map(str, nums)) + '\n'
		start = timeit.default_timer()
		d = Brother(test)
		calc = timeit.default_timer()
		d.calculate()
		stop = timeit.default_timer()
		print('\nTimelimit Test: ' + '{0:.3f}s (init {1:.3f}s calc {2:.3f}s)'.format(stop - start, calc - start, stop - calc))
sys.setrecursionlimit(100000)
if sys.argv[-1] == '-ut':
	unittest.main(argv=[' '])
sys.stdout.write(Brother().calculate())


d = input()
d = d.split(' ')
x = int(d[0])
z = int(d[1])
step = 0
while x <= z:
	x *= 3
	z *= 2
	step += 1
print(step)


(a, b) = map(int, input().split())
i = 1
x = 1.5 ** i
y = b / a
while x <= y:
	i += 1
	x = 1.5 ** i
print(i)


ab = str(input())
a = int(ab[0:ab.index(' ')])
b = int(ab[ab.index(' ') + 1:])
sum = 0
while a <= b:
	a = a * 3
	b = b * 2
	sum = sum + 1
print(sum)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(a, b) = LI()
	for i in range(100):
		if a > b:
			return i
		a *= 3
		b *= 2
	return -1
print(main())


(x, y) = input().split()
x = int(x)
y = int(y)
sum = 0
while x <= y:
	sum += 1
	x *= 3
	y *= 2
print(sum)


(a, r) = input().split()
a = int(a)
r = int(r)
d = 0
while a <= r:
	a = a * 3
	r = r * 2
	d += 1
print(d)


ans = 0
(a, b) = list(map(int, input().split()))
x = True
while x:
	a *= 3
	b *= 2
	ans += 1
	if a > b:
		x = False
print(ans)


(N, M) = map(int, input().split())
k = 0
while N <= M:
	N *= 3
	M *= 2
	k += 1
print(k)


(x, y) = map(int, input().split())
i = 0
while x <= y:
	x = x + x + x
	y = y + y
	i += 1
print(i)


s = input()
t = int(s[0:s.index(' ')])
o = int(s[s.index(' ') + 1:len(s)])
i = 1
while t <= o:
	t = 3 * t
	o = o * 2
	i += 1
print(int(i - 1))


x = input()
x = x.split()
y = int(x[0])
z = int(x[1])
c = 1
while True:
	y *= 3
	z *= 2
	if y > z:
		print(c)
		break
	else:
		c += 1


def solve(a, b):
	y = 0
	while a <= b:
		a = a * 3
		b = b * 2
		y = y + 1
	print(y)
(a, b) = map(int, input().split())
solve(a, b)


umur = list(map(int, input().split()))
i = 0
if umur[0] <= umur[1]:
	for i in range(0, 10000):
		if umur[0] > umur[1]:
			break
		umur[0] *= 3
		umur[1] *= 2
print(i)


a = str(input())
a = a.split(' ')
limak = int(a[0])
bob = int(a[1])
i = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	i = i + 1
print(i)


(a, b) = map(int, input().split(' '))
(ans, t) = (1, 1)
while True:
	a *= 3
	b *= 2
	if a > b:
		ans = t
		break
	else:
		t += 1
print(ans)


import sys
import math
input = sys.stdin.read()
(x, y) = input.split()
x = int(x)
y = int(y)
n = int(math.log(x / y, 2 / 3)) + 1
if x * 3 ** n <= y * 2 ** n:
	n += 1
print(n)


x = input()
x = x.split()
co = 0
while int(x[0]) < int(x[1]) + 1:
	x[0] = int(x[0]) * 3
	x[1] = int(x[1]) * 2
	co = co + 1
print(co)


(li, bo) = map(int, input().split(' '))
counter = 0
while not li > bo:
	li *= 3
	bo *= 2
	counter += 1
print(counter)


import math
import re
s = list(map(int, input().split(' ')))
a = s[0]
b = s[1]
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


import math
(a, b) = [int(a) for a in input().split()]
n = math.floor(math.log2(b / a) / math.log2(3 / 2))
print(n + 1)


import math
(a, b) = map(int, input().split())
res = math.log(b / a, 1.5)
if res == math.ceil(res):
	res += 1
res = math.ceil(res)
print(res)


input_string = input()
strarr = input_string.split()
limak = int(strarr[0])
bob = int(strarr[1])
count = 0
while limak <= bob:
	count += 1
	limak *= 3
	bob *= 2
print(count)


import math
(a, b) = tuple(map(int, input().split()))
i = math.log(b / a) / math.log(3 / 2)
if math.ceil(i) > i:
	print(math.ceil(i))
else:
	print(math.ceil(i) + 1)


n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = 0
for i in range(1, 1000):
	if a <= b:
		c = c + 1
		a = a * 3
		b = b * 2
print(c)


s = input()
n = [int(s) for s in s.split()]
l = 0
while n[0] <= n[1]:
	n[0] = n[0] * 3
	n[1] = n[1] * 2
	l += 1
print(l)


inp = input().split()
a = int(inp[0])
b = int(inp[1])
count = 1
while a <= b:
	a = a + a + a
	b = b + b
	if a > b:
		break
	else:
		count += 1
print(count)


def solve(a: int, b: int, years: int) -> int:
	return years if a > b else solve(a * 3, b * 2, years + 1)
(a, b) = list(map(int, input().split(' ')))
print(solve(a, b, 0))


(n, s) = map(int, input().split(' '))
c = 0
while True:
	(n, s, c) = (n * 3, s * 2, c + 1)
	if n > s:
		print(c)
		break


lb = input().split()
l = int(lb[0])
b = int(lb[1])
s = 0
while l <= b:
	l *= 3
	b *= 2
	s += 1
print(s)


def main():
	(limak, bob) = list(map(int, input().split()))
	output = get_years(limak, bob)
	print(output)

def get_years(bearA, bearB):
	smaller = True
	count = 0
	if bearA == bearB:
		return '1'
	else:
		pass
	while smaller == True:
		bearA *= 3
		bearB *= 2
		count += 1
		if bearA > bearB:
			return count
		else:
			pass
main()


INPUT_VALUE = str(input()).split(' ')
LIMAK_WEIGHTS = int(INPUT_VALUE[0])
BOB_WEIGHTS = int(INPUT_VALUE[1])
YEAR = 0
while LIMAK_WEIGHTS <= BOB_WEIGHTS:
	LIMAK_WEIGHTS *= 3
	BOB_WEIGHTS *= 2
	YEAR += 1
print(YEAR)


(a, b) = map(int, input().split())
r = 0
p = 0
while r == 0:
	if a > b:
		r = 1
	else:
		a = a * 3
		b = b * 2
		p += 1
print(p)


def getYears(w):
	a = w[0]
	b = w[1]
	years = 0
	while a <= b:
		years += 1
		a = a * 3
		b = b * 2
	return years
weights = list(map(int, input().rstrip().split()))
print(getYears(weights))


from sys import stdin, stdout
(a, b) = stdin.readline().split()
counter = 0
while int(a) <= int(b):
	a = int(a) * 3
	b = int(b) * 2
	counter += 1
print(counter)


(b, l) = map(int, input().split())
f = 1
while True:
	b = b * 3
	l = l * 2
	if b > l:
		break
	f += 1
print(f)


l = list(map(int, input().split()))
limar = l[0]
bob = l[1]
count = 0
while limar <= bob:
	limar = limar * 3
	bob = bob * 2
	count = count + 1
print(count)


(l, bo) = map(int, input().split())
c = 0
while l <= bo:
	l = l * 3
	bo = bo * 2
	c += 1
print(c)


(vesLimak, vesbob) = input().split()
vesLimak = int(vesLimak)
vesbob = int(vesbob)
lop = 0
while vesLimak <= vesbob:
	lop = lop + 1
	print()
	vesLimak = vesLimak * 3
	vesbob = vesbob * 2
print(lop)


import sys
(a, b) = [int(el) for el in sys.stdin.readline().strip().split()]
count_years = 0
while a <= b:
	count_years += 1
	a = a * 3
	b = b * 2
print(count_years)


wght = input().split()
a = int(wght[0])
b = int(wght[1])
y = 0
while a <= b:
	a += a * 2
	b += b
	y += 1
print(y)


l = [int(i) for i in input().split()]
for i in range(1, 100000):
	l[0] = l[0] * 3
	l[1] = l[1] * 2
	if l[0] > l[1]:
		print(i)
		break


(l, b) = [int(x) for x in input().split()]
h = 0
if l == b:
	print(1)
else:
	while l < b or l == b:
		l = l * 3
		b = b * 2
		h = h + 1
	print(h)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
w = 0
while a <= b:
	a *= 3
	b *= 2
	w += 1
print(w)


aa = input()
a = aa.split()
b = a[0]
c = a[1]
b = int(b)
c = int(c)
n = 1
while c > b:
	b = b * 3
	c = c * 2
	n = n + 1
if c == b:
	print(n)
else:
	print(n - 1)


s = input().split()
l1 = s[0]
l2 = s[1]
if int(l1) > int(l2):
	print(0)
elif int(l1) == int(l2):
	print(1)
else:
	n = 0
	while int(l1) <= int(l2):
		l1 = int(l1) * 3
		l2 = int(l2) * 2
		n += 1
	print(n)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
q = 0
while a <= b:
	a = a * 3
	b = b * 2
	q = q + 1
print(q)


(a1, a2) = map(int, input().split())
a3 = 0
while a1 <= a2:
	a1 *= 3
	a2 *= 2
	a3 += 1
print(a3)


(l, b) = map(int, input().split())
for i in range(1, 10000):
	l *= 3
	b *= 2
	if l > b:
		print(i)
		break


import math
(a, b) = tuple(map(int, input().split()))
res = math.log(b / a, 10) // math.log(3 / 2, 10) + 1
print(int(res))


n = input().split(' ')
a = int(n[0])
b = int(n[1])
sum = a * 3
sum1 = b * 2
r = 0
count = 0
while r == 0:
	count += 1
	if sum > sum1:
		r = 1
		print(count)
	sum = sum * 3
	sum1 = sum1 * 2


def getLines(num):
	inputLines = []
	for i in range(0, num):
		line = input()
		if line:
			inputLines.append(line)
		else:
			break
	return inputLines

def notZeroPow(num, p):
	return True if num >= 1 and num <= pow(10, p) else False
lines = getLines(1)
result = 0
arr = [int(e) for e in lines[0].split()]
a = arr[0]
b = arr[1]
while True:
	result += 1
	a *= 3
	b *= 2
	if a > b:
		break
print(result)


(n, m) = map(int, input().split())
y = 0
while n <= m:
	n = n + n + n
	m = m + m
	y += 1
print(y)


number_str = input()
number_list = number_str.split(' ')
a = int(number_list[0])
b = int(number_list[1])
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
if year == 0:
	print(1)
else:
	print(year)


c = list(map(int, input().split()))
limak = c[0]
bab = c[1]
p = 0
while limak <= bab:
	limak = limak * 3
	bab = bab * 2
	p = p + 1
print(p)


a = input('')
x = a.split(' ')
years = 0
while True:
	years += 1
	x[0] = int(x[0]) * 3
	x[1] = int(x[1]) * 2
	if x[0] > x[1]:
		break
print(years)


(limka, bob) = map(int, input().split())
count = 0
for i in range(10):
	limka = limka * 3
	bob = bob * 2
	count += 1
	if limka > bob:
		break
print(count)


lis = list(map(int, input().strip().split()))
limka = lis[0]
bob = lis[1]
i = 0
while True:
	limka *= 3
	bob *= 2
	i += 1
	if limka > bob:
		break
print(i)


weights = input()
(limak, bob) = weights.split(' ')
years = 0
limak_l = int(limak)
bob_l = int(bob)
while limak_l <= bob_l:
	years = years + 1
	limak_l = limak_l * 3
	bob_l = bob_l * 2
print(years)


def main():
	(lim, bob) = [int(x) for x in input().split()]
	count = 0
	while lim <= bob:
		lim *= 3
		bob *= 2
		count += 1
	return count
print(main())


(n, k) = map(int, input().split(' '))
diff = n - k
count = 0
while diff <= 0:
	n = n * 3
	k = k * 2
	diff = n - k
	count = count + 1
print(count)


(Limak, Bob) = [int(f) for f in input().split()]
ans = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	ans += 1
print(ans)


(limak_weight, bob_weight) = list(map(int, input().split()))
years = 0
while True:
	years = years + 1
	limak_weight = limak_weight * 3
	bob_weight = bob_weight * 2
	if limak_weight > bob_weight:
		print(years)
		break


(a, b) = input().split()
a = int(a)
b = int(b)
year = int()
while b >= a:
	a = a * 3
	b = b * 2
	year = year + 1
print(year)


import math
(x, y) = list(map(int, input().split()))
print(int(math.log(y / x, 3 / 2) + 1))


(a, b) = [int(x) for x in input().strip().split()]
count = 0
while True:
	if a == 1 and b == 1:
		print(1)
		break
	a = a * 3
	b = b * 2
	count = count + 1
	if a > b:
		print(count)
		break


x = input().split()
Limak = int(x[0])
Bob = int(x[1])
count = 0
while Limak <= Bob:
	Limak = Limak * 3
	Bob = Bob * 2
	count += 1
print(count)


def main(w1, w2):
	years = 0
	while w1 <= w2:
		w1 *= 3
		w2 *= 2
		years += 1
	return years
(w1, w2) = [int(x) for x in input().split()]
print(main(w1, w2))


a = input().split()
num1 = int(a[0])
num2 = int(a[1])
counter = 0
while num1 <= num2:
	num1 *= 3
	num2 *= 2
	counter += 1
print(counter)


import math
b = list(map(int, input().split()))
k = math.log10(b[1] / b[0])
p = math.log10(3 / 2)
print(int(k / p) + 1)


in_string = input().split(' ')
a = int(in_string[0])
b = int(in_string[1])
sum = 0
while b >= a:
	a *= 3
	b *= 2
	sum += 1
print(sum)


main_input = input()
raw_input = main_input.split(' ')
a = int(raw_input[0])
b = int(raw_input[1])
control = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	control = control + 1
print(int(control))


from math import floor, log10
(a, b) = map(int, input().split())
print(floor(log10(b / a) / log10(3 / 2) + 1))


(a, b) = map(int, input().split())
c = 0
while a <= b:
	if a <= b:
		c += 1
	elif a == b:
		break
	a *= 3
	b *= 2
print(c)


import math
import os
import random
import re
import sys

def solve(l, b):
	years = 0
	while l <= b:
		l *= 3
		b *= 2
		years += 1
	return years
(l, b) = list(map(int, input().split(' ')))
print(solve(l, b))


(triple, double) = input().split()
triple = int(triple)
double = int(double)
i = 0
while triple <= double:
	triple *= 3
	double *= 2
	i += 1
print(i)


entrada = input()
(limak, bob) = entrada.split(' ')
(limak, bob) = (int(limak), int(bob))
i = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	i += 1
print(i)


ip = [int(i) for i in input().split(' ')]
smallB = ip[0]
bigB = ip[1]
year = 0
flag = True
while flag:
	smallB *= 3
	bigB *= 2
	if smallB > bigB:
		flag = False
	year += 1
print(year)


ab = input().strip().split(' ')
a = int(ab[0])
b = int(ab[1])
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)

def in_int():
	return int(input())

def in_list():
	return list(map(int, input().split()))

def in_str():
	s = input()
	return list(s[:len(s) - 1])

def in_ints() -> object:
	return map(int, input().split())
(a, b) = in_ints()
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


n = input()
(s, l) = n.split(' ')
s = 3 * int(s)
l = 2 * int(l)
i = 1
while True:
	if s < l:
		i += 1
		s *= 3
		l *= 2
	elif s == l:
		i += 1
		break
	else:
		break
print(i)


import math
input_l = input().split(' ')
a = int(input_l[0])
b = int(input_l[1])
i = 0
while a / b <= math.pow(2 / 3, i):
	i += 1
print(i)


(a, b) = map(int, input().strip().split(' '))
(valA, valB) = (a, b)
years = 0
i = 1
while True:
	if valA > valB:
		break
	valA = 3 * valA
	valB = 2 * valB
	years += 1
print(years)


import sys
from typing import Counter
a = list(map(int, input().split()))
counter = 0
while a[0] <= a[1]:
	a[0] = a[0] * 3
	a[1] = a[1] * 2
	counter += 1
print(counter)


(n, m) = map(int, input().split())
i = 0
while i != 10 ** 9:
	n = n * 3
	m = m * 2
	if n > m:
		print(i + 1)
		break
	i = i + 1


import math
(a, b) = list(map(int, input().split()))
c = 0
while a <= b:
	a = a * 3
	b = b * 2
	c += 1
print(c)


(a, b) = map(int, input().split())
c = 0
s = True
while s:
	if a > b:
		print(c)
		s = False
	else:
		a *= 3
		b *= 2
		c += 1


(liam, bob) = map(int, input().split())
ans = 0
while liam <= bob:
	liam *= 3
	bob *= 2
	ans += 1
print(ans)


a = list(map(int, input().split()))
i = 1
Year = 1
while i:
	a[0] = a[0] * 3
	a[1] = a[1] * 2
	if a[0] > a[1]:
		break
	else:
		Year += 1
print(Year)


(l, b) = input().strip().split()[:3]
l = int(l)
b = int(b)
s = 0
x = 0
if l == b:
	print(1)
else:
	while l <= b:
		l = l * 3
		b = b * 2
		x += 1
	print(x)


(lb, bb) = map(int, input().split())
yrs = 0
while lb < bb:
	yrs += 1
	lb *= 3
	bb *= 2
if lb == bb:
	print(yrs + 1)
else:
	print(yrs)


from math import ceil, sqrt, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())
(a, b) = mi()
a *= 3
b *= 2
i = 1
while 1:
	if a > b:
		print(i)
		break
	b *= 2
	a *= 3
	i += 1


(a, b) = list(map(int, input().split()))
from math import log10
from math import floor
count = log10(b / a) / log10(1.5) + 1
print(floor(count))


s = input()
a = s.split()
for i in range(len(a)):
	a[i] = int(a[i])
sum = 0
while a[0] <= a[1]:
	sum += 1
	a[0] *= 3
	a[1] *= 2
print(sum)


data = input().split()
x = int(data[0])
y = int(data[1])
i = 0
while x <= y:
	i += 1
	x = x * 3
	y = y * 2
print(i)


(oso1, oso2) = map(int, input().split())
year = 0
while oso1 < oso2 or oso1 == oso2:
	oso1 = oso1 * 3
	oso2 = oso2 * 2
	year = year + 1
print(year)


import math
(a, b) = map(int, input().split())
print(math.floor(math.log(float(b) / a, 3.0 / 2.0) + 1))


import math
st = input()
[a, b] = (int(x) for x in st.split())
n = math.log2(a / b) / math.log2(2 / 3)
n = int(math.ceil(n))
if a * 3 ** n == b * 2 ** n:
	n += 1
print(n)


(limakWeight, bobWeight) = input('').split()
limakWeight = int(limakWeight)
bobWeight = int(bobWeight)
for i in range(1, 100):
	limakWeight = limakWeight * 3
	bobWeight = bobWeight * 2
	if limakWeight > bobWeight:
		print(i)
		break


w = list(map(int, input().split()))
a = w[0]
b = w[1]
ans = 0
while a <= b:
	a *= 3
	b *= 2
	ans += 1
print(ans)


(lim, bob) = map(int, input().split())
count = 0
while 1:
	count += 1
	lim = lim * 3
	bob = bob * 2
	if lim > bob:
		print(count)
		break


(limak, bob) = input().split()
L = int(limak)
B = int(bob)
c = 0
while L <= B:
	L = L + L + L
	B = B + B
	c += 1
print(c)


def cn(l, b):
	x = 0
	while 1:
		if l > b:
			return x
		x += 1
		l *= 3
		b *= 2
(l, b) = [int(x) for x in input().split()]
print(cn(l, b))


def main():
	(x, y) = input().split()
	(limak, bob) = (int(x), int(y))
	limak *= 3
	bob *= 2
	years = 1
	while limak <= bob:
		limak *= 3
		bob *= 2
		years += 1
	print(years)
main()


a = list(map(int, input().split()))
n = a[0]
d = a[1]
i = 1
while 1:
	n = n * 3
	d = d * 2
	if n > d:
		print(i)
		break
	i += 1


(a, b) = map(int, input().split())
x = 0
y = 0
for i in range(1, a * b + 1):
	x = 3 * a
	a = x
	y = 2 * b
	b = y
	if a > b:
		break
print(i)


from math import ceil, log
l = [int(x) for x in input().split()]
(a, b) = (l[0], l[1])
t = 1
while 1:
	if 1.5 ** t > b / a:
		print(t)
		break
	t += 1


(x, y) = input().split()
(weight_of_limak, weight_of_bob) = (int(x), int(y))
if weight_of_limak <= weight_of_bob:
	counter_for_years = 0
	current_weight_of_limak = weight_of_limak
	current_weight_of_bob = weight_of_bob
	while current_weight_of_limak <= current_weight_of_bob:
		current_weight_of_limak = current_weight_of_limak * 3
		current_weight_of_bob = current_weight_of_bob * 2
		counter_for_years += 1
	print(counter_for_years)


weights = list(map(int, input().split()))
years = 0
larger = False
while not larger:
	if weights[0] > weights[1]:
		larger = True
	else:
		weights[0] *= 3
		weights[1] *= 2
		years += 1
print(years)


(la, bob) = map(int, input().split())
count = 0
while not la > bob:
	la = la * 3
	bob = bob * 2
	count += 1
print(count)


(a, b) = map(int, input().split())
for i in range(20):
	if a * 3 ** i > b * 2 ** i:
		print(i)
		exit()


import sys

def main():
	(a, b) = map(int, input().split())
	year = 0
	while b >= a:
		a = 3 * a
		b = 2 * b
		year += 1
	print(year)
	return
sys.exit(main())


(l, b) = input().split(' ')
limak = int(l)
bob = int(b)
year = 1
while True:
	limak *= 3
	bob *= 2
	if limak > bob:
		break
	year += 1
print(year)


def solve():
	p = list(map(int, input().split()))
	w1 = p[0]
	w2 = p[1]
	i = 0
	while w1 <= w2:
		w1 *= 3
		w2 *= 2
		i += 1
	print(i)
solve()


(l, b) = map(int, input().split())
flag = False
cnt = 0
while flag != True:
	if l > b:
		flag = True
	else:
		l *= 3
		b *= 2
		cnt += 1
print(cnt)


string = input().split(' ')
a = int(string[0])
b = int(string[1])
num_days = 0
while a <= b:
	a *= 3
	b *= 2
	num_days += 1
print(num_days)


import math
w = input()
w = w.split()
y = 0
for i in range(100):
	if int(w[0]) * math.pow(3, i) > int(w[1]) * math.pow(2, i):
		y = i
		break
print(y)


str = input().split(' ')
p = int(str[0])
q = int(str[1])
c = 0
while q >= p:
	p *= 3
	q *= 2
	c += 1
print(c)


from sys import stdin
(a, b) = map(int, stdin.readline().split())
cnt = 0
while a <= b:
	a *= 3
	b *= 2
	cnt += 1
print(cnt)


(l, b) = map(int, input().split())
y = 0
while b > l or b == l:
	y += 1
	l = l * 3
	b = b * 2
print(y)


def ve(a, b):
	res = 0
	while a <= b:
		a *= 3
		b *= 2
		res += 1
	return res
(a, b) = map(int, input().split())
print(ve(a, b))


from sys import stdin
(limak, bear) = map(int, stdin.readline().rstrip().split())
years = 0
while limak <= bear:
	limak = limak * 3
	bear = bear * 2
	years += 1
print(years)


import sys
read = lambda : sys.stdin.readline().rstrip()
readi = lambda : int(sys.stdin.readline())
writeln = lambda x: sys.stdout.write(str(x) + '\n')
write = lambda x: sys.stdout.write(x)
(a, b) = map(int, read().split())
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
writeln(year)


import sys
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl
from bisect import bisect_right as br
import itertools
from collections import Counter
import collections
import math
import heapq
import re

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def most_frequent(list):
	return max(set(list), key=list.count)

def GCD(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def ncr(n, r, p):
	t = fact[n] * (ifact[r] * ifact[n - r] % p) % p
	return t

def Convert(string):
	li = list(string.split(''))
	return li

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
prime = []
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j

def main():
	a1 = ain()
	a = a1[0]
	b = a1[1]
	count = 0
	z = 0
	while z == 0:
		if a <= b:
			count = count + 1
			a = 3 * a
			b = 2 * b
		else:
			z = 1
			break
	print(count)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from sys import stdin, stdout

def ri():
	return map(int, input().split())
(a, b) = ri()
i = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	i += 1
print(i)


s = input().split()
count = 0
while int(s[0]) <= int(s[1]):
	s[0] = str(int(s[0]) * 3)
	s[1] = str(int(s[1]) * 2)
	count += 1
print(count)


lst = input().split(' ')
a = int(lst[0])
b = int(lst[1])
cnt = 0
while True:
	if a > b:
		print(cnt)
		break
	cnt += 1
	a *= 3
	b *= 2


from math import log, floor
(a, b) = map(int, input().split())
x = float(b) / a
y = floor(log(x, 1.5)) + 1
print(y)


def main():
	nums = input().split(' ')
	(limak, bob) = (int(nums[0]), int(nums[1]))
	years = 0
	while bob >= limak:
		limak *= 3
		bob *= 2
		years += 1
	print(years)
main()


_ = input()
_ = _.split()
a = int(_[0])
b = int(_[1])
i = 1
while a <= b:
	a *= 3
	b *= 2
	if a > b:
		break
	i += 1
print(i, end='\n')


age = input()
ageList = age.split()
for a in range(2):
	ageList[a] = int(ageList[a])
Limak = ageList[0]
Bob = ageList[1]
counter = 0
while Limak <= Bob:
	counter = counter + 1
	Limak = Limak * 3
	Bob = Bob * 2
print(counter)


from sys import stdin

def get_user_input():
	(a, b) = map(int, stdin.readline().rstrip().split())
	return (a, b)
(a, b) = get_user_input()
a_fact = 3
b_fact = 2
res = 0
while b >= a:
	a = a * a_fact
	b = b * b_fact
	res += 1
print(res)


from sys import stdin

def main():
	(a, b) = [int(x) for x in stdin.readline().strip().split()]
	year = 0
	while a <= b:
		a = 3 * a
		b = 2 * b
		year = year + 1
	print(year)
main()


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
(a, b) = mi()
c = 0
while a <= b:
	a *= 3
	b *= 2
	c += 1
print(c)


def solve(limaks_weight, bobs_weight):
	soln = 0
	while limaks_weight <= bobs_weight:
		soln += 1
		limaks_weight *= 3
		bobs_weight *= 2
	return soln

def main():
	import sys
	(limaks_weight, bobs_weight) = (int(i) for i in sys.stdin.readline().split())
	print(solve(limaks_weight, bobs_weight))
main()


import math
l = input().strip().split()
bob = int(l[1])
lym = int(l[0])
x = math.log(bob / lym) / math.log(3 / 2)
x = math.ceil(x)
if 2 ** x * bob == 3 ** x * lym:
	x = x + 1
print(int(x))


(a, b) = [int(tmp) for tmp in input().split()]
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


(a, b) = map(int, input().split())
flag = True
yr = 0
while flag == True:
	a = a * 3
	b = b * 2
	yr += 1
	if a > b:
		print(yr)
		break


(aa, bb) = map(int, input().split())
i = 0
while aa <= bb:
	aa *= 3
	bb *= 2
	i += 1
print(i)


import sys
import itertools
fin = sys.stdin
(a, b) = fin.readline().split()
a = int(a)
b = int(b)
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


(l, b) = map(int, input().split())
c = 0
if l == b or l >= b:
	print('1')
elif l <= b:
	while l <= b:
		l *= 3
		b *= 2
		c += 1
	print(c)


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

def weight(pom):
	pom += 1
	pole[0] = pole[0] * 3
	pole[1] = pole[1] * 2
	if pole[0] <= pole[1]:
		weight(pom)
	else:
		print(pom)
weight(0)


c = input()
c = c.split()
c.append(0)
c[0] = int(c[0])
c[1] = int(c[1])
while c[0] <= c[1]:
	c[0] *= 3
	c[1] *= 2
	c[2] += 1
print(c[2])


indata = input('')
lis = list(indata.split(' '))
a = int(lis[0])
b = int(lis[1])
i = 0
while a <= b:
	a = a * 3
	b = b * 2
	i += 1
print(i)


linha = input()
l = []
for a in linha.split():
	if a.isdigit():
		l.append(int(a))
bear = l[0]
limak = l[1]
a = 0
while bear < limak:
	bear = bear * 3
	limak = limak * 2
	a += 1
if bear == limak:
	a += 1
print(a)


inp = input()
l = inp.split()
a = int(l[0])
b = int(l[1])
years = 0
while True:
	if a > b:
		break
	a = a * 3
	b = b * 2
	years = years + 1
print(years)


def bear(m, n):
	count = 0
	while True:
		if m > n:
			break
		else:
			m = m * 3
			n = n * 2
			count = count + 1
	return count
(m, n) = list(map(int, input().split()))
print(bear(m, n))


(x, y) = map(int, input().split())
one = 0
two = 1
if x >= y:
	print(two)
else:
	while x <= y:
		x = x * 3
		y = y * 2
		one = one + 1
	print(one)


(L, B) = input().split()
(L, B) = (int(L), int(B))
c = 0
while L <= B:
	L *= 3
	B *= 2
	c += 1
print(c)


def fun(a, b):
	i = 0
	while 1:
		if a > b:
			print(i)
			return 1
		else:
			a = a * 3
			b = b * 2
			i += 1
(a, b) = map(int, input().split())
fun(a, b)


import math

def main():
	line = input()
	(a, b) = map(int, line.split())
	t = math.ceil(math.log(a / b) / math.log(2 / 3))
	if a * 3 ** t == b * 2 ** t:
		t += 1
	print(int(t))
main()


import math
(n, k) = map(int, input().split())
x = math.log(k / n) / math.log(1.5)
if int(x) == x:
	x += 1
print(math.ceil(x))


[Limak, Bob] = list(map(int, input().split(' ')))
years = 0
while True:
	years += 1
	if Limak * 3 > Bob * 2:
		break
	else:
		Limak = Limak * 3
		Bob = Bob * 2
print(years)


(A, B) = map(int, input().split())
Y = 0
while A <= B:
	A *= 3
	B *= 2
	Y += 1
else:
	print(Y)


a = input()
(b, c) = a.split()
b = int(b)
c = int(c)
if 3 * b <= 2 * c:
	if 3 ** 2 * b > 2 ** 2 * c:
		print(2)
	elif 3 ** 3 * b > 2 ** 3 * c:
		print(3)
	elif 3 ** 4 * b > 2 ** 4 * c:
		print(4)
	elif 3 ** 5 * b > 2 ** 5 * c:
		print(5)
	elif 3 ** 6 * b > 2 ** 6 * c:
		print(6)
	elif 3 ** 7 * b > 2 ** 7 * c:
		print(7)
	elif 3 ** 8 * b > 2 ** 8 * c:
		print(8)
	elif 3 ** 9 * b > 2 ** 9 * c:
		print(9)
	else:
		print(10)
else:
	print(1)


def main():
	(limak, bob) = map(int, input().split(' '))
	y = 0
	while limak <= bob:
		y += 1
		limak = limak * 3
		bob = bob * 2
	print(y)
main()


def bear_big_brother(limak, bob):
	years = 0
	while limak <= bob:
		years += 1
		limak *= 3
		bob *= 2
	print(years)
(limak, bob) = input().split()
bear_big_brother(int(limak), int(bob))


from sys import stdin, stdout
(limak, bob) = map(int, stdin.readline().split())
year = 0
while limak <= bob:
	year += 1
	limak *= 3
	bob *= 2
stdout.write(str(year) + '\n')


def getFat(a, b):
	if int(a) > int(b):
		return 0
	if int(a) == int(b):
		return 1
	else:
		return 1 + getFat(int(3 * a), int(2 * b))
(n, k) = input().split()
n = int(n)
k = int(k)
print(getFat(int(n), int(k)))


def compute(a, b):
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	return years

def main():
	(a, b) = tuple(map(int, input().split(' ')))
	print(compute(a, b))
main()


str = input()
lst = str.split()
m = int(lst[0])
n = int(lst[1])
num = 0
while m <= n:
	m = m * 3
	n = n * 2
	num += 1
print(num)


n = input()
l = int(n[0])
b = int(n[2:4])
c = 0
while l <= b:
	l = 3 * l
	b = 2 * b
	c += 1
print(c)


def cal_number_of_years(weights):
	limak = int(weights[0])
	bob = int(weights[1])
	numberOfYears = 1
	while True:
		limak *= 3
		bob *= 2
		if limak > bob:
			print(numberOfYears)
			break
		numberOfYears += 1
weights = input()
cal_number_of_years(weights.split())


list_of_numbers = list(map(int, input().split()))
a = list_of_numbers[0]
b = list_of_numbers[1]
no_of_years = 0
product_now = 1
while 1:
	product_now = product_now * 3 / 2
	no_of_years = no_of_years + 1
	if product_now > b / a:
		print(no_of_years)
		break


import sys
from math import ceil, log
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('Yes')

def NO():
	print('No')
INF = 10 ** 18
MOD = 10 ** 9 + 7
(n, k) = RI()
ans = log(k / n, 1.5)
if ceil(ans) == ans:
	print(ceil(ans) + 1)
else:
	print(ceil(ans))


l = list(map(int, input().split()))
a = l[0]
b = l[1]
n = 1
for i in range(10):
	a = a * 3
	b = b * 2
	if a <= b:
		n += 1
	else:
		break
print(n)


(a, b) = map(int, input().split())
years = 0
while 1 is 1:
	years += 1
	a *= 3
	b *= 2
	if a > b:
		print(years)
		break


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	(a, b) = Scanner.map_int()
	ans = 0
	while a <= b:
		a *= 3
		b *= 2
		ans += 1
	print(ans)
main()


input = input()
a = int(input.split(' ')[0])
b = int(input.split(' ')[1])
ctr = 0
while a <= b:
	ctr += 1
	a = a * 3
	b = b * 2
print(ctr)


bears = input().split(' ')
(a, b) = (int(bears[0]), int(bears[1]))
import math
print(math.ceil(0.001 + math.log(b / a, 3 / 2)))


(limak, bob) = map(int, input().split())
count = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	count += 1
	if limak < bob:
		continue
	if limak > bob:
		print(count)


(x, y) = map(int, input().split(' '))
years = 0
n = 0
limak = x
bob = y
while n == 0:
	years = years + 1
	limak = years * 3 * limak
	bob = years * 2 * bob
	if limak > bob:
		print(years)
		break
	else:
		n == 0


(a, b) = tuple(map(int, input().split()))
ans = 0
for i in range(100000):
	if a <= b:
		a = a * 3
		b = b * 2
		ans += 1
print(ans)


import sys
lines = sys.stdin.readlines()[0].split(' ')
limak = int(lines[0])
bob = int(lines[1])
k = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	k += 1
print(k)


def brother(a, x):
	y = 0
	while a <= x:
		a *= 3
		x *= 2
		y += 1
	return y
(a, x) = map(int, input().split())
print(brother(a, x))


a = input()
b = a.split()
Limak = b[0]
Bob = b[1]
LimakW = int(Limak)
BobW = int(Bob)
count = 0
while LimakW <= BobW:
	LimakW *= 3
	BobW *= 2
	count += 1
else:
	print(count)


ages = input()
a = int(ages.split()[0])
b = int(ages.split()[-1])
for i in range(150):
	if a * 3 ** i > b * 2 ** i:
		print(i)
		break


from sys import stdin, stdout
(a, b) = list(map(int, stdin.readline().rstrip().split()))
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


(n1, n2) = input().split(' ')
n1 = int(n1)
n2 = int(n2)

def Limar_bigger_years(n1: int, n2: int):
	if n1 == n2:
		return 1
	year = 0
	while True:
		year = year + 1
		n1 = n1 * 3
		n2 = n2 * 2
		if n1 > n2:
			return year
			break
print(Limar_bigger_years(n1, n2))


(l, b) = list(map(int, input().split()))
l_weight = l
b_weight = b
year = 0
while l_weight <= b_weight:
	year += 1
	l_weight *= 3
	b_weight *= 2
print(year)


(a, b) = list(map(int, input().split()))
result = 0
while not a > b:
	a *= 3
	b *= 2
	result += 1
print(result)


(limark, bob) = [int(i) for i in input().split(' ')]
years = 0
while limark <= bob:
	limark *= 3
	bob *= 2
	years += 1
print(years)


from sys import stdin, stdout
inp = stdin.readline().split()
(a, b, c) = (int(inp[0]), int(inp[1]), 0)
while True:
	(a, b, c) = (a * 3, b * 2, c + 1)
	if a > b:
		stdout.write(str(c) + '\n')
		break


(a, b) = map(int, input().split())
a = a * 3
b = b * 2
c = 1
while a <= b:
	a = a * 3
	b = b * 2
	c = c + 1
print(c)


import math
(a, b) = map(int, input().split())
for var in range(1, 1000):
	if a * pow(3, var) > b * pow(2, var):
		print(var)
		break


inp = input()
info = inp.split()
limak = int(info[0])
bob = int(info[1])
years = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	years = years + 1
print(years)


(Limak, Bob) = input().split(' ')
Limak = int(Limak)
Bob = int(Bob)
c = 0
while Bob >= Limak:
	Bob = Bob * 2
	Limak = Limak * 3
	c = c + 1
print(c)


inp = input()
numberOne = int(inp.split()[0])
numberTwo = int(inp.split()[1])
linakIsBigger = False
anzahlAnJahren = 0
while linakIsBigger == False:
	if numberOne > numberTwo:
		linakIsBigger = True
	else:
		anzahlAnJahren += 1
		numberOne *= 3
		numberTwo *= 2
print(anzahlAnJahren)


weightIn = str(input())
weightList = weightIn.split()
a = int(weightList[0])
b = int(weightList[1])
yearsPassed = 0
while a <= b:
	a = a * 3
	b = b * 2
	yearsPassed += 1
print(yearsPassed)


bear_weights = input().split(' ')
wt1 = int(bear_weights[0])
wt2 = int(bear_weights[1])
count = 0
while wt1 <= wt2:
	wt1 = wt1 * 3
	wt2 = wt2 * 2
	if wt1 > wt2:
		break
	count = count + 1
print(count + 1)


import sys
import math
import bisect

def main():
	(a, b) = map(int, input().split())
	ans = 0
	while a <= b:
		a *= 3
		b *= 2
		ans += 1
	print(ans)
main()


import sys
lst = list(map(int, str(sys.stdin.readline()).split()))
a = lst[0]
b = lst[1]
count = 0
while a <= b:
	count += 1
	a = a * 3
	b = b * 2
print(count)


val = list(map(int, input().split(' ')))
i = 0
while True:
	if val[0] <= val[1]:
		i += 1
		val[0] = val[0] * 3
		val[1] = val[1] * 2
	else:
		break
print(i)


from sys import stdin, stdout
(a, b) = map(int, stdin.readline().strip().split())
counter = 0
while True:
	if a > b:
		break
	a *= 3
	b *= 2
	counter += 1
stdout.write('%d\n' % counter)


(limakWeight, bobWeight) = map(int, input().split())
years = 0
while limakWeight <= bobWeight:
	limakWeight = limakWeight * 3
	bobWeight = bobWeight * 2
	years += 1
print(years)


(n, a) = input().split()
act_a = int(n)
act_b = int(a)
year = 0
while act_a <= act_b:
	(act_a, act_b) = (3 * act_a, 2 * act_b)
	year += 1
print(year)


def function(a, b):
	i = 0
	while a <= b:
		a *= 3
		b *= 2
		i += 1
	print(i)
(a, b) = input('').split()
a = int(a)
b = int(b)
if a == b:
	print(1)
else:
	function(a, b)


(fir, sec) = map(int, input().split())
year = 0
while fir <= sec:
	fir = fir * 3
	sec = sec * 2
	year += 1
print(year)


import math
a = list(map(int, input().split(' ')))
x = math.log(a[1] / a[0])
y = math.log(1.5)
z = x / y
if type(z) == int:
	print(int(z + 1))
else:
	print(int(x // y + 1))


import sys, os.path
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
	sys.stdout = open('out.txt', 'w')
(a, b) = map(int, input().split())
ans = 0
while a <= b:
	a *= 3
	b *= 2
	ans += 1
print(ans)


(x, y) = input().split()
x = int(x)
y = int(y)
cont = 0
while x <= y:
	x *= 3
	y *= 2
	cont += 1
print(cont)


def main(strlist):
	a = strlist[0]
	b = strlist[1]
	yearC = 0
	while a <= b:
		a = a * 3 / 2
		yearC = yearC + 1
	return yearC
strlist = list(map(int, input().split(' ')))
print(main(strlist))


(a, b) = [int(x) for x in input().split()]
n = 0
while a <= b:
	n += 1
	a *= 1.5
print(n)


(Limak, Bob) = [int(n) for n in input().split()]
i = 0
while 1:
	Limak = Limak * 3
	Bob = Bob * 2
	i = i + 1
	if Limak > Bob:
		break
print(i)


a = input().split(' ')
b = [int(i) for i in a]
limak = b[0]
bob = b[1]
liczba_lat = 0
while limak < bob or limak == bob:
	limak = limak * 3
	bob = bob * 2
	liczba_lat = liczba_lat + 1
print(liczba_lat)


def weight_time(a, b):
	year = 1
	while a <= b:
		a *= 3
		b *= 2
		if a > b:
			break
		year += 1
	return year
(a, b) = map(int, input().split())
print(weight_time(a, b))


(lh, bh) = (int(x) for x in input().split())
k = 0
lh = int(lh)
bh = int(bh)
while bh >= lh:
	lh = 3 * lh
	bh = bh * 2
	k = k + 1
print(k)


(a, b) = input().split()
a = int(a)
b = int(b)
year = 0
if a < b or a == b:
	for i in range(1, 50):
		li = 3 * a
		a = li
		bo = 2 * b
		b = bo
		year += 1
		if li > bo:
			break
	print(year)


def bear(a, b, n):
	if a > b:
		return n
	else:
		return bear(3 * a, 2 * b, n + 1)
(a, b) = (int(i) for i in input().split())
print(bear(a, b, 0))


(x, y) = map(int, input().split())
anos = 0
while True:
	if x <= y:
		x *= 3
		y *= 2
	else:
		break
	anos += 1
print(anos)


import sys
(a, b) = map(int, input().split())
count_year = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	count_year += 1
print(count_year)


(a, b) = input().split()
(a, b) = (int(a), int(b))
yearElapsed = 0
while a <= b:
	a *= 3
	b *= 2
	yearElapsed += 1
print(yearElapsed)


(s, m) = input().split()
count = 0
s = int(s)
m = int(m)
while s <= m:
	s *= 3
	m *= 2
	count += 1
print(count)


from sys import stdin
input = stdin.readline
(a, b) = map(int, input().split())
count = 0
while a <= b:
	count += 1
	a *= 3
	b *= 2
print(count)


import math
inputArray = input().split(' ')
LimakWeight = int(inputArray[0])
bobWeight = int(inputArray[1])
n = 1
while LimakWeight <= bobWeight:
	n = n + 1
	LimakWeight = LimakWeight * 3
	bobWeight = bobWeight * 2
print(math.ceil(int(n - 1)))


weight = input()
weight = weight.split()
a_kg = int(weight[0])
b_kg = int(weight[1])
year = 0
while a_kg <= b_kg:
	a_kg *= 3
	b_kg *= 2
	year += 1
print(year)


import math
(a, b) = map(int, input().split())
x = math.log(1.5)
y = math.log(b / a)
c = y / x
if a == b:
	print(int(1))
elif c.is_integer() is True:
	print(int(c) + 1)
else:
	print(math.ceil(c))


import sys
weights = [int(x) for x in sys.stdin.readline().strip().split()]
limak = weights[0]
bob = weights[1]
ans = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	ans = ans + 1
print(ans)


wagi = input().split()
wagaBob = int(wagi[1])
wagaLimak = int(wagi[0])
p = False
years = 0
while p == False:
	years += 1
	wagaBob *= 2
	wagaLimak *= 3
	if wagaLimak > wagaBob:
		p = True
print(years)


(n, m) = list(map(int, input().split()))
i = 1
k = 0
while 1:
	n = n * 3
	m = m * 2
	k += 1
	if n > m:
		print(k)
		break
	i += 1


(p, q) = input().split(' ')
for i in range(1, 11):
	p = int(p) * 3
	q = int(q) * 2
	if p > q:
		print(i)
		break


import math

def BearAndBigBrother():
	(a, b) = map(int, input().split(' '))
	year = 0
	while 1:
		if a > b:
			break
		else:
			a *= 3
			b *= 2
			year += 1
	print(year)
	return None

def main():
	BearAndBigBrother()
main()


data = input()
weight = data.split()
Lw = int(weight[0])
Bw = int(weight[1])
count = 0
while Lw <= Bw:
	count += 1
	Lw = 3 * Lw
	Bw = 2 * Bw
print(count)


(a, b) = [int(n) for n in input().split()]
w = []
while a <= b:
	a = a * 3
	b = b * 2
	w.append([a, b])
print(len(w))


import sys
(n, m) = map(int, input().split())
for i in range(1, 100):
	n = n * 3
	m = m * 2
	if n > m:
		print(i)
		sys.exit()


(a, b) = map(int, input().split())
print(len([1 for i in range(50) if a * 3 ** i <= b * 2 ** i]))


(bear1, bear2) = list(map(int, input().split()))
years = 0
while bear1 <= bear2:
	bear1 *= 3
	bear2 *= 2
	years += 1
print(years)


from math import log as ln
(a, b) = list(map(int, input().split()))

def f(a, b):
	return int(ln(b / a) * 1 / ln(3 / 2)) + 1
print(f(a, b))


(a, b) = [int(x) for x in input().split()]
c = 1
for i in range(b):
	p = a * 3
	q = b * 2
	if p > q:
		c = c + 0
	else:
		c = c + 1
		a = p
		b = q
print(c)


a = input().split()
lim = int(a[0])
bob = int(a[1])
x = 0
while bob >= lim:
	bob = bob * 2
	lim = lim * 3
	x += 1
print(x)


import sys, itertools, math
(a, b) = [int(i) for i in sys.stdin.readline().strip().split(' ')]
n = 0
while True:
	if a > b:
		print(n)
		break
	a *= 3
	b *= 2
	n += 1


(L, B) = map(int, input().split())
c = 0
for i in range(10):
	if L <= B:
		L = L * 3
		B = B * 2
		c += 1
print(c)


(k, m) = map(int, input().split())
s = 1
if k == m:
	print(1)
else:
	while k < m or k == m:
		s = s + 1
		k = k * 3
		m = m * 2
	print(s - 1)


x = input()
y = x.split(' ')
n = [int(z) for z in y]
a = n[0]
b = n[1]
years = 0
while b >= a:
	a = a * 3
	b = b * 2
	years = years + 1
print(years)


def weight(w1, w2):
	count = 0
	if 3 * w1 > 2 * w2:
		count += 1
		return count
	else:
		count += 1
		return count + weight(3 * w1, 2 * w2)
(w1, w2) = map(int, input().split())
print(weight(w1, w2))


(a, b) = input().split()
yrs = 0
while int(a) <= int(b):
	a = 3 * int(a)
	b = 2 * int(b)
	yrs = yrs + 1
print(yrs)


(weight_Limak, weight_Bob) = map(int, input().split())
weight_Bob_new = weight_Bob
weight_Limak_new = weight_Limak
year = 0
while weight_Limak_new <= weight_Bob_new:
	weight_Bob_new = 2 * weight_Bob_new
	weight_Limak_new = 3 * weight_Limak_new
	year = year + 1
print(year)


a = list(map(int, input().split()))
l = a[0]
b = a[1]
count = 0
while True:
	l *= 3
	b *= 2
	count += 1
	if l > b:
		print(count)
		break


import sys
from random import choice, randint
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, sys.stdin.readline().strip().split())

def LI():
	return list(map(int, sys.stdin.readline().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().strip().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().strip().split()]

def LS():
	return sys.stdin.readline().strip().split()

def I():
	return int(sys.stdin.readline().strip())

def F():
	return float(sys.stdin.readline().strip())

def S():
	return sys.stdin.readline().strip()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))
inp = sys.stdin.readline
out = sys.stdout.write

def main():
	(a, b) = MI()
	y = 0
	while a <= b:
		a = a * 3
		b = b * 2
		y += 1
	pf(y)
main()


s = input()
s = s.split(' ')
(limak, bob) = (int(s[0]), int(s[1]))
k = 0
while limak <= bob:
	k += 1
	limak *= 3
	bob *= 2
print(k)


import math
(a, b) = tuple(map(int, input().split()))
x = 0
while (2 / 3) ** x >= a / b:
	x += 1
print(x)


t = [int(e) for e in input().split()]
z = 0

def solution(a, b, z):
	if a > b:
		return z
	z += 1
	return solution(3 * a, 2 * b, z)
print(solution(t[0], t[1], 0))


ls = list(map(lambda x: int(x), input().split()))
c = 0
while True:
	if ls[0] > ls[1]:
		print(c)
		break
	ls[0] *= 3
	ls[1] *= 2
	c += 1


splitted = input().split()
answer = []
count = 0
for item in splitted:
	answer.append(int(item))
a = answer[0]
b = answer[1]
while a <= b:
	a = a * 3
	b = b * 2
	count += 1
print(count)


n = input().split()
y = 0
while int(n[0]) <= int(n[1]):
	n[0] = 3 * int(n[0])
	n[1] = 2 * int(n[1])
	y = y + 1
print(y)


def solve(l, k):
	counter = 0
	while l <= k:
		l *= 3
		k *= 2
		counter += 1
	return counter
(l, k) = [int(i) for i in input().split(' ')]
print(solve(l, k))


s = input().split()
l = int(s[0])
m = int(s[1])
flag = 0
count = 0
while flag != 1:
	l = l * 3
	m = m * 2
	count = count + 1
	if l > m:
		flag = 1
	else:
		flag = 0
print(count)


s = input()
s = s.split()
f = s[0]
f = int(f)
sec = s[1]
sec = int(sec)
c = 0
while f <= sec:
	f = f * 3
	sec = sec * 2
	c = c + 1
print(c)


import sys
(a, b) = map(int, input().split())
for x in range(100000):
	a *= 3
	b *= 2
	if a > b:
		print(x + 1)
		sys.exit()


(x, y) = input().split()
a = int(x)
b = int(y)
counter = 0
while True:
	counter += 1
	a = a * 3
	b = b * 2
	if a > b:
		break
print(counter)


from sys import stdin, stdout
from math import *
from collections import *
mod = 1000000007

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	return a * b // gcd(a, b)

def set_bits(X):
	c = 0
	while X:
		X &= X - 1
		c += 1
	return c

def compute_MOD(N, M):
	return (N % M + M) % M

def get_array():
	return list(map(int, stdin.readline().split()))

def get_ints():
	return map(int, stdin.readline().split())

def get_int():
	return int(stdin.readline())

def get_input():
	return stdin.readline().strip()

def main():
	(a, b) = get_ints()
	c = 0
	while a <= b:
		a *= 3
		b *= 2
		c += 1
	stdout.write(str(c) + '\n')
main()


from math import *
import sys
(L, B) = map(int, input().split(' '))
if L > B:
	print(0)
	sys.exit()
r = ceil((log(L) - log(B)) / (log(2) - log(3)) + 1e-09)
print(r)


(l, b) = map(int, input().split())
z = 0
for i in range(b + l):
	if l <= b:
		l *= 3
		b *= 2
		z += 1
	elif l > b:
		print(z)
		break


a = input()
b = a.split(' ')
x = int(b[0])
y = int(b[1])
i = 0
while x <= y:
	x *= 3
	y *= 2
	i += 1
print(str(i))


import math
s = input().split()
n = math.log10(int(s[1]) / int(s[0])) / math.log10(3 / 2)
print(int(n) + 1)


import math
(a, b) = [int(i) for i in input().split()]
res = math.ceil(math.log(b / a, 3 / 2))
print(res if a * 3 ** res > b * 2 ** res else res + 1)


(n, m) = list(map(int, input().split(' ')))
sol = 0
if n > m:
	sol = 0
	print(sol)
while n <= m:
	sol += 1
	n *= 3
	m *= 2
print(sol)


(limakWeight, bobWeight) = input('').split(' ')
years = 0
for year in range(1000):
	years = years + 1
	limakWeight = int(limakWeight) * 3
	bobWeight = int(bobWeight) * 2
	if limakWeight > bobWeight:
		print(years)
		quit()


try:
	(a, b) = map(int, input().split())
	cnt = 0
	c = True
	while c:
		a *= 3
		b *= 2
		cnt += 1
		if a > b:
			c = False
	print(cnt)
except:
	pass


n = input()
c = []
c = n.split()
d = c[0]
e = c[1]
a = int(d)
b = int(e)
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


(limack, bob) = map(int, input().split(' '))
if limack == bob:
	print('1')
else:
	years = 0
	while True:
		limack = limack * 3
		bob = bob * 2
		years += 1
		if limack > bob:
			print(years)
			break


s = str(input())
(a, b) = [int(elt) for elt in s.split(' ')]
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


poids = input().split(' ')
pl = int(poids[0])
pb = int(poids[1])
a = 0
while pl <= pb:
	pl = pl * 3
	pb = pb * 2
	a = a + 1
print(a)


(small, big) = (int(e) for e in input().split(' '))
done = False
years = 0
while not done:
	if small > big:
		done = True
	else:
		small *= 3
		big *= 2
		years += 1
print(years)


def weighGreater(a, b):
	if a == b:
		return 1
	count = 0
	while a <= b:
		a *= 3
		b *= 2
		count += 1
	return count
(a, b) = map(int, input().split())
print(weighGreater(a, b))


arr = str(input()).split()
(w1, w2) = (int(arr[0]), int(arr[1]))
t = 0
while w1 <= w2:
	w1 *= 3
	w2 *= 2
	t += 1
print(t)


import math
raw = input().split(' ')
(a, b) = [int(x) for x in raw]
thre = math.log(a / b, 2 / 3)
if math.isclose(thre, round(thre), rel_tol=1e-05):
	thre = round(thre)
	overYear = thre + 1
else:
	overYear = int(thre // 1 + 1)
print(overYear)


(WeightLimak, WeightBob) = map(int, input().split(' '))
Years = 0
while WeightLimak <= WeightBob:
	WeightLimak *= 3
	WeightBob *= 2
	Years += 1
print(Years)


(n, m) = input().split()
n = int(n)
m = int(m)
count = 0
f = 0
t = 1
p = n * 3
q = m * 2
if p > q:
	f = 1
	print('1')
while p <= q:
	p = p * 3
	q = q * 2
	t = t + 1
if f == 0:
	print(t)


w = list(map(int, input().split()))
a = w[0]
b = w[1]
k = 3
j = 2
if a <= b:
	for i in range(1, 101):
		a = a * k
		b = b * j
		if a > b:
			k = i
			break
	print(k)


(a, b) = [int(x) for x in input().split()]
count = 0
if a == 1 and b == 1:
	print(1)
else:
	while b >= a:
		count += 1
		a = 3 * a
		b = 2 * b
	print(count)


TN = 1

def solution():
	(a, b) = map(int, input().split())
	ans = 1
	while a * 3 ** ans <= b * 2 ** ans:
		ans += 1
	print(ans)
while TN != 0:
	solution()
	TN -= 1


ab = input().strip().split(' ')
a = int(ab[0])
b = int(ab[1])
import math
n = math.log(b / a) / math.log(3 / 2)
n = int(n) + 1
print(n)


def solve():
	(a, b) = [int(s) for s in input().split()]
	k = 0
	while a <= b:
		a *= 3
		b *= 2
		k += 1
	print(k)
solve()


(limok, bob) = [int(i) for i in input().split()]
ans = 0
while limok <= bob:
	limok *= 3
	bob *= 2
	ans += 1
print(ans)


from fractions import Fraction
import sys
import bisect
import heapq
from math import *
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
mod = 1000000007

def inp():
	return sys.stdin.readline().strip()

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def graph(vertex):
	return [[] for i in range(0, vertex + 1)]

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(a, b):
	ans = 1
	while b > 0:
		if b % 2 == 1:
			ans *= a
		a *= a
		b //= 2
	return ans
(a, b) = map(int, input().split())
c = 0
for i in range(1, b + 1):
	a = a * 3
	b = b * 2
	if a > b:
		c = i
		break
print(c)


(weight_Limak, weight_Bob) = map(int, input().split())
k = 0
while weight_Limak <= weight_Bob:
	weight_Limak *= 3
	weight_Bob *= 2
	k += 1
if weight_Limak > weight_Bob:
	print(k)


import os
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
test_count = 1
if debug:
	test_count = int(input())
for t in range(test_count):
	if debug:
		print('Test Case #', t + 1)
	(a, b) = invr()
	ans = 0
	while a <= b:
		ans += 1
		a *= 3
		b *= 2
	print(ans)


(lm, bob) = map(int, input().split())
n = 0
while lm <= bob:
	n += 1
	lm *= 3
	bob *= 2
print(n)


line1 = input()
line1_list = list(map(int, line1.split()))
count = 0
a = line1_list[0]
b = line1_list[1]
while a <= b:
	a = a * 3
	b = b * 2
	count = count + 1
else:
	print(count)


[Limak, Bob] = [int(x) for x in input().split()]
year = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	year += 1
print(year)


def main():
	(n, c) = [int(v) for v in input().split()]
	s = 0
	while n <= c:
		n *= 3
		c *= 2
		s += 1
	print(s)
main()


import math

def main():
	(a, b) = list(map(int, input().split()))
	real = math.log2(b / a) / math.log2(1.5)
	if real.is_integer():
		real += 1
	print(math.ceil(real))
main()


from sys import stdin, stdout
(limak, brother) = map(int, stdin.readline().rstrip().split())
year = 0
while limak <= brother:
	year += 1
	limak *= 3
	brother *= 2
stdout.write(str(year))


import math
s = input().split()
a = int(s[0])
b = int(s[1])
res = 0
while a <= b:
	a *= 3
	b *= 2
	res += 1
print(res)


nums = input()
little = int(nums.split(' ')[0])
big = int(nums.split(' ')[1])
times = 0
while big >= little:
	little *= 3
	big *= 2
	times += 1
print(times)


from math import *
(a, b) = input().split()
a = int(a)
b = int(b)
x = int(log(b / a, 10) / log(3 / 2, 10))
print(x + 1)


(lw, bw) = map(int, input().split())
if lw <= bw:
	newlw = lw
	newbw = bw
	for i in range(1, 100):
		newlw = newlw * 3
		newbw = newbw * 2
		if newlw > newbw:
			print(i)
			break


def PassYear(a, b):
	a = a * 3
	b = b * 2
	return (a, b)
(a, b) = [int(x) for x in input().split()]
counter = 0
while a <= b:
	counter += 1
	(a, b) = PassYear(a, b)
print(counter)


s = input()
s = s.split()
Limak = int(s[0])
Bob = int(s[1])
i = 0
while Bob >= Limak:
	Limak = Limak * 3
	Bob = Bob * 2
	i += 1
print(i)


import sys
(l, b) = map(int, input().split())
i = 0
while l <= b:
	l = 3 * l
	b = 2 * b
	i += 1
print(i)


weights = input().split(' ')
limak = int(weights[0])
bob = int(weights[1])
years = 0
while True:
	years += 1
	limak *= 3
	bob *= 2
	if limak > bob:
		print(f'{years}')
		break


abStr = input()
aStr = abStr.split()[0]
bStr = abStr.split()[1]
a = int(aStr)
b = int(bStr)
w_a = a
w_b = b
year = 1
while w_a <= w_b:
	w_a = w_a * 3 * year
	w_b = w_b * 2 * year
	year = year + 1
print(year - 1)


def BearBrother(x, y):
	count = 0
	while True:
		x = x * 3
		y = y * 2
		count += 1
		if x > y:
			break
	return count
(x, y) = map(int, input().split())
print(BearBrother(x, y))


(weight_a, weight_b) = list(map(int, input().split(' ')))
for i in range(0, 100):
	if weight_a > weight_b:
		print(i)
		break
	weight_a = weight_a * 3
	weight_b = weight_b * 2


a = list((int(x) for x in input().split()))
limak_w = a[0]
bob_w = a[1]
for i in range(100):
	limak_w *= 3
	bob_w *= 2
	if limak_w > bob_w:
		print(i + 1)
		break
	else:
		continue


import math
(a, b) = input().split()
a = float(a)
b = float(b)
n = 0
while b >= a:
	a *= 3
	b *= 2
	n += 1
print(n)


entrada = list(input().split())
pesoLimark = int(entrada[0])
pesoBob = int(entrada[1])
anho = 0
while pesoLimark <= pesoBob:
	pesoLimark = pesoLimark * 3
	pesoBob = pesoBob * 2
	anho = anho + 1
print(anho)


(l, b) = (int(i) for i in input().strip().split(' '))
y = 0
while True:
	l *= 3
	b *= 2
	y += 1
	if l > b:
		print(y)
		exit()


def weight(a, b):
	years = 0
	while a <= b:
		years += 1
		a = a * 3
		b = b * 2
	return years
(a, b) = input().split()
years = weight(int(a), int(b))
print(years)


from sys import stdin, stdout
(n, m) = map(int, stdin.readline().split())
output = 0
while n <= m:
	(n, m) = (n * 3, m * 2)
	output += 1
stdout.write(str(output))


def year(w):
	y = 0
	while w[0] <= w[1]:
		w[0] *= 3
		w[1] *= 2
		y += 1
	return y
w = list(map(int, input().split()))
print(year(w))


(x, y) = map(int, input().split())
i = 1
while True:
	x *= 3
	y *= 2
	if x > y:
		print(i)
		break
	else:
		i += 1
		continue


a = input().split()
L = int(a[0])
b = int(a[1])
i = 0
while b >= L:
	m = L + L + L
	n = b + b
	i = i + 1
	if m > n:
		print(i)
	L = m
	b = n


from math import floor
from math import log
X = [int(x) for x in input().split()]
print(floor(log(X[1] / X[0], 3 / 2)) + 1)


(a, b) = [int(i) for i in input().split(' ')]
count = 0
if a == b:
	count = 1
else:
	while b >= a:
		a *= 3
		b *= 2
		count += 1
print(count)


(p, o) = input().split()
p = int(p)
o = int(o)
c = 0
if p <= o:
	while p <= o:
		p = p * 3
		o = o * 2
		c += 1
print(c)


command = input().split()
bob = int(command[1])
lim = int(command[0])
years = 0
result = 0
while True:
	years += 1
	bob *= 2
	lim *= 3
	if lim > bob:
		break
print(years)


from sys import stdin
from collections import defaultdict
(a, b) = [int(x) for x in input().split()]
ans = 0
while a <= b:
	ans += 1
	a *= 3
	b *= 2
print(ans)


(L, B) = list(map(int, input().split()))
C = 0
while L <= B:
	C += 1
	L *= 3
	B *= 2
print(C)


(a, b) = map(int, input().split())
ticker = 0
while True:
	if a > b:
		print(ticker)
		break
	elif a == 1 and b == 1:
		print(1)
		break
	else:
		a = a * 3
		b = b * 2
		ticker = ticker + 1


def makeit(a, b, c):
	if a > b:
		return c
	return makeit(3 * a, 2 * b, c + 1)

def main():
	(a, b) = map(int, input().split())
	print(makeit(a, b, 0))
main()


n = input()
limak = int(n.split(' ')[0])
bob = int(n.split(' ')[1])
counter = 0
while True:
	limak = 3 * limak
	bob = 2 * bob
	counter += 1
	if limak > bob:
		break
print(counter)


import math
(limak, bob) = map(int, input().split())
print(math.floor(math.log(bob / limak, 1.5)) + 1)


import sys
weights = input()
weights = weights.split()
limak = int(weights[0])
bob = int(weights[1])
numberOfYears = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	numberOfYears += 1
print(numberOfYears)


(i, j) = map(int, input().split())
count = 0
while j >= i:
	i *= 3
	j *= 2
	count += 1
print(count)


def main():
	while 1:
		try:
			(a, b) = input().split(' ')
			(a, b) = (int(a), int(b))
			years = 0
			while a <= b:
				a *= 3
				b *= 2
				years += 1
			print(years)
		except:
			break
main()


(l, b) = input().split()
(l, b, k) = (int(l), int(b), 0)
while l <= b:
	l *= 3
	b *= 2
	k += 1
print(k)


(limak_w, bob_w) = map(int, input().split(' '))
years = 0
while limak_w <= bob_w:
	years = years + 1
	limak_w = limak_w * 3
	bob_w = bob_w * 2
print(years)


import math
(a, b) = [int(x) for x in input().split()]
c = math.log(b / a)
d = math.log(3 / 2)
if c / d == math.ceil(c / d):
	print(math.ceil(c / d) + 1)
else:
	print(math.ceil(c / d))


import math
(a, b) = map(int, input().split())
t = b / a
ans = math.log(t, 1.5)
if ans % 1 == 0:
	ans += 1
ans = math.ceil(ans)
print(int(ans))


x = input().split(' ')
N = int(x[0])
K = int(x[1])
n = 0
ft = N / K
st = 2 / 3
while ft <= st ** n:
	n += 1
print(n)


import math
cin = map(int, input().split())
a = next(cin)
b = next(cin)
res = 0
while a <= b:
	a *= 3
	b *= 2
	res += 1
print(res)


(first_person, second_person) = map(int, input().split())
counter = 0
while first_person <= second_person:
	first_person *= 3
	second_person *= 2
	counter += 1
print(counter)


from sys import stdin, stdout
from math import ceil, floor, sqrt
from collections import deque, Counter
inp = stdin.readline
out = stdout.write
(a, b) = map(int, inp().strip().split())
c = 0
while a <= b:
	c += 1
	a *= 3
	b *= 2
out(str(c))


(n, k) = map(int, input().split())
for i in range(k):
	if n <= k:
		n = n * 3
		k = k * 2
		if n > k:
			print(i + 1)
			break
		else:
			q = 1


(bear, bob) = map(int, input().split())
year = 0
while bob >= bear:
	bob *= 2
	bear *= 3
	year += 1
print(year)


def bearAndBigBrother():
	n = input().split()
	limark = int(n[0])
	bob = int(n[1])
	count = 0
	while limark <= bob:
		limark *= 3
		bob *= 2
		count += 1
	print(count)
bearAndBigBrother()


(L, B) = input().split()
tl = 0
L = int(L)
B = int(B)
while True:
	if B < L:
		break
	else:
		B = B * 2
		L = L * 3
		tl += 1
print(tl)


list = input().split()
ans = 0
l = int(list[0])
b = int(list[1])
while l <= b:
	l *= 3
	b *= 2
	ans += 1
print(ans)


import math
(x, y) = [int(x) for x in input().split()]
print(int(math.log(y / x, 3 / 2) + 1))


import math
(a, b) = [int(i) for i in input().split(' ')]
x = math.log(b / a) / math.log(1.5)
fl = str(x)
print(int(fl.split('.')[0]) + 1)


(l, r) = map(int, input().split())
flag = 0
while l <= r:
	l *= 3
	r *= 2
	flag += 1
print(flag)


(a, b) = map(int, input().split())
f = 0
while a <= b:
	a *= 1.5
	f += 1
print(f)


Bear = list(map(int, input().split()))
n = 0
while 1:
	if Bear[0] <= Bear[1]:
		n = n + 1
		Bear[0] *= 3
		Bear[1] *= 2
	else:
		print(n)
		exit()


baren = input()
baren = baren.split()
for i in range(len(baren)):
	baren[i] = int(baren[i])
jahre = 0
while baren[0] <= baren[1]:
	jahre += 1
	baren[0] = baren[0] * 3
	baren[1] = baren[1] * 2
print(jahre)


arr = [int(i) for i in input().split()]
c = 0
while arr[0] <= arr[1]:
	c += 1
	arr[0] *= 3
	arr[1] *= 2
print(c)


(a, b) = map(int, input().split())
for y in range(1, 20):
	(a, b) = (a * 3, b * 2)
	if a > b:
		print(y)
		break


data = input().split()
l = int(data[0])
b = int(data[1])
cont = 0
while l <= b:
	l *= 3
	b *= 2
	cont += 1
print(cont)


(a, b) = input().split()
(a, b) = (int(a), int(b))
con = 0
while a <= b:
	a *= 3
	b *= 2
	con += 1
print(con)


s = input()
l = s.split()
a = int(l[0])
b = int(l[1])
cont = 0
while a <= b:
	a *= 3
	b *= 2
	cont += 1
print(cont)


N = input()
weight = [int(x) for x in N.split()]
year = 0
a = weight[0]
b = weight[1]
while a <= b:
	a = a * 3
	b = b * 2
	year += 1
print(year)


(a, b) = input().split()
a = int(a)
b = int(b)
count = 0
for i in range(0, 100):
	if a > b:
		print(count)
		exit()
	elif a <= b:
		a = a * 3
		b = b * 2
		count += 1
print(count)


def int_array():
	return list(map(int, input().split()))
arr = int_array()
bro1 = arr[0]
bro2 = arr[1]
count = 0
while bro1 <= bro2:
	count += 1
	bro1 *= 3
	bro2 *= 2
print(count)


def func(a, b):
	n = 0
	while a <= b:
		a = a * 3
		b = b * 2
		n = n + 1
	print(n)
(a, b) = map(int, input().split())
func(a, b)


inputs = input().split()
a = int(inputs[0])
b = int(inputs[1])
c = 0
if a == b:
	print(c + 1)
else:
	while a <= b:
		a = a * 3
		b = b * 2
		c += 1
	print(c)


import math
(w1, w2) = map(int, input().split())
a = math.log(w2 / w1, 3 / 2)
if math.ceil(a) == a:
	print(int(a + 1))
else:
	print(math.ceil(a))


(a, b) = map(int, input().split(' '))
for i in range(1, 40):
	if a * 3 ** i - b * 2 ** i > 0:
		res = i
		break
print(int(res))


(a, b) = list(map(int, input().split(' ')))
years = 0
t_years = 0
z = True
while z:
	if a * years > b * years:
		z = False
	else:
		a = a * 3
		b = b * 2
		t_years += 1
		years += 1
print(t_years)


import sys
from math import ceil
(a, b) = map(int, input().split())
result = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	result += 1
print(result)


from math import log1p as ln
(a, b) = map(int, input().split())
years = ln(b / a - 1) / ln(3 / 2 - 1)
print(int(years) + 1)


(n, k) = map(int, input().split())
i = 1
while True:
	n = n * 3
	k = k * 2
	if n > k:
		print(i)
		break
	else:
		i += 1


import math
(a, b) = map(int, input().split())
n = int(0)
while a <= b:
	n += 1
	a *= 3
	b *= 2
print(n)


lb = list(map(int, input().strip().split()))
lw = lb[0]
bw = lb[1]
years = 0
while lw <= bw:
	lw *= 3
	bw *= 2
	years += 1
print(years)


(l, m) = input().split()
l = int(l)
m = int(m)
count = 0
while l <= m:
	count = count + 1
	l = l * 3
	m = m * 2
print(count)


(l, b) = list(map(int, input().split()))
y = 0
while l <= b:
	li = l * 3
	bob = b * 2
	(l, b) = (li, bob)
	y = y + 1
print(y)


def howLong(l, b, years):
	if l > b:
		return years
	return howLong(l * 3, b * 2, years + 1)
(l, k) = input().split()
print(howLong(int(l), int(k), 0))


import math
(a, b) = input().split(' ')
a = int(a)
b = int(b)

def solution(a, b):
	if a == b:
		return 1
	else:
		years = math.ceil((math.log(b) - math.log(a)) / (math.log(3) - math.log(2)))
		if 3 ** years * a > 2 ** years * b:
			return years
		elif 3 ** years * a == 2 ** years * b:
			return years + 1
print(solution(a, b))


y = input().split()
s = 1
while int(y[0]) * 3 <= int(y[1]) * 2:
	y[0] = int(y[0]) * 3
	y[1] = int(y[1]) * 2
	s += 1
print(s)


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : li(ent())
(a, b) = ent()
cont = 0
while True:
	if a > b:
		print(cont)
		break
	a *= 3
	b *= 2
	cont += 1


import math
[limak, bob] = list(map(int, input().split()))
print(math.ceil(math.log(limak / bob) / (math.log(2) - math.log(3)) + 0.0001))


counter = 0

def getNum(a, b):
	global counter
	if a > b:
		return
	if a == b:
		counter += 1
		return
	if a < b:
		a *= 3
		b *= 2
		counter += 1
		getNum(a, b)
(a, b) = [int(x) for x in input().split()]
getNum(a, b)
print(counter)


(a, b) = input().split()
a = int(a)
b = int(b)
nr = 0
while a <= b:
	nr += 1
	a *= 3
	b *= 2
print(nr)


(limak, bob) = map(int, input().split())
qtd_anos = 0
controle = False
while controle != True:
	limak = limak * 3
	bob = bob * 2
	qtd_anos = qtd_anos + 1
	if limak > bob:
		controle = True
print(qtd_anos)


(a, b) = map(int, input().split())
(wa, wb, c) = (a, b, 0)
while True:
	wa = wa * 3
	wb = wb * 2
	c += 1
	if wa > wb:
		break
print(c)


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

def solution(a, b):
	year = 0
	while a <= b:
		year += 1
		a = a * 3
		b = b * 2
	return year
print(solution(a, b))


import math
str1 = input().split()
LimWt = int(str1[0])
BobWt = int(str1[1])
y = math.log(BobWt / LimWt, 3 / 2)
if y == math.ceil(y):
	print(math.ceil(y) + 1)
else:
	print(math.ceil(y))


import math
(a, b) = input().split()
(a, b) = (int(a), int(b))
print(math.trunc(math.log(b / a, 1.5)) + 1)


(i, e) = list(map(lambda e: int(e), input().split(' ')))
cnt = 0
while i <= e:
	i *= 3
	e *= 2
	cnt += 1
print(cnt)


import math
(a, b) = [int(item) for item in input().split(' ')]
print(int(math.floor(math.log(b / a, 1.5))) + 1)


(a, b) = [int(_) for _ in input().split()]
y = 0
while b >= a:
	y += 1
	a *= 3
	b *= 2
print(str(y))


def bears(a, b):
	for i in range(1, 100):
		a *= 3
		b *= 2
		if a > b:
			return i
(a, b) = map(int, input().strip().split(' '))
print(bears(a, b))


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def solve():
	(A, B) = getInts()
	count = 0
	while True:
		count += 1
		A *= 3
		B *= 2
		if A > B:
			return count
ans = solve()
print(ans)


x = input()
mylist = x.split(' ')
num = int(mylist[0])
num1 = int(mylist[1])
answer = 0
while num <= num1:
	num *= 3
	num1 *= 2
	answer += 1
print(answer)


import math

def solve(a, b):
	x = math.log(b / a, 3 / 2)
	return math.floor(x) + 1

def main():
	(a, b) = list(map(int, input().split()))
	print(solve(a, b))
main()


a = input().split()
limak = int(a[0])
bro = int(a[1])
year = 0
while True:
	limak *= 3
	bro *= 2
	if limak > bro:
		year += 1
		break
	year += 1
print(year)


a = list(map(int, input().strip().split(' ')))
sum = 0
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	sum += 1
print(sum)


(num1, num2) = map(int, input().split())
if num1 == num2:
	print('1')
else:
	year = 1
	while True:
		num1 = num1 * 3
		num2 = num2 * 2
		if num1 > num2:
			print(year)
			break
		year += 1


age = input().split()
limak = int(age[0])
bob = int(age[1])
c = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	c += 1
print(c)


import math
lst = input().split(' ')
res = math.floor(math.log(int(lst[1]) / int(lst[0]), 3 / 2) + 1)
if res < 0:
	res = 0
print(res)


import math
(limak, bob) = list(map(int, input().split(' ')))
same_age_time = -1 * (math.log(limak / bob) / math.log(3 / 2))
print(int(same_age_time) + 1)


s = input()
(a, b) = s.split()
a = int(a)
b = int(b)
for i in range(1, 1000000):
	a = a * 3
	b = b * 2
	if a <= b:
		continue
	else:
		break
print(i)


(a, b) = tuple(map(int, input().split()))
i = 0
while True:
	if a > b:
		break
	i += 1
	a = 3 * a
	b = 2 * b
print(i)


(m, n) = map(int, input().split())
count = 0
for i in range(1, 100):
	m = m * 3
	n = n * 2
	count += 1
	if m > n:
		break
print(count)


(l, b) = map(int, input().split())
flag = True
year = 0
while flag:
	l = l * 3
	b = b * 2
	if l > b:
		flag = False
	year = year + 1
print(year)


n = list(map(int, input().split()))
c = 0
while True:
	if n[0] > n[1]:
		print(c)
		break
	else:
		n[0] *= 3
		n[1] *= 2
		c += 1


a = []
s = input()
a = list(s.split(' '))
l = int(a[0])
b = int(a[1])
count = 0
while 1:
	l = l * 3
	b = b * 2
	count = count + 1
	if l > b:
		break
print(count)


(pesoLimak, pesoBob) = map(int, input().split(' '))
ano = 0
while pesoLimak <= pesoBob:
	pesoLimak = 3 * pesoLimak
	pesoBob = 2 * pesoBob
	ano += 1
print(ano)


(a, b) = map(int, input().split())
l = []
if a == b:
	l.append(1)
else:
	flag = 0
	for i in range(b):
		if a < b:
			a = a * 3
			b = b * 2
			flag += 1
			if a == b:
				l.append(flag + 1)
				break
			else:
				l.append(flag)
print(l[-1])


import math
(n, m) = input().split()
(n, m) = (int(n), int(m))
y = 0
if n == 1 and m == 1:
	print(1)
else:
	while n <= m:
		n = n * 3
		m = m * 2
		y = y + 1
	print(y)


l = input()
l = l.strip().split()
limak = int(l[0])
bob = int(l[1])
c = 0
while bob >= limak:
	bob = bob * 2
	limak = limak * 3
	c += 1
print(c)


(x, y) = input().split()
a = int(x)
b = int(y)
c = 1
while True:
	a = a * 3
	b = b * 2
	if a > b:
		break
	else:
		c = c + 1
print(c)


import math
(a, b) = list(map(int, input().split()))
print(int(math.log10(b / a) // math.log10(3 / 2)) + 1)


def solve(a, b):
	counter = 0
	while a <= b:
		a *= 3
		b *= 2
		counter += 1
	print(counter)
(n, h) = input().split()
n = int(n)
h = int(h)
solve(n, h)


nums = input().split()
a = int(nums[0])
b = int(nums[1])
year = 0
while True:
	if a > b:
		break
	else:
		a *= 3
		b *= 2
		year += 1
		continue
print(year)


s = input().split()
l = int(s[0])
b = int(s[1])
c = 0
while l < b:
	l *= 3
	b *= 2
	c += 1
if l == b:
	print(c + 1)
else:
	print(c)


(a, b) = map(int, input().split())
cnt = 0
while 1:
	a = 3 * a
	b = 2 * b
	if a <= b:
		cnt += 1
		continue
	elif a > b:
		cnt += 1
		break
print(cnt)


import math
(limak, bob) = map(int, input().split())
print(math.floor(math.log(bob / limak) / math.log(3 / 2) + 1))


import sys
numeros = list()
year = list()
lines = sys.stdin.readlines()
for linea in lines:
	c = linea.split()
	c = list(map(int, c))
	numeros.append(c)
h = numeros[0]
limak = h[0]
bob = h[1]
if limak > bob:
	print(len(year))
	sys.exit()
else:
	while limak <= bob:
		if limak <= bob:
			limak = limak * 3
			bob = bob * 2
			year.append(1)
print(len(year))


def yearsToBeat(weight_limak, weight_bob):
	years = 0
	while weight_limak <= weight_bob:
		weight_limak *= 3
		weight_bob *= 2
		years += 1
	return years
(weight_limak, weight_bob) = list(map(int, input().split()))
print(yearsToBeat(weight_limak, weight_bob))


import math
import sys
(a, b) = map(int, sys.stdin.readline().split(' '))
res = 0
while a <= b:
	b = b * 2
	a = a * 3
	res = res + 1
print(res)


(a, b) = [int(item) for item in input().split()]
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


from math import log, floor
a = list(map(int, input().split()))
print(floor(log(a[1] / a[0], 1.5)) + 1)


(a, b) = [int(i) for i in input().split()]
years = 0
while not a > b:
	a *= 3
	b *= 2
	years += 1
print(years)


(a, y) = map(int, input().split())
i = 0
while a < y:
	a = a * 3
	y = y * 2
	i += 1
if a == y:
	print(i + 1)
else:
	print(i)


x = input()
y = x.split()
z = 1
while [int(y[0]) * 3 ** z] <= [int(y[1]) * 2 ** z]:
	z = z + 1
if [int(y[0]) * 3 ** z] > [int(y[1]) * 2 ** z]:
	print(z)


(t, d) = map(int, input().split(' '))
y = 0
while t <= d:
	y += 1
	d *= 2
	t *= 3
print(y)


(a, b) = map(int, input().split())
ans = i = flag = 0
while flag == 0:
	a *= 3
	b *= 2
	ans += 1
	if a > b:
		print(ans)
		flag = 1


(n, m) = input().split()
(n, m) = (int(n), int(m))
counter = 0
while n <= m:
	counter += 1
	m = m * 2
	n = n * 3
print(counter)


w = input().split()
Lw = int(w[0])
Bw = int(w[1])
i = 0
while True:
	if Lw * 3 ** i > Bw * 2 ** i:
		break
	else:
		i = i + 1
print(i)


import math
x = list(map(int, input().split()))
t = True
i = 1
age1 = 0
age2 = 0
age1 = x[0]
age2 = x[1]
for i in range(0, 1000):
	age1 = age1 * 3
	age2 = age2 * 2
	i += 1
	if age1 > age2:
		print(i)
		break


import math
(a, b) = tuple(map(int, input().split()))
t = math.log2(b / a) / math.log2(1.5)
if t.is_integer():
	t = int(t + 1)
else:
	t = math.ceil(t)
print(t)


(a, b) = map(int, input().split())
i = 0
while i >= 0:
	s = a * 3 ** i
	bi = b * 2 ** i
	if s > bi:
		print(i)
		break
	i += 1


n = 2
a = input().split()
k = int(a[0])
j = int(a[1])
s = 0
while True:
	k = k * 3
	j = j * 2
	s = s + 1
	if k > j:
		break
print(s)


t = list(map(int, input().split()))
a = int(t[0])
b = int(t[1])
z = 1
while z > 0:
	if a <= b:
		a = 3 * a
		b = 2 * b
	if a > b:
		break
	z += 1
print(z)


l = list(map(int, input().split()))
first_person = l[0]
second_person = l[1]
num_iterations = 0
while first_person <= second_person:
	first_person = first_person * 3
	second_person = second_person * 2
	num_iterations = num_iterations + 1
print(num_iterations)


ab = list(map(str, input().split()))
a = int(ab[0])
b = int(ab[1])
c = 0
while a <= b:
	c = c + 1
	a = a * 3
	b = b * 2
print(c)


(a, b) = [int(x) for x in input().split()]
for i in range(1000):
	if a > b:
		print(i)
		break
	a *= 3
	b *= 2


years = 0
ages = list(map(int, input().split()))
(lim, bob) = (ages[0], ages[1])
while lim <= bob:
	lim = lim * 3
	bob = bob * 2
	years = years + 1
print(years)


(a, b) = map(int, input().split())
yearsCounter = 1
aAge = a * 3 * yearsCounter
bAge = b * 2 * yearsCounter
while aAge <= bAge:
	yearsCounter += 1
	aAge = aAge * 3 * yearsCounter
	bAge = bAge * 2 * yearsCounter
print(yearsCounter)


(limak, bob) = [int(x) for x in input().split()]
for i in range(100):
	if limak > bob:
		print(i)
		break
	else:
		limak = limak * 3
		bob = bob * 2


(lw, bw) = map(int, input().split())
count = 0
while lw <= bw:
	lw *= 3
	bw *= 2
	count += 1
	if lw > bw:
		break
print(count)


(l, b) = map(int, input().split())
zero = 0
for i in range(b):
	if l <= b:
		l *= 3
		b *= 2
		zero += 1
print(zero)


from sys import stdin, stdout
(n, k) = map(int, stdin.readline().rstrip().split())
i = 0
while n <= k:
	i = i + 1
	n = n * 3
	k = k * 2
print(i)


(w1, w2) = map(int, input().split())
for i in range(1, 100):
	w1 *= 3
	w2 *= 2
	if w1 > w2:
		break
print(i)


(n1, n2) = map(int, input().split())
fy = 0
while 1:
	n1 = n1 * 3
	n2 = n2 * 2
	fy = fy + 1
	if n1 > n2:
		break
print(fy)


(l, b) = map(int, input().split())

def whenheavier(l, b):
	y = 0
	if l == b:
		y = 1
	else:
		while l < b or l == b:
			l *= 3
			b *= 2
			y = y + 1
	return y
print(whenheavier(l, b))


Y = 0
L = list(map(int, input().split()))
while L[0] <= L[1]:
	L[0] *= 3
	L[1] *= 2
	Y += 1
print(Y)


(limak, bob) = map(int, input().split())
a = 1
while limak * 3 <= bob * 2:
	limak *= 3
	bob *= 2
	a += 1
print(a)


import math
(a, b) = [int(e) for e in input().split()]
n = math.log(b / a) / math.log(1.5)
n_ceiled = math.ceil(n)
if float(n_ceiled) == n:
	n_ceiled += 1
print(n_ceiled)


s = str(input()).split(' ')
a = int(s[0])
b = int(s[1])
output = 1
while True:
	if a * 3 ** output > b * 2 ** output:
		break
	output += 1
print(output)


def solve(limak, bob):
	years = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		years += 1
	return years
(limak, bob) = list(map(int, input().split(' ')))
print(solve(limak, bob))


(l, b) = input().split()
l = int(l)
b = int(b)
i = 0
x = True
while x == True:
	l = 3 * l
	b = 2 * b
	if l > b:
		x = False
	i = i + 1
print(i)


def bear(n):
	a = n[0]
	b = n[1]
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	print(years)
n = list(map(int, input().split()))
bear(n)


import cmath
(a, b) = input().split()
a = int(a)
b = int(b)
counta = 0
while a <= b:
	a = a * 3
	b = b * 2
	counta += 1
else:
	print(counta)


nk = input().split()
n = int(nk[0])
m = int(nk[1])
count = 0
while n <= m:
	n *= 3
	m *= 2
	count += 1
print(count)


(a, b) = list(map(int, input().split()))
c = 0
f = True
while f:
	a = a * 3
	b = b * 2
	c += 1
	if a > b:
		f = False
print(c)


weights = input()
limark = int(weights.split()[0])
bob = int(weights.split()[1])
year = 0
while limark <= bob:
	limark = limark * 3
	bob = bob * 2
	year = year + 1
print(year)


def func():
	a = input().split(' ')
	l1 = list(map(int, a))
	w1 = l1[0]
	w2 = l1[1]
	count = 0
	while w1 <= w2:
		w1 *= 3
		w2 *= 2
		count += 1
	return count
print(func())


from sys import stdin
a = stdin.readline().split()
b = int(a[0])
c = int(a[1])
d = 0
while b <= c:
	b = 3 * b
	c = 2 * c
	d += 1
	if b > c:
		break
print(d)


def program(first, sec):
	turns = 0
	while first <= sec:
		first *= 3
		sec *= 2
		turns += 1
	return turns
n = list(map(int, input().strip().split()))
first = n[0]
sec = n[1]
print(program(first, sec))


(x, y) = map(int, input().split())
score = 0

def bear(a, b):
	while a <= b:
		global score
		score = score + 1
		a = a * 3
		b = b * 2
	print(score)
bear(x, y)


def myMethod(a, b):
	y = 0
	while a <= b:
		a = a * 3
		b = b * 2
		y += 1
	return y
(a, b) = [int(x) for x in input().split()]
print(myMethod(a, b))


lb = input().split()
l = int(lb[0])
b = int(lb[1])
y = 0
while y < 10000:
	l *= 3
	b *= 2
	y += 1
	if l > b:
		print(y)
		break


def find(a, b, year, initial=1):
	if a == b:
		print(year)
	elif a > b:
		print(year - initial)
	else:
		find(a * 3, b * 2, year + 1)
string = input().split(' ')
a = int(string[0])
b = int(string[1])
find(a, b, 1)


s = str(input())
ab = list(s.split(' '))
a = int(ab[0])
b = int(ab[1])
count = 0
while a <= b:
	a = a * 3
	b = b * 2
	count += 1
print(count)


(a, b) = map(float, input().split())
c = 0
while b >= a:
	a = a * 3
	b = b * 2
	c = c + 1
print(c)


bearen = [int(s) for s in input().split(' ')]
bruh = 0
while True:
	bearen[0] = bearen[0] * 3
	bearen[1] = bearen[1] * 2
	bruh += 1
	if bearen[0] > bearen[1]:
		break
print(bruh)


inputs = input()
weights = list(map(int, inputs.split()))
limak = weights[0]
bob = weights[1]
year = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	year += 1
print(year)


counts = input().split()
counts = [int(elem) for elem in counts]
a = counts[0]
b = counts[1]
counter_of_years = 0
while a <= b:
	a *= 3
	b *= 2
	counter_of_years += 1
print(counter_of_years)


nums = 0

def getr(a, b):
	if a <= b:
		global nums
		nums = nums + 1
		a = a * 3
		b = b * 2
		return getr(a, b)
	else:
		return nums
(a, b) = map(int, input().split())
print(getr(a, b))


(lim_w, bob_w) = map(int, input().split())
assert lim_w <= bob_w
year = 0
while lim_w <= bob_w:
	lim_w *= 3
	bob_w *= 2
	year += 1
print(year)


(a, b) = map(int, input().split())
for x in range(1, 11):
	a = a * 3
	b = b * 2
	if a > b:
		print(x)
		break


(a, b) = str(input()).split()
(a, b) = (int(a), int(b))
n = 0
while True:
	n += 1
	a *= 3
	b *= 2
	if a > b:
		print(n)
		break


import math
listOfInputs = input().split()
l = int(listOfInputs[0])
b = int(listOfInputs[1])
years = 1
while years != 999:
	l *= 3
	b *= 2
	if l > b:
		print(years)
		break
	years += 1


def to_list(s):
	return list(map(lambda x: int(x), s.split(' ')))

def solve(a, b):
	i = 0
	while a <= b:
		a *= 3
		b *= 2
		i += 1
	return str(i)
(a, b) = to_list(input())
print(solve(a, b))


(limak_w, bro_weight) = [int(i) for i in input().split(' ')]
n_years = 0
while limak_w <= bro_weight:
	n_years += 1
	limak_w *= 3
	bro_weight *= 2
print(n_years)


(a, b) = map(int, input().split())
year = 0
for i in range(10000000):
	a *= 3
	b *= 2
	year += 1
	if a > b:
		break
print(year)


weight = input().split(' ')
Limak = int(weight[0])
Brother = int(weight[1])
count = 0
while Limak <= Brother:
	count += 1
	Limak *= 3
	Brother *= 2
print(count)


li = [int(a) for a in input().split(' ')]
limak = li[0]
bob = li[1]
for i in range(100000000):
	limak *= 3
	bob *= 2
	if limak > bob:
		print(i + 1)
		break


(a, b) = [int(n) for n in input().split()]
y = 1
while b * (2 / 3) ** y >= a:
	y += 1
print(y)


from math import *
(a, b) = [int(x) for x in input().split(' ')]
print(ceil(log10(b / a) / log10(1.5) + 1e-05))


from sys import stdin, exit
(a, b) = map(int, input().split(' '))
n = 0
while a <= b:
	a *= 3
	b *= 2
	n += 1
print(n)


def main():
	(a, b) = [int(i) for i in input().strip().split()]
	count = 0
	while True:
		count += 1
		a *= 3
		b *= 2
		if a > b:
			print(count)
			break
main()


class check:

	def judge(self, w):
		cntr = 1
		while 3 * w[0] <= 2 * w[1]:
			cntr += 1
			w[0] *= 3
			w[1] *= 2
		return cntr

	def ltoi(self):
		s = input().split()
		return [int(i) for i in s]
c = check()
print(c.judge(c.ltoi()))


(l, b) = [int(u) for u in input().split()]
year = 0
while True:
	if l > b:
		break
	else:
		l = l * 3
		b = b * 2
		year = year + 1
print(year)


(A, B) = [int(d) for d in input().split(' ')]
contador = 0
while A <= B:
	A = 3 * A
	B = 2 * B
	contador += 1
print(contador)


(limak, bob) = [int(x) for x in input().split(' ')]
count = 0
while True:
	if limak > bob:
		break
	count += 1
	limak *= 3
	bob *= 2
print(count)


from math import ceil
(a, b) = map(int, input().split())
c = b / a
t = 0
while c >= 1:
	c /= 1.5
	t += 1
print(t)


import sys
inputs = sys.stdin.readline().split()
a = int(inputs[0])
b = int(inputs[1])
year = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	year = year + 1
print(year)


def grater(a, b):
	i = 0
	if a == b:
		return 1
	while a <= b:
		a = a * 3
		b = b * 2
		i += 1
	return i
(a, b) = [int(a) for a in input().split()]
i = 0
res = grater(a, b)
print(res)


def check(a, b):
	n = 0
	f = 0
	while n == 0:
		a *= 3
		b *= 2
		if a > b:
			n = 1
		f += 1
	return f
(w1, w2) = map(int, input().split())
print(check(w1, w2))


import math
a = list(map(int, input().split()))
x = int(math.log(a[1] / a[0], 1.5))
print(x + 1)


(a, b) = input().split()
(a, b) = (int(a), int(b))
for i in range(1, 1000000):
	a = a * 3
	b = b * 2
	if a > b:
		print(i)
		break


q = input().split()
q[0] = int(q[0])
q[1] = int(q[1])
for i in range(100):
	if q[0] > q[1]:
		print(i)
		break
	q[0] *= 3
	q[1] *= 2


def Greater(a, b):
	global k
	if a > b:
		return k
	else:
		k += 1
		return Greater(3 * a, 2 * b)
(a, b) = map(int, input().split())
k = 1
if a > b:
	print(0)
else:
	print(Greater(3 * a, 2 * b))


lst = [int(i) for i in input().split()]
first = lst[0]
second = lst[1]
counter = 0
while not first > second:
	first *= 3
	second *= 2
	counter += 1
print(counter)


a = [int(x) for x in input().split()]
i = a[0]
j = a[1]
k = 0
while i <= j:
	i *= 3
	j *= 2
	k += 1
print(k)


li = input().split()
i = 0
while i < len(li):
	li[i] = int(li[i])
	i += 1
counter = 0
while not li[0] > li[1]:
	li[0] = li[0] * 3
	li[1] = li[1] * 2
	counter += 1
print(counter)


linea = input()
a = []
a = linea.split()
l = int(a[0])
b = int(a[1])
x = 0
while True:
	x += 1
	if l * 3 > b * 2:
		break
	l *= 3
	b *= 2
print(x)


r = [int(i) for i in input().split()]
(a, b) = (r[0], r[1])
n = 0
while not a > b:
	a = a * 3
	b = b * 2
	n += 1
print(n)


(li, bo) = map(int, input().split())
i = 0
while 1:
	i += 1
	li *= 3
	bo *= 2
	if li > bo:
		break
print(i)


import math
import os
import random
import re
import sys
a = input().split()
Limak = int(a[0])
Bob = int(a[1])
year = 0
while Limak <= Bob:
	Limak = 3 * Limak
	Bob = 2 * Bob
	year = year + 1
print(year)


ages = list(input().split(' '))
ages = [int(i) for i in ages]
count = 0
while ages[0] <= ages[1]:
	count += 1
	ages[0] *= 3
	ages[1] *= 2
print(count)


import sys, os.path
import math
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
(a, b) = map(int, input().split())

def solve(x, y):
	if x == y:
		return 1
	else:
		return math.floor(math.log(y / x) / math.log(1.5) + 1)
print(solve(a, b))


l = [int(i) for i in input().strip().split()]
(a, b) = l
cnt = 0
while a <= b:
	l = [a * 3, b * 2]
	(a, b) = l
	cnt += 1
print(cnt)


(lomaka, boba) = input().split(' ')
lomaka = int(lomaka)
boba = int(boba)
time = 0
while lomaka <= boba:
	time += 1
	lomaka *= 3
	boba *= 2
print(time)


(w1, w2) = map(int, input().split())
k = 0
while True:
	k += 1
	if w1 * 3 ** k > w2 * 2 ** k:
		break
print(k)


import sys
(a, b) = [int(x) for x in input().split()]
for i in range(1, 200):
	a *= 3
	b *= 2
	if a > b:
		print(i)
		raise SystemExit()


(a, b) = map(int, input().split())
q = 0
for i in range(10000):
	q = q + 1
	if a > b:
		print(q - 1)
		break
	a = a * 3
	b = b * 2


(n, m) = [int(elem) for elem in input().split()]
year = 0
while m >= n:
	m *= 2
	n *= 3
	year += 1
print(year)


(s, v) = map(int, input().split())
t = 0
while s <= v:
	t = t + 1
	v = v * 2
	s = s * 3
print(t)


x = input().split(' ')
for i in range(len(x)):
	x[i] = int(x[i])
r = 0
while x[0] <= x[1]:
	x[0] = x[0] * 3
	x[1] = x[1] * 2
	r += 1
print(r)


from sys import stdin, stdout
(less, more) = map(int, stdin.readline().split())
count = 0
while less <= more:
	less *= 3
	more *= 2
	count += 1
stdout.write(str(count))


(littlebear, bigbear) = map(int, input().strip().split())
i = 0
gameover = True
while gameover:
	if littlebear > bigbear:
		print(i)
		gameover = False
	else:
		littlebear = littlebear * 3
		bigbear = bigbear * 2
		i += 1


import sys, re, array, math, functools
input = lambda : sys.stdin.readline()

@functools.lru_cache(maxsize=10000000)
def Main():
	(a, b) = map(int, input().split())
	cnt = 0
	sm = 0
	while a <= b:
		cnt += 1
		(a, b) = (a * 3, b * 2)
	print(cnt)
Main()


def solution():
	(limak, bob) = (int(i) for i in input().split(' '))
	years = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		years += 1
	print(years)
solution()


def main():
	(a, b) = tuple([int(num) for num in input().split()])
	years = 0
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	print(years)
main()


(ves_l, ves_b) = input().split()
ves_l = int(ves_l)
ves_b = int(ves_b)
let = 0
while ves_l <= ves_b:
	let = let + 1
	ves_l = ves_l * 3
	ves_b = ves_b * 2
print(let)


(young, old) = input().split()
ratio = int(young) / int(old)
update = 3 / 2
years = 0
while ratio <= 1:
	ratio *= update
	years += 1
print(years)


def cap(a, b):
	k = 0
	while True:
		(a, b) = (a * 3, b * 2)
		k += 1
		if a > b:
			return k
(a, b) = tuple(map(int, input().split(' ')))
print(cap(a, b))


import sys
counter = 0
for line in sys.stdin:
	if counter == 0:
		(a, b) = [int(j) for j in line.split()]
		break
	counter += 1
i = 0
while True:
	i += 1
	a *= 3
	b *= 2
	if a > b:
		print(i)
		break


(lm, b) = map(int, input().split())
y = 0
if lm == b:
	print('1')
else:
	while lm <= b:
		lm = lm * 3
		b = b * 2
		y = y + 1
	print(y)


inp_arr = list(map(int, input().strip().split()))
l = inp_arr[0]
b = inp_arr[1]
co = 0
while l <= b:
	l *= 3
	b *= 2
	co += 1
print(co)


import sys
(n, m) = map(int, input().split())
y = 0
while n <= m:
	n = n * 3
	m = m * 2
	y = y + 1
print(y)


import math
ch = input().split()
print(int((math.log(int(ch[0])) - math.log(int(ch[1]))) / math.log(2 / 3) + 1))


(a, b) = map(int, input().split())
d = a
c = b
s = 0
while d <= c:
	d *= 3
	c *= 2
	s += 1
print(s)


inp = str(input()).split(' ')
la = int(inp[0])
b = int(inp[1])
years = 0
while la <= b:
	la = la * 3
	b = b * 2
	years += 1
print(years)


import sys
(l, b) = [int(x) for x in input().split()]
count = 0
while True:
	l = l * 3
	b = b * 2
	count += 1
	if l > b:
		break
print(int(count))


year = 0
inputs = input().split(' ')
for i in range(len(inputs)):
	inputs[i] = int(inputs[i])
while inputs[0] <= inputs[1]:
	inputs[0] *= 3
	inputs[1] *= 2
	year += 1
print(year)


list = input().split(' ')
a = int(list[0])
b = int(list[1])
year = 0
while True:
	year += 1
	a *= 3
	b *= 2
	if a > b:
		break
print(year)


n = input().split()
a = int(n[0])
b = int(n[1])
count = 0
while a <= b:
	count += 1
	a = a * 3
	b = b * 2
	if a > b:
		print(count)


def main():
	import math
	(a, b) = map(int, input().split())
	o = math.log10(b / a) / math.log10(3 / 2)
	o = math.ceil(o + 1e-08)
	print(o)
main()


inpu = str(input())
inp = list(map(int, inpu.split()))
a = inp[0]
b = inp[1]
count = 0
while a <= b:
	count = count + 1
	a = a * 3
	b = b * 2
print(count)


astr = input()
x = astr.split()
a = int(x[0])
b = int(x[1])
year = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	year = year + 1
print(year)


def main():
	weights = input().split()
	limak = int(weights[0])
	bob = int(weights[1])
	years = 0
	while True:
		if limak > bob:
			print(years)
			break
		limak *= 3
		bob *= 2
		years += 1
main()


x = input()
x = x.split()
l = []
for i in x:
	i = int(i)
	l.append(i)
for j in range(1, 1000):
	l[0] *= 3
	l[1] *= 2
	if l[0] > l[1]:
		print(j)
		break


from math import log
poids = input().split(' ')
a = int(poids[0])
b = int(poids[1])
while a > b:
	print('il faut que le poids de Limak est inferieur au poids du Bob ')
	poids = input().split(' ')
	a = int(poids[0])
	b = int(poids[1])
if a == 0:
	print('WTFFFF')
elif a == b:
	print(1)
else:
	print(1 + int(log(b / a) / log(3 / 2)))


from sys import stdin, stdout
(a, b) = map(int, stdin.readline().split())
y = 0
while True:
	if a > b:
		break
	else:
		a = a * 3
		b = b * 2
	y = y + 1
stdout.write(str(y))


from sys import exit as sys_return
(limak, bob) = map(int, input().split())
year = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	year += 1
print(year)


(a, b) = input().strip(' ').split(' ')
likam_year = 3
bob_year = 2
count = 0
a = int(a)
b = int(b)
flag = True
while flag:
	a *= likam_year
	b *= bob_year
	count += 1
	if a > b:
		flag = False
print(count)


(n, m) = map(int, input().split())
a = 0
for i in range(10):
	if n * 3 ** i <= m * 2 ** i:
		a += 1
	else:
		a += 0
print(a)


import math
(a, b) = input().split()
y = math.log(int(b) / int(a), 1.5)
year = math.ceil(y)
if year == y:
	year = year + 1
print(year)


(a, b) = [int(x) for x in input().split()]
i = 0
while 1:
	a *= 3
	b *= 2
	i += 1
	if a > b:
		print(i)
		quit()


ab = tuple(map(int, input().split()))
a = ab[0]
b = ab[1]
ans = 0
while a <= b:
	a *= 3
	b *= 2
	ans += 1
print(ans)


xyz = []

def input1():
	global xyz
	if len(xyz) == 0:
		xyz = [i for i in input().split()]
		xyz = xyz[::-1]
	v = xyz[-1]
	del xyz[-1]
	return v
l = int(input1())
b = int(input1())
n = 0
while l <= b:
	l = l * 3
	b = b * 2
	n = n + 1
print(n)


(a, b) = map(int, input().strip().split())
years = 1
while True:
	a *= 3
	b *= 2
	if b >= a:
		years += 1
	else:
		break
print(years)


[a, b] = list(map(float, input().split()))
from math import log2, floor
print(floor(log2(b / a) / log2(3.0 / 2.0)) + 1)


import sys
(a, b) = map(int, sys.stdin.readline().split())
i = 0
if a == b:
	print(1)
else:
	while a <= b:
		i += 1
		a *= 3
		b *= 2
	print(i)


def solve(w1, w2):
	counter = 0
	while w1 <= w2:
		w1 = w1 * 3
		w2 = w2 * 2
		counter += 1
	return counter
(w1, w2) = input().split()
print(solve(int(w1), int(w2)))


(limak, bob) = map(int, input().split())
time = 0
while True:
	limak = limak * 3
	bob = bob * 2
	time = time + 1
	if limak > bob:
		break
	else:
		continue
print(time)


from sys import stdin

def age_is_larger(a, b):
	if a > b:
		return 0
	return 1 + age_is_larger(a * 3, b * 2)
data = [int(x) for x in stdin.readline().split()]
print(age_is_larger(data[0], data[1]))


from math import ceil, log
print(ceil(-log(eval(input().replace(' ', '/')), 3 / 2) + 1e-09))


import math
(x, y) = list(map(int, input().split()))
i = 0
while 1:
	x *= 3
	y *= 2
	if x > y:
		i += 1
		break
	i += 1
print(i)


(a, b) = map(int, input().split())
import math
x = math.log(1.5)
y = math.log(b / a)
n = y // x + 1
print(int(n))


(n, m) = map(int, input().split())
i = int(0)
count = 0
sum = 0
while i < 10:
	n = n * 3
	m = m * 2
	if n <= m:
		count = count + 1
	if n >= m:
		sum = sum + 1
		break
	i = i + 1
print(count + sum)


(a, b) = map(int, input().split())
years = 0
weight = True
while True:
	if a > b:
		break
	else:
		a = a * 3
		b = b * 2
	years += 1
print(years)


(a, b) = [int(i) for i in input().split()]
i = 1
p = 1.5 * a / b
while p <= 1:
	i = i + 1
	p = p * 1.5
print(i)


import math
data = input()
spc = data.find(' ')
a = int(data[:spc])
b = int(data[spc + 1:])
x = math.log(a / b, 10)
y = math.log(3 / 2, 10)
n = int(x / y)
if n >= 0:
	print(n + 1)
else:
	n = -1 * n
	print(n + 1)


x = input().split()
li = int(x[0])
bob = int(x[1])
counter = 0
greater = False
while greater == False:
	counter = counter + 1
	li = li * 3
	bob = bob * 2
	if li > bob:
		greater = True
print(counter)


(a, b) = input().split()
a = int(a)
b = int(b)
jahre = 1
while True:
	a *= 3
	b *= 2
	if a > b:
		print(jahre)
		break
	jahre += 1


weight = list(map(int, input().split()))
Limak = weight[0]
Bob = weight[1]
for i in range(1, 20):
	Limak *= 3
	Bob *= 2
	if Limak > Bob:
		print(i)
		break


a = input()
(m, n) = a.split()
m = int(m)
n = int(n)
d = True
s = 0
while d:
	m = m * 3
	n = n * 2
	if m > n:
		d = False
	s = s + 1
print(s)


def solution(limak: int, bob: int) -> int:
	n = 1
	for year in range(50):
		if limak * 3 ** n > bob * 2 ** n:
			return year + 1
		n += 1
ages = input().split(' ')
limakAge = int(ages[0])
bobAge = int(ages[1])
print(solution(limakAge, bobAge))


def main():
	(n, m) = map(int, input().split())
	n = n / m
	count = 0
	while n <= 1:
		n = n * 1.5
		count += 1
	print(count)
main()


try:
	(a, b) = map(int, input().split())
	count = 0
	while a <= b:
		a *= 3
		b *= 2
		count += 1
	print(count)
except:
	pass


z = [int(s) for s in input().split()]
a = z[0]
b = z[1]
k = 0
while a <= b:
	a *= 3
	b *= 2
	k += 1
print(k)


l = list(input().split())
l = [int(x) for x in l]
y = 0
while True:
	l[0] *= 3
	l[1] *= 2
	y += 1
	if l[0] > l[1]:
		break
print(y)


def main():
	_input = list(map(int, input().split()))
	(a, b) = (_input[0], _input[1])
	ans = 0
	while a <= b:
		a *= 3
		b *= 2
		ans += 1
	print(ans)
main()


from math import log, ceil
(limk, bob) = map(int, input().split())
n = int(log(bob / limk) / log(3 / 2) + 1)
print(n)


from sys import stdin
_input = stdin.readline
_int = int

def solution():
	(l, b) = [_int(i) for i in _input().split()]
	ans = 0
	while l <= b:
		l *= 3
		b *= 2
		ans += 1
	print(ans)
solution()


arr = input().split()
(lemak, bob) = (int(arr[0]), int(arr[1]))
lW = 3
bW = 2
year = 0
while lemak <= bob:
	lemak = lemak * lW
	bob = bob * bW
	year += 1
print(year)


li = list(map(int, input().split(' ')))
i = 1
while True:
	li[0] = li[0] * 3
	li[1] = li[1] * 2
	if li[0] > li[1]:
		print(i)
		break
	i = i + 1


(y, e) = map(int, input().split())
count = 0
while y <= e:
	y *= 3
	e *= 2
	count += 1
print(count)


def solution(n, m):
	i = 0
	while True:
		i += 1
		n *= 3
		m *= 2
		if n > m:
			return i
(n, m) = input().split(' ')
n = int(n)
m = int(m)
print(solution(n, m))


from math import floor, log
(l, b) = list(map(int, input().split(' ')))
print(floor(log(b / l) / log(3 / 2) + 1))


(a, b) = map(int, input().split())
c = 0
y = True
while a <= b:
	a = a * 3
	b = b * 2
	c += 1
print(c)


import sys
from math import gcd, ceil, sqrt, ceil
INF = float('inf')
MOD = 998244353
mod = 10 ** 9 + 7
from collections import Counter, defaultdict as df
from functools import reduce

def counter(l):
	return dict(Counter(l))

def printm(l):
	for i in range(len(l[0])):
		print(*l[i])

def P(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	for i in range(5, ceil(sqrt(n)) + 1, 6):
		if n % i == 0 or n % (i + 2) == 0:
			return False
	return True

def so(x):
	return {k: v for (k, v) in sorted(x.items(), key=lambda item: item[1])}

def rev(l):
	return list(reversed(l))

def ini():
	return int(sys.stdin.readline())

def inp():
	return map(int, sys.stdin.readline().strip().split())

def li():
	return list(map(int, sys.stdin.readline().strip().split()))

def input():
	return sys.stdin.readline().strip()

def inputm(n, m):
	return [li() for i in range(n)]

def solve():
	(a, b) = inp()
	c = 0
	while a <= b:
		c += 1
		a = a * 3
		b = b * 2
	print(c)
solve()


num = list(map(int, input().strip().split()))
count = 0
while num[0] <= num[1]:
	count += 1
	num[0] = 3 * num[0]
	num[1] = 2 * num[1]
print(count)


import math
import bisect
(d, e) = map(int, input().split())
cnt = 0
while d <= e:
	cnt += 1
	d = d * 3
	e = e * 2
print(cnt)


import os
LOCAL_PC = 'n1amr' in os.path.expanduser('~')

def process_file(in_name, out_name):
	with open(in_name, 'r') as fin:
		with open(out_name, 'w') as fout:

			def read():
				return fin.readline().rstrip('\n')

			def write(*args, end='\n'):
				text = ' '.join(map(str, args)) + end
				fout.write(text)
				print(text, end='')
			t = int(fin.readline())
			for i in range(t):
				read()
				write('Case #{T}: \n'.format(T=i + 1), end='')
				solve(read, write)
				write()

def process_stdio():

	def read():
		return input()

	def write(*args, end='\n'):
		print(*args, end=end)
	solve(read, write)
from math import ceil, log

def solve(input, print):
	(a, b) = map(int, input().split())
	n = ceil((log(b) - log(a)) / (log(3) - log(2)))
	if 3 ** n * a == 2 ** n * b:
		n += 1
	print(n)
if LOCAL_PC:
	in_name = __file__[:-3] + '.in'
	out_name = __file__[:-3] + '.out'
	process_file(in_name, out_name)
else:
	process_stdio()


a = [int(s) for s in input().split()]
day = 0
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	day += 1
print(day)


x = input().split()
a = int(x[0])
b = int(x[1])
finallist = []
while a < b:
	c = []
	a = 3 * a
	b = 2 * b
	c.append(a)
	c.append(b)
	finallist.append(c)
if a == b:
	d = []
	a = 3 * a
	b = 2 * b
	d.append(a)
	d.append(b)
	finallist.append(d)
print(len(finallist))


(n, m) = map(int, input().split())
ans = 0
while 1:
	n *= 3
	m *= 2
	ans += 1
	if n > m:
		break
print(ans)


k = 0
s = input().split(' ')
l = [int(x) for x in s]
while l[0] <= l[1]:
	l[0] *= 3
	l[1] *= 2
	k += 1
print(k)


(a, b) = map(int, input().split())
x = 1
cur = 1.5
while cur <= b / a:
	x += 1
	cur *= 1.5
print(x)


val = input().split()
limark_weight = int(val[0])
bob_weight = int(val[1])
count_year = 0
while limark_weight <= bob_weight:
	limark_weight = limark_weight * 3
	bob_weight = bob_weight * 2
	count_year += 1
print(count_year)


(x, z) = map(int, input().split())
f = 0
while x <= z:
	f += 1
	x = x * 3
	z = z * 2
print(f)


a = input()
a = a.split(' ')
little = int(a[0])
bigger = int(a[1])
a = 3 / 2
broCode = bigger / little
counter = 1
while a <= broCode:
	a *= 3 / 2
	counter += 1
print(counter)


bearsWeight = input().split()
Limak = int(bearsWeight[0])
Bob = int(bearsWeight[1])
years = 0
while Limak <= Bob:
	Limak *= 3
	Bob *= 2
	years += 1
print(years)


from math import log, ceil
(a, b) = [int(x) for x in input().split(' ')]
y = log(b / a) / log(1.5)
y = ceil(y) if ceil(y) != y else y + 1
print(int(y))


nm = list(map(int, input().rstrip().split()))
n = nm[0]
m = nm[1]
count = 0
if n == m:
	print(1)
else:
	n *= 3
	m *= 2
	count += 1
	while n <= m:
		count += 1
		n *= 3
		m *= 2
	print(count)


a = input().split()
limaWeight = int(a[0])
brotherWeight = int(a[1])
i = 0
while limaWeight <= brotherWeight:
	limaWeight *= 3
	brotherWeight *= 2
	i += 1
print(i)


def solution():
	answers = input().split(' ')
	answers = array_to_int(answers)
	i = 0
	while answers[0] <= answers[1]:
		answers[0] *= 3
		answers[1] *= 2
		i += 1
	print(i)

def array_to_int(array):
	for i in range(len(array)):
		array[i] = int(array[i])
	return array
solution()


def weight(a, b):
	year = 0
	while a <= b:
		a *= 3
		b *= 2
		year += 1
	return year
x = list(map(int, input().rstrip().split()))
a = x[0]
b = x[1]
print(weight(a, b))


def y(a, b, yy=1):
	if 3 * a > 2 * b:
		return yy
	return y(3 * a, 2 * b, yy + 1)
(a, b) = [int(x) for x in input().split()]
print(y(a, b))


import sys
import math

def rl():
	return sys.stdin.readline().strip()

def rn():
	return list(map(int, sys.stdin.readline().strip().split()))

def ri():
	return map(int, sys.stdin.readline().strip().split())

def rln(n):
	l = [None] * n
	for i in range(n):
		l[i] = int(rl())
	return l
(a, b) = rn()
n = math.ceil(math.log(b / a) / math.log(1.5) + 0.0001)
print(n)


(a, b) = map(int, input().split())
m = 3 * a
n = 2 * b
cnt = 1
while m - n <= 0:
	m = m * 3
	n = n * 2
	cnt += 1
print(cnt)


(a, b) = map(int, input().split())
for x in range(10 ** 5):
	if a * 3 ** x > b * 2 ** x:
		print(x)
		break


wiegths = list(map(int, input().split()))
year = 0
i = 0
while wiegths[i] <= wiegths[i + 1]:
	wiegths = [wiegths[i] * 3, wiegths[i + 1] * 2]
	year += 1
print(year)


def bear():
	(a, b) = map(int, input().split())
	year = 0
	while True:
		a = a * 3
		b = b * 2
		year += 1
		if a > b:
			break
	return year
print(bear())


(x, y) = map(int, input().split())
i = 0

def f(x, y):
	global i
	if x <= y:
		i += 1
		f(x * 3, y * 2)
	else:
		print(i)
f(x, y)


w1w2 = input('')
w1w2 = list(map(int, w1w2.split()))
(w1, w2) = (w1w2[0], w1w2[1])
years = 0
while w1 <= w2:
	w1 *= 3
	w2 *= 2
	years += 1
print(years)


import sys
(wLimak, wBob) = input().split()
wLimak = int(wLimak)
wBob = int(wBob)
count = 0
while wLimak <= wBob:
	wLimak *= 3
	wBob *= 2
	count += 1
print(count)


try:
	(a, b) = list(map(int, input().split()))
	cnt = 0
	while a <= b:
		a = a * 3
		b = b * 2
		cnt += 1
	print(cnt)
except:
	pass


n = list(map(int, input().strip().split()))
(a, b) = n
s = 0
while a <= b:
	s += 1
	a *= 3
	b *= 2
print(s)


(a, b) = map(int, input().split())
count = 0
for _ in range(10 ** 9):
	if a <= b:
		a = 3 * a
		b = 2 * b
		count += 1
	else:
		break
print(count)


x = input()
x = x.split()
b1 = int(x[0])
b2 = int(x[1])
c = 0
while True:
	c += 1
	b1 *= 3
	b2 *= 2
	if b1 > b2:
		break
print(c)


def solve():
	(limak_weight, brother_weight) = map(int, input().split())
	years = 0
	while limak_weight <= brother_weight:
		limak_weight *= 3
		brother_weight *= 2
		years += 1
	print(years)
solve()


a = input()
a = a.split(' ')
lol = int(a[0])
oof = int(a[1])
count = 0
while lol <= oof:
	lol *= 3
	oof *= 2
	count += 1
print(count)


def BearBigBro(a, b):
	cmpt = 0
	while a <= b:
		a *= 3
		b *= 2
		cmpt += 1
	return cmpt
(a, b) = input().split()
print(BearBigBro(int(a), int(b)))


import math
s = input()
s = s.split(' ')
for i in range(2):
	s[i] = int(s[i])
A = s[1] / s[0]
B = 3 / 2
x = math.log(A, B)
if x == int(x):
	x = int(x)
	x = x + 1
else:
	x = math.ceil(x)
print(x)


a = str(input(''))
s = a.split(' ')
l = int(s[0])
b = int(s[1])
count = 0
while l <= b:
	l = l * 3
	b = b * 2
	count += 1
print(count, end='')


t = list(map(int, input().split()))
n = t[0]
n1 = t[1]
c = 0
while n <= n1:
	n *= 3
	n1 *= 2
	c += 1
print(c)


import sys
x = [int(x) for x in input().split()]
for i in range(sys.maxsize):
	x[0] = x[0] * 3
	x[1] = x[1] * 2
	if x[0] > x[1]:
		print(i + 1)
		break


arr = []
arr = list(map(int, input().split()))
n = 0
while 1:
	if arr[0] * 3 ** n > arr[1] * 2 ** n:
		print(n)
		break
	else:
		n += 1


import math
inp = input().split(' ')
a = int(inp[0])
b = int(inp[1])
i = 0
while a <= b:
	a = a * 3
	b = b * 2
	i += 1
print(i)


weights = input()
wls = weights.split()
for i in range(2):
	wls[i] = int(wls[i])
	i += 1
w1 = wls[0]
w2 = wls[1]
time = 0
while w1 <= w2:
	w1 = w1 * 3
	w2 = w2 * 2
	time += 1
print(time)


peso = list(map(int, input().split()))
a = peso[0]
b = peso[1]
c = 0
while a < b or a == b:
	c = c + 1
	a = a * 3
	b = b * 2
print(c)


weight = list(input().split())
x = int(weight[0])
y = int(weight[1])
years = 0
while x < y or x == y:
	x *= 3
	y *= 2
	years += 1
print(years)


n = map(int, input().split())
bears = []
for i in n:
	bears.append(i)
Limak = bears[0]
Bob = bears[1]
counter = 0
while Limak <= Bob:
	Limak = Limak * 3
	Bob = Bob * 2
	counter += 1
print(counter)


inp = input().split()
x = 0
age1 = int(inp[0])
age2 = int(inp[1])
while True:
	age1 *= 3
	age2 *= 2
	x += 1
	if age1 > age2:
		print(x)
		break


import math
(a, b) = map(int, input().split())
c = 1
for i in range(1, 100):
	if a * 3 ** i > b * 2 ** i:
		break
	else:
		c += 1
print(c)


p = input().split()
l = int(p[0])
b = int(p[1])
count = 0
while l <= b:
	l = 3 * l
	b = 2 * b
	count += 1
print(count)


import sys
import math
import statistics
import datetime
import collections

def L23(n):
	return math.log(n) / math.log(2 / 3)

def main():
	(a, b) = map(int, input().split())
	ans = L23(a / b)
	ans += 1e-07
	ans = math.floor(ans)
	print(ans + 1)
main()


(L_weight, B_weight) = map(int, input().split())
year = 0
while L_weight <= B_weight:
	L_weight = 3 * L_weight
	B_weight = 2 * B_weight
	year += 1
print(year)


weights_str = input('')
weights = weights_str.split(' ')
a = int(weights[0])
b = int(weights[1])
years = 0
while a <= b:
	years += 1
	a *= 3
	b *= 2
print(years)


def int_strlist(x: list):
	for i in range(len(x)):
		x[i] = int(x[i])
	return x
x = int_strlist(input().split())
(a, b) = (x[0], x[1])
out = 0
while a * 3 <= b * 2:
	a *= 3
	b *= 2
	out += 1
print(out + 1)


import math
[bear, brother] = [float(x) for x in input().strip().split()]
years = math.ceil(math.log(brother / bear) / math.log(1.5))
if bear * math.pow(3, years) > brother * math.pow(2, years):
	print(years)
else:
	print(1 + years)


(a, b) = map(int, input().split())
d = b
p = a
k = 0
if a == b:
	print(1)
else:
	while a <= b:
		p = p * 3
		a = p
		d = d * 2
		b = d
		k = k + 1
	print(k)


(one, two) = map(int, input().split())
count = 0
while one <= two:
	one *= 3
	two *= 2
	count += 1
print(count)


(l, b) = [int(l) for l in input().split()]
y = 1
while True:
	y += 1
	l = l * 3
	b = b * 2
	if l > b:
		break
print(y - 1)


def bear_and_big_brother():
	(a, b) = map(int, input().split())
	years = 0
	while a <= b:
		a = a * 3
		b = b * 2
		years += 1
	print(years)
	return
bear_and_big_brother()


weightinput = input()
loc = weightinput.find(' ')
limak = int(weightinput[:loc])
bob = int(weightinput[loc + 1:])
years = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	years += 1
print(years)


Datos = input()
Datos = Datos.split()
A = int(Datos[0])
B = int(Datos[1])
Cont = 0
while A <= B:
	A = 3 * A
	B = 2 * B
	Cont = Cont + 1
print(Cont)


(l, b) = map(int, input().strip().split())
yrs = 0
while True:
	if l > b:
		break
	l = l * 3
	b = b * 2
	yrs += 1
print(yrs)


import sys
numbers = [int(i) for i in sys.stdin.readline().split()]
limak = numbers[0]
bob = numbers[1]
years = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	years += 1
print(years)


(a_str, b_str) = input().split()
a = int(a_str)
b = int(b_str)
t = 0
while a <= b:
	a = a * 3
	b = b * 2
	t = t + 1
print(t)


(d, r) = map(int, input().split())
p = 0
while d <= r:
	d *= 3
	r *= 2
	p += 1
print(p)


list1 = input().split(' ')
a = int(list1[0])
b = int(list1[1])
for j in range(0, 100):
	if 3 ** j * a > 2 ** j * b:
		print(j)
		break


import sys
(a, b) = tuple(map(int, sys.stdin.readline().split()))
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


from math import pow
a = input()
a = [int(i) for i in a.split()]
i = 0
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	i += 1
print(i)


(vesL, vesB) = input().split()
vesL = int(vesL)
vesB = int(vesB)
age = 0
while vesL <= vesB:
	age = age + 1
	vesL = vesL * 3
	vesB = vesB * 2
print(age)


(x, y) = input().split()
x = int(x)
y = int(y)
flag = 0
while x <= y:
	x = x * 3
	y = y * 2
	flag += 1
print(int(flag))


(l, b) = map(int, input().split())
s = 0
bl = 1
while bl == 1:
	if b >= l:
		bl = 1
		b *= 2
		l *= 3
		s += 1
	else:
		bl = 0
print(s)


line = list(map(int, input().split()))
limak = line[0]
bob = line[1]
counter = 0
while limak <= bob:
	counter += 1
	limak *= 3
	bob *= 2
print(counter)


def main():
	(a, b) = list(map(int, input().split(' ')))
	y = 0
	while a <= b:
		a = a * 3
		b = b * 2
		y += 1
	print(y)
main()


xyz = []

def input1():
	global xyz
	if len(xyz) == 0:
		xyz = [i for i in input().split()]
		xyz = xyz[::-1]
	v = xyz[-1]
	del xyz[-1]
	return v
L = int(input1())
B = int(input1())
for y in range(10000):
	if L > B:
		print(y)
		break
	L = L * 3
	B = B * 2


import math
from collections import defaultdict
from collections import Counter
import itertools

def solve(a, b):
	res = 0
	while a <= b:
		a *= 3
		b *= 2
		res += 1
	return res
(k, n) = map(int, input().split(' '))
print(solve(k, n))


w = list(map(int, str(input()).split(' ')))
i = 0
while w[0] <= w[1]:
	w[1] = w[1] * 2
	w[0] = w[0] * 3
	i += 1
print(i)


def main():
	(x, y) = input().split()
	(x, y) = (int(x), int(y))
	years = 0
	while x <= y:
		x *= 3
		y *= 2
		years += 1
	print(years)
main()


(a, b) = input().split()
(a, b) = (int(a), int(b))
age = 0
while a <= b:
	a *= 3
	b *= 2
	age += 1
print(age)


(a, b) = input().split()
a = int(a)
b = int(b)
counter = loop = 0
while loop == 0:
	a = a * 3
	b = b * 2
	if a <= b:
		counter += 1
	else:
		loop = 1
print(counter + 1)


from math import log2
(b, a) = input().split()
a = int(a)
b = int(b)
print(int(log2(a / b) / log2(1.5) // 1) + 1)


from sys import stdin, setrecursionlimit
setrecursionlimit(10 ** 6)
input = stdin.readline
(a, b) = map(int, input().split())
ans = 0
while a <= b:
	a *= 3
	b *= 2
	ans += 1
print(ans)


from sys import stdin
(a, b) = [int(c) for c in stdin.readline().split()]
ans = 0
while a <= b:
	a = a * 3
	b = b * 2
	ans += 1
print(ans)


import itertools

def compute_year(a: int, b: int) -> int:
	for year in itertools.count(start=0, step=1):
		a_1 = 3 ** year * a
		b_1 = 2 ** year * b
		if a_1 > b_1:
			return year
(a, b) = [int(elem) for elem in input().strip().split(' ')]
result = compute_year(a, b)
print(result)


weights = [int(x) for x in input().split(' ')]
a = weights[0]
b = weights[1]
number_of_years = 0
while a <= b:
	if a > b:
		break
	else:
		a *= 3
		b *= 2
		number_of_years += 1
print(number_of_years)


L = list(map(int, input().split()))
limak = L[0]
bob = L[1]
i = 0
while limak <= bob:
	i += 1
	limak = 3 * limak
	bob = 2 * bob
print(i)


inp = input()
inp = inp.split()
limak = int(inp[0])
bob = int(inp[1])
years = 0
while True:
	if limak > bob:
		print(years)
		break
	limak *= 3
	bob *= 2
	years += 1


def main():
	from sys import stdin, stdout
	(a, b) = stdin.readline().split()
	a = int(a)
	b = int(b)
	l = 1
	r = 10
	while l < r:
		m = (r + l) // 2
		if 3 ** m * a > 2 ** m * b:
			r = m
		else:
			l = m + 1
	stdout.write(str(r))
main()


weights = input().split()

class Bear:

	def __init__(self, weight, mult):
		self.weight = weight
		self.mult = mult

	def newyear(self):
		self.weight *= self.mult

def newyear():
	global rok
	Limak.newyear()
	Bob.newyear()
	rok += 1
Limak = Bear(int(weights[0]), 3)
Bob = Bear(int(weights[1]), 2)
rok = 2020
while Limak.weight <= Bob.weight:
	newyear()
print(rok - 2020)


(l, b) = list(map(int, input().split()))
if l == b:
	print('1')
else:
	for i in range(1000):
		m = l * 3
		n = b * 2
		if m > n:
			print(i + 1)
			break
		else:
			l = m
			b = n


__author__ = 'Tal Kleiner'

def solve(a, b):
	year_count = 0
	while a <= b:
		a *= 3
		b *= 2
		year_count += 1
	return year_count
(a, b) = map(int, input().split())
print(solve(a, b))


(a, b) = (int(s) for s in input().split())

def year(a, b):
	if a > b:
		return 0
	return 1 + year(3 * a, 2 * b)
print(year(a, b))


from math import floor, ceil, log

def main():
	(a, b) = map(int, input().split())
	ans = floor(log(b / a) / log(3 / 2) + 1)
	print(ans)
main()


(limak_age, bob_age) = map(int, input().split())
years_count = 0
while limak_age <= bob_age:
	limak_age = 3 * limak_age
	bob_age = 2 * bob_age
	years_count += 1
print(years_count)


w = input().split()
(a, b) = (int(w[0]), int(w[1]))
y = 1
while True:
	(a, b) = (a * 3, b * 2)
	if a > b:
		print(y)
		break
	y += 1


q = list(map(int, input().split()))
e = 0
while q[0] <= q[1]:
	q[0] *= 3
	q[1] *= 2
	e += 1
print(e)


l = []
s = input()
y = 0
for i in s.split():
	l.append(int(i))
while l[0] <= l[1]:
	l[0] = l[0] * 3
	l[1] = l[1] * 2
	y = y + 1
print(y)


import sys
input = sys.stdin.readline
(a, b) = map(int, input().split())
for i in range(1, 100000):
	a *= 3
	b *= 2
	if a > b:
		print(i)
		break
	else:
		continue


n = list(map(int, input().split()))
Lw = n[0]
Bw = n[1]
y = 0
while True:
	y += 1
	Lw = Lw * 3
	Bw = Bw * 2
	if Lw > Bw:
		break
print(y)


(a, b) = input().split()
a = int(a)
b = int(b)
answer = 0
while a <= b:
	a *= 3
	b *= 2
	answer = answer + 1
print(answer)


import math

def getyear(w1, w2):
	a = math.log2(w1) - math.log2(w2)
	b = math.log2(3) - math.log2(2)
	return math.floor(a / b + 1)
(w2, w1) = tuple(map(int, input().split()))
print(getyear(w1, w2))


x = list(map(int, input().split()))
j = x[0]
i = x[1]
l = 0
while j <= i:
	j = j * 3
	i = i * 2
	l += 1
print(l)


from math import log
(a, b) = [int(x) for x in input().split(' ')]
y = log(b / a) / log(1.5)
print(int(y // 1 + 1))


import operator as op
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import reduce
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def def_value():
	return 0
(a, b) = invr()
i = 0
while a <= b:
	a *= 3
	b *= 2
	i += 1
print(i)


def howManyYears(limakWeight, bobWeight):
	years = 0
	while limakWeight <= bobWeight:
		limakWeight *= 3
		bobWeight *= 2
		years += 1
	return years
(limakWeight, bobWeight) = [int(i) for i in input().split()]
print(howManyYears(limakWeight, bobWeight))


w = input().split()
y = 0
wa = int(w[0])
wb = int(w[1])
while wa <= wb:
	wa *= 3
	wb *= 2
	y += 1
print(y)


x = list(map(int, input().split(' ')))
limac = x[0]
bob = x[1]
a = limac
b = bob
i = 1
while True:
	limac = a * 3
	a = limac
	bob = b * 2
	b = bob
	if limac > bob:
		print(i)
		break
	else:
		i += 1


(a, b) = map(int, input().split())
s = a
t = b
cn = 0
for i in range(b):
	if s <= t:
		s *= 3
		t *= 2
		cn += 1
	else:
		break
print(cn)


n = [int(s) for s in input().split()]
a = n[0]
b = n[1]
t = 0
while a <= b:
	a = a * 3
	b = b * 2
	t += 1
print(t)


import math
(a, b) = map(int, input().split())
p = math.log2(b / a)
q = math.log2(3 / 2)
print(math.floor(p / q + 1))


(e, f) = map(int, input().split())
g = 0
for i in range(100):
	g += 1
	e = e * 3
	f = f * 2
	if e > f:
		print(g)
		break


(a, b) = [int(x) for x in input().split()]
if a == b:
	print(1)
else:
	c = 0
	while a <= b:
		a = a * 3
		b = b * 2
		c = c + 1
	print(c)


lis = list(map(int, input().strip().split(' ')))
a = lis[0]
b = lis[1]
count = 0
while a <= b:
	a *= 3
	b *= 2
	count += 1
print(count)


(m, o) = map(int, input().split())
c = 0
while True:
	if m > o:
		print(c)
		break
	else:
		m = m * 3
		o = o * 2
		c = c + 1


from math import log, ceil
(a, b) = [int(i) for i in input().strip().split()]
x = ceil(log(b / a) / log(3 / 2))
if a * 3 ** x == b * 2 ** x:
	x += 1
print(x)


x = input()
(lin, bob) = x.split(' ')
lin = int(lin)
bob = int(bob)
x = 0
while bob >= lin:
	bob *= 2
	lin *= 3
	x += 1
print(x)


(a, b) = list(map(int, input().split()))
c = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	c += 1
if a > b:
	print(c, end='')


inp = [int(x) for x in input().split()]
wt_limark = inp[0]
wt_bob = inp[1]
for i in range(1, 100):
	if wt_limark * 3 > wt_bob * 2:
		print(i)
		break
	else:
		wt_limark = wt_limark * 3
		wt_bob = wt_bob * 2


import sys, math
(a, b) = sys.stdin.readline().strip().split(' ')
limak_weight = int(a)
bob_weight = int(b)
num_years = 0
while limak_weight <= bob_weight:
	limak_weight *= 3
	bob_weight *= 2
	num_years += 1
print(num_years)


(a, b) = input().split()
a = int(a)
b = int(b)
var1 = True
i = 0
while var1 == True:
	if a <= b:
		a = a * 3
		b = b * 2
		i += 1
	else:
		var1 = False
print(i)


problemInput = input().split(' ')
weightLimak = int(problemInput[0])
weightBob = int(problemInput[1])
year = 0
while True:
	year += 1
	weightBob *= 2
	weightLimak *= 3
	if weightBob < weightLimak:
		break
print(year)


(limak, bob) = input().split()
a = int(limak)
b = int(bob)
count = 0
while True:
	if a > b:
		break
	else:
		a *= 3
		b *= 2
		count += 1
print(count)


(n, m) = list(map(int, input().strip().split()))
for i in range(2 * m):
	n = 3 * n
	m = 2 * m
	if n > m:
		print(i + 1)
		break


n = input()
(lim, bob) = n.split(' ')
count = 0
lim = int(lim)
bob = int(bob)
while bob >= lim:
	bob = bob * 2
	lim = lim * 3
	count += 1
print(count)


a = list(input().split())
aa = int(a[0])
bb = int(a[1])
i = 0
while aa <= bb:
	i += 1
	aa = aa * 3
	bb = bb * 2
print(i)


numbers = [int(n) for n in input().split()]
limak = numbers[0]
bob = numbers[1]
i = 0
while limak <= bob:
	i += 1
	limak *= 3
	bob *= 2
print(i)


inp = input()
w1 = int(inp.split()[0])
w2 = int(inp.split()[1])
it = 0
solved = False
while not solved:
	if w1 > w2:
		solved = True
	else:
		w1 = w1 * 3
		w2 = w2 * 2
		it = it + 1
print(it)


def bears():
	res = 0
	(bear1, bear2) = input().split()
	bear1 = int(bear1)
	bear2 = int(bear2)
	while bear1 <= bear2:
		bear1 *= 3
		bear2 *= 2
		res += 1
	print(res)
bears()


(a, b) = map(int, input().split())
i = 1
limak = []
bob = []
flag = False
while i <= 10:
	a = a * 3
	limak.append(a)
	b = b * 2
	bob.append(b)
	i += 1
for j in range(len(limak)):
	if limak[j] > bob[j]:
		print(j + 1)
		break


def main(n, k):
	c = 0
	while n < k:
		n = n * 3
		k = k * 2
		c += 1
	if n == k:
		return c + 1
	return c
(n, k) = tuple(map(int, input().strip(' ').split(' ')))
print(main(n, k))


w = input().split()
y = 0
while int(w[0]) <= int(w[1]):
	w[0] = int(w[0]) * 3
	w[1] = int(w[1]) * 2
	y += 1
print(y)


def find(n, m, i):
	x = n * 3 ** i
	y = m * 2 ** i
	if x > y:
		return i
	return find(n, m, i + 1)

def main():
	a = list(map(int, input().split()))
	if a[0] > a[1]:
		print(1, end='\n')
	else:
		print(find(a[0], a[1], 1), end='\n')
main()


from math import log
Bears = str(input(''))
Bears = Bears.split()
Limak = float(Bears[0])
Bob = float(Bears[1])
k = 0
while Limak <= Bob:
	Bob *= 2
	Limak *= 3
	k += 1
print(k)


a = list(map(int, input().split()))
q = a[0]
w = a[1]
x = 1
while 1:
	if q * pow(3, x) - w * pow(2, x) > 0:
		print(x)
		break
	x += 1


import math
(a, b) = map(int, input().split())
c = a / b
c = math.log10(c)
d = 2 / 3
d = math.log10(d)
n = math.ceil(c / d)
if a * 3 ** n <= b * 2 ** n:
	n += 1
print(n)


def solve():
	(a, b) = [int(x) for x in input().strip().split(' ')]
	y = 0
	while a <= b:
		(a, b, y) = (a * 3, b * 2, y + 1)
	print(y)
solve()


(a, b) = list(map(int, input().split()))
if a == b:
	print(1)
else:
	i = 1
	ok = True
	while ok:
		a = a * 3
		b = b * 2
		if a > b:
			ok = False
			print(i)
		else:
			i += 1


(a, b) = input().split()

def main():
	global a, b
	a = int(a)
	b = int(b)
	count = 0
	while a <= b:
		a = a * 3
		b = b * 2
		count += 1
	return count
print(main())


(a, b) = [int(a) for a in input().split()]
years = 0
if a > b:
	print(years)
else:
	while a <= b:
		a *= 3
		b *= 2
		years += 1
	print(years)


s = list(map(int, input().split()))
c = 0
while s:
	c += 1
	s[0] *= 3
	s[1] *= 2
	if s[0] > s[1]:
		break
print(c)


(a, b) = map(int, input().split())
c = False
z = 0
while a <= b:
	a = a * 3
	b = b * 2
	z = z + 1
	if a > b:
		break
print(z)


def func(x):
	a = x[0]
	b = x[1]
	i = 0
	while a <= b:
		a *= 3
		b *= 2
		i += 1
	return i
x = list(map(int, input().strip().split(' ')))
print(func(x))


(a, b) = map(int, input().split())
(m, n) = (a, b)
year = 0
while a <= b:
	a = a * 3
	b = b * 2
	year += 1
if m == n:
	print(1)
else:
	print(year)


years = 0
input = list(map(int, input().split()))
(limak, bob) = input
while True:
	if limak <= bob:
		limak = limak * 3
		bob = bob * 2
		years = years + 1
	else:
		print(years)
		break


import math
(m, n) = map(int, input().split())
print(int(math.log(n / m) / math.log(3 / 2)) + 1)


s = list(map(int, input().split()))
c = 0
l = s[0]
b = s[1]
while 1:
	if l > b:
		print(c)
		break
	else:
		l = l * 3
		b = b * 2
		c = c + 1


def map_to_list(list_, fun):
	for i in range(len(list_)):
		list_[i] = fun(list_[i])

def spaced_string_to_list(count, str_):
	arr = []
	char_index = 0
	word = ''
	for arr_index in range(count):
		while not (char_index >= len(str_) or str_[char_index] == ' '):
			word += str_[char_index]
			char_index += 1
		arr.append(word)
		word = ''
		char_index += 1
	return arr

def spaced_numbers_str_to_list(amount, str_numbers):
	numbers_list = spaced_string_to_list(amount, str_numbers)
	map_to_list(numbers_list, int)
	return numbers_list

def limak_zhret(limak, brother):
	year = 0
	while limak <= brother:
		limak *= 3
		brother *= 2
		year += 1
	return year
arr = spaced_numbers_str_to_list(2, input())
print(limak_zhret(arr[0], arr[1]))


(L, B) = input().split()
L = int(L)
B = int(B)
n = 0
while L <= B:
	L = 3 * L
	B = 2 * B
	n += 1
print(n)


def Solve(a, b):
	count = 0
	while a <= b:
		a *= 3
		b *= 2
		count += 1
	return count
(a, b) = [int(i) for i in input().strip().split()]
print(Solve(a, b))


(a, b) = map(int, input().split())
t = 1
while a < b:
	a *= 3
	b *= 2
	if a <= b:
		t += 1
print(t)


def loop(ar):
	a = ar[0]
	b = ar[1]
	count = 0
	while True:
		a *= 3
		b *= 2
		count += 1
		if b < a:
			break
	print(count)
loop(list(map(int, input().rstrip().split())))


(limak, bob) = input().split()
limak = int(limak)
bob = int(bob)
gadi = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	gadi = gadi + 1
print(gadi)


weight = list(map(int, input().split()))
for i in range(1, 99):
	weight[0] = weight[0] * 3
	weight[1] = weight[1] * 2
	if weight[0] > weight[1]:
		print(i)
		break


def bearWeight():
	(limak, bob) = list(map(int, input().split(' ')))
	c = 0
	while limak <= bob:
		limak *= 3
		bob *= 2
		c += 1
	return c
print(bearWeight())


A = list(map(int, input().split()))
a = A[0]
b = A[1]
y = 0
while a <= b:
	a = a * 3
	b = b * 2
	y = y + 1
print(y)


def bear(x, y, c):
	c = 0
	if x == y:
		c = 1
	else:
		while x <= y:
			x *= 3
			y *= 2
			c += 1
	print(c)
(t, g) = [int(t) for t in input().split()]
d = 1
v = bear(t, g, d)


def solve():
	(limak, bob) = map(int, input().split())
	c = 0
	while True:
		if limak > bob:
			break
		c += 1
		limak *= 3
		bob *= 2
	return c
print(solve())


(a, b) = list(map(int, input().split()))
c = 1
for i in range(1, 10000):
	a = a * 3
	b = b * 2
	if a > b:
		break
	else:
		c = c + 1
print(c)


def main():
	n = input().split()
	years = 0
	while int(n[0]) <= int(n[1]):
		n[0] = int(n[0]) * 3
		n[1] = int(n[1]) * 2
		years += 1
	print(years)
main()


import math
(l, b) = map(int, input().split())
for i in range(100):
	if math.pow(3, i) * l > math.pow(2, i) * b:
		print(i)
		break


import math
(a, b) = map(int, input().split())
k = math.ceil(math.log(b / a, 3 / 2))
print([k, k + 1][a * 3 ** k == b * 2 ** k])


a = input()
e = 0
for i in range(len(a)):
	if a[i] == ' ':
		b = int(a[:i])
		c = int(a[i + 1:])
		break
while c >= b:
	c = c * 2
	b = b * 3
	e += 1
print(e)


bears = input().split()
years_needed = 0
while int(bears[1]) >= int(bears[0]):
	years_needed += 1
	bears[0] = int(bears[0]) * 3
	bears[1] = int(bears[1]) * 2
print(years_needed)


from math import ceil
import sys, bisect, copyreg, copy, statistics, os

def inp():
	return sys.stdin.readline().strip()

def IIX():
	return (int(x) for x in sys.stdin.readline().split())

def II():
	return int(inp())

def LI():
	return list(map(int, inp().split()))

def L(x):
	return list(x)

def out(var):
	return sys.stdout.write(str(var))
(a, b) = IIX()
i = 0
while a <= b:
	a = a * 3
	b = b * 2
	i += 1
out(i)


def find(a, b):
	c = 0
	while a <= b:
		a *= 3
		b *= 2
		c += 1
	return c
(a, b) = list(map(int, input().strip().split(' ')))
print(find(a, b))


import sys
input = sys.stdin.readline

def main():
	(limak, bob) = list(map(int, input().split()))
	n_years = 0
	while True:
		if limak <= bob:
			limak *= 3
			bob *= 2
			n_years += 1
		else:
			break
	print(n_years)
main()


a = list(map(int, input().split()))
limak = a[0]
bob = a[1]
i = 0
temp = 0
while i == 0:
	limak = limak * 3
	bob = bob * 2
	temp = temp + 1
	if limak > bob:
		i = 1
print(temp)


def year_comming(limak, bob):
	if limak > bob:
		return 0
	else:
		return 1 + year_comming(limak * 3, bob * 2)
(limak, bob) = map(int, input().split())
print(year_comming(limak, bob))


(limak, bob) = map(int, input().split(' '))
i = 0
while 1:
	limak *= 3
	bob *= 2
	i += 1
	if limak > bob:
		break
print(i)


s = list(map(int, input().split()))
(a, b) = (s[0], s[1])
n = 0
while True:
	a = a * 3
	b = b * 2
	n += 1
	if a > b:
		break
print(n)


(a, b) = map(int, input().split())
m = True
y = 0
while m:
	a = a + 2 * a
	b = b + 1 * b
	y = y + 1
	if a > b:
		m = False
print(y)


(m, n) = input().split()
m = int(m)
n = int(n)
t = 0
while m <= n:
	m *= 3
	n *= 2
	t += 1
else:
	print(t)


(nipun, mudit) = map(int, input().split())
vaibhav = 0
while nipun <= mudit:
	vaibhav += 1
	nipun = nipun * 3
	mudit = mudit * 2
print(vaibhav)


def get_input():
	input_str = input()
	(limaks_weight, bobs_weight) = input_str.split()
	return (int(limaks_weight), int(bobs_weight))

def show_result(number):
	print(number)

def process(limaks_weight: int, bobs_weight: int) -> int:
	lw = limaks_weight
	bw = bobs_weight
	counter = 0
	while True:
		if lw > bw:
			break
		lw = lw * 3
		bw = bw * 2
		counter += 1
	return counter
(limaks_weight, bobs_weight) = get_input()
r = process(limaks_weight, bobs_weight)
show_result(r)


weights = input()
weight_list = weights.split()
in1 = int(weight_list[0])
in2 = int(weight_list[1])
year = 0
while in1 <= in2:
	in1 = 3 * in1
	in2 = 2 * in2
	year += 1
print(year)


L_B = list(map(int, input().split()))
ans = 0
while True:
	L_B[0] *= 3
	L_B[1] *= 2
	ans += 1
	if L_B[0] > L_B[1]:
		break
print(ans)


(x, y) = list(map(int, input().split()))
a = True
d = 1
while a:
	n = x * 3
	m = y * 2
	if n > m:
		print(d)
		a = False
	elif m >= n:
		d += 1
		x = n
		y = m


def answer():
	a = input().split()
	(b, c) = (int(a[0]), int(a[1]))
	ans = 0
	if b == c:
		return 1
	while True:
		ans += 1
		b *= 3
		c *= 2
		if b > c:
			return ans
print(answer())


def f(a, b):
	s = 0
	while True:
		a *= 3
		b *= 2
		s += 1
		if a > b:
			return s
(a, b) = input().split()
print(f(int(a), int(b)))


(mish, lim) = map(int, input().split())
years = 0
while mish <= lim:
	mish *= 3
	lim *= 2
	years += 1
print(years)


w = input()
we = w.split(' ')
ab = []
for element1 in we:
	ab = ab + [int(element1)]
a = ab[0]
b = ab[1]
count = 0
while a <= b:
	b = b * 2
	a = a * 3
	count += 1
print(count)


(l, b) = input().split()
l = int(l)
b = int(b)
g = 0
while l <= b:
	l = l * 3
	b = b * 2
	g = g + 1
print(g)


cnt = input()
cnt = cnt.split(' ')
br1 = int(cnt[0])
br2 = int(cnt[1])
tmr = 0
flg = True
while flg:
	tmr += 1
	br1 = int(br1) * 3
	br2 = int(br2) * 2
	if br1 > br2:
		flg = False
		print(tmr)


(a, b) = input().split()
a = int(a)
b = int(b)
years = 0
bigger = False
while not bigger:
	a = 3 * a
	b = 2 * b
	years += 1
	if a > b:
		bigger = True
print(years)


(lamik, bob) = map(int, input().split())
i = 0
while True:
	i += 1
	lamik *= 3
	bob *= 2
	if lamik > bob:
		break
print(i)


(A, B) = map(int, input().split())
c = 0
for i in range(0, B):
	A *= 3
	B *= 2
	c += 1
	if A > B:
		print(c)
		break


s = input()
r1 = s.split(' ')
a = int(r1[0])
b = int(r1[1])
count = 0
if a <= b:
	while a <= b:
		a = a * 3
		b = b * 2
		count += 1
	print(count)


S = input()
L = S.split(' ')
a = int(L[0])
b = int(L[1])
i = 0
while b >= a:
	i += 1
	a *= 3
	b *= 2
else:
	print(i)


t = [int(i) for i in input().split()]
(a, b) = (t[0], t[1])
t = a
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


(a, b) = input().split()
a = int(a)
p = 0
b = int(b)
while a <= b:
	a = a * 3
	b = b * 2
	p = p + 1
print(p)


bear = input().split(' ')
i = 0
while i < 10:
	if int(bear[0]) <= int(bear[1]):
		bear[0] = int(bear[0]) * 3
		bear[1] = int(bear[1]) * 2
	else:
		break
	i += 1
print(i)


import math
(a, b) = map(int, input().split())
t = a / b
n = 1
if a > b:
	print('0')
else:
	while t ** (1 / n) <= 2 / 3:
		n = n + 1
	print(n)


nums = input().split(' ')
nums = list(map(lambda x: int(x), nums))
i = 0
while nums[0] <= nums[1]:
	nums[0] *= 3
	nums[1] *= 2
	i += 1
print(i)


f = lambda : map(int, input().split())
(a, b) = f()
i = 0
if a == b:
	print(1)
else:
	while i + 1:
		a *= 3
		b *= 2
		i += 1
		if a > b:
			break
	print(i)


(a, b) = map(int, input().split())
x = a
y = b
count = 1
for i in range(10):
	x = x * 3
	y = y * 2
	if x > y:
		break
	else:
		count += 1
print(count)


(n, k) = list(map(int, input().split()))
for i in range(1, 1000):
	n = n * 3
	k = k * 2
	if n > k:
		print(i)
		break


a = input().split()
a = [int(i) for i in a]
year = 0
while True:
	year += 1
	a[0] = 3 * a[0]
	a[1] *= 2
	if a[0] > a[1]:
		print(year)
		break


(x, y) = map(int, input().split())
d = y - x
t = 3
z = 2
count = 0
while d >= 0:
	x = t * x
	y = z * y
	d = y - x
	count = count + 1
print(count)


a = input().split()
ans = 0
a[0] = int(a[0])
a[1] = int(a[1])
while a[0] <= a[1]:
	a[0] *= 3
	a[1] *= 2
	ans += 1
print(ans)


(n, k) = [int(i) for i in input().split()]
c = 0
while 1:
	c = c + 1
	n = n * 3
	k = k * 2
	if n > k:
		break
print(c)


from math import *
(a, b) = input().split()
(a, b) = (int(a), int(b))
n = log10(a / b) / log10(2 / 3)
if n == int(n):
	print(int(n + 1))
else:
	print(int(n) + 1)


(v, c) = input().split()
v = float(v)
c = float(c)
s = []
s.append(v)
s.append(c)
e = 0
while s[0] <= s[1]:
	s[0] = 3 * s[0]
	s[1] = 2 * s[1]
	e = e + 1
print(e)


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt, gcd, factorial, pow, pi

def binNumber(n, size=4):
	return bin(n)[2:].zfill(size)

def iar():
	return list(map(int, input().split()))

def ini():
	return int(input())

def isp():
	return map(int, input().split())

def sti():
	return str(input())

def par(a):
	print(' '.join(list(map(str, a))))

def tdl(outerListSize, innerListSize, defaultValue=0):
	return [[defaultValue] * innerListSize for i in range(outerListSize)]

class pair:

	def __init__(self, f, s):
		self.fi = f
		self.se = s

	def __lt__(self, other):
		return (self.fi, self.se) < (other.fi, other.se)
(a, b) = isp()
k = 0
while a <= b:
	a *= 3
	b *= 2
	k += 1
print(k)


import sys
args = input().split(' ')
a = int(args[0])
b = int(args[1])

def limak(year):
	return 3 ** year * a

def bob(year):
	return 2 ** year * b
year = 0
while limak(year) <= bob(year):
	year = year + 1
print(year)


from math import floor
from math import log
a = input().split()
l = int(a[0])
b = int(a[1])
print(floor(log(b / l, 1.5)) + 1)


import sys
(a, b) = [int(elem) for elem in sys.stdin.readline().split()]
a = int(a)
b = int(b)
count = 0
while b >= a:
	a *= 3
	b *= 2
	count += 1
print(count)


(lw, bw) = map(int, input().split())
noy = 0
while lw <= bw:
	lw *= 3
	bw *= 2
	noy += 1
print(noy)


entry = input().split()
b = int(entry.pop())
a = int(entry.pop())
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


n = list(map(int, input().split()))
wl = n[0]
wbob = n[1]
i = 0
while wl <= wbob:
	wl = 3 * wl
	wbob = wbob * 2
	i += 1
print(i)


while True:
	try:
		(l, b) = map(int, input().split())
		years = 0
		while l <= b:
			l = 3 * l
			b = 2 * b
			years += 1
		print(years)
	except EOFError:
		break


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
L = inlt()
a = L[0]
b = L[1]
from math import log
c = log(b / a) / log(1.5)
print(int(c) + 1)


from sys import stdin

def main():
	inpts = [int(x) for x in stdin.read().split()]
	limak_weight = inpts[0]
	bob_weight = inpts[1]
	years = 0
	while limak_weight <= bob_weight:
		limak_weight = limak_weight * 3
		bob_weight = bob_weight * 2
		years += 1
	print(years)
main()


(limak, brother) = [int(i) for i in input().split()[:2]]
i = 1
while True:
	limak = limak * 3
	brother = brother * 2
	if limak > brother:
		print(i)
		break
	i = i + 1


x = input('').split()
a = int(x[0])
b = int(x[1])
years = 0
while True:
	if a > b:
		break
	else:
		a = 3 * a
		b = 2 * b
		years += 1
		continue
print(years)


(n, k) = [int(x) for x in input().split()]
d = []
for j in range(1, 101):
	d.append(j)
for i in range(1, 101):
	n = n * i * 3
	k = k * i * 2
	if n > k:
		print(i)
		break


aandb = input()
ablist = aandb.split()
limak = int(ablist[0])
bob = int(ablist[1])
x = 0
while limak <= bob:
	limak = limak * 3
	bob = bob * 2
	x += 1
print(x)


def inputIntegerArray():
	return list(map(int, input().split(' ')))
(a, b) = inputIntegerArray()
for i in range(1, 100):
	a = a * 3
	b = b * 2
	if a > b:
		print(i)
		quit()


n = list(map(int, input().split()))
years = 0
if n[0] == n[1]:
	print('1')
else:
	while True:
		s = n[0] * 3
		w = n[1] * 2
		n[0] = s
		n[1] = w
		years = years + 1
		if s > w:
			print(years)
			break


(limka, bob) = tuple([int(x) for x in input().split(' ')])
year = 0
while limka <= bob:
	limka *= 3
	bob *= 2
	year += 1
print(year)


weight = input().split()
year = 0
L = int(weight[0])
B = int(weight[1])
while True:
	L *= 3
	B *= 2
	year += 1
	if L > B:
		break
print(year)


a = list(map(int, input().split()))
x = 0
l = a[0]
b = a[1]
i = 1
while i == 1:
	x = x + 1
	l = l * 3
	b = b * 2
	if l > b:
		break
print(x)


x = input('')
x = x.split()
p = int(x[0])
q = int(x[1])
count = 0
for i in range(0, 10):
	p = p * 3
	q = q * 2
	count = count + 1
	if p > q:
		print(count)
		break


l = list(map(int, input().strip().split()))
limak = l[0]
bob = l[1]
for i in range(1, 10 ** 5):
	limak = limak * 3
	bob = bob * 2
	if limak > bob:
		print(i)
		break


def bigB(a, b, y):
	a = a * 3
	b = b * 2
	y += 1
	if a > b:
		print(y)
	else:
		bigB(a, b, y)
(a, b) = map(int, input().split())
y = 0
bigB(a, b, y)


(weight_bro1, weight_bro2) = list(map(int, input().split()))
w1 = weight_bro1
w2 = weight_bro2
for i in range(w1 * w2):
	weight_bro1 *= 3
	weight_bro2 *= 2
	if weight_bro1 > weight_bro2:
		years = i
		break
print(years + 1)


c = 0
ar = list(map(int, input().split()))
w1 = ar[0]
w2 = ar[1]
while w1 < w2:
	w1 = w1 * 3
	w2 = w2 * 2
	c = c + 1
if w1 == w2:
	print(c + 1)
else:
	print(c)


import sys
line = sys.stdin.readline()
nums = line.strip().split()
a = int(nums[0])
b = int(nums[1])
year = 0
while a <= b:
	a *= 3
	b *= 2
	year += 1
print(year)


years = 0
(limak, bob) = [int(i) for i in input().split()]
while limak <= bob:
	years += 1
	limak *= 3
	bob *= 2
print(str(years))


(a, b) = map(int, input().split())
count = 0

def checker(a, b):
	global count
	if a > b:
		return a
	else:
		a = a * 3
		b = b * 2
		count = count + 1
		return checker(a, b)
a = checker(a, b)
print(count)


numbers = list(map(int, input().split()))
a = numbers[0]
b = numbers[1]
j = 0
while a <= b:
	a = a * 3
	b = b * 2
	j = j + 1
print(j)


(a, b) = input().split()
(a, b) = (int(a), int(b))
cntr = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	cntr += 1
print(cntr)


(a, b) = map(int, input().split())
for year in range(1, 100):
	a = 3 * a
	b = 2 * b
	if a <= b:
		continue
	elif a > b:
		print(year)
		break


s = input()
l = s.split()
L_w = int(l[0])
B_w = int(l[1])
i = 0
while L_w <= B_w:
	L_w *= 3
	B_w *= 2
	i += 1
else:
	print(i)


from sys import stdin, exit
(limak, bob) = map(int, stdin.readline().rstrip().split(' '))
total = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	total += 1
print(total)


l = list(map(int, input().split()))
d = 0
while l[0] <= l[1]:
	d += 1
	l[0] = l[0] * 3
	l[1] = l[1] * 2
print(d)


import sys
x = input().split()
a = int(x[0])
b = int(x[1])
counter = 0
while a <= b:
	a = a * 3
	b = b * 2
	counter = counter + 1
print(counter)


(a, b) = map(int, input().split())
ll_a = a
ll_b = b
cnt = 0
while ll_a <= ll_b:
	ll_a = 3 * ll_a
	ll_b = 2 * ll_b
	cnt += 1
print(cnt)


def main():
	(first_bear, second_bear) = map(str, input().split())
	first_bear = int(first_bear)
	second_bear = int(second_bear)
	years_count = 0
	while first_bear <= second_bear:
		first_bear *= 3
		second_bear *= 2
		years_count += 1
	print(years_count)
main()


def Brothers(a, b):
	count = 0
	while a <= b:
		count = count + 1
		a = a * 3
		b = b * 2
	return count
(a, b) = input().split()
a = int(a)
b = int(b)
print(Brothers(a, b))


from math import log
s = [int(n) for n in input().split()]
k = int(log(s[1] / s[0]) / log(1.5)) + 1
print(k)


(L, B) = map(int, input().split(' '))
notdone = True
counter = 1
while notdone:
	L = L * 3
	B = B * 2
	if L > B:
		notdone = False
		print(counter)
	counter = counter + 1


(a, b) = input().split()
(a, b) = (int(a), int(b))
num = 1
if a == b:
	print(num)
else:
	for i in range(1, 20):
		a = 3 * a
		b = 2 * b
		if a > b:
			print(i)
			break


string = input()
ls = string.split(' ')
a = int(ls[0])
b = int(ls[1])
years = 0
while a <= b:
	a *= 3
	b *= 2
	years += 1
print(years)


from math import log2
(a, b) = map(int, input().split())
n = int(log2(b / a) / log2(3 / 2))
while 3 ** n * a <= 2 ** n * b:
	n += 1
print(n)


num1 = list(map(int, input().split()))
a = 0
while num1[0] <= num1[1]:
	num1[0] *= 3
	num1[1] *= 2
	a += 1
print(a)


bear_weight = input('')
(limak_wt, bob_wt) = bear_weight.split(' ')
years = 0
while int(limak_wt) <= int(bob_wt):
	years = years + 1
	limak_wt = int(limak_wt) * 3
	bob_wt = int(bob_wt) * 2
print(years)


(l, b) = (int(_) for _ in input().split())
y = 0

def year():
	global l
	global b
	global y
	y += 1
	l *= 3
	b *= 2
	return l > b
for _ in iter(year, True):
	pass
print(y)


(x, y) = map(int, input().split())
z = 0
bol = True
while bol:
	x *= 3
	y *= 2
	z += 1
	if x > y:
		bol = False
print(z)


(a, b) = input().split()
a = int(a)
b = int(b)
for i in range(1, 1000):
	if a <= b:
		a = 3 * a
		b = 2 * b
	else:
		year = i - 1
		break
print(year)


(limaks, bobs) = input().split()
limaks = int(limaks)
bobs = int(bobs)
gads = 0
while limaks <= bobs:
	limaks = limaks * 3
	bobs = bobs * 2
	gads = gads + 1
print(gads)


def main():
	i = 1
	(a, b) = input().split()
	a = eval(a)
	b = eval(b)
	while a > 0:
		if a * 3 ** i > b * 2 ** i:
			break
		i = i + 1
	print(i)
main()


import sys

def get_ints():
	return map(int, sys.stdin.readline().strip().split())
(a, b) = get_ints()
nbYears = 0
while a <= b:
	nbYears += 1
	a = 3 * a
	b = 2 * b
print(nbYears)


import math
l = math.log
print(int(l(eval(input().replace(' ', '/'))) / l(2 / 3) + 0.01) + 1)


(weight_limp, weight_bob) = map(int, input().split())
i = 0
while True:
	if weight_limp <= weight_bob:
		i += 1
		weight_limp *= 3
		weight_bob *= 2
	else:
		break
print(i)


(Limak, Bob) = map(int, input().split())
y = 1
while True:
	Limak *= 3
	Bob *= 2
	if Limak > Bob:
		break
	y += 1
print(y)


x = list(map(int, input().split(' ')))
counter = 0
while x[0] <= x[1]:
	x[0] *= 3
	x[1] *= 2
	counter += 1
print(str(counter))


def years_until_larger(a, b):
	num_years = 0
	while a <= b:
		num_years += 1
		a *= 3
		b *= 2
	return num_years

def main():
	(a, b) = [int(x) for x in input().split()]
	num_years = years_until_larger(a, b)
	print(num_years)
main()


z = input()
z = z.split()
a = int(z[0])
b = int(z[1])
e = 0
for i in range(20):
	if a > b:
		print(i)
		break
	a = a * 3
	b = b * 2
	e += 1


(n, m) = map(int, input().split())

def solve(a, b):
	ans = 0
	while a <= b:
		ans += 1
		a *= 3
		b *= 2
	return ans
print(solve(n, m))


andb = input()
if andb[1] == ' ':
	a = int(andb[0])
else:
	a = int(andb[:2])
if andb[-2] == ' ':
	b = int(andb[-1])
else:
	b = int(andb[-2:])
time = 0
while 1:
	a *= 3
	b *= 2
	time += 1
	if a > b:
		print(time)
		break


(bear, bob) = input().split()
bear = int(bear)
bob = int(bob)
i = 1
while True:
	bear *= 3
	bob *= 2
	if bear > bob:
		print(i)
		break
	i += 1


import sys
input = sys.stdin.readline
(a, b) = map(int, input().split())
y = 0
while a <= b:
	a *= 3
	b *= 2
	y += 1
print(y)


t = list(input().split())
for x in range(2):
	t[x] = int(t[x])
i = 0
while 1:
	i += 1
	if t[0] * 3 > t[1] * 2:
		print(i)
		break
	t[0] *= 3
	t[1] *= 2


args = input()
(limak, bob) = args.split()
limak = int(limak)
bob = int(bob)
year_cnt = 0
while limak <= bob:
	year_cnt += 1
	limak *= 3
	bob *= 2
print(year_cnt)


li = [int(i) for i in input().split()]
c = 0
while 1:
	li[0] = li[0] * 3
	li[1] = li[1] * 2
	c = c + 1
	if li[0] > li[1]:
		break
print(c)


k = input().split()
arr = []
for i in k:
	arr.append(int(i))
v = arr[0]
o = arr[1]
count = 0
while v <= o:
	v = v * 3
	o = o << 1
	count += 1
print(count)


vv = input()
a = ''
b = ''
chs = ''
res = 0
for i in vv:
	if i != ' ':
		chs += i
	else:
		a = int(chs)
		chs = ''
b = int(chs)
while a <= b:
	a *= 3
	b *= 2
	res += 1
print(res)


input_list = []
num = 0
while True:
	if num == 1:
		break
	line = input()
	line = line.split()
	line = list(map(int, line))
	num += 1
a = line[0]
b = line[1]
count = 0
while a <= b:
	count += 1
	a *= 3
	b *= 2
print(count)


a = list(map(int, input().split()))
w1 = a[0]
w2 = a[1]
cnt = 0
while w1 <= w2:
	w1 = 3 * w1
	w2 = 2 * w2
	cnt = cnt + 1
print(cnt)


(a, b) = map(int, input().split())
i = 0
if a < b:
	while a <= b:
		a *= 3
		b *= 2
		i += 1
	print(i)
elif b < a:
	while b <= a:
		a *= 2
		b *= 3
		i += 1
else:
	print(1)


import math
import os
import random
import re
from sys import stdin, stdout
from collections import Counter
from itertools import permutations

def si():
	return str(stdin.readline())

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())

def debug(x):
	return stdout.write(str(x))
(a, b) = mi()
c = 0
while a <= b:
	a = 3 * a
	b = 2 * b
	c += 1
print(c)


def String_to_list(Strings):
	list1 = list(Strings.split(' '))
	return list1

def main_approach(num1, num2):
	i = 0
	a = num1
	b = num2
	while a <= b:
		i += 1
		a = a * 3
		b = b * 2
	else:
		return i
input1 = input()
list2 = String_to_list(input1)
num1 = int(list2[0])
num2 = int(list2[1])
print(main_approach(num1, num2))


(n, h) = input().split()
sum = 0
n = int(n)
h = int(h)
while n <= h:
	n *= 3
	h *= 2
	sum += 1
else:
	print(sum)


(a, b) = map(int, input().strip().split())
ans = 0
while a <= b:
	a = (a << 1) + a
	b <<= 1
	ans += 1
print(ans)


(a, b) = input().split()
n = int(a)
m = int(b)
result = 0
while n <= m:
	n = n * 3
	m = m * 2
	result = result + 1
print(result)


(limak, bob) = map(int, input().split())

def calculateYear(limak, bob, year):
	year += 1
	(limak, bob) = (3 * limak, 2 * bob)
	if limak > bob:
		return year
	else:
		return calculateYear(limak, bob, year)
print(calculateYear(limak, bob, 0))


(a, b) = map(int, input().split())
(p, q) = (a, b)
c = 1
while a < b:
	(a, b) = (p * 3 ** c, q * 2 ** c)
	c += 1
if a == b:
	print(c)
else:
	print(c - 1)


import sys
weights = [0, 0]
for line in sys.stdin:
	line = line.strip().split()
	weights[0] = int(line[0])
	weights[1] = int(line[1])
	break
year = 0
while weights[0] <= weights[1]:
	weights[0] = weights[0] * 3
	weights[1] = weights[1] * 2
	year += 1
print(year)


tru = True
year = 0
l = list(map(int, input().split()))
a = l[0]
b = l[1]
while tru:
	a = a * 3
	b = b * 2
	year += 1
	if a > b:
		tru = False
		print(year)


import math
(a, b) = map(int, input().split())
res = math.ceil(math.log(b / a, 1.5))
print(res + (1 if a * 3 ** res == b * 2 ** res else 0))


s = input()
(L, B) = s.split(' ')
a = int(L)
b = int(B)
c = 0
while a <= b:
	a *= 3
	b *= 2
	c += 1
print(c)


uv = list(map(int, input().split()))
u = uv[0]
v = uv[1]
ans = 0
while u <= v:
	u = u * 3
	v = v * 2
	ans = ans + 1
print(ans)


Bears = input().split()
for bear in Bears:
	i = Bears.index(bear)
	Bears[i] = int(Bears[i])
year = 0
while Bears[0] <= Bears[1]:
	Bears[0] *= 3
	Bears[1] *= 2
	year += 1
print(year)


(a, b) = map(int, input().split())
i = 1
while 1:
	a = a * 3
	b = b * 2
	if a > b:
		print(i)
		break
	else:
		i = i + 1
		continue


utente = input().strip()
utente = utente.split(' ')
limak = int(utente[0])
bob = int(utente[1])
count = 0
while limak <= bob:
	limak *= 3
	bob *= 2
	count += 1
print(count)


input_string = input()
userList = input_string.split()
results = list(map(int, userList))
a = True
n = 1
while a:
	if results[0] * 3 ** n > results[1] * 2 ** n:
		print(n)
		a = False
	n = n + 1


(l, b) = input().split()
l = int(l)
b = int(b)
counter = 0
while l <= b:
	counter += 1
	l = 3 * l
	b = 2 * b
print(counter)


num_array = input().split()
num1 = int(num_array[0])
num2 = int(num_array[1])
count = 0
while num1 <= num2:
	num1 *= 3
	num2 *= 2
	count += 1
print(count)


(a, b) = input().split()
(a, b) = (int(a), int(b))

def find_years(a, b):
	years = 0
	if a == b:
		return years + 1
	while a < b:
		a = a * 3
		b = b * 2
		years += 1
		if a == b:
			return years + 1
	return years
result = find_years(a, b)
print(result)


def solution(a, b):
	count = 0
	while True:
		if a > b:
			break
		else:
			a = 3 * a
			b = 2 * b
			count += 1
	return count
(a, b) = map(int, input().split())
ans = solution(a, b)
print(ans)


(a, b) = input().split(' ')
(a, b) = (int(a), int(b))
itr = 0
while a <= b:
	itr += 1
	(a, b) = (3 * a, 2 * b)
print(itr)


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

def num_yrs(a, b):
	i = 0
	while True:
		i += 1
		a *= 3
		b *= 2
		if a > b:
			return i
print(num_yrs(a, b))


(a, b) = map(int, input().split())
c = 0
while a <= b:
	tr = 3 * a
	db = 2 * b
	a = tr
	b = db
	c = c + 1
print(c)


def function(L, B):
	i = 0
	total = 0
	while i < 10:
		L *= 3
		B *= 2
		total += 1
		if L > B:
			return total
		i += 1
l = list(map(int, input().rstrip().split()))
L = l[0]
B = l[1]
print(function(L, B))


def bob(a, b):
	count = 0
	if a < b:
		while a < b or a == b:
			a = a * 3
			b = b * 2
			count += 1
		return count
	elif a == b or a > b:
		return 1
(a, b) = list(map(int, input().split()))
print(bob(a, b))


(limak, brother) = input().split()
limak = int(limak)
brother = int(brother)
num_years = 0
while limak <= brother:
	limak = limak * 3
	brother = brother * 2
	num_years = num_years + 1
print(num_years)


masukan = input()
masukanl = []
for i in masukan.split():
	masukanl = masukanl + [int(i)]
a = masukanl[0]
b = masukanl[1]
i = True
tahun = 0
while i == True:
	if a > b:
		i = False
		break
	a = a * 3
	b = b * 2
	tahun = tahun + 1
print(tahun)


from sys import stdin

def sol(lim, bob):
	year = 0
	while lim <= bob:
		lim *= 3
		bob *= 2
		year += 1
	return year
(limak, bob) = map(int, stdin.readline().split())
print(sol(limak, bob))


import sys

def rl():
	return sys.stdin.readline().strip()

def rn():
	return list(map(int, sys.stdin.readline().strip().split()))

def ri():
	return map(int, sys.stdin.readline().strip().split())

def rln(n):
	l = [None] * n
	for i in range(n):
		l[i] = int(rl())
	return l
(a, b) = rn()
n_a = a
n_b = b
c = 0
while n_a <= n_b:
	n_a *= 3
	n_b *= 2
	c += 1
print(c)


angka = input().split()
a = int(angka[0])
b = int(angka[1])
tahun = 0
while a <= b:
	a *= 3
	b *= 2
	tahun += 1
	if a > b:
		break
print(tahun)


weights = [int(a) for a in input().split()]
(a, b) = (weights[0], weights[1])
cnt = 1
res = 3 / 2
while res <= b / a:
	cnt += 1
	res *= 3 / 2
print(cnt)


x = input().split()
for a in range(len(x)):
	x[a] = int(x[a])
n = 1
while True:
	if x[0] * 3 ** n > x[1] * 2 ** n:
		print(n)
		break
	n += 1


import re
s = input()
num = re.compile('\\d{2}|\\d')
we = num.findall(s)
a = int(we[0])
b = int(we[1])
ans = 0
for i in range(1, 10):
	if 3 * a > 2 * b:
		break
	else:
		a = 3 * a
		b = 2 * b
		ans = ans + 1
print(ans + 1)


limbob = [int(i) for i in input().split()]
lim = limbob[0]
bob = limbob[1]
year = 0
while True:
	if lim * 3 > bob * 2:
		year += 1
		print(year)
		break
	else:
		lim = lim * 3
		bob = bob * 2
		year += 1


import math
from collections import Counter

def get(f):
	return map(f, input().split())

def main():
	(a, b) = get(int)
	for i in range(1, 100):
		a *= 3
		b *= 2
		if a > b:
			print(i)
			return
main()


years = 0
inputs = [int(i) for i in input().split()]
while 1:
	inputs[0] *= 3
	inputs[1] *= 2
	years += 1
	if inputs[0] > inputs[1]:
		break
print(years)


(one, two) = input().split(' ')
limak = int(one)
bob = int(two)
for i in range(100):
	if limak > bob:
		print(i)
		break
	limak *= 3
	bob *= 2


n = input().split(' ')
a = int(n[0])
b = int(n[1])
output = 0
while a < b or a == b:
	a *= 3
	b *= 2
	output += 1
print(output)


weights = input()
weights = weights.split(' ')
i = 1
x = int(weights[0])
y = int(weights[1])
while True:
	x = x * 3 * i
	y = y * 2 * i
	if x > y:
		break
	i += 1
print(i)


a = input().split(' ')
x = 0
while True:
	if int(a[0]) < int(a[1]):
		a[0] = int(a[0]) * 3
		a[1] = int(a[1]) * 2
		x += 1
	elif a[0] == a[1]:
		x += 1
		break
	else:
		break
print(x)


(n, m) = map(int, input().split())
k = 2
j = 3
count = 0
for i in range(11):
	if n > m:
		print(count)
		break
	elif n <= m:
		count = count + 1
		n = n * 3
		m = m * 2


(lambda math, a: print(math.floor(-math.log(int(a[0]) / int(a[1])) / math.log(3 / 2) + 1)))(__import__('math'), input().split())


def countYear(a, b):
	n = 0
	while a <= b:
		a *= 3
		b *= 2
		n += 1
	return n
ans = countYear(*tuple(map(int, input().split())))
print(ans)


inp = input().split()
ans = 0
age1 = int(inp[0])
age2 = int(inp[1])
while age1 - age2 <= 0:
	age1 *= 3
	age2 *= 2
	ans += 1
print(ans)


n = str(input())
n = n.split()
l = int(n[0])
b = int(n[1])
y = 0
while l <= b:
	l = 3 * l
	b = 2 * b
	y += 1
print(y)


import sys
(a, b) = list(map(int, sys.stdin.readline().strip().split()))
n = 0
while a <= b:
	a = a * 3
	b = b * 2
	n = n + 1
print(n)


x = input().split()
year = 0
while True:
	if int(x[0]) > int(x[1]):
		break
	year += 1
	x[0] = int(x[0]) * 3
	x[1] = int(x[1]) * 2
print(year)


import math
In = input()
In2 = In.split(' ')
a = int(In2[0])
b = int(In2[1])
c = 0
while b >= a:
	a = a * 3
	b = b * 2
	c = c + 1
print(c)


(A, B) = input().split()
c = 0
a = int(A)
b = int(B)
while True:
	if a > b:
		break
	elif a <= b:
		a *= 3
		b *= 2
		c = c + 1
print(c)


(L_Weight, B_Weight) = [int(x) for x in input().split()]
years_passed = 0
while L_Weight <= B_Weight:
	L_Weight *= 3
	B_Weight *= 2
	years_passed += 1
print(years_passed)


(l, b) = map(int, input().split())

def be_beg(l, b):
	how_many_years = 0
	while l <= b:
		how_many_years += 1
		l *= 3
		b *= 2
	return how_many_years
print(be_beg(l, b))


def when_limak_deapases_bob():
	years = 0
	(limak_weight, bob_weight) = input().split(' ')
	limak_weight = int(limak_weight)
	bob_weight = int(bob_weight)
	if limak_weight == bob_weight:
		print('1')
	else:
		while limak_weight <= bob_weight:
			limak_weight = limak_weight * 3
			bob_weight = bob_weight * 2
			years = years + 1
		print(years)
when_limak_deapases_bob()


def code(a, b, year):
	a = a * 3
	b = b * 2
	year += 1
	return (a, b, year)
(a, b) = list(map(int, input().split()))
year = 0
while 1:
	if a > b:
		print(year)
		break
	else:
		(a, b, year) = code(a, b, year)


(x, y) = map(int, input().split())
for n in range(1, 1000000000000):
	x = x * 3
	y = y * 2
	if x > y:
		print(n)
		exit()


weights = input('').split()
limak_weight = int(weights[0])
bob_weight = int(weights[1])
for year in range(1, 100):
	limak_weight *= 3
	bob_weight *= 2
	if limak_weight > bob_weight:
		print(year)
		break


import sys
for line in sys.stdin:
	x = line.split()
	l = x[0]
	b = x[1]
	c = 0
	l = int(l)
	b = int(b)
	while b >= l:
		b *= 2
		l *= 3
		c += 1
	print(c)