// Slower C++ solution:
#include<iostream>

#include<string>

#include<stdio.h>

#include<stdlib.h>

#include<set>

#include<map>

#include<vector>

#include<queue>

#include<cstring>

using namespace std;

#define mp(a,b) make_pair(a,b)

#define pb push_back



int main(){

    long long n,k;

    cin>>n>>k;

    int a[200010], b[200010], c[200010];

    int cnt = 0;

    int start = 1;

    int over = 1;

    memset(a,0,sizeof(a));

    memset(b,0,sizeof(b));

    memset(c,-1,sizeof(c));

    for (int i=1;i<=n;i++){

        cin>>a[i];

    }

    b[0] = 1;

    c[1] = 0;

    while (true){

        //cout<<a[b[cnt]]<<" "<<cnt<<" "<<b[cnt]<<endl;

        long long cur = a[b[cnt]];

        if (c[cur] >= 0){

            start = c[cur];

            over  = cnt;

            break;

        }

        cnt++;

        b[cnt] = cur;

        c[cur] = cnt;

    }

    int total = over - start + 1;

    int ex = (k - start +1) % total;

    //cout<<start<<" "<<over<<" "<<ex<<endl;

    if (k <= over){

         cout<<b[k];

    }else{

        if (ex == 0){

            cout<<b[over];

        }else{

            cout<<b[start - 1 + ex];

        }

    }





//    system("pause");

}


// Faster C++ solution for the same problem (measured speedup: 3.3912139167792614x):
#include<bits/stdc++.h>

#include<iostream>

#include<string>

#include<cmath>

#include<cstdio>

#include<cctype>

#include<cstring>

#include<iomanip>

#include<cstdlib>

#include<ctime>

#include<set>

#include<map>

#include<utility>

#include<queue>

#include<vector>

#include<stack>

#include<sstream>

#include<algorithm>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

typedef pair<int,int> pii;

typedef pair<pii,pii> piiii;

typedef vector<pii> vii;

typedef vector<int> vi;

typedef queue<int> qi;

typedef queue<char> qc;

typedef queue<string> qs;

typedef vector<char> vc;

typedef vector<string> vs;

typedef map<char,int> mpci;

typedef map<int,int> mpii;

typedef map<string,int> mpsi;

typedef set<int> sei;

typedef set<char> sec;

typedef set<string> ses;

typedef stack<ll> si;

typedef stack<char> sc;

typedef vector<ll> vll;

typedef vector<vi> vvi;

typedef vector<double> vd;

typedef pair<ll,ll> pll;

typedef pair<double,double> pdd;

typedef vector<pll> vpll;

typedef vector<pdd> vdd;

typedef unsigned int uint;

typedef long double ld;

typedef vector<bool> vb;

typedef vector<double> vd;

typedef vector<vi> vvi;

typedef vector<vvi> vvvi;

typedef vector<vii> vvii;

/*=====================================================================*/

#define pb push_back

#define rep(i,n) for(int i=0;i<(int)(n);i++)

#define sz(a) (int)(a.size())

#define len(a) (int)(a.length())

#define all(s) (s).begin(),(s).end()

#define fi first

#define se second

#define be begin

#define en end

#define m_p make_pair

#define repd(i,n) for(int i=n-1;i>=0;i--)

#define forn(i,p,n) for(int i=p;i<=n;i++)

#define ford(i,p,n) for(int i=n;i>=p;i--)

#define foreach(i,c) for(__typeof(c.begin())i=(c.begin());i!=(c).end();++i)

#define zero(a) memset(a,0,sizeof(a))

#define number(a,num) memeset(a,num,sizeof(a))

#define INF 1e9

#define PI acos(-1)



/*=====================================================================*/



inline void read(int &x)

{

	short negative=1;

    x=0;

    char c=getchar();

    while(c<'0' || c>'9')

    {

		if(c=='-')

			negative=-1;

		c=getchar();

	}

    while(c>='0' && c<='9')

        x=(x<<3)+(x<<1)+(c^48),c=getchar();

    x*=negative;

}

inline void write(long long x) {

  static long long sta[35];

  long long top = 0;

  do {

    sta[top++] = x % 10, x /= 10;

  } while (x);

  while (top) putchar(sta[--top] + 48);

  puts("");

}

void finish(string s)

{

	cout<<s<<endl;

	exit(0);

}

string int_to_string(int n)

{

	string s="";

	while(n)

	{

		int now=n%10;

		s+=now+'0';

		n/=10;

	}

	reverse(s.begin(),s.end());

	return s;

}

int string_to_int(string s)

