#include<bits/stdc++.h>
#define rep(i,a,b) for (int i=(a);i<=(b);i++)
#define drep(i,a,b) for (int i=(a);i>=(b);i--)
using namespace std;
typedef long long ll;

const int mod=998244353;
inline int qmo(int x){return x+((x>>31)&mod);}
inline int add(int x,int y){return qmo(x+y-mod);}
inline int sub(int x,int y){return qmo(x-y);}
inline void inc(int &x,int y){x=add(x,y);}
inline void dec(int &x,int y){x=sub(x,y);}
inline int quick_pow(int x,int k){int res=1; for (;k;k>>=1,x=1ll*x*x%mod) if (k&1) res=1ll*res*x%mod; return res;}

vector<int> __inv{1,1};

inline int getinv(int x)
{
	if (x>=(1<<21)) return quick_pow(x,mod-2);
	while ((int)__inv.size()<x+1) __inv.push_back(1ll*(mod-mod/__inv.size())*__inv[mod%__inv.size()]%mod);
	return __inv[x];
}

mt19937 rng(time(0));
inline int rnd(int l,int r) {return l+rng()%(r-l+1);}

int CipollaVal;
struct CipollaComplex{int x,y;};
inline CipollaComplex operator * (CipollaComplex x,CipollaComplex y)
{
	return (CipollaComplex){add(1ll*x.x*y.x%mod,1ll*CipollaVal*x.y%mod*y.y%mod),add(1ll*x.x*y.y%mod,1ll*x.y*y.x%mod)};
}	
inline CipollaComplex quick_pow(CipollaComplex x,int k){CipollaComplex res; res.x=1,res.y=0; for (;k;k>>=1,x=x*x) if (k&1) res=res*x; return res;}

inline int Cipolla(int x)
{
	int a;
	while ((a=rnd(1,1e9))&&(quick_pow(sub(1ll*a*a%mod,x),(mod-1)/2)==1));
	CipollaVal=sub(1ll*a*a%mod,x); 
	int v=quick_pow(CipollaComplex{a,1},(mod+1)/2).x;
	return min(v,mod-v);
}

namespace Polynomial
{
	const int __G__=3;
	
	vector<int> rt;
	
	inline void init(int lg)
	{
		rt.resize((1<<lg)+1);
		rt[0]=1,rt[1<<lg]=quick_pow(__G__,(mod-1)>>(lg+2));
		drep(i,lg,1) rt[1<<(i-1)]=1ll*rt[1<<i]*rt[1<<i]%mod;
		rep(i,1,1<<lg) rt[i]=1ll*rt[i&(i-1)]*rt[i&(-i)]%mod;
	}
	
	inline void dif(vector<int> &a)
	{
		int limit=a.size();
		for (int len=limit>>1;len;len>>=1)
		{
			for (int j=0,*w=rt.data();j<limit;j+=(len<<1),w++)
			{
				for (int k=j,r;k<j+len;k++)
				{
					r=1ll*(*w)*a[k+len]%mod;
					a[k+len]=sub(a[k],r);
					inc(a[k],r);
				}
			}
		}
	}
	
	inline void dit(vector<int> &a)
	{
		int limit=a.size();
		for (int len=1;len<limit;len<<=1)
		{
			for (int j=0,*w=rt.data();j<limit;j+=(len<<1),w++)
			{
				for (int k=j,r;k<j+len;k++)
				{
					r=add(a[k],a[k+len]);
					a[k+len]=1ll*sub(a[k],a[k+len])*(*w)%mod;
					a[k]=r;
				}
			}
		}
		reverse(a.begin()+1,a.end());
		rep(i,0,limit-1) a[i]=1ll*a[i]*getinv(limit)%mod;
	} 
	
