#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int N=2e5+5,mod1=998244353,mod2=1e9+7;
int qpow(int a,int b,int m)
{
    int c=1;
    for(;b;b>>=1,a=1ll*a*a%m)
        if(b&1)c=1ll*c*a%m;
    return c;
}
struct hash_val
{
    ll v1;
    hash_val(){v1=0;}
    hash_val(int x){v1=x;}
//    hash_val(int x,int y){v1=x,v2=y;}
    void operator+=(const hash_val&a){v1+=a.v1,v1>=mod1&&(v1-=mod1);}
    void operator-=(const hash_val&a){v1-=a.v1,v1<0&&(v1+=mod1);}
    void operator*=(const hash_val&a){v1=1ll*v1*a.v1%mod1;}
    hash_val operator+(const hash_val&a)const{hash_val c=*this;c+=a;return c;}
    hash_val operator-(const hash_val&a)const{hash_val c=*this;c-=a;return c;}
    hash_val operator*(const hash_val&a)const{hash_val c=*this;c*=a;return c;}
    bool operator==(const hash_val&a)const{return v1==a.v1;}
    bool operator!=(const hash_val&a)const{return v1!=a.v1;}
}pw[N],ipw[N];
const hash_val base={114514},ibase={137043501};
//struct hash_val
//{
//    int v1,v2;
//    hash_val(){v1=v2=0;}
//    hash_val(int x){v1=v2=x;}
//    hash_val(int x,int y){v1=x,v2=y;}
//    void operator+=(const hash_val&a){v1+=a.v1,v2+=a.v2;v1>=mod1&&(v1-=mod1),v2>=mod2&&(v2-=mod2);}
//    void operator-=(const hash_val&a){v1-=a.v1,v2-=a.v2,v1<0&&(v1+=mod1),v2<0&&(v2+=mod2);}
//    void operator*=(const hash_val&a){v1=1ll*v1*a.v1%mod1,v2=1ll*v2*a.v2%mod2;}
//    hash_val operator+(const hash_val&a)const{hash_val c=*this;c+=a;return c;}
//    hash_val operator-(const hash_val&a)const{hash_val c=*this;c-=a;return c;}
//    hash_val operator*(const hash_val&a)const{hash_val c=*this;c*=a;return c;}
//    bool operator==(const hash_val&a)const{return v1==a.v1&&v2==a.v2;}
//    bool operator!=(const hash_val&a)const{return v1!=a.v1||v2!=a.v2;}
//}pw[N],ipw[N];
//const hash_val base={114514,1919811},ibase={137043501,83769705};
struct String
{
    hash_val vl;
    int len;
};
vector<hash_val>coef[N];
String operator+(const String&a,const String&b){return {a.vl+b.vl*pw[a.len],a.len+b.len};};
String operator*(const String&a,int b){return {a.vl*coef[a.len][b],a.len*b};}
bool operator==(const String&a,const String&b){return a.vl==b.vl&&a.len==b.len;}
bool operator!=(const String&a,const String&b){return a.vl!=b.vl||a.len!=b.len;}
struct ___
{
    ___()
    {
        pw[0]=ipw[0]=hash_val(1);
        for(int i=1;i<N;++i)pw[i]=pw[i-1]*base,ipw[i]=ipw[i-1]*ibase;
        for(int i=1;i<N;++i)
        {
            coef[i].resize(N/i+1);
            for(int j=1;j*i<N;++j)
                coef[i][j]=coef[i][j-1]+pw[(j-1)*i];
        }
    }
}____;
namespace DS
{
hash_val pre[N],bpre[N],suf[N],bsuf[N];
int n,bl[N],L[N],R[N];
char a[N];
const int S=400;
void init(int N,char*s)
{
    n=N;
    for(int i=1;i<=n;++i)a[i]=s[i];
    for(int i=1;i<=n;++i)bl[i]=(i+S-1)/S;
    for(int i=1;i<=bl[n];++i)L[i]=i*S-S+1,R[i]=min(i*S,n);
    for(int i=1;i<=n;++i)
        if(i==L[bl[i]])pre[i]=hash_val(s[i]);
        else pre[i]=pre[i-1]+hash_val(s[i])*pw[i-L[bl[i]]];
    for(int i=n;i>=1;--i)
        if(i==R[bl[i]])suf[i]=hash_val(s[i]);
        else suf[i]=suf[i+1]+hash_val(s[i])*pw[R[bl[i]]-i];
    for(int i=1;i<=bl[n];++i)
        bpre[i]=bpre[i-1]+pre[R[i]]*pw[R[i-1]];
    for(int i=bl[n];i>=1;--i)
        bsuf[i]=bsuf[i+1]+suf[L[i]]*pw[n-R[i]];
}
void modify(int x,char c)
{
    hash_val dlt=hash_val(c)-hash_val(a[x]);a[x]=c;
    hash_val tmp=dlt*pw[x-L[bl[x]]];
    for(int i=x;i<=R[bl[x]];++i)
        pre[i]+=tmp;
    tmp=dlt*pw[R[bl[x]]-x];
    for(int i=x;i>=L[bl[x]];--i)
        suf[i]+=tmp;
    tmp=dlt*pw[x-1];
    for(int i=bl[x];i<=bl[n];++i)
        bpre[i]+=tmp;
    tmp=dlt*pw[n-x];
    for(int i=bl[x];i>=1;--i)
        bsuf[i]+=tmp;
}
hash_val getpre(int l,int r)
{
    if(l<1||r>n)return hash_val(-1);
    if(l==r+1)return hash_val(0);
    auto calcblock=[&](int l,int r)
    {
        int x=bl[l];//assert(x==bl[r]);
        return (pre[r]-pre[l!=L[x]?l-1:0])*ipw[l-L[x]];
    };
    hash_val ret=0;
    if(bl[l]<bl[r])
    {
        ret+=calcblock(l,R[bl[l]]);
        if(bl[l]+1<bl[r])ret+=(bpre[bl[r]-1]-bpre[bl[l]])*ipw[l-1];
        ret+=pre[r]*pw[L[bl[r]]-l];
    }
    else ret=calcblock(l,r);
    return ret;
}
hash_val getsuf(int l,int r)
{
    if(l<1||r>n)return hash_val(-1);
    if(l==r+1)return hash_val(0);
//    if(l>r)assert(0);
    // cerr<<l<<' '<<r<<'\n';
    auto calcblock=[&](int l,int r)
    {
        int x=bl[l];//assert(x==bl[r]);
        return (suf[l]-suf[r!=R[x]?r+1:0])*ipw[R[x]-r];
    };
    hash_val ret=hash_val(0);
    if(bl[l]<bl[r])
    {
        ret+=calcblock(L[bl[r]],r);
        if(bl[l]+1<bl[r])ret+=(bsuf[bl[l]+1]-bsuf[bl[r]])*ipw[n-r];
        ret+=suf[l]*pw[r-R[bl[l]]];
    }
    else ret=calcblock(l,r);
    return ret;
}
}//namespace DS
namespace DS2
{
hash_val pre[N],bpre[N],suf[N],bsuf[N];
int n,bl[N],L[N],R[N];
char a[N];
const int S=400;
void init(int N,char*s)
{
    n=N;
    for(int i=1;i<=n;++i)a[i]=s[i];
    for(int i=1;i<=n;++i)bl[i]=(i+S-1)/S;
    for(int i=1;i<=bl[n];++i)L[i]=i*S-S+1,R[i]=min(i*S,n);
    for(int i=1;i<=n;++i)
        if(i==L[bl[i]])pre[i]=hash_val(s[i]);
        else pre[i]=pre[i-1]+hash_val(s[i])*pw[i-L[bl[i]]];
    for(int i=n;i>=1;--i)
        if(i==R[bl[i]])suf[i]=hash_val(s[i]);
        else suf[i]=suf[i+1]+hash_val(s[i])*pw[R[bl[i]]-i];
    for(int i=1;i<=bl[n];++i)
        bpre[i]=bpre[i-1]+pre[R[i]]*pw[R[i-1]];
    for(int i=bl[n];i>=1;--i)
        bsuf[i]=bsuf[i+1]+suf[L[i]]*pw[n-R[i]];
}
void modify(int x,char c)
{
    hash_val dlt=hash_val(c)-hash_val(a[x]);a[x]=c;
    hash_val tmp=dlt*pw[x-L[bl[x]]];
    for(int i=x;i<=R[bl[x]];++i)
        pre[i]+=tmp;
    tmp=dlt*pw[R[bl[x]]-x];
    for(int i=x;i>=L[bl[x]];--i)
        suf[i]+=tmp;
    tmp=dlt*pw[x-1];
    for(int i=bl[x];i<=bl[n];++i)
        bpre[i]+=tmp;
    tmp=dlt*pw[n-x];
    for(int i=bl[x];i>=1;--i)
        bsuf[i]+=tmp;
}
hash_val Getpre(int l,int r)
{
    if(l<1||r>n)return hash_val(-1);
    if(l==r+1)return hash_val(0);
    auto calcblock=[&](int l,int r)
    {
        int x=bl[l];//assert(x==bl[r]);
        return (pre[r]-pre[l!=L[x]?l-1:0])*ipw[l-L[x]];
    };
    hash_val ret=hash_val(0);
    if(bl[l]<bl[r])
    {
        ret+=calcblock(l,R[bl[l]]);
        if(bl[l]+1<bl[r])ret+=(bpre[bl[r]-1]-bpre[bl[l]])*ipw[l-1];
        ret+=pre[r]*pw[L[bl[r]]-l];
    }
    else ret=calcblock(l,r);
    return ret;
}
hash_val Getsuf(int l,int r)
{
    if(l<1||r>n)return hash_val(-1);
    if(l==r+1)return hash_val(0);
    auto calcblock=[&](int l,int r)
    {
        int x=bl[l];//assert(x==bl[r]);
        return (suf[l]-suf[r!=R[x]?r+1:0])*ipw[R[x]-r];
    };
    hash_val ret=hash_val(0);
    if(bl[l]<bl[r])
    {
        ret+=calcblock(L[bl[r]],r);
        if(bl[l]+1<bl[r])ret+=(bsuf[bl[l]+1]-bsuf[bl[r]])*ipw[n-r];
        ret+=suf[l]*pw[r-R[bl[l]]];
    }
    else ret=calcblock(l,r);
    return ret;
}
}//namespace DS2
using DS::getpre;
using DS::getsuf;
using DS2::Getpre;
using DS2::Getsuf;
char s[N];
int n;
struct info{int l,r,d;};
ostream&operator<<(ostream&a,info b){return a<<b.l<<' '<<b.r<<' '<<b.d;}
struct node{vector<info>pre,suf;int l,r;}tr[N*4];
ostream&operator<<(ostream&a,node b)
{
    a<<b.l<<' '<<b.r<<'\n';
    for(info i:b.pre)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
    cerr<<'\n';
    for(info i:b.suf)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
    return a;
}
String getprestr(int l,int r){return {getpre(l,r),r-l+1};}
String getsufstr(int l,int r){return {getsuf(l,r),r-l+1};}
String Getprestr(int l,int r){return {Getpre(l,r),r-l+1};}
String Getsufstr(int l,int r){return {Getsuf(l,r),r-l+1};}
void maintain(vector<info>&v,int lim)
{
//    for(int i=1;i<v.size();++i)assert(v[i].l>=v[i-1].r);
    while(v.back().l>lim)v.pop_back();
    if(v.back().r>lim)v.back().r=(lim-v.back().l)/v.back().d*v.back().d+v.back().l;
    vector<pair<int,int>>t;
    for(int i=0;i<v.size();++i)
    {
        if(i)t.emplace_back(v[i].l-v[i-1].r,1);
        else t.emplace_back(v[i].l,1);
        if(v[i].l<v[i].r)t.emplace_back(v[i].d,(v[i].r-v[i].l)/v[i].d);
    }
    t.erase(partition(t.begin(),t.end(),[&](auto x){return x.first>0;}),t.end());
    v.clear();
    int sum=0;
    for(int l=0,r;l<t.size();l=r+1)
    {
        int num=t[l].second;
        r=l;while(r+1<t.size()&&t[l].first==t[r+1].first)num+=t[++r].second;
        v.push_back({sum+t[l].first,sum+num*t[l].first,t[l].first}),sum+=num*t[l].first;
    }
    assert(v.size()<=20);
}
vector<info>mergepre(const node&a,const node&b)
{
    assert(a.r==b.l-1);
    vector<info>ret=a.pre;
    int lena=a.r-a.l+1,lenb=b.r-b.l+1;
    auto work=[&](int x)
    {
        if(x>lena+lenb)return;
        int m=x+1>>1;
        if(getpre(a.l,a.l+m-1)==getsuf(a.l+x-m,a.l+x-1))
            ret.push_back({x,x,0});
    };
    for(int I=a.suf.size()-1;I>=0;--I)
    {
        info i=a.suf[I];
        if(i.l==i.r)work(2*lena-i.l);
        else
        {
			int tmp=(i.r-i.l)/i.d;
            String B=getsufstr(a.r-i.l-i.d+1,a.r-i.l);
            String C=getsufstr(a.l,a.r-i.r);
            int num=0;
            for(int i=__lg(min(tmp,lenb/B.len)+1);~i;--i)
            {
                int nlen=(num|1<<i)*B.len;
                if(nlen<=lenb&&B*(num|1<<i)==getprestr(b.l,b.l+nlen-1))
                    num|=1<<i;
            }
            if(C.len<B.len&&getsufstr(a.r-i.l-C.len+1,a.r-i.l)==C)
            {
                if(num*B.len+C.len<=lenb&&getprestr(b.l+num*B.len,b.l+num*B.len+C.len-1)==C)
                    ++num;
                if(num)
                    ret.push_back({lena*2-i.r,lena*2-max(i.l,i.r-(num-1)*B.len),i.d});
            }
            else
            {
                if((i.r-i.l)/i.d>=num)
                    work(lena*2-i.r+num*B.len);
            }
        }
    }
    if(lena<=lenb)work(lena*2);
    for(info i:b.pre)
    {
        if(i.l==i.r)work(lena*2+i.l);
        else
        {
			int tmp=(i.r-i.l)/i.d;
            String B=getprestr(b.l+i.l,b.l+i.l+i.d-1);
            int num=0;
            for(int i=__lg(min(tmp,lena/B.len)+1);~i;--i)
            {
                int nlen=(num|1<<i)*B.len;
                if(nlen<=lena&&B*(num|1<<i)==getsufstr(a.r-nlen+1,a.r))
                    num|=1<<i;
            }
            if(num>i.r-i.l)continue;
            String C=getsufstr(a.l,a.r-num*B.len);
            if(C==getprestr(b.l+i.l,b.l+i.l+C.len-1))
            {
                if(b.l+i.r+C.len-1<=b.r&&C!=getprestr(b.l+i.r,b.l+i.r+C.len-1))
                    ++num;
                if((i.r-i.l)/i.d>=num)
                    ret.push_back({lena*2+i.l,lena*2+i.r-num*i.d,i.d});
            }
            else
            {
                if((i.r-i.l)/i.d>=num)
                    work(i.r-num*i.d+lena*2);
            }
        }
    }
    // for(info i:ret)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
    // cerr<<ret.size()<<'\n';
    maintain(ret,lena+lenb);
    return ret;
}
vector<info>mergesuf(const node&a,const node&b)
{
    assert(a.r==b.l-1);
    vector<info>ret=a.pre;
    int lena=a.r-a.l+1,lenb=b.r-b.l+1;
    auto work=[&](int x)
    {
        if(x>lena+lenb)return;
        int m=x+1>>1;
        if(Getpre(a.l,a.l+m-1)==Getsuf(a.l+x-m,a.l+x-1))
            ret.push_back({x,x,0});
    };
    for(int I=a.suf.size()-1;I>=0;--I)
    {
        info i=a.suf[I];
        if(i.l==i.r)work(2*lena-i.l);
        else
        {
			int tmp=(i.r-i.l)/i.d;
            String B=Getsufstr(a.r-i.l-i.d+1,a.r-i.l);
            String C=Getsufstr(a.l,a.r-i.r);
            int num=0;
            for(int i=__lg(min(tmp,lenb/B.len)+1);~i;--i)
            {
                int nlen=(num|1<<i)*B.len;
                if(nlen<=lenb&&B*(num|1<<i)==Getprestr(b.l,b.l+nlen-1))
                    num|=1<<i;
            }
            if(C.len<B.len&&Getsufstr(a.r-i.l-C.len+1,a.r-i.l)==C)
            {
                if(num*B.len+C.len<=lenb&&Getprestr(b.l+num*B.len,b.l+num*B.len+C.len-1)==C)
                    ++num;
                if(num)
                    ret.push_back({lena*2-i.r,lena*2-max(i.l,i.r-(num-1)*B.len),i.d});
            }
            else
            {
                if((i.r-i.l)/i.d>=num)
                    work(lena*2-i.r+num*B.len);
            }
        }
    }
    if(lena<=lenb)work(lena*2);
    for(info i:b.pre)
    {
        if(i.l==i.r)work(lena*2+i.l);
        else
        {
    		int tmp=(i.r-i.l)/i.d;
            String B=Getprestr(b.l+i.l,b.l+i.l+i.d-1);
            int num=0;
            for(int i=__lg(min(tmp,lena/B.len)+1);~i;--i)
            {
                int nlen=(num|1<<i)*B.len;
                if(nlen<=lena&&B*(num|1<<i)==Getsufstr(a.r-nlen+1,a.r))
                    num|=1<<i;
            }
            if(num>i.r-i.l)continue;
            String C=Getsufstr(a.l,a.r-num*B.len);
            if(C==Getprestr(b.l+i.l,b.l+i.l+C.len-1))
            {
                if(b.l+i.r+C.len-1<=b.r&&C!=Getprestr(b.l+i.r,b.l+i.r+C.len-1))
                    ++num;
                if((i.r-i.l)/i.d>=num)
                    ret.push_back({lena*2+i.l,lena*2+i.r-num*i.d,i.d});
            }
            else
            {
                if((i.r-i.l)/i.d>=num)
                    work(i.r-num*i.d+2*lena);
            }
        }
    }
    maintain(ret,lena+lenb);
    return ret;
}
node operator+(node a,node b)
{
//    cerr<<a.l<<' '<<b.l<<'\n';
if(a.l==1&&b.r==7)
    n=n;
    node ret;ret.l=a.l,ret.r=b.r;
    ret.pre=mergepre(a,b);
    a.l=n-a.l+1,a.r=n-a.r+1,b.l=n-b.l+1,b.r=n-b.r+1;
    swap(a.l,a.r),swap(b.l,b.r);
    swap(a.pre,a.suf),swap(b.pre,b.suf);
    ret.suf=mergesuf(b,a);
    return ret;
}
void build(int k,int l,int r)
{
    tr[k].l=l,tr[k].r=r;
    if(l==r){tr[k].pre=tr[k].suf={{1,1,0}};return;}
    int mid=l+r>>1;
    build(k<<1,l,mid),build(k<<1|1,mid+1,r);
    tr[k]=tr[k<<1]+tr[k<<1|1];
//     cerr<<k<<' '<<l<<' '<<r<<"!\n";
//     for(info i:tr[k].pre)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
//     cerr<<'\n';
//     for(info i:tr[k].suf)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
//     cerr<<'\n';
}
void upd(int k,int l,int r,int x)
{
    if(l==r)return;
    int mid=l+r>>1;
    if(mid>=x)upd(k<<1,l,mid,x);
    else upd(k<<1|1,mid+1,r,x);
//    cerr<<k<<' '<<l<<' '<<r<<"!\n";
//     for(info i:tr[k].pre)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
//     cerr<<'\n';
//     for(info i:tr[k].suf)cerr<<i.l<<' '<<i.r<<' '<<i.d<<'\n';
//     cerr<<'\n';
    tr[k]=tr[k<<1]+tr[k<<1|1];
}
node query(int k,int l,int r,int x,int y)
{
    if(l>=x&&r<=y)return tr[k];
    int mid=l+r>>1;
    if(mid>=y)return query(k<<1,l,mid,x,y);
    if(mid<x)return query(k<<1|1,mid+1,r,x,y);
    return query(k<<1,l,mid,x,y)+query(k<<1|1,mid+1,r,x,y);
}
int getans(int l,int r)
{
    node res=query(1,1,n,l,r);
    maintain(res.suf,r-l+1);
    int ans=0,lim=r-l+1;
    for(auto i:res.suf)
        if(i.r<=lim)ans+=(i.r-i.l)/i.d+1;
        else{ans+=(lim-i.l)/i.d+1;break;}
    return ans;
}
int main()
{
    scanf("%s",s+1),n=strlen(s+1);
    DS::init(n,s);
    reverse(s+1,s+n+1);
    DS2::init(n,s);
    build(1,1,n);
    int Q;scanf("%d",&Q);
    int lans=0;
//    cerr<<query(1,1,n,1,5)<<'\n';
//    cerr<<query(1,1,n,6,7)<<'\n';
//    cerr<<query(1,1,n,1,7)<<'\n';
//    cerr<<query(1,1,n,11,16)<<'\n';
//    cerr<<getans(11,16)<<'\n';
//    cerr<<query(1,1,n,11,16)<<'\n';
//    cerr<<query(1,1,n,10,16)<<'\n';
    for(int i=1;i<=Q;++i)
    {
        int o;scanf("%d",&o);
        if(o==1)
        {
            int x;char c;scanf("%d %c",&x,&c);x^=lans;
//            cerr<<x<<' '<<c<<"!\n";
            assert(1<=x&&x<=n);
            DS::modify(x,c),DS2::modify(n-x+1,c);
            upd(1,1,n,x);
        }
        else
        {
//        	for(int i=1;i<=n;++i)for(int j=i;j<=n;++j)
//        		cerr<<i<<' '<<j<<' '<<DS::getsuf(i,j).v1<<'\n';
            int l,r;scanf("%d%d",&l,&r);l^=lans,r^=lans;
//            cerr<<l<<' '<<r<<'\n';
            assert(1<=l&&l<=r&&r<=n);
            printf("%d\n",lans=getans(l,r));
        }
    }
}