#include <bits/stdc++.h>

using namespace std;

string add1(string S) {
    if (S == "") return "1";
    ++S.back();
    for (int i = (int)S.size() - 1; i >= 0; --i) {
        if (S[i] <= '9') break;
        if (i == 0) {
            S = "1" + S;
        } else {
            ++S[i - 1];
        }
        S[i] -= 10;
    }
    return S;
}

string mul2(string S) {
    for (auto &x : S) {
        x = (x - '0') * 2 + '0';
    }
    int ad = 0;
    for (int i = (int)S.size() - 1; i >= 0; --i) {
        if (S[i] > '9') {
            if (i == 0) ad = 1;
            else ++S[i - 1];
            S[i] -= 10;
        }
    }
    if (ad) S = "1" + S;
    return S;
}

const int N = 105, K = 20;
const int L = 32, I = 7;
const unsigned long long B = 1ll << L;

int n, m, q, c1[N][N], c2[N][N];

struct vec {
    long long val[20];
    int sz;

    vec() {
        sz = 0;
        memset(val, 0, sizeof(val));
    }

    size_t size() {
        return sz;
    }

    void resize(int x) {
        sz = x;
    }

    bool empty() {
        return sz == 0;
    }

    long long& operator [](int x) {
        return val[x];
    }

    void push_back(long long x) {
        val[sz++] = x;
    }

    long long& back() {
        return val[sz - 1];
    }

    void pop_back() {
        --sz;
    }
};

struct uInt {
    vec a;

    friend uInt operator + (uInt x, uInt y) {
        uInt res = x;
        if (res.a.size() < y.a.size()) res.a.resize(y.a.size());
        for (int i = 0; i < (int)res.a.size(); ++i) {
            res.a[i] += (i < (int)y.a.size() ? y.a[i] : 0);
            if (res.a[i] >= B) {
                res.a[i] -= B;
                if (i + 1 == (int)res.a.size()) res.a.push_back(0);
                ++res.a[i + 1];
            }
        }
        return res;
    }

    friend uInt operator - (uInt x, uInt y) {
        uInt res = x;
        for (int i = 0; i < (int)res.a.size(); ++i) {
            res.a[i] -= (i < (int)y.a.size() ? y.a[i] : 0);
            if (res.a[i] < 0) {
                res.a[i] += B, --res.a[i + 1];
            }
        }
        while (!res.a.empty() && res.a.back() == 0) res.a.pop_back();
        return res;
    }

    friend bool operator < (uInt x, uInt y) {
        if (x.a.size() != y.a.size()) return x.a.size() < y.a.size();
        for (int i = (int)x.a.size() - 1; ~i; --i) {
            if (x.a[i] != y.a[i]) return x.a[i] < y.a[i];
        }
        return 0;
    }
};

struct Int {
    int sgn;
    uInt a;

    friend Int operator + (Int x, Int y) {
        Int res;
        if (x.sgn == y.sgn) {
            res.sgn = x.sgn;
            res.a = x.a + y.a;
        } else {
            if (x.a < y.a) swap(x, y);
            res.sgn = x.sgn;
            res.a = x.a - y.a;
            if (res.a.a.empty()) res.sgn = 1;
        }
        return res;
    }

    friend Int operator - (Int x, Int y) {
        if (!y.a.a.empty()) y.sgn ^= 1;
        return x + y;
    }

    friend bool operator < (Int x, Int y) {
        if (x.sgn != y.sgn) return x.sgn < y.sgn;
        if (x.sgn == 1) return x.a < y.a;
        return y.a < x.a;
    }

    int zero() {
        int cnt = 0;
        for (int i = 0; i < (int)a.a.size(); ++i) {
            for (int j = 0; j < L; ++j) {
                if (!((a.a[i] >> j) & 1)) ++cnt;
                else break;
            }
            if (cnt != (i + 1) * L) break;
        }
        return cnt;
    }

    void print() {
        if (a.a.empty()) {
            puts("0");
            return;
        }
        assert(sgn == 1);
        string S = "";
        for (int i = (int)a.a.size() - 1; ~i; --i) {
            for (int j = 31; ~j; --j) {
                S = mul2(S);
                if ((a.a[i] >> j) & 1) S = add1(S);
            }
        }
        puts(S.c_str());
    }
};

Int f[N][N], g[N][N];
mt19937_64 rnd;

Int Rand() {
    Int res;
    res.sgn = 1;
    for (int i = 0; i < I; ++i) res.a.a.push_back(0);
    for (int i = 0; i < I; ++i) res.a.a.push_back(rnd() % B);
    return res;
}

Int pw2(int p) {
    Int res;
    res.sgn = 1;
    while (1) {
        if (p >= L) res.a.a.push_back(0), p -= L;
        else {
            res.a.a.push_back(1ll << p), p = 0;
            break;
        }
    }
    return res;
}

Int d2(Int x) {
    Int res;
    res.sgn = x.sgn, res.a = x.a;
    for (int i = (int)res.a.a.size() - 1; ~i; --i) {
        if (res.a.a[i] & 1) res.a.a[i - 1] += B;
        res.a.a[i] >>= 1;
    }
    while (!res.a.a.empty() && res.a.a.back() == 0) res.a.a.pop_back();
    return res;
}

int p;

int getP() {
    int res = 0;
    for (int i = 0; i < K; ++i) {
        for (int j = n + 1; j >= 1; --j) {
            for (int k = m + 1; k >= 1; --k) {
                if (j > n || k > m || c1[j][k] == 0) {
                    f[j][k] = Rand();
                } else {
                    f[j][k] = d2(f[j][k + 1] + f[j + 1][k]);
                }
            }
        }
        res = max(res, L * I - f[1][1].zero());
    }
    return res;
}

