#include <bits/stdc++.h>
using namespace std;
//#define OPENIOBUF

namespace FastIO
{
	class FastIOBase
	{
	 protected:
#ifdef OPENIOBUF
		static const int BUFSIZE=1<<22;
		char buf[1<<22];
		int buf_p=0;
#endif
		FILE *target;
	 public:
#ifdef OPENIOBUF
	 	virtual void flush()=0;
#endif
		FastIOBase(FILE *f): target(f){}
		~FastIOBase()=default;
	};

	class FastOutput: public FastIOBase
	{
#ifdef OPENIOBUF
	 public:
		inline void flush()
			{ fwrite(buf,1,buf_p,target),buf_p=0; }
#endif
	 protected:
		inline void __putc(char x)
		{
#ifdef OPENIOBUF
			buf[buf_p++]=x;if(buf_p>=BUFSIZE)flush();
#else
			putc(x,target);
#endif
		}
		template<typename T>
		void __write(const T &x)
		{
			if(x<0)	__putc('-'),__write(-x);
			else	{ if(x>9)__write(x/10);__putc(x%10+'0'); }
		}
	 public:
		FastOutput(FILE *f=stdout): FastIOBase(f){}
		inline FastOutput &operator <<(char x)
			{ return __putc(x),*this; }
		inline FastOutput &operator <<(const char *s)
			{ for(;*s;__putc(*(s++)));return *this; }
		inline FastOutput &operator <<(const string &s)
			{ return (*this)<<s.c_str(); }
		template<typename T,typename=typename enable_if<is_integral<T>::value>::type>
		inline FastOutput &operator <<(const T &x)
			{ return __write(x),*this; }
		template<typename ...T>
		inline void writesp(const T &...x)
			{ int var[]={(this->operator<<(x),__putc(' '),0)...}; }
		template<typename ...T>
		inline void writeln(const T &...x)
			{ int var[]={(this->operator<<(x),__putc('\n'),0)...}; }
	}qout;

	class FastInput: public FastIOBase
	{
#ifdef OPENIOBUF
	 public:
		inline void flush()
			{ fread(buf,1,BUFSIZE,target),buf_p=0; }
#endif
	 private:
		char ch,sym;
		static char str_buf[1<<22];
	 protected:
	 	inline char __getc()
		{
#ifdef OPENIOBUF
			if(!buf_p || buf_p>=BUFSIZE)flush();return buf[buf_p++];
#else
			return getc(target);
#endif
		}
	 public:
		FastInput(FILE *f=stdin): FastIOBase(f){}
		inline char getchar()
			{ return __getc(); }
		inline FastInput &operator >>(char &x)
			{ while((x=__getc())<33);return *this; }
		template<typename T,typename=typename enable_if<is_integral<T>::value>::type>
		inline FastInput &operator >>(T &x)
		{
			x=0,sym=1;
			while((ch=__getc())<33);if(ch=='-')sym=-1,ch=__getc();
			for(;ch>='0'&&ch<='9';x*=10,x+=(ch^48),ch=__getc());
			return x*=sym,*this;
		}
		inline FastInput &operator >>(char *s)
		{
			while((*s=__getc())<33);
			for(;*s>32;*(++s)=__getc());
			return *s='\0',*this;
		}
		inline FastInput &operator >>(string &s)
		{
			char *p=str_buf;
			while((*p=__getc())<33);for(;*p>32;*(++p)=__getc());
			*p='\0',s=str_buf;
			return *this;
		}
		template<typename ...T>
		inline void read(T &...x)
			{ int var[]={(this->operator>>(x),0)...}; }
	}qin;
	char FastInput::str_buf[1<<22]="";
}
using namespace FastIO;
typedef long long LL;
int n,s,q,ans,MOD;
inline LL quickPow(LL a,LL b,int mod=MOD)
{
	LL res=1;
	for(;b;a=a*a%mod,b>>=1)if(b&1)res=res*a%mod;
	return res;
}
inline int madd(int x,int y)	{ return (x+=y)>=MOD?(x-=MOD):x; }
inline int msub(int x,int y)	{ return (x-=y)<0?(x+=MOD):x; }
inline int mmul(int x,int y)	{ return (LL)x*y%MOD; }
inline int mdiv(int x,int y)	{ return (LL)x*quickPow(y,MOD-2)%MOD; }
int lim,tmp,fac[2000005],inv[2000005];
int main()
{
	qin>>n>>s>>q,MOD=q,lim=n+q;
	fac[0]=1;
	for(int i=1;i<=lim;i++)	fac[i]=mmul(fac[i-1],i);
	inv[lim]=quickPow(fac[lim],MOD-2);
	for(int i=lim;i>=1;i--)	inv[i-1]=mmul(inv[i],i);
	tmp=msub(quickPow(2,q),1);
	for(int i=0;i<n;i++)
		if(((LL)i*q+quickPow(i,q,n))%n==s)
			ans=madd(ans,madd(mmul(fac[q+i],inv[i]),mmul(tmp,i)));
	qout<<ans;
//	return qout.flush(),0;
}