Levko loves all sorts of sets very much.

Levko has two arrays of integers a1, a2, ... , an and b1, b2, ... , bm and a prime number p. Today he generates n sets. Let's describe the generation process for the i-th set:

  1. First it has a single number 1. 
  2. Let's take any element c from this set. For all j (1 ≤ j ≤ m) if number (c·aibj) mod p doesn't occur in the set, then add it to the set. 
  3. Repeat step 2 as long as we can add at least one element to our set. 



Levko wonders, how many numbers belong to at least one set. That is, he wants to know what size is the union of n generated sets.

Input

The first line contains three integers n, m and p (1 ≤ n ≤ 104, 1 ≤ m ≤ 105, 2 ≤ p ≤ 109), p is prime. 

The second line contains space-separated integers a1, a2, ... , an (1 ≤ ai < p). The third line contains space-separated integers b1, b2, ... , bm (1 ≤ bi ≤ 109).

Output

The single number — the size of the union of the sets.

Examples

Input

1 1 7
2
5


Output

3


Input

1 2 7
2
2 4


Output

3


Input

2 1 7
1 6
2


Output

1


Input

2 1 7
1 6
5


Output

2
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, p;
int a[N], b[N];
int dr[N], dn, r[N], f[N];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int fpm(int a, int b, int p) {
  int w = 1;
  for (; b; b >>= 1, a = 1LL * a * a % p)
    if (b & 1) w = 1LL * w * a % p;
  return w;
}
int main() {
  scanf("%d %d %d", &n, &m, &p);
  for (int i = 1; i <= n; ++i) {
    scanf("%d", a + i);
  }
  int tb = p - 1;
  for (int i = 1; i <= m; ++i) {
    scanf("%d", b + i);
    tb = gcd(tb, b[i]);
  }
  for (int x = 1; 1LL * x * x <= p - 1; ++x)
    if ((p - 1) % x == 0) {
      dr[++dn] = x;
      if (x != (p - 1) / x) {
        dr[++dn] = (p - 1) / x;
      }
    }
  sort(dr + 1, dr + dn + 1);
  for (int i = 1; i <= n; ++i)
    for (int j = 1; j <= dn; ++j)
      if (fpm(a[i], dr[j], p) == 1) {
        r[i] = gcd(1LL * (p - 1) / dr[j] * tb % (p - 1), p - 1);
        break;
      }
  sort(r + 1, r + n + 1);
  int nn = unique(r + 1, r + n + 1) - r - 1;
  int tot = 0;
  for (int i = nn; i >= 1; --i) {
    f[i] = (p - 1) / r[i];
    for (int j = i + 1; j <= nn; ++j)
      if (r[j] % r[i] == 0) {
        f[i] -= f[j];
      }
    tot += f[i];
  }
  printf("%d\n", tot);
}
