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

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

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


def sol(x,y):
    count = 1
    start = x
    while True:
        start += start
        if start >y:
            break
        count +=1
    print(count)

sol(X,Y)

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

Solution (Python):
from collections import deque
X, Y = map(int, input().split())
que = deque()
que.append(X)
ans = 1

while que:
  x = que.popleft()
  nx = x * 2
  if nx <= Y:
    que.append(nx)
    ans += 1

print(ans)

Solution (Python):
from collections import defaultdict

def main():
    X,Y = [int(x) for x in 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())

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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
def main():
    x, y = map(int, input().split())
    y_devided = y // x
    y_devided_binary = format(y_devided, "b")
    print(len(y_devided_binary))

if __name__ == "__main__":
    main()

Solution (Python):
x,y=[int(x) for x in input().rstrip().split()]
ans=1
now=x
for i in range(x,y-1):
  if now*2<=y:
    now=now*2
    ans+=1
  else:
    break
print(ans)

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

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

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












     
def main():
    a,b = map(int, input().split())
    ans = 0
    while a <=b:
        ans+=1
        a*=2
    print(ans)
        
if __name__ == '__main__':
    main()

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

while X <= Y:
    X += X
    cnt += 1

print(cnt)

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

for i in range(10**19):
  ans = ans*2
  if ans <= y:
    count += 1
  else:
    break
    
print(count)

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

print(ans)

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

c=x
a=[]
while c <= y:
    a.append(c)
    c *=2
    
print(len(a))

Solution (Python):



def main():
    X, Y = map(int, input().split())
    ret = 1
    tmp = X
    while Y>=tmp:
        if tmp*2>Y:
            break
        else:
            tmp = tmp * 2
            ret += 1

    print(ret)

if __name__ == '__main__':
    main()

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

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

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

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

z = x * 2
count = 1
while z <= y:
    count += 1
    z = z * 2

print(count)

Solution (Python):
def main():
    X, Y = map(int, input().split())
    ans = 1
    for _ in range(Y + 1):
        if 2 * X <= Y:
            X *= 2
            ans += 1
        else:
            print(ans)
            quit()


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
from collections import deque, Counter, defaultdict
from itertools import permutations
import heapq


def resolve():
    X, Y = map(int, sys.stdin.readline().strip().split())
    ans = 0
    while X <= Y:
        ans += 1
        X <<= 1

    print(ans)


if __name__ == "__main__":
    resolve()

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]


def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()


def DD(arg): return defaultdict(arg)



def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


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 make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


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


def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count


def base_10_to_n(X, n):
  if X//n:
    return base_10_to_n(X//n, n)+[X%n]
  return [X%n]

def base_n_to_10(X, n):
  return sum(int(str(X)[-i])*n**i for i in range(len(str(X))))


def int_log(n, a):
  count = 0
  while n>=a:
    n //= a
    count += 1
  return count





X,Y = IL()
P(int_log(Y//X,2)+1)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print(ans)

Solution (Python):
def func(x, y, count):
  new_x = x * 2
  if new_x > y:
    return count
  else:
    new_count = count + 1
    return func(new_x, y, new_count)
    
x, y = [int(i) for i in input().split()]

print(func(x, y, 1))

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

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

print(i)

Solution (Python):
x,y=map(int,input().split())
ans=[x]
tmp=x
while tmp<y:
    if tmp*2<=y:
        ans.append(tmp)
        tmp=tmp*2
    else:
        break
print(len(ans))

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

print(t)

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

count = 0

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

print(count)

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

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())
div = y // x
i = 0
while div >= pow(2, i):
    i += 1
print(i)

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

print(cnt)

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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

if __name__ == '__main__':
    main()

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

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

print(count)

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

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

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


for i in range(61):
    if y < x * 2**i:
        print(i)
        exit()

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


for i in range(61):
    if y < x * 2**i:
        print(i)
        exit()

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

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

Solution (Python):
A,B = list(map(int,input().split()))
ans = 1
for i in range(10**18):
    if A * 2 <= B:
        A *= 2
        ans +=1
    else:
        print(ans)
        exit()

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

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

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

Solution (Python):

import sys


input = sys.stdin.readline
def IS(cb): return cb(input().strip())
def IL(cb): return [cb(s) for s in input().strip().split()]
def IR(cb, rows): return [IS(cb) for _ in range(rows)]
def ILL(cb, rows): return [IL(cb) for _ in range(rows)]


def solve():
    X, Y = IL(int)
    ans = 1
    while Y // 2 >= X:
        ans += 1
        Y //= 2
    print(ans)

solve()

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

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

n = x
ans = 0

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

print(ans)

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

Solution (Python):
X,Y=[int(x) for x in input().rstrip().split()]
ans=[]
cnt=1
now=X
for i in range(1,Y+1):
    now=now*2
    if now<=Y:
        cnt+=1

    else:
        break
print(cnt)

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

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

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

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

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

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

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:
    if X*(2**ans)<=Y:
        ans+=1
    else:
        break
print(ans)

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

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

Solution (Python):
import fractions


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

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

if y < 2*x: 
    print(1)
    exit()

li = [x, 2*x]
i = 0

while True:
    x = lcm(li[i], li[i+1])*2
    if x <= y:
        li.append(x)
        i += 1
    else:
        print(len(li))
        exit()

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())
count = 1
while True:
    X *= 2
    if X <= Y:
        count += 1
    else:
        break
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()))

count = 1

a = x
while a*2 <= y:
    a *= 2
    count += 1

