#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
template<class T> void org(T l, T r) { while (l != r) cerr << ' ' << *l++; cerr << '\n'; }
#define debug(x...) dbg(#x, '=', x, '\n')
#define olist(x...) dbg(#x, '='), org(x)
#else
#define debug(...) ((void)0)
#define olist(...) ((void)0)
#endif
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;

template<class T>
inline constexpr T inf = numeric_limits<T>::max() / 2;
constexpr int mod = 998244353;

template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }
template<class... T> int add(T... x) { int t{}; return (((t += x) %= mod), ...), t; }
template<class... T> int mul(T... x) { i64 t{1}; return (((t *= x) %= mod), ...), t; }

void solve() {
    int n, K, D;
    cin >> n >> K >> D;

    vector<int> H(n);
    vector<int> T(n - 1);
    for (int &x : H) cin >> x;
    for (int &x : T) cin >> x;

    if (1ll * K * K <= 1e5) {
        vector<vector<int>> stk(K);
        vector<i64> dp(n, -inf<i64>);
        dp[n - 1] = H[n - 1];
        stk[(n - 1) % K].push_back(n - 1);
        for (int i = n - 2; i >= 0; i--) {
            for (int j = 0; j < K; j++) {
                auto it = lower_bound(all(stk[j]), i + T[i], greater<int>{});
                if (it != stk[j].end()) {
                    chmax(dp[i], dp[*it] - (*it - i) / K * D + H[i]);
                }
            }
            int s = i % K;
            while (!stk[s].empty() and dp[stk[s].back()] - stk[s].back() / K * D < dp[i] - i / K * D) {
                stk[s].pop_back();
            }
            stk[s].push_back(i);
        }
        cout << dp[0] << '\n';
    } else {
        const int lgK = __lg(K);
        vector st(lgK + 1, vector<i64>(n, -inf<i64>));
        vector<i64> dp(n, -inf<i64>);
        dp[n - 1] = H[n - 1];

        auto upd = [&](int idx) -> void {
            st[0][idx] = dp[idx];
            for (int i = 0; i + 1 <= lgK and idx + (2 << i) <= n; i++) {
                st[i + 1][idx] = max(st[i][idx], st[i][idx + (1 << i)]);
            }
        };

        auto qry = [&](int l, int r) -> i64 {
            int s = __lg(r - l);
            return max(st[s][l], st[s][r - (1 << s)]);
        };

        upd(n - 1);
        for (int i = n - 2; i >= 0; i--) {
            for (int j = i; j <= i + T[i]; j += K) {
                chmax(dp[i], qry(max(j, i + 1), min(j + K, i + T[i] + 1)) - (j - i) / K * D + H[i]);
            }
            upd(i);
        }
        cout << dp[0] << '\n';
    }
    
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    
    return 0;
}