stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

int main()

{

    int exist[50000];

    for(int i = 0; i < 50000; i++)exist[i] = i + 1;

    int N;

    cin >> N;

    for(int i = 0; i < 50000; i++){

        if((int)((float)exist[i]*1.08) == N){

            cout << exist[i];

            return 0;

        }

    }

    cout << ":(";

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 1.2019742283959078x):
#include <iostream>

#include <iomanip>

typedef long long ll;

using namespace std;

const  ll INF = 1e9;

const  ll MOD = 1e9 + 7;

#define repi(i,n,init) for(ll i=init;i<(n);i++)



int main()

{

    int x;

    cin >> x;

    repi(i,x+1,1){

        if(int(i * 1.08) == x){

            cout << i << endl;

            return 0;

        }

    }

    cout << ":(" << endl;

    return 0;

}
// Slower C++ solution:
#include <iostream>



int main(void){

    int n, ans=0;

    std::cin >> n;



    for (int i=0; i<50001; ++i){

        if (i * 108 / 100 == n){

            ans = i;

        }

    }



    if (ans == 0){

        std::cout << ":(" << std::endl;

    } else {

        std::cout << ans << std::endl;

    }



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.1014822439779974x):
#include <iostream>



int main(void){

    int n, ans=0;

    std::cin >> n;



    for (int i=0; i<50001; ++i){

        if (i * 108 / 100 == n){

            ans = i;

            break;

        }

    }



    if (ans == 0){

        std::cout << ":(" << std::endl;

    } else {

        std::cout << ans << std::endl;

    }



    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



#define ll long long

#define endl "\n"



ll n, m;

vector <ll> vis(200006,0);

vector <ll> ad[200006];



void add(ll x, ll y){

    ad[x].push_back(y);

    ad[y].push_back(x);

}



void dfs(ll node){

    vis[node]=1;

    for(ll x:ad[node]){

        if(!vis[x])

            dfs(x);

    }

}



void solve(){

    ll d, s, t;

    cin >> d >> t >> s;

    if(d<=t*s){

        cout << "Yes" << endl;

        return;

    }

    cout << "No" << endl;

    

}



int main(){

    ll t;

   // cin >> t;

    t=1;

    while(t--)

        solve();

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 8.207494506541874x):
#include <bits/stdc++.h>

using namespace std;



#define ll long long

#define endl "\n"



void solve() {

  ll d, t, s;

  cin >> d >> t >> s;

  if (d <= t * s) {

    cout << "Yes\n";

    return;

  }

  cout << "No\n";

}



int main() {

  ll t;

  // cin >> t;

  t = 1;

  while (t--)

    solve();

  return 0;

}
// Slower C++ solution:
#include <cstdio>



const int MOD = 998244353;

const int INV2 = (MOD + 1) >> 1;



int add(int x, int y) {return (x + y >= MOD ? x + y - MOD : x + y);}

int sub(int x, int y) {return (x - y < 0 ? x - y + MOD : x - y);}

int mul(int x, int y) {return 1LL*x*y%MOD;}



int pow_mod(int b, int p) {

	int ret = 1;

	for(int i=p;i;i>>=1,b=mul(b,b))

		if( i & 1 ) ret = mul(ret,b);

	return ret;

}



struct node{

	int k, b;

	node() : k(0), b(0) {}

	node(int _k, int _b) : k(_k), b(_b) {}

	int get(int x) {return add(mul(k, x), b);}

	friend node operator + (node a, node b) {

		return node(add(a.k, b.k), add(a.b, b.b));

	}

	friend node operator - (node a, node b) {

		return node(sub(a.k, b.k), sub(a.b, b.b));

	}

	friend node operator * (node a, int k) {

		return node(mul(a.k, k), mul(a.b, k));

	}

	friend node operator / (node a, int k) {

		return a * pow_mod(k, MOD - 2);

	}

};



void fwt(node *A, int m, int type) {

	int n = (1 << m), f = (type == 1 ? 1 : INV2);

	for(int i=1;i<=m;i++) {

		int s = (1 << i), t = (s >> 1);

		for(int j=0;j<n;j+=s)

			for(int k=0;k<t;k++) {

				node x = A[j+k], y = A[j+k+t];

				A[j+k] = (x + y)*f, A[j+k+t] = (x - y)*f;

			}

	}

}



node A[1<<18], B[1<<18], C[1<<18], f[1<<18];



int main() {

	int N, M, S = 0; scanf("%d", &N), M = (1 << N);

	for(int i=0;i<M;i++) scanf("%d", &A[i].b), S = add(S, A[i].b);

	S = pow_mod(S, MOD - 2);

	for(int i=0;i<M;i++) A[i].b = sub(i == 0 ? 1 : 0, mul(A[i].b, S));

	for(int i=0;i<M;i++) B[i].b = 1;

	C[0].b = MOD - 1;

	fwt(A, N, 1), fwt(B, N, 1), fwt(C, N, 1);

	int tmp = mul(B[0].b, pow_mod(C[0].b, MOD-2));

	for(int i=1;i<M;i++)

		f[i] = (B[i] - C[i]*tmp) / A[i].b;

	f[0].k = 1; fwt(f, N, -1);

	int x = sub(0, mul(pow_mod(f[0].k, MOD-2), f[0].b));

	for(int i=0;i<M;i++) printf("%d\n", f[i].get(x));

}

// Faster C++ solution for the same problem (measured speedup: 9.048307631215648x):
#include<bits/stdc++.h>

#define maxn 300005

using namespace std;

const int mod = 998244353;

int n,N,p[maxn],E[maxn];

int Pow(int a,int b){int s=1;for(;b;b>>=1,a=1ll*a*a%mod) b&1&&(s=1ll*s*a%mod); return s;}

int upd(int x){return x+(x>>31&mod);}

void FWT(int *a,int len,int flg){

	for(int i=2,l=1,v;i<=len;l=i,i<<=1)

		for(int j=0;j<len;j+=i)

			for(int k=j;k<j+l;k++)

				v=a[k],a[k]=upd(v+a[k+l]-mod),a[k+l]=upd(v-a[k+l]);

	if(flg^1) for(int i=0,Inv=Pow(len,mod-2);i<len;i++) a[i]=1ll*a[i]*Inv%mod;

}

int main()

{

	scanf("%d",&n),N=1<<n; int s=0;

	for(int i=0;i<N;i++) scanf("%d",&p[i]),s=upd(s+p[i]-mod);

	s=Pow(s,mod-2);

	for(int i=0;i<N;i++) p[i]=1ll*p[i]*s%mod;

	FWT(p,N,1);

	for(int i=1;i<N;i++) E[i]=1ll*N*Pow(upd(p[i]-1),mod-2)%mod;

	FWT(E,N,-1);

	int x=mod-E[0];

	for(int i=0;i<N;i++) printf("%d\n",upd(E[i]+x-mod));

}
// Slower C++ solution:
#include <cstdio>



const int MOD = 998244353;

const int INV2 = (MOD + 1) >> 1;



int add(int x, int y) {return (x + y >= MOD ? x + y - MOD : x + y);}

int sub(int x, int y) {return (x - y < 0 ? x - y + MOD : x - y);}

int mul(int x, int y) {return 1LL*x*y%MOD;}



int pow_mod(int b, int p) {

	int ret = 1;

	for(int i=p;i;i>>=1,b=mul(b,b))

		if( i & 1 ) ret = mul(ret,b);

	return ret;

}



struct node{

	int k, b;

	node() : k(0), b(0) {}

	node(int _k, int _b) : k(_k), b(_b) {}

	int get(int x) {return add(mul(k, x), b);}

	friend node operator + (node a, node b) {

		return node(add(a.k, b.k), add(a.b, b.b));

	}

	friend node operator - (node a, node b) {

		return node(sub(a.k, b.k), sub(a.b, b.b));

	}

	friend node operator * (node a, int k) {

		return node(mul(a.k, k), mul(a.b, k));

	}

	friend node operator / (node a, int k) {

		return a * pow_mod(k, MOD - 2);

	}

};



void fwt(node *A, int m, int type) {

	int n = (1 << m), f = (type == 1 ? 1 : INV2);

	for(int i=1;i<=m;i++) {

		int s = (1 << i), t = (s >> 1);

		for(int j=0;j<n;j+=s)

			for(int k=0;k<t;k++) {

				node x = A[j+k], y = A[j+k+t];

				A[j+k] = (x + y)*f, A[j+k+t] = (x - y)*f;

			}

	}

}



node A[1<<18], B[1<<18], C[1<<18], f[1<<18];



int main() {

	int N, M, S = 0; scanf("%d", &N), M = (1 << N);

	for(int i=0;i<M;i++) scanf("%d", &A[i].b), S = add(S, A[i].b);

	S = pow_mod(S, MOD - 2);

	for(int i=0;i<M;i++) A[i].b = sub(i == 0 ? 1 : 0, mul(A[i].b, S));

	for(int i=0;i<M;i++) B[i].b = 1;

	C[0].b = MOD - 1;

	fwt(A, N, 1), fwt(B, N, 1), fwt(C, N, 1);

	int tmp = mul(B[0].b, pow_mod(C[0].b, MOD-2));

	for(int i=1;i<M;i++)

		f[i] = (B[i] - C[i]*tmp) / A[i].b;

	f[0].k = 1; fwt(f, N, -1);

	int x = sub(0, mul(pow_mod(f[0].k, MOD-2), f[0].b));

	for(int i=0;i<M;i++) printf("%d\n", f[i].get(x));

}

// Faster C++ solution for the same problem (measured speedup: 45.285332652654475x):
#include<cstdio>

#include<cstring>

#define retrun return

#define cpnst const

typedef long long ll;

cpnst ll mod=998244353,inv2=(mod+1)>>1;

ll qpow(ll x,ll k)

{ll r=1;for(;k;k>>=1,(x*=x)%=mod)if(k&1)(r*=x)%=mod;return r;}

ll N,A[1111111];

void FWT(ll*x,int op)

{

	for(register int i=1,ii,iii;i<N;i<<=1)

		for(ii=0;ii<N;ii+=(i<<1))

			for(iii=0;iii<i;iii++)

			{

				int px=ii+iii,py=px+i;

				ll vx=x[px]+x[py],vy=x[px]-x[py]+mod;

				if(op<0)vx*=inv2,vy*=inv2;

				x[px]=vx%mod,x[py]=vy%mod;

			}

}

ll C[1111111];

int main()

{

	scanf("%lld",&N),N=1<<N;

	register int i;

	ll S=0;

	for(i=0;i<N;i++)

		scanf("%lld",A+i),S+=A[i];

	S=qpow(S,mod-2);

	for(i=0;i<N;i++)(A[i]*=S)%=mod; 

	C[0]=N-1,A[0]=(mod-1+A[0])%mod;

	for(i=1;i<N;i++)C[i]=mod-1;

	FWT(C,1),FWT(A,1);

	for(i=0;i<N;i++)C[i]=qpow(A[i],mod-2)*C[i]%mod;

	FWT(C,-1);

	for(i=0;i<N;i++)printf("%lld\n",(C[i]-C[0]+mod)%mod);

}

/*

Just go for it.

*/
// Slower C++ solution:
#include <iostream>

#include <cstdio>

#define ll long long

using namespace std;

inline int read()

{

	int x = 0, f = 1; char ch = getchar();

	while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}

	while(ch >= '0' && ch <= '9') {x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar();}

	return x * f;

}

