Simon has an array a1, a2, ..., an, consisting of n positive integers. Today Simon asked you to find a pair of integers l, r (1 ≤ l ≤ r ≤ n), such that the following conditions hold:

  1. there is integer j (l ≤ j ≤ r), such that all integers al, al + 1, ..., ar are divisible by aj; 
  2. value r - l takes the maximum value among all pairs for which condition 1 is true; 



Help Simon, find the required pair of numbers (l, r). If there are multiple required pairs find all of them.

Input

The first line contains integer n (1 ≤ n ≤ 3·105).

The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 106).

Output

Print two integers in the first line — the number of required pairs and the maximum value of r - l. On the following line print all l values from optimal pairs in increasing order.

Examples

Input

5
4 6 9 3 6


Output

1 3
2 


Input

5
1 3 5 7 9


Output

1 4
1 


Input

5
2 3 5 7 11


Output

5 0
1 2 3 4 5 

Note

In the first sample the pair of numbers is right, as numbers 6, 9, 3 are divisible by 3.

In the second sample all numbers are divisible by number 1.

In the third sample all numbers are prime, so conditions 1 and 2 are true only for pairs of numbers (1, 1), (2, 2), (3, 3), (4, 4), (5, 5).
import java.awt.*;
import java.io.*; 
import java.math.*;
import java.util.*;
import java.util.Map.Entry;

import static java.lang.Math.*; 
   
public class solver implements Runnable { 
        final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null; 
        BufferedReader in; 
        PrintWriter out; 
        StringTokenizer tok = new StringTokenizer(""); 
        String delim = " ";
          
        String readString() throws IOException { 
        	try {
	    		while(!tok.hasMoreTokens()) {
	    			tok = new StringTokenizer(in.readLine()); 
		        }
		        return tok.nextToken(delim);
	    	}
        	catch (Exception e){
        		return null;
	    	}
        }
         
        int readInt() throws IOException{ 
            return Integer.parseInt(readString()); 
        }   
        long readLong() throws IOException{ 
            return Long.parseLong(readString()); 
        }       
        double readDouble() throws IOException{ 
            return Double.parseDouble(readString()); 
        }
//----------------------------------      
          
        public class Pair<T1,T2> { 
            public T1 x1; 
            public T2 x2; 
            public Pair(){}; 
            public Pair(T1 x1, T2 x2){ 
                this.x1 = x1; 
                this.x2 = x2; 
            } 
            public String toString(){ 
                return x1 + ":" + x2; 
            } 
        }  
        
        public class Three implements Comparable<Three>{ 
            public int x1, x2, x3; 
            public Three(){} 
            public Three(int a, int b, int c){x1 = a;x2=b;x3=c;} 
            public int compareTo(Three o) {               
                if(x1 == o.x1 && x2 == o.x2) return x3-o.x3;
                if(x1 == o.x1) return x2-o.x2;
                return (x1-o.x1);
            } 
            public String toString(){ 
                return x1 + ":" + x2 + ":" + x3; 
            } 
        }
        
//----------------------------------------
        
        
        class SparceTable1 {
        	
        	int[][] table;
        	int n;
        	int h;
        	
        	final double log2 = log(2);
        	
        	public SparceTable1(int[] arr){
        		
        		n = arr.length;
        		h = (int) (log(n)/log2+1);
        		table = new int[h][n];
        		
        		for (int i =0; i < n; i++){
        			table[0][i] = arr[i];
        		}
        		
        		for (int i = 1; i < h; i++){
        			for (int j = 0; j + (1<<(i)) - 1 < n; j++){
        				table[i][j] = calc(j, j+(1<<(i-1)), i-1);
        			}
        		}
        	}
        	
        	int get(int l, int r){
        		
        		int k = (int) (log(r-l+1)/log2);
        		
        		return calc(l, r + 1 - (1<<k), k);
        	}
        	
