#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<algorithm>
#include<set>
#include<map>
#include<queue>

#define ls(x) (x<<1)
#define rs(x) (x<<1|1)
#define pb push_back
#define MP make_pair

using namespace std;

typedef long long LL;

const int maxn=5e5+5;

int n,cst;
int to_nxt[maxn],del[maxn];
int id[maxn];

LL sum[maxn];

vector<int> vec[maxn];

struct Seg1{
	LL mi[maxn<<2];

	void pushup(int x)
	{
		mi[x]=min(mi[ls(x)],mi[rs(x)]);
	}

	void build(int x,int l,int r)
	{
		if(l==r){
			mi[x]=sum[l];
			return;
		}

		int mid=(l+r)>>1;
		build(ls(x),l,mid),build(rs(x),mid+1,r);
		pushup(x);
	}

	int query_nxt(int x,int l,int r,int ql,int qr,LL k)
	{
		if(l>qr||r<ql)
			return n+1;
		if(l>=ql&&r<=qr){
			if(l==r){
				if(mi[x]<k)
					return l;
				else
					return n+1;
			}

			int mid=(l+r)>>1;
			if(mi[ls(x)]<k)
				return query_nxt(ls(x),l,mid,ql,qr,k);
			else if(mi[rs(x)]<k)
				return query_nxt(rs(x),mid+1,r,ql,qr,k);
			else
				return n+1;
		}

		int mid=(l+r)>>1;
		return min(query_nxt(ls(x),l,mid,ql,qr,k),query_nxt(rs(x),mid+1,r,ql,qr,k));
	}

}ST1;


struct Seg2{
	LL rsum[maxn<<2],lsum[maxn<<2];
	LL siz[maxn<<2],mark[maxn<<2];

	void pushup(int x)
	{
		siz[x]=siz[ls(x)]+siz[rs(x)];
		lsum[x]=lsum[ls(x)]+lsum[rs(x)];
		rsum[x]=rsum[ls(x)]+rsum[rs(x)];
	}

	void down(int x,int l,int r)
	{
		if(!mark[x])
			return;
		rsum[ls(x)]=siz[ls(x)]*mark[x];
		rsum[rs(x)]=siz[rs(x)]*mark[x];
		mark[x]=0;
	}
	void update(int x,int l,int r,int ql,int qr,LL k)
	{
		if(r<ql||l>qr)
			return;
		if(l>=ql&&r<=qr){
			rsum[x]=siz[x]*k;
			mark[x]=k;
			return;
		}

		int mid=(l+r)>>1;
		down(x,l,r);
		update(ls(x),l,mid,ql,qr,k),update(rs(x),mid+1,r,ql,qr,k);
		pushup(x);
	}
	void modify(int x,int l,int r,int pos,LL k1,LL k2)
	{
		if(l==r){
			lsum[x]=k1,rsum[x]=k2,siz[x]+=k1?1:-1;
			return;
		}

		int mid=(l+r)>>1;
		down(x,l,r);
		if(pos<=mid)
			modify(ls(x),l,mid,pos,k1,k2);
		else
			modify(rs(x),mid+1,r,pos,k1,k2);
		pushup(x);
	}
}ST2;


void work()
{
	LL anosum=0;
	ST1.build(1,1,n);

	for(int i=1;i<=n;++i){
		int nxt=ST1.query_nxt(1,1,n,i,n,sum[i-1]);
		vec[nxt].pb(i);
		to_nxt[i]=nxt;
		anosum+=nxt-i;
	}

	vector<pair<LL,int>> disp;
	for(int i=0;i<=n;++i)
		disp.pb({sum[i],i+1});
	sort(disp.begin(),disp.end());
	for(int i=0;i<disp.size();++i)
		id[disp[i].second]=i+1;



	LL ans=0;
	for(auto v:vec[n+1]){
		anosum-=to_nxt[v]-v;
		ST2.modify(1,1,disp.size(),id[v],v,n+1);
	}


	for(int i=n;i>=1;--i){
		for(auto v:vec[i]){
			anosum-=to_nxt[v]-v;
			int nxnxt=ST1.query_nxt(1,1,n,i,n,sum[v-1]-cst);
			ST2.modify(1,1,disp.size(),id[v],v,nxnxt);
		}

		int l=lower_bound(disp.begin(),disp.end(),MP(sum[i]+cst+1,0))-disp.begin()+1;
		ST2.update(1,1,disp.size(),l,disp.size(),i);

		ans=max(ans,anosum+ST2.rsum[1]-ST2.lsum[1]);

		ST2.modify(1,1,disp.size(),id[i],0,0);
		anosum+=to_nxt[i]-i;
	}

	printf("%lld",ans);
}

int main()
{
	scanf("%d%d",&cst,&n);

	for(int i=1;i<=n;++i)
		scanf("%lld",&sum[i]),sum[i]+=sum[i-1];

	work();

	return 0;
}