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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using static System.Math;
using Debug = System.Diagnostics.Debug;

static class P
{
    static void Main()
    {
        var nk = Console.ReadLine().Split().Select(long.Parse).ToArray();
        var n = (int)nk[0];
        var k = nk[1];
        var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
        //偶奇で循環しそう←ごどく
        //まあどこかで循環しそうで
        //順関節割り出してシミュレーション?
        //多分グループに分けられて、
        //範囲が消えるから後ろがつながるみたいなそういうこと?
        //消えるところまで移動→その次 で配列の先頭が求められる
        int[] hop = new int[a.Length + 1];
        int[] next = new int[a.Length + 1];
        {
            hop[n] = n;
            List<int>[] shouldCameHere = Enumerable.Repeat(0, a.Length + 1).Select(_ => new List<int>()).ToArray();
            shouldCameHere[0].Add(a.Length);
            int[] beforeInd = Enumerable.Repeat(-1, 200001).ToArray();
            for (int i = 0; i < a.Length; i++)
            {
                if (beforeInd[a[i]] != -1)
                {
                    hop[beforeInd[a[i]]] = i;

                    shouldCameHere[i + 1] = shouldCameHere[beforeInd[a[i]]];
                    shouldCameHere[beforeInd[a[i]]] = new List<int>();
                }
                shouldCameHere[i + 1].Add(i);
                beforeInd[a[i]] = i;
            }
            for (int i = 0; i < a.Length; i++)
            {
                if (beforeInd[a[i]] != -1)
                {
                    hop[beforeInd[a[i]]] = i;
                }
                beforeInd[a[i]] = -1;
            }
            for (int i = 0; i < shouldCameHere.Length; i++)
            {
                for (int j = 0; j < shouldCameHere[i].Count; j++)
                {
                    next[shouldCameHere[i][j]] = i;
                }
            }
        }
        var cycle = GetCycleCount(n, hop, next);
        Console.WriteLine(string.Join(" ", Solve(n, (int)(k % cycle), hop, next, a)));

    }

    static IEnumerable<int> Solve(int n, int k, int[] hop, int[] next, int[] a)
    {
        int ptr = n;
        for (int iterate = 0; iterate < k; iterate++)
        {
            ptr = next[hop[ptr]];
        }
        var stack = new Stack<int>();
        Simulation(a.Skip(ptr).ToArray(), stack);
        return stack.Reverse();
    }

    static int GetCycleCount(int n, int[] hop, int[] next)
    {
        int ptr = n;
        int count = 0;
        do
        {
            ptr = next[hop[ptr]];
            count++;
        } while (ptr != n);
        return count;
    }

    static void Simulation(int[] a, Stack<int> state)
    {
        HashSet<int> has = new HashSet<int>(state);
        int ptr = 0;
        for (int i = 0; i < a.Length; i++)
        {
            if (has.Contains(a[i]))
            {
                while (has.Contains(a[i]))
                {
                    has.Remove(state.Pop());
                }
                continue;
            }
            state.Push(a[i]);
            has.Add(a[i]);
        }
    }
}