#include <iostream>
#include <vector>
#include <cassert>

using namespace std;
using ll = long long;
const int NMAX = 2e6;
const ll INF = 1e16 + 5;
const ll delta = 1e15;

struct function {
    ll a, b, y;
    ll eval (ll x)
    {
        if (x <= a) return 0;
        else if (a < x && x <= b) return y;
        else return x-b+y;
    }
    
    function o (function f2)
    {
    //    assert(f2.o(identity()) == f2);
        ll new_a , new_b , new_y;
        if (a < f2.y) {
            new_a = f2.a;
        }
        else if (a == f2.y)
        {
            new_a = f2.b;
        }
        else {
            new_a = a + f2.b - f2.y;
        }
        new_y = y;
        if (b < f2.y) {
            new_b = f2.b;
            new_y = f2.y - b + y;
        }
        else if (b == f2.y)
        {
            new_b = f2.b;
        }
        else {
            new_b = b + f2.b - f2.y;
        }
        if (new_a < 0) new_a = 0;
        if (new_b < 0) new_b = 0;
        
        if (new_a > INF - delta) new_a = INF;
        if (new_b > INF - delta) new_b = INF;
        if (new_y > INF - delta) new_y = INF;
        return {new_a , new_b , new_y};
    }

    static function identity(){
        function ret;
        ret = {0,0,0};
        return ret;
    }

} initial[NMAX+10] ;

template<typename data>
struct AINT {
    vector<data> aint;
    int n, offset;
    int nextPowerOf2 (int n)
    {
        int ret = 1;
        while (ret < n) ret *= 2;
        return ret;
    }
    AINT (int _n)
    {
        n = _n;
        offset = nextPowerOf2 (n);
        aint.resize(2*offset + 1, data::identity());
        for (int i = offset; i < 2 * offset; i++)
        {
            if (i-offset+1 <= n) {
                aint[i] = initial[i-offset+1];
            }
        }
        for (int i = offset-1; i > 0; i--)
        {
            aint[i] = merge(aint[2*i] , aint[2*i+1]);
        }
    }

    void update (int pos , data f)
    {
        upd (1 , 1 , offset , pos , f);
    }

    int CB (int pos , ll h)
    {
        int nod = pos + offset-1;
        data func = aint[nod];
        if (func.eval(h) == 0) return -1;
        data prev = data::identity();
        while (func.eval(h) > 0)
        {
            if ((nod & 1) && !(nod & (nod+1))){
                return n;
            }
            else if (nod % 2 == 1)
            {
                prev = func;
                nod = nod/2 + 1;
                func = aint[nod].o(func);
            }
            else {
                nod /= 2;
                func = aint[nod].o(prev);
            //    prev = data::identity();
            }
        }
        func = prev;

        while (nod < offset)
        {
            data new_func = aint[2 * nod].o(func);
            if (new_func.eval(h) > 0)
            {
                func = new_func;
                nod = 2 * nod + 1;
            }
            else {
                nod = 2 * nod;
            }
        }
        return nod-offset;
    }

    
    void upd (int nod , int l , int r , int pos , data f)
    {
        if (l == r)
        {
            if (l == pos) aint[nod] = f;
            return;
        }
        else if (pos < l || r < pos) return;
        int mid = (l + r) / 2;
        upd(2 * nod , l , mid , pos , f);
        upd(2*nod+1, mid+1 , r, pos , f);
        aint[nod] = merge(aint[2*nod] , aint[2*nod+1]);
        return;
    }

    data merge (data f1 , data f2)
    {
        return f2.o(f1);
    }

    void print ()
    {
        for (int nod = 1; nod < aint.size(); nod++)
        {
            cout << nod << ": " << aint[nod].a << ' ' << aint[nod].b << ' ' << aint[nod].y << '\n';
        }
    }
};

int main ()
{
    int teste; cin >> teste;
    while (teste--) {
        
        int n, q; cin >> n >> q;
        ll h; cin >> h;
        for (int i = 1; i <= n; i++)
        {
            char ch; cin >> ch;
            if (ch == 'B')
            {
                ll b; cin >> b;
                initial[i] = {b, b, 0};
            }
            else if (ch == 'K')
            {
                ll k; cin >> k;
                initial[i] = {k-1 , INF , k};
            }
            else {
                ll c; cin >> c;
                initial[i] = {0, c, c};
            }
        }
        AINT<function> aint(n);

        while (q--)
        {
        //    aint.print();
            char t; cin >> t;
        
            if (t == 'Z')
            {
                int x;
                char ch; cin >> x >>  ch;
                if (ch == 'B')
                {
                    ll b; cin >> b;
                    aint.update(x, {b, b, 0});
                }
                else if (ch == 'K')
                {
                    ll k; cin >> k;
                    aint.update(x, {k-1 , INF , k});
                }
                else {
                    ll c; cin >> c;
                    aint.update(x, {0, c, c});
                }
            }
            else {
                
                int pos; cin >> pos;
                
                cout << aint.CB(pos , h) << '\n';
            }
        }
    }
}