#if !defined(__clang__) && defined(__GNUC__)
#include <bits/stdc++.h>
#else
#include <cstdlib>
#include <climits>
#include <iostream>
#include <cstdint>
#include <vector>
#include <string>
#include <complex>
#include <bitset>
#include <queue>
#include <deque>
#include <stack>
#include <utility>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <regex>
#endif //  !defined(__clang__) && defined(__GNUG__)
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/multi_array.hpp>
#include <boost/optional.hpp>
#include <boost/math/common_factor_rt.hpp>

using namespace std;


/* エラトステネスのふるい

   O(n log log n) だいたい線形。 10万とかは余裕
*/
template<typename T>
std::vector<T> sieve(T n)
{
    std::vector<T> primes;
    std::vector<bool> is_prime(n, true);
    is_prime[0] = is_prime[1] = false;

    for (T i = 2; i <= n; ++i) {
        if (is_prime[i]) {
            primes.push_back(i);
            for (T j = 2 * i; j <= n; j += i) {
                is_prime[j] = false;
            }
        }
    }
    return primes;
}


/** 素因数分解
 */
template<typename T>
std::map<T, size_t>&
factor( T n, const std::vector<T>& primes, std::map<T, size_t>& ret) {
    auto f = primes.begin();
    while (n > 1) {
        while (n % *f == 0) {
            ret[*f] = ret[*f] + 1;
            n /= *f;
        }
        ++f;
    }

    return ret;
}

int main()
{
    int64_t N;
    std::cin >> N;

    for (int64_t i = 3; i <= sqrt(N); ++i) {
        if (N % i == 0) {
            std::cout << i << std::endl;
            return 0;
        }
    }

    if (N % 2 == 0 && N / 2 != 2) {
        std::cout << N/2 << std::endl;
    }
    else {
        std::cout << N << std::endl;
    }
    return 0;
}