Problem: 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.

Constraints

* 1 \leq N, Q \leq 500000
* 0 \leq a_i, c < 998244353
* 1 \leq b < 998244353
* 0 \leq l < r \leq N
* All values in Input are integer.

Input

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}


Output

For each query of the latter type, print the answer.

Example

Input

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


Output

15
404
41511
4317767

Solution (in PYTHON3):

Solution:
import sys
input = sys.stdin.buffer.readline


class LazySegmentTree:
    def __init__(self, n, unitX, unitA, X_f, A_f, XA_map):
        self.n = n
        self.unitX = unitX
        self.unitA = unitA
        self.X_f = X_f  # (X, X) -> X
        self.A_f = A_f  # (A, A) -> A
        self.XA_map = XA_map  # (X, A) -> X
        self.X = [unitX] * (n + n)
        self.A = [unitA] * (n + n)

    def __getitem__(self, i):
        i += self.n
        self._propagate_above(i)
        return self.X[i]

    def __setitem__(self, i, x):
        i += self.n
        self._propagate_above(i)
        self.X[i] = x
        self._calc_above(i)

    def build(self, array):
        for i, val in enumerate(array, self.n):
            self.X[i] = val
        for i in range(self.n - 1, 0, -1):
            self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])

    def _calc_above(self, i):
        while i > 1:
            i >>= 1
            self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])

    def _propagate_above(self, i):
        k = i >> 1
        H = k.bit_length() - 1
        for h in range(H, -1, -1):
            i = k >> h
            if self.A[i] == self.unitA:
                continue
            self.X[i << 1] = self.XA_map(self.X[i << 1], self.A[i])
            self.X[i << 1 | 1] = self.XA_map(self.X[i << 1 | 1], self.A[i])
            self.A[i << 1] = self.A_f(self.A[i << 1], self.A[i])
            self.A[i << 1 | 1] = self.A_f(self.A[i << 1 | 1], self.A[i])
            self.A[i] = self.unitA

    def fold(self, l, r):
        l += self.n
        r += self.n
        l0, r0 = l // (l & -l), r // (r & -r) - 1
        self._propagate_above(l0)
        self._propagate_above(r0)
        xl = self.unitX
        xr = self.unitX
        while l < r:
            if l & 1:
                xl = self.X_f(xl, self.X[l])
                l += 1
            if r & 1:
                r -= 1
                xr = self.X_f(self.X[r], xr)
            l >>= 1
            r >>= 1
        return self.X_f(xl, xr)

    def apply(self, i, a):
        i += self.n
        self._propagate_above(i)
        self.X[i] = self.XA_map(self.X[i], a)
        self.A[i] = self.A_f(self.A[i], a)
        self._calc_above(i)

    def apply_range(self, l, r, a):
        l += self.n
        r += self.n
        l0, r0 = l // (l & -l), r // (r & -r) - 1
        self._propagate_above(l0)
        self._propagate_above(r0)
        while l < r:
            if l & 1:
                self.X[l] = self.XA_map(self.X[l], a)
                self.A[l] = self.A_f(self.A[l], a)
                l += 1
            if r & 1:
                r -= 1
                self.X[r] = self.XA_map(self.X[r], a)
                self.A[r] = self.A_f(self.A[r], a)
            l >>= 1
            r >>= 1
        self._calc_above(l0)
        self._calc_above(r0)


n, q = map(int, input().split())
a = list(map(int, input().split()))
queries = [list(map(int, input().split())) for i in range(q)]
MOD = 998244353

"""
unitX = (0, 0)
unitA = (1, 0)
X_f = lambda x1, x2: ((x1[0] + x2[0]) % MOD, (x1[1] + x2[1]) % MOD)
XA_map = lambda x, a: ((x[0] * a[0] + x[1] * a[1]) % MOD, x[1])
A_f = lambda a1, a2: ((a2[0] * a1[0]) % MOD, (a2[0] * a1[1] + a2[1]) % MOD)
"""

unitX = 0
unitA = MOD
def X_f(x1, x2):
    x10, x11 = divmod(x1, MOD)
    x20, x21 = divmod(x2, MOD)
    return ((x10 + x20) % MOD) * MOD + (x11 + x21) % MOD

def XA_map(x, a):
    x0, x1 = divmod(x, MOD)
    a0, a1 = divmod(a, MOD)
    return ((x0 * a0 + x1 * a1) % MOD) * MOD + x1

def A_f(a1, a2):
    a10, a11 = divmod(a1, MOD)
    a20, a21 = divmod(a2, MOD)
    return ((a20 * a10) % MOD) * MOD + (a20 * a11 + a21) % MOD


lst = LazySegmentTree(n, unitX, unitA, X_f, A_f, XA_map)
lst.build([val * MOD + 1 for val in a])

ans = []
for flag, *query in queries:
    if flag == 0:
        l, r, b, c = query
        if l + 1 == r:
            lst.apply(l, b * MOD + c)
        else:
            lst.apply_range(l, r, b * MOD + c)
    else:
        l, r = query
        if l + 1 == r:
            ans.append(lst[l] // MOD)
        else:
            ans.append(lst.fold(l, r) // MOD)

print("\n".join(map(str, ans)))