Harryxun/stf_run huggingface dataset:
at2084
n = list(input())
c = n.count('C')
f = n.count('F')
for i in range(len(n)):
    if c >= 1 and f >= 1:
        print('Yes')
    else:
        print('No')


### FIXED CODE ###

s = input()
f = False
l = False
for i in range(len(s)):
    if s[i] == 'C':
        for j in range(i, len(s)):
            if s[j] == 'F':
                print('Yes')
                f = True
                break
        if f == False:
            print('No')
        l = True
        break
if l == False:
    print('No')
while True:
    n,m = list(map(int,input().split()))
    if n == 0 and m == 0:
        break

    amari = int(n % m)
    yasai = list(map(int,input().split())) 
    yasai.sort()

    s = 0
    if amari > 0:
        s = sum(yasai[0:amari])

    i = 0
    for y in yasai[amari:]:
        pass
        if i % m > 0:
            s += y
        i+=1

    print(s)

### FIXED CODE ###

while True:
    try:
        n,m = list(map(int,input().split()))
        if n == 0 and m == 0:
            break
        amari = n % m
        yasai = list(map(int,input().split())) 
        yasai.sort()

        s = 0
        for i in range(n):
            if (i+1) % m > 0:
                s += yasai[-i-1]
        print(s)
    except:
        pass
n,m,x=map(int,input().split)
s=sum(int(i)<x for i in input().split())
print(min(s,m-s))

### FIXED CODE ###

n,m,x=map(int,input().split())
s=sum(int(i)<x for i in input().split())
print(min(s,m-s))
# coding: utf-8
# Your code here!
import math

def isok(a,b,c,d):
    if a < b:
        print('No')
        return
    g= math.gcd(d, b)
    r=((c-a%g)//g)*g+a%g
#    print(r)
    if r+g-b < 0:
        print('No')
    else:
        print('Yes')
    

T=int(input())

for _ in range(T):
    a,b,c,d = list(map(int,input().split()))
    isok(a,b,c,d)



### FIXED CODE ###

# coding: utf-8
# Your code here!
import fractions

def isok(a,b,c,d):
    if a < b or b > d:
        print('No')
        return
    g= fractions.gcd(d, b)
    r=((c-a%g)//g)*g+a%g
#    print(r)
    if r+g-b < 0:
        print('No')
    else:
        print('Yes')
    

T=int(input())

for _ in range(T):
    a,b,c,d = list(map(int,input().split()))
    isok(a,b,c,d)
N,K=map(int,input().split())
li=[]
k=K
for i in range(N):
  a,b=map(int,input().split())
  K-=b
  li.append(a)
  if K<=0:
    li.sort()
    print(li[k-1])
    exit()

### FIXED CODE ###

N,K=map(int,input().split())
li=sorted([list(map(int,input().split())) for _ in range(N)])
for l in li:
  K-=l[1]
  if K<=0:
    print(l[0])
    exit()
hoge = input().split()
N = int(hoge[0])
M = int(hoge[1])
broken = []
for i in range(M):
  broken.append(int(input()))

anss = []
safes = []
fibo = [1,2]
safes.append(broken[0]-1)
for i in range(M-1):
  safes.append(broken[i+1] - broken[i] - 1)

safes.append(N-broken[M-1] - 1)

for i in range(len(safes)):
  if safes[i] == 0:
    anss.append(1) # 間が0
  elif safes[i] == 1:
    anss.append(1) # 間が1つ
  elif safes[i] == 2:
    anss.append(2) # 間が2つ
  else:
    for i in range(safes[i] - 2): # 間が3つ以上
      fibo.append(fibo[i] + fibo[i+1])
    anss.append(fibo.pop())
    fibo = [1, 2]

answer = 1
print(safes)
print(anss)
for i in range(len(anss)):
  answer = answer * anss[i]
# print(safes)
  
flag = 0
for i in range(M-1):
  if broken[i+1] - broken[i] == 1:
    flag = 1

if flag == 0:
  print(answer%1000000007)
else:
  print(0)

### FIXED CODE ###

N, M = list(map(int,input().split()))
     
b = [0]*(N+2)
b[0] = 1
     
for i in range(M):
  b[int(input())] = -1
     
for i in range(N):
  if b[i] != -1:
    if b[i+1] != -1:
      b[i+1] += b[i]
    if b[i+2] != -1:
      b[i+2] += b[i]

print(b[N]%1000000007)
import math

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

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

print(lcm(a,b))

### FIXED CODE ###

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

n = max(a,b)
m = min(a,b)

def gcd(n,m):
    l = n % m
    if l == 0:
        return m
    return gcd(m,l)

def lcm(n,m):
    return (n*m) // gcd(n,m)
    
print(lcm(n,m))
a = int(input())

b = int(input())

ans = int(0)

for i in range(21):
    if b > a*i-i:
            ans += 1
    else:
            break

print(ans)


### FIXED CODE ###

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

ans = int(1)

for i in range(20):
    ans += a-1
    if ans < b:
        continue
    elif i == 0 and 1 == b:
        print(0)
        break
    else:
        print(i+1)
        break
(a, b) = [int(x) for x in input().split(' ')]

di = a // b
m = a % b
df = a / b

print(dl, m, df)

### FIXED CODE ###

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

di = a // b
m = a % b
df = a / b

print('{0} {1} {2:.8f}'.format(di, m, df))
n,k=map(int,input().split())

import math

def boxball(box,ball):
    cal=math.factorial(ball-1)//math.factorial(ball-box)//math.factorial(box-1)
    return cal%1000000007

def redball(box,ball,i):
    if ball==0:
        if i==1:
            return 1
        else:
            return 0
    else:
        cal=math.factorial(ball+1)//math.factorial(ball-box+2)//math.factorial(box-1)
        return cal%1000000007

#print(boxball(3,5),redball(3,5))
    
for i in range(k):
    ans=boxball(i+1,k)*redball(i+2,n-k,i+1)
    print(ans%1000000007)

### FIXED CODE ###

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

import math

def boxball(box,ball):
    if ball>=box:
        cal=math.factorial(ball-1)//math.factorial(ball-box)//math.factorial(box-1)
        return cal%1000000007
    else:
        return 0

def redball(box,ball,i):
    if ball==0:
        if i==1:
            return 1
        else:
            return 0
    else:
        if ball>=box-2:
            cal=math.factorial(ball+1)//math.factorial(ball-box+2)//math.factorial(box-1)
            return cal%1000000007
        else:
            return 0
#print(boxball(3,5),redball(3,5))
    
for i in range(k):
    ans=boxball(i+1,k)*redball(i+2,n-k,i+1)
    print(ans%1000000007)
N = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))
lst = []

