#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;
}