# Original solution
"""
遅延評価セグメント木
op(s, t)：二項演算の関数（実際に評価する値同士の演算）：現在の値の中での比較
composition(f, g)：二項演算の関数（遅延評価する値同士の演算）：どちらの値を遅延伝播するか決定
mapping(f, a)：二項演算の関数（二つの集合についての演算（ただし、X・Mの順））：現在の値と遅延評価により生じた値のどちらを採用するかを決定
rangeop(f, length)：範囲が関係してくるときに行う演算
e()：実際に評価する値の単位元
id()：遅延評価する値の単位元
update, find, bisect, 全てにおいて, 1-indexとなっている。
(大抵の場合、Atcoderの問題文の表記のままの値を、メソッドに代入すれば良い)
"""
import sys
input = sys.stdin.readline


class LazySegmentTree:
    #遅延評価セグメント木
    def __init__(s, op, e, mapping, composition, rangeop, id, v):
        if type(v) is int: v = [e()] * v
        s._n = len(v)
        s.log = s.ceil_pow2(s._n)
        s.size = 1 << s.log
        s.d = [e()] * (2 * s.size)
        s.lz = [id()] * s.size
        s.e = e
        s.op = op
        s.mapping = mapping
        s.rangeop = rangeop
        s.composition = composition
        s.id = id
        for i in range(s._n): s.d[s.size + i] = v[i]
        for i in range(s.size - 1, 0, -1): s.update(i)

    def get_length(s, i):
        return pow(2, (s.size).bit_length() - (i).bit_length())
    # 1点更新
    def set(s, p, x):
        p += s.size
        for i in range(s.log, 0, -1): s.push(p >> i)
        s.d[p] = x
        for i in range(1, s.log + 1): s.update(p >> i)

    # 1点取得
    def get(s, p):
        p += s.size
        for i in range(s.log, 0, -1): s.push(p >> i)
        return s.d[p]

    # 区間演算
    def prod(s, l, r):
        if l == r: return s.e()
        l += s.size
        r += s.size
        for i in range(s.log, 0, -1):
            if (((l >> i) << i) != l): s.push(l >> i)
            if (((r >> i) << i) != r): s.push(r >> i)
        sml, smr = s.e(), s.e()
        while (l < r):
            if l & 1: 
                sml = s.op(sml, s.d[l])
                l += 1
            if r & 1:
                r -= 1
                smr = s.op(s.d[r], smr)
            l >>= 1
            r >>= 1
        return s.op(sml, smr)

    # 全体演算
    def all_prod(s): return s.d[1]

    # 1点写像
    def apply(s, p, f):
        p += s.size
        for i in range(s.log, 0, -1): s.push(p >> i)
        s.d[p] = s.mapping(f, s.d[p])
        for i in range(1, s.log + 1): s.update(p >> i)

    # 区間写像
    def apply(s, l, r, f):
        if l == r: return
        l += s.size
        r += s.size
        for i in range(s.log, 0, -1):
            if (((l >> i) << i) != l): s.push(l >> i)
            if (((r >> i) << i) != r): s.push((r - 1) >> i)
        l2, r2 = l, r
        while l < r:
            if l & 1: 
                sml = s.all_apply(l, f)
                l += 1
            if r & 1:
                r -= 1
                smr = s.all_apply(r, f)
            l >>= 1
            r >>= 1
        l, r = l2, r2
        for i in range(1, s.log + 1):
            if (((l >> i) << i) != l): s.update(l >> i)
            if (((r >> i) << i) != r): s.update((r - 1) >> i)

    # L固定時の最長区間のR
    def max_right(s, l, g):
        if l == s._n: return s._n
        l += s.size
        for i in range(s.log, 0, -1): s.push(l >> i)
        sm = s.e()
        while True:
            while (l % 2 == 0): l >>= 1
            if not g(s.op(sm, s.d[l])):
                while l < s.size:
                    s.push(l)
                    l = 2 * l
                    if g(s.op(sm, s.d[l])):
                        sm = s.op(sm, s.d[l])
                        l += 1
                return l - s.size
            sm = s.op(sm, s.d[l])
            l += 1
            if (l & -l) == l: break
        return s._n

    # R固定時の最長区間のL
    def min_left(s, r, g):
        if r == 0: return 0
        r += s.size
        for i in range(s.log, 0, -1): s.push((r - 1) >> i)
        sm = s.e()
        while True:
            r -= 1
            while r > 1 and (r % 2): r >>= 1
            if not g(s.op(s.d[r], sm)):
                while r < s.size:
                    s.push(r)
                    r = 2 * r + 1
                    if g(s.op(s.d[r], sm)):
                        sm = s.op(s.d[r], sm)
                        r -= 1
                return r + 1 - s.size
            sm = s.op(s.d[r], sm)
            if (r & - r) == r: break
        return 0

    def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
    def all_apply(s, k, f):
        s.d[k] = s.mapping(s.rangeop(f, s.get_length(k)), s.d[k])
        if k < s.size: s.lz[k] = s.composition(f, s.lz[k])
    def push(s, k):
        s.all_apply(2 * k, s.lz[k])
        s.all_apply(2 * k + 1, s.lz[k])
        s.lz[k] = s.id()
    def ceil_pow2(s, n):
        x = 0
        while (1 << x) < n: x += 1
        return x


