利用倍增数组，记录：

  • B[i][j]: 从下标开始，向后走步会走到哪个下标
  • C[i][j]: 从下标开始，向后走步经过的所有数之和对取模的结果
'''
Hala Madrid!
https://github.com/USYDDonghaoLi/Programming_Competition
'''

import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def I():
    return input()
def II():
    return int(input())
def MI():
    return map(int, input().split())
def LI():
    return list(input().split())
def LII():
    return list(map(int, input().split()))
def GMI():
    return map(lambda x: int(x) - 1, input().split())

#------------------------------FastIO---------------------------------

from bisect import *
from heapq import *
from collections import *
from functools import *
from itertools import *
from time import *
from random import *
from math import log, gcd, sqrt, ceil

inf = float('inf')

fmin = lambda x, y: x if x < y else y
fmax = lambda x, y: x if x > y else y

mod = 10 ** 9 + 7

# @TIME
def solve(testcase):
    n, k, q = MI()
    A = LII()
    assert len(A) == n

    B = [[-1 for _ in range(n)] for _ in range(60)]
    
    for i in range(n):
        nxt = (i + k) % n
        B[0][i] = nxt
    
    for i in range(1, 60):
        for j in range(n):
            B[i][j] = B[i - 1][B[i - 1][j]]
    
    C = [[-1 for _ in range(n)] for _ in range(60)]
    for i in range(n):
        nxt = B[0][i]
        C[0][i] = A[nxt]
    
    for i in range(1, 60):
        for j in range(n):
            nxt = B[i - 1][j]
            C[i][j] = (C[i - 1][j] + C[i - 1][nxt]) % mod
    
    for i in range(q):
        t, step = MI()
        t -= 1
        res = 0

        for bit in range(60):
            if step >> bit & 1:
                # print("t", t)
                res = (res + C[bit][t]) % mod
                t = B[bit][t]
        
        print(res)

for testcase in range(1):
    solve(testcase)