#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define ll long long
#define RCL(a,b,c,d) memset(a,b,sizeof(c)*(d))
#define tomin(a,...) ((a)=min({(a),__VA_ARGS__}))
#define tomax(a,...) ((a)=max({(a),__VA_ARGS__}))
#define FOR(i,a,b) for(int i(a); i<=(int)(b); ++i)
#define DOR(i,a,b) for(int i(a); i>=(int)(b); --i)
#define EDGE(g,i,x,y) for(int i(g.h[x]),y(g[i].v); ~i; y=g[i=g[i].nxt].v)
using namespace std;
constexpr int N(1e6+10),lN(20),lV(lN+1);

namespace IOEstream {
#define isdigit(ch) ('0'<=(ch)&&(ch)<='9')
#define DE(...) E(#__VA_ARGS__,__VA_ARGS__)

	struct Istream {
		char getc() {
			return getchar();
		}
		template<class T>void operator ()(T &x) {
			static bool sign(0);
			static char ch(0);
			sign=0,x=0;
			while(ch=getc(),!isdigit(ch))if(ch=='-')sign=1;
			do x=(x<<1)+(x<<3)+(ch^48);
			while(ch=getc(),isdigit(ch));
			if(sign)x=-x;
		}
		template<class T,class...Types>void operator ()(T &x,Types&...args) {
			return (*this)(x),(*this)(args...);
		}
	} I;

	struct Ostream {
		void putc(const char c) {
			putchar(c);
		}
		template<class T>void operator ()(T x,const char lst='\n') {
			static int top(0);
			static char st[50];
			if(x<0)x=-x,putc('-');
			do st[++top]=(x%10)^48,x/=10;
			while(x);
			while(top)putc(st[top--]);
			putc(lst);
		}
		template<class T,class...Types>void operator ()(const T x,const char lst='\n',const Types...args) {
			return (*this)(x,lst),(*this)(args...);
		}
	} O;

	struct Estream {
		template<class T>void operator ()(const char *fmt,const T x) {
			cerr<<fmt<<':'<<x<<".\n";
		}
		template<class T,class...Types>void operator ()(const char *fmt,const T x,const Types...args) {
			while(*fmt^',')cerr<<*fmt++;
			return cerr<<':'<<x<<", ",(*this)(++fmt,args...);
		}
	} E;

} using namespace IOEstream;

namespace Modular {
#define Mod 998244353
	template<class T1,class T2>constexpr auto add(const T1 a, const T2 b) {
		return a+b>=Mod?a+b-Mod:a+b;
	}

	template<class T1,class T2>constexpr auto mul(const T1 a,const T2 b) {
		return (ll)a*b%Mod;
	}

	template<class T,class...Types>constexpr auto add(const T a,const Types...args) {
		return add(a,add(args...));
	}

	template<class T,class...Types>constexpr auto mul(const T a,const Types...args) {
		return mul(a,mul(args...));
	}

	template<class T1,class T2>T1 &toadd(T1 &a,const T2 b) {
		return a=add(a,b);
	}

	template<class T1,class T2>T1 &tomul(T1 &a,const T2 b) {
		return a=mul(a,b);
	}

	template<class T0,class T,class...Types>T0 &toadd(T0 &a,const T b,const Types...args) {
		return toadd(a,b),toadd(a,args...);
	}

	template<class T0,class T,class...Types>T0 &tomul(T0 &a,const T b,const Types...args) {
		return tomul(a,b),tomul(a,args...);
	}

} using namespace Modular;

int n;
int f[N],g[N],Lg[N];

int main() {
	I(n),f[0]=1,g[0]=1,Lg[0]=-1;
	FOR(i,1,n)f[i]=i&1?f[i-1]:add(f[i-1],f[i>>1]);
	FOR(i,1,n) {
		Lg[i]=Lg[i>>1]+1;
		if(i==(1<<Lg[i]))g[i]=1;
		else if(i+1==(2<<Lg[i]))g[i]=f[i];
		else g[i]=i&1?g[i-1]:add(g[i-1],g[i>>1]);
		O(g[i],' ');
	}
	puts("");
	return 0;
}