#ifndef ZHR_DEBUG
#define NDEBUG
#endif

#include <cassert>
#include <cmath>

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <memory>

using flt = double;

class SumCalc {
private:
  flt sum = 0, c = 0;

public:
  void add(flt v) {
    const flt y = v - c;
    const flt t = sum + y;
    c = (t - sum) - y;
    sum = t;
  }

  flt get() const { return sum; }
};

int main() {
  int n, k;
  flt p;
  std::cin >> n >> k >> p;
  if (k >= 200) { // TODO
    std::cout << std::fixed << std::setprecision(10) << n / (1 - p)
              << std::endl;
    return 0;
  }
  std::unique_ptr<flt[]> s[2]{std::make_unique<flt[]>(n + 1),
                              std::make_unique<flt[]>(n + 1)};
  int cur = 0;
  s[cur][0] = 1 / p / std::pow(1 - p, n) - 1 / p;
  for (int i = 1; i <= k; ++i) {
    cur ^= 1;
    const int lst = cur ^ 1;
    s[cur][0] = s[lst][0];
    std::fill(s[cur].get() + 1, s[cur].get() + n, 0);
    for (int j = n - 1; j > 0; --j) {
      if (s[lst][j] == 0) {
        s[lst][j] = s[lst][0] - 1 / p / std::pow(1 - p, j) + 1 / p;
      }
      if (s[lst][j] >= s[cur][0]) {
        // std::cerr << "Break at " << j << '!' << std::endl;
        // When j is 1, i is ~60 (n=10^5, p=20/n)
        break;
      }
      s[cur][j] = 1 + (1 - p) * s[cur][j + 1] + p * s[lst][j];
      s[cur][0] = s[cur][j] + 1 / p / std::pow(1 - p, j) - 1 / p;
    }
    // if (s[cur][1] > 0 && i < k) {
    //   // Payload: 100000 62 0.0002
    //   // Always respawn if we have won any
    //   const int dk = k - i;
    //   SumCalc ln_d;
    //   ln_d.add(dk * std::log(p));
    //   // flt d = std::pow(p, dk);
    //   SumCalc res;
    //   res.add(p * p * (n - 1) * (1 - std::pow(p, dk - 1)) / (1 - p)); // TODO
    //   for (int j = 1; j < n; ++j) {
    //     const flt t = s[cur][j] - (n - j) * (1 + p);
    //     assert(t > 0);
    //     res.add(t * std::exp(ln_d.get()));
    //     // res.add(t * d);
    //     ln_d.add(std::log((1 - p) * (j + dk - 1) / j));
    //     // d *= (1 - p) * (j + dk - 1) / j;
    //   }
    //   res.add((n - 1) * (1 + p));
    //   // Now res = s[k][1], but we want s[k][0]
    //   s[cur][0] = res.get() + 1 / (1 - p);
    //   break;
    // }
  }
  std::cout << std::fixed << std::setprecision(10) << s[cur][0] << std::endl;
  return 0;
}