import sys

def main():
    A, B, N = map(int, sys.stdin.readline().split())
    MOD = 10**9 + 7
    MOD_PHI = MOD - 1  # Since MOD is prime

    # Precompute c[m] for m from 1 to B
    max_m = B
    c = [0] * (max_m + 1)
    for m in range(1, max_m + 1):
        c[m] = (B // m) - ((A - 1) // m)

    # Precompute pow_cm[m] = c[m]^N mod MOD_PHI, but handle c[m] = 0
    pow_cm = [0] * (max_m + 1)
    for m in range(1, max_m + 1):
        if c[m] > 0:
            pow_cm[m] = pow(c[m], N, MOD_PHI)
        else:
            pow_cm[m] = 0

    # Sieve to compute Mobius function
    mobius = [1] * (max_m + 1)
    is_prime = [True] * (max_m + 1)
    min_prime = [0] * (max_m + 1)

    for i in range(2, max_m + 1):
        if not is_prime[i]:
            continue
        min_prime[i] = i
        for j in range(i * i, max_m + 1, i):
            if is_prime[j]:
                is_prime[j] = False
                min_prime[j] = i  # For numbers with multiple prime factors, min_prime will be set to smallest

    for n in range(2, max_m + 1):
        if is_prime[n]:
            mobius[n] = -1
        else:
            temp = n
            p = min_prime[temp]
            cnt = 0
            if temp % p == 0:
                temp //= p
                cnt += 1
                if temp % p == 0:
                    # has square factor
                    mobius[n] = 0
                else:
                    mobius[n] = -mobius[temp]
            else:
                # shouldn't happen since p is the smallest prime factor
                pass

    # Compute f array
    f = [0] * (max_m + 1)
    for k in range(1, max_m + 1):
        mu_k = mobius[k]
        if mu_k == 0:
            continue
        # Iterate over m = k * d where m <= B, d = m //k
        # which means m ranges from k, 2k, ... to up to B
        for m in range(k, max_m + 1, k):
            if pow_cm[m] == 0:
                continue
            d = m // k
            f[d] += mu_k * pow_cm[m]
            # To handle large sums mod MOD_PHI, take modulo at each step
            # But for correctness in summation, we can do mod once after
            # Because summing integers could overflow, but in Python it's okay

    # Compute the final product
    result = 1
    for d in range(1, max_m + 1):
        if f[d] == 0:
            continue
        exponent = f[d] % MOD_PHI
        if exponent < 0:
            exponent += MOD_PHI
        d_mod = d % MOD
        result = (result * pow(d_mod, exponent, MOD)) % MOD

    print(result)

if __name__ == '__main__':
    main()