#include<bits/stdc++.h>
using namespace std;
#define Root T.rt,-inf,inf
const int maxn=5e6+10,inf=1e16;
int n,E;
struct node{
	int a,b,op;
}nd[maxn];
void sub1(){
	int ans=0;
	for(int l=1;l<=n;l++){
		int Emin=0,maxsub=0,presub=0,sigget=0,siglost=0;
		for(int i=l;i<=n;i++){
			int nowsub=presub,nowmin=presub+nd[i].a;
			if(!nd[i].op)Emin+=nd[i].a-nd[i].b,maxsub+=nd[i].a-nd[i].b,presub+=nd[i].a-nd[i].b;
			if(nowmin>Emin)Emin=nowmin,maxsub=nowsub;
			if(Emin>E)break;
			sigget+=nd[i].b,siglost+=nd[i].a;
			if(sigget>=siglost)ans++;
		}
	}
	cout<<ans<<"\n";
}
struct SGT{
	struct trnode{
		int ls,rs,val;
	}tr[maxn<<2];
	int tnod,rt;
	int newnod(){
		tnod++;
		tr[tnod].ls=0,tr[tnod].rs=0,tr[tnod].val=0;
		return tnod;
	}
	void PU(int x){
		tr[x].val=0;
		if(tr[x].ls)tr[x].val+=tr[tr[x].ls].val;
		if(tr[x].rs)tr[x].val+=tr[tr[x].rs].val;
	}
	void ins(int &x,int l,int r,int pos,int cv){
		if(!x)x=newnod();
		if(l==r){
			tr[x].val+=cv;	
			return;
		}
		int mid=(l+r)>>1;
		if(pos<=mid)ins(tr[x].ls,l,mid,pos,cv);
		else ins(tr[x].rs,mid+1,r,pos,cv);
		PU(x);
	}
	int QT(int x,int l,int r,int L,int R){
		if(!x)return 0;
		if(L<=l&&R>=r)return tr[x].val;
		int mid=(l+r)>>1,res=0;
		if(L<=mid)res+=QT(tr[x].ls,l,mid,L,R);
		if(R>mid)res+=QT(tr[x].rs,mid+1,r,L,R);
		return res;
	}
}T;
int flag=0,v[maxn],pv[maxn],predelt[maxn],d[maxn];
int Q[maxn],lq=1,rq=0;
long long ans=0;
void suball(){
	for(int i=1;i<=n;i++){
		predelt[i]=predelt[i-1]+nd[i].b-nd[i].a;
//		cout<<predelt[i]<<" ";
		if(nd[i].a>nd[i].b)v[i]=nd[i].a-nd[i].b;
		else v[i]=0;
		d[i]=nd[i].a-v[i];
	}
//	cout<<endl;
	for(int i=1;i<=n;i++)pv[i]=pv[i-1]+v[i];
	for(int L=1,R=0;L<=n;L++){
		if(nd[L].a>E){
			R=L,lq=1,rq=0;
			flag+=nd[L].b-nd[L].a;
			continue;
		}
		while(R<n&&(lq>rq||pv[R+1]-pv[L-1]+max(d[R+1],d[Q[lq]])<=E)){
			R++;
			while(lq<=rq&&d[R]>d[Q[rq]])rq--;
			Q[++rq]=R;
			T.ins(Root,predelt[R],1);
		}
//		cout<<L<<" "<<R<<endl;
		ans+=1ll*T.QT(Root,flag,inf);
//		cout<<ans<<endl;
		T.ins(Root,predelt[L],-1);
		flag+=nd[L].b-nd[L].a;		
		if(Q[lq]==L)lq++;
	}
	cout<<ans<<endl;
}
signed main(){
//	freopen("top.in","r",stdin);
//	freopen("top.out","w",stdout);
	cin.tie(0),cout.tie(0),ios::sync_with_stdio(false);
	cin>>n>>E;
	for(int i=1;i<=n;i++)cin>>nd[i].a;
	for(int i=1;i<=n;i++)cin>>nd[i].b,nd[i].op=(nd[i].a<nd[i].b);
	if(n<=5000)sub1();
	else suball();
	return 0;
}
/*
10 2
4 7 10 0 4 7 1 1 0 6 
4 6 6 2 1 3 7 10 8 6 
*/ 
/*
When can [l,r] be a possible solution?
two main factors:
1.$\sum a<=\sum b$ because if it isn't then it will keep getting smaller
2.we go through all the nodes in [l,r],see if it can "die" at this one:
worse case is that if everything before this node makes E smaller,and then it has to face this a_i
if none node can "die" then it is a possible solution
lets make v_i=(a_i-b_i)*[a_i>b_i]
then this transfer to $Emin=\max (\sum v_i)-v_i+a_i$
the interesting thing is -v_i+a_i dosn't really matter with [l,r]
and what is more interesting is when L incrases,R increase as well,and if [l,r] is bad then [l,r+x] is bad as well
this is two-pointer
Going back to the first limitation, we need to find given [L,R] how many [L,r<=R] can be used
Since L++ everytime,we can use range-based segement tree for this process by maintaining a flag and \sum a-\sum b.
O(nlogn)
*/