Problem:
 Score : 300 points    Problem Statement 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 1 3 20      Sample Output 1 3  The sequence 3,6,18 satisfies the conditions.       Sample Input 2 25 100      Sample Output 2 3       Sample Input 3 314159265 358979323846264338      Sample Output 3 31

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

Solution (Python):
x, y = map(int, input().split())
n = 0
while x <= y:
    x += x
    n += 1
print(n)

Solution (Python):
x,y = map(int, input().split())

cnt = 0
a = x
while a <= y:
    a += a
    cnt += 1
print(cnt)

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

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

Solution (Python):
X, Y = map(int,input().split())

ans = 1

while 1:
  X *= 2
  if X <= Y:
    ans += 1
  else:
    print(ans)
    break

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

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

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

Solution (Python):
X, Y = map(int, input().split())
cn = 1
for i in range(10**7):
    X = X *2
    if X <= Y:
        cn = cn + 1
    else:
        print(cn)
        break

Solution (Python):
X, Y = map(int, input().split())

A = []
a = X

while 1:
    A.append(a)
    if a*2 > Y:
        break
    a *= 2

print(len(A))

Solution (Python):
x,y=map(int,input().split())
ans=1
tmp=x
while 1:
  if tmp*2<=y:
    ans+=1
    tmp*=2
  else:
    print(ans)
    exit()

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

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

Solution (Python):
x, y = map(int, input().split())
ans = 1

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

Solution (Python):

"""
Created on Mon Sep 21 22:43:47 2020

@author: liang
"""

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

tmp = X
ans = 1

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**6)

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

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

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    X, Y = LI()

    ans = 0
    num = X
    while num <= Y:
        ans += 1
        num *= 2

    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
