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 re
import math
from collections import defaultdict
from collections import deque
import itertools
from copy import deepcopy
import random
import time
import os
import queue
import sys
import datetime
from functools import lru_cache

readline=sys.stdin.readline
sys.setrecursionlimit(2000000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_pow(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod_>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:return num
def get_primes(n,type="int"):
    if n==0:
        if type=="int":return []
        else:return [False]
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=1):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=""):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)
    return ret
def seifu(x):
    return x//abs(x)

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

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))

def resolve():
    X,Y=pin()
    for i in range(10**7):
        if X>Y:print(i);return
        else:X*=2

resolve()

Solution (Python):
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
X,Y = LI()
ans = 1
while 1:
    X *= 2
    if X>Y:
        break
    ans += 1
print(ans)

Solution (Python):
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
X,Y = LI()
ans = 1
while 2*X<=Y:
    X *= 2
    ans += 1
print(ans)

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

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

print(ans)

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

last = x
count = 0
while last <= y:
    last *= 2
    count += 1

print(count)

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

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

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

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

main()

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

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

left = 0
right = 10**5
maxi = y//x
while left+1 < right:
    mid = (left+right)//2
    now = 2**mid
    if now > maxi:
        right = mid
    else:
        left = mid

print(left+1)

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

while x<=y:
    ans.append(x)
    x*=2

print(len(ans))

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

Solution (Python):
X,Y=map(int,input().split())
for i in range(1,1000):
	if X*(2**i)>Y:
		print(i)
		exit()

Solution (Python):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right


from functools import reduce
from pprint import pprint

INF = float("inf")

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def mycount(ls,x):
    
    l = bisect_left(ls,x)
    r = bisect_right(ls,x)
    return (r-l)

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

from math import ceil,floor,log
x,y = myinput()

M = ceil( log(y/x,2) ) + 1

count = 0
for i in range(M):
    if x*(2**i)<=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())
i = 2
cnt = 0
while 1:
    if x > y:
        break
    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())
ans = 1
while x*2 <= y:
    ans += 1
    x *= 2
print(ans)

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

for i in range(1,10**18):
  x<<=1
  if x>y:
    print(i)
    break

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

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

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

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

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

print(res)

Solution (Python):
from statistics import median


from fractions import gcd
from itertools import combinations 
from collections import deque
from collections import defaultdict
import bisect










import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

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

def main():
    x,y = readInts()
    cnt = 0
    while x <= y:
        cnt += 1
        x *= 2
    print(cnt)
if __name__ == '__main__':
  main()

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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

    
resolve()

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

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7


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

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

tmp = X
ans = [X]
for i in range(int(1e5)):
    tmp *= 2
    if tmp > Y:
        break
    ans.append(tmp)

print(len(ans))

Solution (Python):
def main():
    x, y = (int(i) for i in input().split())
    A = [x]
    while A[-1]*2 <= y:
        A.append(A[-1]*2)
    print(len(A))


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

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

Solution (Python):

import sys

import fractions
import copy
import bisect
import math
import numpy as np
import itertools
from itertools import combinations_with_replacement


from operator import itemgetter
from sys import stdin

from operator import mul
from functools import reduce
from collections import Counter





j=0
k=0
n=3
r=1
a=[0]






"1行1つの整数を入力を取得し、整数と取得する"




"12 21 332 とか入力する時に使う"
"1行に複数の整数の入力を取得し、整数として扱う"

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

for i in number_list:
    print(number_list[i-1])

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

'''
x=[]
y=[]
for i in range(N):
    x1, y1=[int(i) for i in input().split()]
    x.append(x1)
    y.append(y1)
print(x)
print(y)
"複数行に2数値を入力する形式 x座標とy座標を入力するイメージ"
'''

'''
mixlist=[]
for i in range(N):
    a,b=input().split()
    mixlist.append((int(a),b))
print(mixlist)
"複数行にintとstrを複合して入力するやつ，今回はリスト一つで処理している"
'''

