#include <bits/stdc++.h>

using namespace std;

ifstream f("scmax.in");
ofstream g("scmax.out");

const int NMAX=1e5+5;

int A[NMAX], B[NMAX], Sol[NMAX], N;

int Init[NMAX];

int AIB[NMAX];

static inline int UB (int X)
{
    return (X&(-X));
}

inline void Update (int poz, int val)
{
    for(int i=poz; i<=N; i+=UB(i))
        AIB[i]=max(AIB[i], val);
}

static inline int Query (int poz)
{
    int Max=0;

    for(int i=poz; i>=1; i-=UB(i))
        Max=max(Max, AIB[i]);

    return Max;
}

static inline int Get ()
{
    int ans=0;

    char C=0;

    while(1)
    {
        f.get(C);

        if(isdigit(C))
            ans=ans*10+(C-'0');
        else
            break;
    }

    return ans;
}

inline void Read ()
{
    f.tie(NULL);

    f>>N;

    f.get();

    for(int i=1; i<=N; ++i)
    {
        A[i]=Get();

        B[i]=Init[i]=A[i];
    }

    return;
}

inline void Normalize ()
{
    sort(B+1, B+N+1);

    Sol[++Sol[0]]=B[1];

    for(int i=2; i<=N; ++i)
        if(B[i] != B[i-1])
            Sol[++Sol[0]]=B[i];

    for(int i=1; i<=N; ++i)
        A[i]=(lower_bound(Sol+1, Sol+Sol[0]+1, A[i])-Sol);

    return;
}

int dp[NMAX];

int V[NMAX], M;

inline void Solve ()
{
    dp[1]=1;

    Update(A[1], 1);

    int Min=A[1];

    for(int i=2; i<=N; ++i)
    {
        if(A[i] < Min)
        {
            dp[i]=1;

            Update(A[i], dp[i]);

            Min=A[i];

            continue;
        }

        int Q=Query(A[i]-1);

        dp[i]=Q+1;

        Update(A[i], dp[i]);
    }

    int Max=0, poz=0;

    for(int i=1; i<=N; ++i)
        if(dp[i] > Max)
        {
            Max=dp[i];

            poz=i;
        }

    V[++M]=poz;

    int j=Max-1;

    for(int i=poz-1; i>=1 && j; --i)
    {
        if(dp[i] == j)
        {
            V[++M]=i;

            poz=i;

            --j;
        }
    }

    g<<M<<'\n';

    for(int i=M; i>=1; --i)
        g<<Init[V[i]]<<' ';

    g<<'\n';

    exit(0);
}

int main()
{
    Read();

    Normalize();

    Solve();

    return 0;
}