// Arup Guha
// 7/29/2013
// Solution to 2013 World Finals Problem B: Hey, Better Bettor

import java.util.*;

public class bettor {

	// Input values
	public static double refund;
	public static double p;

	public static void main(String[] args) {

		Scanner stdin = new Scanner(System.in);

		// Read input
		refund = stdin.nextDouble()/100;
		p = stdin.nextDouble()/100;
		int win, loss, bestwin = 1;
		double best = 0;

		// Try folding at 1 loss and iteratively increment.
		loss = 1;

		// We'll break out of this loop.
		while (true) {

			// No point in searching in this case.
			if (p == 0) break;

			double prev = 0;
			boolean flag = false;

			// Notice that there is no point in searching below this value, if we
			// increase our loss point.
			win=bestwin;

			// Try each value at which to cash out.
			while (true) {

				// Try this, see if it's better.
				double cur = solve(win, loss);
				if (cur > best) {
					best = cur;
					bestwin = win;
					flag = true;
				}

				// This function hits a max and comes down, so we can cut out of our search here.
				if (cur < prev) break;
				prev = cur;
				win++;
			}

			// If we never updated, then no further searching will help.
			if (!flag) break;
			loss++;
		}

		// Here is our answer!
		System.out.println(best);
	}


	// This function returns the expectation of returns given that we plan on cashing out when we're
	// ahead by win or down by loss. The math here is from the Gambler's Ruin Problem. I haven't
	// solved it out myself from first priciples, but it stems from solving a recurrence relation.
	// My solution used a large matrix exponentiation previously, but that would time out. Antony
	// pointed me to the Gambler's Ruin.
	public static double solve(int win, int loss) {

		// Precompute the necessary terms.
		double factor = (1-p)/p;
		double x = Math.pow(factor, loss);
		double y = Math.pow(factor, win+loss);

		// Calculate our probabilities of winning and losing.
		double pLoss = (x-y)/(1-y);
		double pWin = (1-x)/(1-y);

		// Return the corresponding expectation.
		return -pLoss*loss*(1-refund) + pWin*win;
	}
}