	struct Poly
	{
		vector<int> a;
		Poly () {}
		Poly (const vector<int> &x):a(x) {}
		Poly (const initializer_list<int> &x):a(x) {}
		inline int size() const {return a.size();}
		inline void resize(int n) {a.resize(n);}
		inline int operator [] (int n) const
		{
			if (n<0||n>=size()) return 0;
			return a[n];
		}
		inline Poly reverse() const {return Poly(vector<int>(a.rbegin(),a.rend()));}
		inline Poly mulxn(int n) const {auto b=a; b.insert(b.begin(),n,0); return Poly(b);}
		inline Poly divxn(int n) const {if (n>=size()) return Poly(); return Poly(vector<int>(a.begin()+n,a.end()));}
		inline Poly modxn(int n) const {if (!size()) return Poly(); int k=min(size(),n); return Poly(vector<int>(a.begin(),a.begin()+k));}
		inline Poly shrink() const {if (!size()) return Poly(); int lst=size()-1; while (lst>=0&&!a[lst]) lst--; return Poly(vector<int>(a.begin(),a.begin()+lst+1));}
		inline friend Poly operator + (const Poly &a,const Poly &b)
		{
			vector<int> res(max(a.size(),b.size()));
			rep(i,0,(int)res.size()-1) res[i]=add(a[i],b[i]);
			return Poly(res);
		}
		inline friend Poly operator - (const Poly &a,const Poly &b)
		{
			vector<int> res(max(a.size(),b.size()));
			rep(i,0,(int)res.size()-1) res[i]=sub(a[i],b[i]);
			return Poly(res);
		}
		inline friend Poly operator * (Poly a,Poly b)
		{
			if (!a.size()||!b.size()) return Poly();
			if (a.size()<=40||b.size()<=40)
			{
				if (a.size()>b.size()) swap(a,b);
				vector<int> res(a.size()+b.size()-1);
				rep(i,0,(int)(res.size()-1))
				{
					for (int j=max(0,i-b.size()+1);j<=i&&j<a.size();j++) inc(res[i],1ll*a[j]*b[i-j]%mod);
				}
				return Poly(res).shrink();
			}
			int limit=1,sz=a.size()+b.size()-1;
			while (limit<sz) limit<<=1; a.a.resize(limit),b.a.resize(limit);
			dif(a.a),dif(b.a); 
			rep(i,0,limit-1) a.a[i]=1ll*a.a[i]*b.a[i]%mod;
			dit(a.a);
			return a.shrink(); 
		}
		inline friend Poly operator * (Poly a,int b) {rep(i,0,a.size()-1) a.a[i]=1ll*a.a[i]*b%mod; return a;}
		inline friend Poly operator * (int a,Poly b) {rep(i,0,b.size()-1) b.a[i]=1ll*b.a[i]*a%mod; return b;}
		inline Poly& operator += (Poly b) {return (*this)=(*this)+b;}
		inline Poly& operator -= (Poly b) {return (*this)=(*this)-b;}
		inline Poly& operator *= (Poly b) {return (*this)=(*this)*b;}
		inline Poly& operator *= (int b) {return (*this)=(*this)*b;}
		inline friend bool operator == (const Poly &a,const Poly &b) {rep(i,0,max(a.size(),b.size())-1) if (a[i]!=b[i]) return false; return true;}
		inline Poly deriv() const
		{
			if (!size()) return Poly();
			vector<int> res(size()-1);
			rep(i,0,size()-2) res[i]=1ll*a[i+1]*(i+1)%mod;
			return Poly(res);
		}
		inline Poly integ() const
		{
			vector<int> res(size()+1);
			rep(i,0,size()-1) res[i+1]=1ll*a[i]*getinv(i+1)%mod;
			return Poly(res);
		}
		inline Poly inv(int n) const
		{
			Poly res{getinv(a[0])},tmp;
			int k=1;
			while (k<n)
			{
				k<<=1; int limit=k<<1; tmp.resize(limit); res.resize(limit);
				rep(i,0,k-1) tmp.a[i]=(*this)[i];
				dif(tmp.a),dif(res.a);
				rep(i,0,limit-1) res.a[i]=1ll*res[i]*sub(2,1ll*tmp[i]*res[i]%mod)%mod;
				dit(res.a);
				rep(i,k,limit-1) res.a[i]=0;
				rep(i,0,limit-1) tmp.a[i]=0;
			}
			return res.modxn(n);
		}
		inline Poly sqrt(int n) const
		{
			Poly x{Cipolla(a[0])};
			int k=1;
			while (k<n)
			{
				k<<=1;
				x=(x+(modxn(k)*x.inv(k))).modxn(k)*getinv(2);
			}
			return x.modxn(n);
		}
		inline Poly ln(int n) const {return (modxn(n).deriv()*inv(n)).modxn(n).integ().modxn(n);}
		inline Poly exp(int n) const
		{
			Poly res{1};
			int k=1;
			while (k<n)
			{
				k<<=1;
				res=(res*(Poly{1}-res.ln(k)+modxn(k))).modxn(k);
			}
			return res.modxn(n);
		}
		inline Poly pow(int k,int n) const
		{
			int i=0; while (i<size()&&!a[i]) i++;
			if (i==size()||1ll*i*k>=n) return Poly();
			Poly x=quick_pow(a[i],mod-2)*divxn(i);
			return (x.ln(n-i*k)*k).exp(n-i*k).mulxn(i*k)*quick_pow(a[i],k); 
		}
		inline pair<Poly,Poly> div(const Poly &o) const
		{
			if (size()<o.size()) return make_pair(Poly(),*this);
			Poly f=(reverse().modxn(size()-o.size()+1)*o.reverse().modxn(size()-o.size()+1).inv(size()-o.size()+1)).modxn(size()-o.size()+1).reverse();
			Poly g=(modxn(o.size()-1)-o.modxn(o.size()-1)*f.modxn(o.size()-1)).modxn(o.size()-1);
			return make_pair(f,g);
		}
	};
}
using Polynomial::Poly;

inline Poly conv(const Poly &x,const Poly &y)
{
	int n=x.size();
	assert(x.size()==y.size());
	Poly z=x*y;
	Poly res; res.resize(n);
	rep(i,0,z.size()-1) inc(res.a[i%n],z[i]);
	return res;
}
inline Poly quick_pow(Poly x,ll k)
{
	int n=x.size();
	Poly res; res.resize(n);
	res.a[0]=1;

	while (k)
	{
		if (k&1) res=conv(res,x);
		k>>=1;
		x=conv(x,x);
	}
	return res;
}

int main()
{
	ios::sync_with_stdio(false); cin.tie(0);
	Polynomial::init(21);

	int n,rem;
	string S; 
	cin>>n>>rem>>S;

	ll r=0,s=0;
	for (auto &c:S)
	{
		int v=c-'0';
		r=10ll*r+v;
		s=(10*s+r/n);
		if (s>mod-1)
		{
			s=(s%(mod-1))+(mod-1);
		}
		r%=n;
	}

	vector<int> f(n);
	f[0]=1;
	rep(i,0,n-1)
	{
		vector<int> g=f;
		rep(j,0,n-1) inc(g[(i+j)%n],f[j]);
		swap(f,g);
	}
	Poly u{f};
	u=quick_pow(u,s);
	f=u.a;

	rep(i,0,r-1)
	{
		vector<int> g=f;
		rep(j,0,n-1) inc(g[(i+j)%n],f[j]);
		swap(f,g);
	}

	printf("%d\n",f[rem]);

	return 0;
}