#include <bits/stdc++.h>

using namespace std;
constexpr int LOG = 20;
constexpr int INF = 1e9;

using vi = vector<int>;
#define all(c) c.begin(),c.end()
#define sz(c) (int)c.size()
#define rep(i, l, r) for(int i = l;i < r;++i)

struct SuffixArray {
    vi sa, lcp;

    SuffixArray() = default;

    SuffixArray(string &s, int lim = 256) { // or basic_string<int>
        int n = sz(s) + 1, k = 0, a, b;
        vi x(all(s)), y(n), ws(max(n, lim)), rank(n);
        x.push_back(0), sa = lcp = y, iota(all(sa), 0);
        for (int j = 0, p = 0; p < n; j = max(1, j * 2), lim = p) {
            p = j, iota(all(y), n - j);
            rep(i, 0, n) if (sa[i] >= j) y[p++] = sa[i] - j;
            fill(all(ws), 0);
            rep(i, 0, n) ws[x[i]]++;
            rep(i, 1, lim) ws[i] += ws[i - 1];
            for (int i = n; i--;) sa[--ws[x[y[i]]]] = y[i];
            swap(x, y), p = 1, x[sa[0]] = 0;
            rep(i, 1, n) a = sa[i - 1], b = sa[i], x[b] =
                        (y[a] == y[b] && y[a + j] == y[b + j]) ? p - 1 : p++;
        }
        rep(i, 1, n) rank[sa[i]] = i;
        for (int i = 0, j; i < n - 1; lcp[rank[i++]] = k)
            for (k &&k--, j = sa[rank[i] - 1];
                    s[i + k] == s[j + k];
        k++);
    }
};

struct LCP {
    SuffixArray SA;
    vector<int> pos;
    vector<vector<int>> st;

    LCP() = default;

    LCP(string &s) : SA(s) {
        int n = s.size();
        pos.resize(s.size());
        for (int i = 1; i <= n; ++i) {
            pos[SA.sa[i]] = i;
        }
        st = vector<vector<int>>(LOG, vector<int>(n + 1));
        st[0] = SA.lcp;
        for (int i = 1; i < LOG; ++i) {
            for (int j = 0; j + (1 << i) - 1 <= n; ++j) {
                st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
            }
        }
    }

    int ask(int l, int r) {
        int len = r - l + 1;
        int lg = __lg(len);
        return min(st[lg][l], st[lg][r - (1 << lg) + 1]);
    }

    int query(int x, int y) {
        if (x == y)return (pos.size() - x);
        int l = pos[x], r = pos[y];
        if (l > r)swap(l, r);
        ++l;
        return ask(l, r);
    }

    int query(int l1, int r1, int l2, int r2) {
        return min({query(l1, l2), r1 - l1 + 1, r2 - l2 + 1});
    }
};

using blocks = vector<array<int, 2>>;

struct query {
    blocks start;
    blocks end;
    int id;
};

int cmp(const blocks &lhs, const blocks &rhs, string &s, LCP &lcp) {
    int i = 0, j = 0;
    int x = 0, y = 0;
    while (i < lhs.size() && j < rhs.size()) {
        int mn = min(lhs[i][1] - lhs[i][0] + 1 - x, rhs[j][1] - rhs[j][0] + 1 - y);
        int lp = lcp.query(lhs[i][0] + x, lhs[i][1], rhs[j][0] + y, rhs[j][1]);
        x += lp, y += lp;
        if (lp == mn) {
            if (x == lhs[i][1] - lhs[i][0] + 1)++i, x = 0;
            if (y == rhs[j][1] - rhs[j][0] + 1)++j, y = 0;
            continue;
        }
        return s[lhs[i][0] + x] < s[rhs[j][0] + y] ? -1 : 1;
    }
    if (i == lhs.size() && j == rhs.size())return 0;
    if (i == lhs.size())return -1;
    return 1;
}

string s, sr;
LCP l, lr;
vector<int> what;

struct cmpf {
    bool operator()(const pair<blocks, int> &lhs, const pair<blocks, int> &rhs) const {
        int it = cmp(lhs.first, rhs.first, s, l);
        if (it == -1)return true;
        if (it == 1)return false;
        if ((what[lhs.second] == -1) == (what[rhs.second] == -1)) {
            return lhs.second < rhs.second;
        }
        if (~what[lhs.second])return true;
        return false;
    }
};

struct cmpr {
    bool operator()(const pair<blocks, int> &lhs, const pair<blocks, int> &rhs) const {
        int it = cmp(lhs.first, rhs.first, sr, lr);
        if (it == -1)return true;
        if (it == 1)return false;
        if ((what[lhs.second] == -1) == (what[rhs.second] == -1)) {
            return lhs.second < rhs.second;
        }
        if (~what[lhs.second])return true;
        return false;
    }
};

struct Fenwick {
    int n;
    vector<int> f;

    Fenwick(int n) : n(n), f(n) {}

    void upd(int i, int x) {
        for (; i < n; i |= i + 1)f[i] += x;
    }

    int get(int i) {
        int res = 0;
        for (; i >= 0; i &= i + 1, --i)res += f[i];
        return res;
    }

    int sum(int l, int r) {
        return get(r) - get(l - 1);
    }
};

