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

using ll = long long;
using namespace std;

int dp[300][300][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;

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

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

    auto get_pos = [&](int i, int j) -> int {
        if (i == 0) {
            return 0;
        }

        if (j == 0) {
            return x[i - 1];
        } else {
            return x[n - i];
        }
    };


    auto get_time = [&](int i, int j) -> int {
        if (i == 0) {
            return INT32_MAX;
        }

        if (j == 0) {
            return t[i - 1];
        } else {
            return t[n - i];
        }
    };

    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 ? get_pos(l, 0) : get_pos(r, 1));

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

                        int posB = (tB == 0 ? get_pos(l + 1, 0) : get_pos(r + 1, 1));
                        int timeB = (tB == 0 ? get_time(l + 1, 0) : get_time(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;
}