#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
using namespace std;
  
const string file = "scmax";
  
const string infile = file + ".in";
const string outfile = file + ".out";


int N;
vector<int> A;
vector<int> B;
vector<int> C;
vector<int> DP;
vector<int> AIB;
vector<int> prec;
int Sol;

inline int zeros(int x)
{
	return (x ^ (x - 1)) & x;
}

void update(int x, int v)
{
	for(; x <= N; x += zeros(x))
	{
		if(DP[v] > DP[AIB[x]])
		{
			AIB[x] = v;
		}
	}
}

int query(int x)
{
	int result = 0;
	for(; x > 0; x -= zeros(x))
	{
		if(DP[result] < DP[AIB[x]])
		{
			result = AIB[x];
		}
	}
	return result;
}


int pred(int a, int b)
{
	return A[a] < A[b];
}

int main()
{
	fstream fin(infile.c_str(), ios::in);

	fin >> N;

	A.resize(N);
	B.resize(N);
	C.resize(N);

	AIB.resize(N + 1);
	DP.resize(N + 1);
	prec.resize(N);

	for(int i = 0; i < N; i++)
	{
		fin >> A[i];
		B[i] = i;
	}
	fin.close();

	sort(B.begin(), B.end(), pred);

	for(int i = 0; i < N; i++)
	{
		C[B[i]] = i;
		if(i > 0 && A[B[i-1]] == A[B[i]])
		{
			C[B[i]] = C[B[i-1]];
		}
	}

	for(int i = 0; i < N; i++)
	{
		prec[i] = query(C[i]);

		DP[i + 1] = DP[prec[i]] + 1;
		update(C[i] + 1, i + 1);
		Sol = DP[Sol] < DP[i + 1] ? i + 1 : Sol;

	}

	vector<int> road;
	road.reserve(DP[Sol]);
	int current = Sol;
	for(int i = 0; i < DP[Sol]; i++)
	{
		road.push_back(A[current - 1]);
		current = prec[current - 1];
	}

	fstream fout(outfile.c_str(), ios::out);

	fout << DP[Sol] << "\n";

	for(vector<int>::reverse_iterator itr = road.rbegin(); 
		itr != road.rend();
		itr ++)
	{
		fout << *itr << " ";
	}
	fout << "\n";

	fout.close();
}