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

#define For(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) For(i, 0, n)
#define rFor(i, a, b) for(int i = (a); i >= (b); i--)
#define ALL(v) (v).begin(), (v).end()
#define rALL(v) (v).rbegin(), (v).rend()

using lint = long long;
using ld = long double;

int INF = 2000000000;
lint LINF = 1000000000000000000;

namespace debug {

void out() {
    cout << "\n";
}

void out(int x) {
    int INF = 2000000000;
    if (x == -INF) {
        cout << "-INF";
    } else if (x == INF) {
        cout << "INF";
    } else {
        cout << x;
    }
}

void out(long long x) {
    long long LINF = 1000000000000000000;
    if (x == -LINF) {
        cout << "-LINF";
    } else if (x == LINF) {
        cout << "LINF";
    } else {
        cout << x;
    }
}

void out(double x) {
    cout << fixed << setprecision(10);
    cout << x;
}

void out(long double x) {
    cout << fixed << setprecision(10);
    cout << x;
}

void out(char c) {
    cout << "'";
    cout << c;
    cout << "'";
}

void out(string s) {
    cout << "\"";
    cout << s;
    cout << "\"";
}

template <class T, class U>
void out(pair<T, U> &p) {
    cout << "{";
    out(p.first);
    cout << ", ";
    out(p.second);
    cout << "}";
}

template <class T, class U, class V>
void out(tuple<T, U, V> &t) {
    cout << "{";
    out(get<0>(t));
    cout << ", ";
    out(get<1>(t));
    cout << ", ";
    out(get<2>(t));
    cout << "}";
}

template <class T, class U, class V, class W>
void out(tuple<T, U, V, W> &t) {
    cout << "{";
    out(get<0>(t));
    cout << ", ";
    out(get<1>(t));
    cout << ", ";
    out(get<2>(t));
    cout << ", ";
    out(get<3>(t));
    cout << "}";
}

template <class T, class U, class V, class W, class X>
void out(tuple<T, U, V, W, X> &t) {
    cout << "{";
    out(get<0>(t));
    cout << ", ";
    out(get<1>(t));
    cout << ", ";
    out(get<2>(t));
    cout << ", ";
    out(get<3>(t));
    cout << ", ";
    out(get<4>(t));
    cout << "}";
}

template <class T>
void out(vector<T> &v) {
    for (auto x : v) {
        out(x);
        cout << " ";
    }
}

template <class T>
void out(vector<vector<T>> &v) {
    for (int i = 0; i < (int)v.size(); i++) {
        cout << i << " : ";
        out(v[i]);
        cout << "\n";
    }
}

template <class T>
void out2(vector<T> &v) {
    for (int i = 0; i < (int)v.size(); i++) {
        cout << "[" << i << "] = ";
        out(v[i]);
        cout << "\n";
    }
}

template <class T>
void out2(vector<vector<T>> &v) {
    for (int i = 0; i < (int)v.size(); i++) {
        for (int j = 0; j < (int)v[i].size(); j++) {
            cout << "[" << i << "][" << j << "] = ";
            out(v[i][j]);
            cout << "\n";
        }
    }
}

template <class T>
void out3(vector<vector<T>> &v) {
    for (int i = 0; i < (int)v.size(); i++) {
        for (int j = 0; j < (int)v[i].size(); j++) {
            cout << v[i][j];
        }
        cout << "\n";
    }
}

template <class T>
void out(set<T> &s) {
    for (auto x : s) {
        out(x);
        cout << " ";
    }
}

template <class T>
void out(multiset<T> &s) {
    for (auto x : s) {
        out(x);
        cout << " ";
    }
}

template <class T>
void out(unordered_set<T> &s) {
    for (auto x : s) {
        out(x);
        cout << " ";
    }
}

template <class T, class U>
void out(map<T, U> &mp) {
    for (auto &[x, y] : mp) {
        out(x);
        cout << " : ";
        out(y);
        cout << "\n";
    }
}

template <class T, class U>
void out(unordered_map<T, U> &mp) {
    for (auto &[x, y] : mp) {
        out(x);
        cout << " : ";
        out(y);
        cout << "\n";
    }
}

} // namespace debug

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    lint n, d, k;
    cin >> n >> d >> k;
    vector<lint> a(n), c(n);
    rep(i, n) {
        cin >> a[i];
    }
    rep(i, n) {
        cin >> c[i];
    }
    vector<vector<lint>> dp(d + 1, vector<lint>(k + 1, -LINF));
    auto ndp = dp;
    dp[0][0] = 0;
    rep(i, n) {
        ndp = dp;
        rep(j, d + 1) {
            rep(kk, k + 1) {
                if (dp[j][kk] == -LINF) {
                    continue;
                }
                if (j < d) {
                    int nj = j + 1, nk = min(k, kk + c[i]);
                    ndp[nj][nk] = max(ndp[nj][nk], dp[j][kk] + a[i]);
                }
            }
        }
        swap(dp, ndp);
        // debug::out2(dp);
        // debug::out();
    }
    if (dp[d][k] != -LINF) {
        cout << dp[d][k] << "\n";
    } else {
        cout << "No\n";
    }
}