#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <array>
#include <bitset>

long long mod = 1e9 + 7;
class Mint
{
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a)
  {
    x = a % mod;
    while (x < 0)
    {
      x += mod;
    }
  };
  Mint &operator+=(const Mint &a)
  {
    x += a.x;
    x %= mod;
    return *this;
  }
  Mint &operator-=(const Mint &a)
  {
    x += (mod - a.x);
    x %= mod;
    return *this;
  }
  Mint &operator*=(const Mint &a)
  {
    x *= a.x;
    x %= mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const
  {
    if (n == 0)
      return Mint(1);
    Mint y = pow(n >> 1); // pow(n/2)を計算する
    y *= y;
    if (n % 2 == 1)
      y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const
  {
    return a.pow(mod - 2);
  }

  Mint &operator/=(const Mint &a)
  {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator+(Mint &a) const
  {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator-(Mint &a) const
  {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator*(Mint &a) const
  {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator/(Mint &a) const
  {
    Mint y(*this);
    y /= a;
    return y.x;
  }
};
  // nCk @mod を計算する
Mint nCk(Mint &n, const long long k)
{
  Mint y = Mint(1);
  Mint iy = Mint(1);
  Mint one = Mint(1);
  // 割り算の演算は時間がかかるので最後に1度だけ行うようにすること
  for (Mint i(0); (i.x) < k; i.x++)
  {
    y *= (n - i);
    iy *= (i + one);
  }
  return y / iy;
}

// nPk @mod を計算する
Mint nPk(Mint &n, long long k)
{
  Mint y(1);
  for (Mint i(0); (i.x) < k; i.x++)
  {
    y *= (n - i);
  }
  return y;
}

class UnionFind
{
private:
  int n;
  std::vector<int> parent;

public:
  UnionFind(int num) : n(num)
  {
    parent = std::vector<int>(n);
    for (int i = 0; i < n; i++)
    {
      parent[i] = i;
    }
  }
  int GetRoot(int i)
  {
    int n = i;
    while (parent[n] != n)
    {
      n = parent[n];
    }
    parent[i] = n;
    return n;
  }

  bool SameGroup(int n, int m)
  {
    n = this->GetRoot(n);
    m = this->GetRoot(m);
    return n == m;
  }

  bool Unite(int n, int m)
  {
    n = this->GetRoot(n);
    m = this->GetRoot(m);
    if (n == m)
      return false;
    parent[n] = m;
    return true;
  }
};

long long getgcd(long long a, long long b)
{
  long long max = std::max(a, b);
  long long min = std::min(a, b);
  if (min == 0)
    return max;
  return getgcd(min, max % min);
}

//Mint nCk_pascar[1004][1004];
// nの値までのnCkをパスカルの三角形から求めておく
/*void Calc_nCk_pascar(int n){
  for (int i=0; i<=n; i++) {
    for (int j=0; j<=i; j++) {
      if (j==0 || j==i) nCk_pascar[i][j] = Mint(1);
      else nCk_pascar[i][j] = nCk_pascar[i-1][j-1] + nCk_pascar[i-1][j];
    }
  }
  return;
}*/

// nの値までのnCkをパスカルの三角形から求めておく
/*long long nCk_pascar[1004][1004];
void Calc_nCk_pascar(int n){
  for (int i=0; i<=n; i++) {
    for (int j=0; j<=i; j++) {
      if (j==0 || j==i) nCk_pascar[i][j] = 1;
      else nCk_pascar[i][j] = nCk_pascar[i-1][j-1] + nCk_pascar[i-1][j];
    }
  }
  return;
}
*/
Mint mynCk(int n, int k)
{
  if (2 * k > n)
    return mynCk(n, n - k);
  Mint retval(1);
  Mint iretval(1);
  for (int i = 0; i < k; i++)
  {
    retval *= Mint(n - i);
  }
  for (int i = 1; i <= k; i++)
  {
    iretval *= Mint(i);
  }
  return retval / iretval;
}

// 呼び方の例
// SegmentTree <int> st(3000, IntMax, 0, 0);
// SegmentTree <Mint> st(3000, MintMax, 0, 0);
// 値の更新：st.Update(3,4);
// 値の取得：st.GetValue(0, 2000) << std::endl;
template<typename T>
class SegmentTree {
public:
  int leaf;
  int num;
  int e;
  T (*op)(T, T);
  std::vector<T > node;
  // 初期値が指定されていないときは単位元で初期化する
  SegmentTree(int n, T (*_op)(T, T), T e) {
    leaf = 1;
    num = n;
    op = *_op;
    e = e;
    while(leaf < num) {
      leaf *= 2;
    }
    node = std::vector<T>(num * 3, e);
  }
  SegmentTree(int n, T (*_op)(T, T), T e, T init_value) {
    leaf = 1;
    num = n;
    op = *_op;
    e = e;
    while(leaf < num) {
      leaf *= 2;
    }
    node = std::vector<T>(num * 3, init_value);
  }
  // nの値をvに更新
  void Update(int n, T v) {
    n += leaf;
    node[n] = (*op)(v, node[n]);
    while(n>0) {
      n /= 2;
      node[n] = (*op)(node[2*n+1], node[2*n]);
    }
    return;
  }
  // node v（L~Rまでの範囲を管理）を起点としてmin~maxの範囲の演算結果を取得
  T GetFromNodes(int v, int min, int max, int L, int R) {
    if (min<=L && R<=max) return node[v];
    else if (max<L || R<min) return e;
    else return (*op)(GetFromNodes(2*v, min, max, L, (L+R)/2),
                         GetFromNodes(2*v+1, min, max, (L+R)/2+1, R));
  }
  // 外からはこれを呼ぶ
  T GetValue(int l, int r){
    return GetFromNodes(1, l, r, 0, leaf-1);
  }
  T GetNode(int n) {
    return node[n + leaf];
  }
};
int IntMax(int a, int b) {
  return std::max(a, b);
}
long long LongMax(long long a, long long b){
  return std::max(a, b);
}
Mint MintMax(Mint a, Mint b) {
  return Mint(std::max(a.x, b.x));
}

template<typename T>
class LazySegmentTreeSum {
public:
  int n;
  int leaf;
  T e;
  std::vector<T> node, lazy;
  LazySegmentTreeSum(int n, T e, T init_value){
    e = e;
    leaf = 1;
    while(leaf<n) leaf*=2;
    node = std::vector<T>(leaf, e);
    lazy = std::vector<T>(leaf, e);
  }
  void AddNode(int v, int min, int max, int L, int R, T value) {
    Evaluate(v);
    if (max<L || R<min) {
      return;
    } else if (min<=L && R<=max) {
      lazy[v] += value * (T)(R-L+1);
      printf("add lazy[%d] to %d\n", v, value * (T)(R-L+1));
      Evaluate(v);
      return;
    } else {
      AddNode(2*v, min, max, L, (L+R)/2, value);
      AddNode(2*v+1, min, max, (L+R)/2+1, R, value);
      node[v] = node[2*v] + node[2*v+1];
      return;
    }
  }
  // あるノードについて遅延配列の影響を評価
  void Evaluate(int v) {
    if (lazy[v]==e) return;
    node[v] += lazy[v];
    if (v<leaf) { // 子がいる場合
      lazy[2*v] += lazy[v] / T(2);
      lazy[2*v+1] += lazy[v] / T(2);
    }
    lazy[v] = e;
    return;
  }
  // [l, r]にvを足す
  void Add(int l, int r, T value) {
    AddNode(1, l, r, 0, leaf-1, value);
  }
  T GetSumNode(int v, int min, int max, int L, int R) {
    if (max<L || R<min) {
      return e;
    } else if (min<=L && R<=max) {
      Evaluate(v);
      return node[v];
    } else {
      Evaluate(v);
      T sum1 = GetSumNode(2*v, min, max, L, (L+R)/2);
      T sum2 = GetSumNode(2*v+1, min, max, (L+R)/2+1, R);
      return sum1 + sum2;
    }
  }
  // [l, r]の和を求める
  T GetSum(int l, int r) {
    return GetSumNode(1, l, r, 0, leaf-1);
  }
  T GetNode(int n) {
    return node[n + leaf];
  }
};

struct mynode {
  Mint value;
  int l;
  int r;
};

class MyLazySegmentTree {
public:
  int n;
  int leaf;
  Mint e;
  std::vector<Mint> d;
  std::vector<int> lazy;
  std::vector<mynode > node;
  MyLazySegmentTree(int n, Mint init_value){
    leaf = 1;
    while(leaf<n) leaf*=2;
    lazy = std::vector<int>(leaf*3, 0);
    d = std::vector<Mint>(leaf,0);
    node = std::vector<mynode>(leaf*3);
    // printf("d set\n");
    d[0].x = 0;
    for (int i=1; i<=leaf; i++) {
      d[i] = d[i-1];
      d[i] *= Mint(10);
      d[i] += Mint(1);
      // printf("d[%d]=%lld\n",i,d[i].x);
    }
    int tmp = 1;
    int width = leaf;
    int counter = 1;
    int pos;
    while(tmp<=leaf) {
      // printf("tmp=%d\n", tmp);
      pos = 0;
      for (int j=0; j<tmp; j++) {
        node[j+tmp].value = Mint(0);
        node[j+tmp].l = pos;
        node[j+tmp].r = pos+width-1;
        pos += width;
      }
      tmp*=2;
      width /= 2;
    }
  }
  void UpdateNode(int v, int min, int max, int L, int R, int value) {
    // printf("UpdateNode(%d,%d,%d,%d,%d,%d) called\n",v,min,max,L,R,value);
    Evaluate(v);
    if (max<L || R<min) {
      return;
    } else if (min<=L && R<=max) {
      lazy[v] = value;
      // printf("lazy[%d]=%d\n",v,lazy[v]);
      Evaluate(v);
      return;
    } else {
      UpdateNode(2*v, min, max, L, (L+R)/2, value);
      UpdateNode(2*v+1, min, max, (L+R)/2+1, R, value);
      node[v].value = node[2*v].value + node[2*v+1].value;
      // printf("node[%d].value=%lld\n",v,node[v].value.x);
      return;
    }
  }
  // あるノードについて遅延配列の影響を評価
  void Evaluate(int v) {
    if (lazy[v]==0) return;
    node[v].value = d[node[v].r+1];
    node[v].value -= d[node[v].l];
    node[v].value *= Mint(lazy[v]);
    // printf("node[%d].evaluate value=%lld\n",v,node[v].value.x);
    if (v<leaf) { // 子がいる場合
      lazy[2*v] = lazy[v];
      lazy[2*v+1] = lazy[v];
      // printf("lazy[%d]=lazy[%d]=%d\n",2*v,2*v+1,lazy[v]);
    }
    lazy[v] = 0;
    return;
  }
  // [l, r]をvに変える
  void Update(int l, int r, int value) {
    UpdateNode(1, l, r, 0, leaf-1, value);
  }
  Mint GetSumNode(int v, int min, int max, int L, int R) {
    if (max<L || R<min) {
      return Mint(0);
    } else if (min<=L && R<=max) {
      Evaluate(v);
      return node[v].value;
    } else {
      Evaluate(v);
      Mint sum1 = GetSumNode(2*v, min, max, L, (L+R)/2);
      Mint sum2 = GetSumNode(2*v+1, min, max, (L+R)/2+1, R);
      return sum1 + sum2;
    }
  }
  // [l, r]の和を求める
  Mint GetSum(int l, int r) {
    return GetSumNode(1, l, r, 0, leaf-1);
  }
  mynode GetNode(int n) {
    return node[n + leaf];
  }
  void Print() {
    for (int i=1; i<leaf*2; i++) {
      printf("vertex%d: node=(%lld,%d,%d), lazy=%d\n",
             i,node[i].value.x,node[i].l,node[i].r,lazy[i]);
    }
  }
};

int main()
{
  mod = 998244353;
  // mod = 100100100100100;
  int N, Q;
  std::cin >> N >> Q;
  std::vector<int > L(Q), R(Q), D(Q);
  for (int i=0; i<Q; i++) {
    // printf("i=%d\n",i);
    std::cin >> L[i] >> R[i] >> D[i];
    L[i] = N - L[i];
    R[i] = N - R[i];
    
  }
  // printf("read end\n");
  MyLazySegmentTree lst(N,1);
  lst.Update(0,N-1,1);
  // lst.Print();
  Mint ans;
  ans = lst.GetSum(0, N-1);
  // printf("ans init =%lld\n", ans.x);
  for (int i=0; i<Q; i++) {
    // printf("i=%d\n", i);
    lst.Update(R[i], L[i], D[i]);
    ans = lst.GetSum(0, N-1);
    printf("%lld\n", ans.x);
    // lst.Print();
  }
  return 0;
}

Measured memory_bytes: 22584