#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using ld = long double;

#define pb push_back

const ld pi = 3.14159265358979323846;
const int mod = 998244353;
const ll INF = 1e18;

struct pair_hash {
    template<class T1, class T2>
    size_t operator()(const std::pair<T1, T2> &pair) const {
        return hash<T1>()(pair.first) ^ hash<T2>()(pair.second);
    }
};

template<typename T>
T chmax(T a, T b) {
    return a > b ? a : b;
}

template<typename T>
T chmin(T a, T b) {
    return a > b ? b : a;
}

const int N = (int) 1e5 + 1, M = N * 2;

int n;
ll p, k;
vector<ll> d;

vector<int> a;

void solve() {
    cin >> n >> p >> k;
    d.resize(n);
    for (int i = 0; i < n; ++i) cin >> d[i];

    ll total_pass_time = accumulate(d.begin(), d.end(), 0LL);
    vector<ll> cum(n + 1, 0); // cumulative sum from current student to the end
    for (int i = n - 1; i >= 0; --i) {
        cum[i] = cum[i + 1] + d[i];
    }

    ll total_passes = 0;
    int current_student = 0;
    ll day = 0;

    // Map to detect cycles: (current_student) -> (day, total_passes)
    unordered_map<int, pair<ll, ll>> mp;

    while (day < k) {
        if (mp.count(current_student)) {
            ll prev_day = mp[current_student].first;
            ll prev_passes = mp[current_student].second;
            ll cycle_days = day - prev_day;
            ll cycle_passes = total_passes - prev_passes;
            if (cycle_days == 0) {
                // Cannot detect a cycle; proceed to next day
                day += 1;
                continue;
            }
            ll remaining_days = k - day;
            ll cycles = remaining_days / cycle_days;
            total_passes += cycles * cycle_passes;
            day += cycles * cycle_days;
            if (day >= k) break;
        }
        mp[current_student] = {day, total_passes};

        ll remaining_time = p;

        // Try to finish the remaining performances in the current rehearsal pass
        ll time_needed = cum[current_student];
        if (time_needed <= remaining_time) {
            // Complete the current rehearsal pass
            remaining_time -= time_needed;
            total_passes += 1;
            current_student = 0;

            // Complete as many full rehearsal passes as possible with remaining time
            ll full_passes = remaining_time / total_pass_time;
            total_passes += full_passes;
            remaining_time -= full_passes * total_pass_time;

            // Perform additional performances if possible
            while (remaining_time >= d[current_student]) {
                remaining_time -= d[current_student];
                current_student += 1;
                if (current_student == n) {
                    total_passes += 1;
                    current_student = 0;
                }
            }
        } else {
            // Cannot finish the current rehearsal pass today
            // Perform as many performances as possible until the next cannot fit
            while (current_student < n && remaining_time >= d[current_student]) {
                remaining_time -= d[current_student];
                current_student += 1;
            }
            // Remaining performances are moved to the next day
        }
        day += 1;
    }

    cout << total_passes << endl;
}

int main() {
    // freopen(".in", "r", stdin);
    // freopen(".out", "w", stdout);

    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

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

    solve();

    return 0;
}