use proconio::input; fn main() { input! { x:usize, k:usize, } if 10 < k { return; } let p = ModInt::::new(100).pow(2 * k * (MOD - 2)); let mut ans = ModInt::new(0); for i in 0..1 << (2 * k) { let mut stack = vec![]; let mut valid = true; let mut dep = 0; let mut q = ModInt::new(1); for j in 0..2 * k { if i & (1 << j) != 0 { if stack.is_empty() { valid = false; break; } stack.pop(); q *= ModInt::new(100 - x); } else { stack.push('('); dep = dep.max(stack.len()); q *= ModInt::new(x); } } if !stack.is_empty() { valid = false; } if valid { ans += ModInt::new(dep) * q * p; } } println!("{}", ans); } const MOD: usize = 998244353; use modint::*; mod modint { use std::fmt; use std::ops; #[derive(Copy, Clone, PartialEq, Eq)] pub struct ModInt { pub val: usize, } impl ModInt { pub fn new(val: usize) -> Self { Self { val: val % MOD } } pub fn pow(mut self, mut e: usize) -> Self { let mut res = Self::new(1); while 0 < e { if e & 1 != 0 { res *= self; } self *= self; e >>= 1; } res } } impl From for ModInt { fn from(value: usize) -> Self { Self { val: value % MOD } } } impl fmt::Display for ModInt { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.val) } } impl fmt::Debug for ModInt { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.val) } } impl ops::Neg for ModInt { type Output = Self; fn neg(self) -> Self::Output { Self { val: (MOD - self.val) % MOD, } } } impl ops::Add for ModInt { type Output = Self; fn add(self, rhs: Self) -> Self::Output { Self { val: (self.val + rhs.val) % MOD, } } } impl ops::AddAssign for ModInt { fn add_assign(&mut self, rhs: Self) { *self = *self + rhs; } } impl ops::Mul for ModInt { type Output = Self; fn mul(self, rhs: Self) -> Self::Output { Self { val: self.val * rhs.val % MOD, } } } impl ops::MulAssign for ModInt { fn mul_assign(&mut self, rhs: Self) { *self = *self * rhs; } } impl ops::Sub for ModInt { type Output = Self; fn sub(mut self, rhs: Self) -> Self::Output { if self.val < rhs.val { self.val += MOD; } Self { val: (self.val - rhs.val) % MOD, } } } impl ops::SubAssign for ModInt { fn sub_assign(&mut self, rhs: Self) { if self.val < rhs.val { self.val += MOD; } *self = *self - rhs; } } impl ops::Div for ModInt { type Output = Self; fn div(self, rhs: Self) -> Self { assert!(rhs.val != 0); self * rhs.pow(MOD - 2) } } impl ops::DivAssign for ModInt { fn div_assign(&mut self, rhs: Self) { *self = *self / rhs } } }