Problem:
 Score : 200 points    Problem Statement There are N pieces of source code. The characteristics of the i -th code is represented by M integers A_{i1}, A_{i2}, ..., A_{iM} .  Additionally, you are given integers B_1, B_2, ..., B_M and C .  The i -th code correctly solves this problem if and only if A_{i1} B_1 + A_{i2} B_2 + ... + A_{iM} B_M + C > 0 .  Among the N codes, find the number of codes that correctly solve this problem.      Constraints  All values in input are integers.  1 \leq N, M \leq 20  -100 \leq A_{ij} \leq 100  -100 \leq B_i \leq 100  -100 \leq C \leq 100         Input Input is given from Standard Input in the following format:  N  M  C  B_1  B_2  ...  B_M  A_{11}  A_{12}  ...  A_{1M}  A_{21}  A_{22}  ...  A_{2M}  \vdots  A_{N1}  A_{N2}  ...  A_{NM}       Output Print the number of codes among the given N codes that correctly solve this problem.        Sample Input 1 2 3 -10
1 2 3
3 2 1
1 2 2      Sample Output 1 1  Only the second code correctly solves this problem, as follows:   Since 3 \times 1 + 2 \times 2 + 1 \times 3 + (-10) = 0 \leq 0 , the first code does not solve this problem.  1 \times 1 + 2 \times 2 + 2 \times 3 + (-10) = 1 > 0 , the second code solves this problem.        Sample Input 2 5 2 -4
-2 5
100 41
100 40
-3 0
-6 -2
18 -13      Sample Output 2 2       Sample Input 3 3 3 0
100 -100 0
0 100 100
100 100 100
-100 100 100      Sample Output 3 0  All of them are Wrong Answer . Except yours.

Solution (Python):

n, m, c = map(int, input().split(' '))
B = [int(el) for el in input().split(' ')]

A = [[int(el) for el in input().split(' ')] for i in range(n)]
count = 0
for i in range(n):
    total = c
    for a, b in zip(A[i],B):
        total += a*b
    if total > 0:
        count += 1
print(count)

Solution (Python):
I=lambda:map(int,input().split())
n,m,c=I();B=list(I());e=0
for t in range(n):
  d=0
  for a,b in zip(list(I()),B):d+=a*b
  e+=(d+c>0)
print(e)

Solution (Python):
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)

Solution (Python):
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
for i in range(n):
    total=0
    for j in range(m):
        total+=B[j]*A[i][j]
    total+=c
    if 0<total:
        cnt+=1
print(cnt)

Solution (Python):
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
for i in range(n):
    total=0
    for j in range(m):
        total+=B[j]*A[i][j]
    total+=c
    if 0<total:
        cnt+=1
print(cnt)

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

Solution (Python):
"""


 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())


 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  


a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 
"""

import math
import sys
import itertools
import queue
from fractions import gcd

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

mod = 1000000007

if __name__ == "__main__":
    N,M,C = map(int, sys.stdin.readline().split())
    b= list(map(int, sys.stdin.readline().split()))
    a= [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]

    ans=0
    for i in range(N):
        l=[]
        for j in range(M):
            n = a[i][j]*b[j]
            l.append(n)
        s = sum(l)
        if s + C >0:
            ans += 1
    print(ans)

Solution (Python):
def main44():
    data1 = input().split()
    nmc = []
    for i in range(3):
        nmc.append(int(data1[i]))
    data2 = input().split()
    b = []
    for i in range(nmc[1]):
        b.append(int(data2[i]))
    a = []
    for i in range(nmc[0]):
        data3 = input().split()
        kari = []
        for j in range(nmc[1]):
            kari.append(int(data3[j]))
        a.append(kari)
    result = 0
    for i in range(nmc[0]):
        karinum = nmc[2]
        for j in range(nmc[1]):
            karinum = karinum + b[j] * a[i][j]
        if karinum > 0:
            result = result + 1
    print(result)

if __name__ == "__main__":
    main44()

