We'll define S(n) for positive integer n as follows: the number of the n's digits in the decimal base. For example, S(893) = 3, S(114514) = 6.

You want to make a consecutive integer sequence starting from number m (m, m + 1, ...). But you need to pay S(n)·k to add the number n to the sequence.

You can spend a cost up to w, and you want to make the sequence as long as possible. Write a program that tells sequence's maximum length.

Input

The first line contains three integers w (1 ≤ w ≤ 1016), m (1 ≤ m ≤ 1016), k (1 ≤ k ≤ 109).

Please, do not write the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.

Output

The first line should contain a single integer — the answer to the problem.

Examples

Input

9 1 1


Output

9


Input

77 7 7


Output

7


Input

114 5 14


Output

6


Input

1 1 2


Output

0
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Exercise2 implements Runnable {

    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer st;

    private void solve() throws IOException {
        long maxPrice = nextLong();
        long firstNumber = nextLong();
        long coeff = nextLong();
        BigInteger bigCoeff = BigInteger.valueOf(coeff);
        BigInteger bigMaxPrice = BigInteger.valueOf(maxPrice);

        BigInteger currentSum = BigInteger.ZERO;

        BigInteger digits;
        BigInteger curNumber;
        BigInteger nextNumber = BigInteger.valueOf(firstNumber);
        boolean canHigher = true;
        BigInteger count = BigInteger.ZERO;

        while (canHigher) {
            curNumber = nextNumber;
            digits = BigInteger.valueOf(getNumberLenght(curNumber));
            nextNumber = provideNextNumber(digits.intValue());

            BigInteger tempCount = nextNumber.subtract(curNumber);
            BigInteger tempSum = tempCount.multiply(digits).multiply(bigCoeff);

            if (currentSum.add(tempSum).compareTo(bigMaxPrice) <= 0) {
                currentSum = currentSum.add(tempSum);
                count =  count.add(tempCount);
            } else {
                BigInteger leftOver = bigMaxPrice.subtract(currentSum).divide(digits).divide(bigCoeff);
                currentSum = currentSum.add(leftOver.multiply(digits).multiply(bigCoeff));
                count = count.add(leftOver);
                canHigher = false;
            }
        }

        out.printf("%s", count.toString());
    }

    private int getNumberLenght(BigInteger number) {
        return number.toString().length();
    }

    private BigInteger provideNextNumber(int digits) {
        BigInteger result = BigInteger.TEN;
        result = result.pow(digits);
        return result;
    }

    public static void main(String[] args) {
        new Exercise2().run();
    }

    @Override
    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace(System.err);
            System.exit(1);
        }
    }

    private String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = in.readLine();

            if (line == null) {
                return null;
            }

            st = new StringTokenizer(line);
        }

        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}
