qyliang/CodeNanoFix huggingface dataset:
Buggy code:
n,m,c=map(int,input().split())
b=[int(i) for i in input().split()]
a=[[int(i) for i in input().split()] for j in range(n)]
count = 0
ans = 0
for j in range(n):
    for i in range(m):
        count += b[i]*a[i]
        if count>0:
            ans += 1
print(ans)

Fixed code:
n , m, c = map(int, input().split())
b = list(map(int, input().split()))
ans = 0

for i in range(n):
    a = list(map(int, input().split()))
    check = 0
    for j in range(m):
        check += a[j] * b[j]
    if check + c > 0:
        ans += 1
print(ans)
Buggy code:
N, M, C = map(int, input().split())
B= list(map(int, input().split()))

for j in range(N):
  A= list(map(int, input().split()))
  i=0
  sum=0
  cnt=0
  for i in range(M):
    sum = sum + B[i]*A[i]
  if sum >= 0:
    cnt = cnt+1

Fixed code:
N, M, C = map(int, input().split())
B= list(map(int, input().split()))
cnt = 0
for j in range(N):
    A= list(map(int, input().split()))
    i=0
    sum=0
    for i in range(M):
        sum = sum + B[i]*A[i]
    sum = sum + C
    if sum > 0:
        cnt += 1

print(cnt)
Buggy code:
# coding: utf-8

s = input().rstrip().split(' ')
n, m, c = int(s[0]),int(s[1]),int(s[2])

b = input().rstrip().split(' ')

a = []
count = 0
sum = c
for i in range(n):
    a = input().rstrip().split(' ')
    for j in range(m):
        sum += int(a[j])*int(b[j])
    a.clear()
    if sum > 0:
        count += 1

print(count)



Fixed code:
# coding: utf-8

s = input().rstrip().split(' ')
n, m, c = int(s[0]),int(s[1]),int(s[2])

b = input().rstrip().split(' ')

a = []
count = 0
sum = c
for i in range(n):
    a = input().rstrip().split(' ')
    for j in range(m):
        sum += int(a[j])*int(b[j])
    a.clear()
    if sum > 0:
        count += 1
    sum = c

print(count)
Buggy code:
n,m,c=map(int,input().split())
b_list=list(map(int,input().split()))

ans=0
for i in range(n):
  a_list=list(map(int,input().split()))
  num=0
  for j in range(m):
    num+=b_list[j]*a_list[j]
  if num-c>0:
    ans+=1
  

Fixed code:
n,m,c=map(int,input().split())
b_list=list(map(int,input().split()))

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

print(ans)
Buggy code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
    a = list(map(int,input().split()))
    num = 0
    for j in range(m):
        num += a[j]*b[j]
    num += C
    if num > 0:
        ans += 1
print(ans)

Fixed code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
    a = list(map(int,input().split()))
    num = 0
    for j in range(m):
        num += a[j]*b[j]
    num += c
    if num > 0:
        ans += 1
print(ans)
Buggy code:
a,s,d=map(int,input().split())
list=list(map(int,input().split()))
c=0
for i in range(a):
  l=list(map(int,input().split()))
  sum=d
  for k in range(s):
    sum+=list[k]*l[k]
  if sum>0:
    c+=1
print(c)
  

Fixed code:
a,s,d=map(int,input().split())
lis=list(map(int,input().split()))
c=0
for i in range(a):
  l=list(map(int,input().split()))    
  sum=d
  for k in range(s):
    sum+=lis[k]*l[k]
  if sum>0:
    c+=1
print(c)
Buggy code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
check = 0
d = 0
for i in range(n):
    A = list(map(int,input().split()))
    for j in range(m):
        d += b[j]*A[j]
    if d+c > 0:
        check += 1

print(check)


Fixed code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
check = 0
for i in range(n):
    d = 0
    A = list(map(int,input().split()))
    for j in range(m):
        d += b[j]*A[j]
    if d+c > 0:
        check += 1

print(check)
Buggy code:
N,M,C=map(int,input().split())
B=list(int,input().split())
num=0
for i in range(N):
  sum=0
  A=list(int,input().split())
  for j in range(M):
    sum+=A[j] * B[j]
  if sum+C >0:
    num+=1
print(num)

