Problem:
問題 J : 乱択平衡分二分探索木
ところで，G○○gle Code Jam の地区大会で右の席に座っていた男の
ID は rng_58 と言うらしい．
東京大学時代の記憶に，似たような ID の仲間が居た覚えがあるが，僕の仲間は一人残さず美少女だったはずだ．
彼女はいわゆる無表情不思議系キャラだったような気がする．
ということは，彼は知らない男だ．rng とは何の略だろう．
おそらく Random Number Generator に違いない．
乱択アルゴリズムを得意とするのだろう．
ところで，乱数を用いた平衡二分探索木である Treap は，
2011 年頃のプログラミングコンテストではしばしば用いられていたようだが，
20XX 年の今では，あまり使用されていない．
当時 Treap は実装が平易であるという理由により Splay 木や Scapegoat 木と並んでよく使われていた．
20XX 年の今，命をかけたプログラミングコンテストが日常的に行われるこの世界では，
実装が多少平易になるというような甘い根拠での選択は到底考えられない．
皆，少しでもプログラムが高速になるよう考えているし，
世界大会出場者ともなれば，Left-leaning 赤黒木程度なら十数秒で記述できるのが当然だ．
例えば，Treap が赤黒木よりも遅くなってしまうのは，
高さの定数倍が効いてくるからであると言われている．
ここは，落ち着いてそれを数値的に考察することにより，精神の安定を取り戻そう．
問題
キーを実数とする Treap に
N
個のランダムな要素を挿入した際に，
高さが
h
(
h
= 0, 1, …,
N
- 1
) となる確率を求めよ．
以下，より詳しく説明する．
Treap とは乱数を用いた平衡二分探索木である．
各ノードは，キーの他に，優先度という値を持つ．
ここでは，キーと優先度は
0
から
1
までの実数値とする．
Treap では，以下の 2 つの条件が常に保たれる．
キーに関する条件
各ノードに関して，左の子以下のノードは自分より小さなキーを持つ
各ノードに関して，右の子以下のノードは自分より大きなキーを持つ
優先度に関する条件
各ノードに関して，子のノードは自分より小さな優先度を持つ
下図は，Treap の例である．
各ノードの，上部にキーが，下部に優先度が書かれている．
7 つのノードからなる Treap の例．
挿入の操作は，以下のように行われる．
挿入するキー を
x
とおく．
挿入する新しいノードの優先度
p
を
0
から
1
までの一様分布よりランダムに決定する．
通常の二分探索木と同様に，まずは優先度を無視し新しいノードを挿入する．
優先度の条件を満たすように，新しいノードを上に持ち上げるような回転操作を必要なだけ繰り返す．
木の回転操作に関しては，補足の節に詳しく記述したので，参考にせよ．
下図は，先ほどの例にキーとして 0.5，優先度として 0.7 を持つ頂点を挿入した過程の例である．
まずは優先度が無視され，ノードが挿入される．
回転を行い新しいノードが上へ行く．
さらに回転を行うと，優先度の条件が満たされるので，挿入は終了する．
空の Treap に
N
個のキーを，
やはり
0
から
1
までの一様分布よりランダムに選び挿入してゆくとする．
最終的に高さが
h
となる確率を，
各
h
= 0, 1, …,
N
- 1
について求めよ．
なお，実数は十分な精度を持って扱われるとし，
例えば 2 つのノードの優先度が等しくなる確率は 0 としてよい．
また，高さとは，根のノードから各ノードに至るために通らなければならない辺の本数の最大値である．
入力
1 つの整数
N
が書かれている．
出力
出力は
N
行から成る．
i
行目に高さが
i
- 1
となる確率を出力せよ．
値は小数点以下何桁表示しても構わない．
制約
1 ≤
N
≤ 3 × 10
4
出力する値は
10
- 5
以下の誤差を含んでいても構わない．
入出力例
入力例 1:
1
入力例 1 に対する出力例:
1.0
入力例 2:
2
入力例 2 に対する出力例:
0.0000000000
1.0000000000
補足
木の回転操作には，右回転と左回転がある．
右回転とは，以下の 2 つの図の 1 つめの状態を 2 つめの状態にする操作であり，
左回転とは，以下の 2 つの図の 2 つめの状態を 1 つめの状態にする操作である．
右回転をする前，または左回転をした後
右回転をした後，または左回転をする前
Treap においては，持ち上げたいノードがその親ノードの左の子であった場合，
持ち上げたいノードを上図の P とするような右回転を適用し，
持ち上げたいノードがその親ノードの右の子であった場合，
持ち上げたいノードを上図の Q とするような左回転を適用する．
木の回転操作について，より詳しくは，例えば以下を参照せよ．
http://ja.wikipedia.org/wiki/%E6%9C%A8%E3%81%AE%E5%9B%9E%E8%BB%A2
Treap について，より詳しくは，例えば以下を参照せよ．
http://en.wikipedia.org/wiki/Treap
http://www.prefield.com/algorithm/container/treap.html

Submitted solutions:

code_snippet: // AOJ #2268 Randomized Self-Balancing Binary Search Tree
// 2025.3.17

#include <bits/stdc++.h>
using namespace std;

template <typename R>
void fft(vector<complex<R>> &f, int dir) {
    int n = f.size();
    assert(n == (1 << static_cast<int>(log2(n))));
    R theta = dir * 2 * M_PI / n;

    for (int m = n; m >= 2; m /= 2) {
        for (int i = 0; i < m / 2; i++) {
            complex<R> w = polar<R>(1, i * theta);
            for (int j = i; j < n; j += m) {
                int k = j + m / 2;
                complex<R> diff = f[j] - f[k];
                f[j] += f[k];
                f[k] = w * diff;
            }
        }
        theta *= 2;
    }

    int i = 0;
    for (int j = 1; j < n - 1; j++) {
        for (int k = n / 2; k > (i ^= k); k /= 2);
        if (j < i) swap(f[i], f[j]);
    }
}

template <typename T, typename R = double>
void conv(vector<T> &a, int result_n) {
    int m = 2 * a.size() - 1;
    int n = pow(2, ceil(log2(m)));
    vector<complex<R>> x(n);

    copy(a.begin(), a.end(), x.begin());
    fft(x, +1);
    for (int i = 0; i < n; i++) x[i] *= x[i];
    fft(x, -1);

    a.resize(result_n);
    for (int i = 0; i < result_n; i++) a[i] = x[i].real() / n;
}

