Person in Charge

Problem Description

Functions are a crucial concept in various programming languages. With the help of functions, we can always decompose complex tasks into relatively simple subtasks, breaking them down into extremely simple basic operations until they are fully refined. This makes the code structure more rigorous and organized. However, an excessive number of function calls can also lead to additional overhead and affect the runtime efficiency of the program.

A database application provides several functions for maintaining data. It is known that the functions can be classified into three types based on their functionality:

1. Add a specific value to a designated element in the data;
2. Multiply every element in the data by the same value;
3. Execute several function calls in sequence, with no recursion allowed (i.e., the function will not call itself directly or indirectly).

When using this database application, the user can input a sequence of functions to be called at once (a function may be called multiple times). After executing the functions in the sequence in order, the data in the system is updated. One day, User A encountered difficulties while using this database program to process data: due to frequent and inefficient function calls, the system became unresponsive during execution, and he had to forcefully terminate the database program. To calculate the correct data, User A consulted the software documentation to learn the specific functional information of each function. Now he wants you to help him calculate the updated data based on this information.

Input Format

The first line contains a positive integer $n$, representing the number of data elements.
The second line contains $n$ integers, where the $i$-th integer denotes the initial value of the data element with index $i$ as $a_i$.
The third line contains a positive integer $m$, representing the number of functions provided by the database application. The functions are numbered from $1$ to $m$.
For the next $m$ lines, the first integer in the $j$-th line ($1 \le j \le m$) is $T_j$, indicating the type of the $j$-th function:

1. If $T_j = 1$, the next two integers $P_j$ and $V_j$ respectively represent the index of the element to which the addition is performed and the value to be added;
2. If $T_j = 2$, the next integer $V_j$ represents the value by which all elements are multiplied;
3. If $T_j = 3$, the next positive integer $C_j$ represents the number of functions to be called by the $j$-th function, followed by $C_j$ integers $g^{(j)}_1, g^{(j)}_2, \ldots, g^{(j)}_{C_j}$ which denote the numbers of the functions to be called in sequence.

The $(m + 4)$-th line contains a positive integer $Q$, representing the length of the input function operation sequence.
The $(m + 5)$-th line contains $Q$ integers $f_i$, where the $i$-th integer denotes the number of the function to be executed as the $i$-th step.

Output Format

Output a line of $n$ integers separated by spaces, in the order of indices $1$ to $n$, representing the value of each element in the database after executing the input function sequence. The answer should be taken modulo $\boldsymbol{998244353}$.

Samples

3
1 2 3
3
1 1 1
2 2
3 2 1 2
2
2 3

6 8 12

Sample 1 Explanation

Function 1 is used to add 1 to the value of $a_1$. Function 2 is used to multiply all elements by 2. Function 3 first calls Function 1, then calls Function 2.

The final function sequence first executes Function 2, changing the values of all elements to $2, 4, 6$.

When executing Function 3 next, it first calls Function 1, changing the values of all elements to $3, 4, 6$. Then it calls Function 2, changing the values of all elements to $6, 8, 12$.

Sample 2

See call/call2.in and call/call2.ans in the contestant's directory.

Sample 3

See call/call3.in and call/call3.ans in the contestant's directory.

Data Range

For all test cases: $0 \le a_i \le 10^4$, $T_j \in \{1,2,3\}$, $1 \le P_j \le n$, $0 \le V_j \le 10^4$, $1 \le g^{(j)}_k \le m$, $1 \le f_i \le m$.