class BIT():

    __slots__ = ["func", "e", "n", "data"]

    def __init__(self, length_or_list, func, e):
        self.func = func
        self.e = e
        if isinstance(length_or_list, int):
            self.n = length_or_list + 1
            self.data = [self.e] * self.n
        else:
            self.n = len(length_or_list) + 1
            self.data = [self.e] + length_or_list
            for i in range(1, self.n):
                if i + (i & -i) < self.n:
                    self.data[i + (i & -i)] = self.func(self.data[i + (i & -i)], self.data[i])        

    def point_append(self, index, delta):
        index += 1
        while index < self.n:
            self.data[index] = self.func(self.data[index], delta)
            index += index & -index
        
    def prefix_folded(self, end):
        res = 0
        while end > 0:
            res = self.func(res, self.data[end])
            end -= end & -end
        return res

from operator import add

MOD = 998244353

N = int(input())
As = list(map(int, input().split()))

a2A = sorted(set(As))
A2a = {A: a for a, A in enumerate(a2A)}

def modadd(a, b):
    return (a + b) % MOD


ansi = []
cnti = []
ansk = []
cntk = []


cnt_bit = BIT(N, add, 0)
A_bit = BIT(N, modadd, 0)
for A in As:
    a = A2a[A]
    ansi.append(A_bit.prefix_folded(N - a))
    cnti.append(cnt_bit.prefix_folded(N - a))
    A_bit.point_append(N - a, A)
    cnt_bit.point_append(N - a, 1)

cnt_bit = BIT(N, add, 0)
A_bit = BIT(N, modadd, 0)
for A in reversed(As):
    a = A2a[A]
    ansk.append(A_bit.prefix_folded(a))
    cntk.append(cnt_bit.prefix_folded(a))
    A_bit.point_append(a, A)
    cnt_bit.point_append(a, 1)

ansk = ansk[::-1]
cntk = cntk[::-1]

# print(ansi, ansk, cnti, cntk)

ans = 0
for ai, ci, ak, ck, A in zip(ansi, cnti, ansk, cntk, As):
    ans += ci * ck * A % MOD
    ans += ci * ak % MOD
    ans += ai * ck % MOD
    ans %= MOD

print(ans)