#![allow(unused_imports)] #![allow(non_snake_case)] use std::cmp::*; use std::collections::*; use std::io::Write; #[allow(unused_macros)] macro_rules! debug { ($($e:expr),*) => { #[cfg(debug_assertions)] $({ let (e, mut err) = (stringify!($e), std::io::stderr()); writeln!(err, "{} = {:?}", e, $e).unwrap() })* }; } fn main() { let v = read_vec::(); let (n, k) = (v[0], v[1]); let v = read_vec::(); if k >= 11 { println!("0"); return; } let mut possible = vec![vec![]; n]; for i in 0..n { for prev in 0..1024 { if v[i] & prev == 0 { possible[i].push(prev); } } } let mut dp = vec![vec![Modulo(0); 1024]; k + 1]; dp[0][0] += 1; for i in 0..n { let num = v[i]; for ki in (0..k).rev() { for &prev in &possible[i] { let next = prev ^ num; let prev_num = dp[ki][prev]; dp[ki + 1][next] += prev_num; } } } let ans = dp[k].iter().sum::(); println!("{}", ans); } fn read() -> T { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().parse().ok().unwrap() } fn read_vec() -> Vec { read::() .split_whitespace() .map(|e| e.parse().ok().unwrap()) .collect() } #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] struct Modulo(i64); static mut MODULUS: i64 = 998244353; impl Modulo { fn set_modulus(m: i64) { unsafe { MODULUS = m; } } fn get_modulus() -> i64 { unsafe { MODULUS } } fn new(x: i64) -> Modulo { let m = Modulo::get_modulus(); if x < 0 { Modulo(x % m + m) } else if x < m { Modulo(x) } else { Modulo(x % m) } } fn pow(self, p: i64) -> Modulo { if p == 0 { Modulo(1) } else { let mut t = self.pow(p / 2); t *= t; if p & 1 == 1 { t *= self; } t } } fn inv(self) -> Modulo { self.pow(Modulo::get_modulus() - 2) } } impl std::fmt::Display for Modulo { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { self.0.fmt(f) } } impl std::ops::AddAssign for Modulo { fn add_assign(&mut self, other: Modulo) { let m = Modulo::get_modulus(); self.0 += other.0; if self.0 >= m { self.0 -= m; } } } impl std::ops::MulAssign for Modulo { fn mul_assign(&mut self, other: Modulo) { let m = Modulo::get_modulus(); self.0 *= other.0; self.0 %= m; } } impl std::ops::SubAssign for Modulo { fn sub_assign(&mut self, other: Modulo) { let m = Modulo::get_modulus(); self.0 += m - other.0; if self.0 >= m { self.0 -= m; } } } macro_rules! impl_modulo_ops { ($imp:ident, $method:ident, $assign_imp:ident, $assign_method:ident) => { impl<'a> std::ops::$assign_imp<&'a Modulo> for Modulo { fn $assign_method(&mut self, other: &'a Modulo) { std::ops::$assign_imp::$assign_method(self, *other); } } impl std::ops::$imp for Modulo { type Output = Modulo; fn $method(self, other: Modulo) -> Modulo { let mut x = self; std::ops::$assign_imp::$assign_method(&mut x, other); x } } impl<'a> std::ops::$imp for &'a Modulo { type Output = Modulo; fn $method(self, other: Modulo) -> Modulo { std::ops::$imp::$method(*self, other) } } impl<'a> std::ops::$imp<&'a Modulo> for Modulo { type Output = Modulo; fn $method(self, other: &'a Modulo) -> Modulo { std::ops::$imp::$method(self, *other) } } impl<'a, 'b> std::ops::$imp<&'b Modulo> for &'a Modulo { type Output = Modulo; fn $method(self, other: &'b Modulo) -> Modulo { std::ops::$imp::$method(*self, *other) } } impl std::ops::$assign_imp for Modulo { fn $assign_method(&mut self, other: i64) { std::ops::$assign_imp::$assign_method(self, Modulo::new(other)); } } impl<'a> std::ops::$assign_imp<&'a i64> for Modulo { fn $assign_method(&mut self, other: &'a i64) { std::ops::$assign_imp::$assign_method(self, *other); } } impl std::ops::$imp for Modulo { type Output = Modulo; fn $method(self, other: i64) -> Modulo { let mut x = self; std::ops::$assign_imp::$assign_method(&mut x, other); x } } impl<'a> std::ops::$imp<&'a i64> for Modulo { type Output = Modulo; fn $method(self, other: &'a i64) -> Modulo { std::ops::$imp::$method(self, *other) } } impl<'a> std::ops::$imp for &'a Modulo { type Output = Modulo; fn $method(self, other: i64) -> Modulo { std::ops::$imp::$method(*self, other) } } impl<'a, 'b> std::ops::$imp<&'b i64> for &'a Modulo { type Output = Modulo; fn $method(self, other: &'b i64) -> Modulo { std::ops::$imp::$method(*self, *other) } } }; } impl_modulo_ops!(Add, add, AddAssign, add_assign); impl_modulo_ops!(Mul, mul, MulAssign, mul_assign); impl_modulo_ops!(Sub, sub, SubAssign, sub_assign); use std::iter::Sum; impl Sum for Modulo { fn sum(iter: I) -> Self where I: Iterator, { iter.fold(Modulo(0), |a, b| a + b) } } impl<'a> Sum<&'a Modulo> for Modulo { fn sum(iter: I) -> Self where I: Iterator, { iter.fold(Modulo(0), |a, b| a + b) } }