Solution (Python):
n,m,p=map(int,input().split())
y=list(map(int,input().split()))
x=list(list(map(int,input().split())) for _ in range(n))

import numpy as np

cnt=0

for i in range(n):
	if np.dot(np.array(y),np.array(x[i]).T)+p>0:
		cnt+=1

print(cnt)

Solution (Python):
n,m,p=map(int,input().split())
y=list(map(int,input().split()))
x=list(list(map(int,input().split())) for _ in range(n))

import numpy as np

cnt=0

for i in range(n):
	if np.dot(np.array(y),np.array(x[i]).T)+p>0:
		cnt+=1

print(cnt)

Solution (Python):


inp_1 = input().split()
n = int(inp_1[0])
m = int(inp_1[1])
c = int(inp_1[2])


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

a_mat = []

for i in range(n):
    a_mat.append([int(a) for a in input().split()])

count = 0

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


print(count)

Solution (Python):
list = [int(i) for i in input().split(" ")]
n = list[0]
m = list[1]
c = list[2]
b_list = [int(i) for i in input().split(" ")]
count = 0
for i in range(n):
    a_list = [int(i) for i in input().split(" ")]
    total = 0
    for a,b in zip(a_list,b_list):
        total += a*b
    total += c
    if total > 0:
        count += 1
print(count)

Solution (Python):

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

res=0
for _ in range(n):
    a=list(map(int,input().split()))
    d=sum(map(lambda a:a[0]*a[1], list(zip(a,b))))+c
    if d > 0:
        res += 1
print(res)

Solution (Python):
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
ans = 0
for i in range(n):
    for j in range(m):
        ans += a[i][j]*b[j]
    if ans + c > 0:
        count += 1
    ans = 0
print(count)

Solution (Python):
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):
    sumA = 0
    for j in range(m):
        sumA += A[i][j] * B[j]
    if sumA > -c :
        ans += 1

print(ans)

Solution (Python):
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()))
    if sum([a[j] * b[j] for j in range(m)]) + c > 0:
        ans += 1

print(ans)

Solution (Python):
N,M,C = (int(x) for x in input().split())
B_arr = [int(x) for x in input().split()]+[C]

ans = 0
for _ in range(N):
    A_arr = [int(x) for x in input().split()] + [1]
    t = 0
    for a,b in zip(A_arr, B_arr):
        t += a*b
    if t > 0:
        ans += 1
print(ans)

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
AA = [list(map(int, input().split())) for _ in range(N)]

print(sum(sum(a * b for a, b in zip(A, B)) + C > 0 for A in AA))

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
AA = [list(map(int, input().split())) for _ in range(N)]

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

Solution (Python):
import numpy as np
def q48(n, m, c, b, a):
    return (np.count_nonzero(np.dot(a, b) + c > 0))

N, M, C = [int(i) for i in 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()])

print(q48(N, M, C, B, A))

Solution (Python):
import numpy as np
def q48(n, m, c, b, a):
    correct = 0
    
    for s in a:
        if np.dot(s, b) + c > 0:
            correct += 1
    return correct
        

N, M, C = [int(i) for i in 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()])

print(q48(N, M, C, B, A))

Solution (Python):
def solve():
    N,M,C = [int(s) for s in input().split() if s]
    B = [int(s) for s in input().split() if s]
    A = [[int(s) for s in input().split() if s] for _ in range(N)]
    count = sum(sum(a*b for a,b in zip(A[i],B)) + C > 0 for i in range(N))
    print(count)
    
solve()

Solution (Python):
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

for i in range(n):
    if sum([A[i][j]*B[j] for j in range(m)]) > -c:
        cnt += 1
        
print(cnt)

Solution (Python):
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):
    tm = 0
    for j in range(m):
        tm = tm + a[i][j] * b[j]
    if (tm + c > 0):
        ans += 1
print(ans)

Solution (Python):
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)

