Sparse_TL

// TL10 https://codeforces.com/gym/100093/attachments E

# include <iostream>
# include <vector>
# include <limits>
# include <fstream>
int main() {
    uint64_t n, m, a;
    std::ifstream in;
    in.open("sparse.in");
    std::ofstream out;
    out.open("sparse.out");
    in >> n >> m >> a;
    std::vector<uint64_t> vec(n);
    std::vector<uint64_t> p(n + 1, 0); // логарифм с округлением вниз
    uint64_t u1, u2, u1_cur, u2_cur;
    in >> u1 >> u2;
    u1--;
    u2--;
    vec[0] = a;
    for (uint64_t i = 1; i < n; i++) {
        vec[i] = (23 * vec[i - 1] + 21563) % 16'714'589;
    }

    for (uint64_t base = 1, j = 0; base <= n; base *= 2, j++) {
        p[base] = j;
    }

    uint64_t cur = 0;
    for (uint64_t i = 0; i <= n; i++) {
        if (p[i] == 0) {
            p[i] = cur;
        } else {
            cur = p[i];
        }
    }

    std::vector<uint64_t>pow_2(p[n] + 1); // 2^n
    for (uint64_t i = 0, base = 1; base <= n; base *= 2, i++) {
        pow_2[i] = base;
    }

    std::vector<std::vector<uint64_t>> min_value(n, std::vector<uint64_t>(p[n] + 1, std::numeric_limits<uint64_t>::max()));

    for (uint64_t i = 0; i < n; i++) {
        min_value[i][0] = vec[i];
    }
    for (uint64_t j = 1; j <= p[n]; j++) {
        for (uint64_t i = 0; i + pow_2[j] <= n; i++) {
            min_value[i][j] = std::min(min_value[i][j - 1], min_value[i + pow_2[j - 1]][j - 1]);
        }
    }
    uint64_t j = p[std::max(u1, u2) - std::min(u1, u2) + 1];
    uint64_t ans = std::min(min_value[std::min(u1, u2)][j], min_value[std::max(u1, u2) - (pow_2[j] - 1)][j]);
    for (uint64_t i = 2; i <= m; i++) {
        u1 = ((17 * (u1 + 1) + 751 + ans + 2 * (i - 1)) % n);
        u2 = ((13 * (u2 + 1) + 593 + ans + 5 * (i - 1)) % n);
        j = p[std::max(u1, u2) - std::min(u1, u2) + 1];
        ans = std::min(min_value[std::min(u1, u2)][j], min_value[std::max(u1, u2) - (pow_2[j] - 1)][j]);
    }
    out << u1 + 1 << ' ' << u2 + 1 << ' ' << ans;
    in.close();
    out.close();
    return 0;
}