peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
n,k,s=map(int,input().split())
if k==n:print(*[s]*n);exit()
if s%2==0:
  ans=[s//2]*(k+1)
  if s<10**8:ans+=(n-len(ans))*[10**9]
  else:ans+=(n-len(ans))*[1]
else:
  ans=[]
  for i in range(k+1):
    ans.append(s//2)
    if i%2==0:ans[-1]+=1
  if s<10**8:ans+=(n-len(ans))*[10**9]
  else:ans+=(n-len(ans))*[1]
print(*ans)
# Judge status: Wrong Answer
n = int(input())
ls = list(map(int,input().split()))
p = 0
for i in list(set(ls)):
    a = ls.count(i)
    p += min(a,abs(a-i))
print(p)
# Judge status: Wrong Answer
S = 'cupofcoffee'
T = 'cupofhottea'

counter = 0

for s, t in zip(S, T):
    if s != t:
        counter += 1

print(counter)
# Judge status: Accepted
K = int(input())
S = input()
if len(S) <= K:
    print(S)
else:
    print(S[:K]+'...')
# Judge status: Wrong Answer
import math
def main():
    #N,K,C=map(int,input().split())
    #A=list(map(int,input().split()))
    S=input()
    S=int(S)
    ans=0
    for i in range(S+1):
        for j in range(S+1):
            tmp=math.gcd(j,i)
            for k in range(S+1):
                ans+=math.gcd(k,tmp)
    #print()
    print(ans)
    

main()
# Judge status: Accepted
n, m = map(int, raw_input().split())
print 'Yes' if n == m else 'No'
# Judge status: Accepted
N, A, B = map(int, input().split())
res = 0
for i in range(N+1):
    if A <= sum([int(s) for s in str(i)]) <= B:
        res += i
print(res)
# Judge status: Accepted
import numpy
N, K  = map(int, input().split(' '))
right = 0
s = 0
for i in range(K, N+2):
    mi = (i-1)*i/2
    ma = (2*N-i+1)*i/2
    s += (ma - mi) + 1
print(int(s%(1e9+7)))
# Judge status: Wrong Answer
s,w = map(int, input().split())

if s > w:
  print('safe')
else:
  print('unsase')
# Judge status: Accepted
from collections import Counter

N = int(input())

sosu = []
while N % 2 == 0:
    sosu.append(2)
    N = int(N/2)

f = 3
while f * f <= N:
    while N % f == 0:
        sosu.append(f)
        N = int(N/f)
    f += 2
if N != 1: sosu.append(N)

count = Counter(sosu)

ans = 0
for k,v in count.items():
    beki = 1
    while beki <= v:
        ans += 1
        v -= beki
        beki += 1
print(ans)
# Judge status: Wrong Answer
MOD = 10*9 + 7

import math
print(math.factorial(int(input()))%MOD)
# Judge status: Accepted
a,b=map(int,input().split())
if a==b:print("Draw")
else:
    if a==1:
        print("Alice")
    elif b==1:
        print("Bob")
    else:
        if a>b:
            print("Alice")
        else:
            print("Bob")
# Judge status: Accepted
a,b=map(int,input().split())
ans=0
for i in range(1,b-a) :
    ans+=i
print(ans-a)
# Judge status: Wrong Answer
def resolve():
	d, n = map(int, input().split())
	print(100**d*n+n//100)
resolve()
# Judge status: Wrong Answer
N = int(input())
P = list(map(int, input().split()))
Q = sorted(P)
 
flag = True
buf = 0
for i, p in enumerate(P):
    if buf > p:
        flag = False
        break
    buf = p

P[i], P[p-1] = P[p-1], P[i]

if P == Q:
    print("YES")
else:
    print("NO")
# Judge status: Accepted
n,a,b = map(int,input().split())

p = b-a-1

if p%2==0:
    ans=0
    if a <=n-b:
        k = a-1
        a-=k
        b-=(k+1)
        ans+=k+1
    else:
        k = n-b
        a+=(k+1)
        b+=k
        ans += k+1
    p=b-a-1

    print(ans + (p+1)//2)
else:
    print((p+1)//2)
# Judge status: Accepted
import numpy as np
S = input()

if S[2] == S[3]:
    if S[4] == S[5]:
        print("Yes")
    else:
        print("No")
else:
    print("No")
# Judge status: Accepted
a = int(input())
l = []
c,f =0, 0
for i in range(a):
    ta,tb = map(int,input().split())
    if ta==tb : c+=1
    else: c = 0
    if c>=3 : f = 1
if f:
    print("Yes")
else:
    print("No")
# Judge status: Wrong Answer
n,m=map(int,input().split())
if n<=2*m:
  res=m-2*n
  ans=n+res//4
else:
  ans=m//2
print(ans)
# Judge status: Wrong Answer
s = {s: list(input()) for s in "abc"}
x = "a"
while(s[x]):
  if len(s[x]) == 0:
    break
  x = s[x][0]
  del s[x][0]
print(x.upper())
# Judge status: Accepted
from math import ceil

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

if ceil(C/B) <= ceil(A/D):
  print("Yes")
else:
  print("No")
# Judge status: Accepted
import os, sys, re, math

(A, B, T) = [int(n) for n in input().split()]

print(T // A * B)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
a.sort(reverse=True)

print(sum(a[1:2*n:2]))
# Judge status: Accepted
A = sorted(list(map(int,input().split())))
cnt = 0
n = (A[2]-A[0])//2
cnt += n
A[0] += 2*n
n = (A[2]-A[1])//2
cnt += n
A[1] += 2*n
A = sorted(A)
if A[0]<A[1]==A[2]:
    cnt += 2
elif A[0]==A[1]<A[2]:
    cnt += 1
print(cnt)
# Judge status: Accepted
a, b = input().split()
keta = len(b) - b.find(".") - 1
a_n = int(a)
b_n = int(b.replace(".", ""))
ans = a_n * b_n
ans_s = str(ans)
if len(ans_s) < keta + 1:
    print(0)
else:
    print(ans_s[:-keta])
# Judge status: Wrong Answer
a, b, c = map(int, input().split())
print(max(a*10+b+c, a+b*10+c))
# Judge status: Accepted
str = input().split('i')
flag = True

for s in str[0:-1]:
  if(flag):
    if(s != 'h'):
      print('No')
      flag = False

if(flag):
  if(str[len(str)-1] != ''):
    print('No')
    flag = False
if(flag):
  print('Yes')
# Judge status: Accepted
s = input()
ans = chr(ord(s)+1)
print(ans)
# Judge status: Accepted
from math import ceil
n = int(input())
a = [int(input()) for _ in range(5)]

print(ceil(n/min(a)) + 4)
# Judge status: Accepted
N = int(input())
ans = 0

for i in range(1, N):
  if N%i == 0:
    ans += N//i -1
  else:
    ans += N//i
print(ans)
# Judge status: Accepted
S=input()
N=len(S)+1
A=[0]*(N)
for i in range(N-1):
    if S[i]=="<":
        A[i+1]=A[i]+1
for i in range(len(S)-1,-1,-1):
    if S[i]==">":
        A[i]=max(A[i+1]+1,A[i])
print(sum(A))
# Judge status: Accepted
N,K=map(int,input().split())
ans=0
for i in range(1,N+1):
  cnt=i
  pro=1
  while cnt<K:
    cnt*=2
    pro/=2
  pro/=N
  #print(pro)
  ans+=pro
print(ans)
# Judge status: Accepted
import heapq

n,m = map(int, input().split())
day_rews_l = [ [] for _ in range(m+1)]
for _ in range(n):
    a,b = map(int, input().split())
    if a > m: continue
    day_rews_l[a].append(b)


jobs = []
ans = 0
for i in range(1,m+1):
    for rew in day_rews_l[i]:
        heapq.heappush(jobs, (-1)*rew)
    if jobs:
        rew_i = heapq.heappop(jobs)
        ans += (-1)*rew_i

print(ans)
# Judge status: Accepted
#!/usr/bin/env python3
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


def solve(K: int, X: int):
    if 500 * K >= X:
        print(YES)
    else:
        print(NO)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    K = int(next(tokens))  # type: int
    X = int(next(tokens))  # type: int
    solve(K, X)


if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

r = int(input())
# Judge status: Accepted
S = sorted(list(set(list(input()))))
alfabet = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
count = 0
for char in alfabet:
    if not(char in S):
        print(char)
        break
    count+=1
if count == 26:
    print("None")
# Judge status: Wrong Answer
K, X = map(int, input().split())

print([x for x in range(X - K + 1, X + K)])
# Judge status: Wrong Answer
"""
author : halo2halo
date : 29, Jan, 2020
"""

import sys
import itertools

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

A, B, C, D = map(int, readline().split())

print(min(B - C,D-C) if B > C else 0)
# Judge status: Accepted
import math

N = int(input())
print(math.ceil(N / 2))
# Judge status: Accepted
n,k,q = map(int,input().split())
li = [k-q]*n
for i in range(q):
    a = int(input())
    li[a-1] += 1
for i in range(n):
    if li[i] >= 1:
        print("Yes")
    else:
        print("No")
# Judge status: Wrong Answer
from operator import itemgetter
from collections import deque

n, m = map(int, input().split())
ab = [tuple(map(int, input().split())) for _ in range(n)]

ab.sort(key=itemgetter(1, 0))
ab = deque(ab)

ans = 0
while ab:
    a, b = ab.pop()
    if a <= m:
       ans += b
       m -= 1
print(ans)
# Judge status: Accepted
import sys
input = sys.stdin.readline


def readstr():
    return input().strip()


def readint():
    return int(input())


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


def readstrs():
    return input().split()


x = readint()

if x % 11 > 6:
    print(x // 11 * 2 + 2)
elif x % 11:
    print(x // 11 * 2 + 1)
else:
    print(x // 11 * 2)
# Judge status: Accepted
A, B, X = map(int, input().split())

if X < A:
  r = 'NO'
elif X - A > B:
  r ='NO'
else:
  r = 'YES'
print(r)
# Judge status: Accepted
H = int(input())
W = int(input())
N = int(input())
v = max(H, W)
ans = N // v
if N%v != 0:
    ans += 1

print(ans)
# Judge status: Accepted
r,g,b=map(int,input().split())
if (10*g+b)%4==0:
  print("YES")
else:
  print("NO")
# Judge status: Accepted
N=int(input())
s=[input() for i in range(N)]
M=int(input())
t=[input() for i in range(M)]
l=[]

tmp=s.copy()
tmp=set(tmp)
tmp=list(tmp)

for i in tmp:
    S=s.count(i)
    T=t.count(i)
    l.append(S-T)
print(max(0,max(l)))
# Judge status: Accepted
n,*a=map(int,open(0).read().split())
tot=sum(a)
v=[1]
for q in a:
  tot-=q
  vt=min(2*(v[-1]-q),tot)
  if vt<0:print(-1);exit()
  v.append(vt)
print(sum(v))
# Judge status: Accepted
a,b,c = tuple(map(int,input().split()))

ans = 0
while True:
  if len(set((a,b,c)))==1:
    if a%2==1:
      print(0)
      exit()
    print(-1)
    exit()
  if a%2==0 and b%2==0 and c%2==0:
    a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
    ans+=1
  else:
    break
print(ans)
# Judge status: Accepted
import numpy as np
a=[list(map(int, input().split())) for _ in range(3)]
a = np.array(a)
for i in range(3):
    a[i]-=min(a[i])
print('Yes' if all(a[0]==a[1]) and all(a[1]==a[2]) else 'No')
# Judge status: Accepted
A, B, K = map(int, input().split())
n = min(A, K)

A -= n
K -= n

n = min(B, K)
B -= n

print(A, B)
# Judge status: Accepted
import numpy as np
n = int(input())
li_a = list(map(int, input().split()))
m = max(li_a)
e = np.zeros(m)
dup = []
for a in li_a:
    if(e[a-1]==1):
        dup.append(a-1)
        continue
    e[a-1] = 1

for i in dup:
    e[i] = 0

for a in set(li_a):
    origin = a
    while a <= m:
        if a==origin:
            a += origin
            continue
        e[a-1]=0
        a += origin
print(int(sum(e)))
# Judge status: Wrong Answer
def laod_to_mill():
    days = int(input())
    prices = tuple(map(int, input().split()))

    if max(prices) == prices[0]:
        print(1000)
        return

    total = 1000
    ks = 0

    for d in range(days - 1):
        total += prices[d] * ks
        ks = 0
     
        if prices[d + 1] > prices[d]:
            ks = total // prices[d]
            total %= prices[d]

    total += ks * prices[-1]
    print(total)


def main():
    laod_to_mill()


if __name__ == '__main__':
    main()
# Judge status: Accepted
n, k = map(int,input().split())
for i in range(0,n):
    if n == 1:
        print(1)
    elif k**i > n:
        print(i)
        break
# Judge status: Wrong Answer
s = input().split(" ")
k = int(s[0])
n = int(s[1])

d = input().split(" ")
dist = []

for i in range(0,n):
    dist.append(int(d[i]))

res = dist[n-1] - dist[0]

for i in range(i, n):
    diff = dist[i] - dist[i-1]
    aux = k - diff
    if aux < res:
        res = aux

print(str(res))
# Judge status: Accepted
a,b=map(int,input().split())
print("Impossible" if a*b*(a+b)%3 else "Possible")
# Judge status: Wrong Answer
import heapq
n,m = map(int,input().split())
xlist = sorted(list(map(int,input().split())))
dlist = []
for i in range(m-1):
  heapq.heappush(dlist,-xlist[i+1]+xlist[i])

for i in range(m-n-2):
  heapq.heappop(dlist)

print(-sum(dlist))
# Judge status: Accepted
n,x,t = map(int,input().split())
cnt = -((-n)//x)
print(t*cnt)
# Judge status: Accepted
import queue
import sys
input = sys.stdin.readline

N, M = map(int, input().split())
AB = []
for _ in range(N):
    ab = list(map(int, input().split()))
    a,b = ab[0], ab[1]
    AB.append((a,b))
AB.sort()

q = queue.PriorityQueue()
idx = 0
ans = 0
for i in range(1, M+1):
    while True:
        if idx >= N or AB[idx][0] > i:
            break
        b = AB[idx][1]
        q.put((-b, b))
        idx += 1
    if not q.empty():
        ans += q.get()[1]
print(ans)
# Judge status: Accepted
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2 * 10**6)


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


def main():
    N = int(input())
    ans = 0
    for i in range(1, N + 1):
        n = N // i
        ans += n * (n + 1) * i // 2
    print(ans)
    return


if __name__ == '__main__':
    main()
# Judge status: Accepted
N = int(input())
A = int(input())

if 0 <= N % 500 <= A:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
W,H,N = map(int,input().split())
grid = []
for i in range(N):
	array = list(map(int,input().split()))
	grid.append(array)
x1 = 0
xW = W
y1 = 0
yH = H
for i in grid:
	if i[2] == 1 and x1 < i[0]:
		x1 = i[0]
	elif i[2] == 2 and xW > i[0]:
		xH = i[0]
	elif i[2] == 3 and y1 < i[1]:
		y1 == i[1]
	elif i[2] == 4 and yH > i[1]:
		yH == i[1]
	else:
		continue
print(max(0,xW-x1)*max(0,yH-y1))
# Judge status: Accepted
a=list(map(int,input().split()))
sum=0
for i in range(1,a[1]-a[0]):
    sum+=i
print(sum-a[0])
# Judge status: Wrong Answer
a, b, c, d = [int(i) for i in input().split()]
if (a//d)>=(c//b):
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
N,M=map(int, input().split())
A=list(map(int, input().split()))

import numpy as np
import fractions
A=np.array(A)

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

mm=1
for x in A//2:
    mm=lcm(mm,x)

if mm%2==0:
    ans=0
else:
    ans=int((M/mm+1)//2)

print(ans)
# Judge status: Accepted
from fractions import gcd

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

gcd=gcd(a,b)
ab_gcd=gcd

f=[]
for i in range(2,int(ab_gcd**0.5)+1):
    while gcd%i==0:
        gcd=gcd//i
        f.append(i)
if gcd!=1:
    f.append(gcd)

print(len(set(f))+1)
# Judge status: Accepted
n,k = map(int,input().split())

if (n % k) > abs(n % k -k):
    print(abs(n%k-k))
else:
    print(n%k)
# Judge status: Accepted
n=int(input())
a=list(map(int,input().split()))
if len(a)==len(list(set(a))):
  print("YES")
else:
  print("NO")
# Judge status: Wrong Answer
N = int(input())
W = [int(weight) for weight in input().split()]
sum_w = sum(W)
left_sum = 0
min = 10000
min_index = 0
for i in range(len(W)):
  left_sum += W[i]
  if abs(sum_w - left_sum) < min:
    min = abs(sum_w - left_sum)
    min_index = i
print(i+1)
# Judge status: Accepted
a = 0

a += int(input())
a += int(input())

print(6 - a)
# Judge status: Accepted
n=int(input())
a=[list(map(int,input().split())) for _ in range(n-1)]
for i in range(n):
    t=0
    for c,s,f in a[i:]:
        k=max(0,(t-s+f-1)//f)
        t=s+f*k+c
    print(t)
# Judge status: Accepted
import sys
input = sys.stdin.readline
 
 
def main():
    n,a,b = [int(i) for i in input().strip().split()]
    if (b-a) % 2 == 0:
        print(abs(b - a) // 2)
    else:
        ans = min(a - 1, n - b) + 1 + (b - a - 1) // 2
        print(ans)
    return 
 
 
 
if __name__ == "__main__":
    main()
# Judge status: Accepted
N = int(input())
cc = list(map(int,input().split()))
min_sum = float('inf')
for i in range(1,101):
  count = 0
  for j in cc:
    count += (i-j)**2
  min_sum = min(min_sum,count)
print(min_sum)
# Judge status: Accepted
import sys
readline = sys.stdin.readline
import fractions

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

def main():
    A, B, C, D = map(int, readline().rstrip().split())
    ans = B - (B//C + B//D - B//lcm_base(C, D))
    ans -= ((A-1) - ((A-1)//C + (A-1)//D - (A-1)//lcm_base(C, D)))
    print(ans)

if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
N=int(input())
lis=[0,0,0,0]
for i in range(N):
  tmp=input()
  if tmp=="AC":
    lis[0]+=1
  elif tmp=="WA":
    lis[1]+=1
  elif tmp=="TLE":
    lis[2]+=1
  else:
    lis[3]+=1
print("AC × "+str(lis[0]))
print("WA × "+str(lis[1]))
print("TLE × "+str(lis[2]))
print("RE × "+str(lis[3]))
# Judge status: Accepted
def main():
    n=int(input())
    s=input()
    
    ans=s[1:].count('E')
    tmp=ans
    for i in range(n-1):
        if s[i]=='W':
            tmp+=1
        if s[i+1]=='E':
            tmp-=1
        ans=min(ans,tmp)
    tmp=s[:-1].count('W')
    ans=min(ans,tmp)
    print(ans)
if __name__=='__main__':
    main()
# Judge status: Accepted
import itertools
import math
import functools

K = int(input())

ans = 0

for i in itertools.product(range(1,K+1),repeat=3):
    ans += functools.reduce(math.gcd,i)
print(ans)
# Judge status: Wrong Answer
s = input()
rt = s.rindex("T")

st = s[: rt + 1].count("T")
sc = s[: rt + 1].count("S")
ans = len(s) - min(st, sc) * 2

print(ans)
# Judge status: Accepted
N, A, B, C, D = map(int, input().split())
S = input()
canA = "##" not in S[A-1:C]
canB = "##" not in S[B-1:D]
if C < D:
    if canA and canB:
        print("Yes")
    else:
        print("No")
else:
    if canA and canB and ("..." in S[B-2:D+1]):
        print("Yes")
    else:
        print("No")
# Judge status: Wrong Answer
N = int(input())
a = [i for i in map(int,input().split())]
ball = [0 for i in range(N)]

a = [0]+a
ball = [0]+ball

for i in range(N,0,-1):
  num = 0
  for j in range(i,N,i):
    num += ball[j]
  if num%2 != a[i]:
    ball[i] += 1
    
print(sum([1 for i in range(len(ball)) if ball[i]]))
num_list = []
for i in range(1,len(ball)):
  if ball[i]:
    num_list.append(i)
    
print(*num_list)
# Judge status: Accepted
a,b,c=map(int,input().split())
print("Yes" if c>=a and c<=b else "No")
# Judge status: Accepted
n = int(input())

ans = 0

for i in range(n+1):
  if i % 3 != 0 and i % 5 != 0:
    ans += i

print(ans)
# Judge status: Accepted
n, x, t = map(int, input().split())
 
if n % x > 0:
  print(int((n//x + 1) * t))
else:
  print(int(n/x * t))
# Judge status: Accepted
import math
N, A, B = [int(i) for i in input().split()]
if A == 0 and B == 0:
    print(0)
else:
    count = A + B
    setCount = math.floor(N / count)
    amari = N - setCount * count
    if amari > 0:
        if A > amari:
            result = setCount * A + amari
        else:
            result = setCount * A + A
    else:
        result = setCount * A
    print(result)
# Judge status: Accepted
S = input()
n = len(S)
shift_max = [0]*(n+1)

big_run = 0
for i in range(n):
    if S[i] == '<':
        big_run += 1
    else:
        big_run = 0
    shift_max[i+1] = big_run
small_run = 0
for i in reversed(range(n)):
    if S[i] == '>':
        small_run += 1
    else:
        small_run = 0
    shift_max[i] = max(shift_max[i],small_run)


print(sum(shift_max))
# Judge status: Wrong Answer
import heapq

Color = []
N = int(input())
for _ in range(N):
    a = int(input())
    if len(Color) == 0:
        Color.append(a)
    elif Color[0] >= a:
        heapq.heappush(Color, a)
    else:
        for i in range(1,len(Color)+1):
            if Color[-i] < a:
                Color[-i] = a
                break

print(len(Color))
# Judge status: Accepted
N = int(input())
A = [0]+list(map(int,input().split()))
for i in range(1,N+1):
  A[i] = A[i]+A[i-1]
ans = float('inf')
for i in range(1,N):
  ans = min(ans, abs(A[N]-2*A[i]))
print(ans)
# Judge status: Accepted
D = int(input())

if D==25:
    print('Christmas')
elif D==24:
    print('Christmas Eve')
elif D==23:
    print('Christmas Eve Eve')
elif D==22:
    print('Christmas Eve Eve Eve')
# Judge status: Wrong Answer
A, B, C, K = map(int,input().split())
if K == 0:
  ans = A-B
else:
  ans = (A-B)**(K-1)
if abs(ans) > 10**18:
  print("Unfair")
else:
  print(ans)
# Judge status: Wrong Answer
n, k = map(int, input().split())
l = list(map(int, input().split()))

ptns = []
for i in range(n-k+1):
    ptns.append(l[i:i+k])

ans = 10**8
for j in ptns:
    ans = min(ans, abs(0 -j[-1]) + abs(j[-1] - j[0]), abs(0 - j[0]) + abs(j[0] - j[-1]))

print(ans)
# Judge status: Accepted
n = int(input())
s = input()
x=0
ans =0
for i in range(0,n):
	if s[i]=='I':
		x =x+1
		ans = max(ans, x)
	else:
		ans = max(ans, x)
		x = x-1
print(ans)
# Judge status: Wrong Answer
s = raw_input()
print 'Yes' if len(s) % 2 == 0 and s[:len(s)/2] == s[len(s)/2:] else 'No'
# Judge status: Accepted
N = int(input())
str_list = []
str_list = [str(input()) for i in range(N)]

print('AC x ' + str(str_list.count(('AC'))))
print('WA x ' + str(str_list.count(('WA'))))
print('TLE x ' + str(str_list.count(('TLE'))))
print('RE x ' + str(str_list.count(('RE'))))
# Judge status: Wrong Answer
import bisect

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

sorted_x = sorted(X)

print(sorted_x)

l, r = sorted_x[n//2-1], sorted_x[n//2]

for x in X:
    if x < r:
        print(r)
    else:
        print(l)
# Judge status: Accepted
import math
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(_) for _ in input().split()]
for i in range(k):
    pre = [0] * (n + 1)
    for j in range(n):
        pre[max(0, j - a[j])] += 1
        pre[min(n, j + a[j] + 1)] -= 1
    total = 0
    good = True
    for j in range(n):
        total += pre[j]
        a[j] = total
        if a[j] != n:
            good = False
    if good:
        break
print(' '.join(map(str, a)))
# Judge status: Accepted
x = int(input())
ans = 0

ans = x//11*2
x %= 11

# 0 <= x < 11 になっている
if x == 0:
  pass
elif x <= 6:
  ans += 1
else:
  ans += 2

print(ans)
# Judge status: Accepted
"""
author : halo2halo
date : 9, Jan, 2020
"""

import sys

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

N = int(readline())

# flag = False
# for i in range(10):
#     for j in range(10):
#         if i * j == N:
#             flag = True
#             break

se = set(x * y for x in range(1, 10) for y in range(1, 10))

ans = 'Yes' if N in se else 'No'
print(ans)
# Judge status: Wrong Answer
N,A,B = [int(x) for x in input().split()]
if abs(A-B)%2==0:
  print(abs(A-B)//2)
else:
  print(min(A-1+B-1,N-A+N-B))
# Judge status: Wrong Answer
n = int(input())
lst = list(map(int,input().split()))
dct = {}
for i in lst:
    dct[i] = dct.get(i, 0) + 1
ans = 0
for i in dct:
    ans += (dct[i] == 1)
print(ans)
# Judge status: Wrong Answer
n = int(input())
a = list(map(int, input().split()))
z = sum(a)
ln = []
x = 0
for i in range(1, n):
    x += a[i]
    ln.append(abs(z - 2 * x))
print(min(ln))
# Judge status: Wrong Answer
import math
n, a, b = map(int,input().split())
if n == 2:
  print(0)
else:
  total = 2 ** n -1
  total  = total - math.factorial(n)//(math.factorial(a)*math.factorial(n-a)) -math.factorial(n) //(math.factorial(b) * math.factorial(n-b))
  print(total // (10 ** 9 + 7))
# Judge status: Wrong Answer
inputs = str(input())
S = int(inputs.split()[0])
W = int(inputs.split()[1])
if S < W:
    print("unsafe")
else:
    print("safe")
# Judge status: Accepted
import numpy as np
ans=0
D=int(input())
C=np.array(list(map(int,input().split())))
last_day=np.array([0 for _ in range(26)])

for day in range(1,D+1):
    score=np.array(list(map(int,input().split())))
    tmp=C*(last_day-day)
    #今回行うコンテストで得られる
    idx=np.argmax(tmp+score)
    # ans=ans+score[idx]+np.sum(tmp)+abs(tmp[idx])
    last_day[idx]=day
    print(idx+1)
# Judge status: Accepted
a, b, c = map(int, input().split())
whole = a + b + c
print("Yes") if (whole / 2) == max([a, b, c]) else print("No")
# Judge status: Wrong Answer
s = int(input())

a = 0

if s >= 100:
  a + 1

if s -100 >= 10:
  a + 1

if s -110 >= 1:
  a + 1
  
print(a)
# Judge status: Wrong Answer
a,b=map(int,input().split())
ans=0
if b<0:
	ans=(b+a+b-1)*a/2
else:
	ans=(b+1+a+b-1)*(a-1)/2

print(ans)