Fixed code:
N,M,C=map(int,input().split())
B=list(map(int,input().split()))
num=0
A=[]
for i in range(N):
  A.append(list(map(int,input().split())))
D=[]
for j in range(N):
  sum=0
  D=A[j]
  for k in range(M):
    sum+=B[k]*D[k]
  if sum+C>0:
    num+=1
print(num)
Buggy code:
n,m,c=map(int,input().split())
b=list(map(int, input().split()))
u=0
for i in range(n):
    inp=list(map(int,input().split()))
    s=0
    for j in range(m):
        s+=inp[j]*(j+1)
    s+=c
    if s>0:
        u+=1
print(u)

Fixed code:
n,m,c=map(int,input().split())
b=list(map(int, input().split()))
u=0
for i in range(n):
    inp=list(map(int,input().split()))
    s=0
    for j in range(m):
        s+=inp[j]*(b[j])
    s+=c
    if s>0:
        u+=1
print(u)
Buggy code:
n,m,c=map(int,input().split())
b=list(map(int,input().split()))

ans = 0

for i in range(n):
    a = list(map(int,input().split()))
    x = c
    for j in range():
        x += a[j]*b[j]
    if x > 0:
        ans += 1
print(ans)

Fixed code:
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in range(n):
    if sum([a[i][j] * b[j] for j in range(m)]) + c > 0:
        ans += 1
print(ans)
Buggy code:
n,m,c = map(int,input().split())

bl = list(map(int,input().split()))
al = [list(map(int,input().split())) for i in range(n)]
cnt = 0

for i in range(n):
    total = 0
    for j in range(m):
        total+=bl[j]*al[i][j]
        total+=c
        if 0 < total:
            cnt+=1
print(cnt)



Fixed code:
n,m,c = map(int,input().split())

bl = list(map(int,input().split()))
al = [list(map(int,input().split())) for i in range(n)]
cnt = 0

for i in range(n):
    total = 0
    for j in range(m):
        total+=bl[j]*al[i][j]
    total+=c
    if 0 < total:
        cnt+=1