print(count)

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

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

print(cnt)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
from decimal import Decimal, ROUND_DOWN
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X, Y = MAP()

print(1+((Decimal(str(Y))/Decimal(str(X))).log10()/Decimal("2").log10()).quantize(Decimal('0'), rounding=ROUND_DOWN))

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    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 main():
    x,y = map(int,input().strip().split())
    i=1
    while True:
        x*=2
        if x<=y:
            i+=1
        else:
            break
    print(i)
    

if __name__ == '__main__':
    main()

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop

import collections

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X, Y = MAP()

cnt = 1
A = X

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

print(cnt-1)

Solution (Python):

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

Solution (Python):
inf = 10**15
mod = 10**9+7
def getans(x,y):
    count=1
    while 2*x <= y:
        x *= 2
        count+=1
    return count

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

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

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

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

Solution (Python):

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

Solution (Python):
import sys

def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))

INIT_VAL = 0
def DD2(d1,d2): return [[INIT_VAL]*d2 for _ in range(d1)]
def DD3(d1,d2,d3): return [DD2(d2,d3) for _ in range(d1)]

MOD=10**9+7
def divc(x,y): return -(-x//y)
def divf(x,y): return x//y
def gcd(x,y):
    while y: x,y = y,x%y
    return x
def lcm(x,y): return x*y//gcd(x,y)
def get_primes(MAX_NUM=10**3):
    """Return a list of prime numbers"""
    is_prime = [True] * MAX_NUM
    is_prime[0] = False
    is_prime[1] = False
    primes = []
    for i in range(MAX_NUM):
        if is_prime[i]:
            primes.append(i)
            for j in range(2*i, MAX_NUM, i):
                is_prime[j] = False
    return primes

from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left



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

if __name__ == '__main__':
    main()

Solution (Python):
MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)

def main():
    X,Y = map(int,input().split())
    ans = 0
    power = 1
    while power*X <= Y:
        ans += 1
        power *= 2
    print(ans)
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())
c = 1
for i in range(1000000000):
    x *= 2
    if (x<=y):
        c += 1
    else:
        break
    
print(c)

Solution (Python):
import sys

x,y=map(int,input().split())
output=0
while True:
	if x * (2**output) >y :
		print(output)
		sys.exit()
	else:
		output+=1

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

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

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

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

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

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


print(cnt)

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

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

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

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

    d = y // x

    i = 0
    while 2 ** i <= d:
        i += 1

    print(i)

resolve()

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

ans = len(format(y//x,'b'))
print(ans)

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

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

Solution (Python):
import math

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

ans = []
for i in range(0, int(math.log2(10**18))+1):
    Z = X*pow(2, i)
    if Z<=Y:
        ans.append(Z)

print(len(ans))

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

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

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

print(len(A)-1)

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


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


print(ans)

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

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

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

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

Solution (Python):
nim,mike = map(int,input().split())
array = []

while nim<=mike:
  array.append(nim)
  nim*=2

print(len(array))

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


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

    ans = 0
    c = x

    while c <= y:
        ans += 1
        c <<= 1

    print(ans)


if __name__ == '__main__':
    main()

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


for i in range(100):
    if X * 2**i > Y:
        print(i)
        exit()

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

s=1

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

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

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

print(ans)

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

if __name__ == "__main__":
    main()

Solution (Python):
def main():
    X, Y = map(int, input().split())
    cnt = 1
    for i in range(Y):
        X = 2*X
        if X <= Y:
            cnt += 1
        else:
            break
    print(cnt)
if __name__ == "__main__":
    main()

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

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

print(ans)

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

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

print(count)

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

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

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

Solution (Python):
def resolve():
    X, Y = list(map(int, input().split(" ")))
    A = [X]
    while Y >= A[-1]*2:
        A.append(A[-1]*2)
    print(len(A))



if '__main__' == __name__:
    resolve()

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

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

print(ans-1)

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

number = X
ans = 0

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

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

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

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

Solution (Python):
import sys

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

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

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

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

print(res)

Solution (Python):
if __name__ == '__main__':
    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 = [x]
while True:
  a = 2 * A[-1]
  if a > y:
    break
  A.append(a)
print(len(A))

Solution (Python):
from sys import stdin

[X, Y] = [int(x) for x in stdin.readline().rstrip().split()]

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

print(index)

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

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

print(ans)

Solution (Python):


def readInts():
  return list(map(int,input().split()))
mod = 10**9 + 7
def main():
    x,y = readInts()
    now = x
    cnt = 0
    while now <= y:
        now *= 2
        cnt += 1
    print(cnt)



if __name__ == '__main__':
  main()

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

Solution (Python):
import sys
from io import StringIO
import unittest







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

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

    print(count)



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)

if __name__ == "__main__":
    
    resolve()

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

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

Solution (Python):



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



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


print(max_length)

Solution (Python):
from collections import deque
from copy import copy,deepcopy
from itertools import permutations,combinations
from pprint import pprint

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

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

def mysort(data,col):
    data.sort(key=lambda x:x[col],reverse=False)
    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

x,y = myinput()

ans = []
na = copy(x)

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


print(len(ans))

Solution (Python):
X,Y=list(map(int, input().split()))
present=[X]
i=0
while present[i]<=Y:
    present.append(present[i]*2)
    i=i+1

print(len(present)-1)

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

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

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

Solution (Python):






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

    ans = 0
    x = X
    while True:
        if x > Y:
            return ans

        ans += 1
        x *= 2


print(main())