Problem: Roma found a new character in the game "World of Darkraft - 2". In this game the character fights monsters, finds the more and more advanced stuff that lets him fight stronger monsters.

The character can equip himself with k distinct types of items. Power of each item depends on its level (positive integer number). Initially the character has one 1-level item of each of the k types.

After the victory over the monster the character finds exactly one new randomly generated item. The generation process looks as follows. Firstly the type of the item is defined; each of the k types has the same probability. Then the level of the new item is defined. Let's assume that the level of player's item of the chosen type is equal to t at the moment. Level of the new item will be chosen uniformly among integers from segment [1; t + 1].

From the new item and the current player's item of the same type Roma chooses the best one (i.e. the one with greater level) and equips it (if both of them has the same level Roma choses any). The remaining item is sold for coins. Roma sells an item of level x of any type for x coins.

Help Roma determine the expected number of earned coins after the victory over n monsters.

Input

The first line contains two integers, n and k (1 ≤ n ≤ 105; 1 ≤ k ≤ 100).

Output

Print a real number — expected number of earned coins after victory over n monsters. The answer is considered correct if its relative or absolute error doesn't exceed 10 - 9.

Examples

Input

1 3


Output

1.0000000000


Input

2 1


Output

2.3333333333


Input

10 2


Output

15.9380768924

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
  os << (POS == 0 ? "" : ", ") << get<POS>(t);
  deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
  os << "(";
  deploy<0, std::tuple<Ts...>, Ts...>(os, t);
  os << ")";
  return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
  int remain = v.size();
  os << "{";
  for (auto e : v) os << e << (--remain == 0 ? "" : ", ");
  os << "}";
  return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
  int remain = v.size();
  os << "{";
  for (auto e : v) os << e << (--remain == 0 ? "" : ", ");
  os << "}";
  return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::queue<T> &q) {
  auto qq = q;
  os << "{";
  for (; !qq.empty(); qq.pop()) {
    os << qq.front() << (qq.size() != 1 ? ", " : "");
  }
  os << "}";
  return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> &q) {
  auto qq = q;
  os << "{";
  for (; !qq.empty(); qq.pop()) {
    os << qq.top() << (qq.size() != 1 ? ", " : "");
  }
  os << "}";
  return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::pair<T, K> &p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &mp) {
  int remain = mp.size();
  os << "{";
  for (auto e : mp)
    os << "(" << e.first << " -> " << e.second << ")"
       << (--remain == 0 ? "" : ", ");
  os << "}";
  return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::unordered_map<T, K> &mp) {
  int remain = mp.size();
  os << "{";
  for (auto e : mp)
    os << "(" << e.first << " -> " << e.second << ")"
       << (--remain == 0 ? "" : ", ");
  os << "}";
  return os;
}
const int64_t MAX = 100500;
const int64_t M = 605;
vector<double> dp[MAX];
inline double recur(int64_t rem, int64_t level) {
  if (rem == 0) return 0;
  level = min(level, M - 5);
  double &res = dp[rem & 1][level];
  if (res != -1) return res;
  res = 0;
  res +=
      level / (level + 1.0) * (recur(rem - 1, level + 0) + level * 0.5 + 0.5);
  res += 1.0 / (level + 1.0) * (recur(rem - 1, level + 1) + level);
  return res;
}
int main() {
  int64_t n, k;
  cin >> n >> k;
  double dat[MAX];
  dp[0] = vector<double>(M, 0);
  dp[1] = vector<double>(M, 0);
  for (int64_t i = 0; i < ((int64_t)(MAX - 5)); ++i) {
    int64_t index = 1 - (i & 1);
    for (int64_t j = 0; j < ((int64_t)(M)); ++j) dp[index][j] = -1;
    for (int64_t l = 0; l < ((int64_t)(M)); ++l) recur(i + 1, l);
    dat[i] = dp[i & 1][1];
  }
  if (k == 1) {
    printf("%0.20lf\n", (double)dat[n]);
    return 0;
  }
  double ans = 0;
  double in = log(1.0 / k);
  double out = log((k - 1.0) / k);
  double bef_total = log(1.0);
  for (int64_t t = 0; t <= n; ++t) {
    double total = bef_total;
    total += in * t;
    total += out * (n - t);
    ans += exp(total) * dat[t];
    bef_total += log(n - t);
    bef_total -= log(t + 1);
  }
  printf("%0.20lf\n", (double)ans * k);
}