print(cnt)
Buggy code:
import sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx():return list(map(lambda x:int(x)*-1,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":pass
n,m,c = i2()
b = intl()
cnt = 0
s = 0
for i in range(n):
    a = intl()
    for i in range(m):
        s += a[i]*b[i]
        print(s)
    if s+c > 0:
        cnt += 1
    s = 0
print(cnt)

Fixed code:
import sys
import math
def i():return int(sys.stdin.readline().replace("\n",""))
def i2():return map(int,sys.stdin.readline().replace("\n","").split())
def s():return str(sys.stdin.readline().replace("\n",""))
def l():return list(sys.stdin.readline().replace("\n",""))
def intl():return [int(k) for k in sys.stdin.readline().replace("\n","").split()]
def lx():return list(map(lambda x:int(x)*-1,sys.stdin.readline().replace("\n","").split()))
def t():return tuple(map(int,sys.stdin.readline().replace("\n","").split()))

if __name__ == "__main__":pass
n,m,c = i2()
b = intl()
cnt = 0
s = 0
for i in range(n):
    a = intl()
    for i in range(m):
        s += a[i]*b[i]
    if s+c > 0:
        cnt += 1
    s = 0
print(cnt)
Buggy code:
import sys

n, m, c = map(int, sys.stdin.readline().split())
blist = list([int(i)-1 for i in sys.stdin.readline().split()])

ans = 0
for _ in range(n):
    tmp = list([int(i)-1 for i in sys.stdin.readline().split()])
    check = c
    for i in range(m):
        check += tmp[i] * blist[i]
    if check > 0:
        ans += 1

print(ans)


Fixed code:
import sys

n, m, c = map(int, sys.stdin.readline().split())
blist = list([int(i) for i in sys.stdin.readline().split()])

ans = 0
for _ in range(n):
    tmp = list([int(i) for i in sys.stdin.readline().split()])
    check = c
    for i in range(m):
        check += tmp[i] * blist[i]
    if check > 0:
        ans += 1

print(ans)
Buggy code:
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
l=[]
ans=[]
cnt=0
for i in range(n):
	a=list(map(int,input().split()))
	l.append(a)
for i in range(n):
	sum=0
	for j in range(m):
		sum+=b[j]*l[i][j]
		if j==(m-1):
			sum-=c
			ans.append(sum)
for i in ans:
	if i>0:
		cnt+=1
print(cnt)

Fixed code:
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
l=[]
ans=[]
cnt=0
for i in range(n):
	a=list(map(int,input().split()))
	l.append(a)
for i in range(n):
	sum=0
	for j in range(m):
		sum+=b[j]*l[i][j]
		if j==(m-1):
			sum+=c
			ans.append(sum)
for i in ans:
	if i>0:
		cnt+=1
print(cnt)
Buggy code:
n,m,c=map(int, input().split())
B=list(map(int, input().split()))
g=0
for i in range(n):
  A=list(map(int, input().split()))
  for i in range(m):
    t=A[i]*B[i]
    if t+c>0:
      g+=1
print(g)

Fixed code:
n,m,c=map(int, input().split())
B=list(map(int, input().split()))
g=0
t=0
for i in range(n):
  A=list(map(int, input().split()))
  for i in range(m):
    t+=A[i]*B[i]
  if t+c>0:
    g+=1
  t=0
print(g)
Buggy code:
from sys import stdin
 
n,m,c = map(int, input().split())
b = list(map(int, input().split()))

ans = 0
Sum = 0
for i in range(n):
    a = list(map(int, input().split()))

    for j in range(m):
        Sum+=a[j]*b[j]
    if Sum+c>0:
        ans+=1
print(ans)



Fixed code:
from sys import stdin
 
n,m,c = map(int, input().split())
b = list(map(int, input().split()))

ans = 0
for i in range(n):
    a = list(map(int, input().split()))
    d = 0
    for j in range(m):
        d = d + a[j]*b[j]
    if d+c > 0:
        ans = ans + 1
print(ans)
Buggy code:
N, M, C = map(int, input().split())
B = [int(i) for i in input().split()]
ans = 0
for _ in range(N):
  A = [B[i] * int(j) for i,j in enumerate(input().split())]
  ans += 1 if sum(A) > 0 else 0
print(ans)

Fixed code:
N, M, C = map(int, input().split())
B = [int(i) for i in input().split()]
ans = 0
for _ in range(N):
  A = [B[i] * int(j) for i,j in enumerate(input().split())]
  ans += 1 if sum(A) + C > 0 else 0
print(ans)
Buggy code:
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
x = -c
lst = []
tmp = 0

for i in range(n):

    for j in range(m):
        x += a[i][j]*b[j]
    lst.append(x)

for i in range(n):
    if lst[i] > 0:
        tmp += 1

print(tmp)

Fixed code:
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
lst = []
tmp = 0

for i in range(n):
    
    x = c
    for j in range(m):
        x += a[i][j]*b[j]
    lst.append(x)

for i in range(n):
    if lst[i] > 0:
        tmp += 1

print(tmp)
Buggy code:
N, M, C = map(int, input().split())
B=list(map(int, input().split))
for i in range(N):
  A=list(map(int, input().split))
  for j in range(M):
    sum=sum(B[j]*A[j])
  if sum+C>0:
  answer+=1
print(answer)


Fixed code:
N,M,C = map(int, input().split())

B = list(map(int, input().split()))
ans = 0
for i in range(N):
    sum = C
    A = list(map(int, input().split()))
    for j in range(M):
        sum += (B[j] * A[j])
    if sum > 0:
        ans += 1

print(ans)
Buggy code:
N,M,C = map(int,input().split())
B_lst = map(int,input().split())
count=0
for _ in range(N):
	A_lst = map(int,input().split())
	ans = C
	for a,b in zip(A_lst,B_lst):
		ans += a*b
	if ans > 0:
		count += 1
print(count)


Fixed code:
N,M,C = map(int,input().split())
B_lst = list(map(int,input().split()))
count=0
for _ in range(N):
	A_lst = list(map(int,input().split()))
	ans = C
	for a,b in zip(A_lst,B_lst):
		ans += a*b
	if ans > 0:
		count += 1
print(count)
Buggy code:
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
count = 0
for i in range(n):
    a = list(map(int, input().split()))
    z = 0
    for j in range(m):
        z += b[j] * a[j]
    if z + c >= 0:
        count += 1
print(count)

Fixed code:
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
count = 0
for i in range(n):
    a = list(map(int, input().split()))
    z = 0
    for j in range(m):
        z += b[j] * a[j]
    if z + c > 0:
        count += 1
print(count)
Buggy code:
import numpy as np

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

b=np.array([int, input().split()])
count=0
for _ in range(M):
    a=np.array([map(int, input().split())])
    e=a*b
    d=np.sum(e,axis=0)+C
    if d>0:
        count+=1
print(count)

Fixed code:
import numpy as np

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

b=list(map(int, input().split()))
b=np.array(b)
count=0
for _ in range(N):
    a=list(map(int, input().split()))
    a=np.array(a)
    e=a*b
    d=np.sum(e,axis=0)+C
    if d>0:
        count+=1
print(count)
Buggy code:
N,M,C=map(int,input().split())
B=list(input().split())
right_answer=0
for i in range(N):
  A=list(input().split())
  if sum(a*b for a,b in zip(A,B))+C>0:
    right_answer+=1
print(right_answer)

Fixed code:
N,M,C=map(int,input().split())
B=list(map(int,input().split()))
right_answer=0
for i in range(N):
  A=list(map(int,input().split()))
  if sum(a*b for a,b in zip(A,B))+C>0:
    right_answer+=1
print(right_answer)
Buggy code:
N,M,C = list(map(int,input().split()))
B = list(map(int,input().split()))
total = 0
ans = 0
for i in range(N):
    A = list(map(int,input().split()))
    for j in range(N):
        total += A[i]*B[i]
if total > 0:
    ans += 1
print(ans)

Fixed code:
N,M,C = list(map(int,input().split()))
B = list(map(int,input().split()))
ans = 0
total = 0
lst = []
for i in range(N):
  A = list(map(int,input().split()))
  for j in range(M):
    total += A[j]*B[j]
  lst.append(total)
  total = 0
for i in lst:
    if i +C > 0:
      ans += 1
print(ans)
Buggy code:
import numpy as np
N, M ,C = map(int, input().split())
a = []
for i in range(M):
    a.append(list(map(int, input().split())))
all = np.array(a)
sum = 0
num = 0

for i in range(N):
    mul = np.sum(all[0] * all[i+1]) + C
    if mul > 0:
        num += 1
    mul = 0

print(num)

Fixed code:
import numpy as np
N, M ,C = map(int, input().split())
a = []
for i in range(N+1):
    a.append(list(map(int, input().split())))
all = np.array(a)
sum = 0
num = 0

for i in range(N):
    mul = np.sum(all[0] * all[i+1]) + C
    if mul > 0:
        num += 1
    mul = 0

print(num)
Buggy code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
a = []
ans = 0
for i in range(n):
    arr = list(map(int,input().split()))
    a.append(arr)
for i in a:
    tmp = c
    for j in range(n+1):
        tmp += i[j]*b[j]
    if tmp > 0:ans+=1
print(ans)

Fixed code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
a = []
ans = 0
for i in range(n):
    arr = list(map(int,input().split()))
    a.append(arr)
for i in a:
    tmp = c
    for j in range(m):
        tmp += i[j]*b[j]
    if tmp > 0:ans+=1
print(ans)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))

