#include<bits/stdc++.h>
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int inf = 0x3f3f3f3f;

inline int getid(char c)
{
	return '0' <= c && c <= '9'? c - '0':
		'a' <= c && c <= 'z'? c - 'a' + 10:
		'A' <= c && c <= 'Z'? c - 'A' + 36:
		-1;
}

struct NFA
{
	vector< array<int,62> > g;
	vector< vector<int> > e;
	string s; int ptr;
	int allbeg, allenn;
	
	int new_Node(void)
	{
		g.emplace_back(); e.emplace_back();
		g.back().fill(-1);
		return (int)g.size() - 1;
	}
	void makeRegexp(int beg,int enn)
	{
		// eprintf("makeRegexp, ptr = %d\n",ptr);
		while(ptr < (int)s.size() && s[ptr] != ')')
		{
			int u = new_Node(); makeAlternative(u, enn);
			e[beg].push_back(u);
			if(ptr < (int)s.size() && s[ptr] == '|') ++ptr;
		}
		// eprintf("finish Regexp, ptr = %d\n",ptr);
	}
	void makeAlternative(int beg,int enn)
	{
		// eprintf("makeAlternative, ptr = %d, s[ptr] = %c\n",ptr,s[ptr]);
		while(ptr < (int)s.size() && (getid(s[ptr]) != -1 || s[ptr] == '[' || s[ptr] == '('))
		{
			int u = new_Node(); makeTerm(beg, u);
			beg = u;
		}
		e[beg].push_back(enn);
		// eprintf("finish Alternative, ptr = %d\n",ptr);
	}
	void makeTerm(int beg,int enn)
	{
		// eprintf("makeTerm, ptr = %d, beg = %d, enn = %d\n",ptr,beg,enn);
		int mid = ptr, cnt = 0;
		while(1)
		{
			if(s[mid] == '[' || s[mid] == '(')
				++cnt;
			if(s[mid] == ']' || s[mid] == ')')
				--cnt;
			if(!cnt) break;
			++mid;
		}
		++mid;
		// eprintf("mid = %d\n",mid);
		if(s[mid] != '{')
		{
			makeAtom(beg, enn);
			return;
		}
		
		int l = 0, r = 0;
		while(s[++mid] != ',') l = l * 10 + s[mid] - '0';
		while(s[++mid] != '}') r = r * 10 + s[mid] - '0';
		
		// eprintf("l = %d, r = %d, mid = %d\n",l,r,mid);
		
		int save = ptr;
		vector<int> pos(l+1);
		pos[0] = new_Node();
		e[beg].push_back(pos[0]);
		for(int i=1; i<=l; ++i)
		{
			pos[i] = new_Node();
			ptr = save; makeAtom(pos[i-1], pos[i]);
		}
		
		// eprintf("ok l = %d, r = %d\n",l,r);
		
		if(s[mid-1] == ',')
		{
			if(l >= 1)
			{
				e[pos[l]].push_back(pos[l-1]);
				e[pos[l]].push_back(enn);
			}
			else
			{
				ptr = save;
				int u = new_Node();
				makeAtom(pos[0], u);
				e[pos[0]].push_back(u);
				e[u].push_back(pos[0]);
				e[u].push_back(enn);
			}
		}
		else
		{
			pos.resize(r+1);
			for(int i=l+1; i<=r; ++i)
			{
				pos[i] = new_Node();
				ptr = save; makeAtom(pos[i-1], pos[i]);
				e[pos[i-1]].push_back(enn);
			}
			e[pos[r]].push_back(enn);
		}
		ptr = mid + 1;
		// eprintf("finish Term, ptr = %d\n",ptr);
	}
	void makeAtom(int beg,int enn)
	{
		// eprintf("makeAtom, ptr = %d\n",ptr);
		if(s[ptr] == '(')
			++ptr, makeRegexp(beg, enn), ++ptr;
		else if(s[ptr] == '[')
		{
			int l = s[ptr+1];
			while(s[ptr] != ']') ++ptr;
			int r = s[ptr-1]; ++ptr;
			for(int i=l; i<=r; ++i)
				g[beg][getid(i)] = enn;
		}
		else
		{
			g[beg][getid(s[ptr])] = enn;
			++ptr;
		}
	}
	void build(string _s)
	{
		g.clear(); e.clear();
		s = _s; ptr = 0;
		allbeg = new_Node(); allenn = new_Node();
		makeRegexp(allbeg, allenn);
	}
	void dfs_e(int u,set<int> &cur)
	{
		if(!cur.emplace(u).second) return;
		for(int v: e[u])
			dfs_e(v, cur);
	}
	bool match(string t)
	{
		// eprintf("match my = %s, oth = %s\n",s.c_str(),t.c_str());
		// eprintf("allbeg = %d, allenn = %d\n",allbeg,allenn);
		set<int> cur;
		dfs_e(allbeg, cur);
		for(char c: t)
		{
			int cid = getid(c);
			// for(auto u: cur)
			// 	eprintf("cur: %d\n",u);
			// eprintf("add c = %c, id = %d\n",c,cid);
			set<int> nxt;
			for(int u: cur)
			{
				int v = g[u][cid];
				// eprintf("walk %d -> %d\n",u,v);
				if(v != -1) dfs_e(v, nxt);
			}
			cur.swap(nxt);
			if(!cur.size()) break;
		}
		// for(auto u: cur)
		// 	eprintf("cur: %d\n",u);
		return cur.find(allenn) != cur.end();
	}
}nfa[60];