Solution (Python):
N, M, C = map(int, input().split())
B = list(map(int, input().split()))
A = []
for i in range(N):
    AS = list(map(int, input().split()))
    A.append(AS)

ans = 0
for i in range(N):
    if sum([a * b for a, b in zip(A[i], B)]) + C > 0:
        ans += 1
print(ans)

Solution (Python):
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()))

    wa = 0
    for i in range(M):
        wa += A[i] * B[i]

    if wa + C > 0:
        ans += 1

print(ans)

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

Solution (Python):
import sys
input = sys.stdin.readline
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()))
    temp = 0
    for i in range(m):
        temp += a[i] * b[i]
    if temp + c > 0:
        ans += 1
print(ans)

Solution (Python):
n,m,c=map(int,input().split())
b=[int(x) for x in input().split()]
ans=0
for i in range(n):
  a=[int(x) for x in input().split()]
  combined1 = [x * y for (x, y) in zip(a, b)]
  if sum(combined1) + c >0:
    ans+=1
print(ans)

Solution (Python):
N, M, C = list(map(int, input().split()))
B = list(map(int, input().split()))

z = 0
for n in range(N):
    x = C
    A = list(map(int, input().split()))
    for a,b in zip(A,B):
        x += a*b

    if x>0 : z+=1

print(z)

Solution (Python):



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()))
    sum_ab = 0
    for j in range(m):
        sum_ab += a[j] * b[j]
    sum_ab += c
    if sum_ab > 0:
        ans += 1

print(ans)

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

print(ans)

Solution (Python):
N,M,C = list(map(int,input().split()))

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

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

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

print(count)

Solution (Python):
n, m, c = map(int, input().split())
bn = list(map(int, input().split()))
cnt = 0
for _ in range(n):
  an = list(map(int, input().split()))
  val = sum([a * b for (a, b) in zip(an, bn)]) + c
  if val > 0:
    cnt += 1
print(cnt)

Solution (Python):
import numpy as np
N,M,C=map(int,input().split())
B=np.array([int(x) for x in input().split()])
A=np.array([[int(x) for x in input().split()] for n in range(N)])
print(np.count_nonzero(np.dot(A,B)+C > 0))

Solution (Python):
n,m,c=map(int,input().split())
l_1=list(map(int,input().split()))
l_2=[list(map(int,input().split()))for n in range(n)]
c_1=0
for i in range(n):
    a=c
    for j in range(m):
        a+=l_1[j]*l_2[i][j]
    if a>0:
        c_1+=1
print(c_1)

Solution (Python):
n, m, c = map(int, input().split())
b = list(map(int, input().split()))

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

print(ans)

Solution (Python):
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()))
    if sum([j * k for  j, k in zip(a, b)]) + c > 0:
        ans += 1

print(ans)

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

Solution (Python):
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()))
    s = 0
    for ai, bi in zip(a, b):
        s += ai * bi
    s += c
    if s > 0:
        ans += 1

print(ans)

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

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

for i in range(N):
    tmp = list(map(int,input().split()))
    sum = 0

    for j in range(M):
        sum += B[j]*tmp[j]
    
    if sum + C > 0:
        count += 1

print(count)

Solution (Python):
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, input().split())) for i in range(n)])
cnt = 0
for i in range(n):
  if sum(a[i]*b)+c>0:
    cnt+=1
print(cnt)

Solution (Python):
def main():

    """ convenient functions
    
    
    
    
    
    """

    """convenient decorator
    
    
        
        
        
        
        
        
        
        
        
        
    """
    
    
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product 
    
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  
        b, e = 2, 0  
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict 
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest 
    from copy import deepcopy, copy 
    import operator
    from operator import itemgetter
    
    
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd 
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    
    
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) 
    def modinv(a, p = MOD):
        
        
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        
        
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    
        
        
    
        
        
        
        
        
    
        
        
        
        
    
        
        
    """

    
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    
    
    
    
    
    
    
    """

    if __name__ != '__main__':
        
        sys.stdin = open('sample.txt')

    
    

    N, _, C = R()
    B = R()
    A = [R() for _ in range(N)]
    count = 0
    for a in A:
        Sum = 0
        for i, j in zip(a, B):
            Sum += i * j
        if Sum + C > 0:
            count += 1
    
    print(count)
        
    
    
    

    """memo: how to use defaultdict of list
    
    Dic = defaultdict(list)
    
    Dic[x].append(y)
    
    for k, v in Dic.items():
    """

