func_code_string: #include <bits/stdc++.h>   const uint64_t MAX_NUM = 1000000000000000001ul;   uint64_t get_iteration_simple(const int n, const uint64_t k,                                 std::vector<uint64_t>& a) {     int iterations = 0;     while (true) {       ++iterations;       for (int i = 1; i < n; ++i) {         a[i] += a[i - 1];         if (a[i] >= k) {           return iterations;         }       }     }   }   bool is_there_more_than_k_with_coeffs(       const int n, const uint64_t k, std::vector<uint64_t>& a,       std::vector<std::vector<uint64_t>>& coeffs) {     for (int i = 0; i < n; ++i) {       uint64_t result = 0;       for (int j = 0; j <= i; ++j) {         if (static_cast<double>(a[j]) * static_cast<double>(coeffs[i][j]) >             MAX_NUM) {           return true;         }         result += coeffs[i][j] * a[j];         if (result >= k) {           return true;         }       }     }     return false;   }   std::tuple<std::vector<std::vector<uint64_t>>, bool> generate_mixed_coeffs(       const int n, const uint64_t k,       std::vector<std::vector<uint64_t>>& first_coeffs,       std::vector<std::vector<uint64_t>>& second_coeffs) {     bool is_there_overflow = false;     std::vector<std::vector<uint64_t>> new_coeffs(n);     for (int i = 0; i < n; ++i) {       new_coeffs[i].resize(i + 1, 0);       for (int j = 0; j <= i; ++j) {         new_coeffs[i][j] = 0;         for (int k = j; k <= i; ++k) {           if (static_cast<double>(second_coeffs[i][k]) *                   static_cast<double>(first_coeffs[k][j]) >               MAX_NUM) {             is_there_overflow = true;           }           new_coeffs[i][j] += second_coeffs[i][k] * first_coeffs[k][j];         }       }     }     return std::make_tuple(new_coeffs, is_there_overflow);   }   uint64_t get_iteration_binsearch(const int n, const uint64_t k,                                    std::vector<uint64_t>& a) {     uint64_t left = 0;     uint64_t right = 1;     std::vector<std::vector<std::vector<uint64_t>>> level_coeffs(100);     level_coeffs[0].resize(n);     std::vector<std::vector<uint64_t>> current_coeffs(n);     for (int i = 0; i < n; ++i) {       level_coeffs[0][i].resize(i + 1, 0);       current_coeffs[i].resize(i + 1, 0);       for (int j = 0; j <= i; ++j) {         level_coeffs[0][i][j] = 1;         current_coeffs[i][j] = (i == j ? 1 : 0);       }     }     int diff_two_power = 0;     while (true) {       if (is_there_more_than_k_with_coeffs(n, k, a,                                            level_coeffs[diff_two_power])) {         break;       } else {         right *= 2;         bool is_there_overflow;         std::tie(level_coeffs[diff_two_power + 1], is_there_overflow) =             generate_mixed_coeffs(n, k, level_coeffs[diff_two_power],                                   level_coeffs[diff_two_power]);         ++diff_two_power;         if (is_there_overflow) {           break;         }       }     }     while (right - left > 1) {       uint64_t middle = left + (1ull << (diff_two_power - 1));       std::vector<std::vector<uint64_t>> middle_coeffs;       bool is_there_overflow;       std::tie(middle_coeffs, is_there_overflow) = generate_mixed_coeffs(           n, k, current_coeffs, level_coeffs[diff_two_power - 1]);       if (is_there_overflow ||           is_there_more_than_k_with_coeffs(n, k, a, middle_coeffs)) {         right = middle;       } else {         left = middle;         current_coeffs = std::move(middle_coeffs);       }       --diff_two_power;     }     return left + 1;   }   bool is_there_more_than_k(const int n, const uint64_t k,                             const std::vector<uint64_t>& a) {     for (int i = 0; i < n; ++i) {       if (a[i] >= k) {         return true;       }     }     return false;   }   int main() {     int n;     uint64_t k;     std::cin >> n >> k;     bool still_zero = true;     std::vector<uint64_t> a(n);     int new_n = 0;     for (int i = 0; i < n; ++i) {       uint64_t number;       std::cin >> number;       if (number != 0 || !still_zero) {         a[new_n++] = number;       }       if (number != 0) {         still_zero = false;       }     }     const int simple_algo_bound = 60;     uint64_t result;     if (is_there_more_than_k(new_n, k, a)) {       result = 0;     } else if (new_n >= simple_algo_bound) {       result = get_iteration_simple(new_n, k, a);     } else {       result = get_iteration_binsearch(new_n, k, a);     }     std::cout << result << std::endl;     return 0;   }   