Problem:
Score: 400 points

Problem Statement

The Kingdom of Takahashi has N towns, numbered 1 through N.

There is one teleporter in each town. The teleporter in Town i (1 \leq i \leq N) sends you to Town A_i.

Takahashi, the king, loves the positive integer K. The selfish king wonders what town he will be in if he starts at Town 1 and uses a teleporter exactly K times from there.

Help the king by writing a program that answers this question.

Constraints

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

1 \leq A_i \leq N

1 \leq K \leq 10^{18}

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \dots A_N

Output

Print the integer representing the town the king will be in if he starts at Town 1 and uses a teleporter exactly K times from there.

Sample Input 1

4 5
3 2 4 1

Sample Output 1

4

If we start at Town 1 and use the teleporter 5 times, our travel will be as follows: 1 \to 3 \to 4 \to 1 \to 3 \to 4.

Sample Input 2

6 727202214173249351
6 5 2 5 3 2

Sample Output 2

2

Solution in Common Lisp (SBCL 2.0.3) (judge verdict: Accepted)

(defun get-loop-origin (n arr)
  (let ((visited (make-array n
                             :initial-contents
                             (loop repeat n collect 0))))
       (loop with pos = 0
             while t
             when (= 1 (aref visited pos))
               return (1- (aref arr pos))
             do (setf (aref visited pos) 1)
                (setf pos (1- (aref arr pos))))))

(defun get-loop-length (n arr idx)
  (let ((visited (make-array n
                             :initial-contents
                             (loop repeat n collect 0))))
       (loop with c = 0
             with pos = idx
             when (= 1 (aref visited pos))
               return c
             do (setf (aref visited pos) 1)
                (setf pos (1- (aref arr pos)))
                (incf c))))

(defun cost-until-origin (arr idx)
  (loop with c = 0
        with pos = 0
        when (= pos idx)
          return c
        do (setf pos (1- (aref arr pos)))
           (incf c)))

(defun solve (n arr k)
  (let* ((origin (get-loop-origin n arr))
         (length (get-loop-length n arr origin))
         (cost (cost-until-origin arr origin))
         (shortened-k (mod (- k cost) length)))
        (if (<= k cost)
            (loop with pos = 0
                  with rest-time = k
                  when (= rest-time 0)
                    return (1+ pos)
                  do (setf pos (1- (aref arr pos)))
                     (decf rest-time))
            (loop with pos = 0
                  with rest-time = (+ cost shortened-k)
                  when (= rest-time 0)
                    return (1+ pos)
                  do (setf pos (1- (aref arr pos)))
                     (decf rest-time)))))
              
  
(let* ((n (read))
       (k (read))
       (arr (make-array n
                        :initial-contents
                        (loop repeat n collect (read)))))
      (format t "~A" (solve n arr k)))