int main() {
    int n;
    cin >> n;

    int h = min(n, 50);
    vector<double> dp(n + 1, 0);
    dp[0] = 1;
    double last = 0;

    for (int j = 1; j <= h; j++) {
        conv(dp, n + 1);
        for (int i = n - 1; i >= 0; i--) {
            dp[i + 1] = dp[i] / (i + 1);
        }
        dp[0] = 1;
        printf("%.10lf\n", dp[n] - last);
        last = dp[n];
    }
    for (int j = h + 1; j <= n; j++) puts("0");
    return 0;
}
accuracy: 1
time_ms: 470
memory_kb: 4984
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;

const double PI = acos(-1.0);

// FFT（Cooley-Tukeyアルゴリズム）
void fft(vector<complex<double>> &a, bool invert) {
    int n = (int)a.size();
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n >> 1;
        for (; j & bit; bit >>= 1)
            j -= bit;
        j += bit;
        if (i < j) swap(a[i], a[j]);
    }

    for (int len = 2; len <= n; len <<= 1) {
        double ang = 2 * PI / len * (invert ? -1 : 1);
        complex<double> wlen(cos(ang), sin(ang));
        for (int i = 0; i < n; i += len) {
            complex<double> w(1);
            for (int j = 0; j < len / 2; j++) {
                complex<double> u = a[i + j], v = a[i + j + len / 2] * w;
                a[i + j] = u + v;
                a[i + j + len / 2] = u - v;
                w *= wlen;
            }
        }
    }

    if (invert) {
        for (int i = 0; i < n; i++)
            a[i] /= n;
    }
}

// 畳み込み（convolution）: O(N log N)
// a, b は実数ベクトル。戻り値は a∗b の畳み込みの実部のみを返す。
vector<double> convolution(const vector<double> &a, const vector<double> &b) {
    int n_fft = 1;
    int result_size = a.size() + b.size() - 1;
    while (n_fft < result_size)
        n_fft <<= 1;
    vector<complex<double>> fa(n_fft), fb(n_fft);
    for (int i = 0; i < (int)a.size(); i++)
        fa[i] = a[i];
    for (int i = a.size(); i < n_fft; i++)
        fa[i] = 0;
    for (int i = 0; i < (int)b.size(); i++)
        fb[i] = b[i];
    for (int i = b.size(); i < n_fft; i++)
        fb[i] = 0;

    fft(fa, false);
    fft(fb, false);
    for (int i = 0; i < n_fft; i++)
        fa[i] *= fb[i];
    fft(fa, true);

    vector<double> res(result_size);
    for (int i = 0; i < result_size; i++)
        res[i] = fa[i].real();
    return res;
}

// main：dp層hについての更新を FFT畳み込みで O(n log n) で行う
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    // dp_prev[x] = dp[x][h-1]、dp_cur[x] = dp[x][h] (0 <= x <= n)
    // 初期条件：h=0 では dp[0][0]=1, dp[x>0][0]=0
    vector<double> dp_prev(n + 1, 0.0), dp_cur(n + 1, 0.0);
    dp_prev[0] = 1.0;
    for (int i = 1; i <= n; i++)
        dp_prev[i] = 0.0;

    // 各高さ h = 1,2,...,n について dp[n][h] - dp[n][h-1] を出力
    for (int h = 1; h <= n; h++) {
        if (h >= 50) {
            printf("0.0000000000\n");
            continue;
        }
        // dp[n][h] = (1/n) * (畳み込み結果の index n-1)
        // つまり、dp[.][h] は dp[.][h-1] 同士の畳み込み結果を利用して求められる。
        vector<double> convRes = convolution(dp_prev, dp_prev);

        dp_cur[0] = 1.0; // dp[0][h] = 1
        for (int m = 1; m <= n; m++) {
            // convRes[m-1] = ∑_{i+j = m-1} dp[i][h-1]*dp[j][h-1]
            dp_cur[m] = convRes[m - 1] / m;
        }

        // 高さが正確に h となる確率は dp[n][h] - dp[n][h-1]
        double ans = dp_cur[n] - dp_prev[n];
        printf("%.10f\n", ans);

        dp_prev = dp_cur;
    }
    return 0;
}
accuracy: 1
time_ms: 480
memory_kb: 6676
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
long double PI = acos(-1);
vector<complex<long double>> fft(vector<complex<long double>> A, bool inv){
	int N = A.size();
	complex<long double> r = polar((long double) 1, (2 * PI) / (N));
	if (inv){
		r = pow(r, -1);
	}
	vector<complex<long double>> B(N);
	for (int i = N / 2; i > 0; i /= 2){
		complex<long double> z = pow(r, i);
		complex<long double> z2 = 1;
		for (int j = 0; j < N; j += i * 2){
			for (int k = 0; k < i; k++){
				A[i + j + k] *= z2;
				B[j / 2 + k] = A[j + k] + A[i + j + k];
				B[N / 2 + j / 2 + k] = A[j + k] - A[i + j + k];
			}
			z2 *= z;
		}
		swap(A, B);
	}
	if (inv){
		for (int i = 0; i < N; i++){
			A[i] /= N;
		}
	}
	return A;
}
vector<long double> convolution(vector<long double> A, vector<long double> B){
	int deg = A.size() + B.size() - 1;
	int N = 1;
	while (N < deg){
		N *= 2;
	}
	vector<complex<long double>> A2(N, 0);
	for (int i = 0; i < A.size(); i++){
		A2[i] = A[i];
	}
	vector<complex<long double>> B2(N, 0);
	for (int i = 0; i < B.size(); i++){
		B2[i] = B[i];
	}
	A2 = fft(A2, false);
	B2 = fft(B2, false);
	vector<complex<long double>> C2(N);
	for (int i = 0; i < N; i++){
		C2[i] = A2[i] * B2[i];
	}
	C2 = fft(C2, true);
	vector<long double> C(deg);
	for (int i = 0; i < deg; i++){
	  C[i] = C2[i].real();
	}
	return C;
}
int main(){
  cout << fixed << setprecision(20);
  int N;
  cin >> N;
  int M = min(N, 100);
  vector<vector<long double>> dp(M + 1, vector<long double>(N + 1, 0));
  dp[0][0] = 1;
  for (int i = 0; i < M; i++){
    vector<long double> tmp = convolution(dp[i], dp[i]);
    dp[i + 1][0] = 1;
    for (int j = 1; j <= N; j++){
      dp[i + 1][j] = tmp[j - 1] / j;
    }
  }
  for (int i = 1; i <= M; i++){
    cout << max(dp[i][N] - dp[i - 1][N], (long double) 0) << endl;
  }
  for (int i = M; i < N; i++){
    cout << 0 << endl;
  }
}
accuracy: 1
time_ms: 3380
memory_kb: 61956
final_rank: 13

