// use std::ops::{Index, IndexMut};
// use std::cmp::{Ordering, min, max};
// use std::collections::{BinaryHeap, BTreeMap};
// use std::collections::btree_map::Entry::{Occupied, Vacant};
// use std::clone::Clone;

fn getline() -> String{
    let mut res = String::new();
    std::io::stdin().read_line(&mut res).ok();
    res
}

macro_rules! readl {
    ($t: ty) => {
        {
            let s = getline();
            s.trim().parse::<$t>().unwrap()
        }
    };
    ($( $t: ty),+ ) => {
        {
            let s = getline();
            let mut iter = s.trim().split(' ');
            ($(iter.next().unwrap().parse::<$t>().unwrap(),)*) 
        }
    };
}

macro_rules! readlvec {
    ($t: ty) => {
        {
            let s = getline();
            let iter = s.trim().split(' ');
            iter.map(|x| x.parse().unwrap()).collect::<Vec<$t>>()
        }
    }
}

macro_rules! mvec {
    ($v: expr, $s: expr) => {
        vec![$v; $s]
    };
    ($v: expr, $s: expr, $($t: expr),*) => {
        vec![mvec!($v, $($t),*); $s]
    };
}

macro_rules! debug {
    ($x: expr) => {
        println!("{}: {:?}", stringify!($x), $x)
    }
}

fn printiter<'a, T>(v: &'a T)
where
    &'a T: std::iter::IntoIterator, 
    <&'a T as std::iter::IntoIterator>::Item: std::fmt::Display {
    for (i,e) in v.into_iter().enumerate() {
        if i != 0 {
            print!(" ");
        }
        print!("{}", e);
    }
    println!("");
}

struct ContestPrinter {
    s: String,
}

impl ContestPrinter {
    fn new() -> ContestPrinter {
        ContestPrinter {
            s: String::new(),
        }
    }

    fn add<T>(&mut self, x: T)
        where T: std::fmt::Display {
        self.s.push_str(format!("{}\n", x).as_str());
    }
}

impl std::ops::Drop for ContestPrinter {
    fn drop(&mut self) {
        print!("{}", self.s);
    }
}

fn main() {
    let (n, sd) = readl!(usize, i64);
    let d = readlvec!(i64);
    let qn = readl!(usize);
    let q = readlvec!(usize);
    let mut xs = vec![0; n+1];
    xs[n] = 1;
    for i in (0..n).rev() {
        if xs[i+1] <= d[i]/2 {
            xs[i] = xs[i+1];
        } else {
            xs[i] = xs[i+1]+d[i];
        }
    }
    // debug!(xs);

    use std::cmp::{min, max};
    let mut ans = Vec::with_capacity(n);
    let mut p = sd;
    for i in 0..n {
        // debug!(i); debug!(p);
        ans.push(xs[i+1] <= p);
        p = min(p, (p-d[i]).abs());
    }

    // debug!(ans);
    let mut printer = ContestPrinter::new();
    let mut s = String::new();
    for &q in &q {
        // debug!(q);
        if ans[q-1] {
            // s.push_str("YES\n");
            printer.add("YES");
        } else {
            printer.add("NO");
            // s.push_str("NO\n");
        }
    }
    // print!("{}", s);

    // let sd = sd as usize;
    // let mut dp = vec![false; sd+1];
    // dp[0] = true;
    // for &d in d.iter().rev() {
    //     let mut nex = vec![false; sd+1];
    //     for i in 0..sd+1 {
    //         nex[i] = dp[min(i, max(i as i64 - d, d - i as i64) as usize)];
    //     }
    //     dp = nex;
    //     debug!(d);
    //     for &v in &dp {
    //         if v {
    //             print!("1 ");
    //         } else {
    //             print!("0 ");
    //         }
    //     }
    //     println!("");
    // }
}



Measured memory_bytes: 21404