#include <fstream>
#include <vector>
#include <iostream>

using namespace std;

int search_insertion_pos
(
    vector<int> & dp,
    int longest_inc_subseq_len,
    int val
) {
    int left = 0;
    int right = longest_inc_subseq_len - 1;
    int insertion_pos = 0;

    while (left <= right) {
        insertion_pos = left + (right - left) / 2;

        if (dp[insertion_pos] == val) {
            break;
        } else if (val < dp[insertion_pos]) {
            right = insertion_pos - 1;
        } else {
            left = insertion_pos + 1;
            insertion_pos = left;
        }
    }

    return insertion_pos;
}

int main() {
    int N;

    // reading data
    ifstream fin("scmax.in");
    fin >> N;
    vector<int> a(N);
    for (int i = 0; i < N; i++) {
        fin >> a[i];
    }
    fin.close();

    // dp[i] = the smallest element that a sequence of length i + 1 ends with
    vector<int> dp(N, -1);
    // index[i] = the index (in a) of the element dp[i]
    vector<int> index(N, -1);
    // prev[i] = the index (in a) of the element that preceds a[i] in a subsequence
    vector<int> prev(N, -1);

    dp[0] = a[0];
    index[0] = 0;
    int longest_inc_subseq_len = 1;

    for (int i = 1; i < N; i++) {
        int insertion_pos = search_insertion_pos(
            dp,
            longest_inc_subseq_len,
            a[i]
        );

        dp[insertion_pos] = a[i];
        index[insertion_pos] = i;
        prev[i] = insertion_pos > 0 ? index[insertion_pos - 1] : -1;

        if (insertion_pos == longest_inc_subseq_len) {
            longest_inc_subseq_len++;
        }
    }

    // we will set dp so that dp will contain a valid sequence
    int insertion_pos = longest_inc_subseq_len - 1;
    int idx = index[insertion_pos];
    while (insertion_pos >= 0)
    {
        dp[insertion_pos] = a[idx];
        idx = prev[idx];
        insertion_pos--;
    }

    // printing the results
    ofstream fout("scmax.out");
    fout << longest_inc_subseq_len << endl;
    for (int i = 0; i < longest_inc_subseq_len; i++) {
        fout << dp[i] << " ";
    }
    fout.close();

    return 0;
}