{*************************************************************************
 *                                                                       *
 *                       Pogromcy Algorytmów 2004                        *
 *                                                                       *
 *   Rozwiązanie zadania: Superliczby w permutacjach                     *
 *   Plik:                sup.pas                                        *
 *   Autor:               Krzysztof Onak                                 *
 *************************************************************************}

(*
 * Algorytm: Program oblicza dla każdej liczby maksymalną długość rosnącego
 * 	ciągu rozpoczynającego się od niej i kończączego się na niej.
 * 	Superliczbami są te liczby, dla których suma ta jest największa.
 * 	Wykorzystywane są tu informacje pojawiające się podczas działania
 * 	standardowego algorytmu na najdłuższy podciąg rosnący. Program
 * 	działa w czasie O(n log n) zamiast proponowanego przez autora
 * 	O(n^3). Cha, cha! ;)
 *)

const MAXN = 100000;

type IntArray = array[1..MAXN] of LongInt;

procedure reverse(n : LongInt; var arr : IntArray);
var
	i, tmp : LongInt;
begin
	for i := 1 to n div 2 do begin
		tmp := arr[i];
		arr[i] := arr[n + 1 - i];
		arr[n + 1 - i] := tmp;
	end;
	for i := 1 to i div 2 do
end;

procedure rotate(n : LongInt; var arr : IntArray);
var
	i : LongInt;
begin
	for i := 1 to n do
		arr[i] := -arr[i];
	reverse(n, arr);
end;

function search(n : LongInt; var arr : IntArray; x : LongInt) : LongInt;
var
	i, j, k : LongInt;
begin
	i := 1;
	j := n + 1;
	while i < j do begin
		k := (i + j) div 2;
		if arr[k] < x then
			i := k + 1
		else
			j := k;
	end;
	search := i;
end;

procedure longestEndedChain(n : LongInt; var arr : IntArray; var lengths : IntArray);
var
	ending : IntArray;
	endingLength, i, pos : LongInt;
begin
	endingLength := 0;
	for i := 1 to n do begin
		pos := search(endingLength, ending, arr[i]);
		if pos = endingLength + 1 then inc(endingLength);
		ending[pos] := arr[i];
		lengths[i] := pos;
	end;
end;

var
	n, i, best, counter : LongInt;
	perm, ended, started : IntArray;
	super: array[1..MAXN] of Boolean;
begin
	{wczytujemy}
	read(n);
	for i := 1 to n do
		read(perm[i]);
	{obliczamy dlugosci najdluzszych konczonych...}
	longestEndedChain(n, perm, ended);
	{...i rozpoczynanych podciagow}
	rotate(n, perm);
	longestEndedChain(n, perm, started);
	reverse(n, started);
	rotate(n, perm);
	{szukamy najlepszej sumy}
	best := -1;
	for i := 1 to n do
		if ended[i] + started[i] > best then
			best := ended[i] + started[i];
	{wybieramy najlepszych}
	for i := 1 to n do super[i] := false;
	counter := 0;
	for i := 1 to n do
		if best = ended[i] + started[i] then begin
			inc(counter);
			super[perm[i]] := true;
		end;
	{wypisujemy wynik}
	writeln(counter);
	for i := 1 to n do
		if super[i] then begin
			write(i);
			dec(counter);
			if counter <> 0 then
				write(' ');
		end;
	writeln;
end.
