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

const int MaxN = 1e5 + 10;

int N, Q, id;
vector <int> adj[MaxN];
int health[MaxN], start[MaxN], finish[MaxN], node[MaxN];

class SegmentTree {
private :
    int minhealth[MaxN << 2], Count[MaxN << 2], poison[MaxN << 2];
public:
    #define mid ((l + r) >> 1)
    void build(int k, int l, int r) {
        if (l == r) {
            poison[k] = 0;
            minhealth[k] = health[node[l]];
            Count[k] = 1;
            return;
        }

        build(2 * k, l, mid);
        build((2 * k) + 1, mid + 1, r);

        minhealth[k] = min(minhealth[2 * k], minhealth[(2 * k) + 1]);
        Count[k] = Count[2 * k] + Count[(2 * k) + 1];
        poison[k] = 0;
    }

    void lazy(int k, int l, int r) {
        if (!poison[k])  return;
        poison[l] += poison[k];     poison[r] += poison[k];
        minhealth[l] -= poison[k];  minhealth[r] -= poison[k];
        poison[k] = 0;
    }

    void update(int k, int l, int r, int i, int j, int value) {
        if (l > j || r < i) return;
        if (i <= l && r <= j) {
            poison[k] += value;
            minhealth[k] -= value;
            return;
        }
        lazy(k, 2 * k, (2 * k) + 1);

        update(2 * k, l, mid, i, j, value);
        update((2 * k) + 1, mid + 1, r, i, j, value);
        minhealth[k] = min(minhealth[2 * k], minhealth[(2 * k) + 1]);
    }

    int get(int k, int l, int r, int i, int j) {
        if (l > j || r < i) return 0;
        lazy(k, 2 * k, (2 * k) + 1);
        if (l == r) {
            if (minhealth[k] > 0) return Count[k];
            minhealth[k] = 2e9 + 7;
            return Count[k] = 0;
        }

        if (i <= l && r <= j) {
            if (minhealth[k] <= 0) {
                get(2 * k, l, mid, i, j);
                get((2 * k) + 1, mid + 1, r, i, j);
                minhealth[k] = min(minhealth[2 * k], minhealth[(2 * k) + 1]);
                Count[k] = Count[2 * k] + Count[(2 * k) + 1];
            }
            return Count[k];
        }

        int x = get(2 * k, l, mid, i, j);
        int y = get((2 * k) + 1, mid + 1, r, i, j);
        minhealth[k] = min(minhealth[2 * k], minhealth[(2 * k) + 1]);
        Count[k] = Count[2 * k] + Count[(2 * k) + 1];
        return x + y;
    }
} IT;

void Enter() {
    cin >> N;
    for (int i = 1; i <= N; ++i) {
        int parent; cin >> health[i] >> parent;
        adj[parent].push_back(i);
    }
}

void DFS(int u) {
    node[id] = u; start[u] = id++;
    for (int i = 0; i < adj[u].size(); ++i)
        DFS(adj[u][i]);
    finish[u] = id - 1;
}

void Process() {
    cin >> Q;
    IT.build(1, 0, N);
    while (Q--) {
        int type; cin >> type;
        if (type == 1) {
            int A, X; cin >> A >> X;
            IT.update(1, 0, N, start[A] + 1, finish[A], X);
        } else {
            int A; cin >> A;
            cout << IT.get(1, 0, N, start[A] + 1, finish[A]) << "\n";
        }
    }
}

int main() {
  //  freopen("input.in", "r", stdin);
    //freopen("output.out", "w", stdout);

    Enter();
    DFS(0);
    Process();

    return 0;
}