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):
import sys
sys.setrecursionlimit(4100000)

import logging



logger = logging.getLogger(__name__)

import math


def resolve():
    X, Y = [int(x) for x in sys.stdin.readline().split()]

    logger.debug('{} {}'.format(X, Y))

    count = 1
    while (True):
        X = X * 2
        if X > Y:
            break
        else:
            count += 1

    print(count)


if __name__ == "__main__":
    resolve()





import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """3 20"""
        output = """3"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """25 100"""
        output = """3"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """314159265 358979323846264338"""
        output = """31"""
        self.assertIO(input, output)

    def test_入力例_4(self):
        input = """1 2"""
        output = """2"""
        self.assertIO(input, output)

    def test_入力例_5(self):
        input = """3 3"""
        output = """1"""
        self.assertIO(input, output)

    def test_入力例_6(self):
        input = """999999999999999999 1000000000000000000"""
        output = """1"""
        self.assertIO(input, output)

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

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

Solution (Python):



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

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

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

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

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

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

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

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

Solution (Python):



X, Y = map(int, input().split())
num = pow(10,18)

for i in range(1, num):
    X = X * 2
    if X > Y:
        print(i)
        exit()

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

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

print(ans)

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

Solution (Python):
if __name__ == '__main__':
    X, Y = map(int,input().split())

    Ai = X

    answer = 1
    while Ai * 2 <= Y:
       if Ai * 2 <= Y:
           Ai = Ai * 2
           answer += 1
    print(answer)

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

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

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

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

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

Solution (Python):

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


if __name__ == "__main__":
    main()

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

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

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

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())
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*2<=y:
    ans+=1
    tmp*=2
print(ans)

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

k = X

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

print(ans)

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

Solution (Python):

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

Solution (Python):
import sys

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    [X, Y] = string_to_int(inputs[0])
    count = 0
    num = X
    while num <= Y:
        num *= 2
        count += 1
    return str(count)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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

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

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):
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())
cnt = 0
A = X
while A <= Y:
    A = A * 2
    cnt += 1
print(cnt)

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())

res = 0

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

print(res)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from heapq import heappop, heappush, heapify, heappushpop
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

X, Y = MAP()
i = 0
while 1:
	tmp = X*2**(i-1)
	if tmp > Y:
		break
	i += 1
print(i-1)

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

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

print(cnt)

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

Solution (Python):

"""
Created on Mon Jun 24 21:42:42 2019