'''



"正方行列にstr型の値を入力"
'''




'''
入力
1 2
4 5
7 8
出力結果
[[1, 2], [4, 5], [7, 8]]
'''
"列数に関して自由度の高いint型の値を入力するタイプの行列"


'''
table = [[int(i) for i in input().split()] for m in range(m)]

print(type(N))
print(N)
print(type(M))
print(M)

print(type(table))
print(table)
'''











'''
入力
1234
出力
1
[[1, 2, 3, 4]]
'''




'''
word_list= input().split(" ")
print(word_list[0])
"連続文字列の入力"
"qw er ty とかの入力に使う"
"入力すると空白で区切ったところでlistの番号が与えられる"
'''



'''
A, B, C=stdin.readline().rstrip().split()
print(A)
"リストではなく独立したstr型を入れるなら以下のやり方でOK"
'''




"aという変数に入っているものを大文字にして出力"

















'''
コンビネーションの組み合わせの中身を出力する形式
for i in itertools.combinations(brray, 2)
combinationsをpermutationsにすれば順列になる
今回なら(abc133B)
入力
1 2
5 5
-2 8
出力
[[1, 2], [5, 5], [-2, 8]]
もちろん一次元リストでも使えるし
何よりiもリストのように使えるので便利
'''


'''
def cmb(n,r):
    
    r= min(n-r,r)
    
    if r == 0: return 1
    over = reduce(mul, range(n, n-r, -1))
    
    
    

    under = reduce(mul, range(1, r+1))
    
    
    
    

    return over // under
    
    
    
    
a = cmb(n, r)

'''

'''
import itertools
from itertools import combinations_with_replacement

combinationについて
以下の違いを意識しよう
combinations() p, r 長さrのタプル列、ソートされた順で重複なし

combinations_with_replacement() p, r 長さrのタプル列、ソートされた順で重複あり


使用例 　　　　　　　　　　　                  出力　　
combinations('ABCD', 2)　　　　　　　　　　　　AB AC AD BC BD CD

combinations_with_replacement('ABCD', 2)　　 AA AB AC AD BB BC BD CC CD DD
'''



'''




for i in a.most_common(n):print(i)





 


'''









'''
bisect.bisect_left(a, x, lo=0, h=len(a))
引数
a: ソート済みリスト
x: 挿入したい値
lo: 探索範囲の下限
hi: 探索範囲の上限
(lo, hiはスライスと同様の指定方法)
bisect_leftはソートされたリストaに対して順序を保ったままxを挿入できる箇所を探索します。leftが示す通り、aにすでにxが存在している場合は、挿入箇所は既存のxよりも左側になります。また、lo, hiを指定することで探索範囲を絞り込むことも可能です。デフォルトはaの全体が探索対象です。
'''

'''
素数の判定
'''


def is_prime(n):
    if n == 1: return False

    for k in range(2, int(np.sqrt(n)) + 1):
        
        if n % k == 0:
            return False
            
    return True


'''
npのmaxとmaximumの違い
xs = np.array([1, -2, 3])
np.max(xs, 0)
この出力は3となります．[1, -2, 3]と0の4つの数字のうち，最も大きい値を出力します．

一方で，[max(1, 0), max(-2, 0), max(3, 0)]を出力したい時があります．
その時は，numpyのmaximum関数を用います．

xs = np.array([1, -2, 3])
np.maximum(xs, 0)  

'''
def yuu(n1, n2):
 x=max(n1,n2)
 y=min(n1,n2)
 while y==0:
    r=x%y

    x=y
    y=r
 return y