int tc;
Int mf[K][N][N], mg[K][N][N];

void genP(int p) {
    for (int i = 0; tc != K; ++i) {
        for (int j = n + 1; j >= 1; --j) {
            for (int k = m + 1; k >= 1; --k) {
                if (j > n || k > m || c1[j][k] == 0) {
                    f[j][k] = Rand();
                } else {
                    f[j][k] = d2(f[j][k + 1] + f[j + 1][k]);
                    g[j][k] = d2(f[j][k + 1] - f[j + 1][k]);
                }
            }
        }
        if (L * I - f[1][1].zero() == p) {
            for (int j = 1; j <= n; ++j) {
                for (int k = 1; k <= m; ++k) {
                    mf[tc][j][k] = f[j][k], mg[tc][j][k] = g[j][k];
                }
            }
            ++tc;
        }
    }
}

Int pwP, dlt[K], id[K], inv[K], eq[K];

Int trans(Int x) {
    int len = p;
    Int res;
    res.sgn = x.sgn, res.a.a.resize((len + L - 1) / L);
    for (int ri = L * I - 1, li; ri > L * I - 1 - len; ri = li - 1) {
        int rj = ri - (L * I - 1 - len) - 1;
        li = ri - min(ri & 31, rj & 31);
        int lj = li - (L * I - 1 - len) - 1;
        res.a.a[rj >> 5] |= ((x.a.a[ri >> 5] >> (li & 31)) & ((1ll << (ri - li + 1)) - 1)) << (lj & 31);
    }
    if (res.sgn == 0) res = res + pwP;
    return res;
}

Int mod(Int x, int y) {
    assert(x.sgn == 1);
    x.a.a.resize((y + L - 1) / L);
    if (y % L != 0) {
        x.a.a.back() &= ((1ll << (y % L)) - 1);
    }
    return x;
}

Int prod(Int x, Int y, int p) {
    assert(x.sgn == 1 && y.sgn == 1);
    if (x.a.a.size() == 0) return x;
    if (y.a.a.size() == 0) return y;
    Int res;
    res.sgn = 1;
    vector<__int128> tmp(x.a.a.size() + y.a.a.size() - 1);
    for (int i = 0; i < (int)x.a.a.size(); ++i) {
        for (int j = 0; j < (int)y.a.a.size() && (i + j) * L < p; ++j) {
            tmp[i + j] += (__int128)x.a.a[i] * y.a.a[j];
        }
    }
    for (int i = 0; i < (int)tmp.size(); ++i) {
        if (tmp[i] >= B) {
            if (i + 1 == (int)tmp.size()) tmp.push_back(0);
            tmp[i + 1] += tmp[i] >> L, tmp[i] &= (B - 1);
        }
    }
    for (int i = 0; i < (int)tmp.size(); ++i) {
        res.a.a.push_back(tmp[i]);
    }
    return mod(res, p);
}

Int Inv(Int x, int y) {
    if (y <= 2) return x;
    Int res = x;
    for (int i = 1; i <= y - 3; ++i) {
        x = prod(x, x, y), res = prod(res, x, y);
    }
    return res;
}

Int solve(int id) {
    if (dlt[id].a.a.empty()) return dlt[id];
    int len = L * I - dlt[id].zero();
    if (len > p) return Rand();
    Int mul = trans(dlt[id]), ans = prod(mul, inv[id], p);
    return ans;
}

signed main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; ++i) {
        string S; cin >> S, S = ' ' + S;
        for (int j = 1; j <= m; ++j) {
            c1[i][j] = (S[j] == '.' ? 0 : (S[j] == 'v' ? 1 : 2));
        }
    }
    for (int i = 1; i <= n; ++i) {
        string S; cin >> S, S = ' ' + S;
        for (int j = 1; j <= m; ++j) {
            c2[i][j] = (S[j] == '.' ? 0 : (S[j] == 'v' ? 1 : 2));
        }
    }
    p = getP(), pwP = pw2(p), genP(p);
    for (int i = 0; i < K; ++i) {
        id[i] = mf[i][1][1], inv[i] = Inv(trans(id[i]), p);
        for (int j = 1; j <= n; ++j) {
            for (int k = 1; k <= m; ++k) {
                if (c2[j][k] == 1) dlt[i] = dlt[i] + mg[i][j][k];
                if (c1[j][k] == 1) dlt[i] = dlt[i] - mg[i][j][k];
            }
        }
        eq[i] = solve(i);
    }
    for (int t = 1; t <= q + 1; ++t) {
        if (t != 1) {
            int opt, x, y; scanf("%d%d%d", &opt, &x, &y);
            for (int i = 0; i < K; ++i) {
                if ((opt == 1) ^ ((opt == 1 ? c1 : c2)[x][y] == 1)) dlt[i] = dlt[i] - mg[i][x][y];
                else dlt[i] = dlt[i] + mg[i][x][y];
            }
            for (int i = 0; i < K; ++i) {
                eq[i] = solve(i);
                if (eq[0] < eq[i] || eq[i] < eq[0]) break;
            }
            (opt == 1 ? c1 : c2)[x][y] ^= 3;
        }
        int flg = 1;
        for (int i = 1; i < K; ++i) {
            if (eq[0] < eq[i] || eq[i] < eq[0]) {
                flg = 0;
                break;
            }
        }
        if (!flg) puts("-1");
        else {
            Int ans = eq[0];
            if (pwP - ans < ans) ans = pwP - ans;
            ans.print();
        }
    }
    return 0;
}