Harryxun/stf_run huggingface dataset:
import numpy as np
n,w=map(int,input().split())
dp=np.zeros(w+1,dtype=np.int64)
for _ in range(n):
    we,v=map(int,input().split())
    if we > w:
        continue
    else:
        np.maximum(dp[we:],dp[:-we]+v,out = dp[we:])
print(dp[w])

### FIXED CODE ###

n,w=map(int,input().split())
wv=[list(map(int,input().split())) for _ in range(n)]
wv.sort()
cost=[[0]*(w+1) for _ in range(n+1)]
for i in range(1,n+1):
    for j in range(w+1):
        if wv[i-1][0] <= j:
            cost[i][j]=max(wv[i-1][1]+cost[i-1][j-wv[i-1][0]],cost[i-1][j])
        else:
            cost[i][j]=cost[i-1][j]
print(cost[n][w])
import math

r = int(input())
print(round(2*r*math.pi, 3)

### FIXED CODE ###

import math


r = int(input())
print(2*r*math.pi)
A, B, C = map(int, iinput().split())
if A <= C and B >= C:
    print("Yes")
else:
    print("No")
    

### FIXED CODE ###

A, B, C = map(int, input().split())
if A <= C and B >= C:
    print("Yes")
else:
    print("No")
l= list(map(int, input()))
l.sort()
print(l[2] - l[1])


### FIXED CODE ###

l= list(map(int, input().split()))
l.sort()
print(l[2] - l[0])
N,M=[int(x) for x in input().split()]
ans=[0]*N
for n in range(N):
  a,b=[int(x) for x in input().split()]
  ans[a-1]+=1
  ans[b-1]+=1
for a in ans:
  print(a)

### FIXED CODE ###

N,M=[int(x) for x in input().split()]
ans=[0]*N
for m in range(M):
  a,b=[int(x) for x in input().split()]
  ans[a-1]+=1
  ans[b-1]+=1
for a in ans:
  print(a)
def func(i, d, marks):
    rooms = numpy.nonzero(d[i])[0]
    new_room = []
    if rooms.size == 0:
        return marks
    for j in rooms:
        room_idx = j
        if room_idx in marks:
            continue
        marks[room_idx] = i
        new_room.append(room_idx)
    for j in new_room:
        marks = func(j, d, marks)
    return marks

def get_input():
    N, M =  list(map(int, input().split()))
    d = numpy.zeros((N,M))
    for i in range(M):
        a, b =  list(map(int, input().split()))
        d[a-1, b-1] = 1
        d[b-1, a-1] = 1
    return N, M, d

def write_result(marks, N):
    flag = True
    output_str = ''
    for i in range(1, N):
        if i not in marks:
            flag = False
            break
        output_str += f'{marks[i]+1}\n'
    if flag:
        print('Yes')    
        print(output_str)
    else:
        print('No')

import numpy


N, M, d = get_input()

marks = {0:0}
try:
    marks = func(0, d, {0: 0})
    write_result(marks, N)
except:
    pass



### FIXED CODE ###


def get_input():
    N, M =  list(map(int, input().split()))
    routes = {}
    for i in range(M):
        a, b =  list(map(int, input().split()))
        a_idx = a - 1
        b_idx = b - 1
        if a_idx in routes:
            routes[a_idx].append(b_idx)
        else:
            routes[a_idx] = [b_idx]
        
        if b_idx in routes:
            routes[b_idx].append(a_idx)
        else:
            routes[b_idx] = [a_idx]

    return N, M, routes

def write_result(marks, N):
    flag = True
    output_str = ''
    for i in range(1, N):
        if i not in marks:
            flag = False
            break
        output_str += f'{marks[i]+1}\n'
    if flag:
        print('Yes')    
        print(output_str)
    else:
        print('No')

import numpy


marks = {0:0}

N, M, routes = get_input()
mark = {0:0}
start_nodes = [0]
while start_nodes:
    next_nodes = []
    for i in start_nodes:
        for n in routes[i]:
            if n in marks:
                continue
            marks[n] = i
            next_nodes.append(n)
    start_nodes = next_nodes   
write_result(marks, N)
a,b,c=map(int,input(),.split())
n=[a,b,c]
d=[]
for i in range(1,len(n)):
  d.append(n[i]+n[i])
print(min(d))

### FIXED CODE ###

a,b,c=map(int,input().split())
n=sorted([a,b,c])
print(n[0]+n[1])
import sys
import copy
import numpy as np
sys.setrecursionlimit(2147483647)
input = sys.stdin.readline

if __name__ == '__main__':
#  cnt=0
  def dfs(C,t,hw,i):
    global k
    global h
    global w
    #print(t,k)
    #print(C)
    if t==k:
      return 1
    elif t<k:
      return 0
    if hw=='w' and i==w:
      return 0
    C1=copy.copy(C)
    C2=copy.copy(C)
    if hw=='h':
      #print(i,C1,np.zeros((1,w)))
      C1[i]=np.zeros((1,w))
      #print(C1)
      #exit(0)
      hw='w' if i==h-1 else 'h'
      i=0 if hw=='w' else i+1
      return dfs(C1,np.sum(C1),hw,i)+dfs(C2,np.sum(C2),hw,i)
    else:
      #print(C1)
      #C1[:][i]=np.zeros((h,1))
      for j in range(h):
        #tmp=C1[j]
        C1[j][i]=0
      #print(C1)
      #exit(0)
      i+=1
      return dfs(C1,np.sum(C1),hw,i)+dfs(C2,np.sum(C2),hw,i)

#  C=[[0 for _ in range(6)] for _ in range(6)]
  h,w,k=map(int,input().strip("\n").split())
  C=np.zeros((h,w))
  #print(C)
  for i in range(h):
    s=[1 if c=='#' else 0 for c in input().strip("\n")]
    #print(s)
    C[i]=np.array(s)
  #sprint(np.sum(C))
  print(dfs(copy.copy(C),np.sum(C),'h',0))


### FIXED CODE ###

import sys
input = sys.stdin.readline

if __name__ == '__main__':
  h,w,k=map(int,input().strip("\n").split())
  s=[]
  for i in range(h):
    s.append(list(input().strip("\n")))
  ans=0
  #print(s)
  # 2 -> 100 rangeだから11まで
  for iS in range(1<<h):
    # 3->1000=2^3=8
    for js in range(1<<w):
      #print(iS,js)
      cnt=0
      for i in range(h):
        for j in range(w):
          # 赤で塗る場合
          # ex)iS=01,i=0->i+1桁目が1か
          if iS>>i&1: continue
          if js>>j&1: continue
          if s[i][j]=='#': cnt+=1
      if cnt==k: ans+=1

  print(ans)
while(True):
    for i in input():
        x += int(i)
    print(x)


### FIXED CODE ###

while(True):
    num = input()
    if num == '0':
        break
    x = 0
    for i in num:
        x += int(i)
    print(x)
import numpy as np
N = input()
X = list(map(int,input().split()))

muf = np.floor(np.mean(X))
muc = np.ceil(np.mean(X))
ansf = 0
ansc = 0
for i in X:
    ansf += (muf-i)**2
    ansc += (muc-i)**2

print(min(int(ansf),int(ansc)))

### FIXED CODE ###

import math
N = int(input())
X = list(map(int,input().split()))

s = 0
for i in X:
    s += i
s = s/N

muf = math.floor(s)
muc = math.ceil(s)
ansf = 0
ansc = 0
for i in X:
    ansf += (muf-i)**2
    ansc += (muc-i)**2

print(min(int(ansf),int(ansc)))
import math
N = int(input())
print(int(2 * N /math.gcd(2, N)))

### FIXED CODE ###

N = int(input())
if(N % 2 == 0):
    print(N)
else:
    print(N * 2)
n = int(input())
p = [float(x) for x in input().strip().split()]
dp = {}
def solve(i,k):
    if i in dp and k in dp[i]:
        return dp[i][k]
    if k<=0:
        if i not in dp:
            dp[i] ={}
        dp[i][k] = 1
    elif k>n-i:
        if i not in dp:
            dp[i] ={}
        dp[i][k] = 0
    elif i>n-1:
        if i not in dp:
            dp[i] ={}
        dp[i][k] = 0
    else:
        if i not in dp:
            dp[i] ={}
        dp[i][k] = p[i]*solve(i+1,k-1)+(1-p[i])*solve(i+1,k)
    return dp[i][k]

print(solve(0,n//2+1))

### FIXED CODE ###

n = int(input())
p = [float(x) for x in input().strip().split()]
dp = [[None for i in range(n//2+2)] for j in range(n)]
for i in range(n):
    dp[i][0] =1

for j in range(n//2+2):
    dp[n-1][j] = 0
dp[n-1][0] = 1
dp[n-1][1] = p[n-1]

for i in range(n-2,-1,-1):
    for j in range(1,n//2+2):
        dp[i][j] = p[i]*dp[i+1][j-1]+(1-p[i])*dp[i+1][j]

print(dp[0][-1])

"""
Recursive top down

# def solve(i,k):
#     # print(i,k)
#     if i<=n-1 and k>0 and dp[i][k]:
#         return dp[i][k]
#     if k<=0:
#         # if i not in dp:
#         #     dp[i] ={}
#         # dp[i][k] = 1
#         return 1

#     elif i>n-1:
#         # if i not in dp:
#         #     dp[i] ={}
#         # dp[i][k] = 0
#         return 0
#     elif k>n-i:
#         # if i not in dp:
#         #     dp[i] ={}
#         dp[i][k] = 0

#     else:
#         # if i not in dp:
#         #     dp[i] ={}
#         dp[i][k] = p[i]*solve(i+1,k-1)+(1-p[i])*solve(i+1,k)
#     return dp[i][k]


# print(solve(0,n//2+1))


"""
import math

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

N,M = map(int, input().split())

if(N == 1 and M == 1):
	ans = 0
elif(N != 0 and M != 0): 
	ans = combinations_count(N, 2)
	ans += combinations_count(M, 2)
elif(N == 1 and M != 1):
  ans = combinations_count(M, 2)
elif(N != 1 and M == 1):
  ans = combinations_count(N, 2)
elif(N == 1 and M ==1 ):
  ans = 0
elif(N == 0 and M != 0):
  ans = combinations_count(M, 2)
elif(N != 0 and M == 0):
  ans = combinations_count(N, 2)
  
print(ans)


### FIXED CODE ###

N,M = map(int, input().split())

ansA = 0

if N < 2 and M < 2:
    ansA = 0
if N >=2:
    ansA += ((N * (N-1)) / 2)
if M >= 2:
    ansA += ((M * (M-1)) / 2)

print(int(ansA))
n = int(raw_input())
s = map(int, raw_input().split())
m = int(raw_input())
t = map(int, raw_input().split())

s = list(set(s))
s.sort()
a = [0 for in range(s[len(s)])]
for i in s:
    a[i] += 1

count = 0
for i in t:
    count += a[i] 
print count

### FIXED CODE ###

n = int(raw_input())
s = map(int, raw_input().split())
m = int(raw_input())
t = map(int, raw_input().split())

s = list(set(s))
s.sort()
l = len(s)-1

count = 0
for i in t:
    low = 0
    high = l
    while low <= high:
        mid = (low+high)/2
        if s[mid] == i:
            count += 1
            break
        if s[mid] < i:
            low = mid+1
        else:
            high = mid-1

print count
A, B, C = map(int, input().split())

print(C if A == B else B if A == C else A if B == C)

### FIXED CODE ###


A, B, C = map(int, input().split())

if A == B :
    print(C)
elif B == C :
    print(A)
elif C == A :
    print(B)
def swap(A, i, j):
    tmp  = A[i]
    A[i] = A[j]
    A[j] = tmp

def insertionSort(A, n, g):
    global cnt
    for i in range(g, n):
        v = A[i]
        j = i - g
        while j >= 0 and A[j] > v:
            A[j+g] = A[j]
            j = j - g
            cnt += 1
        A[j+g] = v
  
def shellSort(A, n):
    global cnt
    cnt = 0
    g = 1
    G = [g]
    while 3 * g + 1 < n:
        g = 3 * g + 1
        G.append(g)
    if G[-1] < n//2: G.append(n//2)
    m = len(G)
    G.reverse()
    print(m)
    print(' '.join(map(str, G)))
    for i in range(m):
        insertionSort(A, n, G[i])

n = int(input())
A = []
for i in range(n):
    a = int(input())
    A.append(a)

shellSort(A, n)
print(cnt)
for a in A:
    print(a)



### FIXED CODE ###

from sys import stdin

def insertionSort(A, n, g):
    global cnt
    for i in range(g, n):
        v = A[i]
        j = i - g
        while j >= 0 and A[j] > v:
            A[j+g] = A[j]
            j = j - g
            cnt += 1
        A[j+g] = v
  
def shellSort(A, n):
    global cnt
    cnt = 0
    g = 1
    G = [g]
    while 3 * g + 1 < n:
        g = 3 * g + 1
        G.append(g)
    m = len(G)
    G.reverse()
    print(m)
    print(' '.join(map(str, G)))
    for i in range(m):
        insertionSort(A, n, G[i])

n =  int(stdin.readline())
A = [int(stdin.readline()) for i in range(n)]

shellSort(A, n)
print(cnt)
for a in A:
    print(a)
from fractions import gcd

a,b = map(int,input().split())

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)

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

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

    return arr
if a == 1 or b == 1:
  print(1)
else:
  print(len(set(factorization(a)) & set(factorization(b))) + 1)

### FIXED CODE ###

from fractions import gcd

a,b = map(int,input().split())

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)

    if temp!=1:
        arr.append(temp)

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

    return arr
  
a = factorization(a)
b = factorization(b)
if (len(a)==1 and a[0] == 1) or (len(b)==1 and b[0] == 1):
  print(1)
else:
  print(len(set(a) & set(b)) + 1)
import sys
S = input()

if not ( len(S) == 3 and ( "A" in S or "B" in S)): sys.exit()

print('No') if S = 'AAA' or S = 'BBB' else print('Yes')

### FIXED CODE ###

import sys
S = input()

if not ( len(S) == 3 and ( "A" in S or "B" in S)): sys.exit()

print('No') if S == 'AAA' or S == 'BBB' else print('Yes')
# N < 10000
N = int(input())

# len(s) < 10

count = 0
a, b, ba = 0, 0, 0
for i in range(N):
    s = input().rstrip()
    i = 0
    while True:
        i = s.find("AB", i)
        if i < 0:
            break
        i += 2
        count+=1

    if s[-1] == 'A':
        if s[0] == 'B':
            ba += 1
        else:
            a += 1
    elif s[0] == 'B':
        b += 1

e = int(input())
#print("*A=",a, ", B*=",b, "B*A=",ba, ",AB=", count, ",expected=", e)

if ba > 1:
    count += ba - 1
    ba = 1
count+=max(min(a+ba,b),min(a,b+ba))
print(count)









### FIXED CODE ###

# N < 10000
N = int(input())

# len(s) < 10

count = 0
a, b, ba = 0, 0, 0
for i in range(N):
    s = input().rstrip()
    count += s.count("AB")

    if s[-1] == 'A':
        if s[0] == 'B':
            ba += 1
        else:
            a += 1
    elif s[0] == 'B':
        b += 1

#e = int(input())
#print("*A=",a, ", B*=",b, "B*A=",ba, ",AB=", count, ",expected=", e)

if ba > 1:
    count += ba - 1
    ba = 1

if a + b > 0:
    #count += max(min(a + ba, b),min (a, b + ba))
    count += min(a,b) + ba
print(count)
N, M = map(int, input().split())

l = []

for i in range(N):
    l.append(list(map(int, input().split())))

lis = [[] for i in range(N)]

for i in range(N):
    lis[l[i][0] - 1].append(l[i][1])
    if l[i][1] == N:
        lis[l[i][1] - 1].append(l[i][0])

# list = [[0 for c in range(M)] for r in range(N)]
#
# for i in range(M):
#     tmp_n, tmp_m = map(int, input().split())
#     list[tmp_n - 1][tmp_m - 1] = 1
#
#
# def dot(index1, index2):
#     results = [[0 for c in range(M)] for r in range(N)]
#     for (i, j) in zip(index1, zip(*index2)):
#         print(i,j)
#     return results

ends = []
que = []

# def travel(now, nextnodes, visited):
#     ends.append(visited)
#     visited.append(now + 1)
#     for node in nextnodes:
#         if node in visited:
#             continue
#         travel(node - 1, lis[node - 1], visited[:])
#
#
# travel(0, lis[0], [])

que = [[0, lis[0], []]]

while que:
    now, nextnodes, visited = que.pop()
    ends.append(visited)
    visited.append(now + 1)
    for node in nextnodes:
        if node in visited:
            continue
        que.append([node - 1, lis[node - 1], visited[:]])

print(len(list(filter(lambda i: len(i) is 3, ends))))

### FIXED CODE ###

N, M = map(int, input().split())

l = []

for i in range(M):
    l.append(list(map(lambda x: int(x) - 1, input().split())))

lis = [[] for i in range(N)]

for i in range(M):
    lis[l[i][0]].append(l[i][1])
    lis[l[i][1]].append(l[i][0])


# 隣接行列
# list = [[0 for c in range(M)] for r in range(N)]
#
# for i in range(M):
#     tmp_n, tmp_m = map(int, input().split())
#     list[tmp_n - 1][tmp_m - 1] = 1
#
#
# def dot(index1, index2):
#     results = [[0 for c in range(M)] for r in range(N)]
#     for (i, j) in zip(index1, zip(*index2)):
#         print(i,j)
#     return results



# 再起関数
# def travel(now, nextnodes, visited):
#     ends.append(visited)
#     visited.append(now + 1)
#     for node in nextnodes:
#         if node in visited:
#             continue
#         travel(node - 1, lis[node - 1], visited[:])
#
#
# travel(0, lis[0], [])

que = [[0, lis[0], []]]
ends = []

while que:
    now, nextnodes, visited = que.pop()
    ends.append(visited)
    visited.append(now)
    for node in nextnodes:
        if node in visited:
            continue
        que.append([node, lis[node], visited[:]])

print(len(list(filter(lambda ii: len(ii) is N, ends))))
import numpy as np
H, W, M = map(int, input().split())

A = np.zeros((H, W), dtype='bool')
for _ in range(M):
    h, w = map(int, input().split())
    h, w = h - 1, w - 1  # 0-indexed
    A[h, w] = 1

arr = A.sum(axis=0)
col_max = arr.max()
col_idx = np.where(arr == col_max)[0]

arr = A.sum(axis=1)
row_max = arr.max()
row_idx = np.where(arr == row_max)[0]

# print(A.sum(axis=0).argsort()[-1])

ans = col_max + row_max
for r in row_idx:
    for c in col_idx:
        if A[r, c] == 0:
            print(ans)
            exit()
print(ans - 1)


### FIXED CODE ###

import numpy as np
H, W, M = map(int, input().split())

C = [0] * W
R = [0] * H
S = set()
for _ in range(M):
    h, w = map(int, input().split())
    h, w = h - 1, w - 1  # 0-indexed
    C[w] += 1
    R[h] += 1
    S.add((h, w))

col_max = max(C)
col_idx = [i for i in range(W) if C[i] == col_max]
row_max = max(R)
row_idx = [i for i in range(H) if R[i] == row_max]

ans = col_max + row_max
for r in row_idx:
    for c in col_idx:
        if not (r, c) in S:
            print(ans)
            exit()
print(ans - 1)
import math

A, B, K = map(int, input().split())
C = math.gcd(A, B)
L = [1]

for i in range(2, C+1):
    if A % i == 0 and B % i == 0:
        L.append(i)

print(L[-K])


### FIXED CODE ###

A, B, K = map(int, input().split())
L = [1]

for i in range(2, 101):
    if A % i == 0 and B % i == 0:
        L.append(i)

print(L[-K])
h,w=map(int,input().split())
a=[]
for i in range(h):
  aa=list(input())
  if "#" not in aa:
    continue
  else:
    a.append(aa)
for i in range(w):
  c=0
  for j in range(len(a)):
    if a[j][i]=="#":
      c+=1
  if c==0:
    for j in range(len(a)):
      del a[j][i]
for i in range(len(a)):
  print("".join(a[i]))

### FIXED CODE ###

h,w=map(int,input().split())
a=[]
for i in range(h):
  aa=list(input())
  if "#" not in aa:
    continue
  else:
    a.append(aa)
aa=[]
for i in range(w):
  c=0
  for j in range(len(a)):
    if a[j][i]=="#":
      c+=1
  if c==0:
    aa.append(i)
aa.reverse()
for i in aa:
  for j in range(len(a)):
    del a[j][i]
for i in range(len(a)):
  print("".join(a[i]))
a,b = map(int,input().split())
if (a*b)%2 = 1:
    print(odd)
print(even)

### FIXED CODE ###

a,b = map(int,input().split())
if (a*b)%2 == 1:
  print('Odd')
else:
  print('Even')
import sys
import math
input = sys.stdin.readline

_n, _k = map(int, input().split())
_a = input()[:-1]
_f = input()[:-1]
alist = [item for item in _a]
flist = [item for item in _f]


def chker(costs, diffs, max_k):
    if sum(costs) <= max_k:
        print(0)

    costs.sort()
    diffs.sort(reverse=True)
    sclist = [(item1, item2, item1 * item2) for item1, item2 in zip(costs, diffs)].sort(key=lambda x:x[2], reverse=True)
    k = max_k
    while k > 0:
        k -= 1
        sclist[0][0] = sclist[0][0] - 1
        if sclist[0][0] == 0:
            sclist = sclist[1:]
        else:
            sclist[0][2] = sclist[0][0] * sclist[0][1]
            sclist.sort(key=lambda x:x[2], reverse=True)

    print(sclist[0][2])


chker(alist, flist, _k)


### FIXED CODE ###

import numpy as np
import sys
input = sys.stdin.readline

_n, _k = map(int, input().split())
alist = [int(item) for item in input().split()]
flist = [int(item) for item in input().split()]


def chker(costs, diffs, max_k):
	costs = np.sort(costs)[::-1]
	diffs = np.sort(diffs)
	
	_min, _max = 0, 10 ** 12
	while _min < _max:
		_mid = (_min + _max) // 2
		cnt = costs - _mid // diffs
		if cnt[cnt > 0].sum() <= max_k:
			_max = _mid
		else:
			_min = _mid + 1


	print(_min)


chker(alist, flist, _k)
import sys

input = sys.stdin.readline

d = []
ABC = []


def solve(i, dis):
    global d
    global ABC
    d[i] = dis

    for n, c in ABC[i]:
        if d[n] == -1:
            solve(n, dis + c)


def main():
    N = int(input())
    global ABC
    ABC = [[] for j in range(N)]
    global d
    d = [-1] * N
    for _ in range(N - 1):
        a, b, c = [int(x) for x in input().split()]
        ABC[a - 1].append([b - 1, c])
        ABC[b - 1].append([a - 1, c])

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

    solve(K - 1, 0)

    for _ in range(Q):
        x, y = [int(x) for x in input().split()]
        print(d[x - 1] + d[y - 1])


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys

input = sys.stdin.readline

d = []
ABC = []

sys.setrecursionlimit(10 ** 8)


def solve(i, dis):
    global d
    global ABC
    d[i] = dis

    for n, c in ABC[i]:
        if d[n] == -1:
            solve(n, dis + c)


def main():
    N = int(input())
    global ABC
    ABC = [[] for _ in range(N + 1)]
    global d
    d = [-1] * (N + 2)
    for _ in range(N - 1):
        a, b, c = [int(x) for x in input().split()]
        ABC[a - 1].append([b - 1, c])
        ABC[b - 1].append([a - 1, c])

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

    solve(K - 1, 0)

    for _ in range(Q):
        x, y = [int(x) for x in input().split()]
        print(d[x - 1] + d[y - 1])


if __name__ == '__main__':
    main()
x,y = map(int,input().split())
if x => 10:
	print(y)  
else:
	print(y+(100*(10-x)))

### FIXED CODE ###

x,y = map(int,input().split())
if x >= 10:
	print(y)  
else:
	print(y+(100*(10-x)))
# -*- coding: utf-8 -*-
tmp = map(int, input().split())
if tmp[0] < tmp[1]:
  print(0)
else:
  print(10)

### FIXED CODE ###

# -*- coding: utf-8 -*-
tmp = list(map(int, input().split()))
if tmp[0] < tmp[1]:
  print(0)
else:
  print(10)
L,R = map(int,input()split())
 
x = 2019**2
for i in range(L, R):
    for r in range(i+1, R+1):
        ans = (i*r) % 2019 
        if x > ans:
            x = ans
            if x == 0:
        	    break
    if x == 0:
      break

### FIXED CODE ###

L,R = map(int,input().split())
 
x = 2019**2
for i in range(L, R):
    for r in range(i+1, R+1):
        ans = (i*r) % 2019 
        if x > ans:
            x = ans
            if x == 0:
        	    break
    if x == 0:
      break
print(x)
a=input()
if a>999:
    print('ABD')
else:
    print('ABC')

### FIXED CODE ###

a=int(input())
if (a>999):
    print('ABD')
else:
    print('ABC')
import math
import numpy as np

def main():
    h,w,k = tuple([int(t)for t in input().split()])

    s = [[int(i) for i in list(input())] for _ in range(h)]
    
    s = np.array(s)

    candidates = []

    for i in range(1<<h):
        s_subs = divide(s,i)
        cutnum = 0
        pos = 0
        subsum = np.array([0]*len(s_subs))
        j = 0
        while j<w:
            temp = np.array([np.sum(s_[:,j]) for s_ in s_subs])
            if any([s_>k for s_ in temp]):
                cutnum = -1-bin(i).count('1')
                break

            subsum = subsum+temp
            if any([s_>k for s_ in subsum]):
                cutnum+=1
                subsum = np.array([0]*len(s_subs))
                j-=1
            
            j+=1

        candidates.append((bin(i).count('1')+cutnum))

    print(min([t for t in candidates if t>=0]))

def divide(s,i):
    subs = []
    counter = 0
    pos = 0
    while i!= 0:
        counter +=1
        if i%2==1:
            subs.append(s[pos:counter])
            pos = counter
        i >>=1

    subs.append(s[pos:])
    return subs
    
if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    n,m = tuple([int(t)for t in input().split()])

    print(n*(n-1)//2+m*(m-1)//2)

if __name__ == "__main__":
    main()
i = 0 //????????????

while True:
	n = map(int,input())
	if n == 0:
		break
	i += 1//?????????????????????
	
	print('Case {} : {}'.format(i,n))

### FIXED CODE ###


i = 0 #????????????

while True:
	n = input()
	if n == '0':
		break
	i += 1#?????????????????????
	print('Case {}: {}'.format(i,n))
def solve():
    x, y = LI()
    ans = 0

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

    print(ans)

solve()

### FIXED CODE ###

def LI(): return [int(x) for x in input().split(" ")]
def LS(): return [str(x) for x in input().split(" ")]
def ItoS(L): return [str(x) for x in L]
def StoI(L): return [int(c) for c in L]


def solve():
    x, y = LI()
    ans = 0

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

    print(ans)

solve()