#include <iostream>
#include <tuple>
#include <vector>
#include <string>
#include <cstring>
#include <deque>
#include <numeric>
#include <algorithm>
using namespace std;

int n, m, t, X[11], Y[11], G[16][16], GG[16][16], B[16][16], C[16][16], V[16][16], best = 1000;
char c;

vector<int> dx, dy;

void r()
{
	for (int i = 0; i < 15; ++i)
	{
		dx.push_back(-i);
		dy.push_back(0);
		dx.push_back(i);
		dy.push_back(0);
		dx.push_back(0);
		dy.push_back(-i);
		dx.push_back(0);
		dy.push_back(i);
	}
}

void b()
{
	for (int i = 0; i < 15; ++i)
	{
		dx.push_back(-i);
		dy.push_back(-i);
		dx.push_back(i);
		dy.push_back(i);
		dx.push_back(i);
		dy.push_back(-i);
		dx.push_back(-i);
		dy.push_back(i);
	}
}

void gen()
{
	switch (c)
	{
		case 'K':
			dx = {-1, 0, 1, -1, 1, -1, 0, 1};
			dy = {-1, -1, -1, 0, 0, 1, 1, 1};
			break;
		case 'Q':
			r();
			b();
			break;
		case 'R':
			r();
			break;
		case 'N':
			dx = {-2, -1, 1, 2, -2, -1, 1, 2};
			dy = {1, 2, 2, 1, -1, -2, -2, -1};
			break;
		case 'B':
			b();
			break;
	}
}

bool good(int x, int y)
{
	return x <= n && x > 0 && y <= m && y > 0;
}

int main()
{
	cin >> n >> m >> X[10] >> Y[10] >> c >> t;
	for (int i = 0; i < t; ++i)
	{
		cin >> X[i] >> Y[i];
		GG[X[i]][Y[i]] = 1;
	}
	X[t] = X[10];
	Y[t] = Y[10];
	GG[X[t]][Y[t]] = 1;

	gen();
	int A[10], I[10];
	for (int i = t; i <= t; ++i)
	{
		int k = 0;
		for (int j = 0; j <= t; ++j)
			if (i != j)
				A[k++] = j;
		
		iota(I, I + t, 0);
		do
		{
			memcpy(G, GG, sizeof G);
			int num = t;
			for (int l = 0; l < t; ++l)
			{
				int dex = X[I[l]], dey = Y[I[l]];
				deque<pair<int, int> > Q;
				Q.emplace_front(X[t], Y[t]);
				memset(B, 0, sizeof B);
				memset(C, 0, sizeof C);
				memset(V, 0, sizeof V);
				B[X[t]][Y[t]] = C[X[t]][Y[t]] = -1;
				while (!Q.empty())
				{
					int x, y;
					tie(x, y) = Q.front(); Q.pop_front();
					V[x][y] = 1;
					if (x == dex && y == dey)
						break;
					for (int o = 0; o < dx.size(); ++o)
					{
						int xx = x + dx[o];
						int yy = y + dy[o];
						if (good(xx, yy) && !V[xx][yy])
						{
							if (G[xx][yy])
							{
								B[xx][yy] = x;
								C[xx][yy] = y;
								Q.emplace_front(xx, yy);
							}
							else if (!B[xx][yy])
							{
								B[xx][yy] = x;
								C[xx][yy] = y;
								Q.emplace_back(xx, yy);
							}
						}
					}
				}
				vector<int> hx, hy;
				while (true)
				{
					int px = B[dex][dey];
					int py = C[dex][dey];
					if (G[px][py])
						break;
					hx.push_back(px);
					hy.push_back(py);
					dex = px;
					dey = py;
				}
				for (int r = 0; r < hx.size(); ++r)
					G[hx[r]][hy[r]] = 1;
				num += hx.size();
			}
			best = min(best, num);
		} while (next_permutation(I, I + t));
	}
	cout << best;
}