#include <cstdio>
#include <cmath>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
typedef __int128 ll;
ll read() {
	long long x;
	scanf("%lld", &x);
	return (ll)x;
}
void write(ll x, char end) {
	printf("%lld%c", (long long)x, end);
}
ll pow(ll a, ll b, ll p) {
	ll ans = 1;
	while (b != 0) {
		if ((b & 1) == 1) {
			ans = ans * a % p;
		}
		a = a * a % p;
		b = b / 2;
	}
	return ans;
}
ll gcd(ll a, ll b) {
	return b == 0 ? a : gcd(b, a % b);
}
ll lcm(ll a, ll b) {
	return a / gcd(a, b) * b;
}
void exgcd(ll a, ll b, ll & x0, ll & y0) {
	if (b == 0) {
		x0 = 1;
		y0 = 0;
	} else {
		exgcd(b, a % b, y0, x0);
		y0 -= a / b * x0;
	}
}
ll inv(ll a, ll b) {
	ll x0, y0;
	exgcd(a, b, x0, y0);
	x0 = (x0 + b) % b;
	return x0;
}
namespace MillerRabin {
	const ll prime[12] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37};
	const int pcnt = 12;
	bool check(ll n, ll a) {
		ll t = n - 1, k = 0;
		while ((t & 1) == 0) {
			t /= 2;
			k++;
		}
		ll now = pow(a, t, n), next;
		for (int i = 0; i < k; i++) {
			next = now * now % n;
			if (next == 1 && now != 1 && now != n - 1) {
				return false;
			}
			now = next;
		}
		if (now != 1) {
			return false;
		} else {
			return true;
		}
	}
	bool is_prime(ll n) {
		if (n == 1) {
			return false;
		}
		for (int i = 0; i < pcnt; i++) {
			if (n == prime[i]) {
				return true;
			}
			if (!check(n, prime[i])) {
				return false;
			}
		}
		return true;
	}
}
namespace PollardRho {
	vector < ll > factors;
	ll f(ll x, ll c, ll n) {
		return (x * x + c) % n;
	}
	ll abs(ll x) {
		return x < 0 ? -x : x;
	}
	ll gcd(ll a, ll b) {
		return b == 0 ? a : gcd(b, a % b);
	}
	void get_factors(ll n) {
		if (MillerRabin::is_prime(n)) {
			factors.push_back(n);
		} else if (n == 4) {
			factors.push_back(2);
			factors.push_back(2);
		} else {
			while (true) {
				ll c = rand() % n;
				ll t = 0, r = 0;
				do {
					ll val = 1;
					for (int i = 0; i < 128; i++) {
						t = f(t, c, n);
						r = f(f(r, c, n), c, n);
						if (t == r || val * abs(r - t) % n == 0) {
							break;
						}
						val = val * abs(r - t) % n;
					}
					ll g = gcd(n, val);
					if (g > 1) {
						get_factors(g);
						get_factors(n / g);
						return;
					}
				} while (t != r);
			}
		}
	}
}
namespace Lucas {
	const int N = 1000005;
	ll mod;
	ll fac[N];
	ll invfac[N];
	void set_mod(ll p) {
		mod = p;
		fac[0] = 1;
		for (ll i = 1; i < mod; i++) {
			fac[i] = fac[i - 1] * i % mod;
		}
		invfac[mod - 1] = pow(fac[mod - 1], mod - 2, mod);
		for (ll i = mod - 2; i >= 0; i--) {
			invfac[i] = invfac[i + 1] * (i + 1) % mod;
		}
	}
	ll C(ll n, ll m) {
		if (m > n) {
			return 0;
		} else {
			return fac[n] * invfac[m] % mod * invfac[n - m] % mod;
		}
	}
	ll Lucas(ll n, ll m) {
		if (m == 0) {
			return 1;
		} else {
			return C(n % mod, m % mod) * Lucas(n / mod, m / mod);
		}
	}
}
namespace CRT {
	const int N = 100005;
	int n;
	ll a[N], b[N];
	ll CRT() {
		ll ans = 0;
		ll M = 1;
		for (int i = 1; i <= n; i++) {
			M *= b[i];
		}
		for (int i = 1; i <= n; i++) {
			ans = (ans + a[i] * M / b[i] * inv(M / b[i], b[i])) % M;
		}
		return ans;
	}
}
namespace exCRT {
	const int N = 100005;
	int n;
	ll a[N], b[N];
	void merge(ll & a0, ll & b0, ll a1, ll b1) {
		ll k0, k1;
		exgcd(b0, b1, k0, k1);
		k0 *= a1 - a0;
		k0 /= gcd(b0, b1);
		a0 = a0 + b0 * k0;
		b0 = lcm(b0, b1);
		a0 = (a0 % b0 + b0) % b0;
	}
	ll exCRT() {
		ll ansa = a[1], ansb = b[1];
		for (int i = 2; i <= n; i++) {
			merge(ansa, ansb, a[i], b[i]);
		}
		return ansa;
	}
}
namespace exLucas {
	ll f(ll n, ll p) {
		if (n < p) {
			return 0;
		} else {
			return f(n / p, p) + n / p;
		}
	}
	ll g(ll n, ll p, ll k, ll power) { // power = p ^ k
		if (n == 0) {
			return 1;
		} else {
			ll part1 = g(n / p, p, k, power);
			ll part2 = 1;
			for (ll i = 1; i <= power; i++) {
				if (gcd(i, p) == 1) {
					part2 = part2 * i % power;
				}
			}
			part2 = pow(part2, n / power, power);
			ll part3 = 1;
			for (ll i = n / power * power; i <= n; i++) {
				if (gcd(i, p) == 1) {
					part3 = part3 * i % power;
				}
			}
			return part1 * part2 % power * part3 % power;
		}
	}
	ll __binom(ll n, ll m, ll p, ll k, ll power) {
		return g(n, p, k, power) * inv(g(m, p, k, power), power) % power * inv(g(n - m, p, k, power), power) % power * pow(p, f(n, p) - f(m, p) - f(n - m, p), power) % power;
	}
	ll exLucas(ll n, ll m, ll p) {
		PollardRho::factors.clear();
		PollardRho::get_factors(p);
		map < ll , ll > k;
		for (ll factor : PollardRho::factors) {
			k[factor]++;
		}
		int cnt = 0;
		for (auto g : k) {
			cnt++;
			CRT::a[cnt] = __binom(n, m, g.first, g.second, pow(g.first, g.second, 0x7fffffffffffffffLL));
			CRT::b[cnt] = pow(g.first, g.second, 0x7fffffffffffffffLL);
		}
		CRT::n = cnt;
		return CRT::CRT();
	}
}
namespace BSGS {
	ll a, b, p;
	ll BSGS() {
		ll t = sqrtl(p);
		map < ll , ll > hash;
		for (ll bpowerai = b, i = 0; i < t; i++, bpowerai = bpowerai * a % p) {
			hash[bpowerai] = i;
		}
		ll powerat = 1;
		for (ll i = 0; i < t; i++) {
			powerat = powerat * a % p;
		}
		for (ll powerati = 1, i = 0; i <= t; i++) {
			ll j = hash.find(powerati) == hash.end() ? -1 : hash[powerati];
			if (j != -1 && i * t - j >= 0) {
				return i * t - j;
			}
			powerati = powerati * powerat % p;
		}
		return -1;
	}
}
namespace Cipolla {
	ll n, p, w;
	struct Complex {
		ll a, b;
		Complex() {
			a = b = 0;
		}
	};
	Complex operator * (const Complex & a, const Complex & b) {
		Complex c;
		c.a = (a.a * b.a % p + w * a.b % p * b.b % p) % p;
		c.b = (a.b * b.a % p + a.a * b.b % p) % p;
		return c;
	}
	Complex pow(Complex a, ll b) {
		Complex ans;
		ans.a = 1;
		while (b != 0) {
			if ((b & 1) == 1) {
				ans = ans * a;
			}
			b /= 2;
			a = a * a;
		}
		return ans;
	}
	ll pow(ll a, ll b, ll p) {
		int ans = 1;
		while (b != 0) {
			if ((b & 1) == 1) {
				ans = ans * a % p;
			}
			b /= 2;
			a = a * a % p;
		}
		return ans;
	}
	ll Legendre(ll n, ll p) {
		return pow(n, (p - 1) / 2, p);
	}
	ll solve() {
		if (n == 0) {
			return 0;
		} else if (Legendre(n, p) == p - 1) {
			return -1;
		} else {
			ll a;
			while (true) {
				a = rand() % p;
				w = (a * a % p - n + p) % p;
				if (Legendre(w, p) == p - 1) {
					break;
				}
			}
			Complex res;
			res.a = a;
			res.b = 1;
			res = pow(res, (p + 1) / 2);
			return res.a;
		}
	}
}
int main() {
	ll n, m, p;
	n = read();
	m = read();
	p = read();
	write(exLucas::exLucas(n, m, p), '\n');
	return 0;
}