OI XXIX - arm

// https://szkopul.edu.pl/problemset/problem/gxeCvLD1xW1t-Y33bbC0n3wZ/statement/

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

// #define int int64_t

constexpr int sizik = 1000 * 1001;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

[[nodiscard]] inline bool pow_le(uint64_t base, uint32_t exp, uint64_t limit) noexcept {
    if (base <= 1) return true;

    uint64_t res = 1;
    for (uint32_t i = 0; i < exp; i++) {
        if (res > limit / base) {
            return false;
        }
        res *= base;
    }
    return true;
}

[[nodiscard]] inline uint64_t integer_kth_root(uint64_t n, uint32_t k) noexcept {
    if (k == 0) return 0;
    if (n <= 1 || k == 1) return n;
    if (k >= 64) return 1;

    if (k == 2) {
        uint64_t r = static_cast<uint64_t>(std::sqrt(static_cast<double>(n)));
        if (r + 1 <= n / (r + 1)) {
            ++r;
        } else if (r > n / r) {
            --r;
        }
        return r;
    }

    uint64_t r = static_cast<uint64_t>(std::pow(static_cast<double>(n), 1.0 / k));

    if (pow_le(r + 1, k, n)) {
        ++r;
    } else if (!pow_le(r, k, n)) {
        --r;
    }

    return r;
}

int64_t koszt(int32_t k, int32_t p, int64_t a, int64_t b, int64_t r) {
    return (int64_t)k * a + b * (k * (r - 1) + p);
}

bool check(int64_t r, int64_t k, int64_t p, int64_t n) {
    int64_t u = n;
    for (int i = 0; i < p; i++) {
        u = (u + r) / (r + 1);
    }
    for (int i = 0; i < k - p; i++) {
        u = (u + r - 1) / r;
    }
    return u <= 1;
}

void solver(int64_t n, int64_t a, int64_t b) {
    int64_t ans = INT64_MAX;

    if (b == 0 || (n - 1) <= (INT64_MAX - a) / b) {
        ans = a + b * (n - 1);
    }

    for (int k = 2; k <= 60; k++) {
        int64_t r = integer_kth_root(n, k);

        if (!check(r, k, k, n)) {
            continue;
        }

        int l = 0, rr = k;
        while (l < rr) {
            int s = (l + rr) / 2;
            if (check(r, k, s, n)) {
                rr = s;
            } else {
                l = s + 1;
            }
        }

        int p = l;
        ans = std::min(ans, koszt(k, p, a, b, r));
    }

    std::cout << ans << '\n';
}

void solve() {
    int64_t n, a, b;
    std::cin >> n >> a >> b;

    solver(n + 1, a, b);
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}