Problem:
Score : 700 points

Problem Statement

We have a sequence of N \times K integers: X=(X_0,X_1,\cdots,X_{N \times K-1}).
Its elements are represented by another sequence of N integers: A=(A_0,A_1,\cdots,A_{N-1}). For each pair i, j (0 \leq i \leq K-1,\ 0 \leq j \leq N-1), X_{i \times N + j}=A_j holds.

Snuke has an integer sequence s, which is initially empty.
For each i=0,1,2,\cdots,N \times K-1, in this order, he will perform the following operation:

If s does not contain X_i: add X_i to the end of s.

If s does contain X_i: repeatedly delete the element at the end of s until s no longer contains X_i. Note that, in this case, we do not add X_i to the end of s.

Find the elements of s after Snuke finished the operations.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq K \leq 10^{12}

1 \leq A_i \leq 2 \times 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
A_0 A_1 \cdots A_{N-1}

Output

Print the elements of s after Snuke finished the operations, in order from beginning to end, with spaces in between.

Sample Input 1

3 2
1 2 3

Sample Output 1

2 3

In this case, X=(1,2,3,1,2,3).
We will perform the operations as follows:

i=0: s does not contain 1, so we add 1 to the end of s, resulting in s=(1).

i=1: s does not contain 2, so we add 2 to the end of s, resulting in s=(1,2).

i=2: s does not contain 3, so we add 3 to the end of s, resulting in s=(1,2,3).

i=3: s does contain 1, so we repeatedly delete the element at the end of s as long as s contains 1, which causes the following changes to s: (1,2,3)→(1,2)→(1)→().

i=4: s does not contain 2, so we add 2 to the end of s, resulting in s=(2).

i=5: s does not contain 3, so we add 3 to the end of s, resulting in s=(2,3).

Sample Input 2

5 10
1 2 3 2 3

Sample Output 2

3

Sample Input 3

6 1000000000000
1 1 2 2 3 3

Sample Output 3

s may be empty in the end.

Sample Input 4

11 97
3 1 4 1 5 9 2 6 5 3 5

Sample Output 4

9 2 6

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::{stdin, Read};

macro_rules! parse {
    ($it: ident ) => {};
    ($it: ident, ) => {};
    ($it: ident, $var:ident : $t:tt $($r:tt)*) => {
        let $var = parse_val!($it, $t);
        parse!($it $($r)*);
    };
    ($it: ident, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = parse_val!($it, $t);
        parse!($it $($r)*);
    };
}

macro_rules! parse_val {
    ($it: ident, [$t:tt; $len:expr]) => {
        (0..$len).map(|_| parse_val!($it, $t)).collect::<Vec<_>>();
    };
    ($it: ident, $t: ty) => {
        $it.next().unwrap().parse::<$t>().unwrap()
    };
}

fn solve(s: &str) {
    let mut it = s.split_whitespace();
    parse!(it, n: usize, k: usize, a: [usize; n]);
    let mut d = std::collections::HashMap::new();
    for i in 0..n {
        d.entry(a[i]).or_insert(vec![]).push(i);
    }
    let mut b = vec![0];
    while b[b.len() - 1] % n != 0 || b[b.len() - 1] == 0 {
        let mut i = b[b.len() - 1];
        let ai = a[i % n];
        let j = d[&ai].binary_search(&(i % n + 1)).unwrap_or_else(|x| x);
        if j == d[&ai].len() {
            i += n + d[&ai][0] + 1 - (i % n);
        } else {
            i += d[&ai][j] + 1 - (i % n);
        }
        b.push(i);
    }

    let len = b[b.len() - 1];
    let r = (n * k) % len;
    let r = match b.binary_search(&r) {
        Ok(_) => 0,
        Err(i) => r - b[i - 1],
    };
    let mut s = std::collections::HashMap::<usize, usize>::new();
    let mut stack = vec![];
    for i in (n - r)..n {
        if let Some(&j) = s.get(&a[i]) {
            if j < stack.len() {
                stack = stack[..j].to_vec();
                continue;
            } else {
                s.remove(&a[i]).unwrap();
            }
        }
        stack.push(a[i]);
        s.insert(a[i], stack.len() - 1);
    }
    println!(
        "{}",
        stack
            .into_iter()
            .map(|i| i.to_string())
            .collect::<Vec<_>>()
            .join(" ")
    );
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    solve(&s);
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    #[test]
    fn test_file() {
        let s = fs::read_to_string("src/bin/in").expect("foo");
        solve(&s);
    }
    //     fn test_input() {
    //         let s = "
    //         11 97
    // 3 1 4 1 5 9 2 6 5 3 5
    //         ";
    //         solve(s);
    //     }
}