Problem: E: Binary Sequence-Binary Sequence-

story

I love binaries Bonald.Brvin.Bnuth! He is known as Uncle Bnuth, who is studying the nature of binary sequences at Offtunford University! By the way, if my name "Bonald.Brvin.Bnuth" is binarized from ASCII code, it will be "1000010 1101111 1101110 1100001 1101100 1100100 101110 1000010 1110010 1110110 1101001 1101110 101110 1000010 1101110 1110101 1110100 1101000"! It's fun!

I'm looking forward to it from the morning because my disciples are going to do some interesting experiments today! What are you doing?

What! I want to discover some properties by continuing to rewrite binary strings! HM! This is the scent of an important discovery! Let's start the experiment! Let's summarize more detailed settings as sentences!

problem

Given a binary sequence of length n x = (x_1, ..., x_n) (x_i \ in \\ {0,1 \\}, i = 1, ..., n). For the binary string x, we define two functions f (x) and g (x) as follows.


f (x) = Σ_ {i = 1} ^ {n} x_i = x_1 + x_2 + ... + x_n
g (x) = Σ_ {i = 1} ^ {n-1} x_i x_ {i + 1} = x_1 x_2 + x_2 x_3 + ... x_ {n-1} x_n


Now, perform the following change operation on the binary string x q times. The jth change operation is given by l_j, r_j, b_j (1 \ leq l_j \ leq r_j \ leq n, b_j \ in \\ {0,1 \\}, j = 1, ..., q). This corresponds to the operation of replacing the l_jth to r_jths of the binary string x with b_j. Find f (x) --g (x) after each change operation.

Input format


n
x
q
l_1 r_1 b_1
...
l_q r_q b_q


The first line is given the integer n that represents the length of the binary column. The second line is given a string that represents the binary column x. The third line is given the integer q, which represents the number of queries. In the following q lines, the i-th line is given information about the i-th query l_i, r_i, b_i in this order, separated by blanks.

Constraint

* 2 \ leq n \ leq 100000
* x is a character string consisting of ‘0’ and ‘1’
* | x ​​| = n
* 1 \ leq q \ leq 100000
* 1 \ leq l_j \ leq r_j \ leq n, b_j \ in \\ {0,1 \\}, j = 1, ..., q



Output format

For each i = 1, ..., q, output the value of f (x) --g (x) after processing the i-th query on the i-line.

Input example 1


Ten
0101100110
3
3 3 1
1 6 0
2 5 1


Output example 1


2
1
2


Input example 2


8
00111100
3
8 8 1
4 5 0
7 8 1


Output example 2


2
3
2






Example

Input

10
0101100110
3
3 3 1
1 6 0
2 5 1


Output

2
1
2

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

int NN = 1;
struct Node{
  int f, g, l, r;
  int lazy;
};
Node segT[2*(1<<17)-1]; // =131072

class LazySegT{
public:
  LazySegT(){
	for(int i=0;i<2*NN-1;++i){
	  segT[i].f = segT[i].g = segT[i].l = segT[i].r = 0;
	  segT[i].lazy = -1;
	}
  }

  void eval(int k, int l, int r){
	if(segT[k].lazy < 0) return;
	
	segT[k].f = (r-l) * segT[k].lazy;
	segT[k].g = (r-l-1) * segT[k].lazy;
	segT[k].l = segT[k].r = segT[k].lazy;

	if(k < NN-1){ // not leaf
	  segT[2*k+1].lazy = segT[2*k+2].lazy = segT[k].lazy;
	}
	segT[k].lazy = -1;
  }

  void update(int a, int b, int bit, int k=0, int l=0, int r=NN){
	eval(k,l,r);
	if(r <= a || b <= l) return;

	if(a <= l && r <= b){
	  segT[k].lazy = bit;
	  eval(k,l,r);
	}
	else{
	  int m = (l+r) / 2;
	  update(a, b, bit, k*2+1, l, m);
	  update(a, b, bit, k*2+2, m, r);

	  segT[k].f = segT[k*2+1].f + segT[k*2+2].f;
	  segT[k].g = segT[k*2+1].g + segT[k*2+2].g + segT[k*2+1].r * segT[k*2+2].l;
	  segT[k].l = segT[k*2+1].l;
	  segT[k].r = segT[k*2+2].r;
	}
  }

  int query(){
	eval(0, 0, NN);
	return segT[0].f - segT[0].g;
  }
};

int main(){
  int N; cin >> N;
  while(NN < N) NN <<= 1;
  string X; cin >> X;
  int Q; cin >> Q;

  LazySegT seg;
  for(int i=0;i<X.size();++i){
	seg.update(i, i+1, X[i]-'0');
  }

  for(int q=0;q<Q;++q){
	int l, r, b;
	cin >> l >> r >> b;
	--l;
	seg.update(l, r, b);
	cout << seg.query() << endl;
  }
  
  return 0;
}