/*************************************************************************
 *                                                                       *
 *                       Pogromcy Algorytmów 2004                        *
 *                                                                       *
 *   Rozwiązanie zadania: Superliczby w permutacjach                     *
 *   Plik:                sup.cpp                                        *
 *   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! ;)
 */

#include <cstdio>
#include <vector>
#include <algorithm>
#include <utility>

using namespace std;

#define REP(i,n) for(int i = 0; i < (n); ++i)

typedef vector<int> vi;

template<class T> inline int size(const T &v) {return v.size();}

void longestEndedChain(const vi &chain, vi &lengths) {
	lengths.clear();
	vi ending;
	REP(i,size(chain)) {
		int pos =
			lower_bound(ending.begin(), ending.end(), chain[i])
			- ending.begin();
		if (pos == size(ending)) ending.push_back(chain[i]);
		else ending[pos] = chain[i];
		lengths.push_back(pos + 1);
	}
}

void reverse(vi &v) {
	reverse(v.begin(), v.end());
}

void rotate(vi &v) {
	REP(i,size(v)) v[i] = -v[i];
	reverse(v);
}

int main() {
	// wczytujemy
	int n;
	scanf("%d", &n);
	vi perm;
	REP(i,n) {
		int tmp;
		scanf("%d", &tmp);
		perm.push_back(tmp);
	}
	// obliczamy dlugosci najdluzszych...
	vi ended, started;
	// ... konczonych ...
	longestEndedChain(perm, ended);
	// ... i rozpoczynanych podciagow
	rotate(perm);
	longestEndedChain(perm, started);
	reverse(started);
	rotate(perm);
	// szukamy najlepszej sumy
	int best = -1;
	REP(i,n) best = max(best, ended[i] + started[i]);
	// wybieramy najlepszych
	vi supernumbers;
	REP(i,n)
		if (best == ended[i] + started[i])
			supernumbers.push_back(perm[i]);
	sort(supernumbers.begin(), supernumbers.end());
	// wypisujemy wynik
	printf("%d\n", size(supernumbers));
	REP(i,size(supernumbers)) {
		if (i != 0) printf(" ");
		printf("%d", supernumbers[i]);
	}
	printf("\n");
}