const int N = 1e6 + 1000,mod = 998244353;

ll n,sum,A[N],S[N];

ll ksm(ll x,ll y)

{

	ll res = 1; 

	for(;y;y >>= 1,x = x * x % mod) 

		if(y & 1) res = res * x % mod; 

	return res;

}

void Xor(ll *f,ll opt)

{

	ll a,b;

	for(int len = 2,mid = 1;len <= n;len <<= 1,mid <<= 1)

		for(int i = 0;i < n;i += len)

			for(int j = 0;j < mid;j ++)

			{

				a = f[i + j]; b = f[i + j + mid];

				f[i + j] = (a + b) % mod * opt % mod;

				f[i + j + mid] = (a - b) % mod * opt % mod;

			}

	for(int i = 0;i < n;i ++) f[i] = (f[i] + mod) % mod;

}

int main()

{

	n = read(); n = (1 << n);

	for(int i = 0;i < n;i ++) sum = sum + (A[i] = read());

	sum = ksm(sum,mod - 2); 

	for(int i = 0;i < n;i ++) A[i] = A[i] * sum % mod;

	A[0] --; if(A[0] < 0) A[0] += mod; 

	S[0] = n - 1; for(int i = 1;i < n;i ++) S[i] = mod - 1;

	Xor(S,1); Xor(A,1);

	for(int i = 0;i < n;i ++) A[i] = ksm(A[i],mod - 2) * S[i] % mod;

	Xor(A,(mod + 1) >> 1);

	ll x = mod - A[0];

	for(int i = 0;i < n;i ++) cout << ((x + A[i]) % mod + mod) % mod << "\n";

}

