#ifndef Yamada
#define Yamada
#include Yamada __FILE__ Yamada

const int maxn = 1e5 + 5;
const int INF = 1e18;

struct SGT {
    vector<int> tr;
    vector<multiset<int>> st;
    SGT(int sz) : tr(sz << 2, -INF), st(sz << 2) {}
    void pull(int x) {
        tr[x] = max(tr[x << 1], tr[(x << 1) | 1]);
    }
    void add(int x, int L, int R, int p, int v) {
        if(L == R) {
            st[x].insert(v);
            tr[x] = *st[x].rbegin();
            return;
        }
        int mid = (L + R) >> 1;
        if(p <= mid) add(x << 1, L, mid, p, v);
        else add((x << 1) | 1, mid + 1, R, p, v);
        pull(x);
    }
    void rm(int x, int L, int R, int p, int v) {
        if(L == R) {
            auto it = st[x].find(v);
            assert(it != st[x].end());
            st[x].erase(it);
            if(st[x].empty()) tr[x] = -INF;
            else tr[x] = *st[x].rbegin();
            return;
        }
        int mid = (L + R) >> 1;
        if(p <= mid) rm(x << 1, L, mid, p, v);
        else rm((x << 1) | 1, mid + 1, R, p, v);
        pull(x);
    }
    int ask(int x, int L, int R, int l, int r) {
        if(l <= L && R <= r) {
            return tr[x];
        }
        int mid = (L + R) >> 1;
        int ret = -INF;
        if(l <= mid) chmax(ret, ask(x << 1, L, mid, l, r));
        if(r >  mid) chmax(ret, ask((x << 1) | 1, mid + 1, R, l, r));
        return ret;
    }
} loli(maxn);

int H[maxn], T[maxn], dp[maxn];
int n, k, d;

int cal(int x) {
    return dp[x] + x * d - (x % k) * d;
}

int get(int x, bool c) {
    return H[x] - x * d + (x % k) * d + (c ? 0 : k*d);
}

void solve() {
    cin >> n >> k >> d;
    for(int i = 1; i <= n; ++i) {
        cin >> H[i];
        H[i] *= k;
    }
    for(int i = 1; i < n; ++i) {
        cin >> T[i];
    }
    MinHeap<pair<int, int>> pq;
    dp[1] = H[1];
    pq.emplace(1 + T[1], 1);
    loli.add(1, 0, k - 1, 1 % k, cal(1));
    for(int i = 2; i <= n; ++i) {
        int md = i % k;
        while(SZ(pq) && pq.top().X < i) {
            int _pos = pq.top().Y;
            int _md = _pos % k;
            loli.rm(1, 0, k - 1, _md, cal(_pos));
            pq.pop();
        }
        dp[i] = loli.ask(1, 0, k - 1, 0, md) + get(i, true);
        if(md < k - 1) {
            chmax(dp[i], loli.ask(1, 0, k - 1, md+1, k-1) + get(i, false));
        }
        pq.emplace(i + T[i], i);
        loli.add(1, 0, k - 1, md, cal(i)); 
    }
    cout << dp[n] / k << '\n';
}

signed main() {
    IOS();
    int t = 1; // cin >> t;
    for (int i = 1; i <= t; ++i) solve();
    return 0;
}

#else

#ifdef local
#define _GLIBCXX_DEBUG 1
#endif
#include <bits/stdc++.h>
using namespace std;

#define int int64_t
using pii = pair<int, int>;
template <typename T> using MaxHeap = std::priority_queue<T>;
template <typename T> using MinHeap = std::priority_queue<T, vector<T>, greater<T>>;

#define SZ(a) ((int)(a).size())
#define ALL(a) begin(a), end(a)
#define RALL(a) rbegin(a), rend(a)
#define ee emplace
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front
#define X first
#define Y second

#ifdef local
#define IOS() void()
#else
#define IOS() ios_base::sync_with_stdio(0), cin.tie(0);
#endif

template <typename U, typename V> bool chmin(U &u, V v) {return (u > v ? u = v, 1 : 0);}
template <typename U, typename V> bool chmax(U &u, V v) {return (u < v ? u = v, 1 : 0);}

#endif