/*
dp[i] = lungimea maxima a unui subsir care se termina pe pozitia i din vectorul initial
previous[i] = pozitia de dinaintea pozitiei i din cel mai lung subsir care se termina pe pozitia i
v[] este ordonat crescator dupa valori, deci, in momentul in care caut in aib o pozitie, toate pozitiile
care exista in aib pana in momentul respectiv corespund unor valori < valoarea de pe pozitia cautata (nu am folosit
niciodata pana in momentul respectiv functia Update() pentru o valoare mai mare, deoarece nu am intalnit-o in vector)
aib[i] = pozitia pe care se termina cel mai lung subsir crescator din intervalul acoperit de aib[i]
Query(pos) returneaza pozitia < pos pe care se termina cel mai lung subsir crescator
*/

#include <iostream>
#include <fstream>
#include <algorithm>
#include <stack>

using namespace std;

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

const int NMax = 1e5;

struct ValuePosition{
    int value, position;
    bool operator < (const ValuePosition other) const{
        if (value == other.value)
            return position > other.position;
        return value < other.value;
    }
}v[NMax + 5];

stack <int> st;
int n, posmax;
int initial[NMax + 5], dp[NMax + 5], aib[NMax + 5], previous[NMax + 5];

void Read(){
    fin >> n;
    for (int i = 1; i <= n; i++){
        fin >> initial[i];
        v[i].value = initial[i];
        v[i].position = i;
    }
}

int Query(int pos){
    int ans = 0;
    for (int i = pos; i >= 1; i -= i & (-i))
        if (dp[aib[i]] > dp[ans])
            ans = aib[i];
    return ans;
}

void Update(int pos){
    for (int i = pos; i <= n; i += i & (-i))
        if (dp[aib[i]] < dp[pos])
            aib[i] = pos;
}

void Solve(){
    sort(v + 1, v + n + 1);
    for (int i = 1; i <= n; i++){
        int position = Query(v[i].position - 1);
        dp[v[i].position] = dp[position] + 1;
        previous[v[i].position] = position;
        if (dp[v[i].position] > dp[posmax])
            posmax = v[i].position;
        Update(v[i].position);
    }
}

void Print(){
    fout << dp[posmax] << '\n';
    int pos = posmax;
    while (pos){
        st.push(pos);
        pos = previous[pos];
    }
    while (!st.empty()){
        fout << initial[st.top()] << ' ';
        st.pop();
    }
    fout << '\n';
}

int main(){
    Read();
    Solve();
    Print();
    return 0;
}