#include <bits/stdc++.h>

using namespace std;

char nl = '\n';
char sp = ' ';
using ll = long long;
using vb = vector<bool>;
using vi = vector<int>;
using vl = vector<ll>;
using vvb = vector<vb>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using si = unordered_set<int>;
using sl = unordered_set<ll>;
using tsi = set<int>;
using tsl = set<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using tmii = map<int, int>;
using tmll = map<ll, ll>;
using mii = unordered_map<int, int>;
using mll = unordered_map<ll, ll>;
using pqi = priority_queue<int>;
using pqig = priority_queue<int, vi, greater<int>>;
using pql = priority_queue<ll>;
using pqlg = priority_queue<ll, vl, greater<ll>>;
using pqpii = priority_queue<pii>;
using pqpll = priority_queue<pll>;

#define tp3(T) tuple<T,T,T>
#define tp4(T) tuple<T,T,T,T>

#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define outrange(x,min,max) ((x)<(min) || (x)>(max))

ll _start_time;
#define nano (chrono::system_clock::now().time_since_epoch().count())
#define reset_timer _start_time=nano
#define chime cout<<((nano-_start_time)/1e9)<<endl
#define init_rng mt19937 rng(nano)
#define randint(a,b) ((a)+rng()%((b)-(a)+1))

#ifndef ONLINE_JUDGE
#define debug(x) (cout<<(#x)<<':'<<(x)<<'\n')
#else
#define debug(x)
#endif

void yesno(bool a) {
	cout << (a ? "Yes\n" : "No\n");
}

template<typename L, typename R>
ostream& operator<<(ostream& out, const pair<L, R>& p) {
	out << '(' << p.first << ',' << p.second << ')';
	return out;
}

template<typename T1, typename T2, typename T3>
ostream& operator<<(ostream& out, const tuple<T1, T2, T3>& tp) {
	auto [t1, t2, t3] = tp;
	out << '(' << t1 << ',' << t2 << ',' << t3 << ')';
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
	for (auto &i : v) out << i << ' ';
	out << nl;
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, const set<T>& v) {
	for (auto &i : v) out << i << ' ';
	out << nl;
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, const unordered_set<T>& v) {
	for (auto &i : v) out << i << ' ';
	out << nl;
	return out;
}

template<typename K, typename V>
ostream& operator<<(ostream& out, const map<K, V>& m) {
	out << '[';
	for (auto &[k, v] : m) {
		out << k << ':' << v << sp;
	}
	out << "]\n";
	return out;
}

template<typename K, typename V>
ostream& operator<<(ostream& out, const unordered_map<K, V>& m) {
	out << '[';
	for (auto &[k, v] : m) {
		out << k << ':' << v << sp;
	}
	out << "]\n";
	return out;
}

using u64 = unsigned long long;