// Faster C++ solution for the same problem (measured speedup: 5.001392336943704x):
#include<cstdio>

#include<cstring>

#define retrun return

#define cpnst const

typedef long long ll;

cpnst ll mod=998244353,inv2=(mod+1)>>1;

ll qpow(ll x,ll k)

{ll r=1;for(;k;k>>=1,(x*=x)%=mod)if(k&1)(r*=x)%=mod;return r;}

ll N,A[1111111];

void FWT(ll*x,int op)

{

	for(register int i=1,ii,iii;i<N;i<<=1)

		for(ii=0;ii<N;ii+=(i<<1))

			for(iii=0;iii<i;iii++)

			{

				int px=ii+iii,py=px+i;

				ll vx=x[px]+x[py],vy=x[px]-x[py]+mod;

				if(op<0)vx*=inv2,vy*=inv2;

				x[px]=vx%mod,x[py]=vy%mod;

			}

}

ll C[1111111];

int main()

{

	scanf("%lld",&N),N=1<<N;

	register int i;

	ll S=0;

	for(i=0;i<N;i++)

		scanf("%lld",A+i),S+=A[i];

	S=qpow(S,mod-2);

	for(i=0;i<N;i++)(A[i]*=S)%=mod; 

	C[0]=N-1,A[0]=(mod-1+A[0])%mod;

	for(i=1;i<N;i++)C[i]=mod-1;

	FWT(C,1),FWT(A,1);

	for(i=0;i<N;i++)C[i]=qpow(A[i],mod-2)*C[i]%mod;

	FWT(C,-1);

	for(i=0;i<N;i++)printf("%lld\n",(C[i]-C[0]+mod)%mod);

}

