// -*- coding:utf-8-unix -*- // #![feature(map_first_last)] #![allow(dead_code)] #![allow(unused_imports)] #![allow(unused_macros)] use std::cmp::*; use std::collections::*; use std::fmt::*; use std::hash::*; use std::io::BufRead; use std::iter::FromIterator; use std::*; const INF: i64 = 1223372036854775807; const UINF: usize = INF as usize; const LINF: i64 = 2147483647; const INF128: i128 = 1223372036854775807000000000000; const MOD1: i64 = 1000000007; const MOD9: i64 = 998244353; const MOD: i64 = MOD9; const UMOD: usize = MOD as usize; const M_PI: f64 = 3.14159265358979323846; macro_rules! p { ($x:expr) => { //if expr println!("{}", $x); }; } macro_rules! vp { // vector print separate with space ($x:expr) => { println!( "{}", $x.iter() .map(|x| x.to_string()) .collect::>() .join(" ") ); }; } macro_rules! d { ($x:expr) => { eprintln!("{:?}", $x); }; } macro_rules! yn { ($val:expr) => { if $val { println!("Yes"); } else { println!("No"); } }; } macro_rules! map{ // declear btreemap ($($key:expr => $val:expr),*) => { { let mut map = ::std::collections::BTreeMap::new(); $( map.insert($key, $val); )* map } }; } macro_rules! set{ // declear btreemap ($($key:expr),*) => { { let mut set = ::std::collections::BTreeSet::new(); $( set.insert($key); )* set } }; } //input output #[allow(dead_code)] fn read() -> T { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().parse().ok().unwrap() } #[allow(dead_code)] fn read_vec() -> Vec { read::() .split_whitespace() .map(|e| e.parse().ok().unwrap()) .collect() } #[allow(dead_code)] fn read_mat(n: u32) -> Vec> { (0..n).map(|_| read_vec()).collect() } #[allow(dead_code)] fn readii() -> (i64, i64) { let mut vec: Vec = read_vec(); (vec[0], vec[1]) } #[allow(dead_code)] fn readiii() -> (i64, i64, i64) { let mut vec: Vec = read_vec(); (vec[0], vec[1], vec[2]) } #[allow(dead_code)] fn readuu() -> (usize, usize) { let mut vec: Vec = read_vec(); (vec[0], vec[1]) } fn readuuu() -> (usize, usize, usize) { let mut vec: Vec = read_vec(); (vec[0], vec[1], vec[2]) } // Computes a^e UMOD UMOD by binary exponentiation. fn UMOD_pow(mut a: usize, mut e: usize) -> usize { let mut result = 1; a %= UMOD; while e > 0 { if e & 1 == 1 { result = result * a % UMOD; } a = a * a % UMOD; e >>= 1; } result } fn main() { let n = read::(); let mut fac = vec![1; n + 1]; for i in 1..=n { fac[i] = fac[i - 1] * i % UMOD; } let mut inv = vec![1; n + 1]; inv[n] = UMOD_pow(fac[n], UMOD - 2); for i in (1..=n).rev() { inv[i - 1] = inv[i] * i % UMOD; } let comb = |n: usize, k: usize| -> usize { if k > n { 0 } else { fac[n] * (inv[k] * inv[n - k] % UMOD) % UMOD } }; let mut out = Vec::with_capacity(n + 1); for k in 0..=n { let bk = if k == 0 { if n % 2 == 0 { comb(n, n / 2) } else { 0 } } else { if (k + n) % 2 == 0 { let j = (k + n) / 2; (2 * comb(n, j)) % UMOD } else { 0 } }; out.push(bk); } for (i, v) in out.iter().enumerate() { if i > 0 { print!(" "); } print!("{}", v); } println!(); }