use proconio::{
    input,
    marker::{Bytes, Usize1},
};

const MOD: usize = 998_244_353;

fn main() {
    input! {
        n: usize,
        m: usize,
        s: Bytes,
        ab: [(Usize1, Usize1); m],
    }

    let mut pow_26 = vec![1];
    for _ in 0..=6000 {
        pow_26.push((pow_26.last().unwrap() * 26) % MOD);
    }

    let mut e = vec![vec![]; n];
    for &(a, b) in &ab {
        e[a].push(b);
        e[b].push(a);
    }

    let hatena = s.iter().filter(|c| **c == b'?').count();

    let ans = s
        .iter()
        .copied()
        .zip(e.iter())
        .filter(|x| x.0 == b'o' || x.0 == b'?')
        .map(|(c, e)| {
            let a = e.iter().filter(|e| s[**e] == b'a').count();
            let i = e.iter().filter(|e| s[**e] == b'i').count();
            let w = e.iter().filter(|e| s[**e] == b'?').count();
            if c == b'o' {
                (a * i) * pow_26[hatena]
                    + if hatena > 0 {
                        (a * w + w * i) * pow_26[hatena - 1]
                    } else {
                        0
                    }
                    + if hatena > 1 {
                        w * (w - 1) * pow_26[hatena - 2]
                    } else {
                        0
                    }
            } else {
                (a * i) * pow_26[hatena - 1]
                    + if hatena > 1 {
                        (a * w + w * i) * pow_26[hatena - 2]
                    } else {
                        0
                    }
                    + if hatena > 2 {
                        w * (w - 1) * pow_26[hatena - 3]
                    } else {
                        0
                    }
            }
        })
        .fold(0, |acc, a| (acc + a) % MOD);

    println!("{}", ans);
}