mod = 998244353
lim = 1 << 32

 
def func1(x, y):
    return (x + y) % mod

def func2(a2, a1):
    return (((a1 >> 32) * (a2 >> 32) % mod) << 32) + (((a1 % lim) * (a2 >> 32) + (a2 % lim)) % mod)

def func3(a, x):
    return ((a >> 32) * x + (a % lim)) % mod

def func4(x, n):
    return ((x >> 32) << 32) + (x % lim) * n % mod

def e1():
    return 0

def e2():
    return (1 << 32)


def main():
    n, q = list(map(int, input().split()))
    a = list(map(int, input().split()))

    segment = LazySegmentTree(func1, e1, func3, func2, func4, e2, a)
 
    for i in range(q):
        query = list(map(int, input().split()))
        if query[0] == 0:
            l, r, b, c = query[1:]
            segment.apply(l, r, (b << 32)+c)
        else:
            l, r = query[1:]
            res = segment.prod(l, r)
            print(res)
 
    
if __name__ == "__main__":
    main()


# Optimized solution
"""
遅延評価セグメント木
op(s, t)：二項演算の関数（実際に評価する値同士の演算）：現在の値の中での比較
composition(f, g)：二項演算の関数（遅延評価する値同士の演算）：どちらの値を遅延伝播するか決定
mapping(f, a)：二項演算の関数（二つの集合についての演算（ただし、X・Mの順））：現在の値と遅延評価により生じた値のどちらを採用するかを決定
rangeop(f, length)：範囲が関係してくるときに行う演算
e()：実際に評価する値の単位元
id()：遅延評価する値の単位元
update, find, bisect, 全てにおいて, 1-indexとなっている。
(大抵の場合、Atcoderの問題文の表記のままの値を、メソッドに代入すれば良い)
"""
import sys
input = sys.stdin.readline


