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

Fixed code:
c = input().split()
c = list(map(int, c))
b = input().split()
b = list(map(int, b))
ans = 0
a = [0] * (c[0])
for n in range(c[0]):
	a[n] = input().split()
	a[n] = list(map(int, a[n]))
	tmp = 0
	for m in range(c[1]):
		tmp += b[m] * a[n][m]
	if tmp > -c[2]:
		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 j in range(N)]

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

Fixed 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):
    s = C
    for j in range(M):
        s += A[i][j]*B[j]
    if s>0:
        ans += 1
print(ans)
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()))
    for j in range(m):
        Sum+=a[j]*b[j]
    if Sum+c>0:
        Count+=1
    Sum=0
print(Count)

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)]
Count=0
for t in a:
    Sum=0
    for i in range(m):
        Sum+=t[i]*b[i]
    if Sum+c>0:
        Count+=1
print(Count)
Buggy code:
N,M,C = map(int, input().split())
B = list(map(int, input().split()))
A = []
counter = 0
for i in range(N):
    A.append(list(map(int, input().split())))
    val = 0
    for j in range(M):
        val += A[i][j] * B[j]
    else:
        if val + C > 0:
            count += 1 
print(count)


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

def solve(a,b,c):
    val = 0
    for ia,ib in zip(a,b):
        val += ia*ib
    val += c
    return val > 0

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

print(cnt)    

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

def solve(a,b,c):
    val = 0
    for ia,ib in zip(a,b):
        val += ia*ib
    val += c
    return val > 0

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

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

Fixed code:
n,m,c=map(int,input().split())
a=[]
for i in range(n+1):  
  a.append(list(map(int,input().split())) )
y=0
for i in range(n):
  x=0  
  for j in range(m):
    x+=a[i+1][j]*a[0][j]
  if x+c>0:
    y+=1
print(y)
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)]
ans = 0
for i in range(n):
    total = c
    for j in range(m):
        total += a[i][j] * b[j]
    if total > 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):
    total = c
    for j in range(m):
        total += A[i][j] * B[j]
    if total > 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()))
    tmp=0
    for j in range(M):
        tmp+=A[j]*B[j]
        if tmp+C>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()))
    tmp=0
    for j in range(M):
        tmp+=A[j]*B[j]
    if tmp+C>0:
        ans+=1
print(ans)
Buggy code:
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)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
hoge = [list(map(int, input().split())) for _ in range(N-1)]
C_m = [C for _ in range(M)]

out = []
res = 0
for i in range(N-1):
  for j in range(M):
    res += (hoge[i][j]* B[j])
  out.append((res+C) > 0)
  res = 0

print(sum(out))

Fixed code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
hoge = [list(map(int, input().split())) for _ in range(N)]
C_m = [C for _ in range(M)]

out = []
res = 0
for i in range(N):
  for j in range(M):
    res += (hoge[i][j]* B[j])
  out.append((res+C) > 0)
  res = 0

  
print(sum(out))
Buggy code:
N,M,C = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
A = [[int(x) for x in input().split()] for i in range(N)]

for i in range(N):
    sum = C
    for j in range(M):
        sum += A[i][j]*B[j]
    print(sum,sum>0)

Fixed code:
N,M,C = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
A = [[int(x) for x in input().split()] for i in range(N)]

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


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

Fixed code:
N, M, C = list(map(int, input().split()))
B = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
cnt = 0
for x in A:
  total = sum([x[i]*B[i] for i in range(M)])
  total += C
  if total > 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):
    num = c
    lis = list(map(int,input().split()))
    for j in range(m):
        num += b[j] * lis[i]
    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):
    num = c
    lis = list(map(int,input().split()))
    for j in range(m):
        num += b[j] * lis[j]
    if num > 0:ans += 1
print(ans)
Buggy code:
N,M,C = map(int,input().split())
B = list(map(int,input().split()))
AC = 0
x = C
for i in range(N):
    A = list(map(int,input().split()))
    for j in range(M):
        x += A[j]*B[j]
    if x > 0:
        AC += 1
print(AC)


Fixed code:
N,M,C = map(int,input().split())
B = list(map(int,input().split()))
AC = 0
for i in range(N):
    A = list(map(int,input().split()))
    x = C
    for j in range(M):
        x += A[j]*B[j]
    if x > 0:
        AC += 1
print(AC)
Buggy 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())
	
def main():
	cnt = 0
	for i in range(N):
		val = C
		for j in range(M):
			val += A[i][j] * B[j]
		if val > 0:
			cnt += 1
	return cnt
print(main)


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

def main():
    cnt = 0
    for i in range(N):
        val = C
        for j in range(M):
            val += A[i][j] * B[j]
        if val > 0:
            cnt += 1
    return cnt

