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: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 998244353
#define s(x, n) memset(x, n, sizeof(x));
#define pb(x) push_back(x)
#define NIL -1
#define MAX 200010
int n, q;
int p[MAX];
int tree[4 * MAX];
int lazy[4 * MAX];

void build(int node, int start, int end)
{
    if (start == end)
        tree[node] = 1;
    else
    {
        int mid = (start + end) / 2;
        build(2 * node, start, mid);
        build(2 * node + 1, mid + 1, end);
        //cout << p[mid - start + 2] - p[mid - start + 1] << " ";
        tree[node] = ((tree[2 * node] * (p[mid - start + 2] - p[mid - start + 1])) % mod + (tree[2 * node + 1]) % mod) % mod;
        //cout << tree[node] << "\n";
    }
}
void updaterange(int node, int start, int end, int l, int r, int val)
{
    if (lazy[node] != 0)
    {
        tree[node] = ((p[end - start + 1]) * lazy[node]) % mod;

        if (start != end)
        {
            lazy[node * 2] = lazy[node];
            lazy[node * 2 + 1] = lazy[node];
        }
        lazy[node] = 0;
    }
    if (start > end || start > r || end < l)
        return;
    if (start >= l && end <= r)
    {
        tree[node] = (val * p[end - start + 1]) % mod;
        if (start != end)
        {
            lazy[node * 2] = val;
            lazy[node * 2 + 1] = val;
        }
        return;
    }
    ll mid = (start + end) / 2;
    updaterange(2 * node, start, mid, l, r, val);
    updaterange(2 * node + 1, mid + 1, end, l, r, val);
    tree[node] = ((tree[2 * node] * (p[mid - start + 2] - p[mid - start + 1])) % mod + (tree[2 * node + 1]) % mod) % mod;
}

void solve()
{
    cin >> n >> q;
    p[0] = 0;
    int c = 1;
    for (int i = 1; i <= n; i++)
    {
        p[i] = (p[i - 1] + c) % mod;
        c *= 10;
        c %= mod;
        //cout << p[i] << " ";
    }

    build(1, 1, n);
    // cout << queryrange(1, 1, n, 1, n) % mod << "\n";
    while (q--)
    {
        int l, r, d;
        cin >> l >> r >> d;
        updaterange(1, 1, n, l, r, d);
        cout << tree[1] % mod << "\n";
    }
}
int main()
{
#ifdef WIN32
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif

#ifndef WIN32
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#endif
    int t;
    t = 1;
    /// cin >> t;
    for (int I = 1; I <= t; I++)
    {
        solve();
    }
    return 0;
}