Problem:
Score : 500 points

Problem Statement

You have a string S of length N.
Initially, all characters in S are 1s.

You will perform queries Q times.
In the i-th query, you are given two integers L_i, R_i and a character D_i (which is a digit).
Then, you must replace all characters from the L_i-th to the R_i-th (inclusive) with D_i.

After each query, read the string S as a decimal integer, and print its value modulo 998,244,353.

Constraints

1 \leq N, Q \leq 200,000

1 \leq L_i \leq R_i \leq N

1 \leq D_i \leq 9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N Q
L_1 R_1 D_1
:
L_Q R_Q D_Q

Output

Print Q lines.
In the i-th line print the value of S after the i-th query, modulo 998,244,353.

Sample Input 1

8 5
3 6 2
1 4 7
3 8 3
2 2 2
4 5 1

Sample Output 1

11222211
77772211
77333333
72333333
72311333

Sample Input 2

200000 1
123 456 7

Sample Output 2

641437905

Don't forget to take the modulo.

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <functional>
#include <cmath>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define pll pair<ll,ll>
#define MOD (ll)998244353
const int sz = 1 << 18;
ll arr[sz * 2], lazy[sz * 2];
ll mod[sz * 2];

void construct()
{
	for (int i = sz - 1; i >= 1; i--)
		arr[i] = (arr[i * 2] + arr[i * 2 + 1]) % MOD;
}

void propagate(int node, int ns, int ne)
{
	if (lazy[node])
	{
		if (node < sz)
		{
			lazy[node * 2] = lazy[node];
			lazy[node * 2 + 1] = lazy[node];
		}
		arr[node] = (lazy[node] * ((mod[ns] - mod[ne + 1] + MOD) % MOD)) % MOD;
		lazy[node] = 0LL;
	}
}

void query(int s, int e, ll k, int node, int ns, int ne)
{
	propagate(node, ns, ne);
	if (e < ns || ne < s) return;
	if (s <= ns && ne <= e)
	{
		lazy[node] = k;
		propagate(node, ns, ne);
		return;
	}
	int mid = (ns + ne) / 2;
	query(s, e, k, node * 2, ns, mid);
	query(s, e, k, node * 2 + 1, mid + 1, ne);
	arr[node] = (arr[node * 2] + arr[node * 2 + 1]) % MOD;
}

ll sum(int s, int e, int node, int ns, int ne)
{
	propagate(node, ns, ne);
	if (e < ns || ne < s) return 0LL;
	if (s <= ns && ne <= e) return arr[node];
	int mid = (ns + ne) / 2;
	return (sum(s, e, node * 2, ns, mid) + sum(s, e, node * 2 + 1, mid + 1, ne)) % MOD;
}


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

	mod[n] = 1LL;
	arr[n + sz] = 1LL;
	for (int i = n - 1; i >= 1; i--)
	{
		mod[i] = (mod[i + 1] * 10LL + 1LL) % MOD;
		arr[i + sz] = (mod[i] - mod[i + 1] + MOD) % MOD;
	}

	construct();

	int l, r;
	ll d;
	while (q--)
	{
		scanf("%d %d %lld", &l, &r, &d);
		query(l, r, d, 1, 0, sz - 1);
		printf("%lld\n", sum(1, n, 1, 0, sz - 1));
	}

	return 0;
}