/// @author Camillus
#include <bits/stdc++.h>

using ll = long long;
using namespace std;

int dp[300][300][300][2];

int x[300][2];
int t[300][2];

int min_equal(int &first, int second) {
    return first = min(first, second);
}

signed main() {
#ifndef LOCAL
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#else
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

    for (auto &a : dp) {
        for (auto &b : a) {
            for (auto &c : b) {
                for (auto &d : c) {
                    d = INT32_MAX;
                }
            }
        }
    }

    dp[0][0][0][0] = 0;

    int n, l;
    cin >> n >> l;

    for (int i = 1; i <= n; i++) {
        cin >> x[i][0];
        x[n - i + 1][1] = l - x[i][0];
    }

    for (int i = 1; i <= n; i++) {
        cin >> t[i][0];
        t[n - i + 1][1] = t[i][0];
    }

    int ans = 0;

    auto dist = [&l](int x, int y) {
        return min(abs(x - y), l - abs(x - y));
    };

    for (int c = 0; c <= n; c++) {
        for (int l = 0; l <= n; l++) {
            for (int r = 0; r <= n; r++) {
                for (int tA : {0, 1}) {
                    if (dp[c][l][r][tA] == INT32_MAX) {
                        continue;
                    } else {
                        ans = max(ans, c);
                    }

                    if (l + r >= n) {
                        continue;
                    }

                    int posA = (tA == 0 ? x[l][0] : x[r][1]);

                    for (int tB : {0, 1}) {
                        if (l + (tB == 0) > n || r + (tB == 1) > n) {
                            continue;
                        }

                        int posB = (tB == 0 ? x[l + 1][0] : x[r + 1][1]);
                        int timeB = (tB == 0 ? t[l + 1][0] : t[r + 1][1]);

                        int cur = dp[c][l][r][tA] + dist(posA, posB);

                        if (cur <= timeB) {
                            min_equal(dp[c + 1][l + (tB == 0)][r + (tB == 1)][tB], cur);
                        } else {
                            min_equal(dp[c][l + (tB == 0)][r + (tB == 1)][tB], cur);
                        }
                    }
                }
            }
        }
    }

    cout << ans << '\n';
    return 0;
}