import sys

sys.setrecursionlimit(1000000000)

import math

from math import gcd

def lcm(a, b): return a * b // gcd(a, b)

from itertools import count, permutations, chain

from functools import lru_cache

from collections import deque, defaultdict

from pprint import pprint

ii = lambda: int(eval(input()))

mis = lambda: list(map(int, input().split()))

lmis = lambda: list(mis())

INF = float('inf')

N1097 = 10**9 + 7



def meg(f, ok, ng):

    while abs(ok-ng)>1:

        mid = (ok+ng)//2

        if f(mid):

            ok=mid

        else:

            ng=mid

    return ok



def get_inv(n, modp):

    return pow(n, modp-2, modp)



def factorials_list(n, modp):    # 10**6

    fs = [1]

    for i in range(1, n+1):

        fs.append(fs[-1] * i % modp)

    return fs



def invs_list(n, fs, modp):     # 10**6

    invs = [get_inv(fs[-1], modp)]

    for i in range(n, 1-1, -1):

        invs.append(invs[-1] * i % modp)

    invs.reverse()

    return invs



def comb(n, k, modp):

    num = 1

    for i in range(n, n-k, -1):

        num = num * i % modp

    den = 1

    for i in range(2, k+1):

        den = den * i % modp

    return num * get_inv(den, modp) % modp



def comb_from_list(n, k, modp, fs, invs):   

    return fs[n] * invs[n-k] * invs[k] % modp



#



class UnionFindEx:

    def __init__(self, size):

        #正なら根の番号、負ならグループサイズ

        self.roots = [-1] * size

    def getRootID(self, i):

        r = self.roots[i]

        if r < 0:   #負なら根

            return i

        else:

            r = self.getRootID(r)

            self.roots[i] = r

            return r

    def getGroupSize(self, i):

        return -self.roots[self.getRootID(i)]

    def connect(self, i, j):

        r1, r2 = self.getRootID(i), self.getRootID(j)

        if r1 == r2:

            return False

        if self.getGroupSize(r1) < self.getGroupSize(r2):

            r1, r2 = r2, r1

        self.roots[r1] += self.roots[r2]    #サイズ更新

        self.roots[r2] = r1

        return True



Yes = 'Yes'

No = 'No'





def main():

    N, K = mis()

    A = [a-1 for a in mis()]

    B = [None]*N

    now = 0

    B[now] = 0

    for i in range(1, K+1):

        now = A[now]

        K -= 1

        if B[now] is not None:

            K %= (i - B[now])

            break

        B[now] = i

    for _ in range(K):

        now = A[now]

    print((now+1))



main()



'''

・基本的には素直なシミュレーションを行う

・ループ分のシミュレーションを省略することでTLEを回避

・Kは「残りのワープ数」と考える



K回のワープ中にループが含まれる場合、

1. 素直なシミュレーションを行う。このとき、Kを減算していく。

2. ループを検出したら、Kからループ長をできるだけ多く引くことで、計算を省略する。

3. 残りのステップ数、再度シミュレーションを行う

という手順で答えを求められる。

なお、ループが含まれない場合も1のみで答えを求められる。

'''



def main():

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

    A = [a-1 for a in map(int, input().split())]    # 0-indexed に変換

    B = [None]*N    # 何ステップ目に到達したかを記録。Noneなら未到達を表す

    now = 0         # 現在地

    step = 0        # ステップ数

    B[now] = 0      # 開始地点は、0ステップ目に到達済みとする

    while K:

        now = A[now]    # 現在地を更新 

        step += 1

        K -= 1

        if B[now] is not None:  # ループを検出したら...

            K %= (step - B[now])      # Kからループ長さを引けるだけ引く

        else:

            B[now] = step  # 到達したステップ数を記録

    print((now+1))    # 1-indexed に再変換



main()



import sys

sys.setrecursionlimit(1000000000)
import math
from math import gcd


def lcm(a, b):
    return a * b // gcd(a, b)


from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint

ii = lambda: int(eval(input()))
mis = lambda: list(map(int, input().split()))
lmis = lambda: list(mis())
INF = float("inf")
N1097 = 10**9 + 7


def meg(f, ok, ng):
    while abs(ok - ng) > 1:
        mid = (ok + ng) // 2
        if f(mid):
            ok = mid
        else:
            ng = mid
    return ok


def get_inv(n, modp):
    return pow(n, modp - 2, modp)


def factorials_list(n, modp):  # 10**6
    fs = [1]
    for i in range(1, n + 1):
        fs.append(fs[-1] * i % modp)
    return fs


def invs_list(n, fs, modp):  # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1 - 1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs


def comb(n, k, modp):
    num = 1
    for i in range(n, n - k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k + 1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp


def comb_from_list(n, k, modp, fs, invs):
    return fs[n] * invs[n - k] * invs[k] % modp


#
class UnionFindEx:
    def __init__(self, size):
        # 正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size

    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:  # 負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r

    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]

    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]  # サイズ更新
        self.roots[r2] = r1
        return True


Yes = "Yes"
No = "No"


def main():
    N, K = mis()
    A = [a - 1 for a in mis()]
    B = [None] * N
    now = 0
    B[now] = 0
    for i in range(1, K + 1):
        now = A[now]
        K -= 1
        if B[now] is not None:
            K %= i - B[now]
            break
        B[now] = i
    for _ in range(K):
        now = A[now]
    print((now + 1))


