from collections import defaultdict
import math

def Factorize(N):
    assert N>=1
    factors=defaultdict(int)
    for p in range(2,N):
        if p**2>N:
            break
        while N%p==0:
            factors[p]+=1
            N//=p
    if N!=1:
        factors[N]+=1
    return factors
def CRT(remainder_lst,mod_lst):
    assert len(remainder_lst)==len(mod_lst)
    if not remainder_lst:
        return 0,1
    remainder,mod=remainder_lst[0],mod_lst[0]
    for r,m in zip(remainder_lst[1:],mod_lst[1:]):
        if (r,m)==(-1,0):
            remainder,mod=-1,0
            break
        r%=m
        g=math.gcd(mod,m)
        lcm=LCM(mod,m)
        if remainder%g!=r%g:
            remainder,mod=-1,0
            break
        remainder,mod=(r+m*((remainder-r)//g)*Extended_Euclid(m//g,mod//g)[0])%lcm,lcm
    return remainder,mod
def Extended_Euclid(n,m):
    stack=[]
    while m:
        stack.append((n,m))
        n,m=m,n%m
    if n>=0:
        x,y=1,0
    else:
        x,y=-1,0
    for i in range(len(stack)-1,-1,-1):
        n,m=stack[i]
        x,y=y,x-(n//m)*y
    return x,y

def inverse(x,mod):
    return Extended_Euclid(x,mod)[0]
    
def LCM(n,m):
    if n or m:
        return abs(n)*abs(m)//math.gcd(n,m)
    return 0

M,N,D=map(int,input().split())
F=Factorize(D)
def solve(N,M):
    remainders=[]
    mods=[]
    C=[]
    P,E=[],[]
    for p,e in F.items():
        pe=p**e
        def solve0(N,p,e,pe):
            if p==2:
                if e==2:
                    return 3
                return 1
            c=N//pe
            retu=pow(pe-1,c,pe)
            N=N-pe*c
            for i in range(1,N+1):
                if i%p:
                    retu*=i
                    retu%=pe
            return retu
        def solve1(N,p,e,pe):
            retu=1
            NN=N
            while NN:
                retu*=solve0(NN,p,e,pe)
                retu%=pe
                NN//=p
            cnt=0
            NN=N
            while NN:
                cnt+=NN//p
                NN//=p
            return retu,cnt
        x,c=solve1(M,p,e,pe)
        x0,c0=solve1(N,p,e,pe)
        x0=inverse(x0,pe)
        x*=x0
        c-=c0
        x%=pe
        x1,c1=solve1(M-N,p,e,pe)
        x1=inverse(x1,pe)
        x*=x1
        c-=c1
        x%=pe
        remainders.append(x)
        mods.append(pe)
        C.append(c)
        P.append(p)
        E.append(e)
    mi=min(c//e for c,e in zip(C,E))
    le=len(P)
    for i in range(le):
        C[i]-=mi*E[i]
    retu,mod=CRT(remainders,mods)
    for i in range(le):
        retu*=pow(P[i],C[i],mod)
        retu%=mod
    return retu

ans=solve(N,M)
print(ans)