qyliang/CodeNanoFix huggingface dataset:
Buggy code:
n, m, c =map(int, input().split())
b = [int(x) for x in input().split()]
a = [[int (x) for x in input().split()] for _ in range(n)]

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

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

ans = 0
for i in range(n):
    cnt = 0
    for j in range(m):
        cnt += a[i][j] * b[j]
    
    cnt += c
    
    if 0 < cnt:
        ans += 1
        
print(ans)
Buggy code:
def resolve():
    cnt=0
    n,m,c=map(int, input().split())
    b_list=list(map(int, input().split()))
    for i in range(n):
        a_list=list(map(int, input().split()))
        for x in range(m):
            siki=0
            siki+=a_list[i]*b_list[i]
            if siki>-c:
                cnt+=1
    print(cnt)
resolve()

Fixed code:
def resolve():
    cnt = 0
    n, m, c = map(int, input().split())
    b_list = list(map(int, input().split()))
    for i in range(n):
        a_list = list(map(int, input().split()))
        siki = 0
        for x in range(m):
            siki += (a_list[x] * b_list[x])
        if siki+c > 0:
                cnt += 1
    print(cnt)
resolve()
Buggy code:
n, m, c = map(int, input().split())
bm = list(map(int, input().split()))
anm = []
for _ in range(n):
    anm.append(list(map(int, input().split())))
    
count = 0
for i in range(n):
    sumAB = 0
    for j in range(m):
        sumAB += anm[i][j] * bm[j]

    if sumAB -10 > 0:
        count += 1

print(count)

Fixed code:
n, m, c = map(int, input().split())
bm = list(map(int, input().split()))
anm = []
for _ in range(n):
    anm.append(list(map(int, input().split())))
    
count = 0
for i in range(n):
    sumAB = 0
    for j in range(m):
        sumAB += anm[i][j] * bm[j]

    #print(sumAB)
    if (sumAB + c) > 0:
        count += 1
print(count)
Buggy code:
import numpy as np
n, m, c = map(int, input().split())
B = np.array([list(map(int, input().split()))])
count = 0
for i in range(n):
  ab = np.array([list(map(int, input().split()))])
  if abs(np.dot(ab, B.T)) + c > 0:
    count += 1
print(count)

Fixed code:
import numpy as np
n, m, c = map(int, input().split())
B = np.array([list(map(int, input().split()))])
count = 0
for i in range(n):
  ab = np.array([list(map(int, input().split()))])
  if int(np.dot(ab, B.T)) + c > 0:
    count += 1
print(count)
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)]

res = 0
for p in a:
  if sum(i+j for i,j in zip(p,b)) + c > 0:
    res += 1
return res

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

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

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

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

Fixed code:
import numpy as np
N,M,C = (int(j) for j in input().split())
B = [int(j) for j in input().split()]
list = [[0]* M]*N
for j in range(0,N):
        list[j] = [int(k) for k in input().split()]
count = 0
for j in range(0,N):
    if np.sum(np.array(list[j]) * np.array(B)) + C > 0:
        count = count + 1
print(count)
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()))
ans=0
for i in range(n):
  C=c
  for j in range(m):
    C=C+a[i][j]*b[j]
    if C>0:
      ans=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 d in range(n)]
ans=0
for i in range(n):
    C=c
    for j in range(m):
        C+=a[i][j]*b[j]
    if C>0:
        ans+=1
print(ans)
Buggy code:
N,M,C=map(int,input().split())
B=list(map(int,input().split()))
A=[]
for i in range(N):
  A.append([int(i) in i for input().split()])
ans=0
for a in A:
  asum=0
  for i in range(M):
    asum+=A[i]+B[i]
  asum+=C
  if asum > 0:
    ans+=1
print(ans)

Fixed code:
N,M,C=map(int,input().split())
B=list(map(int,input().split()))
A=[]
for i in range(N):
  A.append([int(i) for i in input().split()])
ans=0
for a in A:
  asum=0
  for i in range(M):
    asum += a[i]*B[i]
  asum+=C
  if asum > 0:
    ans+=1
print(ans)
Buggy code:
#import sys
#import math
#import numpy as np
'''a,b= map(int,input().split())'''
#a, b, c = [list(map(int, input().split())) for _ in range(3)]
#li0= [int(x) for x in input().split()]
#n,l= map(int, input().split())
#x = [list(map(int, input().split())) for _ in range(n)] 
a,b,c=map(int,input().split())
li=[list(map(int,input().split())) for _ in range(a)]
ans=ju=0

for i in range(1,a):
  ans=0
  for j in range(b):
    ans+=li[0][j]*li[i][j]
  ans+=c

  if ans>0:
    ju+=1
print(ju)



