#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e5 + 5;

ll t, n, m;
ll a[N], b[N];

// Tính số sản phẩm phân xưởng có thể làm được trong thời gian time_limit
ll count_products(ll time_limit, ll arr[], int k) {
    ll sum = 0;
    for (int i = 1; i <= k; i++) {
        sum += (time_limit / arr[i]);
    }
    return sum;
}

ll bin_search() {
    ll l = 0, r = t; // Khoảng thời gian phân xưởng nặn làm việc
    ll ans = 0;
    while (l <= r) {
        ll mid = (l + r) / 2;
        // mid là thời gian phân xưởng nặn hoạt động
        // T - mid là thời gian phân xưởng vẽ hoạt động
        ll sp_nan = count_products(mid, a, n);
        ll sp_ve = count_products(t - mid, b, m);

        // Số lượng sản phẩm hoàn thành là số ít hơn trong hai phân xưởng
        ll completed = min(sp_nan, sp_ve);
        ans = max(ans, completed);

        // Logic tìm kiếm:
        // Nếu phân xưởng nặn làm ra ít sản phẩm hơn (sp_nan < sp_ve),
        // ta cần tăng thời gian cho phân xưởng nặn (tăng mid).
        if (sp_nan < sp_ve) {
            l = mid + 1;
        } else {
            r = mid - 1;
        }
    }
    return ans;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cin >> t >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    cin >> m;
    for (int i = 1; i <= m; i++) cin >> b[i];
    cout << bin_search();
    return 0;
}

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

#define ll long long

// Kiểm tra xem liệu có thể hoàn thành 'need' sản phẩm hay không
bool check(ll need, int n, int m, ll t, vector<int> &a, vector<int> &b) {
    // Bước 1: Tối thiểu hóa thời gian cần thiết để nặn 'need' sản phẩm
    // Dùng Binary Search để tìm thời gian t_nan nhỏ nhất thỏa mãn
    ll l = 0, r = t, t_nan = t + 1;
    while (l <= r) {
        ll mid = (l + r) / 2;
        ll sum = 0;
        for (int i = 0; i < n; i++) {
            sum += mid / a[i];
            if (sum >= need) break; // Tối ưu hóa tốc độ
        }
        if (sum >= need) {
            t_nan = mid;
            r = mid - 1;
        } else {
            l = mid + 1;
        }
    }

    if (t_nan > t) return false; // Ngay cả khi dùng hết T vẫn không đủ nặn

    // Bước 2: Kiểm tra xem phần thời gian còn lại có đủ vẽ không
    ll t_ve = t - t_nan;
    ll sum_ve = 0;
    for (int i = 0; i < m; i++) {
        sum_ve += t_ve / b[i];
        if (sum_ve >= need) return true;
    }
    return sum_ve >= need;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    ll t;
    int n, m;
    cin >> t >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    cin >> m;
    vector<int> b(m);
    for (int i = 0; i < m; i++) cin >> b[i];

    ll l = 0, r = 2e9; // Giới hạn trên đủ lớn (hoặc tính max possible)
    ll ans = 0;
    while (l <= r) {
        ll mid = (l + r) / 2;
        if (check(mid, n, m, t, a, b)) {
            ans = mid;
            l = mid + 1;
        } else {
            r = mid - 1;
        }
    }
    cout << ans;
    return 0;
}

// Chỉ mang tính chất gợi ý, không phải code tối ưu hoàn toàn
// Áp dụng khi N, M rất nhỏ (ví dụ N, M <= 10)
// Duyệt qua các thời điểm chia tách (split point)
#include <bits/stdc++.h>
using namespace std;

int main() {
    long long T; int N, M;
    cin >> T >> N;
    vector<long long> a(N);
    for(int i=0; i<N; i++) cin >> a[i];
    cin >> M;
    vector<long long> b(M);
    for(int i=0; i<M; i++) cin >> b[i];

    long long max_prod = 0;

    // Chỉ duyệt các thời điểm mà phân xưởng nặn hoàn thành một sản phẩm
    // Hoặc các thời điểm quan trọng (thời gian chia hết cho a_i)
    vector<long long> important_times;
    important_times.push_back(0);
    important_times.push_back(T);

    for (long long x : a) {
        for (long long k = 1; k * x <= T; k++) {
            important_times.push_back(k * x);
            if (k * x + 1 <= T) important_times.push_back(k * x + 1);
        }
    }

    sort(important_times.begin(), important_times.end());
    important_times.erase(unique(important_times.begin(), important_times.end()), important_times.end());

    for (long long split : important_times) {
        if (split > T) break;
        long long cnt_nan = 0;
        for (long long x : a) cnt_nan += split / x;

        long long cnt_ve = 0;
        for (long long y : b) cnt_ve += (T - split) / y;

        max_prod = max(max_prod, min(cnt_nan, cnt_ve));
    }

    cout << max_prod << endl;
    return 0;
}