package main

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


const L = 2520

func main() {
	
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n int
	fmt.Fscan(reader, &n)

	k := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &k[i])
	}

	m := make([]int, n)
	adj := make([][]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &m[i])
		adj[i] = make([]int, m[i])
		for j := 0; j < m[i]; j++ {
			fmt.Fscan(reader, &adj[i][j])
			adj[i][j]-- 
		}
	}

	
	totalStates := n * L
	nextState := make([]int, totalStates)

	
	for u := 0; u < n; u++ {
		
		effK := k[u] % L
		if effK < 0 {
			effK += L
		}
		modM := m[u]
		baseState := u * L

		for r := 0; r < L; r++ {
			
			val := r + effK
			if val >= L {
				val -= L
			}
			
			
			
			
			
			
			idx := val % modM
			v := adj[u][idx]
			
			
			nextState[baseState + r] = v*L + val
		}
	}

	ans := make([]int, totalStates)
	vis := make([]byte, totalStates) 
	onStack := make([]int, totalStates)
	for i := range onStack {
		onStack[i] = -1
	}

	
	path := make([]int, 0, 4096)
	seen := make([]bool, n)
	seenList := make([]int, 0, n)

	for i := 0; i < totalStates; i++ {
		if vis[i] != 0 {
			continue
		}

		curr := i
		path = path[:0]
		
		
		for vis[curr] == 0 {
			vis[curr] = 1
			onStack[curr] = len(path)
			path = append(path, curr)
			curr = nextState[curr]
		}

		var result int
		if vis[curr] == 1 {
			
			
			startIdx := onStack[curr]
			
			
			cnt := 0
			
			for j := startIdx; j < len(path); j++ {
				node := path[j]
				u := node / L
				if !seen[u] {
					seen[u] = true
					seenList = append(seenList, u)
					cnt++
				}
			}
			result = cnt
			
			
			for _, u := range seenList {
				seen[u] = false
			}
			seenList = seenList[:0]
		} else {
			
			result = ans[curr]
		}

		
		for _, node := range path {
			ans[node] = result
			vis[node] = 2
			onStack[node] = -1
		}
	}

	var q int
	fmt.Fscan(reader, &q)
	for i := 0; i < q; i++ {
		var x, y int
		fmt.Fscan(reader, &x, &y)
		u := x - 1
		r := y % L
		if r < 0 {
			r += L
		}
		
		fmt.Fprintln(writer, ans[u*L+r])
	}
}