Fixed code:
#import sys
#import math
#import numpy as np
'''a,b= map(int,input().split())'''
#a, b, c = [list(map(int, input().split())) for _ in range(3)]
#li0= [int(x) for x in input().split()]
#n,l= map(int, input().split())
#x = [list(map(int, input().split())) for _ in range(n)] 
a,b,c=map(int,input().split())
li=[list(map(int,input().split())) for _ in range(a+1)]
ans=ju=0
for i in range(1,a+1):
  ans=0
  for j in range(b):
    ans+=li[0][j]*li[i][j]
  ans+=c
  if ans>0:
    ju+=1
print(ju)
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()))
  tmp = C
  for j in range(M):
    tmp += A[j]*B[j]
  if tmp > 0:
    ans += 1
print(ans)


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

B = list(input().split())

ans = []

src = []

for i in range(N):
  src.append(list(map(int, input().split())))
  
  for n in range(N):
    d = src[i][n]*B[n] + C
    if (d > 0):
      ans.append(1)

print(ans.count(1))

  
  

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

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

print(ans)
Buggy code:
#5
n,m,c = map(int,input().split())

b = [int(i) for i in input().split()]

ans = 0 
cnt = 0

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

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

b = [int(i) for i in input().split()]


cnt = 0

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

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

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

print(A)
cnt = 0
for a_list in A:
    sum = 0
    for a, b in zip(a_list, B):
        sum += a*b
    if sum + C > 0:
        cnt += 1

print(cnt)

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

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

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

cnt = 0
for a_list in A:
    sum = 0
    for a, b in zip(a_list, B):
        sum += a*b
    if sum + C > 0:
        cnt += 1

print(cnt)
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()))
  d=0
  for j,k in zip(A,B):
    d+=A*B
  if d>-C:
    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()))
  d=0
  for j,k in zip(A,B):
    d+=j*k
  if d>-C:
    ans+=1
print(ans)
Buggy code:
n,m,c = map(int,input().split())
li = []
for i in range(n+1):
	li.append(list(map(int,input().split())))

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

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

cnt = 0
for i in range(1,n+1):
  tmp = 0
  for j in range(m):
    tmp += li[i][j] * li[0][j]
  tmp += c
  if tmp > 0:
    cnt += 1
    
print(cnt)
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()))
    p = 0
    for j in range(m):
        p += a[j] * b[j]
    p += c
    if p > 0:
        count =+ 1
print(count)

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

count=0
sum=0

for i in range(n):
    a=list(map(int,input().split()))
    for j in range(m):
        sum+=a[j]*b[j]

    sum+=c
    if sum>0:
        count+=1
    sum=0

print(count)
Buggy code:
n,m,c = map(int,input().split())
ans = 0
b = list(map(int,input().split()))
for i in range(n):
    current = 0
    a = list(map(int,input().split()))
    for j in range(m):
        current += a[j]*b[j]
    ans += 1 if c+current else 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()))
    ans += 1 if 0 < c+sum([a[j]*b[j] for j in range(m)]) else 0
print(ans)
Buggy code:
#import sys
#import numpy as np
#import math
#import itertools
#from fractions import Fraction
#import itertools
from collections import deque
#import heapq
#from fractions  import gcd
#input=sys.stdin.readline
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
ans=0c
for i in range(n):
    a=list(map(int,input().split()))
    res=[a[i]*b[i] for i in range(m)]
    if sum(res)+c>0:
        ans+=1
print(ans)

Fixed code:
#import sys
#import numpy as np
#import math
#import itertools
#from fractions import Fraction
#import itertools
from collections import deque
#import heapq
#from fractions  import gcd
#input=sys.stdin.readline
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()))
    res=[a[i]*b[i] for i in range(m)]
    if sum(res)+c>0:
        ans+=1
print(ans)
Buggy code:
import numpy as np
N, M, C = map(int, input().split()) 
B = np.array(list(map(int, input().split())))
A = np.array([list(map(int,list(input()))) for i in range(N)])

ans = 0
for i in range(M):
  if np.sum(A[:, i] * B) + C > 0:
    ans += 1
print(ans)

Fixed code:
import numpy as np
N, M, C = map(int, input().split()) 
B = np.array(list(map(int, input().split())))
A = np.array([list(map(int,list(input().split()))) for i in range(N)])
 
ans = 0
for i in range(N):
    val = np.sum(A[i, :] * B) + C
    if val > 0:
        ans += 1
print(ans)
Buggy code:
n,m,c = map(int, input().split())
b = list(map(int,input().split()))
a = []

def mul(x, y):
  ret = 0
  for i in range(len(x)):
    ret += x[i]*y[i]

ans = 0
for i in range(n):
  a = list(map(int, input().split()))
  if mul(a, b) + c > 0:
    ans += 1

print(ans)

