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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
  "bufio"
  "container/list"
  "fmt"
  "os"
  "strconv"
  "strings"
)

func main() {
  input := Input{bufio.NewReaderSize(os.Stdin,10000)}
  n,k := input.NextInts()
  a := input.NextIntArray()
  idx := map[int]int{}
  g := make([][]int64,60)
  for i:=0;i<60;i++ { g[i] = make([]int64,n) }
  for i:=0;i<n;i++ {
    if _,ok := idx[a[i]];!ok { idx[a[i]] = n+i }
  }
  for i:=n-1;i>-1;i-- {
    g[0][i] = int64(idx[a[i]]-i)
    idx[a[i]] = i
  }
  x := int64(0)
  r := int64(n)*k-1
  for i:=1;i<60;i++ {
    for j:=0;j<n;j++ {
      if g[i-1][(g[i-1][j]+int64(j))%int64(n)]+g[i-1][j] <= 2*(r+1) {
        g[i][j] = g[i-1][(g[i-1][j]+int64(j))%int64(n)]+g[i-1][j]
      }
    }
  }
  for x+g[0][x%int64(n)] <= r {
    for i:=59;i>-1;i-- {
      if x+g[i][x%int64(n)] <= r { x += g[i][x%int64(n)] }
    }
  }
  queue := list.New()
  set := make(map[int]struct{})
  for ;x<=r;x++ {
    if _,ok := set[a[x%int64(n)]];ok {
      for {
        y,_ := queue.Remove(queue.Back()).(int)
        delete(set,y)
        if y == a[x%int64(n)] { break }
      }
      continue
    }
    queue.PushBack(a[x%int64(n)])
    set[a[x%int64(n)]] = struct{}{}
  }
  for queue.Len() > 0 {
    v,_ := queue.Remove(queue.Front()).(int)
    fmt.Print(v)
    if queue.Len() == 0 { break }
    fmt.Print(" ")
  }
  fmt.Println()
}

type Input struct { reader *bufio.Reader }
func(i *Input) NextLine() string {
  var buffer []byte
  for {
    line,isPrefix,err := i.reader.ReadLine()
    if err != nil { panic(err) }
    buffer = append(buffer,line...)
    if !isPrefix { break }
  }
  return string(buffer)
}
func(i *Input) NextInts() (int,int64) {
  s := strings.Fields(i.NextLine())
  x,_ := strconv.Atoi(s[0])
  y,_ := strconv.ParseInt(s[1],10,64)
  return x,y
}
func(i *Input) NextIntArray() []int {
  s := strings.Fields(i.NextLine())
  a := make([]int,len(s))
  for i:=0;i<len(s);i++ { a[i],_ = strconv.Atoi(s[i]) }
  return a
}