Given are three positive integers A, B, and C. Compute the following value modulo 998244353:
\sum_{a=1}^{A} \sum_{b=1}^{B} \sum_{c=1}^{C} abc

-----Constraints-----
 - 1 \leq A, B, C \leq 10^9

-----Input-----
Input is given from standard input in the following format:
A B C

-----Output-----
Print the value modulo 998244353.

-----Sample Input-----
1 2 3

-----Sample Output-----
18

We have: (1 \times 1 \times 1) + (1 \times 1 \times 2) + (1 \times 1 \times 3) + (1 \times 2 \times 1) + (1 \times 2 \times 2) + (1 \times 2 \times 3) = 1 + 2 + 3 + 2 + 4 + 6 = 18.

Source: atcoder | Difficulty: MEDIUM_HARD


Solutions:
(A, B, C) = map(int, input().split())
mod = 998244353
ans = A * (A + 1) * B * (B + 1) * C * (C + 1) // 8
print(ans % mod)


(A, B, C) = list(map(int, input().split()))
D = A * (A + 1) // 2 * (B * (B + 1) // 2) * (C * (C + 1) // 2)
print(D % 998244353)


l = list(map(int, input().split()))
ans = l[0] * (l[0] + 1) * l[1] * (l[1] + 1) * l[2] * (l[2] + 1) // 8 % 998244353
print(ans)


(A, B, C) = map(int, input().split())
s = A * (A + 1) // 2 * (B * (B + 1) // 2) * (C * (C + 1) // 2)
print(s % 998244353)