code_snippet: #include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
vector<complex<double>> fft(vector<complex<double>> A, bool inv){
	int N = A.size();
	complex<double> r = polar((double) 1, (2 * PI) / (N));
	if (inv){
		r = pow(r, -1);
	}
	vector<complex<double>> B(N);
	for (int i = N / 2; i > 0; i /= 2){
		complex<double> z = pow(r, i);
		complex<double> z2 = 1;
		for (int j = 0; j < N; j += i * 2){
			for (int k = 0; k < i; k++){
				A[i + j + k] *= z2;
				B[j / 2 + k] = A[j + k] + A[i + j + k];
				B[N / 2 + j / 2 + k] = A[j + k] - A[i + j + k];
			}
			z2 *= z;
		}
		swap(A, B);
	}
	if (inv){
		for (int i = 0; i < N; i++){
			A[i] /= N;
		}
	}
	return A;
}
vector<double> convolution(vector<double> A, vector<double> B){
	int deg = A.size() + B.size() - 1;
	int N = 1;
	while (N < deg){
		N *= 2;
	}
	vector<complex<double>> A2(N, 0);
	for (int i = 0; i < A.size(); i++){
		A2[i] = A[i];
	}
	vector<complex<double>> B2(N, 0);
	for (int i = 0; i < B.size(); i++){
		B2[i] = B[i];
	}
	A2 = fft(A2, false);
	B2 = fft(B2, false);
	vector<complex<double>> C2(N);
	for (int i = 0; i < N; i++){
		C2[i] = A2[i] * B2[i];
	}
	C2 = fft(C2, true);
	vector<double> C(deg);
	for (int i = 0; i < deg; i++){
	  C[i] = C2[i].real();
	}
	return C;
}
int main(){
  cout << fixed << setprecision(20);
  int N;
  cin >> N;
  int M = min(N, 100);
  vector<vector<double>> dp(M + 1, vector<double>(N + 1, 0));
  dp[0][0] = 1;
  for (int i = 0; i < M; i++){
    vector<double> tmp = convolution(dp[i], dp[i]);
    dp[i + 1][0] = 1;
    for (int j = 1; j <= N; j++){
      dp[i + 1][j] = max(tmp[j - 1], (double) 0) / j;
    }
  }
  for (int i = 1; i <= M; i++){
    cout << max(dp[i][N] - dp[i - 1][N], (double) 0) << endl;
  }
  for (int i = M; i < N; i++){
    cout << 0 << endl;
  }
}
accuracy: 0.3225806451612903
time_ms: 860
memory_kb: 32608
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;
double PI = acos(-1);
vector<complex<double>> fft(vector<complex<double>> A, bool inv){
	int N = A.size();
	complex<double> r = polar((double) 1, (2 * PI) / (N));
	if (inv){
		r = pow(r, -1);
	}
	vector<complex<double>> B(N);
	for (int i = N / 2; i > 0; i /= 2){
		complex<double> z = pow(r, i);
		complex<double> z2 = 1;
		for (int j = 0; j < N; j += i * 2){
			for (int k = 0; k < i; k++){
				A[i + j + k] *= z2;
				B[j / 2 + k] = A[j + k] + A[i + j + k];
				B[N / 2 + j / 2 + k] = A[j + k] - A[i + j + k];
			}
			z2 *= z;
		}
		swap(A, B);
	}
	if (inv){
		for (int i = 0; i < N; i++){
			A[i] /= N;
		}
	}
	return A;
}
vector<double> convolution(vector<double> A, vector<double> B){
	int deg = A.size() + B.size() - 1;
	int N = 1;
	while (N < deg){
		N *= 2;
	}
	vector<complex<double>> A2(N, 0);
	for (int i = 0; i < A.size(); i++){
		A2[i] = A[i];
	}
	vector<complex<double>> B2(N, 0);
	for (int i = 0; i < B.size(); i++){
		B2[i] = B[i];
	}
	A2 = fft(A2, false);
	B2 = fft(B2, false);
	vector<complex<double>> C2(N);
	for (int i = 0; i < N; i++){
		C2[i] = A2[i] * B2[i];
	}
	C2 = fft(C2, true);
	vector<double> C(deg);
	for (int i = 0; i < deg; i++){
	  C[i] = C2[i].real();
	}
	return C;
}
int main(){
  cout << fixed << setprecision(20);
  int N;
  cin >> N;
  int M = min(N, 100);
  vector<vector<double>> dp(M + 1, vector<double>(N + 1, 0));
  dp[0][0] = 1;
  for (int i = 0; i < M; i++){
    vector<double> tmp = convolution(dp[i], dp[i]);
    dp[i + 1][0] = 1;
    for (int j = 1; j <= N; j++){
      dp[i + 1][j] = tmp[j - 1] / j;
    }
  }
  for (int i = 1; i <= M; i++){
    cout << dp[i][N] - dp[i - 1][N] << endl;
  }
  for (int i = M; i < N; i++){
    cout << 0 << endl;
  }
}
accuracy: 0.3225806451612903
time_ms: 850
memory_kb: 32644
final_rank: 16

code_snippet: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i=0;i<n;i++)
#define repn(i, n) for(int i=1;i<=n;i++)
typedef pair<ll,ll> P;
#define fi first
#define sc second
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define POSL(v, x) lower_bound(v.begin(), v.end(), x) - v.begin()