ans = 0

for i in range(N):
  work = C
  for j in range(M):
    work += A[j] * B[j]
  if work >= 0:
    ans += 1
    
print(ans)

Fixed code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))

ans = 0

for i in range(N):
  A = list(map(int, input().split()))
  work = C
  for j in range(M):
    work += A[j] * B[j]
  if work > 0:
    ans += 1
    
print(ans)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
a = []
correct_num = 0
for i in range(N):
    a.append(map(int, input().split()))
    sum = 0
    for j in range(M):
        sum + =a[i][j] * B[j]
    if sum > 0:
        correct_num += 1
    else:
        pass
print(sum)

Fixed code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
a = []
correct_num = 0
for i in range(N):
    a.append(list(map(int, input().split())))
    sum = 0
    for j in range(M):
        sum += a[i][j] * B[j]
    if sum + C > 0:
        correct_num += 1
    else:
        pass
print(correct_num)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
ans = 0
s = 0

for _ in range(N):
    A = list(map(int, input().split()))
    for i in range(M):
        s += A[i] * B[i]
    s += C
    if s > 0:
        ans += 1
print(ans)

Fixed code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
ans = 0
s = 0

for _ in range(N):
    A = list(map(int, input().split()))
    for i in range(M):
        s += A[i] * B[i]
    s += C
    if s > 0:
        ans += 1
    s = 0