Fixed code:
n,m,c = map(int, input().split())
b = list(map(int,input().split()))
a = []

def mul(x, y):
  ret = 0
  for i in range(len(x)):
    ret += x[i]*y[i]
  return ret
    
ans = 0
for i in range(n):
  a = list(map(int, input().split()))
  if mul(a, b) + 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)]
cnt = 0
sum = 0
for i in range(n):
    for j in range(m):
        sum += A[i][j] * B[j]
    if sum + c > 0:
        cnt += 1
print(cnt)


Fixed code:
n, m, c = map(int,input().split())
B = list(map(int,input().split()))
A = [input().split() for l in range(n)]
cnt = 0
for i in range(n):
    sum = 0
    for j in range(m):
        sum += int(A[i][j]) * B[j]
    if sum + c > 0:
        cnt += 1
print(cnt)
Buggy code:
N,M,C = map(int,input().split())
B = list(map(input().split()))
result = 0
for i in range(N):
  C = 0
  A = list(map(input().split()))
  for j in range(M):
    C += B[j]*A[j]
  if sum(C) > 0:
    result += 1
  else:
    None
print(result)

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

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

print(result)
Buggy code:
n,m,c=map(int,input().split())
sum=0
count=0
for i in range(m):
    b=list(map(int,input().split()))
    a=list(map(int,input().split()))
    sum+=b[i]*a[i]
for j in range(n):
    if sum>-c:
        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):
    p=c
    a=list(map(int,input().split()))
    for j in range(m):
        p+=a[j]*b[j]
    if p>0:
        count+=1
print(count)
Buggy code:
n,m,c=map(int, input().split())
b=list(map(int, input().split()))
tmp=0
cnt=0
a_i=[]
for _ in range(n):
    a=list(map(int, input().split()))
    for i in range(m):
        tmp=int(a[i])*int(b[i])
    if tmp+c>0:
        cnt+=1
print(cnt)

Fixed code:
n,m,c=map(int, input().split())
b=list(map(int, input().split()))
tmp=0
cnt=0
a_i=[]
for _ in range(n):
    a=list(map(int, input().split()))
    tmp=0
    for i in range(m):
       
        tmp+=int(a[i])*int(b[i])
    
    if tmp+c>0:
        cnt+=1
        
print(cnt)
Buggy code:
N,M,C=map(int,(input()).split())
List_B=[int(i) for i in (input()).split()]
t=0
for j in range(1,N+1):
  List_A=[int(k) for k in (input()).split()]
  if sum([x*y for (x,y) in zip(List_A,List_B)])==-C:
    t+=1
print(t)

Fixed code:
N,M,C=map(int,(input()).split())
List_B=[int(i) for i in (input()).split()]
t=0
for j in range(1,N+1):
  List_A=[int(k) for k in (input()).split()]
  if sum([x*y for (x,y) in zip(List_A,List_B)])>-C:
    t+=1
print(t)
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):
  s = sum([a[i][j]*b[j] for j in range(m)])
  if s+c > 0:
    print(i)
    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 i in range(n)]

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

Fixed code:
#B
count = 0
n,m,c = map(int, input().split())
b = list(map(int, input().split()))
for i in range(n):
    a = list(map(int, input().split()))
    ab=0
    for j in range(m):
        ab += a[j] * b[j]
    if -c<ab:
        count += 1
print(count)
Buggy code:
N,M,C = map(int,input().split())
B = input().split()
Anm = []
for i in range(N):
    Anm.append(input().split())
cont = 0
for A in Anm:
    c = 0
    for i in range(M):
        c += int(A[i]) * int(B[i])
    if c > 0:
        cont += 1
print(cont)

Fixed code:
N,M,C = map(int,input().split())
B = input().split()
Anm = []
for i in range(N):
    Anm.append(input().split())
cont = 0
for A in Anm:
    c = C
    for i in range(M):
        c += int(A[i]) * int(B[i])
    if c > 0:
        cont += 1
print(cont)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = []

for i in range(N):
    A.append(list(map(int, input().split())))

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

    

Fixed code:
N, M, C = map(int, input().split())
B = list(int(x) for x in input().split())
ans = 0
for i in range(N):
  x = 0
  A = list(int(x) for x in input().split())
  for j in range(M):
    x += A[j]*B[j]
  if x + C > 0:
    ans += 1
print(ans)
Buggy code:
import numpy as np
n, m, c = list(map(int, input().split()))
b = np.array(list(map(int, input().split())))
count = 0
print(b)
for i in range(n):
    a = np.array(list(map(int, input().split())))
    result = sum(a*b) + c
    print(result)
    if result > 0:
        count += 1
print(count)

