Problem:
Score : 800 points

Problem Statement

Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N.
Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:

The bitwise AND of the chosen numbers is S.

The bitwise OR of the chosen numbers is T.

Constraints

1 \leq N \leq 50

1 \leq K \leq N

0 \leq A_i < 2^{18}

0 \leq S < 2^{18}

0 \leq T < 2^{18}

A_i \neq A_j (1 \leq i < j \leq N)

Input

Input is given from Standard Input in the following format:

N K S T
A_1 A_2 ... A_N

Output

Print the answer.

Sample Input 1

3 3 0 3
1 2 3

Sample Output 1

2

The conditions are satisfied when we choose \{1,2\} or \{1,2,3\}.

Sample Input 2

5 3 1 7
3 4 9 1 5

Sample Output 2

2

Sample Input 3

5 4 0 15
3 4 9 1 5

Sample Output 3

3

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

// -*- coding:utf-8-unix -*-

use num::Float;
use proconio::input;
use std::collections::VecDeque;
use std::collections::{BTreeSet, HashSet};
use std::io::*;
use std::str::FromStr;
// ABC086C - Traveling
// https://atcoder.jp/contests/abs/fasks/arc089_a

fn switch<T>(flag: bool, t: T, f: T) -> T {
    if flag {
        t
    } else {
        f
    }
}

#[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")
}
#[allow(dead_code)]
fn read_string() -> Vec<char> {
    read::<String>().chars().collect()
}
#[allow(dead_code)]
fn read_vector<T: FromStr>(number: usize) -> Vec<T> {
    (0..number).map(|_| read()).collect()
}

fn main() {
    let (n, k, s, t): (usize, usize, u32, u32) = (read(), read(), read(), read());
    let list: Vec<u32> = read_vector(n);

    //候補の作成 O(n)
    let mut candidate = list.clone();
    for i in 0..18 {
        let mask = 1 << i;
        //and
        if (s & mask) != 0 {
            candidate.retain(|x: &u32| x & mask != 0);
        }
        //or
        if (t & mask) == 0 {
            candidate.retain(|x: &u32| x & mask == 0);
        }
    }
    //条件を満たし続ける間探索

    let mut stack = VecDeque::new();
    let mut log = HashSet::new();
    let mut sum = 0;

    let btree: BTreeSet<_> = candidate.iter().collect();
    stack.push_back(btree);

    while let Some(list) = stack.pop_back() {
        //条件を満たしているか?
        let mut ss = !0;
        let mut tt = 0;
        for item in list.iter() {
            ss &= *item;
            tt |= *item;
        }
        if ss == s && tt == t {
            if list.len() <= k {
                sum += 1;
            }
            println!("{:?}", list);
            for item in list.iter() {
                let mut tmp: BTreeSet<_> = list.clone();
                tmp.remove(*item);
                if !log.contains(&tmp) {
                    stack.push_back(tmp.clone());
                    log.insert(tmp);
                }
            }
        }
    }
    println!("{}", sum);
}