/*
	Author: Ritik Patel
	
	Idea: 
*/


//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& STL DEBUGGER &&&&&&&&&&&&&&&&&&&&&&&&&&&

// #define _GLIBCXX_DEBUG       // Iterator safety; out-of-bounds access for Containers, etc.
// #pragma GCC optimize "trapv" // abort() on (signed) integer overflow.

//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& LIBRARIES &&&&&&&&&&&&&&&&&&&&&&&&&&&

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

/*#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
template<typename T, typename V = __gnu_pbds::null_type>
using ordered_set = __gnu_pbds::tree<T, V, less<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>; 
*/
//find_by_order()->returns an iterator to the k-th largest element(0-based indexing)
//order_of_key()->Number of items that are strictly smaller than our item

//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& DEFINES &&&&&&&&&&&&&&&&&&&&&&&&&&&

#define int long long int
#define all(i) i.begin(), i.end()
#define sz(a) (int)a.size()
 
// const ld PI  = 3.141592;
const int dx4[4] = {0, 1, 0, -1};
const int dy4[4] = {-1, 0, 1, 0};
const int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
 
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& DEBUG &&&&&&&&&&&&&&&&&&&&&&&&&&&
 
#define XOX
vector<string> vec_splitter(string s) {
    for(char& c: s) c = c == ','?  ' ': c;
    stringstream ss; ss << s;
    vector<string> res;
    for(string z; ss >> z; res.push_back(z));
    return res;
}
 
void debug_out(vector<string> __attribute__ ((unused)) args, __attribute__ ((unused)) int idx) { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, Head H, Tail... T) {
    if(idx > 0) cerr << ", ";
    stringstream ss; ss << H;
    cerr << args[idx] << " = " << ss.str();
    debug_out(args, idx + 1, T...);
}
 
#ifdef XOX
#define debug(...) debug_out(vec_splitter(#__VA_ARGS__), 0, __VA_ARGS__)
#else
#define debug(...) 42
#endif
 
 
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& CODE &&&&&&&&&&&&&&&&&&&&&&&&&&&

int n, m, K;
vector<int> a, b;
vector<int> prefA, prefB;

void pre(){
    a.resize(n + 1), b.resize(m + 1);
    prefA.resize(n + 1), prefB.resize(m + 1);
    for(int i = 1; i <= n; ++i){
        cin >> a[i];
    }
    for(int i = 1; i <= m; ++i){
        cin >> b[i];
    }
    prefA[0] = 0, prefB[0] = 0;
    for(int i = 1; i <= m; ++i){
        prefB[i] = b[i];
        prefB[i] += prefB[i - 1];
        
    }
    for(int i = 1; i <= n; ++i){
        prefA[i] = a[i];
        prefA[i] += prefA[i - 1];
        
    }
}

bool check(int total){
    bool poss = false;
    for(int i = min(total, n); i >= 0; --i){
        int left_books = total - i;
        if(left_books > m){
            break;
        }
        // debug(i, left_books, prefA[i], prefB[left_books]);
        if(prefA[i] + prefB[left_books] <= K){
            poss = true; break;
        }
    }
    // debug("B");
    for(int i = min(total, m); i >= 0; --i){
        int left_books = total - i;
        if(left_books > n){
            break;
        }
        // debug(i, left_books, prefB[i], prefA[left_books]);
        if(prefB[i] + prefA[left_books] <= K){
            poss = true; break;
        }
    }
    return poss;
}

void solve(){
  	cin >> n >> m >> K;
    pre();
    int lo = 0, hi = n + m;
    while(lo < hi){
        int mid = (lo + hi) / 2;
        if(check(mid)){
            lo = mid + 1;
        } else {
            hi = mid - 1;
        }
    }
    for(int books = min(lo + 5, n + m); books >= max((int)0, lo - 5); --books){
        if(check(books)){
            cout << books << '\n';
            return;
        }
    }
}



int32_t main(){
    ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr); 
    int T = 1; 
    // cin >> T;
    for(int i = 1; i <= T; ++i){
        // brute();
        solve();
    }
    return 0;
}

/*
Sample inp
*/

Measured memory_bytes: 9504