//POJ 2195.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define READ_FILE
#define READ_FREAD
//#define VISUAL_STUDIO

const int MAXN = 110;
const int MAXPT = 210;

#ifdef LOCAL
#define LOCAL_TIME
//#define LOCAL_DEBUG
//#define STD_DEBUG
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
	fread_char = getchar();
}

inline int get_int()
{
	int ret = 0;
	while ((fread_char < '0') || (fread_char > '9'))
	{
		fread_char = getchar();
	}
	while ((fread_char >= '0') && (fread_char <= '9'))
	{
		ret = ret * 10 + fread_char - '0';
		fread_char = getchar();
	}
	return ret;
}

inline char get_char()
{
	char ret;
	while ((fread_char == ' ') || (fread_char == 'n'))
	{
		fread_char = getchar();
	}
	ret = fread_char;
	fread_char = getchar();
	return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
	a = get_int();
#else
	scanf("%d", &a);
#endif
}

inline void read(char &a)
{
#ifdef READ_FREAD
	a = get_char();
#else
	scanf("%c", &a);
#endif
}

struct man_node
{
	int x, y;
};

typedef man_node house_node;

struct edge_node
{
	int to;
	int d;
	edge_node *next;
};

edge_node edge[MAXN * MAXN];
edge_node *head_edge[MAXPT];
int tot_edge;

man_node man[MAXN];
house_node house[MAXN];
int tot_man;
int tot_house;

inline void add_edge(const int u, const int v, const int d)
{
#ifdef LOCAL_DEBUG
	//printf("ADD_EDGE: M_X M_Y H_X H_Y D: %d %d %d %d %dn", man[u].x, man[u].y, house[v].x, house[v].y, d);
#endif
	edge[tot_edge].d = d;
	edge[tot_edge].to = v;
	edge[tot_edge].next = head_edge[u];
	head_edge[u] = edge + tot_edge++;
}

int n, m;
char map_pt;
int slack[MAXN], height_man[MAXN], height_house[MAXN];
int ans;
bool visit_man[MAXN], visit_house[MAXN];
int match_house[MAXN], match_d[MAXN];

inline int min(const int a, const int b)
{
	if (a == -1)
	{
		return b;
	}
	else if (b == -1)
	{
		return a;
	}
	return a < b ? a : b;
}

inline bool aug(const int u)
{
	visit_man[u] = true;
	int delta;
	for (edge_node *tmp = head_edge[u]; tmp != NULL; tmp = tmp->next)
	{
		if (!visit_house[tmp->to])
		{
			delta = tmp->d - height_man[u] - height_house[tmp->to];
			if (delta == 0)
			{
				visit_house[tmp->to] = true;
				if ((match_house[tmp->to] == -1) || (aug(match_house[tmp->to])))
				{
					match_house[tmp->to] = u;
					match_d[tmp->to] = tmp->d;
					return true;
				}
			}
			else
			{
				slack[tmp->to] = min(slack[tmp->to], delta);
			}
		}
	}
	return false;
}

inline void init_km()
{
	memset(slack, -1, sizeof(slack));
	memset(height_man, -1, sizeof(height_man));
	memset(height_house, 0, sizeof(height_house));
	memset(match_house, -1, sizeof(match_house));
	memset(match_d, 0, sizeof(match_d));
	ans = 0;
	for (int i = 0; i < tot_man; i++)
	{
		for (edge_node *tmp = head_edge[i]; tmp != NULL; tmp = tmp->next)
		{
			height_man[i] = min(height_man[i], tmp->d);
		}
	}
}

inline int km()
{
	init_km();
	for (int i = 0; i < tot_man; i++)
	{
#ifdef LOCAL_DEBUG
		printf("AUG: %dn", i);
#endif
		//memset(slack, -1, sizeof(slack));
		while (1)
		{
			memset(visit_man, false, sizeof(visit_man));
			memset(visit_house, false, sizeof(visit_house));
			if (aug(i))
			{
				break;
			}
			int delta = -1;
			for (int j = 0; j < tot_house; j++)
			{
				if (!visit_house[j])
				{
					delta = min(delta, slack[j]);
				}
			}
#ifdef LOCAL_DEBUG
			printf("DELTA: %dn", delta);
#endif
			for (int j = 0; j < tot_man; j++)
			{
				if (visit_man[j])
				{
					height_man[j] += delta;
				}
			}
			for (int j = 0; j < tot_house; j++)
			{
				if (visit_house[j])
				{
					height_house[j] -= delta;
				}
				else
				{
					slack[j] += delta;
				}
			}
		}
	}
	for (int i = 0; i < tot_house; i++)
	{
#ifdef LOCAL_DEBUG
		printf("HOUSE: %d %d MAX: %d %d D: %dn", house[i].x, house[i].y, man[match_house[i]].x, man[match_house[i]].y, match_d[i]);
#endif
		ans += match_d[i];
	}
	return ans;
}

int main()
{
#ifdef LOCAL_TIME
	long long start_time_ = clock();
#endif
#ifdef READ_FILE
	freopen("2195.in", "r", stdin);
#ifndef STD_DEBUG
	freopen("2195.out", "w", stdout);
#endif
#endif
#ifdef READ_FREAD
	fread_init();
#endif
	read(n);
	read(m);
	while (n != 0)
	{
		tot_man = tot_house = 0;
		memset(head_edge, 0, sizeof(head_edge));
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < m; j++)
			{
				read(map_pt);
				if (map_pt == 'm')
				{
					man[tot_man].x = i;
					man[tot_man++].y = j;
				}
				else if (map_pt == 'H')
				{
					house[tot_house].x = i;
					house[tot_house++].y = j;
				}
			}
		}
		tot_edge = 0;
		for (int i = 0; i < tot_man; i++)
		{
			for (int j = 0; j < tot_house; j++)
			{
				add_edge(i, j, std::abs(man[i].x - house[j].x) + std::abs(man[i].y - house[j].y));
			}
		}
		printf("%dn", km());
		read(n);
		read(m);
	}
#ifdef LOCAL_TIME
	printf("run time: %lld msn", (clock() - start_time_) / 1000);
#endif
#ifdef READ_FILE
	fclose(stdin);
#ifndef STD_DEBUG
	fclose(stdout);
#endif
#endif
	return 0;
}

//HNOI2007 evacuate.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>

//#define LOCAL
//#define VISUAL_STUDIO
#define READ_FREAD
//#define READ_FILE

const int MAXN = 25;
const int MAXPT = 410;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define STD_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
	fread_char = getchar();
}

inline int get_int()
{
	int ret = 0;
	while ((fread_char < '0') || (fread_char > '9'))
	{
		fread_char = getchar();
	}
	while ((fread_char >= '0') && (fread_char <= '9'))
	{
		ret = ret * 10 + fread_char - '0';
		fread_char = getchar();
	}
	return ret;
}

inline char get_char()
{
	char ret;
	while ((fread_char == ' ') || (fread_char == 'n'))
	{
		fread_char = getchar();
	}
	ret = fread_char;
	fread_char = getchar();
	return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
	a = get_int();
#else
	scanf("%d", &a);
#endif
}

inline void read(char &a)
{
#ifdef READ_FREAD
	a = get_char();
#else
	scanf("%c", &a);
#endif
}

int n, m;
char map[MAXN][MAXN];
int d[MAXPT][MAXPT];
bool graph_in[MAXPT], graph_out[MAXPT];
int l, r, mid, tot_p;
int s, t;

inline int get_node(const int i, const int j)
{
	return (i - 1) * m + j;
}

struct queue_node
{
	int id, height;
	inline queue_node(const int id_ = 0, const int height_ = 0)
	{
		id = id_;
		height = height_;
	}
	inline bool operator < (const queue_node &b) const
	{
		return height < b.height;
	}
};

int flow_graph[MAXPT][MAXPT];
int height[MAXPT], inflow[MAXPT], gap[MAXPT];
bool visit[MAXPT], in_q[MAXPT];
std::queue <int> bfs_q;
std::priority_queue <queue_node> Q;

inline void bfs()
{
	gap[0] = 1;
	bfs_q.push(t);
	visit[t] = true;
	int tmp;
	while (!bfs_q.empty())
	{
		tmp = bfs_q.front();
		bfs_q.pop();
		for (int i = s; i <= t; i++)
		{
			if ((!visit[i]) && (flow_graph[i][tmp] > 0))
			{
				gap[height[i] = height[tmp] + 1]++;
				visit[i] = true;
				bfs_q.push(i);
			}
		}
	}
}

inline void max_flow_init(const int time)
{
	memset(flow_graph, 0, sizeof(flow_graph));
	memset(height, 0, sizeof(height));
	memset(inflow, 0, sizeof(inflow));
	memset(gap, 0, sizeof(gap));
	memset(visit, false, sizeof(visit));
	memset(in_q, false, sizeof(in_q));
	in_q[s] = in_q[t] = true;
	for (int i = s + 1; i < t; i++)
	{
		flow_graph[s][i] = graph_in[i];
		flow_graph[i][t] = graph_out[i] * time;
	}
	for (int i = s + 1; i < t; i++)
	{
		for (int j = s + 1; j < t; j++)
		{
			if (graph_out[j])
			{
				flow_graph[i][j] = (d[i][j] <= time) && (d[i][j] > 0) ? 1 : 0;
			}
		}
	}
	bfs();
}

inline int max_flow(const int time)
{
	max_flow_init(time);
	for (int i = s + 1; i < t; i++)
	{
		if (flow_graph[s][i] > 0)
		{
			flow_graph[i][s] = inflow[i] = flow_graph[s][i];
			flow_graph[s][i] = 0;
			in_q[i] = true;
			Q.push(queue_node(i, height[i]));
		}
	}
	queue_node tmp;
	int push_flow, min_height;
	while (!Q.empty())
	{
		tmp = Q.top();
		Q.pop();
		in_q[tmp.id] = false;
		for (int i = s + 1; (i <= t) && (inflow[tmp.id] > 0); i++)
		{
			if ((flow_graph[tmp.id][i] > 0) && (height[tmp.id] == height[i] + 1))
			{
				push_flow = std::min(inflow[tmp.id], flow_graph[tmp.id][i]);
				inflow[i] += push_flow;
				inflow[tmp.id] -= push_flow;
				flow_graph[tmp.id][i] -= push_flow;
				flow_graph[i][tmp.id] += push_flow;
				if (!in_q[i])
				{
					in_q[i] = true;
					Q.push(queue_node(i, height[i]));
				}
			}
		}
		if ((inflow[tmp.id] > 0) && (tmp.id < t))
		{
			min_height = -1;
			for (int i = s + 1; i < t; i++)
			{
				if (flow_graph[tmp.id][i] > 0)
				{
					if ((min_height == -1) || (min_height > height[i]))
					{
						min_height = height[i];
					}
				}
			}
			if ((min_height > -1) && (min_height < t))
			{
				gap[height[tmp.id]]--;
				if (gap[height[tmp.id]] == 0)
				{
					for (int i = s + 1; i < t; i++)
					{
						if ((height[i] >= height[tmp.id]) && (height[i] < t))
						{
							gap[height[i]]--;
							height[i] = t;
							if (in_q[i])
							{
								Q.pop();
							}
						}
					}
				}
				else
				{
					gap[height[tmp.id] = min_height + 1]++;
					Q.push(queue_node(tmp.id, height[tmp.id]));
				}
				in_q[tmp.id] = true;
			}
		}
	}
	return inflow[t];
}

struct map_node
{
	int x, y;
	inline map_node(const int x_ = 0, const int y_ = 0)
	{
		x = x_;
		y = y_;
	}
};

std::queue <map_node> map_q;

inline void do_bfs(const int x, const int y)
{
	map_node tmp;
	while (!map_q.empty())
	{
		tmp = map_q.front();
		map_q.pop();
		if ((map[tmp.x - 1][tmp.y] == '.') && (d[get_node(tmp.x - 1, tmp.y)][get_node(x, y)] == 0))
		{
			d[get_node(tmp.x - 1, tmp.y)][get_node(x, y)] = d[get_node(tmp.x, tmp.y)][get_node(x, y)] + 1;
			map_q.push(map_node(tmp.x - 1, tmp.y));
		}
		if ((map[tmp.x + 1][tmp.y] == '.') && (d[get_node(tmp.x + 1, tmp.y)][get_node(x, y)] == 0))
		{
			d[get_node(tmp.x + 1, tmp.y)][get_node(x, y)] = d[get_node(tmp.x, tmp.y)][get_node(x, y)] + 1;
			map_q.push(map_node(tmp.x + 1, tmp.y));
		}
		if ((map[tmp.x][tmp.y - 1] == '.') && (d[get_node(tmp.x, tmp.y - 1)][get_node(x, y)] == 0))
		{
			d[get_node(tmp.x, tmp.y - 1)][get_node(x, y)] = d[get_node(tmp.x, tmp.y)][get_node(x, y)] + 1;
			map_q.push(map_node(tmp.x, tmp.y - 1));
		}
		if ((map[tmp.x][tmp.y + 1] == '.') && (d[get_node(tmp.x, tmp.y + 1)][get_node(x, y)] == 0))
		{
			d[get_node(tmp.x, tmp.y + 1)][get_node(x, y)] = d[get_node(tmp.x, tmp.y)][get_node(x, y)] + 1;
			map_q.push(map_node(tmp.x, tmp.y + 1));
		}
	}
}

inline void prepare_bfs(const int x, const int y)
{
	if (map[x][y] != 'D')
	{
		return;
	}
	if (x == 1)
	{
		if (map[x + 1][y] == '.')
		{
			map_q.push(map_node(x + 1, y));
			d[get_node(x + 1, y)][get_node(x, y)] = 1;
			do_bfs(x, y);
		}
	}
	else if (x == n)
	{
		if (map[x - 1][y] == '.')
		{
			map_q.push(map_node(x - 1, y));
			d[get_node(x - 1, y)][get_node(x, y)] = 1;
			do_bfs(x, y);
		}
	}
	else if (y == 1)
	{
		if (map[x][y + 1] == '.')
		{
			map_q.push(map_node(x, y + 1));
			d[get_node(x, y + 1)][get_node(x, y)] = 1;
			do_bfs(x, y);
		}
	}
	else if (y == m)
	{
		if (map[x][y - 1] == '.')
		{
			map_q.push(map_node(x, y - 1));
			d[get_node(x, y - 1)][get_node(x, y)] = 1;
			do_bfs(x, y);
		}
	}
#ifdef LOCAL_DEBUG
	for (int i = 2; i < n; i++)
	{
		for (int j = 2; j < m; j++)
		{
			printf("%d ", d[get_node(i, j)][11]);
		}
		printf("n");
	}
#endif
}

