#include<bits/stdc++.h>
using namespace std;
 
using pii=pair<int,int>;
 
const int N=3e6+1e3+7,M=2e5+1e3+7;
 
string s;
 
struct SA {
    int sa[M],wa[M],wb[M],wv[M],tong[M],rk[M],height[M]; 
 
    char s[M];
 
    int n;
 
    bool cmp(int *r,int a,int b,int l)
    {
        return r[a]==r[b]&&r[a+l]==r[b+l];
    }
 
    void da(char *r,int *sa,int n,int m)
    {
        int i,j,p,*x=wa,*y=wb,*t;
        for(i=0;i<n;i++)
            tong[x[i]=r[i]]++;
        for(i=1;i<m;i++)
            tong[i]+=tong[i-1];
        for(i=n-1;i>=0;i--)
            sa[--tong[x[i]]]=i;
        for(j=1,p=0;j<n;j<<=1,m=p)
        {
            for(i=n-j,p=0;i<n;i++)
                y[p++]=i;
            for(i=0;i<n;i++)
                if(sa[i]>=j)
                    y[p++]=sa[i]-j;
            for(i=0;i<m;i++)
                tong[i]=0;
            for(i=0;i<n;i++)
                tong[wv[i]=x[y[i]]]++;
            for(i=1;i<m;i++)
                tong[i]+=tong[i-1];
            for(i=n-1;i>=0;i--)
                sa[--tong[wv[i]]]=y[i];
            for(t=x,x=y,y=t,x[sa[0]]=0,i=1,p=1;i<n;i++)
                x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
        }
    }
 
    void calheight(char *r,int *sa,int n)
    {
        int i,j,k=0;
        for(i=1;i<=n;i++)
            rk[sa[i]]=i;
        for(i=0;i<n;height[rk[i++]]=k)
            for(k?k--:0,j=sa[rk[i]-1];r[i+k]==r[j+k];k++);
    }
 
    int mn[20][M];
 
    void pre(string _s)
    {
        n=_s.size();
        for(int i=0;i<n;i++)
            s[i]=_s[i];
        da(s,sa,n+1,256);
        calheight(s,sa,n);
        for(int i=1;i<=n;i++)
            mn[0][i]=height[i];
        for(int j=1;j<20;j++)
            for(int i=1;i+(1<<j)-1<=n;i++)
                mn[j][i]=min(mn[j-1][i],mn[j-1][i+(1<<(j-1))]);
    }
 
    int lcp(int u,int v)
    {
        if(u==v)
            return n-u;
        u=rk[u],v=rk[v];
        if(u>v)
            swap(u,v);
        u++;
        int k=__lg(v-u+1);
        return min(mn[k][u],mn[k][v-(1<<k)+1]);
    }
 
    int qry(int a,int b,int c,int d)
    {
        return min({b-a+1,d-c+1,lcp(a,c)});
    }
}SA[2];
 
struct Edge{
    int v,l,r;
};
 
int tot,tmpt;
 
vector<Edge> g[N];
 
// vector<int> pool;
 
int n,q,ty[N];
 
int ed[N][2];
 
vector<pii> ep[N];
 
int newnode()
{
    return ++tot;
}
 
int tmpnode()
{
    int x=--tmpt;
    g[x].clear();
    return x;
}
 
int st[N],en[N],dfn[N];
 
int dc;
 
void dfs(int x)
{
    dfn[++dc]=x;
    st[x]=dc;
    for(auto [v,l,r]:g[x])
        dfs(v);
    en[x]=dc;
}
 
int merge(int x,int y,int p)
{
    int i=0,j=0;
    vector<Edge> ng;
    while(i<g[x].size()||j<g[y].size())
    {
        int cx=i<g[x].size()?SA[p].s[g[x][i].l]:999;
        int cy=j<g[y].size()?SA[p].s[g[y][j].l]:999;
        if(cx<cy)
            ng.push_back(g[x][i++]);
        else if(cx>cy)
            ng.push_back(g[y][j++]);
        else
        {
            int len=SA[p].qry(g[x][i].l,g[x][i].r,g[y][j].l,g[y][j].r);
            int lx=g[x][i].r-g[x][i].l+1,ly=g[y][j].r-g[y][j].l+1;
            if(len<lx&&len<ly)
            {
                int w=newnode();
                g[w].resize(2);
                int xp=SA[p].s[g[x][i].l+len]>SA[p].s[g[y][j].l+len];
                g[w][xp]={g[x][i].v,g[x][i].l+len,g[x][i].r};
                g[w][xp^1]={g[y][j].v,g[y][j].l+len,g[y][j].r};
                ng.push_back({w,g[x][i].l,g[x][i].l+len-1});
            }
            else if(len==lx&&len==ly)
            {
                int s=merge(g[x][i].v,g[y][j].v,p);
                ng.push_back({s,g[x][i].l,g[x][i].r});
            }
            else if(len==lx)
            {
                int w=tmpnode();
                g[w].push_back({g[y][j].v,g[y][j].l+len,g[y][j].r});
                int s=merge(g[x][i].v,w,p);
                ng.push_back({s,g[x][i].l,g[x][i].r});
            }
            else if(len==ly)
            {
                int w=tmpnode();
                g[w].push_back({g[x][i].v,g[x][i].l+len,g[x][i].r});
                int s=merge(g[y][j].v,w,p);
                ng.push_back({s,g[y][j].l,g[y][j].r});
            }
            i++,j++;
        }
    }
    g[x].swap(ng);
    for(auto [p,q]:ep[y])
        ep[x].push_back({p,q}),ed[p][q]=x;
    return x;
}
 
