#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;

typedef long long ll;
#define pll pair<ll, ll>
#define pil pair<int, ll>
#define ff first
#define ss second
#define all(v) v.begin(), v.end()

const int MAXN = 1e3 + 5;
const ll INF = 1e9 + 7;

ll tot, tot2;    // tot number of things with less, num of checkpoints
ll shift;
pil bus[MAXN];  // speed, time
ll times[MAXN][MAXN];
ll ans[2 * MAXN * MAXN];
ll boundaries[2 * MAXN * MAXN];
set<ll> checkpoints;

struct Point {
    ll t1, t2;
    int i;
    Point(){}
    Point(ll t1, ll t2, int i) : t1(t1), t2(t2), i(i){}

    bool operator<(const Point &other) const {
        if(t1 == other.t1) {
            if(t2 == other.t2) return i < other.i;
            return t2 < other.t2;
        }
        return t1 < other.t1;
    }
};
Point points[MAXN];

struct Segment {
    ll l, r, t;

    Segment(){}
    Segment(ll l, ll r, ll t) : l(l), r(r), t(t){}
};

vector<Segment> segments[MAXN];

void init(int l, int n, vector<ll> t, vector<int> w, int x, int m, vector<int> s) {
    shift = l * x;

    tot = 0;
    for(int i = 0; i < n; ++i) {
        if(w[i] > x) bus[tot++] = {w[i], t[i]};
    }

    sort(bus, bus + tot);

    for(int i = 0; i < tot; ++i) times[0][i] = bus[i].ss;

    for(int i = 1; i < m; ++i) {
        int dists = s[i] - s[i - 1];

        for(int j = 0; j < tot; ++j) points[j] = Point(times[i - 1][j], times[i - 1][j] + dists * bus[j].ff, j);
        sort(points, points + tot);

        ll mx = 0; int idx = 0;
        for(int j = 0; j < tot; ++j) {
            while(points[idx].t1 < points[j].t1) {
                mx = max(mx, points[idx].t2); ++idx;
            }
            times[i][points[j].i] = max(mx, points[j].t2) - dists * x;
        }

        vector<pll> curtime;
        for(int j = 0; j < tot; ++j) curtime.push_back({times[i - 1][j], times[i][j]});
        sort(all(curtime));
        for(int j = 1; j < tot; ++j) curtime[j].ss = max(curtime[j].ss, curtime[j - 1].ss);

        for(int j = 0; j < tot; ++j) {
            ll lbound = curtime[j].ff + 1;
            ll rbound;
            if(j == tot - 1) rbound = INF;
            else rbound = curtime[j].ss;

            if(lbound <= rbound) segments[i].push_back(Segment(lbound, rbound, curtime[j].ss));
            checkpoints.insert(lbound); checkpoints.insert(rbound + 1);
        }
    }

    tot2 = 0;
    for(auto checkpoint : checkpoints) {
        ans[tot2] = checkpoint;
        boundaries[tot2++] = checkpoint;
    }

    for(int i = 1; i < m; ++i) {
        vector<pair<pll, ll>> prs;

        for(auto [l, r, val] : segments[i]) {
            int lbound = lower_bound(ans, ans + tot2, l) - ans;
            int rbound = upper_bound(ans, ans + tot2, r) - ans;

            if(lbound < rbound) prs.push_back({{lbound, rbound}, val});
        }

        for(auto [pr, v] : prs) {
            for(int j = pr.ff; j < pr.ss; ++j) ans[j] = v;
        }
    }
}

ll arrival_time(ll y) {
    ll pos = upper_bound(boundaries, boundaries + tot2, y) - boundaries - 1;
    if(pos == -1 || boundaries[pos] == ans[pos]) {
        return y + shift;
    }
    return ans[pos] + shift;
}

//signed main() {
//    int l, n, x, m;
//
//    cin >> l >> n;
//    vector<ll> t(n);
//    vector<int> w(n);
//    for(int i = 0; i < n; ++i) cin >> t[i];
//    for(int i = 0; i < n; ++i) cin >> w[i];
//    cin >> x >> m;
//    vector<int> s(m);
//    for(int i = 0; i < m; ++i) cin >> s[i];
//
//    init(l, n, t, w, x, m, s);
//    cout << arrival_time(0) << " " << arrival_time(50) << endl;
//}