#ifndef LOCAL
#include <bits/stdc++.h>

using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using ld = long double;
using i128 = __int128_t;
using u128 = __uint128_t;

namespace fastio {
static constexpr int BUF_SIZE = 1 << 20;

struct Pre {
    char num[10000][4];
    constexpr Pre() : num() {
        for (int i = 0; i < 10000; i++) {
            int n = i;
            for (int j = 3; j >= 0; j--) {
                num[i][j] = n % 10 | '0';
                n /= 10;
            }
        }
    }
} constexpr pre;

static struct FastOutput {
   private:
    static constexpr int TMP_SIZE = 1 << 10;
    char tmp[TMP_SIZE];
    char buf[BUF_SIZE];
    size_t buf_pos = 0;

    template <class T>
    inline char* wt_integer(T x) {
        char* p = tmp + TMP_SIZE - 1;
        if (x == 0) {
            *--p = '0';
        } else {
            bool is_negative = false;
            if (x < 0) {
                is_negative = true;
                x = -x;
            }
            while (x >= 10000) {
                memcpy(p -= 4, pre.num[x % 10000], 4);
                x /= 10000;
            }
            if (x >= 1000) {
                memcpy(p -= 4, pre.num[x], 4);
            } else if (x >= 100) {
                memcpy(p -= 3, pre.num[x] + 1, 3);
            } else if (x >= 10) {
                memcpy(p -= 2, pre.num[x] + 2, 2);
            } else {
                *--p = pre.num[x][3];
            }
            if (is_negative) *--p = '-';
        }
        return p;
    }

    template <class T, size_t N = 0>
    inline void wt_tuple(const T& t) {
        if constexpr (N < std::tuple_size<T>::value) {
            if constexpr (N > 0) wt(' ');
            const auto x = std::get<N>(t);
            wt(x);
            wt_tuple<T, N + 1>(t);
        }
    }

   public:
    inline void wt(char c) {
        buf[buf_pos++] = c;
        if (buf_pos == BUF_SIZE) flush();
    }

    inline void wt(const char* s) {
        for (; *s != '\0'; s++) {
            wt(*s);
        }
    }

    inline void wt(const std::string& s) {
        for (char c : s) wt(c);
    }

    template <class Tp>
    inline std::enable_if_t<std::is_floating_point_v<Tp>>
    wt(const Tp& x) {
        std::ostringstream oss;
        oss << std::fixed << std::setprecision(16) << x;
        wt(oss.str());
    }

    template <class Tp>
    inline std::enable_if_t<std::is_integral_v<Tp>>
    wt(const Tp& x) { wt(wt_integer(x)); }

    inline void wt(const __int128_t& x) { wt(wt_integer(x)); }
    inline void wt(const __uint128_t& x) { wt(wt_integer(x)); }

    template <class T, class U>
    inline void wt(const std::pair<T, U>& p) {
        wt(p.first);
        wt(' ');
        wt(p.second);
    }

    template <class... Args>
    inline void wt(const std::tuple<Args...>& t) {
        wt_tuple(t);
    }

    template <class T, size_t N = 0>
    inline void wt(const std::array<T, N>& a) {
        for (size_t i = 0; i < N; i++) {
            if (i) wt(' ');
            wt(a[i]);
        }
    }
    template <class T>
    inline void wt(const std::vector<T>& x) {
        for (size_t i = 0; i < x.size(); i++) {
            if (i) wt(' ');
            wt(x[i]);
        }
    }

    inline void flush() {
        fwrite(buf, 1, buf_pos, stdout);
        buf_pos = 0;
    }
    ~FastOutput() { flush(); }
} fastout;

static struct FastInput {
   private:
    char buf[BUF_SIZE];
    size_t buf_pos = 0;
    size_t size = 0;
    char cur = 0;
    inline char rd_char() {
        if (buf_pos >= size) {
            size = fread(buf, 1, BUF_SIZE, stdin);
            buf_pos = 0;
            buf[0] = (size == 0 ? -1 : buf[0]);
        }
        return cur = buf[buf_pos++];
    }

    template <class Tp>
    inline void rd_integer(Tp& x) {
        x = Tp{};
        if (skip_blanks()) {
            int sign = +1;
            if (cur == '-') {
                sign = -1;
                rd_char();
            }
            do {
                x += x + (x << 3) + (cur & 15);
            } while (!is_blank(rd_char()));
            x *= sign;
        }
    }

