Harryxun/stf_run huggingface dataset:
a,b=map(int,input().split())
if a%b!=0:print((a//b)+1) else:print(a//b)


### FIXED CODE ###

a,b=map(int,input().split())
if a%b!=0:print((a//b)+1)
else:print(a//b)
def rec(n):
    if n == 0:
        memo[n] = 0
        return memo[n]
    if memo[n] != -1:
        return memo[n]
    res = n
    pow6 = [1]
    pow9 = [1]
    for i in range(1, n):
        if 6 ** i > n:
            break
        pow6.append(6 ** i)
    
    for j in range(1, n):
        if 9 ** j > n:
            break
        pow9.append(9 ** j)
    L = set(pow6 + pow9)
    
    for k in L:
        res = min(res, rec(n - k)+1)
        
    memo[n] = res
    return memo[n]
    

N = int(input())
memo = [-1] * (N+1)
print(rec(N))

### FIXED CODE ###

import sys
sys.setrecursionlimit(100000)

def rec(n):
    if n == 0:
        memo[n] = 0
        return memo[n]
    if memo[n] != -1:
        return memo[n]
    res = n
    pow6 = []
    pow9 = []
    for i in range(n):
        if 6 ** i > n:
            break
        pow6.append(6 ** i)
    
    for j in range(1, n):
        if 9 ** j > n:
            break
        pow9.append(9 ** j)
    L = set(pow6 + pow9)
    
    for k in L:
        res = min(res, rec(n - k)+1)
        
    memo[n] = res
    return memo[n]
    

N = int(input())
memo = [-1] * (N+1)
print(rec(N))
import sys
# input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7

S = list(input())
K = int(input())

N = len(S)

T = S + S

count1 = 0
for i in range(N - 1):
    if T[i] == T[i + 1]:
        T[i + 1] = '*'
        count1 += 1

count2 = 0
if K >= 2:
    for i in range(N - 1, 2 * N - 1):
        if T[i] == T[i + 1]:
            T[i + 1] = '*'
            count2 += 1
    ans = (count1 + count2) * (K // 2) + count1 * (K % 2)
    if T[0] == T[-1]:
        ans += (K // 2) - 1
    if K % 2 == 1 and T[-1] == T[0] and T[N - 1] == T[0]:
        ans += 1
    print (ans)

else:
    print (error)
    print (count1)

# print (T)

### FIXED CODE ###

S = list(input())
K = int(input())

n = len(S)
start = 0
i = 0
while i < n and S[0] == S[i]:
    start += 1
    i += 1

if i == n:
    print ((n * K) // 2)
    exit()

lst = [start]
count = 1
tmp = i
i += 1
while i < n:
    if S[tmp] == S[i]:
        count += 1
        i += 1
    else:
        lst.append(count)
        count = 1
        tmp = i
        i += 1

lst.append(count)
# print (lst)
if S[0] != S[-1]:
    ans = 0
    for i in lst:
        ans += i // 2
    print (ans * K)
else:
    ans = (lst[0] + lst[-1]) // 2
    for i in lst[1:-1]:
        ans += i //2
    ans *= (K - 1)
    # print (ans)
    for i in lst:
        ans += i //2
    print (ans)
n = int(input())
 
g1 = []
g2 = []
g3 = []
 
cnt = 0
 
for i in range(n):
    s = input()
    cnt += s.count("AB")
    if s[0] == "B" and s[-1] == "A":
        g3.append(s)
    elif s[0] == "B":
        g1.append(s)
    elif s[-1] == "A":
        g2.append(s)
        
a = len(g1)
b = len(g2)
c = len(g3)
 
if a == b:
    if a == c:
        cnt += c * 2
    elif a > c:
        cnt += c
        cnt += a
    elif a < c:
        if a == 0:
            cnt += c - 1
        else]:
            cnt += a
            cnt += c
elif a > b:
    cnt += b
    cnt += c
elif b > a:
    cnt += a
    cnt += c
 
print(cnt)

### FIXED CODE ###

n = int(input())
 
g1 = []
g2 = []
g3 = []
 
cnt = 0
 
for i in range(n):
    s = input()
    cnt += s.count("AB")
    if s[0] == "B" and s[-1] == "A":
        g3.append(s)
    elif s[0] == "B":
        g1.append(s)
    elif s[-1] == "A":
        g2.append(s)
        
a = len(g1)
b = len(g2)
c = len(g3)
 
if a == b:
    if a == c:
        cnt += c * 2
    elif a > c:
        cnt += c
        cnt += a
    elif a < c:
        if a == 0:
            cnt += c - 1
        else:
            cnt += a
            cnt += c
elif a > b:
    cnt += b
    cnt += c
elif b > a:
    cnt += a
    cnt += c
 
print(cnt)
def all_water(h_list):
  if len(h_list) == 0:
    return 0
  min_h = min(h_list)
  new_list = [x - min_h for x in h_list]
  i = new_list.index(0)
  return min_h + all_water(new_list[:i]) + all_water(new_list[i+1:])

n = input()

height = list(map(int,input().split(" ")))

print(allwater(height))

### FIXED CODE ###

def all_water(h_list):
  if len(h_list) == 0:
    return 0
  min_h = min(h_list)
  new_list = [x - min_h for x in h_list]
  i = new_list.index(0)
  return min_h + all_water(new_list[:i]) + all_water(new_list[i+1:])

n = input()

height = list(map(int,input().split(" ")))

print(all_water(height))
N = input()
judge = "No"
for i in 3:
  if N[i] == 7:
    judge = "Yes"
    break
print(judge)

### FIXED CODE ###

N = input()
judge = "No"
for i in N:
  if i == "7":
    judge = "Yes"
    break
print(judge)
n, x = map(int, input().split())

L = list(map(int, input().split()))

dis = 0
ans = 1
for i in range(n+1):
    dis += L[i]
    if dis > x:
        dis -= L[i]
        break
    ans += 1

print(ans)

### FIXED CODE ###

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

L = list(map(int, input().split()))

dis = 0
ans = 1
for i in range(n):
    dis += L[i]
    if dis > x:
        dis -= L[i]
        break
    ans += 1

print(ans)
import fractions
from functools import reduce

n = int(input())

# a = list(map(int,input().split()))

a = [4,8,12,9,16]


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


gcd_l = [a[0]]
gcd_r = [a[-1]]
for i in range(1,n):
    gcd_l.append(fractions.gcd(gcd_l[i-1],a[i]))
    gcd_r.append(fractions.gcd(gcd_r[i-1],a[-i-1]))

gcd_r.reverse()

ans = max(gcd_l[1],gcd_r[-2])
for i in range(1,n-1):
    gcd = fractions.gcd(gcd_l[i-1],gcd_r[i+1])
    ans = max(ans,gcd)

print(ans)

### FIXED CODE ###

import fractions
from functools import reduce

n = int(input())

a = list(map(int,input().split()))
#
# a = [4,8,12,9,16]


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


gcd_l = [a[0]]
gcd_r = [a[-1]]
for i in range(1,n):
    gcd_l.append(fractions.gcd(gcd_l[i-1],a[i]))
    gcd_r.append(fractions.gcd(gcd_r[i-1],a[-i-1]))

gcd_r.reverse()

ans = max(gcd_r[1],gcd_l[-2])
for i in range(1,n-1):
    gcd = fractions.gcd(gcd_l[i-1],gcd_r[i+1])
    ans = max(ans,gcd)

print(ans)
a = int(input())
b = int(input())
c = int(input())

map_ = {}
map_[a] = 1
map_[b] = 1
map_[c] = 1

print len(map_)

### FIXED CODE ###

l = raw_input().split()
map_ = {}
for data in l:
    map_[l[0]] = 1
    map_[l[1]] = 1
    map_[l[2]] = 1
print len(map_)
n=int(input())
a=[]
m1=0
m2=0
for i in range(n):
    a.append(int(input()))
    if a>m1:
        m2=m1
        m1=a
        index=i
    elif m1==a:
        m2=a
    elif a>m2:
        m2=a
for i in range(n):
    if i==index:
        print(m2)
    else:
        print(m1)

### FIXED CODE ###

n=int(input())
a=[]
m1=0
m2=0
for i in range(n):
    a.append(int(input()))
    A=a[i]
    if a[i]>m1:
        m2=m1
        m1=a[i]
        index=i
    elif m1==a[i]:
        m2=a[i]
    elif a[i]>m2:
        m2=a[i]
for i in range(n):
    if i==index:
        print(m2)
    else:
        print(m1)
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

h, w, a, b = map(int, readline().split())
x_cnt = [0] * h
y_cnt = [0] * w
ans = [''] * h
if h == 1:
    print('1' * a + '0' * (w - a))
elif w == 1:
    for i in range(b):
        print('1')
    for i in range(h - b):
        print('0')
else:
    for i in range(h):
        for j in range(w):
            print(ans)
            if y_cnt[j] < b and x_cnt[i] < a:
                y_cnt[j] += 1
                x_cnt[i] += 1
                ans[i] += '1'
            else:
                ans[i] += '0'
        if a != 0:
            if x_cnt[i] != a:
                print('No')
                exit()
    if b != 0:
        for i in range(w):
            if y_cnt[i] != b:
                print('No')
                exit()
    for i in range(h):
        print(ans[i])


### FIXED CODE ###

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

h, w, a, b = map(int, readline().split())
ans_1 = '1' * a + '0' * (w - a)
ans_2 = '0' * a + '1' * (w - a)
for i in range(b):
    print(ans_1)
for i in range(h - b):
    print(ans_2)
n = int(input())
a = map(float,input().split())
for i in range(n)
    r += 1 / a[i]
print(1/r)

### FIXED CODE ###

d = input()
a = input().split()
r = 0
for i in a:
    r += 1 / int(i)
print(1 / r)
N = int(input())
m = list(map(int, input().split()))
b = list(map(int, input().split()))
s = 0
for i in range(N):
  if m[i]<b[i]:
    if (m[i]+m[i+1])>b[i]:
        s += b[i]
        m[i+1] += m[i]-b[i]
    else:
       s += m[i]+m[i+1]
  else:
    s += b[i]
print(s)

### FIXED CODE ###

A, B=map(int,input().split())
k = (A+B)//2 
if (A+B)%2 == 0:
  print(k)
else:
  print("IMPOSSIBLE")
import math

a, b, h, m = map(int, input().split())
ang_a = 360 * h / 12
ang_b = 360 * m / 60
s_a = 0
s_b = 0

while ang_a - 90 > 0:
    ang_a -= 90
    s_a += 1
while ang_b - 90 > 0:
    ang_b -= 90
    s_b += 1


def ppp(xx, yy, s):
    if s == 0:
        return map(int, xx, yy)
    elif s == 1:
        return map(int, xx, -yy)
    elif s == 2:
        return map(int, -xx, -yy)
    elif s == 3:
        return map(int, -xx, yy)
    else:
        return map(int, [0, 0])


x_a = math.cos(ang_a)
y_a = math.sin(ang_a)
y_b = math.cos(ang_b)
x_b = math.sin(ang_b)

x_a, y_a = ppp(x_a, y_a, s_a)
x_b, y_b = ppp(x_b, y_b, s_b)
x = abs(x_a, x_b)
y = abs(y_a, y_b)
ans_r = math.sqrt(x) + math.sqrt(y)
ans = math.sqrt(ans_r)
print(ans)


### FIXED CODE ###

import math
a, b, h, m = map(int, input().split())
ang_a = (360 * h / 12) + (0.5 * m)
ang_b = 360 * m / 60
ang = abs(ang_a - ang_b if ang_a > ang_b else ang_b - ang_a)
ans = math.sqrt((a ** 2 + b ** 2) - (2*a*b*math.cos(math.radians(ang))))
print(ans)
import sys
input = sys.stdin.readline
N, A, B, C, D = map(int, input().split())

dp = [0] * N
dp[0] = A
dp[-1] = B
x = -1
def no():
  print("NO")
  exit(0)
if B < A: A, B = B, A
for i in range(N - 2):
  if dp[i] < B:
    dp[i + 1] = dp[i] + D
  else:
    #print(dp[i], (i - 1) * (D - C), B)
    if abs(dp[i] - (i - 1) * (D - C)) <= B:
      x = i
      dp[i] = B
    else:
      x = i + -(-abs(B - dp[i]) // (D - C)) * 2
      if x >= N: no()
      dp[x] = B
    break

#print(x, dp[x])
t = (N - 1 - x)
#print(t)
if t % 2:
  if t == 1: no()
  if -(-C // (D - C)) > t: no()
print("YES")


### FIXED CODE ###

import sys
input = sys.stdin.readline
N, A, B, C, D = map(int, input().split())
for i in range(N - 1):
  r = D * (N - i - 1) + A
  l = C * (N - i - 1) + A

  r -= C * i
  l -= D * i
  #print(l, r, i)
  if B in range(l, r + 1):
    print("YES")
    exit(0)
print("NO")
N=int(input())
A_list=list(map(int,input().split()))
ans=1
for i in A_list:
    ans*=i
    if ans>10**18:
        ans=-1
        break 
for i in A_list:
    if i==0:
        ans=0
print(ans)

### FIXED CODE ###

A,B=map(int,input().split())
print(A*B)
N = int(input())
X_bin = input()

X_int = int(X_bin, 2)  # bin => int
dp = {1: 1}
bin_cnt = {}


def calc_bin_cnt(next_int):
    print('calc_bin')
    if next_int in bin_cnt.keys():
        print('bin dp')
        cnt = bin_cnt[next_int]
    else:
        next_bin = format(next_int, 'b')
        # popcount
        cnt = 0
        for i in next_bin:
            if i == '1':
                cnt += 1
        bin_cnt[next_int] = cnt
    return cnt


def calc_ans(next_int):
    key = next_int
    if key in dp.keys():
        print('dp')
        ans = dp[key]
    else:
        '''
        next_bin = format(next_int, 'b')
        # popcount
        cnt = 0
        for i in next_bin:
            if i == '1':
                cnt += 1
        '''
        cnt = calc_bin_cnt(next_int)
        bin_cnt[next_int] = cnt
        next_int = next_int % cnt
        if next_int > 0:
            ans = calc_ans(next_int) + 1
        else:
            ans = 1
        dp[key] = ans
    return ans


for i in range(N):
    if X_bin[i] == '1':
        print(calc_ans(X_int - (2**(N-i-1))))
    else:
        print(calc_ans(X_int + (2**(N-i-1))))


### FIXED CODE ###

N = int(input())
X_bin = input()
#N = 10**5
#X_bin = '1' * N

X_int = int(X_bin, 2)  # bin => int


def calc_bin_cnt(next_int):
    if next_int == 0:
        return 0
    next_bin = bin(next_int)[2:]
    # popcount
    cnt = 0
    for i in next_bin:
        if i == '1':
            cnt += 1
    return cnt


def calc_ans(next_int, cnt=None):
    if next_cnt == 0:
        return 0
    if next_int == 0:
        return 1
    if cnt is None:
        cnt = calc_bin_cnt(next_int)
    next_int = next_int % cnt
    if next_int > 0:
        ans = calc_ans(next_int) + 1
    else:
        ans = 1
    return ans


X_cnt = calc_bin_cnt(X_int)
f_p = X_int % (X_cnt+1)
if X_cnt-1 == 0:
    f_m = 0
else:
    f_m = X_int % (X_cnt-1)
for i in range(N):
    if X_bin[i] == '1':
        next_cnt = X_cnt - 1
        if next_cnt == 0:
            next_int = 0
        else:
            next_int = f_m - pow(2, (N-i-1), next_cnt)  # マイナスでも正しく求まる？
    else:
        next_cnt = X_cnt + 1
        next_int = f_p + pow(2, (N-i-1), next_cnt)
    print(calc_ans(next_int, next_cnt))
    #calc_ans(next_cnt, next_cnt)
lst = input().split()
X = int(lst[0])
Y = int(lst[1])
A = int(lst[2])
B = int(lst[3])
C = int(lst[4])

p_list = [int(num) for num in input().split(" ")]
q_list = [int(num) for num in input().split(" ")]
r_list = [int(num) for num in input().split(" ")]

sort_p = sorted(p_list,reverse = True)[:X]
sort_q = sorted(q_list,reverse = True)[:Y]
sort_r = sorted(r_list,reverse = True)[:X+Y]

max_score = 0

for i in range(X+Y):
    if len(sort_p) ==0:
        if sort_q[0] >= sort_r[0]:
            max_score += sort_q[0]
            sort_q = sort_q[1:]
        else:
            max_score += sort_r[0]
            sort_r = sort_r[1:]
            sort_q.pop()
    elif len(sort_q) ==0:
        if sort_p[0] >= sort_r[0]:
            max_score += sort_p[0]
            sort_p = sort_p[1:]
        else:
            max_score += sort_r[0]
            sort_r = sort_r[1:]
            sort_p.pop()

    else:
        if sort_p[0] >= sort_q[0] and sort_p[0] >= sort_r[0]:
            max_score += sort_p[0]
            sort_p = sort_p[1:]
        elif sort_p[0] >= sort_r[0]:
            max_score += sort_q[0]
            sort_q = sort_q[1:]
        else:
            max_score += sort_r[0]
            sort_r = sort_r[1:]
            if sort_p[-1] < sort_q[-1]:
                sort_p.pop()
            else :
                sort_q.pop()
print(max_score)


### FIXED CODE ###

lst = input().split()
X = int(lst[0])
Y = int(lst[1])
A = int(lst[2])
B = int(lst[3])
C = int(lst[4])

p_list = [int(num) for num in input().split(" ")]
q_list = [int(num) for num in input().split(" ")]
r_list = [int(num) for num in input().split(" ")]

sort_p = sorted(p_list,reverse = True)[:X]
sort_q = sorted(q_list,reverse = True)[:Y]
sort_r = sorted(r_list,reverse = True)[:X+Y]

max_score = 0
sort_p.extend(sort_q)
sort_p.extend(sort_r)
sort_p.sort(reverse = True)
for i in range(X+Y):
    max_score += sort_p[i]

print(max_score)
n = int(input())
a = []
b = []

for i in range(1, int(n**0.5)+1):
    if n % i ==0:
        a.append(i)
        if i != n//i:
            b.append(n//i)

def Check(x):
    cont= 0
    while x > 0:
        cont += 1
        x = x//10
    return cont

A = []
for i in a:
    A.append(Check(i))

B = []
for i in b:
    B.append(Check(i)) 

print(max(max(A), min(B)))


### FIXED CODE ###

n = int(input())

def Check(x):
    cont= 0
    while x > 0:
        x = x//10
        cont += 1
    return cont

a = []
for i in range(1, int(n**0.5)+1):
    if n % i == 0:
        a.append(i)

a = max(a)
b = n//a

print(max(Check(a), Check(b)))
import collections as col
from collections import defaultdict as dd

d=dd(list)

N,M=map(int, input().split())
p=[-1]*N
cnt=[0]*N

for _ in range(M):
    i,j=map(int, input().split())
    if i>j:
        i,j=j,i
    d[i].append(j)

for i in d:
    for j in d[i]:
        if p[j-1]!=-1:
            if p[i-1]==-1:
                p[i-1]=j
                cnt[p[j-1]]+=1
            continue
        if p[i-1]==-1:
            p[j-1]=i
            cnt[i]+=1
        else:
            p[j-1]=p[i-1]
            cnt[p[i-1]]+=1

cnt.sort(reverse=True)
print(cnt[0]+1)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**8)

def find(x):
    if par[x]==x:
        return x
    else:
        par[x]=find(par[x])
        return par[x]

def union(a,b):
    a=find(a)
    b=find(b)
    if a==b:
        return
    
    if rank[a]<rank[b]:
        par[a]=b
        rank[b]+=rank[a]
        rank[a]=rank[b]
    else:
        par[b]=a
        rank[a]+=rank[b]
        rank[b]=rank[a]

    return

def chk(a,b):
    if par[a]==par[b]:
        print('Yes')
    else:
        print('No')

    return

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

par=(list(range(N+1)))
rank=[1]*(N+1)

for _ in range(M):
    A,B=map(int, input().split())
    union(A,B)

print(max(rank))
c = 1
while True:
    x = input()
    if x == 0: break
    print("Case ", c, ": ", x) 
    c += 1


### FIXED CODE ###

c = 1
while True:
    x = int(input())
    if x == 0: break
    print("Case {}: {}".format(c, x))
    c += 1
print(int(input()**3)

### FIXED CODE ###

N = int(input())

print(N**3)
from itertools import product
n, m, x = map(int, input().split())
books = [[int(j) for j in input().split()] for i in range(n)]
min_cost = float('inf')
for bit in product([0, 1], repeat=n):
    cost = 0
    skill = [0] * m
    for i, b in enumerate(bit):
        if b == 1:
            cost += books[i][0]
            for j in range(m):
                skill[j] += books[i][j + 1]
    if x <= min(*skill):
        min_cost = min(min_cost, cost)
print(min_cost if min_cost != float('inf') else -1)

### FIXED CODE ###

from itertools import product
n, m, x = map(int, input().split())
books = [[int(j) for j in input().split()] for i in range(n)]
min_cost = float('inf')
for bit in product([0, 1], repeat=n):
    cost = 0
    skill = [0] * m
    for i, b in enumerate(bit):
        if b == 1:
            cost += books[i][0]
            for j in range(m):
                skill[j] += books[i][j + 1]
    if x <= min(i for i in skill):
        min_cost = min(min_cost, cost)
print(min_cost if min_cost != float('inf') else -1)
import math
n,x=map(int,input().split())
s=list(map(int,input().split()))
b=s[0]
t=abs(b-x)
for i in range(1,n):
    t=math.gcd(t,abs(s[i]-x))   
print(t)    

### FIXED CODE ###

from fractions import gcd 
n,x=map(int,input().split())
s=list(map(int,input().split()))
b=s[0]
t=abs(b-x)
for i in range(1,n):
    t=gcd(t,abs(s[i]-x))   
print(t)
S = sorted(input())

if S = "abc":
  print("Yes")
else:
  print("No")

### FIXED CODE ###

S = sorted(input())
if S == sorted('abc'):
    print('Yes')
else:
    print('No')
import math
def main():
    A, B = input().split()
    A = int(A)
    B = round(100 * (B))
    out = (A * B) // 100
    
    print(out)

main()

### FIXED CODE ###

import math
def main():
    A, B = input().split()
    A = int(A)
    B = round(100 * float(B))
    out = (A * B) // 100
    
    print(out)

main()
#!/usr/bin/env python
# coding: utf-8

# In[1]:


import sys
#import numpy as np
#import itertools
input = sys.stdin.readline
N, K = map(int, input().split())
V = list(map(int, input().split()))


# In[2]:


#print(N, K)
#print(V)


# In[ ]:


"""
6 4
-10 8 2 1 2 6
"""


# In[29]:


scs = []
for i in range(K//2):
    #print("{}個返す".format(i))
    scss = []
    for j in range(K+1-i):
        #print("左から{}個　右から{}個/{}".format(j,K-j-i, K-i))
        if j == K-i:
            choices = V[:j]
        else:
            choices = V[:j] + V[-K+j+i:]
        #print(choices)
        #print(sorted(choices)[i:])
        scss.append(sum(sorted(choices)[i:]))
    scs.append(max(scss))
print(max(scs))


# In[ ]:






### FIXED CODE ###

#!/usr/bin/env python
# coding: utf-8

# In[30]:


import sys
#import numpy as np
#import itertools
input = sys.stdin.readline
N, K = map(int, input().split())
V = list(map(int, input().split()))


# In[36]:


#print(N, K)
#print(V)


# In[ ]:


"""
6 4
-10 8 2 1 2 6
"""


# In[46]:


ans = 0
for l in range(K+1):
    if l > N:
        continue
    for r in range(K+1-l):
        if l+r>K or l+r>N:
            continue
        d = K-(l+r)
        picked = V[:l] + V[-r:] if r != 0 else V[:l]
        #print("l:{}, r:{}, picked{}".format(l, r, picked))
        sp = sorted(picked)
        now = sum(picked)
        #print(sp)
        for i in range(d):
            if i >= len(picked):
                break
            if sp[i] > 0:
                break
            now -= sp[i]
        ans = max(ans, now)
print(ans)
        
"""
if N < K:
    scs = []
    for i in range(K-N):
        scs.append(sorted(V[i:]))
    s = max(scs)
else:
    scs = []
    for i in range(K//2):
        #print("{}個返す".format(i))
        scss = []
        for j in range(K+1-i):
            #print("左から{}個　右から{}個/{}".format(j,K-j-i, K-i))
            if j == K-i:
                choices = V[:j]
            else:
                choices = V[:j] + V[-K+j+i:]
            #print(choices)
            #print(sorted(choices)[i:])
            scss.append(sum(sorted(choices)[i:]))
        scs.append(max(scss))
    s = max(scs)
    s = 0 if s<0 else s
print(s)
"""


# In[ ]:
inf = 2019
L, R = map(int, input().split())
ans = 2018
L = L % 2019
R = R % 2019
if L > R:
    print(0)
    sys.exit
for i in range(L, R):
    for j in range(i + 1, R):
        tmp = int((i * j) % inf)
        ans = min(ans, tmp)
        
print(ans)


### FIXED CODE ###

inf = 2019
L, R = map(int, input().split())
ans = 0
df = R - L
if df < 2019:
    L = L % inf
    R = L + df
    ans = 2019
    for i in range(L, R):
        for j in range(i + 1, R + 1):
            tmp = int((i * j) % inf)
            ans = min(ans, tmp)

print(ans)
from heapq import _heapify_max, _heapreplace_max

n, m = map(int, input().split())
a = list(map(int, input().split()))

_heapify_max(a)

for i in range(m):
    _heapreplace_max(a, a[0] // 2)
    
print(sum(a))

### FIXED CODE ###

n, m = map(int, input().split())
a = sorted(map(int, input().split()), reverse=True)

while m > 0:
    a = sorted(a, reverse=True)
    temp = a[0] // 2
    for i in range(n):
        if a[i] >= temp:
            a[i] = a[i]//2
            m -= 1
            if m <= 0:
                break
        else:
            break

count = 0
for i in a:
    count += i
print(count)
N = str(input())
s = 0
for i in range(0,2):
  if N[i] = 1:
    s = s + 1
print(s)
   


### FIXED CODE ###

A = input()
s = 0
for i in range(len(A)):
  if A[i]=="1":
    s = s + 1
print(s)
import sys
import collections
import bisect
input = sys.stdin.readline

n = int(input())
a = list(map(int, input().split()))
ab = sorted(a)
memo = collections.Counter(ab)
memo_key = list(memo.keys())
memo_v = list(memo.values())
len_v = len(memo_v)
max = max(memo_v)
cnt = [0] * max
cnt_sum = 0
ans_memo = [0] * len_v
for i in range(1, max):
    cnt[i] = cnt[i - 1] + i
for i in range(len_v):
    cnt_sum += cnt[memo_v[i] - 1]
for i in range(len_v):
    ans_memo[i] = cnt[memo_v[i] - 2] + cnt_sum - cnt[memo_v[i] - 1]
for i in range(n):
    ans = ans_memo[bisect.bisect_left(memo_key, a[i])]
    print(ans)


### FIXED CODE ###

import sys
import collections
input = sys.stdin.readline

n = int(input())
a = list(map(int, input().split()))
count = collections.Counter(a)
sm = {}
sm2 = {}
for key, value in count.items():
    sm[key] = value * (value - 1) // 2
    sm2[key] = (value - 1) * (value - 2) // 2
total = sum(sm.values())

for num in a:
    print(total - sm[num] + sm2[num])
N = int(input())
L = []
if not (1 <= N <= 2*(10**5)):
    exit()


for i in range(N):
    d = input()
    if not (1 <= len(d) <= 10):
        exit()
    if not (d.lower() == d):
        exit()
    L.append(d)

print(len(set(L)))
root@stypr-ubuntu:~/1# 

### FIXED CODE ###

N = int(input())
L = []
if not (1 <= N <= 2*(10**5)):
    exit()


for i in range(N):
    d = input()
    # if not (1 <= len(d) <= 10):
    #    exit()
    # if not (d.lower() == d):
    #     exit()
    L.append(d)

print(len(set(L)))
n=int(input());t,a=map(int,input().split())
lis=list(map(int,input().split()))
li,l=abs((t-lis[0]*0.006)-a),0
for i in range(1,n):
    b = abs((t-lis[i]*0.006)-a)
    if b < li:
        li=b
        l=i
print(l+1)

### FIXED CODE ###

a,b = map(int,input().split())
print(a+int(b/2))