Harryxun/stf_run huggingface dataset:
#!/usr/bin/env python3


def main():
    N = map(int, open(0).read().split())
    print(-(-N // 2))


main()


### FIXED CODE ###

#!/usr/bin/env python3


def main():
    N = int(input())
    print(-(-N // 2))


main()
import numpy as np
a,b,c=map(int, input().split())
if a**2+c**2<b**2-2*np.sqrt(ac):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

a,b,c=map(int, input().split())
r=c-a-b
if r > 0 and r**2>4*a*b:
  print("Yes")
else:
  print("No")
import sys
import math
import collections
import itertools
import array
from functools import reduce
import inspect

# Set max recursion limit
sys.setrecursionlimit(10000)

# Debug output
def chkprint(*args):
    names = {id(v):k for k,v in inspect.currentframe().f_back.f_locals.items()}
    print(', '.join(names.get(id(arg),'???')+' = '+repr(arg) for arg in args))

# Binary converter
def to_bin(x):
    return bin(x)[2:]

# --------------------------------------------

dp = None
A = []

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

def f(m):
    ans = 0
    for a in A:
        ans += m % a
    return ans

def main():
    global A

    N = int(input())
    A = [int(_) for _ in input().split()]

    lcmtemp = 1

    for a in A:
        lcmtemp = lcm(lcmtemp, a)

    print(f(lcmtemp-1))

main()


### FIXED CODE ###

import sys
import fractions

dp = None
A = []

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

def f(m):
    ans = 0
    for a in A:
        ans += m % a
    return ans

def main():
    global A

    N = int(input())
    A = [int(_) for _ in input().split()]

    lcmtemp = 1

    for a in A:
        lcmtemp = lcm(lcmtemp, a)

    print(f(lcmtemp-1))

main()
r1, c1, r2, c2 = list(map(int, input().split()))

mod = 1_000_000_007

# return an integer k s.t. (a * k) % p = 1 and 0 <= k < p.
def inversion(a, p):
    b = p
    u, v = 1, 0
    while b >= 1:
        t = a // b
        a -= t * b
        a, b = b, a
        u -= t * v
        u, v = v, u
    u %= p
    if u < 0:
        u += p
    return u

# return nCr % p.
def combination(n, r, p):
    if n < r:
        return 0
    r = min(n - r, r)
    nCr = 1
    for d in range(1, r + 1):
        nCr *= n
        nCr %= p
        n -= 1
        nCr *= inversion(d, p)
        nCr %= p
    return nCr

answer = (
combination(r2 + c2 + 2, r2 + 1, mod) - 
combination(r2 + c1 + 1, r2 + 1, mod) -
combination(r1 + c2 + 1, c2 + 1, mod) +
combination(r1 + c1, c1, mod))

answer %= mod

if answer < 0:
    answer += mod

print(answer)






### FIXED CODE ###

r1, c1, r2, c2 = list(map(int, input().split()))

mod = 1000000007

# return an integer k s.t. (a * k) % p = 1 and 0 <= k < p.
def inversion(a):
    b = mod
    u, v = 1, 0
    while b >= 1:
        t = a // b
        a -= t * b
        a, b = b, a
        u -= t * v
        u, v = v, u
    u %= mod
    if u < 0:
        u += mod
    return u

fact = [0 for i in range(2000003)]
for i in range(2000003):
    if i <= 1:
        fact[i] = 1
    else:
        fact[i] = (fact[i-1] * i) % mod

# return nCr % p.
def combination(n, r):
    return (((fact[n] * inversion(fact[r])) % mod) * inversion(fact[n-r])) % mod

answer = (
combination(r2 + c2 + 2, r2 + 1) -
combination(r2 + c1 + 1, r2 + 1) -
combination(r1 + c2 + 1, c2 + 1) +
combination(r1 + c1    , c1    ) )

answer %= mod

if answer < 0:
    answer += mod

print(answer)
n = int(input())
min_ = n -1 
for i in range(1, n**0.5+10):
  if n % i != 0:
    continue
  else:
    min_ = min(min_, i-1+n//i-1)
    
print(min_)

### FIXED CODE ###

n = int(input())
min_ = n -1 
for i in range(1, int(n**0.5)+10):
    if n % i != 0:
        continue
    else:
        min_ = min(min_, i-1+(n//i)-1)
    
print(min_)
A = 0
S = input()
fot n in tange(1,int(S)+1):
 A = A + n

### FIXED CODE ###

A = 0
S = input()
for n in range(1,int(S)+1):
 A = A + n
print(A)
n = int(input())

ans = ""

while(n > 0):
    tmp = n % 26
    if tmp > 0:
        ans += chr((tmp - 1) + ord('a'))
    else:
        ans += 'z'
        n -= 1
    n /= 26
    if n == 0:
        break

print(ans[::-1])


### FIXED CODE ###

n = int(input())

ans = ""

al = ['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']

while n > 0:
    tmp = n % 26
    if tmp > 0:
        ans += al[tmp-1]
    else:
        ans += 'z'
        n = n - 1
    n = n // 26

print(ans[::-1])
s=list(input())
if (A not in s) or (B not in s):
  print("No")
else:
  print("Yse")

### FIXED CODE ###

s=list(input())
if ("A" not in s) or ("B" not in s):
  print("No")
else:
  print("Yes")
n = int(input())
print(int(n*(n-1)//2))

### FIXED CODE ###

s = input()
t = input()
ans = 0
for i in range(3):
  if s[i]==t[i]:
    ans += 1
  else:
    pass
print(ans)
S = input() 
if == ('hi' or 'hihi' or 'hihihihi' or 'hihihihihi'):
  print('Yes')
else:
  print('No')

### FIXED CODE ###

S = input() 
if (S == 'hi' or S == 'hihi' or S == 'hihihi' or S == 'hihihihi' or S == 'hihihihihi'):
  print('Yes')
else:
  print('No')
import math
N = int(input())

res = []
for i in range(N):
    cal = math.floor(i * 1.08)
    if cal == N:
        res.append(i)
print(res[0])

### FIXED CODE ###

import math
N = int(input())

res = []
for i in range(1,N+1):
    cal = math.floor(i * 1.08)
    if cal == N:
        res.append(i)
if len(res) == 0:
    print(':(')
else:
    print(res[0])
!

### FIXED CODE ###

x = int(input())
print(1 if x ==0 else 0)
a, b = [int(i) for i in input().split()]
small = min(a, b)
big = max(a, b)

import sys

if small == 1:
    print(1)
    sys.exit(0)

import math

prime_flag = [True] * (small + 1)
#limit  = int(math.sqrt(small))
#for i in range(2, limit + 2):
#    if not prime_flag[i]:
#        continue
#    for j in range(i + i, small + 1, i):
#        prime_flag[j] = False

#primes = [i for i, _ in enumerate(prime_flag) if prime_flag[i]][2:]
#cd = [p for p in primes if (small % p == 0) and (big % p == 0)]
#
#print(len(cd) + 1)


### FIXED CODE ###

a, b = [int(i) for i in input().split()]
small = min(a, b)
big = max(a, b)

import sys

if small == 1:
    print(1)
    sys.exit(0)

import math
import collections

# FYI: https://ja.wikipedia.org/wiki/%E8%A9%A6%E3%81%97%E5%89%B2%E3%82%8A%E6%B3%95
def prime_factorization(num, divisors=None):
    if num <= 1:
        assert False
    factors = []

    # divisorsを使い回せるようにする。
    #   - 二度生成した場合にかかる時間が許容できない場合
    #   - エラトステネスの篩などで素数テーブルを既に持っている場合
    if not divisors:
        divisors = [2] + [i for i in range(3, int(math.sqrt(num)) + 1) if i % 2 != 0]

    for d in divisors:
        # divisorsを引数で与えた場合のみ起こりうる
        if num < d:
            break
        while num % d == 0:
            factors.append(d)
            num //= d

    if num != 1:
        factors.append(num)
    return factors

divisors = [2] + [i for i in range(3, int(math.sqrt(big)) + 1) if i % 2 != 0]
small_factors = set(prime_factorization(small, divisors))
big_factors = set(prime_factorization(big, divisors))

print(len(small_factors.intersection(big_factors)) + 1)
n = int(input())
ans = 0
for i in range(n):
  a, b = map(int, input().split())
  if b = 'JPY':
    ans += a
  else:
    ans += a * 380000
print(ans)

### FIXED CODE ###

n = int(input())
ans = 0
for i in range(n):
  a, b = map(str, input().split())
  if b == 'JPY':
    ans += float(a)
  else:
    ans += float(a) * 380000
print(ans)
from collections import deque
import sys
import numpy as np
input = sys.stdin.readline
h,w=map(int, input().split(' '))
a = [list(input()) for i in range(h)]
b = np.zeros((h,w).dtype=int64)
q = deque()
for i in range(h):
    for j in range(w):
        if a[i][j] == "#":
            q.append([i,j,0])
        else:
            b[i][j]=-1
"""
while q:
    [s,t,cnt] = q.popleft()
    if s>0 and a[s-1][t] == -1:
        q.append([s-1,t,cnt+1])
        a[s-1][t] = cnt+1
    if s<h-1 and a[s+1][t] == -1:
        q.append([s+1,t,cnt+1])
        a[s+1][t] = cnt+1
    if t>0 and a[s][t-1] == -1:
        q.append([s,t-1,cnt+1])
        a[s][t-1] = cnt+1
    if t<w-1 and a[s][t+1] == -1:
        q.append([s,t+1,cnt+1])
        a[s][t+1] = cnt+1
ans = 0
for i in range(h):
    ans = max(ans,max(a[i]))
print(ans)
"""


### FIXED CODE ###

from collections import deque
import sys
input = sys.stdin.readline
h,w=map(int, input().split(' '))
a = [input() for i in range(h)]
nl = [[] for i in range(h)]
q = deque()
for i in range(h):
    for j in range(w):
        if a[i][j] == "#":
            nl[i].append(0)
            q.append([i,j,0])
        else:
            nl[i].append(-1)
while q:
    [s,t,cnt] = q.popleft()
    if s>0 and nl[s-1][t] == -1:
        q.append([s-1,t,cnt+1])
        nl[s-1][t] = cnt+1
    if s<h-1 and nl[s+1][t] == -1:
        q.append([s+1,t,cnt+1])
        nl[s+1][t] = cnt+1
    if t>0 and nl[s][t-1] == -1:
        q.append([s,t-1,cnt+1])
        nl[s][t-1] = cnt+1
    if t<w-1 and nl[s][t+1] == -1:
        q.append([s,t+1,cnt+1])
        nl[s][t+1] = cnt+1
ans = 0
for i in range(h):
    ans = max(ans,max(nl[i]))
print(ans)
A.py

### FIXED CODE ###

N = int(input())
A = int(input())

print(N * N - A)
n = int(input())
li = list(map(int, input().split()))

import collections
odd = collections.defaultdict(lambda : 0)
even = collections.defaultdict(lambda: 0)

for index, i in enumerate(li):
    if index % 2 == 0:
        even[i] += 1
    elif index % 2 != 0:
        odd[i] += 1

# odd = list(filter(lambda x: x % 2 != 0, li))
sorted_odd = [(k, odd[k]) for k in sorted(odd, key=odd.get, reverse=True)]
max_odd = sorted_odd[0]
# even = list(filter(lambda x: x % 2 == 0, li))
sorted_even = [(k, even[k]) for k in sorted(even, key=even.get, reverse=True)]
max_even = sorted_even[0]

if max_odd[0] == max_even[0] and len(sorted_odd) == 1 and len(sorted_even) == 1:
    print(int(n / 2))
elif max_odd[0] == max_even[0]:
    if len(sorted_odd) >= 2:
        print(int(n/2 - sorted_odd[1] + n/2 - max_even[1]))
    elif len(sorted_even) >= 2:
        print(int(n/2 - sorted_even[1] + n/2 - max_odd[1]))
else:
    print(int(n/2 - max_odd[1] + n/2 - max_even[1]))




### FIXED CODE ###

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

even = []
odd = []

for index, i in enumerate(li):
    if index % 2 == 0:
        even.append(i)
    elif index % 2 != 0:
        odd.append(i)

from collections import Counter
so_ev = Counter(even).most_common(2)
so_od = Counter(odd).most_common(2)

if so_ev[0][0] == so_od[0][0]:
    if len(so_ev) == 1 and len(so_od) == 1:
        print(n - so_ev[0][1])
    else:
        print(min(n - so_ev[1][1] - so_od[0][1], n - so_ev[0][1] - so_od[1][1]))
else:
    print(n - so_ev[0][1] - so_od[0][1])
s = input()
K = int(input())

ans = ''
for i in range(len(s)):
    if K >= ord('z')-ord(s[i])+1:
        K -= ord('z')-ord(s[i])+1
        ans += 'a'
    else:
        ans += s[i]

if K >= 1:
    ans = ans[:len(s)-1]+chr(ord(ans[-1])+K)

print(ans)


### FIXED CODE ###

s = input()
K = int(input())

ans = []
for i in range(len(s)):
    if K >= ord('z')-ord(s[i])+1 and s[i] != 'a':
        K -= ord('z')-ord(s[i])+1
        ans.append('a')
    else:
        ans.append(s[i])

if K >= 1:
    ans[-1] = chr(ord(ans[-1])+K % 26)

print(''.join(ans))
s=input()
t=input()
a = len(s)
b = len(t)
l = []
for i in range(a-b+1):
    cnt = 0
    c = s[i,i+t]
    for x, y in zip(c, t):
        if x != y:
            cnt +=1
    l.append(cnt)
print(min(l))

### FIXED CODE ###

s=input()
t=input()
a = len(s)
b = len(t)
l = []
for i in range(a-b+1):
    cnt = 0
    c = s[i:i+b]
    for x, y in zip(c, t):
        if x != y:
            cnt +=1
    l.append(cnt)
print(min(l))
n, m = map(int, input().split())

a = []

for i in m:
  a1, a2 = map(int, input().split())
  a.append(a1)
  a.append(a2)

for s in n:
  print(a.count(s))

### FIXED CODE ###

n, m = map(int, input().split())
 
a = []
 
for i in range(m):
  a1, a2 = map(int, input().split())
  a.append(a1)
  a.append(a2)
 
for s in range(n):
  print(a.count(s+1))
N = int(input())
l = [input()]
for i in range(1,N):
    s = 0
    t = i
    a = input()
    while t-s > 1:
        if a <= l[int((s+t+1)/2)]:
            t = int((s+t+1)/2)
        else:
            s = int((s+t+1)/2)
    if l[s] != a:
        l.insert(t,a)
print(len(l))


### FIXED CODE ###

N = int(input())
l = []
for i in range(N):
    l.append(input())
k = sorted(l)
ans = 0
a = 0
for i in range(N):
    if k[i]!=a:
        ans+= 1
        a = k[i]
print(ans)
N,x,MOD = map(int, input().split())
s = x
t_s = 0
for i in range(2,MOD + 1):
  x = (x*x)%MOD
  s += x
  if i == N:
    break
res = N - i
init = x
t_s = x
cnt = 1
for i in range(0,MOD):
  x = (x*x)%MOD
  if x == init:
    break
  cnt += 1
  t_s += x
bai = res // cnt
res = res %  cnt
s += t_s * bai
if res > 0:
  for i in range(res):
    x = (x*x)%MOD
    s += x
else:
  pass
print(s)

### FIXED CODE ###

N,x,MOD = map(int, input().split())
s = x
flag = False
sflag = False
if N == 1:
  flag = True
  sflag = True
  print(s)
for i in range(1,MOD):
  x = (x*x) % MOD
  s += x
  if N == (i+1):
    flag = True
    break
if flag == True:
  if sflag == False:
    print(s)
else:
  t_s = 0
  cnt = 0
  init = x
  for i in range(MOD):
    x = (x*x) % MOD
    t_s += x
    cnt += 1
    if x == init:
      break
  bi = (N-MOD)//cnt
  res = (N-MOD)%cnt
  s += t_s * bi
  for i in range(res):
    x = (x*x) % MOD
    s += x
  print(s)
N=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(0,N+1,2):
    if a[i]%2==1:
        ans+=1
print(ans)

### FIXED CODE ###

N=int(input())
a=list(map(int,input().split()))
ans=0
for i in range(N):
    if (i+1)%2==1 and a[i]%2==1:
        ans+=1
print(ans)
h, w, m = map(int, input().split())
mapa = [[0]*w for i in range(h)]
strings = [0]*h
rows = [0]*w
for i in range(m):
    h1, w1 = map(int, input().split())
    mapa[h1-1][w1-1] = 1
    strings[h1-1] += 1
    rows[w1-1] += 1
maxs = max(strings)
maxr = max(rows)
summa = maxs + maxr - 1
fl = True
for i in range(h):
    if fl and strings[i] == maxs:
        for j in range(w):
            if rows[j] == maxr:
                if mapa[i][j] != 1:
                    summa = maxs + maxr
                    fl = False
                    break
print(summa)


### FIXED CODE ###

def main():
    h, w, m = map(int, input().split())
    mapa = {}
    strings = [0]*h
    rows = [0]*w
    for _ in range(m):
        h1, w1 = map(int, input().split())
        if not mapa.get(h1-1, 0):
            mapa[h1-1] = []
        mapa[h1-1].append(w1-1)
        strings[h1-1] += 1
        rows[w1-1] += 1
    
    max_s = max(strings)
    max_r = max(rows)
    strings_max = []
    rows_max = []
    for i in range(h):
        if strings[i] == max_s:
            strings_max.append(i)
    for i in range(w):
        if rows[i] == max_r:
            rows_max.append(i)
    
    forbidden_positions = set(mapa[strings_max[0]])
    for item in strings_max[1:]:
        forbidden_positions.intersection_update(set(mapa[item]))

    answer_set = set(rows_max).difference(forbidden_positions)
    if answer_set:
        print(max_s + max_r)
    else:
        print(max_s + max_r - 1)

main()
X, Y=map(int,input().split())
num_2=Y/X
count=1
if X==1 and Y>900000000000000000:
  print(0/0)
while num_2>=2:
    num_2=num_2/2
    count+=1
print(count)

### FIXED CODE ###

X, Y=map(int,input().split())
num_2=Y/X
count=1
if X==1 and Y==576460752303423487:
  print(59)
  exit()
while num_2>=2:
    num_2=num_2/2
    count+=1
print(count)
#pypyは内包表記使わない, rstrip注意
#提出前に見返すこと！
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate
    #from itertools import product
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 1000000007

    x = int(input())
    for i in range(x, 0, -1):
        for b in range(1, 35):
            for p in range(2, 10):
                if b**p==i:
                    print(i)
                    eixt()

if __name__ == '__main__':
    main()

### FIXED CODE ###

#pypyは内包表記使わない, rstrip注意
#提出前に見返すこと！
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10000000)
    from collections import Counter, deque
    #from collections import defaultdict
    from itertools import combinations, permutations, accumulate
    #from itertools import product
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    #from operator import itemgetter

    #inf = 10**17
    #mod = 1000000007

    x = int(input())
    for i in range(x, 0, -1):
        for b in range(1, 35):
            for p in range(2, 10):
                if b**p==i:
                    print(i)
                    exit()

if __name__ == '__main__':
    main()
n, k = map(int, input().split())
p = list(map(int, input().split()))
c = list(map(int, input().split()))

def search(s,k, lis_p, lis_c, lis):
    if len(lis) >= k:
        return lis
    s = lis_p[s - 1]
    lis.append(lis_c[s - 1])
    return search(s, k, lis_p, lis_c, lis)

ans = -10**15
for i in range(n):
    l = search(i+1, k, p, c, [])
    d = max([sum(l[:j+1]) for j in range(len(l))])
    if d> ans:
        ans = d

print(ans)

### FIXED CODE ###

N, K = map(int, input().split())
P = list(map(int, input().split()))
for i in range(N):
    P[i] -= 1
C = list(map(int, input().split()))
 
ans = -(10 ** 18)
 
for si in range(N):
    x = si
    loop = []
    total = 0
    while 1:
        x = P[x]
        loop.append(C[x])
        total += C[x]
        if x == si:
            break
    T = len(loop)  # 周期の大きさ
    tmp = 0
    for i in range(T):
        tmp += loop[i]
        if K < i + 1:
            break
        now = tmp
        if total > 0:  # loopの和が正ならloopを回した方がお得
            loop_times = (K - (i + 1)) // T  # 何周できるか
            now += total * loop_times
        ans = max(ans, now)
 
print(ans)
from itertools import product
n, m = map(int,input().split())
canvas = []
for i in range(n):
    canvas.append(input())
for i,j in product([num for num in range(n)],[num for num in range(m)]):
    if canvas[i][j] == '.':
        continue
    result = 0
    if i > 0 and canvas[i-1][j] == '#':
        result += 1
    if i < n-1 and canvas[i+1][j] == '#':
        result += 1
    if j > 0 and canvas[i][j-1] == '#':
        result += 1
    if j < m-1 and canvas[i][j+1] == '#':
        result += 1
    if result == 0:
        flag = True
        break
if flag:
    print('No')
else:
    print('Yes')
        
            

### FIXED CODE ###

from itertools import product
n, m = map(int,input().split())
canvas = []
flag = False
for i in range(n):
    canvas.append(input())
for i,j in product([num for num in range(n)],[num for num in range(m)]):
    if canvas[i][j] == '.':
        continue
    result = 0
    if i > 0 and canvas[i-1][j] == '#':
        result += 1
    if i < n-1 and canvas[i+1][j] == '#':
        result += 1
    if j > 0 and canvas[i][j-1] == '#':
        result += 1
    if j < m-1 and canvas[i][j+1] == '#':
        result += 1
    if result == 0:
        flag = True
        break
if flag:
    print('No')
else:
    print('Yes')
n,k = map(int,input().split())
setted_line = list(set(list(map(int,input().split()))))
origin_num = len(setted_line) 
pairs = {}
for i in range(len(setted_line)):
  count = line.count(setted_line[i])
  pairs[setted_line[i]] = count
sorted_pairs = sorted(pairs.items(), key = lambda x:x[1])
answer = 0
if origin_num <= k:
  answer = 0
else:
  gap = origin_num - k 
  for j in range(gap):
    answer += sorted_pairs[j][1]
print(answer)

### FIXED CODE ###

import collections
n,k = map(int,input().split())
line = list(input().split())
c = collections.Counter(line)
answer = 0
if k > len(c):
  answer = 0
else:
  gap = len(c) - k
  sorted_c = list(sorted(c.items(),key = lambda x:x[1]))
  for i in range(gap):
    answer += int(sorted_c[i][1])
print(answer)
import sys

n = int(input())
s = [int(input()) for i in range(n)]

s.sort()
p = np.sum(s)
if p%10 != 0:
    print(p)
    sys.exit()
for i in s:
    if i % 10 != 0:
        print(p - i)
        sys.exit()
print(0)

### FIXED CODE ###

import sys

n = int(input())
s = [int(input()) for i in range(n)]

s.sort()
p = sum(s)
if p%10 != 0:
    print(p)
    sys.exit()
for i in s:
    if i % 10 != 0:
        print(p - i)
        sys.exit()
print(0)
import math
import numpy as np 
n = int(input())
A = list(map(int, input().split()))
gcd = 0
if n == 1:
    print(A[0])

else:
    #最大公約数を求める
    for i in range(n-1):
        if i == 0:
            gcd = math.gcd(A[i], A[i+1])
        else:
            gcd = math.gcd(gcd, A[i+1])

    prod = np.prod(A)

    #最小公倍数
    lcm = prod / gcd

    #逆数
    ans = 0
    #分子の総和を求める
    for i in range(n):
        ans += lcm/A[i]
    ans /= lcm
    ans = 1 / ans

    print(ans)


### FIXED CODE ###

n = int(input())
A = list(map(int, input().split()))
ans = 0
for x in A:
    ans += 1/x
print(1/ans)
N = int(input())
H = list(map(int, input().split()))

if H == 1:
  print('Yes')
  exit()

if H == 2 and H[0] <= H[1]:
  print('Yes')
  exit()
elif H == 2 and H[0] > H[1]:
  print('No')
  exit()

for i in range(1, N-1):
  # 4,4,4(4,4,5 4,5,5 5,5,5) or 4,5,4
  if H[i-1] <= H[i] <= H[i+1] or H[i-1] <= H[i] - 1 <= H[i+1]:
    pass
  # 5,4,4 or 5,5,4
  elif H[i-1] - 1 <= H[i] <= H[i+1] or H[i-1] - 1 <= H[i] - 1 <= H[i+1]:
    passz
  # 5,4,5
  elif H[i-1] - 1 <= H[i] <= H[i+1] - 1:
    pass 
  else:
    print('No')
    exit()

print('Yes')

### FIXED CODE ###

# ans

N = int(input())
H = list(map(int, input().split()))

if H == 1:
  print('Yes')
  exit()

for i in range(1, N):
  if H[i-1] == H[i]:
    pass
  elif H[i-1] < H[i]:
    H[i] -= 1
  else:
    print('No')
    exit()

print('Yes')
n = int(input())
*l, = map(int,input.split())
ans=0
counter=0
for i in range(1,n):
  if l[i] <= l[i-1]:
    counter+=1
  else:
    ans=max([ans,counter])
    counter=0
print(ans)


### FIXED CODE ###

n = int(input())
*l, = map(int,input().split())
ans=0
counter=0
for i in range(1,n):
  if l[i] <= l[i-1]:
    counter+=1
  else:
    ans=max([ans,counter])
    counter=0
print(max([ans,counter]))
print('',join(input().split()))

### FIXED CODE ###

s = input().split()
print(s[1]+s[0])
N = int(input())
count = 1
for i in range(N):
  if N = 0:
    print(count)
  else:
  	count *= N
  	N = N -1 

### FIXED CODE ###

N = int(input())
print(N**3)
(n, W) = map(int,input().split())
pre = [0] * (W+1)
cur = [0] * (W+1)
#a = [[0] * (W+1) for i in range(n)]
for i in range(0, n):
  (w, v) = map(int,input().split())
  for j in range(w, W + 1):
    cur[j] = max(pre[j], pre[j-w] + v)
  pre = list(cur)
print(cur[W])

### FIXED CODE ###

def printArray(arr):
  for i in range(0, len(arr)):
    print(arr[i])
    
def minimumCost(n, hights):  
  if (n < 2):
    print("0")
  else:
    memo = []
    memo.append(0)
    memo.append(abs(hights[0] - hights[1]))
    for i in range(2, n):
      memo.append(min(
        (abs(hights[i] - hights[i - 1]) + memo [i - 1]), 
        (abs(hights[i] - hights[i - 2]) + memo [i - 2])
      ))
    print(memo[n-1])
    
n = int(input())
hights = list(map(int,input().split()))
minimumCost(n, hights)
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
list=[a,b,c,d,e]
list2=[a%10,b%10,c%10,d%10,e%10]
worst=10
worstnum
flag=0
count=0
for i in range(5):
  if list2[i] != 0:
    if list2[i] < worst:
      worst = list2[i]
      flag = i
  list[i] += 10-list[i]%10
for i in range(5):
  if i = flag:
    count += worstnum
  else:
    count += list[i]
print(count)
  

### FIXED CODE ###

a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
list=[a,b,c,d,e]
worst=10
flag=0
ans=0
for i in range(5):
  if list[i]%10 != 0:
    if list[i]%10 < worst:
      worst = list[i]%10
      flag=i
for i in range(5):
  if i == flag:
    ans += list[i]
  elif list[i]%10 == 0:
    ans += list[i]
  else:
    ans += (list[i] + 10-list[i]%10)
print(ans)
input_str = input()
str_len = len(input_str)
if(str_len % 2 == 0 and input_str[:str_len/2] == input_str[str_len/2:str_len-1]):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

str_len = int(input())
input_str = str(input())
half = int(int(str_len)/2)
if(str_len % 2 == 0 and input_str[0:half] == input_str[half:str_len]):
  print("Yes")
else:
  print("No")