#![allow(non_snake_case)]



fn main(){
    proconio::input!{
        n:usize,
        mut a:[usize;n],
    }

    use std::iter::*;
    let mut prev=once(!0).chain(0..n-1).collect::<Vec<_>>();
    let mut next=(1..n).chain(once(!0)).collect::<Vec<_>>();
    let mut que=(0..n).filter(|&i|a[i]==0).collect::<Vec<_>>();
    
    let mut perm=vec![!0;n];
    let mut it=0;
    
    while let Some(i)=que.pop(){
        perm[i]=it;
        it+=1;
        for ni in [prev[i],next[i]]{
            if ni==!0{
                continue;
            }
            if a[ni]==0{
                println!("0");
                return;
            }
            a[ni]-=1;
            if a[ni]==0{
                que.push(ni);
            }
        }

        if next[i]!=!0{
            prev[next[i]]=prev[i];
        }
        if prev[i]!=!0{
            next[prev[i]]=next[i];
        }
    }

    if it!=n{
        println!("0");
        return;
    }
    
    let mut pos=vec![!0;n];
    for i in 0..n{
        pos[perm[i]]=i;
    }

    const W:usize=512;
    let mut block=vec![!0;n/W];
    for i in 0..n/W{
        block[i]=*perm[i*W..(i+1)*W].iter().max().unwrap();
    }

    const MOD:u64=998244353;
    fn rec(perm:&[usize],block:&[usize],pos:&[usize],l:usize,r:usize)->u64{
        if l==r{
            return 1;
        }
        let mut max=0;
        let mut i=l;
        while i<r{
            if i%W==0 && i+W<r{
                max=max.max(block[i/W]);
                i+=W;
            } else{
                max=max.max(perm[i]);
                i+=1;
            }
        }
        let mi=pos[max];
        rec(perm,block,pos,l,mi)*rec(perm,block,pos,mi+1,r)%MOD*(r-l) as u64%MOD
    }

    let mut inv=1;
    let mut k=MOD-2;
    let mut pow2=rec(&perm,&block,&pos,0,n);
    while k>0{
        if k&1==1{
            inv=inv*pow2%MOD;
        }
        pow2=pow2*pow2%MOD;
        k>>=1;
    }

    let mut ans=inv;
    for i in 1..=n{
        ans=ans*i as u64%MOD;
    }

    println!("{ans}");
}