#include <iostream>
#include <fstream>
#include <set>


using namespace std;

struct pos
{
    uint32_t element;
    int16_t lungime;
    int16_t pozitie;
};

struct B
{
    bool operator()(const pos& lhs, const pos& rhs) const
    {
        return (lhs.lungime < rhs.lungime) || (( lhs.lungime == rhs.lungime) && (lhs.element < rhs.element));
    }
};


void printSubsir(int16_t* previous, ofstream& fout, uint32_t index, uint32_t* sir)
{
    if (previous[index] == -1)
    {
        fout << sir[index] << " ";
        return;
    }
    printSubsir(previous, fout, previous[index], sir);

    fout << sir[index] << " ";
}

int main()
{
    uint32_t* sir;
    int16_t n, i, *best, *previous;
    multiset<pos, B> lookupTable;

    ifstream fin("scmax.in");
    ofstream fout("scmax.out");

    fin >> n;

    sir = new uint32_t[n];
    best = new int16_t[n];
    previous = new int16_t[n];

    for(i = 0; i < n; i++)
    {
        fin >> sir[i];
    }

    best[0] = 1;
    previous[0] = -1;

    pos x;

    x.element = sir[0];
    x.lungime = 1;
    x.pozitie = 0;

    lookupTable.insert(x);
    multiset<pos, B>::reverse_iterator tt = lookupTable.rbegin();

    for (i = 1; i < n; i++)
    {
        x.lungime = 1;
        x.element = sir[i];
        x.pozitie = i;
        previous[i] = -1;

        for (multiset<pos, B>::reverse_iterator it = lookupTable.rbegin(); it != lookupTable.rend(); ++it)
        {
            if ((it->lungime >= x.lungime) && (sir[it->pozitie] < sir[i]))
            {
                x.lungime = it->lungime + 1;
                previous[i] = it->pozitie;
                break;
            }
        }
        lookupTable.insert(x);
    }

    multiset<pos, B>::reverse_iterator maxSubsir = lookupTable.rbegin();

    fout << maxSubsir->lungime  << endl;
    ///cout << "\n lungime maxima: " << maxSubsir->lungime << " pozitie " << maxSubsir->pozitie << endl;

    i = maxSubsir->pozitie;

    printSubsir(previous, fout, i, sir);

    return 0;
}