import sys
from collections import defaultdict, deque

def main():
    sys.setrecursionlimit(1 << 25)
    input = sys.stdin.read().split()
    ptr = 0

    N = int(input[ptr])
    ptr += 1

    edges = [[] for _ in range(N)]
    for _ in range(N-1):
        u = int(input[ptr])
        v = int(input[ptr+1])
        ptr += 2
        edges[u].append(v)
        edges[v].append(u)

    A = list(map(int, input[ptr:ptr+N]))
    ptr += N

    Q = int(input[ptr])
    ptr += 1

    queries = []
    for _ in range(Q):
        a_prime = int(input[ptr])
        b_prime = int(input[ptr+1])
        k_prime = int(input[ptr+2])
        delta = int(input[ptr+3])
        ptr +=4
        queries.append( (a_prime, b_prime, k_prime, delta) )

    # Precompute distance from each node to all others
    dist = [ [0]*N for _ in range(N) ]
    for i in range(N):
        q = deque()
        q.append(i)
        visited = [False]*N
        visited[i] = True
        while q:
            u = q.popleft()
            for v in edges[u]:
                if not visited[v]:
                    dist[i][v] = dist[i][u] + 1
                    visited[v] = True
                    q.append(v)

    X = []
    sum_X = 0
    for q_idx in range(Q):
        a_prime, b_prime, k_prime, delta = queries[q_idx]

        if q_idx ==0:
            a = a_prime
            b = b_prime
            k = k_prime
        else:
            a = (a_prime + sum_X) % N
            b = (b_prime + 2 * sum_X) % N
            k = (k_prime + (sum_X **2)) % 150001

        l = min(a, b)
        r = max(a, b) + 1

        min_f = float('inf')
        best_v = -1
        for v in range(N):
            total = 0
            for w in range(l, r):
                total += (A[w] + k) * dist[v][w]
            if total < min_f:
                min_f = total
                best_v = v

        X.append(best_v)
        sum_X += best_v

    for x in X:
        print(x)

if __name__ == '__main__':
    main()