#include <bits/stdc++.h>

// #define int int64_t

const int kMaxN = 1.2e5 + 5, kLog = 18;

int n, m, q, cr, cb;
int a[kMaxN], nxt[kLog][kLog][kMaxN], rx[kMaxN], bx[kMaxN], lg[kMaxN], prer[kMaxN];
int64_t sumr[kLog][kLog][kMaxN], sumb[kLog][kLog][kMaxN];
std::string s;

struct SGT {
  std::vector<std::pair<int, int>> v[kMaxN * 4];

  int func(int x, int val) {
    auto it = std::upper_bound(v[x].begin(), v[x].end(), std::pair<int, int>(val, 1e9)) - 1;
    return val + it->second;
  }

  void pushup(int x) {
    int ls = (x << 1), rs = (x << 1 | 1);
    for (int i = 0; i < (int)v[ls].size(); ++i) {
      auto [L, val] = v[ls][i];
      int R = (i + 1 == (int)v[ls].size() ? n + 1 : v[ls][i + 1].first);
      auto itl = std::lower_bound(v[rs].begin(), v[rs].end(), std::pair<int, int>(L + val, -1e9));
      auto itr = std::lower_bound(v[rs].begin(), v[rs].end(), std::pair<int, int>(R + val, -1e9));
      v[x].emplace_back(L, 0);
      for (auto it = itl; it != itr; ++it) {
        v[x].emplace_back(it->first - val, 0);
      }
    }
    std::sort(v[x].begin(), v[x].end());
    v[x].erase(std::unique(v[x].begin(), v[x].end()), v[x].end());
    for (auto &[xx, val] : v[x]) {
      val = func(rs, func(ls, xx)) - xx;
    }
  }

  void build(int x, int l, int r) {
    if (l == r) {
      if (n - a[l] > 0) {
        v[x].emplace_back(0, a[l] + 1);
        if (n - a[l] <= a[l] - 1) v[x].emplace_back(n - a[l], a[l] - n);
      } else {
        v[x].emplace_back(0, a[l] - n);
      }
      if (a[l] < n + 1 - a[l]) {
        v[x].emplace_back(a[l], a[l]);
        v[x].emplace_back(n - a[l] + 1, a[l] - (n + 1));
      } else {
        v[x].emplace_back(a[l], a[l] - (n + 1));
      }
      std::sort(v[x].begin(), v[x].end());
      return;
    }
    int mid = (l + r) >> 1;
    build(x << 1, l, mid), build(x << 1 | 1, mid + 1, r);
    pushup(x);
  }

  int query(int x, int l, int r, int ql, int qr, int val) {
    if (l > qr || r < ql) {
      return val;
    } else if (l >= ql && r <= qr) {
      return func(x, val);
    }
    int mid = (l + r) >> 1;
    return query(x << 1 | 1, mid + 1, r, ql, qr, query(x << 1, l, mid, ql, qr, val));
  }
} sgt;

void prework() {
  sgt.build(1, 1, m);

  lg[0] = -1;
  for (int i = 1; i <= 1.2e5; ++i) lg[i] = lg[i >> 1] + 1;

  for (int i = 1; i <= n; ++i) prer[i] = prer[i - 1] + (s[i] == 'R');

  for (int i = 1; i <= n + 1; ++i) {
    if (i == n + 1 || s[i] == 'B') {
      rx[++cr] = i - 1;
    }
  }
  for (int i = n; ~i; --i) {
    if (!i || s[i] == 'R') {
      bx[++cb] = n - i;
    }
  }

  for (int x = 0; x <= lg[n] + 1; ++x) {
    for (int y = 0; y <= lg[n] + 1; ++y) {
      int lenr, lenb;
      if (!x) lenr = 0;
      else lenr = (1 << (x - 1));
      if (!y) lenb = 0;
      else lenb = (1 << (y - 1));
      if (lenr + lenb > n) continue;
      for (int i = 1; i <= m; ++i) {
        sumr[x][y][i] = sumr[x][y][i - 1];
        sumb[x][y][i] = sumb[x][y][i - 1];
        if (a[i] <= lenr) sumr[x][y][i] += a[i];
        else if (n - a[i] + 1 <= lenb) sumb[x][y][i] += n - a[i];
      }
      nxt[x][y][m + 1] = m + 1;
      for (int i = m; i; --i) {
        if (a[i] > lenr && a[i] <= n - lenb) nxt[x][y][i] = i;
        else nxt[x][y][i] = nxt[x][y][i + 1];
      }
    }
  }
}

int getcntr(int l, int r) {
  if (l > r) return 0;
  return prer[r] - prer[l - 1];
}

int getcntb(int l, int r) {
  if (l > r) return 0;
  return (r - l + 1) - (prer[r] - prer[l - 1]);
}

char getch(int x, int nowr, int nowb) {
  if (x <= rx[nowr]) return 'R';
  else if (x > n - bx[nowb]) return 'B';
  else return s[x];
}

