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.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.Comparator;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author MottoX
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            Integer[] a = new Integer[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt();
            }
            SparseTable<Integer> minTable = new SparseTable<>(a);

            SparseTable gcdTable = new SparseTable(a) {

                protected Comparable pick(Comparable a, Comparable b) {
                    return MathUtils.gcd((int) a, (int) b);
                }
            };

            int l = 0, r = n - 1, length = 0;
            while (l <= r) {
                int mid = l + r >>> 1;
                boolean okay = false;
                for (int i = 0; i + mid < n && !okay; i++) {
                    int x = minTable.query(i, i + mid);
                    int y = (int) gcdTable.query(i, i + mid);
                    if (x == y) {
                        okay = true;
                    }
                }
                if (okay) {
                    length = mid;
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
            List<Integer> indices = new ArrayList<>();
            for (int i = 0; i + length < n; i++) {
                int x = minTable.query(i, i + length);
                int y = (int) gcdTable.query(i, i + length);
                if (x == y) {
                    indices.add(i + 1);
                }
            }
            out.println(indices.size() + " " + length);
            indices.forEach(out::println);
        }

    }

    static class InputReader {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

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

    }

    static class SparseTable<E extends Comparable<? super E>> {
        private final Comparator<? super E> comparator;
        private final E[] data;
        private final Object[][] dp;
        private final int[] logTable;

        public SparseTable(E[] data) {
            this(data, Comparator.naturalOrder());
        }

        public SparseTable(E[] data, Comparator<? super E> comparator) {
            this.data = data;
            this.comparator = comparator;
            int n = data.length;
            logTable = new int[n + 1];
            for (int i = 2; i <= n; i++) {
                logTable[i] = logTable[i >>> 1] + 1;
            }
            dp = new Object[n][logTable[n] + 1];
            calc(n);
        }

        protected E pick(E a, E b) {
            return comparator.compare(a, b) <= 0 ? a : b;
        }

        @SuppressWarnings("unchecked")
        private void calc(int n) {
            for (int i = 0; i < n; i++) {
                dp[i][0] = data[i];
            }
            for (int i = n - 1; i >= 0; i--) {
                dp[i][0] = data[i];
                for (int j = 1; i + (1 << j) <= n; j++) {
                    dp[i][j] = pick((E) dp[i][j - 1], (E) dp[i + (1 << j - 1)][j - 1]);
                }
            }
        }

        @SuppressWarnings("unchecked")
        public E query(int l, int r) {
            if (l > r) {
                int t = r;
                r = l;
                l = t;
            }
            int k = logTable[r - l + 1];
            return pick((E) dp[l][k], (E) dp[r - (1 << k) + 1][k]);
        }

    }

    static final class MathUtils {
        private MathUtils() {
        }

        public static int gcd(int x, int y) {
            return y == 0 ? x : gcd(y, x % y);
        }

    }
}