inline void bfs_init()
{
	for (int i = 2; i < n; i++)
	{
		prepare_bfs(i, 1);
		prepare_bfs(i, m);
	}
	for (int i = 2; i < m; i++)
	{
		prepare_bfs(1, i);
		prepare_bfs(n, i);
	}
}

int main()
{
#ifdef LOCAL_TIME
	long long start_time_ = clock();
#endif
#ifdef READ_FILE
	freopen("evacuate.in", "r", stdin);
#ifndef STD_DEBUG
	freopen("evacuate.out", "w", stdout);
#endif
#endif
#ifdef READ_FREAD
	fread_init();
#endif
	read(n);
	read(m);
	s = 0;
	t = n * m + 1;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			read(map[i][j]);
			if (map[i][j] == '.')
			{
				tot_p++;
				graph_in[get_node(i, j)] = true;
			}
			else if (map[i][j] == 'D')
			{
				graph_out[get_node(i, j)] = true;
			}
		}
	}
	bfs_init();
	l = 1, r = n * m;
	while (l < r)
	{
		mid = (l + r) >> 1;
#ifdef LOCAL_DEBUG
		int ret = max_flow(mid);
		printf("MAX_FLOW: %d %d %dn", mid, ret, tot_p);
		if (ret >= tot_p)
#else
		if (max_flow(mid) >= tot_p)
#endif
		{
			r = mid;
		}
		else
		{
			l = mid + 1;
		}
	}
	if (l >= n * m)
	{
		printf("impossible");
	}
	else
	{
		printf("%d", l);
	}
#ifdef LOCAL_TIME
	printf("nrun time: %lld msn", (clock() - start_time_) / 1000);
#endif
#ifdef READ_FILE
	fclose(stdin);
#ifndef STD_DEBUG
	fclose(stdout);
#endif
#endif
	return 0;
}

//ZJOI2009 holiday.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define READ_FILE
#define READ_FREAD
//#define VISUAL_STUDIO

const int MAXN = 50;
const int MAXPT = 110;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define STD_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
	fread_char = getchar();
}

inline int get_int()
{
	int ret = 0;
	while ((fread_char < '0') || (fread_char > '9'))
	{
		fread_char = getchar();
	}
	while ((fread_char >= '0') && (fread_char <= '9'))
	{
		ret = ret * 10 + fread_char - '0';
		fread_char = getchar();
	}
	return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
	a = get_int();
#else
	scanf("%d", &a);
#endif
}

struct queue_node
{
	int id, height;
	inline queue_node(const int id_ = 0, const int height_ = 0)
	{
		id = id_;
		height = height_;
	}
	inline bool operator < (const queue_node &b) const
	{
		return height < b.height;
	}
};

int cases, n;
int s, t;
int tot_at_school;
int school_student[MAXN];
int at_home[MAXN];
int k;
int graph[MAXPT][MAXPT];
int height[MAXPT], inflow[MAXPT], gap[MAXPT];
bool visit[MAXPT], in_q[MAXPT];
std::queue <int> bfs_q;
std::priority_queue <queue_node> Q;

inline void add_edge(const int u, const int v)
{
#ifdef LOCAL_DEBUG
	printf("ADDEDGE %d %dn", u, v);
#endif
	graph[u][v] = 1;
}

inline void bfs()
{
	memset(visit, false, sizeof(visit));
	memset(height, 0, sizeof(height));
	memset(gap, 0, sizeof(gap));
	gap[0] = 1;
	bfs_q.push(t);
	int tmp;
	while (!bfs_q.empty())
	{
		tmp = bfs_q.front();
		bfs_q.pop();
		for (int i = s; i < t; i++)
		{
			if ((graph[i][tmp] > 0) && (!visit[i]))
			{
				gap[height[i] = height[tmp] + 1]++;
				visit[i] = true;
				bfs_q.push(i);
			}
		}
	}
}

inline int max_flow()
{
	memset(in_q, false, sizeof(in_q));
	memset(inflow, 0, sizeof(inflow));
	in_q[s] = in_q[t] = true;
	for (int i = 1; i <= n; i++)
	{
		if (graph[s][i] > 0)
		{
			graph[i][s] = inflow[i] = graph[s][i];
			graph[s][i] = 0;
			in_q[i] = true;
			Q.push(queue_node(i, height[i]));
		}
	}
	queue_node tmp;
	int push_flow = -1;
	int min_height = -1;
	while (!Q.empty())
	{
		tmp = Q.top();
		Q.pop();
#ifdef LOCAL_DEBUG
		printf("POP ID HEIGHT INFLOW: %d %d %dn", tmp.id, tmp.height, inflow[tmp.id]);
#endif
		in_q[tmp.id] = false;
		for (int i = s + 1; (i <= t) && (inflow[tmp.id] > 0); i++)
		{
			if ((graph[tmp.id][i] > 0) && (height[tmp.id] == height[i] + 1))
			{
				push_flow = std::min(graph[tmp.id][i], inflow[tmp.id]);
				graph[tmp.id][i] -= push_flow;
				graph[i][tmp.id] += push_flow;
				inflow[tmp.id] -= push_flow;
				inflow[i] += push_flow;
				if (!in_q[i])
				{
					in_q[i] = true;
					Q.push(queue_node(i, height[i]));
				}
			}
		}
		if ((inflow[tmp.id] > 0) && (tmp.id < t))
		{
			min_height = -1;
			for (int i = s + 1; i <= t; i++)
			{
				if (graph[tmp.id][i] > 0)
				{
					if ((min_height == -1) || (min_height > height[i]))
					{
						min_height = height[i];
					}
				}
			}
			if ((min_height > -1) & (min_height < t))
			{
				gap[height[tmp.id]]--;
				if (gap[height[tmp.id]] == 0)
				{
					for (int i = s + 1; i < t; i++)
					{
						if ((height[i] >= height[tmp.id]) && (height[i] < t))
						{
							gap[height[i]]--;
							height[i] = t;
							if (in_q[i])
							{
								Q.pop();
							}
							else
							{
								in_q[i] = true;
							}
						}
					}
				}
				else
				{
					gap[height[tmp.id] = min_height + 1]++;
					in_q[tmp.id] = true;
					Q.push(queue_node(tmp.id, height[tmp.id]));
				}
			}
		}
	}
	return inflow[t];
}

int main()
{
#ifdef LOCAL_TIME
	long long start_time_ = clock();
#endif
#ifdef READ_FILE
	freopen("holiday.in", "r", stdin);
#ifndef STD_DEBUG
	freopen("holiday.out", "w", stdout);
#endif
#endif
	read(cases);
	while (cases--)
	{
		read(n);
		s = 0;
		t = 2 * n + 1;
		tot_at_school = 0;
		memset(graph, 0, sizeof(graph));
		for (int i = 1; i <= n; i++)
		{
			read(school_student[i]);
			if (school_student[i])
			{
				add_edge(n + i, t);
			}
			else
			{
				add_edge(s, i);
				tot_at_school++;
			}
		}
		for (int i = 1; i <= n; i++)
		{
			read(at_home[i]);
			if (school_student[i] && (!at_home[i]))
			{
				add_edge(s, i);
				tot_at_school++;
			}
		}
		for (int i = 1; i <= n; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				read(k);
				if (i == j)
				{
					if (school_student[i])
					{
						add_edge(i, n + i);
					}
				}
				else if (k)
				{
					if (school_student[i])
					{
						add_edge(j, n + i);
					}
					if (school_student[j])
					{
						add_edge(i, n + j);
					}
				}
			}
		}
		bfs();
#ifdef LOCAL_DEBUG
		int ret = max_flow();
		printf("%d %dn", ret, tot_at_school);
		if (ret == tot_at_school)
#else
		if (max_flow() == tot_at_school)
#endif
		{
			printf("^_^n");
		}
		else
		{
			printf("T_Tn");
		}
	}
#ifdef LOCAL_TIME
	printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
	fclose(stdin);
#ifndef STD_DEBUG
	fclose(stdout);
#endif
#endif
	return 0;
}

//SCOI2007 lizard.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<map>

//#define LOCAL
#define READ_FREAD
//#define READ_FILE
//#define VISUAL_STUDIO

const int MAXN = 20;
const int MAXPT = 2 * MAXN * MAXN + 2;
const int MAXM = 170000;

#ifdef LOCAL
#define LOCAL_DEBUG
#define LOCAL_TIME
//#define STD_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
    fread_char = getchar();
}

inline int get_int()
{
    int ret = 0;
    while ((fread_char < '0') || (fread_char > '9'))
    {
        fread_char = getchar();
    }
    while ((fread_char >= '0') && (fread_char <= '9'))
    {
        ret = ret * 10 + fread_char - '0';
        fread_char = getchar();
    }
    return ret;
}

inline char get_char()
{
    char ret;
    while ((fread_char == ' ') || (fread_char == 'n'))
    {
        fread_char = getchar();
    }
    ret = fread_char;
    fread_char = getchar();
    return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

inline void read(char &a)
{
#ifdef READ_FREAD
    a = get_char();
#else
    scanf("%c", &a);
#endif
}

struct pillar_node
{
    int x, y, d;
};

int graph[MAXPT][MAXPT];

inline void add_edge(const int u, const int v, const int d)
{
#ifdef LOCAL_DEBUG
    printf("ADD_EDGE %d %d %dn", u, v, d);
#endif
    graph[u][v] = d;
    graph[v][u] = 0;
}

struct queue_node
{
    int id, height;
    inline queue_node(const int id_ = 0, const int height_ = 0)
    {
        id = id_;
        height = height_;
    }
    inline bool operator < (const queue_node &b) const
    {
        return height < b.height;
    }
};

int r, c, d;
int tot_lizard;
pillar_node pillar[MAXM];
int tot_pillar;
int k;
char tmp_k;
char lizard_pt;
int s, t;
int gap[MAXPT];
int height[MAXPT], inflow[MAXPT];
bool in_q[MAXPT];
bool visit[MAXPT];
std::priority_queue <queue_node> Q;

inline int in_pt(const int x, const int y)
{
    return (x - 1) * c + y;
}

inline int out_pt(const int x, const int y)
{
    return r * c + (x - 1) * c + y;
}

std::queue <int> bfs_q;

inline void bfs()
{
    gap[0] = 1;
    bfs_q.push(t);
    visit[t] = true;
    int tmp;
    while (!bfs_q.empty())
    {
        tmp = bfs_q.front();
        bfs_q.pop();
        for (int i = s; i < t; i++)
        {
            if ((!visit[i]) && (graph[i][tmp] > 0))
            {
                height[i] = height[tmp] + 1;
                gap[height[i]]++;
                visit[i] = true;
                bfs_q.push(i);
            }
        }
    }
}

inline int max_flow()
{
    in_q[s] = in_q[t] = true;
    for (int i = s + 1; i < t; i++)
    {
        if (graph[s][i] > 0)
        {
            inflow[i] = graph[s][i];
            graph[i][s] = inflow[i];
            graph[s][i] = 0;
            in_q[i] = true;
            Q.push(queue_node(i, height[i]));
        }
    }
    queue_node tmp;
    int push_flow = -1;
    int min_height = -1;
    while (!Q.empty())
    {
        tmp = Q.top();
        Q.pop();
#ifdef LOCAL_DEBUG
        printf("DEBUG ID HEIGHT INFLOW: %d %d %dn", tmp.id, tmp.height, inflow[tmp.id]);
#endif
        in_q[tmp.id] = false;
        for (int i = s + 1; (i <= t) && (inflow[tmp.id] > 0); i++)
        {
            if ((graph[tmp.id][i] > 0) && (height[tmp.id] == height[i] + 1))
            {
                push_flow = std::min(inflow[tmp.id], graph[tmp.id][i]);
                inflow[tmp.id] -= push_flow;
                inflow[i] += push_flow;
                graph[tmp.id][i] -= push_flow;
                graph[i][tmp.id] += push_flow;
                if (!in_q[i])
                {
                    in_q[i] = true;
                    Q.push(queue_node(i, height[i]));
                }
            }
        }
        if (inflow[tmp.id] > 0)
        {
            min_height = -1;
            for (int i = s + 1; i <= t; i++)
            {
                if (graph[tmp.id][i] > 0)
                {
                    if ((min_height == -1) || (min_height > height[i]))
                    {
                        min_height = height[i];
                    }
                }
            }
            if ((min_height > -1) && (min_height < t))
            {
                gap[height[tmp.id]]--;
                if (gap[height[tmp.id]] == 0)
                {
                    for (int i = s + 1; i < t; i++)
                    {
                        if ((height[i] >= height[tmp.id]) && (height[i] < t))
                        {
                            gap[height[i]]--;
                            height[i] = t;
                            if (in_q[i])
                            {
                                Q.pop();
                            }
                        }
                    }
                }
                else
                {
                    gap[height[tmp.id] = min_height + 1]++;
                    in_q[tmp.id] = true;
                    Q.push(queue_node(tmp.id, height[tmp.id]));
                }
            }
        }
    }
    return inflow[t];
}

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("lizard.in", "r", stdin);
#ifndef STD_DEBUG
    freopen("lizard.out", "w", stdout);
#endif
#endif
#ifdef READ_FREAD
    fread_init();
#endif
    read(r);
    read(c);
    read(d);
    s = 0;
    t = r * c * 2 + 1;
    for (int i = 1; i <= r; i++)
    {
        for (int j = 1; j <= c; j++)
        {
            read(tmp_k);
            k = tmp_k - '0';
            if (k > 0)
            {
                pillar[tot_pillar].x = i;
                pillar[tot_pillar].y = j;
                pillar[tot_pillar++].d = k;
                add_edge(in_pt(i, j), out_pt(i, j), k);
            }
        }
    }
    for (int i = 1; i <= r; i++)
    {
        for (int j = 1; j <= c; j++)
        {
            read(lizard_pt);
            if (lizard_pt == 'L')
            {
                tot_lizard++;
                add_edge(s, in_pt(i, j), 1);
            }
        }
    }
    for (int i = 0; i < tot_pillar; i++)
    {
        if ((pillar[i].x <= d) || (pillar[i].y <= d) || (r - pillar[i].x + 1 <= d) || (c - pillar[i].y + 1 <= d))
        {
            add_edge(out_pt(pillar[i].x, pillar[i].y), t, pillar[i].d);
        }
        for (int j = 0; j < tot_pillar; j++)
        {
            if (i == j)
            {
                continue;
            }
            if ((pillar[i].x - pillar[j].x) * (pillar[i].x - pillar[j].x) + (pillar[i].y - pillar[j].y) * (pillar[i].y - pillar[j].y) <= d * d)
            {
                add_edge(out_pt(pillar[i].x, pillar[i].y), in_pt(pillar[j].x, pillar[j].y), pillar[i].d);
            }
        }
    }
    bfs();
    printf("%d", tot_lizard - max_flow());
#ifdef LOCAL_TIME
    printf("nrun time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
#ifndef STD_DEBUG
    fclose(stdout);
#endif
#endif
    return 0;
}

//JLOI2010 champion.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
#define READ_FREAD
//#define READ_FILE
//#define VISUAL_STUDIO

const int MAXN = 310;
const int MAXM = 100000;

#ifdef LOCAL
#define LOCAL_TIME
//#define LOCAL_DEBUG
//#define STD_DEBUG
//#define DATA
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
    fread_char = getchar();
}