print(ans)
Buggy code:
import numpy as np
N,M,C = map(int,input().split())
B = [int(k) for k in input().split()]
for i in range(1,N):
    Ai = [int(j) for j in input().split()]
    ai = np.array(Ai)   
b = np.array(B)
cnt = 0
for i in range(1,N):
    if (np.dot(ai,b) + C >0):
        cnt += 1
    else:
        cnt = cnt
        
print(cnt)




Fixed code:
import numpy as np
N,M,C = map(int,input().split())
B = [int(k) for k in input().split()]
A = [[int(j) for j in input().split()] for i in range(N)] 
b = np.array(B)
cnt = 0
for i in range(N):
    if (np.dot(np.array(A[i]),b) + C >0):
        cnt += 1
    else:
        cnt = cnt
        
print(cnt)
Buggy code:
n,m,c = [int(i) for i in input().split()]
e = [[int(i) for i in input().split()] for i in range(1+n)]

count=0
tmp=0

for j in range(1,n+1):
  for i in range(1,m):
    tmp+=e[j][i]*e[0][i]
  if tmp>c:
    count+=1
    
print(count)

Fixed code:
n,m,c = [int(i) for i in input().split()]
e = [[int(i) for i in input().split()] for i in range(1+n)]

count=0
for j in range(1,n+1):
  tmp=0
  for i in range(0,m):
    tmp+=e[j][i]*e[0][i]
#  print(tmp)
  if tmp+c>0:
    count+=1
    
print(count)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [0]*N
count = 0

for n in range(N):
  A[n] = list(map(int, input().split()))
  
  for i in range(M):
    _sum += A[n][i] * B[i]
    
  if _sum + C > 0:
    count += 1
  else:
    continue
    
print(count)

Fixed code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [0]*N
count = 0

for n in range(N):
  A[n] = list(map(int, input().split()))
  
  _sum = 0
  for i in range(M):
    _sum += A[n][i] * B[i]
    
  if _sum + C > 0:
    count += 1
  else:
    continue
    
print(count)
Buggy code:
#B
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
# print(a, b)
count=0
for i in a:
    for j in range(len(i)):
        i[j] *= b[j]
    if sum(i) >= -c:
        count += 1

print(count)

Fixed code:
#B
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
# print(a, b)
count=0
for i in a:
    for j in range(len(i)):
        i[j] *= b[j]
    if sum(i) > -c:
        count += 1

print(count)
Buggy code:
# ABC 121: B – Can you solve this?
n, m, c = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]

a = []
for _ in range(n):
    a.append([int(s) for s in input().split()])

counter = 0

for i in range(n):
    answer = c
    
    for j in range(m):
        answer += a[i][j] * b[j]

    if answer > 0:
        print(i, answer)
        counter += 1

print(counter)

Fixed code:
# ABC 121: B – Can you solve this?
n, m, c = [int(s) for s in input().split()]
b = [int(s) for s in input().split()]

a = []
for _ in range(n):
    a.append([int(s) for s in input().split()])

counter = 0

for i in range(n):
    answer = c
    
    for j in range(m):
        answer += a[i][j] * b[j]

    if answer > 0:
        counter += 1

print(counter)
Buggy code:
n, m, c = map(int, input().split())
b = list(map(int, input().split()))
ans = 0
for _ in range(n):
    a = list(map(int, input().split()))

    if a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + c > 0:
         ans += 1
print(ans)


Fixed code:
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
ans=0
for _ in range(n):
    a=list(map(int,input().split()))
    if sum(a[i]*b[i] for i in range(m))+c>0: ans+=1
print(ans)
Buggy code:
N,M,C=map(int,input().split()) 
B=list(map(int,input().split()))
A =[list(map(int,input().split()))for i in range(N)]
ans=0
for i in range(N):
    for j in range(M):
        X+=(A[i][j]*B[i])+C
    if  0 < X:
        ans = ans+1
    else:
        ans = ans
print(ans)

