Problem: Valera is a coder. Recently he wrote a funny program. The pseudo code for this program is given below:
    
    
      
    //input: integers x, k, p  
    a = x;  
    for(step = 1; step <= k; step = step + 1){  
        rnd = [random integer from 1 to 100];  
        if(rnd <= p)  
            a = a * 2;  
        else  
            a = a + 1;  
    }  
      
    s = 0;  
      
    while(remainder after dividing a by 2 equals 0){  
        a = a / 2;  
        s = s + 1;  
    }  
      
    

Now Valera wonders: given the values x, k and p, what is the expected value of the resulting number s?

Input

The first line of the input contains three integers x, k, p (1 ≤ x ≤ 109; 1 ≤ k ≤ 200; 0 ≤ p ≤ 100).

Output

Print the required expected value. Your answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.

Examples

Input

1 1 50


Output

1.0000000000000


Input

5 3 0


Output

3.0000000000000


Input

5 3 25


Output

1.9218750000000

Note

If the concept of expected value is new to you, you can read about it by the link: 

http://en.wikipedia.org/wiki/Expected_value

Solution (in JAVA):

Solution:
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Itpossible
 */
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);
		E solver = new E();
		solver.solve(1, in, out);
		out.close();
	}
}

class E {
    public double[][][][] dp;
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        int x = in.nextInt();
        int k = in.nextInt();
        int p = in.nextInt();
        dp = new double[2][256][251][2];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 256; j++) {
                for (int u = 0; u < 251; u++) {
                    dp[i][j][u][0] = 0;
                    dp[i][j][u][1] = 0;
                }
            }
        }
        int y=x/256;
        if(y==0) {
            dp[0][x&255][0][0]=1;
        } else {
            if((y&1)==0) {
                int z=0;
                for(; (y&1)==0; z++) {
                    y>>=1;
                }
                dp[0][x&255][z][0]=1;
            } else {
                int z=0;
                for(; (y&1)>0; z++) {
                    y>>=1;
                }
                dp[0][x&255][z][1]=1;
            }
        }
        for(int i=0; i<k; i++) {

            for(int j=0; j<256; j++) {
                for (int u = 0; u < 250; u++) {
                    dp[(i+1)&1][j][u][0]=0;
                    dp[(i+1)&1][j][u][1]=0;
                }
            }
            for(int j=0; j<256; j++) {
                for(int u=0; u<250; u++) {
                    if((j&128)>0) {
                        dp[(i+1)&1][(j<<1)&255][1][1]+=dp[i&1][j][u][0]*p*0.01;
                        dp[(i+1)&1][(j<<1)&255][u+1][1]+=dp[i&1][j][u][1]*p*0.01;
                    } else {
                        dp[(i+1)&1][(j<<1)&255][u+1][0]+=dp[i&1][j][u][0]*p*0.01;
                        dp[(i+1)&1][(j<<1)&255][1][0]+=dp[i&1][j][u][1]*p*0.01;
                    }
                    if(j==255) {
                        dp[(i+1)&1][0][1][1]+=dp[i&1][j][u][0]*(1-p*0.01);
                        dp[(i+1)&1][0][u][0]+=dp[i&1][j][u][1]*(1-p*0.01);
                    } else {
                        dp[(i+1)&1][j+1][u][0]+=dp[i&1][j][u][0]*(1-p*0.01);
                        dp[(i+1)&1][j+1][u][1]+=dp[i&1][j][u][1]*(1-p*0.01);
                    }
                }
            }
        }
        double ans=0;
        for(int j=0; j<256; j++) {
            int cnt=0;
            if(j>0) {
                for (int t = j; (t & 1) == 0; cnt++) {
                    t >>= 1;
                }
            }
            for(int u=0; u<250; u++) {
                if(j==0) {
                    ans+=dp[k&1][0][u][0]*(8+u);
                    ans+=dp[k&1][0][u][1]*8;
                } else {
                    ans+=dp[k&1][j][u][0]*cnt;
                    ans+=dp[k&1][j][u][1]*cnt;
                }
            }
        }
        out.printf("%.13f\n",ans);
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream),65536);
        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());
    }

}