inline int get_int()
{
    int ret = 0;
    while ((fread_char < '0') || (fread_char > '9'))
    {
        fread_char = getchar();
    }
    while ((fread_char >= '0') && (fread_char <= '9'))
    {
        ret = ret * 10 + fread_char - '0';
        fread_char = getchar();
    }
    return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

int n, m;
int k;
int s, t;
int x, y;
int map[MAXN][MAXN];

struct node_node
{
    int id, height;
    inline node_node(const int id_ = 0, const int height_ = 0)
    {
        id = id_;
        height = height_;
    }
    inline bool operator < (const node_node &b) const
    {
        return height < b.height;
    }
};

bool visit[MAXN];
int inflow[MAXN], height[MAXN];
std::priority_queue <node_node> Q;

int gap[MAXN];

inline void add_edge(const int u, const int v, const int d, const bool both_way = false)
{
    map[u][v] = d;
    map[v][u] = both_way ? d : 0;
}

inline void bfs()
{
    std::queue <int> bfs_q;
    bfs_q.push(t);
    int tmp;
    gap[0] = 1;
    while (!bfs_q.empty())
    {
        tmp = bfs_q.front();
        bfs_q.pop();
        for (int i = s; i <= t; i++)
        {
            if ((!visit[i]) && (map[i][tmp] > 0))
            {
                height[i] = height[tmp] + 1;
                gap[height[i]]++;
                visit[i] = true;
                bfs_q.push(i);
            }
        }
    }
}

inline int max_flow()
{
    memset(visit, false, sizeof(visit));
    for (int i = s + 1; i < t; i++)
    {
        if (map[s][i] > 0)
        {
            inflow[i] = map[s][i];
            map[i][s] += inflow[i];
            map[s][i] = 0;
            Q.push(node_node(i, height[i]));
            visit[i] = true;
        }
    }
    node_node tmp;
    int push_flow = -1;
    int min_height = -1;
    visit[t] = true;
    while (!Q.empty())
    {
        tmp = Q.top();
        Q.pop();
#ifdef LOCAL_DEBUG
        printf("POP ID HEIGHT INFLOW: %d %d %dn", tmp.id, tmp.height, inflow[tmp.id]);
#endif
        visit[tmp.id] = false;
        for (int i = s + 1; (i <= t) && (inflow[tmp.id] > 0); i++)
        {
            if ((height[tmp.id] == height[i] + 1) && (map[tmp.id][i] > 0))
            {
                push_flow = std::min(inflow[tmp.id], map[tmp.id][i]);
                inflow[tmp.id] -= push_flow;
                inflow[i] += push_flow;
                map[tmp.id][i] -= push_flow;
                map[i][tmp.id] += push_flow;
                if (!visit[i])
                {
                    Q.push(node_node(i, height[i]));
                    visit[i] = true;
                }
            }
        }
        min_height = -1;
        if ((inflow[tmp.id] > 0) && (tmp.id != t))
        {
            for (int i = s + 1; i <= t; i++)
            {
                if (map[tmp.id][i] > 0)
                {
                    if ((min_height == -1) || (height[i] < min_height))
                    {
                        min_height = height[i];
                    }
                }
            }
            if ((min_height != -1) && (min_height < t))
            {
                gap[height[tmp.id]]--;
                if (gap[height[tmp.id]] == 0)
                {
                    for (int i = s; i <= t; i++)
                    {
                        if ((height[i] >= height[tmp.id]) && (height[i] < t))
                        {
                            gap[height[i]]--;
                            height[i] = t;
                            if (visit[i])
                            {
                                Q.pop();
                            }
                        }
                    }
                }
                gap[height[tmp.id] = min_height + 1]++;
                Q.push(node_node(tmp.id, height[tmp.id]));
                visit[tmp.id] = true;
            }
        }
    }
    return inflow[t];
}

#ifndef DATA
int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("champion.in", "r", stdin);
#ifndef STD_DEBUG
    freopen("champion.out", "w", stdout);
#endif
#endif
    read(n);
    read(m);
    s = 1;
    t = n + 2;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &k);
        if (k == 1)
        {
            add_edge(s, i + 1, 1);
        }
        else
        {
            add_edge(i + 1, t, 1);
        }
    }
    for (int i = 0; i < m; i++)
    {
        read(x);
        read(y);
        add_edge(x + 1, y + 1, 1, true);
    }
    bfs();
    printf("%d", max_flow());
#ifdef LOCAL_TIME
    printf("nrun time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
#ifndef STD_DEBUG
    fclose(stdout);
#endif
#endif
    return 0;
}
#else
int main()
{
    int N = 300;
    int M = 44850;
    int RAND_BASE = 32;
    freopen("champion.in", "w", stdout);
    srand(RAND_BASE);
    printf("%d %dn", N, M);
    for (int i = 0; i < N; i++)
    {
        printf("%d ", rand() % 2);
    }
    printf("n");
    for (int i = 0; i < M; i++)
    {
        int x = rand() % N + 1;
        int y = rand() % N + 1;
        if (x == y)
        {
            i--;
            continue;
        }
        printf("%d %dn", x, y);
    }
    fclose(stdout);
    return 0;
}
#endif

//SCOI2014 oj.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define READ_FILE
#define READ_FREAD
//#define VISUAL_STUDIO

const int MAXM = 140000;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define STD_DEBUG
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
    fread_char = getchar();
}

inline int get_int()
{
    int ret = 0;
    while ((fread_char < '0') || (fread_char > '9'))
    {
        fread_char = getchar();
    }
    while ((fread_char >= '0') && (fread_char <= '9'))
    {
        ret = ret * 10 + fread_char - '0';
        fread_char = getchar();
    }
    return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

int n, m;
int a;
int op;
int x, y, k;
std::map <int, int> id_to_num;
std::map <int, int> num_to_id;
std::map <int, int> ::iterator tmp;
std::map <int, int> interval_to_splay;

struct splay_node
{
    int l, r;
    splay_node *l_child, *r_child, *parent;
    int size;
    inline splay_node *init()
    {
        l_child = r_child = parent = NULL;
        return this;
    }
};

splay_node recover_splay_node[MAXM];
splay_node *stack_recover_splay_node[MAXM];
int top_stack_recover_splay_node = MAXM;

inline void recover_splay_init()
{
    for (int i = 0; i < MAXM; i++)
    {
        stack_recover_splay_node[i] = recover_splay_node + i;
    }
}

inline splay_node *new_node()
{
    return stack_recover_splay_node[--top_stack_recover_splay_node]->init();
}

inline void delete_node(splay_node *del_node)
{
    stack_recover_splay_node[top_stack_recover_splay_node++] = del_node;
}

splay_node *splay_head;

inline void attach_as_l_child(splay_node *parent, splay_node *child)
{
    parent->l_child = child;
    if (child != NULL)
    {
        child->parent = parent;
    }
}

inline void attach_as_r_child(splay_node *parent, splay_node *child)
{
    parent->r_child = child;
    if (child != NULL)
    {
        child->parent = parent;
    }
}

inline int splay_size(splay_node *query_node)
{
    if (query_node == NULL)
    {
        return 0;
    }
    return query_node->size;
}

inline void splay_update_size(splay_node *update_node)
{
    update_node->size = splay_size(update_node->l_child) + splay_size(update_node->r_child) + update_node->r - update_node->l + 1;
}

inline void splay_zig(splay_node *axis)
{
    splay_node *left_child = axis->l_child;
    splay_node *parent = axis->parent;
    attach_as_l_child(axis, left_child->r_child);
    attach_as_r_child(left_child, axis);
    left_child->parent = parent;
    if (parent != NULL)
    {
        if (parent->l_child == axis)
        {
            parent->l_child = left_child;
        }
        else
        {
            parent->r_child = left_child;
        }
    }
    left_child->size = axis->size;
    splay_update_size(axis);
}

inline void splay_zag(splay_node *axis)
{
    splay_node *right_child = axis->r_child;
    splay_node *parent = axis->parent;
    attach_as_r_child(axis, right_child->l_child);
    attach_as_l_child(right_child, axis);
    right_child->parent = parent;
    if (parent != NULL)
    {
        if (parent->l_child == axis)
        {
            parent->l_child = right_child;
        }
        else
        {
            parent->r_child = right_child;
        }
    }
    right_child->size = axis->size;
    splay_update_size(axis);
}

inline splay_node *splay_route(splay_node *v)
{
    splay_node *parent, *grand_parent;
    while (((parent = v->parent) != NULL) && ((grand_parent = parent->parent) != NULL))
    {
        if (parent->l_child == v)
        {
            if (grand_parent->l_child == parent)
            {
                splay_zig(grand_parent);
                splay_zig(parent);
            }
            else
            {
                splay_zig(parent);
                splay_zag(grand_parent);
            }
        }
        else
        {
            if (grand_parent->r_child == parent)
            {
                splay_zag(grand_parent);
                splay_zag(parent);
            }
            else
            {
                splay_zag(parent);
                splay_zig(grand_parent);
            }
        }
    }
    if ((parent = v->parent) != NULL)
    {
        if (parent->l_child == v)
        {
            splay_zig(parent);
        }
        else
        {
            splay_zag(parent);
        }
    }
    return v;
}

inline splay_node *splay_bottom(splay_node *v = splay_head)
{
    while (v != NULL)
    {
        if (v->r_child == NULL)
        {
            return v;
        }
        else
        {
            v = v->r_child;
        }
    }
    return NULL;
}

inline splay_node *splay_top(splay_node *v = splay_head)
{
    while (v != NULL)
    {
        if (v->l_child == NULL)
        {
            return v;
        }
        else
        {
            v = v->l_child;
        }
    }
    return NULL;
}

inline void splay_init()
{
    splay_head = new_node();
    splay_head->l = 1;
    splay_head->r = n;
    splay_head->size = splay_head->r - splay_head->l + 1;
    interval_to_splay.insert(std::pair <int, int>(n, splay_head - recover_splay_node));
}

inline int get_num_by_id(const int id)
{
    tmp = id_to_num.find(id);
    if (tmp == id_to_num.end())
    {
        return id;
    }
    return tmp->second;
}

inline int get_id_by_num(const int num)
{
    tmp = num_to_id.find(num);
    if (tmp == num_to_id.end())
    {
        return num;
    }
    return tmp->second;
}

inline splay_node *get_splay_by_num(const int num)
{
    tmp = interval_to_splay.lower_bound(num);
    return recover_splay_node + tmp->second;
}

inline int splay_get_rank(const int id)
{
    int num = get_num_by_id(id);
    splay_head = splay_route(get_splay_by_num(num));
    return splay_size(splay_head->l_child) + num - splay_head->l + 1;
}

inline void map_change(int x, const int y)
{
    tmp = id_to_num.find(x);
    if (tmp != id_to_num.end())
    {
        x = tmp->second;
        id_to_num.erase(tmp);
        tmp = num_to_id.find(x);
        num_to_id.erase(tmp);
    }
    id_to_num.insert(std::pair <int, int>(y, x));
    num_to_id.insert(std::pair <int, int>(x, y));
}

inline int splay_move_to_top(const int id)
{
    int num = get_num_by_id(id);
    tmp = interval_to_splay.lower_bound(num);
    splay_head = splay_route(recover_splay_node + tmp->second);
    int ret = splay_size(splay_head->l_child) + num - splay_head->l + 1;
    splay_node *move_node = NULL;
    if (splay_head->l == splay_head->r)
    {
        move_node = splay_head;
        if (splay_head->l_child == NULL)
        {
            splay_head->r_child->parent = NULL;
            splay_head = splay_head->r_child;
        }
        else
        {
            splay_head->l_child->parent = NULL;
            splay_node *new_root = splay_route(splay_bottom(splay_head->l_child));
            attach_as_r_child(new_root, splay_head->r_child);
            splay_update_size(new_root);
            splay_head = new_root;
        }
        move_node->l_child = move_node->r_child = NULL;
        move_node->size = 1;
    }
    else if (splay_head->l == num)
    {
        move_node = new_node();
        move_node->l = move_node->r = num;
        move_node->size = 1;
        interval_to_splay.insert(std::pair <int, int>(num, move_node - recover_splay_node));
        splay_head->l = num + 1;
        splay_head->size--;
    }
    else if (splay_head->r == num)
    {
        move_node = new_node();
        move_node->l = move_node->r = num;
        move_node->size = 1;
        interval_to_splay.erase(tmp);
        interval_to_splay.insert(std::pair <int, int>(num - 1, splay_head - recover_splay_node));
        interval_to_splay.insert(std::pair <int, int>(num, move_node - recover_splay_node));
        splay_head->r = num - 1;
        splay_head->size--;
    }
    else
    {
        move_node = new_node();
        move_node->l = move_node->r = num;
        move_node->size = 1;
        interval_to_splay.erase(tmp);
        interval_to_splay.insert(std::pair <int, int>(num, move_node - recover_splay_node));
        splay_node *splite_right = new_node();
        splite_right->l = num + 1;
        splite_right->r = splay_head->r;
        interval_to_splay.insert(std::pair <int, int>(splite_right->r, splite_right - recover_splay_node));
        interval_to_splay.insert(std::pair <int, int>(num - 1, splay_head - recover_splay_node));
        splay_head->r = num - 1;
        splay_head->size--;
        attach_as_r_child(splite_right, splay_head->r_child);
        attach_as_r_child(splay_head, splite_right);
        splay_update_size(splite_right);
    }
    splay_head = splay_route(splay_top());
    attach_as_l_child(splay_head, move_node);
    splay_head->size++;
    return ret;
}

inline int splay_move_to_bottom(const int id)
{
    int num = get_num_by_id(id);
    tmp = interval_to_splay.lower_bound(num);
    splay_head = splay_route(recover_splay_node + tmp->second);
    int ret = splay_size(splay_head->l_child) + num - splay_head->l + 1;
    splay_node *move_node = NULL;
    if (splay_head->l == splay_head->r)
    {
        move_node = splay_head;
        if (splay_head->l_child == NULL)
        {
            splay_head->r_child->parent = NULL;
            splay_head = splay_head->r_child;
        }
        else
        {
            splay_head->l_child->parent = NULL;
            splay_node *new_root = splay_route(splay_bottom(splay_head->l_child));
            attach_as_r_child(new_root, splay_head->r_child);
            splay_update_size(new_root);
            splay_head = new_root;
        }
        move_node->l_child = move_node->r_child = NULL;
    }
    else if (splay_head->l == num)
    {
        move_node = new_node();
        move_node->l = move_node->r = num;
        move_node->size = 1;
        interval_to_splay.insert(std::pair <int, int>(num, move_node - recover_splay_node));
        splay_head->l = num + 1;
        splay_head->size--;
    }
    else if (splay_head->r == num)
    {
        move_node = new_node();
        move_node->l = move_node->r = num;
        move_node->size = 1;
        interval_to_splay.erase(tmp);
        interval_to_splay.insert(std::pair <int, int>(num - 1, splay_head - recover_splay_node));
        interval_to_splay.insert(std::pair <int, int>(num, move_node - recover_splay_node));
        splay_head->r = num - 1;
        splay_head->size--;
    }
    else
    {
        move_node = new_node();
        move_node->l = move_node->r = num;
        move_node->size = 1;
        interval_to_splay.erase(tmp);
        interval_to_splay.insert(std::pair <int, int>(num, move_node - recover_splay_node));
        splay_node *splite_right = new_node();
        splite_right->l = num + 1;
        splite_right->r = splay_head->r;
        interval_to_splay.insert(std::pair <int, int>(splite_right->r, splite_right - recover_splay_node));
        interval_to_splay.insert(std::pair <int, int>(num - 1, splay_head - recover_splay_node));
        splay_head->r = num - 1;
        splay_head->size--;
        attach_as_r_child(splite_right, splay_head->r_child);
        attach_as_r_child(splay_head, splite_right);
        splay_update_size(splite_right);
    }
    splay_head = splay_route(splay_bottom());
    attach_as_r_child(splay_head, move_node);
    splay_head->size++;
    return ret;
}

inline int splay_get_num(int k)
{
    splay_node *v = splay_head;
    int left_length;
    while (v != NULL)
    {
        left_length = splay_size(v->l_child);
        if (left_length < k)
        {
            if (left_length + v->r - v->l + 1 >= k)
            {
                return get_id_by_num(v->l + k - left_length - 1);
            }
            else
            {
                k -= left_length + v->r - v->l + 1;
                v = v->r_child;
            }
        }
        else
        {
            v = v->l_child;
        }
    }
    return -1;
}

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("oj.in", "r", stdin);
#ifndef STD_DEBUG
    freopen("oj.out", "w", stdout);
#endif
#endif
    fread_init();
    recover_splay_init();
    read(n);
    read(m);
    splay_init();
    for (int i = 0; i < m; i++)
    {
#ifdef LOCAL_DEBUG
        if (i == 5)
        {
            printf("");
        }
#endif
        read(op);
        if (op == 1)
        {
            read(x);
            read(y);
            x -= a;
            y -= a;
            map_change(x, y);
            printf("%dn", a = splay_get_rank(y));
        }
        else if (op == 2)
        {
            read(x);
            x -= a;
            printf("%dn", a = splay_move_to_top(x));
        }
        else if (op == 3)
        {
            read(x);
            x -= a;
            printf("%dn", a = splay_move_to_bottom(x));
        }
        else if (op == 4)
        {
            read(k);
            k -= a;
            printf("%dn", a = splay_get_num(k));
        }
    }
#ifdef LOCAL_TIME
    printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
#ifndef STD_DEBUG
    fclose(stdout);
#endif
#endif
    return 0;
}

