output_description: For each query of the latter type, print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N Q
      a_0 a_1 ... a_{N - 1}
      \textrm{Query}_0
      \textrm{Query}_1
      :
      \textrm{Query}_{Q - 1}
attempt: #!/usr/bin/env python3
  import sys
  
  sys.setrecursionlimit(10**6)
  INF = 10**9 + 1  # sys.maxsize # float("inf")
  MOD = 998244353
  
  
  def set_depth(depth):
      global DEPTH, SEGTREE_SIZE, NONLEAF_SIZE
      DEPTH = depth
      SEGTREE_SIZE = 1 << DEPTH
      NONLEAF_SIZE = 1 << (DEPTH - 1)
  
  
  def set_width(width):
      set_depth((width - 1).bit_length() + 1)
  
  
  def get_size(pos):
      ret = pos.bit_length()
      return 1 << (DEPTH - ret)
  
  
  def up(pos):
      pos += SEGTREE_SIZE // 2
      return pos // (pos & -pos)
  
  
  def up_propagate(table, pos, binop):
      while pos > 1:
          pos >>= 1
          table[pos] = binop(table[pos * 2], table[pos * 2 + 1])
  
  
  def full_up(table, binop):
      for i in range(NONLEAF_SIZE - 1, 0, -1):
          table[i] = binop(table[2 * i], table[2 * i + 1])
  
  
  def force_down_propagate(
      action_table, value_table, pos, action_composite, action_force, action_unity
  ):
      max_level = pos.bit_length() - 1
      size = NONLEAF_SIZE
      for level in range(max_level):
          size //= 2
          i = pos >> (max_level - level)
          action = action_table[i]
          if action != action_unity:
              action_table[i * 2] = action_composite(action, action_table[i * 2])
              action_table[i * 2 + 1] = action_composite(action, action_table[i * 2 + 1])
              action_table[i] = action_unity
              value_table[i * 2] = action_force(action, value_table[i * 2], size)
              value_table[i * 2 + 1] = action_force(action, value_table[i * 2 + 1], size)
  
  
  def force_range_update(
      value_table,
      action_table,
      left,
      right,
      action,
      action_force,
      action_composite,
      action_unity,
  ):
      """
      action_force: action, value, cell_size => new_value
      action_composite: new_action, old_action => composite_action
      """
      left += NONLEAF_SIZE
      right += NONLEAF_SIZE
      while left < right:
          if left & 1:
              value_table[left] = action_force(action, value_table[left], get_size(left))
              action_table[left] = action_composite(action, action_table[left])
              left += 1
          if right & 1:
              right -= 1
              value_table[right] = action_force(
                  action, value_table[right], get_size(right)
              )
              action_table[right] = action_composite(action, action_table[right])
  
          left //= 2
          right //= 2
  
  
  def range_reduce(table, left, right, binop, unity):
      ret_left = unity
      ret_right = unity
      left += NONLEAF_SIZE
      right += NONLEAF_SIZE
      while left < right:
          if left & 1:
              ret_left = binop(ret_left, table[left])
              left += 1
          if right & 1:
              right -= 1
              ret_right = binop(table[right], ret_right)
  
          left //= 2
          right //= 2
      return binop(ret_left, ret_right)
  
  
  def lazy_range_update(
      action_table,
      value_table,
      start,
      end,
      action,
      action_composite,
      action_force,
      action_unity,
      value_binop,
  ):
      "update [start, end)"
      L = up(start)
      R = up(end)
      force_down_propagate(
          action_table, value_table, L, action_composite, action_force, action_unity
      )
      force_down_propagate(
          action_table, value_table, R, action_composite, action_force, action_unity
      )
  
      # print("action", file=sys.stderr)
      # debugprint(action_table)
      # print("value", file=sys.stderr)
      # debugprint(value_table)
      # print(file=sys.stderr)
  
      force_range_update(
          value_table,
          action_table,
          start,
          end,
          action,
          action_force,
          action_composite,
          action_unity,
      )
      up_propagate(value_table, L, value_binop)
      up_propagate(value_table, R, value_binop)
  
  
  def lazy_range_reduce(
      action_table,
      value_table,
      start,
      end,
      action_composite,
      action_force,
      action_unity,
      value_binop,
      value_unity,
  ):
      "reduce [start, end)"
      force_down_propagate(
          action_table,
          value_table,
          up(start),
          action_composite,
          action_force,
          action_unity,
      )
      force_down_propagate(
          action_table, value_table, up(end), action_composite, action_force, action_unity
      )
  
      return range_reduce(value_table, start, end, value_binop, value_unity)
  
  
  def debug(*x):
      print(*x, file=sys.stderr)
  
  
  def main():
      # parse input
      N, Q = map(int, input().split())
      AS = list(map(int, input().split()))
      set_width(N)
  
      value_unity = 0
      value_table = [value_unity] * SEGTREE_SIZE
      value_table[NONLEAF_SIZE : NONLEAF_SIZE + len(AS)] = AS
  
      action_unity = None
      action_table = [action_unity] * SEGTREE_SIZE
  
      def action_force(action, value, size):
          if action == action_unity:
              return value
          b, c = action
          return (value * b + c * size) % MOD
  
      def action_composite(new_action, old_action):
          if new_action == action_unity:
              return old_action
          if old_action == action_unity:
              return new_action
          b1, c1 = old_action
          b2, c2 = new_action
          debug(new_action, old_action, (b1 * b2, b2 * c1 + c2))
          return (b1 * b2, b2 * c1 + c2)
  
      def value_binop(a, b):
          return (a + b) % MOD
  
      full_up(value_table, value_binop)
  
      for _q in range(Q):
          q, *args = map(int, input().split())
          if q == 0:
              l, r, b, c = args
              lazy_range_update(
                  action_table,
                  value_table,
                  l,
                  r,
                  (b, c),
                  action_composite,
                  action_force,
                  action_unity,
                  value_binop,
              )
  
              pass
          else:
              l, r = args
              print(
                  lazy_range_reduce(
                      action_table,
                      value_table,
                      l,
                      r,
                      action_composite,
                      action_force,
                      action_unity,
                      value_binop,
                      value_unity,
                  )
              )
  
  
  T1 = """
  5 7
  1 2 3 4 5
  1 0 5
  0 2 4 100 101
  1 0 3
  0 1 3 102 103
  1 2 5
  0 2 5 104 105
  1 0 5
  """
  TEST_T1 = """
  >>> as_input(T1)
  >>> main()
  15
  404
  41511
  4317767
  """
  
  
  def _test():
      import doctest
  
      doctest.testmod()
      g = globals()
      for k in sorted(g):
          if k.startswith("TEST_"):
              doctest.run_docstring_examples(g[k], g, name=k)
  
  
  def as_input(s):
      "use in test, use given string as input file"
      import io
  
      f = io.StringIO(s.strip())
      g = globals()
      g["input"] = lambda: bytes(f.readline(), "ascii")
      g["read"] = lambda: bytes(f.read(), "ascii")
  
  
  input = sys.stdin.buffer.readline
  read = sys.stdin.buffer.read
  
  if sys.argv[-1] == "-t":
      print("testing")
      _test()
      sys.exit()
  
  main()
  
problem_description: Statement
  
  You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries
  of the following types.
  
    * `0 l r b c`: For each i = l, l+1, \dots, {r - 1}, set a_i \gets b \times a_i + c.
    * `1 l r`: Print \sum_{i = l}^{r - 1} a_i \bmod 998244353.
samples: [{"input": "5 7\n    1 2 3 4 5\n    1 0 5\n    0 2 4 100 101\n    1 0 3\n    0 1 3 102 103\n    1 2 5\n    0 2 5 104 105\n    1 0 5", "output": "15\n    404\n    41511\n    4317767"}]