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 threading

_M_ = 1000000007

n = int(raw_input())
par = map(int, raw_input().split())

tr = [[] for _ in xrange(n+1)]
ind = 2
for p in par:
	tr[p].append(ind)
	ind+=1


cnt = 0
node = [(0,0,0) for i in xrange(n+1)]
def createRange(root, ht):
	global cnt, node
	cnt += 1
	st = cnt
	for ch in tr[root]:
		createRange(ch, ht+1)
	en = cnt
	node[root] = (st,en,ht)
createRange(1,0)

#print node

bit = [(0,0) for i in xrange(cnt+1)]

def update(hkx,k,posi):
	global bit,n
	if posi <= 0: return
	while posi <= cnt:
		#print(posi)
		bit[posi] = (bit[posi][0]+hkx, bit[posi][1]+k)
		posi += (posi&-posi)
		#print(pos)

def get(pos,h):
	global bit, _M_
	ret = 0
	while(pos>0):
		ret += bit[pos][0] - h*bit[pos][1]
		pos -= (pos&-pos)
		#print(ret)
	return ret%_M_

def main():
	for _ in xrange(int(raw_input())):
		q = map(int, raw_input().split())
		st,en,ht = node[q[1]]
		#print(st,en)
		#print(node[q[1]])
		if (q[0]==1):
			update(q[2]+ht*q[3], q[3], st)
			#print(bit)
			if (en < cnt):
				update(-q[2]-ht*q[3], -q[3], en+1)
		else:
			print(get(st,ht))





if __name__ == "__main__":
    sys.setrecursionlimit(2000 * 1000)
    threading.stack_size(128 * 1024 * 1024)
    main_thread = threading.Thread(target=main)
    main_thread.start()
    main_thread.join()