u64 pow_10[]={1, 10, 100, 1000, 10000, 100'000, 1'000'000,
	10'000'000, 100'000'000, 1'000'000'000};

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	u64 A,B,N;
//	cin>>A>>B>>N;
	A=pow_10[5];
	B=pow_10[5];
	N=pow_10[9];
	vector<vector<u64>> b_factors(100001,vector<u64>());
	vector<vector<u64>> factors(10,vector<u64>());
	
	for(int i=1;i<=100000;i++){
		for(int j=i;j<=100000;j+=i){
			b_factors[j].push_back(i);
		}
	}
	
	for(int digit_n=1;digit_n<=9;digit_n++){
		int t=pow_10[digit_n]-1;
		for(int i=1;i*i<=t;i++){
			int j=t/i;
			if(i*j!=t) continue;
			factors[digit_n].push_back(i);
			if(i!=j) factors[digit_n].push_back(j);
		}
	}
	u64 ans=0;
	
	unordered_set<u64> checked;
	vector<tp3(int)> v;
	for(int digit_b=1;digit_b<=5;digit_b++){
		u64 pow10_b=pow_10[digit_b];
		for(u64 b=pow10_b/10;b<min(B,pow10_b);b++){

			//The whole process could cost over 30 seconds, so we need to 
			//know how many values of b we've processed.
			if(b%100==0) cout<<b<<endl;
			
			for(int digit_n=1;digit_n<=9;digit_n++){
				checked.clear();
				for(u64 d1:b_factors[b]){
					for(u64 d2:factors[digit_n]){
						u64 d=d1*d2;
						if(d<pow10_b-b) continue;
						if(checked.count(d)) {
							continue;
						}
						
						checked.insert(d);
						
						u64 r=pow10_b-d%pow10_b;
						if(b%r!=0) continue;
						u64 c=b/r;
						u64 k=(d+r)/pow10_b;
						u64 a=k*c;
						if(a>=A || c!=gcd(a,b)) continue;
						u64 n=k*b*(pow_10[digit_n]-1)/(pow10_b*k-r);
						if(pow_10[digit_n-1]<=n && n<N && n<pow_10[digit_n]) {
							ans++;
							v.emplace_back(a,b,n);
						}
					}
				}
			}
		}
	}
	cout<<ans<<nl;
	
	// Output special values of b.
	ofstream ofs;
	ofs.open("D:\\PandaCpp\\Codeforces\\my_out.txt");
	sort(all(v));
	set<u64> s;
	int t=0;
	for(auto [a,b,n]:v){
		if(b==a || b==10*a || b==100*a || b==1000*a || b==10000*a) continue;
		if(a==b || a==10*b || a==100*b || a==1000*b || a==10000*b) continue;
		if(s.count(b)) continue;
		ofs<<b<<',';
		t++;
		if(t%20==0) ofs<<nl;
		s.insert(b);
	}
}

#include <bits/stdc++.h>

using namespace std;

char nl = '\n';
char sp = ' ';
using ll = long long;
using vb = vector<bool>;
using vi = vector<int>;
using vl = vector<ll>;
using vvb = vector<vb>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using si = unordered_set<int>;
using sl = unordered_set<ll>;
using tsi = set<int>;
using tsl = set<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using tmii = map<int, int>;
using tmll = map<ll, ll>;
using mii = unordered_map<int, int>;
using mll = unordered_map<ll, ll>;
using pqi = priority_queue<int>;
using pqig = priority_queue<int, vi, greater<int>>;
using pql = priority_queue<ll>;
using pqlg = priority_queue<ll, vl, greater<ll>>;
using pqpii = priority_queue<pii>;
using pqpll = priority_queue<pll>;

#define tp3(T) tuple<T,T,T
#define tp4(T) tuple<T,T,T,T>;

#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define outrange(x,min,max) ((x)<(min) || (x)>(max))

#define nano (chrono::system_clock::now().time_since_epoch().count())
#define second_since_start ((nano-start)/1e9)
#define init_rng mt19937 rng(nano)
#define randint(a,b) ((a)+rng()%((b)-(a)+1))

void yesno(bool a) {
	cout << (a ? "YES\n" : "NO\n");
}

template<typename L, typename R>
ostream& operator<<(ostream& out, const pair<L, R>& p) {
	out << '(' << p.first << ',' << p.second << ')';
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, vector<T>& v) {
	for (auto &i : v) out << i << ' ';
	out << nl;
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, set<T>& v) {
	for (auto &i : v) out << i << ' ';
	out << nl;
	return out;
}

template<typename T>
ostream& operator<<(ostream& out, unordered_set<T>& v) {
	for (auto &i : v) out << i << ' ';
	out << nl;
	return out;
}

template<typename K, typename V>
ostream& operator<<(ostream& out, map<K, V>& m) {
	out << '[';
	for (auto &[k, v] : m) {
		out << k << ':' << v << sp;
	}
	out << "]\n";
	return out;
}

template<typename K, typename V>
ostream& operator<<(ostream& out, unordered_map<K, V>& m) {
	out << '[';
	for (auto &[k, v] : m) {
		out << k << ':' << v << sp;
	}
	out << "]\n";
	return out;
}

namespace NTT{
	ll mod=998244353;
	ll w[]= {1, 998244352, 911660635, 
		372528824, 929031873, 452798380, 922799308, 781712469,
		476477967, 166035806, 258648936, 584193783, 63912897,
		350007156, 666702199, 968855178, 629671588, 24514907, 
		996173970, 363395222, 565042129, 733596141, 267099868,
		15311432};
	ll pow2Inv[]={1, 499122177, 748683265, 
		873463809, 935854081, 967049217, 982646785, 990445569, 
		994344961, 996294657, 997269505, 997756929, 998000641, 
		998122497, 998183425, 998213889, 998229121, 998236737, 
		998240545, 998242449, 998243401, 998243877, 998244115, 
		998244234};
	
