#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

class segtree{
public:
	static const int N=1<<22;
	int dp_max[1<<23];
	int lazy[1<<23];
	segtree(){
		memset(dp_max,0,sizeof(dp_max));
		memset(lazy,0,sizeof(lazy));
	}

	void lazy_eval(int k){
		dp_max[k]+=lazy[k];
		if(k<N-1){
			lazy[k*2+1]+=lazy[k];
			lazy[k*2+2]+=lazy[k];
		}
		lazy[k]=0;
	}
	void lazy_upd(int k){
		dp_max[k]=max(dp_max[k*2+1],dp_max[k*2+2]);
	}

	void update(int a,int b,int v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(r<=a || b<=l)return;
		if(a<=l && r<=b){
			lazy[k]+=v;
			lazy_eval(k);
			return;
		}
		int mid=(l+r)/2;
		update(a,b,v,k*2+1,l,mid);
		update(a,b,v,k*2+2,mid,r);
		lazy_upd(k);
	}

	int find(int v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(l+1==r){
			return l;
		}
		int pos;
		int mid=(l+r)/2;
		lazy_eval(k*2+1);
		if(dp_max[k*2+1]>=v){
			pos=find(v,k*2+1,l,mid);
			lazy_eval(k*2+2);
		}else{
			pos=find(v,k*2+2,mid,r);
			lazy_eval(k*2+1);
		}
		lazy_upd(k);
		return pos;
	}

	int find2(int v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(l+1==r){
			return dp_max[k];
		}
		int val;
		int mid=(l+r)/2;
		lazy_eval(k*2+1);
		if(mid>v){
			val=find2(v,k*2+1,l,mid);
			lazy_eval(k*2+2);
		}else{
			val=find2(v,k*2+2,mid,r);
			lazy_eval(k*2+1);
		}
		lazy_upd(k);
		return val;
	}
};

int m,n;
int a[2500005],b[2500005];
segtree seg;

void init(){
	int m0,n0,md,nd;
	scanf("%d%d%d%d%d%d",&m,&n,&m0,&md,&n0,&nd);
	a[0]=m0;
	b[0]=n0;
	for(int i=1;i<m;i++){
		a[i]=(a[i-1]*58+md)%(n+1);
	}
	for(int i=1;i<n;i++){
		b[i]=(b[i-1]*58+nd)%(m+1);
	}
	sort(a,a+m);
}

int main(void){
	init();
	for(int i=0;i<m;i++){
		seg.update(i,i+1,a[i]);
	}
	ll ans=0;
	sort(b,b+n);
	reverse(b,b+n);
	for(int i=0;i<n;i++){
		if(b[i]==0)break;
		int cnt=seg.find(1);
		//printf("cnt%d %d\n",cnt,m-cnt);

		ans+=max(min(m-cnt,b[i]),0);
		if(m-cnt<=b[i]){
			seg.update(cnt,m,-1);
		}else{
			int vmin=seg.find2(m-b[i]);
			int p1=seg.find(vmin);
			int p2=seg.find(vmin+1);
			//printf("%d %d %d\n",p1,p2,vmin);
			seg.update(p2,m,-1);
			seg.update(p1,p1+b[i]-max(0,(m-p2)),-1);
		}
	}
	printf("%lld\n",ans);
	return 0;
}

### Prompt

Your task is to create a Cpp solution to the following problem:

Example

Input

2 3 1 3 1 0


Output

2

### Response

```cpp
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef long long ll;
typedef pair<int,int> P;

class segtree{
public:
	static const int N=1<<22;
	int dp_max[1<<23];
	int lazy[1<<23];
	segtree(){
		memset(dp_max,0,sizeof(dp_max));
		memset(lazy,0,sizeof(lazy));
	}

	void lazy_eval(int k){
		dp_max[k]+=lazy[k];
		if(k<N-1){
			lazy[k*2+1]+=lazy[k];
			lazy[k*2+2]+=lazy[k];
		}
		lazy[k]=0;
	}
	void lazy_upd(int k){
		dp_max[k]=max(dp_max[k*2+1],dp_max[k*2+2]);
	}

	void update(int a,int b,int v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(r<=a || b<=l)return;
		if(a<=l && r<=b){
			lazy[k]+=v;
			lazy_eval(k);
			return;
		}
		int mid=(l+r)/2;
		update(a,b,v,k*2+1,l,mid);
		update(a,b,v,k*2+2,mid,r);
		lazy_upd(k);
	}

	int find(int v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(l+1==r){
			return l;
		}
		int pos;
		int mid=(l+r)/2;
		lazy_eval(k*2+1);
		if(dp_max[k*2+1]>=v){
			pos=find(v,k*2+1,l,mid);
			lazy_eval(k*2+2);
		}else{
			pos=find(v,k*2+2,mid,r);
			lazy_eval(k*2+1);
		}
		lazy_upd(k);
		return pos;
	}

	int find2(int v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(l+1==r){
			return dp_max[k];
		}
		int val;
		int mid=(l+r)/2;
		lazy_eval(k*2+1);
		if(mid>v){
			val=find2(v,k*2+1,l,mid);
			lazy_eval(k*2+2);
		}else{
			val=find2(v,k*2+2,mid,r);
			lazy_eval(k*2+1);
		}
		lazy_upd(k);
		return val;
	}
};

int m,n;
int a[2500005],b[2500005];
segtree seg;

void init(){
	int m0,n0,md,nd;
	scanf("%d%d%d%d%d%d",&m,&n,&m0,&md,&n0,&nd);
	a[0]=m0;
	b[0]=n0;
	for(int i=1;i<m;i++){
		a[i]=(a[i-1]*58+md)%(n+1);
	}
	for(int i=1;i<n;i++){
		b[i]=(b[i-1]*58+nd)%(m+1);
	}
	sort(a,a+m);
}

int main(void){
	init();
	for(int i=0;i<m;i++){
		seg.update(i,i+1,a[i]);
	}
	ll ans=0;
	sort(b,b+n);
	reverse(b,b+n);
	for(int i=0;i<n;i++){
		if(b[i]==0)break;
		int cnt=seg.find(1);
		//printf("cnt%d %d\n",cnt,m-cnt);

		ans+=max(min(m-cnt,b[i]),0);
		if(m-cnt<=b[i]){
			seg.update(cnt,m,-1);
		}else{
			int vmin=seg.find2(m-b[i]);
			int p1=seg.find(vmin);
			int p2=seg.find(vmin+1);
			//printf("%d %d %d\n",p1,p2,vmin);
			seg.update(p2,m,-1);
			seg.update(p1,p1+b[i]-max(0,(m-p2)),-1);
		}
	}
	printf("%lld\n",ans);
	return 0;
}

```