#include <bits/stdc++.h>
using namespace std;
using ll=long long;
const ll ILL=2167167167167167167;
const int INF=2100000000;
#define rep(i,a,b) for (int i=(int)(a);i<(int)(b);i++)
#define all(p) p.begin(),p.end()
template<class T> using pq_ = priority_queue<T, vector<T>, greater<T>>;
template<class T> int LB(vector<T> &v,T a){return lower_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> int UB(vector<T> &v,T a){return upper_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> bool chmin(T &a,T b){if(b<a){a=b;return 1;}else return 0;}
template<class T> bool chmax(T &a,T b){if(a<b){a=b;return 1;}else return 0;}
template<class T> void So(vector<T> &v) {sort(v.begin(),v.end());}
template<class T> void Sore(vector<T> &v) {sort(v.begin(),v.end(),[](T x,T y){return x>y;});}
bool yneos(bool a,bool upp=false){if(a){cout<<(upp?"YES\n":"Yes\n");}else{cout<<(upp?"NO\n":"No\n");}return a;}
template<class T> void vec_out(vector<T> &p,int ty=0){
    if(ty==2){cout<<'{';for(int i=0;i<(int)p.size();i++){if(i){cout<<",";}cout<<'"'<<p[i]<<'"';}cout<<"}\n";}
    else{if(ty==1){cout<<p.size()<<"\n";}for(int i=0;i<(int)(p.size());i++){if(i) cout<<" ";cout<<p[i];}cout<<"\n";}}
template<class T> T vec_min(vector<T> &a){assert(!a.empty());T ans=a[0];for(auto &x:a) chmin(ans,x);return ans;}
template<class T> T vec_max(vector<T> &a){assert(!a.empty());T ans=a[0];for(auto &x:a) chmax(ans,x);return ans;}
template<class T> T vec_sum(vector<T> &a){T ans=T(0);for(auto &x:a) ans+=x;return ans;}
int pop_count(long long a){int res=0;while(a){res+=(int)(a&1),a>>=1;}return res;}
template<class T> T square(T a){return a * a;}

using u64 = u_int64_t;
#define sz(a) a.size()
u64 B = 64;
struct FastSet {
    u64 size;
    vector<vector<u64>> a;
    FastSet(u64 n) : size(n) {
        do a.emplace_back(n = (n + B - 1) / B);
        while(n > 1);
    }
    bool operator[](ll i) { return a[0][i / B] >> (i % B) & 1; }
    void set(ll i) {
        for(auto& v : a) {
            v[i / B] |= 1ULL << (i % B);
            i /= B;
        }
    }
    void reset(ll i) {
        for(auto& v : a) {
            v[i / B] &= ~(1ULL << (i % B));
            if(v[i / B]) break;
            i /= B;
        }
    }
    ll next(ll i) {  // i を超える最⼩の要素
        rep(h, 0, sz(a)) {
            i++;
            if(i / B >= sz(a[h])) break;
            u64 d = a[h][i / B] >> (i % B);
            if(d) {
                i += countr_zero(d);
                while(h--) i = i * B + countr_zero(a[h][i]);
                return i;
            }
            i /= B;
        }
        return size;
    }
    ll prev(ll i) {  // i より小さい最⼤の要素
        rep(h, 0, sz(a)) {
            i--;
            if(i < 0) break;
            u64 d = a[h][i / B] << (~i % B);
            if(d) {
                i -= countl_zero(d);
                while(h--) i = i * B + __lg(a[h][i]);
                return i;
            }
            i /= B;
        }
        return -1;
    }
};


namespace po167{
    struct Mo{
        std::vector<int> left,right,order;
        int width,nl,nr,index,_n;
        Mo(int n):width((int) std::sqrt(n)),nl(0),nr(0),index(0),_n(0){}

        //[l,r)
        void insert(int l,int r){
            assert(l<=r);
            left.push_back(l);
            right.push_back(r);
        }

        void bulid(){
            //width=(int)((double)_n/std::max((double)1,sqrt((int)(left.size()))));
            width=max(1,width);
            order.resize((int)left.size());
            std::vector<int> order1((int)left.size());
            std::iota(order1.begin(),order1.end(),0);
            auto order2=order1;
            std::sort(order1.begin(),order1.end(),[&](int a,int b){
                if(left[a]/width!=left[b]/width){
                    return left[a]>left[b];
                }
                else if((left[a]/width)&1){
                    return right[a]<right[b];
                }
                return right[a]>right[b];
            });
            std::sort(order2.begin(),order2.end(),[&](int a,int b){
                if((width/2+left[a])/width!=(width/2+left[b])/width){
                    return left[a]>left[b];
                }
                else if(((width/2+left[a])/width)&1){
                    return right[a]<right[b];
                }
                return right[a]>right[b];
            });
            int score1=0,score2=0;
            for(int i=1;i<(int)(left.size());i++){
                score1+=std::abs(left[order1[i]]-left[order1[i-1]]);
                score1+=std::abs(right[order1[i]]-right[order1[i-1]]);
                score2+=std::abs(left[order2[i]]-left[order2[i-1]]);
                score2+=std::abs(right[order2[i]]-right[order2[i-1]]);
            }
            if(score1<score2) order=order1;
            else order=order2;
        }
    };
}
using po167::Mo;

void solve();
// DEAR MYSTERIES / TOMOO
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t = 1;
    // cin >> t;
    rep(i, 0, t) solve();
}

void solve(){
    int N, Q;
    cin >> N >> Q;
    const int s = 10'000'100;
    vector<int> ex(s);
    FastSet dif(s);
    FastSet mo(N);
    vector<int> A(N);
    rep(i, 0, N) cin >> A[i];
    vector<int> order(N);
    rep(i, 0, N) order[i] = i;
    sort(all(order), [&](int l, int r){
        return A[l] < A[r];
    });
    vector<int> inv(N);
    rep(i, 0, N) inv[order[i]] = i;
    vector<int> ans(Q);
    vector<int> L(Q), R(Q);
    vector<int> X(Q);
    vector<char> C(Q);
    Mo M(N);
    rep(i, 0, Q) {
        cin >> L[i] >> R[i] >> X[i] >> C[i];
        L[i]--, M.insert(L[i], R[i]);
    }
    M.bulid();
    mo.set(inv[0]);
    int l = 0, r = 1;
    auto del_diff = [&](int v) -> void {
        if (ex[v] == 1){
            dif.reset(v);
        }
        ex[v]--;
    };
    auto add_diff = [&](int v) -> void {
        if (ex[v] == 0){
            dif.set(v);
        }
        ex[v]++;
    };
    auto add = [&](int id) -> void {
        int lv = mo.prev(inv[id]);
        int rv = mo.next(inv[id]);
        if (lv != -1) lv = order[lv];
        if (rv != N) rv = order[rv];
        else rv = -1;
        if (lv != -1 && rv != -1){
            del_diff(A[rv] - A[lv]);
        }
        if (rv != -1){
            add_diff(A[rv] - A[id]);
        }
        if (lv != -1){
            add_diff(A[id] - A[lv]);
        }
        mo.set(inv[id]);
    };
    auto del = [&](int id) -> void {
        mo.reset(inv[id]);
        int lv = mo.prev(inv[id]);
        int rv = mo.next(inv[id]);
        if (lv != -1) lv = order[lv];
        if (rv != N) rv = order[rv];
        else rv = -1;
        if (lv != -1 && rv != -1){
            add_diff(A[rv] - A[lv]);
        }
        if (rv != -1){
            del_diff(A[rv] - A[id]);
        }
        if (lv != -1){
            del_diff(A[id] - A[lv]);
        }
    };
    for (auto id : M.order){
        while (r < R[id]){
            add(r++);
        }
        while (l > L[id]){
            add(--l);
        }
        while (l < L[id]){
            del(l++);
        }
        while (r > R[id]){
            del(--r);
        }
        if (C[id] == 'R'){
            ans[id] = dif.next(X[id] - 1);
        }
        else{
            ans[id] = dif.prev(X[id] + 1);
        }
    }
    for (auto x : ans){
        if (x == dif.size) cout << "-1\n";
        else cout << x << "\n";
    }
}