#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const ll INF = 1e18 + 10;
const int N = 101010;
const int S = 400;

int n, k, d, a[N], t[N], off[N];
ll dp[N];

struct DS {
    vector<pair<int, ll>> stk;

    void insert(int p, ll v) {
        while (!stk.empty() && stk.back().second <= v) {
            stk.pop_back();
        }
        stk.push_back({ p, v });
    }
    ll query(int l) {
        if (stk.back().first < l) return -INF;
        return lower_bound(stk.begin(), stk.end(), pair<int, ll>(l, -INF))->second;
    }
} t2[S];

struct SEG {
    ll tree[N * 8];
    
    void update(int a, ll v, int l, int r, int x) {
        if (l == r) {
            tree[x] += v;
            return;
        }
        int m = (l + r) / 2;
        if (a <= m) {
            update(a, v, l, m, 2 * x);
        }
        else update(a, v, m + 1, r, 2 * x + 1);
        tree[x] = max(tree[2 * x], tree[2 * x + 1]);
    }
    ll query(int a, int b, int l, int r, int x) {
        if (b < l || a > r) return -INF;
        if (a <= l && r <= b) return tree[x];
        int m = (l + r) / 2;
        return max(query(a, b, l, m, 2 * x), query(a, b, m + 1, r, 2 * x + 1));
    }
} t1;

int main() {
    cin.tie(0); ios_base::sync_with_stdio(0);
    cin >> n >> k >> d;
    for (int i = n; i >= 1; i--) cin >> a[i];
    for (int i = n; i >= 1; i--) cin >> t[i];

    dp[1] = a[1];
    fill(dp + 2, dp + 1 + n, -INF);
    if (k > S) {
        for (int i = 1; i <= n; i++) {
            for (int j = i - k; j >= 1; j -= k) {
                t1.update(j, -d, 1, n, 1);
            }
            if (i != 1) {
                dp[i] = a[i] + t1.query(i - t[i], i - 1, 1, n, 1);
            }
            t1.update(i, dp[i], 1, n, 1);
        }
    }
    else {
        int q = (n + k - 1) / k;
        for (int i = 1; i <= n; i++) {
            int r = (i - 1) / k;
            int s = (i - 1) % k;
            if (r) off[s] -= d;
            if (i != 1) {
                for (int j = 0; j < min(i - 1, k); j++) {
                    int l = (i - j - t[i] + k - 2) / k;
                    dp[i] = max(dp[i], a[i] + off[j] + t2[j].query(l));
                }
            }
            t2[s].insert(r, dp[i] + r * d);
        }
    }
    cout << dp[n];
}