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

using ll = long long;
using Vi = std::vector<int>;
using Vl = std::vector<ll>;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;

constexpr int I_INF = std::numeric_limits<int>::max();
constexpr ll L_INF = std::numeric_limits<ll>::max();

template <typename T1, typename T2>
inline bool chmin(T1& a, const T2& b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template <typename T1, typename T2>
inline bool chmax(T1& a, const T2& b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template <std::ostream& os = std::cout>
class Prints {
private:
    class __Prints {
    public:
        __Prints(const char* sep, const char* term) : sep(sep), term(term) {}
        template <class... Args>
        auto operator()(const Args&... args) const -> decltype((os << ... << std::declval<Args>()), void()) { print(args...); }
        template <typename T>
        auto pvec(const T& vec, size_t sz) const -> decltype(os << std::declval<decltype(std::declval<T>()[0])>(), void()) {
            for (size_t i = 0; i < sz; i++)
                os << vec[i] << (i == sz - 1 ? term : sep);
        }
        template <typename T>
        auto pmat(const T& mat, size_t h, size_t w) -> decltype(os << std::declval<decltype(std::declval<T>()[0][0])>(), void()) {
            for (size_t i = 0; i < h; i++)
                for (size_t j = 0; j < w; j++)
                    os << mat[i][j] << (j == w - 1 ? term : sep);
        }

    private:
        const char *sep, *term;
        void print() const { os << term; }
        void print_rest() const { os << term; }
        template <class T, class... Tail>
        void print(const T& head, const Tail&... tail) const { os << head, print_rest(tail...); }
        template <class T, class... Tail>
        void print_rest(const T& head, const Tail&... tail) const { os << sep << head, print_rest(tail...); }
    };

public:
    Prints() {}
    __Prints operator()(const char* sep = " ", const char* term = "\n") const { return __Prints(sep, term); }
};

Prints<> prints;
Prints<std::cerr> prints_err;

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

using Graph = std::vector<std::vector<int>>;

void solve() {
    int N;
    cin >> N;
    Graph g(N);
    vector<Pii> edges(N - 1);
    for (ll i = 0; i < N - 1; i++) {
        int a, b;
        cin >> a >> b;
        --a, --b;
        g[a].emplace_back(b);
        g[b].emplace_back(a);
        edges[i] = {a, b};
    }

    Vi ls(N), rs(N);
    {
        int idx = 0;
        auto dfs = [&](auto&& self, int u, int p) -> void {
            ls[u] = idx++;
            for (auto v : g[u]) {
                if (v != p) self(self, v, u);
            }
            rs[u] = idx;
        };
        dfs(dfs, 0, -1);
    }

    Vl imos(N + 1);

    int Q;
    cin >> Q;
    while (Q--) {
        ll t, e, x;
        cin >> t >> e >> x;
        --e;
        auto [a, b] = edges[e];
        if (t == 2) swap(a, b);
        if (ls[a] < ls[b]) {
            imos[0] += x;
            imos[N] -= x;
            imos[ls[b]] -= x;
            imos[rs[b]] += x;
        }
        else {
            imos[ls[a]] += x;
            imos[rs[a]] -= x;
        }
    }
    for (ll i = 0; i < N; i++) {
        imos[i + 1] += imos[i];
    }

    for (ll i = 0; i < N; i++) {
        prints()(imos[ls[i]]);
    }
}

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

int main() {
#ifdef FASTIO
    std::cin.tie(nullptr), std::cout.tie(nullptr);
    std::ios::sync_with_stdio(false);
#endif
#ifdef FILEINPUT
    std::ifstream ifs("./in_out/input.txt");
    std::cin.rdbuf(ifs.rdbuf());
#endif
#ifdef FILEOUTPUT
    std::ofstream ofs("./in_out/output.txt");
    std::cout.rdbuf(ofs.rdbuf());
#endif
    std::cout << std::setprecision(18) << std::fixed;
    solve();
    std::cout << std::flush;
    return 0;
}
#include <bits/stdc++.h>
// clang-format off
using namespace std; using ll = long long; using ull = unsigned long long; using pll = pair<ll,ll>; const ll INF = 4e18;
void print0() {}
template<typename Head,typename... Tail> void print0(Head head,Tail... tail){cout<<fixed<<setprecision(15)<<head;print0(tail...);}
void print() { print0("\n"); }
template<typename Head,typename... Tail>void print(Head head,Tail... tail){print0(head);if(sizeof...(Tail)>0)print0(" ");print(tail...);}
// clang-format on

vector<pll> val;
vector<vector<ll>> memo(2, vector<ll>(200005, -INF));
ll rec(ll isright, ll i) {
    if (i == val.size()) {
        return (isright ? abs(val[i - 1].second) : abs(val[i - 1].first));
    }
    if (memo[isright][i] != -INF) return memo[isright][i];

    ll cur = 0;
    if (i > 0) {
        cur = (isright ? val[i - 1].second : val[i - 1].first);
    }

    return memo[isright][i] = min(
      abs(cur - val[i].second) + abs(val[i].second - val[i].first) + rec(0, i + 1),
      abs(cur - val[i].first) + abs(val[i].first - val[i].second) + rec(1, i + 1));
}
int main() {
    ll n;
    cin >> n;
    vector<vector<ll>> bkt(n + 1);
    for (ll i = 0; i < n; i++) {
        ll x, c;
        cin >> x >> c;
        bkt[c].push_back(x);
    }

    for(ll i = 0; i <= n; i++) {
      if(bkt[i].size()==0)continue;
      ll mx=-INF;
      ll mn=INF;
      for(auto e: bkt[i]){
        mx=max(mx,e);
        mn=min(mn,e);
      }
      val.push_back({mn,mx});
    }
    print(rec(0, 0));
}