	int prev_n=-1;
	int* rev_bit;
	ll __b[1<<21];
	
	void but(ll &_a,ll &_b, ll _w){
		ll mul=_w*_b%mod;
		_b=_a+mod-mul;
		if(_b>=mod) _b-=mod;
		_a+=mul;
		if(_a>=mod) _a-=mod;
		//		cout<<_a<<":"<<_b<<":"<<_w<<endl;
	}
	
	void intt(ll *a,int n){
		int pow2=1<<n;
		if(n!=prev_n){
			rev_bit=new int[pow2];
			for(int i=0;i<pow2;i++){
				int rev=0;
				int j=i;
				for(int k=0;k<n;k++){
					rev<<=1;
					rev|=(j&1);
					j>>=1;
				}
				rev_bit[i]=rev;
			}
		}
		for(int i=0;i<pow2;i++) __b[i]=a[rev_bit[i]];
		for(int L=n;L>0;L--){
			
			//			for(int i=0;i<8;i++) cout<<b[i]<<' '<<endl;
			
			int d=1<<(n-L);
			int d2=2*d;
			ll w1=1;
			int w0=w[n-L+1];
			for(int i=0;i<d;i++){
				for(int j=i;j<pow2;j+=d2){
					//					cout<<j<<":"<<j+d<<":"<<w1<<endl;
					but(__b[j],__b[j+d],w1);
				}
				w1=(w1*w0%mod);
			}
		}
		ll lenInv=pow2Inv[n];
		a[0]=(__b[0]*lenInv)%mod;
		for(int i=1;i<pow2;i++) a[i]=(__b[pow2-i]*lenInv)%mod;
		prev_n=n;
	}
	
	void ntt(ll *a,int n){
		int pow2=1<<n;
		if(n!=prev_n){
			rev_bit=new int[pow2];
			for(int i=0;i<pow2;i++){
				int rev=0;
				int j=i;
				for(int k=0;k<n;k++){
					rev<<=1;
					rev|=(j&1);
					j>>=1;
				}
				rev_bit[i]=rev;
			}
		}
		for(int i=0;i<pow2;i++) __b[i]=a[rev_bit[i]];
		for(int L=n;L>0;L--){
			int d=1<<(n-L);
			int d2=2*d;
			ll w1=1;
			int w0=w[n-L+1];
			for(int i=0;i<d;i++){
				for(int j=i;j<pow2;j+=d2){
					but(__b[j],__b[j+d],w1);
				}
				w1=(w1*w0%mod);
			}
		}
		for(int i=0;i<pow2;i++) a[i]=__b[i];
		prev_n=n;
	}
	
	ll* convolution(ll *a,ll *b,int n) {
		int len=1<<n;
		ll *c=new ll[len];
		ntt(a,n);
		ntt(b,n);
		for(int i=0;i<len;i++) {
			c[i]=(a[i]*b[i])%mod;
		}
		intt(c,n);
		return c;
	}
	
	ll *selfConvolution(ll *a,int n) {
		int len=1<<n;
		ntt(a,n);
		for(int i=0;i<len;i++) {
			a[i]=(a[i]*a[i])%mod;
		}
		intt(a,n);
		return a;
	}
}
using namespace NTT;

ll *factorial;//[upperBound];
ll *factorial_inv;

ll modInv(ll n) {
	ll pow=mod-2;
	ll result=1;
	while(pow>0) {
		if((pow&1)==1) result=(result*n)%mod;
		n=(n*n)%mod;
		pow>>=1;
	}
	return result;
}

ll modPow(ll n,ll pow) {
	ll result=1;
	while(pow>0) {
		if((pow&1)==1) result=(result*n)%mod;
		n=(n*n)%mod;
		pow>>=1;
	}
	return result;
}