print(main())
Buggy 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())))
S = []
count = 0
for i in range(N):
    for j in range(M):
        S.append(A[j]*B[j])
    if sum(S) > -1 * C:
        count += 1
    S = []
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] +sum
    sum=C+sum
    
    if sum>0:
        count=count+1

print(count)
Buggy code:
N, M, C = input().split(' ')
N = int(N)
M = int(M)
C = int(C)
B = []
B = input().split(' ')
B = [int(i) for i in B]
A = []
R = 0
for i in range(N):
  A = input().split(' ')
  A = [int(i) for i in A]
  combine = [x * y for (x, y) in zip(A, B)]
  print(sum(combine) + C)
  if sum(combine) + C > 0:
    R += 1
print(R)

Fixed code:
N, M, C = input().split(' ')
N = int(N)
M = int(M)
C = int(C)
B = []
B = input().split(' ')
B = [int(i) for i in B]
A = []
R = 0
for i in range(N):
  A = input().split(' ')
  A = [int(i) for i in A]
  combine = [x * y for (x, y) in zip(A, B)]
  if sum(combine) + C > 0:
    R += 1
print(R)
Buggy code:
N, M, C = map(int, input().split())
B = list(map(int, input().split()))

correct_answer = 0

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

print(correct_answer)

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

correct_answer = 0

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

print(correct_answer)
Buggy code:
N,M,C=map(int,input().split())
A=[list(map(int,input().split())) for _ in range(N)]
print(len([i for i in range(N) if sum([A[i][j] for j in range(M)]) + C > 0]))

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

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

count = 0
for i in range(N):
    tmp = 0
    for j in range(M):
        tmp += b[j] * a[i][j]
    if tmp + C > 0:
        count += 1

print(count)

Fixed code:
N, M, C = map(int, input().split())
b = [int(i) for i in input().split()]
a = []
for i in range(N):
    a.append([int(i) for i in input().split()])

count = 0
for i in range(N):
    tmp = 0
    for j in range(M):
        tmp += b[j] * a[i][j]
    if tmp + C > 0:
        count += 1

print(count)
Buggy code:
n, m, c = map(int, input().split())
b_lists = list(map(int, input().split()))
a_lists = []
for _ in range(n):
    tmp = list(map(int, input().split()))
    a_lists.append(tmp)

cond = c
ans = 0
for i in a_lists:
    for j in range(m):
        cond = c
        cond += i[j]*b_lists[j]
    if cond > 0:
        ans += 1

print(ans)

Fixed code:
n, m, c = map(int, input().split())
b_lists = list(map(int, input().split()))
a_lists = []
for _ in range(n):
    tmp = list(map(int, input().split()))
    a_lists.append(tmp)

ans = 0
for i in a_lists:
    cond = c
    for j in range(m):
        cond += i[j]*b_lists[j]
    if cond > 0:
        ans += 1

print(ans)
Buggy code:
n,m,c = map(int,input().split())
B = list(map(int,input().split()))
L = [list(map(int,input().split())) for i in range(n)]

ans = 0
for i in range(n):
      acm = 0
      for j in range(m):
            acm += L[i][j] * B[j]
      if acm - 10 > 0:
            ans += 1      

print(ans)


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

ans = 0
for i in range(n):
      acm = 0
      for j in range(m):
            acm += L[i][j] * B[j]
      if acm + 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())))
ans=0

for i in range(N):
  A=np.array(list(map(int,input().split())))
  if sum(A-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())))
ans=0

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

print(count)

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

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


Fixed code:
n, m , c = map(int, input().split())
b_li = list(map(int, input().split()))
ans = 0
for i in range(n):
    a_li = list(map(int, input().split()))
    if sum(a * b for a, b in zip(a_li, b_li)) + c > 0:
        ans += 1
print(ans)
Buggy code:
from sys import stdin

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

print(ans)

Fixed code:
from sys import stdin

N, M, C = map(int, stdin.readline().split())
B = list(map(int, stdin.readline().split()))
ans = 0
for i in range(N):
  A = list(map(int, stdin.readline().split()))
  temp = 0
  for j in range(M):
    temp += (A[j] * B[j])
  if temp + 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 _ in range(n)]
count=0
for i in range(n-1):
    for j in range(m-1):
        total+=b[j]*a[i][j]
    if total>-c:
        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 _ in range(n)]
count=0
for i in range(n):
    total=0
    for j in range(m):
        total+=b[j]*a[i][j]
    if total>-c:
        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))
ab=list(range(N))
count=0

for i in range(N):
    for j in range(M):
        ab[i]+=a[i][j]*b[j]
    if ab[i]+C>0:
        count+=1
print(count)

Fixed code:
N,M,C=map(int,input().split())
b=list(map(int,input().split()))
a=list(range(N))
for i in range(N):
    a[i]=list(map(int,input().split()))
