output_description: Print Q lines. In the i-th line print the value of S after the i-th query,
  modulo 998,244,353.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N Q
      L_1 R_1 D_1
      :
      L_Q R_Q D_Q
attempt: def _ceil_pow2(n: int) -> int:
      x = 0
      while (1 << x) < n:
          x += 1
  
      return x
  
  
  def _bsf(n: int) -> int:
      x = 0
      while n % 2 == 0:
          x += 1
          n //= 2
  
      return x
  
  
  class LazySegTree:
      def __init__(self, op, e, mapping, composition, id_, v):
          self._op = op
          self._e = e
          self._mapping = mapping
          self._composition = composition
          self._id = id_
  
          if isinstance(v, int):
              v = [e] * v
  
          self._n = len(v)
          self._log = _ceil_pow2(self._n)
          self._size = 1 << self._log
          self._d = [e] * (2 * self._size)
          self._lz = [self._id] * self._size
          for i in range(self._n):
              self._d[self._size + i] = v[i]
          for i in range(self._size - 1, 0, -1):
              self._update(i)
  
      def set(self, p: int, x) -> None:
          assert 0 <= p < self._n
  
          p += self._size
          for i in range(self._log, 0, -1):
              self._push(p >> i)
          self._d[p] = x
          for i in range(1, self._log + 1):
              self._update(p >> i)
  
      def get(self, p: int):
          assert 0 <= p < self._n
  
          p += self._size
          for i in range(self._log, 0, -1):
              self._push(p >> i)
          return self._d[p]
  
      def prod(self, left: int, right: int):
          assert 0 <= left <= right <= self._n
  
          if left == right:
              return self._e
  
          left += self._size
          right += self._size
  
          for i in range(self._log, 0, -1):
              if ((left >> i) << i) != left:
                  self._push(left >> i)
              if ((right >> i) << i) != right:
                  self._push(right >> i)
  
          sml = self._e
          smr = self._e
          while left < right:
              if left & 1:
                  sml = self._op(sml, self._d[left])
                  left += 1
              if right & 1:
                  right -= 1
                  smr = self._op(self._d[right], smr)
              left >>= 1
              right >>= 1
  
          return self._op(sml, smr)
  
      def all_prod(self):
          return self._d[1]
  
      def apply(self, left: int, right=None, f=None):
          assert f is not None
  
          if right is None:
              p = left
              assert 0 <= left < self._n
  
              p += self._size
              for i in range(self._log, 0, -1):
                  self._push(p >> i)
              self._d[p] = self._mapping(f, self._d[p])
              for i in range(1, self._log + 1):
                  self._update(p >> i)
          else:
              assert 0 <= left <= right <= self._n
              if left == right:
                  return
  
              left += self._size
              right += self._size
  
              for i in range(self._log, 0, -1):
                  if ((left >> i) << i) != left:
                      self._push(left >> i)
                  if ((right >> i) << i) != right:
                      self._push((right - 1) >> i)
  
              l2 = left
              r2 = right
              while left < right:
                  if left & 1:
                      self._all_apply(left, f)
                      left += 1
                  if right & 1:
                      right -= 1
                      self._all_apply(right, f)
                  left >>= 1
                  right >>= 1
              left = l2
              right = r2
  
              for i in range(1, self._log + 1):
                  if ((left >> i) << i) != left:
                      self._update(left >> i)
                  if ((right >> i) << i) != right:
                      self._update((right - 1) >> i)
  
      def max_right(self, left: int, g) -> int:
          assert 0 <= left <= self._n
          assert g(self._e)
  
          if left == self._n:
              return self._n
  
          left += self._size
          for i in range(self._log, 0, -1):
              self._push(left >> i)
  
          sm = self._e
          first = True
          while first or (left & -left) != left:
              first = False
              while left % 2 == 0:
                  left >>= 1
              if not g(self._op(sm, self._d[left])):
                  while left < self._size:
                      self._push(left)
                      left *= 2
                      if g(self._op(sm, self._d[left])):
                          sm = self._op(sm, self._d[left])
                          left += 1
                  return left - self._size
              sm = self._op(sm, self._d[left])
              left += 1
  
          return self._n
  
      def min_left(self, right: int, g) -> int:
          assert 0 <= right <= self._n
          assert g(self._e)
  
          if right == 0:
              return 0
  
          right += self._size
          for i in range(self._log, 0, -1):
              self._push((right - 1) >> i)
  
          sm = self._e
          first = True
          while first or (right & -right) != right:
              first = False
              right -= 1
              while right > 1 and right % 2:
                  right >>= 1
              if not g(self._op(self._d[right], sm)):
                  while right < self._size:
                      self._push(right)
                      right = 2 * right + 1
                      if g(self._op(self._d[right], sm)):
                          sm = self._op(self._d[right], sm)
                          right -= 1
                  return right + 1 - self._size
              sm = self._op(self._d[right], sm)
  
          return 0
  
      def _update(self, k: int) -> None:
          self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
  
      def _all_apply(self, k: int, f) -> None:
          self._d[k] = self._mapping(f, self._d[k])
          if k < self._size:
              self._lz[k] = self._composition(f, self._lz[k])
  
      def _push(self, k: int) -> None:
          self._all_apply(2 * k, self._lz[k])
          self._all_apply(2 * k + 1, self._lz[k])
          self._lz[k] = self._id
  
  
  D = [1, 10]
  E = [1, 11]
  mod = 998244353
  
  
  def op(a, b):
      return (b[0] + a[0] * D[b[1]]) % mod, a[1] + b[1]
  
  
  e = (0, 0)
  
  
  def mapping(f, a):
      if f is None:
          return a[0], a[1]
      if a[0] == 0:
          return 0, 0
      return (f * E[a[1] - 1]) % mod, a[1]
  
  
  def composition(f, g):
      if f is None:
          return g
      else:
          return f
  
  
  id = None
  
  import sys
  
  
  def input():
      return sys.stdin.readline()[:-1]
  
  
  def main():
      N, Q = list(map(int, input().split()))
      a = 10
      for i in range(N + 1):
          a *= 10
          a %= mod
          D.append(a)
          E.append((E[-1] + a) % mod)
  
      lst = LazySegTree(op, e, mapping, composition, id, [(1, 1) for i in range(N)])
  
      for i in range(Q):
          l, r, d = list(map(int, input().split()))
          l, r = l - 1, r - 1
          lst.apply(l, r + 1, d)
          print(lst.all_prod()[0])
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  You have a string S of length N. Initially, all characters in S are `1`s.
  
  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.
samples: [{"input": "8 5\n    3 6 2\n    1 4 7\n    3 8 3\n    2 2 2\n    4 5 1", "output": "11222211\n    77772211\n    77333333\n    72333333\n    72311333\n    \n\n* * *"}, {"input": "200000 1\n    123 456 7", "output": "641437905\n    \n\nDon't forget to take the modulo."}]