#include <bits/stdc++.h>
using namespace std;

struct Node{
  vector<Node*> nodes;
  long long val;
  int depth;
};
vector<Node> node;

void depth_dfs(Node& a, int d){
  a.depth = d;
  for (auto& next:a.nodes)
    if(next->depth==-1)
      depth_dfs(*next, d+1);
}

void imos_dfs(Node& a, long now){
  now += a.val;
  a.val = now;
  for (auto& next:a.nodes)
    if(next->depth > a.depth)
      imos_dfs(*next, now);
}

int main(){
  int N;
  cin >> N;
  int a[N], b[N];
  node.resize(N);
  
  for (int i = 0; i < N; i++)node[i].val = 0;
  for (int i = 0; i < N; i++)node[i].depth = -1;
  for (int i = 0; i < N-1; i++){
    cin >> a[i] >> b[i];
    a[i]--;b[i]--;
    node[a[i]].nodes.push_back(&node[b[i]]);
    node[b[i]].nodes.push_back(&node[a[i]]);
  } 
  depth_dfs(node[0],0);
  int Q;
  cin >> Q;
  for (int i = 0; i < Q; i++){
    int t, e, x, u, v;
    cin >> t >> e >> x;
    e--;
    u = a[e]; v = b[e];
    if(t==2)swap(u,v);
    if(node[u].depth > node[v].depth)
      node[u].val += x;
    else{
      node[0].val += x;
      node[v].val -= x;
    }
  }
  imos_dfs(node[0],0);
  for (int i = 0; i < N; i++)
    cout << node[i].val << endl;
}


/* In the name of Allah, The Most Gracious, The Most Merciful!

   Iffat Sanzida
   JU CSE48

   ❀(◕‿◕)❀

*/
#include<bits/stdc++.h>
#define ll long long int
#define pi acos(-1)
#define FAST() ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
using namespace std;

//ll mod=1000000007;
//bool sortBysec(pair<ll,ll>a,pair<ll,ll>b)
//{
//    return a.second>b.second;
//}
//
//bool prime[2000000];
//vector<ll>vv;
//void SieveOfEratosthenes(ll n)
//{
//
//    prime[2]=true;
//    memset(prime, true, sizeof(prime));
//    for(ll i=4; i<=n; i+=2)
//    {
//        prime[i]=false;
//    }
//
//    for (ll p=3; p*p<=n; p+=2)
//    {
//
//        if (prime[p] == true)
//        {
//
//            for (ll i=p*p; i<=n; i +=(2*p))
//                prime[i] = false;
//        }
//    }
//    vv.push_back(2);
//    for(ll i=3; i<=n; i+=2)
//    {
//        if(prime[i])
//        {
//            vv.push_back(i);
//        }
//    }
//
//}
////
////ll phi[10000000];
////void EulerTotientFunction(ll n)
////{
////    for(ll i=1; i<=n; i++)
////    {
////        phi[i]=i;
////    }
////    for(ll i=2; i*i<=n; i++)
////    {
////        if(phi[i]==i)
////        {
////            for(ll j=i; j<=n; j+=i)
////            {
////                phi[j]/=i;
////                phi[j]*=(i-1);
////            }
////        }
////    }
////}
//
//
//ll binExp(ll a,ll n)
//{
//    ll res=1;
//    while(n)
//    {
//        if(n%2==1)
//        {
//            res=(res*a)%mod;
//            n--;
//        }
//        else
//        {
//            a=(a*a)%mod;
//            n=n/2;
//        }
//    }
//    return res;
//}
//
//ll ncr(ll n,ll r)
//{
//    if(r>n-r)
//    {
//        r=n-r;
//    }
//    ll i,j,ans=1;
//    for(i=n,j=1; j<=r; j++,i--)
//    {
//        ans=((ans*i)%mod);
//        ans=ans/j;
//        //ans=(ans*binExp(j,mod-2))%mod;
//    }
//    return ans;
//}
//
//ll power(ll n,ll m)
//{
//    ll ans=1;
//    while(m)
//    {
//        ans*=n;
//        m--;
//    }
//    return ans;
//}
//
//ll digsum(ll n)
//{
//    ll sum=0;
//    while(n)
//    {
//        sum+=n%10;
//        n=n/10;
//    }
//    return sum;
//}
//ll fac[2000006];
//void fact(ll n)
//{
//
//    fac[1]=1;
//    fac[0]=1;
//    for (ll i=1; i<=n; i++)
//    {
//        fac[i]=((fac[i-1]%mod)*(i%mod))%mod;
//    }
//
//}
//
//ll npr(ll n,ll r)
//{
//    ll ans=1;
//    for(ll i=n,j=1; j<=r; j++,i--)
//    {
//        ans=((ans%mod)*(i%mod))%mod;
//    }
//    return ans;
//}
//
//
//ll bigmod(ll a,ll b)
//{
//    ll ans=1;
//    for(ll i=1; i<=b; i++)
//    {
//        ans*=a;
//
//    }
//    return ans;
//}
//bool sortbysecTuple(const tuple<int, int, int>& a, const tuple<int, int, int>& b)
//{
//    return (get<1>(a) < get<1>(b));
//}
//
//ll ex_gcd(ll a,ll b,ll &x, ll &y)
//{
//    if(b==0)
//    {
//        x=1;
//        y=0;
//        return a;
//    }
//    ll x1,y1;
//    ll d=ex_gcd(b,a%b,x1,y1);
//    x=y1;
//    y=x1-y1*(a/b);
//    return d;
//}
//ll cntdig(ll n)
//{
//    ll cnt=0;
//    while(n)
//    {
//        cnt++;
//        n=n/10;
//    }
//    return cnt;
//}


int main()
{
    FAST();
    ll t=1,i=0,m,n,j,l,k,x,y,z,a,b,p,c,d,q,tt=0,r,s;

    //cin>>t;

    while(t--)
    {
        tt++;
        double D,H,di,hi,ans=0.0;
       // vector<double>d,h;
        cin>>n>>D>>H;
        for(i=0;i<n;i++)
        {
            cin>>di>>hi;
            ans=max(ans,H-((D*(H-hi))/(D-di)));
        }
        cout<<fixed<<setprecision(15)<<ans<<endl;


    }
    return 0;

}