ab=list(range(N))
count=0

for i in range(N):
    ab[i]=0
    for j in range(M):
        ab[i]+=a[i][j]*b[j]
    if ab[i]+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 k in range(n)]

count=0

for i in range(n)
       absum=0
       for j in range(m)
       absum +=a[i][j]*b[j]
       
       ans=absum+c
       if ans>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 k in range(n)]
 
count=0
 
for i in range(n):
       s=0
       for j in range(m):
        s += a[i][j]*b[j]
       
       ans=s+c
       if ans>0:
        count +=1
print(count)
Buggy code:
n,m,c = map(int,input().split())
input_b = map(int,input().split())
a_list=[input() for i in range(n)]
for i in range(n):
  answer = c
  count = 0
  aitems = map(int,a_list[i].split())
  for j in range(m):
    answer += input_b[m] * aitems[m]
  if answer > 0
    count+=1
print count

Fixed code:
n,m,c = map(int,input().split())
input_b = list(map(int,input().split()))
a_list=[input() for i in range(n)]
count = 0
for i in range(n):
  answer = c
  aitems = list(map(int,a_list[i].split()))
  for j in range(m):
    answer += input_b[j] * aitems[j]
  if answer > 0:
    count+=1
print(count)
Buggy code:
N,M,H=list(map(int().input(),split()))
B=list(map(int,input().split()))
count=0
for i in range(N):
  A=list(map(int,input().split()))
  ans=0
  for k in range(M):
    ans+=A[k]*B[k]
  if ans+H>:
    count+=1
print(count)


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

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

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

Fixed code:
N,M,C=map(int, input().split())
B=list(map(int, input().split()))
A=[]
ans=0
a=0
for i in range(N):
    A.append([int(j) for j in input().split()])
for i in range(N):
    for j in range(M):
         a+=A[i][j]*B[j]
    if a+C>0:
        ans+=1
        a=0
    else:
        a=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)]

cnt = 0

for a in A:
    print(sum([ta * tb for ta, tb in zip(a, B)]) + C)
    
    if(sum([ta * tb for ta, tb in zip(a, B)]) + C > 0):
        cnt += 1

print(cnt)

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)]
 
cnt = 0
 
for a in A:
    
    if(sum([ta * tb for ta, tb in zip(a, B)]) + C > 0):
        cnt += 1
 
print(cnt)
Buggy code:
N,M,C=map(int, input().split())
B=list(map(int, input().split()))
A=[]
ans=0
a=0
for i in range(N):
    A.append([int(j) for j in input().split()])
for i in range(N):
    for j in range(M):
         a+=A[i][j]*B[j]
    if a+C>0:
        ans+=1
print(ans)

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

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

	if s + C > 0:
		ans += 1

print(ans)
Buggy code:
n,m,c = map(int,input().split())
a = input().split()
a = [int(x) for x in a]

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

Fixed code:
n,m,c = map(int,input().split())
a = input().split()
a = [int(x) for x in a]
     
d = 0
e = 0
for i in range(n):
    b = input().split()
    b = [int(x) for x in b]
    for j in range(m):
        d += b[j]*a[j]
        #print(d)
    if d + c >0:
        e += 1
    d = 0
print(e)
Buggy code:
def main():
    N, M, C = map(int, input().split())
    B = list(input().split(' '))
    for i in range(M):
        B[i] = int(B[i])
    all_A = []
    clear_count = 0
    cal = 0
    for i in range(N):
        A = list(input().split(' '))
        for j in range(M):
            A[j] = int(A[j])
        all_A.append(A)
    for A in all_A:
        for i in range(M):
            cal += A[i] * B[i]
        cal += C
        if cal > 0:
            clear_count += 1

    print(clear_count)


if __name__ == '__main__':
    main()

Fixed code:
def main():
    N, M, C = map(int, input().split())
    B = list(input().split(' '))
    for i in range(M):
        B[i] = int(B[i])

    all_A = []
    clear_count = 0
    cal = 0

    for i in range(N):
        A = list(input().split(' '))
        for j in range(M):
            A[j] = int(A[j])
        all_A.append(A)

    #print(all_A)

    for A in all_A:
        cal = 0
        for i in range(M):
            cal += A[i] * B[i]
        cal += C
        #print(cal)
        if cal > 0:
            clear_count += 1

    print(clear_count)


if __name__ == '__main__':
    main()
Buggy code:
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
s=0
ans=0
for i in range(n):
    a=list(map(int,input().split()))
    for k in range(m):
        s+=a[k]*b[k]
    if s+c>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):
    s=0
    a=[]
    a=list(map(int,input().split()))
    for k in range(m):
        s+=a[k]*b[k]
    if s+c>0:
        ans+=1
print(ans)