int solve(int l, int r) {
  int pos = l - 1, nowr = 1, nowb = 1, val = -1;
  for (;;) {
    if (rx[nowr] + bx[nowb] >= n) {
      val = rx[nowr];
      break;
    }
    int x = lg[rx[nowr]] + 1, y = lg[bx[nowb]] + 1;
    int nxtp = std::min(nxt[x][y][pos + 1], r + 1);
    int detr = std::min<int>(sumr[x][y][nxtp - 1] - sumr[x][y][pos], n);
    int detb = std::min<int>(sumb[x][y][nxtp - 1] - sumb[x][y][pos], n);
    // std::cerr << pos << ' ' << nxtp << ' ' << rx[nowr] << ' ' << bx[nowb] << ' ' << detr << ' ' << detb << '\n';
    if (rx[std::min(nowr + detr, cr)] + bx[std::min(nowb + detb, cb)] < n) {
      // std::cerr << pos << ' ' << nxtp << ' ' << detr << ' ' << detb << ' ' << rx[nowr] << ' ' << bx[nowb] << ' ' << rx[std::min(nowr + detr, cr)] + bx[std::min(nowb + detb, cb)] << '\n';
      nowr += detr, nowb += detb, pos = nxtp;
      if (pos == r + 1) break;
      int cntr = rx[nowr] + getcntr(rx[nowr] + 1, n - bx[nowb]);
      if (getch(a[pos], nowr, nowb) == 'B') ++cntr;
      // std::cerr <<  "!!! " << pos << ' ' << getch(a[pos], nowr, nowb) << ' ' << nxtp << ' ' << rx[nowr] << ' ' << bx[nowb] << ' ' << cntr << '\n';
      if (n - cntr >= a[pos]) { // 把前 a[pos] 个 B 变成 R
        nowr = std::min(nowr + a[pos], cr);
        if (s[a[pos]] == 'B') ++nowr;
        nowr = std::min(nowr, cr);
        // std::cerr <<  "??? " << pos << ' ' << nxtp << ' ' << rx[nowr] << ' ' << bx[nowb] << ' ' << cntr << '\n';
        if (rx[nowr] + bx[nowb] >= n) {
          val = n - (n - cntr - a[pos]);
          break;
        }
      } else { // 把后 n - a[pos] + 1 个 R 变成 B
        nowb = std::min(nowb + n - a[pos] + 1, cb + 1);
        if (s[a[pos]] == 'B') --nowb;
        // std::cerr << nowb << ' ' << rx[nowr] << ' ' << bx[nowb] << '\n';
        nowb = std::min(nowb, cb);
        if (rx[nowr] + bx[nowb] >= n) {
          val = cntr - (n - a[pos] + 1);
          break;
        }
      }
    } else {
      int L = pos, R = nxtp, res = pos;
      while (L + 1 < R) {
        int mid = (L + R) >> 1;
        int detr = std::min<int>(sumr[x][y][mid] - sumr[x][y][pos], n);
        int detb = std::min<int>(sumb[x][y][mid] - sumb[x][y][pos], n);
        if (rx[std::min(nowr + detr, cr)] + bx[std::min(nowb + detb, cb)] >= n) R = res = mid;
        else L = mid;
      }
      assert(res != pos);
      int detr = std::min<int>(sumr[x][y][res - 1] - sumr[x][y][pos], n);
      int detb = std::min<int>(sumb[x][y][res - 1] - sumb[x][y][pos], n);
      nowr += detr, nowb += detb;
      assert(nowr <= cr && nowb <= cb && rx[nowr] + bx[nowb] < n);
      int cntr = rx[nowr] + getcntr(rx[nowr] + 1, n - bx[nowb]);
      if (getch(a[res], nowr, nowb) == 'B') ++cntr;
      // std::cerr << "heige " << res << ' ' << cntr << ' ' << rx[nowr] << ' ' << bx[nowb] << '\n';
      pos = res;
      if (a[res] <= n - cntr) {
        val = cntr + a[res];
        // val = rx[nowr + a[res]];
        break;
      } else {
        // val = n - bx[nowb + n - a[res]];
        val = cntr - (n - a[res] + 1);
        break;
      }
    }
  }
  // std::cerr << "fuckkkk " << val << ' ' << pos << '\n';
  if (val == -1) {
    return rx[nowr] + getcntr(rx[nowr] + 1, n - bx[nowb]);
  } else {
    return sgt.query(1, 1, m, pos + 1, r, val);
  }
}

void dickdreamer() {
  std::cin >> n >> m >> s;
  s = " " + s;
  for (int i = 1; i <= m; ++i) std::cin >> a[i];
  prework();
  std::cin >> q;
  for (int i = 1; i <= q; ++i) {
    int l, r;
    std::cin >> l >> r;
    std::cout << solve(l, r) << '\n';
  }
}

int32_t main() {
#ifdef ORZXKR
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
#endif
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  int T = 1;
  // std::cin >> T;
  while (T--) dickdreamer();
  // std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
  return 0;
}