Harryxun/stf_run huggingface dataset:
from operator import itemgetter
N, M = map(int, input().split())
A = [int(i) for i in input().split()]
K = [[int(i) for i in input().split()] for j in range(M)]
K.sort()
K.sort(key=itemgetter(1))
#B_C = list(map(list, zip(*K)))
A.sort()

ans = 0
changed = []
for i in K[::-1]:
    changed += [i[1]]*i[0]
    if len(changed) < N:
        continue
    else:
        while(len(changed) > N):
            changed.pop()
        break

print(changed.__len__(),A.__len__())
for i in range(N):
    if changed[i] <= A[i]:
        SUM = sum(changed[:i]) + sum(A[i:])
        print(SUM)
        exit()
else:
    print(sum(changed))


### FIXED CODE ###

from operator import itemgetter
N, M = map(int, input().split())
A = [int(i) for i in input().split()]
K = [[int(i) for i in input().split()] for j in range(M)]
K.sort()
K.sort(key=itemgetter(1))
#B_C = list(map(list, zip(*K)))
A.sort()

changed = []
for i in K[::-1]:
    changed += [i[1]]*i[0]
    if len(changed) < N:
        continue
    else:
        while(len(changed) > N):
            changed.pop()
        break
if len(changed) < N:
    changed += [0]*(N-len(changed))
#print(changed.__len__(),A.__len__())
for i in range(N):
    if changed[i] <= A[i]:
        SUM = sum(changed[:i]) + sum(A[i:])
        print(SUM)
        exit()
else:
    print(sum(changed))
from decimal import *

a = list(input().rstrip().split(" "))

A,B =Decimal(int(a[0])),float(a[1])

if A > 10**6:
    C = int(B*100)
    ans1 = int(100*B)
    ans2 = (A-100)*C
    ans3 = ans2/100
    ans = int(ans1 + ans3)
else:
    ans = int(A*B)
    
print(ans)

### FIXED CODE ###