@author: Owner
"""


X, Y = list(map(int, input().split()))
cnt = 0
for n in range(Y):
    if X*2**n ==Y:
        cnt = n +1
        break
    elif X*2**n >Y:
        cnt = n
        break
    else:
        pass

print(cnt)

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

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:
    x *= 2
    ans += 1
print(ans)

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

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

Solution (Python):

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

  i = 1
  n = x
  while(True):
    n *= 2
    if n > y:
      print(i)
      return

    i += 1

main()

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

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

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

Solution (Python):

import sys


def solve(X: int, Y: int):
    res = 0
    i = X
    while i <= Y:
        res += 1
        i *= 2
    print(res)

    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    solve(X, Y)

if __name__ == '__main__':
    main()

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

sys.setrecursionlimit(2000)

def solve(x,y,i):
    if x>y:
        return print(i-1)
    else:
        x *=2
        i +=1
        return solve(x,y,i)

solve(x,y,1)

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

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

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())
count = 0
while x <= y:
    count += 1
    x *= 2
print(count)

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

ans = 0
while 1:
    if X > Y:
        break
    ans += 1
    X *= 2

print(ans)

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

ans = 0
tgt = X

while tgt <= Y:
    tgt *= 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):



if __name__ == '__main__':
    length = 1
    X, Y = map(int, input().split())
    twice = 2 * X
    while True:
        if Y < twice:
            break
        twice *= 2
        length += 1
    print(length)

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

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

Solution (Python):

import sys


def solve(X: int, Y: int):
    ans = []

    cur = X
    while cur <= Y:
        ans.append(cur)
        cur *= 2

    print(len(ans))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    solve(X, Y)

if __name__ == '__main__':
    main()

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

Solution (Python):

def solve(X, Y):
    
    a = X
    c = 1
    while True:
        a *= 2
        if a > Y:
            break
        c+=1
    return c

X, Y = [int(x) for x in input().split()]

print(solve(X, Y))

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7

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

def main():
  a,b=LI()

  c=1
  while True:
    a*=2
    if a>b:
      break
    else:
      c+=1

  return c

print(main())

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

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


print(ans)

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

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


print(ans)

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

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

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

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

Solution (Python):
n, m = map(int, input().split())
l=[]

def dfs(a):
	if a > m: return
	l.append(a)
	dfs(a*2)
	return

dfs(n)
print(len(l))

Solution (Python):
n, m = map(int, input().split())
l=[]

def dfs(a):
	if a > m:
		return
	l.append(a)
	dfs(a*2)
	return

dfs(n)
print(len(l))

Solution (Python):
import math

def main():
    a, b = map(int, input().split())
    data = b // a
    ans = 0
    while data >= 1:
        ans += 1
        data //= 2
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
X, Y = map(int, input().split())
A = []
tmp = X
while tmp <= Y:
	A.append(tmp)
	tmp *= 2
print(len(A))

Solution (Python):

import sys


def solve(X: int, Y: int):
    ret = 1
    while X <= Y:
        X *= 2
        ret += 1
    ret -= 1
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  
    solve(X, Y)

if __name__ == '__main__':
    main()

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

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

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

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


def log2(x, y):
    temp = 0
    while y >= 2 * x:
        temp += 1
        x *= 2
    return temp


print(int(log2(x, y))+1)

Solution (Python):











import sys
input=sys.stdin.readline
inf=float('inf')
mod = 10**9+7
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [input() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    X, Y = MI()
    ans = 0
    while X<=Y:
        X*=2
        ans += 1
    print(ans)
if __name__ == '__main__':
    main()

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

print(cnt)

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

arr = [X]

while arr[-1]*2 <= Y:
  arr.append(arr[-1]*2)

print(len(arr))

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

Solution (Python):
x,y = map(int,input().split())
result = []
while x<=y:
    result.append(x)
    x=x*2
print(len(result))

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())
i = 1
while True:
    if X * pow(2, i) > Y:
        print(i)
        break
    i += 1

Solution (Python):

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

for i in range(y):
	x = x * 2
	if x > y:
		print(i+1)
		break

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

Solution (Python):

import sys
import math
INF = float("inf")


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


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    Y = int(next(tokens))  

    solve(X, Y)


if __name__ == '__main__':
    main()

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

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

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

print(c)

Solution (Python):
from functools import reduce
import math
import fractions

def lcm(a,b):
    return (a*b)/fractions.gcd(a,b)

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    X,Y = (int(_) for _ in input().split())
    ans = 0
    tmp = X
    while tmp<=Y:
        ans +=1
        tmp *= 2
    print(ans)
    
if __name__ == '__main__':
    main()

Solution (Python):

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

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

Solution (Python):
a=list(map(int,input().split()))
ans=1

kitei=a[0]
while kitei<=a[1]:
  kitei*=2
  ans+=1
print(ans-1)

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

print(ans)

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

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

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

print(cnt)

Solution (Python):
import numpy as np

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

ans = 1
var = X
while True:
  X *= 2
  if X <= Y:
    ans += 1
  else:
    break

print(ans)


"""





def power2_smaller(num):
    return len(str(bin(num))[2:])-1

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

