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.awt.List;
import java.io.*;
import java.util.*;




/*
 * kishan Thesiya
 * daiict
 * kishanthesiya25@gmail.com
 * 
 * 
 */


public class Main {
	FastScanner in;
	PrintWriter out;

	static ArrayList[] adj;
	static ArrayList[] obj;
	static int n;
	static int x;
	static int c;
	static int visited[];
	static int Ad[];
	static int Bd[];
 
	static int brr[][];
	static int a;
	static int b;
	static int parent[];
	static int size[];
	long mod = (long)1e9+7;
	static int ds[];
	
//Segment tree do not delete
	static int arr[];	
	static int d[];
	static int h;
// till now	

	class Segment{
	  private  int Lazy[];
	 
	    void ans(){
	   
	    	
	     int x = (int) (Math.ceil(Math.log(100000) / Math.log(2)));
	        int max_size = 2 * (int) Math.pow(2, x) - 1;
	        int SegTree[][] = new int[max_size][3]; // allocate memory
	        Lazy = new int[max_size];
	        
	       String s = in.next();
	       n = s.length();
	        
	        int q=in.nextInt();
	        

	        build_ST(0, 0, n - 1,SegTree,s);
	  
	        for(int i = 0;i<2*n;i++){
	        	System.out.println(SegTree[i][0] + " " + SegTree[i][1] + " " + SegTree[i][2] + " " + (i+n));
	        }
	        
	        while(q-->0)
	        {
	          int a = in.nextInt();
	          int b = in.nextInt();
	          
	          int d = getMaxST(0, n-1, a-1, b-1, 0,SegTree);
	          System.out.println(d);
	        }
	    }
	    
	    
	 void build_ST(int node, int start, int end,int SegTree[][],String s) 
	   {
	    if(start > end) return; 
	  	if(start == end) { 
	  		System.out.println(start + " " + node);
	  		if(s.charAt(start) == '('){
	  			SegTree[node][1] = 1;
	  		}else{
	  			SegTree[node][2] = 1;
	  		}
	  		
			return;
		}
		int mid=(start + end) >> 1;
		build_ST(node*2+1, start, mid, SegTree,s); // Init left child
		build_ST(node*2+2, 1+mid, end,SegTree,s); // Init right child
		
		// Init root value
		
		int t = Math.min(SegTree[2*node + 1][1], SegTree[2*node+2][2]);
		
		SegTree[node][0] = SegTree[2*node+1][0] + SegTree[2*node+2][0] + 2*t;
		SegTree[node][1] = SegTree[2*node+1][1] + SegTree[2*node+2][1] - t;
		SegTree[node][2] = SegTree[2*node+1][2] + SegTree[2*node+2][2] - t;
		
		
	}
//	    void update_ST(int node, int start, int end, int l, int r, int diff) {
//	        if(Lazy[node] != 0)
//	        {
//	            int pending = Lazy[node];
//	            
//	            SegTree[node] -= pending;
//	            
//	           if(start != end)
//	            {
//	                Lazy[2 * node + 1] += Lazy[node];
//	                Lazy[2 * node + 2] += Lazy[node];
//	            }
//	           Lazy[node] = 0;
//	        }
//	        if (end < l || start > r)
//	            return ;
//	          if(l<=start && end<=r)
//	        {
//	        	  SegTree[node] -= diff;
//	               
//	            if(start != end) // not a leaf
//	            {
//	                Lazy[2*node+1] += diff;
//	                Lazy[2*node+2] += diff;
//	            }
//	            return;
//	        }
//	        int mid=(start + end) >> 1;
//		update_ST(node*2+1, start, mid, l, r, diff); // Updating left child
//		update_ST(2+node*2, 1+mid, end, l, r, diff); // Updating right child
//	
//		SegTree[node] = Math.max(SegTree[node*2+1],SegTree[node*2+2]); 
//		
//	    }
	      int getMaxST(int start, int end, int l, int r, int node,int SegTree[][])
	    {
//	    	  if(Lazy[node] != 0)
//		        {
//		            int pending = Lazy[node];
//		            
//		            SegTree[node] -= pending;
//		            
//		           if(start != end)
//		            {
//		                Lazy[2 * node + 1] += Lazy[node];
//		                Lazy[2 * node + 2] += Lazy[node];
//		            }
//		           Lazy[node] = 0;
//		        }
	        if (l <= start && r >= end)
	            return SegTree[node][0];
	         if (end < l || start > r)
	            return 0;
	        int mid = (start + end) >> 1;
	        return getMaxST(start, mid, l, r, 2 * node + 1,SegTree)+getMaxST(mid + 1, end, l, r, 2 * node + 2,SegTree);
	    }
	      
	}
	
