

import sys

input = sys.stdin.readline



class Doubling:

    def __init__(self, A, K_max, decrement=True):

        """

        :param A: リスト。i から A[i] へと移動する

        :param K_max: K_max = 2**(k_max) まで参照する可能性がある

        :param decrement: True = A の要素の decrement が必要

        """

        N = len(A)

        k_max = K_max.bit_length()

        self.N = N

        self.doubling = [[None] * N for _ in range(k_max + 1)]

        self.decrement = decrement

        for i, a in enumerate(A):

            self.doubling[0][i] = a - self.decrement



        for i in range(1, k_max):

            for j in range(N):

                if self.doubling[i - 1][j] is None:

                    self.doubling[i][j] = None

                else:

                    self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]



    def apply(self, start, K):

        """

        :param start: スタート地点

        :param K: K回進む

        :return:

        """

        i = start - self.decrement

        for k in range(K.bit_length()):

            m = 1 << k

            if m & K:

                i = self.doubling[k][i]

            if i is None:

                break

        return i + self.decrement





######################################################################################





N, K = list(map(int, input().split()))

A = list(map(int, input().split()))

doubling = Doubling(A, 10**18 + 1, decrement=True)

print((doubling.apply(1, K)))
#####################################################################################################

##### ダブリング

#####################################################################################################



"""



全体の要素数がN個あって1回移動した時にどの要素に到達するのか定まっているとき、

「K個先の要素を求めるのに O(K) かかる」ような状況において



前処理：O(N logK) 時間, O(N logK) 空間

クエリ：O(logK)



で行うことができるようにするアルゴリズム



参考

https://algo-logic.info/doubling/



ベンチマーク

https://atcoder.jp/contests/abc167/submissions/15103640





"""



import sys

input = sys.stdin.readline



class Doubling:

    def __init__(self, A, K_max, decrement=True):

        """

        :param A: リスト。i から A[i] へと移動する

        :param K_max: K_max = 2**(k_max) まで参照する可能性がある

        :param decrement: True = A の要素の decrement が必要

        """

        N = len(A)

        k_max = K_max.bit_length()

        self.N = N

        self.doubling = [[-1] * N for _ in range(k_max + 1)]

        self.decrement = decrement

        for i, a in enumerate(A):

            self.doubling[0][i] = a - self.decrement



        for i in range(1, k_max):

            for j in range(N):

                if self.doubling[i - 1][j] == -1:

                    self.doubling[i][j] = -1

                else:

                    self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]



    def apply(self, start, K):

        """

        :param start: スタート地点

        :param K: K回進む

        :return:

        """

        i = start - self.decrement

        for k in range(K.bit_length()):

            m = 1 << k

            if m & K:

                i = self.doubling[k][i]

            if i is None:

                break

        return i + self.decrement





######################################################################################





N, K = list(map(int, input().split()))

A = list(map(int, input().split()))

doubling = Doubling(A, 10**18 + 1, decrement=True)

print((doubling.apply(1, K)))
import sys

input = sys.stdin.readline


class Doubling:
    def __init__(self, A, K_max, decrement=True):
        """
        :param A: リスト。i から A[i] へと移動する
        :param K_max: K_max = 2**(k_max) まで参照する可能性がある
        :param decrement: True = A の要素の decrement が必要
        """
        N = len(A)
        k_max = K_max.bit_length()
        self.N = N
        self.doubling = [[None] * N for _ in range(k_max + 1)]
        self.decrement = decrement
        for i, a in enumerate(A):
            self.doubling[0][i] = a - self.decrement
        for i in range(1, k_max):
            for j in range(N):
                if self.doubling[i - 1][j] is None:
                    self.doubling[i][j] = None
                else:
                    self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]

    def apply(self, start, K):
        """
        :param start: スタート地点
        :param K: K回進む
        :return:
        """
        i = start - self.decrement
        for k in range(K.bit_length()):
            m = 1 << k
            if m & K:
                i = self.doubling[k][i]
            if i is None:
                break
        return i + self.decrement


######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K)))

#####################################################################################################
##### ダブリング
#####################################################################################################
"""
全体の要素数がN個あって1回移動した時にどの要素に到達するのか定まっているとき、
「K個先の要素を求めるのに O(K) かかる」ような状況において
前処理：O(N logK) 時間, O(N logK) 空間
クエリ：O(logK)
で行うことができるようにするアルゴリズム
参考
https://algo-logic.info/doubling/
ベンチマーク
https://atcoder.jp/contests/abc167/submissions/15103640
"""
import sys

input = sys.stdin.readline


class Doubling:
    def __init__(self, A, K_max, decrement=True):
        """
        :param A: リスト。i から A[i] へと移動する
        :param K_max: K_max = 2**(k_max) まで参照する可能性がある
        :param decrement: True = A の要素の decrement が必要
        """
        N = len(A)
        k_max = K_max.bit_length()
        self.N = N
        self.doubling = [[-1] * N for _ in range(k_max + 1)]
        self.decrement = decrement
        for i, a in enumerate(A):
            self.doubling[0][i] = a - self.decrement
        for i in range(1, k_max):
            for j in range(N):
                if self.doubling[i - 1][j] == -1:
                    self.doubling[i][j] = -1
                else:
                    self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]

    def apply(self, start, K):
        """
        :param start: スタート地点
        :param K: K回進む
        :return:
        """
        i = start - self.decrement
        for k in range(K.bit_length()):
            m = 1 << k
            if m & K:
                i = self.doubling[k][i]
            if i is None:
                break
        return i + self.decrement


######################################################################################
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
doubling = Doubling(A, 10**18 + 1, decrement=True)
print((doubling.apply(1, K)))

+##################################################################################################### +##### ダブリング +##################################################################################################### +""" +全体の要素数がN個あって1回移動した時にどの要素に到達するのか定まっているとき、 +「K個先の要素を求めるのに O(K) かかる」ような状況において +前処理：O(N logK) 時間, O(N logK) 空間 +クエリ：O(logK) +で行うことができるようにするアルゴリズム +参考 +https://algo-logic.info/doubling/ +ベンチマーク +https://atcoder.jp/contests/abc167/submissions/15103640 +""" -        self.doubling = [[None] * N for _ in range(k_max + 1)] +        self.doubling = [[-1] * N for _ in range(k_max + 1)] -                if self.doubling[i - 1][j] is None: -                    self.doubling[i][j] = None +                if self.doubling[i - 1][j] == -1: +                    self.doubling[i][j] = -1