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.util.*;
import java.io.*;
import java.lang.reflect.Array;
import java.math.*;
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        int t = 1;
        while ((t --) > 0)
            solver.solve(in, out);
        out.close();
    }
}

class Task{ 
    void solve (InputReader cin , PrintWriter cout) {
        BigInteger w , m , k , ans = BigInteger.ZERO;
        w = cin.nextBigInteger();
        m = cin.nextBigInteger();
        k = cin.nextBigInteger();
        String s = m.toString();
        int now = s.length();
        for (int i = now ; ; i ++) {
            if (i == now) {
                BigInteger remain = BigInteger.valueOf(10).pow(now).subtract(m);
                BigInteger cost = remain.multiply(k).multiply(BigInteger.valueOf(i));
                if (cost.compareTo(w) < 0) {
                    w = w.subtract(cost);
                    ans = ans.add (remain);
                }
                else {
                    BigInteger t = w.divide(BigInteger.valueOf(i).multiply(k));
                    ans = ans.add(t);
                    break;
                }
            }
            else {
                BigInteger remain = BigInteger.valueOf(10).pow(i).subtract(BigInteger.valueOf(10).pow(i - 1));
                BigInteger cost = remain.multiply(k).multiply(BigInteger.valueOf(i));
                if (cost.compareTo(w) < 0) {
                    w = w.subtract(cost);
                    ans = ans.add (remain);
                }
                else {
                    BigInteger t = w.divide(BigInteger.valueOf(i).multiply(k));
                    ans = ans.add(t);
                    break;
                }
            }
        }
        cout.println (ans);
    }  
}  
class InputReader {  
    public BufferedReader reader;  
    public StringTokenizer tokenizer;  
    public InputReader(InputStream stream) {  
        reader = new BufferedReader(new InputStreamReader(stream));  
        tokenizer = null;  
    }  
    public String next() {  
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {  
            try {  
                tokenizer = new StringTokenizer(reader.readLine());  
            } catch (IOException e) {  
                throw new RuntimeException(e);  
            }  
        }  
        return tokenizer.nextToken();  
    }  
    public int nextInt() {  
        return Integer.parseInt(next());  
    }  
    public long nextLong() {  
        return Long.parseLong(next());  
    }  
    public double nextDouble() {  
        return Double.parseDouble(next());  
    }  
    public BigInteger nextBigInteger() {  
        return new BigInteger(next());  
    }  
}  