Watto, the owner of a spare parts store, has recently got an order for the mechanism that can process strings in a certain way. Initially the memory of the mechanism is filled with n strings. Then the mechanism should be able to process queries of the following type: "Given string s, determine if the memory of the mechanism contains string t that consists of the same number of characters as s and differs from s in exactly one position".

Watto has already compiled the mechanism, all that's left is to write a program for it and check it on the data consisting of n initial lines and m queries. He decided to entrust this job to you.

Input

The first line contains two non-negative numbers n and m (0 ≤ n ≤ 3·105, 0 ≤ m ≤ 3·105) — the number of the initial strings and the number of queries, respectively.

Next follow n non-empty strings that are uploaded to the memory of the mechanism.

Next follow m non-empty strings that are the queries to the mechanism.

The total length of lines in the input doesn't exceed 6·105. Each line consists only of letters 'a', 'b', 'c'.

Output

For each query print on a single line "YES" (without the quotes), if the memory of the mechanism contains the required string, otherwise print "NO" (without the quotes).

Examples

Input

2 3
aaaaa
acacaca
aabaa
ccacacc
caaac


Output

YES
NO
NO

        		    import java.awt.Checkbox;
import java.awt.Point;
import java.io.*;
        		    import java.math.*;
        		    import java.util.*;
        		    import javax.print.attribute.SetOfIntegerSyntax;
     
     
     
        		    public class LIS{
        		    	private static InputStream stream;
        		    	private static byte[] buf = new byte[1024];
        		    	private static int curChar;
        		    	private static int numChars;
        		    	private static SpaceCharFilter filter;
        		    	private static PrintWriter pw;
        		    	private static long count = 0,mod=(long)1e16 + 7;
        		    //	private static TreeSet<Integer> ts=new TreeSet[200000];
 
    		        public static void main(String[] args) {
    		        	InputReader(System.in);
    		    		pw = new PrintWriter(System.out); 
    		            new Thread(null ,new Runnable(){
    		               public void run(){
    		                   try{
    		                       solve();
    		                       pw.close();
    		                   } catch(Exception e){
    		                       e.printStackTrace();
    		                   }
    		               }
    		           },"1",1<<26).start();
   }
    public static void Merge(long a[],int p,int r){
        if(p<r){
            int q = (p+r)/2;
            Merge(a,p,q);
            Merge(a,q+1,r);
            Merge_Array(a,p,q,r);
        }
    }
    public static void Merge_Array(long a[],int p,int q,int r){
       long b[] = new long[q-p+1];
        long c[] = new long[r-q];
        for(int i=0;i<b.length;i++)
            b[i] = a[p+i];
        for(int i=0;i<c.length;i++)
            c[i] = a[q+i+1];
        int i = 0,j = 0;
        for(int k=p;k<=r;k++){
            if(i==b.length){
                a[k] = c[j];
                j++;
            }
            else if(j==c.length){
                a[k] = b[i];
                i++;
            }
            else if(b[i]<c[j]){
                a[k] = b[i];
                i++;
            }
            else{
                a[k] = c[j];
                j++;
            }
        }
    }
	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd( y % x,x);
	}	public static boolean isPrime(int n) {
	// Corner cases
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
 
		// This is checked so that we can skip 
// middle five numbers in below loop
		if (n % 2 == 0 || n % 3 == 0)
			return false;
 
		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;
 
		return true;
	}
	public static void test(){
		int t=nextInt();
		while(t-->0){
			solve();
		}
	}
      static long pow[]=new long[600001];
      static HashSet<Long> hs=new HashSet<Long>();
        public static void solve() {
  

        	int n=nextInt();
        	int m=nextInt();
        	calPow();
        	while(n-->0){
        		String s=nextLine();
        		hs.add(getHash(s));
        	}
        	StringBuilder sb=new StringBuilder();
        	while(m-->0){
        		String s=nextLine();
        		if(contained(s, getHash(s))){
        			sb.append("YES\n");
        		}else{
        			sb.append("NO\n");
        		}
        	}
        	pw.println(sb);
        	
        }
        private static long getHash(String s){
        	 long result = 0;
             for (int i = 0; i < s.length(); i++) {
                 result += pow[i] * (s.charAt(i) - 'a' + 1) % mod;    
             }
             return result;
        }
        private static boolean contained(String s, long hash) {
            int n = s.length();
            for (int i = 0; i < n; i++) {
                long temp = hash - (pow[i] * (s.charAt(i) - 'a' + 1)) % mod;
                for (char c = 'a'; c <= 'c'; c++) {
                    if (c != s.charAt(i)) {
                        int x = c - 'a' + 1;
                        long newHash = temp + pow[i] * (x) % mod;
                        if (hs.contains(newHash)) return true;
                    }
                }
            }
            return false;
        }

        private static void calPow(){
        	pow[0]=1;
        	int prime=31;
        	for(int i=1;i<=600000;i++){
        		pow[i]=(pow[i-1]*prime)%mod;
        	}
        }
        
        public static long pow(long n, long p,long mod) {
			if(p==0)
				return 1;
			if(p==1)
				return n%mod;
			if(p%2==0){
				long temp=pow(n, p/2,mod);
			return (temp*temp)%mod;
			}else{
				 	long temp=pow(n,p/2,mod);
				 	temp=(temp*temp)%mod;
				 	return(temp*n)%mod;
				 	
			}
		}
    
		        
		        
        public static int LCS(String a,String b){
        	int dp[][]=new int [a.length()+1][b.length()+1];
        	for(int i=0;i<a.length();i++){
        		for(int j=0;j<b.length();j++){
        			if(a.charAt(i)==b.charAt(j)){
        				dp[i+1][j+1]=1+dp[i][j];
        			}else{
        				dp[i+1][j+1]=Math.max(dp[i][j+1], dp[i+1][j]);
        			}
        		}
        	}
        	return dp[a.length()][b.length()];
        }
      
        public static String reverseString(String s) {
			StringBuilder sb = new StringBuilder(s);
			sb.reverse();
			return (sb.toString());
		}
  
    		       
