#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, k, sx, sy, d;
char ch[5];
long long ans;
set<int> s1[N], s2[N];
map<pair<int, int>, bool> mp;
struct node {
  int x, y, d;
};
inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * f;
}
inline int get(int x, int y, int d) { return d == 1 ? x - y + m + 1 : x + y; }
inline bool same(node a, node b) {
  return a.x == b.x && a.y == b.y && a.d == b.d;
}
inline bool check(int x, int y) { return mp[make_pair(x, y)]; }
inline void add(int x, int y) {
  s1[get(x, y, 1)].insert(x);
  s2[get(x, y, 2)].insert(x);
  mp[make_pair(x, y)] = 1;
}
inline pair<node, int> dfs(node u) {
  node re;
  set<int>::iterator it;
  if (u.d == 1) {
    it = s1[get(u.x, u.y, 1)].lower_bound(u.x);
    it--;
    re.x = u.x - (abs(*it - u.x) - 1);
    re.y = u.y - (abs(*it - u.x) - 1);
    if (check(re.x - 1, re.y) && check(re.x, re.y - 1))
      re.d = 3;
    else if (check(re.x - 1, re.y)) {
      re.y--;
      re.d = 4;
    } else if (check(re.x, re.y - 1)) {
      re.x--;
      re.d = 2;
    } else
      re.d = 3;
  }
  if (u.d == 2) {
    it = s2[get(u.x, u.y, 2)].lower_bound(u.x);
    it--;
    re.x = u.x - (abs(*it - u.x) - 1);
    re.y = u.y + (abs(*it - u.x) - 1);
    if (check(re.x - 1, re.y) && check(re.x, re.y + 1))
      re.d = 4;
    else if (check(re.x - 1, re.y)) {
      re.y++;
      re.d = 3;
    } else if (check(re.x, re.y + 1)) {
      re.x--;
      re.d = 1;
    } else
      re.d = 4;
  }
  if (u.d == 3) {
    it = s1[get(u.x, u.y, 1)].lower_bound(u.x);
    re.x = u.x + (abs(*it - u.x) - 1);
    re.y = u.y + (abs(*it - u.x) - 1);
    if (check(re.x + 1, re.y) && check(re.x, re.y + 1))
      re.d = 1;
    else if (check(re.x + 1, re.y)) {
      re.y++;
      re.d = 2;
    } else if (check(re.x, re.y + 1)) {
      re.x++;
      re.d = 4;
    } else
      re.d = 1;
  }
  if (u.d == 4) {
    it = s2[get(u.x, u.y, 2)].lower_bound(u.x);
    re.x = u.x + (abs(*it - u.x) - 1);
    re.y = u.y - (abs(*it - u.x) - 1);
    if (check(re.x + 1, re.y) && check(re.x, re.y - 1))
      re.d = 2;
    else if (check(re.x + 1, re.y)) {
      re.y--;
      re.d = 1;
    } else if (check(re.x, re.y - 1)) {
      re.x++;
      re.d = 3;
    } else
      re.d = 2;
  }
  return make_pair(re, abs(*it - u.x));
}
bool judge(node u) {
  node re = u;
  do {
    pair<node, int> cur = dfs(u);
    ans += (long long)cur.second;
    switch (cur.first.d) {
      case 1:
        if (u.d == 3) return 0;
        break;
      case 2:
        if (u.d == 4) return 0;
        break;
      case 3:
        if (u.d == 1) return 0;
        break;
      case 4:
        if (u.d == 2) return 0;
        break;
    }
    u = cur.first;
  } while (!same(re, u));
  return 1;
}
void pre_build() {
  for (int i = 0; i <= m + 1; i++) {
    add(0, i);
    add(n + 1, i);
  }
  for (int i = 1; i <= n; i++) {
    add(i, 0);
    add(i, m + 1);
  }
}
int main() {
  scanf("%d%d%d", &n, &m, &k);
  pre_build();
  for (int i = 1; i <= k; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    add(x, y);
  }
  int x, y, d;
  char ch[5];
  scanf("%d%d%s", &x, &y, ch + 1);
  if (ch[1] == 'N' && ch[2] == 'W') d = 1;
  if (ch[1] == 'N' && ch[2] == 'E') d = 2;
  if (ch[1] == 'S' && ch[2] == 'E') d = 3;
  if (ch[1] == 'S' && ch[2] == 'W') d = 4;
  node st = {x, y, d};
  st = dfs(st).first;
  if (!judge(st)) {
    ans--;
    switch (st.d) {
      case 1:
        st.d = 3;
        break;
      case 2:
        st.d = 4;
        break;
      case 3:
        st.d = 1;
        break;
      case 4:
        st.d = 2;
        break;
    }
    judge(st);
  }
  printf("%lld", ans);
  return 0;
}
