#include <iostream>
#include <string>

using namespace std;
using ll = long long;

// Hàm nhân hai số lớn theo modulo, sử dụng __int128 để tránh tràn số
ll mul_mod(ll a, ll b, ll mod) {
    return (__int128)a * b % mod;
}

// Hàm tính lũy thừa theo modulo: (base^exp) % mod
ll pow_mod(ll base, ll exp, ll mod) {
    ll res = 1 % mod;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) res = mul_mod(res, base, mod);
        base = mul_mod(base, base, mod);
        exp >>= 1;
    }
    return res;
}

// Hàm tính tổng cấp số nhân: S = 1 + r + r^2 + ... + r^{n-1} (mod mod)
// Sử dụng chia để trị (đệ quy)
ll geom_sum(ll r, ll n, ll mod) {
    if (n == 0) return 0;
    if (n == 1) return 1 % mod;

    // Trường hợp đặc biệt: r % mod == 1 thì tổng là n * 1 = n
    if (r % mod == 1) {
        return n % mod;
    }

    if (n % 2 == 0) {
        // Nửa đầu: S(n/2)
        // Nửa sau: r^{n/2} * S(n/2)
        // Tổng: S(n) = S(n/2) * (1 + r^{n/2})
        ll half_sum = geom_sum(r, n / 2, mod);
        ll r_pow_half = pow_mod(r, n / 2, mod);
        return mul_mod(half_sum, (1 + r_pow_half) % mod, mod);
    } else {
        // N = 2k + 1
        // S(2k+1) = S(2k) + r^{2k}
        //          = S(k) * (1 + r^k) + (r^k)^2
        ll half_sum = geom_sum(r, n / 2, mod);
        ll r_pow_half = pow_mod(r, n / 2, mod);
        ll term1 = mul_mod(half_sum, (1 + r_pow_half) % mod, mod);
        ll term2 = mul_mod(r_pow_half, r_pow_half, mod);
        return (term1 + term2) % mod;
    }
}

int main() {
    ll x, n, m;
    if (cin >> x >> n >> m) {
        // Bước 1: Tính d = số chữ số của x
        string s = to_string(x);
        ll d = s.length();

        // Bước 2: Tính base = 10^d % m
        ll base = pow_mod(10, d, m);

        // Bước 3: Tính tổng cấp số nhân S = 1 + base + ... + base^{n-1}
        ll S = geom_sum(base, n, m);

        // Bước 4: Tính kết quả cuối cùng
        // y = x * (10^{d(n-1)} + ... + 10^d + 1) = x * S
        ll ans = mul_mod(x % m, S, m);

        cout << ans << endl;
    }
    return 0;
}

// Pseudocode logic
// Giả sử có hàm mul_mod(a, b, m) và pow_mod(base, exp, m)

struct State {
    ll val; // Giá trị phần số hiện tại modulo m
    ll len; // Chiều dài phần số hiện tại modulo phi(m) (hoặc chỉ đơn giản là độ dài chu kỳ)
};

int main() {
    ll x, n, m;
    cin >> x >> n >> m;

    string s = to_string(x);
    ll d = s.length();
    ll base = pow_mod(10, d, m); // 10^d % m

    // Tính tổng geometric series S = (base^n - 1) / (base - 1)
    // Tránh chia nếu base == 1
    ll S;
    if (base == 1) {
        S = n % m;
    } else {
        // Tính (base^n - 1) * inv(base - 1) mod m
        // Nếu m không phải số nguyên tố, cần dùng Bézout hoặc cách khác.
        // Thực tế, giải pháp chia để trị an toàn hơn với mọi m.
        // Tuy nhiên, nếu m là số nguyên tố, ta có thể dùng:
        // ll inv = pow_mod(base - 1, m - 2, m);
        // ll num = (pow_mod(base, n, m) - 1 + m) % m;
        // S = mul_mod(num, inv, m);
    }

    ll ans = mul_mod(x % m, S, m);
    cout << ans << endl;
}

#include <iostream>
#include <string>

using namespace std;
using ll = long long;

int main() {
    ll x, n, m;
    cin >> x >> n >> m;

    string s = to_string(x);
    ll current = 0;

    // Lặp n lần
    for (ll i = 0; i < n; i++) {
        for (char c : s) {
            current = (current * 10 + (c - '0')) % m;
        }
    }

    cout << current << endl;
    return 0;
}