for i in range(len(N)):
  lst.append(V[i] - C[i])
  
high_score = 0
  
for i in range(2 ** len(N)):
  a = str(bin(i)).split[2 :]
  b = map(int, a)
  score = 0
  for j in range(len(b)):
    score += lst[i] * b[j]
  if high_score < score:
    high_score = score
    
print(high_score)

### FIXED CODE ###

N = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))
lst = []

for i in range(N):
	if V[i] > C[i]:
		lst.append(V[i] - C[i])

print(sum(lst))
a, b, c = int(input().split())
if a+b+c > 21:
  print("bust")
else:
  print("win")

### FIXED CODE ###

a, b, c = map(int, input().split())
if a+b+c > 21:
  print("bust")
else:
  print("win")
def gcd(a, b):
	if b == 0:
		return a
	_max = max(a, b)
	_min = min(a, b)
	return gcd(_min, _max % _min)

N, X = map(int, raw_input().split())
x = map(int, raw_input().split())

for i in range(N):
	if X < x[i]:
		x.insert(i, X)
		N += 1
diff = []
for i in range(N - 1):
	d = abs(x[i] - x[i+1])
	diff.append(d)

res = diff[0]
for i in range(N - 2):
	res = gcd(res, diff[i + 1])
print res



### FIXED CODE ###

def gcd(a, b):
	if b == 0:
		return 1
	_max = max(a, b)
	_min = min(a, b)
	rest = _max % _min
	if rest == 0:
		return _min
	else:
		return gcd(_min, rest)

N, X = map(int, raw_input().split())
x = map(int, raw_input().split())
x.sort()
	
for i in range(N):
	if X < x[i]:
		x.insert(i, X)
		break
if len(x) == N:
	x.append(X)
diff = []
for i in range(N):
	d = abs(x[i] - x[i+1])
	diff.append(d)

res = diff[0]
for i in range(N - 1):
	res = gcd(res, diff[i + 1])
