You are given a rooted tree consisting of *n* vertices numbered from 1 to *n*. The root of the tree is a vertex number 1.

Initially all vertices contain number 0. Then come *q* queries, each query has one of the two types:
 -  The format of the query: 1 *v* *x* *k*. In response to the query, you need to add to the number at vertex *v* number *x*; to the numbers at the descendants of vertex *v* at distance 1, add *x* - *k*; and so on, to the numbers written in the descendants of vertex *v* at distance *i*, you need to add *x* - (*i*·*k*). The distance between two vertices is the number of edges in the shortest path between these vertices. -  The format of the query: 2 *v*. In reply to the query you should print the number written in vertex *v* modulo 1000000007 (10<sup class="upper-index">9</sup> + 7). 
Process the queries given in the input.
The first line contains integer *n* (1 ≤ *n* ≤ 3·10<sup class="upper-index">5</sup>) — the number of vertices in the tree. The second line contains *n* - 1 integers *p*<sub class="lower-index">2</sub>, *p*<sub class="lower-index">3</sub>, ... *p*<sub class="lower-index">*n*</sub> (1 ≤ *p*<sub class="lower-index">*i*</sub> &lt; *i*), where *p*<sub class="lower-index">*i*</sub> is the number of the vertex that is the parent of vertex *i* in the tree.

The third line contains integer *q* (1 ≤ *q* ≤ 3·10<sup class="upper-index">5</sup>) — the number of queries. Next *q* lines contain the queries, one per line. The first number in the line is *type*. It represents the type of the query. If *type* = 1, then next follow space-separated integers *v*, *x*, *k* (1 ≤ *v* ≤ *n*; 0 ≤ *x* &lt; 10<sup class="upper-index">9</sup> + 7; 0 ≤ *k* &lt; 10<sup class="upper-index">9</sup> + 7). If *type* = 2, then next follows integer *v* (1 ≤ *v* ≤ *n*) — the vertex where you need to find the value of the number.
import sys
import random

input = sys.stdin.readline
rd = random.randint(10 ** 9, 2 * 10 ** 9)


class FenwickTree:
    def __init__(self, n):
        self.n = n + 1
        self.bit = [[0] * (self.n) for _ in range(2)]

    def add_sub(self, p, i, x):
        while i < self.n:
            self.bit[p][i] += x
            i += i & -i

    # add x to [l, r)
    def add(self, l, r, x):
        self.add_sub(0, l, -x * (l - 1))
        self.add_sub(0, r, x * (r - 1))
        self.add_sub(1, l, x)
        self.add_sub(1, r, -x)

    # a[i] <- x
    def update(self, i, x):
        self.add(i, i + 1, x - self.get(i))

    def sum_sub(self, p, i):
        s = 0
        while i > 0:
            s += self.bit[p][i]
            i -= i & -i
        return s

    # a[1] + ... + a[i]
    def sum(self, i):
        return self.sum_sub(0, i) + self.sum_sub(1, i) * i

    # a[i]
    def get(self, i):
        return self.sum(i) - self.sum(i - 1)


n = int(input())
g = [[] for _ in range(n)]
p = list(map(int, input().split()))
for i in range(n - 1):
    g[p[i] - 1].append(i + 1)
sum_x = FenwickTree(n)
sum_k = FenwickTree(n)
q = int(input())
queries = [[] for _ in range(n)]
for i in range(q):
    a = list(map(int, input().split()))
    if a[0] == 1:
        queries[a[1] - 1].append([1, i, a[2], a[3]])
    else:
        queries[a[1] - 1].append([2, i])
Mod = 10 ** 9 + 7
from types import GeneratorType
def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc
ans = [-1] * q
@bootstrap
def dfs(son, d):
    for a in queries[son]:
        if a[0] == 1:
            sum_x.add(a[1] + 1, a[1] + 2, a[2] + d * a[3])
            sum_k.add(a[1] + 1, a[1] + 2, a[3])
        else:
            ans[a[1]] = (sum_x.sum(a[1] + 1) - sum_k.sum(a[1] + 1) * d) % Mod
    for i in g[son]:
        yield dfs(i, d + 1)
    for a in queries[son]:
        if a[0] == 1:
            sum_x.add(a[1] + 1, a[1] + 2, -d * a[3] - a[2])
            sum_k.add(a[1] + 1, a[1] + 2, -a[3])
    yield
dfs(0, 0)
for i in range(q):
    if ans[i] != -1:
        print(ans[i])