if __name__ == '__main__':
    main()

Solution (Python):
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 = len([x for x in a if sum([x[i] * b[i] for i in range(m)]) + c > 0])
print(ans)

Solution (Python):
import sys
import math
from collections import deque

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(N, M, C, inputs1, inputs2):
    B = string_to_int(inputs1)
    A = list(map(lambda i: string_to_int(i), inputs2))

    num = 0
    for a in A:
        score = 0
        for i in range(0, M):
            score += a[i] * B[i]
        score += C

        if score > 0:
            num += 1

    return num


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    [N, M, C] = string_to_int(input())
    ret = solve(N, M, C, input(), inputs(N))
    print(ret)

Solution (Python):
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 = int(0)
a = int(0)
for i in range(N):
    a = int(0)
    for j in range(M):
            a += A[i][j]*B[j]
            if a > -C and j == M-1:
                    ans += 1
print(ans)

Solution (Python):
N, M, C = map(int, input().split())  
BB = list(map(int, input().split()))

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

print(ans)

Solution (Python):

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


ans=0

for i in range(N):
  
  la=list(map(int,input().split()))

  sm=0
  for j in range(M):
    sm+=la[j]*lb[j]

  
  if sm+C>0:
    ans+=1


print(ans)

Solution (Python):
def main():
    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 a in A:
        result = sum([x * y for x, y in zip(a, B)]) + C
        if result > 0:
            count += 1

    print(count)

if __name__ == '__main__':
    main()

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

Solution (Python):
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[j] * B[j]
  if sum_A + C > 0:
    ans += 1
print(ans)

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

Solution (Python):
import numpy as np

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()))
    temp =0
    for j in range(m):
        temp+=a[j]*b[j]
    if temp+c > 0:
        ans += 1
print(ans)

Solution (Python):
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 np.dot(a, b) + c > 0:
        ans += 1
    
print(ans)

Solution (Python):
n,m,c=map(int,input().split())
b=list(map(int,input().split()))
info=[]
for i in range(n):
    info.append(list(map(int,input().split())))

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

Solution (Python):
n,m,c=map(int,input().split())
b=[int(x) for x in input().split()]
ans=0
for i in range(n):
  a=[int(x) for x in input().split()]
  combined1 = [x * y for (x, y) in zip(a, b)]
  if sum(combined1) + c >0:
    ans+=1
print(ans)

Solution (Python):
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 ai in a:
  s = sum([bi*aii for bi, aii in zip(b,ai)]) + c  
  if s > 0:
    count += 1

print(count)

Solution (Python):
a, b, c = map(int, input().split())
d = list(map(int, input().split()))
g = 0
for i in range(a):
    e = list(map(int, input().split()))
    f = 0
    for j in range(b):
        f += d[j] * e[j]
    if f + c > 0:
        g += 1
print(g)

Solution (Python):
n, m, c = map(int, input().split())
list_b = [int(x) for x in input().split()]
list_a = [[int(y) for y in input().split()] for z in range(n)]

cnt = 0

for i in range(n):
    sum = c
    for j in range(m):
        sum += list_a[i][j] * list_b[j]
    if sum > 0:
        cnt += 1

print(cnt)

Solution (Python):
n,m,c=map(int, input().split())
b = list(map(int, input().split()))
src_a = [0]*n
for i in range(n):
    src_a[i] = list(map(int, input().split()))

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

Solution (Python):
N, M, C = map(int,input().split())
B = list(map(int,input().split()))

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

print(ans)

