#include <bits/stdc++.h>
using namespace std;

#define ll long long
const int MAXN = 355;

int n;
ll dp[MAXN][MAXN]; // dp[i][j]: LCM lớn nhất có thể đạt được khi xét các số từ 2 đến p[j] (số nguyên tố thứ j) với tổng các số là i
vector<int> primes;

void sieve(int n) {
    vector<bool> is_prime(n + 1, true);
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i * i <= n; i++) {
        if (is_prime[i]) {
            for (int j = i * i; j <= n; j += i)
                is_prime[j] = false;
        }
    }
    for (int i = 2; i <= n; i++) {
        if (is_prime[i]) primes.push_back(i);
    }
}

int main() {
    cin >> n;
    sieve(n);

    // Khởi tạo
    for (int i = 0; i <= n; i++) dp[i][0] = 1;

    ll ans = 1;
    int m = primes.size();

    for (int j = 1; j <= m; j++) {
        int p = primes[j-1];
        for (int i = 0; i <= n; i++) {
            dp[i][j] = dp[i][j-1]; // Bỏ qua số p
            // Thêm các bội của p (p, p^2, ...) vào dãy
            ll val = p;
            while (val <= i) {
                dp[i][j] = max(dp[i][j], dp[i - val][j-1] * val);
                if (val > (LLONG_MAX / p)) break; // Tránh tràn số
                val *= p;
            }
            if (i == n) ans = max(ans, dp[i][j]);
        }
    }
    cout << ans << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

typedef unsigned long long ull;
const int N = 355;

int n;
ull dp[N]; // dp[x]: LCM lớn nhất với tổng x
vector<int> primes;

void sieve(int limit) {
    vector<bool> is_prime(limit + 1, true);
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i <= limit; i++) {
        if (is_prime[i]) {
            primes.push_back(i);
            for (int j = i * i; j <= limit; j += i) is_prime[j] = false;
        }
    }
}

int main() {
    cin >> n;
    sieve(n);

    for (int i = 0; i <= n; i++) dp[i] = 1;

    ull ans = 1;

    for (int p : primes) {
        // Duyệt ngược để đảm bảo mỗi loại số chỉ dùng 1 lần (tương tự bài toán túi đồ)
        // Tuy nhiên, do LCM yêu cầu, ta cần xét các hệ số lũy thừa
        // Ta dùng mảng temp để lưu kết quả mới
        ull temp[N];
        for (int i = 0; i <= n; i++) temp[i] = dp[i];

        for (int i = n; i >= 0; i--) {
            ll val = p;
            while (val <= i) {
                // Nếu dùng val (là p, p^2, ...), tổng còn lại là i - val
                // LCM mới = LCM cũ * val (vì val là lũy thừa của p, và các số trước không chứa p)
                // Tuy nhiên, phải chú  ý: dp[i - val] có thể đã chứa p?
                // Không, vì ta duyệt qua các số nguyên tố tuần tự, mỗi số nguyên tố chỉ xét 1 lần.
                // Nên dp[i - val] không chứa thừa số p.
                temp[i] = max(temp[i], dp[i - val] * val);

                if (val > (1e18 / p)) break;
                val *= p;
            }
        }
        // Cập nhật lại dp sau khi xử lý xong số p
        for (int i = 0; i <= n; i++) {
            dp[i] = temp[i];
            if (i == n) ans = max(ans, dp[i]);
        }
    }

    cout << ans << endl;
    return 0;
}

// Ý tưởng: Sử dụng các số nguyên tố nhỏ để tạo ra LCM lớn nhất.
// Do n nhỏ, ta có thể liệt kê các số nguyên tố.
// LCM lớn nhất sẽ là tích của các số nguyên tố hoặc lũy thừa của chúng.
// Ví dụ: n=7, ta có thể dùng 3 và 4 (tức 2^2 * 3). Tổng = 7, LCM = 12.
// n=10, ta có thể dùng 2, 3, 5 (tổng 10, LCM 30).
// Hoặc 2*2=4, 3, 3 (tổng 10, LCM 12).
// Cách này về cơ bản là tìm cách phân tách n thành các số sao cho tích (LCM) lớn nhất.
// Do n <= 350, có thể dùng DP.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

typedef unsigned long long ull;

int main() {
    int n;
    cin >> n;
    vector<int> primes;
    for (int i = 2; i <= n; i++) {
        bool ok = true;
        for (int j = 2; j * j <= i; j++) {
            if (i % j == 0) { ok = false; break; }
        }
        if (ok) primes.push_back(i);
    }

    // dp[i] là LCM lớn nhất với tổng i
    vector<ull> dp(n + 1, 1);

    for (int p : primes) {
        vector<ull> next_dp = dp;
        for (int i = 0; i <= n; i++) {
            ull val = p;
            while (i + val <= n) {
                next_dp[i + val] = max(next_dp[i + val], dp[i] * val);
                val *= p;
            }
        }
        dp = next_dp;
    }

    cout << dp[n] << endl;
    return 0;
}