#include <iostream>
#include <fstream>
#include <string>
#include <set>
#include <map>
#include <vector>
#include <queue>
 
using namespace std;
 
struct t_node
{
	map<char, t_node*> m_nodes;
 
	~t_node()
	{
		if (!m_nodes.empty())
		{
			for (map<char, t_node*>::iterator it = m_nodes.begin(); it != m_nodes.end(); ++it)
			{
				delete it->second;
			}
		}
	}
};
 
 
ifstream fin("c:\\A-large.in");
ofstream fout("c:\\A-large.out");
 
#define cin fin
#define cout fout
 
int main()
{
	int L;
	int D;
	int N;
	cin >> L >> D >> N;
	t_node root;
	t_node *p_node;
	// Build tree
	for (int d = 0; d < D; ++d)
	{
		string word;
		cin >> word;
		p_node = &root;
		for (int l = 0; l < L; ++l)
		{
			if (p_node->m_nodes.find(word[l]) == p_node->m_nodes.end())
			{
				// Insert char->node pair to m_nodes
				p_node->m_nodes[word[l]] = new t_node;
			}
			p_node = p_node->m_nodes[word[l]];
		}
	}
	// Matching cases
	for(int n = 0; n < N; ++n)
	{
		string line;
		cin >> line;
		queue<t_node *> possible_matches;
		possible_matches.push(&root);
		for (string::size_type pos = 0; !possible_matches.empty() && pos < line.length(); ++pos)
		{
			queue<t_node *>::size_type n_matches = possible_matches.size();
			int chars_begin = pos;
			int chars_end;
			if (line[pos] == '(')
			{
				chars_begin++;
				chars_end = line.find_first_of(')', chars_begin);
				pos = chars_end;
			}
			else
			{
				chars_end = chars_begin + 1;
			}
			for (queue<t_node *>::size_type i = 0; i < n_matches; ++i)
			{
				t_node *this_node = possible_matches.front();
				possible_matches.pop();
				for (int char_pos = chars_begin; char_pos != chars_end; ++char_pos)
				{
					char ch = line[char_pos];
					if (this_node->m_nodes.find(ch) != this_node->m_nodes.end())
					{
						possible_matches.push(this_node->m_nodes[ch]);
					}
				}
			}
		}
		cout << "Case #" << n + 1 << ": " << possible_matches.size() << endl;
	}
	return 0;
}

#include <iostream>
#include <string>
#include <fstream>
 
using namespace std;
 
#define MAX_H	100;
#define MAX_W	100;
 
ifstream fin("C:\\B-large.in");
ofstream fout("C:\\B-large.out");
 
#define cin fin
#define cout fout
 
int map[100][100] = {0};
char mark[100][100] = {0};
 
int W;
int H;
 
char ch_mark;
 
int rec_mark(int r, int c)
{
	if (mark[r][c] != 0)
	{
		return mark[r][c];
	}
	else
	{
		// Calculate diff of altitude
		int up, left, right, down;
		up = left = right = down = -1;
		if (r > 0)
		{
			up = map[r][c] - map[r-1][c];
		}
		if (c > 0)
		{
			left = map[r][c] - map[r][c-1];
		}
		if (c < W - 1)
		{
			right = map[r][c] - map[r][c+1];
		}
		if (r < H - 1)
		{
			down = map[r][c] - map[r+1][c];
		}
		if (up <= 0 && left <= 0 && right <= 0 && down <= 0)
		{
			// Sink
			mark[r][c] = ch_mark;
			ch_mark++;
		}
		else
		{
			// Find the flow direction
			int max_diff = up;
			int dr = -1; int dc = 0;
			if (left > max_diff)
			{
				max_diff = left;
				dr = 0; dc = -1;
			}
			if (right > max_diff)
			{
				max_diff = right;
				dr = 0; dc = 1;
			}
			if (down > max_diff)
			{
				dr = 1; dc = 0;
			}
			if (mark[r + dr][c + dc] != 0)
			{
				mark[r][c] = mark[r + dr][c + dc];
			}
			else
			{
				mark[r][c] = rec_mark(r + dr, c + dc);
			}
		}
		return mark[r][c];
	}
}
 
int main()
{
	int N;
	cin >> N;
 
	for (int n = 0; n < N; ++n)
	{
		ch_mark = 'a';
		int a;
		cin >> H >> W;
		for (int i = 0; i < H; ++i)
		{
			for (int j = 0; j < W; ++j)
			{
				cin >> a;
				map[i][j] = a;
				mark[i][j] = 0;
			}
		}
		// Look for next cell to eval
		for (int r = 0; r < H; r++)
		{
			for (int c = 0; c < W; c++)
			{
				if (mark[r][c] == 0)
				{
					rec_mark(r, c);
				}
			}
		}
		cout << "Case #" << n + 1 << ":" << endl;
		for (int r = 0; r < H; r++)
		{
			for (int c = 0; c < W; c++)
			{
				cout << mark[r][c] << ' ';
			}
			cout << endl;
		}
	}
	return 0;
}

#include <iostream>
#include <string>
#include <fstream>
 
using namespace std;
 
int n_src;
string src;
const int n_ptrn = 19;
const string ptrn = "welcome to code jam";
 
ifstream fin("C:\\C-small-attempt0.in");
 
#define cin fin
 
FILE *file;
 
int tbl[512][32];
 
int find_substring(const int s_src, const int s_ptrn)
{
	if (tbl[s_src][s_ptrn] != -1)
	{
		return tbl[s_src][s_ptrn];
	}
	if (n_src - s_src < n_ptrn - s_ptrn)
	{
		tbl[s_src][s_ptrn] = 0;
		return 0;
	}
	if (n_src - s_src == n_ptrn - s_ptrn)
	{
		string sub_src = src.substr(s_src, n_src - s_src);
		string sub_ptrn = ptrn.substr(s_ptrn, n_ptrn - s_ptrn);
		tbl[s_src][s_ptrn] = (sub_src == sub_ptrn) ? 1 : 0;
		return tbl[s_src][s_ptrn];
	}
	int total = 0;
	// Skip current char
	total += find_substring(s_src+1, s_ptrn);
	total %= 10000;
	// If current char matches
	if (src[s_src] == ptrn[s_ptrn])
	{
		total += find_substring(s_src+1, s_ptrn+1);
		total %= 10000;
	}
	tbl[s_src][s_ptrn] = total;
	return total;
}
 
int main()
{
	file = fopen("C:\\a.out", "w");
	int N;
	cin >> N;
	getline(cin, src);
	for (int n = 0; n < N; ++n)
	{
		getline(cin, src);
		memset(tbl, -1, sizeof(tbl));
		n_src = src.length();
		int cnt = find_substring(0, 0);
		fprintf(file, "Case #%d: %04d\n", n+1, cnt);
	}
	return 0;
}