//BEIJING2006 animal.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define VISUAL_STUDIO
#define READ_FREAD
//#define READ_FILE

const int MAXN = 1010;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
    fread_char = getchar();
}

inline int get_int()
{
    int ret = 0;
    while ((fread_char < '0') || (fread_char > '9'))
    {
        fread_char = getchar();
    }
    while ((fread_char >= '0') && (fread_char <= '9'))
    {
        ret = ret * 10 + fread_char - '0';
        fread_char = getchar();
    }
    return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

struct queue_node
{
    int d;
    int type; //1: row, 2: list, 3:slant
    int x, y;
    inline queue_node()
    {

    }
    inline queue_node(const int d_, const int type_, const int x_, const int y_)
    {
        d = d_;
        type = type_;
        x = x_;
        y = y_;
    }
    inline bool operator < (const queue_node &b) const
    {
        if (d == -1)
        {
            return b.d == -1 ? false : true;
        }
        else if (b.d == -1)
        {
            return false;
        }
        return d > b.d;
    }
};

int n, m;
int row[MAXN][MAXN], list[MAXN][MAXN], slant[MAXN][MAXN];
int d_row[MAXN][MAXN], d_list[MAXN][MAXN], d_slant[MAXN][MAXN];
bool visit_row[MAXN][MAXN], visit_list[MAXN][MAXN], visit_slant[MAXN][MAXN];
std::priority_queue <queue_node> Q;

inline int min(const int a, const int b)
{
    if (a == -1)
    {
        return b;
    }
    if (b == -1)
    {
        return a;
    }
    return a < b ? a : b;
}

inline int dijkstra()
{
    memset(d_row, -1, sizeof(d_row));
    memset(d_list, -1, sizeof(d_list));
    memset(d_slant, -1, sizeof(d_slant));
    for (int i = 1; i < n; i++)
    {
        d_list[i][1] = list[i][1];
        Q.push(queue_node(d_list[1][i], 2, i, 1));
    }
    for (int i = 1; i < m; i++)
    {
        d_row[n][i] = row[n][i];
        Q.push(queue_node(d_row[n][i], 1, n, i));
    }
    queue_node tmp;
    while (!Q.empty())
    {
        tmp = Q.top();
        Q.pop();
        if (tmp.type == 1)
        {
            if (visit_row[tmp.x][tmp.y])
            {
                continue;
            }
            visit_row[tmp.x][tmp.y] = true;
            if (tmp.x > 1)
            {
                if ((d_slant[tmp.x - 1][tmp.y] == -1) || (tmp.d + slant[tmp.x - 1][tmp.y] < d_slant[tmp.x - 1][tmp.y]))
                {
                    d_slant[tmp.x - 1][tmp.y] = tmp.d + slant[tmp.x - 1][tmp.y];
                    Q.push(queue_node(d_slant[tmp.x - 1][tmp.y], 3, tmp.x - 1, tmp.y));
                    visit_slant[tmp.x - 1][tmp.y] = false;
                }
                if ((d_list[tmp.x - 1][tmp.y] == -1) || (tmp.d + list[tmp.x - 1][tmp.y] < d_list[tmp.x - 1][tmp.y]))
                {
                    d_list[tmp.x - 1][tmp.y] = tmp.d + list[tmp.x - 1][tmp.y];
                    Q.push(queue_node(d_list[tmp.x - 1][tmp.y], 2, tmp.x - 1, tmp.y));
                    visit_list[tmp.x - 1][tmp.y] = false;
                }
            }
            if (tmp.x < n)
            {
                if ((d_list[tmp.x][tmp.y + 1] == -1) || (tmp.d + list[tmp.x][tmp.y + 1] < d_list[tmp.x][tmp.y + 1]))
                {
                    d_list[tmp.x][tmp.y + 1] = tmp.d + list[tmp.x][tmp.y + 1];
                    Q.push(queue_node(d_list[tmp.x][tmp.y + 1], 2, tmp.x, tmp.y + 1));
                    visit_list[tmp.x][tmp.y + 1] = false;
                }
                if ((d_slant[tmp.x][tmp.y] == -1) || (tmp.d + slant[tmp.x][tmp.y] < d_slant[tmp.x][tmp.y]))
                {
                    d_slant[tmp.x][tmp.y] = tmp.d + slant[tmp.x][tmp.y];
                    Q.push(queue_node(d_slant[tmp.x][tmp.y], 3, tmp.x, tmp.y));
                    visit_slant[tmp.x][tmp.y] = false;
                }
            }
        }
        else if (tmp.type == 2)
        {
            if (visit_list[tmp.x][tmp.y])
            {
                continue;
            }
            visit_list[tmp.x][tmp.y] = true;
            if (tmp.y > 1)
            {
                if ((d_row[tmp.x][tmp.y - 1] == -1) || (tmp.d + row[tmp.x][tmp.y - 1] < d_row[tmp.x][tmp.y - 1]))
                {
                    d_row[tmp.x][tmp.y - 1] = tmp.d + row[tmp.x][tmp.y - 1];
                    Q.push(queue_node(d_row[tmp.x][tmp.y - 1], 1, tmp.x, tmp.y - 1));
                    visit_row[tmp.x][tmp.y - 1] = false;
                }
                if ((d_slant[tmp.x][tmp.y - 1] == -1) || (tmp.d + slant[tmp.x][tmp.y - 1] < d_slant[tmp.x][tmp.y - 1]))
                {
                    d_slant[tmp.x][tmp.y - 1] = tmp.d + slant[tmp.x][tmp.y - 1];
                    Q.push(queue_node(d_slant[tmp.x][tmp.y - 1], 3, tmp.x, tmp.y - 1));
                    visit_slant[tmp.x][tmp.y - 1] = false;
                }
            }
            if (tmp.y < m)
            {
                if ((d_slant[tmp.x][tmp.y] == -1) || (tmp.d + slant[tmp.x][tmp.y] < d_slant[tmp.x][tmp.y]))
                {
                    d_slant[tmp.x][tmp.y] = tmp.d + slant[tmp.x][tmp.y];
                    Q.push(queue_node(d_slant[tmp.x][tmp.y], 3, tmp.x, tmp.y));
                    visit_slant[tmp.x][tmp.y] = false;
                }
                if ((d_row[tmp.x + 1][tmp.y] == -1) || (tmp.d + row[tmp.x + 1][tmp.y] < d_row[tmp.x + 1][tmp.y]))
                {
                    d_row[tmp.x + 1][tmp.y] = tmp.d + row[tmp.x + 1][tmp.y];
                    Q.push(queue_node(d_row[tmp.x + 1][tmp.y], 1, tmp.x + 1, tmp.y));
                    visit_row[tmp.x + 1][tmp.y] = false;
                }
            }
        }
        else if (tmp.type == 3)
        {
            if (visit_slant[tmp.x][tmp.y])
            {
                continue;
            }
            visit_slant[tmp.x][tmp.y] = true;
            if ((d_row[tmp.x][tmp.y] == -1) || (tmp.d + row[tmp.x][tmp.y] < d_row[tmp.x][tmp.y]))
            {
                d_row[tmp.x][tmp.y] = tmp.d + row[tmp.x][tmp.y];
                Q.push(queue_node(d_row[tmp.x][tmp.y], 1, tmp.x, tmp.y));
                visit_row[tmp.x][tmp.y] = false;
            }
            if ((d_row[tmp.x + 1][tmp.y] == -1) || (tmp.d + row[tmp.x + 1][tmp.y] < d_row[tmp.x + 1][tmp.y]))
            {
                d_row[tmp.x + 1][tmp.y] = tmp.d + row[tmp.x + 1][tmp.y];
                Q.push(queue_node(d_row[tmp.x + 1][tmp.y], 1, tmp.x + 1, tmp.y));
                visit_row[tmp.x + 1][tmp.y] = false;
            }
            if ((d_list[tmp.x][tmp.y] == -1) || (tmp.d + list[tmp.x][tmp.y] < d_list[tmp.x][tmp.y]))
            {
                d_list[tmp.x][tmp.y] = tmp.d + list[tmp.x][tmp.y];
                Q.push(queue_node(d_list[tmp.x][tmp.y], 2, tmp.x, tmp.y));
                visit_list[tmp.x][tmp.y] = false;
            }
            if ((d_list[tmp.x][tmp.y + 1] == -1) || (tmp.d + list[tmp.x][tmp.y + 1] < d_row[tmp.x][tmp.y + 1]))
            {
                d_list[tmp.x][tmp.y + 1] = tmp.d + list[tmp.x][tmp.y + 1];
                Q.push(queue_node(d_list[tmp.x][tmp.y + 1], 2, tmp.x, tmp.y + 1));
                visit_list[tmp.x][tmp.y + 1] = false;
            }
        }
    }
    int min_num = -1;
    for (int i = 1; i < m; i++)
    {
        min_num = min(min_num, d_row[1][i]);
    }
    for (int i = 1; i <= n; i++)
    {
        min_num = min(min_num, d_list[i][m]);
    }
    return min_num;
}

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("animal.in", "r", stdin);
    freopen("animal.out", "w", stdout);
#endif
    read(n);
    read(m);
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < m; j++)
        {
            read(row[i][j]);
        }
    }
    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            read(list[i][j]);
        }
    }
    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j < m; j++)
        {
            read(slant[i][j]);
        }
    }
    printf("%d", dijkstra());
#ifdef LOCAL_TIME
    printf("nrun time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

//ZJU 2112.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<map>

//#define LOCAL
//#define READ_FILE
#define READ_FREAD
//#define VISUAL_STUDIO

const int MAXN = 10010;
const int MAXTMP = 100;
const int MAXTREE = 600000;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define STD_DEBUG
//#define LOCAL_SIMP
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
    fread_char = getchar();
}

inline int get_int()
{
    int ret = 0;
    while ((fread_char < '0') || (fread_char > '9'))
    {
        fread_char = getchar();
    }
    while ((fread_char >= '0') && (fread_char <= '9'))
    {
        ret = ret * 10 + fread_char - '0';
        fread_char = getchar();
    }
    return ret;
}

