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.math.BigInteger;
import java.util.Scanner;

/**
 * \
 * 
 * http://codeforces.com/problemset/problem/373/B
 * 
 */
public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		long w = in.nextLong();
		long m = in.nextLong();
		long k = in.nextInt();
		
		/*
		 * high is always not in the actual range low is not in the actual range
		 * MOST of the time except for this beginning value (the m). This
		 * exception is so that size calculations are accurate.
		 */
		
		long low = m;
		// currS = current length of numbers being investigated
		int currS = S(m);
		long high = powten(currS);
		long maxLength = 0; // max length of sequence

		while (true) {
			long size = high - low;
			BigInteger tempSize = new BigInteger(Long.toString(size));
			BigInteger tempCurrS = new BigInteger(Long.toString(currS));
			BigInteger tempK = new BigInteger(Long.toString(k));
			BigInteger tempW = new BigInteger(Long.toString(w));
			BigInteger temp = tempSize.multiply(tempCurrS).multiply(tempK);
			int tempGreater = temp.compareTo(tempW);
			if (tempGreater > 0){
				break;
			} else {
				w -= k * currS * size;
			}
			if (w == 0) {
				currS++;
				maxLength += size;
				break;
			} else {
				currS++;
				low = high;
				high = powten(currS);
				maxLength += size;
			}
		}
		
		//added this statement, otherwise int used instead and overflow occurs
		long addCost = k * currS;
		maxLength += w / addCost;

		System.out.println(maxLength);

	}

	private static int S(long m) {
		return Long.toString(m).length();
	}

	private static long powten(int s) {
		long result = 1;
		for (int i = 0; i < s; i++) {
			result = result * 10;
		}
		return result;
	}

}