def main():

    w=1
    j=0
    k=0
    x1=0
    x2=0
    ans=[0]*1000000
    
    x,y=map(int, input().split(" "))
    
    
    

    ans[0]=x
    x1=2*ans[0]
    if x1 > y:
        ans=[i for i in ans if i > 0]
        print(len(ans))
        sys.exit()
    ans[1]=x1
    for i in range(100000):
        x2= 2*x1*x//(yuu(x1, x))
        
        if x2 >y:
            ans=[i for i in ans if i > 0]
            print(len(ans))
            sys.exit()
        ans[i+2]=x2
        x=x1
        x1=x2


    
    
    
    
    
    DP = np.zeros(w+1, dtype=int)
    exdp=np.zeros((3,4)) 
    
    
    
        
        
    
    
        
        
    


    "1行1つの整数を入力を取得し、整数と取得する"
    
    
    "12 21 332 とか入力する時に使う"
    "1行に複数の整数の入力を取得し、整数として扱う"
    
    


    
    
    
    '''
    入力
    1234
    出力
    [1, 2, 3, 4]
    '''
    pin_l=["x" for i in range(10)]
    

    ls = ["a", "b", "c", "d", "e"]


    
    

    
    

    
    
    
    
    
    '''
    lsというリストの場合に、1つ飛びの値を取得したい場合には
    ls[::2]
    のようにします。こうすると、
    ["a", "c", "d"]と出力される
    '''

if __name__ == "__main__":
    main()

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

Solution (Python):
x, y = list(map(int, input().split()))
cnt = 1
a = x
while(2*a<=y):
    a *= 2
    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 = 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):
import sys
import math

input = sys.stdin.readline
MOD = 1000000007

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


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

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

ans = 0

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

print(ans)

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

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

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

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

Solution (Python):
X, Y = map(int, input().split())
cnt = 0
while True:
    if X > Y:
        break
    X*=2
    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())
cnt = 0

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

print(cnt)

Solution (Python):
a,b= map(int,input().split())
c = b//a
ans = 0
for i in range(10000):
    if 2**i <= c < 2**(i+1) :
        ans += i
print(ans +1)

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

Solution (Python):



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


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


if __name__ == "__main__":
    main()

Solution (Python):
X, Y = map(int, input().split())
ans = 1
i = X
while i * 2 <= Y: 
  i *= 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())
print(len(bin(y//x))-2)

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

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

cnt = 0

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

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

cnt = 0
for i in range(bits):
  if x * (2 ** i) > y:
    break
  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())
now = X
count = 0
while now <= Y:
    now = now * 2
    count += 1
print(count)

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

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

print(ans)

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

Solution (Python):

def myAnswer(X:int,Y:int) -> int:
   if(X*2 > Y): return 1
   ans = X
   total = 1
   while True:
      ans *= 2
      if(ans > Y):
         break
      else:
         total += 1
   return total


def modelAnswer():
   tmp=1
def main():
   X, Y = map(int,input().split())
   print(myAnswer(X,Y))
if __name__ == '__main__':
   main()

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

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

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

Solution (Python):
import math
x,y = map(int, input().rstrip().split(' '))



for i in range(100):
  a = x*(2**i)
  if(a<=y):
    continue
  else:
    print(i)
    break

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())
num=x
ans=1
while num<=y:
  num=num*2
  if (num<=y):
    ans+=1
    
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):
x,y = map(int,input().split())
i =x
ans = []
while y >= i:
    i *= 2
    ans.append(i)