a, b = map(float, input().split())
a = int(a)
b = int(b * 1000)
print((a*b)//1000)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
N, H, W = map(int, input().split())
P = [-1 for i in range(H+W)]
C = [1] * (H+W)
arr = []
for _ in range(N):
    r, c, a = map(int, input().split())
    arr.append((a, r-1, c+H-1))
arr = sorted(arr)


def find(a):
    if P[a] < 0: return a
    t = find(P[a])
    P[a] = t
    return t

def unite(r, c):
    fr, fc = find(r), find(c)
    if fr == fc:  return 0
    C[fr] = C[fc] = C[fr] + C[fc]
    if P[fr] == P[fc]:
        P[fc] = fr
        P[fr] -= 1
    elif P[fr] > P[fc]:
        P[fc] = fr
    else:
        P[fr] = fc
    
while arr:
    a, r, c = arr.pop()
    unite(r, c)
    fr = find(r)
    if C[fr]:
        ans += a
        C[fr] -= 1
print(ans)


### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

def par(a):
    if P[a] < 0: return a
    t = par(P[a])
    P[a] = t
    return t
def unite(a, b):
    if par(a) == par(b): return 0
    C[par(a)], C[par(b)] = C[par(a)] + C[par(b)], C[par(a)] + C[par(b)]
    if P[par(b)] == P[par(a)]:
        P[par(b)] = par(a)
        P[par(a)] -= 1
    elif P[par(b)] > P[par(a)]:
        P[par(b)] = par(a)
    else:
        P[par(a)] = par(b)
N, H, W = map(int, input().split())
P = [-1 for i in range(H+W)]
C = [1] * (H+W)
X = []
for _ in range(N):
    r, c, a = map(int, input().split())
    X.append((a, r-1, c+H-1))
X = sorted(X)
ans = 0
while X:
    a, r, c = X.pop()
    unite(r, c)
    if C[par(r)]:
        ans += a
        C[par(r)] -= 1
print(ans)
import math
n=int(input())
m=int(input())
s=1
for i in range(n):
  s = math.min(s*2, s+m)
print(s)

### FIXED CODE ###

n=int(input())
m=int(input())
s=1
for i in range(n):
  s = min(s*2, s+m)
print(s)
import sys

class Deque:
    # セルの定義
    class Cell2:
        def __init__(self, x, y = None, z = None):
            self.data = x
            self.next = y
            self.prev = z

    # 初期化
    def __init__(self):
        head = Deque.Cell2(None)  # ヘッダ
        head.next = head          # 循環リスト
        head.prev = head
        self.size = 0
        self.head = head

    # 先頭に追加
    def push_front(self, x):
        h = self.head
        q = h.next
        p = Deque.Cell2(x, q, h)
        h.next = p
        q.prev = p
        self.size += 1

    # 最後尾のデータを取り出す
    def pop_back(self):
        if self.size == 0: raise IndexError
        h = self.head
        q = h.prev
        p = q.prev
        p.next = h
        h.prev = p
        self.size -= 1
        return q.data

    # 先頭のデータを取り出す
    def pop_front(self):
        if self.size == 0: raise IndexError
        h = self.head
        q = h.next
        p = q.next
        p.prev = h
        h.next = p
        self.size -= 1
        return q.data

    # xをもつセルを削除する
    def delete(self,x):
        h=self.head.next
        while h.data!=x:
            h=h.next
            if h==self.head: raise IndexError
        q=h.next
        p=h.prev
        q.prev=p
        p.next=q
        self.size -= 1
        return

    # 表示
    def __str__(self):
        if self.size == 0: return
        buff = ''
        n = self.size
        cp = self.head.next
        while n > 1:
            buff += '%s, ' % cp.data
            cp = cp.next
            n -= 1
        buff += '%s' % cp.data
        return buff
    
A=Deque()
n=int(raw_input())
while n:
    s = (raw_input().split())
    if s[0] == 'insert':
        A.push_front(s[1])
    elif s[0] == 'delete':
        A.delete(s[1])
    elif s[0] == 'deleteFirst':
        A.pop_front()
    elif s[0] == 'deleteLast':
        A.pop_back()
    n -=1
    
print A
print

### FIXED CODE ###

import sys,gc
    
A=[]
fp =0
bp =0

n=int(raw_input())
while n:
    s = raw_input()
    if s[0] == 'i':
        A.append(int(s[7:]))
        fp += 1
    elif s[6] == ' ':
        try:
            i = A[::-1].index(int(s[7:]))
            if i!=-1:
                del A[-i-1]
                fp -=1
        except:
            pass
    elif s[6] == 'F':
        A.pop()
        fp -=1
    elif s[6] == 'L':
        bp +=1
    n -=1

for e in A[bp:fp+1][::-1]:
    print int(e),
while True:
 m,f,r=map(int,input().split())
 if m==f==r==-1 : break
 if((m==-1) or (f==-1))
   print('F')

 if m+f>=80 :
   print('A')

 elif m+f >= 65 :
   print('B')

 elif m+f >= 50 :
   print('C')

 elif m+f >= 30 :
   if r >= 50
    print('C')
   else
    print('D')

 if(m+f<30)
   print('F')



 

### FIXED CODE ###

while True:
 m,f,r=map(int,input().split())
 if m==f==r==-1 : break

 if m==-1 or f==-1 :
   print('F')

 elif (m+f)>=80 :
   print('A')

 elif 65<= (m+f) and (m+f)<80 :
   print('B')

 elif 50<= (m+f) and (m+f)<65 :
   print('C')

 elif 30<=(m+f) and (m+f)<50 :
   if 50<=r :
    print('C')
   else:
    print('D')

 elif (m+f)<30 :
   print('F')
A=int(input())
B=int(input())
K=int(input())
count = 0
while count<K:
    if count%2==0:
        if A%2==0:
            A//=2
            B+=A
        else:
            A-=1
            A//=2
            B+=A
    else:
        if B%2==0:
            B//=2
            A+=B
        else:
            B-=1
            B//=2
            A+=B
    count+=1
print(A,B)

### FIXED CODE ###

S=input()
if len(S)==2:
    print(S)
elif len(S)==3:
    print(S[::-1])
String s
String t
int x
int i = 0
s = input()
t = input()
for i in range(len(s))
  if(s[i] == t[i]):
    x = x + 1
  i = i + 1
print(x)

### FIXED CODE ###

x = 0
s = input()
t = input()
y = len(s)
for i in range(y):
  if s[i] != t[i]:
    x += 1
  i += 1
print(x)
a=map(int,raw_input().split())
a=list(set(a))
b=0
for i in a:
    t=True
    for I in range(2,int(i**0.5)+1):
        if i%I==0:
            t=False
    if t: 
        b+=1
print b

### FIXED CODE ###

a=input()
def ip(a):
    i=2
    while i**2<=a:
        if a%i==0:return False
        i+=1
    return True
b=0
for i in range(int(a)):
    c=input()
    if ip(int(c)):b+=1
print(str(b))
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
def prime_decomposition(n):
  i = 2
  d = {}
  while i * i <= n:
    while n % i == 0:
      n /= i
      if i not in d:
          d[i] = 0
      d[i] += 1
    i += 1
  if n > 1:
    if n not in d:
        d[n] = 1
  return d

def eratosthenes(n):
    prime = []
    limit = n**0.5
    numbers = [i for i in range(2,n+1)]
    while True:
        p = numbers[0]
        if limit <= p:
            return prime + numbers
        prime.append(p)
        numbers = [i for i in numbers if i%p != 0]
    return prime

N = int(input())
A = [int(input()) for i in range(N+1)]
A.reverse()
g = A[0]
for a in A:
     g = gcd(g,a)
d = prime_decomposition(g)
ans = [p for p in d]

prime = eratosthenes(N+2)

for p in prime:
    for n in range(p-1):
        s = 0
        for k in range(int((N-n)/(p-1))+1):
            s += A[n+k*(p-1)]
            s %= p
        if s != 0:
            break
    if s == 0:
        ans.append(p)

ans = list(set(ans))
ans.sort()

for p in ans:
    print(p)


### FIXED CODE ###

N = int(input())
S = input()
w = [0]*N
b = [0]*N
s = S[::-1]
for i in range(N):
    b[i] = b[i-1]
    if S[i] == '#':
        b[i] += 1
    w[i] = w[i-1]
    if s[i] == '.':
        w[i] += 1

m = min(w[N-1],b[N-1])
for i in range(N-1):
    m = min(m,b[i]+w[N-i-2])

print(m)
N = input()
A, B, C, D = int(N[0]), int(N[1]), int(N[2]), int(N[3])
OP = ["+", "-"]

ANS = A
for op1 in OP:
    if ANS == 7:
        break
    ANS = A
    if op1 == "+":
        ANS = ANS + B
    else:
        ANS = ANS - B
    for op2 in OP:
        if ANS == 7:
            Break
        if op2 == "+":
            ANS = ANS + C
        else:
            ANS = ANS - C
        for op3 in OP:
            if op3 == "+":
                ANS = ANS + D
            else:
                ANS = ANS - D
            if ANS == 7:
                print("%d%s%d%s%d%s%d=7" % (A, op1, B, op2, C, op3, D))
                break


### FIXED CODE ###

N = input()
A, B, C, D = int(N[0]), int(N[1]), int(N[2]), int(N[3])
OP = ["+", "-"]

ANS = 0
flg = False


for op1 in OP:
    if flg is True:
        break
    ANS = A
    if op1 == "+":
        ANS = ANS + B
    else:
        ANS = ANS - B
    for op2 in OP:
        if flg is True:
            break
        ANS2 = ANS
        if op2 == "+":
            ANS2 = ANS + C
        else:
            ANS2 = ANS - C
        for op3 in OP:
            ANS3 = ANS2
            if op3 == "+":
                ANS3 = ANS2 + D
            else:
                ANS3 = ANS2 - D
            if ANS3 == 7:
                print("%d%s%d%s%d%s%d=7" % (A, op1, B, op2, C, op3, D))
                flg = True
                break
N = int(input())

L = []
for i in range(N):
    x, y, h = map(int, input().split())
    L.append([x, y, h])
    if h != 0:
        idx = i


for i in range(101):
    for j in range(101):
        H = L[idx][2] + abs(L[idx][0]-i) + abs(L[idx][1]-j)
        for k in range(N):
            if L[k][2] == H - abs(L[k][0]-i) - abs(L[k][1]-j):
                pass
            else:
                break
            if k == N-1:
                ansx = i
                ansy = j
                ansh = H

print(ansx, ansy, ansh)

### FIXED CODE ###

n = int(input())

arr = []

for i in range(n):
    x, y, h = map(int, input().split())
    arr.append([x, y, h])

for i in range(101):
    for j in range(101):
        for k in range(n):
            if arr[k][2] > 0:
                len1 = abs(arr[k][0] - i) + abs(arr[k][1] - j)
                ch = len1 + arr[k][2]
                break
            else:
                continue
        for k in range(n):
            lenk = abs(arr[k][0] - i) + abs(arr[k][1] - j)
            if max(ch - lenk, 0) == arr[k][2]:
                if k == n-1:
                    print("{} {} {}".format(i, j, ch))
                else:
                    continue
            else:
                break
list = []
while list[0] != 0 or list[1] != 0:
    list = [int(x) for x in input().split( )]
    print(' '.join(map(str,sorted(list))))




### FIXED CODE ###

while True:
    l = [int(x) for x in input().split( )]
    if l == [0,0]:
        break
    else:
        l.sort()
        print(*l)
# -*- coding: utf-8-*-
strs = []
n,k = map(int,input().split())
hates = list(input().split())

give = n

while(True):
  stri = str(give)
  for hate in hates:
    if hate in stri:
      give = give + 1
      break
    else:
      print(give)
      exit()

### FIXED CODE ###

# -*- coding: utf-8-*-
a = []
a = list(map(int,input().split()))
if (a[0] + a[1] + a[2] == 17) and (7 in a) and (5 in a):   
  print("YES")
else:
  print("NO")
import sys

l_1 = [1,3,5,7,8,10,12]
l_2 = [4,6,9,11]

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

if x == 2:
    if y == 2:
        print("yes")
    else:
        print("no")
elif x in l_1:
    if y in x_1:
        print("yes")
    else:
        print("no")
else x in l_2:
    if y in l_2:
        print("yes")
    else:
        print("no")

### FIXED CODE ###

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

a = [0,1,3,1,2,1,2,1,1,2,1,2,1]

if a[x] == a[y]:
    print("Yes")
else:
    print("No")
from collections import Counter

n, m = map(int, input().split())
ab = [map(int, input().split()) for _ in range(m)]
a, b = [list(i) for i in zip(*ab)]

a.extend(b)
c = Counter(a)
most = c.most_common(1)[0][0]

temp = []
for i in range(m):
  if a[i] == most or b[i] == most:
    temp.append(a[i])
    temp.append(b[i])
temp = list(set(temp))
print(len(temp))

### FIXED CODE ###

import networkx as nx
n,m=map(int, input().split())
uf=nx.utils.UnionFind()
for _ in range(m):
    a,b=map(int, input().split())
    uf.union(a, b)
ans=1
for i in uf.to_sets():
    ans=max(ans,len(i))
print(ans)
n,x = map(int,input().split())

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

def solve(now,ls,x,cnt):
    if now>x:
        return print(cnt)
    else:
        return solve(now+ls[cnt-1],ls,x,cnt+1)
solve(0,l,x,0)

### FIXED CODE ###

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

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

cnt = 1
now = 0
for i in l:
    now += i
    if now>x:
        break
    cnt += 1

print(cnt)
n, x = map(int, input().split())
l = list(map(int, input().split()))

dist, count = 0, 0
while dist <= x and count < n+1:
    dist += l[count]
    count += 1

print(count)

### FIXED CODE ###

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

dist, count = 0, 1
for i in range(n):
    dist += l[i]
    if dist > x:
        break
    count += 1

print(count)
import sys
input=sys.stdin.readline
class BinaryIndexedTree:
  def __init__(self,n):
    self.bit=[0]*n
  def add(self,i,x):
    i+=1
    while i<=len(self.bit):
      self.bit[i-1]+=x
      i+=i&-i
  def sum_sub(self,i):
    a=0
    i+=1
    while i:
      a+=self.bit[i-1]
      i-=i&-i
    return a
  def sum(self,i,j):
    a=self.sum_sub(j+1)
    if i!=0:a-=self.sum_sub(i-1)
    return a
def main():
  n,q,*a=map(int,open(0).read().split())
  ans=[0]*q
  queries=[]
  for i in range(q):queries.append((a[n+i*2+1]-1,a[n+i*2]-1,i))
  queries.sort()
  queries.append((10**20,0,0))
  lastAppeared=[n]*n
  bitt=BinaryIndexedTree(n+1)
  j=0
  for i in range(n):
    bitt.add(lastAppeared[a[i]],-1)
    bitt.add(i,1)
    lastAppeared[a[i]]=i
    while queries[j][0]==i:
      r,l,ind=queries[j]
      j+=1
      ans[ind]=bitt.sum(l,r-1)
  print(*ans)

if __name__ == "__main__":
  main()

### FIXED CODE ###

def main():
  def add(i,x):
    i+=1
    while i<=n:
      bit[i-1]+=x
      i+=i&-i
  def sum_sub(i):
    a=0
    i+=1
    while i:
      a+=bit[i-1]
      i-=i&-i
    return a
  def sum(i,j):
    a=sum_sub(j+1)
    if i!=0:a-=sum_sub(i-1)
    return a
  
  n,q,*x=map(int,open(0).read().split())
  a=x[:n]
  queries=[]
  for i in range(q):
    l,r=x[n+i*2:n+(i+1)*2]
    l-=1
    r-=1
    queries.append(r<<40|l<<20|i)
  ans=[0]*q
  queries.sort()
  for i in range(q):
    ind=queries[i]%(1<<20)
    queries[i]>>=20
    l=queries[i]%(1<<20)
    queries[i]>>=20
    r=queries[i]
    queries[i]=[r,l,ind]
  queries.append([10*20])
  lastAppeared=[-1]*n
  bit=[0]*n
  j=0
  for i in range(n):
    if lastAppeared[a[i]-1]!=-1:
      add(lastAppeared[a[i]-1],-1)
      add(i,1)
      lastAppeared[a[i]-1]=i
    else:
      add(i,1)
      lastAppeared[a[i]-1]=i
    while queries[j][0]==i:
      r,l,ind=queries[j]
      j+=1
      ans[ind]=sum(l,r-1)
  print(*ans)
if __name__ == "__main__":
  main()
def tenth(a):
  temp = a
  if temp % 10 == 0:
    return temp
  else:
    temp += 1

a = tenth(int(input()))
b = tenth(int(input()))
c = tenth(int(input()))
d = tenth(int(input()))
e = int(input())

print(a + b + c + d + e)


### FIXED CODE ###

def tenth(a):
  temp = a
  while True:
    if temp % 10 == 0:
      return temp
    else:
      temp += 1

li = list()
ans = 0

for i in range(5):
  li.append(int(input()))
  ans += tenth(li[i])
  li[i] = tenth(li[i]) - li[i]
  
ans -= max(li)

print(ans)
n = int(input())

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

ans = 0
li = [0]*(n+1)

for i,a in enumerate(a_li):
  ans += (i+1)*a

for i,a in enumerate(a_li[::-1]):
  if i >= 1:
    li[i] = li[i-1]+a
  else:
    li[i] = a

li = li[::-1]

#print(li)
#print(ans)


flag = True
ne = 0.5
for i in range(n):
  if li[i]  > 2*ne:
    ans -= li[i] -2*ne
    #print(li[i] -2*ne)

  ne = 2*ne - a_li[i]
  #print(ne)
  if ne <= 0:
    flag = True

  
if flag:
  print(int(ans))
else:
  print(-1)

### FIXED CODE ###

n = int(input())

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

ans = 0
li = [0]*(n+1)

for i,a in enumerate(a_li):
  ans += (i+1)*a

for i,a in enumerate(a_li[::-1]):
  if i >= 1:
    li[i] = li[i-1]+a
  else:
    li[i] = a

li = li[::-1]

flag = True
ne = 0.5
for i in range(n+1):
  if li[i]  > 2*ne:
    ans -= li[i] -int(2*ne)

  
  ne = min(li[i] - a_li[i],int(2*ne)-a_li[i])

  if (i == n and ne != 0) or (i != n and ne <= 0):
    flag = False

  
if flag:
  print(ans)
else:
  print(-1)
n, max_dist = int(input().split())

points = 0

for _ in range(n):
  x, y = int(input().split())
  
  dist_origin = sqrt(x * x + y * y)
	if dist_origin <= max_dist:
    	points += 1
        
print(points)


### FIXED CODE ###

import math

n, max_dist = input().split()

points = 0

for _ in range(int(n)):
    x, y = input().split()
    x = int(x)
    y = int(y)

    dist = math.sqrt(x * x + y * y)

    if dist <= float(max_dist):
        points += 1

print(points)
x=input().split()
a = x[0]
b = x[1]

print(a*b,end=' ')
print(a*2+b*2)

### FIXED CODE ###

x=input().split()
a = int(x[0])
b = int(x[1])

print( a*b , a*2+b*2 )
n = input()
print((n-1)*n/2)

### FIXED CODE ###

n = int(input().strip())
print(((n-1)*n)//2)
N = int(input())
nums = list(map(int, input().split()))
cnt = 0
ren = 0
for i in range(N):
  if nums[i] == i+1:
    cnt += 1
    ren += 1
  elif ren > 1:
    cnt -= 1
    ren = 0
  else:
    ren = 0
if ren > 1:
  cnt -= 1
print(cnt)

### FIXED CODE ###

X, t = map(int, input().split())
print(max(X-t, 0))
x=input()
print(x*x*x)


### FIXED CODE ###

x=int(input())
result = x**3
print(result)
# import fractions
import math
from functools import reduce

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

n = int(input())
a = [int(value) for value in input().split(" ")]


a = sorted(a)

b = []
c = []

for value in a:
    if value % 2 != 0:
        b.append(value)
    else:
        c.append(value)

if len(b) == 0:
    a.remove(c[0])
    print(gcd_list(a))
else:
    a.remove(b[0])
    print(gcd_list(a))

### FIXED CODE ###

import fractions
# import math
from functools import reduce
 
def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)
 
n = int(input())
a = [int(value) for value in input().split(" ")]

from_right_gcd = []
from_left_gcd = []

# 左から
for index in range(len(a)):
    if index == 0:
        from_left_gcd.append(a[index])
        continue
    from_left_gcd.append(fractions.gcd(from_left_gcd[index - 1], a[index]))

# 右から
for index in range(len(a) - 1, -1, -1):
    if index == len(a) - 1:
        from_right_gcd.append(a[index])
        continue
    from_right_gcd.append(fractions.gcd(from_right_gcd[len(a) - index - 1 - 1], a[index]))

maybe_answer_list = []

for index in range(len(a)):
    if index == 0:
        maybe_answer_list.append(from_right_gcd[len(a) - 1 - 1])
        continue
    if index == len(a) - 1:
        maybe_answer_list.append(from_left_gcd[index - 1])
        continue
    maybe_answer_list.append(fractions.gcd(from_left_gcd[index - 1], from_right_gcd[len(a) - index - 1 - 1]))

print(max(maybe_answer_list))
n,m,k = map(int,input().split())

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

s = 0
t = 0
for i in range(n+m):
    if a != []:
        c = min(a[0],b[0])
        if c == a[0]:
            a.pop(0)
        else:
            b.pop(0)
    else:
        c = b[0]
        b.pop(0)
    if k-c < s:
        break
    else:
        s += c
        t += 1
print(t)




### FIXED CODE ###

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

A,B = [0],[0]

for i in range(n):
    A.append(A[i] + a[i])
for i in range(m):
    B.append(B[i] + b[i])

ans,j = 0,m

for i in range(n+1):
    if A[i] > k:
        break
    while B[j] > k - A[i]:
        j -= 1
    ans = max(ans,i+ j)
print(ans)
K, X = input().split()
K, X = int(K), int(X)
print(' '.join([i for i in range(X-K+1, X+K)]))

### FIXED CODE ###

K, X = map(int, input().strip().split())
print(' '.join([str(i) for i in range(X-K+1, X+K)]))
n,d=map(int,input().split())
if n%(2*d+1)==0:
  print(int(n/(2*d+1)))
else:
  print(int(n/(2*d+1))+1)

### FIXED CODE ###

r = int(input())

print(3*r*r)
import math
import sys
from collections import defaultdict
from itertools import product, permutations, combinations

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

N = int(input())

if N%2:
    print(0)
    exit()

v = math.floor(math.log(N, 5))

print(sum([N//(2*5**i) for i in range(1, v+1)]))



### FIXED CODE ###

import math
import sys
from collections import defaultdict
from itertools import product, permutations, combinations

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]


N = int(input())
if N % 2:
    print(0)
    exit()
else:
    N //= 2

ans = 0
while N > 0:
    N //= 5
    ans += N
print(ans)
n = int(input())
l = []
for i in range(n):
    x = int(input())
    l.append(x)
l.sort()
l = l[::-1]
ans = 0 
ans += l[0]//2
for i in range(1,n):
    ans+=l[i]
print(ans)




### FIXED CODE ###

n = int(input())
l = ["Christmas"]
for i in range(25-n):
    l.append("Eve")
print(*l)
from math import ceil
n,m=map(int,input().split())
if n==1 or m==1:
  print(1)
  else:
    print(ceil(n/2)*ceil(m/2)+n//2*m//2)

### FIXED CODE ###

from math import floor,ceil
h,w=map(int,input().split())
if h == 1 or w == 1:
    print(1)
else:
    m =ceil(w/2) * ceil(h/2) + floor(w/2) * floor(h/2)
    print(m)
N = int(input())
A = sorted(map(int, input().split()))

colors = [0] * 9

for a in A:
    colors[a // 400] += 1

ans = 0
for i in range(8):
    if colors[i] > 0:
        ans += 1

max_ans = ans
if colors[8] > 0:
    max_ans += colors[8]
print(ans, max_ans)

### FIXED CODE ###

N = int(input())
A = sorted(map(int, input().split()))

colors = [0] * 9
for a in A:
    idx = a // 400
    if idx >= 8:
        idx = 8
    colors[idx] += 1
ans = 0
for i in range(8):
    if colors[i] > 0:
        ans += 1
max_ans = ans
if colors[8] > 0:
    max_ans += colors[8]

if ans == 0 and max_ans > 0:
    ans += 1
print(ans, max_ans)
S = input()
week = {'SUN':7,'MON':6,'TUE':5,'WED':4,'THR':3,'FRI':2,'SAT':1}
print(week[S])

### FIXED CODE ###

S = input()
week = {'SUN':7,'MON':6,'TUE':5,'WED':4,'THU':3,'FRI':2,'SAT':1}
print(week[S])
s = input()
t = input()

cnt = 0
for i in range():
    if s[i] != t[i]:
        cnt += 1

print(cnt)        


### FIXED CODE ###

s = input()
t = input()

cnt = 0
for i in range(len(s)):
    if s[i] != t[i]:
        cnt += 1

print(cnt)
import math
n=int(input())
lists=list(map(int,input().split()))
gcds=lists[0]
for x in range(n-1):
    if x==0:
        gcds=math.gcd(lists[0],lists[1])
    else:
        add=math.gcd(lists[x],lists[x+1])
        gcds=math.gcd(gcds,add)
print(gcds)

### FIXED CODE ###

import fractions
n=int(input())
lists=list(map(int,input().split()))
gcds=lists[0]
for x in range(n-1):
    if n==0:
        gcds=fractions.gcd(lists[0],lists[1])
    else:
        add=fractions.gcd(lists[x],lists[x+1])
        gcds=fractions.gcd(gcds,add)
print(gcds)