int main() {
    cin.tie(0)->sync_with_stdio(false);
    int n, q;
    cin >> n >> q;
    what.resize(q, -1);
    ++n;
    cin >> s;
    s += 'z' + 1;
    sr = s;
    reverse(sr.begin(), sr.end());
    l = LCP(s), lr = LCP(sr);
    vector<blocks> a;
    vector<query> plus, minus;
    int now = 0;
    for (int i = 0; i < q; ++i) {
        char c;
        cin >> c;
        if (c == '+') {
            int k;
            cin >> k;
            blocks v(k);
            for (auto &[x, y]: v)cin >> x >> y, --x, --y;
            a.push_back(v);
            plus.push_back({v, {}, i});
        } else if (c == '-') {
            int who;
            cin >> who;
            --who;
            auto v = a[who];
            a.emplace_back();
            minus.push_back({v, {}, i});
        } else {
            int k;
            cin >> k;
            blocks start(k);
            for (auto &[x, y]: start)cin >> x >> y, --x, --y;
            int m;
            cin >> m;
            blocks end(m);
            for (auto &[x, y]: end)cin >> x >> y, --x, --y;
            a.emplace_back();
            plus.push_back({start, end, i});
            minus.push_back({start, end, i});
            what[i] = now++;
        }
    }
    auto solve = [&](const vector<query> &v) {
        vector<int> res(now);
        if(v.empty())return res;
        vector<array<int, 2>> fi(now, {INF, -INF}), se(now, {INF, -INF});
        vector<int> pos(q), posr(q);
        {
            vector<pair<blocks, int>> z;
            for (auto [s, _, id]: v) {
                z.push_back({s, id});
                if (~what[id]) {
                    s.push_back({n - 1, n - 1});
                    z.push_back({s, id});
                }
            }
            sort(z.begin(), z.end(), [&](const auto &x, const auto &y) {
                return x.first.size() < y.first.size();
            });
            set<pair<blocks, int>, cmpf> s;
            for (auto &v: z)s.insert(v);
            int ord = 0;
            for (auto &[_, it]: s) {
                if (~what[it]) {
                    fi[what[it]][0] = min(fi[what[it]][0], ord);
                    fi[what[it]][1] = max(fi[what[it]][1], ord);
                }
                pos[it] = ord;
                ++ord;
            }
        }
        {
            vector<pair<blocks, int>> z;
            for (auto [s, e, id]: v) {
                for (auto &[l, r]: s) {
                    l = n - l - 1;
                    r = n - r - 1;
                    swap(l, r);
                }
                for (auto &[l, r]: e) {
                    l = n - l - 1;
                    r = n - r - 1;
                    swap(l, r);
                }
                reverse(s.begin(), s.end());
                reverse(e.begin(), e.end());
                if (~what[id]) {
                    z.push_back({e, id});
                    e.push_back({0,0});
                    z.push_back({e, id});
                } else {
                    z.push_back({s, id});
                }
            }
            sort(z.begin(), z.end(), [&](const auto &x, const auto &y) {
                return x.first.size() < y.first.size();
            });
            set<pair<blocks, int>, cmpr> s;
            for (auto &v: z)s.insert(v);
            int ord = 0;
            for (auto &[_, it]: s) {
                if (~what[it]) {
                    se[what[it]][0] = min(se[what[it]][0], ord);
                    se[what[it]][1] = max(se[what[it]][1], ord);
                }
                posr[it] = ord;
                ++ord;
            }
        }
        vector<int> o(2 * q);
        for (auto &[_, __, id]: v) {
            o[pos[id]] = posr[id];
        }
        auto rec = [&](auto &&rec, int l, int r) -> void {
            if (l + 1 == r)return;
            int m = (r + l) / 2;
            rec(rec, l, m);
            vector<int> all, allr;
            for (int i = l; i < m; ++i) {
                auto &[_, __, id] = v[i];
                if (!~what[id]) {
                    all.push_back(pos[id]);
                    allr.push_back(posr[id]);
                }
            }
            sort(all.begin(), all.end());
            sort(allr.begin(), allr.end());
            int k = all.size();
            vector<vector<array<int, 4>>> Q(k);
            for (int i = m; i < r; ++i) {
                auto &[_, __, id] = v[i];
                if (~what[id]) {
                    int l1 = lower_bound(all.begin(), all.end(), fi[what[id]][0]) - all.begin();
                    int r1 = upper_bound(all.begin(), all.end(), fi[what[id]][1]) - all.begin() - 1;
                    int l2 = lower_bound(allr.begin(), allr.end(), se[what[id]][0]) - allr.begin();
                    int r2 = upper_bound(allr.begin(), allr.end(), se[what[id]][1]) - allr.begin() - 1;
                    if (l1 > r1 || l2 > r2)continue;
                    Q[r1].push_back({l2, r2, what[id], 1});
                    if (--l1 >= 0)Q[l1].push_back({l2, r2, what[id], -1});
                }
            }
            Fenwick fw(k);
            for (int i = 0; i < k; ++i) {
                int it = lower_bound(allr.begin(), allr.end(), o[all[i]]) - allr.begin();
                fw.upd(it, 1);
                for (auto &[lq, rq, id, sgn]: Q[i]) {
                    res[id] += sgn * fw.sum(lq, rq);
                }
            }
            rec(rec, m, r);
        };
        rec(rec, 0, v.size());
        return res;
    };
    auto ra = solve(plus);
    auto rm = solve(minus);
    for (int i = 0; i < now; ++i) {
        cout << ra[i] - rm[i] << "\n";
    }
}