void prepareFactorialAndInv(int max) {
	factorial=new ll[max+1];
	factorial_inv=new ll[max+1];
	factorial[0]=1;
	for(int i=1;i<=max;i++) {
		factorial[i]=factorial[i-1]*i%mod;
	}
	factorial_inv[max]=modInv(factorial[max]);
	for(int i=max-1;i>=0;i--) {
		factorial_inv[i]=factorial_inv[i+1]*(i+1)%mod;
	}
}

const int MAX=(1<<20)+5;
ll dp[MAX];
int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int n;
	cin>>n;
	if(n==1){
		cout<<"0\n2";
		return 0;
	}
	prepareFactorialAndInv(1<<n);
	dp[0]=0;
	dp[1]=0;
	dp[2]=0;
	dp[3]=1;
	dp[4]=2;
	ll dp_sum=3;
	for(int m=3;m<=n;m++){
		ll* f=new ll[1<<m];
		ll* g=new ll[1<<m];
		ll pow2=1<<(m-1);
		for(ll j=0;j<pow2;j++){
			f[j]=factorial_inv[j]*factorial_inv[pow2-(j+1)]%mod;
			g[j]=f[j]*dp[j+1]%mod;
		}
		for(ll j=pow2;j<2*pow2;j++){
			f[j]=0;
			g[j]=0;
		}
		ll* conv=convolution(f,g,m);
		ll dp_sum_next=0;
		for(ll k=0;k<=m;k++) dp[k]=0;
		for(ll k=m+1;k<=(1<<m);k++){
			dp[k]=dp_sum*factorial[k-2]%mod*factorial[(1<<m)-k]%mod*conv[k-2]%mod;
			dp_sum_next+=dp[k];
			if(dp_sum_next>=mod) dp_sum_next-=mod;
		}
		dp_sum=dp_sum_next;
//		cout<<m<<":"<<dp_sum<<nl;
	}
	ll pow2=modPow(2,(1<<n)-1);
//	cout<<pow2<<nl;
	for(int k=1;k<=n;k++) cout<<"0\n";
	for(int k=n+1;k<=(1<<n);k++){
		cout<<pow2*dp[k]%mod<<nl;
	}
}

import java.util.*;
import java.io.*;
public class Problem1768F {

	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

	public static void main(String[] args) throws Exception {
		long start = System.nanoTime();
		
		int n =400000; //Integer.parseInt(br.readLine());
		long[] a = new long[n];
		long[] dp=new long[n];
		int mod=640;// also tested for 1000 and 320
		for (int i = 0; i < n; i++) {
			//Simulate the test case: 1 2 3 4 5 ...
			a[i] =(i%mod)+1; //readInt();
			dp[i]=2L*n*n;
		}
		dp[0]=0;
		for(int i=0;i<n;i++) {
			int lb=(int)Math.max(0,i-n/a[i]);
			for(int j=i-1;j>=lb;j--) {
				dp[i]=Math.min(dp[i], dp[j]+a[i]*(i-j)*(i-j));
				if(a[i]>=a[j]) break;
			}
			int ub=(int)Math.min(n-1, i+n/a[i]);
			for(int j=i+1;j<=ub;j++) {
				dp[j]=Math.min(dp[j], dp[i]+a[i]*(j-i)*(j-i));
				if(a[i]>=a[j]) break;
			}
		}
		StringBuilder sb = new StringBuilder();
		for(int i=0;i<n;i++) sb.append(dp[i]).append(' ');
		
		long end = System.nanoTime();
		
		//Tested for dozens of times. Max time cost is 0.63s
		System.out.println((end - start) / 1E9);
		
		//System.out.println(sb);
	}

	public static int readInt() {
		int input = 0;
		int c;
		int sign = 1;
		try {
			while ((c = br.read()) == '-') {
				sign = -sign;
			}
			input *= 10;
			input += (c - 48);
			while ((c = br.read()) > 32) {
				input *= 10;
				input += (c - 48);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return (sign == 1) ? input : -input;
	}

	public static long readLong() {
		long input = 0;
		int c;
		int sign = 1;
		try {
			while ((c = br.read()) == '-') {
				sign = -sign;
			}
			input *= 10;
			input += (c - 48);
			while ((c = br.read()) > 32) {
				input *= 10;
				input += (c - 48);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return (sign == 1) ? input : -input;
	}
}