Problem: Your friend recently gave you some slimes for your birthday. You have a very large amount of slimes with value 1 and 2, and you decide to invent a game using these slimes.

You initialize a row with n empty spaces. You also choose a number p to be used in the game. Then, you will perform the following steps while the last space is empty. 

  1. With probability <image>, you will choose a slime with value 1, and with probability <image>, you will choose a slime with value 2. You place the chosen slime on the last space of the board. 
  2. You will push the slime to the left as far as possible. If it encounters another slime, and they have the same value v, you will merge the slimes together to create a single slime with value v + 1. This continues on until the slime reaches the end of the board, or encounters a slime with a different value than itself. 



You have played the game a few times, but have gotten bored of it. You are now wondering, what is the expected sum of all values of the slimes on the board after you finish the game.

Input

The first line of the input will contain two integers n, p (1 ≤ n ≤ 109, 1 ≤ p < 109).

Output

Print the expected sum of all slimes on the board after the game finishes. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 4.

Namely, let's assume that your answer is a and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

2 500000000


Output

3.562500000000000


Input

10 1


Output

64.999983360007620


Input

100 123456789


Output

269.825611298854770

Note

In the first sample, we have a board with two squares, and there is a 0.5 probability of a 1 appearing and a 0.5 probability of a 2 appearing.

Our final board states can be 1 2 with probability 0.25, 2 1 with probability 0.375, 3 2 with probability 0.1875, 3 1 with probability 0.1875. The expected value is thus (1 + 2)·0.25 + (2 + 1)·0.375 + (3 + 2)·0.1875 + (3 + 1)·0.1875 = 3.5625.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
int n, p;
double dp[1010][1010], dp2[1010][1010], prob[1010][1010], prob2[1010][1010];
double pw[1010];
const int matdim = 50 * 4 + 2;
double m[matdim][matdim], vec[matdim], rez[matdim][matdim];
void mult(double a[][matdim], double b[][matdim], double c[][matdim]) {
  double temp[matdim][matdim];
  memset(temp, 0, sizeof(temp));
  for (int i = 1; i < matdim; ++i) {
    for (int j = 1; j < matdim; ++j) {
      for (int k = 1; k < matdim; ++k) {
        temp[i][j] += b[i][k] * c[k][j];
      }
    }
  }
  memcpy(a, temp, sizeof(temp));
}
void mult(double vec[], double a[][matdim]) {
  double newvec[matdim];
  memset(newvec, 0, sizeof(newvec));
  for (int i = 1; i < matdim; ++i) {
    for (int j = 1; j < matdim; ++j) {
      newvec[j] += vec[i] * a[i][j];
    }
  }
  memcpy(vec, newvec, sizeof(newvec));
}
void pow(double m[][matdim], int k, double rez[][matdim]) {
  for (int i = 1; i < matdim; ++i) {
    for (int j = 1; j < matdim; ++j) {
      if (i == j)
        rez[i][j] = 1;
      else
        rez[i][j] = 0;
    }
  }
  for (int p = 0; (1 << p) <= k; ++p) {
    if ((k >> p) & 1) {
      mult(rez, rez, m);
    }
    mult(m, m, m);
  }
}
int main() {
  cout << fixed << setprecision(15);
  cin >> n >> p;
  dp[1][1] = 1.0 * p / 1000000000;
  prob[1][1] = 1.0 * p / 1000000000;
  dp[1][2] = 2.0 * (1000000000 - p) / 1000000000;
  prob[1][2] = 1.0 * (1000000000 - p) / 1000000000;
  dp2[1][1] = 0;
  prob2[1][1] = 0;
  dp2[1][2] = 2;
  prob2[1][2] = 1;
  long long p1 = 1LL * (1000000000 - p) * 1000000000 + 1LL * p * p;
  long long p2 = 1LL * p * (1000000000 - p);
  long long nnum = 1LL * 1000000000 * 1000000000;
  pw[0] = 1.0 * p1 / nnum;
  for (int j = 1; j <= 50; ++j) pw[j] = pw[j - 1] * pw[j - 1];
  for (int i = 2; i <= 50; ++i) {
    for (int j = 1; j <= i + 1 && j <= 50; ++j) {
      if (j == 1) {
        for (int k = 1; k <= 50; ++k) {
          dp[i][j] += dp2[i - 1][k] * p2 / nnum;
          dp[i][j] += prob2[i - 1][k] * p2 / nnum;
          prob[i][j] += prob2[i - 1][k] * p2 / nnum;
        }
      } else {
        double coef1, coef2;
        if (j <= i) {
          coef1 = pw[j - 2];
          coef2 = pw[j - 2] / pw[0];
        } else {
          coef1 = pw[j - 2] / pw[0] * (1.0 * (1000000000 - p) / 1000000000);
          coef2 = pw[j - 2] / pw[1] * (1.0 * (1000000000 - p) / 1000000000);
        }
        for (int k = 1; k < j; ++k) {
          dp[i][j] += dp[i - 1][k] * coef1;
          dp[i][j] += prob[i - 1][k] * coef1 * j;
          prob[i][j] += prob[i - 1][k] * coef1;
          dp2[i][j] += dp[i - 1][k] * coef2;
          dp2[i][j] += prob[i - 1][k] * coef2 * j;
          prob2[i][j] += prob[i - 1][k] * coef2;
        }
      }
    }
  }
  for (int j = 1; j <= 50; ++j) {
    if (j == 1) {
      for (int k = 1; k <= 50; ++k) {
        m[k + 50][j] += 1.0 * p2 / nnum;
        m[k + 3 * 50][j] += 1.0 * p2 / nnum;
        m[k + 3 * 50][j + 2 * 50] += 1.0 * p2 / nnum;
      }
    } else {
      double coef1 = pw[j - 2];
      double coef2 = pw[j - 2] / pw[0];
      for (int k = 1; k < j; ++k) {
        m[k][j] += coef1;
        m[k + 2 * 50][j] += coef1 * j;
        m[k + 2 * 50][j + 2 * 50] += coef1;
        m[k][k + 50] += coef2;
        m[k + 2 * 50][k + 50] += coef2 * j;
        m[k + 2 * 50][k + 3 * 50] += coef2;
      }
    }
  }
  double ans = 0;
  if (n <= 50) {
    for (int j = 1; j <= 50; ++j) ans += dp[n][j];
  } else {
    for (int j = 1; j <= 50; ++j) {
      vec[j] = dp[50][j];
      vec[j + 50] = dp2[50][j];
      vec[j + 2 * 50] = prob[50][j];
      vec[j + 3 * 50] = prob2[50][j];
    }
    int cap = 250000;
    int ret = n;
    n = min(n, cap);
    pow(m, n - 50, rez);
    mult(vec, rez);
    for (int j = 1; j <= 50; ++j) ans += vec[j];
    if (ret > cap) {
      ans = ans * ret / cap;
    }
  }
  cout << fixed << setprecision(9) << ans << "\n";
}