/*

Just go for it.

*/
// Slower C++ solution:
#include <cstdio>

#include <cstring>

#include <iostream>

#include <algorithm>

using namespace std;

#define ll long long

#define mod 998244353

#define inv2 499122177

void Read(int &p)

{

	p = 0;

	char c = getchar();

	for (; c < '0' || c > '9'; c = getchar());

	for (; c >= '0' && c <= '9'; c = getchar())p = p * 10 + c - '0';

}

int Add(int a, int b)

{

	int c = a + b;

	if (c >= mod)

		c -= mod;

	return c;

}

int Sub(int a, int b)

{

	int c = a - b;

	if (c < 0)

		c += mod;

	return c;

}

int Pow(int a, int k)

{

	if (!k)

		return 1;

	int p = Pow(a, k / 2);

	if (k & 1)

		return (ll)p * p % mod * a % mod;

	return (ll)p * p % mod;

}

int A[1 << 18], B[1 << 18], C[1 << 18], D[1 << 18];

int n, s;

void FWT(int *A, int w)

{

	if (w == 1)

		return;

	FWT(A, w >> 1);

	FWT(A + (w >> 1), w >> 1);

	for (int i = 0; i < (w >> 1); i++)

	{

		int x = A[i], y = A[i + (w >> 1)];

		A[i] = Add(x, y);

		A[i + (w >> 1)] = Sub(x, y);

	}

}