    inline bool is_blank(char c) { return c <= ' '; }

    inline bool skip_blanks() {
        while (is_blank(cur) && cur != -1) {
            rd_char();
        }
        return cur != -1;
    }

    template <class T, size_t N = 0>
    void rd_tuple(T& t) {
        if constexpr (N < std::tuple_size<T>::value) {
            auto& x = std::get<N>(t);
            rd(x);
            rd_tuple<T, N + 1>(t);
        }
    }

   public:
    inline void rd(char& c) {
        skip_blanks();
        c = cur;
        rd_char();
    }

    inline void rd(std::string& s) {
        if (skip_blanks()) {
            s.clear();
            do {
                s += cur;
            } while (!is_blank(rd_char()));
        }
    }

    template <class T>
    inline auto rd(T& x) -> std::void_t<std::enable_if_t<std::is_integral<T>::value>> { rd_integer(x); }
    inline auto rd(__int128_t& x) { rd_integer(x); }
    inline auto rd(__uint128_t& x) { rd_integer(x); }

    inline void rd(double& x) {
        std::string s;
        rd(s);
        x = std::stod(s);
    }

    inline void rd(long double& x) {
        std::string s;
        rd(s);
        x = std::stold(s);
    }

    template <class T, class U>
    void rd(std::pair<T, U>& p) {
        rd(p.first);
        rd(p.second);
    }

    template <class... Args>
    void rd(std::tuple<Args...>& t) {
        rd_tuple(t);
    }

    template <class T, size_t N>
    void rd(std::array<T, N>& x) {
        for (auto& d : x) rd(d);
    }

    template <class T>
    void rd(std::vector<T>& x) {
        for (auto& d : x) rd(d);
    }
} fastin;

inline void flush() { fastout.flush(); }
void IN() {}
template <class Head, class... Tails>
void IN(Head& head, Tails&... tails) {
    fastin.rd(head);
    IN(tails...);
}
template <class Last>
void print(const Last& last) { fastout.wt(last); }
template <class Head, class... Tails>
void print(const Head& head, const Tails&... tails) {
    fastout.wt(head);
    fastout.wt(' ');
    print(tails...);
}
template <class... Args>
void println(const Args&... args) {
    print(args...);
    fastout.wt('\n');
}
}  // namespace fastio
using fastio::flush;
using fastio::IN;
using fastio::print;
using fastio::println;

#define INT(...)     \
    int __VA_ARGS__; \
    IN(__VA_ARGS__)
#define LL(...)            \
    long long __VA_ARGS__; \
    IN(__VA_ARGS__)
#define STR(...)        \
    string __VA_ARGS__; \
    IN(__VA_ARGS__)
#define CHAR(...)     \
    char __VA_ARGS__; \
    IN(__VA_ARGS__)
#define DBL(...)        \
    double __VA_ARGS__; \
    IN(__VA_ARGS__)

#define VEC(type, name, size) \
    vector<type> name(size);  \
    IN(name)

#define VV(type, name, h, w)                       \
    vector<vector<type>> name(h, vector<type>(w)); \
    IN(name)

#define debug(...) (void(0))
#else
#include "algo/debug.h"
#endif

void solve() {
    using namespace std;
    INT(N, M, K);
    CHAR(o);
    VEC(ll, B, M);
    VEC(ll, A, N);
    if(o == '+') {
        for(int i = 0; i < N; i++) A[i] %= K;
        map<int, int> mp;
        for(int i = 0; i < M; i++) {
            B[i] %= K;
            mp[B[i]]++;
        }
        ll ans = 0;
        for(int i = 0; i < N; i++) {
            int t = K - A[i];
            ans += mp[t == K ? 0 : t];
        }
        println(ans);
    } else {
        map<ll, ll> a, b;
        for(int i = 0; i < N; i++) a[gcd(A[i], K)]++;
        for(int i = 0; i < M; i++) b[gcd(B[i], K)]++;
        ll ans = 0;
        for(const auto&[fa, ca] : a) {
            for(const auto&[fb, cb]: b) {
                if(fa * fb % K == 0) ans += ca * cb;
            }
        }
        println(ans);
    }
}

int main() {
    int T = 1;
    // std::cin >> T;
    while (T--) {
        solve();
    }
}