#include<bits/stdc++.h>
using namespace std;
namespace fastio
{
	constexpr int S1=1<<20;
	char buf1[S1],*l1,*r1;
	inline char getc()
	{
		return ((l1==r1&&(r1=(l1=buf1)+fread(buf1,1,S1,stdin)),l1!=r1)?*l1++:EOF);
	}
	template<typename T=int>inline T read()
	{
		T x=0,y=1;
		char c=getc();
		while(c<'0'||c>'9')
		{
			if(c=='-')
				y=-1;
			c=getc();
		}
		while(c>='0'&&c<='9')
		{
			x=c-'0'+x*10;
			c=getc();
		}
		return x*y;
	}
	inline double read_db()
	{
		double x=0,y=1;
		char c=getc();
		while(c<'0'||c>'9')
		{
			if(c=='-')
				y=-1;
			c=getc();
		}
		while(c>='0'&&c<='9')
		{
			x=x*10+c-'0';
			c=getc();
		}
		if(c=='.')
		{
			double r=.1;
			for(c=getc();c>='0'&&c<='9';c=getc())
			{
				x+=r*(c-'0');
				r*=.1;
			}
		}
		return x*y;
	}
	constexpr int S2=1<<20;
	char buf2[S2],*l2=buf2;
	inline void putc(char c)
	{
		l2==buf2+S2&&(fwrite(buf2,1,S2,stdout),l2=buf2),*l2++=c;
	}
	int _st[22];
	template<typename T>inline void write(T x,char end='\n')
	{
		if(x<0)
			putc('-'),x=-x;
		int tp=0;
		do
			_st[++tp]=x%10;
		while(x/=10);
		while(tp)
			putc(_st[tp--]+'0');
		if(end)
			putc(end);
	}
	constexpr int DIGIT=3;
	constexpr long long _p=pow(10,DIGIT);
	inline void write_db(double y,char end='\n')
	{
		if(y<0)
			putc('-'),y=-y;
		long long x=round(y*_p);
		write(x/_p),putc('.');
		x%=_p;
		for(int i=1;i<=DIGIT;i++)
			_st[i]=x%10,x/=10;
		for(int i=DIGIT;i;i--)
			putc(_st[i]+'0');
		if(end)
			putc(end);
	}
	inline void ps(const char*s,char end='\n')
	{
		for(auto p=s;*p;p++)
			putc(*p);
		if(end)
			putc(end);
	}
	struct end
	{
		~end()
		{
			fwrite(buf2,1,l2-buf2,stdout);
		}
	}ender;
}
using fastio::getc;
using fastio::read;
using fastio::read_db;
using fastio::putc;
using fastio::write;
using fastio::write_db;
using fastio::ps;
constexpr int MN=200005,B=447;
constexpr long long mod=998244353,base=13331;
inline long long ksm(long long b,int p=mod-2)
{
	long long res=1;
	for(;p;p>>=1)
	{
		if(p&1)
			res=res*b%mod;
		b=b*b%mod;
	}
	return res;
}
int n,q,lg,a[MN],ans;
long long pw[MN],npw[MN];
inline void trans(int&l,int&r)
{
	l=-l,r=-r,swap(l,r);
}
struct bl
{
	long long a1[MN],s1[MN/B+5],a2[MN],s2[MN/B+5];
	void init()
	{
		for(int i=1;i<=n;i++)
		{
			a1[i]=(a1[i-1]+a[i]*pw[i])%mod;
			a2[i]=(a2[i-1]+a[i]*npw[i])%mod;
		}
	}
	void add(int x,long long y)
	{
		long long y1=y*pw[x],y2=y*npw[x];
		for(int i=x;i<(x/B+1)*B&&i<=n;i++)
		{
			a1[i]=(a1[i]+y1)%mod;
			a2[i]=(a2[i]+y2)%mod;
		}
		for(int i=x/B+1;i<=n/B;i++)
		{
			s1[i]=(s1[i]+y1)%mod;
			s2[i]=(s2[i]+y2)%mod;
		}
	}
	int ask1(int l,int r)
	{
		if(l>r)
			return 0;
		if(l<0)
			trans(l,r);
		return ((a1[r]+s1[r/B]-a1[l-1]-s1[(l-1)/B])*npw[l]%mod+mod)%mod;
	}
	int ask2(int l,int r)
	{
		if(l>r)
			return 0;
		if(l<0)
			trans(l,r);
		return ((a2[r]+s2[r/B]-a2[l-1]-s2[(l-1)/B])*pw[r]%mod+mod)%mod;
	}
}H;
struct seq
{
	int m,d[20],t[20],p[20];
	void add1(int x)
	{
		if(x==p[m])
			return;
		if(x-p[m]==d[m])
			p[m]=x,t[m]++;
		else
			d[m+1]=x-p[m],t[++m]=1,p[m]=x;
	}
	void add2(int S,int T,int D)
	{
		if(S==p[m])
		{
			S+=D;
			if(S>T)
				return;
		}
		if(S-p[m]==d[m])
			if(D==d[m])
				p[m]=T,t[m]+=(T-S)/D+1;
			else
			{
				p[m]=S,t[m]++;
				if(S<T)
					d[++m]=D,t[m]=(T-S)/D,p[m]=T;
			}
		else
			if(D==S-p[m])
				d[++m]=D,t[m]=(T-S)/D+1,p[m]=T;
			else
			{
				d[m+1]=S-p[m],t[++m]=1,p[m]=S;
				if(S<T)
					d[++m]=D,t[m]=(T-S)/D,p[m]=T;
			}
	}
};
struct node
{
	int l,r;
	seq L,R;
}T[MN*4],tmp;
inline seq merge(node A,node B)
{
	int na=A.r-A.l+1,nb=B.r-B.l+1;
	for(int i=B.L.m;~i;i--)
	{
		int d=B.L.d[i],t=B.L.t[i],p=B.L.p[i];
		if(!i||t==1)
		{
			if(nb-p<=na&&H.ask1(B.l-(nb-p),A.r)==H.ask2(B.l+p,B.r))
				B.R.add1(nb+nb-p);
		}
		else if(nb-p<d&&H.ask1(B.l+p,B.r)==H.ask1(B.l+p-d,B.r-d))
		{
			int L=-1,R=t,M;
			while(L+1<R)
			{
				M=(L+R)>>1;
				int tmp=B.l-(nb-p+d*M);
				if(tmp>=A.l&&H.ask1(B.l+p-d*M,B.r)==H.ask2(tmp,A.r))
					L=M;
				else
					R=M;
			}
			if(L>=0)
				B.R.add2(nb+nb-p,nb+nb-p+L*d,d);
		}
		else
		{
			int L=0,R=t,M;
			while(L+1<R)
			{
				M=(L+R)>>1;
				int tmp=B.l-d*M;
				if(tmp>=A.l&&H.ask1(B.l+p-M*d,A.r+p)==H.ask2(tmp,A.r))
					L=M;
				else
					R=M;
			}
			int tmp=B.l-(L*d+nb-p);
			if(tmp>=A.l&&H.ask1(B.l+p-L*d,B.r)==H.ask2(tmp,A.r))
				B.R.add1(nb+L*d+nb-p);
		}
	}
	int HB=H.ask2(B.l,B.r);
	if(na>=nb&&H.ask1(B.l-nb,A.r)==HB)
		B.R.add1(nb*2);
	for(int i=0;i<=A.R.m;i++)
	{
		int d=A.R.d[i],t=A.R.t[i],p=(i?A.R.p[i]-(t-1)*d:A.R.p[i]);
		if(!i||t==1)
		{
			if(nb<=na-p&&H.ask1(B.l-p-nb,A.r-p)==HB)
				B.R.add1(p+2*nb);
		}
		else if((t-1)*d>=nb&&H.ask1(B.l-p-nb,A.r-p)==HB)
		{
			int np=p+((t-1)*d-nb)/d*d;
			B.R.add2(p+2*nb,np+2*nb,d);
			p=np+d;
			if(nb<=na-p&&H.ask1(B.l-p-nb,A.r-p)==HB)
				B.R.add1(p+2*nb);
		}
		else
		{
			int L=0,R=t,M;
			while(L+1<R)
			{
				M=(L+R)>>1;
				if(M*d<=nb&&H.ask1(B.l-p-M*d,A.r-p)==H.ask2(B.l,A.r+M*d))
					L=M;
				else
					R=M;
			}
			int p2=p+(t-1-L)*d;
			if(na>=p2+nb&&H.ask1(B.l-p2-nb,A.r-p2)==HB)
				B.R.add1(p2+2*nb);
		}
	}
	return B.R;
}
inline node operator*(node A,node B)
{
	if(!A.l)
		return B;
	if(!B.l)
		return A;
	node C;
	C.l=A.l,C.r=B.r;
	C.R=merge(A,B);
	trans(A.l,A.r),swap(A.L,A.R);
	trans(B.l,B.r),swap(B.L,B.R);
	C.L=merge(B,A);
	return C;
}
inline void upd(int x)
{
	for(x=(x|(1<<lg))>>1;x;x>>=1)
		T[x]=T[x<<1]*T[x<<1|1];
}
inline node ask(int l,int r)
{
	node vl,vr;
	vl.l=vr.l=0;
	for(l=(l-1)|(1<<lg),r=(r+1)|(1<<lg);l^r^1;l>>=1,r>>=1)
	{
		if(~l&1)
			vl=vl*T[l^1];
		if(r&1)
			vr=T[r^1]*vr;
	}
	return vl*vr;
}
int main()
{
	while(1)
	{
		a[++n]=getc();
		if(a[n]<'a'||a[n]>'z')
		{
			n--;
			break;
		}
		a[n]-='a';
	}
	*pw=1;
	for(int i=1;i<=n;i++)
		pw[i]=pw[i-1]*base%mod;
	npw[n]=ksm(pw[n]);
	for(int i=n;i;i--)
		npw[i-1]=npw[i]*base%mod;
	H.init();
	q=read();
	lg=__lg(n+1)+1;
	tmp.L.p[0]=1;
	tmp.R=tmp.L;
	for(int i=1;i<=n;i++)
	{
		tmp.l=tmp.r=i;
		T[i|(1<<lg)]=tmp;
	}
	for(int i=(1<<lg)-1;i;i--)
		T[i]=T[i<<1]*T[i<<1|1];
	while(q--)
	{
		int o=read();
		if(o==1)
		{
			int x=read()^ans,y=getc()-'a';
			H.add(x,y-a[x]);
			a[x]=y;
			upd(x);
		}
		else
		{
			int l=read()^ans,r=read()^ans;
			ans=1;
			seq A=ask(l,r).R;
			for(int i=1;i<=A.m;i++)
				ans+=A.t[i];
			write(ans);
		}
	}
	return 0;
}