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.
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<fstream>
#include<map>
#include<ctime>
#include<set>
#include<queue>
#include<cmath>
#include<vector>
#include<bitset>
#include<functional>
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define REP(i,l,r) for((i)=(l);(i)<=(r);++(i))
#define REP2(i,l,r) for((i)=(l);(i)!=(r);++(i))
using namespace std;

typedef long long LL;
typedef double ld;

const int Mod = 1000000007;
const int MAX = 300000 + 10;

int n,fa[MAX];
int l[MAX],r[MAX],dep[MAX],sum[MAX],sum2[MAX];
vector<int> ne[MAX];

void add( int a, int b, int c)
{
    for(; a < MAX ; a += a & ( -a ) )
    {
        sum[a] = ( sum[a] + b ) % Mod;
        sum2[a] = ( sum2[a] + c ) % Mod;
    }
    return;
}

int ask( int u )
{
    int a = l[u];
    int ans = 0, ans2 = 0;
    for( ; a ; a -= a& ( -a ) )
    {
        ans = ( ans + sum[a] ) % Mod;
        ans2 = ( ans2 + sum2[a] ) % Mod;
    }
    return ( ans - (LL)ans2 * dep[u] % Mod + Mod ) % Mod;
}

int dfs(int u, int tot)
{
    tot += 1;
    l[u] = tot;
    int i;
    REP2(i,0,(int)ne[u].size())
    {
        int v = ne[u][i];
        dep[v] = dep[u] + 1;
        tot = dfs(v, tot);
    }
    r[u] = tot;
    return tot;
}

int main()
{
#ifndef ONLINE_JUDGE
    freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#endif
    int i;
    scanf("%d",&n);
    REP(i,2,n)
    {
        scanf("%d",&fa[i]);
        ne[fa[i]].pb(i);
    }

    dfs(1,0);

    int m;
    scanf("%d", &m);
    while( m-- )
    {
        int type,u;
        scanf("%d%d", &type, &u);
        if(type==1)
        {
            int x,k;
            scanf("%d%d",&x,&k);
            int val = ( x + (LL)k * dep[u] % Mod + Mod ) % Mod;
            add( l[u], val, k ) ;
            add( r[u] + 1, ( Mod - val ) % Mod , ( Mod - k ) % Mod ) ;
        }
        else
            printf("%d\n", ask(u) );
    }
    return 0;
}
