#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;

const double PI = atan2l(0, -1);
using cd = complex<double>;

void fft(vector<cd>& a, bool inv = false) {
  int n = a.size();
  int k = 0;
  while ((1 << k) < n) ++k;
  static vector<int> rev;
  static vector<cd> power = {0, 1};
  rev.resize(n);
  rev[0] = 0;
  for (int i = 1; i < n; ++i) {
    rev[i] = rev[i / 2] / 2 + ((i & 1) << (k - 1));
    if (i < rev[i]) {
      swap(a[i], a[rev[i]]);
    }
  }
  for (int l = 1; l < n; l *= 2) {
    if ((int)power.size() == l) {
      power.resize(2 * l);
      cd w = {cosl(PI / l), sinl(PI / l)};
      for (int i = l; i < 2 * l; ++i) {
        power[i] = power[i / 2];
        if (i & 1) power[i] *= w;
      }
    }
    for (int i = 0; i < n; i += 2 * l) {
      for (int j = 0; j < l; ++j) {
        cd x = a[i + j], y = a[i + j + l] * power[j + l];
        a[i + j] = x + y;
        a[i + j + l] = x - y;
      }
    }
  }
  if (inv) {
    cd anti = {(double)1 / n, 0};
    reverse(a.begin() + 1, a.end());
    for (int i = 0; i < n; ++i) {
      a[i] *= anti;
    }
  }
}

vector<double> operator*(vector<double> a, vector<double> b) {
  int sz = a.size() + b.size() - 1;
  int k = 0;
  while ((1 << k) < sz) ++k;
  vector<cd> ac(1 << k, {0, 0}), bc(1 << k, {0, 0});
  for (int i = 0; i < (int)a.size(); ++i) {
    ac[i] = {a[i], 0};
  }
  for (int i = 0; i < (int)b.size(); ++i) {
    bc[i] = {b[i], 0};
  }
  fft(ac); fft(bc);
  for (int i = 0; i < (1 << k); ++i) {
    ac[i] *= bc[i];
  }
  fft(ac, true);
  a.resize(sz);
  for (int i = 0; i < sz; ++i) {
    a[i] = ac[i].real();
  }
  return a;
}

const double EPS = 1e-6;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout << fixed << setprecision(20);

  int n;
  cin >> n;
  int minh = 60;
  vector<double> ans = {0};
  vector<double> p = {1};
  double lst = 0;
  for (int h = 1; h <= n; ++h) {
    p = p * p;
    vector<double> res(p.size() + 1);
    res[0] = 1;
    for (int i = 1; i <= (int)p.size(); ++i) {
      res[i] = p[i - 1] / i;
    }
    if (res.size() > n) {
      res.resize(n + 1);
      ans.push_back(res[n] - lst);
      lst = res[n];
    } else {
      ans.push_back(0 - lst);
      lst = 0;
    }
    p = res;
    if (h >= minh && ans.back() < EPS && lst >= 0.5) {
      break;
    }
  }
  while ((int)ans.size() <= n) ans.push_back(0);
  for (int i = 1; i <= n; ++i) {
    cout << ans[i] << "\n";
  }

  return 0;
}