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.
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Iterator;
import java.util.StringTokenizer;

public class Main {

  public static void main(String[] args) throws IOException {
    IOScanner scanner;
    if (new File("data.in").exists()) {
      scanner = new IOScanner("data.in", null);
    } else {
      scanner = new IOScanner();
    }
    while (scanner.hasNext()) {
      new Solver(scanner).solve();
    }
    scanner.close();
  }
}

class IOScanner {
  private final BufferedReader reader;
  private final PrintWriter writer;
  private StringTokenizer stringTokenizer;

  public IOScanner() {
    this(System.in, System.out);
  }

  public IOScanner(String input, String output) throws FileNotFoundException {
    this(input == null ? null : new File(input), output == null ? null : new File(output));
  }

  public IOScanner(File input, File output) throws FileNotFoundException {
    this(input == null ? System.in : new FileInputStream(input), output == null ? System.out
        : new FileOutputStream(output));
  }

  public IOScanner(InputStream inputStream, OutputStream outputStream) {
    reader = new BufferedReader(new InputStreamReader(inputStream));
    writer = new PrintWriter(outputStream);
  }

  private StringTokenizer read() {
    while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
      try {
        stringTokenizer = new StringTokenizer(reader.readLine());
      } catch (Exception e) {
        return null;
      }
    }
    return stringTokenizer;
  }

  public boolean hasNext() {
    StringTokenizer tokenizer = read();
    return tokenizer != null && tokenizer.hasMoreTokens();
  }

  public int nextInt() {
    return Integer.parseInt(next());
  }

  public long nextLong() {
    return Long.parseLong(next());
  }

  public double nextDouble() {
    return Double.parseDouble(next());
  }

  public int[] nextInts(int n) {
    int[] input = new int[n];
    for (int i = 0; i < n; i++) {
      input[i] = nextInt();
    }
    return input;
  }

  public double[] nextDoubles(int n) {
    double[] input = new double[n];
    for (int i = 0; i < n; i++) {
      input[i] = nextDouble();
    }
    return input;
  }

  public String[] nexts(int n) {
    String[] input = new String[n];
    for (int i = 0; i < n; i++) {
      input[i] = next();
    }
    return input;
  }

  public char[][] nextCharArrays(int n) {
    String[] input = nexts(n);
    char[][] result = new char[n][];
    for (int i = 0; i < n; i++) {
      result[i] = input[i].toCharArray();
    }
    return result;
  }

  public String next() {
    return read().nextToken();
  }

  public void println() {
    writer.println();
  }

  public void println(Iterable<?> iterable) {
    println(iterable.iterator());
  }

  public void println(Iterator<?> iterator) {
    boolean first = true;
    while (iterator.hasNext()) {
      if (first) {
        first = false;
      } else {
        print(' ');
      }
      print(iterator.next());
    }
    println();
  }

  public void println(Object token) {
    writer.println(token);
  }

  public void print(Object token) {
    writer.print(token);
  }

  public void printf(String format, Object... args) {
    writer.printf(format, args);
  }

  public void flush() {
    writer.flush();
  }

  public void close() throws IOException {
    reader.close();
    writer.close();
  }
}

class Solver {

  private final IOScanner scanner;

  public Solver(IOScanner scanner) {
    this.scanner = scanner;
  }

  public void solve() {
    int n = scanner.nextInt();
    int m = scanner.nextInt();
    int mod = scanner.nextInt();
    long[][][] dp = new long[n + 1][m][2];
    long[] ten = new long[n + 1];
    for (int i = 0; i <= n; i++) {
      for (int j = 0; j < m; j++) {
        Arrays.fill(dp[i][j], 0);
      }
      ten[i] = (i == 0) ? 1 : (ten[i - 1] * 10 % m);
    }
    dp[n][0][0] = 1;
    for (int i = n; i > 0; i--) {
      for (int j = 0; j < m; j++) {
        for (int k = 0; k < 2; k++) {
          if (dp[i][j][k] != 0) {
            if (k != 0 && j == 0) {
              dp[i - 1][j][k] += dp[i][j][k] * (i == 1 ? 9 : 10) % mod;
              dp[i - 1][j][k] %= mod;
            } else {
              for (int p = i == 1 ? 1 : 0; p < 10; p++) {
                int nk = (k == 0 && p == 0) ? 0 : 1;
                dp[i - 1][(int) ((j + p * ten[n - i]) % m)][nk] += dp[i][j][k];
                dp[i - 1][(int) ((j + p * ten[n - i]) % m)][nk] %= mod;
              }
            }
          }
        }
      }
    }
    scanner.println(dp[0][0][1]);
  }
}