(a, b, c) = map(int, input().split())
mod = 998244353
print(a * (a + 1) * b * (b + 1) * c * (c + 1) // 8 % mod)


r = 1
for n in list(map(int, input().split())):
	s = n * (n + 1) // 2 % 998244353
	r = r * s % 998244353
print(int(r))


(mod1, mod2) = (10 ** 9 + 7, 998244353)
mod = mod2

def f(a):
	return int(a) * (int(a) + 1) % mod
(a, b, c) = map(f, input().split())
d = a * b * c % mod
print(d * pow(8, -1, mod) % mod)


from functools import reduce
from operator import mul
print(reduce(mul, (i * (1 + i) // 2 for i in map(int, input().split()))) % 998244353)


def f(a):
	return a * (a + 1) // 2
(a, b, c) = map(int, input().split())
ans = f(a) * f(b) * f(c)
ans = ans % 998244353
print(ans)


import math
from collections import Counter
import itertools
ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(map(int, input().split()))
(a, b, c) = mi()
ans = a * (a + 1) // 2 * (b * (b + 1) // 2) * (c * (c + 1) // 2)
print(ans % 998244353)


(A, B, C) = map(int, input().split())
S = A * (A + 1) // 2 * (B * (B + 1) // 2) * (C * (C + 1) // 2)
print(S % 998244353)


(a, b, c) = list(map(int, input().split()))
t = (a + 1) * a * (b + 1) * b * (c + 1) * c // 8
ans = t % 998244353
print(ans)


(a, b, c) = map(int, input().split())
mod = 998244353
print(a * (a + 1) // 2 % mod * (b * (b + 1) // 2 % mod) * (c * (c + 1) // 2 % mod) % mod)


(a, b, c) = list(map(int, input().split()))
sum = 0
sum = a * b * c * (a + 1) * (b + 1) * (c + 1) // 8
print(int(sum % 998244353))


mod = 998244353

def main():
	(a, b, c) = map(int, input().split())
	a = a * (a + 1) // 2 % mod
	b = b * (b + 1) // 2 % mod
	c = c * (c + 1) // 2 % mod
	print(a * b % mod * c % mod)

def __starting_point():
	main()
__starting_point()


import sys
try:
	import os
	f = open('input.txt', 'r')
	sys.stdin = f
except FileNotFoundError:
	None
from math import sqrt, ceil, floor
from collections import deque, Counter, defaultdict
input = lambda : sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import ROUND_HALF_UP, Decimal
from functools import lru_cache
from bisect import bisect_left as bileft, bisect_right as biright, insort
from itertools import combinations as com, permutations as per
from fractions import Fraction as frac

def f(n):
	return n * (n + 1) // 2
(a, b, c) = list(map(int, input().split()))
mod = 998244353
print(f(a) % mod * (f(b) % mod) * (f(c) % mod) % mod)


(A, B, C) = map(int, input().split())
print(A * B * C * (A + 1) * (B + 1) * (C + 1) // 8 % 998244353)


(A, B, C) = list(map(int, input().split()))
MOD = 998244353
ans = A * (1 + A) // 2 * (B * (1 + B) // 2) * (C * (1 + C) // 2) % MOD
print(ans)


A = list(map(lambda X: X * (X + 1) // 2, map(int, input().split())))
print(A[0] * A[1] * A[2] % 998244353)


MOD = 998244353
(a, b, c) = map(int, input().split())
sa = a * (a + 1) // 2 % MOD
sb = b * (b + 1) // 2 % MOD
sc = c * (c + 1) // 2 % MOD
ans = sa * sb % MOD * sc % MOD
if ans < 0:
	ans += MOD
print(ans)


(A, B, C) = list(map(int, input().split()))
x = 998244353
ans = A * (A + 1) * B * (B + 1) * C * (C + 1) // 8
ans %= x
print(ans)


while True:
	try:
		(a, b, c) = map(int, input().split())
		print((1 + a) * a // 2 * (1 + b) * b // 2 * (1 + c) * c // 2 % 998244353)
	except:
		break


(A, B, C) = map(int, input().split())

def func(x):
	return x * (x + 1) // 2
mod = 998244353
ans = pow(func(A) * func(B) * func(C), 1, mod)
print(ans)


(a, b, c) = map(int, input().split())
ans = a * (a + 1) // 2 * b * (b + 1) // 2 * c * (c + 1) // 2
print(ans % 998244353)


(a, b, c) = map(int, input().split())
p = 998244353
print(a * (a + 1) * b * (b + 1) * c * (c + 1) // 8 % p)


def main():
	law = 998244353
	(a, b, c) = list(map(int, input().split()))
	print(sum_mod(a, law) * sum_mod(b, law) * sum_mod(c, law) % law)
	return

def sum_mod(max, law):
	x = max
	y = max + 1
	if x % 2 == 0:
		x //= 2
	else:
		y //= 2
	x = x % law
	y = y % law
	return x * y % law

def __starting_point():
	main()
__starting_point()


(a, b, c) = map(int, input().split())
mod = 998244353
x = a * (a + 1) // 2
y = b * (b + 1) // 2
z = c * (c + 1) // 2
print(x * y * z % mod)


ans = 0
(a, b, c) = map(int, input().split())

def ss(n):
	return n * (n + 1) // 2
a = ss(a)
b = ss(b)
c = ss(c)
ans = a * b * c
print(ans % 998244353)


(a, b, c) = map(int, input().split(' '))
P = 998244353

def f(x):
	return x * (x + 1) // 2 % P
print(f(a) * f(b) % P * f(c) % P)


(A, B, C) = map(lambda x: int(x), input().split())
SA = (A + 1) * A // 2 % 998244353
SB = (B + 1) * B // 2 % 998244353
SC = (C + 1) * C // 2 % 998244353
print(SA * SB * SC % 998244353)


a = list(map(int, input().split()))
z = 998244353
print(a[0] * (a[0] + 1) * (a[1] + 1) * a[1] * a[2] * (a[2] + 1) // 8 % z)


(A, B, C) = map(int, input().split())
M = 998244353
x = (1 + A) * A // 2
y = (1 + B) * B // 2
z = (1 + C) * C // 2
x %= M
y %= M
z %= M
ans = x * y * z % M
print(ans)


(A, B, C) = map(int, input().split())
n = A * (A + 1) // 2 * B * (B + 1) // 2 * C * (C + 1) // 2
ans = n % 998244353
print(ans)


(a, b, c) = map(int, input().split())
MOD = 998244353
(A, B, C) = (a * (a + 1) // 2, b * (b + 1) // 2, c * (c + 1) // 2)
print(A * B * C % MOD)


import sys
sys.setrecursionlimit(10 ** 7)
import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor

def cmb(n, r, mod):
	bunshi = 1
	bunbo = 1
	for i in range(r):
		bunbo = bunbo * (i + 1) % mod
		bunshi = bunshi * (n - i) % mod
	return bunshi * pow(bunbo, mod - 2, mod) % mod
mod = 998244353

def I():
	return int(input())

def LI():
	return list(map(int, input().split()))

def MI():
	return list(map(int, input().split()))

def LLI(n):
	return [list(map(int, input().split())) for _ in range(n)]
(a, b, c) = MI()
sum_a = a * (a + 1) // 2
sum_b = b * (b + 1) // 2
sum_c = c * (c + 1) // 2
sum_a = sum_a % mod
sum_b = sum_b % mod
sum_c = sum_c % mod
print(sum_a * sum_b * sum_c % mod)


def sum_arith_prog(a, b, c):
	tmp_list = [a, b, c]
	for i in tmp_list:
		yield (i * (i + 1) // 2)

def main():
	(a, b, c) = list(map(int, input().split()))
	(a_sum, b_sum, c_sum) = sum_arith_prog(a, b, c)
	a_b_c_multi = a_sum * b_sum * c_sum
	ans = a_b_c_multi % 998244353
	print(ans)

def __starting_point():
	main()
__starting_point()


(A, B, C) = list(map(int, input().split()))
total_c = (1 + C) * C // 2
total_b = (1 + B) * B // 2
total_a = (1 + A) * A // 2
ans = total_a * total_b * total_c % 998244353
print(ans)


(a, b, c) = map(int, input().split())
sumA = a * (a + 1) // 2
sumB = b * (b + 1) // 2
sumC = c * (c + 1) // 2
print(sumA * sumB * sumC % 998244353)


(a, b, c) = list(map(int, input().split()))
a = a * (a + 1) // 2 % 998244353
b = b * (b + 1) // 2 % 998244353
c = c * (c + 1) // 2 % 998244353
print(a * b * c % 998244353)


(A, B, C) = map(int, input().split())
mod = 998244353
suma = (A + 1) * A // 2 % mod
sumb = (B + 1) * B // 2 % mod
sumc = (C + 1) * C // 2 % mod
print(suma * sumb * sumc % mod)


(A, B, C) = list(map(int, input().split()))
MOD = 998244353
Sa = A * (A + 1) // 2
Sb = B * (B + 1) // 2
Sc = C * (C + 1) // 2
print(Sa * Sb * Sc % MOD)


(A, B, C) = map(int, input().split())
A = A * (A + 1) // 2 % 998244353
B = B * (B + 1) // 2 % 998244353
C = C * (C + 1) // 2 % 998244353
X = A * B % 998244353
X = X * C % 998244353
print(int(X))


MOD = 998244353

def solve(A, B, C):
	tmp = 1
	tmp *= A * (A + 1) // 2
	tmp %= MOD
	tmp *= B * (B + 1) // 2
	tmp %= MOD
	tmp *= C * (C + 1) // 2
	tmp %= MOD
	return tmp

def main():
	(A, B, C) = list(map(int, input().split()))
	a = solve(A, B, C)
	print(a)

def __starting_point():
	main()
__starting_point()


(A, B, C) = map(int, input().split())

def modder(x):
	ans = int(x % 998244353)
	return ans
A = modder(A)
B = modder(B)
C = modder(C)
resulta = modder(A * (A + 1))
resultb = modder(B * (B + 1))
resultc = modder(C * (C + 1))
resultu = modder(resulta * resultb * resultc)
no = 1
while no:
	if resultu % 8 != 0:
		resultu = resultu + 998244353
	else:
		no = 0
result = int(resultu / 8)
print(result)


(a, b, c) = list(map(int, input().split()))
mod = 998244353
ta = a * (a + 1) // 2
tb = b * (b + 1) // 2
tc = c * (c + 1) // 2
ans = ta * tb % mod
ans = ans * tc % mod
print(ans)


ABC = list(map(int, input().split()))
total = 1
for i in ABC:
	total *= i * (i + 1) // 2
print(total % 998244353)


MOD = 998244353
(a, b, c) = map(int, input().split())
print(a * (a + 1) // 2 * b * (b + 1) // 2 * c * (c + 1) // 2 % MOD)


import math, sys

def nsum(n):
	return n * (n + 1) // 2
a = list(map(int, input().split()))
(a, b, c) = (a[0], a[1], a[2])
num = nsum(a) * nsum(b) * nsum(c)
print(num % 998244353)


import sys
import io
import math
import collections
import decimal
import itertools
from queue import PriorityQueue
import bisect

def input():
	return sys.stdin.readline()[:-1]
sys.setrecursionlimit(1000000)
MOD = 998244353

def solve(A, B, C):
	pass

def main():
	(A, B, C) = list(map(int, input().split()))
	a = A * (A + 1) // 2 * (B * (B + 1) // 2) * (C * (C + 1) // 2)
	print(a % MOD)

def __starting_point():
	main()
__starting_point()


import itertools
(a, b, c) = list(map(int, input().split()))
ans = a * b * c * (a + 1) * (b + 1) * (c + 1) // 8
print(ans % 998244353)


p = 998244353
(A, B, C) = map(int, input().split())
x = A * (A + 1) // 2 % p
x = x * (B * (B + 1)) // 2 % p
x = x * (C * (C + 1)) // 2 % p
print(x)


import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce
rr = lambda : sys.stdin.readline().rstrip()
rs = lambda : sys.stdin.readline().split()
ri = lambda : int(sys.stdin.readline())
rm = lambda : list(map(int, sys.stdin.readline().split()))
rf = lambda : list(map(float, sys.stdin.readline().split()))
rl = lambda : list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod1 = 10 ** 9 + 7
mod2 = 998244353
al = 'abcdefghijklmnopqrstuvwxyz'
Al = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
(a, b, c) = rm()
ans = 1
c = (c + 1) * c // 2
ans *= c
ans %= mod2
b = (b + 1) * b // 2
ans *= b
ans %= mod2
a = (a + 1) * a // 2
ans *= a
ans %= mod2
print(ans)


import sys
from math import factorial
MOD = 998244353
INF = float('inf')
(A, B, C) = list(map(int, input().split()))
aa = A * (A + 1) // 2 % MOD
bb = B * (B + 1) // 2 % MOD
cc = C * (C + 1) // 2 % MOD
out = aa * bb * cc % MOD
print('{}'.format(out))


import sys
(a, b, c) = map(int, input().split())
n = 998244353
print(a * (a + 1) // 2 % n * b * (b + 1) // 2 % n * c * (c + 1) // 2 % n)


import sys
sys.setrecursionlimit(10 ** 7)

def I():
	return int(sys.stdin.readline().rstrip())

def MI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def LI():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def LI2():
	return list(map(int, sys.stdin.readline().rstrip()))

def S():
	return sys.stdin.readline().rstrip()

def LS():
	return list(sys.stdin.readline().rstrip().split())

def LS2():
	return list(sys.stdin.readline().rstrip())
(A, B, C) = MI()
mod = 998244353
ans = A * (A + 1) // 2 * B * (B + 1) // 2 * C * (C + 1) // 2
ans %= mod
print(ans)


(a, b, c) = map(int, input().split())
total = 1
for i in [a, b, c]:
	total *= i * (i + 1) // 2
print(total % 998244353)


(A, B, C) = map(int, input().split())
sum = A * (A + 1) // 2 * B * (B + 1) // 2 * C * (C + 1) // 2
print(sum % 998244353)


MOD = 998244353
(a, b, c) = map(int, input().split())
f = lambda x: x * (x + 1) // 2 % MOD
(x, y, z) = (f(a), f(b), f(c))
print(f(a) * f(b) * f(c) % MOD)


(A, B, C) = list(map(int, input().split()))
a_sum = A * (A + 1) // 2
b_sum = B * (B + 1) // 2
c_sum = C * (C + 1) // 2
ans = a_sum * b_sum * c_sum % 998244353
print(ans)


(A, B, C) = map(int, input().split())
d = 998244353
sumA = A * (A + 1) // 2
sumB = B * (B + 1) // 2
sumC = C * (C + 1) // 2
ans = sumA * sumB * sumC % d
print(ans)


(a, b, c) = map(int, input().split())
sum = a * (a + 1) // 2
sum *= b * (b + 1) // 2
sum *= c * (c + 1) // 2
print(sum % 998244353)


num = list(map(int, input().split()))
mod = 998244353
ans = 1
for i in num:
	ans *= i * (i + 1) // 2
print(ans % mod)