import itertools as iter
import collections as coll
import heapq as hq
import bisect as bis
from decimal import Decimal as dec
from functools import cmp_to_key
import math
import sys
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10 ** 6)
inp = sys.stdin.readline
input = lambda : inp()[:-1]
getN = lambda : int(inp())
getNs = lambda : map(int, inp().split())
getList = lambda :list(map(int, inp().split()))
getStrs = lambda n : [input() for _ in [0] * n]
def yexit(): print("Yes"); exit(0)
def nexit(): print("No"); exit(0)
pi = 3.141592653589793
mod = 1000000007
MOD = 998244353
INF = 4611686018427387903
dx = [1, 0, -1, 0];  dy = [0, 1, 0, -1]
#di = coll.defaultdict(int)

class ModInt:
    mod = 998244353

    def __init__(self, x):
        self.x = x % ModInt.mod

    @classmethod
    def set_mod(cls, mod: int) -> None:
        ModInt.mod = mod
        
    def __str__(self):
        return str(self.x)

    __repr__ = __str__

    def __add__(self, other):
        return (ModInt(self.x + other.x) if isinstance(other, ModInt) else ModInt(self.x + other))

    def __sub__(self, other):
        return (ModInt(self.x - other.x) if isinstance(other, ModInt) else ModInt(self.x - other))

    def __mul__(self, other):
        return (ModInt(self.x * other.x) if isinstance(other, ModInt) else ModInt(self.x * other))

    def __truediv__(self, other):
        return (ModInt(self.x * self.inv_mod(other.x, self.mod)) if isinstance(other, ModInt)
          else ModInt(self.x * self.inv_mod(other, self.mod)))

    def __pow__(self, other):
        return ModInt(pow(self.x, other.x, ModInt.mod)) if isinstance(other, ModInt) else ModInt(pow(self.x, other, ModInt.mod))

    __radd__ = __add__

    def __rsub__(self, other):
        return (ModInt(other.x - self.x) if isinstance(other, ModInt) else ModInt(other - self.x))

    __rmul__ = __mul__

    def __rtruediv__(self, other):
        return (ModInt(other.x * self.inv_mod(self.x, self.mod)) if isinstance(other, ModInt)
          else ModInt(other * self.inv_mod(self.x, self.mod)))

    def __rpow__(self, other):
        return ModInt(pow(other.x, self.x, ModInt.mod)) if isinstance(other, ModInt) else ModInt(pow(other, self.x, ModInt.mod))

    def __iadd__(self, other):
        self = self + other
        return self

    def __isub__(self, other):
        self = self - other
        return self

    def __imul__(self, other):
        self = self * other
        return self

    def __itruediv__(self, other):
        self = self / other
        return self

    @classmethod
    def inv_gcd(cls, n, m):
        n %= m
        if(n == 0):
            return m, 0
        s, t, m0, m1 = m, n, 0, 1
        while(t):
            u = s // t
            s -= t * u
            m0 -= m1 * u
            m0, m1, s, t = m1, m0, t, s
        if(m0 < 0):
            m0 += m // s
        return s, m0

    @classmethod
    def inv_mod(cls, n, m):
        _, im = cls.inv_gcd(n, m)
        return im

    @classmethod
    def prod(cls, A):
        ret = ModInt(1)
        for k in A:
            ret *= k
        return ret

    @classmethod
    def nPk(cls, n, k):
        if(isinstance(n, ModInt)):
            n = n.x
        if(isinstance(k, ModInt)):
            k = k.x
        return cls.prod([*range(n - k + 1, n + 1)])
    
    @classmethod
    def nCk(cls, n, k):
        if(isinstance(n, ModInt)):
            n = n.x
        if(isinstance(k, ModInt)):
            k = k.x
        r = min(n - k, k)
        return cls.nPk(n, r) / cls.nPk(r, r)

class Matrix:
    def __init__(self, A: list):
        if not(A and isinstance(A[0], list)):
            A = [A]
        self.A = A
        self.row = len(A)
        self.col = len(A[0])
        self.I = None
        if(self.row == self.col):
            self.I = self.calc_I()

    def set_A(self, A: list) -> None:
        self.A = A

    def calc_I(self) -> list:
        ret = [[int(i == j) for j in range(self.col)] for i in range(self.row)]
        return ret

    def __str__(self):
        return str(self.A)

    __repr__ = __str__

    def __add__(self, other):
        ret = Matrix(self)
        for i in range(self.row):
            for j in range(self.col):
                ret.A[i][j] = self.A[i][j] + other.A[i][j]
        return ret

    def __sub__(self, other):
        ret = Matrix(self)
        for i in range(self.row):
            for j in range(self.col):
                ret.A[i][j] = self.A[i][j] - other.A[i][j]
        return ret

    def __mul__(self, other):
        assert(self.col == other.row)
        ret = Matrix([[0]*other.col for _ in [0]*self.row])
        for i in range(self.row):
            for j in range(other.col):
                ret.A[i][j] = sum(self.A[i][k] * other.A[k][j] for k in range(self.col))
        return ret

    def __pow__(self, other: int):
        mat = self
        ret = Matrix(self.I)
        n = other
        while(n):
            if(n & 1):
                ret = mat * ret
            mat = mat * mat
            n >>= 1
        return ret
 
 
"""
Main Code
"""

n, b, q = getNs()
ModInt.set_mod(b)
A_lis = [[[ModInt(x) for x in getNs()] for _ in [0] * 2] for _ in [0] * n]
query = [getList() for _ in [0] * q]

As = [Matrix(A) for A in A_lis]
A_prod = Matrix(As[0].calc_I())
Bs = [A_prod]
for A in As:
    A_prod = A * A_prod
    Bs.append(A_prod)

# print(Bs)

def inverse(A):
    return Matrix([[A.A[1][1], ModInt(0)-A.A[0][1]], [ModInt(0)-A.A[1][0], A.A[0][0]]])

for l, r, x, y in query:
    vec = Matrix([[ModInt(x)], [ModInt(y)]])
    ans = Bs[r] * inverse(Bs[max(0, l)]) * vec
    print(ans.A[0][0], ans.A[1][0])