python

import sys
from collections import deque

MOD = 998244353

def solve() -> None:
    input = sys.stdin.readline
    n = int(input())
    a = list(map(int, input().split()))
    m = int(input())
    # 1-based 函数
    typ = [0] * (m + 1)
    pos = [0] * (m + 1)   # 对类型1：加的位置
    val = [0] * (m + 1)   # 类型1加的值，类型2乘的值
    edges = [[] for _ in range(m + 1)]
    indeg = [0] * (m + 1)

    for j in range(1, m + 1):
        data = list(map(int, input().split()))
        typ[j] = data[0]
        if typ[j] == 1:
            pos[j] = data[1]
            val[j] = data[2]
        elif typ[j] == 2:
            val[j] = data[1]
        else:  # typ[j] == 3
            c = data[1]
            edges[j] = data[2:2 + c]
            for x in edges[j]:
                indeg[x] += 1

    _ = int(input())        # Q，不需要使用
    seq = list(map(int, input().split()))

    # 第一步：拓扑排序求入度
    topo = []
    q = deque()
    indeg_copy = indeg[:]   # 复制一份，因为后面要改
    for i in range(1, m + 1):
        if indeg_copy[i] == 0:
            q.append(i)
    while q:
        u = q.popleft()
        topo.append(u)
        for v in edges[u]:
            indeg_copy[v] -= 1
            if indeg_copy[v] == 0:
                q.append(v)

    # 第二步：计算每个函数的 mul[j]（调用一次函数 j 后全局乘法系数）
    mul = [1] * (m + 1)
    for u in reversed(topo):
        if typ[u] == 2:
            mul[u] = val[u] % MOD
        elif typ[u] == 3:
            prod = 1
            for v in reversed(edges[u]):
                prod = prod * mul[v] % MOD
            mul[u] = prod
        else:
            mul[u] = 1

    # 第三步：从主调用序列反向计算每个函数被调用的次数
    times = [0] * (m + 1)
    cur_mul = 1
    for func in reversed(seq):
        times[func] = (times[func] + cur_mul) % MOD
        cur_mul = cur_mul * mul[func] % MOD

    # 第四步：将调用次数按拓扑序正向传播（类型3）
    for u in topo:
        if typ[u] == 3:
            prod = 1
            for v in reversed(edges[u]):
                times[v] = (times[v] + times[u] * prod) % MOD
                prod = prod * mul[v] % MOD

    # 第五步：应用结果到数组
    total_mul = 1
    for func in seq:
        total_mul = total_mul * mul[func] % MOD
    for i in range(n):
        a[i] = a[i] * total_mul % MOD

    for j in range(1, m + 1):
        if typ[j] == 1 and times[j]:
            a[pos[j] - 1] = (a[pos[j] - 1] + times[j] * val[j]) % MOD

    print(' '.join(map(str, a)))

if __name__ == "__main__":
    solve()