#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

#define int int64_t

const int MAXN = 1e3 + 10, MAXK = 11;

vector<double> p[1 << MAXK][MAXK];

vector<int> operator*(const vector<int>& a, const vector<int>& b) {
  vector<int> c(a.size() + b.size() - 1);
  for (int i = 0; i < (int)a.size(); ++i) {
    for (int j = 0; j < (int)b.size(); ++j) {
      c[i + j] += a[i] * b[j];
    }
  }
  return c;
}

vector<int> operator+(const vector<int>& a, const vector<int>& b) {
  vector<int> c(max(a.size(), b.size()));
  for (int i = 0; i < (int)a.size(); ++i) {
    c[i] += a[i];
  }
  for (int i = 0; i < (int)b.size(); ++i) {
    c[i] += b[i];
  }
  return c;
}

double dp[MAXN][1 << MAXK][MAXK];
double ans[MAXN];

signed main() {
#ifdef DEBUG
  freopen("input.txt", "r", stdin);
  freopen("output.txt", "w", stdout);
#else
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
#endif

  int n, k;
  cin >> n >> k;

  for (int mask = 0; mask < (1 << (k - 1)); ++mask) {
    for (int d = 0; d < k; ++d) {
      vector<int> a;
      for (int i = 0; i < (k - 1); ++i) {
        if (mask & (1 << i)) {
          a.push_back(i);
        }
      }
      a.push_back(k - 1);
      a.push_back(k + d);
      p[mask][d].resize(k + 1);
      for (int i : a) {
        for (int t = i; t < i + k; ++t) {
          vector<int> prod = {1};
          vector<int> sum = {0};
          int cntk = 0;
          for (int j : a) {
            if (j == i) continue;
            vector<int> up = {-j, 1};
            vector<int> down = {j + k, -1};
            ++cntk;
            if (t >= j + k) {
              up = {1};
              down = {0};
              --cntk;
            } else if (t + 1 <= j) {
              up = {0};
              down = {1};
              --cntk;
            }
            sum = sum * up + prod * down;
            prod = prod * up;
          }
          vector<double> intsum(sum.size() + 1);
          for (int i = 1; i <= (int)sum.size(); ++i) {
            intsum[i] = (double)sum[i - 1] / i;
            for (int t = 0; t < cntk; ++t) {
              intsum[i] /= k;
            }
          }
          double vall = 0, valr = 0;
          for (int i = (int)sum.size(); i >= 0; --i) {
            vall = vall * t + intsum[i];
            valr = valr * (t + 1) + intsum[i];
          }
          p[mask][d][min(i, k)] += (valr - vall) / k;
        }
      }
    }
  }

  /// cerr << "p: " << p[0][0][1] << endl;

  int mask0 = (1 << (k - 1)) - 1;
  if (n - 2 < k - 1) {
    mask0 = ((1 << (n - 2)) - 1) << (k - n + 1);
  }
  dp[n - 2][mask0][0] = 1;
  /// cerr << mask0 << endl;
  for (int mx2 = n - 2; mx2 >= 0; --mx2) {
    for (int mask = (1 << (k - 1)) - 1; mask >= 0; --mask) {
      int cnt = mx2 + 2;
      for (int i = 0; i < (k - 1); ++i) {
        if (mx2 - k + 1 + i < 0) continue;  
        if (!(mask & (1 << i))) {
          --cnt;
        }
      }
      int mx3 = mx2 - k;
      for (int i = 0; i < (k - 1); ++i) {
        if (mask & (1 << i)) {
          mx3 = mx2 - k + 1 + i;
        }
      }
      int start = mx3 - k + 1;
      int mask1 = 0;
      for (int i = start; i < mx3; ++i) {
        if (i < 0) continue;
        if (i <= mx2 - k) {
          mask1 |= (1 << (i - start));
        } else {
          if (mask & (1 << (i - (mx2 - k + 1)))) {
            mask1 |= (1 << (i - start));
          }
        }
      }
      for (int d = 0; d < k; ++d) {
        for (int i = 0; i < (k - 1); ++i) {
          if (mask & (1 << i)) {
            dp[mx2][mask ^ (1 << i)][d] += dp[mx2][mask][d] * p[mask][d][i];
            ans[mx2 - k + 1 + i] += dp[mx2][mask][d] * p[mask][d][i] * (cnt - 1);
          }
        }
        ans[mx2] += dp[mx2][mask][d] * p[mask][d][k - 1] * (cnt - 1);
        ans[mx2 + d + 1] += dp[mx2][mask][d] * p[mask][d][k] * (cnt - 1);
        if (mx3 >= 0) {
          dp[mx3][mask1][min(k - 1, mx2 + d + 1 - mx3 - 1)] += dp[mx2][mask][d] * p[mask][d][k - 1];
          dp[mx3][mask1][min(k - 1, mx2 - mx3 - 1)] += dp[mx2][mask][d] * p[mask][d][k];
        }
      }
    }
  }

  cout << fixed << setprecision(20);
  for (int i = 0; i < n; ++i) {
    cout << 1 + ans[i] << "\n";
  }

  return 0;
}