import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class Euler765 {
    static final MathContext MC = new MathContext(50, RoundingMode.HALF_UP);

    static BigDecimal optimalSuccessProbability(int rounds, double pWin, double target) {
        if (target <= 1.0) {
            return BigDecimal.ONE;
        }

        BigDecimal budgetQ = BigDecimal.ONE.divide(new BigDecimal(Double.toString(target)), MC);

        BigDecimal[] q = new BigDecimal[rounds + 1];
        BigDecimal two = new BigDecimal("2");
        q[0] = BigDecimal.ONE.divide(two.pow(rounds, MC), MC);

        for (int w = 0; w < rounds; ++w) {
            BigDecimal rw = new BigDecimal(rounds - w);
            BigDecimal w1 = new BigDecimal(w + 1);
            q[w + 1] = q[w].multiply(rw, MC).divide(w1, MC);
        }

        BigDecimal pWinDec = new BigDecimal(Double.toString(pWin));
        BigDecimal oneMinusP = BigDecimal.ONE.subtract(pWinDec, MC);
        BigDecimal base = two.multiply(oneMinusP, MC).pow(rounds, MC);
        BigDecimal ratio = pWinDec.divide(oneMinusP, MC);

        BigDecimal[] p = new BigDecimal[rounds + 1];
        BigDecimal ratioPow = BigDecimal.ONE;
        for (int w = 0; w <= rounds; ++w) {
            p[w] = q[w].multiply(base, MC).multiply(ratioPow, MC);
            ratioPow = ratioPow.multiply(ratio, MC);
        }

        BigDecimal usedQ = BigDecimal.ZERO;
        BigDecimal successP = BigDecimal.ZERO;
        int boundaryW = -1;
        BigDecimal eps = new BigDecimal("1e-30");

        for (int w = rounds; w >= 0; --w) {
            BigDecimal candidateQ = usedQ.add(q[w], MC);
            if (candidateQ.compareTo(budgetQ.add(eps, MC)) <= 0) {
                usedQ = candidateQ;
                successP = successP.add(p[w], MC);
            } else {
                boundaryW = w;
                break;
            }
        }

        if (boundaryW == -1) {
            return BigDecimal.ONE;
        }

        BigDecimal frac = budgetQ.subtract(usedQ, MC).divide(q[boundaryW], MC);
        if (frac.compareTo(BigDecimal.ZERO) < 0)
            frac = BigDecimal.ZERO;
        if (frac.compareTo(BigDecimal.ONE) > 0)
            frac = BigDecimal.ONE;

        successP = successP.add(frac.multiply(p[boundaryW], MC), MC);
        return successP;
    }

    public static String solve() {
        BigDecimal ans = optimalSuccessProbability(1000, 0.6, 1000000000000.0);
        return ans.setScale(10, RoundingMode.HALF_UP).toPlainString();
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}