Problem:
Exhaustive Search

Write a program which reads a sequence A of n elements and an integer M, and outputs "yes" if you can make M by adding elements in A, otherwise "no". You can use an element only once.

You are given the sequence A and q questions where each question contains Mi.

Input

In the first line n is given. In the second line, n integers are given. In the third line q is given. Then, in the fourth line, q integers (Mi) are given.

Output

For each question Mi, print yes or no.

Constraints

n ≤ 20

q ≤ 200

1 ≤ elements in A ≤ 2000

1 ≤ Mi ≤ 2000

Sample Input 1

5
1 5 7 10 21
8
2 4 17 8 22 21 100 35

Sample Output 1

no
no
yes
yes
yes
yes
no
no

Notes

You can solve this problem by a Burte Force approach. Suppose solve(p, t) is a function which checkes whether you can make t by selecting elements after p-th element (inclusive). Then you can recursively call the following functions:

solve(0, M)

solve(1, M-{sum created from elements before 1st element})

solve(2, M-{sum created from elements before 2nd element})

...

The recursive function has two choices: you selected p-th element and not. So, you can check solve(p+1, t-A[p]) and solve(p+1, t) in solve(p, t) to check the all combinations.

For example, the following figure shows that 8 can be made by A[0] + A[2].

Solution in Rust (judge verdict: Accepted)

#[allow(unused_imports)]
use std::cmp::{max, min};
use std::io::{stdin, stdout, BufWriter, Write};

#[derive(Default)]
struct Scanner {
    buffer: Vec<String>,
}

impl Scanner {
    fn next<T: std::str::FromStr>(&mut self) -> T {
        loop {
            if let Some(token) = self.buffer.pop() {
                return token.parse().ok().expect("Failed parse");
            }
            let mut input = String::new();
            stdin().read_line(&mut input).expect("Failed read");
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }
}

fn solve(a: &[i32], m: usize) -> bool {
    let n = a.len();
    let mut dp = vec![vec![false; m+1]; n+1];
    dp[0][0] = true;
    for i in 0..n {
        for j in 0..m+1 {
            dp[i+1][j] = dp[i][j];
            if j as i32 >= a[i] {
                dp[i+1][j] |= dp[i][j - a[i] as usize]
            }
        }
    }
    dp[n][m]
}

/* Blute force
fn solve(a: &[i32], m: i32, sum: i32, ind: usize) -> bool {
    if sum == m {
        return true;
    }
    if sum > m || ind >= a.len() {
        return false;
    }
    solve (a, m, sum + a[ind], ind+1) || solve(a, m, sum, ind+1)
}
*/

fn main() {
    let mut scan = Scanner::default();
    let out = &mut BufWriter::new(stdout());

    let n = scan.next();
    let mut a = vec![0; n];
    for i in 0..n {
        a[i] = scan.next();
    }

    let q = scan.next();
    for _ in 0..q {
        let m = scan.next();
        if solve(&a[..], m) {
            writeln!(out, "yes").ok();
        } else {
            writeln!(out, "no").ok();
        }
    }
}