Erelong Leha was bored by calculating of the greatest common divisor of two factorials. Therefore he decided to solve some crosswords. It's well known that it is a very interesting occupation though it can be very difficult from time to time. In the course of solving one of the crosswords, Leha had to solve a simple task. You are able to do it too, aren't you?

Leha has two strings s and t. The hacker wants to change the string s at such way, that it can be found in t as a substring. All the changes should be the following: Leha chooses one position in the string s and replaces the symbol in this position with the question mark "?". The hacker is sure that the question mark in comparison can play the role of an arbitrary symbol. For example, if he gets string s="ab?b" as a result, it will appear in t="aabrbb" as a substring.

Guaranteed that the length of the string s doesn't exceed the length of the string t. Help the hacker to replace in s as few symbols as possible so that the result of the replacements can be found in t as a substring. The symbol "?" should be considered equal to any other symbol.

Input

The first line contains two integers n and m (1 ≤ n ≤ m ≤ 1000) — the length of the string s and the length of the string t correspondingly.

The second line contains n lowercase English letters — string s.

The third line contains m lowercase English letters — string t.

Output

In the first line print single integer k — the minimal number of symbols that need to be replaced.

In the second line print k distinct integers denoting the positions of symbols in the string s which need to be replaced. Print the positions in any order. If there are several solutions print any of them. The numbering of the positions begins from one.

Examples

Input

3 5
abc
xaybz


Output

2
2 3 


Input

4 10
abcd
ebceabazcd


Output

1
2 
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Iterator;


public class Main
{
    static class Pair{
    	int first,second;
    	Pair(){
    		this.first=first;
    		this.second=second;
    	}
    }
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	static class Solution
	{
		final long mod = 1000000007;
		 int  max = Integer.MIN_VALUE;
		final boolean SIEVE = false;
		boolean[] prime;
		ArrayList<Integer> al;
		////////////////////////////////
		

	    public void solve(InputReader sc,PrintWriter out) 
	    {
	    	////////////////////////////////
	       if(SIEVE)
	       {
	          al = new ArrayList<Integer>();
	          prime = new boolean[max];
	          for(int i=2;i<max;i++)
	          {
	              prime[i] = true;
	          }
	          for(int i=2;i<max;i++)
	          {
	              if(prime[i])
	              {
	                  al.add(i);
	                  for(int j=2*i;j<max;j+=i)
	                  {
	                      prime[j] = false;
	                  }
	              }
	          }
	          
	       }
	       /////////////////////////
		   int length1=i(),length2=i();
		   int[] ar = new int[length1];
		   String s1=s();
		   String s2=s();
		   int k,count=0,j;
		   for(int i=0;i<=length2-length1;i++)
		   {
		   		k=0;
		   		count=0;
		   	    for(j=i;j<i+length1;j++)
		   	    {
		   	    	if(s1.charAt(k)==s2.charAt(j))
		   	    		count++;
		   	    	
		   	    	k++;
		   	    }
		   	   // out.println(count+" "+j);
		   	    if(count>max)
		   	    	{
		   	    		int u=0;
		   	    		for(int t=i;t<i+length1;t++)
		   	    		{
		   	    			if(s1.charAt(u)!=s2.charAt(t))
		   	    				ar[u]=100;
		   	    			else
		   	    				ar[u]=0;
		   	    			u++;
		   	    		}
		   	    		max=count;
		   	    	}
		   }
		   out.println(length1-max);
		   for(int i=0;i<length1;i++)
		   {
		   	if(ar[i]!=0)
		   		out.print((i+1)+" ");
		   }
	      
    	}
       
    	///////////////////////////////Methods///////////////////////////////////////////////////////
        int lower_bound(ArrayList<Integer> a, int key) {
    		int l = 0;
    		int h = a.size(); // Not n - 1

    		
    		
    		while (l < h) {
        		int mid = (l + h) / 2;
        		if (key <= a.get(mid)) {
            		h = mid;
        		} else {
            		l = mid + 1;
        		}
    		}
    		return l;
		}
    	int upper_bound(ArrayList<Integer> a, int key) {
    		int l = 0;
   		    int h = a.size(); // Not n - 1

   		    if(key>=a.get(h-1))
    			return (h);
    		
   			while (l < h) {
        		int mid = (l + h) / 2;
        		if (key >= a.get(mid)) {
            		l = mid + 1;
        		} else {
            		h = mid;
        		}
    		}
	
    		return l;
		}

        ////////////////////////////////////////////////////////////
        public int i(){	return sc.nextInt();}
		public long l(){ return sc.nextLong();}
		public String s(){ return sc.next();}
		public int[] iarr(int n){int[] ar = new int[n];for(int i=0;i<n;++i) ar[i] = sc.nextInt(); return ar; }
		public long[] larr(int n){long[] ar = new long[n];for(int i=0;i<n;++i) ar[i] = sc.nextLong(); return ar; }
		public void parr(int[] ar){	for(int i=0;i<ar.length;i++)	out.print(ar[i]+" ");
			out.println();
		}
		public void parl(long[] ar){	for(int i=0;i<ar.length;i++)	out.print(ar[i]+" ");
			out.println();
		}
        ///////////////////////////////////////Methods/////////////////////////////////////////////////////
 	}
    

 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	static	InputReader sc = new InputReader();
	static    PrintWriter out= new PrintWriter(System.out);
	Main() throws IOException {
	   
	    final long start = System.currentTimeMillis();		
		new Solution().solve(sc,out);
		@SuppressWarnings("unused")
		final long duration = System.currentTimeMillis()-start;
		out.close();
	}
 
	public static void main(String args[]) {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					new Main();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "1", 1 << 26).start();
	}
	static class InputReader{
		final InputStream stream;
		final byte[] buf = new byte[8192];
		int curChar, numChars;
		SpaceCharFilter filter;
 
		public InputReader(){
			this.stream = System.in;
		}
 
		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 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 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 String next(){
			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 boolean isSpaceChar(int c){
			if(filter != null)
				return filter.isSpaceChar(c);
			return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1;
		}
 
		public interface SpaceCharFilter{
			public boolean isSpaceChar(int ch);
		}
	}

}