結果

問題 No.2303 Frog on Grid
ユーザー 37kt37kt
提出日時 2023-07-11 08:07:51
言語 Rust
(1.83.0 + proconio)
結果
CE  
(最新)
AC  
(最初)
実行時間 -
コード長 61,403 bytes
コンパイル時間 14,162 ms
コンパイル使用メモリ 401,972 KB
最終ジャッジ日時 2024-09-13 00:02:06
合計ジャッジ時間 14,957 ms
ジャッジサーバーID
(参考情報)
judge1 / judge4
このコードへのチャレンジ
(要ログイン)
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。(リジャッジ後のコンパイルエラーは公開されます)
ただし、clay言語の場合は開発者のデバッグのため、公開されます。

コンパイルメッセージ
error[E0659]: `proconio` is ambiguous
 --> src/main.rs:6:5
  |
6 | use proconio::{
  |     ^^^^^^^^ ambiguous name
  |
  = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
  = note: `proconio` could refer to a crate passed with `--extern`
  = help: use `::proconio` to refer to this crate unambiguously
note: `proconio` could also refer to the module imported here
 --> src/main.rs:1:9
  |
1 | pub use __cargo_equip::prelude::*;
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^
  = help: consider adding an explicit import of `proconio` to disambiguate
  = help: or use `crate::proconio` to refer to this module unambiguously

For more information about this error, try `rustc --explain E0659`.
error: could not compile `main` (bin "main") due to 1 previous error

ソースコード

diff #
プレゼンテーションモードにする

pub use __cargo_equip::prelude::*;
use combination::Combination;
use formal_power_series::fps;
#[allow(unused_imports)]
use proconio::{
input,
marker::{Bytes, Chars, Usize1},
};
use modint::ModInt998244353 as Mint;
fn main() {
input! {
h: usize,
w: usize,
}
let mut f = fps![0; h + 1];
let mut g = fps![0; w + 1];
let comb = Combination::<Mint>::new();
for i in (h + 1) / 2..=h {
f[i] = comb.nck(i, h - i) * comb.fact_inv(i);
}
for i in (w + 1) / 2..=w {
g[i] = comb.nck(i, w - i) * comb.fact_inv(i);
}
let mut h = f * g;
for i in 0..h.len() {
h[i] *= comb.fact(i);
}
println!("{}", h.eval(1.into()));
}
// The following code was expanded by `cargo-equip`.
/// # Bundled libraries
///
/// - `combination 0.1.0 (path+██████████████████████████████████████████████████████████████)` published in **missing**
    licensed under `CC0-1.0` as `crate::__cargo_equip::crates::combination`
/// - `convolution-arbitrary-mod 0.1.0 (path+██████████████████████████████████████████████████████████████████████████)` published in **missing**
    licensed under `CC0-1.0` as `crate::__cargo_equip::crates::__convolution_arbitrary_mod_0_1_0`
/// - `convolution-naive 0.1.0 (path+██████████████████████████████████████████████████████████████████)` published in **missing**
    licensed under `CC0-1.0` as `crate::__cargo_equip::crates::__convolution_naive_0_1_0`
/// - `convolution-ntt-friendly 0.1.0 (path+█████████████████████████████████████████████████████████████████████████)` published in **missing**
    licensed under `CC0-1.0` as `crate::__cargo_equip::crates::__convolution_ntt_friendly_0_1_0`
/// - `formal-power-series 0.1.0 (path+███████████████████████████████████████████████████████████████████)` published in **missing**
    licensed under `CC0-1.0` as `crate::__cargo_equip::crates::formal_power_series`
/// - `lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)`
    licensed under `MIT/Apache-2.0` as `crate::__cargo_equip::crates::__lazy_static_1_4_0`
/// - `modint 0.1.0 (path+█████████████████████████████████████████████████████████)` published in **missing**
    licensed under `CC0-1.0` as `crate::__cargo_equip::crates::modint`
/// - `proconio 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)`
    licensed under `MIT OR Apache-2.0` as `crate::__cargo_equip::crates::proconio`
///
/// # License and Copyright Notices
///
/// - `lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)`
///
/// ```text
/// Copyright (c) 2010 The Rust Project Developers
///
/// Permission is hereby granted, free of charge, to any
/// person obtaining a copy of this software and associated
/// documentation files (the "Software"), to deal in the
/// Software without restriction, including without
/// limitation the rights to use, copy, modify, merge,
/// publish, distribute, sublicense, and/or sell copies of
/// the Software, and to permit persons to whom the Software
/// is furnished to do so, subject to the following
/// conditions:
///
/// The above copyright notice and this permission notice
/// shall be included in all copies or substantial portions
/// of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
/// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
/// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
/// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
/// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
/// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
/// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
/// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
/// DEALINGS IN THE SOFTWARE.
/// ```
///
/// - `proconio 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)`
///
/// ```text
/// The MIT License
/// Copyright 2019 (C) statiolake <statiolake@gmail.com>
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy of
/// this software and associated documentation files (the "Software"), to deal in
/// the Software without restriction, including without limitation the rights to
/// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
/// the Software, and to permit persons to whom the Software is furnished to do so,
/// subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in all
/// copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
/// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
/// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
/// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
/// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
///
/// Copyright for original `input!` macro is held by Hideyuki Tanaka, 2019. The
/// original macro is licensed under BSD 3-clause license.
///
/// Redistribution and use in source and binary forms, with or without
/// modification, are permitted provided that the following conditions are met:
///
/// 1. Redistributions of source code must retain the above copyright notice, this
/// list of conditions and the following disclaimer.
///
/// 2. Redistributions in binary form must reproduce the above copyright notice,
/// this list of conditions and the following disclaimer in the documentation
/// and/or other materials provided with the distribution.
///
/// 3. Neither the name of the copyright holder nor the names of its contributors
/// may be used to endorse or promote products derived from this software
/// without specific prior written permission.
///
/// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
/// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
/// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
/// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
/// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
/// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
/// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
/// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
/// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
/// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/// ```
#[cfg_attr(any(), rustfmt::skip)]
#[allow(unused)]
mod __cargo_equip {
pub(crate) mod crates {
pub mod combination {use crate::__cargo_equip::preludes::combination::*;use std::cell::RefCell;use modint::ModInt;pub struct Combination<M
            :ModInt>{inv:RefCell<Vec<M>>,fact:RefCell<Vec<M>>,fact_inv:RefCell<Vec<M>>,}impl<M:ModInt>Combination<M>{pub fn new()->Self{Self{inv
            :RefCell::new(vec![M::from(0),M::from(1)]),fact:RefCell::new(vec![M::from(1);2]),fact_inv:RefCell::new(vec![M::from(1);2]),}}fn expand
            (&self,n:usize){let mut inv=self.inv.borrow_mut();let mut fact=self.fact.borrow_mut();let mut fact_inv=self.fact_inv.borrow_mut();let m
            =inv.len();let mut nn=m;while nn<=n{nn*=2;}inv.resize(nn,M::default());fact.resize(nn,M::default());fact_inv.resize(nn,M::default());let
            p=M::modulus()as usize;for i in m..nn{inv[i]=-inv[p%i]*M::from((p/i)as u32);fact[i]=fact[i-1]*M::from(i);fact_inv[i]=fact_inv[i-1]*inv[i]
            ;}}pub fn inv(&self,n:usize)->M{self.expand(n);self.inv.borrow()[n]}pub fn fact(&self,n:usize)->M{self.expand(n);self.fact.borrow
            ()[n]}pub fn fact_inv(&self,n:usize)->M{self.expand(n);self.fact_inv.borrow()[n]}pub fn nck(&self,n:usize,k:usize)->M{if n<k{M::from(0
            )}else{self.expand(n);self.fact.borrow()[n]*self.fact_inv.borrow()[k]*self.fact_inv.borrow()[n-k]}}pub fn npk(&self,n:usize,k:usize
            )->M{if n<k{M::from(0)}else{self.expand(n);self.fact.borrow()[n]*self.fact_inv.borrow()[n-k]}}pub fn nhk(&self,n:usize,k:usize)->M{if n
            ==0&&k==0{M::from(1)}else{self.nck(n+k-1,k)}}pub fn catalan(&self,n:usize)->M{self.expand(n*2);self.fact.borrow()[n*2]*self.fact_inv
            .borrow()[n+1]*self.fact_inv.borrow()[n]}}}
pub mod __convolution_arbitrary_mod_0_1_0 {use crate::__cargo_equip::preludes::__convolution_arbitrary_mod_0_1_0::*;use convolution_naive
            ::convolution_naive;use convolution_ntt_friendly::convolution_ntt_friendly;use modint::{ModInt,StaticModInt};const M1:u32=167_772_161
            ;const M2:u32=469_762_049;const M3:u32=754_974_721;type Fp1=StaticModInt<M1>;type Fp2=StaticModInt<M2>;type Fp3=StaticModInt<M3>;pub fn
            convolution_arbitrary_mod<T:ModInt>(a:&[T],b:&[T])->Vec<T>{if a.len().min(b.len())<60{return convolution_naive(a,b);}let a1=a.iter().map
            (|&x|Fp1::new(x.val())).collect::<Vec<_>>();let a2=a.iter().map(|&x|Fp2::new(x.val())).collect::<Vec<_>>();let a3=a.iter().map(|&x|Fp3
            ::new(x.val())).collect::<Vec<_>>();let b1=b.iter().map(|&x|Fp1::new(x.val())).collect::<Vec<_>>();let b2=b.iter().map(|&x|Fp2::new(x.val
            ())).collect::<Vec<_>>();let b3=b.iter().map(|&x|Fp3::new(x.val())).collect::<Vec<_>>();let a1=convolution_ntt_friendly(a1,b1);let a2
            =convolution_ntt_friendly(a2,b2);let a3=convolution_ntt_friendly(a3,b3);a1.iter().zip(a2.iter()).zip(a3.iter()).map(|((&e1,&e2),&e3)|{let
            x1=e1;let x2=(e2-Fp2::new(x1.val()))*Fp2::new(Fp1::modulus()).inv();let x3=((e3-Fp3::new(x1.val()))*Fp3::new(Fp1::modulus()).inv()-Fp3
            ::new(x2.val()))*Fp3::new(Fp2::modulus()).inv();T::from(x1.val())+T::from(x2.val())*T::from(Fp1::modulus())+T::from(x3.val())*T::from(Fp1
            ::modulus())*T::from(Fp2::modulus())}).collect()}}
pub mod __convolution_naive_0_1_0 {use crate::__cargo_equip::preludes::__convolution_naive_0_1_0::*;use modint::ModInt;pub fn
            convolution_naive<T:ModInt>(a:&[T],b:&[T])->Vec<T>{let n=a.len();let m=b.len();if n==0||m==0{return vec![];}let l=n+m-1;let mut c=vec![0
            .into();l];for i in 0..n{for j in 0..m{c[i+j]+=a[i]*b[j];}}c}}
pub mod __convolution_ntt_friendly_0_1_0 {use crate::__cargo_equip::preludes::__convolution_ntt_friendly_0_1_0::*;use convolution_naive
            ::convolution_naive;use modint::StaticModInt;pub fn ntt<const P:u32>(a:&mut[StaticModInt<P>]){assert!(StaticModInt::<P>::IS_NTT_FRIENDLY
            );let n=a.len();assert_eq!(n.count_ones(),1);let h=n.trailing_zeros()as usize;let mut len=0;while len<h{if h-len==1{let p=1<<h-len-1;let
            mut rot=StaticModInt::raw(1);for s in 0..1<<len{let offset=s<<h-len;for i in 0..p{let l=a[i+offset];let r=a[i+offset+p]*rot;a[i+offset]=l
            +r;a[i+offset+p]=l-r;}if s+1!=1<<len{rot*=StaticModInt::raw(StaticModInt::<P>::RATE2[(!s).trailing_zeros()as usize]);}}len+=1;}else{let p
            =1<<h-len-2;let mut rot=StaticModInt::<P>::raw(1);let imag=StaticModInt::<P>::raw(StaticModInt::<P>::ROOT[2]);for s in 0..1<<len{let rot2
            =rot*rot;let rot3=rot2*rot;let offset=s<<h-len;for i in 0..p{let mod2=(StaticModInt::<P>::modulus()as u64).pow(2);let a0=a[i+offset].val
            ()as u64;let a1=a[i+offset+p].val()as u64*rot.val()as u64;let a2=a[i+offset+p*2].val()as u64*rot2.val()as u64;let a3=a[i+offset+p*3].val
            ()as u64*rot3.val()as u64;let a1na3imag=StaticModInt::<P>::from(a1+mod2-a3).val()as u64*imag.val()as u64;let na2=mod2-a2;a[i+offset]
            =StaticModInt::from(a0+a2+a1+a3);a[i+offset+p]=StaticModInt::from(a0+a2+(mod2*2-(a1+a3)));a[i+offset+p*2]=StaticModInt::from(a0+na2
            +a1na3imag);a[i+offset+p*3]=StaticModInt::from(a0+na2+mod2-a1na3imag);}if s+1!=1<<len{rot*=StaticModInt::raw(StaticModInt::<P>::RATE3[(!s
            ).trailing_zeros()as usize]);}}len+=2;}}}pub fn ntt_inv<const P:u32>(a:&mut[StaticModInt<P>]){assert!(StaticModInt::<P>::IS_NTT_FRIENDLY
            );let n=a.len();assert_eq!(n.count_ones(),1);let h=n.trailing_zeros()as usize;let mut len=h;while len>0{if len==1{let p=1<<h-len;let mut
            irot=StaticModInt::<P>::raw(1);for s in 0..1<<len-1{let offset=s<<h-len+1;for i in 0..p{let l=a[i+offset];let r=a[i+offset+p];a[i+offset]
            =l+r;a[i+offset+p]=StaticModInt::<P>::from((StaticModInt::<P>::modulus()+l.val()-r.val())as u64*irot.val()as u64,);}if s+1!=1<<len-1{irot
            *=StaticModInt::<P>::raw(StaticModInt::<P>::IRATE2[(!s).trailing_zeros()as usize],);}}len-=1;}else{let p=1<<h-len;let mut irot
            =StaticModInt::<P>::raw(1);let iimag=StaticModInt::<P>::raw(StaticModInt::<P>::IROOT[2]);for s in 0..1<<len-2{let irot2=irot*irot;let
            irot3=irot2*irot;let offset=s<<h-len+2;for i in 0..p{let a0=a[i+offset].val()as u64;let a1=a[i+offset+p].val()as u64;let a2=a[i+offset+p
            *2].val()as u64;let a3=a[i+offset+p*3].val()as u64;let a2na3iimag=StaticModInt::<P>::from((StaticModInt::<P>::modulus()as u64+a2-a3
            )*iimag.val()as u64,).val()as u64;a[i+offset]=StaticModInt::<P>::from(a0+a1+a2+a3);a[i+offset+p]=StaticModInt::<P>::from((a0
            +(StaticModInt::<P>::modulus()as u64-a1)+a2na3iimag)*irot.val()as u64,);a[i+offset+p*2]=StaticModInt::<P>::from((a0+a1+(StaticModInt::<P
            >::modulus()as u64-a2)+(StaticModInt::<P>::modulus()as u64-a3))*irot2.val()as u64,);a[i+offset+p*3]=StaticModInt::<P>::from((a0
            +(StaticModInt::<P>::modulus()as u64-a1)+(StaticModInt::<P>::modulus()as u64-a2na3iimag))*irot3.val()as u64,);}if s+1!=1<<len-2{irot
            *=StaticModInt::<P>::raw(StaticModInt::<P>::IRATE3[(!s).trailing_zeros()as usize],);}}len-=2;}}let inv_n=StaticModInt::<P>::new(n).inv
            ();for x in a.iter_mut(){*x*=inv_n;}}pub fn ntt_doubling<const P:u32>(a:&mut Vec<StaticModInt<P>>){let n=a.len();a.append(&mut a.clone
            ());ntt_inv(&mut a[n..]);let mut r=StaticModInt::new(1);let zeta=StaticModInt::new(StaticModInt::<P>::G).pow((P-1)as usize/(n<<1));for i
            in n..n*2{a[i]*=r;r*=zeta;}ntt(&mut a[n..]);}pub fn convolution_ntt_friendly<const P:u32>(mut a:Vec<StaticModInt<P>>,mut b:Vec
            <StaticModInt<P>>,)->Vec<StaticModInt<P>>{let n=a.len();let m=b.len();if n==0||m==0{return vec![];}else if n.min(m)<=60{return
            convolution_naive(&a,&b);}let len=n+m-1;let z=1<<64-(len-1).leading_zeros();a.resize(z,0.into());b.resize(z,0.into());ntt(&mut a);ntt
            (&mut b);for i in 0..z{a[i]*=b[i];}ntt_inv(&mut a);a.truncate(len);a}}
pub mod formal_power_series {use crate::__cargo_equip::preludes::formal_power_series::*;pub use crate::__cargo_equip::macros
            ::formal_power_series::*;use convolution_arbitrary_mod::convolution_arbitrary_mod;use convolution_ntt_friendly::{convolution_ntt_friendly
            ,ntt,ntt_inv};use modint::StaticModInt;use std::{fmt::{Debug,Display},iter::repeat,mem::swap,ops::{Add,AddAssign,Deref,DerefMut,Div
            ,DivAssign,Mul,MulAssign,Neg,Rem,RemAssign,Shl,ShlAssign,Shr,ShrAssign,Sub,SubAssign,},};#[derive(Default,Clone,PartialEq,Eq)]#[repr
            (transparent)]pub struct FormalPowerSeries<const P:u32>(pub Vec<StaticModInt<P>>);#[derive(Default,Clone,PartialEq,Eq)]#[repr(transparent
            )]pub struct SparseFormalPowerSeries<const P:u32>(pub Vec<(usize,StaticModInt<P>)>);pub type FormalPowerSeries998244353=FormalPowerSeries
            <998_244_353>;pub type FormalPowerSeries1000000007=FormalPowerSeries<1_000_000_007>;pub type SparseFormalPowerSeries998244353
            =SparseFormalPowerSeries<998_244_353>;pub type SparseFormalPowerSeries1000000007=SparseFormalPowerSeries<1_000_000_007
            >;#[macro_export]macro_rules!__cargo_equip_macro_def_formal_power_series_fps{($($x:expr),*)=>($crate::__cargo_equip::crates
            ::formal_power_series::FormalPowerSeries(vec![$(modint::StaticModInt::from($x)),*]));($x:expr;$n:expr)=>($crate::__cargo_equip::crates
            ::formal_power_series::FormalPowerSeries(vec![modint::StaticModInt::from($x);$n]));}macro_rules!fps{($($tt:tt)*)=>(crate
            ::__cargo_equip_macro_def_formal_power_series_fps!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def_formal_power_series_sfps{
            ($(($d:expr,$x:expr)),*)=>($crate::__cargo_equip::crates::formal_power_series::SparseFormalPowerSeries(vec![$(($d,modint::StaticModInt
            ::from($x))),*]));}macro_rules!sfps{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_formal_power_series_sfps!{$($tt)*})}impl<const P:u32
            >FormalPowerSeries<P>{pub fn shrink(&mut self){while self.last()==Some(&0.into()){self.pop();}}pub fn pre(mut self,d:usize)->Self{self
            .truncate(d);self}pub fn eval(&self,x:StaticModInt<P>)->StaticModInt<P>{let mut r=0.into();let mut w=StaticModInt::new(1);for&v in&self
            .0{r+=w*v;w*=x;}r}pub fn differential(&self)->Self{Self(self.iter().enumerate().skip(1).map(|(i,v)|v*i).collect(),)}pub fn integral(&self
            )->Self{let n=self.len();let mut res=fps![0;n+1];if n>0{res[1]=1.into();}let m=StaticModInt::<P>::modulus()as usize;for i in 2..=n{res[i]
            =-res[m%i]*(m/i);}for i in 0..n{res[i+1]*=self[i];}res}pub fn inv(&self,d:usize)->Self{assert_ne!(self[0].val(),0);if StaticModInt::<P
            >::IS_NTT_FRIENDLY{let mut res=fps![0;d];res[0]=self[0].inv();for k in 0..{let k=1<<k;if k>=d{break;}let mut f=Self(self.iter().take(k*2
            ).map(|&x|x).collect());f.resize(k*2,0.into());let mut g=Self(res.iter().take(k).map(|&x|x).collect());g.resize(k*2,0.into());ntt(&mut f
            );ntt(&mut g);for(a,b)in f.iter_mut().zip(g.iter()){*a*=b;}ntt_inv(&mut f);for a in f.iter_mut().take(k){*a=0.into();}ntt(&mut f);for(a,b
            )in f.iter_mut().zip(g.iter()){*a*=b;}ntt_inv(&mut f);for(a,b)in res.iter_mut().zip(f.iter()).skip(k){*a=-b;}}res.truncate(d
            );res}else{let mut res=fps![self[0].inv()];for k in 0..{if k>=d{break;}let k=1<<k;res=(&res+&res-&res*&res*res.pre(k*2)).pre(k*2);}res
            .truncate(d);res}}pub fn log(&self,d:usize)->Self{assert!(self[0].val()==1);(self.differential()*self.inv(d)).pre(d-1).integral()}pub fn
            exp(&self,d:usize)->Self{assert!(self.len()==0||self[0].val()==0);if StaticModInt::<P>::IS_NTT_FRIENDLY{let mut b=fps![1,if self.len
            ()>1{self[1]}else{0.into()}];let mut c=fps![1];let mut z1;let mut z2=fps![1,1];for m in 1..{let m=1<<m;if m>=d{break;}let mut y=b.clone
            ();y.resize(m*2,0.into());ntt(&mut y);z1=z2;let mut z=Self((0..m).map(|i|y[i]*z1[i]).collect());ntt_inv(&mut z);for v in z.iter_mut
            ().take(m/2){*v=0.into();}ntt(&mut z);for i in 0..m{z[i]*=-z1[i];}ntt_inv(&mut z);c.append(&mut z.drain(m/2..).collect());z2=c.clone();z2
            .resize(m*2,0.into());ntt(&mut z2);let mut x:Self=self.clone().pre(m);x.resize(m,0.into());x=x.differential();x.push(0.into());ntt(&mut x
            );for i in 0..m{x[i]*=y[i];}ntt_inv(&mut x);x-=b.differential();x.resize(m*2,0.into());for i in 0..m-1{x[m+i]=x[i];x[i]=0.into();}ntt
            (&mut x);for i in 0..m*2{x[i]*=z2[i];}ntt_inv(&mut x);x.pop();x=x.integral();for i in m..self.len().min(m*2){x[i]+=self[i];}for v in x
            .iter_mut().take(m){*v=0.into();}ntt(&mut x);for i in 0..m*2{x[i]*=y[i];}ntt_inv(&mut x);b.append(&mut x.drain(m..).collect());}b.pre(d
            )}else{let mut res=fps![1];for i in 0..{let i=1<<i;if i>=d{break;}let mut t=self.clone().pre(i<<1);t[0]+=1;t-=res.log(i<<1);res=(res*t
            ).pre(i<<1);}res.pre(d)}}pub fn pow(&self,k:usize,d:usize)->FormalPowerSeries<P>{let n=self.len();if k==0{let mut res=fps![0;d];if d
            >0{res[0]=1.into();}return res;}for i in 0..n{if self[i].val()!=0{let c=self[i].inv();let mut res=(((self*c)>>i).log(d)*StaticModInt::new
            (k)).exp(d);res*=self[i].pow(k);res=(res<<i*k).pre(d);if res.len()<d{res.resize(d,0.into());}return res;}if i+1>=d/k{return fps![0;d]
            ;}}fps![0;d]}pub fn sqrt(&self,d:usize)->Option<FormalPowerSeries<P>>{if self.len()==0{return Some(fps![0;d]);}if self[0].val()==0{if let
            Some(i)=self.iter().position(|&x|x.val()!=0){if i&1!=0{return None;}else if d<=i/2{return Some(fps![0;d]);}let mut res=(self>>i).sqrt(d-i
            /2)?;res<<=i/2;if res.len()<d{res.resize(d,0.into());}return Some(res);}return Some(fps![0;d]);}let r=self[0].sqrt()?;assert_eq!(r*r
            ,self[0]);let mut res=fps![r];let inv2=StaticModInt::new(2).inv();for i in 0..{let i=1<<i;if i>=d{break;}res=(&res+self.clone().pre(i<<1
            )*res.inv(i<<1))*inv2;}Some(res.pre(d))}pub fn multipoint_evaluate(&self,xs:&[StaticModInt<P>])->Vec<StaticModInt<P>>{let m=xs.len();if m
            ==0{return vec![];}let m2=1<<64-(m-1).leading_zeros();let mut g=vec![fps![1];m2+m2];for i in 0..m{g[m2+i]=fps![-xs[i],1];}for i in(1..m2
            ).rev(){g[i]=&g[i<<1|0]*&g[i<<1|1];}g[1]=self%&g[1];for i in 2..m2+m{g[i]=&g[i>>1]%&g[i];}(m2..m2+m).map(|i|if g[i].len()==0{0.into
            ()}else{g[i][0]}).collect()}pub fn taylor_shift(mut self,c:StaticModInt<P>)->Self{if self.len()==0{return self;}let n=self.len();let mut
            fact=vec![StaticModInt::new(1);n];let mut inv=vec![StaticModInt::new(1);n];let mut fact_inv=vec![StaticModInt::new(1);n];for i in 1
            ..n{fact[i]=fact[i-1]*i;}fact_inv[n-1]=fact[n-1].inv();for i in(1..n).rev(){inv[i]=fact_inv[i]*fact[i-1];fact_inv[i-1]=fact_inv[i]*i;}for
            i in 0..n{self[i]*=fact[i];}self.reverse();let mut g=fps![1;n];for i in 1..n{g[i]=g[i-1]*c*inv[i];}self=(self*g).pre(n);self.reverse
            ();for i in 0..n{self[i]*=fact_inv[i];}self}}impl<const P:u32>SparseFormalPowerSeries<P>{pub fn normalize(&mut self){if self.len
            ()==0{return;}self.0.sort_by_key(|&(i,_)|i);let mut res=Self(vec![(self[0].0,StaticModInt::new(0))]);for&(i,v)in&self.0{if res.len
            ()==0||res.last().unwrap().0!=i{res.push((i,v));}else{res.last_mut().unwrap().1+=v;}}if res.len()!=0&&res.last().unwrap().1.val()==0{res
            .pop();}*self=res;}pub fn differential(&self)->Self{Self(self.iter().filter_map(|&(i,v)|(i>0).then(||(i-1,v*i))).collect(),)}pub fn
            integral(&self)->Self{Self(self.iter().map(|&(i,v)|(i+1,v/(i+1))).collect())}pub fn inv(self,d:usize)->FormalPowerSeries<P>{let mut f
            =fps![0;d];f[0]+=1;f/=self;f}pub fn log(self,d:usize)->FormalPowerSeries<P>{assert!(self[0].0==0&&self[0].1.val()==1);let f=self
            .differential();let mut res=(self.inv(d)*f).pre(d-1).integral();res.resize(d,0.into());res}pub fn exp(&self,d:usize)->FormalPowerSeries<P
            >{if self.len()==0{let mut res=fps![0;d];if d>0{res[0]=1.into();}return res;}assert_ne!(self[0].0,0);let mut res=fps![0;d];if d==0{return
            res;}let mut a=self.differential();for(d,_)in a.iter_mut(){*d+=1;}res[0]=1.into();let mut inv=vec![StaticModInt::<P>::new(1);d];let m
            =StaticModInt::<P>::modulus()as usize;for i in 1..d{if i>1{inv[i]=-inv[m%i]*(m/i);}res[i]=a.iter().filter_map(|&(j,v)|(i>=j).then(||v
            *res[i-j])).sum::<StaticModInt<P>>()*inv[i];}res}pub fn pow(&self,k:usize,d:usize)->FormalPowerSeries<P>{let offset=self.iter().position
            (|&(_,v)|v.val()!=0);let mut res=fps![0;d];if offset.is_none(){if k==0{res[0]+=1;}return res;}let offset=offset.unwrap();if self[offset]
            .0>0{let deg=self[offset].0;if k>(d-1)/deg{return res;}let g=Self(self.iter().filter_map(|&(i,v)|(i>=deg).then(||(i-deg,v))).collect
            (),);let t=g.pow(k,d-k*deg);for i in 0..d-k*deg{res[k*deg+i]=t[i];}return res;}let mut inv=vec![StaticModInt::<P>::new(1);d+1];let m=P as
            usize;for i in 2..=d{inv[i]=-inv[m%i]*(m/i);}res[0]=self[0].1.pow(k);let c=self[0].1.inv();for i in 1..d{for&(j,v)in self.iter().skip(1
            ).filter(|&&(j,_)|i>=j){res[i]=res[i]+v*res[i-j]*(StaticModInt::<P>::new(k)*j-(i-j));}res[i]*=inv[i]*c;}res}pub fn sqrt(&self,d:usize
            )->Option<FormalPowerSeries<P>>{if self.len()==0{return Some(fps![0;d]);}let p=self[0].0;if p&1!=0{return None;}else if p/2>=d{return
            Some(fps![0;d]);}let inv_f0=self[0].1.inv();let lz=p/2;let mut g=fps![0;d];g[lz]=self[0].1.sqrt()?;let k=StaticModInt::new(2).inv();let
            mut inv=vec![StaticModInt::new(1);d];let m=P as usize;for i in 2..d{inv[i]=-inv[m%i]*(m/i);}for i in 1..d-lz{g[lz+i]=self.iter().skip(1
            ).filter_map(|&(j,v)|(j-p<=i).then(||(j-p,v))).map(|(j,v)|v*g[lz+i-j]*(k*j-(i-j))).sum::<StaticModInt<P>>()*inv[i]*inv_f0;}Some(g)}}impl
            <const P:u32>Debug for FormalPowerSeries<P>{fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{f.write_fmt(format_args!("{
            :?}",&self.0))}}impl<const P:u32>Display for FormalPowerSeries<P>{fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{if self
            .len()!=0{f.write_fmt(format_args!("{}",self[0]))?;}for v in self.iter().skip(1){f.write_fmt(format_args!(" {}",v))?;}Ok(())}}impl<const
            P:u32>Debug for SparseFormalPowerSeries<P>{fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{f.write_fmt(format_args!("{:?}"
            ,&self.0))}}impl<const P:u32>Deref for FormalPowerSeries<P>{type Target=Vec<StaticModInt<P>>;fn deref(&self)->&Self::Target{&self.0}}impl
            <const P:u32>Deref for SparseFormalPowerSeries<P>{type Target=Vec<(usize,StaticModInt<P>)>;fn deref(&self)->&Self::Target{&self.0}}impl
            <const P:u32>DerefMut for FormalPowerSeries<P>{fn deref_mut(&mut self)->&mut Self::Target{&mut self.0}}impl<const P:u32>DerefMut for
            SparseFormalPowerSeries<P>{fn deref_mut(&mut self)->&mut Self::Target{&mut self.0}}impl<const P:u32>From<Vec<StaticModInt<P>>>for
            FormalPowerSeries<P>{fn from(v:Vec<StaticModInt<P>>)->Self{Self(v)}}impl<const P:u32>From<Vec<(usize,StaticModInt<P>)>>for
            SparseFormalPowerSeries<P>{fn from(v:Vec<(usize,StaticModInt<P>)>)->Self{Self(v)}}impl<const P:u32>From<SparseFormalPowerSeries<P>>for
            FormalPowerSeries<P>{fn from(f:SparseFormalPowerSeries<P>)->Self{if f.len()==0{return fps![];}let mut g=FormalPowerSeries(vec![0.into();f
            .last().unwrap().0+1]);for(i,v)in f.0{g[i]+=v;}g}}impl<const P:u32>From<FormalPowerSeries<P>>for SparseFormalPowerSeries<P>{fn from(f
            :FormalPowerSeries<P>)->Self{Self(f.0.into_iter().enumerate().collect())}}impl<const P:u32>Neg for FormalPowerSeries<P>{type Output=Self
            ;fn neg(mut self)->Self::Output{for v in self.iter_mut(){*v=-*v;}self}}impl<const P:u32>Neg for SparseFormalPowerSeries<P>{type Output
            =Self;fn neg(mut self)->Self::Output{for(_,v)in self.iter_mut(){*v=-*v;}self}}impl<const P:u32>Neg for&FormalPowerSeries<P>{type Output
            =FormalPowerSeries<P>;fn neg(self)->Self::Output{-self.clone()}}impl<const P:u32>Neg for&SparseFormalPowerSeries<P>{type Output
            =SparseFormalPowerSeries<P>;fn neg(self)->Self::Output{-self.clone()}}impl<const P:u32>MulAssign<StaticModInt<P>>for FormalPowerSeries<P
            >{fn mul_assign(&mut self,rhs:StaticModInt<P>){for v in self.iter_mut(){*v*=rhs;}}}impl<const P:u32>MulAssign<StaticModInt<P>>for
            SparseFormalPowerSeries<P>{fn mul_assign(&mut self,rhs:StaticModInt<P>){for(_,v)in self.iter_mut(){*v*=rhs;}}}impl<const P:u32>DivAssign
            <StaticModInt<P>>for FormalPowerSeries<P>{fn div_assign(&mut self,rhs:StaticModInt<P>){*self*=rhs.inv();}}impl<const P:u32>DivAssign
            <StaticModInt<P>>for SparseFormalPowerSeries<P>{fn div_assign(&mut self,rhs:StaticModInt<P>){*self*=rhs.inv();}}impl<const P:u32
            >AddAssign<Self>for FormalPowerSeries<P>{fn add_assign(&mut self,rhs:Self){if self.len()<rhs.len(){self.resize(rhs.len(),0.into());}self
            .iter_mut().zip(rhs.iter()).for_each(|(a,b)|*a+=b);}}impl<const P:u32>AddAssign<Self>for SparseFormalPowerSeries<P>{fn add_assign(&mut
            self,rhs:Self){let mut res=sfps![];let n=self.len();let m=rhs.len();let mut i=0;let mut j=0;while i<n&&j<m{if j==m{res.push(self[i]);i+=1
            ;}else if i==n{res.push(rhs[j]);j+=1;}else if self[i].0==rhs[j].0{res.push((self[i].0,self[i].1+rhs[j].1));i+=1;j+=1;}else if self[i].0
            <rhs[j].0{res.push(self[i]);i+=1;}else{res.push(rhs[j]);j+=1;}}*self=res;}}impl<const P:u32>AddAssign<SparseFormalPowerSeries<P>>for
            FormalPowerSeries<P>{fn add_assign(&mut self,rhs:SparseFormalPowerSeries<P>){if rhs.len()==0{return;}let m=rhs.last().unwrap().0+1;if
            self.len()<m{self.resize(m,0.into());}for(i,v)in rhs.0{self[i]+=v;}}}impl<const P:u32>SubAssign<Self>for FormalPowerSeries<P>{fn
            sub_assign(&mut self,rhs:Self){if self.len()<rhs.len(){self.resize(rhs.len(),0.into());}self.iter_mut().zip(rhs.iter()).for_each(|(a,b)|
            *a-=b);}}impl<const P:u32>SubAssign<Self>for SparseFormalPowerSeries<P>{fn sub_assign(&mut self,rhs:Self){*self+=-rhs;}}impl<const P:u32
            >SubAssign<SparseFormalPowerSeries<P>>for FormalPowerSeries<P>{fn sub_assign(&mut self,rhs:SparseFormalPowerSeries<P>){*self+=-rhs;}}impl
            <const P:u32>MulAssign<Self>for FormalPowerSeries<P>{fn mul_assign(&mut self,rhs:Self){if StaticModInt::<P>::IS_NTT_FRIENDLY{let mut a
            =vec![];swap(&mut a,&mut self.0);self.0=convolution_ntt_friendly(a,rhs.0);}else{self.0=convolution_arbitrary_mod(&self.0,&rhs.0);}}}impl
            <const P:u32>MulAssign<Self>for SparseFormalPowerSeries<P>{fn mul_assign(&mut self,rhs:Self){self.0=self.0.drain(..).map(|(i,x)|rhs.iter
            ().map(move|(j,y)|(i+j,x*y))).flatten().collect::<Vec<_>>();self.normalize();}}impl<const P:u32>MulAssign<SparseFormalPowerSeries<P>>for
            FormalPowerSeries<P>{fn mul_assign(&mut self,rhs:SparseFormalPowerSeries<P>){if self.len()==0||rhs.len()==0{self.clear();return;}let n
            =self.len();self.resize(n+rhs.last().unwrap().0,0.into());let c=if rhs[0].0==0{rhs[0].1}else{0.into()};for i in(0..n).rev(){for&(j,v)in
            rhs.iter().rev(){if j==0{continue;}self[i+j]=self[i+j]+self[i]*v;}self[i]*=c;}}}impl<const P:u32>DivAssign<Self>for FormalPowerSeries<P
            >{fn div_assign(&mut self,mut g:Self){if self.len()<g.len(){self.clear();return;}let n=self.len()+1-g.len();if g.len()<=64{let mut f
            =FormalPowerSeries(vec![]);swap(&mut f.0,&mut self.0);g.shrink();let coef=g.last().unwrap().inv();for x in g.iter_mut(){*x*=coef;}let d=f
            .len()+1-g.len();let m=g.len();let mut quo=FormalPowerSeries(vec![StaticModInt::new(0);d]);for i in(0..d).rev(){quo[i]=f[i+m-1];for j in
            0..m{f[i+j]-=quo[i]*g[j];}}*self=quo*coef;self.resize(n,0.into());}else{self.reverse();self.truncate(n);g.reverse();*self*=g.inv(n);self
            .truncate(n);self.reverse();}}}impl<const P:u32>DivAssign<SparseFormalPowerSeries<P>>for FormalPowerSeries<P>{fn div_assign(&mut self,mut
            rhs:SparseFormalPowerSeries<P>){assert_eq!(rhs[0].0,0);let c=rhs[0].1.inv();self.iter_mut().for_each(|v|*v*=c);rhs.iter_mut().for_each(|
            (_,v)|*v*=c);for i in 0..self.len(){for&(j,v)in rhs.iter().filter(|&&(j,_)|j>0&&i>=j){self[i]=self[i]-self[i-j]*v;}}}}impl<const P:u32
            >RemAssign<Self>for FormalPowerSeries<P>{fn rem_assign(&mut self,rhs:Self){*self-=self.clone()/&rhs*&rhs;self.shrink();}}impl<const P:u32
            >ShlAssign<usize>for FormalPowerSeries<P>{fn shl_assign(&mut self,rhs:usize){self.0=repeat(0.into()).take(rhs).chain(self.0.drain
            (..)).collect();}}impl<const P:u32>ShlAssign<usize>for SparseFormalPowerSeries<P>{fn shl_assign(&mut self,rhs:usize){self.iter_mut
            ().for_each(|(i,_)|*i+=rhs);}}impl<const P:u32>ShrAssign<usize>for FormalPowerSeries<P>{fn shr_assign(&mut self,rhs:usize){self.0=self.0
            .drain(rhs..).collect();}}impl<const P:u32>ShrAssign<usize>for SparseFormalPowerSeries<P>{fn shr_assign(&mut self,rhs:usize){self.0=self
            .0.drain(..).filter_map(|(i,v)|(i>=rhs).then(||(i-rhs,v))).collect();}}macro_rules!impl_ops{($($ty_l:ty,$ty_r:ty,$trait:ident
            ,$trait_assign:ident,$fn:ident,$fn_assign:ident,)*)=>{$(impl<const P:u32>$trait_assign<&$ty_r>for$ty_l{fn$fn_assign(&mut self,rhs:&$ty_r
            ){self.$fn_assign(rhs.clone());}}impl<const P:u32>$trait<$ty_r>for$ty_l{type Output=$ty_l;fn$fn(mut self,rhs:$ty_r)->$ty_l{self
            .$fn_assign(rhs);self}}impl<const P:u32>$trait<$ty_r>for&$ty_l{type Output=$ty_l;fn$fn(self,rhs:$ty_r)->$ty_l{let mut r=self.clone();r
            .$fn_assign(rhs);r}}impl<const P:u32>$trait<&$ty_r>for$ty_l{type Output=$ty_l;fn$fn(mut self,rhs:&$ty_r)->$ty_l{self.$fn_assign(rhs.clone
            ());self}}impl<const P:u32>$trait<&$ty_r>for&$ty_l{type Output=$ty_l;fn$fn(self,rhs:&$ty_r)->$ty_l{let mut r=self.clone();r.$fn_assign
            (rhs.clone());r}})*};}impl_ops!{FormalPowerSeries<P>,StaticModInt<P>,Mul,MulAssign,mul,mul_assign,FormalPowerSeries<P>,StaticModInt<P
            >,Div,DivAssign,div,div_assign,FormalPowerSeries<P>,FormalPowerSeries<P>,Add,AddAssign,add,add_assign,FormalPowerSeries<P
            >,FormalPowerSeries<P>,Sub,SubAssign,sub,sub_assign,FormalPowerSeries<P>,FormalPowerSeries<P>,Mul,MulAssign,mul,mul_assign
            ,FormalPowerSeries<P>,FormalPowerSeries<P>,Div,DivAssign,div,div_assign,FormalPowerSeries<P>,FormalPowerSeries<P>,Rem,RemAssign,rem
            ,rem_assign,FormalPowerSeries<P>,usize,Shl,ShlAssign,shl,shl_assign,FormalPowerSeries<P>,usize,Shr,ShrAssign,shr,shr_assign
            ,SparseFormalPowerSeries<P>,StaticModInt<P>,Mul,MulAssign,mul,mul_assign,SparseFormalPowerSeries<P>,StaticModInt<P>,Div,DivAssign,div
            ,div_assign,SparseFormalPowerSeries<P>,SparseFormalPowerSeries<P>,Add,AddAssign,add,add_assign,SparseFormalPowerSeries<P
            >,SparseFormalPowerSeries<P>,Sub,SubAssign,sub,sub_assign,SparseFormalPowerSeries<P>,SparseFormalPowerSeries<P>,Mul,MulAssign,mul
            ,mul_assign,SparseFormalPowerSeries<P>,usize,Shl,ShlAssign,shl,shl_assign,SparseFormalPowerSeries<P>,usize,Shr,ShrAssign,shr,shr_assign
            ,FormalPowerSeries<P>,SparseFormalPowerSeries<P>,Add,AddAssign,add,add_assign,FormalPowerSeries<P>,SparseFormalPowerSeries<P>,Sub
            ,SubAssign,sub,sub_assign,FormalPowerSeries<P>,SparseFormalPowerSeries<P>,Mul,MulAssign,mul,mul_assign,FormalPowerSeries<P
            >,SparseFormalPowerSeries<P>,Div,DivAssign,div,div_assign,}}<hide>
pub mod __lazy_static_1_4_0 {#![no_std]use crate::__cargo_equip::preludes::__lazy_static_1_4_0::*;pub use crate::__cargo_equip::macros
            ::__lazy_static_1_4_0::*;#[path="inline_lazy.rs"]pub mod lazy{use crate::__cargo_equip::preludes::__lazy_static_1_4_0::*;extern crate
            core;extern crate std;use self::std::prelude::v1::*;use self::std::cell::Cell;use self::std::hint::unreachable_unchecked;use self::std
            ::sync::Once;#[allow(deprecated)]pub use self::std::sync::ONCE_INIT;pub struct Lazy<T:Sync>(Cell<Option<T>>,Once);impl<T:Sync>Lazy<T
            >{#[allow(deprecated)]pub const INIT:Self=Lazy(Cell::new(None),ONCE_INIT);#[inline(always)]pub fn get<F>(&'static self,f:F)->&T where F
            :FnOnce()->T,{self.1.call_once(||{self.0.set(Some(f()));});unsafe{match*self.0.as_ptr(){Some(ref x)=>x,None=>{debug_assert!(false
            ,"attempted to derefence an uninitialized lazy static. This is a bug");unreachable_unchecked()},}}}}unsafe impl<T:Sync>Sync for Lazy<T
            >{}#[macro_export]macro_rules!__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_create{($NAME:ident,$T:ty)=>{static$NAME:$crate
            ::__cargo_equip::crates::__lazy_static_1_4_0::lazy::Lazy<$T> =$crate::__cargo_equip::crates::__lazy_static_1_4_0::lazy::Lazy::INIT;}
            ;}macro_rules!__lazy_static_create{($($tt:tt)*)=>(crate::__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_create!{$($tt)*})}}pub
            use core::ops::Deref as __Deref;#[macro_export(local_inner_macros
            )]macro_rules!__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_internal{($(#[$attr:meta])*($($vis:tt)*)static ref$N:ident:$T:ty
            =$e:expr;$($t:tt)*)=>{__lazy_static_internal!(@MAKE TY,$(#[$attr])*,($($vis)*),$N);__lazy_static_internal!(@TAIL,$N:$T=$e);lazy_static!($
            ($t)*);};(@TAIL,$N:ident:$T:ty=$e:expr)=>{impl$crate::__cargo_equip::crates::__lazy_static_1_4_0::__Deref for$N{type Target=$T;fn deref
            (&self)->&$T{#[inline(always)]fn __static_ref_initialize()->$T{$e}#[inline(always)]fn __stability()->&'static$T{__lazy_static_create!
            (LAZY,$T);LAZY.get(__static_ref_initialize)}__stability()}}impl$crate::__cargo_equip::crates::__lazy_static_1_4_0::LazyStatic for$N{fn
            initialize(lazy:&Self){let _=&**lazy;}}};(@MAKE TY,$(#[$attr:meta])*,($($vis:tt)*),$N:ident)=>{#[allow(missing_copy_implementations
            )]#[allow(non_camel_case_types)]#[allow(dead_code)]$(#[$attr])*$($vis)*struct$N{__private_field:()}#[doc(hidden)]$($vis)*static$N:$N
            =$N{__private_field:()};};()=>()}macro_rules!__lazy_static_internal{($($tt:tt)*)=>(crate
            ::__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_internal!{$($tt)*})}#[macro_export(local_inner_macros
            )]macro_rules!__cargo_equip_macro_def___lazy_static_1_4_0_lazy_static{($(#[$attr:meta])*static ref$N:ident:$T:ty=$e:expr;$($t:tt
            )*)=>{__lazy_static_internal!($(#[$attr])*()static ref$N:$T=$e;$($t)*);};($(#[$attr:meta])*pub static ref$N:ident:$T:ty=$e:expr;$($t:tt
            )*)=>{__lazy_static_internal!($(#[$attr])*(pub)static ref$N:$T=$e;$($t)*);};($(#[$attr:meta])*pub($($vis:tt)+)static ref$N:ident:$T:ty=$e
            :expr;$($t:tt)*)=>{__lazy_static_internal!($(#[$attr])*(pub($($vis)+))static ref$N:$T=$e;$($t)*);};()=>()}macro_rules!lazy_static{($($tt
            :tt)*)=>(crate::__cargo_equip_macro_def___lazy_static_1_4_0_lazy_static!{$($tt)*})}pub trait LazyStatic{fn initialize(lazy:&Self);}pub fn
            initialize<T:LazyStatic>(lazy:&T){LazyStatic::initialize(lazy);}}
pub mod modint {use std::{fmt,hash::Hash,iter::{Product,Sum},num::ParseIntError,ops::{Add,AddAssign,Div,DivAssign,Mul,MulAssign,Neg,Sub
            ,SubAssign},str::FromStr,sync::atomic::{self,AtomicU32,AtomicU64},};#[derive(Clone,Copy,Default,PartialEq,Eq,Hash)]#[repr(transparent
            )]pub struct StaticModInt<const P:u32>(u32);#[derive(Clone,Copy,Default,PartialEq,Eq,Hash)]#[repr(transparent)]pub struct DynamicModInt
            (u32);pub type ModInt998244353=StaticModInt<998_244_353>;pub type ModInt1000000007=StaticModInt<1_000_000_007>;pub trait ModInt:Default
            +FromStr+From<i8>+From<i16>+From<i32>+From<i64>+From<i128>+From<isize>+From<u8>+From<u16>+From<u32>+From<u64>+From<u128>+From<usize>+Copy
            +Eq+Hash+fmt::Display+fmt::Debug+Neg<Output=Self>+Add<Output=Self>+Sub<Output=Self>+Mul<Output=Self>+Div<Output=Self>+AddAssign+SubAssign
            +MulAssign+DivAssign{fn modulus()->u32;fn raw(val:u32)->Self;fn val(self)->u32;fn inv(self)->Self;fn pow(self,k:usize)->Self;fn sqrt(self
            )->Option<Self>;}const fn mul(x:u32,y:u32,m:u32)->u32{(x as u64*y as u64%m as u64)as u32}const fn pow(x:u32,mut n:u32,m:u32)->u32{if m
            ==1{return 0;}let mut r=1u64;let mut y=(x%m)as u64;while n!=0{if n&1!=0{r=r*y%m as u64;}y=y*y%m as u64;n>>=1;}r as u32}const fn is_prime
            (n:u32)->bool{match n{_ if n<=1=>return false,2|7|61=>return true,_ if n&1==0=>return false,_=>{}}let mut d=n-1;while d&1==0{d>>=1;}let a
            =[2,7,61];let mut i=0;while i<3{let mut t=d;let mut y=pow(a[i],t,n);while t!=n-1&&y!=1&&y!=n-1{y=(y as u64*y as u64%n as u64)as u32;t<<=1
            ;}if y!=n-1&&t&1==0{return false;}i+=1;}true}const fn extgcd(mut a:u32,b:u32)->(u32,u32){a=a%b;if a==0{return(b,0);}let mut s=b as i64
            ;let mut t=a as i64;let mut m0=0;let mut m1=1;while t!=0{let u=s/t;s-=t*u;m0-=m1*u;let tmp=s;s=t;t=tmp;let tmp=m0;m0=m1;m1=tmp;}if m0
            <0{m0+=b as i64/s;}(s as u32,m0 as u32)}const fn primitive_root(m:u32)->u32{match m{2=>return 1,167_772_161=>return 3,469_762_049=>return
            3,754_974_721=>return 11,998_244_353=>return 3,_=>{}}let mut divs=[0;20];divs[0]=2;let mut cnt=1;let mut x=(m-1)/2;while x%2==0{x/=2;}let
            mut i=3;while i<std::u32::MAX{if i as u64*i as u64>x as u64{break;}if x%i==0{divs[cnt]=i;cnt+=1;while x%i==0{x/=i;}}i+=2;}if x
            >1{divs[cnt]=x;cnt+=1;}let mut g=2;loop{let mut i=0;while i<cnt{if pow(g,(m-1)/divs[i],m)==1{break;}i+=1;}if i==cnt{break g;}g+=1;}}const
            fn ntt_info(m:u32,)->(u32,usize,[u32;30],[u32;30],[u32;30],[u32;30],[u32;30],[u32;30],){let g=primitive_root(m);let rank2=(m-1
            ).trailing_zeros()as usize;let mut root=[0;30];let mut iroot=[0;30];let mut rate2=[0;30];let mut irate2=[0;30];let mut rate3=[0;30];let
            mut irate3=[0;30];root[rank2]=pow(g,(m-1)>>rank2,m);iroot[rank2]=extgcd(root[rank2],m).1;let mut i=rank2;while i>0{i-=1;root[i]=mul
            (root[i+1],root[i+1],m);iroot[i]=mul(iroot[i+1],iroot[i+1],m);}let mut prod=1;let mut iprod=1;let mut i=0;while i+2<=rank2{rate2[i]=mul
            (root[i+2],prod,m);irate2[i]=mul(iroot[i+2],iprod,m);prod=mul(prod,iroot[i+2],m);iprod=mul(iprod,root[i+2],m);i+=1;}let mut prod=1;let
            mut iprod=1;let mut i=0;while i+3<=rank2{rate3[i]=mul(root[i+3],prod,m);irate3[i]=mul(iroot[i+3],iprod,m);prod=mul(prod,iroot[i+3],m
            );iprod=mul(iprod,root[i+3],m);i+=1;}(g,rank2,root,iroot,rate2,irate2,rate3,irate3)}fn rat_convert(x:u64,m:u64,d:u64)->Option<(u64,u64
            )>{let n=m/(2*d);if x<n&&1<d{return Some((x,1));}let mut l=(0,1);let mut r=(1,0);loop{let num=l.0+r.0;let den=l.1+r.1;let(i,q)=match(num
            *m).cmp(&(den*x)){std::cmp::Ordering::Less=>{let k=(x*l.1-m*l.0-1)/(m*r.0-x*r.1);l.0+=k*r.0;l.1+=k*r.1;l}std::cmp::Ordering::Equal
            =>return None,std::cmp::Ordering::Greater=>{let k=(m*r.0-x*r.1-1)/(x*l.1-m*l.0);r.0+=k*l.0;r.1+=k*l.1;r}};if q*x<i*m{continue;}let p=q*x
            -i*m;if p<n&&q<d{return Some((p,q));}}}impl<const P:u32>ModInt for StaticModInt<P>{#[inline(always)]fn modulus()->u32{P}#[inline]fn raw
            (val:u32)->Self{Self(val)}#[inline]fn val(self)->u32{self.0}#[inline]fn inv(self)->Self{self.inv()}fn pow(self,k:usize)->Self{self.pow(k
            )}fn sqrt(self)->Option<Self>{self.sqrt()}}impl<const P:u32>StaticModInt<P>{#[inline]pub fn new<T:Into<StaticModInt<P>>>(x:T)->Self{x
            .into()}#[inline(always)]pub fn modulus()->u32{P}#[inline]pub fn raw(val:u32)->Self{Self(val)}#[inline]pub fn val(self)->u32{self
            .0}#[inline]pub fn inv(self)->Self{assert_ne!(self.0,0);self.pow(P as usize-2)}pub fn pow(mut self,mut k:usize)->Self{let mut res=Self
            ::from(1);while k!=0{if k&1!=0{res*=self;}k>>=1;self*=self;}res}pub fn sqrt(self)->Option<Self>{let p=Self::modulus()as usize;if self.val
            ()<2{return Some(self);}else if self.pow(p-1>>1).val()!=1{return None;}let mut b=Self::from(1);while b.pow((p-1>>1)as usize).val()==1{b
            +=1;}let mut e=(p-1).trailing_zeros()as usize;let m=(p-1)>>e;let mut x=self.pow(m-1>>1);let mut y=self*x*x;x*=self;let mut z=b.pow(m
            );while y.val()!=1{let mut j=0;let mut t=y;while t.val()!=1{j+=1;t*=t;}z=z.pow(1<<e-j-1);x*=z;z*=z;y*=z;e=j;}Some(x)}}impl ModInt for
            DynamicModInt{#[inline(always)]fn modulus()->u32{BARRETT.modulus()}#[inline]fn raw(val:u32)->Self{Self(val)}#[inline]fn val(self
            )->u32{self.0}#[inline]fn inv(self)->Self{self.inv()}fn pow(self,k:usize)->Self{self.pow(k)}fn sqrt(self)->Option<Self>{self.sqrt()}}impl
            DynamicModInt{#[inline]pub fn new<T:Into<DynamicModInt>>(x:T)->Self{x.into()}#[inline(always)]pub fn modulus()->u32{BARRETT.modulus
            ()}#[inline]pub fn raw(val:u32)->Self{Self(val)}#[inline]pub fn val(self)->u32{self.0}#[inline]pub fn inv(self)->Self{let(g,x)=extgcd
            (self.0,Self::modulus());assert_eq!(g,1);Self(x)}pub fn pow(mut self,mut k:usize)->Self{let mut res=Self::from(1);while k!=0{if k&1!
            =0{res*=self;}k>>=1;self*=self;}res}pub fn sqrt(self)->Option<Self>{let p=Self::modulus()as usize;if self.val()<2{return Some(self);}else
            if self.pow(p-1>>1).val()!=1{return None;}let mut b=Self::from(1);while b.pow((p-1>>1)as usize).val()==1{b+=1;}let mut e=(p-1
            ).trailing_zeros()as usize;let m=(p-1)>>e;let mut x=self.pow(m-1>>1);let mut y=self*x*x;x*=self;let mut z=b.pow(m);while y.val()!=1{let
            mut j=0;let mut t=y;while t.val()!=1{j+=1;t*=t;}z=z.pow(1<<e-j-1);x*=z;z*=z;y*=z;e=j;}Some(x)}pub fn set_modulus(modulus:u32){BARRETT.set
            (modulus)}}struct Barrett{m:AtomicU32,im:AtomicU64,}impl Barrett{const fn new(m:u32)->Self{Self{m:AtomicU32::new(m),im:AtomicU64::new((!0
            /m as u64).wrapping_add(1)),}}#[inline]fn set(&self,m:u32){let im=(!0/m as u64).wrapping_add(1);self.m.store(m,atomic::Ordering::SeqCst
            );self.im.store(im,atomic::Ordering::SeqCst);}#[inline]fn modulus(&self)->u32{self.m.load(atomic::Ordering::SeqCst)}#[inline]fn mul(&self
            ,a:u32,b:u32)->u32{let m=self.m.load(atomic::Ordering::SeqCst);let im=self.im.load(atomic::Ordering::SeqCst);let mut z=a as u64;z*=b as
            u64;let x=(((z as u128)*(im as u128))>>64)as u64;let mut v=z.wrapping_sub(x.wrapping_mul(m as u64))as u32;if m<=v{v=v.wrapping_add(m
            );}v}}static BARRETT:Barrett=Barrett::new(998_244_353);impl<const P:u32>FromStr for StaticModInt<P>{type Err=ParseIntError;fn from_str(s
            :&str)->Result<Self,Self::Err>{s.parse::<i64>().map(Self::from)}}impl FromStr for DynamicModInt{type Err=ParseIntError;fn from_str(s:&str
            )->Result<Self,Self::Err>{s.parse::<i64>().map(Self::from)}}impl<const P:u32>fmt::Display for StaticModInt<P>{fn fmt(&self,f:&mut fmt
            ::Formatter<'_>)->fmt::Result{write!(f,"{}",self.0)}}impl fmt::Display for DynamicModInt{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt
            ::Result{write!(f,"{}",self.0)}}impl<const P:u32>fmt::Debug for StaticModInt<P>{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{if
            let Some((num,den))=rat_convert(self.0 as u64,P as u64,1025){write!(f,"{}",num)?;if den!=1{write!(f,"/{}",den)?;}}else if let Some((num
            ,den))=rat_convert((P-self.0)as u64,P as u64,1025){write!(f,"-{}",num)?;if den!=1{write!(f,"/{}",den)?;}}else{write!(f,"{}",self.0)?;}Ok
            (())}}impl fmt::Debug for DynamicModInt{fn fmt(&self,f:&mut fmt::Formatter<'_>)->fmt::Result{write!(f,"{}",self.0
            )}}macro_rules!impl_from_integer{($(($t1:ty,$t2:ty)),*)=>{$(impl<const P:u32>From<$t1>for StaticModInt<P>{fn from(x:$t1)->Self{Self((x
            as$t2).rem_euclid(P as$t2)as u32)}}impl From<$t1>for DynamicModInt{fn from(x:$t1)->Self{Self((x as$t2).rem_euclid(Self::modulus()as$t2)as
            u32)}})*};}impl_from_integer!((i8,i32),(i16,i32),(i32,i32),(i64,i64),(isize,i64),(i128,i128),(u8,u32),(u16,u32),(u32,u32),(u64,u64
            ),(usize,u64),(u128,u128));impl<const P:u32,T:Into<Self>>AddAssign<T>for StaticModInt<P>{fn add_assign(&mut self,rhs:T){self.0+=rhs.into
            ().0;if self.0>=P{self.0-=P;}}}impl<T:Into<Self>>AddAssign<T>for DynamicModInt{fn add_assign(&mut self,rhs:T){self.0+=rhs.into().0;if
            self.0>=Self::modulus(){self.0-=Self::modulus();}}}impl<const P:u32,T:Into<Self>>SubAssign<T>for StaticModInt<P>{fn sub_assign(&mut self
            ,rhs:T){let rhs=rhs.into().0;if self.0<rhs{self.0+=P;}self.0-=rhs;}}impl<T:Into<Self>>SubAssign<T>for DynamicModInt{fn sub_assign(&mut
            self,rhs:T){let rhs=rhs.into().0;if self.0<rhs{self.0+=Self::modulus();}self.0-=rhs;}}impl<const P:u32,T:Into<Self>>MulAssign<T>for
            StaticModInt<P>{fn mul_assign(&mut self,rhs:T){*self=Self((self.0 as u64*rhs.into().0 as u64%P as u64)as u32);}}impl<T:Into<Self
            >>MulAssign<T>for DynamicModInt{fn mul_assign(&mut self,rhs:T){*self=Self(BARRETT.mul(self.0,rhs.into().0));}}impl<const P:u32,T:Into
            <Self>>DivAssign<T>for StaticModInt<P>{fn div_assign(&mut self,rhs:T){*self*=rhs.into().inv()}}impl<T:Into<Self>>DivAssign<T>for
            DynamicModInt{fn div_assign(&mut self,rhs:T){*self=*self*rhs.into().inv()}}impl<const P:u32>Neg for StaticModInt<P>{type Output=Self;fn
            neg(self)->Self::Output{if self.0==0{Self(0)}else{Self(P-self.0)}}}impl Neg for DynamicModInt{type Output=Self;fn neg(self)->Self
            ::Output{if self.0==0{Self(0)}else{Self(Self::modulus()-self.0)}}}impl<const P:u32>Neg for&StaticModInt<P>{type Output=StaticModInt<P>;fn
            neg(self)->Self::Output{if self.0==0{StaticModInt(0)}else{StaticModInt(P-self.0)}}}impl Neg for&DynamicModInt{type Output=DynamicModInt
            ;fn neg(self)->Self::Output{if self.0==0{DynamicModInt(0)}else{DynamicModInt(DynamicModInt::modulus()-self.0)}}}macro_rules!impl_ops{($
            ($trait:ident,$trait_assign:ident,$fn:ident,$fn_assign:ident,)*)=>{$(impl<const P:u32>$trait_assign<&StaticModInt<P>>for StaticModInt<P
            >{fn$fn_assign(&mut self,rhs:&StaticModInt<P>){self.$fn_assign(*rhs);}}impl<const P:u32,T:Into<StaticModInt<P>>>$trait<T>for StaticModInt
            <P>{type Output=StaticModInt<P>;fn$fn(mut self,rhs:T)->Self::Output{self.$fn_assign(rhs.into());self}}impl<const P:u32>$trait
            <&StaticModInt<P>>for StaticModInt<P>{type Output=StaticModInt<P>;fn$fn(self,rhs:&StaticModInt<P>)->Self::Output{self.$fn(*rhs)}}impl
            <const P:u32,T:Into<StaticModInt<P>>>$trait<T>for&StaticModInt<P>{type Output=StaticModInt<P>;fn$fn(self,rhs:T)->Self::Output{(*self).$fn
            (rhs.into())}}impl<const P:u32>$trait<&StaticModInt<P>>for&StaticModInt<P>{type Output=StaticModInt<P>;fn$fn(self,rhs:&StaticModInt<P
            >)->Self::Output{(*self).$fn(*rhs)}}impl$trait_assign<&DynamicModInt>for DynamicModInt{fn$fn_assign(&mut self,rhs:&DynamicModInt){self
            .$fn_assign(*rhs);}}impl<T:Into<DynamicModInt>>$trait<T>for DynamicModInt{type Output=DynamicModInt;fn$fn(mut self,rhs:T)->Self
            ::Output{self.$fn_assign(rhs.into());self}}impl$trait<&DynamicModInt>for DynamicModInt{type Output=DynamicModInt;fn$fn(self,rhs
            :&DynamicModInt)->Self::Output{self.$fn(*rhs)}}impl<T:Into<DynamicModInt>>$trait<T>for&DynamicModInt{type Output=DynamicModInt;fn$fn(self
            ,rhs:T)->Self::Output{(*self).$fn(rhs.into())}}impl$trait<&DynamicModInt>for&DynamicModInt{type Output=DynamicModInt;fn$fn(self,rhs
            :&DynamicModInt)->Self::Output{(*self).$fn(*rhs)}})*};}impl_ops!{Add,AddAssign,add,add_assign,Sub,SubAssign,sub,sub_assign,Mul,MulAssign
            ,mul,mul_assign,Div,DivAssign,div,div_assign,}impl<const P:u32>Sum for StaticModInt<P>{fn sum<I:Iterator<Item=Self>>(iter:I)->Self{iter
            .fold(Self::raw(0),|b,x|b+x)}}impl<const P:u32>Product for StaticModInt<P>{fn product<I:Iterator<Item=Self>>(iter:I)->Self{iter.fold(Self
            ::from(1),|b,x|b*x)}}impl<'a,const P:u32>Sum<&'a Self>for StaticModInt<P>{fn sum<I:Iterator<Item=&'a Self>>(iter:I)->Self{iter.fold(Self
            ::raw(0),|b,x|b+x)}}impl<'a,const P:u32>Product<&'a Self>for StaticModInt<P>{fn product<I:Iterator<Item=&'a Self>>(iter:I)->Self{iter
            .fold(Self::from(1),|b,x|b*x)}}impl<const P:u32>StaticModInt<P>{pub const G:u32=ntt_info(P).0;pub const RANK2:usize=ntt_info(P).1;pub
            const ROOT:[u32;30]=ntt_info(P).2;pub const IROOT:[u32;30]=ntt_info(P).3;pub const RATE2:[u32;30]=ntt_info(P).4;pub const IRATE2:[u32;30]
            =ntt_info(P).5;pub const RATE3:[u32;30]=ntt_info(P).6;pub const IRATE3:[u32;30]=ntt_info(P).7;pub const IS_NTT_FRIENDLY:bool=is_prime(P
            )&&Self::RANK2>=21;}}<hide>