void IFWT(int *A, int w)

{

	if (w == 1)

		return;

	IFWT(A, w >> 1);

	IFWT(A + (w >> 1), w >> 1);

	for (int i = 0; i < (w >> 1); i++)

	{

		int x = A[i], y = A[i + (w >> 1)];

		A[i] = (ll)Add(x, y) * inv2 % mod;

		A[i + (w >> 1)] = (ll)Sub(x, y) * inv2 % mod;

	}

}

int main()

{

	Read(n);

	for (int i = 0; i < (1 << n); i++)

		Read(D[i]), s = Add(s, D[i]);

	s = Pow(s, mod - 2);

	for (int i = 0; i < (1 << n); i++)

		A[i] = D[i] = (ll)D[i] * s % mod;

	B[0] = (1 << n) - 1;

	for (int i = 1; i < (1 << n); i++)

		B[i] = mod - 1;

	A[0] = Sub(A[0], 1);

	FWT(A, 1 << n);

	FWT(B, 1 << n);

	int x = 0, p = 0;

	for (int i = 0; i < (1 << n); i++)

	{

		if (A[i] == 0)

			x = i;

		C[i] = (ll)Pow(A[i], mod - 2) * B[i] % mod;

	}

	IFWT(C, 1 << n);

	p = (ll)Sub(0, C[0]) * (1 << n) % mod;

	FWT(C, 1 << n);

	C[x] = p;

	IFWT(C, 1 << n);

	for (int i = 0; i < (1 << n); i++)

		printf("%d\n", C[i]);

}


// Faster C++ solution for the same problem (measured speedup: 4.9973467267978595x):
#include<cstdio>

#include<cstring>

#define retrun return

#define cpnst const

typedef long long ll;

cpnst ll mod=998244353,inv2=(mod+1)>>1;

ll qpow(ll x,ll k)

{ll r=1;for(;k;k>>=1,(x*=x)%=mod)if(k&1)(r*=x)%=mod;return r;}

ll N,A[1111111];

void FWT(ll*x,int op)

{

	for(register int i=1,ii,iii;i<N;i<<=1)

		for(ii=0;ii<N;ii+=(i<<1))

			for(iii=0;iii<i;iii++)

			{

				int px=ii+iii,py=px+i;

				ll vx=x[px]+x[py],vy=x[px]-x[py]+mod;

				if(op<0)vx*=inv2,vy*=inv2;

				x[px]=vx%mod,x[py]=vy%mod;

			}

}

ll C[1111111];

int main()

{

	scanf("%lld",&N),N=1<<N;

	register int i;

	ll S=0;

	for(i=0;i<N;i++)

		scanf("%lld",A+i),S+=A[i];

	S=qpow(S,mod-2);

	for(i=0;i<N;i++)(A[i]*=S)%=mod; 

	C[0]=N-1,A[0]=(mod-1+A[0])%mod;

	for(i=1;i<N;i++)C[i]=mod-1;

	FWT(C,1),FWT(A,1);

	for(i=0;i<N;i++)C[i]=qpow(A[i],mod-2)*C[i]%mod;

	FWT(C,-1);

	for(i=0;i<N;i++)printf("%lld\n",(C[i]-C[0]+mod)%mod);

}

/*

Just go for it.

*/
// Slower C++ solution:
#include<bits/stdc++.h>

#define maxn 300005

using namespace std;

const int mod = 998244353;

int n,N,p[maxn],E[maxn];

int Pow(int a,int b){int s=1;for(;b;b>>=1,a=1ll*a*a%mod) b&1&&(s=1ll*s*a%mod); return s;}

int upd(int x){return x+(x>>31&mod);}

