Amr doesn't like Maths as he finds it really boring, so he usually sleeps in Maths lectures. But one day the teacher suspected that Amr is sleeping and asked him a question to make sure he wasn't.

First he gave Amr two positive integers n and k. Then he asked Amr, how many integer numbers x > 0 exist such that:

  * Decimal representation of x (without leading zeroes) consists of exactly n digits; 
  * There exists some integer y > 0 such that: 
    * <image>; 
    * decimal representation of y is a suffix of decimal representation of x. 



As the answer to this question may be pretty huge the teacher asked Amr to output only its remainder modulo a number m.

Can you help Amr escape this embarrassing situation?

Input

Input consists of three integers n, k, m (1 ≤ n ≤ 1000, 1 ≤ k ≤ 100, 1 ≤ m ≤ 109).

Output

Print the required number modulo m.

Examples

Input

1 2 1000


Output

4

Input

2 2 1000


Output

45

Input

5 3 1103


Output

590

Note

A suffix of a string S is a non-empty string that can be obtained by removing some number (possibly, zero) of first characters from S.
#include <bits/stdc++.h>
using namespace std;
namespace QoE_Library {
namespace QL_Bare_Minimum {
const double PI = 3.141592653589793238460;
const long double E = 2.7182818284590452353;
const long double pi = 10000 * acos(-1.0L);
template <typename T1>
void swap(T1 &x, T1 &y) {
  x = x + y;
  y = x - y;
  x = x - y;
}
void swapChars(char *a, char *b) {
  char tmp = *a;
  *a = *b;
  *b = tmp;
}
template <typename T1>
T1 gcd(T1 a, T1 b) {
  if (!b)
    return a;
  else
    return gcd(b, a % b);
}
}  // namespace QL_Bare_Minimum
}  // namespace QoE_Library
using namespace QoE_Library::QL_Bare_Minimum;
void storePowers(unsigned long long int *powers, unsigned long long int base,
                 unsigned long long int exponent,
                 unsigned long long int modulo = -1) {
  powers[0] = 1;
  for (int i = (1); i < (exponent + 1); i = i + (1)) {
    powers[i] = base * powers[i - 1];
    if (-1 != modulo) powers[i] %= modulo;
  }
}
long long int recurse_dp(int dp[1001][101][2], int idx, int rem,
                         bool zeroRemInterim, int n, int k, int mod,
                         unsigned long long int *powMod,
                         unsigned long long int *powK) {
  if (!rem && zeroRemInterim)
    return idx != n ? (powMod[n - idx - 1] * 9LL) % mod : 1LL;
  if (idx == n) return 0;
  if (-1 != dp[idx][rem][zeroRemInterim]) return dp[idx][rem][zeroRemInterim];
  dp[idx][rem][zeroRemInterim] = 0;
  int &t = dp[idx][rem][zeroRemInterim];
  for (int i = (0); i < (10); i = i + (1)) {
    t += recurse_dp(dp, idx + 1, (rem + (i * powK[idx]) % k) % k,
                    zeroRemInterim || (i != 0), n, k, mod, powMod, powK);
    t %= mod;
  }
  return dp[idx][rem][zeroRemInterim];
}
int dp[1001][101][2];
unsigned long long int powMod[1001];
unsigned long long int powK[1001];
int main() {
  int n, k, mod;
  ios_base::sync_with_stdio(0);
  cin >> n >> k >> mod;
  storePowers(powMod, 10, n, mod);
  storePowers(powK, 10, n, k);
  memset(dp, -1, sizeof(dp));
  bool zeroRemInterim = false;
  int remainder = 0, startIdx = 0;
  cout << recurse_dp(dp, startIdx, remainder, zeroRemInterim, n, k, mod, powMod,
                     powK);
}
