#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int SIZE = 1 << 20;
char buf[SIZE + 10], *iS, *iT;
inline char Getc() {
  return iS == iT && (iT = (iS = buf) + fread(buf, 1, SIZE, stdin), iS == iT)
             ? EOF
             : *iS++;
}
template <class TT>
inline void Read(TT &x) {
  x = 0;
  register char cc = '\0';
  TT fff = 1;
  for (; cc < '0' || cc > '9'; cc = Getc())
    if (cc == '-') fff = -1;
  for (; cc >= '0' && cc <= '9'; cc = Getc())
    x = (x << 1) + (x << 3) + (cc & 15);
  x *= fff;
}
}  // namespace IO
using IO::Read;
const int N = 1e5 + 10;
int n, K, fans, Top, Stack[N], a[N], b[N];
long long f[N], g[N];
namespace Seg {
long long Tree[N * 4 + 10], Original[N * 4 + 10], Lazy[N * 4 + 10];
inline void Pushup(int x) {
  if (x) Tree[x] = max(Tree[(x << 1)], Tree[(x << 1 | 1)]);
}
inline void Pushdown(int x) {
  if (!Lazy[x]) return;
  Lazy[(x << 1)] += Lazy[x], Tree[(x << 1)] += Lazy[x];
  Lazy[(x << 1 | 1)] += Lazy[x], Tree[(x << 1 | 1)] += Lazy[x];
  Lazy[x] = 0;
}
void Build(long long *A, int x = 1, int nl = 1, int nr = n) {
  if (nl == nr) {
    Tree[x] = Original[x] = A[nl];
    return;
  }
  int nm = (nl + nr) >> 1;
  Build(A, (x << 1), nl, nm), Build(A, (x << 1 | 1), nm + 1, nr);
  Original[x] = max(Original[(x << 1)], Original[(x << 1 | 1)]), Pushup(x);
}
void Update(int el, int er, long long ad, int x = 1, int nl = 1, int nr = n) {
  if (el <= nl && nr <= er) {
    Tree[x] += ad, Lazy[x] += ad;
    return;
  }
  int nm = (nl + nr) >> 1;
  Pushdown(x);
  if (el <= nm) Update(el, er, ad, (x << 1), nl, nm);
  if (er > nm) Update(el, er, ad, (x << 1 | 1), nm + 1, nr);
  Pushup(x);
}
int wantx, wantnl, wantnr;
long long premaxh, wantmaxh;
int FinalFind(int x, int nl, int nr, long long lim) {
  if (nl == nr) {
    return nr;
  }
  int nm = (nl + nr) >> 1;
  Pushdown(x);
  if (max(lim, Tree[(x << 1)]) <= Original[(x << 1 | 1)] + K) {
    return FinalFind((x << 1 | 1), nm + 1, nr, max(lim, Tree[(x << 1)]));
  }
  return FinalFind((x << 1), nl, nm, lim);
}
void PreFind(int el, int er, int x = 1, int nl = 1, int nr = n) {
  if (el <= nl && nr <= er) {
    if (premaxh <= Original[x] + K)
      wantmaxh = premaxh, wantx = x, wantnl = nl, wantnr = nr;
    premaxh = max(premaxh, Tree[x]);
    return;
  }
  int nm = (nl + nr) >> 1;
  Pushdown(x);
  if (el <= nm) PreFind(el, er, (x << 1), nl, nm);
  if (er > nm) PreFind(el, er, (x << 1 | 1), nm + 1, nr);
}
long long Query(int ed, int x = 1, int nl = 1, int nr = n) {
  if (nl == nr) return Tree[x];
  int nm = (nl + nr) >> 1;
  Pushdown(x);
  if (ed <= nm)
    return Query(ed, (x << 1), nl, nm);
  else
    return Query(ed, (x << 1 | 1), nm + 1, nr);
}
}  // namespace Seg
int main() {
  Read(n), Read(K);
  for (int i = 1; i < n; ++i) Read(b[i]);
  for (int i = 1; i <= n; ++i) Read(a[i]);
  f[0] = f[1] = g[0] = g[1] = 0;
  for (int i = 2; i <= n; ++i) {
    f[i] = f[i - 1] + (a[i - 1] - b[i - 1]);
    g[i] = g[i - 1] + (a[i] - b[i - 1]);
  }
  Seg::Build(g);
  Stack[++Top] = n, fans = 1;
  for (int i = n - 1; i >= 1; --i) {
    while (Top > 0 && f[Stack[Top]] >= f[i]) {
      if (Top != 1)
        Seg::Update(Stack[Top - 1] - 1, n,
                    -(f[Stack[Top]] - f[Stack[Top - 1]]));
      --Top;
    }
    if (Top != 0) Seg::Update(Stack[Top] - 1, n, f[i] - f[Stack[Top]]);
    Stack[++Top] = i;
    int L = 1, R = Top, mid = 0, fps = n + 1;
    while (L <= R) {
      mid = (L + R) >> 1;
      if (f[i] - f[Stack[mid]] > K)
        fps = Stack[mid], L = mid + 1;
      else
        R = mid - 1;
    }
    Seg::premaxh = Seg::wantmaxh = -0x3f3f3f3f3f3f3f3fLL;
    Seg::wantx = 1, Seg::wantnl = 1, Seg::wantnr = n;
    Seg::PreFind(i, fps - 1);
    int rightpos =
        Seg::FinalFind(Seg::wantx, Seg::wantnl, Seg::wantnr, Seg::wantmaxh);
    fans = max(fans, rightpos - i + 1);
  }
  printf("%d\n", fans);
  return 0;
}