x , y = map(int,input().split())
print(len(format(y//x, 'b')))

Solution (Python):
X,Y = map(int,input().split())
count = 0

while X <= Y:
  X = 2*X
  count += 1
  
print(count)

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

Solution (Python):
x,y = map(int,input().split())
tmp = x
cnt = 0

while tmp <= y:
  tmp *= 2
  cnt += 1

print(cnt)

Solution (Python):
import math
from math import gcd,pi,sqrt
INF = float("inf")

import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

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

    ans = 0
    while True:
        ans += 1
        x *= 2
        if x > y:
            break
    print(ans)



if __name__=="__main__":
    main()

Solution (Python):
x,y=map(int,input().strip().split())

cnt=1
while True:
    x*=2
    if x<=y:
        cnt+=1
    else:
        break

print(cnt)

Solution (Python):
from itertools import count
X, Y = map(int, input().split())
for i in count(1):
    if 2**i*X > Y:
        print(i)
        break

Solution (Python):

[X,Y] = list(map(int,input().split()))
out=0

i=X
while i<=Y:
    i=i*2
    out+=1
    
print(out)

Solution (Python):
X,Y=map(int,input().split())
a=0
while X<=Y:
   Y=Y//2
   a+=1
   
print(a)

Solution (Python):
x,y = input().split()
X = int(x)
Y = int(y)

A = X
count = 0
while Y >= A:
  A = A*2
  count += 1

print(count)

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

Solution (Python):

X, Y = map(int, input().split())
results = list()
num = X
while num <= Y:
    results.append(num)
    num += num
print(len(results))

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

Solution (Python):
X, Y = map(int, input().split())

cnt = 0
i = X
while i <= Y:
  cnt += 1
  i *= 2
  
print(cnt)

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

print(ans)

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

print(ans)

Solution (Python):

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

temp = x
cnt = 0

while temp <= y:
    temp = temp*2
    cnt += 1

print(cnt)

Solution (Python):
import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
    x, y = LI()
    ans = 1
    cnt = x
    while cnt*2<=y:
        ans += 1
        cnt *= 2
    print(ans)
main()

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

Solution (Python):
X, Y = map(int, input().split())

cnt = 1
num = X
while num <= Y:
    num *= 2
    if(num > Y):
        break
    cnt += 1

print(cnt)

Solution (Python):
x, y = map(int, input().split())

ans = 0

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

print(ans)

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

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

Solution (Python):
x,y = map(int,input().split())
li = []
while True:
    li += [x]
    x *= 2
    if x>y:
        break
print(len(li))

Solution (Python):
x, y = map(int, input().split())

for l in range(1, 100):
    if 2 ** (l - 1) * x > y:
        l -= 1
        break

print(l)

Solution (Python):
x, y = map(int, input().split())
tmp_memo = 1
for l in range(2, 100):
    tmp_memo *= 2
    if tmp_memo * x > y:
        l -= 1
        break

print(l)

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

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

Solution (Python):
X, Y = map(int, input().split())
ans = 1
nextX = X
for i in range(0, 10 ** 8):
    t = nextX * 2
    if t <= Y:
        ans += 1
        nextX = t
    else:
        break
print(ans)

Solution (Python):
X, Y = map(int, input().split())

cnt=1
while 2*X<=Y:
	X*=2
	cnt+=1
print(cnt)

Solution (Python):
X, Y = map(int, input().split())

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

Solution (Python):
x,y = map(int, input().split())
for i in range(60,-1,-1):
    if x*(2**i) <= y:
        print(i+1)
        break

Solution (Python):
X, Y = map(int, input().split())

now = X
res = 0
for i in range(10 ** 9):
    res += 1
    now *= 2
    if now > Y:
        break

print(res)

Solution (Python):
X,Y = map(int,input().split())
div = Y//X
bitnum = bin(div)
print(len(bitnum)-2)

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

Solution (Python):
x,y=[int(i) for i in input().split()]


def func(i):
    return len(bin(i))-2

print(func(y//x))

Solution (Python):
X, Y = map(int, input().split())

A = [X]
while True:
    if A[-1] * 2 <= Y:
        A.append(A[-1] * 2)
    else:
        break

print(len(A))

Solution (Python):
X,Y = map(int,input().split())

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

Solution (Python):
X,Y = map(int,input().split())

def solve(now,y,ans=1):
  if now*2 > y:
    return ans
  else:
    return solve(now*2,y,ans+1)
  
print(solve(X,Y))

Solution (Python):
x, y = map(int, input().split())

cnt = 1
while x <= y:
    x *= 2
    cnt += 1
print(cnt-1)

Solution (Python):
N,M = map(int,input().split())

si = N
ans = 0

while(si <= M):
    ans += 1
    si = si * 2

print(ans)

Solution (Python):
def main():
    x, y = map(int, input().split())
    
    count = 1
    while True:
        x *= 2
        
        if x > y:
            break
        else:
            count += 1
            
    print(count)
    

if __name__ == '__main__':
    main()

Solution (Python):
n,k=map(int,input().split())
c=0
s=n
while(s<=k):
    c=c+1
    s=s*2
print(c)

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

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

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

Solution (Python):









import os
import sys




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


if __name__ == "__main__":
    main()

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

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

Solution (Python):
x,y = map(int, input().split())

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

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

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

Solution (Python):
import math
x,y=map(int,input().split())
lst=[]
lst.append(x)
for i in range(2,100):
    z=0
    z=math.pow(2,i-1)*x
    if z>y:
        print(len(lst))
        break
    else:
        lst.append(z)

Solution (Python):
x, y = map(int, input().split())

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

Solution (Python):

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

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

Solution (Python):
X,Y = map(int,input().split())
ans = 0
t = 1
while 1:
    if X*t<=Y:
        ans += 1
        t *= 2
    else:break
print(ans)

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

Solution (Python):
X,Y = map(int,input().split())
ans = 1
x = X

for n in range(Y):
  if x*2<=Y:
    ans+=1
    x*=2
  else:
    print(ans)
    exit()

Solution (Python):
x, y = map(int, input().split())

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

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

Solution (Python):
X, Y = map(int, input().split())

ans = 1
while True:
    X *= 2
    if X <= Y:
        ans += 1
    else:
        break
print(ans)

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

Solution (Python):
import math
X, Y = map(int,input().split())

ans = 0

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

Solution (Python):
X, Y = map(int, input().split())

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

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

Solution (Python):
x, y = map(int, input().split())

ans = 0

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

Solution (Python):
def resolve():
    X, Y =map(int, input().split())
    ans = 1
    count = X
    while count*2 <= Y:
        ans += 1
        count *= 2
    print(ans)
resolve()

Solution (Python):

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

Solution (Python):
X, Y = list(map(int, input().split()))

ans = []
num = X
while(num <= Y):
  ans.append(num)
  num *= 2

print(len(ans))

Solution (Python):

X,Y=open(0).read().split()

X=int(X)

Y=int(Y)


for i in range(110000):
    if (2**i) >= 1000000000000000000:
        
        break



list1=[2**i*X for i in range(61) if 2**i*X <= Y]

print(len(list1))

Solution (Python):
x,y=map(int,input().split())
import bisect as bi
ans=1
for i in range(80):
    if x*2<=y:
        ans+=1
        x*=2
print(ans)

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

Solution (Python):
X,Y = map(int,input().split())
i = X
c = 1
while i < Y:
    i *= 2
    if i <= Y:
        c += 1
print(c)

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

Solution (Python):
X, Y = map(int, input().split())

count = 0
while X <= Y:
    X *= 2
    count += 1
print(count)

Solution (Python):
X, Y = list(map(int, input().split()))

ans = 0
math = X
while(math <= Y):
  ans += 1
  math = math * 2

print(ans)

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

Solution (Python):
x,y=map(int,input().split())

i=0
while y>=x:
  i+=1
  x<<=1
print(i)

Solution (Python):
X,Y=map(int,input().split())
count=1
old=X
new=X
while 1:
  new += old
  if new > Y:break
  count += 1
  old = new

print(count)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush

def main():
    x,y = map(int, input().split())

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


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

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

Solution (Python):
X, Y = map(int, input().split())

ans = 0
cur = X
while cur <= Y:
    cur *= 2
    ans += 1
print(ans)

Solution (Python):

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

print(ans)

Solution (Python):
X, Y = map(int, input().split())

cnt = 0
while X <= Y:
    X = X*2
    cnt += 1

print(cnt)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    X, Y = map(int, readline().split())

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

    print(ans)
    return


if __name__ == '__main__':
    main()

Solution (Python):
import math
X, Y = list(map(int, input().split()))

val = X
cnt = 1

while val <= Y:

    val *= 2
    cnt += 1

print(cnt - 1)

Solution (Python):
x,y = map(int, raw_input().split())
c = 0
while(x <= y):
	c +=1
	x <<=1

print c

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

Solution (Python):
x, y = map(int, input().split())

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

Solution (Python):
X,Y = map(int,input().split())

ans = 1
tmp = X

while tmp <= Y:
    tmp = tmp*2
    if tmp <= Y:
        ans+=1

print(ans)

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

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

Solution (Python):
X,Y=map(int,input().split())

def solve() :
    a=Y//X
    b,n=1,1
    while a>=b :
        b=2**n
        n+=1
    return n-1
  
print(solve())

Solution (Python):
X,Y = (int(T) for T in input().split())
Count = 0
for T in range(61):
    if X*(2**T)<=Y:
        Count += 1
    else:
        print(Count)
        break

Solution (Python):
x, y = map(int, input().split())
ans = 0
for i in range(10000000000000):
    if x*2**i <= y:
        ans += 1
    else:
        break

print(ans)

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

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

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

Solution (Python):
X, Y = map(int, input().split())

cnt = 0
while X <= Y:
    cnt += 1
    X *= 2
print(cnt)

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left, bisect_right 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

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

val = X
cnt = 0
while val <= Y:
    val *= 2
    cnt += 1
print(cnt)

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

Solution (Python):


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


ans = 0
now = X
while now <= Y:
  now *= 2
  ans += 1
  
print(ans)

Solution (Python):
if __name__ == '__main__':
	X, Y = map(int, input().split())
	count = 0
	while X <= Y:
		count += 1
		X *= 2

	print(count)

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

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

Solution (Python):
x, y = map(int, input().split())

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

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

Solution (Python):
X,Y = map(int,input().split())
ans = 0

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

print(ans)

Solution (Python):
X,Y = map(int,input().split())
print(len(bin(Y//X))-2)

Solution (Python):
import sys
x,y = map(int,input().split())
cnt = 1
for i in range(1,100):
  if x*2 <= y:
    cnt += 1
    x *= 2
  else:
    print(cnt)
    sys.exit()

Solution (Python):
X,Y = map(int, input().split())

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

print(ans , flush=True)

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

Solution (Python):
x, y = map(int,input().split())

cnt = 1
while True:
    x = x * 2
    if x > y:
        break
    cnt += 1
print(cnt)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

Solution (Python):
[x,y] = [int(i) for i in input().split()]
ans = 0
if x == y:
  print(1)
else:
  while x <= y:
    x *= 2
    ans += 1
  print(ans)

Solution (Python):
x,y=map(int,input().split())
c=1
for _ in range(y):
    x=x*2
    if x>y:
        break
    c+=1
print(c)

Solution (Python):

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



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

print(ans)

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

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

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

Solution (Python):
X,Y = list(map(int,input().split()))

ans=0
while True:
    if X > Y:
        break
    X=2*X
    ans += 1
print(ans)

Solution (Python):
import sys,math,collections,itertools
input = sys.stdin.readline

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

count = 1
while X<=Y:
    count +=1
    X*=2
print(count-1)

Solution (Python):
x,y = map(int, input().split())

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

Solution (Python):
X, Y = map(int, input().split())
ans = 1
while(1):
	if Y < X*(2**(ans-1)):
		ans -= 1
		break
	ans += 1
print(ans)

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

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


if __name__ == "__main__":
    main()

Solution (Python):
X,Y=map(int,input().split())
total=1
while 1:
  X=X*2
  if X>Y:
    break
  total=total+1
print(str(total))

Solution (Python):
X, Y = [int(x) for x in input().split()]
pow = 1
for i in range(100):
    if pow > Y // X: break
    pow *= 2

print(i)

Solution (Python):
x, y = map(int, input().split())

res = 0
while x <= y:
    x *= 2
    res += 1

print(res)

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

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
from decimal import Decimal
from operator import mul

INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)



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

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

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

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

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

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

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

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

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

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

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

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


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def combinations_count(n, r):
    if n < r:
        return 0
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret

def make_divisors(n):
    lower_divisors , upper_divisors = [], []
    i = 1
    while i*i <= n:
        if n % i == 0:
            lower_divisors.append(i)
            if i != n // i:
                upper_divisors.append(n//i)
        i += 1
    return lower_divisors + upper_divisors[::-1]




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

Solution (Python):
import sys


def resolve():
    readline = sys.stdin.readline    

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

    
    A = X
    cnt = 1
    while 1:
        A = 2 * A
        if A <= Y:
            cnt += 1
        else:
            print(cnt)
            break


resolve()

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

Solution (Python):
x, y = map(int, input().split())

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

Solution (Python):
x,y = map(int, input().split())

ans = 0
i = 1
while True:
    t = x*i
    if t > y:
        break
    
    ans += 1
    i = i*2
    

print(ans)

Solution (Python):


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

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

print(res)

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

Solution (Python):


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

count = 0
num = X

while True:
    if not X <= num <= Y:
        break

    num *= 2
    count += 1

print(count)

Solution (Python):
x,y = map(int, input().split())

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

Solution (Python):
x,y = map(int,input().split())

ans = 0
while True:
    if x <= y:
        ans += 1
        x *= 2
    else:
        break
print(ans)

Solution (Python):
from sys import stdin
input = stdin.readline


def main():
  X, Y = list(map(int, input().split()))
  cnt = 1
  while True:
    X *= 2
    if X > Y:
      break
    cnt += 1

  print(cnt)


if(__name__ == '__main__'):
  main()

Solution (Python):


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

ans = 1 
while True:
    x *= 2
    if x <= y:
        ans += 1
    else:
        break
print(ans)

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

Solution (Python):
X,Y=map(int,input().split())
if Y<X:
    print(0)
else:
    count=1
    while X<Y:
        X*=2
        if X<=Y:
            count+=1
    print(count)

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

Solution (Python):
x, y = map(int, input().split())
print(len(bin((y // x)))-2)

Solution (Python):
X, Y = map(int, input().split())
ans = 1
while X <= Y:
    X *= 2
    if X > Y:
        break
    ans += 1

print(ans)

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

Solution (Python):
x, y = map(int, input().split())
res = 1
for i in range(100):
  x *= 2
  if x <= y:
    res += 1
  else:
    print(res)
    exit()

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

Solution (Python):
x,y = map(int,input().split())

ans = 0

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

print(ans)

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

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

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

Solution (Python):
from math import log2

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

def ii():
    return int(input())

def main():
    X, Y = mi()
    cnt = 0
    while X <= Y:
        X *= 2
        cnt += 1
    print(cnt)
    


if __name__ == '__main__':
    main()

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

Solution (Python):
X, Y = map(int,input().split())
count = 0

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

print(count)

Solution (Python):
x, y = map(int, input().split())

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

l = []
while x <= y:
    l.append(x)
    x *= 2

print(len(l))

Solution (Python):





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

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

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

X, Y = MI()
ans = 0

while Y >= X:
    X *= 2
    ans += 1
    
print(ans)

Solution (Python):
import math

x, y = [int(i) for i in input().split()]

ans = 0

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

print(ans)

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

Solution (Python):
X, Y = map(int, input().split())

ans = 0
num = X
while num<= Y:
    ans += 1
    num *= 2

print(ans)

Solution (Python):
def solve():
    ret = 1
    cur_num = X
    while cur_num * 2 <= Y:
        cur_num *= 2
        ret += 1
    print(ret)

if __name__ == "__main__":
    X, Y = map(int, input().split())
    solve()

Solution (Python):
x,y=map(int,input().split())

cnt = 0

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

print (cnt)

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