As a token of his gratitude, Takahashi has decided to give his mother an integer sequence.
The sequence A needs to satisfy the conditions below:
 - A consists of integers between X and Y (inclusive).
 - For each 1\leq i \leq |A|-1, A_{i+1} is a multiple of A_i and strictly greater than A_i.
Find the maximum possible length of the sequence.

-----Constraints-----
 - 1 \leq X \leq Y \leq 10^{18}
 - All input values are integers.

-----Input-----
Input is given from Standard Input in the following format:
X Y

-----Output-----
Print the maximum possible length of the sequence.

-----Sample Input-----
3 20

-----Sample Output-----
3

The sequence 3,6,18 satisfies the conditions.

Source: atcoder | Difficulty: MEDIUM_HARD


Solutions:
(X, Y) = list(map(int, input().split()))
for t in range(1, 100):
	if 2 ** (t - 1) * X <= Y:
		out = t
	else:
		break
print(out)


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


(x, y) = list(map(int, input().split()))
ans = len(str(bin(y // x))) - 2
print(ans)


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


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


mod = 1000000007
eps = 10 ** (-9)

def main():
	import sys
	input = sys.stdin.readline
	(x, y) = list(map(int, input().split()))
	ans = 0
	while x <= y:
		ans += 1
		x *= 2
	print(ans)

def __starting_point():
	main()
__starting_point()


import sys
from math import floor
from fractions import Fraction
from decimal import Decimal
from collections import Counter
import itertools

def input():
	return sys.stdin.readline().strip()
sys.setrecursionlimit(250000)

def getInt():
	return int(input())

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

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

def getStr():
	return input()

def getMultiStr():
	return map(str, input().split())

def getStrList():
	return list(map(str, input().split()))

def main():
	(x, y) = getMultiInt()
	count = 1
	while True:
		if x * 2 <= y:
			x = x * 2
			count += 1
		else:
			break
	print(count)

def __starting_point():
	main()
__starting_point()


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


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


(x, y) = map(int, input().split())
arr = [x]
while arr[-1] <= y:
	arr.append(arr[-1] * 2)
arr.pop()
print(len(arr))


def solve(X, Y):
	ans = 0
	tmp = X
	while tmp <= Y:
		ans += 1
		tmp *= 2
	return ans

def __starting_point():
	(X, Y) = list(map(int, input().split()))
	print(solve(X, Y))
__starting_point()


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


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


(x, y) = map(int, input().split())
for i in range(10 ** 10):
	if x * 2 ** i > y:
		print(i)
		break


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


(X, Y) = list(map(int, input().split()))
i = 1
while Y >= 2 ** i * X:
	i = i + 1
print(i)


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


(X, Y) = map(int, input().split())
k = 1
a = X
while a <= Y:
	a = a * 2
	k += 1
print(k - 1)


import sys

def IN_I():
	return int(sys.stdin.readline().rstrip())

def IN_LI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def IN_LF():
	return list(map(float, sys.stdin.readline().rstrip().split()))

def IN_S():
	return sys.stdin.readline().rstrip()

def IN_LS():
	return list(sys.stdin.readline().rstrip().split())
INF = float('inf')
MOD = 10 ** 9 + 7
(X, Y) = IN_LI()
ans = 0
while X <= Y:
	ans += 1
	X = X * 2
print(ans)


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


(x, y) = list(map(int, input().split()))
cnt = 1
while 1:
	if x * 2 <= y:
		cnt += 1
		x *= 2
	else:
		break
print(cnt)


(x, y) = map(int, input().split())
cnt = 0
while True:
	if x <= y:
		cnt += 1
		x = x * 2
	else:
		print(cnt)
		return


3
import sys
input = lambda : sys.stdin.readline().strip()
(x, y) = [int(x) for x in input().split()]
ans = 0
while x <= y:
	ans += 1
	x *= 2
print(ans)


import sys
import math
import itertools
from collections import defaultdict, deque, Counter
from copy import deepcopy
from bisect import bisect, bisect_right, bisect_left
from heapq import heapify, heappop, heappush
input = sys.stdin.readline

def RD():
	return input().rstrip()

def F():
	return float(input().rstrip())

def I():
	return int(input().rstrip())

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

def MF():
	return map(float, input().split())

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

def TI():
	return tuple(map(int, input().split()))

def LF():
	return list(map(float, input().split()))

def Init(H, W, num):
	return [[num for i in range(W)] for j in range(H)]

def main():
	(X, Y) = MI()
	ans = 1
	while True:
		X *= 2
		if X > Y:
			break
		ans += 1
	print(ans)

def __starting_point():
	main()
__starting_point()


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


def resolve():
	import sys
	input = sys.stdin.readline
	(x, y) = [int(x) for x in input().rstrip().split(' ')]
	count = 1
	num = x
	while num * 2 <= y:
		count += 1
		num *= 2
	print(count)

def __starting_point():
	resolve()
__starting_point()


import sys
input = sys.stdin.readline
(X, Y) = list(map(int, input().split()))
ans = 0
for i in range(100):
	temp = X * 2 ** i
	if temp > Y:
		ans = i
		break
print(ans)


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


(X, Y) = map(int, input().split())
cnt = 0
x_temp = X
while True:
	x_temp *= 2
	if x_temp <= Y:
		cnt += 1
	else:
		break
print(cnt + 1)


import sys
sys.setrecursionlimit(10 ** 6)

def II():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LC():
	return list(input())

def IC():
	return [int(c) for c in input()]

def MI():
	return map(int, input().split())
(X, Y) = MI()
Out = 1
while X * 2 <= Y:
	Out += 1
	X *= 2
print(Out)


from fractions import gcd
from itertools import combinations, permutations, accumulate, product
from collections import deque, defaultdict, Counter
import decimal
import re
import math
import bisect
import sys
sys.setrecursionlimit(10000000)
mod = 10 ** 9 + 7
from sys import stdin
readline = stdin.readline

def readInts():
	return list(map(int, readline().split()))

def readTuples():
	return tuple(map(int, readline().split()))

def I():
	return int(readline())
(x, y) = readInts()
cnt = 1
while x <= y:
	x += x
	if x <= y:
		cnt += 1
print(cnt)


import sys
import pprint
import math
import itertools
from collections import defaultdict
input = sys.stdin.readline
(X, Y) = list(map(int, input().split()))
ans = 0
for i in range(X, X + 100):
	now = i
	cnt = 0
	while True:
		if now <= Y:
			cnt += 1
			now *= 2
		else:
			break
	ans = max(ans, cnt)
print(ans)


from collections import Counter

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

def main():
	(X, Y) = lmi()
	cur = X
	result = 0
	while cur <= Y:
		result += 1
		cur *= 2
	print(result)

def __starting_point():
	main()
__starting_point()


import math
(X, Y) = list(map(int, input().split()))
power = 0
while X * pow(2, power) <= Y:
	power += 1
print(power)


(x, y) = list(map(int, input().split()))
ans = 0
while x <= y:
	ans += 1
	x <<= 1
print(ans)


def main():
	import sys
	input = sys.stdin.readline
	(x, y) = map(int, input().split())
	answer = 0
	if x == 1:
		answer = 1
		while pow(2, answer) <= y:
			answer += 1
	else:
		while x * pow(2, answer) <= y:
			answer += 1
	print(answer)

def __starting_point():
	main()
__starting_point()


(X, Y) = map(int, input().split())
A = [X]
while True:
	next = A[-1] * 2
	if next > Y:
		break
	else:
		A.append(next)
print(len(A))


def solve():
	(X, Y) = [int(i) for i in input().split()]
	ans = 0
	while X <= Y:
		ans += 1
		X *= 2
	print(ans)

def __starting_point():
	solve()
__starting_point()


(x, y) = map(int, input().split())
lst = [x]
for i in range(10 ** 18):
	if lst[-1] * 2 > y:
		break
	else:
		lst.append(lst[-1] * 2)
print(len(lst))


(X, Y) = map(int, input().split())
ans = []
n = X
while n <= Y:
	ans.append(n)
	n *= 2
print(len(ans))


(X, Y) = input().split(' ')
(X, Y) = (int(X), int(Y))
cnt = 1
Num = X
while Num <= Y:
	Num *= 2
	if Num <= Y:
		cnt += 1
print(cnt)


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


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
(x, y) = list(map(int, input().split()))
ans = 0
while x <= y:
	ans += 1
	x *= 2
print(ans)


import sys
readline = sys.stdin.readline
read = sys.stdin.read
(x, y) = list(map(int, readline().split()))
ans = 0
while x <= y:
	x *= 2
	ans += 1
print(ans)


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


def LI():
	return list(map(int, input().split()))
(X, Y) = LI()
count = 1
total = X
for i in range(1000000):
	total *= 2
	if total > Y:
		break
	count += 1
print(count)


(X, Y) = map(int, input().split())
a = 1
x = X
mul = min(max(X, 2), 2)
cnt = 1
for i in range(10000):
	x *= mul
	if x > Y:
		cnt += i
		break
print(cnt)


(x, y) = list(map(int, input().split()))
if y < 2 * x:
	print(1)
	return
ans = 1
while x * 2 <= y:
	ans += 1
	x = 2 * x
print(ans)


(x, y) = map(int, input().split())

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


(X, Y) = map(int, input().split())
ans = 0
for _ in range(100):
	ans += 1
	X *= 2
	if X > Y:
		break
print(ans)


def main():
	(X, Y) = list(map(int, input().split()))
	ans = 0
	while X <= Y:
		X *= 2
		ans += 1
	print(ans)

def __starting_point():
	main()
__starting_point()


def main():
	(x, y) = list(map(int, input().split()))
	cnt = 1
	while True:
		x *= 2
		if x <= y:
			cnt += 1
		else:
			break
	print(cnt)

def __starting_point():
	main()
__starting_point()


(X, Y) = list(map(int, input().split()))
ans = 1
tmp = X
while tmp * 2 <= Y:
	ans += 1
	tmp *= 2
print(ans)


def main():
	(X, Y) = list(map(int, input().split()))
	ans = 1
	cnt = X
	for _ in range(300):
		cnt *= 2
		if cnt <= Y:
			ans += 1
		else:
			print(ans)
			return

def __starting_point():
	main()
__starting_point()


import sys
pin = sys.stdin.readline

def main():
	(x, y) = map(int, pin().split())
	cnt = 0
	while x <= y:
		x *= 2
		cnt += 1
	print(cnt)
	return
main()


def main():
	(X, Y) = map(int, input().split())
	ans = 1
	x = X
	for i in range(Y):
		if x * 2 > Y:
			break
		else:
			x *= 2
			ans += 1
	print(ans)

def __starting_point():
	main()
__starting_point()