import sys
import random
from math import gcd
from collections import Counter
from itertools import product

def is_prime(n):
    if n < 2:
        return False
    for p in [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]:
        if n % p == 0:
            return n == p
    d = n - 1
    s = 0
    while d % 2 == 0:
        d //= 2
        s += 1
    for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
        if a >= n:
            continue
        x = pow(a, d, n)
        if x == 1 or x == n - 1:
            continue
        for _ in range(s - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

def pollards_rho(n):
    if n % 2 == 0:
        return 2
    if n % 3 == 0:
        return 3
    if n % 5 == 0:
        return 5
    while True:
        c = random.randint(1, n - 1)
        f = lambda x: (pow(x, 2, n) + c) % n
        x, y, d = 2, 2, 1
        while d == 1:
            x = f(x)
            y = f(f(y))
            d = gcd(abs(x - y), n)
        if d != n:
            return d

def factor(n):
    factors = []
    if n == 1:
        return factors
    if is_prime(n):
        factors.append(n)
        return factors
    d = pollards_rho(n)
    factors += factor(d)
    factors += factor(n // d)
    return factors

def divisors(n):
    if n == 0:
        return []
    prime_factors = factor(n)
    cnt = Counter(prime_factors)
    primes = list(cnt.keys())
    exponents = [list(range(cnt[p] + 1)) for p in primes]
    divs = []
    for exp in product(*exponents):
        d = 1
        for p, e in zip(primes, exp):
            d *= p ** e
        divs.append(d)
    divs = list(set(divs))
    divs.sort()
    return divs

def solve():
    N_str = sys.stdin.read().strip()
    N = int(N_str)
    if N == 4:
        print(3)
        return
    
    candidate1 = []
    if N > 1:
        n_minus_1 = N - 1
        divs = divisors(n_minus_1)
        for w in divs:
            if w <= 1:
                continue
            if n_minus_1 % w != 0:
                continue
            h = n_minus_1 // w
            valid = True
            for i in range(h + 1):
                num = 1 + i * w
                if num == 1:
                    continue
                if is_prime(num):
                    valid = False
                    break
            if valid:
                candidate1.append(w)
    
    candidate2 = []
    r_limit = min(1000, N)
    for r in range(1, r_limit + 1):
        W_candidate = N - r
        if W_candidate <= 1:
            continue
        if r >= W_candidate:
            continue
        start = W_candidate + 1
        end = W_candidate + r
        if start > end:
            continue
        if is_prime(start):
            continue
        all_composite = True
        for num in range(start, end + 1):
            if is_prime(num):
                all_composite = False
                break
        if all_composite:
            candidate2.append(W_candidate)
    
    min_candidate = float('inf')
    if candidate1:
        min_candidate = min(candidate1)
    if candidate2:
        min_c2 = min(candidate2)
        if min_c2 < min_candidate:
            min_candidate = min_c2
    print(min_candidate)

if __name__ == "__main__":
    solve()