	static class Pair implements Comparable<Pair>
    {
		int x;int y;
       
        Pair(int l, int m) {
          
        	this.x = l;
            this.y = m;
        }
        
        public int compareTo(Pair p) {
            if (this.x == p.x) {
                return (int)(this.y-p.y);
            }
            return (int)(this.x - p.x);
        }
        
        public String toString(){
        	return x + " " + y;
        }
        
        public boolean equals(Object o){
        	if(o instanceof Pair){
        		Pair a = (Pair)o;
        		
        		return this.x == a.x && this.y == a.y;
        	}
        	
        	return false;
        }
        
        public int hashCode(){
        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
        }
    
    }
    
	
	public static int gcd(int a, int b) {
		if (b == 0) return a;
		return gcd(b, a%b);
	}
	
	public static int find(int i){
		if(parent[i] != i){
			return find(parent[i]);
		}
		
		return i;
	}
	
	
	public static void union(int a,int b){
		int ra = find(a);
		int rb = find(b);

		if(ra!= rb){
			if(size[ra] > size[rb]){
				parent[rb] =ra;
				size[ra] += size[rb];
			}else{
				parent[ra] = rb;
				size[rb] += size[ra];
			}
		}
		
	}

	public static void apply(int p,int value){
		arr[p] += value;
		
		if(p < n){
			d[p] += value;
		}
	}
	
	public static void push(int p){
		
		for(int s = h;s>0;s--){
			int i = p >> s;
			
			if(d[i] != 0){
				apply(i<<1,d[i]);
				apply(i<<1|1,d[i]);
				d[i] = 0;
			}		
		}		
	}
	
	public static void lazybuild(int p){
		while(p > 1){
			p>>=1;
			arr[p] = Math.max(arr[p<<1], arr[p<<1|1]) + d[p];
		}
	}
	
	public static void lazyupdate(int l,int r,int value){
		l += n; r += n+1;		
		int l0 = l;int r0 = r;
		for(;l<r; l>>=1,r>>=1){
			if((l&1) == 1){
				apply(l++,value);
			}
			
			if((r&1) == 1){
				apply(--r,value);
			}
		}
		lazybuild(l0);
		lazybuild(r0-1);
			
	}
	
	public static int lazyquery(int l,int r){
		l += n;r += n+1;
		push(l);push(r-1);
		int res = (int)-2e9;
		
		for(;l<r;l>>=1,r>>=1){
			if((l&1) == 1){
				res = Math.max(arr[l++], res);
			}
			
			if((r&1) == 1){
				res = Math.max(arr[--r], res);
			}
		}
		
		return res;
	}
	
	public static void build(){
		
		for(int i = n-1;i>0;i--){
			arr[i] = Math.max(arr[i<<1], arr[i<<1|1]);
		}
		
	}
	
	public static void update(int p,int v){
		
		for(arr[p += n] = v; p>0; p>>=1 ){
			arr[p>>1] = Math.max(arr[p], arr[p^1]);
		}
		
	}
	
	public static int query(int l,int r){
		
		r++;
		int max = 0;
		for(l +=n,r +=n;l<r; l>>=1,r>>=1 ){
			
		
			
			if((l&1) == 1){
				max = Math.max(max, arr[l++]);
			}
			
			if((r&1) == 1){
				max = Math.max(max, arr[--r]);
			}
		}
		
		return max;
	}
	
	void multiply(long a[][], long b[][])
	{
	    
	    long mul[][] = new long[3][3];
	    for (int i = 0; i < 3; i++)
	    {
	        for (int j = 0; j < 3; j++)
	        {
	            mul[i][j] = 0;
	            for (int k = 0; k < 3; k++)
	                mul[i][j] = (int) ((mul[i][j] + (a[i][k]*b[k][j])%mod)%mod);
	        }
	    }
	 
	  
	    for (int i=0; i<3; i++)
	        for (int j=0; j<3; j++)
	            a[i][j] = mul[i][j];  
	}
	
