//code by Nobody.Emissary
#include <bits/stdc++.h>

using namespace std;

const int MAXN = 3e5 + 5;
const int mod = 1e9 + 7;

int n, q;
int tree[MAXN << 2], tag[MAXN << 2], pre[MAXN], powc[MAXN];

char t[MAXN], a[3][MAXN], b[MAXN];

map<int, bool> M;

inline int HashCode(char *x) {
    int now = 0;

    for (int i = 1; i <= n; ++i)
        now = (13331ll * now + x[i] - 'A' + 1) % mod;

    return now;
}

inline void pushup(int p) {
    tree[p] = (tree[p << 1] + tree[p << 1 | 1]) % mod;
}

inline void pushdown(int p, int l, int r) {
    int mid = (l + r) >> 1;

    if (tag[p]) {
        tree[p << 1] = 1ll * (pre[mid] - pre[l - 1] + mod) * tag[p] % mod;
        tree[p << 1 | 1] = 1ll * (pre[r] - pre[mid] + mod) * tag[p] % mod;
        tag[p << 1] = tag[p << 1 | 1] = tag[p];
        tag[p] = 0;
    }

    return ;
}

inline void build(int p, int l, int r) {
    if (l == r)
        return tree[p] = 1ll * (pre[r] - pre[r - 1] + mod) * (t[l] - 'A' + 1) % mod, void();

    int mid = (l + r) >> 1;
    build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
    return pushup(p);
}

inline void cov(int p, int l, int r, int L, int R, int v) {
    if (L <= l && r <= R)
        return tree[p] = 1ll * (pre[r] - pre[l - 1] + mod) * v % mod, tag[p] = v, void();

    int mid = (l + r) >> 1;
    pushdown(p, l, r);

    if (L <= mid)
        cov(p << 1, l, mid, L, R, v);

    if (R > mid)
        cov(p << 1 | 1, mid + 1, r, L, R, v);

    return pushup(p);
}

int main() {
    scanf("%d", &n);
    powc[0] = 1;

    for (int i = 1; i <= n; ++i)
        powc[i] = 1ll * powc[i - 1] * 13331 % mod;

    for (int i = 1; i <= n; ++i)
        pre[i] = (pre[i - 1] + powc[n - i]) % mod;

    for (int i = 0; i <= 2; ++i)
        scanf("%s", a[i] + 1);

    int p[3];

    for (int i = 0; i <= 2; ++i)
        p[i] = i;

    do {
        for (int i = 1; i < 8; ++i) {
            bool o = 0;

            for (int j = 0; j <= 2; ++j) {
                if ((i >> j) & 1) {
                    if (o) {
                        for (int k = 1; k <= n; ++k) {
                            if (b[k] == a[p[j]][k])
                                continue;

                            if (b[k] != a[p[j]][k]) {
                                b[k] = (int)'J' + 'O' + 'I' - b[k] - a[p[j]][k];
                            }
                        }
                    } else {
                        o = 1;

                        for (int k = 1; k <= n; ++k)
                            b[k] = a[p[j]][k];
                    }
                }
            }

            M[HashCode(b)] = 1;
        }
    } while (next_permutation(p, p + 3));

    scanf("%d", &q);
    scanf("%s", t + 1);
    build(1, 1, n);

    if (M[tree[1]])
        puts("Yes");
    else
        puts("No");

    while (q--) {
        int l, r;
        char c[2];
        scanf("%d%d%s", &l, &r, c + 1);
        cov(1, 1, n, l, r, c[1] - 'A' + 1);
        puts(M[tree[1]] ? "Yes" : "No");
    }

    return 0;
}