#include <bits/stdc++.h>

int ri() {
	int n;
	scanf("%d", &n);
	return n;
}

std::vector<bool> data[2];
std::vector<int> next[2][2], prev[2][2];

struct Info {
	int lower;
	int upper;
	int con;
};

#define INF 1000000000

int res;
int n[2];
int goal[2];
int goal_adj[2][2][2]; // axis, dir, what
std::vector<Info> used[2];
int depth;
void dfs(int x, int y, bool next_axis, int cost) {
	if (depth >= 6) return;
	// fprintf(stderr, "(%d, %d) dir:%d cost:%d\n", x, y, next_axis, cost);
	int axis_pos = next_axis ? y : x;
	int axis_start = next_axis ? x : y;
	if (x == goal[0] && y == goal[1]) {
		res = std::min(res, cost);
		return;
	} else if (!next_axis && x == goal[0] && (y < goal[1]) == data[next_axis][axis_pos]) {
		res = std::min(res, cost + std::abs(y - goal[1]));
		return;
	} else if (next_axis && y == goal[1] && (x < goal[0]) == data[next_axis][axis_pos]) {
		res = std::min(res, cost + std::abs(x - goal[0]));
		return;
	}
	auto trial = [&] (int next_pos) {
		for (auto i : used[!next_axis]) {
			if ((i.con < axis_start) == (axis_start < next_pos) && axis_pos >= i.lower && axis_pos <= i.upper) return;
			if (i.con == next_pos && axis_pos >= i.lower && axis_pos <= i.upper) return;
		}
		depth++;
		used[next_axis].push_back({axis_start, next_pos > axis_pos ? axis_pos : -INF, next_pos > axis_pos ? INF : next_pos});
		dfs(next_axis ? next_pos : x, next_axis ? y : next_pos, !next_axis, cost + std::abs(axis_start - next_pos));
		used[next_axis].pop_back();
		depth--;
	};
	if (data[next_axis][axis_pos]) { // positive
		if (goal[!next_axis] > axis_start) {
			for (int i = 0; i < 2; i++) {
				for (int j = 0; j < 2; j++) {
					int r0 = goal_adj[!next_axis][j][i];
					if (r0 != -1 && r0 > axis_start) trial(r0);
				}
			}
		} else for (int i = 0; i < 2; i++)
			if (next[!next_axis][i][axis_start] != -1) trial(next[!next_axis][i][axis_start]);
	} else {
		if (goal[!next_axis] < axis_start) {
			for (int i = 0; i < 2; i++) {
				for (int j = 0; j < 2; j++) {
					int r0 = goal_adj[!next_axis][j][i];
					if (r0 != -1 && r0 < axis_start) trial(r0);
				}
			}
		} else for (int i = 0; i < 2; i++) if (prev[!next_axis][i][axis_start] != -1) trial(prev[!next_axis][i][axis_start]);
	}
}

int main() {
	n[0] = ri();
	n[1] = ri();
	int q = ri();
	{
		std::string s, t;
		std::cin >> s >> t;
		data[0].resize(n[0]);
		data[1].resize(n[1]);
		for (int i = 0; i < n[0]; i++) data[0][i] = s[i] == 'E';
		for (int i = 0; i < n[1]; i++) data[1][i] = t[i] == 'S';
	}
	for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) {
		int n = data[i].size();
		next[i][j].resize(n);
		prev[i][j].resize(n);
		next[i][j][n - 1] = -1;
		for (int k = n; --k; ) {
			if (data[i][k] == j) next[i][j][k - 1] = k;
			else next[i][j][k - 1] = next[i][j][k];
		}
		prev[i][j][0] = -1;
		for (int k = 0; k + 1 < n; k++) {
			if (data[i][k] == j) prev[i][j][k + 1] = k;
			else prev[i][j][k + 1] = prev[i][j][k];
		}
	}
	/*
	for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) {
		std::cerr << "axis:" << i << " what:" << j << "  : ";
		for (auto k : next[i][j]) std::cerr << k << " ";
		std::cerr << std::endl;
	}*/
	
	for (int i = 0; i < q; i++) {
		int sx = ri() - 1;
		int sy = ri() - 1;
		goal[0]	= ri() - 1;
		goal[1] = ri() - 1;
		for (int j = 0; j < 2; j++) for (int k = 0; k < 2; k++) {
			goal_adj[j][0][k] = data[j][goal[j]] == k ? goal[j] : prev[j][k][goal[j]];
			goal_adj[j][1][k] = data[j][goal[j]] == k ? goal[j] : next[j][k][goal[j]];
		}
		// std::cerr << "!" << goal_adj[1][0][0] << " " << goal_adj[1][0][1] << std::endl;
		res = INF;
		dfs(sx, sy, false, 0);
		dfs(sx, sy, true, 0);
		printf("%d\n", res == INF ? -1 : res);
	}
	
	return 0;
}


Measured memory_bytes: 4684