print(len(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 True:
    x *= 2
    if x > y:
        break
    ans += 1
print(ans)

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

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

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

A = X
ans = 1

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

print(ans)

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

A = X
ans = 1

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

print(ans)

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

if __name__ == "__main__":
  resolve()

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

X_tmp = X
for ans in range(1000000007):
    if X_tmp > Y: break
    X_tmp <<= 1

print(ans)

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

Solution (Python):
import sys

def solve():
    input = sys.stdin.readline
    X, Y = map(int, input().split())
    length = 0
    now = X
    while now <= Y:
        now *= 2
        length += 1
    print(length)

    return 0

if __name__ == "__main__":
    solve()

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

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

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

Solution (Python):
def solve():
    x,y = map(int,input().split())
    cnt = 0
    while x<=y:
        x*=2
        cnt+=1
    print(cnt)
if __name__=='__main__':
    solve()

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

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

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


if __name__ == "__main__":
    solve()

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 True:
    if x * 2 <= y:
        x *= 2
        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):
X, Y = map(int,input().split())

x = X
c = 0
while x <= Y:
    x <<= 1
    c += 1
print(c)

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

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

print(count)

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

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

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

print(ans)

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

x,y = iim()
cnt = 0
while x <= y:
    cnt += 1
    x *= 2
print(cnt)

Solution (Python):
X, Y = map(int, input().split())
l = -1
r = 100
while r - l > 1:
    m = l + (r - l) // 2
    if X * 2**m > Y:
        r = m
    else:
        l = m
print(r)

Solution (Python):
from math import log
x, y = map(int, input().split())
for i in range(64):
    x *= 2
    if x > y:
        print(i + 1)
        exit()

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

num = X
cnt = 0
for i in range(1000):
    if(num > Y):
        break
    num = num * 2
    cnt += 1
print(cnt)

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

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

Solution (Python):
x,y = map(int,input().split())
ans = 1
while 1:
  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):
a, b = map(int,input().split())

cnt = 0
num = a
while num<=b:
  cnt += 1
  num *= 2
  
print(cnt)

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

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

ai = x
ai1 = 0
res = 0
while ai1 <= y:
    ai1 = ai * 2
    if ai1 % ai == 0:
        res += 1
    ai = ai1

print(res)

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

num=y//x
cnt=0
while num>=2:
    cnt+=1
    num//=2
print(cnt+1)

Solution (Python):
import sys

def solve():
    input = sys.stdin.readline
    X, Y = map(int, input().split())
    Ans = 0
    d = 1
    while X * d <= Y:
        d *= 2
        Ans += 1
    print(Ans)

    return 0

if __name__ == "__main__":
    solve()

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

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

Solution (Python):
def resolve():

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


resolve()

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

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

ans = 0

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


print(ans)

Solution (Python):
if __name__ == "__main__":
    x, y = map(int, input().split())

    ans = 0
    tmp = x

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

    print(ans)

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

Solution (Python):
def main():
    X, Y = (int(i) for i in 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())
A = []
while (x <= y):
    A.append(x)
    x *= 2
print(len(A))

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

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

if x > y:
    ans -= 1

print(ans)

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

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
num = X
while num <= Y:
    ans += 1
    num *= 2

print(ans)

Solution (Python):
def solve():
    a,y = map(int,input().split())
    ans = 1
    while(a<=y):
        a*=2
        ans+=1
    print(ans-1)
if __name__ == "__main__":
    solve()

Solution (Python):
import sys
import os

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    X, Y = il()
    ret = 0
    while True:
        X *= 2
        ret += 1
        if X > Y: break

    print(ret)


if __name__ == '__main__':
    main()

Solution (Python):
import math
x,y=map(int,input().split())
f=0
for i in range(100):
    if x*2**i==y:
        f=1
print(math.ceil(math.log2(y)-math.log2(x))+f)

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

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())
t=x
ans=0
while t<=y:
    t*=2 
    ans+=1
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):
X, Y = [int(i) for i in input().split()]
N = X
c = 1
while N<=Y:
    
    N *= 2
    if N<=Y:
        c += 1
print(c)

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


resolve()

Solution (Python):
from sys import stdin
def main():
    readline=stdin.readline
    X,Y=map(int,readline().split())
    a=X
    res=1
    while a*2<=Y:
        a*=2
        res+=1
    print(res)
if __name__=="__main__":
    main()

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


if __name__ == '__main__':
    main()

Solution (Python):

dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]

x, y = map(int,input().split())
ans = [x]
while ans[-1] < y:
    ans.append(ans[-1] * 2)
    
if ans[-1] > y:
    print(len(ans) - 1)
else:
    print(len(ans))

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

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

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

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

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

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

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

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