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.
from collections import deque
I = lambda : map(int,input().split())
n = int(input())
mod = pow(10,9)+7
parent = [ 0 for i in range (300001)]  
ht = [ 0 for i in range (300001)]  
gr = [ [] for i in range (300001)]
visited = [ 0 for i in range (300001)]  
node = [ 0 for i in range (300001)]  
li = list(I())
for i in range (2,n+1) :
    gr[li[i-2]] += [i]
#print(gr)
qu = deque([1])
while qu :
    t = qu.popleft()
    for i in range (len(gr[t])) :
        if visited[gr[t][i]] == 0 :
            visited[gr[t][i]] = 1
            qu.append(gr[t][i])
            ht[gr[t][i]] = ht[t] + 1
#print(gr[1:4])
q = int(input())
for _ in range (q) :
    li = list(I())
    if li[0] == 1 :
        ver , add , sub = li[1] ,li[2] ,li[3]
        #print(ver,add,sub)
        for i in range (1,n+1) :
            visited[i] = 0 
        node[ver] += add
        #print(node[ver])
        qu = deque([ver])
        visited[ver] =1
        while qu :
            t= qu.popleft()
            for i in range (len(gr[t])) :
                if visited[gr[t][i]] == 0 :
                    visited[gr[t][i]] = 1
                    qu.append(gr[t][i])
                    node[gr[t][i]] += add -sub*(ht[gr[t][i]] - ht[t])
        #print(node[1:4])
    else :
        print(node [li[1] ])

   