print res
n = int(input())
a = list(map(int, input().split()))
A = set(a)
if A == (0):
    ans = "Yes"
elif len(A) == 2 and 0 in A:
    b = list(A)
    if a.count(b[1]) == (2*n // 3) :
        ans = "Yes"
elif len(A) == 3:
    b = list(A)
    if b[0]^b[1]^b[2] == 0:
        if a.count(b[0]) == n//3 and a.count(b[1]) == n//3 and a.count(b[2]) == n//3:
            ans = "Yes"
else:
    ans = "No"

print(ans)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
A = list(set(a))
A.sort()
ans = "No"
if len(A) == 1:
    if A[0] == 0:
        ans = "Yes"
elif len(A) == 2:
    if A[0] == 0:
        if a.count(A[1]) == 2* (n // 3) :
            ans = "Yes"
elif len(A) == 3:
    if A[0]^A[1]^A[2] == 0:
        if a.count(A[0]) == n//3:
            if a.count(A[1]) == n//3:
                if a.count(A[2]) == n//3:
                    ans = "Yes"
print(ans)
W = input().lower()
T = ""
while True:
    t = input().lower()
    if t == "END_OF_TEXT":
        break
    T += t
print(T.count(W))


### FIXED CODE ###

W = input().upper()
T = []
while True:
    t = input()
    if t == "END_OF_TEXT":
        break
    T += [x.upper() for x in t.split()]
print(T.count(W))
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return map(int, sys.stdin.readline().split())
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())


def FLIST(n):
    res = [1]
    for i in range(1, n+1):
        res.append(res[i-1]*i % DVSR)
    return res


class ModInt:
    def __init__(self, a, dvsr=DVSR):
        self.dvsr = dvsr
        self.value = a % dvsr

    def __iadd__(self, b):
        self.value += b
        self.value %= self.dvsr

    def __isub__(self, b):
        self.value -= b
        self.value %= self.dvsr

    def __imul__(self, b):
        self.value *= b
        self.value %= self.dvsr

    def __ifloordiv__(self, b):
        self.value *= pow(b, self.dvsr - 2, self.dvsr)
        self.value %= self.dvsr

    def __str__(self):
        return str(self.value)


N, M = LI()
FACT = FLIST(M)


def NCR(n, r):
    res = FACT[n-r]
    res *= FACT[r]
    res %= DVSR
    res = INV(res)
    res *= FACT[n]
    res %= DVSR
    return res


def NPR(n, r):
    res = FACT[n]*INV(FACT[n-r])
    res %= DVSR
    return res


ALL = ModInt(NPR(M, N))
ALL *= ALL.value

PAT = ModInt(0)
for i in reversed(range(1, N+1)):
    v = ModInt(NCR(N, i))
    v *= NPR(M, i)
    v *= NPR(M-i, N-i)
    v *= NPR(M-i, N-i)
    PAT = ModInt(v.value - PAT.value)

print(ModInt(ALL.value - PAT.value))


### FIXED CODE ###

import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return map(int, sys.stdin.readline().split())
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())


def FLIST(n):
    res = [1]
    for i in range(1, n+1):
        res.append(res[i-1]*i % DVSR)
    return res


N, M = LI()
FACT = FLIST(M)


def NCR(n, r):
    res = 1
    res *= FACT[n-r]
    res *= FACT[r]
    res %= DVSR
    res = INV(res)
    res *= FACT[n]
    res %= DVSR
    return res


def NPR(n, r):
    res = 1
    res *= FACT[n]
    res *= INV(FACT[n-r])
    res %= DVSR
    return res


ALL = NPR(M, N)
ALL %= DVSR
ALL *= ALL
ALL %= DVSR


PAT = 0
for i in reversed(range(1, N+1)):
    v = NCR(N, i)
    v *= NPR(M, i)
    v %= DVSR
    v *= NPR(M-i, N-i)
    v %= DVSR
    v *= NPR(M-i, N-i)
    v %= DVSR
    PAT = v - PAT
    PAT %= DVSR

print((ALL - PAT) % DVSR)
n=int(input())
a=[int(x) for x in input().split()]
c=0
for i in range(n):
  c+=1//a[i]
