#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
#define rep(i, a, b) for (int i = a, I = b; i <= I; ++i)
#define per(i, a, b) for (int i = a, I = b; i >= I; --i)

const int inf = 1e9;

namespace flow {
    const int N = 12000;
    int n, s, t, dis[N], h[N], prv[N];
    struct edge {
        int to, cap, cost;
    };
    vector<edge> E;
    vector<int> e[N];

    void add(int u, int v, int cap, int cost) {
        e[u].push_back(E.size()), E.push_back({v, cap, cost});
        e[v].push_back(E.size()), E.push_back({u, 0, -cost});
    }
    void dij() {
        memset(dis, 0x3f, sizeof dis);
        dis[s] = 0;
        priority_queue<pii, vector<pii>, greater<pii>> pq;
        pq.push({0, s});
        while (!pq.empty()) {
            auto cur = pq.top(); pq.pop();
            int u = cur.second;
            for (auto i : e[u]) {
                auto [v, cap, cost] = E[i];
                if (!cap) continue;
                cost += h[u] - h[v];
                if (dis[v] > dis[u] + cost) {
                    dis[v] = dis[u] + cost, prv[v] = i;
                    pq.push({dis[v], v});
                }
            }
        }
    }
    int solve(int lim) {
        int ans = 0;
        while (lim--) {
            dij();
            if (dis[t] >= inf) return -1;
            ans += dis[t];
            int u = t;
            while (u != s) {
                --E[prv[u]].cap;
                ++E[prv[u] ^ 1].cap;
                u = E[prv[u] ^ 1].to;
            }
        }
        return ans;
    }
}

const int N = 105;
const int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
int n, m, px[N * 4], py[N * 4], qx[N * 4], qy[N * 4];
char s[N][N];
bool valid_r[N][N], valid_b[N][N], free_r[N][N], free_b[N][N];
vector<pair<int, int>> e[N * N];
bool banned[N * N];

int ID(int x, int y) {
    if (x == 1) return y;
    if (y == m) return m + x - 1;
    if (x == n) return n + m - 1 + m - y;
    if (y == 1) return n + 2 * m - 2 + n - x;
    return 0;
}
bool is_normal(int i, int j) {
    return s[i][j] == '.' || s[i][j] == '#';
}
int idx(int i, int j) {
    return i * (m + 1) + j;
}
void add_edge(int u, int v, int w) {
    e[u].push_back({v, w});
    e[v].push_back({u, w});
}

int main() {
    // freopen("1.in", "r", stdin);
    ios::sync_with_stdio(0), cin.tie(0);

    cin >> n >> m;
    rep(i, 1, n) cin >> (s[i] + 1);
    int k; cin >> k;
    while (k--) {
        int x, y; char op;
        cin >> x >> y >> op;
        (op == 'b' ? valid_b : valid_r)[x][y] = true;
    }
    
    rep(i, 1, n) rep(j, 1, m) {
        int id = ID(i, j);
        if (!id) continue;
        px[id] = i, py[id] = j;
        qx[id] = px[id], qy[id] = py[id];
        if (id <= m - 1) --qx[id];
        else if (id <= n + m - 2);
        else if (id <= n + 2 * m - 3) --qy[id];
        else --qy[id], --qx[id];
    }

    vector<int> st, su, tu;
    int cnt = 2 * (n + m) - 4;
    rep(i, 1, cnt) {
        char prv, nxt;
        {
            int j = i;
            while (is_normal(px[j], py[j])) j = (j == 1 ? cnt : (j - 1));
            prv = s[px[j]][py[j]];
        }
        {
            int j = (i == cnt ? 1 : (i + 1));
            while (is_normal(px[j], py[j])) j = (j == cnt ? 1 : (j + 1));
            nxt = s[px[j]][py[j]];
        }
        if (prv > nxt) swap(prv, nxt);
        int cur = idx(qx[i], qy[i]);
        if (prv == 'S' && nxt == 'T') st.push_back(cur);
        else if (prv == 'S' && nxt == 'U') su.push_back(cur);
        else tu.push_back(cur);
    }

    rep(i, 1, n) rep(j, 1, m) {
        if (!is_normal(i, j)) continue;
        if (s[i][j] == '#') {
            valid_r[i][j] = valid_r[i][j - 1] = free_r[i][j] = free_r[i][j - 1] = true;
            valid_b[i][j] = valid_b[i - 1][j] = free_b[i][j] = free_b[i - 1][j] = true;
        }
    }
    rep(i, 1, n) rep(j, 1, m) {
        if (valid_r[i][j]) add_edge(idx(i - 1, j), idx(i, j), !free_r[i][j]);
        if (valid_b[i][j]) add_edge(idx(i, j - 1), idx(i, j), !free_b[i][j]);
    }

    flow::n = flow::t = (n + 1) * (m + 1) + 1;
    queue<int> que;
    auto push = [&](int u) {
        if (banned[u]) return;
        banned[u] = true, que.push(u);
    };
    for (auto u : st) push(u);
    while (!que.empty()) {
        int u = que.front(); que.pop();
        for (auto [v, w] : e[u]) if (!w) push(v);
    }

    for (auto u : su) flow::add(flow::s, u, inf, 0);
    for (auto u : tu) flow::add(u, flow::t, inf, 0);
    rep(u, 1, flow::n - 1) {
        if (banned[u]) continue;
        for (auto [v, w] : e[u]) {
            if (banned[v]) continue;
            flow::add(u, v, 1, w);
        }
    }

    int ans = flow::solve(2);
    cout << ans << "\n";

    return 0;
}