void FWT(int *a,int len,int flg){

	for(int i=2,l=1,v;i<=len;l=i,i<<=1)

		for(int j=0;j<len;j+=i)

			for(int k=j;k<j+l;k++)

				v=a[k],a[k]=upd(v+a[k+l]-mod),a[k+l]=upd(v-a[k+l]);

	if(flg^1) for(int i=0,Inv=Pow(len,mod-2);i<len;i++) a[i]=1ll*a[i]*Inv%mod;

}

int main()

{

	scanf("%d",&n),N=1<<n; int s=0;

	for(int i=0;i<N;i++) scanf("%d",&p[i]),s=upd(s+p[i]-mod);

	s=Pow(s,mod-2);

	for(int i=0;i<N;i++) p[i]=1ll*p[i]*s%mod;

	FWT(p,N,1);

	for(int i=1;i<N;i++) E[i]=1ll*N*Pow(upd(p[i]-1),mod-2)%mod;

	FWT(E,N,-1);

	int x=mod-E[0];

	for(int i=0;i<N;i++) printf("%d\n",upd(E[i]+x-mod));

}

// Faster C++ solution for the same problem (measured speedup: 5.004840075996659x):
#include<cstdio>

#include<cstring>

#define retrun return

#define cpnst const

typedef long long ll;

cpnst ll mod=998244353,inv2=(mod+1)>>1;

ll qpow(ll x,ll k)

{ll r=1;for(;k;k>>=1,(x*=x)%=mod)if(k&1)(r*=x)%=mod;return r;}

ll N,A[1111111];

void FWT(ll*x,int op)

{

	for(register int i=1,ii,iii;i<N;i<<=1)

		for(ii=0;ii<N;ii+=(i<<1))

			for(iii=0;iii<i;iii++)

			{

				int px=ii+iii,py=px+i;

				ll vx=x[px]+x[py],vy=x[px]-x[py]+mod;

				if(op<0)vx*=inv2,vy*=inv2;

				x[px]=vx%mod,x[py]=vy%mod;

			}

}

ll C[1111111];

int main()

{

	scanf("%lld",&N),N=1<<N;

	register int i;

	ll S=0;

	for(i=0;i<N;i++)

		scanf("%lld",A+i),S+=A[i];

	S=qpow(S,mod-2);

	for(i=0;i<N;i++)(A[i]*=S)%=mod; 

	C[0]=N-1,A[0]=(mod-1+A[0])%mod;

	for(i=1;i<N;i++)C[i]=mod-1;

	FWT(C,1),FWT(A,1);

	for(i=0;i<N;i++)C[i]=qpow(A[i],mod-2)*C[i]%mod;

	FWT(C,-1);

	for(i=0;i<N;i++)printf("%lld\n",(C[i]-C[0]+mod)%mod);

}

/*

Just go for it.

*/
// Slower C++ solution:
#include <cstdio>



const int MOD = 998244353;

const int INV2 = (MOD + 1) >> 1;



int add(int x, int y) {return (x + y >= MOD ? x + y - MOD : x + y);}

int sub(int x, int y) {return (x - y < 0 ? x - y + MOD : x - y);}

int mul(int x, int y) {return 1LL*x*y%MOD;}



int pow_mod(int b, int p) {

	int ret = 1;

	for(int i=p;i;i>>=1,b=mul(b,b))

		if( i & 1 ) ret = mul(ret,b);

	return ret;

}



struct node{

	int k, b;

	node() : k(0), b(0) {}

	node(int _k, int _b) : k(_k), b(_b) {}

	int get(int x) {return add(mul(k, x), b);}

	friend node operator + (node a, node b) {

		return node(add(a.k, b.k), add(a.b, b.b));

	}

	friend node operator - (node a, node b) {

		return node(sub(a.k, b.k), sub(a.b, b.b));

	}

	friend node operator * (node a, int k) {

		return node(mul(a.k, k), mul(a.b, k));

	}

	friend node operator / (node a, int k) {

		return a * pow_mod(k, MOD - 2);

	}

};



