template<bool r>class Range{struct It{int it;explicit constexpr It(int it_):it(it_){}int operator*(){return it;}bool operator!=(It& a){return it!=a.it;}void operator++(){r?--it:++it;}};const It i,n;public:explicit constexpr Range(int i,int n):i(i),n(n){}Range<true> rev(){return Range<true>(n.it-1, i.it-1);};const It&begin(){return i;}const It&end(){return n;}};
inline Range<false> in(int n) { return Range<false>(0, n);}
inline Range<false> in(int i, int n) { return Range<false>(i, n);}
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const i64 INF = 1e17;
template<class T> T num_in() { T x; cin >> x; return x;}
template<class T> vector<T> vec_in(int n) { vector<T> res(n); for (auto& x : res) cin >> x; return res;}
template<class T> void print_vec(const vector<T>& v) { for (auto& x : v) cout << x << ' '; cout << endl;}
  
int main() {
    i64 goal_dist = num_in<i64>();
    int n = num_in<int>();
    auto speed_rev = vec_in<i64>(n);
    int m = num_in<int>();
    auto hiroi = vec_in<i64>(m);
    sort(hiroi.begin(), hiroi.end());
    struct State {
        vector<int> perm; // 
        vector<vector<i64>> adj_mat;
        // adj_mat[i][j] :=  |j????????????????????? - i?????????????????????|
        State(int n) : perm(n), adj_mat(n, vector<i64>(n, INF)) {
            iota(perm.begin(), perm.end(), 0);
            for (int i : in(n)) adj_mat[i][i] = 0ll;
        }
    };
    const int MAX_N = 5;
    using Bs = bitset<MAX_N>;
    vector<Bs> swap_pairs = [&]() {
        vector<Bs> res = { static_cast<Bs>(0)};        
        for (int it : in(n - 1)) {
            auto nxt = res;
            for (const auto& b : res) {
                if (it < 1 || b[it - 1] == false) {
                    auto bn = b;
                    bn[it] = true;
                    nxt.emplace_back(bn);
                }
            }
            res = nxt;
        }
        return res;
    }();
    vector<State> cur_states = { State(n)};
    for (const auto& pass_dist : hiroi) {
        vector<State> nxt_states = cur_states;
        for (const auto& s : cur_states) {
            for (auto flag : swap_pairs) {
                if (flag == static_cast<Bs>(0)) continue;
                State ns = s;
                bool ok = true;
                for (int i : in(n - 1)) {
                    if (flag[i] == false) continue;
                    i64 spr1 = speed_rev[s.perm[i]], spr2 = speed_rev[s.perm[i + 1]];
                    if (spr1 <= spr2) {
                        ok = false;
                        break;
                    };
                    swap(ns.perm[i], ns.perm[i + 1]);
                    // pass_dist * spr1 = pass_dist * spr2 + time_diff
                    i64 time_diff = pass_dist * (spr1 - spr2);
                    ns.adj_mat[s.perm[i]][s.perm[i + 1]] = time_diff;
                    ns.adj_mat[s.perm[i + 1]][s.perm[i]] = -time_diff;
                }
                if (ok) nxt_states.emplace_back(ns);
            }
        }
        cur_states = nxt_states;
    }
    i64 ans = INF;
    auto calc_stime = [&](const vector<vector<i64>>& g, int start) {
        vector<i64> start_time(n - start, INF);
        start_time[0] = 0ll;
        queue<int> que;
        que.emplace(start);
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int i : in(start, n)) {
                if (g[cur][i] != INF && start_time[i - start] == INF) {
                    start_time[i - start] = start_time[cur - start] + g[cur][i];
                    que.emplace(i);
                }
            }
        }
        while (start_time.back() == INF) start_time.pop_back();
        return start_time;
    };
    auto collison_ok = [&](const vector<vector<i64>>& adj, const vector<i64>& stime, int start) {
        int gsize = stime.size();
        for (int i : in(start, gsize + start)) {
            for (int j : in(i + 1, gsize + start)) {
                if (speed_rev[i] <=  speed_rev[j]) continue;
                if (adj[i][j] != INF) {
                    if (stime[j - start] - stime[i - start] != adj[i][j]) return false;
                    continue;
                }
                i64 collision_point = (stime[i - start] - stime[j - start]) / (speed_rev[j] - speed_rev[i]);
                if (collision_point < goal_dist) return false;
            }
        }
        return true;
    };
    for (const auto& state : cur_states) {
        vector<i64> start_time(n);
        bool is_valid = [&]() {
            Bs used(0);
            for (int i : in(n)) {
                if (used[i]) continue;
                auto stime = calc_stime(state.adj_mat, i);
                int gsize = stime.size();
                for (int j : in(i, gsize + i)) used[j] = true;
                for (int j : in(i + 1, gsize + i)) if (stime[j - i - 1] >= stime[j - i]) return false;
                if (collison_ok(state.adj_mat, stime, i) == false) return false;
                i64 offset = [&]() {
                    if (i == 0) return 0ll;
                    i64 tdiff_max = start_time[i - 1] + 1ll;
                    for (int j : in(i, i + gsize)) {
                        for (int k : in(i)) {
                            if (speed_rev[k] <= speed_rev[j]) continue;
                            i64 need = goal_dist * (speed_rev[k] - speed_rev[j]);
                            tdiff_max = max(tdiff_max, need + start_time[k] - stime[j - i]);
                        }
                    }
                    return tdiff_max;
                }();
                for (int j : in(i, gsize + i)) start_time[j] = offset + stime[j - i];
            }
            return true;
        }();
        if (!is_valid) continue;
        i64 local_ans = 0;
        for (int i : in(n)) local_ans = max(local_ans, start_time[i] + goal_dist * speed_rev[i]);
        // cout << ">_<: " << local_ans << endl;
        // print_vec(start_time);
        // for (auto v : state.adj_mat) print_vec(v);
        ans = min(ans, local_ans);
    }
    cout << ans << endl;
    return 0;
}

Measured memory_bytes: 3332