struct FFT{
	const double PI = acos(-1.);
	struct cp{
		double x, y; 
		cp(double x = 0, double y = 0) : x(x), y(y) {}
		cp operator + (const cp & a) { return cp(x+a.x, y+a.y); }
		cp operator - (const cp & a) { return cp(x-a.x, y-a.y); }
		cp operator * (const cp & a) { return cp(x*a.x-y*a.y, x*a.y+y*a.x); }
	};
	cp g[1<<17];
	void FFTMakeG(int n){
		rep(i, n){
			double th = PI * 2.0 * i / n;
			g[i] = cp(cos(th), sin(th));
		}
	}
	void fft( vector<cp>&z ){
		int n = z.size();
		int i, j, k, l, m;
		for(i = 1, j = 0; i < n; ++i){
			for(int k=n>>1;(j^=k) < k ; k >>= 1);
			if(i < j) swap(z[i], z[j]);
		}
		for(l = k = 1, m = __builtin_ctz(n); m--; l |= k <<= 1){
			for(i = 0;i<n;i++) if(i < (j=i^k)){
				cp t = z[j] * g[(i & l) << m];
				z[j] = z[i] - t;
				z[i] = z[i] + t;
			}
		}
	}
	vector<double>conv (vector<double>a){
		int n = a.size() + a.size();
		int t = 1;
		while(t < n) t <<= 1;
		FFTMakeG(t);
		vector<cp>fa, fb;
		rep(i, t){
			if(i < a.size()) fa.pb(cp(a[i]));
			else fa.pb(cp());
			
			//if(i < a.size()) fb.pb(cp(a[i]));
			//else fb.pb(cp());
		}
		fft(fa); //fft(fb);
		rep(i, t) fa[i] = fa[i] * fa[i];
		for(int l=1,r=t-1;l<r;l++,r--) swap(g[l], g[r]);
		fft(fa);
		vector<double>ret;
		rep(i, t) ret.pb(fa[i].x / (double)t);
		return ret;
	}
}kaede;

double dp[30005][105];


int main(){
	rep(j, 105){
		dp[0][j] = 1.;
	}
	repn(j, 104){
		dp[1][j] = 1.;
	}
	for(int j=2;j<105;j++){
		{
			vector<double>a;
			rep(c, 30005) a.pb(dp[c][j-1]);
			auto b = kaede.conv(a);
			rep(c, 30003) dp[c+1][j] = b[c] / (double)(c+1);
		}
	}
	int n; cin >> n;
	repn(i, n){
		if(i <= 100) printf("%.12f\n", dp[n][i]-dp[n][i-1]);
		else puts("0");
	}
}
accuracy: 1
time_ms: 910
memory_kb: 32384
final_rank: 9

