use std::io::*;
use std::str::FromStr;
use std::collections::VecDeque;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

const MOD: i64 = 998244353;
struct Solver {
    x: VecDeque<u8>,
    aseq: Vec<VecDeque<u8>>,
    base: Vec<Option<VecDeque<u8>>>,
    memo: Vec<Option<i64>>,
}

impl Solver {
    fn new() -> Solver {
        let n: usize = read();
        let x = read::<String>()
            .chars()
            .rev()
            .map(|v| v as u8 - '0' as u8)
            .collect::<VecDeque<_>>();
        let mut aseq = vec![VecDeque::new(); n];
        for i in 0..n {
            aseq[i] = read::<String>()
                .chars()
                .rev()
                .map(|v| v as u8 - '0' as u8)
                .collect::<VecDeque<_>>();
        }
        Solver {
            x: x,
            aseq: aseq,
            base: vec![None; 9000],
            memo: vec![None; 9000],
        }
    }
    fn xor(&self, lhs: &VecDeque<u8>, rhs: &VecDeque<u8>) -> VecDeque<u8> {
        let (mut lhs, mut rhs) = (lhs, rhs);
        if lhs.len() < rhs.len() {
            let temp = lhs;
            lhs = rhs;
            rhs = temp;
        }
        let mut ret = lhs.clone();
        for i in 0..rhs.len() {
            ret[i] = lhs[i] ^ rhs[i];
        }
        while ret.len() > 0 && *ret.back().unwrap() == 0 {
            ret.pop_back();
        }
        ret
    }
    fn set_base(&mut self, vs: &VecDeque<u8>) -> usize {
        let mut vs = vs.clone();
        while let Some(ref b) = self.base[vs.len()] {
            vs = self.xor(&vs, &b);
        }
        if vs.len() == 0 {
            return 0;
        }
        assert!(*vs.back().unwrap() == 1);
        let len = vs.len();
        self.base[len] = Some(vs);
        return len;
    }
    fn dfs(&mut self, vs: &VecDeque<u8>, depth: usize, upper: bool) -> i64 {
        if !upper && self.memo[depth].is_some() {
            return self.memo[depth].unwrap();
        }
        if depth == 0 {
            return 1;
        }
        let mut ret = 0;
        {
            let v = if vs.len() <= depth - 1 {
                0
            } else {
                vs[depth - 1]
            };
            if !upper || self.x[depth - 1] == 1 || v == 0 {
                let nupper = upper && (self.x[depth - 1] == v);
                ret += self.dfs(vs, depth - 1, nupper);
            }
        }
        if self.base[depth].is_some() {
            let nvs = self.xor(vs, &self.base[depth].clone().unwrap());
            let nv = if nvs.len() <= depth - 1 {
                0
            } else {
                nvs[depth - 1]
            };
            if !upper || self.x[depth - 1] == 1 || nv == 0 {
                let nupper = upper && (self.x[depth - 1] == nv);
                ret += self.dfs(&nvs, depth - 1, nupper);
            }
        }
        ret %= MOD;
        if !upper {
            self.memo[depth] = Some(ret);
        }
        ret
    }
    fn solve(&mut self) {
        let mut que = VecDeque::<usize>::new();
        for vs in self.aseq.clone().iter() {
            let len = self.set_base(vs);
            if len > 0 {
                que.push_back(len);
            }
        }
        while let Some(len) = que.pop_front() {
            let mut vs = self.base[len].clone().unwrap();
            if vs.len() > 4100 {
                continue;
            }
            vs.push_front(0);
            let nvs = vs;
            let nlen = self.set_base(&nvs);
            if nlen > 0 {
                que.push_back(nlen);
            }
        }
        let l = self.x.len();
        let ans = self.dfs(&VecDeque::new(), l, true);
        println!("{}", ans);
    }
}

fn main() {
    let mut solver = Solver::new();
    solver.solve();
}


Measured memory_bytes: 23420