#include <bits/stdc++.h>

using namespace std;

ifstream fin;
ofstream fout;

void rebuild_scmax(vector<int>& v, int sol, int pos, vector<int>& prec) {
    vector<int> scmax; // vectorul cu numerele din scmax

    for (int i = 1; i <= sol; ++i) {
        // v[pos] este ultimul element pe care il stiu din SCMAX
        scmax.push_back(v[pos]);

        // inainte de el era v[prec[pos]] (..., v[ prec[pos] ], v[ pos ])
        pos = prec[pos];
    }

    reverse(scmax.begin(), scmax.end()); // oglindire vector solutie

    for (int i = 0; i < sol; ++i) {
        fout << scmax[i] << " ";
    }
    fout << "\n";
}

void scmax(int n, vector<int>& v) {
    vector<int> dp(n + 1); // in explicatii indexarea incepe de la 1
    vector<int> prec(n + 1); // dp[1], ..., dp[n] | prec[1], ..., prec[n]

    // caz de baza
    dp[1] = 1; // [ v[1] ] este singurul subsir (crescator) care se termina pe 1
    prec[1] = 0; // nu are precedent

    // caz general
    for (int i = 2; i <= n; ++i) {
        dp[i] = 1; // [ v[i] ] - este un subsir (crescator) care se termina pe i
        prec[i] = 0; // nu are precedent (cel putin momentan)

        // incerc sa il pun pe v[i] la finalul tuturor solutiilor disponibile
        // o solutie se termina cu un element v[j]
        for (int j = 1; j < i; ++j) {
            // solutia triviala: v[i]
            if (v[j] < v[i]) {
                // din (..., v[j]) pot obtine (..., v[j], v[i])
                // (caz in care prec[i] = j)

                // voi alege j-ul curent, cand alegerea imi gaseste o solutie mai buna decat ce am deja
                if (dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1;
                    prec[i] = j;
                }
            }
        }
    }

    // solutia e maximul din vectorul dp
    int sol = dp[1], pos = 1;
    for (int i = 2; i <= n; ++i) {
        if (dp[i] > sol) {
            sol = dp[i];
            pos = i;
        }
    }
    fout << sol << "\n";
    rebuild_scmax(v, sol, pos, prec);
}

int main() {
    
    fin.open("./scmax.in", ios::in);
    fout.open("./scmax.out", ios::out);
    int n;
    fin >> n;
    vector<int> v(n + 1);
    for (int i = 1; i <= n; i++)
    {
        int x;
        fin >> x;
        v[i] = x;
    }
    scmax(n, v);
}