void fwt(node *A, int m, int type) {

	int n = (1 << m), f = (type == 1 ? 1 : INV2);

	for(int i=1;i<=m;i++) {

		int s = (1 << i), t = (s >> 1);

		for(int j=0;j<n;j+=s)

			for(int k=0;k<t;k++) {

				node x = A[j+k], y = A[j+k+t];

				A[j+k] = (x + y)*f, A[j+k+t] = (x - y)*f;

			}

	}

}



node A[1<<18], B[1<<18], C[1<<18], f[1<<18];



int main() {

	int N, M, S = 0; scanf("%d", &N), M = (1 << N);

	for(int i=0;i<M;i++) scanf("%d", &A[i].b), S = add(S, A[i].b);

	S = pow_mod(S, MOD - 2);

	for(int i=0;i<M;i++) A[i].b = sub(i == 0 ? 1 : 0, mul(A[i].b, S));

	for(int i=0;i<M;i++) B[i].b = 1;

	C[0].b = MOD - 1;

	fwt(A, N, 1), fwt(B, N, 1), fwt(C, N, 1);

	int tmp = mul(B[0].b, pow_mod(C[0].b, MOD-2));

	for(int i=1;i<M;i++)

		f[i] = (B[i] - C[i]*tmp) / A[i].b;

	f[0].k = 1; fwt(f, N, -1);

	int x = sub(0, mul(pow_mod(f[0].k, MOD-2), f[0].b));

	for(int i=0;i<M;i++) printf("%d\n", f[i].get(x));

}

// Faster C++ solution for the same problem (measured speedup: 9.078495245882005x):
#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<vector>

#include<iostream>

#include<map>

#include<string>



#define maxn 3000005

#define MOD 998244353

#define inv2 499122177



using namespace std;



inline int getint()

{

	int num=0,flag=1;char c;

	while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;

	while(c>='0'&&c<='9')num=num*10+c-48,c=getchar();

	return num*flag;

}



int n,N;

int E[maxn],P[maxn],I[maxn];



inline int ksm(int num,int k)

{

	int ret=1;

	for(;k;k>>=1,num=1ll*num*num%MOD)if(k&1)ret=1ll*ret*num%MOD;

	return ret;

}

inline void FWT_xor(int *a,int opt,int N)

{

	for(int i=1;i<N;i<<=1)for(int j=0;j<N;j+=(i<<1))

		for(int k=0;k<i;k++)

		{

			int x=a[j+k],y=a[i+j+k];

			a[j+k]=(x+y)%MOD,a[i+j+k]=(x-y+MOD)%MOD;

			if(!~opt)a[j+k]=1ll*a[j+k]*inv2%MOD,a[i+j+k]=1ll*a[i+j+k]*inv2%MOD;

		}

}



int main()

{

	n=getint(),N=1<<n;int s=0;

	for(int i=0;i<N;i++)s+=P[i]=getint(),s%=MOD;

	s=ksm(s,MOD-2);

	for(int i=0;i<N;i++)P[i]=1ll*P[i]*s%MOD;P[0]--;

	I[0]=N-1,s=0;

	for(int i=1;i<N;i++)I[i]=MOD-1;

	FWT_xor(P,1,N),FWT_xor(I,1,N);

	for(int i=1;i<N;i++)E[i]=1ll*I[i]*ksm(P[i],MOD-2)%MOD,s=(s+E[i])%MOD;

	E[0]=MOD-s;

	FWT_xor(E,-1,N);

	for(int i=0;i<N;i++)printf("%d\n",E[i]);

}
// Slower C++ solution:
#include <cstdio>



const int MOD = 998244353;

const int INV2 = (MOD + 1) >> 1;



int add(int x, int y) {return (x + y >= MOD ? x + y - MOD : x + y);}

int sub(int x, int y) {return (x - y < 0 ? x - y + MOD : x - y);}

int mul(int x, int y) {return 1LL*x*y%MOD;}



int pow_mod(int b, int p) {

	int ret = 1;

	for(int i=p;i;i>>=1,b=mul(b,b))

		if( i & 1 ) ret = mul(ret,b);

	return ret;

}



struct node{

	int k, b;

	node() : k(0), b(0) {}

	node(int _k, int _b) : k(_k), b(_b) {}