ans = power2_smaller(int(Y/X)) + 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())
print(len(bin(y//x))-2)

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

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

count = 0
n = Y
while True:
    if X<= n <=Y:
        count += 1
        n = n//2
    else:
        break

print(count)

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

Solution (Python):










from math import log2
X, Y = list(map(int, input().split()))


print(len(bin(Y // X))-2)

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

x = X
c = 0
while x <= Y:
	x *= 2
	c += 1

print(c)

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

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):
def main():
    X, Y = map(int, input().split())
    ans = 0
    while Y >= X:
        X *= 2
        ans += 1
    print(ans)


main()

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

num = X
counter = 0

if num == 1:
    counter += 1
    num += 1

for i in range (1, Y):
    if num > Y:
        break

    else:
        counter += 1
        num *= 2

print(counter)

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 = 0
while x<=y:
    x *= 2
    ans += 1
print(ans)

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

max_int = Y // X

i = 1
while max_int >= 2**i:
    i += 1
print(i)

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())

a = Y//X
i = 0
b = 2 ** i
while b <= a:
    b *= 2
    i += 1
print (i)

Solution (Python):

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


def submit():
    x, y = read_input()

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


if __name__ == '__main__':
    submit()

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

Solution (Python):
X, Y = map(int, input().split())
A_list = []
A_list.append(X)
A = X
while A <= Y:
    A = A*2
    A_list.append(A)
print(len(A_list)-1)

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

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

print(count)

Solution (Python):
import math
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):
x,y=list(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:
    X *= 2
    ans += 1
print(ans)

Solution (Python):
X, Y = map(int, input().split())
A = []
while X <= Y:
  A.append(X)
  X *= 2

print(len(A))

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

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

Solution (Python):
min, max = map(int, input().split(" "))
answer = 0
while True:
    answer += 1
    temp = min * (2 ** answer)
    if temp > max:
        break
print(answer)

Solution (Python):
x,y=map(int,input().split())
ans=1
now=x
while True:
    if now*2>y:
        break
    else:
        now*=2
        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 True:
    if X*2**ans > Y:
        break
    ans += 1

print(ans)

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

ans = 1
for i in range(100):
    if x * 2 <= y:
        ans += 1
        x *= 2
    else:
        break
print(ans)

Solution (Python):
x,y=map(int,input().split())
lst=[]
ans=0
while True:
    if x<=y:
        ans+=1
        x=2*x
    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):
x,y=map(int,input().split());print(len(bin(y//x))-2)

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

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

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

ans = 0

s = x

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

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())

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

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, raw_input().split())
cnt = 0
now = X
while True:
	if now > Y: break
	else:
		cnt += 1
		now = now * 2
print cnt

Solution (Python):


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

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

print(cnt)

Solution (Python):
X,Y = (int(_) for _ in input().split())



cnt = 1 
progression_num = X

while progression_num <= Y:
    progression_num *= 2
    if progression_num > Y:
        break
    cnt += 1

print(cnt)

Solution (Python):


import sys
import math
input = sys.stdin.readline

def io_generator():
	return input()



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



if __name__ == "__main__":
	io= lambda : io_generator()
	print (main(io))

Solution (Python):
import math

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

num = 1

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

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

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

if x == y:
    print(1)
    exit()

for i in range(62):
    if x * 2 ** (i - 1) > y:
        print(i - 1)
        exit()

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

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

Solution (Python):
X,Y=map(int,input().split())
count=0
c=1
while c<=Y//X:
    if c>Y//X:
        break
    c*=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 = [int(item) for item in 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):
    x *= 2
    ans += 1
print(ans)

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

count = 0
i =0

while True:
    tmp = X * 2 ** i
    if tmp < Y:
        pass
    elif tmp == Y:
        count +=1
        break
    else:
        break
    i+=1
    count +=1
print(count)

Solution (Python):
x, y = list(map(int, input().split()))
count = 0
while x <= y:
    x = x * 2
    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 = (int(x) for x in input().split())

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

Solution (Python):
a, b = map(int, input().split())  

ans = 0
while a <= b:
    a *= 2
    ans += 1

print(ans)

Solution (Python):
N, X = map(int, input().split())
ans = 0
while X >= N:
    N = N * 2
    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):
two_multiple=[]
for i in range(60):
  two_multiple.append(2**i)
x,y=map(int,input().split())
for i in range(59,-1,-1):
  if x*two_multiple[i]<=y:
    print(i+1)
    exit()

Solution (Python):


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

under = x
up = 0
ans = 0

for i in range(90):
    temp = x * 2 ** i
    if temp > y and up == 0:
        up = temp / 2
        ans = i
        break

print(ans)

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

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

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

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

Solution (Python):
import math

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


for i in range(61):
    if x*(1<<i)>y:
        print(i)
        exit(0)

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

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

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

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 = 0
while x<=y:
    x = x<<1
    ans+=1
print(ans)

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

i = 0

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

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

Solution (Python):
""" AtCoder """

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

ans = 0

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

print(ans)

Solution (Python):
def solve(string):
    x, y = map(int, string.split())
    ans = 0
    while x <= y:
        x *= 2
        ans += 1
    return str(ans)


if __name__ == '__main__':
    print(solve(input()))

Solution (Python):
def solve(string):
    x, y = map(int, string.split())
    ans = 0
    while x <= y:
        x *= 2
        ans += 1
    return str(ans)


if __name__ == '__main__':
    print(solve(input()))

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

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

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

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

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

cnt = 0
inf = 10 ** 18
for i in range(inf):
  num = X * (2 ** i)
  if num <= Y:
    cnt +=1
  else:
    break

print(cnt)

Solution (Python):
x,y = map(int,input().split())
num = []
k = x
while k <= y:
    num.append(k)
    k *= 2
print(len(num))

Solution (Python):
import sys
sys.setrecursionlimit(1000000)
from operator import itemgetter

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

cnt = 1
temp = X

for i in range(100):
    if temp * 2 <= Y:
        cnt += 1
        temp = temp * 2
    else:
        break

print(cnt)

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)


def read_int():
    return int(input())


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


def read_float():
    return float(input())


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


def read_str():
    return input().strip()


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


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(X, Y):
    ans = 0
    a = X
    while a <= Y:
        ans += 1
        a *= 2
    return ans


def main():
    X, Y = read_int_n()
    print(slv(X, Y))


if __name__ == '__main__':
    main()

Solution (Python):
X, Y = map(int, input().split())
for i in range(500):
    if X * (2 ** i) > Y:
        ans = i
        break
print(ans)

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

bin_str = format(Y//X, 'b')
print(len(bin_str))