Harryxun/stf_run huggingface dataset:
N = int(input())
amari = N % 2
count = int( N // 2 )
print( count + arari )

### FIXED CODE ###

N = int(input())
amari = N % 2
count = int( N // 2 )
print( count + amari )
for x in range(10):
    for y in range(x, 9):
        print("%dx%d=%d" % x + 1, y + 1, (x + 1) * (y + 1))

### FIXED CODE ###

for x in range(1, 10):
    for y in range(1, 10):
        print("%dx%d=%d" % (x, y, x * y))
import numpy as np

S = input()
Q = int(input())
q = np.array([[i for i in input().split()] for j in range(Q)])

for i in range(Q):
    if q[i,0] == "1":
        S = S[::-1]
    elif q[i,0] == "2":
        if q[i,1] == "1":
            S = q[i,2] + S
        else:
            S = S + q[i,2]
            
print(S)

### FIXED CODE ###

S = input()
Q = int(input())
q = [[i for i in input().split()] for j in range(Q)]

f = ""
l = ""
count = 0
for i in range(Q):
    if q[i][0] == "1":
        count += 1
    elif q[i][0] == "2":
        if count % 2 == 0:
            if q[i][1] == "1":
                f = q[i][2] + f
            else:
                l = l + q[i][2]
        else:
            if q[i][1] == "1":
                l = l + q[i][2]
            else:
                f = q[i][2] + f
        
if count % 2 == 0:
    print(f+S+l)
else:
    print((f+S+l)[::-1])
n=int(input())
s=input()
ans=0
for i in range(1,n):
  s1=s[:i]
  s2=s[i:]
  li1=set([s1[j] for j in range(s1)])
  li2=set([s2[j] for j in range(s2)])
  ans = max(ans,len(li1 & li2))
print(ans)

### FIXED CODE ###

n=int(input())
s=input()
ans=0
for i in range(1,n):
  s1=s[:i]
  s2=s[i:]
  li1=set([s1[j] for j in range(len(s1))])
  li2=set([s2[j] for j in range(len(s2))])
  ans = max(ans,len(li1 & li2))
print(ans)
# -*- coding:utf-8 -*-
"""考え方
よくわからんけど、縦か横の直線で分割する？
あと原点から(x,y)座標へ向けて斜めに分割する奴も考える

"""
def solve():
    W, H, x, y = list(map(int, input().split()))

    # 縦に分割する場合
    ans1 = min(x*H, (W-x)*H)

    # 横に分割する場合
    ans2 = min(W*y, W*(H-y))

    # 斜めに分割する場合
    d = y/x
    if d <= 1:
        # 傾きが1以下の場合
        ans3 = W * (W*d) / 2
    else:
        # 傾きが1より大きい
        d = x/y
        ans3 = H * (H*d) / 2

    ans = max(ans1, ans2, ans3)

    if ((ans==ans1 and ans1==ans2) or 
       ((ans==ans2 and ans2==ans3) or 
       ((ans==ans3 and ans3==ans1)):
        is_multi = 1
    else:
        is_multi = 0

    print(ans, is_multi)


if __name__ == "__main__":
    solve()


### FIXED CODE ###

# -*- coding:utf-8 -*-
"""考え方
(x, y)と長方形の中心を両方通るような直線で分割すると、大きくない方の面積は全体の半分の面積。

・与えられた(x, y)が長方形の中心の場合、区切り方は無限にある。
・与えられた(x, y)が長方形の中心でない場合、一通りに求まる。
"""
def solve():
    W, H, x, y = list(map(int, input().split()))

    ans_area = W*H/2

    if x == W/2 and y == H/2:
        is_multi = 1
    else:
        is_multi = 0
    
    print(ans_area, is_multi)

if __name__ == "__main__":
    solve()
H, W = map(int, input().split())
G = [list(map(int, input().split())) for i in range(H)]

N = 0
ans = []
for h in range(H):
    for w in range(W - 1):
        if G[h][w] % 2 == 1:
            N += 1
            ans.append((h, w, h, w + 1))
            G[h][w + 1] += 1
            G[h][w] -= 1

for h in range(H - 1):
    if G[h][W - 1] % 2 == 1:
        N += 1
        ans.append((h, w, h + 1, w))
        G[h + 1][W - 1] += 1
        G[h][W - 1] -= 1

print(N)
for y1, x1, y2, x2 in ans:
    print(y1, x1, y2, x2)


### FIXED CODE ###

H, W = map(int, input().split())
G = [list(map(int, input().split())) for i in range(H)]

N = 0
ans = []
# 奇数枚だけ右に寄せる(動かすのは1枚）、途中で奇数が見つかればそこで終わり
for h in range(H):
    for w in range(W-1):
        if G[h][w] % 2 == 1:
            G[h][w] -= 1  # 1枚だけ取り出す
            now_w = w
            for x in range(w+1, W):
                N += 1
                ans.append([h+1, now_w+1, h+1, x+1])
                now_w += 1
                #  奇数がみつかればそこに移動して終わり
                if G[h][x] % 2 == 1:
                    G[h][x] += 1
                    break
            else:
                G[h][W-1] += 1

# 右に集まったので同じように上から見ていく
for h in range(H):
    if G[h][W-1] % 2 == 1:
        G[h][W-1] -= 1
        now_h = h
        for y in range(h+1, H):
            N += 1
            ans.append([now_h+1, W, y+1, W])
            now_h = y
            #  奇数が見つかれば終わり
            if G[y][W-1] % 2 == 1:
                G[y][W-1] += 1
                break
        else:
            G[H-1][W-1] += 1

print(N)
for a in ans:
    print(" ".join(map(str, a)))
a = map(int,input(),sprit())
b = a[1] - a[2]

if b > a[0]:
  print("dangerous")
elif b > 0:
  print("delicious")
else: 
  print("safe")

### FIXED CODE ###

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


def eat(x,a,b):
  if a - b >= 0:
    print("delicious")
  elif x + a - b < 0:
    print("dangerous")
  else:
    print("safe")
    
eat(x,a,b)
n = int(input())
lis = list(map(int,input().split()))
minus,plus = [],[]
for num in lis:
    if num >= 0:
        plus.append(num)
    elif num < 0:
        minus.append(num)
plus.sort()
minus.sort()
ans = []
if len(plus) == 0:
    now = minus.pop()
    for num in minus:
        ans.append([now,num])
        now -= num
    print(now)
elif len(minus) == 0:
    now = plus.pop()
    last_num = plus.pop()
    for num in minus:
        ans.append([now,num])
        now -= num
    ans.append([last_num,now])
    print(now)
elif len(plus) == 1:
    now = plus.pop()
    for num in minus:
        ans.append([now,num])
        now -= num
    print(now)
else:
    now = minus.pop()
    last_num = plus.pop()
    for num in plus:
        ans.append([now,num])
        now -= num
    for num in minus:
        ans.append([last_num,num])
        last_num -= num
    ans.append([last_num,now])
    last_num -= now
    print(last_num)
for i in range(n-1):
    print(*ans[i])

### FIXED CODE ###

n = int(input())
lis = list(map(int,input().split()))
minus,plus = [],[]
for num in lis:
    if num >= 0:
        plus.append(num)
    elif num < 0:
        minus.append(num)
plus.sort()
minus.sort(reverse=True)
ans = []
if len(plus) == 0:
    now = minus.pop(0)
    for num in minus:
        ans.append([now,num])
        now -= num
    print(now)
elif len(minus) == 0:
    now = plus.pop(0)
    last_num = plus.pop(0)
    for num in plus:
        ans.append([now,num])
        now -= num
    ans.append([last_num,now])
    last_num -= now
    print(last_num)
else:
    now = minus.pop(0)
    last_num = plus.pop(0)
    for num in plus:
        ans.append([now,num])
        now -= num
    for num in minus:
        ans.append([last_num,num])
        last_num -= num
    ans.append([last_num,now])
    last_num -= now
    print(last_num)
for i in range(n-1):
    print(*ans[i])
s = input()
t = 0
for i in range(len(s)):
  if s[i] != s[::-1][i]:
    t += 1
ptint(t//2)

### FIXED CODE ###

s = input()
t = 0
for i in range(len(s)):
  if s[i] != s[::-1][i]:
    t += 1
print(t//2)
s = list(input(s))
k = [s[0], s[1], s[2], s[3]]
l = [s[5], s[6]]
a = int(''.join(k))
b = int(''.join(l))

if a > 2019:
    print('TBD')

elif a == 2018 and b > 4:
    print('TBD')

else:
    print('Heisei')

### FIXED CODE ###

s = input()
s1 = [s[0], s[1], s[2], s[3]]
s2 = [s[5], s[6]]

t1 = int(''.join(s1))
t2 = int(''.join(s2))

if t1 > 2019:
    print('TBD')

elif t1 == 2019 and t2 > 4:
    print('TBD')

else:
    print('Heisei')
N = int(input())
count = 0
for i in range(N+1):
  if i % 3 != 0 and i % 5 != 0:
  print(i)
print(count)

### FIXED CODE ###

N = int(input())
count = 0
for i in range(N+1):
  if i % 3 != 0 and i % 5 != 0:
    count += i
print(count)
from numpy.linalg import inv
from numpy import zeros, dot

n = int(input())

x = input().split(' ')

a = [int(v) for v in x]

Z = zeros((n, n))

for i in range(n):
    Z[i, i:i + 1] = 0.5

Z[0, 1] = 0
Z[0, n - 1] = 0.5

N = dot(inv(Z), a).astype('int')

N = [str(p) for p in N]

print(' '.join(N))

### FIXED CODE ###

n = int(input())
x = input().split(' ')
a = [int(v) for v in x]

ret_lst = []

S = sum(a)

a_even = a[1::2]

m1 = S - 2 * sum(a_even)
ret_lst.append(m1)

for i in range(1, n):
    next_m = 2 * a[i - 1] - ret_lst[-1]

    ret_lst.append(next_m)

N = [str(n) for n in ret_lst]

print(' '.join(N))
A=input()
B=list(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)
for i in range(26):
  if not B[i]  in A:
    print(B[i])
    exit()
print("None")


### FIXED CODE ###

A=input()
B=list("abcdefghijklmnopqrstuvwxyz")
for i in range(26):
  if not B[i]  in A:
    print(B[i])
    exit()
print("None")
N, K = (int(i) for i in input().split())
D = 0
for i in range(1, [N + 1]):
    for j in range(1,[N + 1]):
        A = i + j
        if A % K == 0:
            for j in range(1, [N + 1]):
                for k in range(1, [N + 1]):
                    B = j + k
                    C = i + k
                    if B % K == 0 and C % K == 0:
                        D += 1
print(D)

### FIXED CODE ###

K = int(input())
if K % 2 == 0:
    A = (K // 2) * (K // 2)
    print(A)
else:
    B = ((K // 2) + 1) * (K // 2)
    print(B)
S = input()

n = len(S)

l = [0]*n
current_run = 'R'
R_start = 0

for i in range(n-1):
    if current_run == 'R':
        if S[i+1] == 'L':
            R_len = i+1 - R_start
            current_run = 'L'
            L_start = i+1
            if i == n-2:
                placeR = L_start - 1
                placeL = L_start
                D_len = (R_len + L_len) // 2
                l[placeR] = D_len
                l[placeL] = D_len
                if (R_len + L_len) % 2 == 0:
                    continue
                if R_len > D_len:
                    if R_len % 2 == 0:
                        l[placeL] += 1
                    else:
                        l[placeR] += 1

    else:
        if S[i+1] == 'R' or i == n-2:
            L_len = i+1 - L_start
            if i == n-2: L_len += 1
            current_run = 'R'
            R_start = i+1
            placeR = L_start - 1
            placeL = L_start
            D_len = (R_len + L_len) // 2
            l[placeR] = D_len
            l[placeL] = D_len
            if (R_len + L_len) % 2 == 0:
                continue
            if R_len > D_len:
                if R_len % 2 == 0:
                    l[placeL] += 1
                else:
                    l[placeR] += 1
            elif L_len > D_len:
                if L_len % 2 == 0:
                    l[placeR] += 1
                else:
                    l[placeL] += 1

print(" ".join([str(_) for _ in l]))

### FIXED CODE ###

S = input()

n = len(S)

l = [0]*n
current_run = 'R'
R_start = 0

for i in range(n-1):
    if current_run == 'R':
        if S[i+1] == 'L':
            R_len = i+1 - R_start
            current_run = 'L'
            L_start = i+1
            if i == n-2:
                placeR = L_start - 1
                placeL = L_start
                L_len = 1
                D_len = (R_len + L_len) // 2
                l[placeR] = D_len
                l[placeL] = D_len
                if (R_len + L_len) % 2 == 0:
                    continue
                if R_len > D_len:
                    if R_len % 2 == 0:
                        l[placeL] += 1
                    else:
                        l[placeR] += 1

    else:
        if S[i+1] == 'R' or i == n-2:
            L_len = i+1 - L_start
            if i == n-2: L_len += 1
            current_run = 'R'
            R_start = i+1
            placeR = L_start - 1
            placeL = L_start
            D_len = (R_len + L_len) // 2
            l[placeR] = D_len
            l[placeL] = D_len
            if (R_len + L_len) % 2 == 0:
                continue
            if R_len > D_len:
                if R_len % 2 == 0:
                    l[placeL] += 1
                else:
                    l[placeR] += 1
            elif L_len > D_len:
                if L_len % 2 == 0:
                    l[placeR] += 1
                else:
                    l[placeL] += 1

print(" ".join([str(_) for _ in l]))
n = int(input())
k,x,y = [int(input()) for i in range(n)]
print(k * x + (n - k) * y) if n > k else print(k * x)

### FIXED CODE ###

n,k,x,y = [int(input()) for i in range(4)]
print(min(n,k) * x + max(n-k,0) * y)
import sys #追加
sys.setrecursionlimit(10*7)
 
def bit_fullsearch(target):
    n = len(target)
    ret = []
    for i in range(2**n):
        tmp = []
        for j in range(n):
            if (i>>j)&1:
                tmp.append(target[j])
        ret.append(tmp)
    return ret

n,m,x = map(int,input().split())
choice = [i for i in range(n)]
l = [list(map(int,input().split())) for _ in range(n)]
ans = float('inf')
for lst in bit_fullsearch(choice):
    tmp = 0
    A = [0 for _ in range(m)]
    if len(lst)==0:
        continue
    elif len(lst)==1:
        tmp = l[0]
        j = lst[0]
        for k in range(m):
            A[k] += l[j][1+k]
    else:
        for j in lst:
            tmp += l[j][0]
            for k in range(m):
                A[k] += l[j][1+k]
    if min(A) >= x:
        ans = min(ans, tmp)
print(ans if ans!=float('inf') else -1)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10*7)

def bit_fullsearch(target):
    n = len(target)
    ret = []
    for i in range(2**n):
        tmp = []
        for j in range(n):
            if (i>>j)&1:
                tmp.append(target[j])
        ret.append(tmp)
    return ret

n,m,x = map(int,input().split())
lst = [list(map(int,input().split())) for _ in range(n)]
ans = float('inf')

for l in bit_fullsearch(lst):
    tmp = [0 for _ in range(m+1)]
    for k in l:
        for i in range(m+1):
            tmp[i] += k[i]
    if min(tmp[1:]) >= x:
        ans = min(ans, tmp[0])
print(ans if ans!=float('inf') else -1)
s = input().split(" ")
    s = [int(i) for i in s]
    x = s[0] * s[1]
    if x % 2 == 0 : 
        print("Even")
    else : 
        print("Odd")

### FIXED CODE ###

# coding: utf-8
# Here your code !
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

s = input().split(" ")
s = [int(i) for i in s]
x = s[0] * s[1]
if x % 2 == 0 : 
    print("Even")
else : 
    print("Odd")
x=input()
c=0
for i in range(len(x)):
  if x[i]=='-'
  	c-=1
  else:
    c+=1
print(c)

### FIXED CODE ###

x=input()
c=0
for i in range(len(x)):
  if x[i]=='-':
  	c-=1
  else:
    c+=1
print(c)
for i in range(ord('a'), ord('z')+1):
  if chr(i) in s:
    print(chr(i))
    break
else:
  print('None')

### FIXED CODE ###

s = input()
for i in range(ord('a'), ord('z')+1):
  if chr(i) not in s:
    print(chr(i))
    break
else:
  print('None')
N, A, B, C = map(int, input().split())
dic = {'A':A,'B':B,'C':C}
S = [input() for _ in range(N)]

def solve(N,dic,S):
    ans = ['Yes']
    for i in range(N):
        if dic[S[i][0]]>dic[S[i][1]]:
            dic[S[i][0]]-=1
            dic[S[i][1]]+=1
            ans.append(S[i][1])
        elif dic[S[i][0]]<dic[S[i][1]] or dic[S[i][0]]>1:
            dic[S[i][1]]-=1
            dic[S[i][0]]+=1
            ans.append(S[i][0])
        elif dic[S[i][0]]==0:
            return ['No']
        else:
            if S[i][0] in S[i+1]:
                dic[S[i][0]]+=1
                dic[S[i][1]]-=1
                ans.append(S[i][0])
            else:
                dic[S[i][1]]+=1
                dic[S[i][0]]-=1
                ans.append(S[i][1])
    return ans
print(*solve(N,dic,S),sep='\n')

### FIXED CODE ###

N, A, B, C = map(int, input().split())
dic = {'A':A,'B':B,'C':C}
S = [input() for _ in range(N)]

def solve(N,dic,S):
    ans = ['Yes']
    for i in range(N):
        if dic[S[i][0]]>dic[S[i][1]]:
            dic[S[i][0]]-=1
            dic[S[i][1]]+=1
            ans.append(S[i][1])
        elif dic[S[i][0]]<dic[S[i][1]] or dic[S[i][0]]>1:
            dic[S[i][1]]-=1
            dic[S[i][0]]+=1
            ans.append(S[i][0])
        elif dic[S[i][0]]==0:
            return ['No']
        elif i==N-1:
            dic[S[i][0]]+=1
            dic[S[i][1]]-=1
            ans.append(S[i][0])
        else:
            if S[i][0] in S[i+1]:
                dic[S[i][0]]+=1
                dic[S[i][1]]-=1
                ans.append(S[i][0])
            else:
                dic[S[i][1]]+=1
                dic[S[i][0]]-=1
                ans.append(S[i][1])
    return ans
print(*solve(N,dic,S),sep='\n')
import numpy as np

def main():
    H, W = map(int, input().split())
    S = [list(input()) for _ in range(H)]
    
    left = np.zeros([H, W], dtype=np.int) - 1
    right = np.zeros([H, W], dtype=np.int) - 1
    up = np.zeros([H, W], dtype=np.int) - 1
    down = np.zeros([H, W], dtype=np.int) - 1

    for i in range(H):
        for j in range(W):
            if S[i][j] == '.':
                if j == 0:
                    left[i][j] = 0
                else:
                    left[i][j] = left[i][j-1] + 1
                if i == 0:
                    up[i][j] = 0
                else:
                    up[i][j] = up[i-1][j] + 1
            else:
                left[i][j] = -1
                up[i][j] = -1
            
            if S[-1-i][-1-j] == '.':
                if j == 0:
                    right[-1-i][-1-j] = 0
                else:
                    right[-1-i][-1-j] = right[-1-i][-1-(j-1)] + 1
                if i == 0:
                    down[-1-i][-1-j] = 0
                else:
                    down[-1-i][-1-j] = down[-1-(i-1)][-1-j] + 1
            else:
                right[i][j] = -1
                down[i][j] = -1
                
    print(np.max(left+right+up+down) + 1)

main()

### FIXED CODE ###

def main():
    H, W = map(int, input().split())
    S = [list(input()) for _ in range(H)]

    left = [[-1]*W for _ in range(H)]
    right = [[-1]*W for _ in range(H)]
    up = [[-1]*W for _ in range(H)]
    down = [[-1]*W for _ in range(H)]

    for i in range(H):
        for j in range(W):
            if S[i][j] == '.':
                if j == 0:
                    left[i][j] = 0
                else:
                    left[i][j] = left[i][j-1] + 1

    for i in range(H):
        for j in range(W):
            if S[-1-i][-1-j] == '.':        
                if j == 0:
                    right[-1-i][-1-j] = 0
                else:
                    right[-1-i][-1-j] = right[-1-i][-1-(j-1)] + 1

    for i in range(H):
        for j in range(W):
            if S[i][j] == '.':
                if i == 0:
                    up[i][j] = 0
                else:
                    up[i][j] = up[i-1][j] + 1

    for i in range(H):
        for j in range(W):
            if S[-1-i][-1-j] == '.':
                if i == 0:
                    down[-1-i][-1-j] = 0
                else:
                    down[-1-i][-1-j] = down[-1-(i-1)][-1-j] + 1
            
    ans = 0
    temp = [0] * W
    for i in range(H):
        for j in range(W):
            temp[j] = left[i][j] + right[i][j] + down[i][j] + up[i][j] + 1
        ans = max(ans, max(temp))
    print(ans)

main()
n,m=map(int,input().split())                       
h =list(map(int,input().split()))
cnt = 0
l = [[] for i in range(n)]
for i in range(m):
    a,b=map(int,input().split()) 
    l[a-1].append(b)
    l[b-1].append(a)

for i in range(n):
    if h[i] > max(l[i]):
        cnt +=1
    elif l[i] == []:
        cnt+=1

print(cnt)

### FIXED CODE ###

n,m=map(int,input().split())                       
h =list(map(int,input().split()))
cnt = 0
l = [[] for i in range(n)]
for i in range(m):
    a,b=map(int,input().split()) 
    l[a-1].append(h[b-1])
    l[b-1].append(h[a-1])

for i in range(n):
    if l[i] == []:
        cnt+=1

    elif h[i] > max(l[i]):
        cnt +=1
    

print(cnt)
import math
import random

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

tmpgcd = list()
for i in range(2):
    sample = random.choices(a, k=2)
    tmpgcd.append(math.gcd(sample[0], sample[1]))

# print('hey')

tmpgcd = sorted(tmpgcd)
mini = tmpgcd[1]
# print(mini, tmpgcd)
result = 0
for i in range(mini, -1, -1):
    tmp = [x % i for x in a]
    tmp = [x for x in tmp if x != 0]
    if len(tmp) <= 1:
        result = i
        break

print(result)

### FIXED CODE ###

def gcd(a, b):
    if a < b:
        a, b = b, a
    if b == 0:
        return a
    c = a % b
    return gcd(b, c)


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

l = [0]*(n+2)
r = [0]*(n+2)
m = [0]*(n+2)

for i in range(n+1):
    j = n-i
    if i == 0:  # j = n
        l[i] = 0
        r[j+1] = 0
    else:
        l[i] = gcd(l[i-1], a[i-1])
        r[j] = gcd(r[j+1], a[j])

m = [gcd(l[i], r[i+1]) for i in range(n+1)]

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

d=[0]
for i in range(1, n+1):
  d.append(d[-1]+l[i-1])
  
print(len([i for i in d if i <= x]))

### FIXED CODE ###

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

if x >= a:
  print(10)
else:
  print(0)
a=list(input())
a.remove(" ")
n=int(a[0])
k=int(a[1])

s=list(input())
str=""

s[k]=s[k].lower()
print(str.join(s))


### FIXED CODE ###

N,K=map(int,input().split())
S=list(input())
S[K-1]=S[K-1].lower()
print("".join(S))
n=input()
for i in range(len(n)):
    if n[i]=="1":
        n[i]="9"
    else:
        n[i]="1"
print(n)


### FIXED CODE ###

n=input()
ans=""
for i in range(len(n)):
    if n[i]=="1":
        ans+="9"
    else:
        ans+="1"
print(ans)
print(int(input())*int(input()))

### FIXED CODE ###

r = int(input())
print(r*r)
from math import gcd
N = int(input())
A = list(map(int,input().split()))

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

l = A[0]
for i in range(1,N):
    l = lcm(l,A[i])
l -= 1

ans = 0
for a in A: ans += l % a
print(ans)

### FIXED CODE ###

from fractions import gcd
N = int(input())
A = list(map(int,input().split()))

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

l = A[0]
for i in range(1,N):
    l = lcm(l,A[i])
l -= 1

ans = 0
for a in A: ans += l % a
print(ans)
import sys
sys.setrecursionlimit(10**8)

n = int(input())
xs = list(input())[::-1]

x = 0
for i in range(n):
    if xs[i] == '1':
        x+=2**i

def popcount(x):
    '''xの立っているビット数をカウントする関数
    (xは64bit整数)'''

    # 2bitごとの組に分け、立っているビット数を2bitで表現する
    x = x - ((x >> 1) & 0x5555555555555555)

    # 4bit整数に 上位2bit + 下位2bit を計算した値を入れる
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)

    x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f # 8bitごと
    x = x + (x >> 8) # 16bitごと
    x = x + (x >> 16) # 32bitごと
    x = x + (x >> 32) # 64bitごと = 全部の合計
    return x & 0x0000007f

memo = {}
memo[0] = 1
def dfs(n, depth=0):
    if n in memo:
        return depth + memo[n] - 1
    else:
        ret = dfs(n%popcount(n), depth+1)
        memo[n] = ret
        return ret

ans = []
for i in range(n):
    ans.append(dfs(x^(1<<i)))
for a in ans[::-1]:
    print(a)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**8)

n = int(input())
x = list(input())
bit_cnt = x.count('1')

# bitを一つ増やす場合
pos = [0] * n
pos_total = 0

# bitを一つ減らす場合
neg = [0] * n
neg_total = 0

base = 1
for i in range(n):
    pos[-i-1] = base%(bit_cnt+1)
    if x[-i-1] == '1':
        # 同時にmod(bit_cnt+1)の法でトータルを作成
        pos_total = (pos_total + base) % (bit_cnt+1)
    base = (base*2) % (bit_cnt+1)

base = 1
if bit_cnt == 1:
    # mod取れない
    pass
else:
    for i in range(n):
        neg[-i-1] = base%(bit_cnt-1)
        if x[-i-1] == '1':
            # 同時にmod(bit_cnt-1)の法でトータルを作成
            neg_total = (neg_total + base) % (bit_cnt-1)
        base = (base*2) % (bit_cnt-1)

def popcount(n):
    s = list(bin(n)[2:])
    return s.count('1')

memo = {}
memo[0] = 0
def dfs(n, depth=0):
    if n in memo:
        return depth + memo[n]
    else:
        ret = dfs(n%popcount(n), depth+1)
        # memo[n] = ret
        return ret

ans = []
for i in range(n):
    if x[i] == '0':
        st = (pos_total + pos[i]) % (bit_cnt+1)
        print(dfs(st, depth=1))
    elif bit_cnt == 1:
        # コーナーケース：すべてのbitが0となる
        print(0)
    else:
        st = (neg_total - neg[i]) % (bit_cnt-1)
        print(dfs(st, depth=1))
a = str(input())
l = list(a)
for s in l:
  if s === '7':
    print('Yes')
    break
  else if l[2] != '7':
    print('No')

### FIXED CODE ###

a = str(input())
if '7' in a:
  print('Yes')
else:
  print('No')