#pragma comment(linker, "/STACK:10000000")
#define _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_DEPRECATE

#include <cassert>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <numeric>
#include <bitset>
#include <vector>
#include <set>
#include <string>
#include <map>
#include <cmath>
#include <algorithm>
#include <queue>
#include <cstdlib>
#include <functional>
#include <cstring>
#include <ctime>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;


#define pb push_back
#define mp make_pair
#define e1 first
#define e2 second
#define sz size

const int maxn = 200 * 1000;
const long long maxlen = 2 * (long long)(maxn) * (long long)(maxn);

struct item 
{
	ll key, right;
	int prior;
	ll add, val;

	item * l, * r;
	item() { }
	item (ll key, int prior) : key(key), prior(prior), l(NULL), r(NULL), add(0), val(0) { }
};
typedef item * pitem;

void upd(pitem t)
{
	if (!t)
		return;
	if (t->l)
		t->l->add += t->add;
	if (t->r)
		t->r->add += t->add;
	t->val += t->add;
	t->add = 0;
}

void split (pitem t, ll key, pitem & l, pitem & r) 
{
	upd(t);
	if (!t)
		l = r = NULL;
	else if (key <= t->key)
		split (t->l, key, l, t->l),  r = t;
	else
		split (t->r, key, t->r, r),  l = t;
	//upd(t);
}

void merge (pitem & t, pitem l, pitem r) 
{
	upd(l); upd(r);
	if (!l || !r)
		t = l ? l : r;
	else if (l->prior > r->prior)
		merge (l->r, l->r, r),  t = l;
	else
		merge (r->l, l, r->l),  t = r;
	//upd(t);
}

ll get(pitem t, ll key)
{
	upd(t);
	if (key >= t->key && key <= t->right)
		return t->val;
	if (key < t->key)
		return get(t->l, key);
	return get(t->r, key);
}

ll ch_left(pitem t, ll new_key)
{
	upd(t);
	if (t->l)
		return ch_left(t->l, new_key);
	else
	{
		t->key = new_key;
		return t->val;
	}
}

ll upp_bound(pitem t, ll key)
{
	upd(t);
	if (key >= t->key && key <= t->right)
		return t->key;
	if (key < t->key)
		return upp_bound(t->l, key);
	return upp_bound(t->r, key);
}

void add(pitem& t, ll x, ll del)
{
	static pitem l, r;
	l = r = NULL;
	ll k = upp_bound(t, x);
	assert(k <= x);
	split(t, k, l, r);
	if (k != x)
	{
		ll v = ch_left(r, x);
		pitem ne = new item(k, rand());
		ne->val = v;
		ne->right = x - 1;
		merge(l, l, ne);
	}
	r->add += del;
	merge(t, l, r);
}

int N, T, B, Q;
map< int, vector< pair< ll, ll > > > box[maxn];
map< int, int> sum[maxn];
int sumAll[maxn];
ll Max[maxn];
pitem root[maxn];


int main ()
{	
	scanf("%d%d\n", &N, &T);
	scanf("%d\n", &B);
	for (int i = 0; i < B; ++i)
	{
		int k, c;
		scanf("%d", &k);
		for (int j = 0; j < k; ++j)
		{
			scanf("%d", &c);c--;
			box[i][c].pb(mp(j, j));
			sum[i][c] += 1;
			sumAll[i]++;
			Max[i]++;
		}
		
		root[i] = new item(0, rand());
		root[i]->right = maxlen;
	}
	
	scanf("%d\n", &Q);
	
	int c, f, t, h, p;
	for (int i = 0; i < Q; ++i)
	{
		scanf("%d", &c);
		if (c == 1)
		{
			scanf("%d%d\n", &p, &f);
			f--;p--;
			printf("%d\n", sum[f][p]);
		}
		else 
		{
			scanf("%d%d%d%d\n", &p, &f, &h, &t);
			f--;t--;p--;
			
			int len = 0;
			while (!box[f][p].empty())
			{
 				ll b = box[f][p].back().e1, e = box[f][p].back().e2;
				b -= get(root[f], b); e -= get(root[f], e);
				
				if (b >= sumAll[f] - h)
				{
					len += e - b + 1;
					add(root[f], box[f][p].back().e2 + 1, e - b + 1);
					box[f][p].pop_back();
				}
				else 
				{
					int d = max( 0ll, e - (sumAll[f] - h) + 1 );
					len += d;
					if (d != 0) add(root[f], box[f][p].back().e2, d);
                    box[f][p].back().e2 -= d;
					break;
				}
			}
			
			sum[f][p] -= len;
			sumAll[f] -= len;
			
			sum[t][p] += len;
			sumAll[t] += len;
			
			if (len != 0)
			{
				box[t][p].pb(mp(Max[t], Max[t] + len - 1));
				Max[t] += len;
			}
		}
	}
	return 0;
}
/*#include <bits/stdc++.h>

using namespace std;
#define int long long
int seg[96069*4],lazy[96069*4];
void build(int p,int l,int r){
    seg[p] = lazy[p] = 0;
    if(l==r){
        return ;
    }
    int md = (l+r)/2;
    build(p*2,l,md);
    build(p*2+1,md+1,r);
}
void prop(int p,int l,int r){
    seg[p]+=lazy[p];
    if(l!=r){
        lazy[p*2]+=lazy[p];
        lazy[p*2+1]+=lazy[p];
    }
    lazy[p] = 0;
}
void update(int p,int l,int r,int lq,int rq,int val){
    prop(p,l,r);
    if(l>=lq&&r<=rq){
        lazy[p] = val;
        prop(p,l,r);
        return ;
    }
    if(r<lq||l>rq)return ;
    int md = (l+r)/2;
    update(p*2,l,md,lq,rq,val);
    update(p*2+1,md+1,r,lq,rq,val);
    seg[p] = min(seg[p*2],seg[p*2+1]);
}
multiset<int> co,vl,lo;
bool check(){
    if(co.size()<vl.size()){
        return 0;
    }
    auto it = vl.begin();
    for(auto i:co){
        if(it==vl.end())break;
        if((*it)<i){
            return 0;
        }
        it++;
    }
    return 1;
}
signed main(){
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        int x[n],l[n],c[n],lol = -1;
        co.clear();vl.clear();lo.clear();
        map<int,int> sav;set<int> mp;
        int cnt= 0;
        for(int i = 0;i<n;i++){
            cin>>x[i];
        }
        for(int i = 0;i<n;i++){
            cin>>l[i];
            if(!l[i])lol = i;
        }
        for(int i = 0;i<n;i++){
            cin>>c[i];
            mp.insert(c[i]);
        }
        for(auto i:mp){
            sav[i] = ++cnt;
        }
        build(1,1,cnt);
        int le = 0;
        for(int i = 0;i<n;i++){
            if(l[i]){
                co.insert(c[i]);
                update(1,1,cnt,sav[c[i]],cnt,1);
            }else{
                vl.insert(c[i]);
                update(1,1,cnt,sav[c[i]],cnt,-1);
            }
            if(i<lol){
                cout<<-1<<" ";
                continue;

                le++;
            }
            if(le==0)cout<<-1<<" ";
            else cout<<x[i]+x[i]-x[le-1]<<" ";
        }
        cout<<endl;
    }
    return 0;
}
*/