#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,sse3")
#include <iostream>
#include <vector>
#include <string>
#include <math.h>
#include <cmath>
#include <iomanip>
#include <cstdio>
#include <algorithm>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <bitset>
#include <cstring>
#include <unordered_map>

using namespace std;
typedef long long ll;

#define endl '\n'

ll t[4 * 120007], mod[4 * 120007];
ll n, m;

void build(ll v, ll l, ll r, string &a){
    if(l == r){
        t[v] = (a[l] == '>' ? 1 : 0);
        mod[v] = -1;
        return;
    }
    
    ll mid = (l + r) >> 1;
    build(2 * v, l, mid, a);
    build(2 * v + 1, mid + 1, r, a);
    
    t[v] = t[2 * v] + t[2 * v + 1];
    mod[v] = -1;
}

void push(ll v, ll l, ll r){
    if(l != r && mod[v] != -1){
        ll mid = (l + r) >> 1;
        
        t[2 * v] = (mid - l + 1) * mod[v];
        t[2 * v + 1] = (r - mid) * mod[v];
        
        mod[2 * v] = mod[v];
        mod[2 * v + 1] = mod[v];
        
        mod[v] = -1;
    }
}

void update(ll v, ll l, ll r, ll ql, ll qr, ll val){
    if(r < ql || qr < l)
        return;
    
    if(ql <= l && r <= qr){
        t[v] = (r - l + 1) * val;
        mod[v] = val;
        
        return;
    }
    
    ll mid = (l + r) >> 1;
    push(v, l, r);
    
    update(2 * v, l, mid, ql, qr, val);
    update(2 * v + 1, mid + 1, r, ql, qr, val);
    
    t[v] = t[2 * v] + t[2 * v + 1];
}

ll getsum(ll v, ll l, ll r, ll ql, ll qr){
    if(r < ql || qr < l)
        return 0;
    
    if(ql <= l && r <= qr)
        return t[v];
    
    ll mid = (l + r) >> 1;
    push(v, l, r);
    
    return getsum(2 * v, l, mid, ql, qr) + getsum(2 * v + 1, mid + 1, r, ql, qr);
}

ll getk1(ll v, ll l, ll r, ll pref, ll k){
    if(pref < l)
        return -1;
        
    if(l == r)
        return l;
    
    push(v, l, r);
    ll mid = (l + r) >> 1;
    
    if(pref <= mid || t[2 * v] >= k)
        return getk1(2 * v, l, mid, pref, k);
    
    return getk1(2 * v + 1, mid + 1, r, pref, k - t[2 * v]);
}
ll getk0(ll v, ll l, ll r, ll pref, ll k){
    if(pref < l)
        return -1;
        
    if(l == r)
        return l;
    
    push(v, l, r);
    ll mid = (l + r) >> 1;
    
    if(pref <= mid || (mid - l + 1) - t[2 * v] >= k)
        return getk0(2 * v, l, mid, pref, k);
    
    return getk0(2 * v + 1, mid + 1, r, pref, k - ((mid - l + 1) - t[2 * v]));
}

string simulation(string a, ll p){
    for(int i = 1; i < a.size(); i++)
        a[i] = (a[i] == '>' ? 'R' : 'B');
    a[p] = 'R';
    while(p >= 1 && p <= n){
        if(a[p] == 'R'){
            a[p] = 'B';
            p++;
        }
        else{
            a[p] = 'R';
            p--;
        }
    }
    for(int i = 1; i < a.size(); i++)
        a[i] = (a[i] == 'R' ? '>' : '<');
    
    return a;
}

int main(){
//    n = 5;
//    cout << simulation("#BBBBB", 4) << endl;
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    
    cin >> n >> m;
    
    string a;
    cin >> a;
    
    for(auto &i: a)
        i = (i == 'R' ? '>' : '<');
    a = "#" + a;
    
    vector<ll> d(m + 1);
    for(int i = 1; i <= m; i++)
        cin >> d[i];
    
    ll q;
    cin >> q;
    
    auto a0 = a;
    while(q--){
        ll l, r;
        cin >> l >> r;
        
        a = a0;
        
        build(1, 1, n, a);
          
        for(int i = l; i <= r; i++){
            ll left0 = 0, right = 0;
            
            ll p = d[i];
            update(1, 1, n, p, p, 1);
            
            if(p != 1)
                left0 = getsum(1, 1, n, 1, p - 1);
            if(p != n)
                right = (n - p) - getsum(1, 1, n, p + 1, n);
                        
            if(left0 >= right){
                // sufix to '<'
                
                ll need = right;
                // find need-th obstacle (ie '>', 1) on the prefix
                
                need = left0 - right + 1;
                
                ll cur = p;
                
                if(need != 0 && p != 1)
                    cur = getk1(1, 1, n, n, need);
                
                update(1, 1, n, cur, n, 0);
            }
            else{
                // prefix to '>'
                
                ll need = left0 + 1;
                // find need-th obstacle (ie '<', 0) on sufix
                ll cur = p;
                
                if(p != 1)
                    need = need + (p - 1) - getsum(1, 1, n, 1, p - 1);
                
                if(p != n)
                    cur = getk0(1, 1, n, n, need);
                
                //cout << need << ' ' << cur << endl;
                
                update(1, 1, n, 1, cur, 1);
            }
            
            //a = simulation(a, p);
//            cout << a << endl;
//            for(int i = 1; i <= n; i++)
//                cout << getsum(1, 1, n, i, i) << ' ';
//            cout << endl;
        }

        
        ll ans = getsum(1, 1, n, 1, n);
        cout << ans << endl;
    }
    
    return 0;
}
/*
 10 10
 RRRBBBBBBB
 3 1 4 1 5 9 2 6 5 3
 1
 5 6
 
 */