```go
package main

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

var (
	trie   []Node
	m_base int
	k      int
)

const MOD = 1000000007

type Node struct {
	next [20]int
	fail int
	val  int
}

func insert(s []int, v int) {
	u := 0
	for _, c := range s {
		if trie[u].next[c] == 0 {
			trie = append(trie, Node{})
			trie[u].next[c] = len(trie) - 1
		}
		u = trie[u].next[c]
	}
	trie[u].val += v
}

func buildAC() {
	queue := make([]int, 0, len(trie))
	for c := 0; c < m_base; c++ {
		if trie[0].next[c] != 0 {
			queue = append(queue, trie[0].next[c])
		}
	}
	for len(queue) > 0 {
		u := queue[0]
		queue = queue[1:]
		trie[u].val += trie[trie[u].fail].val
		for c := 0; c < m_base; c++ {
			if trie[u].next[c] != 0 {
				trie[trie[u].next[c]].fail = trie[trie[u].fail].next[c]
				queue = append(queue, trie[u].next[c])
			} else {
				trie[u].next[c] = trie[trie[u].fail].next[c]
			}
		}
	}
}

func subOne(X []int) []int {
	res := make([]int, len(X))
	copy(res, X)
	for i := len(res) - 1; i >= 0; i-- {
		if res[i] > 0 {
			res[i]--
			break
		} else {
			res[i] = m_base - 1
		}
	}
	if len(res) > 1 && res[0] == 0 {
		res = res[1:]
	}
	return res
}

func solve(X []int) int {
	if len(X) == 0 || (len(X) == 1 && X[0] == 0) {
		return 0
	}

	S := len(trie)
	dp := make([][]int, S)
	new_dp := make([][]int, S)
	for i := 0; i < S; i++ {
		dp[i] = make([]int, k+1)
		new_dp[i] = make([]int, k+1)
	}

	eqState := 0
	eqVal := 0

	for pos := 0; pos < len(X); pos++ {
		for i := 0; i < S; i++ {
			for j := 0; j <= k; j++ {
				new_dp[i][j] = 0
			}
		}

		for state := 0; state < S; state++ {
			for val := 0; val <= k; val++ {
				if dp[state][val] == 0 {
					continue
				}
				for d := 0; d < m_base; d++ {
					nstate := trie[state].next[d]
					nval := val + trie[nstate].val
					if nval <= k {
						new_dp[nstate][nval] = (new_dp[nstate][nval] + dp[state][val]) % MOD
					}
				}
			}
		}

		if pos > 0 {
			for d := 1; d < m_base; d++ {
				nstate := trie[0].next[d]
				nval := trie[nstate].val
				if nval <= k {
					new_dp[nstate][nval] = (new_dp[nstate][nval] + 1) % MOD
				}
			}
		}

		if eqState != -1 {
			start_d := 0
			if pos == 0 {
				start_d = 1
			}
			for d := start_d; d < X[pos]; d++ {
				nstate := trie[eqState].next[d]
				nval := eqVal + trie[nstate].val
				if nval <= k {
					new_dp[nstate][nval] = (new_dp[nstate][nval] + 1) % MOD
				}
			}

			eqState = trie[eqState].next[X[pos]]
			eqVal += trie[eqState].val
			if eqVal > k {
				eqState = -1
			}
		}

		dp, new_dp = new_dp, dp
	}

	ans := 0
	for state := 0; state < S; state++ {
		for val := 0; val <= k; val++ {
			ans = (ans + dp[state][val]) % MOD
		}
	}
	if eqState != -1 && eqVal <= k {
		ans = (ans + 1) % MOD
	}
	return ans
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	nextInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			if b < '0' || b > '9' {
				continue
			}
			res = res*10 + int(b-'0')
		}
		return res
	}

	n := nextInt()
	m_base = nextInt()
	k = nextInt()

	lenL := nextInt()
	L := make([]int, lenL)
	for i := 0; i < lenL; i++ {
		L[i] = nextInt()
	}

	lenR := nextInt()
	R := make([]int, lenR)
	for i := 0; i < lenR; i++ {
		R[i] = nextInt()
	}

	trie = make([]Node, 1)

	for i := 0; i < n; i++ {
		sLen := nextInt()
		s := make([]int, sLen)
		for j := 0; j < sLen; j++ {
			s[j] = nextInt()
		}
		v := nextInt()
		insert(s, v)
	}

	buildAC()

	ans := (solve(R) - solve(subOne(L)) + MOD) % MOD
	fmt.Println(ans)
}
```