        	int calc(int i1, int i2, int len){
        		
        		int x1 = table[len][i1];
        		int x2 = table[len][i2];
        		
        		return min(x1, x2);
        	}
        }
        
        class SparceTable2 {
        	
        	int[][] table;
        	int n;
        	int h;
        	
        	final double log2 = log(2);
        	
        	public SparceTable2(int[] arr){
        		
        		n = arr.length;
        		h = (int) (log(n)/log2+1);
        		table = new int[h][n];
        		
        		for (int i =0; i < n; i++){
        			table[0][i] = arr[i];
        		}
        		
        		for (int i = 1; i < h; i++){
        			for (int j = 0; j + (1<<(i)) - 1 < n; j++){
        				table[i][j] = calc(j, j+(1<<(i-1)), i-1);
        			}
        		}
        	}
        	
        	int get(int l, int r){
        		
        		int k = (int) (log(r-l+1)/log2);
        		
        		return calc(l, r + 1 - (1<<k), k);
        	}
        	
        	int calc(int i1, int i2, int len){
        		
        		int x1 = table[len][i1];
        		int x2 = table[len][i2];
        		
        		return gcd(x1, x2);
        	}
        	
        	int gcd(int x, int y){
        		while (y != 0){
        			int temp = x%y;
        			x = y;
        			y = temp;
        		}
        		return x;
        	}
        }
        
        boolean find(int len, int n, SparceTable1 msp, SparceTable2 gsp){
        	
        	for (int i = 0; i + len-1 < n; i++){
        		
        		int min = msp.get(i, i+len-1);
        		int gcd = gsp.get(i, i+len-1);
        		
        		if (min == gcd){
        			return true;
        		}
        	}
        	
        	return false;
        }
        
        
        void solve() throws NumberFormatException, IOException {
        	int n = readInt();
        	int[] arr = new int[n];
        	for (int i = 0; i < n; i++){
        		arr[i] = readInt();
        	}
        	
        	SparceTable1 msp = new SparceTable1(arr);
        	SparceTable2 gsp = new SparceTable2(arr);
        	
        	int ans = 0;
        	
        	int l = 0, r = n+1;
        	while (l < r){
        		
        		int med = l + (r - l)/2;
        		
        		if (find(med, n, msp, gsp)){
        			ans = max(ans, med);
        			l = med+1;
        		}else{
        			r = med;
        		}
        	}
        	
        	ArrayList<Integer> aa = new ArrayList<Integer>();
        	
        	for (int i = 0; i + ans -1 < n; i++){
        		
        		int min = msp.get(i, i+ans-1);
        		int gcd = gsp.get(i, i+ans-1);
        		
        		if (min == gcd)        		
        		{
        			aa.add(i);
        		}
        	}
        	
        	out.println(aa.size() + " " + (ans-1));
        	for (Integer x : aa){
        		out.print((x+1) + " ");
        	}
        	
        }
        
//---------------------------------------- 
        public static void main(String[] args){ 
            new Thread(null, new solver(), "", 256 * (1L << 20)).start(); 
        } 
         
        public void run(){ 
                try{ 
                        timeBegin = System.currentTimeMillis(); 
                        try{ 
                            if (ONLINE_JUDGE){ 
                                in = new BufferedReader(new InputStreamReader(System.in)); 
                                out = new PrintWriter(System.out);
                            }  
                            else { 
                                in = new BufferedReader(new FileReader("input.txt")); 
                                out = new PrintWriter("output.txt"); 
                            } 
                        }catch(Throwable e){
                            in = new BufferedReader(new InputStreamReader(System.in)); 
                            out = new PrintWriter(System.out); 
                        }
                          
                        solve(); 
                        out.close(); 
                          
                        timeEnd = System.currentTimeMillis(); 
                        System.err.println("Time = " + (timeEnd - timeBegin)); 
                }catch (Exception e){ 
                        e.printStackTrace(System.err); 
                        System.exit(-1); 
                } 
        } 
         
        long timeBegin, timeEnd; 
}