```go
package main

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

const MOD int64 = 1000000007

type FastScanner struct {
	data []byte
	idx  int
}

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

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

func conv(a, b []int64, m int) []int64 {
	c := make([]int64, m)
	for i := 0; i < m; i++ {
		if a[i] == 0 {
			continue
		}
		ai := a[i]
		for j := 0; j < m; j++ {
			if b[j] == 0 {
				continue
			}
			idx := i + j
			if idx >= m {
				idx -= m
			}
			c[idx] = (c[idx] + ai*b[j]) % MOD
		}
	}
	return c
}

func powConv(base []int64, exp, m int) []int64 {
	res := make([]int64, m)
	res[0] = 1
	cur := make([]int64, m)
	copy(cur, base)
	for exp > 0 {
		if exp&1 == 1 {
			res = conv(res, cur, m)
		}
		exp >>= 1
		if exp > 0 {
			cur = conv(cur, cur, m)
		}
	}
	return res
}

func main() {
	fs := NewFastScanner()
	N := fs.NextInt()
	L := fs.NextInt()
	M := fs.NextInt()

	A := make([]int64, M)
	for i := 0; i < N; i++ {
		v := fs.NextInt() % M
		A[v]++
	}

	B := make([]int64, M)
	mid := make([]byte, N)
	for i := 0; i < N; i++ {
		v := fs.NextInt() % M
		mid[i] = byte(v)
		B[v]++
	}

	D := make([]int64, M)
	for i := 0; i < N; i++ {
		v := fs.NextInt() % M
		r := int(mid[i]) + v
		if r >= M {
			r -= M
		}
		D[r]++
	}

	p := powConv(B, L-2, M)
	ans := conv(conv(A, p, M), D, M)

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprintln(w, ans[0]%MOD)
	w.Flush()
}
```