class LazySegmentTree:
    #遅延評価セグメント木
    def __init__(s, op, e, mapping, composition, rangeop, id, v):
        if type(v) is int: v = [e()] * v
        s._n = len(v)
        s.log = s.ceil_pow2(s._n)
        s.size = 1 << s.log
        s.d = [e()] * (2 * s.size)
        s.lz = [id()] * s.size
        s.e = e
        s.op = op
        s.mapping = mapping
        s.rangeop = rangeop
        s.composition = composition
        s.id = id
        for i in range(s._n): s.d[s.size + i] = v[i]
        for i in range(s.size - 1, 0, -1): s.update(i)

    def get_length(s, i):
        return pow(2, (s.size).bit_length() - (i).bit_length())
    # 1点更新
    def set(s, p, x):
        p += s.size
        for i in range(s.log, 0, -1): s.push(p >> i)
        s.d[p] = x
        for i in range(1, s.log + 1): s.update(p >> i)

    # 1点取得
    def get(s, p):
        p += s.size
        for i in range(s.log, 0, -1): s.push(p >> i)
        return s.d[p]

    # 区間演算
    def prod(s, l, r):
        if l == r: return s.e()
        l += s.size
        r += s.size
        for i in range(s.log, 0, -1):
            if (((l >> i) << i) != l): s.push(l >> i)
            if (((r >> i) << i) != r): s.push(r >> i)
        sml, smr = s.e(), s.e()
        while (l < r):
            if l & 1: 
                sml = s.op(sml, s.d[l])
                l += 1
            if r & 1:
                r -= 1
                smr = s.op(s.d[r], smr)
            l >>= 1
            r >>= 1
        return s.op(sml, smr)

    # 全体演算
    def all_prod(s): return s.d[1]

    # 1点写像
    def apply(s, p, f):
        p += s.size
        for i in range(s.log, 0, -1): s.push(p >> i)
        s.d[p] = s.mapping(s.d[p], f)
        for i in range(1, s.log + 1): s.update(p >> i)

    # 区間写像
    def apply(s, l, r, f):
        if l == r: return
        l += s.size
        r += s.size
        for i in range(s.log, 0, -1):
            if (((l >> i) << i) != l): s.push(l >> i)
            if (((r >> i) << i) != r): s.push((r - 1) >> i)
        l2, r2 = l, r
        while l < r:
            if l & 1: 
                sml = s.all_apply(l, f)
                l += 1
            if r & 1:
                r -= 1
                smr = s.all_apply(r, f)
            l >>= 1
            r >>= 1
        l, r = l2, r2
        for i in range(1, s.log + 1):
            if (((l >> i) << i) != l): s.update(l >> i)
            if (((r >> i) << i) != r): s.update((r - 1) >> i)

    # L固定時の最長区間のR
    def max_right(s, l, g):
        if l == s._n: return s._n
        l += s.size
        for i in range(s.log, 0, -1): s.push(l >> i)
        sm = s.e()
        while True:
            while (l % 2 == 0): l >>= 1
            if not g(s.op(sm, s.d[l])):
                while l < s.size:
                    s.push(l)
                    l = 2 * l
                    if g(s.op(sm, s.d[l])):
                        sm = s.op(sm, s.d[l])
                        l += 1
                return l - s.size
            sm = s.op(sm, s.d[l])
            l += 1
            if (l & -l) == l: break
        return s._n

    # R固定時の最長区間のL
    def min_left(s, r, g):
        if r == 0: return 0
        r += s.size
        for i in range(s.log, 0, -1): s.push((r - 1) >> i)
        sm = s.e()
        while True:
            r -= 1
            while r > 1 and (r % 2): r >>= 1
            if not g(s.op(s.d[r], sm)):
                while r < s.size:
                    s.push(r)
                    r = 2 * r + 1
                    if g(s.op(s.d[r], sm)):
                        sm = s.op(s.d[r], sm)
                        r -= 1
                return r + 1 - s.size
            sm = s.op(s.d[r], sm)
            if (r & - r) == r: break
        return 0

    def update(s, k): s.d[k] = s.op(s.d[2 * k], s.d[2 * k + 1])
    def all_apply(s, k, f):
        s.d[k] = s.mapping(s.d[k], s.rangeop(f, s.get_length(k)))
        if k < s.size: s.lz[k] = s.composition(s.lz[k], f)
    def push(s, k):
        s.all_apply(2 * k, s.lz[k])
        s.all_apply(2 * k + 1, s.lz[k])
        s.lz[k] = s.id()
    def ceil_pow2(s, n):
        x = 0
        while (1 << x) < n: x += 1
        return x


mod = 998244353
lim = 1 << 32

 
def func1(x, y):
    return (x + y) % mod

def func2(a1, a2):
    return (((a1 >> 32) * (a2 >> 32) % mod) << 32) + (((a1 % lim) * (a2 >> 32) + (a2 % lim)) % mod)

def func3(x, a):
    return ((a >> 32) * x + (a % lim)) % mod

def func4(x, n):
    return ((x >> 32) << 32) + (x % lim) * n % mod

def e1():
    return 0

def e2():
    return (1 << 32)


def main():
    n, q = map(int, input().split())
    a = list(map(int, input().split()))

    segment = LazySegmentTree(func1, e1, func3, func2, func4, e2, a)
 
    ans = []
    for i in range(q):
        query = list(map(int, input().split()))
        if query[0] == 0:
            l, r, b, c = query[1:]
            segment.apply(l, r, (b << 32)+c)
        else:
            l, r = query[1:]
            res = segment.prod(l, r)
            ans.append(res)
    
    print(*ans, sep="\n")
 
    
if __name__ == "__main__":
    main()