import java.util.*;
import java.io.*;
import java.math.*;
public class Practice{
	static long mod=(long)Math.pow(10,9)+7;
	static final int lint=Integer.MAX_VALUE;
	static final double ldouble=Double.MAX_VALUE;
	public static void main(String args[]) {
        new Thread(null, new Runnable() {
            public void run() {
                try{
                    solve();
                }
                catch(Exception e){
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();
	}
	public static void solve(){
		InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);
        int n=in.nextInt();
        int a=in.nextInt();
        int b=in.nextInt();
        int q=in.nextInt();
        while(q-->0){
        	w.println("Yes");
        }
        w.close();
	}
	static long gcd(long a,long b){
	    if (a == 0)
	        return b;
	    return gcd(b%a, a);
	}
	static long modInverse(long A, long M)
	{
		long x=extendedEuclid(A,M)[0];
		return (x%M+M)%M;    //x may be negative
	}
	static long[] extendedEuclid(long A, long B) {
		if(B == 0) {
			long d = A;
			long x = 1;
			long y = 0;
			return new long[]{x,y,d};
		}
		else {
			long arr[]=extendedEuclid(B, A%B);
			long temp = arr[0];
			arr[0] = arr[1];
			arr[1] = temp - (A/B)*arr[1];
			return arr;
		}
	}
	static int nCrModpDP(int n, int r, int p){
	    // The array C is going to store last row of
	    // pascal triangle at the end. And last entry
	    // of last row is nCr
	    int C[]=new int[r+1];
	    //memset(C, 0, sizeof(C));
	 
	    C[0] = 1; // Top row of Pascal Triangle
	 
	    // One by constructs remaining rows of Pascal
	    // Triangle from top to bottom
	    for (int i = 1; i <= n; i++)
	    {
	        // Fill entries of current row using previous
	        // row values
	        for (int j =(int)Math.min(i, r); j > 0; j--)
	 
	            // nCj = (n-1)Cj + (n-1)C(j-1);
	            C[j] = (C[j] + C[j-1])%p;
	    }
	    return C[r];
	}
	static int nCrModpLucas(int n, int r, int p){
	   // Base case
	   if (r==0)
	      return 1;
	 
	   // Compute last digits of n and r in base p
	   int ni = n%p, ri = r%p;
	 
	   // Compute result for last digits computed above, and
	   // for remaining digits.  Multiply the two results and
	   // compute the result of multiplication in modulo p.
	   return (nCrModpLucas(n/p, r/p, p) * // Last digits of n and r
	           nCrModpDP(ni, ri, p)) % p;  // Remaining digits
	}
//	static boolean nextPermutation() {
//	    // Find longest non-increasing suffix
//	    int i = array.length - 1;
//	    while (i > 0 && array[i - 1] >= array[i])
//	        i--;
//	    // Now i is the head index of the suffix
//
//	    // Are we at the last permutation already?
//	    if (i <= 0)
//	        return false;
//	    
//	    // Let array[i - 1] be the pivot
//	    // Find rightmost element that exceeds the pivot
//	    int j = array.length - 1;
//	    while (array[j] <= array[i - 1])
//	        j--;
//	    // Now the value array[j] will become the new pivot
//	    // Assertion: j >= i
//	    
//	    // Swap the pivot with j
//	    char temp = array[i - 1];
//	    array[i - 1] = array[j];
//	    array[j] = temp;
//	    
//	    // Reverse the suffix
//	    j = array.length - 1;
//	    while (i < j) {
//	        temp = array[i];
//	        array[i] = array[j];
//	        array[j] = temp;
//	        i++;
//	        j--;
//	    }
//	    
//	    // Successfully computed the next permutation
//	    return true;
//	}
	static long power(long base, long exponent, long modulus){
	    long result = 1;
	    while (exponent > 0) {
	        if (exponent % 2 == 1)
	            result = (result * base) % modulus;
	        exponent = exponent >> 1;
	        base = (base * base) % modulus;
	    }
    	return result;
	}
	static boolean isPrime(long n) {
        if(n < 2L) return false;
        if(n == 2L || n == 3L) return true;
        if(n%2 == 0 || n%3 == 0) return false;	
        long sqrtN = (long)Math.sqrt(n)+1L;
        for(long i = 6; i <= sqrtN; i += 6) {
            if(n%(i-1) == 0 || n%(i+1) == 0) return false;
        }
        return true;
    }
	static long modpowIter(long a, long b) {
        long ans=1;
        while(b != 0) {
                if(b%2==1)
                	ans=(ans*a)%mod;
                a=(a*a)%mod;
                b=b>>1;
        }
        return ans;
	}
	static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, numChars;
        private SpaceCharFilter filter;
 
        public InputReader(InputStream stream) {
            this.stream = stream;
        }
        
        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }
 
        public String nextLine() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }
 
        public String readString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
 
        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
 
        public int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }
 
        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }
 
        public boolean isSpaceChar(int c) {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
 
        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
	}
}