package main

import (
	"fmt"
	"io"
	"os"
)

type Factor struct {
	p int64
	e int64
}

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt() int64 {
	n := len(fs.data)
	for fs.idx < n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') && fs.data[fs.idx] != '-' {
		fs.idx++
	}
	sign := int64(1)
	if fs.idx < n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var v int64
	for fs.idx < n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		v = v*10 + int64(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return sign * v
}

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	if a < 0 {
		return -a
	}
	return a
}

func modPow(a, e, mod int64) int64 {
	res := int64(1)
	a %= mod
	for e > 0 {
		if e&1 == 1 {
			res = res * a % mod
		}
		a = a * a % mod
		e >>= 1
	}
	return res
}

func factorize(x int64) []Factor {
	res := make([]Factor, 0)
	if x%2 == 0 {
		cnt := int64(0)
		for x%2 == 0 {
			x /= 2
			cnt++
		}
		res = append(res, Factor{2, cnt})
	}
	for d := int64(3); d*d <= x; d += 2 {
		if x%d == 0 {
			cnt := int64(0)
			for x%d == 0 {
				x /= d
				cnt++
			}
			res = append(res, Factor{d, cnt})
		}
	}
	if x > 1 {
		res = append(res, Factor{x, 1})
	}
	return res
}

func multiplicativeOrder(a, q, p int64, primes []int64) int64 {
	ord := q
	for _, r := range primes {
		for ord%r == 0 && modPow(a, ord/r, p) == 1 {
			ord /= r
		}
	}
	return ord
}

func phi(x int64, primes []int64) int64 {
	res := x
	for _, r := range primes {
		if x%r == 0 {
			res = res / r * (r - 1)
		}
	}
	return res
}

func main() {
	fs := NewFastScanner()
	n := int(fs.NextInt())
	m := int(fs.NextInt())
	p := fs.NextInt()

	a := make([]int64, n)
	for i := 0; i < n; i++ {
		a[i] = fs.NextInt()
	}

	var g int64
	for i := 0; i < m; i++ {
		x := fs.NextInt()
		if i == 0 {
			g = x
		} else {
			g = gcd(g, x)
		}
	}

	q := p - 1
	factors := factorize(q)
	primes := make([]int64, len(factors))
	for i, f := range factors {
		primes[i] = f.p
	}

	divisors := []int64{1}
	for _, f := range factors {
		cur := len(divisors)
		mul := int64(1)
		for e := int64(1); e <= f.e; e++ {
			mul *= f.p
			for i := 0; i < cur; i++ {
				divisors = append(divisors, divisors[i]*mul)
			}
		}
	}

	seen := make(map[int64]struct{})
	for _, x := range a {
		ord := multiplicativeOrder(x, q, p, primes)
		s := ord / gcd(ord, g)
		seen[s] = struct{}{}
	}

	orders := make([]int64, 0, len(seen))
	for s := range seen {
		orders = append(orders, s)
	}

	covered := make([]bool, len(divisors))
	for _, s := range orders {
		for i, d := range divisors {
			if s%d == 0 {
				covered[i] = true
			}
		}
	}

	ans := int64(0)
	for i, d := range divisors {
		if covered[i] {
			ans += phi(d, primes)
		}
	}

	fmt.Print(ans)
}