#include <bits/stdc++.h>

#define show(x) cerr << #x << " = " << x << endl

using namespace std;
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;

template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
    os << "sz=" << v.size() << "\n[";
    for (const auto& p : v) {
        os << p << ",";
    }
    os << "]\n";
    return os;
}

template <typename S, typename T>
ostream& operator<<(ostream& os, const pair<S, T>& p)
{
    os << "(" << p.first << "," << p.second
       << ")";
    return os;
}


constexpr ll MOD = 1e9 + 7;

template <typename T>
constexpr T INF = numeric_limits<T>::max() / 100;

ll A, N, M;
vector<int> prime;


template <typename T>
T extgcd(const T a, const T b, T& x, T& y)  // ax+by=gcd(a,b)
{
    T d = a;
    if (b != 0) {
        d = extgcd(b, a % b, y, x);
        y -= (a / b) * x;
    } else {
        x = 1;
        y = 0;
    }
    return d;
}

template <typename T>
pair<T, T> ChineseRemainderTheorem(const pair<T, T> a1, const pair<T, T> a2)
{
    assert(gcd(a1.first, a2.first) == 1);
    const T p1 = a1.first;
    const T m1 = a1.second;
    const T p2 = a2.first;
    const T m2 = a2.second;
    if (m1 == m2) {
        return make_pair(p1 * p2, m1);
    } else {
        T x, y;
        extgcd(p1, p2, x, y);
        assert(p1 * x + p2 * y == 1);
        x *= (m2 - m1);
        y *= (m2 - m1);
        const T p = p1 * p2;
        return make_pair(p, (((p1 * x + m1) % p) + p) % p);
    }
}

int rem(const int n, const int mod)  // a↑↑n (mod n)
{
    if (n == 0) {
        return 1 % mod;
    } else if (mod == 1) {
        return 0;
    } else {
        int num = mod;
        vector<pii> fac;
        vector<int> phi;
        for (const int p : prime) {
            if (num % p == 0) {
                int beki = 1;
                while (num % p == 0) {
                    beki *= p;
                    num /= p;
                }
                fac.push_back(make_pair(beki, 1));
                phi.push_back(beki / p * (p - 1));
            }
            if (num == 1) {
                break;
            }
        }
        const int size = fac.size();
        for (int i = 0; i < size; i++) {
            const int m = rem(n - 1, phi[i]);
            for (int j = 0; j < m; j++) {
                fac[i].second = (fac[i].second * (A % fac[i].first)) % fac[i].first;
            }
        }

        pair<int, int> result = fac[0];
        for (int i = 1; i < size; i++) {
            result = ChineseRemainderTheorem(result, fac[i]);
        }
        return result.second;
    }
}

int main()
{
    cin >> A >> N >> M;
    vector<bool> isprime(M + 1, true);
    for (int i = 2; i <= M; i++) {
        if (isprime[i]) {
            for (int j = 2; i * j <= M; j++) {
                isprime[i * j] = false;
            }
        }
    }
    for (int i = 2; i <= M; i++) {
        if (isprime[i]) {
            prime.push_back(i);
        }
    }

    cout << rem(N, M) << endl;

    return 0;
}