inline char get_char()
{
    while ((fread_char == ' ') || (fread_char == 'n'))
    {
        fread_char = getchar();
    }
    char ret = fread_char;
    fread_char = getchar();
    return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

inline void read(char &a)
{
#ifdef READ_FREAD
    a = get_char();
#else
    scanf("%c", &a);
#endif
}

struct discre_node
{
    int val, id;
    inline bool operator < (const discre_node &b) const
    {
        return val < b.val;
    }
};

struct tree_node
{
    int tot;
    tree_node *l_child, *r_child;
    inline tree_node *init()
    {
        l_child = r_child = 0;
        return this;
    }
};

tree_node recover_tree_node[MAXTREE];
tree_node *stack_recover_tree_node[MAXTREE];
int top_stack_recover_tree_node = MAXTREE;

inline void init_recover_tree_node()
{
    for (int i = 0; i < MAXTREE; i++)
    {
        stack_recover_tree_node[i] = recover_tree_node + i;
    }
}

inline tree_node *new_node()
{
    return stack_recover_tree_node[--top_stack_recover_tree_node]->init();
}

inline void delete_node(tree_node *del_node)
{
    stack_recover_tree_node[top_stack_recover_tree_node++] = del_node;
}

int n, m;
discre_node discre_tmp[2 * MAXN];
int tot_discre;
int discre_to_num[2 * MAXN];
int max_discre;
char op_string;
int discre[MAXN];
int op[MAXN], op_i[MAXN], op_j[MAXN], op_k[MAXN];
tree_node *interval[MAXN];

inline void tree_insert(int root, const int val)
{
    tree_node *tmp = interval[root];
    tree_node **last_tmp = interval + root;
    int l = 1, r = max_discre, mid;
    while (l < r)
    {
        if (tmp == NULL)
        {
            *last_tmp = tmp = new_node();
            tmp->tot = 1;
        }
        else
        {
            tmp->tot++;
        }
        mid = (l + r) >> 1;
        if (val <= mid)
        {
            last_tmp = &tmp->l_child;
            tmp = tmp->l_child;
            r = mid;
        }
        else
        {
            last_tmp = &tmp->r_child;
            tmp = tmp->r_child;
            l = mid + 1;
        }
    }
    if (tmp == NULL)
    {
        *last_tmp = tmp = new_node();
        tmp->tot = 1;
    }
    else
    {
        tmp->tot++;
    }
}

inline void tree_delete(int root, const int val)
{
    tree_node *tmp = interval[root];
    if (tmp == NULL)
    {
        return;
    }
    tree_node **last_tmp = interval + root;
    int l = 1, r = max_discre, mid;
    while (l < r)
    {
        tmp->tot--;
        if (tmp->tot == 0)
        {
            delete_node(tmp);
            *last_tmp = NULL;
        }
        mid = (l + r) >> 1;
        if (val <= mid)
        {
            last_tmp = &tmp->l_child;
            tmp = tmp->l_child;
            r = mid;
        }
        else
        {
            last_tmp = &tmp->r_child;
            tmp = tmp->r_child;
            l = mid + 1;
        } //我知道这样写不好。。但是不管了
    }
    tmp->tot--;
    if (tmp->tot == 0)
    {
        delete_node(tmp);
        *last_tmp = NULL;
    }
}

inline int tree_left_size(tree_node *query_node)
{
    if (query_node == NULL)
    {
        return 0;
    }
    if (query_node->l_child == NULL)
    {
        return 0;
    }
    return query_node->l_child->tot;
}

inline int lowerbit(const int x)
{
    return x & (-x);
}

inline void interval_insert(int l, const int val)
{
    while (l <= n)
    {
        tree_insert(l, val);
        l += lowerbit(l);
    }
}

inline void interval_delete(int l, const int val)
{
    while (l <= n)
    {
        tree_delete(l, val);
        l += lowerbit(l);
    }
}

tree_node *tmp_add[MAXTMP];
int tot_tmp_add;
tree_node *tmp_minus[MAXTMP];
int tot_tmp_minus;

inline int interval_query(int l, int r, const int k)
{
    tot_tmp_add = tot_tmp_minus = 0;
    while (r > 0)
    {
        tmp_add[tot_tmp_add++] = interval[r];
        r -= lowerbit(r);
    }
    l--;
    while (l > 0)
    {
        tmp_minus[tot_tmp_minus++] = interval[l];
        l -= lowerbit(l);
    }
    int binary_l = 1, binary_r = max_discre, mid, tot_left;
    int tot_length = 0;
    while (binary_l < binary_r)
    {
        mid = (binary_l + binary_r) >> 1;
        tot_left = 0;
        for (int i = 0; i < tot_tmp_add; i++)
        {
            tot_left += tree_left_size(tmp_add[i]);
        }
        for (int i = 0; i < tot_tmp_minus; i++)
        {
            tot_left -= tree_left_size(tmp_minus[i]);
        }
        if (tot_length + tot_left >= k)
        {
            for (int i = 0; i < tot_tmp_minus; i++)
            {
                if (tmp_minus[i] != NULL)
                {
                    tmp_minus[i] = tmp_minus[i]->l_child;
                }
            }
            for (int i = 0; i < tot_tmp_add; i++)
            {
                if (tmp_add[i] != NULL)
                {
                    tmp_add[i] = tmp_add[i]->l_child;
                }
            }
            binary_r = mid;
        }
        else
        {
            for (int i = 0; i < tot_tmp_minus; i++)
            {
                if (tmp_minus[i] != NULL)
                {
                    tmp_minus[i] = tmp_minus[i]->r_child;
                }
            }
            for (int i = 0; i < tot_tmp_add; i++)
            {
                if (tmp_add[i] != NULL)
                {
                    tmp_add[i] = tmp_add[i]->r_child;
                }
            }
            binary_l = mid + 1;
            tot_length += tot_left;
        }
    }
    return binary_l;
}

#ifndef LOCAL_SIMP
int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("1901.in", "r", stdin);
#ifndef STD_DEBUG
    freopen("1901.out", "w", stdout);
#endif
#endif
#ifdef READ_FREAD
    fread_init();
#endif
    init_recover_tree_node();
    read(n);
    read(m);
    for (int i = 0; i < n; i++)
    {
        read(discre_tmp[i].val);
        discre_tmp[i].id = i;
    }
    tot_discre = n;
    for (int i = 0; i < m; i++)
    {
        read(op_string);
        if (op_string == 'Q')
        {
            op[i] = 1;
            read(op_i[i]);
            read(op_j[i]);
            read(op_k[i]);
        }
        else
        {
            op[i] = 2;
            read(op_i[i]);
            read(discre_tmp[tot_discre].val);
            discre_tmp[tot_discre++].id = n + i;
        }
    }
    std::sort(discre_tmp, discre_tmp + tot_discre);
    max_discre = 0;
    for (int i = 0; i < tot_discre; i++)
    {
        if ((i == 0) || (discre_tmp[i - 1] < discre_tmp[i]))
        {
            discre_to_num[++max_discre] = discre_tmp[i].val;
        }
        if (discre_tmp[i].id < n)
        {
            discre[discre_tmp[i].id] = max_discre;
        }
        else
        {
            op_k[discre_tmp[i].id - n] = max_discre;
        }
    }
    for (int i = 0; i < n; i++)
    {
        interval_insert(i + 1, discre[i]);
    }
    for (int i = 0; i < m; i++)
    {
#ifdef LOCAL_DEBUG
        if (i == 6)
        {
            printf("");
        }
#endif
        if (op[i] == 1)
        {
            printf("%dn", discre_to_num[interval_query(op_i[i], op_j[i], op_k[i])]);
        }
        else if (op[i] == 2)
        {
            interval_delete(op_i[i], discre[op_i[i] - 1]);
            interval_insert(op_i[i], op_k[i]);
            discre[op_i[i] - 1] = op_k[i];
        }
    }
#ifdef LOCAL_TIME
    printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
#ifndef STD_DEBUG
    fclose(stdout);
#endif
#endif
    return 0;
}
#else
int a[MAXN];
int sort_tmp[MAXN];
//int op[MAXN], op_i[MAXN], op_j[MAXN], op_k[MAXN];
int main()
{
    const int N = 5;
    const int M = 10;
    const int RAND_BASE = 234;
    freopen("1901.in", "w", stdout);
    srand(RAND_BASE);
    printf("%d %dn", N, M);
    for (int i = 0; i < N; i++)
    {
        printf("%d ", a[i] = rand());
    }
    printf("n");
    for (int i = 0; i < M; i++)
    {
        op[i] = rand() % 2;
        if (op[i] == 0)
        {
            printf("Q ");
            op_i[i] = rand() % N + 1;
            op_j[i] = op_i[i] + rand() % (N - op_i[i] + 1);
            op_k[i] = rand() % (op_j[i] - op_i[i] + 1) + 1;
            printf("%d %d %dn", op_i[i], op_j[i], op_k[i]);
        }
        else if (op[i] == 1)
        {
            printf("C ");
            op_i[i] = rand() % N + 1;
            op_k[i] = rand();
            printf("%d %dn", op_i[i], op_k[i]);
        }
    }
    fclose(stdout);
    freopen("1901std.out", "w", stdout);
    for (int i = 0; i < M; i++)
    {
        if (op[i] == 1)
        {
            a[op_i[i] - 1] = op_k[i];
        }
        else if (op[i] == 0)
        {
            memcpy(sort_tmp, a + op_i[i] - 1, (op_j[i] - op_i[i] + 1) * sizeof(int));
            std::sort(sort_tmp, sort_tmp + op_j[i] - op_i[i] + 1);
            printf("%dn", sort_tmp[op_k[i] - 1]);
        }
    }
    fclose(stdout);
}
#endif

//ZJU 2112.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<set>
#include<map>

//#define LOCAL
//#define READ_FILE
#define READ_FREAD
//#define VISUAL_STUDIO

const int MAXN = 50010;
const int MAXM = 10000;
const int MAXTMP = 100;
const int MAXTREE = 3500000;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define STD_DEBUG
//#define LOCAL_SIMP
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
	fread_char = getchar();
}

inline int get_int()
{
	int ret = 0;
	while ((fread_char < '0') || (fread_char > '9'))
	{
		fread_char = getchar();
	}
	while ((fread_char >= '0') && (fread_char <= '9'))
	{
		ret = ret * 10 + fread_char - '0';
		fread_char = getchar();
	}
	return ret;
}

inline char get_char()
{
	while ((fread_char == ' ') || (fread_char == 'n'))
	{
		fread_char = getchar();
	}
	char ret = fread_char;
	fread_char = getchar();
	return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
	a = get_int();
#else
	scanf("%d", &a);
#endif
}

inline void read(char &a)
{
#ifdef READ_FREAD
	a = get_char();
#else
	scanf("%c", &a);
#endif
}

struct discre_node
{
	int val, id;
	inline bool operator < (const discre_node &b) const
	{
		return val < b.val;
	}
};

struct tree_node
{
	int tot;
	tree_node *l_child, *r_child;
	inline tree_node *init()
	{
		l_child = r_child = 0;
		return this;
	}
};

tree_node recover_tree_node[MAXTREE];
tree_node *stack_recover_tree_node[MAXTREE];
int top_stack_recover_tree_node = MAXTREE;

inline void init_recover_tree_node()
{
	for (int i = 0; i < MAXTREE; i++)
	{
		stack_recover_tree_node[i] = recover_tree_node + i;
	}
}

inline tree_node *new_node()
{
	return stack_recover_tree_node[--top_stack_recover_tree_node]->init();
}

inline void delete_node(tree_node *del_node)
{
	stack_recover_tree_node[top_stack_recover_tree_node++] = del_node;
}

int n, m;
discre_node discre_tmp[MAXN + MAXM];
int tot_discre;
int discre_to_num[MAXN + MAXM];
int max_discre;
char op_string;
int discre[MAXN];
int cases;
int op[MAXN], op_i[MAXM], op_j[MAXM], op_k[MAXM];
tree_node *interval[MAXN];

inline void tree_insert(int root, const int val)
{
	tree_node *tmp = interval[root];
	tree_node **last_tmp = interval + root;
	int l = 1, r = max_discre, mid;
	while (l < r)
	{
		if (tmp == NULL)
		{
			*last_tmp = tmp = new_node();
			tmp->tot = 1;
		}
		else
		{
			tmp->tot++;
		}
		mid = (l + r) >> 1;
		if (val <= mid)
		{
			last_tmp = &tmp->l_child;
			tmp = tmp->l_child;
			r = mid;
		}
		else
		{
			last_tmp = &tmp->r_child;
			tmp = tmp->r_child;
			l = mid + 1;
		}
	}
	if (tmp == NULL)
	{
		*last_tmp = tmp = new_node();
		tmp->tot = 1;
	}
	else
	{
		tmp->tot++;
	}
}

inline void tree_delete(int root, const int val)
{
	tree_node *tmp = interval[root];
	if (tmp == NULL)
	{
		return;
	}
	tree_node **last_tmp = interval + root;
	int l = 1, r = max_discre, mid;
	while (l < r)
	{
		tmp->tot--;
		if (tmp->tot == 0)
		{
			delete_node(tmp);
			*last_tmp = NULL;
		}
		mid = (l + r) >> 1;
		if (val <= mid)
		{
			last_tmp = &tmp->l_child;
			tmp = tmp->l_child;
			r = mid;
		}
		else
		{
			last_tmp = &tmp->r_child;
			tmp = tmp->r_child;
			l = mid + 1;
		} //我知道这样写不好。。但是不管了
	}
	if (tmp != NULL)
	{
		tmp->tot--;
		if (tmp->tot == 0)
		{
			delete_node(tmp);
			*last_tmp = NULL;
		}
	}
}

inline int tree_left_size(tree_node *query_node)
{
	if (query_node == NULL)
	{
		return 0;
	}
	if (query_node->l_child == NULL)
	{
		return 0;
	}
	return query_node->l_child->tot;
}

inline int lowerbit(const int x)
{
	return x & (-x);
}

inline void interval_insert(int l, const int val)
{
	while (l <= n)
	{
		tree_insert(l, val);
		l += lowerbit(l);
	}
}

inline void interval_delete(int l, const int val)
{
	while (l <= n)
	{
		tree_delete(l, val);
		l += lowerbit(l);
	}
}

tree_node *tmp_add[MAXTMP];
int tot_tmp_add;
tree_node *tmp_minus[MAXTMP];
int tot_tmp_minus;