// To Get Input
// Some Buffer Methods
 
    		     	public static void sort(long a[]){
    		     		Merge(a, 0, a.length-1);
    		     	}
    		    	public static void InputReader(InputStream stream1) {
    		    		stream = stream1;
    		    	}
 
    		    	private static boolean isWhitespace(int c) {
    		    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    		    	}
 
    		    	private static boolean isEndOfLine(int c) {
    		    		return c == '\n' || c == '\r' || c == -1;
    		    	}
 
    		    	private static 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++];
    		    	}
 
    		    	private static 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;
    		    	}
 
    		    	private static 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;
    		    	}
 
    		    	private static String nextToken() {
    		    		int c = read();
    		    		while (isSpaceChar(c))
    		    			c = read();
    		    		StringBuilder res = new StringBuilder();
    		    		do {
    		    			res.appendCodePoint(c);
    		    			c = read();
    		    		} while (!isSpaceChar(c));
    		    		return res.toString();
    		    	}
 
    		    	private static 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();
    		    	}
 
    		    	private static int[] nextIntArray(int n) {
    		    		int[] arr = new int[n];
    		    		for (int i = 0; i < n; i++) {
    		    			arr[i] = nextInt();
    		    		}
    		    		return arr;
    		    	}
 
    		    	private static long[][] next2dArray(int n, int m) {
    		    		long[][] arr = new long[n][m];
    		    		for (int i = 0; i < n; i++) {
    		    			for (int j = 0; j < m; j++) {
    		    				arr[i][j] = nextLong();
    		    			}
    		    		}
    		    		return arr;
    		    	}
    		    	private static char[][] nextCharArray(int n,int m){
    		    		char [][]c=new char[n][m];
    		    		for(int i=0;i<n;i++){
    		    			String s=nextLine();
    		    			for(int j=0;j<s.length();j++){
    		    				c[i][j]=s.charAt(j);
    		    			}
    		    		}
    		    		return c;
    		    	}
 
    		    	private static long[] nextLongArray(int n) {
    		    		long[] arr = new long[n];
    		    		for (int i = 0; i < n; i++) {
    		    			arr[i] = nextLong();
    		    		}
    		    		return arr;
    		    	}
 
    		    	private static void pArray(int[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}
 
    		    	private static void pArray(long[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}
 
    		    	private static void pArray(boolean[] arr) {
    		    		for (int i = 0; i < arr.length; i++) {
    		    			pw.print(arr[i] + " ");
    		    		}
    		    		pw.println();
    		    		return;
    		    	}
 
    		    	private static boolean isSpaceChar(int c) {
    		    		if (filter != null)
    		    			return filter.isSpaceChar(c);
    		    		return isWhitespace(c);
    		    	}
 
    		    	private interface SpaceCharFilter {
    		    		public boolean isSpaceChar(int ch);
    		    	}
        		    }
    		    	 class Pair implements Comparable<Pair>{
	        				
	    					
	    					int start,end;
	    					Pair(int start,int end){
	    					
	    						this.start=start;
	    						this.end=end;
	    					
	    					}
	    					@Override
	    					public int compareTo(Pair o) {
	    				
	    							
	    					
	    						if(start!=o.start)
	    						return (start-o.start);
	    						else
	    							return end-o.end;
	    					}
	    					public int hashCode() {
	    							//int hu = (int) (x ^ (x >>> 32));
	    							//int hv = (int) (y ^ (y >>> 32));
	    							//int hw = (int) (mass ^ (mass >>> 32));
	    							//return 31 * hu + hv ;
	    						return 0;
	    						}
	    						public boolean equals(Object o) {
	    							Pair other = (Pair) o;
	    						//	return x == other.x && y == other.y;
	    						return false;
	    						}
	    				}
 

        		  