code_snippet: #include <cmath>
#include <vector>
#include <complex>
#include <iostream>
#include <algorithm>
using namespace std;
const double pi = acos(-1);
void discrete_fourier_transform(std::size_t n, std::complex<double> *v, bool rev) {
	for (std::size_t i = 0, j = 1; j < n - 1; ++j) {
		for (std::size_t k = n >> 1; k > (i ^= k); k >>= 1);
		if (i > j) std::swap(v[i], v[j]);
	}
	for (std::size_t b = 1; b < n; b <<= 1) {
		std::complex<double> wr = std::polar(1.0, (rev ? -1.0 : 1.0) * pi / b);
		for (std::size_t i = 0; i < n; i += 2 * b) {
			std::complex<double> w = 1.0;
			for (std::size_t j = 0; j < b; ++j) {
				std::complex<double> v0 = v[i + j];
				std::complex<double> v1 = w * v[i + j + b];
				v[i + j] = v0 + v1;
				v[i + j + b] = v0 - v1;
				w *= wr;
			}
		}
	}
	if (!rev) return;
	for (std::size_t i = 0; i < n; i++) v[i] /= n;
}
double prob[54][65555]; complex<double> tmp[65555];
int main() {
	ios::sync_with_stdio(false);
	int N;
	cin >> N;
	int b = 1;
	while (b < 2 * (N + 1)) b *= 2;
	prob[0][0] = 1.0; prob[0][1] = 1.0;
	for (int i = 0; i < 50; ++i) {
		for (int j = 0; j < b; ++j) {
			tmp[j] = (j <= N ? prob[i][j] : 0.0);
		}
		discrete_fourier_transform(b, tmp, false);
		for (int j = 0; j < b; ++j) {
			tmp[j] *= tmp[j];
		}
		discrete_fourier_transform(b, tmp, true);
		prob[i + 1][0] = 1.0;
		for (int j = 0; j < N; ++j) {
			prob[i + 1][j + 1] = tmp[j].real() / (j + 1);
		}
	}
	cout.precision(7);
	for (int i = 0; i < N; ++i) {
		cout << fixed << (i > 50 ? 0.0 : max(prob[i][N] - (i > 0 ? prob[i - 1][N] : 0.0), 0.0)) << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 400
memory_kb: 16536
final_rank: 4

code_snippet: #include <cmath>
#include <vector>
#include <complex>
#include <iostream>
#include <algorithm>
using namespace std;
const double pi = acos(-1);
void discrete_fourier_transform(std::size_t n, std::complex<double> *v, bool rev) {
	for (std::size_t i = 0, j = 1; j < n - 1; ++j) {
		for (std::size_t k = n >> 1; k > (i ^= k); k >>= 1);
		if (i > j) std::swap(v[i], v[j]);
	}
	for (std::size_t b = 1; b < n; b <<= 1) {
		std::complex<double> wr = std::polar(1.0, (rev ? -1.0 : 1.0) * pi / b);
		for (std::size_t i = 0; i < n; i += 2 * b) {
			std::complex<double> w = 1.0;
			for (std::size_t j = 0; j < b; ++j) {
				std::complex<double> v0 = v[i + j];
				std::complex<double> v1 = w * v[i + j + b];
				v[i + j] = v0 + v1;
				v[i + j + b] = v0 - v1;
				w *= wr;
			}
		}
	}
	if (!rev) return;
	for (std::size_t i = 0; i < n; i++) v[i] /= n;
}
double prob[64][65555]; complex<double> tmp[65555];
int main() {
	ios::sync_with_stdio(false);
	int N;
	cin >> N;
	int b = 1;
	while (b < 2 * (N + 1)) b *= 2;
	prob[0][0] = 1.0; prob[0][1] = 1.0;
	for (int i = 0; i < 55; ++i) {
		for (int j = 0; j < b; ++j) {
			tmp[j] = (j <= N ? prob[i][j] : 0.0);
		}
		discrete_fourier_transform(b, tmp, false);
		for (int j = 0; j < b; ++j) {
			tmp[j] *= tmp[j];
		}
		discrete_fourier_transform(b, tmp, true);
		prob[i + 1][0] = 1.0;
		for (int j = 0; j < N; ++j) {
			prob[i + 1][j + 1] = tmp[j].real() / (j + 1);
		}
	}
	cout.precision(7);
	for (int i = 0; i < N; ++i) {
		cout << fixed << (i > 55 ? 0.0 : max(prob[i][N] - (i > 0 ? prob[i - 1][N] : 0.0), 0.0)) << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 610
memory_kb: 17604
final_rank: 5

code_snippet: #include <cmath>
#include <vector>
#include <complex>
#include <iostream>
#include <algorithm>
using namespace std;
const double pi = acos(-1);
void discrete_fourier_transform(std::size_t n, std::complex<double> *v, bool rev) {
	for (std::size_t i = 0, j = 1; j < n - 1; ++j) {
		for (std::size_t k = n >> 1; k > (i ^= k); k >>= 1);
		if (i > j) std::swap(v[i], v[j]);
	}
	for (std::size_t b = 1; b < n; b <<= 1) {
		std::complex<double> wr = std::polar(1.0, (rev ? -1.0 : 1.0) * pi / b);
		for (std::size_t i = 0; i < n; i += 2 * b) {
			std::complex<double> w = 1.0;
			for (std::size_t j = 0; j < b; ++j) {
				std::complex<double> v0 = v[i + j];
				std::complex<double> v1 = w * v[i + j + b];
				v[i + j] = v0 + v1;
				v[i + j + b] = v0 - v1;
				w *= wr;
			}
		}
	}
	if (!rev) return;
	for (std::size_t i = 0; i < n; i++) v[i] /= n;
}
double prob[64][65555]; complex<double> tmp[65555];
int main() {
	ios::sync_with_stdio(false);
	int N;
	cin >> N;
	int b = 1;
	while (b < 2 * (N + 1)) b *= 2;
	prob[0][0] = 1.0; prob[0][1] = 1.0;
	for (int i = 0; i < 55; ++i) {
		for (int j = 0; j < b; ++j) {
			tmp[j] = (j <= N ? prob[i][j] : 0.0);
		}
		discrete_fourier_transform(b, tmp, false);
		for (int j = 0; j < b; ++j) {
			tmp[j] *= tmp[j];
		}
		discrete_fourier_transform(b, tmp, true);
		prob[i + 1][0] = 1.0;
		for (int j = 0; j < N; ++j) {
			prob[i + 1][j + 1] = tmp[j].real() / (j + 1);
		}
	}
	cout.precision(7);
	for (int i = 0; i < N; ++i) {
		cout << fixed << (i > 55 ? 0.0 : prob[i][N] - (i > 0 ? prob[i - 1][N] : 0.0)) << '\n';
	}
	return 0;
}
accuracy: 0.3225806451612903
time_ms: 440
memory_kb: 17676
final_rank: 14

code_snippet: #include <cmath>
#include <vector>
#include <complex>
#include <iostream>
#include <algorithm>
using namespace std;
const long double pi = acos(-1);
void discrete_fourier_transform(std::size_t n, std::complex<long double> *v, bool rev) {
	for (std::size_t i = 0, j = 1; j < n - 1; ++j) {
		for (std::size_t k = n >> 1; k > (i ^= k); k >>= 1);
		if (i > j) std::swap(v[i], v[j]);
	}
	for (std::size_t b = 1; b < n; b <<= 1) {
		std::complex<long double> wr = std::polar(1.0L, (rev ? -1.0 : 1.0) * pi / b);
		for (std::size_t i = 0; i < n; i += 2 * b) {
			std::complex<long double> w = 1.0;
			for (std::size_t j = 0; j < b; ++j) {
				std::complex<long double> v0 = v[i + j];
				std::complex<long double> v1 = w * v[i + j + b];
				v[i + j] = v0 + v1;
				v[i + j + b] = v0 - v1;
				w *= wr;
			}
		}
	}
	if (!rev) return;
	for (std::size_t i = 0; i < n; i++) v[i] /= n;
}
long double prob[64][65555]; complex<long double> tmp[65555];
int main() {
	ios::sync_with_stdio(false);
	int N;
	cin >> N;
	int b = 1;
	while (b < 2 * (N + 1)) b *= 2;
	prob[0][0] = 1.0; prob[0][1] = 1.0;
	for (int i = 0; i < 60; ++i) {
		for (int j = 0; j < b; ++j) {
			tmp[j] = (j <= N ? prob[i][j] : 0.0);
		}
		discrete_fourier_transform(b, tmp, false);
		for (int j = 0; j < b; ++j) {
			tmp[j] *= tmp[j];
		}
		discrete_fourier_transform(b, tmp, true);
		prob[i + 1][0] = 1.0;
		for (int j = 0; j < N; ++j) {
			prob[i + 1][j + 1] = tmp[j].real() / (j + 1);
			if (abs(prob[i + 1][j + 1]) <= 1.0e-8) prob[i + 1][j + 1] = 0.0;
		}
	}
	cout.precision(7);
	for (int i = 0; i < N; ++i) {
		cout << fixed << (i > 60 ? 0.0 : prob[i][N] - (i > 0 ? prob[i - 1][N] : 0.0)) << '\n';
	}
	return 0;
}
accuracy: 1
time_ms: 2960
memory_kb: 34008
final_rank: 11

code_snippet: #include <cmath>
#include <vector>
#include <complex>
#include <iostream>
#include <algorithm>
using namespace std;
const double pi = acos(-1);
void discrete_fourier_transform(std::size_t n, std::complex<double> *v, bool rev) {
	for (std::size_t i = 0, j = 1; j < n - 1; ++j) {
		for (std::size_t k = n >> 1; k > (i ^= k); k >>= 1);
		if (i > j) std::swap(v[i], v[j]);
	}
	for (std::size_t b = 1; b < n; b <<= 1) {
		std::complex<double> wr = std::polar(1.0, (rev ? -1.0 : 1.0) * pi / b);
		for (std::size_t i = 0; i < n; i += 2 * b) {
			std::complex<double> w = 1.0;
			for (std::size_t j = 0; j < b; ++j) {
				std::complex<double> v0 = v[i + j];
				std::complex<double> v1 = w * v[i + j + b];
				v[i + j] = v0 + v1;
				v[i + j + b] = v0 - v1;
				w *= wr;
			}
		}
	}
	if (!rev) return;
	for (std::size_t i = 0; i < n; i++) v[i] /= n;
}
double prob[104][65555]; complex<double> tmp[65555];
int main() {
	ios::sync_with_stdio(false);
	int N;
	cin >> N;
	int b = 1;
	while (b < 2 * (N + 1)) b *= 2;
	prob[0][0] = 1.0; prob[0][1] = 1.0;
	for (int i = 0; i < 100; ++i) {
		for (int j = 0; j < b; ++j) {
			tmp[j] = (j <= N ? prob[i][j] : 0.0);
		}
		discrete_fourier_transform(b, tmp, false);
		for (int j = 0; j < b; ++j) {
			tmp[j] *= tmp[j];
		}
		discrete_fourier_transform(b, tmp, true);
		prob[i + 1][0] = 1.0;
		for (int j = 0; j < N; ++j) {
			prob[i + 1][j + 1] = tmp[j].real() / (j + 1);
			if (abs(prob[i + 1][j + 1]) <= 1.0e-8) prob[i + 1][j + 1] = 0.0;
		}
	}
	cout.precision(7);
	for (int i = 0; i < N; ++i) {
		cout << fixed << (i > 100 ? 0.0 : prob[i][N] - (i > 0 ? prob[i - 1][N] : 0.0)) << '\n';
	}
	return 0;
}
accuracy: 0.3225806451612903
time_ms: 810
memory_kb: 28456
final_rank: 15

code_snippet: #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < int(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < int(n); ++ (i))
#define REP_R(i, n) for (int i = int(n) - 1; (i) >= 0; -- (i))
using namespace std;

template <typename R>
void fft_inplace(vector<complex<R> > & f, int dir) {
    int n = f.size();
    assert(n == pow(2, log2(n)));
    R theta = dir * 2 * M_PI / n;
    for (int m = n; m >= 2; m >>= 1) {
        REP (i, m / 2) {
            complex<R> w = polar<R>(1, i * theta);
            for (int j = i; j < n; j += m) {
                int k = j + m / 2;
                complex<R> x = f[j] - f[k];
                f[j] += f[k];
                f[k] = w * x;
            }
        }
        theta *= 2;
    }
    int i = 0;
    REP3 (j, 1, n - 1) {
        for (int k = n >> 1; k > (i ^= k); ) k >>= 1;
        if (j < i) {
            swap(f[i], f[j]);
        }
    }
}
template <typename T, typename R = double>
void convolution_self_inplace(vector<T> & a, int result_n) {
    int m = 2 * a.size() - 1;
    int n = pow(2, ceil(log2(m)));
    vector<complex<R> > x(n);
    copy(a.begin(), a.end(), x.begin());
    fft_inplace(x, +1);
    vector<complex<R> > z(n);
    REP (i, n) x[i] *= x[i];
    fft_inplace(x, -1);
    a.resize(result_n);
    REP (i, result_n) a[i] = x[i].real() / n;
}

int main() {
    // input
    int n; scanf("%d", &n);
    // solve
    const int height = min(n, 50);
    vector<double> dp(n + 1);
    dp[0] = 1;
    double last_dp_n = 0;
    REP3 (j, 1, height + 1) {
        convolution_self_inplace(dp, n + 1);
        REP_R (i, n) {
            dp[i + 1] = dp[i] / (i + 1);
        }
        dp[0] = 1;
        // output
        printf("%.10lf\n", double(dp[n] - last_dp_n));
        last_dp_n = dp[n];
    }
    REP3 (j, height + 1, n + 1) {
        printf("0\n");
    }
    return 0;
}
accuracy: 1
time_ms: 680
memory_kb: 5632
final_rank: 3

code_snippet: #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < int(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < int(n); ++ (i))
#define REP_R(i, n) for (int i = int(n) - 1; (i) >= 0; -- (i))
using namespace std;

template <typename R>
void fft_inplace(vector<complex<R> > & f, int dir) {
    int n = f.size();
    assert(n == pow(2, log2(n)));
    R theta = dir * 2 * M_PI / n;
    for (int m = n; m >= 2; m >>= 1) {
        REP (i, m / 2) {
            complex<R> w = polar<R>(1, i * theta);
            for (int j = i; j < n; j += m) {
                int k = j + m / 2;
                complex<R> x = f[j] - f[k];
                f[j] += f[k];
                f[k] = w * x;
            }
        }
        theta *= 2;
    }
    int i = 0;
    REP3 (j, 1, n - 1) {
        for (int k = n >> 1; k > (i ^= k); ) k >>= 1;
        if (j < i) {
            swap(f[i], f[j]);
        }
    }
}
template <typename T, typename R = long double>
void convolution_self_inplace(vector<T> & a, int result_n) {
    int m = 2 * a.size() - 1;
    int n = pow(2, ceil(log2(m)));
    vector<complex<R> > x(n);
    copy(a.begin(), a.end(), x.begin());
    fft_inplace(x, +1);
    vector<complex<R> > z(n);
    REP (i, n) x[i] *= x[i];
    fft_inplace(x, -1);
    a.resize(result_n);
    REP (i, result_n) a[i] = x[i].real() / n;
}

int main() {
    // input
    int n; scanf("%d", &n);
    // solve
    const int height = min(n, 50);
    vector<long double> dp(n + 1);
    dp[0] = 1;
    long double last_dp_n = 0;
    REP3 (j, 1, height + 1) {
        convolution_self_inplace(dp, n + 1);
        REP_R (i, n) {
            dp[i + 1] = dp[i] / (i + 1);
        }
        dp[0] = 1;
        // output
        printf("%.10lf\n", double(dp[n] - last_dp_n));
        last_dp_n = dp[n];
    }
    REP3 (j, height + 1, n + 1) {
        printf("0\n");
    }
    return 0;
}
accuracy: 1
time_ms: 2370
memory_kb: 7936
final_rank: 7

code_snippet: #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; (i) < int(n); ++ (i))
#define REP3(i, m, n) for (int i = (m); (i) < int(n); ++ (i))
using namespace std;

template <typename T>
void fft_inplace(vector<complex<T> > & f, int dir) {
    int n = f.size();
    assert (n == pow(2, log2(n)));
    if (n == 1) return;
    vector<complex<T> > a(n / 2), b(n / 2);
    REP (i, n / 2) {
        a[i] = f[2 * i];
        b[i] = f[2 * i+ 1];
    }
    fft_inplace(a, dir);
    fft_inplace(b, dir);
    const complex<T> zeta = polar<T>(1, dir * 2 * M_PI / n);
    complex<T> pow_zeta = 1;
    REP (i, n) {
        f[i] = a[i % (n / 2)] + pow_zeta * b[i % (n / 2)];
        pow_zeta *= zeta;
    }
}
template <typename T, typename R = double>
deque<T> convolution(deque<T> const & a, deque<T> const & b) {
    int m = a.size() + b.size() - 1;
    int n = pow(2, ceil(log2(m)));
    vector<complex<R> > x(n), y(n);
    copy(a.begin(), a.end(), x.begin());
    copy(b.begin(), b.end(), y.begin());
    fft_inplace(x, +1);
    fft_inplace(y, +1);
    vector<complex<R> > z(n);
    REP (i, n) z[i] = x[i] * y[i];
    fft_inplace(z, -1);
    deque<T> c(m);
    REP (i, m) c[i] = is_integral<T>::value ? round(z[i].real() / n) : z[i].real() / n;
    return c;
}

int main() {
    // input
    int n; scanf("%d", &n);
    // solve
    const int height = min(n, 50);
    deque<double> dp(n + 1);
    dp[0] = 1;
    double last_dp_n = 0;
    REP3 (j, 1, height + 1) {
        dp = convolution(dp, dp);
        dp.push_front(1);
        dp.resize(n + 1);
        REP (i, n) {
            dp[i + 1] /= (i + 1);
        }
        // output
        printf("%.10lf\n", dp[n] - last_dp_n);
        last_dp_n = dp[n];
    }
    REP3 (j, height + 1, n + 1) {
        printf("0\n");
    }
    return 0;
}
accuracy: 0.3225806451612903
time_ms: 4400
memory_kb: 8636
final_rank: 18

code_snippet: #include <cstdio>
#include <cmath>
#include <algorithm>
#include <complex>
#include <cstring>
using namespace std;

const int MAX_N = 30000<<3;
const double PI = 4.0*atan(1.0);

int N, NN;
double prev[MAX_N], cur[MAX_N];
complex<double> xs[MAX_N], zs[MAX_N];

static const complex<double> I(0,1);

void init(){
	scanf("%d", &N);
}

void fft(complex<double> a[], int n, bool inv = false){
	double theta = 2 * PI / n * (inv ? -1 : 1);
	for(int m=n; m>=2; m>>=1){
		int mh = m >> 1;
		for(int i=0; i<mh; ++i){
			complex<double> w = exp(i*theta*I);
			for(int j=i; j<n; j+=m){
				int k = j + mh;
				complex<double> x = a[j] - a[k];
				a[j] += a[k];
				a[k] = w * x;
			}
		}
		theta *= 2;
	}
	int i = 0;
	for(int j=1; j<n-1; ++j){
		for(int k=n>>1; k>(i^=k); k>>=1);
		if(j<i){
			swap(a[i], a[j]);
		}
	}
	if(inv){
		for(int i=0; i<n; ++i){
			a[i] /= n;
		}
	}
}

void calc(){
	for(int i=0; i<NN; ++i){
		xs[i] = complex<double>(prev[i], 0.0);
	}
	fft(xs, NN);
	for(int i=0; i<NN; ++i){
		zs[i] = xs[i] * xs[i];
	}
	fft(zs, NN, true);
	memset(cur, 0, sizeof(cur));
	cur[0] = 1.0;
	for(int i=1; i<=N; ++i){
		cur[i] = zs[i-1].real() / i;
	}
}

void solve(){
	NN = 4<<(31 - __builtin_clz(N));
	fill(prev, prev+NN, 0.0);
	prev[0] = prev[1] = 1.0;
	bool small = false;
	printf("%f\n", prev[N]);
	for(int i=0; i<N-1; ++i){
		if(small){
			puts("0.0");
		}
		else{
			calc();
			printf("%.12f\n", cur[N] - prev[N]);

			if(i>50 && cur[N] - prev[N] < 1e-5){
				small = true;
			}
			memcpy(prev, cur, sizeof(prev));
		}
	}
}

int main(){
	init();
	solve();

	return 0;
}
accuracy: 1
time_ms: 2250
memory_kb: 0
final_rank: 6

code_snippet: #include <iostream>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <cmath>
#include <complex>
#include <cstdio>

using namespace std;

inline int getInt(){ int s; scanf("%d", &s); return s; }

// sizeof v must be 2 ^ n
template<class T>
void fft_core(vector<complex<T> > &v, bool rev = false){
  const int n = v.size();

  for(int i = 0; i < n; i++){
    int k = 0;
    int b = (n >> 1);
    int a = 1;

    while(b >= a){
      if(b & i) k |= a;
      if(a & i) k |= b;
      b >>= 1;
      a <<= 1;
    }

    if(i < k) swap(v[i], v[k]);
  }

  int m = 2;

  while(m <= n){
    double arg = -2.0 * M_PI / m;
    complex<T> w(cos(arg), sin(arg));
    if(rev) w = 1.0 / w;

    for(int i = 0; i < n; i += m){
      complex<T> ww(1.0);

      for(int j = 0; j < m / 2; j++){
	int a = i + j;
	int b = i + j + m / 2;
	complex<T> t = ww * v[b];

	v[b] = v[a] - t;
	v[a] = v[a] + t;

	ww *= w;
      }
    }
    m *= 2;
  }

  if(rev){
    double s = (double)n;
    for(int i = 0; i < n; i++)
      v[i] /= s;
  }
}

template<class T> inline void  fft(vector<T> &v){ fft_core(v); }
template<class T> inline void ifft(vector<T> &v){ fft_core(v, true); }

int next(int n){
  int i = 1;
  while(i < n) i *= 2;
  return i;
}


int main(){
  int n  = getInt();
  int m  = next(n + 1);
  int mm = m * 2;
  vector<complex<double> > p(mm, 0.0);
  double prev = 0.0;
  p[0] = 1.0;
  
  for(int i = 1; i <= n; i++){
    if(i < 51){
      fft(p);

      for(int j = mm - 1; j >= 0; j--){
	p[j] = p[j] * p[j];
      }
      
      ifft(p);

      for(int j = mm - 1; j >= 1; j--){
	p[j] = p[j - 1];
      }
      p[0] = 1.0;
      for(int j = 1; j < mm / 2; j++)
	p[j] /= j;
      for(int j = mm / 2; j < mm; j++)
	p[j] = 0.0;
      
      double ans = n >= p.size() ? 0.0 : p[n].real();
      double pans = (ans - prev);
      if(ans > 1e-10) pans += 0.000007;
      printf("%.7f\n", max(0.0, pans) + 1e-10);
      prev = ans;
    }else{
      printf("%.7f\n", 0.0 + 1e-10);
    }
  }

  return 0;
}
accuracy: 1
time_ms: 2980
memory_kb: 0
final_rank: 8

code_snippet: #include <iostream>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <cmath>
#include <complex>
#include <cstdio>

using namespace std;

inline int getInt(){ int s; scanf("%d", &s); return s; }

// sizeof v must be 2 ^ n
template<class T>
void fft_core(vector<complex<T> > &v, bool rev = false){
  const int n = v.size();

  for(int i = 0; i < n; i++){
    int k = 0;
    int b = (n >> 1);
    int a = 1;

    while(b >= a){
      if(b & i) k |= a;
      if(a & i) k |= b;
      b >>= 1;
      a <<= 1;
    }

    if(i < k) swap(v[i], v[k]);
  }

  int m = 2;

  while(m <= n){
    double arg = -2.0 * M_PI / m;
    complex<T> w(cos(arg), sin(arg));
    if(rev) w = 1.0 / w;

    for(int i = 0; i < n; i += m){
      complex<T> ww(1.0);

      for(int j = 0; j < m / 2; j++){
	int a = i + j;
	int b = i + j + m / 2;
	complex<T> t = ww * v[b];

	v[b] = v[a] - t;
	v[a] = v[a] + t;

	ww *= w;
      }
    }
    m *= 2;
  }

  if(rev){
    double s = (double)n;
    for(int i = 0; i < n; i++)
      v[i] /= s;
  }
}

template<class T> inline void  fft(vector<T> &v){ fft_core(v); }
template<class T> inline void ifft(vector<T> &v){ fft_core(v, true); }

int next(int n){
  int i = 1;
  while(i < n) i *= 2;
  return i;
}


int main(){
  int n  = getInt();
  int m  = next(n + 1);
  int mm = m * 2;
  vector<complex<double> > p(mm, 0.0);
  double prev = 0.0;
  p[0] = 1.0;
  
  for(int i = 1; i <= n; i++){
    if(i < 80){
      fft(p);

      for(int j = mm - 1; j >= 0; j--){
	p[j] = p[j] * p[j];
      }
      
      ifft(p);

      for(int j = mm - 1; j >= 1; j--){
	p[j] = p[j - 1];
      }
      p[0] = 1.0;
      for(int j = 1; j < mm / 2; j++)
	p[j] /= j;
      for(int j = mm / 2; j < mm; j++)
	p[j] = 0.0;
      
      double ans = n >= p.size() ? 0.0 : p[n].real();
      double pans = (ans - prev);
      if(ans > 1e-10) pans += 0.000007;
      printf("%.7f\n", max(0.0, pans) + 1e-10);
      prev = ans;
    }else{
      printf("%.7f\n", 0.0 + 1e-10);
    }
  }

  return 0;
}
accuracy: 1
time_ms: 4620
memory_kb: 0
final_rank: 10

code_snippet: #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
#include <complex>

using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);

#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))

#include <complex>

typedef complex<double> Complex;

// a.size must 2^x
vector<Complex> FFT(double theta, const vector<Complex> &a) {
  int n = a.size();
  vector<Complex> ret = a;
  for (int m = n; m >= 2; m >>= 1) {
    int mh = m >> 1;
    for (int i = 0; i < mh; i++) {
      Complex w = exp(i * theta * Complex(0, 1));
      for (int j = i; j < n; j += m) {
        int k = j + mh;
        Complex x = ret[j] - ret[k];
        ret[j] += ret[k];
        ret[k] = w * x;
      }
    }
    theta *= 2;
  }
  int i = 0;
  for (int j = 1; j < n - 1; j++) {
    for (int k = n >> 1; k > (i ^= k); k >>= 1) {;}
    if (j < i) { swap(ret[i], ret[j]); }
  }
  return ret;
}

vector<double> Convolution(const vector<double> &lhs, const vector<double> &rhs) {
  int n = 1;
  while (n < (int)max(lhs.size(), rhs.size()) * 2) { n <<= 1; }
  vector<Complex> temp1(n);
  vector<Complex> temp2(n);
  for (int i = 0; i < n; i++) {
    if (i < (int)lhs.size()) {
      temp1[i] = Complex(lhs[i], 0);
    }
    if (i < (int)rhs.size()) {
      temp2[i] = Complex(rhs[i], 0);
    }
  }
  temp1 = FFT(2.0 * PI / n, temp1);
  temp2 = FFT(2.0 * PI / n, temp2);
  for (int i = 0; i < n; i++) { temp1[i] *= temp2[i]; }
  temp1 = FFT(-2.0 * PI / n, temp1);
  vector<double> ret;
  ret.resize(n + 1);
  for (int i = 0; i < n; i++) {
    ret[i + 1] = temp1[i].real() / n;
  }
  ret[0] = 1.0;
  return ret;
}

const int H = 60;
vector<double> anss[H + 1];
int main() {
  int n;
  while (scanf("%d", &n) > 0) {
    anss[0] = vector<double>(n + 1, 0);
    anss[0][0] = 1.0;

    FOREQ(h, 1, H) {
      anss[h] = Convolution(anss[h - 1], anss[h - 1]);
      anss[h].resize(n + 1);
      FOREQ(i, 1, n) {
        anss[h][i] /= i;
      }
    }

    FOREQ(h, 1, min(n, H)) {
      printf("%.8f\n", anss[h][n] - anss[h - 1][n] + EPS);
    }
    FOREQ(h, H + 1, n) {
      printf("%.8f\n", 0.0);
    }
  }
}
accuracy: 1
time_ms: 4250
memory_kb: 33000
final_rank: 12