Fixed code:
N,M,C=map(int,input().split()) 
B=list(map(int,input().split()))
A =[list(map(int,input().split()))for i in range(N)]
ans=0
for i in range(N):
    X=0
    for j in range(M):
        X += A[i][j]*B[j]
    X += C
    if  0 < X:
        ans += 1
print(ans)
Buggy code:
import numpy as np

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

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

count = 0
for i in range (N):
    A = list(map(int,input().split()))
    if np.array(A)*np.array(B) > 0:
        count += 1
print(count)

Fixed code:
import numpy as np
 
N, M, C = map(int,input().split())
 
B = list(map(int,input().split()))
 
count = 0
for i in range (N):
    A = list(map(int,input().split()))
    if np.sum(np.array(A)*np.array(B)) + C> 0:
        count += 1
print(count)
Buggy code:
from functools import reduce
N, M, C = map(int, input().split())
B = map(int, input().split())
count = 0
for _ in range(N):
  	if 0 < C + reduce(lambda p: p[0]*p[1], zip(map(int, input().split()), B)):
    	count += 1
print(count)

Fixed code:
from functools import reduce
N, M, C = map(int, input().split())
*B, = map(int, input().split())
count = 0
for _ in range(N):
	if 0 < C + reduce(lambda acc, p: acc + p[0]*p[1], zip(map(int, input().split()), B), 0):
		count += 1
print(count)
Buggy code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
  a = list(map(int,input().split()))
  count = 0
  for j in range(m):
    count += b[j]*a[j]
  count += c
  if count > 0:
    ans += 0
print(ans)

Fixed code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
ans = 0
for i in range(n):
  a = list(map(int,input().split()))
  count = 0
  for j in range(m):
    count += b[j]*a[j]
  count += c
  if count > 0:
    ans += 1
print(ans)
Buggy code:
a=tuple(map(int,input().split()))
b=[]
for i in range(a[0]+1):
    b.append(list(map(int,input().split())))
ans=0
s=0
for j in range(a[0]):
    for k in range(a[1]):
        s+=b[j][k]*b[0][k]
    s+=a[2]
    if s>0:
        ans+=1
    s=0
print(ans)

Fixed code:
a=tuple(map(int,input().split()))
b=[]
for i in range(a[0]+1):
    b.append(list(map(int,input().split())))
ans=0
s=0
for j in range(a[0]+1)[1:a[0]+1]:
    for k in range(a[1]):
        s+=b[j][k]*b[0][k]
    s+=a[2]
    if s>0:
        ans+=1
    s=0
print(ans)
Buggy code:
I=lambda:map(int,input().split())
n,m,c=I()
b=list(I())
A=[];c=0
A+=list(I())
for a in A:
  d=0
  for i,j in zip(b,a):
    d+=i*j
  c+=(c+d>0)
print(c)

Fixed code:
I=lambda:map(int,input().split())
n,m,c=I()
b=list(I())
A=[list(I()) for _ in[0]*n]
e=0
for a in A:
  d=0
  for i,j in zip(b,a):
    d+=i*j
  e+=(d+c>0)
print(e)
Buggy code:
n,m,c = map(int,input().split())
b = [i for i in map(int,input().split())]
a = []
for j in range(n):
    a.append( [i for i in map(int,input().split())] )


ans = [0]*(n)
count = 0
print(ans)
for i in range(n) :
    for j in range(m):
        ans[i] += a[i][j] * b[j]
    if ans[i] + c > 0 :
        count += 1 
print(count)

Fixed code:
n,m,c = map(int,input().split())
b = [i for i in map(int,input().split())]
a = []
for j in range(n):
    a.append( [i for i in map(int,input().split())] )


ans = [0]*(n)
count = 0
for i in range(n) :
    for j in range(m):
        ans[i] += a[i][j] * b[j]
    if ans[i] + c > 0 :
        count += 1 
print(count)
Buggy code:
n, m, c=map(int, input().split())
b=list(map(int, input().split()))
x=0
for _ in range(n):
	s=list(map(int, input().split()))
	z=c
	for i in range(m):
		z+=s[i]*b[i]
		if z>0:
			x+=1
print(x)

Fixed code:
n, m, c=map(int, input().split())
b=list(map(int, input().split()))
x=0
for _ in range(n):
	s=list(map(int, input().split()))
	z=c
	for i in range(m):
		z+=(s[i]*b[i])
	if z>0:
			x+=1
print(x)