import heapq

def dijkstra(G, s):
    D = [4 * 10 ** 18] * len(G)
    D[s] = 0
    q = [(0, s)]
    while q:
        d, u = heapq.heappop(q)
        if D[u] < d:
            continue
        for v, c in G[u]:
            new_d = D[u] + c
            if new_d < D[v]:
                D[v] = new_d
                heapq.heappush(q, (new_d, v))
    return D

def main():
    N = int(input())
    H = [list(map(int, input().split())) for _ in range(N)]
    S = [input().strip() for _ in range(N)]
    A = [list(map(int, input().split())) for _ in range(N - 1)]
    B = [list(map(int, input().split())) for _ in range(N)]

    G = [[[] for _ in range(N * N + 1)] for _ in range(2)]
    D = [[] for _ in range(2)]

    for k in range(2):
        for i in range(N - 1):
            for j in range(N):
                T = (H[i][j] + H[i + 1][j]) * (1 - (i + j + k) % 2 * 2)
                G[k][i * N + j].append(((i + 1) * N + j, abs(T) * A[i][j] + T))
                G[k][(i + 1) * N + j].append((i * N + j, abs(T) * A[i][j] - T))

        for i in range(N):
            for j in range(N - 1):
                T = (H[i][j] + H[i][j + 1]) * (1 - (i + j + k) % 2 * 2)
                G[k][i * N + j].append((i * N + j + 1, abs(T) * B[i][j] + T))
                G[k][i * N + j + 1].append((i * N + j, abs(T) * B[i][j] - T))

        for i in range(N):
            for j in range(N):
                if S[i][j] == '?':
                    continue
                if S[i][j] == '=' or ((S[i][j] == '-') ^ (i + j + k) % 2) == 0:
                    G[k][i * N + j].append((N * N, 0))
                if S[i][j] == '=' or ((S[i][j] == '-') ^ (i + j + k) % 2) == 1:
                    G[k][N * N].append((i * N + j, 0))

        D[k] = dijkstra(G[k], N * N)

    Q = int(input())
    for _ in range(Q):
        R, C, E = map(int, input().split())
        R -= 1
        C -= 1
        if D[(R + C) % 2][R * N + C] + H[R][C] >= E:
            print("Yes")
        else:
            print("No")

if __name__ == "__main__":
    main()