inline int interval_query(int l, int r, const int k)
{
	tot_tmp_add = tot_tmp_minus = 0;
	while (r > 0)
	{
		tmp_add[tot_tmp_add++] = interval[r];
		r -= lowerbit(r);
	}
	l--;
	while (l > 0)
	{
		tmp_minus[tot_tmp_minus++] = interval[l];
		l -= lowerbit(l);
	}
	int binary_l = 1, binary_r = max_discre, mid, tot_left;
	int tot_length = 0;
	while (binary_l < binary_r)
	{
		mid = (binary_l + binary_r) >> 1;
		tot_left = 0;
		for (int i = 0; i < tot_tmp_add; i++)
		{
			tot_left += tree_left_size(tmp_add[i]);
		}
		for (int i = 0; i < tot_tmp_minus; i++)
		{
			tot_left -= tree_left_size(tmp_minus[i]);
		}
		if (tot_length + tot_left >= k)
		{
			for (int i = 0; i < tot_tmp_minus; i++)
			{
				if (tmp_minus[i] != NULL)
				{
					tmp_minus[i] = tmp_minus[i]->l_child;
				}
			}
			for (int i = 0; i < tot_tmp_add; i++)
			{
				if (tmp_add[i] != NULL)
				{
					tmp_add[i] = tmp_add[i]->l_child;
				}
			}
			binary_r = mid;
		}
		else
		{
			for (int i = 0; i < tot_tmp_minus; i++)
			{
				if (tmp_minus[i] != NULL)
				{
					tmp_minus[i] = tmp_minus[i]->r_child;
				}
			}
			for (int i = 0; i < tot_tmp_add; i++)
			{
				if (tmp_add[i] != NULL)
				{
					tmp_add[i] = tmp_add[i]->r_child;
				}
			}
			binary_l = mid + 1;
			tot_length += tot_left;
		}
	}
	return binary_l;
}

#ifndef LOCAL_SIMP
int main()
{
#ifdef LOCAL_TIME
	long long start_time_ = clock();
#endif
#ifdef READ_FILE
	freopen("1901.in", "r", stdin);
#ifndef STD_DEBUG
	freopen("1901.out", "w", stdout);
#endif
#endif
#ifdef READ_FREAD
	fread_init();
#endif
	init_recover_tree_node();
	read(cases);
	while (cases--)
	{
		top_stack_recover_tree_node = MAXTREE;
		init_recover_tree_node();
		memset(interval, 0, sizeof(interval));
		read(n);
		read(m);
		for (int i = 0; i < n; i++)
		{
			read(discre_tmp[i].val);
			discre_tmp[i].id = i;
		}
		tot_discre = n;
		for (int i = 0; i < m; i++)
		{
			read(op_string);
			if (op_string == 'Q')
			{
				op[i] = 1;
				read(op_i[i]);
				read(op_j[i]);
				read(op_k[i]);
			}
			else
			{
				op[i] = 2;
				read(op_i[i]);
				read(discre_tmp[tot_discre].val);
				discre_tmp[tot_discre++].id = n + i;
			}
		}
		std::sort(discre_tmp, discre_tmp + tot_discre);
		max_discre = 0;
		for (int i = 0; i < tot_discre; i++)
		{
			if ((i == 0) || (discre_tmp[i - 1] < discre_tmp[i]))
			{
				discre_to_num[++max_discre] = discre_tmp[i].val;
			}
			if (discre_tmp[i].id < n)
			{
				discre[discre_tmp[i].id] = max_discre;
			}
			else
			{
				op_k[discre_tmp[i].id - n] = max_discre;
			}
		}
		for (int i = 0; i < n; i++)
		{
			interval_insert(i + 1, discre[i]);
		}
		for (int i = 0; i < m; i++)
		{
#ifdef LOCAL_DEBUG
			if (i == 6)
			{
				printf("");
			}
#endif
			if (op[i] == 1)
			{
				printf("%dn", discre_to_num[interval_query(op_i[i], op_j[i], op_k[i])]);
			}
			else if (op[i] == 2)
			{
				interval_delete(op_i[i], discre[op_i[i] - 1]);
				interval_insert(op_i[i], op_k[i]);
				discre[op_i[i] - 1] = op_k[i];
			}
		}
	}
#ifdef LOCAL_TIME
	printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
	fclose(stdin);
#ifndef STD_DEBUG
	fclose(stdout);
#endif
#endif
	return 0;
}
#else
int a[MAXN];
int sort_tmp[MAXN];
//int op[MAXN], op_i[MAXN], op_j[MAXN], op_k[MAXN];
int main()
{
	const int N = 50000;
	const int M = 10000;
	const int BASE = 4;
	const int RAND_BASE = 23104;
	freopen("1901.in", "w", stdout);
	srand(RAND_BASE);
	printf("%dn", BASE);
	for (int j = 0; j < BASE; j++)
	{
		printf("%d %dn", N, M);
		for (int i = 0; i < N; i++)
		{
			printf("%d ", a[i] = rand());
		}
		printf("n");
		for (int i = 0; i < M; i++)
		{
			op[i] = rand() % 2;
			if (op[i] == 0)
			{
				printf("Q ");
				op_i[i] = rand() % N + 1;
				op_j[i] = op_i[i] + rand() % (N - op_i[i] + 1);
				op_k[i] = rand() % (op_j[i] - op_i[i] + 1) + 1;
				printf("%d %d %dn", op_i[i], op_j[i], op_k[i]);
			}
			else if (op[i] == 1)
			{
				printf("C ");
				op_i[i] = rand() % N + 1;
				op_k[i] = rand();
				printf("%d %dn", op_i[i], op_k[i]);
			}
		}
	}
	fclose(stdout);
	/*freopen("1901std.out", "w", stdout);
	for (int i = 0; i < M; i++)
	{
		if (op[i] == 1)
		{
			a[op_i[i] - 1] = op_k[i];
		}
		else if (op[i] == 0)
		{
			memcpy(sort_tmp, a + op_i[i] - 1, (op_j[i] - op_i[i] + 1) * sizeof(int));
			std::sort(sort_tmp, sort_tmp + op_j[i] - op_i[i] + 1);
			printf("%dn", sort_tmp[op_k[i] - 1]);
		}
	}
	fclose(stdout);*/
}
#endif

//POJ 2104.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>

//#define LOCAL
//#define READ_FILE
#define READ_FREAD
//#define VISUAL_STUDIO

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define LOCAL_SIMP
#endif

const int MAXN = 100010;
const int MAXTREE = 2000000;

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
	fread_char = getchar();
}

inline int get_int()
{
	int ret = 0;
	while ((fread_char < '0') || (fread_char > '9'))
	{
		fread_char = getchar();
	}
	while ((fread_char >= '0') && (fread_char <= '9'))
	{
		ret = ret * 10 + fread_char - '0';
		fread_char = getchar();
	}
	return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
	a = get_int();
#else
	scanf("%d", &a);
#endif
}

struct discre_node
{
	int val, id;
	inline bool operator < (const discre_node &b) const
	{
		return val < b.val;
	}
};

struct tree_node
{
	int tot;
	tree_node *l_child, *r_child;
	inline tree_node *init()
	{
		l_child = r_child = NULL;
		tot = 0;
		return this;
	}
};

tree_node recover_tree_node[MAXTREE];
tree_node *stack_recover_tree_node[MAXTREE];
int top_stack_recover_treee_node = MAXTREE;

inline void init_recover_tree_node()
{
	for (int i = 0; i < MAXTREE; i++)
	{
		stack_recover_tree_node[i] = recover_tree_node + i;
	}
}

inline tree_node *new_node()
{
	return stack_recover_tree_node[--top_stack_recover_treee_node]->init();
}

int n, m;
discre_node discre_tmp[MAXN];
int discre_to_num[MAXN];
int discre[MAXN];
int max_dis;
int l, r, k;
tree_node *prefix[MAXN];

inline void tree_insert(const int i)
{
	prefix[i] = new_node();
	tree_node *last_root = (i == 0 ? NULL : prefix[i - 1]);
	tree_node *new_root = prefix[i];
	int l = 1, r = max_dis, mid;
	while (l < r)
	{
		mid = (l + r) >> 1;
		if (discre[i] <= mid)
		{
			new_root->r_child = (last_root == NULL ? NULL : last_root->r_child);
			if (last_root != NULL)
			{
				new_root->tot = last_root->tot + 1;
				last_root = last_root->l_child;
			}
			else
			{
				new_root->tot = 1;
			}
			new_root->l_child = new_node();
			new_root = new_root->l_child;
			r = mid;
		}
		else
		{
			new_root->l_child = (last_root == NULL ? NULL : last_root->l_child);
			if (last_root != NULL)
			{
				new_root->tot = last_root->tot + 1;
				last_root = last_root->r_child;
			}
			else
			{
				new_root->tot = 1;
			}
			new_root->r_child = new_node();
			new_root = new_root->r_child;
			l = mid + 1;
		}
	}
	if (last_root != NULL)
	{
		new_root->tot = last_root->tot + 1;
	}
	else
	{
		new_root->tot = 1;
	}
}

inline int left_size(tree_node *query)
{
	if (query == NULL)
	{
		return 0;
	}
	if (query->l_child == NULL)
	{
		return 0;
	}
	return query->l_child->tot;
}

inline int tree_k_th(const int l, const int r, const int k)
{
	tree_node *left_root = (l == 0 ? NULL : prefix[l - 1]);
	tree_node *right_root = prefix[r];
	int binary_l = 1, binary_r = max_dis, mid;
	int tot_left = 0;
	while (binary_l < binary_r)
	{
		mid = (binary_l + binary_r) >> 1;
		if (tot_left + left_size(right_root) - left_size(left_root) >= k)
		{
			right_root = right_root->l_child;
			if (left_root != NULL)
			{
				left_root = left_root->l_child;
			}
			binary_r = mid;
		}
		else
		{
			tot_left += left_size(right_root) - left_size(left_root);
			right_root = right_root->r_child;
			if (left_root != NULL)
			{
				left_root = left_root->r_child;
			}
			binary_l = mid + 1;
		}
	}
	return binary_l;
}

#ifndef LOCAL_SIMP
int main()
{
#ifdef LOCAL_TIME
	long long start_time_ = clock();
#endif
#ifdef READ_FILE
	freopen("2104.in", "r", stdin);
	freopen("2104.out", "w", stdout);
#endif
#ifdef READ_FREAD
	fread_init();
#endif
	read(n);
	read(m);
	init_recover_tree_node();
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &discre_tmp[i].val);
		discre_tmp[i].id = i;
	}
	std::sort(discre_tmp, discre_tmp + n);
	max_dis = 0;
	for (int i = 0; i < n; i++)
	{
		if ((i == 0) || (discre_tmp[i - 1] < discre_tmp[i]))
		{
			discre_to_num[++max_dis] = discre_tmp[i].val;
		}
		discre[discre_tmp[i].id] = max_dis;
	}
	for (int i = 0; i < n; i++)
	{
		tree_insert(i);
	}
	for (int i = 0; i < m; i++)
	{
		read(l);
		read(r);
		read(k);
		printf("%dn", discre_to_num[tree_k_th(l - 1, r - 1, k)]);
	}
#ifdef LOCAL_TIME
	printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
	fclose(stdin);
	fclose(stdout);
#endif
	return 0;
}
#else
int a[MAXN];
int sort_tmp[MAXN];

int main()
{
	const int N = 10;
	const int M = 10;
	const int RAND_BASE = 243;
	freopen("2104.in", "w", stdout);
	srand(RAND_BASE);
	printf("%d %dn", N, M);
	for (int i = 0; i < N; i++)
	{
		printf("%d ", rand());
	}
	printf("n");
	for (int i = 0; i < M; i++)
	{
		int l = rand() % N + 1;
		int r = l + rand() % (N - l + 1);
		int k = rand() % (r - l + 1) + 1;
		printf("%d %d %dn", l, r, k);
	}
	fclose(stdout);
	freopen("2104.in", "r", stdin);
	freopen("2104std.out", "w", stdout);
	scanf("%d %d", &n, &m);
	for (int i = 0; i < n; i++)
	{
		scanf("%d", a + i);
	}
	for (int i = 0; i < m; i++)
	{
		scanf("%d %d %d", &l, &r, &k);
		memcpy(sort_tmp, a + l - 1, (r - l + 1) * sizeof(int));
		std::sort(sort_tmp, sort_tmp + r - l + 1);
		printf("%dn", sort_tmp[k - 1]);
	}
	fclose(stdin);
	fclose(stdout);
	return 0;
}
#endif

//JSOI2008 maxnumber.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<stack>
#include<queue>
#include<map>
#include<set>

//#define LOCAL
//#define READ_FILE
//#define VISUAL_STUDIO

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

int m, d;
int size;
char op[2];
int op_num;
int t;
int interval[200010];

inline int lowerbit(const int x)
{
    return x & (-x);
}

inline int interval_query(int x)
{
    int ret = 0;
    for (; x > 0; x -= lowerbit(x))
    {
        ret = std::max(ret, interval[x]);
    }
    return ret;
}

inline void interval_add(int x, const int val)
{
    for (; x <= m; x += lowerbit(x))
    {
        interval[x] = std::max(interval[x], val);
    }
}

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("maxnumber.in", "r", stdin);
    freopen("maxnumber.out", "w", stdout);
#endif
    scanf("%d %d", &m, &d);
    for (int i = 0; i < m; i++)
    {
        scanf("%s %d", op, &op_num);
        if (op[0] == 'Q')
        {
            printf("%dn", t = interval_query(m - size + op_num));
        }
        else if (op[0] == 'A')
        {
            op_num = (op_num + t) % d;
            interval_add(m - size, op_num);
            size++;
        }
    }
#ifdef READ_FILE
    fclose(stdin);
    fclose(stdout);
#endif
#ifdef READ_FILE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

//HEOI2012 flower.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define READ_FILE
//#define READ_FREAD
//#define VISUAL_STUDIO

const int MAXN = 1000010;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

struct query_node
{
    int l, r, id;
    inline bool operator < (const query_node &b) const
    {
        return r < b.r;
    }
};

int n, c, m;
int color[MAXN];
query_node query[MAXN];
int pre[MAXN], last_color[MAXN];
int ans[MAXN];

int interval[MAXN];

inline int lowerbit(const int x)
{
    return x & (-x);
}

inline void interval_add(const int l, const int add)
{
    for (int i = l; i <= n; i += lowerbit(i))
    {
        interval[i] += add;
    }
}

inline int interval_sum(int n)
{
    int ret = 0;
    while (n > 0)
    {
        ret += interval[n];
        n -= lowerbit(n);
    }
    return ret;
}

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("flower.in", "r", stdin);
    freopen("flower.out", "w", stdout);
