use std::fs::{self, File};
use std::io::{BufWriter, Write};

macro_rules! parse_line {
    ($iter:expr, $($t:ty),+) => {{
        let line = $iter.next().unwrap();
        let mut parts = line.split_whitespace();
        ($(parts.next().unwrap().parse::<$t>().unwrap()),+)
    }};
}
macro_rules! parse_vector {
    ($iter:expr, $t:ty) => {{
        $iter
            .next()
            .unwrap()
            .split_whitespace()
            .map(|x| x.parse::<$t>().unwrap())
            .collect::<Vec<$t>>()
    }};
}

fn main() -> std::io::Result<()> {
    let content = fs::read_to_string("scmax.in")?;
    let mut lines = content.lines();
    let mut writer = BufWriter::new(File::create("scmax.out")?);

    let n = parse_line!(lines, usize);
    let vect = parse_vector!(lines, usize);

    let mut from: Vec<usize> = vec![0; n];
    let mut high: Vec<usize> = vec![0; n + 1];
    let mut answ = 1;
    high[1] = 0;

    for i in 1..n {
        let pos = high[1..=answ]
            .partition_point(|&idx| vect[idx] < vect[i])
            + 1;

        high[pos] = i;
        from[i] = high[pos - 1];
        answ = answ.max(pos);
    }

    writeln!(writer, "{}", answ)?;

    let mut elements = Vec::with_capacity(answ);
    let mut cur = high[answ];
    for _ in 0..answ {
        elements.push(vect[cur]);
        cur = from[cur];
    }
    elements.reverse();

    for (i, elem) in elements.iter().enumerate() {
        if i > 0 {
            write!(writer, " ")?;
        }
        write!(writer, "{}", elem)?;
    }
    writeln!(writer)?;

    Ok(())
}