{

	int n=0;

	rep(i,s.size())

	{

		n*=10;

		n+=s[i]-'0';

	}

	return n;

}

/*======================================================================*/

ll lcm(int a,int b)

{

	return a/__gcd(a,b)*b;

}

bool prime(int n)

{

	if(n==0||n==1)

	  return false;

	for(int i=2;i*i<=n;i++)

	  if(n%i==0)

	    return false;

	return true;

}

const ll power(int n,int k)

{

	ll t=1;

	rep(i,k)

	  t*=n;

	return t;

}

const string turn2(int n)

{

	string s="";

	while(n!=0)

	{

		s+=(char)(n%2+'0');

		n/=2;

	}

	reverse(s.begin(),s.end());

	return s;

}

string turn(int n,int k)

{

	string s="";

	while(n)

	{

		s+=(char)(n%k+'0');

		n/=k;

	}

	reverse(s.begin(),s.end());

	return s;

}

const string turn16(int n)

{

	string s="";

	while(n!=0)

	{

		if(n%16>9)

		  s+=(char)('A'+n%16-10);

		else

		  s+=(char)('0'+n%16);

		n/=16;

	}

	reverse(s.begin(),s.end());

	return s;

}

/*

void merge(int a[],int left,int mid,int right)

{

	int n1=mid-left;

	int n2=right-mid;

	for(int i=0;i<n1;i++)

	{

	  l[i]=a[i+left];

    }

	for(int i=0;i<n2;i++)

	{

	  r[i]=a[mid+i];

	}

	r[n2]=l[n1]=INF;

	int i=0;

	int j=0;

	for(int k=left;k<right;k++)

	{

		if(l[i]<=r[j])

		{

			a[k]=l[i++];

		}

		else

		{

			a[k]=r[j++];

		}

	}

}

void mergesort(int a[],int left,int right)

{

	if(left+1<right)

	{

		int mid=(left+right)/2;

		mergesort(a,left,mid);

		mergesort(a,mid,right);

		merge(a,left,mid,right);

	}

}

int binsearch(int x,int v[],int n)

{

	int low=0,high=n-1;

	int mid;

	while(low<=high)

	{

		mid=(low+high)/2;

		if(x<v[mid])

		  high=mid-1;

		else

		  if(x>v[mid])

		    low=mid+1;

		  else

		    return mid+1;

	}

	return -1;

}

int partition(int a[],int left,int right)

{

	int p=a[left];

	int i=left;

	int j=right+1;

	for(;;)

	{

		while(a[++i]<p)

		  if(i>=right)

		    break;

		while(a[j--]>p)

		  if(j<=left)

		    break;

		if(i>=j)

		  break;

		else

		  swap(a[i],a[j]);

	}

	if(j>=left)

	  return j;

	swap(a[left],a[j]);

	return j;

}

void quicksort(int a[],int left,int right)

{

	int q;

	while(right>left)

	{

		q=partition(a,left,right);

	    if(n-q+1==k)

	    {

	        cout<<a[q];

	  		exit(0);

		}

		quicksort(a,left,q-1);

		quicksort(a,q+1,right);

	}

}

void dfs(int n)

{

	if(use[n])

	  return;

	use[n]=true;

	cout<<n<<endl;

	for(int i=0;i<v[n].size();i++)

	  dfs(v[n][i]);

}*/

/*======================================================================*/

const int dx[]={-1,0,1,0};

const int dy[]={0,-1,0,1};

const int month[2][12]={{31,28,31,30,31,30,31,31,30,31,30,31},{31,29,31,30,31,30,31,31,30,31,30,31}};

int dp[200020][100],a[200020];

/*======================================================================*/

int main()

{

  /*

	freopen("input.txt","r",stdin);

	freopen("output.txt","w",stdout);

  */

  /*====================================================================*/

  int n;

  ll m;

  cin>>n>>m;

  forn(i,1,n)

  {

  	cin>>a[i];

  }

  forn(i,1,n)

  {

  	dp[i][0]=a[i];

  }

  forn(j,0,70)

  {

  	forn(i,1,n)

  	{

  		dp[i][j+1]=dp[dp[i][j]][j];

	}

  }

  /*forn(i,1,n)

  {

  	forn(j,0,70)

  	{

  	  cout<<dp[i][j]<<" ";	

	}

	cout<<endl;

  }*/

  ll now=m,t=0,ans=1;

  while(now)

  {

  	if(now%2)

  	{

  	  	ans=dp[ans][t];

	}

	t++;

	now/=2;

  }

  cout<<ans<<endl;

  return 0; 

}