Solution (Python):
N, M, C = map(int, input().split())
Bs = list(map(int, input().split()))
As = [list(map(int, input().split())) for _ in range(N)]
cr = 0
code_result = 0
for a in As:
  for i in range(M):
    code_result += a[i] * Bs[i]
  if code_result + C > 0:
    cr += 1
  code_result = 0
print(cr)

Solution (Python):
import numpy as np
N,M,C = map(int,input().split())
B = np.array(input().split(),dtype=np.int)
A = np.array([input().split() for _ in range(N)],dtype=np.int)
answer = (((A*B).sum(axis=1)+C)>0).sum()
print(answer)

Solution (Python):
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = 0

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

Solution (Python):
n,m,c = map(int, input().split())
b = [int(x) for x in input().split()]
codes = []
for _ in range(n):
    codes.append(list(int(x) for x in input().split()))

ans = 0
for i in range(n):
    cnt = c
    for j in range(m):
        cnt += b[j] * codes[i][j]

    if cnt > 0:
        ans += 1
    else:
        continue

print(ans)

Solution (Python):
def main():
    n, m, c = map(int, input().split())
    *b, = map(int, input().split())
    a = [[int(x) for x in 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:
            ans += 1
    print(ans)


main()

Solution (Python):
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()))
    sum=c
    for j in range(m):sum+=a[j]*b[j]
    if sum>0:ans+=1
print(ans)

Solution (Python):
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):
  tmp = 0
  for j in range(M):
    tmp += A[i][j] * B[j]
  if tmp + C > 0:
    ans += 1
print(ans)

Solution (Python):
N, M, C = map(int, input().split())
b = list(map(int, input().split()))
cnt = 0
for _ in range(N):
    a = list(map(int, input().rstrip().split()))
    if sum([ai*bi for ai,bi in zip(a,b)])+C > 0:
        cnt += 1
        
print(cnt)

Solution (Python):


import numpy as np

N, M, C = map(int, input().split())
B = np.ndarray([M, 1])
B = list(map(int, input().split()))
A = np.ndarray([N, M])
for i in range(N):
    A[i, :] = list(map(int, input().split()))

ans = sum((np.dot(A,B) + C) > 0)

print(ans)

Solution (Python):
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 = 0
    for j in range(M):
         s += A[i][j]*B[j]
    s += C
    if s > 0:
        ans += 1
print(ans)

Solution (Python):
import numpy as np

n, m, c = map(int, input().split())
arr = list(map(int, input().split()))
mtr = []
for i in range(n):
    a = list(map(int, input().split()))
    mtr.append(a)

count = 0
for i in range(n):
    if np.dot(mtr[i], arr)+c > 0:
        count += 1
print(count)

Solution (Python):
n, m, c = map(int,input().split())

b = list(map(int,input().split()))
ls = [list(map(int,input().split())) for i in range(n)]

ans = 0
for i in range(n):
  tmp = []
  for j in range(m):
    tmp.append(ls[i][j] * b[j])
  tmp.append(c)
  if sum(tmp) > 0:
    ans += 1
print(ans)

Solution (Python):
n, m , c = map(int, input().split())

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

a = [list(map(int, input().split())) for i in range(n)]

out = 0

for i in range(len(a)):
    x = 0
    for j in range(m):
        x += a[i][j] * b[j]
    if x + c > 0:
        out += 1

print(out)

Solution (Python):
n, m, c = map(int, input().split())
l = [list(map(int, input().split())) for i in range(n+1)]
count = 0
for i in range(1, n+1):
    s = 0
    for j in range(m):
        s += l[i][j] * l[0][j]
    if s + c > 0:
        count += 1
print(count)

Solution (Python):
n, m, c = map(int, 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 x in [sum([a_ij * b_j for a_ij, b_j in zip(a[i], b)]) for i in range(n)]:
  if x + c > 0:
    count += 1
print(count)

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

Solution (Python):
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 += C
  if sum > 0:
    count += 1
print(count)

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

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