print(1//c)

### FIXED CODE ###

n=int(input())
a=[int(x) for x in input().split()]
c=0
for i in range(n):
  c+=a[i]**(-1)
print(c**(-1))
N, K = map(int, input().split())
S = list(map(str, input()))
score = 0
for i in range(1, N):
	if S[i] == S[i + 1]:
		score += 1
print(min(score + 2 * K, N - 1))

### FIXED CODE ###

N, K = map(int, input().split())
S = list(map(str, input()))
score = 0
for i in range(N - 1):
	if S[i] == S[i + 1]:
		score += 1
print(min(score + 2 * K, N - 1))
s = input()
sl = list(s)
for i in range(1, len(sl) + 1):
    if i % 2 == 1:
        if sl[i] == 'L':
            print('No')
            break
        else:
            continue
    else:
        if sl[i] == 'R':
            print('No')
            break
        else:
            continue
else:
    print('Yes')

### FIXED CODE ###

s = input()
sl = list(s)
for i in range(len(sl)):
    if (i + 1) % 2 == 1:
        if sl[i] == 'L':
            print('No')
            break
        else:
            continue
    else:
        if sl[i] == 'R':
            print('No')
            break
        else:
            continue
else:
    print('Yes')
import fractions # version 3.4
from collections import defaultdict
from functools import reduce

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

def lcm(*numbers):
    ans = numbers[0]
    for a in numbers:
        ans = ans * a // fractions.gcd(ans, a)
    # return reduce(lambda x,y: (x * y) // fractions.gcd(x, y), numbers, 1)

    return ans


def s_in():
    return input()

def n_in():
    return int(input())

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

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

N, M = l_in()
A = l_in()

B = [a//2 for a in A]
L = lcm(*B)

if any((L//b)%2 == 0 for b in B):
    print(0)
else:
    print((M//L + 1)//2)


### FIXED CODE ###

def s_in():
    return input()

def n_in():
    return int(input())

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

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res


K, X = l_in()

if 500*K >= X:
    print("Yes")
else:
    print("No")
n = int(input())
a = int(input())
b = int(input())
if n == 1:
    print('Hello World')
else:
    print(a + b)

### FIXED CODE ###

n = int(input())
if n == 1:
    print('Hello World')
else:
    a = int(input())
    b = int(input())
    print(a + b)
def det(n):
    seven = range((n // 7) + 1)
    four = range((n // 4) + 1)
    for i in seven:
        for p in four:
            if (i*7 + p*4) == n:
                return 'Yes'
    return 'No'
x = int(input)
print(det(x))

### FIXED CODE ###

def cakes_and_donuts(arg1):
    four = range(( arg1 // 4 ) + 1)
    seven = range(( arg1 // 7 ) + 1)
    for i in seven:
        for p in four:
            if (i*7 + p*4) == arg1:
                return 'Yes'
    return 'No'

N = int(input())
print(cakes_and_donuts(N))
N = int(input())
x, y, h = [], [], []
for i in range(N):
    s, t, u = map(int, input().split())
    x.append(s)
    y.append(t)
    h.append(u)

for i in range(N):
    tmp = []
    for cx in range(101):
        for cy in range(101):
            H = h[i] + abs(x[i] - cx) + abs(y[i] - cy)
            tmp.append((cx, cy, H)) # setはtmp.add(要素)で追加できるが要素としてtupleを追加しようとすると和集合を書いたりしなきゃいけないので遅い
    if i == 0:
        ans = tmp
    else:
        ans = set(ans) & set(tmp) # set

ans = list(list(ans)[0])
ans = ' '.join(list(map(str, ans)))
print(ans)







### FIXED CODE ###

N = int(input())
x, y, h = [], [], []
for i in range(N):
    s, t, u = map(int, input().split())
    x.append(s)
    y.append(t)
    h.append(u)

# h>0となるものは必ず存在するので
# そのときの答えの(cx, cy, H)の候補としてprobに(10000個)格納する
# 最大でN*100*100=10^6
prob = []
for i in range(N):
    if h[i] > 0:
        for cx in range(101):
            for cy in range(101):
                H = h[i] + abs(x[i] - cx) + abs(y[i] - cy)
                prob.append([cx, cy, H])
        break

# 答えの候補probの中から全ての条件を満たすものを探す
# 最大でN*10000=10^6
for i in range(N):
    minus = []
    for j in range(len(prob)):
        cx = prob[j][0]
        cy = prob[j][1]
        H = prob[j][2]
        if h[i] == max(H - abs(x[i] - cx) - abs(y[i] - cy), 0):
            continue
        else:
            minus.append([cx, cy, H])
    if len(minus) == 0:
        continue
    else:
        for k in range(len(minus)):
            prob.remove(minus[k])

ans = ' '.join(list(map(str, list(list(prob)[0]))))
print(ans)
N, W = map(int,input().split())

dp = [[0]*(101) for i in range(N+1)]

for i in range(N):
    w, v = map(int,input().split())
    for j in range(10000):
        if j - v >= 0:
            dp[i+1][j] = max(dp[i][j],dp[i][j-v] + w)
        else:
            dp[i+1][j] = dp[i][j]


print(dp)

### FIXED CODE ###

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

dp = [[10**12]*((10**3)*N+1) for i in range(N+1)]
dp[0][0] = 0
v_sum = 0
for i in range(N):
    w, v = map(int,input().split())
    v_sum += v
    for j in range((10**3)*N+1):
        if j > v_sum:
            break
        if j - v >= 0:
            dp[i+1][j] = min(dp[i][j],dp[i][j-v]+w)#諸悪の根源
        else:
            dp[i+1][j] =dp[i][j]

for i in range(len(dp[-1])):
    if 0 < dp[-1][i]<= M:
        ans = i
    else:
        pass

print(ans)
a = list(map(int,input().split()))
sum = a[0] + a[1] + a[2]
if sum >= 22
	print("bust")
else:
	print("win")

### FIXED CODE ###

a = list(map(int,input().split()))
sum = a[0] + a[1] + a[2]
if sum >= 22:
	print("bust")
else:
	print("win")
def func(len_a):
    ans = ""
    for i in range(1, len_a):
        if i & 1 == 0:
            ans += "0"
        elif i & 1 == 1:
            ans += "9"
    return ans

def main():
    a = input()
    len_a = len(a)
    if len_a & 1 == 0:
        ans = func(len_a)
        print(ans)
    else:
        ans = int(func(len_a-1))
        ans = ans + ( int(a) - 10 ** (len_a-1) ) + 1
        print(ans)


main()


### FIXED CODE ###

def func(len_a):
    ans = ""
    for i in range(1, len_a):
        if i & 1 == 0:
            ans += "0"
        elif i & 1 == 1:
            ans += "9"
    return ans

def main():
    a = input()
    len_a = len(a)
    if len_a & 1 == 0:
        ans = func(len_a)
        print(ans)
    else:
        if len_a == 1:
            print(a)
        else:
            ans = int(func(len_a-1))
            ans = ans + ( int(a) - 10 ** (len_a-1) ) + 1
            print(ans)


main()
# -*- coding: utf-8 -*-
import numpy as np

K = int(input())
K = K

# astypeを入れないとおかしくなっちゃう
a = np.ones(50).astype(np.int64)*(49) + (K)//50

if K%50 != 0:
    a[:K%50] += 51 - (K%50)
    a[K%50:] -= (K%50)
else:
    pass
              
result = "50\n{}".format(a[0])
for a_ in a[1:]:
    result += (" {}".format(int(a_)))
print(result)

### FIXED CODE ###

# -*- coding: utf-8 -*-

N, M = [int(n) for n in input().split()]
islands = {n:[] for n in range(1, N+1)}
result = "IMPOSSIBLE"

for m in range(M):
    a, b = [int(n) for n in input().split()]
    islands[a].append(b)
    islands[b].append(a)

ok_isl = set()
search_isl = [1]
next_isl = set()

loop = True
for x in range(2):
    for i in search_isl:
        if N in islands[i]:
            loop = False
            result = "POSSIBLE"            
        else:
            next_isl.update(islands[i])
    
    ok_isl = ok_isl.union(search_isl)
    
    search_isl = next_isl.difference(ok_isl)
    if len(search_isl) == 0:
        break

print(result)
n, K = map(int, input().split())
a = list(map(int, input().split()))

MAX = 40

k = [0 for _ in range(MAX)]
c = [0 for _ in range(MAX)]
b = [0 for _ in range(MAX)]
v = [[0 for _ in range(MAX)] for _ in range(2)]

d = 0
while K > 0:
    if K % 2 == 1:
        k[d] = 1
    d += 1
    K //= 2

for p in a:
    counter = 0
    while p > 0:
        if p % 2 == 1:
            c[counter] += 1
        counter += 1
        p //= 2

temp = 1
for i in range(MAX):
    if c[i] > n - c[i]:
        b[i] = 0
    else:
        b[i] = 1
    v[0][i] = temp * c[i]
    v[1][i] = temp * (n - c[i])
    temp *= 2

ans = 0
for i in range(d, -1, -1):
    if k[i] == 0:
        continue

    temp_ans = 0
    for j in range(i+1, MAX):
        temp_ans += v[k[j]][j]

    temp_ans += v[0][i]

    for j in range(i):
        temp_ans += v[b[j]][j]

    ans = max(ans, temp_ans)

print(ans)


### FIXED CODE ###

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

MAX = 41

k = [0 for _ in range(MAX)]
c = [0 for _ in range(MAX)]
b = [0 for _ in range(MAX)]
v = [[0 for _ in range(MAX)] for _ in range(2)]

K = input_k + 1
d = 0
while K > 0:
    if K % 2 == 1:
        k[d] = 1
    d += 1
    K //= 2

for p in a:
    counter = 0
    while p > 0:
        if p % 2 == 1:
            c[counter] += 1
        counter += 1
        p //= 2

temp = 1
for i in range(MAX):
    if c[i] > n - c[i]:
        b[i] = 0
    else:
        b[i] = 1
    v[0][i] = temp * c[i]
    v[1][i] = temp * (n - c[i])
    temp *= 2

if input_k == 0:
    print(sum(v[0]))
    exit()

ans = 0
for i in range(MAX - 1, -1, -1):
    if k[i] == 0:
        continue

    temp_ans = 0
    for j in range(i+1, MAX):
        temp_ans += v[k[j]][j]

    temp_ans += v[0][i]

    for j in range(i):
        temp_ans += v[b[j]][j]

    #print(i, temp_ans)
    ans = max(ans, temp_ans)

print(ans)
n,a,b=map(int,input().split())

if (b-a)%2==0:
    print((b-a)//2)
else:
    print(min((b+a-1)//2),(2*n-a-b+1)//2)

### FIXED CODE ###

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

if (b-a)%2==0:
    print((b-a)//2)
else:
    print(min((b+a-1)//2,(2*n-a-b+1)//2))
N,Q= map(int, input().split())
d = {}
counter = [0]*N
for i in range(N-1):
    key, value = input().split()
    if key in d.keys():
        d[key] += value
    else:
        d[key] = value

def fun_dict(key):
    temp = len(d[key])
    for i in range(temp):
        if d[key][i] in d.keys():
            d[key] += d[d[key][i]]
            fun_dict(d[key][i])
fun_dict('1')

for i in range(Q):
    p, x = map(int, input().split())
    counter[p-1] += x
    if str(p) in d.keys():
        for values in d[str(p)]:
            counter[int(values) - 1] += x
print(list(map(str, counter)))
print(' '.join(map(str, counter)))

### FIXED CODE ###

from collections import deque
N,Q= map(int, input().split())
tree = [[] for _ in range(N)]
counter = [0]*N
visited = [False]*N
q = deque([0])

for i in range(N-1):
    a,b = map(int, input().split())
    tree[a-1].append(b-1)
    tree[b-1].append(a-1)

for i in range(Q):
    p,x = map(int, input().split())
    counter[p-1] += x

while q:
    parent = q.popleft()
    visited[parent] = True
    for child in tree[parent]:
        if visited[child]:
            continue
        counter[child] += counter[parent]
        q.append(child)
print(*counter)
import math
a,b,n=map(int,input().split())
max=-2
lim=min(n,b)
for i in range(1,lim+1):
    if i<b:
        s=math.floor(a*i/b)
    else:
        s=math.floor(a*i/b)-a*floor(i/b)
    if s>max:
        max=s
print(int(max))

### FIXED CODE ###

import math
a,b,n=map(int,input().split())
max=-2
if n<b:
    max=math.floor(a*n/b)
else:
    #b<=n
    max=math.floor(a*(b-1)/b)
    

print(max)
a = int(input())
b = int(math.sqrt(a))-1
for i in range(b):
    x = a/b
    if x.is_integer():
        break
    else:
        b -= 1
print(int(x + b -2))

### FIXED CODE ###

import math
a = int(input())
b = int(math.sqrt(a))
for i in range(b):
    x = a/b
    if x.is_integer():
        break
    else:
        b -= 1
print(int(x + b -2))