#include <bits/stdc++.h>
 
using namespace std;
 
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ld,ld> pdd;
 
#define X first
#define Y second
 
const int MAXP = 25100000;
const int MAXN = MAXP+10;
const ld pi = 3.1415926535897932384626433;
 
bool b[MAXN];
int tot, p[MAXN];
int u[MAXN];
 
void ready()
{
	u[1] = 1;
	for (int i = 2; i <= MAXP; ++ i)
	{
		if (!b[i])
		{
			p[++ tot] = i;
			u[i] = -1;
		}
		for (int j = 1, t; (t = i*p[j]) <= MAXP; ++ j)
		{
			b[t] = 1;
			if (i%p[j] == 0)
			{
				u[t] = 0;
				break;
			}
			u[t] = -u[i];
		}
		u[i] += u[i-1];
	}
}
 
const int MAXI = 100010;
 
int x[MAXI];
ull M[MAXI];
 
int len, v[MAXI];
 
ull myroot(ull n, int e)
{
	ull pn = pow(n, (ld)1/e);
	while (1)
	{
		ull tmp = 1;
		for (int i = 1; i <= e; ++ i) tmp *= pn+1;
		if (tmp > n) break;
		++ pn;
	}
	return pn;
}
 
bool is_square(ull n)
{
	ull pn = myroot(n, 2);
	return pn*pn == n;
}
 
void trans(int n, int &len, int *s)
{
	int pn = sqrt(n);
	len = 0;
	for (int i = 1; i <= pn; ++ i) s[++ len] = i;
	if (n != pn*pn) s[++ len] = pn+1;
	for (int i = pn; i >= 1; -- i) s[++ len] = n/i+1;
}
 
ull calc(ull n)
{
	if (n <= 1000000)
	{
		ull ret = 0;
		for (int i = 1; i <= n; ++ i)
			if (u[i] != u[i-1]) ret ++;
		return ret;
	}
	int I = myroot(n, 5)*0.85;
	for (int i = 1; i <= I; ++ i)
		x[i] = myroot(n/i, 2);
	ull D = x[I];
	M[I] = u[D];
	ull ret = (1-I)*M[I];
	for (int i = I-1; i >= 1; -- i)
	{
		trans(x[i], len, v);
		M[i] = 1;
		for (int k = 2, t; k < len; ++ k)
		{
			if ((t = x[i]/v[k]) <= D)
				M[i] -= (v[k+1]-v[k])*u[t];
			else
				M[i] -= (v[k+1]-v[k])*M[v[k]*v[k]*i];
		}
		ret += M[i];
	}
	for (int i = 1; i <= D; ++ i)
		ret += (u[i]-u[i-1])*(n/((ull)i*i));
	return ret;
}
 
const int GAP = 400000;
const int GAPS = GAP+10;
 
bool ok[GAPS];
ull val[GAPS];
 
void seive(ull L, ull R)
{
	for (ull x = L; x <= R; ++ x)
		val[x-L] = x;
	for (int i = 1; p[i] <= 1400000; ++ i)
	{
		for (ull x = (L-1)/p[i]*p[i]+p[i]; x <= R; x += p[i])
		{
			if (!ok[x-L])
			{
				val[x-L] /= p[i];
				if (val[x-L]%p[i] == 0)
					ok[x-L] = 1;
			}
		}
	}
	for (ull x = L; x <= R; ++ x)
	{
		if (!ok[x-L])
		{
			if (is_square(x)) ok[x-L] = 1;
		}
	}
}
 
void solve(ull n)
{
	ull m = n/(1-6/pi/pi);
	ull s = m-calc(m);
	if (s >= n)
	{
		ull L = m > GAP+1 ? m-GAP : 2;
		ull R = m;
		seive(L, R);
		for (ull x = R; x >= L; -- x)
			if (ok[x-L])
			{
				if (s -- == n)
				{
					cout << x << endl;
					return;
				}
			}
	}
	else
	{
		ull L = m+1;
		ull R = m+GAP;
		seive(L, R);
		for (ull x = L; x <= R; ++ x)
		{
			if (ok[x-L])
			{
				if (++ s == n)
				{
					cout << x << endl;
					return;
				}
			}
		}
	}
}
 
int main()
{
	
	ready();
	ull n;
	cin >> n;
	solve(n);
	
	return 0;
}