pub mod proconio {#![allow(clippy::needless_doctest_main,clippy::print_literal)]use crate::__cargo_equip::preludes::proconio::*;pub use crate
            ::__cargo_equip::macros::proconio::*;pub mod marker{use crate::__cargo_equip::preludes::proconio::*;use crate::__cargo_equip::crates
            ::proconio::source::{Readable,Source};use std::io::BufRead;pub enum Chars{}impl Readable for Chars{type Output=Vec<char>;fn read<R
            :BufRead,S:Source<R>>(source:&mut S)->Vec<char>{source.next_token_unwrap().chars().collect()}}pub enum Bytes{}impl Readable for
            Bytes{type Output=Vec<u8>;fn read<R:BufRead,S:Source<R>>(source:&mut S)->Vec<u8>{source.next_token_unwrap().bytes().collect()}}pub enum
            Usize1{}impl Readable for Usize1{type Output=usize;fn read<R:BufRead,S:Source<R>>(source:&mut S)->usize{usize::read(source).checked_sub(1
            ).expect("attempted to read the value 0 as a Usize1")}}pub enum Isize1{}impl Readable for Isize1{type Output=isize;fn read<R:BufRead,S
            :Source<R>>(source:&mut S)->isize{isize::read(source).checked_sub(1).unwrap_or_else(||{panic!(concat!("attempted to read the value {} as
            a Isize1:"," the value is isize::MIN and cannot be decremented"),std::isize::MIN,)})}}}pub mod source{use crate::__cargo_equip::preludes
            ::proconio::*;use std::any::type_name;use std::fmt::Debug;use std::io::BufRead;use std::str::FromStr;pub mod line{use crate
            ::__cargo_equip::preludes::proconio::*;use super::Source;use std::io::BufRead;use std::iter::Peekable;use std::str::SplitWhitespace;pub
            struct LineSource<R:BufRead>{tokens:Peekable<SplitWhitespace<'static>>,current_context:Box<str>,reader:R,}impl<R:BufRead>LineSource<R
            >{pub fn new(reader:R)->LineSource<R>{LineSource{current_context:"".to_string().into_boxed_str(),tokens:"".split_whitespace().peekable
            (),reader,}}fn prepare(&mut self){while self.tokens.peek().is_none(){let mut line=String::new();let num_bytes=self.reader.read_line(&mut
            line).expect("failed to get linel maybe an IO error.");if num_bytes==0{return;}self.current_context=line.into_boxed_str();self.tokens
            =unsafe{std::mem::transmute::<_,&'static str>(&*self.current_context)}.split_whitespace().peekable();}}}impl<R:BufRead>Source<R>for
            LineSource<R>{fn next_token(&mut self)->Option<&str>{self.prepare();self.tokens.next()}fn is_empty(&mut self)->bool{self.prepare();self
            .tokens.peek().is_none()}}use std::io::BufReader;impl<'a>From<&'a str>for LineSource<BufReader<&'a[u8]>>{fn from(s:&'a str)->LineSource
            <BufReader<&'a[u8]>>{LineSource::new(BufReader::new(s.as_bytes()))}}}pub mod once{use crate::__cargo_equip::preludes::proconio::*;use
            super::Source;use std::io::BufRead;use std::iter::Peekable;use std::marker::PhantomData;use std::str::SplitWhitespace;pub struct
            OnceSource<R:BufRead>{tokens:Peekable<SplitWhitespace<'static>>,context:Box<str>,_read:PhantomData<R>,}impl<R:BufRead>OnceSource<R>{pub
            fn new(mut source:R)->OnceSource<R>{let mut context=String::new();source.read_to_string(&mut context).expect("failed to read from source;
            maybe an IO error.");let context=context.into_boxed_str();let mut res=OnceSource{context,tokens:"".split_whitespace().peekable(),_read
            :PhantomData,};use std::mem;let context:&'static str=unsafe{mem::transmute(&*res.context)};res.tokens=context.split_whitespace().peekable
            ();res}}impl<R:BufRead>Source<R>for OnceSource<R>{fn next_token(&mut self)->Option<&str>{self.tokens.next()}fn is_empty(&mut self
            )->bool{self.tokens.peek().is_none()}}use std::io::BufReader;impl<'a>From<&'a str>for OnceSource<BufReader<&'a[u8]>>{fn from(s:&'a str
            )->OnceSource<BufReader<&'a[u8]>>{OnceSource::new(BufReader::new(s.as_bytes()))}}}pub mod auto{use crate::__cargo_equip::preludes
            ::proconio::*;#[cfg(debug_assertions)]pub use super::line::LineSource as AutoSource;#[cfg(not(debug_assertions))]pub use super::once
            ::OnceSource as AutoSource;}pub trait Source<R:BufRead>{fn next_token(&mut self)->Option<&str>;fn is_empty(&mut self)->bool;fn
            next_token_unwrap(&mut self)->&str{self.next_token().expect(concat!("failed to get the next token; ","maybe reader reached an end of
            input. ","ensure that arguments for `input!` macro is correctly ","specified to match the problem input."))}}impl<R:BufRead,S:Source<R
            >>Source<R>for&'_ mut S{fn next_token(&mut self)->Option<&str>{(*self).next_token()}fn is_empty(&mut self)->bool{(*self).is_empty()}}pub
            trait Readable{type Output;fn read<R:BufRead,S:Source<R>>(source:&mut S)->Self::Output;}impl<T:FromStr>Readable for T where T::Err:Debug
            ,{type Output=T;fn read<R:BufRead,S:Source<R>>(source:&mut S)->T{let token=source.next_token_unwrap();match token.parse(){Ok(v)=>v,Err(e
            )=>panic!(concat!("failed to parse the input `{input}` ","to the value of type `{ty}`: {err:?}; ","ensure that the input format is
            collectly specified ","and that the input value must handle specified type.",),input=token,ty=type_name::<T>(),err=e,),}}}}use crate
            ::__cargo_equip::crates::proconio::source::auto::AutoSource;use lazy_static::lazy_static;use std::io;use std::io::{BufReader,Stdin};use
            std::sync::Mutex;pub use crate::__cargo_equip::crates::proconio::source::Readable as __Readable;lazy_static!{#[doc(hidden)]pub static ref
            STDIN_SOURCE:Mutex<AutoSource<BufReader<Stdin>>>=Mutex::new(AutoSource::new(BufReader::new(io::stdin
            ())));}#[macro_export]macro_rules!__cargo_equip_macro_def_proconio_input{(@from[$source:expr]@rest)=>{};(@from[$source:expr]@rest mut$
            ($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[mut]@rest$($rest)*}};(@from[$source:expr]@rest$($rest
            :tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[]@rest$($rest)*}};(@from[$source:expr]@mut[$($mut:tt
            )?]@rest$var:tt:$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!{@from[$source]@mut[$($mut)*]@var$var@kind[]@rest$($rest
            )*}};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest)=>{let$($mut)*$var=$crate::__cargo_equip::crates::proconio
            ::read_value!(@source[$source]@kind[$($kind)*]);};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest,$($rest:tt
            )*)=>{$crate::__cargo_equip::crates::proconio::input!(@from[$source]@mut[$($mut)*]@var$var@kind[$($kind)*]@rest);$crate::__cargo_equip
            ::crates::proconio::input!(@from[$source]@rest$($rest)*);};(@from[$source:expr]@mut[$($mut:tt)?]@var$var:tt@kind[$($kind:tt)*]@rest$tt
            :tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::input!(@from[$source]@mut[$($mut)*]@var$var@kind[$($kind)*$tt]@rest$($rest
            )*);};(from$source:expr,$($rest:tt)*)=>{#[allow(unused_variables,unused_mut)]let mut s=$source;$crate::__cargo_equip::crates::proconio
            ::input!{@from[&mut s]@rest$($rest)*}};($($rest:tt)*)=>{let mut locked_stdin=$crate::__cargo_equip::crates::proconio::STDIN_SOURCE.lock
            ().expect(concat!("failed to lock the stdin; please re-run this program. ","If this issue repeatedly occur, this is a bug in `proconio`.
             ","Please report this issue from ","<https://github.com/statiolake/proconio-rs/issues>."));$crate::__cargo_equip::crates::proconio
            ::input!{@from[&mut*locked_stdin]@rest$($rest)*}drop(locked_stdin);};}macro_rules!input{($($tt:tt)*)=>(crate
            ::__cargo_equip_macro_def_proconio_input!{$($tt)*})}#[macro_export]macro_rules!__cargo_equip_macro_def_proconio_read_value{
            (@source[$source:expr]@kind[[$($kind:tt)*]])=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[]@rest$
            ($kind)*)};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest)=>{{let len=<usize as$crate::__cargo_equip::crates::proconio::__Readable
            >::read($source);$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[[$($kind)*;len]])}};(@array@source[$source
            :expr]@kind[$($kind:tt)*]@rest;$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!(@array@source[$source]@kind[$($kind
            )*]@len[$($rest)*])};(@array@source[$source:expr]@kind[$($kind:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio
            ::read_value!(@array@source[$source]@kind[$($kind)*$tt]@rest$($rest)*)};(@array@source[$source:expr]@kind[$($kind:tt)*]@len[$($len:tt)*]
            )=>{{let len=$($len)*;(0..len).map(|_|$crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*])).collect
            ::<Vec<_>>()}};(@source[$source:expr]@kind[($($kinds:tt)*)])=>{$crate::__cargo_equip::crates::proconio::read_value!
            (@tuple@source[$source]@kinds[]@current[]@rest$($kinds)*)};(@tuple@source[$source:expr]@kinds[$([$($kind:tt)*])*]@current[]@rest)=>{($
            ($crate::__cargo_equip::crates::proconio::read_value!(@source[$source]@kind[$($kind)*]),)*)};(@tuple@source[$source:expr]@kinds[$($kinds
            :tt)*]@current[$($curr:tt)*]@rest)=>{$crate::__cargo_equip::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*[$($curr
            )*]]@current[]@rest)};(@tuple@source[$source:expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest,$($rest:tt)*)=>{$crate::__cargo_equip
            ::crates::proconio::read_value!(@tuple@source[$source]@kinds[$($kinds)*[$($curr)*]]@current[]@rest$($rest)*)};(@tuple@source[$source
            :expr]@kinds[$($kinds:tt)*]@current[$($curr:tt)*]@rest$tt:tt$($rest:tt)*)=>{$crate::__cargo_equip::crates::proconio::read_value!
            (@tuple@source[$source]@kinds[$($kinds)*]@current[$($curr)*$tt]@rest$($rest)*)};(@source[$source:expr]@kind[])=>{compile_error!(concat!
            ("Reached unreachable statement while parsing macro input. ","This is a bug in `proconio`. ","Please report this issue from ","<https
            ://github.com/statiolake/proconio-rs/issues>."));};(@source[$source:expr]@kind[$kind:ty])=>{<$kind as$crate::__cargo_equip::crates
            ::proconio::__Readable>::read($source)}}macro_rules!read_value{($($tt:tt)*)=>(crate::__cargo_equip_macro_def_proconio_read_value!{$($tt
            )*})}pub fn is_stdin_empty()->bool{use crate::__cargo_equip::crates::proconio::source::Source;let mut lock=STDIN_SOURCE.lock().expect
            (concat!("failed to lock the stdin; please re-run this program. ","If this issue repeatedly occur, this is a bug in `proconio`. "
            ,"Please report this issue from ","<https://github.com/statiolake/proconio-rs/issues>."));lock.is_empty()}}
}
pub(crate) mod macros {
pub mod combination {}
pub mod __convolution_arbitrary_mod_0_1_0 {}
pub mod __convolution_naive_0_1_0 {}
pub mod __convolution_ntt_friendly_0_1_0 {}
pub mod formal_power_series {pub use crate::{__cargo_equip_macro_def_formal_power_series_fps as fps
            ,__cargo_equip_macro_def_formal_power_series_sfps as sfps};}
pub mod __lazy_static_1_4_0 {pub use crate::{__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_create as __lazy_static_create
            ,__cargo_equip_macro_def___lazy_static_1_4_0___lazy_static_internal as __lazy_static_internal
            ,__cargo_equip_macro_def___lazy_static_1_4_0_lazy_static as lazy_static};}
pub mod modint {}
pub mod proconio {pub use crate::{__cargo_equip_macro_def_proconio_input as input,__cargo_equip_macro_def_proconio_read_value as read_value}
            ;}
}
pub(crate) mod prelude {pub use crate::__cargo_equip::{crates::*,macros::__lazy_static_1_4_0::*};}
mod preludes {
pub mod combination {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::modint;}
pub mod __convolution_arbitrary_mod_0_1_0 {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::{__convolution_naive_0_1_0 as
            convolution_naive,__convolution_ntt_friendly_0_1_0 as convolution_ntt_friendly,modint};}
pub mod __convolution_naive_0_1_0 {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::modint;}
pub mod __convolution_ntt_friendly_0_1_0 {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::{__convolution_naive_0_1_0 as
            convolution_naive,modint};}
pub mod formal_power_series {pub(in crate::__cargo_equip)use crate::__cargo_equip::crates::{__convolution_arbitrary_mod_0_1_0 as
            convolution_arbitrary_mod,__convolution_ntt_friendly_0_1_0 as convolution_ntt_friendly,modint};}
pub mod __lazy_static_1_4_0 {pub(in crate::__cargo_equip)use crate::__cargo_equip::macros::__lazy_static_1_4_0::*;}
pub mod modint {}
pub mod proconio {pub(in crate::__cargo_equip)use crate::__cargo_equip::macros::__lazy_static_1_4_0::*;pub(in crate::__cargo_equip)use crate
            ::__cargo_equip::crates::__lazy_static_1_4_0 as lazy_static;}
}
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0