#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
 
using namespace std;
using namespace __gnu_pbds;
typedef long long int lld;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define trav(a,v) for(auto a:v)
const lld MOD=1'000'000'007;
lld ModPow(lld base, lld exp){
	if(exp==0)return 1;
	if(exp%2==1)return (base*ModPow(base,exp-1))%MOD;
	lld a=ModPow(base,exp/2);
	return (a*a)%MOD;
}
struct func{
	vector<lld> coef;
	lld lim;//x>=lim a resposta e 0
};
func operator *(func a, func b){
	func c;
	c.coef.resize(a.coef.size()+b.coef.size()-1,0);
	c.lim=min(a.lim,b.lim);
	rep(i,0,(int)a.coef.size()){
		rep(j,0,(int)b.coef.size()){
			c.coef[i+j]+=a.coef[i]*b.coef[j];
			c.coef[i+j]%=MOD;
		}
	}
	return c;
}
func operator +(func a, func b){
	func c;
	c.coef.resize(max(a.coef.size(),b.coef.size()),0);
	c.lim=min(a.lim,b.lim);
	rep(i,0,(int)a.coef.size()){
		c.coef[i]+=a.coef[i];
		c.coef[i]%=MOD;
	}
	rep(i,0,(int)b.coef.size()){
		c.coef[i]+=b.coef[i];
		c.coef[i]%=MOD;
	}
	return c;
}
func operator *(func a, lld b){
	func c;
	c.lim=a.lim;
	c.coef.resize(a.coef.size(),0);
	rep(i,0,(int)a.coef.size()){
		c.coef[i]=a.coef[i]*b;
		c.coef[i]%=MOD;
	}
	return c;
}
func operator /(func a, lld b){
	func c;
	c.lim=a.lim;
	c.coef.resize(a.coef.size(),0);
	rep(i,0,(int)a.coef.size()){
		c.coef[i]=a.coef[i]*ModPow(b,MOD-2);
		c.coef[i]%=MOD;
	}
	return c;
}

lld eval(func f, lld x){
	lld ans=0;
	lld pow=1;
	rep(i,0,(int)f.coef.size()){
		ans+=pow*f.coef[i];
		pow*=x;
		ans%=MOD;
		pow%=MOD;
	}
	return ans;
}
int n;
func pref(func a){
	func c;
	c.coef.resize(a.coef.size()+1,0);
	c.lim=a.lim;
	rep(i,0,(int)a.coef.size()){
		c.coef[i+1]=a.coef[i]*ModPow(i+1,MOD-2);
		c.coef[i+1]%=MOD;
	}
	lld cval=eval(c,c.lim);
	rep(i,0,(int)c.coef.size())c.coef[i]*=MOD-1,c.coef[i]%=MOD;
	c.coef[0]+=cval;
	c.coef[0]%=MOD;
	return c;
}
void Print(func a){
	trav(x,a.coef)cout<<x<<" ";
	cout<<endl;
	cout<<a.lim<<endl;
}
func DP[1000];
vector<int> nei[1000000];
lld B[1000000];
void calcDP(int node){
	if(nei[node].size()==0){
		DP[node].coef={B[node],MOD-1};
		DP[node].lim=B[node];

		return;
	}
	DP[node].coef={1};
	DP[node].lim=B[node];
	trav(a,nei[node]){
		calcDP(a);
		DP[node]=DP[node]*DP[a];
	}

	DP[node]=pref(DP[node]);

}
void solve(){
	cin>>n;

	lld totalposs=1;
	int root=-1;
	rep(i,0,n){
		cin>>B[i];
		totalposs*=B[i];
		totalposs%=MOD;
		int x;
		cin>>x;
		if(x>0){
			nei[x-1].push_back(i);
		}else root=i;
	}
	calcDP(root);
	lld ans=eval(DP[root],0);
	ans*=ModPow(totalposs,MOD-2);
	ans%=MOD;
	cout<<ans<<"\n";
}

int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);
	int tt=1;
	//cin>>tt;
	while(tt--){
		solve();
	}
}