Fixed code:
import numpy as np
n, m, c = list(map(int, input().split()))
b = np.array(list(map(int, input().split())))
count = 0
for i in range(n):
    a = np.array(list(map(int, input().split())))
    result = sum(a*b) + c
    if result > 0:
        count += 1
print(count)
Buggy code:
n,m,c = map(int,input().split())
b = list(map(int,input().split()))
#a = []
count = 0
for i in range(n):
	a = list(map(int,input().split()))
    tokuten = 0
	for j in range(m):
		tokuten += b[j]*a[j]
	if tokuten > c:
		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()))
	tokuten = 0
	for j in range(m):
		tokuten += b[j]*a[j]
	if tokuten > -c:
		count += 1

print(count)
Buggy code:
s = list(map(int, input().split()))
N = i[0]
M = i[1]
C = i[2]
B = list(map(int, input().split()))
x = 0
for i in range(N):
  k = C
  A = list(map(int, input().split()))
  for j in range(M):
    k = k + A[j] * B[j]
  if k > 0:
    x = x + 1
  else:
    pass
print(x)  

Fixed code:
s = list(map(int, input().split()))
N = s[0]
M = s[1]
C = s[2]
B = list(map(int, input().split()))
x = 0
for i in range(N):
  k = C
  A = list(map(int, input().split()))
  for j in range(M):
    k = k + A[j] * B[j]
  if k > 0:
    x = x + 1
  else:
    pass
print(x)
Buggy code:
import sys
N, M, C = map(int, input().split())
B = input().split()
sumN = 0
count = 0

for i in range(N):
    A = input().split()
    for j in range(M):
        sumN = sumN + int(A[j])*int(B[j])
    if sumN + C > 0:
        count += 1
    sumN = 0

Fixed code:
import sys
N, M, C = map(int, input().split())
B = input().split()
sumN = 0
count = 0

for i in range(N):
    A = input().split()
    for j in range(M):
        sumN = sumN + int(A[j])*int(B[j])
    if sumN + C > 0:
        count += 1
    sumN = 0

print(count)
Buggy code:
n, m, c = list(map(int, input().split()))
Bs = list(map(int, input().split()))
As = [list(map(int, input().split())) for i in range(n)]

counter = 0
for i in range(n):
    x = 0
    for j in range(m):
        x += As[i][j] * Bs[j]
        if x + c > 0:
            counter += 1
print(counter)


Fixed code:
n, m, c = list(map(int, input().split()))
Bs = list(map(int, input().split()))
As = [list(map(int, input().split())) for i in range(n)]

counter = 0
for i in range(n):
    x = 0
    for j in range(m):
        x += As[i][j] * Bs[j]
    x += c
    if x > 0:
        counter += 1
print(counter)
Buggy code:
#coding: utf-8
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = list(map(int, input().split())) for _ in range(N))
l []
for i in range(N):
    A = list(map(int, input().split()))
    l.append(sum(A[j] * B[j] for j in range(M)) + C > 0)
print(l)

Fixed code:
#coding: utf-8
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
l = []
for i in range(N):
    A = list(map(int, input().split()))
    l.append(sum(A[j] * B[j] for j in range(M)) + C > 0)
print(sum(l))
Buggy code:
import numpy as np
n,m,c=map(int,input().split())
b=np.array(list(map(int,input().split())))
ans=0
cnt=0
for i in range(0,n):
  a=np.array(list(map(int,input().split())))
  x=a*b
  
  for j in range(0,m):
    cnt+=x[j]
  cnt+=c  
  
  if cnt>0:
    ans+=1
    
print(ans)    
    
  
  



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

count = 0
for low in range(n):
    Sum = c
    for col in range(m):
        Sum += A[low][col]*B[col]

    if Sum >= 0:
        count += 1

print(count)

Fixed code:
n, m, c = map(int, input().split())
B = [int(i) for i in input().split()]
A = [list(map(int, input().split())) for i in range(n)]

count = 0
for low in range(n):
    Sum = c
    for col in range(m):
        Sum += A[low][col]*B[col]

    if Sum > 0:
        count += 1

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

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)]
count=0
for j in A:
    ans=C
    for i in range(M):
        ans+=B[i]*j[i]
    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()))
  hyoka = 0
  for k in range(M):
    hyoka = hyoka + A[k]*B[k]
  if hyoka+C > 0:
    count = cocunt + 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()))
  hyoka = 0
  for k in range(M):
    hyoka = hyoka + A[k]*B[k]
  if hyoka+C > 0:
    count = count + 1
print(count)
Buggy code:
N, M, C  = map(int, input().split())

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

count = 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:
        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()))
    sum = 0
    for j in range(M):
        sum += A[j] * B[j]
    if (sum + C) > 0:
        count += 1

print(count)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = [0] * N
for i in range(N):
  A[i] = list(map(int, input().split()))

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


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