struct BIT {
    int c[N];
 
    void add(int x,int v)
    {
        while(x<N)
        {
            c[x]+=v;
            x+=x&-x;
        }
    }
 
    int qry(int x)
    {
        int ret=0;
        while(x)
        {
            ret+=c[x];
            x-=x&-x;
        }
        return ret;
    }
}T;
 
struct EV {
    int x,y,v;
};
 
bool operator <(const EV &a,const EV &b)
{
    if(a.x!=b.x)
        return a.x<b.x;
    if(a.y!=b.y)
        return a.y<b.y;
    return abs(a.v)<abs(b.v);
}
 
int ans[N];
 
vector<pii> rem[2][N];
 
pii build(int l,int r)
{
    if(l==r)
    {
        string op;
        cin>>op;
        vector<pii>v[2];
        if(op[0]=='+')
        {
            ty[l]=0;
            int k;
            cin>>k;
            for(int i=0;i<k;i++)
            {
                int l,r;
                cin>>l>>r;
                v[0].push_back({l-1,r-1});
            }
            for(int i=k-1;i>=0;i--)
                v[1].push_back({n-1-v[0][i].second,n-1-v[0][i].first});
            rem[0][l]=v[0],rem[1][l]=v[1];
        }
        else if(op[0]=='-')
        {
            ty[l]=1;
            int k;
            cin>>k;
            v[0]=rem[0][k],v[1]=rem[1][k];
        }
        else
        {
            ty[l]=2;
            int k,m;
            cin>>k;
            for(int i=0;i<k;i++)
            {
                int l,r;
                cin>>l>>r;
                v[0].push_back({l-1,r-1});
            }
            cin>>m;
            for(int i=0;i<m;i++)
            {
                int l,r;
                cin>>l>>r;
                v[1].push_back({n-r,n-l});
            }
            reverse(v[1].begin(),v[1].end());
        }
        
        int rt[2];
        for(int p=0;p<2;p++)
        {
            int x=newnode();
            rt[p]=x;
            for(int i=0;i<v[p].size();i++)
            {
                int y=newnode();
                g[x].push_back({y,v[p][i].first,v[p][i].second});
                x=y;
            }
            ed[l][p]=x;
            ep[x].push_back({l,p});
        }
        return {rt[0],rt[1]};
    }
 
    int mid=(l+r)>>1;
    auto [l0,l1]=build(l,mid);
    auto [r0,r1]=build(mid+1,r);
    tmpt=N-1;
    l0=merge(l0,r0,0);
    tmpt=N-1;
    l1=merge(l1,r1,1);
    // cerr<<N-1-pool.size()<<endl;
    return {l0,l1};
}
 
void solve(int l,int r)
{
    if(l==r)
        return ;
    int mid=(l+r)>>1;
    solve(l,mid);
    solve(mid+1,r);
    vector<EV>Event;
    for(int i=l;i<=mid;i++)
    {
        if(ty[i]==2)
            continue;
        Event.push_back({st[ed[i][0]],st[ed[i][1]],ty[i]==0?1:-1});
    }
    for(int i=mid+1;i<=r;i++)
    {
        if(ty[i]!=2)
            continue;
        int u=ed[i][0],v=ed[i][1];
        Event.push_back({st[u]-1,st[v]-1,i+1});
        Event.push_back({en[u],st[v]-1,-(i+1)});
        Event.push_back({st[u]-1,en[v],-(i+1)});
        Event.push_back({en[u],en[v],i+1});
    }
    sort(Event.begin(),Event.end());
    for(auto [x,y,id]:Event)
    {
        if(abs(id)==1)
        {
            T.add(y,id);
        }
        else
        {
            int pid=abs(id)-1;
            ans[pid]+=T.qry(y)*(id/abs(id));
        }
    }
    for(auto [x,y,id]:Event)
        if(abs(id)==1)
            T.add(y,-id);
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n>>q;
    cin>>s;
    SA[0].pre(s);
    auto rs=s;
    reverse(rs.begin(),rs.end());
    SA[1].pre(rs);
    auto [l0,l1]=build(1,q);
    
    dc=0;
    dfs(l0);
    dc=0;
    dfs(l1);
    solve(1,q);
    for(int i=1;i<=q;i++)
        if(ty[i]==2)
            cout<<ans[i]<<"\n";
}
/*
8 7
abcaabbc
+ 3 1 3 2 4 3 8
+ 2 1 4 1 8
+ 1 2 4
? 1 5 6 1 7 8
- 3
+ 1 2 5
? 1 2 3 1 5 5
01234567
 
+ abcbcacaabbc
+ abcaabcaabbc
+ bca
? ab bc
- bca
+ bcaa
? bc a
*/