#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <bitset>
#include <cmath>
#include <queue>
using namespace std;

#define x first

#define y second


typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<double, double> PDD;
typedef pair<LD, int> PLDI;
typedef pair<LD, LD> PLDLD;
typedef pair<PII, int> PIII;
const int N = 1000010, M = 2 * N, U = 200000, P = 13331, INF = 1e9 + 10, mod = 998244353;
const double PI = acos(-1);

int T, n, m, k;
struct Node {
    int l, r;
    int lx, rx, ly, ry;
    int dx, dy;
} tr[N * 4];
char str[N];

void pushup(int x) {
    auto &u = tr[x], &l = tr[x * 2], &r = tr[x * 2 + 1];
    if (l.rx != 0 && r.rx != 0) {
        int nl = l.lx + l.dx, nr = l.rx + l.dx;
        if (max(r.lx, nl) > min(r.rx, nr)) {
            u.lx = 1, u.rx = 0;
            if (nr < r.lx)
                u.dx = r.dx + r.lx;
            else
                u.dx = r.dx + r.rx;
        } else {
            u.lx = max(l.lx, r.lx - l.dx), u.rx = min(l.rx, r.rx - l.dx);
            u.dx = l.dx + r.dx;
        }
    } else if (l.rx == 0 && r.rx != 0) {
        u.lx = 1, u.rx = 0;
        int t = l.dx;
        if (t >= r.lx && t <= r.rx)
            u.dx = t + r.dx;
        else if (t < r.lx)
            u.dx = r.lx + r.dx;
        else
            u.dx = r.rx + r.dx;
    } else {
        u.lx = 1, u.rx = 0;
        u.dx = r.dx;
    }
    //
    if (l.ry != 0 && r.ry != 0) {
        int nl = l.ly + l.dy, nr = l.ry + l.dy;
        if (max(r.ly, nl) > min(r.ry, nr)) {
            u.ly = 1, u.ry = 0;
            if (nr < r.ly)
                u.dy = r.dy + r.ly;
            else
                u.dy = r.dy + r.ry;
        } else {
            u.ly = max(l.ly, r.ly - l.dy), u.ry = min(l.ry, r.ry - l.dy);
            u.dy = l.dy + r.dy;
        }
    } else if (l.ry == 0 && r.ry != 0) {
        u.ly = 1, u.ry = 0;
        int t = l.dy;
        if (t >= r.ly && t <= r.ry)
            u.dy = t + r.dy;
        else if (t < r.ly)
            u.dy = r.ly + r.dy;
        else
            u.dy = r.ry + r.dy;
    } else {
        u.ly = 1, u.ry = 0;
        u.dy = r.dy;
    }
}

void build(int u, int l, int r) {
    tr[u] = { l, r };
    if (tr[u].l == tr[u].r) {
        if (str[l] == 'U')
            tr[u] = { l, r, 2, n, 1, n, -1, 0 };
        else if (str[l] == 'D')
            tr[u] = { l, r, 1, n - 1, 1, n, 1, 0 };
        else if (str[l] == 'L')
            tr[u] = { l, r, 1, n, 2, n, 0, -1 };
        else
            tr[u] = { l, r, 1, n, 1, n - 1, 0, 1 };
        //		cout<<l<<' '<<r<<' '<<tr[u].ly<<' '<<tr[u].ry<<endl;
        return;
    }
    int mid = l + r >> 1;
    build(u * 2, l, mid), build(u * 2 + 1, mid + 1, r);
    pushup(u);
    //	cout<<l<<' '<<r<<' '<<tr[u].ly<<' '<<tr[u].ry<<endl;
}

void modify(int u, int pos, char c) {
    if (tr[u].l == tr[u].r) {
        int l = tr[u].l, r = tr[u].r;
        if (c == 'U')
            tr[u] = { l, r, 2, n, 1, n, -1, 0 };
        else if (c == 'D')
            tr[u] = { l, r, 1, n - 1, 1, n, 1, 0 };
        else if (c == 'L')
            tr[u] = { l, r, 1, n, 2, n, 0, -1 };
        else
            tr[u] = { l, r, 1, n, 1, n - 1, 0, 1 };
        return;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    if (pos <= mid)
        modify(u * 2, pos, c);
    else
        modify(u * 2 + 1, pos, c);
    pushup(u);
}

int get(int u, int d, int type) {
    if (!type) {
        if (tr[u].rx == 0)
            return tr[u].dx;
        else if (d >= tr[u].lx && d <= tr[u].rx)
            return d + tr[u].dx;
        else if (d < tr[u].lx)
            return tr[u].lx + tr[u].dx;
        else
            return tr[u].rx + tr[u].dx;
    } else {
        if (tr[u].ry == 0)
            return tr[u].dy;
        else if (d >= tr[u].ly && d <= tr[u].ry)
            return d + tr[u].dy;
        else if (d < tr[u].ly)
            return tr[u].ly + tr[u].dy;
        else
            return tr[u].ry + tr[u].dy;
    }
}

int query(int u, int l, int r, int d, int type) {
    if (tr[u].l >= l && tr[u].r <= r)
        return get(u, d, type);
    int mid = tr[u].l + tr[u].r >> 1;
    int t = d;
    if (l <= mid)
        t = query(u * 2, l, r, t, type);
    if (r > mid)
        t = query(u * 2 + 1, l, r, t, type);
    return t;
}

int main() {
    //	freopen("5.in","r",stdin);
    //	freopen("5.out","w",stdout);
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d%d%s", &n, &m, &k, str + 1);
        build(1, 1, m);
        // 		cout<<tr[1].ly<<' '<<tr[1].ry<<' '<<tr[1].dy<<endl;
        while (k--) {
            int op;
            scanf("%d", &op);
            if (op == 1) {
                int x, y, l, r;
                scanf("%d%d%d%d", &x, &y, &l, &r);
                int ansx = query(1, l, r, x, 0), ansy = query(1, l, r, y, 1);
                printf("%d %d\n", ansx, ansy);
            } else {
                int pos;
                char op[2];
                scanf("%d%s", &pos, op);
                modify(1, pos, *op);
            }
        }
    }
    return 0;
}