	long power(long F[][], long n)
	{
	    long M[][] = {{1,1,0}, {1,0,0}, {0,1,0}};
	 
	    if (n==1)
	        return (long) ((F[0][0] + F[0][1])%mod);
	 
	    power(F, n/2);
	 
	    multiply(F, F);
	 
	    if (n%2 != 0)
	        multiply(F, M);
	 
	    return (long) ((F[0][0] + F[0][1])%mod) ;
	}
	 
	
	long findNthTerm(long n)
	{
	    long[][] F = {{1,1,0}, {1,0,0}, {0,1,0}} ;
	 
	    return power(F, n);
	}
	 
	
	
    void solve() throws NumberFormatException, IOException {
 
    	Scanner in = new Scanner (System.in);
		
    	int n = in.nextInt();
    	int m = in.nextInt();
    	in.nextLine();
    	
    	String s = in.nextLine();
    	String t = in.nextLine();
    	
    	String ans = "";
    	int min = Integer.MAX_VALUE;
    	for(int i = 0;i<=t.length()-s.length();i++){
    		int c = 0;
    		String p ="";
    		for(int j = 0;j<s.length();j++){
    			if(s.charAt(j) != t.charAt(i+j)){
    				p += (j+1) + " ";
    				c++;
    			}
    			
    		}
    		
    		if(c < min){
    			min = c;
    			ans = p;
    			
    		}
    	}
    	
    	System.out.println(min);
    	System.out.println(ans);
    	
//    	Segment s = new Segment();
//    	
//    	s.ans();
    	
//    	n = in.nextInt();
//    	arr = new int[2*n];
//    	d = new int[n];
//    	h = (int)Math.ceil((Math.log(n)/Math.log(2)));
//    	for(int i = 0;i<n;i++){
//    		arr[i+n] = in.nextInt();
//    	}
//    	
//    	build();
    	
//    	 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//        
//    	 StringBuilder sb = new StringBuilder();
// 
//    	 int tests = Integer.parseInt(br.readLine().trim());
//    	  
//          while (tests-- > 0) {
//        	 
//        	
//          }
//          
//          
//          System.out.println(sb.toString());
//          
//           
//         
}

    
    
    public static String[] reverse(String arr[]){
    	
    	
    	for(int i = 0;i<arr.length/2;i++){
    		String temp = arr[i];
    		arr[i] = arr[arr.length-i-1];
    		arr[arr.length-1-i] = temp;
    	}
    	
    	return arr;
    	
    }
	
	
    
  
    private static long ans(long n){
        if(n==1) return 2;
        n+=1;
        int cnt=-1;
        while(n%2==0){
            n/=2;
            cnt++;
        }
        if(n==1){
            return (int)Math.pow(2,cnt)-1;
        }
        return -1;
    }
    public static long sum(long x){
    	return x<10?x:x%10 + sum(x/10);
    }
	
	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd( y % x,x);
	}
	public static long pow(long n,long p,long m){
        long  result = 1;
         if(p==0)
           return 1;
       if (p==1)
           return n;
       while(p!=0)
       {
           if(p%2==1)
               result *= n;
           if(result>=m)
           result%=m;
           p >>=1;
           n*=n;
           if(n>=m)
           n%=m;
       }
       return result;
       }
	
	
	
	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;
	}
	

	void run() throws NumberFormatException, IOException {
		in = new FastScanner();
		out = new PrintWriter(System.out);

		solve();

		out.close();
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(in.br.readLine());
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}
	
	class Tri{
		
		Tri[] arr;
		
		public Tri(){
			arr = new Tri[27];
		}
		
	}
	
	
 

	public static void main(String[] args) throws NumberFormatException, IOException {
		new Main().run();
	}
}


class Node{
	int a;
	int b;
	int c;
}

class MyComp implements Comparator<Node>{
    
	@Override
	public int compare(Node a,Node b) {
		
		// < == -1
		
		if(a.a < b.a){
			return -1;
		}else if(a.a > b.a){
			return 1;
		}else{
			return 0;
		}
		
		
	}
}

