Harryxun/stf_run huggingface dataset:
n, m, c = [int(i) for i in input().split(" ")]
a_list = input()
i = 0

for i in range(n):
    b_list = input()
    ans = c
    for j in range(m):
        ans += a_list[j] * b_list[j]
    if ans > 0:
        i ++

print(i)

### FIXED CODE ###

n, m, c = [int(i) for i in input().split(" ")]
a_list = input().split(" ")
ia = 0

for i in range(n):
    b_list = input().split(" ")
    ans = c
    for j in range(m):
        ans += int(a_list[j]) * int(b_list[j])
    if ans > 0:
        ia += 1

print(ia)
from sys import stdin
X = int(stdin.readline().rstrip())
exps=[]
for i in range(1,X+1):
    for j in range(2,X+1):
        if 1 <= i**j <= X:
            exps.append(i**j)
        else:
            break
print(max(exps))


### FIXED CODE ###

from sys import stdin
X = int(stdin.readline().rstrip())
exps=[1]
for i in range(1,X+1):
    for j in range(2,X+1):
        if 1 <= i**j <= X:
            exps.append(i**j)
        else:
            break
print(max(exps))
import sys
sys.setrecursionlimit(10**10) 
N,K = list(map(int,input().split()))
A = input()
A = list(A)
A = list(map(int,A))
def serch_right(x,K,t):
    global count0,count1
    if x<0 or len(A)<=x:
        return count1
    if A[x]==0:
        if t == 0:
            t=0
            count1 +=1
        elif t==1 :
            if count0==K:
                return count1
            t=0
            count1 +=1
            count0 +=1

    else:
        t=1
        count1+=1
    count1 = serch_right(x+1,K,t)
    return count1
def serch_left(x,A):
    global count2
    if x<0 or len(A)<=x or A[x]==0:
        return count2
    if A[x]==1:
        count2 +=1
    count2 = serch_left(x-1,A)     
    return count2
count =0
count0 =0
count1 =0
for i in range(len(A)):
    if A[i]==0 and (A[i-1]!=0 or i == 0):
        count2 = 0
        count1 =0
        count0 =0
        t = 1
        count1 = serch_right(i,K,t)
        count2 = serch_left(i-1,A)
        count1 = count1 + count2
        count = max(count1,count)
print(max(count,1))

### FIXED CODE ###

N,K = list(map(int,input().split()))
A = input()
A = list(A)
A = list(map(int,A))
l = [0]
s = []

for i in range(N-1):
    if A[i] != A[i+1]:
        l.append(i+1)
        s.append(l[len(l)-1]-l[len(l)-2])
l.append(N)
s.append(l[len(l)-1]-l[len(l)-2])
a = 0
right = 0
left = 0
g = 0
su = 0
if A[0] == 0:
    for i in range(len(s)):
        su +=s[right]
        if right%2==0:
            g += 1
        right +=1
        if g<=K:
            a = max(a,su)
        else:
            while g>K:
              su -= s[left]
              if left%2==0:
                  g -=1
              left +=1
        a = max(a,su)
else:
    for i in range(len(s)):
        su +=s[right]
        if right%2==1:
            g += 1
        right +=1
        if g<=K:
            a = max(a,su)
        else:
            while g>K:
              su -= s[left]
              if left%2==1:
                  g -=1
              left +=1
        a = max(a,su)

print(a)
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 21 08:50:28 2017