map<string,int> name_to_nfa;
string nfa_to_name[60];
int totnfa = 0;

vector<string> splitRoute(string s)
{
	vector<string> res;
	int l = 0;
	for(int i=1; i<(int)s.size(); ++i)
	{
		if(s[i] == '/')
			res.emplace_back(s.begin() + l + 1, s.begin() + i), l = i;
	}
	res.emplace_back(s.begin() + l + 1, s.end());
	return res;
}

namespace Trie
{
	vector< map<string,int> > tr;
	vector< array<int,60> > tr_nfa;
	vector< string > name;
	
	int new_Node(void)
	{
		tr.emplace_back(); tr_nfa.emplace_back(); name.emplace_back();
		tr_nfa.back().fill(-1);
		return (int)tr.size() - 1;
	}
	void init(void)
	{
		tr.clear(); tr_nfa.clear(); name.clear();
		new_Node();
	}
	void insert(string _s,string _name)
	{
		auto s = splitRoute(_s);
		int u = 0;
		for(auto t: s)
		{
			if(t[0] == ':')
			{
				int id;
				auto tt = t.substr(1);
				if(!name_to_nfa.count(tt))
				{
					id = name_to_nfa[tt] = totnfa;
					nfa_to_name[totnfa] = tt;
					++totnfa;
				}
				else
				{
					id = name_to_nfa[tt];
				}
				
				int v = tr_nfa[u][id];
				if(v == -1) v = new_Node(), tr_nfa[u][id] = v;
				u = v;
			}
			else
			{
				int v;
				if(tr[u].count(t))
					v = tr[u][t];
				else
					v = tr[u][t] = new_Node();
				u = v;
			}
		}
		name[u] = _name;
	}
	void query(string _s)
	{
		auto s = splitRoute(_s);
		map< string, vector<string> > para;
		
		string saveback;
		{
			int pos = s.back().find('?');
			if(pos != -1)
			{
				saveback = s.back().substr(pos+1);
				s.back().resize(pos);
			}
		}
		
		// eprintf("\nquery: ");
		// for(auto t: s)
		// 	eprintf("<%s> ",t.c_str());
		// eprintf("\n");
		
		int u = 0;
		for(auto t: s)
		{
			int v = -1;
			if(tr[u].count(t))
			{
				v = tr[u][t];
			}
			else
			{
				for(int i=0; i<totnfa; ++i)
				{
					// eprintf("try u = %d, id = %d, v = %d\n",u,i,tr_nfa[u][i]);
					if(tr_nfa[u][i] != -1 && nfa[i].match(t))
					{
						para[ nfa_to_name[i] ].push_back(t);
						v = tr_nfa[u][i];
						break;
					}
				}
			}
			if(v == -1)
			{
				cout << "404 Not Found\n";
				return;
			}
			u = v;
		}
		if(name[u].size() == 0)
		{
			cout << "404 Not Found\n";
			return;
		}
		
		if(saveback.size())
		{
			for(char &c: saveback)
				if(getid(c) == -1)
					c = ' ';
			
			stringstream tt(saveback);
			vector<string> vec;
			for(string x; tt>>x;)
				vec.emplace_back(x);
			
			for(int i=0; i+1<(int)vec.size(); i+=2)
				para[vec[i]].push_back(vec[i+1]);
		}
		
		cout << "Request matches action \"" << name[u] << "\" with parameters {";
		
		bool isfir = 1;
		for(auto it: para)
		{
			if(!isfir) cout << ',';
			isfir = 0;
			
			cout << "\"" << it.first << "\":";
			auto &vec = it.second;
			if(vec.size() == 1)
			{
				cout << "\"" << vec[0] << "\"";
			}
			else
			{
				cout << '[';
				cout << "\"" << vec[0] << "\"";
				for(int i=1; i<(int)vec.size(); ++i)
					cout << ",\"" << vec[i] << "\"";
				cout << ']';
			}
		}
		cout << "}\n";
	}
}

void solve(int testid)
{
	cout << "Case #" << testid << ":\n";
	
	Trie::init();
	name_to_nfa.clear(); totnfa = 0;
	
	int n;
	cin >> n;
	for(int i=1; i<=n; ++i)
	{
		string s, name;
		cin >> s >> name;
		Trie::insert(s, name);
	}
	
	for(int i=0; i<totnfa; ++i)
	{
		string x,y;
		cin >> x >> y;
		// eprintf("(%s).build(%s)\n",x.c_str(),y.c_str());
		nfa[ name_to_nfa[x] ].build(y);
	}
	
	int Q;
	cin >> Q;
	while(Q--)
	{
		string s;
		cin >> s;
		Trie::query(s);
	}
}

int main(void)
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	
	int T;
	cin >> T;
	for(int i=1; i<=T; ++i)
		solve(i);
	return 0;
}