The sequence is called ordered if it is non-decreasing or non-increasing. For example, sequnces [3, 1, 1, 0] and [1, 2, 3, 100] are ordered, but the sequence [1, 3, 3, 1] is not. You are given a sequence of numbers. You are to find it's shortest subsequence which is not ordered.

A subsequence is a sequence that can be derived from the given sequence by deleting zero or more elements without changing the order of the remaining elements.

Input

The first line of the input contains one integer n (1 ≤ n ≤ 105). The second line contains n space-separated integers — the given sequence. All numbers in this sequence do not exceed 106 by absolute value.

Output

If the given sequence does not contain any unordered subsequences, output 0. Otherwise, output the length k of the shortest such subsequence. Then output k integers from the range [1..n] — indexes of the elements of this subsequence. If there are several solutions, output any of them.

Examples

Input

5
67 499 600 42 23


Output

3
1 3 5


Input

3
1 2 3


Output

0


Input

3
2 3 1


Output

3
1 2 3
import java.io.*;
import java.util.*;
/**
 * Created by peacefrog on 12/4/15.
 * Time : 9:57 PM
 */

public class CF27C {
    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    PrintWriter out;
    long timeBegin, timeEnd;

    public void runIO() throws IOException {
        timeBegin = System.currentTimeMillis();

        InputStream inputStream;
        OutputStream outputStream;


        if (ONLINE_JUDGE) {
            inputStream = System.in;
            Reader.init(inputStream);
            outputStream = System.out;

            out = new PrintWriter(outputStream);

        } else {
            inputStream = new FileInputStream("/home/peacefrog/Dropbox/IdeaProjects/Problem Solving/input");
            Reader.init(inputStream);
            out = new PrintWriter(System.out);
        }

        solve();

        out.flush();
        out.close();
        timeEnd = System.currentTimeMillis();

        System.err.println("Time = " + (timeEnd - timeBegin));

    }

    /*
     * Start Solution Here
     */
    class Node implements Comparable<Node>{

        int id , val;

        public Node(int id, int val) {
            this.id = id;
            this.val = val;
        }

        @Override
        public int compareTo(Node o) {
            return Integer.compare(val , o.val);
        }
    }
    private void solve() throws IOException {
        int n = Reader.nextInt(); //This Variable default in Code Template
        int arr[] = Reader.nextIntArray(n);
        ArrayList<Node> s = new ArrayList<>();
        int last = 0;
        s.add(new Node(1 , arr[0]));
        for (int i = 1; i < n; i++) {
            if(arr[i] == arr[last]) continue;
            s.add(new Node(i+1 , arr[i]));
            last = i;
        }

        boolean found = false ;
        Node[] t = new Node[s.size()];
        t =s.toArray(t);
        if(n > 2) {
            for (int i = 1; i < t.length - 1; i++) {
                if ((t[i + 1].val < t[i].val) && (t[i].val > t[i - 1].val)) {
                    out.println(3);
                    out.println(t[i - 1].id + " " + t[i].id + " " + t[i + 1].id);
                    found = true;
                    break;
                }
                if ((t[i + 1].val > t[i].val) && (t[i].val < t[i - 1].val)) {
                        out.println(3);
                        out.println(t[i - 1].id + " " + t[i].id + " " + t[i + 1].id);
                        found = true;
                        break;
            }
        }
                              
        if (!found) out.println(0);
        }else  out.println(0);
    }



    public static void main(String[] args) throws IOException {

        new CF27C().runIO();
    }

    static class Reader {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        /**
         * call this method to initialize reader for InputStream
         */
        static void init(InputStream input) {
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

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

        static String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
        }

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

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

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        static long[] nextLongArray(int n) throws IOException {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }

            return arr;
        }

        static int[] nextIntArray(int n) throws IOException {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }

            return arr;
        }
    }

}