#include<vector>

namespace ProconLib{

    template<class graph_t>
    class EulerTour{
        private:
        int N;
        std::vector<int> ins;
        std::vector<int> outs;
        void dfs(int v,int pre,const graph_t& g,int& id);

        public:
        EulerTour(int root,const graph_t& g);
        int in(int v){return ins[v];}
        int out(int v){return outs[v];}
    };

    template<class graph_t>
    EulerTour<graph_t>::EulerTour(int root,const graph_t& g):N(g.size()),
                                                      ins(N),
                                                        outs(N)
    {   
        int id=0;
        dfs(root,-1,g,id);
    }   

    template<class graph_t>
    void EulerTour<graph_t>::dfs(int v,int pre,const graph_t& g,int& id){
        ins[v]=id++;
        for(auto& e:g[v]){
            if(e.to==pre) continue;
            dfs(e.to,v,g,id);
        }
        outs[v]=id++;
    }
}


#include<vector>

namespace ProconLib{
    
    template<class Monoid>
    class SegmentTree{
        public: 
        using value_t= typename Monoid::value_t;
        private:
        int N;
        std::vector<value_t> dat;
        static int calcN(int n){int res=1; while(res<n) res*=2; return res;}
        value_t queryImpl(int a,int b,int k,int l,int r);

        public:
        SegmentTree(int N);
        void update(int pos,value_t val);        
        void updateALL(std::vector<value_t> x);
        value_t query(int a,int b);
    };

    // struct MonoidExample{
    //     using value_t=int;
    //     static constexpr value_t E(){return 0;}
    //     static value_t op(value_t lhs,value_t rhs){return lhs+rhs;}
    // };
    
    template<typename Monoid>
    SegmentTree<Monoid>::SegmentTree(int n):N(calcN(n)),dat(2*N-1,Monoid::E()){}

    template<typename Monoid>
    void SegmentTree<Monoid>::update(int pos,value_t val){
        pos+=N-1;
        dat[pos]=val;
        while(pos!=0){
            int par=(pos-1)/2;
            dat[par]=Monoid::op(dat[par*2+1],dat[par*2+2]);
            pos=par;
        }
    }

    template<typename Monoid>
    void SegmentTree<Monoid>::updateALL(std::vector<value_t> x){
        for(int i=0;i<x.size();i++) dat[N-1+i]=x[i];
        for(int i=N-2;i>=0;i--) dat[i]=Monoid::op(dat[i*2+1],dat[i*2+2]);
    }

    template<typename Monoid>
    typename SegmentTree<Monoid>::value_t SegmentTree<Monoid>::query(int a,int b){
        return queryImpl(a,b,0,0,N);
    }

    template<typename Monoid>
    typename SegmentTree<Monoid>::value_t SegmentTree<Monoid>::queryImpl(int a,int b,int k,int l,int r){
        if(a<=l && r<=b) return dat[k];
        if(r<=a || b<=l) return Monoid::E();
        int mid=(l+r)/2;
        value_t c1v=queryImpl(a,b,k*2+1,l,mid);
        value_t c2v=queryImpl(a,b,k*2+2,mid,r);
        return Monoid::op(c1v,c2v);
    }
}



#include<bits/stdc++.h>
// #include"../DataStructure/SegmentTree.cpp"
using namespace std;
using namespace ProconLib;

struct Edge{
    int to;
};

struct Monoid{
    using value_t=int;
    static constexpr value_t E(){return 0;}
    static value_t op(value_t lhs,value_t rhs){return lhs+rhs;}
};    

using Graph=vector<vector<Edge>>;
int main(){
    int n;
    cin>>n;
    Graph g(n);
    vector<int> par(n,-1);
    vector<int> val(n,0);
    for(int i=0;i<n;i++){
        int k; cin>>k;
        while(k--){
            int c; cin>>c;
            par[c]=i;
            g[i].push_back(Edge{c});
            g[c].push_back(Edge{i});
        }
    }
    EulerTour<Graph> et(0,g);
    SegmentTree<Monoid> seg(2*n);

    int q; cin>>q;
    while(q--){
        int type; cin>>type;
        if(!type){
            int v,w; cin>>v>>w;
            val[v]+=w;
            seg.update(et.in(v),val[v]);
            seg.update(et.out(v),-val[v]);
        }
        else{
            int u; cin>>u;
            cout<<seg.query(et.in(0),et.in(u)+1)<<endl;
        }
    }


}


Measured memory_bytes: 19776