#include <bits/stdc++.h>

using namespace std;

#if __cplusplus >= 201103L
    struct pairhash {
        static uint64_t splitmix64(uint64_t x) {
            x += 0x9e3779b97f4a7c15;
            x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
            x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
            return x ^ (x >> 31);
        }

        template<class T, class U>
        size_t operator() (const pair<T,U> &p) const {
            static const uint64_t FIXED_RANDOM = (uint64_t)chrono::steady_clock::now().time_since_epoch().count();
            return splitmix64(p.first + FIXED_RANDOM) ^ splitmix64(p.second+ FIXED_RANDOM);
        }
    };
    struct custom_hash {
        static uint64_t splitmix64(uint64_t x) {
            x += 0x9e3779b97f4a7c15;
            x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
            x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
            return x ^ (x >> 31);
        }

        size_t operator()(uint64_t x) const {
            static const uint64_t FIXED_RANDOM = (uint64_t)chrono::steady_clock::now().time_since_epoch().count();
            return splitmix64(x + FIXED_RANDOM);
        }
    };
    mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
    inline int randint(int l, int r) {
        return uniform_int_distribution<int>(l,r)(rng);
    }
    inline double randdouble(double l, double r) {
        return uniform_real_distribution<double>(l,r)(rng);
    }
    inline long long randll(long long l, long long r) {
        mt19937_64 rng2((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
        return uniform_int_distribution<long long>(l, r)(rng2);
    }
#endif
 
#ifndef ONLINE_JUDGE
#  define LOG(x) (cerr << #x << " = " << (x) << endl)
#else
#  define LOG(x) 0
#endif

#define fastio ios::sync_with_stdio(false); cin.tie(0);
#define ll long long
#define ull unsigned long long
#define ll128 __int128_t
#define PI 3.14159265358979323846
#define abs(a) ((a>0)?a:-(a))
#define pii pair<int,int>
#define pll pair<ll,ll>

const long double pi = acos(-1.0);
const long double eps = (double)1e-10;

// const int mod = 1e9+7;
int mod;

template<class T>
T qpow(T a, int b) {
    T res = 1;
    while (b) {
        if (b & 1) res *= a;
        a *= a;
        b >>= 1;
    }
    return res;
}
int norm(int x) {
    if (x < 0) {
        x += mod;
    }
    if (x >= mod) {
        x -= mod;
    }
    return x;
}
struct Z {
    int x;
    Z(int x = 0) : x(norm(x)) {}
    Z(ll x) : x(norm((int)(x % mod))) {}
    int val() const {
        return x;
    }
    Z operator-() const {
        return Z(norm(mod - x));
    }
    Z inv() const {
        assert(x != 0);
        return qpow(*this, mod - 2);
    }
    Z &operator*=(const Z &rhs) {
        x = (int)((ll)(x) * rhs.x % mod);
        return *this;
    }
    Z &operator+=(const Z &rhs) {
        x = norm(x + rhs.x);
        return *this;
    }
    Z &operator-=(const Z &rhs) {
        x = norm(x - rhs.x);
        return *this;
    }
    Z &operator/=(const Z &rhs) {
        return *this *= rhs.inv();
    }
    friend Z operator*(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res *= rhs;
        return res;
    }
    friend Z operator+(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res += rhs;
        return res;
    }
    friend Z operator-(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res -= rhs;
        return res;
    }
    friend Z operator/(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Z &a) {
        ll v;
        is >> v;
        a = Z(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Z &a) {
        return os << a.val();
    }
};

const int maxn = 1e6+5;
const int maxm = 1e6+5;


struct State {
    int c1, r1, c2, r2, m, b;
    bool operator<(const State& other) const {
        return tuple {m, b} < tuple {other.m, other.b};
    }
};

pii dp[51][51][51][51];
int c, r, e;  // exit: (e, 0)
int dir[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};   // S, W, N, E
bool bad[51][51][4];  // S, W, N, E; if bad, cannot use

char D1, D2;
vector<pii> op;
int mapdir(int d) {
    if (d == 'S') return 0;
    if (d == 'W') return 1;
    if (d == 'N') return 2;
    if (d == 'E') return 3;
}

queue<State> q;
void bfs() {
    while (q.size()) {
        auto [c1, r1, c2, r2, m, b] = q.front(); q.pop();
        // printf("{%d, %d, %d, %d} = %d, %d\n",c1,r1,c2,r2,m,b);

        vector<State> tmp;
        for (int o = 0; o < 4; o++) {
            auto [o1, o2] = op[o];
            int nc1 = c1 + dir[o1][0], nr1 = r1 + dir[o1][1];
            int nc2 = c2 + dir[o2][0], nr2 = r2 + dir[o2][1];
            // if (c1 == 2 && r1 == 0 && c2 == 2 && r2 == 1) {
            //     printf("o1 = %d, o2 = %d, bad1 = %d, bad2 = %d\n",o1,o2,bad[c1][r1][o1],bad[c2][r2][o2]);
            //     printf("nc1 = %d, nr1 = %d, nc2 = %d, nr2 = %d\n",nc1,nr1,nc2,nr2);
            // }
            
            int bp = 0;
            if (bad[c1][r1][o1]) nc1 = c1, nr1 = r1, bp++;
            if (bad[c2][r2][o2]) nc2 = c2, nr2 = r2, bp++;
            if (c1 == e && r1 == 0) nc1 = c1, nr1 = r1;  // 终点：在原地呆着
            if (c2 == e && r2 == 0) nc2 = c2, nr2 = r2;

            State nstate = {nc1, nr1, nc2, nr2, m+1, b+bp};
            tmp.push_back(nstate);
        }
        sort(tmp.begin(), tmp.end());
        for (auto nstate : tmp) {
            auto [C1, R1, C2, R2, M, B] = nstate;
            if (!(C1 == e && R1 == 0) && C1 == C2 && R1 == R2) continue;

            // if (c1 == 4 && r1 == 0 && c2 == 4 && r2 == 1)
            //     printf("{%d, %d, %d, %d} = %d, %d\n",C1,R1,C2,R2,M,B);
            if (pii{M, B} < dp[C1][R1][C2][R2]) {
                dp[C1][R1][C2][R2] = {M, B};
                q.push(nstate);
            }
        }
    }
    cout << dp[e][0][e][0].first << " " << dp[e][0][e][0].second << "\n";
}

int main() {
    int c1, r1, d1, c2, r2, d2;
    cin >> c >> r >> e;
    cin >> c1 >> r1 >> D1 >> c2 >> r2 >> D2;
    memset(dp, 63, sizeof(dp));
    dp[c1][r1][c2][r2] = {0, 0};
    // cout << dp[1][1][1][1].first << " " << dp[1][1][1][1].second << endl;
    d1 = mapdir(D1), d2 = mapdir(D2);
    for (int i = 0; i < 4; i++) {
        op.push_back({d1, d2});
        d1++, d2++;
        d1 %= 4, d2 %= 4;
    }

    int n; cin >> n;
    while (n--) {
        int ci, ri; cin >> ci >> ri;  // (ci, ri) -> (ci, ri+1)
        // (ci, ri): N bad
        // (ci, ri+1): S bad
        bad[ci][ri][2] = 1;
        bad[ci][ri+1][0] = 1;
    }
    cin >> n;
    while (n--) {
        int ci, ri; cin >> ci >> ri;  // (ci, ri) -> (ci+1, ri)
        // (ci, ri): E bad
        // (ci+1, ri): W bad
        bad[ci][ri][3] = 1;
        bad[ci+1][ri][1] = 1;
    }
    for (int i = 1; i <= c; i++) {
        for (int j = 1; j <= r; j++) {
            if (i == 1) bad[i][j][1] = 1;
            if (i == c) bad[i][j][3] = 1;
            if (j == 1) bad[i][j][0] = 1;
            if (j == r) bad[i][j][2] = 1;
        }
    }
    bad[e][1][0] = 0;
    fill(bad[e][0], bad[e][0]+4, 0);

    q.push({c1, r1, c2, r2, 0, 0});
    bfs();
}