	int get(int x) {return add(mul(k, x), b);}

	friend node operator + (node a, node b) {

		return node(add(a.k, b.k), add(a.b, b.b));

	}

	friend node operator - (node a, node b) {

		return node(sub(a.k, b.k), sub(a.b, b.b));

	}

	friend node operator * (node a, int k) {

		return node(mul(a.k, k), mul(a.b, k));

	}

	friend node operator / (node a, int k) {

		return a * pow_mod(k, MOD - 2);

	}

};



void fwt(node *A, int m, int type) {

	int n = (1 << m), f = (type == 1 ? 1 : INV2);

	for(int i=1;i<=m;i++) {

		int s = (1 << i), t = (s >> 1);

		for(int j=0;j<n;j+=s)

			for(int k=0;k<t;k++) {

				node x = A[j+k], y = A[j+k+t];

				A[j+k] = (x + y)*f, A[j+k+t] = (x - y)*f;

			}

	}

}



node A[1<<18], B[1<<18], C[1<<18], f[1<<18];



int main() {

	int N, M, S = 0; scanf("%d", &N), M = (1 << N);

	for(int i=0;i<M;i++) scanf("%d", &A[i].b), S = add(S, A[i].b);

	S = pow_mod(S, MOD - 2);

	for(int i=0;i<M;i++) A[i].b = sub(i == 0 ? 1 : 0, mul(A[i].b, S));

	for(int i=0;i<M;i++) B[i].b = 1;

	C[0].b = MOD - 1;

	fwt(A, N, 1), fwt(B, N, 1), fwt(C, N, 1);

	int tmp = mul(B[0].b, pow_mod(C[0].b, MOD-2));

	for(int i=1;i<M;i++)

		f[i] = (B[i] - C[i]*tmp) / A[i].b;

	f[0].k = 1; fwt(f, N, -1);

	int x = sub(0, mul(pow_mod(f[0].k, MOD-2), f[0].b));

	for(int i=0;i<M;i++) printf("%d\n", f[i].get(x));

}

// Faster C++ solution for the same problem (measured speedup: 9.01266291208088x):
#include<bits/stdc++.h>

using namespace std;

const int mod=998244353;

const int inv2=(mod+1)/2;

inline int qpow(int d,int z,int t=0,int a=1){

	for(;z;z>>=1,d=1ll*d*d%(mod-t))

		if(z&1) a=1ll*a*d%(mod-t); return a;

}

const int N=20;



int n,s,a[1<<N],b[1<<N];

inline void fwt(int *a){

	for(int i=0;i<(1<<n);++i) if(a[i]<0) a[i]+=mod;

	for(int i=0;i<n;++i){

		for(int len=1<<i,j=0;j<(1<<n);j+=2*len){

			for(int p=0;p<len;++p){

				int x=a[j+p],y=a[j+len+p];

				a[j+p]=(x+y)%mod;

				a[j+p+len]=(x-y+mod)%mod;

			}

		}

	}

}

inline void ifwt(int *a){

	for(int i=0;i<n;++i){

		for(int len=1<<i,j=0;j<(1<<n);j+=2*len){

			for(int p=0;p<len;++p){

				int x=a[j+p],y=a[j+len+p];

				a[j+p]=1ll*inv2*(x+y)%mod;

				a[j+p+len]=1ll*inv2*(x-y+mod)%mod;

			}

		}

	}

}



int main(){

	scanf("%d",&n); b[0]=1<<n;

	for(int i=0;i<(1<<n);++i) --b[i],scanf("%d",&a[i]),s+=a[i];

	for(int i=0;i<(1<<n);++i) a[i]=1ll*a[i]*qpow(s,mod-2)%mod;

	--a[0]; fwt(a); fwt(b);

	for(int i=1;i<(1<<n);++i) a[i]=1ll*b[i]*qpow(a[i],mod-2)%mod;

	a[0]=0; ifwt(a);

	int x=mod-a[0];

	for(int i=0;i<(1<<n);++i) printf("%d\n",(a[i]+x)%mod);

	return 0;

}