main()

"""
・基本的には素直なシミュレーションを行う
・ループ分のシミュレーションを省略することでTLEを回避
・Kは「残りのワープ数」と考える
K回のワープ中にループが含まれる場合、
1. 素直なシミュレーションを行う。このとき、Kを減算していく。
2. ループを検出したら、Kからループ長をできるだけ多く引くことで、計算を省略する。
3. 残りのステップ数、再度シミュレーションを行う
という手順で答えを求められる。
なお、ループが含まれない場合も1のみで答えを求められる。
"""


def main():
    N, K = list(map(int, input().split()))
    A = [a - 1 for a in map(int, input().split())]  # 0-indexed に変換
    B = [None] * N  # 何ステップ目に到達したかを記録。Noneなら未到達を表す
    now = 0  # 現在地
    step = 0  # ステップ数
    B[now] = 0  # 開始地点は、0ステップ目に到達済みとする
    while K:
        now = A[now]  # 現在地を更新
        step += 1
        K -= 1
        if B[now] is not None:  # ループを検出したら...
            K %= step - B[now]  # Kからループ長さを引けるだけ引く
        else:
            B[now] = step  # 到達したステップ数を記録
    print((now + 1))  # 1-indexed に再変換


main()

-import sys - -sys.setrecursionlimit(1000000000) -import math -from math import gcd - - -def lcm(a, b): -    return a * b // gcd(a, b) - - -from itertools import count, permutations, chain -from functools import lru_cache -from collections import deque, defaultdict -from pprint import pprint - -ii = lambda: int(eval(input())) -mis = lambda: list(map(int, input().split())) -lmis = lambda: list(mis()) -INF = float("inf") -N1097 = 10**9 + 7 - - -def meg(f, ok, ng): -    while abs(ok - ng) > 1: -        mid = (ok + ng) // 2 -        if f(mid): -            ok = mid -        else: -            ng = mid -    return ok - - -def get_inv(n, modp): -    return pow(n, modp - 2, modp) - - -def factorials_list(n, modp):  # 10**6 -    fs = [1] -    for i in range(1, n + 1): -        fs.append(fs[-1] * i % modp) -    return fs - - -def invs_list(n, fs, modp):  # 10**6 -    invs = [get_inv(fs[-1], modp)] -    for i in range(n, 1 - 1, -1): -        invs.append(invs[-1] * i % modp) -    invs.reverse() -    return invs - - -def comb(n, k, modp): -    num = 1 -    for i in range(n, n - k, -1): -        num = num * i % modp -    den = 1 -    for i in range(2, k + 1): -        den = den * i % modp -    return num * get_inv(den, modp) % modp - - -def comb_from_list(n, k, modp, fs, invs): -    return fs[n] * invs[n - k] * invs[k] % modp - - -# -class UnionFindEx: -    def __init__(self, size): -        # 正なら根の番号、負ならグループサイズ -        self.roots = [-1] * size - -    def getRootID(self, i): -        r = self.roots[i] -        if r < 0:  # 負なら根 -            return i -        else: -            r = self.getRootID(r) -            self.roots[i] = r -            return r - -    def getGroupSize(self, i): -        return -self.roots[self.getRootID(i)] - -    def connect(self, i, j): -        r1, r2 = self.getRootID(i), self.getRootID(j) -        if r1 == r2: -            return False -        if self.getGroupSize(r1) < self.getGroupSize(r2): -            r1, r2 = r2, r1 -        self.roots[r1] += self.roots[r2]  # サイズ更新 -        self.roots[r2] = r1 -        return True - - -Yes = "Yes" -No = "No" +""" +・基本的には素直なシミュレーションを行う +・ループ分のシミュレーションを省略することでTLEを回避 +・Kは「残りのワープ数」と考える +K回のワープ中にループが含まれる場合、 +1. 素直なシミュレーションを行う。このとき、Kを減算していく。 +2. ループを検出したら、Kからループ長をできるだけ多く引くことで、計算を省略する。 +3. 残りのステップ数、再度シミュレーションを行う +という手順で答えを求められる。 +なお、ループが含まれない場合も1のみで答えを求められる。 +""" -    N, K = mis() -    A = [a - 1 for a in mis()] -    B = [None] * N -    now = 0 -    B[now] = 0 -    for i in range(1, K + 1): -        now = A[now] +    N, K = list(map(int, input().split())) +    A = [a - 1 for a in map(int, input().split())]  # 0-indexed に変換 +    B = [None] * N  # 何ステップ目に到達したかを記録。Noneなら未到達を表す +    now = 0  # 現在地 +    step = 0  # ステップ数 +    B[now] = 0  # 開始地点は、0ステップ目に到達済みとする +    while K: +        now = A[now]  # 現在地を更新 +        step += 1 -        if B[now] is not None: -            K %= i - B[now] -            break -        B[now] = i -    for _ in range(K): -        now = A[now] -    print((now + 1)) +        if B[now] is not None:  # ループを検出したら... +            K %= step - B[now]  # Kからループ長さを引けるだけ引く +        else: +            B[now] = step  # 到達したステップ数を記録 +    print((now + 1))  # 1-indexed に再変換