#endif
    scanf("%d %d %d", &n, &c, &m);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", color + i);
    }
    for (int i = 0; i < m; i++)
    {
        scanf("%d %d", &query[i].l, &query[i].r);
        query[i].id = i;
    }
    std::sort(query, query + m);
    for (int i = 1; i <= n; i++)
    {
        pre[i] = last_color[color[i]];
        last_color[color[i]] = i;
    }
    int last_right = 0;
    for (int i = 0; i < m; i++)
    {
        while (query[i].r > last_right)
        {
            last_right++;
            interval_add(pre[pre[last_right]] + 1, 1);
            interval_add(pre[last_right] + 1, -1);
        }
        ans[query[i].id] = interval_sum(query[i].l);
    }
    for (int i = 0; i < m; i++)
    {
        printf("%dn", ans[i]);
    }
#ifdef LOCAL_TIME
    printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

//HNOI2005 DAY2 memory.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define VISUAL_STUDIO
#define READ_FREAD
//#define READ_FILE

const int MAXN = 10000;
const int MAX_HASH_LIST = 100000;
const int HASH_BASE = 7;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
//#define STD_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_char;

inline void fread_init()
{
    fread_char = getchar();
}

inline int get_int()
{
    int ret = 0;
    while ((fread_char < '0') || (fread_char > '9'))
    {
        fread_char = getchar();
    }
    while ((fread_char >= '0') && (fread_char <= '9'))
    {
        ret = ret * 10 + fread_char - '0';
        fread_char = getchar();
    }
    return ret;
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

int n, m, k, ans;
int splay_size;

struct memory_node
{
    int val;
    memory_node *next;
    int times, add_time;
    memory_node *parent, *l_child, *r_child;

    inline memory_node *init()
    {
        next = NULL;
        parent = l_child = r_child = NULL;
        times = 0;
        return this;
    }

    inline bool operator < (memory_node &b) const
    {
        if (times != b.times)
        {
            return times < b.times;
        }
        return add_time < b.add_time;
    }
};

memory_node recover_memory_node[MAXN];
memory_node *stack_memory_node[MAXN];
int top_stack_memory_node = MAXN;

inline void init_recover_memory()
{
    for (int i = 0; i < MAXN; i++)
    {
        stack_memory_node[i] = recover_memory_node + i;
        //stack_memory_node[i]->rank = get_rank();
    }
}

inline memory_node *new_node()
{
    return stack_memory_node[--top_stack_memory_node]->init();
}

inline void delete_node(memory_node *del_node)
{
    stack_memory_node[top_stack_memory_node++] = del_node;
}

memory_node *hash_list[MAX_HASH_LIST];

char hash_tmp[11];
inline int hash(const int k)
{
    int ret = 0;
    sprintf(hash_tmp, "%d", k);
    int length = strlen(hash_tmp);
    for (int i = 0; i < length; i++)
    {
        ret = ret * HASH_BASE + hash_tmp[i] - '0';
        if (ret >= MAX_HASH_LIST)
        {
            ret %= MAX_HASH_LIST;
        }
    }
    return ret;
}

inline memory_node *hash_find(const int k)
{
    memory_node *tmp = hash_list[hash(k)];
    while (tmp != NULL)
    {
        if (tmp->val == k)
        {
            tmp->times++;
            return tmp;
        }
        tmp = tmp->next;
    }
    return NULL;
}

inline memory_node *hash_insert(const int k, const int i = -1)
{
    memory_node *new_pt = new_node();
    new_pt->val = k;
    if (i != -1)
    {
        new_pt->add_time = i;
    }
    int hash_tmp = hash(k);
    new_pt->next = hash_list[hash_tmp];
    hash_list[hash_tmp] = new_pt;
    return new_pt;
}

inline void hash_delete(memory_node *del_node)
{
    int tmp_hash = hash(del_node->val);
    if (hash_list[tmp_hash] == del_node)
    {
        hash_list[tmp_hash] = del_node->next;
    }
    else
    {
        memory_node *tmp = hash_list[tmp_hash];
        while (tmp->next != del_node)
        {
            tmp = tmp->next;
        }
        tmp->next = del_node->next;
    }
    delete_node(del_node);
}

memory_node *splay_head = NULL;

inline void attach_as_l_child(memory_node *parent, memory_node *child)
{
    parent->l_child = child;
    if (child != NULL)
    {
        child->parent = parent;
    }
}

inline void attach_as_r_child(memory_node *parent, memory_node *child)
{
    parent->r_child = child;
    if (child != NULL)
    {
        child->parent = parent;
    }
}

inline void splay_zig(memory_node *axis)
{
    memory_node *left_child = axis->l_child;
    memory_node *parent = axis->parent;
    attach_as_l_child(axis, left_child->r_child);
    attach_as_r_child(left_child, axis);
    left_child->parent = parent;
    if (parent != NULL)
    {
        if (parent->l_child == axis)
        {
            parent->l_child = left_child;
        }
        else
        {
            parent->r_child = left_child;
        }
    }
}

inline void splay_zag(memory_node *axis)
{
    memory_node *right_child = axis->r_child;
    memory_node *parent = axis->parent;
    attach_as_r_child(axis, right_child->l_child);
    attach_as_l_child(right_child, axis);
    right_child->parent = parent;
    if (parent != NULL)
    {
        if (parent->l_child == axis)
        {
            parent->l_child = right_child;
        }
        else
        {
            parent->r_child = right_child;
        }
    }
}

inline memory_node *splay_route(memory_node *v)
{
    memory_node *parent, *grand_parent;
    while (((parent = v->parent) != NULL) && ((grand_parent = parent->parent) != NULL))
    {
        if (parent->l_child == v)
        {
            if (grand_parent->l_child == parent)
            {
                splay_zig(grand_parent);
                splay_zig(parent);
            }
            else
            {
                splay_zig(parent);
                splay_zag(grand_parent);
            }
        }
        else
        {
            if (grand_parent->r_child == parent)
            {
                splay_zag(grand_parent);
                splay_zag(parent);
            }
            else
            {
                splay_zag(parent);
                splay_zig(grand_parent);
            }
        }
    }
    if ((parent = v->parent) != NULL)
    {
        if (parent->l_child == v)
        {
            splay_zig(parent);
        }
        else
        {
            splay_zag(parent);
        }
    }
    return v;
}

inline void splay_insert(memory_node *insert_node)
{
    if (splay_head == NULL)
    {
        splay_head = insert_node;
    }
    else
    {
        memory_node *tmp = splay_head;
        memory_node *last_visit = NULL;
        while (tmp != NULL)
        {
            last_visit = tmp;
            if (*tmp < *insert_node)
            {
                tmp = tmp->r_child;
            }
            else
            {
                tmp = tmp->l_child;
            }
        }
        if (*last_visit < *insert_node)
        {
            attach_as_r_child(last_visit, insert_node);
        }
        else
        {
            attach_as_l_child(last_visit, insert_node);
        }
        splay_head = splay_route(insert_node);
    }
}

inline memory_node *splay_top()
{
    for (memory_node *tmp = splay_head; tmp != NULL; tmp = tmp->l_child)
    {
        if (tmp->l_child == NULL)
        {
            return tmp;
        }
    }
    return NULL;
}

inline memory_node *splay_bottom(memory_node *root = splay_head)
{
    for (memory_node *tmp = root; tmp != NULL; tmp = tmp->r_child)
    {
        if (tmp->r_child == NULL)
        {
            return tmp;
        }
    }
    return NULL;
}

inline void splay_delete(memory_node *del_node)
{
    splay_head = splay_route(del_node);
    if (splay_head->l_child == NULL)
    {
        splay_head = splay_head->r_child;
        if (splay_head != NULL)
        {
            splay_head->parent = NULL;
        }
    }
    else
    {
        memory_node *left_root = splay_route(splay_bottom(splay_head->l_child));
        attach_as_r_child(left_root, splay_head->r_child);
        splay_head = left_root;
    }
    del_node->l_child = del_node->r_child = del_node->parent = NULL;
}

inline void memory_read(const int k, const int i)
{
    memory_node *tmp = hash_find(k);
    if (tmp == NULL)
    {
        if (splay_size < n)
        {
            tmp = hash_insert(k, i);
            splay_insert(tmp);
            splay_size++;
        }
        else
        {
            tmp = splay_top();
            splay_delete(tmp);
            hash_delete(tmp);
            tmp = hash_insert(k, i);
            splay_insert(tmp);
        }
    }
    else
    {
        ans++;
        splay_delete(tmp);
        tmp->times++;
        splay_insert(tmp);
    }
}

#ifdef LOCAL_DEBUG
int max_deepen;
int splay_checker(const int deepen, memory_node *root = splay_head)
{
    if (root == NULL)
    {
        return 0;
    }
    max_deepen = std::max(max_deepen, deepen);
    int ret = 1;
    ret += splay_checker(deepen + 1, root->l_child);
    ret += splay_checker(deepen + 1, root->r_child);
    return ret;
}
#endif

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("memory.in", "r", stdin);
#ifndef STD_DEBUG
    freopen("memory.out", "w", stdout);
#endif
#endif
#ifdef READ_FREAD
    fread_init();
#endif
    init_recover_memory();
    read(n);
    read(m);
    for (int i = 0; i < m; i++)
    {
        read(k);
#ifdef LOCAL_DEBUG
        printf("%d %dn", i, k);
        if (i == 2)
        {
            printf("");
        }
#endif
        memory_read(k, i);
#ifdef LOCAL_DEBUG
        max_deepen = -1;
        if (splay_checker(1) != splay_size)
        {
            printf("SIZE_ERRORn");
        }
        //printf("%dn", max_deepen);
#endif
    }
    printf("%d", ans);
#ifdef LOCAL_TIME
    printf("nrun time: %lld ms", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
#ifndef STD_DEBUG
    fclose(stdout);
#endif
#endif
    return 0;
}

//ZJOI 2006 day1 trans.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<map>

//#define LOCAL
//#define READ_FILE
//#define VISUAL_STUDIO

const int MAXM = 22;
const int MAXD = 100;
const int MAXN = 110;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

struct edge_node
{
    int to;
    int val;
    edge_node *next;
    inline edge_node()
    {
        next = NULL;
    }
};

struct unable_node
{
    int node, begin, end;
};

struct queue_node
{
    int node;
    int val;
    inline queue_node()
    {

    }
    inline queue_node(const int node_, const int val_)
    {
        node = node_;
        val = val_;
    }
    inline bool operator < (const queue_node &b) const
    {
        if (val == -1)
        {
            return true;
        }
        else if (b.val == -1)
        {
            return false;
        }
        return val > b.val;
    }
};

std::priority_queue <queue_node> Q;
queue_node tmp;
int val[MAXN];
bool visit[MAXN];
int n, m, k, e, d;
edge_node edge[MAXM * MAXM];
int edge_top;
edge_node* edge_head[MAXM];
int l, r, v;
unable_node unable[MAXD];
bool sign_able[MAXN];
int f[MAXN][MAXN];
int dp[MAXN];
int ans;

inline void add_edge(const int l, const int r, const int val)
{
    edge[edge_top].to = r;
    edge[edge_top].val = val;
    edge[edge_top].next = edge_head[l];
    edge_head[l] = edge + edge_top++;
}

inline int min(const int a, const int b)
{
    if (a == -1)
    {
        return b;
    }
    else if (b == -1)
    {
        return a;
    }
    return a < b ? a : b;
}

inline int dijkstra(const int begin, const int end)
{
    memset(val, -1, sizeof(val));
    memset(visit, 0, sizeof(visit));
    val[begin] = 0;
    Q.push(queue_node(begin, 0));
    while (!Q.empty())
    {
        tmp = Q.top();
        Q.pop();
        if (visit[tmp.node])
        {
            continue;
        }
        visit[tmp.node] = true;
        for (edge_node *e = edge_head[tmp.node]; e != NULL; e = e->next)
        {
            if (sign_able[e->to])
            {
                if ((val[e->to] == -1) || (val[e->to] > val[tmp.node] + e->val))
                {
                    val[e->to] = val[tmp.node] + e->val;
                    visit[e->to] = false;
                    Q.push(queue_node(e->to, val[e->to]));
                }
            }
        }
    }
    return val[end];
}

inline int min_val(const int begin, const int end)
{
    if (f[begin][end] != -1)
    {
        return f[begin][end];
    }
    memset(sign_able, 1, sizeof(sign_able));
    for (int i = 0; i < d; i++)
    {
        if ((unable[i].begin <= end) && (unable[i].end >= begin))
        {
            sign_able[unable[i].node] = false;
        }
    }
#ifdef LOCAL_DEBUG
    printf("DIJ: %d %d %dn", begin, end, dijkstra(1, m));
#endif
    return f[begin][end] = (end - begin + 1) * dijkstra(1, m);
}

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("1003.in", "r", stdin);
    freopen("1003.out", "w", stdout);
#endif
    scanf("%d %d %d %d", &n, &m, &k, &e);
    for (int i = 0; i < e; i++)
    {
        scanf("%d %d %d", &l, &r, &v);
        add_edge(l, r, v);
        add_edge(r, l, v);
    }
    scanf("%d", &d);
    for (int i = 0; i < d; i++)
    {
        scanf("%d %d %d", &unable[i].node, &unable[i].begin, &unable[i].end);
    }
    memset(dp, -1, sizeof(dp));
    memset(f, -1, sizeof(f));
    dp[0] = 0;
    for (int i = 1; i <= n; i++)
    {
        dp[i] = min_val(1, i);
        if (dp[i] <= -1)
        {
            dp[i] = -1;
        }
        for (int j = 1; j < i; j++)
        {
            if ((min_val(j + 1, i) > -1) && (dp[j] > -1))
            {
                dp[i] = min(dp[i], dp[j] + k + min_val(j + 1, i));
            }
        }
    }
    printf("%d", dp[n]);
#ifdef LOCAL_TIME
    printf("nrun time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

//FJOI 2007 virus.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>

//#define LOCAL
//#define READ_FILE
//#define VISUAL_STUDIO

const int MAXBIT = 1000;
const int MAXN = 110;

#ifdef LOCAL
#define LOCAL_TIME
#define LOCAL_DEBUG
#endif

#ifdef VISUAL_STUDIO
#pragma warning(disable:4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

struct bign
{
    int val[MAXBIT];
    int length;
    inline bign()
    {
        memset(val, 0, MAXBIT);
        length = 1;
    }
    inline bign(char *a)
    {
        memset(val, 0, MAXBIT);
        length = strlen(a);
        for (int i = 0; i < length; i++)
        {
            val[i] = a[length - i - 1] - '0';
        }
    }
    inline bign(const int a)
    {
        memset(val, 0, MAXBIT);
        char tmp[MAXBIT];
        sprintf(tmp, "%d", a);
        *this = bign(tmp);
    }
    inline bign operator = (const int a)
    {
        return *this = bign(a);
    }
    inline bign operator = (char *a)
    {
        return *this = bign(a);
    }
    inline bign operator * (const int b) const
    {
        int tmp = 0;
        bign c;
        c.length = length;
        for (int i = 0; i < c.length; i++)
        {
            c.val[i] = val[i] * b + tmp;
            tmp = c.val[i] / 10;
            c.val[i] %= 10;
        }
        while (tmp > 0)
        {
            c.val[c.length++] = tmp % 10;
            tmp /= 10;
        }
        return c;
    }
    inline bign operator + (const bign &b) const
    {
        int tmp = 0;
        bign c;
        c.length = std::max(length, b.length);
        for (int i = 0; i < c.length; i++)
        {
            c.val[i] = val[i] + b.val[i] + tmp;
            tmp = 0;
            if (c.val[i] >= 10)
            {
                tmp = 1;
                c.val[i] -= 10;
            }
        }
        if (tmp > 0)
        {
            c.val[c.length++] = tmp;
            tmp = 0;
        }
        return c;
    }
    inline bign operator + (const int b) const
    {
        return *this + bign(b);
    }
    inline bign operator - (const bign &b) const
    {
        bign c;
        c.length = length;
        for (int i = 0; i < length; i++)
        {
            c.val[i] += val[i] - b.val[i];
            if (c.val[i] < 0)
            {
                c.val[i] += 10;
                c.val[i + 1]--;
            }
        }
        while (c.val[c.length - 1] == 0)
        {
            c.length--;
        }
        return c;
    }
    inline void print() const
    {
        for (int i = length - 1; i >= 0; i--)
        {
            printf("%d", val[i]);
        }
    }
};

int n;
bign f[MAXN];

int main()
{
#ifdef LOCAL_TIME
    long long start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("1002.in", "r", stdin);
    freopen("1002.out", "w", stdout);
#endif
    scanf("%d", &n);
    f[1] = 1;
    f[2] = 5;
    for (int i = 3; i <= n; i++)
    {
        f[i] = f[i - 1] * 3 - f[i - 2] + 2;
    }
    f[n].print();
    /*for (int i = 1; i <= 100; i++)
    {
        printf("%d ", i);
        f[i].print();
        printf("\n");
    }*/
#ifdef LOCAL_TIME
    printf("\nrun time: %lld ms\n", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
    fclose(stdout);
#endif
    return 0;
}

//HAOI2008 rank.cpp
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<string>
#include<cmath>
#include<queue>
#include<stack>
#include<map>

//#define LOCAL
#define READ_FREAD
//#define READ_FILE
//#define VISUAL_STUDIO

#ifdef LOCAL
#define LOCAL_TIME
//#define LOCAL_DEBUG
//#define STD_DEBUG
#endif

const int MAXN = 250010;
const int MAXTRIE = 500000;

#ifdef VISUAL_STUDIO
#pragma warning(disable: 4996)
#endif

#ifdef LOCAL_TIME
#include<ctime>
#endif

#ifdef READ_FREAD
char fread_point;

inline int get_int()
{
    int ret = 0;
    while ((fread_point < '0') || (fread_point > '9'))
    {
        fread_point = getchar();
    }
    while ((fread_point >= '0') && (fread_point <= '9'))
    {
        ret = ret * 10 + fread_point - '0';
        fread_point = getchar();
    }
    return ret;
}

inline char get_char()
{
    while ((fread_point == ' ') || (fread_point == 'n'))
    {
        fread_point = getchar();
    }
    char ret = fread_point;
    fread_point = getchar();
    return ret;
}

inline void get_string(char *input)
{
    memset(input, 0, 12);
    while ((fread_point == ' ') || (fread_point == 'n'))
    {
        fread_point = getchar();
    }
    int loop = 0;
    while ((fread_point != ' ') && (fread_point != 'n') && (fread_point != EOF))
    {
        input[loop++] = fread_point;
        fread_point = getchar();
    }
}
#endif

inline void read(int &a)
{
#ifdef READ_FREAD
    a = get_int();
#else
    scanf("%d", &a);
#endif
}

inline void read(char &a)
{
#ifdef READ_FREAD
    a = get_char();
#else
    scanf("%c", &a);
#endif
}

inline void read(char *a)
{
#ifdef READ_FREAD
    get_string(a);
#else
    scanf("%s", a);
#endif
}

typedef long long ll;

inline int string_to_int(char *a)
{
    int ret = 0;
    for (int i = 0; a[i] != 0; i++)
    {
        ret = ret * 10 + a[i] - '0';
    }
    return ret;
}

struct splay_node
{
    int val;
    char name[12];
    splay_node *parent, *l_child, *r_child;
    int size;
    inline splay_node *init()
    {
        parent = l_child = r_child = NULL;
        size = 1;
        return this;
    }
};

splay_node recover_splay[MAXN];
splay_node *stack_splay[MAXN];
int top_stack_splay = MAXN;

inline void init_splay()
{
    for (int i = 0; i < MAXN; i++)
    {
        stack_splay[i] = recover_splay + i;
    }
}

inline splay_node *new_node()
{
    return stack_splay[--top_stack_splay]->init();
}

inline void delete_node(splay_node *del_node)
{
    stack_splay[top_stack_splay++] = del_node;
}

splay_node *head_splay;

inline int splay_size(splay_node *query_node)
{
    if (query_node == NULL)
    {
        return 0;
    }
    return query_node->size;
}

inline void attach_as_l_child(splay_node *parent, splay_node *child)
{
    parent->l_child = child;
    if (child != NULL)
    {
        child->parent = parent;
    }
}

inline void attach_as_r_child(splay_node *parent, splay_node *child)
{
    parent->r_child = child;
    if (child != NULL)
    {
        child->parent = parent;
    }
}

inline void zig(splay_node *axis)
{
    splay_node *left_child = axis->l_child;
    splay_node *parent = axis->parent;
    attach_as_l_child(axis, left_child->r_child);
    attach_as_r_child(left_child, axis);
    left_child->parent = parent;
    if (parent != NULL)
    {
        if (parent->l_child == axis)
        {
            parent->l_child = left_child;
        }
        else
        {
            parent->r_child = left_child;
        }
    }
    left_child->size = axis->size;
    axis->size = splay_size(axis->l_child) + splay_size(axis->r_child) + 1;
}

inline void zag(splay_node *axis)
{
    splay_node *right_child = axis->r_child;
    splay_node *parent = axis->parent;
    attach_as_r_child(axis, right_child->l_child);
    attach_as_l_child(right_child, axis);
    right_child->parent = parent;
    if (parent != NULL)
    {
        if (parent->l_child == axis)
        {
            parent->l_child = right_child;
        }
        else
        {
            parent->r_child = right_child;
        }
    }
    right_child->size = axis->size;
    axis->size = splay_size(axis->l_child) + splay_size(axis->r_child) + 1;
}

inline splay_node *splay_route(splay_node *v)
{
    splay_node *parent, *grand_parent;
    while (((parent = v->parent) != NULL) && ((grand_parent = parent->parent) != NULL))
    {
        if (parent->l_child == v)
        {
            if (grand_parent->l_child == parent)
            {
                zig(grand_parent);
                zig(parent);
            }
            else
            {
                zig(parent);
                zag(grand_parent);
            }
        }
        else
        {
            if (grand_parent->r_child == parent)
            {
                zag(grand_parent);
                zag(parent);
            }
            else
            {
                zag(parent);
                zig(grand_parent);
            }
        }
    }
    if ((parent = v->parent) != NULL)
    {
        if (parent->l_child == v)
        {
            zig(parent);
        }
        else
        {
            zag(parent);
        }
    }
    return v;
}

inline splay_node *splay_find(const int val, const int add_size = 0)
{
    splay_node *last_visit = NULL;
    for (splay_node *tmp = head_splay; tmp != NULL;)
    {
        last_visit = tmp;
        tmp->size += add_size;
        if (tmp->val >= val)
        {
            tmp = tmp->r_child;
        }
        else
        {
            tmp = tmp->l_child;
        }
    }
    return last_visit;
}

inline splay_node *splay_find_by_rank(splay_node *v, const int k)
{
    int rank = 0;
    int left_size;
    while (v != NULL)
    {
        left_size = splay_size(v->l_child) + 1;
        if (rank + left_size == k)
        {
            return v;
        }
        else if (rank + left_size > k)
        {
            v = v->l_child;
        }
        else
        {
            rank += left_size;
            v = v->r_child;
        }
    }
    return NULL;
}

inline splay_node *splay_last(splay_node *v)
{
    while (v->r_child != NULL)
    {
        v = v->r_child;
    }
    return v;
}

void splay_print(splay_node *root)
{
    if (root == NULL)
    {
        return;
    }
    splay_print(root->l_child);
    printf(" %s", root->name);
    splay_print(root->r_child);
}

inline splay_node *splay_insert(const int val, char *name, splay_node *new_pt = NULL)
{
    if (new_pt == NULL)
    {
        new_pt = new_node();
        for (int i = 0; i < 10; i++)
        {
            new_pt->name[i] = name[i];
        }
    }
    else
    {
        new_pt->init();
    }
    new_pt->val = val;
    if (head_splay == NULL)
    {
        head_splay = new_pt;
    }
    else
    {
        splay_node *insert_pt = splay_find(val, 1);
        if (insert_pt->val >= val)
        {
            attach_as_r_child(insert_pt, new_pt);
        }
        else
        {
            attach_as_l_child(insert_pt, new_pt);
        }
        head_splay = splay_route(new_pt);
    }
    return new_pt;
}

inline void splay_delete(splay_node *del_node)
{
    splay_route(del_node);
    if (del_node->l_child != NULL)
    {
        del_node->l_child->parent = NULL;
    }
    if (del_node->r_child != NULL)
    {
        del_node->r_child->parent = NULL;
    }
    if (del_node->l_child == NULL)
    {
        head_splay = del_node->r_child;
    }
    else
    {
        head_splay = splay_route(splay_last(del_node->l_child));
        attach_as_r_child(head_splay, del_node->r_child);
        head_splay->size += splay_size(del_node->r_child);
    }
}

inline void splay_change(splay_node *change_node, const int val)
{
    splay_delete(change_node);
    splay_insert(val, NULL, change_node);
}

inline void splay_query_users(const int k)
{
    head_splay = splay_route(splay_find_by_rank(head_splay, k));
    printf("%s", head_splay->name);
    if (splay_size(head_splay->r_child) <= 9)
    {
        splay_print(head_splay->r_child);
    }
    else
    {
        head_splay->r_child->parent = NULL;
        attach_as_r_child(head_splay, splay_route(splay_find_by_rank(head_splay->r_child, 10)));
        splay_print(head_splay->r_child->l_child);
    }
    printf("n");
}

inline int splay_query_rank(splay_node *v)
{
    int ret = splay_size(v->l_child) + 1;
    while (v->parent != NULL)
    {
        if (v->parent->r_child == v)
        {
            ret += splay_size(v->parent->l_child) + 1;
        }
        v = v->parent;
    }
    return ret;
}

struct trie_node
{
    trie_node *next[26];
    splay_node *val;
    inline trie_node *init()
    {
        for (int i = 0; i < 26; i++)
        {
            next[i] = NULL;
        }
        val = NULL;
        return this;
    }
};

trie_node recover_trie[MAXTRIE];
trie_node *stack_trie[MAXTRIE];
int top_stack_trie = MAXTRIE;

inline void init_trie()
{
    for (int i = 0; i < MAXTRIE; i++)
    {
        stack_trie[i] = recover_trie + i;
    }
}

inline trie_node *new_trie()
{
    return stack_trie[--top_stack_trie]->init();
}

inline void delete_trie(trie_node *del_node)
{
    stack_trie[top_stack_trie++] = del_node;
}

trie_node *head_trie;

inline splay_node *trie_find(char *find_string)
{
    trie_node *tmp = head_trie;
    for (int i = 0; find_string[i] != 0; i++)
    {
        if (tmp->next[find_string[i] - 'A'] == NULL)
        {
            return NULL;
        }
        else
        {
            tmp = tmp->next[find_string[i] - 'A'];
        }
    }
    return tmp->val;
}

inline void trie_insert(char *insert_string, splay_node *val)
{
    trie_node *tmp = head_trie;
    for (int i = 0; insert_string[i] != 0; i++)
    {
        if (tmp->next[insert_string[i] - 'A'] == NULL)
        {
            tmp->next[insert_string[i] - 'A'] = new_trie();
        }
        tmp = tmp->next[insert_string[i] - 'A'];
    }
    tmp->val = val;
}

int n;
char op_char;
char op_name[12];
int k;
splay_node *found;

int main()
{
#ifdef LOCAL_TIME
    ll start_time_ = clock();
#endif
#ifdef READ_FILE
    freopen("rank.in", "r", stdin);
#ifndef STD_DEBUG
    freopen("rank.out", "w", stdout);
#endif
#endif
    fread_point = getchar();
    read(n);
    init_splay();
    init_trie();
    head_trie = new_trie();
    for (int i = 0; i < n; i++)
    {
        read(op_char);
        read(op_name);
#ifdef LOCAL_DEBUG
        printf("%d %c %s ", i, op_char, op_name);
#endif
        if (op_char == '+')
        {
            read(k);
#ifdef LOCAL_DEBUG
            printf("%dn", k);
#endif
            if ((found = trie_find(op_name)) != NULL)
            {
                splay_change(found, k);
            }
            else
            {
                trie_insert(op_name, splay_insert(k, op_name));
            }
        }
        else if (op_char == '?')
        {
#ifdef LOCAL_DEBUG
            printf("n");
#endif
            if ((op_name[0] >= '0') && (op_name[0] <= '9'))
            {
                k = string_to_int(op_name);
                splay_query_users(k);
            }
            else
            {
                printf("%dn", splay_query_rank(trie_find(op_name)));
            }
        }
    }
#ifdef LOCAL_TIME
    printf("run time: %lld msn", clock() - start_time_);
#endif
#ifdef READ_FILE
    fclose(stdin);
#ifndef STD_DEBUG
    fclose(stdout);
#endif
#endif
    return 0;
}