from bisect import bisect_left, bisect_right


def ceildiv(a: int, b: int) -> int:
    return (a + b - 1) // b


class Sorted:
    def __init__(self, xs: list):
        self.xs = sorted(xs)

    def __len__(self):
        return len(self.xs)

    def ilt(self, x):
        p = bisect_left(self.xs, x)
        if p == 0: return None
        return p - 1

    def ile(self, x):
        p = bisect_right(self.xs, x)
        if p == 0: return None
        return p - 1

    def igt(self, x):
        p = bisect_right(self.xs, x)
        if p == len(self.xs): return None
        return p

    def ige(self, x):
        p = bisect_left(self.xs, x)
        if p == len(self.xs): return None
        return p

    def lt(self, x, default=None):
        """Find the largest element < x, or default if it doesn't exist."""
        p = self._lt(x)
        if p is None: return default
        return self.xs[p]

    def le(self, x, default=None):
        """Find the largest element <= x, or default if it doesn't exist."""
        p = self._le(x)
        if p is None: return default
        return self.xs[p]

    def gt(self, x, default=None):
        """Find the smallest element > x, or default if it doesn't exist."""
        p = self._gt(x)
        if p is None: return default
        return self.xs[p]

    def ge(self, x, default=None):
        """Find the smallest element >= x, or default if it doesn't exist."""
        p = self._ge(x)
        if p is None: return default
        return self.xs[p]


N, M, K = map(int, input().split())
s = input().split()
op = s[0]
B = [int(x) for x in s[1:]]
A = []
for _ in range(N):
    A.append(int(input()))


def calc_add():
    res = 0
    bb = Sorted(B)
    for a in A:
        p = bb.ige(K - a)
        if p is None: continue
        res += len(bb) - p

    return res


def calc_mul():
    res = 0
    bb = Sorted(B)
    for a in A:
        p = bb.ige(ceildiv(K, a))
        if p is None: continue
        res += len(bb) - p

    return res


if op == '+':
    print(calc_add())
else:
    print(calc_mul())