#include<bits/stdc++.h>
#define L(i, j, k) for(int i = (j); i <= (k); ++i)
#define R(i, j, k) for(int i = (j); i >= (k); --i)
#define ll long long
#define vi vector <int>
#define sz(a) ((int) (a).size())
#define me(f, x) memset(f, x, sizeof(f))
#define uint unsigned int
#define ull unsigned long long 
#define bs bitset < N >
using namespace std;
const int N = 1e7 + 7;
int n, q, mod;

struct fastmod {
  typedef unsigned long long u64;
  typedef __uint128_t u128;

  int m;
  u64 b;

  fastmod(int m) : m(m), b(((u128)1 << 64) / m) {}
  int reduce(u64 a) {
    u64 q = ((u128)a * b) >> 64;
    int r = a - q * m;
    return r < m ? r : r - m;
  }
} z(2);

int pw[N], fac[N], ifac[N];
int qpow(int x, int y = mod - 2) {
	int res = 1;
	for(; y; x = (ll) x * x % mod, y >>= 1) if(y & 1) res = (ll) res * x % mod;
	return res;
}
void q_init(int x) {
	pw[0] = 1;
	L(i, 1, x) pw[i] = (ll) pw[i - 1] * q % mod;
	L(i, 1, x) fac[i] = pw[i] - 1;
	fac[0] = ifac[0] = 1;
	L(i, 1, x) 
		fac[i] = (ll) fac[i - 1] * fac[i] % mod;
	ifac[x] = qpow(fac[x]);
	R(i, x - 1, 0) 
		ifac[i] = (ll) ifac[i + 1] * (pw[i + 1] - 1) % mod;
} 
int q_C(int x, int y) {
	return x < y || y < 0 ? 0 : (ll) fac[x] * ifac[y] % mod * ifac[x - y] % mod;
}
inline int sgn(int x) {
	return (x & 1) ? mod - 1 : 1;
}

template < int L, int K > struct DBM {
	static const int R = (L + 1) * (K + 1);
	
	int lpos, a[R * 10 + 7];
	int G[R + 7][R + 7], cur[R + 7], ns[R + 7];
	int f[L + 2][K + 2], id[L + 2][K + 2], idt;
	inline void insert() {
		R(i, idt, 1) if(cur[i]) {
			if(!G[i][i]) {
				L(j, 1, i) 
					G[i][j] = cur[j];
			} 
			int iv = (ll) (mod - cur[i]) * qpow(G[i][i]) % mod;
			L(j, 1, i) 
				(cur[j] += (ll) iv * G[i][j] % mod) %= mod;
		}
	}
	void gauss(int *a, int n, int lpos = 0) {
		n = min(n, R * 10), idt = 0;
		L(i, 0, L) 
			L(j, 0, K) 
				id[i][j] = ++idt;
		L(i, L + 1, n) {
			L(j, 0, idt) 
				cur[j] = 0;
			L(x, 0, L) if(x < i) {
				int pw = a[i - x];
				L(y, 0, K) 
					cur[id[x][y]] = pw, 
					pw = (ll) pw * ::pw[lpos + i] % mod;
			}
			insert();
		}
		int pos = 1;
		while(G[pos][pos]) ++pos;
		ns[pos] = 1;
		if(pos > idt) {
			cout << "TAT" << endl;
			exit(0);
		}
		L(i, pos + 1, idt) {
			int s = 0;
			L(j, 1, i - 1) {
				(s += (ll) G[i][j] * ns[j] % mod) %= mod; 
			}
			ns[i] = (ll) (mod - s) * qpow(G[i][i]) % mod;
		}
		L(i, 0, L) 
			L(j, 0, K) 
				f[i][j] = ns[id[i][j]];
		L(i, L + 1, n) {
			L(j, 0, idt) 
				cur[j] = 0;
			int s = 0;
			L(x, 0, L) if(x < i) {
				int pw = a[i - x];
				L(y, 0, K) 
					(s += (ll) pw * f[x][y] % mod) %= mod, 
					pw = (ll) pw * ::pw[lpos + i] % mod;
			}
		}
	}
};

DBM < 2, 3 > S;

int f[N], g[N], ans[N], T[N], suf[N];
int Pw1[N], Pw2[N];
int main() {
	ios :: sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n >> q >> mod;
//	n = 1e7, q = 998244353, mod = 1e9 + 7;
	z = fastmod(mod);
	q_init(n + 1);
//	cout << clock() << endl;
	int mn = min(n, 80);
	f[0] = 1;
	L(i, 1, mn) {
		f[i] = (ll) f[i - 1] * (pw[n] + mod - pw[n - i]) % mod;
	}
	L(i, 0, mn) {
		g[i] = (ll) sgn(i) * qpow(q, i * (i - 1) / 2) % mod;
	}
	L(i, 0, mn) {
		L(j, 0, mn - i) {
			(ans[i + j] += (ll) q_C(i + j, i) * f[i] % mod * g[j] % mod) %= mod; 
		}
	}
	L(i, 0, n) {
		ans[i] = (ll) ans[i] * q_C(n, i) % mod;
	}
	if(mn < n) S.gauss(ans, mn);
	
	L(i, mn + 1, n) {
		int pw = 1;
		unsigned long long t = 0;
		L(y, 0, 3) t += (ll) pw * S.f[0][y], pw = z.reduce((ull) pw * ::pw[i]);
		T[i] = t % mod;
	}
	suf[n + 1] = 1;
	R(i, n, mn + 1) 
		suf[i] = z.reduce((ll) suf[i + 1] * T[i]);
	int all = qpow(suf[mn + 1]);
	L(i, mn + 1, n) {
		unsigned long long s = 0;
		L(x, 1, 2) {
			int pw = ans[i - x];
			s += (ull) pw * S.f[x][0];
			pw = z.reduce((ull) pw * ::pw[i]);
			s += (ull) pw * S.f[x][1];
			pw = z.reduce((ull) pw * ::pw[i]);
			s += (ull) pw * S.f[x][2];
			pw = z.reduce((ull) pw * ::pw[i]);
			s += (ull) pw * S.f[x][3];
		}
		ans[i] = z.reduce((ull)z.reduce((ull) (mod - z.reduce(s)) * all) * suf[i + 1]);
		all = z.reduce((ull) all * T[i]);
	}
	int pw = 1;
	L(i, 1, n) {
		pw = (ll) pw * q % (mod - 1);
	}
	const int K = sqrt(mod) + 1;
	Pw1[0] = Pw2[0] = 1;
	L(i, 1, K) {
		Pw1[i] = (ll) Pw1[i - 1] * 3 % mod;
	}
	L(i, 1, K) {
		Pw2[i] = (ll) Pw2[i - 1] * Pw1[K] % mod;
	}
	int s = 1;
	ull ns = 0;
	R(i, n, 0) {
		int w = (ll) Pw1[s % K] * Pw2[s / K] % mod;
		ns += (ull) ans[i] * w;
		if(!(i & 16)) ns %= mod;
		s = (ll) s * pw % (mod - 1);
	}
	ns %= mod;
	cout << ns << '\n';
	return 0;
}