#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>
#include <iterator>
#include <random>
#include <assert.h>
using namespace std;

const string file = "scmax";

const string infile = file + ".in";
const string outfile = file + ".out";

const int INF = 0x3f3f3f3f; 

//#define ONLINE_JUDGE

vector<int> DP;
vector<int> prec;
class AibMax
{
    public:
        AibMax(int N)
        {
            _data.resize(N + 1, 0);
            _N = N;
        }
        int query(int x)
        {
            int res = 0;
            for(int i = x; i > 0; i -= zeros(i))
            {
                if(DP[res] < DP[_data[i]])
                {
                    res = _data[i];
                }
            }
            return res;

        }
        void update(int x, int value)
        {
            for(int i = x; i <= _N; i += zeros(i))
            {
                if(DP[_data[i]] < DP[value])
                {
                    _data[i] = value;
                }
            }
        }

        static int zeros(int x)
        {
            return (x & ((x - 1) ^ x));
        }
    protected:
    private:
        vector<int> _data;
        int _N;
};

int main()
{
#ifdef ONLINE_JUDGE
	ostream &fout = cout;
	istream &fin = cin;
#else
	fstream fin(infile.c_str(), ios::in);
	fstream fout(outfile.c_str(), ios::out);
#endif	

    int N;
    fin >> N;
    vector<int> A(N + 1);
    for(int i = 1; i <= N; i++)
    {
        fin >> A[i];
    }
    vector<int> B = A;
    sort(B.begin() + 1, B.end());
    B.erase(unique(B.begin() + 1, B.end()), B.end());
    vector<int> C(N + 1);
    
    for(int i = 1; i <= N; i++)
    {
        C[i] = lower_bound(B.begin() + 1, B.end(), A[i]) - B.begin();
    }
    DP.resize(N + 1, 0);
    prec.resize(N + 1, 0);
    AibMax aib(N);
    int maxi = 0;
    for(int i = 1; i <= N; i++)
    {
        int c = aib.query(C[i] - 1);
        DP[i] = DP[c] + 1;
        prec[i] = c;
        aib.update(C[i], i);
        if(DP[maxi] < DP[i])
            maxi = i;
    }

    fout << DP[maxi] << "\n";
    vector<int> Sol;
    Sol.reserve(DP[maxi]);
    while(maxi != 0)
    {
        Sol.push_back(A[maxi]);
        maxi = prec[maxi];
    }
    for(vector<int>::reverse_iterator itr = Sol.rbegin();
            itr != Sol.rend();
            itr++)
    {
        fout << *itr << " ";
    }
    fout << "\n";
#ifdef ONLINE_JUDGE
#else
    fout.close();
	fin.close();
#endif
}