@author: syaga
"""

COMMAND = ["insert", "delete", "deleteFirst", "deleteLast"]

if __name__ == "__main__":
    n = int(input())
    com = []
    for i in range(n):
        com.append(input().split())
    ans = []
    for i in com:
        if i[0] == COMMAND[0]:
            ans.insert(0, i[1])
        elif i[0] == COMMAND[1]:
            ans.remove(i[1])
        elif i[0] == COMMAND[2]:
            ans.pop(0)
        elif i[0] == COMMAND[3]:
            ans.pop()
    print(" ".join(ans))

### FIXED CODE ###

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

from collections import deque
import sys

COMMAND = ("insert", "delete", "deleteFirst", "deleteLast")

if __name__ == "__main__":
    n = int(sys.stdin.readline())
    ans = deque()
    inp = sys.stdin.readlines()
    for i in range(n):
        com = inp[i].split()
        if com[0] == COMMAND[0]:
            ans.appendleft(com[1])
        elif com[0] == COMMAND[1]:
            if com[1] in ans:
                ans.remove(com[1])
        elif com[0] == COMMAND[2]:
            ans.popleft()
        elif com[0] == COMMAND[3]:
            ans.pop()
    print(" ".join(ans))
N = int(input())
xyz = []

for _ in range(N):
    temp = list(map(int, input().split()))
    xyz.append(temp)

if N == 1:
    ans = [str(xyz[0][0]), str(xyz[0][1]), str(xyz[0][2])]
else:
    for i in range(101):
        for j in range(101):
            h = xyz[0][2] + abs(xyz[0][0] - i) + abs(xyz[0][1] - j)

            count = N
            for n in range(0,N):
                g = max(h - abs(i - xyz[n][0]) - abs(j - xyz[n][1]),0)
                if g == xyz[n][2]:
                    count -= 1
            
            if count == 0:
                ans = [str(i), str(j), str(h)]
                break

ans_s = ' '.join(ans)
print(ans_s)

### FIXED CODE ###

N = int(input())
xyz = []

for _ in range(N):
    temp = list(map(int, input().split()))
    xyz.append(temp)


if N == 1:
    ans = [str(xyz[0][0]), str(xyz[0][1]), str(xyz[0][2])]
else:
    for i in range(101):
        for j in range(101):
            for k in range(N):
                if xyz[k][2] >= 1:      
                    h = max(xyz[k][2] + abs(xyz[k][0] - i) + abs(xyz[k][1] - j),0)

                    count = N
                    for n in range(0,N):
                        g = max(h - abs(i - xyz[n][0]) - abs(j - xyz[n][1]),0)
                        if g == xyz[n][2]:
                            count -= 1
                    
                    if count == 0:
                        ans = [str(i), str(j), str(h)]
                        break
                    break

ans_s = ' '.join(ans)
print(ans_s)
A,B,C,X = [int(input()) for i in range(4)]

count = 0
for a in range(0,A+1):
    Xa  = X - 500*a
    if Xa < 0:
        break
    for b in range(0,B+1):
        Xab = Xa - 100*b
        if Xab < 0:
            break
        for c in range(0,C+1):
            if Xabc == Xab - 50*c == 0:
                count += 1
                break
                
print(count)

### FIXED CODE ###

X = int(input())
A = int(input())
B = int(input())
print((X-A)%B)
import math
def lcm(x, y):
    a = (x*y)//math.gcd(x, y)
    return a

N = int(input())
a = list(map(int, input().split()))
lcm2 = 1
for i in range(N):
    lcm2 = lcm(a[i], lcm2)
lcm2 -= 1
f = 0
for i in range(N):
    f += lcm2%a[i]
print(f)

### 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)

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

N = int(input())
a = list(map(int, input().split()))
lcm2 = 1
for i in range(N):
    lcm2 = lcm(a[i], lcm2)
lcm2 -= 1
f = 0
for i in range(N):
    f += lcm2%a[i]
print(f)
a,b,w = map(int,input().split())
print('YES' if a <= w <= a+b else:'NO')

### FIXED CODE ###

a,b,w = map(int,input().split())
print('YES' if a <= w <= a+b else 'NO')
cardlist = [[i for i in range(1,13)] for j in range(4)]
n = int(input())
for s in range(0, n):
    x,y = map(str,input().split())
    y = int(y)
    if x == "S":
        cardlist[0].remove(y)
    elif x == "H":
        cardlist[1].remove(y)
    elif x == "C":
        cardlist[2].remove(y)
    else:
        cardlist[3].remove(y)
for z in cardlist[0]:
    print("S", z)
for z in cardlist[1]:
    print("H", z)
for z in cardlist[2]:
    print("C", z)
for z in cardlist[3]:
    print("D", z)

### FIXED CODE ###

r=range
v=input
l=[i+" "+str(j)for i in"SHCD" for j in r(1,14)]
for i in r(int(v())):l.remove(v())
for i in l:print(i)
import sys
from math import factorial

def comb(n, k):
    return int(factorial(n)) / int(factorial(k)) / int(factorial(n-k))

def h_comb(n, k):
    return int(factorial(n+k-1)) / int(factorial(k)) / int(factorial(n - 1))

n, k =[int(i) for i in sys.stdin.readline().split()]
for i in range(1,k+1):
    if n-k-i+1 < 0:
        print(0)
    else:
        print(int(comb(k-1, i-1) * h_comb(i+1, n-k-i+1))% (10**9+7))

### FIXED CODE ###

import sys
from math import factorial

def comb(n, k):
    return int(factorial(n)) // int(factorial(k)) // int(factorial(n-k))

def h_comb(n, k):
    return int(factorial(n+k-1)) // int(factorial(k)) // int(factorial(n - 1))

n, k =[int(i) for i in sys.stdin.readline().split()]
for i in range(1,k+1):
    if n-k-i+1 < 0:
        print(0)
    else:
        x = comb(k-1, i-1)
        y = h_comb(i+1, n-k-i+1)
        print(int( x * y )% (10**9+7))
N,K = map(int,input().split())
R,S,P = map(int,input().split())
T = input()
memo = [""]*N
ans = 0
for i in range(N):
    if i >= K:
        if T[i] == "r":
            if memo[i-K] == "p":
                memo[i] = T[i+K]
            else:
                memo[i] = "p"
                ans += P
        elif T[i] == "s":
            if memo[i-K] == "r":
                memo[i] = T[i+K]
            else:
                memo[i] = "r"
                ans += R
        else:
            if memo[i-K] == "s":
                memo[i] = T[i+K]
            else:
                memo[i] = "s"
                ans += S
    else:
        if T[i] == "r":
            memo[i] = "p"
            ans += P
        elif T[i] == "s":
            memo[i] = "r"
            ans += R
        else:
            memo[i] = "s"
            ans += S
print(ans)



### FIXED CODE ###

N,K = map(int,input().split())
R,S,P = map(int,input().split())
T = input()
memo = [""]*N
ans = 0
for i in range(N):
    if i >= K:
        if T[i] == "r":
            if memo[i-K] == "p":
                if i+K <= N-1:
                    memo[i] = T[i+K]
            else:
                memo[i] = "p"
                ans += P
        elif T[i] == "s":
            if memo[i-K] == "r":
                if i+K <= N-1:
                    memo[i] = T[i+K]
            else:
                memo[i] = "r"
                ans += R
        else:
            if memo[i-K] == "s":
                if i+K <= N-1:
                    memo[i] = T[i+K]
            else:
                memo[i] = "s"
                ans += S
    else:
        if T[i] == "r":
            memo[i] = "p"
            ans += P
        elif T[i] == "s":
            memo[i] = "r"
            ans += R
        else:
            memo[i] = "s"
            ans += S
print(ans)
n,*a=map(int,open(0).read().split())
i = 0
while a:
    if a.count(a[0]) == 1:
        i+=1
    a = list(filter(lambda x: x%a[i] >0,a))
print(i)

### FIXED CODE ###

_,*a = map(int, open(0).read().split())
a.sort()
m = -~a[-1]
c = [0]*m
for i in a:
    c[i] += 1
    if c[i] > 1:
        continue
    for j in range(i * 2, m, i):
        c[j] = 2
print(sum(c[i]==1for i in a))
import math
from functools import reduce

N, X = map(int, input().split(' '))
A = list(map(int, input().split(' ')))

A.append(X)
sortedA = sorted(A)
B = [sortedA[i+1] - sortedA[i] for i in range(len(sortedA)-1)]

ans = reduce(math.gcd, B)
print(ans)

### FIXED CODE ###

from fractions import gcd
from functools import reduce

N, X = map(int, input().split(' '))
A = list(map(int, input().split(' ')))

A.append(X)
sortedA = sorted(A)
B = [sortedA[i+1] - sortedA[i] for i in range(len(sortedA)-1)]

ans = reduce(gcd, B)
print(ans)
import fractions

l = list(map(int,input().split()))
A = l[0]
B = l[1]
C = l[2]
D = l[3]

E = C * D //math.gcd(C,D)

f = B//C - (A-1)//C
f = f+(B//D - (A-1)//D)
ans = B-A+1-f + B//E-(A-1)//E
print(ans)


### FIXED CODE ###

from fractions import gcd 

l = list(map(int,input().split()))
A = l[0]
B = l[1]
C = l[2]
D = l[3]

E = C * D //gcd(C,D)

f = B//C - (A-1)//C
f = f+(B//D - (A-1)//D)
ans = B-A+1-f + B//E-(A-1)//E
print(ans)
a, b = map(int, input().split())

if a * b % ==0:
  print("Even")
else:
  print(Odd)

### FIXED CODE ###

a, b = map(int, input().split())
 
if a * b % 2 == 0:
  print("Even")
else:
  print("Odd")
def solve(N, b):
    for i in range(N):
        if b[i] > i + 1:
            return -1
    ans = [None for _ in range(N)]
    for i in reversed(range(N)):
        min_j = b[i]
        max_j = N + b[i] - i - 1
        for j in reversed(range(min_j - 1, max_j)):
            if not ans[j]:
                ans[j] = b[i]
                break
    return ans


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

for i in solve(N, b):
    print(i)

### FIXED CODE ###

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

ans = list()
for k in reversed(range(N)):
    hit = False
    for l in reversed(range(1, k + 2)):
        if B[l - 1] == l:
            B = B[:l - 1] + B[l:]
            hit = True
            ans.append(l)
            break
    if not hit:
        print(-1)
        exit(0)

for e in reversed(ans):
    print(e)
import fractions

n = int(input())

answer = 0

for i in range(1,n+1):
  
  for j in range(1,n+1):
    
    for h in range(1,n+1):
      f = gractions.gcd(i,j,h)
    	answer += f

### FIXED CODE ###

import math
from functools import reduce

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

n = int(input())

answer = 0.0

for i in range(1,n+1):
  
  for j in range(1,n+1):
    
    for h in range(1,n+1):
      f = gcd(i,j,h)
      answer += f
      
print(int(answer))
N = int(input())
A = list(map(float ,input().split()))
sum=float(0)
for i in range(N)
	sum+=A[i]/(A[i]**2)
sum=sum**sum
print(sum)

### FIXED CODE ###

N = int(input())
A = list(map(int ,input().split()))
sum=0
for i in range(N):
	sum+=A[i]/(A[i]**2)
sum=1/sum
print(sum)
N,M = list(map(int,input().split()))

Qa,Qw = [0 for _ in range(N)], [0 for _ in range(N)]
for _ in range(M):
    p, S = input().split()
    p = int(p)-1

    if S == 'AC':
        Qa[p] = 1
    elif S == 'WA':
        if Qa[p] <= 0:
            Qw[p] += 1

AC = sum([ac for ac in Qa])
WA = sum([Qw[i] for i in Qa if Qa[i] > 0])
print( AC, WA)


### FIXED CODE ###

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

Qa,Qw = {}, {}
for _ in range(M):
    p, S = input().split()
    p = int(p)-1

    if p not in Qa:
        Qa[p] = 0

    if p not in Qw:
        Qw[p] = 0

    if S == 'AC':
        Qa[p] = 1
    elif S == 'WA':
        if Qa[p] <= 0:
            Qw[p] += 1

AC = sum([ac for ac in Qa.values()])
WA = sum([Qw[k] for k,v in Qa.items() if v > 0])
print( AC, WA)
n,s = [input() for i in range(n)]

if n%2 == 0 and s[::(n//2-1)] == s[(n//2-1)::]:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

n = int(input())
s = input()

center=int(n/2)

if n%2==0 and s[:center] == s[center:]:
  print('Yes')
else:
  print('No')
import math
A, B = map(int, input().split())

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

print(lcm(A, B))

### FIXED CODE ###

import fractions
A, B = map(int, input().split())

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

print(lcm(A, B))
a, b, c = map(input().split())
a = int(a)
c = int(c)
if b == +:
  print(a + c)
else:
  print(a - c)

### FIXED CODE ###

a, b, c = input().split()
a = int(a)
c = int(c)
if b == '+':
  print(a + c)
else:
  print(a - c)
n=int(input())
a=sorted(list(map(int,input().split())))
i=0
while(a[1] != 0):
    a[i+1]=a[i+1]-(a[i+1]//a[i])*a[i]
    a=sorted(a)
    if(a[0] == 0):
        i += 1
        while(a[1] != 0):
            a[i+1]=a[i+1]-(a[i+1]//a[i])*a[i]
            a=sorted(a)
print(a[i+1])

### FIXED CODE ###

a,b=map(int,input().split())
if(b%a==0):
    print(a+b)
else:
    print(b-a)
#coding: UTF-8

r, c = map(int, input().split())
list = [[0 for i in range(r+1)] for j in range(c+1)]

a = [input().split() for k in range(c)]

for l in range(r):
    for m in range(c):
        list[l][c] += int(a[l][m])
        list[r][m] += int(a[l][m])
        list[l][m] = int(a[l][m])

for n in range(r):
    print(list[r][c])
    print(int(a[n][c-1]))
    list[r][c] += list[n][c]

print(list)


### FIXED CODE ###

#coding: UTF-8
import sys

H, W = map(int, input().split())
table = [[0]*(W+1) for i in range(H+1)]
# list = [[0 for i in range(W+1)] for j in range(H+1)]

for row in range(H):
    pre_table = list(map(int, input().split()))
    for col in range(W):
        table[row][col] = pre_table[col]

for row in range(H):
    for col in range(W):
        table[row][W] += table[row][col]

for col in range(W+1):
    for row in range(H):
        table[H][col] += table[row][col]

for row in range(H+1):
    print("%d"%(table[row][0]), end="")
    for col in range(1, W+1):
        print(" %d"%(table[row][col]), end = "")
    print()
N=int(input())
edge=[[] for i in range(N)]
for i in range(N-1):
    a,b=map(int,input().split())
    edge[a].append(b)
    edge[b].append(a)

antena=[]
for i in range(N):
    if len(edge[i])>2:
        antena.append(i)

if not antena:
    print(1)
    exit()

parent=[-1]*N
root=antena[0]

def dfs(v,pv):
    parent[v]=pv
    for i in edge[v]:
        if i!=pv:
            dfs(i,v)

dfs(root,-1)

antena=set(antena)

q=[root]
sub=[]
while q:
    while q:
        x=q.pop()
        if x in antena:
            v=x
            while parent[v] not in antena and parent[v]!=-1:
                antena.add(parent[v])
                v=parent[v]
        for nv in edge[x]:
            if nv!=parent[x]:
                sub.append(nv)

        if not q:
            q=sub
            sub=[]
            break

ans=0
for u in antena:
    if len(edge[u])==1:
        ans+=1
    elif len(edge[u])==2:
        check=0
        for v in edge[u]:
            check+=(v in antena)
        if check==1:
            ans+=1
    else:
        check=0
        for v in edge[u]:
            check+=(v in antena)
        if check>=len(edge[u])-1:
            continue
        else:
            ans+=len(edge[u])-1-check
print(ans)


### FIXED CODE ###

import sys

input=sys.stdin.readline
sys.setrecursionlimit(10**7)

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

antena=[]
for i in range(N):
    if len(edge[i])>2:
        antena.append(i)

if not antena:
    print(1)
    exit()

parent=[-1]*N
root=antena[0]

def dfs(v,pv):
    parent[v]=pv
    for i in edge[v]:
        if i!=pv:
            dfs(i,v)

dfs(root,-1)

antena=set(antena)

q=[root]
sub=[]
while q:
    while q:
        x=q.pop()
        if x in antena:
            v=x
            while parent[v] not in antena and parent[v]!=-1:
                antena.add(parent[v])
                v=parent[v]
        for nv in edge[x]:
            if nv!=parent[x]:
                sub.append(nv)

        if not q:
            q=sub
            sub=[]
            break

ans=0
for u in antena:
    if len(edge[u])==1:
        ans+=1
    elif len(edge[u])==2:
        check=0
        for v in edge[u]:
            check+=(v in antena)
        if check==1:
            ans+=1
    else:
        check=0
        for v in edge[u]:
            check+=(v in antena)
        if check>=len(edge[u])-1:
            continue
        else:
            ans+=len(edge[u])-1-check
print(ans)
#19:32
n = int(input())
ans = 0
for i in range(1,int(n**.5)+1):
  if n % i == 0:
    x = n // i - 1
    if n // x == n % x == i:
      ans += x
      #print(x)
print(ans)

### FIXED CODE ###

#19:32
n = int(input())
ans = 0
if n == 1:
  print(0)
else:
  for i in range(1,int(n**.5)+1):
    if n % i == 0:
      x = n // i - 1
      if n // x == n % x == i:
        ans += x
        #print(x)
  print(ans)
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string



INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7


n, k = LI()
dp = [[[0]*n*(n+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n):
    for j in range(i+1):
        for l in range(k+1):
            dp[i+1][j+1][l+2*(j+1)] += dp[i][j][l]
            dp[i+1][j+1][l+2*(j+1)]%=mod
            dp[i+1][j][l+2*j] += dp[i][j][l]*(j*2+1)
            dp[i+1][j][l+2 * j] %= mod
            if j != 0:
                dp[i+1][j-1][l+(j-1)*2] += dp[i][j][l]*j*j
                dp[i + 1][j - 1][l + (j - 1) * 2]%=mod



print(dp[n][0][k]%mod)


### FIXED CODE ###

from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
from bisect import bisect_left, bisect_right
import random
from itertools import permutations, accumulate, combinations
import sys
import string



INF = float('inf')
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7


n, k = LI()
dp = [[[0]*n**2*4 for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n):
    for j in range(i+1):
        for l in range(k+1):
            dp[i+1][j+1][l+2*(j+1)] += dp[i][j][l]
            dp[i+1][j+1][l+2*(j+1)]%=mod
            dp[i+1][j][l+2*j] += dp[i][j][l]*(j*2+1)
            dp[i+1][j][l+2 * j] %= mod
            if j!= 0:
                dp[i+1][j-1][l+(j-1)*2] += dp[i][j][l]*j*j
                dp[i+1][j-1][l+(j-1)*2]%=mod



print(dp[n][0][k]%mod)
n, m = map(int, input().split())
x = list(map(int, input().split()))
x.sort()
cheak = [0]*m
for i in range(m):
    cheak[m] = abs[x[m+1]-x[m]]
cheak.sort()
for j in range(n-1):
    cheak.pop(m-j)
ans = sum(cheak)
print(ans)

### FIXED CODE ###

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

if n >= m:
    ans = 0
else:
    x.sort()
    cheak = [0]*(m-1)
    
    for i in range(m-1):
        cheak[i] = abs(x[i+1]-x[i])
    cheak.sort(reverse=True)
    
    for j in range(n-1):
        cheak.pop(0)
    
    ans = sum(cheak)
print(ans)
import sys

def main():
    n, k = map(int, input().split())
    cnt = 0
    for x in sys.stdin.readlines:
        a, b = map(int, x.split())
        if cnt + b < k:
            cnt += b
        else:
            print(a)
            exit()

if __name__ == "__main__":
    main()

### FIXED CODE ###

# https://atcoder.jp/contests/abc061/tasks/abc061_c
import sys

def main():
    n, k = map(int, input().split())
    ans = [0 for _ in range(10**5+1)]
    for x in sys.stdin.readlines():
        a, b = map(int, x.split())
        ans[a] += b

    cnt = 0
    for i in range(10**5+1):
        cnt += ans[i]
        if cnt >= k:
            print(i)
            exit()

if __name__ == "__main__":
    main()
N = input()

print('Yes' if '7' in str(N) else 'No'

### FIXED CODE ###

N = input()

print('Yes' if '7' in str(N) else 'No')