You wrote down all integers from $0$ to $10^n - 1$, padding them with leading zeroes so their lengths are exactly $n$. For example, if $n = 3$ then you wrote out 000, 001, ..., 998, 999.

A block in an integer $x$ is a consecutive segment of equal digits that cannot be extended to the left or to the right.

For example, in the integer $00027734000$ there are three blocks of length $1$, one block of length $2$ and two blocks of length $3$.

For all integers $i$ from $1$ to $n$ count the number of blocks of length $i$ among the written down integers.

Since these integers may be too large, print them modulo $998244353$.


-----Input-----

The only line contains one integer $n$ ($1 \le n \le 2 \cdot 10^5$).


-----Output-----

In the only line print $n$ integers. The $i$-th integer is equal to the number of blocks of length $i$.

Since these integers may be too large, print them modulo $998244353$.


-----Examples-----
Input
1

Output
10

Input
2

Output
180 10

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Dynamic programming

Combinatorics

Mathematics


Solutions:
def main():
	import sys
	input = sys.stdin.readline
	n = int(input())
	mod = 998244353
	l = [1]
	ans = []
	for i in range(2 * 10 ** 5):
		l.append(l[-1] * 10 % mod)
	for i in range(1, n):
		ans.append((10 * 9 * l[n - i - 1] * 2 + 10 * 81 * l[n - i - 2] * (n - i - 1)) % mod)
	ans.append(10)
	print(*ans)
main()


MOD = 998244353
mxn = 200000
p = [1] * (mxn + 1)
for i in range(1, mxn + 1):
	p[i] = p[i - 1] * 10 % MOD
n = int(input())
for i in range(1, n):
	res = 0
	res += 2 * 10 * 9 * p[n - i - 1]
	if n - i - 2 >= 0:
		res += 10 * 9 * 9 * p[n - i - 2] * (n - i - 1)
	print(res % MOD, end=' ')
print(10)


n = int(input())
ans = [10]
c = 10
cs = 20
for i in range(n - 1):
	y = i + 2
	x = pow(10, y, 998244353)
	s = x * y % 998244353
	nans = (s - cs) % 998244353
	c = (c + nans) % 998244353
	cs = (cs + nans + c) % 998244353
	ans.append(nans)
print(' '.join(map(str, ans[::-1])))


mod = 998244353
n = int(input())
for i in range(n - 1):
	print(pow(10, n - i - 2, mod) * (180 + (n - i - 2) * 81) % mod)
print(10)


n = int(input())
pow10 = [1]
last = 1
for i in range(1, 200010):
	last *= 10
	last %= 998244353
	pow10.append(last)
res = []
for i in range(1, n):
	res.append(int((10 * 9 * 9 * (n - 2 - i + 1) * pow10[n - i - 2] + 2 * 9 * 10 * pow10[n - i - 1]) % 998244353))
res.append(10)
print(' '.join(map(str, res)))


MOD = 998244353
power = [1] * 200005
for i in range(1, 200005):
	power[i] = power[i - 1] * 10 % MOD
n = int(input())
for i in range(1, n):
	res = 180 * power[n - i - 1]
	res += 810 * (n - i - 1) * power[n - i - 2]
	print(res % MOD, end=' ')
print(10)


n = int(input())
x = [10]
s = 10
w = 10
m = 998244353
for i in range(2, n + 1):
	e = (i * pow(10, i, m) % m - (w + s)) % m
	s += e
	w += s
	s %= m
	w %= m
	x += [e]
print(*x[::-1])


n = int(input())
mod = 998244353
ans = []
for i in range(n, 0, -1):
	if i == n:
		ans.append(10)
	elif i == n - 1:
		ans.append(180)
	else:
		now = 10 * 2 * 9 * pow(10, n - i - 1, mod)
		now += 10 * (n - i - 1) * 81 * pow(10, n - i - 2, mod)
		ans.append(now % mod)
ans.reverse()
print(*ans)


n = int(input())
mod = 998244353
arr = [10]
prefix = 10
subtract = 10
for i in range(2, n + 1):
	prefix = (prefix + subtract) % mod
	ans = i * pow(10, i, mod) % mod
	ans = (ans - prefix) % mod
	subtract = (subtract + ans) % mod
	prefix = (prefix + ans) % mod
	arr.append(ans)
arr = arr[::-1]
for i in arr:
	print(i, end=' ')


from sys import stdin
input = stdin.readline
n = int(input())
dp = [0, 10, 180]
s = 190
px = 1000
py = 100
for x in range(3, n + 1):
	dp.append((x * px - (x - 1) * py - s) % 998244353)
	s += dp[-1]
	py = px
	px = px * 10 % 998244353
for x in dp[n:0:-1]:
	print(x, end=' ')


from sys import stdin, stdout
from math import *
import itertools

def wr(text):
	stdout.write(str(text))

def wrs(text):
	stdout.write(str(text) + ' ')

def war(a):
	stdout.write(' '.join(map(str, a)) + '\n')

def wrl(text):
	stdout.write(str(text) + '\n')
cin = list(stdin)
mod = 998244353
n = int(cin[0])
p = [9] * n
for i in range(1, n):
	p[i] = p[i - 1] * 10 % mod
for i in range(1, n):
	wrs(p[n - i - 1] * (11 + (n - i) * 9) % mod)
wrs(10)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def main():
	n = int(input())
	mod = 998244353
	ans = [0] * n
	summy = 0
	cur = 0
	tt = 1
	for s in range(n - 1, -1, -1):
		tt *= 10
		tt = tt % mod
		add = ((n - s) * tt - summy) % mod
		cur += add
		summy += cur + add
		cur = cur % mod
		summy = summy % mod
		ans[s] = add
	print(*ans)
main()


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
import random
from queue import PriorityQueue
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p
from collections import defaultdict
from heapq import heappop, heappush, heapify
mod1 = 998244353
n = int(input())
final = []
for i in range(1, n):
	ans = 0
	cs1 = 2 * 9 * pow(10, n - i - 1, mod1)
	cs2 = 0
	if n - i - 2 >= 0:
		cs2 = (n - i - 1) * 81 * pow(10, n - i - 2, mod1)
	ans = ans % mod1 + 10 * ((cs1 + cs2) % mod1)
	ans %= mod1
	final.append(ans)
final.append(10)
print(*final)


import sys, math
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
t = 1
for tt in range(t):
	n = inp()
	a = []
	q = 0
	w = 0
	for i in range(n):
		q = (q + w) % 998244353
		a.append(((i + 1) * pow(10, i + 1, 998244353) - q) % 998244353)
		w = (w + a[-1]) % 998244353
		q = q + a[-1]
	a.reverse()
	print(*a)


n = int(input())
s = []
(count, temp, mod) = (0, 0, 998244353)
for i in range(1, n + 1):
	temp = (temp + count) % mod
	x = (i * pow(10, i, mod) - temp) % mod
	s.append(x)
	count = (count + x) % mod
	temp = (temp + x) % mod
for i in range(n - 1, -1, -1):
	print(s[i], end=' ')


n = int(input())
M = 998244353
pow10 = []
for i in range(n):
	if i == 0:
		pow10.append(1)
	else:
		pow10.append(pow10[i - 1] * 10 % M)
for i in range(n, 0, -1):
	if i != 1 and i != 2:
		print((9 * i * pow10[i - 1] % M - 9 * (i - 2) * pow10[i - 2] % M) % M, end=' ')
	if i == 1:
		print('10', end=' ')
	if i == 2:
		print('180', end=' ')
print()


def f(n):
	if n == 1:
		return '10'
	if n == 2:
		return '180 10'
	s = 10 + 180
	p = 90
	g = [0] * (n - 2) + [180, 10]
	m = 998244353
	for i in range(n - 3, -1, -1):
		g[i] = ((s + p) * 10 - s) % m
		s = (s + g[i]) % m
		p = p * 10 % m
	return ' '.join(map(str, g))

def main():
	n = int(input())
	print(f(n))
main()


from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')

def main():
	n = N()
	res = 0
	mod = 998244353
	res = [10]

	def cp(x):
		res = 1
		while x:
			res = res * 10 % mod
			x -= 1
		return res
	for i in range(2, n + 1):
		now = (i - 2) * (81 * pow(10, i - 2, mod)) + 2 * (9 * pow(10, i - 1, mod))
		res.append(now % mod)
	print(*res[::-1])
main()


import sys
import math
input = sys.stdin.readline
from functools import cmp_to_key

def pi():
	return int(input())

def pl():
	return int(input(), 16)

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

def ts():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
mod = 998244353
f = []

def fact(n, m):
	global f
	f = [1 for i in range(n + 1)]
	f[0] = 1
	for i in range(1, n + 1):
		f[i] = f[i - 1] * i % m

def fast_mod_exp(a, b, m):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b = b >> 1
	return res

def inverseMod(n, m):
	return fast_mod_exp(n, m - 2, m)

def ncr(n, r, m):
	if r == 0:
		return 1
	return f[n] * inverseMod(f[n - r], m) % m * inverseMod(f[r], m) % m

def main():
	E()

def xdfs(root, v, sub, parent):
	st = [root]
	while len(st) > 0:
		node = st.pop()
		for i in range(len(v[node])):
			if v[node][i] != node:
				st.append(v[node][i])

def X():
	try:
		t = pi()
		while t:
			t -= 1
			n = pi()
			v = [[] for i in range(n)]
			for i in range(n - 1):
				[x, y] = ti()
				v[x - 1].append(y - 1)
				v[y - 1].append(x - 1)
			m = pi()
			p = ti()
			e = [0 for i in range(n - 1)]
			sub = [0 for i in range(n)]
			dfs(0, v, sub, -1)
			for i in range(1, n):
				e[i - 1] = sub[i] * (n - sub[i])
			if len(p) < n - 1:
				while len(p) < n - 1:
					p.append(1)
			p = sorted(p)
			if len(p) > n - 1:
				x = 1
				for i in range(n - 2, len(p)):
					x = x * p[i]
				while len(p) > n - 2:
					p.pop()
				p.append(x)
			e = sorted(e)
			res = 0
			for i in range(n - 1):
				res = (res + p[i] * e[i]) % mod
			print(res)
	except:
		print(sys.exc_info())

def bfs(v, root):
	q = [root, None]
	l = 0
	visited = [0 for i in range(len(v))]
	dist = [0 for i in range(len(v))]
	while len(q) > 0:
		node = q.pop(0)
		if node is not None:
			visited[node] = 1
			dist[node] = l
			for i in range(len(v[node])):
				if visited[v[node][i]] == 0:
					visited[v[node][i]] = 1
					q.append(v[node][i])
		else:
			l += 1
			if len(q) != 0:
				q.append(None)
	return dist

def B():
	n = pi()
	v = [[] for i in range(n)]
	for i in range(n - 1):
		[x, y] = ti()
		v[x - 1].append(y - 1)
		v[y - 1].append(x - 1)
	leafs = []
	for i in range(n):
		if len(v[i]) == 1:
			leafs.append(i)
	mn = 1
	d = bfs(v, leafs[0])
	for i in range(1, len(leafs)):
		if d[leafs[i]] % 2 != 0:
			mn = 3
			break
	count = 0
	for i in range(n):
		f = 0
		for j in range(len(v[i])):
			if len(v[v[i][j]]) == 1:
				f = 1
				break
		if f:
			count += 1
	mx = n - 1 - len(leafs) + count
	print(mn, mx)

def E():
	n = pi()
	ans = [0 for i in range(n)]
	for i in range(1, n + 1):
		if i == n:
			ans[i - 1] = 10 % mod
			continue
		if i == n - 1:
			ans[i - 1] = 2 * 10 * 9 % mod
		else:
			res = 2 * 10 * 9 * fast_mod_exp(10, n - i - 1, mod) % mod
			res = (res + 10 * (n - i - 1) * 9 * 9 * fast_mod_exp(10, n - i - 2, mod)) % mod
			ans[i - 1] = res
	print(*ans, sep=' ')
main()


m = 998244353
p = [1] * 200005
for i in range(1, 200005):
	p[i] = p[i - 1] * 10 % m
n = int(input())
for i in range(1, n):
	ans = 2 * 10 * 9 * p[n - i - 1]
	ans += (n - 1 - i) * 10 * 9 * 9 * p[n - i - 2]
	print(ans % m, end=' ')
print(10)


n = int(input())
MOD = 998244353
for k in range(1, n):
	t = ((n - k - 1) * 81 * pow(10, n - k - 2, MOD) * 10 + 10 * 9 * pow(10, n - k - 1, MOD) * 2) % MOD
	print(t, end=' ')
print(10)


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split()]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
n = val()
arr = []
lastsum = 0
for i in range(1, n + 1, 1):
	curr = 10 * pow(10, n - i, mod) * (n - i + 1)
	arr.append(curr % mod)
help = [0]
for i in range(n - 1, -1, -1):
	arr[i] -= lastsum
	arr[i] %= mod
	help.append((help[-1] + arr[i]) % mod)
	lastsum += (help[-1] + arr[i]) % mod
print(*arr)


n = int(input())
m = 998244353
power = []
x = 1
for i in range(1, n + 1):
	power.append(x)
	x *= 10
	x %= m
for i in range(n - 1):
	ans = 180 * power[n - 2 - i] + (n - 2 - i) * 810 * power[n - 3 - i]
	ans %= m
	print(ans, end=' ')
print(10)


import os, sys
from io import BytesIO, IOBase

def main():
	mod = 998244353
	n = int(input())
	if n == 1:
		print(10)
	elif n == 2:
		print(180, 10)
	else:
		ans = []
		for i in range(1, n - 1):
			x = (n - i - 1) * 810 * pow(10, n - i - 2, mod) % mod
			x += 180 * pow(10, n - i - 1, mod) % mod
			ans.append(x % mod)
		ans.extend([180, 10])
		print(' '.join(map(str, ans)))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import sys

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]

def power(x, y, p):
	res = 1
	x = x % p
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
n = read_int()
d = [0] * n
p = 998244353
d[n - 1] = 10
if n > 1:
	d[n - 2] = 180
	for i in range(n - 3, -1, -1):
		a1 = 10 * (n - (i + 1) - 1) * 9 * 9 % p * power(10, n - i - 3, p) % p
		a2 = 2 * 10 * 9 * power(10, n - i - 2, p) % p
		d[i] = (a1 + a2) % p
print(*d)


from sys import stdin
input = stdin.readline
n = int(input())
dp = [0, 10, 180]
s = 190
for x in range(3, n + 1):
	dp.append((x * pow(10, x, 998244353) - (x - 1) * pow(10, x - 1, 998244353) - s) % 998244353)
	s += dp[-1]
for x in dp[n:0:-1]:
	print(x, end=' ')


import sys

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
INF = 10 ** 20
MOD = 998244353
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(n,) = I()
p = [0] * (n + 1)
for i in range(n + 1):
	p[i] = pow(10, i, MOD)
for i in range(n):
	i += 1
	ans = 0
	if n - i - 1 >= 0:
		ans = 10 * 9 * p[n - i - 1] * 2
		ans %= MOD
	if n - i - 2 >= 0:
		ans += 10 * 9 * 9 * p[n - i - 2] * (n - i - 2 + 1)
	if i == n:
		ans = 10
	print(ans % MOD, end=' ')


from time import time
power = [1] * 200002
for i in range(1, 200002):
	power[i] = power[i - 1] * 10 % 998244353
n = int(input())
if n == 1:
	print(10)
else:
	m = [0] * n
	m[n - 1] = 10
	shag = 2
	for i in range(n - 2, -1, -1):
		ans = 2 * 10 * (9 * power[shag - 2])
		ans %= 998244353
		ans += 10 * 9 * 9 * power[shag - 3] * (shag - 2)
		m[i] = int(ans % 998244353)
		shag += 1
	print(*m)


n = int(input())
q = 998244353
ans = [0] * n
for i in range(1, n):
	ansi = 9 * pow(10, n - i - 1, q) * 2 % q
	if n - i - 2 >= 0:
		ansi += 9 * 9 * pow(10, n - i - 2, q) % q * (n - i - 1) % q
	ans[i - 1] = int(ansi) * 10 % q
ans[-1] = 10
print(*ans)


import sys
MOD = 998244353
n = int(input())
if n == 1:
	print('10')
	sys.exit(0)
p9 = 90
p8 = 81
ls = ['10', '180']
for free in range(2, n):
	r = 10 * (p9 * 2 + p8 * (free - 1))
	p9 *= 10
	p9 %= MOD
	p8 *= 10
	p8 %= MOD
	ls.append(str(r % MOD))
ls = ls[::-1]
print(' '.join(ls))


n = int(input())
ans = [0] * n
ans[0] = 10
mi = 10
c = 0
mod = 998244353
p = 10
for i in range(2, n + 1):
	p *= 10
	p %= mod
	a = (p % mod - mi) % mod
	a *= i
	a %= mod
	a += c
	a %= mod
	ans[i - 1] = a
	mi += a
	mi %= mod
	c += a * (i - 1)
	c %= mod
print(*ans[::-1])


n = int(input())
[print(pow(10, i - 1, 998244353) * (81 * i + 99) % 998244353) for i in range(n - 1, 1, -1)]
print(str(180) + '\n' + str(10)) if n >= 2 else print(10)


n = int(input())
arr = [10]
if n > 1:
	arr.append(10 * 9 * 2)
num1 = 2 * 10 * 9
num2 = 9 * 9
for i in range(n - 2, 0, -1):
	num1 = num1 * 10 % 998244353
	num2 = num2 * 10 % 998244353
	arr.append((num1 + num2 * (n - 1 - i)) % 998244353)
arr.reverse()
for i in arr:
	print(i, end=' ')


n = int(input())
lst = []
for i in range(1, n + 1):
	a = max(n - i - 1, 0) * pow(10, max(n - i - 2, 0), 998244353) % 998244353 * 10 * 9 * 9
	a += 2 * (pow(10, max(n - i - 1, 0), 998244353) % 998244353) * 10 * 9
	a %= 998244353
	lst.append(a)
lst[-1] = 10
print(*lst)


n = int(input())
q = [1 for i in range(n)]
for i in range(1, n):
	q[i] = q[i - 1] * 10 % 998244353
for i in range(n - 1):
	print((180 + (n - i - 2) * 81) * q[n - i - 2] % 998244353, end=' ')
print(10)


n = int(input())
p = 998244353
odp = [0] * (n + 1)
pote = [1] * 250000
for i in range(1, 250000):
	pote[i] = pote[i - 1] * 10 % p
for i in range(1, n + 1):
	if i == n:
		odp[i] = 10
	else:
		brzeg = 2 * pote[n - i - 1] * 10 * 9
		ile = n - i - 1
		srodek_poj = 10 * 9 * 9 * pote[n - i - 2]
		odp[i] = brzeg + ile * srodek_poj
		odp[i] = odp[i] % p
print(*odp[1:])


import sys
from array import array
from typing import List, Tuple, TypeVar, Generic, Sequence, Union

def input():
	return sys.stdin.buffer.readline().decode('utf-8')

def main():
	n = int(input())
	if n == 1:
		print(10)
		exit()
	elif n == 2:
		print(180, 10)
		exit()
	mod = 998244353
	ans = array('i', [0]) * n
	(ans[-1], ans[-2]) = (10, 180)
	for (i, m) in zip(range(n - 3, -1, -1), range(n - 2, 0, -1)):
		ans[i] = (10 * 9 * 9 * pow(10, n - (m + 2), mod) * (n - (m + 2) + 1) + 10 * 9 * pow(10, n - (m + 1), mod) * 2) % mod
	print(*ans)
main()


import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda : readline().rstrip()
ni = lambda : int(readline().rstrip())
nm = lambda : map(int, readline().split())
nl = lambda : list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')

def solve():
	n = ni()
	mod = 998244353
	l = list()
	res = 0
	inc = 0
	t = 1
	for i in range(n):
		res += inc
		t = t * 10 % mod
		c = t * (i + 1) % mod
		a = (c - res) % mod
		l.append(a)
		res = (res + a) % mod
		inc = (inc + a) % mod
	print(*l[::-1])
solve()


n = int(input())
MOD = 998244353
a = [0 for i in range(n)]
a[0] = 10
pow10 = 1
for k in range(1, n):
	x = 2 * (9 * (10 * pow10))
	x += (k - 1) * (9 * 9 * pow10)
	a[k] = x % MOD
	pow10 = pow10 * 10 % MOD
print(*a[::-1])


length = int(input())
for i1 in range(1, length, 1):
	temp = pow(10, length - i1 - 1, 998244353)
	temp *= 180 + (length - i1 - 1) * 81
	print(temp % 998244353)
print(10)


import sys
input = sys.stdin.readline
p = 998244353
pri = p
fac = [1 for i in range(2 * 10 ** 5 + 1)]
for i in range(2, len(fac)):
	fac[i] = fac[i - 1] * (i % pri) % pri

def modi(x):
	return pow(x, p - 2, p) % p

def ncr(n, r):
	x = fac[n] * (modi(fac[r]) % p * (modi(fac[n - r]) % p)) % p % p
	return x
n = int(input())
if n == 1:
	print(10)
	exit(0)
if n == 2:
	print(180, 10)
	exit(0)
ans = []
for i in range(1, n + 1):
	allow = n - i + 1
	if allow == 1:
		ans.append(10)
		continue
	if allow == 2:
		ans.append(180)
		continue
	m1 = 0
	m1 = 10 * 9 * 9 * (allow - 2) * pow(10, n - i - 2, pri)
	m1 %= pri
	m1 += 2 * 10 * 9 * pow(10, n - i - 1, pri)
	m1 %= pri
	ans.append(m1)
print(*ans)


n = int(input())
ans = [10, 180]
if n <= 2:
	print(*ans[:n][::-1])
else:
	for i in range(3, n + 1):
		k = pow(10, i - 2, 998244353) * (180 + (i - 2) * 81)
		ans.append(k % 998244353)
	print(*ans[::-1])


from collections import defaultdict
import math
from functools import reduce
from heapq import heapify, heappush, heappop
mod = 998244353

def mul_mod(a, b):
	return a % mod * (b % mod) % mod

def add_mod(a, b):
	return (a % mod + b % mod) % mod
for _ in range(1):
	n = int(input())
	ans = [10]
	for i in range(2, n + 1):
		temp = mul_mod(pow(10, i - 1, mod), 9)
		temp = mul_mod(temp, 2)
		temp2 = pow(10, i - 2, mod)
		temp2 = mul_mod(temp2, 81)
		temp2 = mul_mod(temp2, i - 2)
		ans.append(add_mod(temp2, temp))
	print(*ans[::-1])


n = int(input())
MOD = 998244353
p = [1] * 200002
for i in range(1, 200002):
	p[i] = p[i - 1] * 10 % MOD
su = [0] + [10] + [180] + [0] * n
sum = 190
for i in range(3, n + 1):
	su[i] = (p[i] * i - 2 * sum - p[i - 2] * (i - 2)) % MOD
	sum += su[i] % MOD
for i in range(n, 0, -1):
	print(su[i], end=' ')


MOD = 998244353
n = int(input())
if n == 1:
	print(10)
	exit(0)
ans = [10] * n
cache = [1] * n
cache[0] = 9
for i in range(1, n):
	cache[i] = cache[i - 1] * 10 % MOD
arr = [20] * n
for i in range(1, n):
	arr[i] = arr[i - 1] + 9
for i in range(1, n):
	ans[i] = arr[i - 1] * cache[i - 1] % MOD
print(*ans[::-1])


def pow(a, b, m):
	res = 1
	while b:
		if b & 1:
			res *= a
			res %= m
		a *= a
		a %= m
		b >>= 1
	return res % m
n = int(input())
m = 998244353
for i in range(1, n + 1):
	if i == n:
		print(10)
		break
	val = 9 * (9 * (n - i) + 11)
	val %= m
	val *= pow(10, n - i - 1, m)
	val %= m
	print(val, end=' ')


n = int(input())
dp = [0] * (n + 1)
mod = 998244353
dp[n] = 10
for i in range(n - 1, 0, -1):
	dp[i] = (n - i + 1) * pow(10, n - i + 1, mod) % mod
psum = [0] * (n + 2)
value = [0] * (n + 1)
subs = [0] * (n + 1)
value[n] = dp[n]
psum[n] = dp[n]
for i in range(n - 1, 0, -1):
	subs[i] = (subs[i + 1] + psum[i + 2] + 2 * value[i + 1]) % mod
	value[i] = (dp[i] - subs[i]) % mod
	psum[i] = (psum[i + 1] + value[i]) % mod
print(*value[1:])


MOD = 998244353
p = [1] * 200005
for i in range(1, 200005):
	p[i] = p[i - 1] * 10 % MOD
n = int(input())
for i in range(1, n):
	res = 2 * 10 * 9 * p[n - i - 1]
	res += (n - 1 - i) * 10 * 9 * 9 * p[n - i - 2]
	print(res % MOD, end=' ')
print(10)


import math
import sys
read = sys.stdin.readline
n = int(read())
mod = 998244353
ret = []
for i in range(1, n):
	ways = 0
	if i + 2 <= n:
		ways += (n - (i + 2) + 1) * 10 * 9 * 9 * pow(10, n - (i + 2), mod)
	ways += 10 * 9 * pow(10, n - (i + 1), mod) * 2
	ways %= mod
	ret.append(ways)
ret.append(10)
print(' '.join(map(str, ret)))


def modInverse(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x
n = int(input())
mod = 998244353
out = []
fac = [1]
big = [1]
for i in range(1, n + 10):
	fac.append(fac[-1] * i % mod)
	big.append(10 * big[-1] % mod)
for i in range(1, n + 1):
	if i == n:
		out.append('10')
	elif i == n - 1:
		out.append('180')
	else:
		num = n - i
		blah = 2 * (big[num] - big[num - 1])
		blah %= mod
		blah += (n - i - 1) * (big[num] - 2 * big[num - 1] + big[num - 2])
		blah %= mod
		blah *= 10
		blah %= mod
		out.append(str(blah))
print(' '.join(out))


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
from collections import defaultdict
from itertools import permutations
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
mod = 998244353
n = int(input())
for i in range(n - 1):
	sol = pow(10, n - i - 2, mod)
	sol *= 180 + (n - i - 2) * 81
	sol %= mod
	print(sol)
print(10)


N = int(input())
mod = 998244353
Ans = []
nums = pow(10, N, mod)
nums_inv = pow(nums, mod - 2, mod)
inv10 = pow(10, mod - 2, mod)
for d in range(1, N):
	ans = 0
	ans += pow(inv10, d, mod) * 9 * nums * 2 % mod
	ans += (N - d - 1) * pow(inv10, d + 1, mod) * 81 * nums % mod
	Ans.append(ans % mod)
Ans.append(10)
print(' '.join(map(str, Ans)))


from sys import stdin
input = stdin.readline
mod = 998244353
n = int(input())
for i in range(1, n):
	print(pow(10, n - i - 1, mod) * (180 + (n - i - 1) * 81) % mod, end=' ')
print(10)


mod = 998244353
p = [1] * 200002
for i in range(1, 200002):
	p[i] = p[i - 1] * 10 % mod
n = int(input())
for i in range(1, n):
	res = 2 * 10 * 9 * p[n - i - 1] % mod
	res = (res + (n - i + 1 - 2) * 10 * 9 * 9 * p[n - i - 2]) % mod
	print(res, end=' ')
print(10)


M = 998244353
n = int(input())
l = [10, 180]
pow10 = 1
for i in range(n - 2):
	pow10 = pow10 * 10 % M
	l.append((10 * l[-1] + 81 * pow10) % M)
l = list(map(str, l))
l.reverse()
if n == 1:
	print('10')
else:
	print(' '.join(l))


n = int(input())
for i in range(n - 1):
	block = pow(10, n - i - 2, 998244353)
	block *= 180 + 81 * (n - i - 2)
	print(block % 998244353, end=' ')
print(10)


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
mod = 998244353
t = 0
t1 = 0
ans = []
n = int(input())
for i in range(1, n + 1):
	t = (t + t1) % mod
	temp = (pow(10, i, mod) * i % mod - t % mod + mod) % mod
	t1 = (t1 + temp) % mod
	t = (t + temp) % mod
	ans.append(temp)
ans.reverse()
print(*ans)


n = int(input())
p = 998244353
ans = [0] * n
dp = 10
stp = 10
mn = 1
ans[n - 1] = 10
for i in range(n - 2, -1, -1):
	ans[i] = (mn + 1) * (stp * 10) % p - dp - stp * mn % p
	dp += ans[i]
	dp %= p
	stp *= 10
	stp %= p
	mn += 1
print(*[i % p for i in ans])


mod = 998244353
n = int(input())
ans = [-1] * n
ans[-1] = 10
for i in range(n - 2, -1, -1):
	ans[i] = (11 + 9 * (n - i - 1)) * (9 * pow(10, n - i - 2, mod) % mod) % mod
print(*ans)


import sys
import math
input = sys.stdin.readline
t = 1
mod = 998244353

def power_mod(y, p):
	x = 10
	res = 1
	x = x % p
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
for _ in range(t):
	n = int(input())
	for i in range(1, n + 1):
		ans = 0
		pos = n - (i - 1)
		if pos == 1:
			ans += 10
		else:
			m1 = power_mod(pos - 1, mod)
			m2 = power_mod(pos - 2, mod)
			ans = (ans % mod + 18 * m1 % mod + (pos - 2) * 81 * m2 % mod) % mod
		print(ans, end=' ')


import sys
input = sys.stdin.readline
n = int(input())
ans = ''
exp10s = {}
val = 1
for f in range(n + 1):
	exp10s[f] = val
	val = 10 * val % 998244353
for i in range(1, n + 1):
	if i == n:
		val = 10
	elif i == n - 1:
		val = 180
	else:
		val = exp10s[n - i - 1] * (180 + (n - i - 1) * 81) % 998244353
	print(val, end=' ')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
sum1 = 10
currnum = 0
ans = [10]
mod = 998244353
n = int(input())
for i in range(1, n):
	currnum = (9 * i + 10) * pow(10, i, mod) - sum1
	sum1 += currnum
	ans.append(currnum % mod)
print(' '.join((str(x) for x in ans[::-1])))


n = int(input())
mod = 998244353
output = []
for i in range(1, n + 1):
	if i == n:
		output.append(10)
	elif i == n - 1:
		output.append(180)
	else:
		a1 = 2 * 9 * 10 * pow(10, n - i - 1, mod)
		a2 = (n - i - 1) * 10 * 9 * 9 * pow(10, n - i - 2, mod)
		output.append((a1 + a2) % mod)
print(*output)


n = int(input())
for i in range(n - 1):
	x = pow(10, n - i - 2, 998244353)
	x *= 180 + (n - i - 2) * 81
	x %= 998244353
	print(round(x))
print(10)


n = int(input())
res = []
mod = 998244353
for w in range(1, n + 1):
	ans = 10
	if n - w >= 2:
		ans = ans * (2 * 9 * pow(10, n - w - 1, mod) + (n - w - 1) * 9 * 9 * pow(10, n - w - 2, mod)) % mod
	elif n - w == 1:
		ans = ans * (2 * 9) % mod
	res.append(ans)
for e in res:
	print(e, end=' ')
print()


n = int(input())
if n == 1:
	print(10)
elif n == 2:
	print(180, 10)
else:
	mo = 998244353
	d = [10, 180]
	s = 190
	pp = 200
	for i in range(n - 2):
		zz = (i + 3) * pow(10, i + 3, mo) % mo
		d.append((zz - pp - s + mo) % mo)
		pp = zz
		s += d[-1]
		s %= mo
	print(*d[::-1])


mod = 998244353
n = int(input())
res = [0] * n
res[0] = 1 * 10
if n >= 2:
	res[1] = 18 * 10
for i in range(2, n):
	res[i] = 10 * ((i - 1) * (pow(10, i, mod) - 2 * pow(10, i - 1, mod) + pow(10, i - 2, mod)) + (2 * pow(10, i, mod) - 2 * pow(10, i - 1, mod))) % mod
res.reverse()
print(*res)


n = int(input())
m = 998244353
for i in range(1, n):
	ans = 2 * 10 * 9 * pow(10, n - i - 1, m) % m
	if i < n - 1:
		ans += (n - i - 1) * 81 * 10 * pow(10, n - i - 2, m) % m
	print(ans % m, end=' ')
print(10)


from sys import stdin
from bisect import bisect_left as bl
from bisect import bisect_right as br

def input():
	return stdin.readline()[:-1]

def intput():
	return int(input())

def sinput():
	return input().split()

def intsput():
	return map(int, sinput())

class RangedList:

	def __init__(self, start, stop, val=0):
		self.shift = 0 - start
		self.start = start
		self.stop = stop
		self.list = [val] * (stop - start)

	def __setitem__(self, key, value):
		self.list[key + self.shift] = value

	def __getitem__(self, key):
		return self.list[key + self.shift]

	def __repr__(self):
		return str(self.list)

	def __iter__(self):
		return iter(self.list)

def dprint(*args, **kwargs):
	if debugging:
		print(*args, **kwargs)
mod = 998244353
debugging = 1
n = intput()
answers = []
valuesum = 0
anssum = 0
for i in range(1, n + 1):
	new_val = i % mod * pow(10, i, mod) - valuesum % mod
	new_val %= mod
	answers.append(new_val)
	anssum += new_val % mod
	anssum %= mod
	valuesum += (new_val + anssum) % mod
	valuesum %= mod
print(*answers[::-1])


import sys
input = sys.stdin.readline
n = int(input())
MOD = 998244353
if n == 1:
	print(10)
	exit()
a = [0] * n
a[0] = 1
a[1] = 18
for i in range(2, n):
	a[i] = (81 * i + 99) * pow(10, i - 2, MOD)
	a[i] %= MOD
a = a[::-1]
for i in range(n):
	a[i] *= 10
	a[i] %= MOD
print(*a)


mod = 998244353
n = int(input())
pow10 = [1]
for i in range(n):
	pow10.append(10 * pow10[-1] % mod)
ans = []
for i in range(1, n + 1):
	tmp = 0
	if i == n:
		tmp = 10
	else:
		tmp += 2 * 10 * 9 * pow10[n - i - 1]
		if n - i - 1 > 0:
			tmp += (n - i - 1) * 10 * 9 * 9 * pow10[n - i - 1 - 1]
		tmp %= mod
	ans.append(tmp)
print(*ans)


from sys import stdout
print = stdout.write
M = 998244353
n = int(input())
cc = [0] * n
for i in range(n):
	(count, u) = (0, i + 1)
	if u == n:
		count += 10
	else:
		count += 2 * 10 * 9 * pow(10, n - u - 1, M)
		if n - u - 2 >= 0:
			count += (n - 2 - u + 1) * 10 * 9 * 9 * pow(10, n - u - 2, M)
	cc[i] = count % M
print(' '.join((str(u) for u in cc)))


MOD = 998244353
n = int(input())
a = [0]
b = [10]
sumb = 10
for i in range(n - 1):
	a.append((b[-1] * 9 + a[-1] * 10) % MOD)
	b.append(sumb * 9 % MOD)
	sumb = (sumb + b[-1]) % MOD
c = [(a[i] + b[i]) % MOD for i in range(n)]
print(*c[::-1])


n = int(input())
x = [10]
sm = 10
wsm = 10
mod = 998244353
for i in range(2, n + 1):
	nex = (i * pow(10, i, mod) % mod - (wsm + sm)) % mod
	sm += nex
	wsm += sm
	sm %= mod
	wsm %= mod
	x += [nex]
print(*x[::-1])


def main():
	n = int(input())
	for i in range(1, n - 1):
		r1 = 18 * pow(10, n - i, 998244353) % 998244353
		r2 = 81 * (n - i - 1) * pow(10, n - i - 1, 998244353) % 998244353
		r = (r1 + r2) % 998244353
		print(r, end=' ')
	if n >= 2:
		print(180, end=' ')
	print(10)
main()


n = int(input())
ans = []
MOD = 998244353
for i in range(1, n):
	t = 2 * 10 * 9 * pow(10, n - i - 1, MOD) + 9 * 9 * pow(10, n - i - 1, MOD) * (n - i - 1)
	ans.append(t % MOD)
ans.append(10)
print(*ans)


def read_int():
	return int(input().strip())

def read_ints():
	return list(map(int, input().strip().split(' ')))

def brute_solve():
	from collections import Counter
	from itertools import groupby
	n = 6
	counter = Counter()
	for i in range(10 ** n):
		for (k, vs) in groupby(f'{i:06}'):
			vs = list(vs)
			counter[len(vs)] += 1
	print(counter)

def solve():
	n = read_int()
	total = [0] * (n + 1)
	power_of_ten = 1
	mod = 998244353
	for k in range(n, 0, -1):
		if k == n:
			total[k] = 10
		elif k == n - 1:
			total[k] = 180
		else:
			power_of_ten = power_of_ten * 10 % mod
			total[k] = (99 + 81 * (n - k)) * power_of_ten % mod
	return ' '.join((str(t) for t in total[1:]))
print(solve())


import sys
import math
from collections import defaultdict, Counter
m = 998244353
n = int(input())
dp = [0] * (n + 1)
prev = 0
prev1 = 0
p1 = 1
for i in range(n, 0, -1):
	dp[i] = (p1 * pow(10, p1, m) % m - prev + m) % m
	prev = (prev + prev1 + 2 * dp[i]) % m
	prev1 = (prev1 + dp[i]) % m
	p1 += 1
print(*dp[1:])


n = int(input())
m = 998244353
a = []
a.append(1)
for i in range(1, 200001):
	a.append(10 * a[i - 1] % m)
for i in range(1, n):
	x = int(2 * 9 * a[n - i - 1] * 10) + (n - i - 1) * 81 * a[n - i - 2] * 10
	print(x % m, end=' ')
print(10)


import sys

def main():
	m = 998244353
	n = int(sys.stdin.read())
	v = [0 for _ in range(n)]
	k10 = 10
	v[0] = 10
	total = 10
	one = 10
	for i in range(1, n):
		total = (total + one) % m
		k10 = k10 * 10 % m
		v[i] = ((k10 * (i + 1) - total) % m + m) % m
		total += v[i]
		one = (one + v[i]) % m
	for i in reversed(v):
		print(i, end=' ')
main()


MOD = 998244353
pow10 = [1] * (2 * 10 ** 5 + 1)
for i in range(1, 2 * 10 ** 5 + 1):
	pow10[i] = pow10[i - 1] * 10
	pow10[i] %= MOD
n = int(input())
for i in range(1, n):
	print((2 * pow10[n - i - 1] * 9 + max(0, n - i - 1) * pow10[max(0, n - i - 2)] * 81) * 10 % MOD, end=' ')
print(10)


n = int(input())
if n == 1:
	print('10')
else:
	res = ['10']
	a = 11
	b = 9 / 10
	for i in range(n - 1, 0, -1):
		a += 9
		b = b * 10 % 998244353
		res.append(str(int(a * b % 998244353)))
	print(' '.join(res[::-1]))


M = 998244353
N = 200010
ten = [1] * N
for i in range(1, N):
	ten[i] = ten[i - 1] * 10 % M
n = int(input())
for i in range(1, n):
	ans = 10 * 9 * 2 * ten[n - i - 1]
	if i < n - 1:
		ans += (n - 1 - i) * 10 * 9 * 9 * ten[n - i - 2]
	print(ans % M, end=' ')
print(10)


def cout(x):
	print(x, end=' ')
	return
from sys import stdin, stdout
n = int(input())
mod = 998244353
(t, a) = (10, 10)
(v, pot) = ([10], 10)
for i in range(2, n + 1):
	t += a
	t %= mod
	pot *= 10
	pot %= mod
	x = (i * pot - t) % mod
	a += x
	a %= mod
	t += x
	t %= mod
	v.append(x % mod)
v.reverse()
for i in range(len(v)):
	cout(v[i])


n = int(input())
m = 998244353
p = [1] * 200005
for i in range(1, 200005):
	p[i] = p[i - 1] * 10 % m
for i in range(1, n):
	temp = 180 * p[n - i - 1]
	temp += (n - i - 1) * 810 * p[n - i - 2]
	print(temp % m, end=' ')
print(10)


import sys
input = sys.stdin.readline
mod = 998244353
n = int(input())
ans = [10]
dp1 = [10]
dp2 = [10]
for i in range(2, n + 1):
	s = i * pow(10, i, mod)
	ans.append((s - dp1[i - 2] - dp2[i - 2]) % mod)
	dp1.append((dp1[i - 2] + ans[i - 1]) % mod)
	dp2.append((dp2[i - 2] + dp1[i - 1]) % mod)
print(*ans[::-1])


n = int(input())
step = [1] * n
for i in range(1, n):
	step[i] = step[i - 1] * 10 % 998244353
for i in range(n):
	if n - i == 1:
		print(10, end=' ')
	elif n - i == 2:
		print(180, end=' ')
	else:
		print((18 * step[n - i - 1] + 81 * step[n - i - 2] * (n - i - 2)) % 998244353, end=' ')


N = int(input())
P = 998244353
ANS = []
for i in range(1, N):
	a = 0
	if N - i >= 2:
		a += (N - i - 1) * 81 * pow(10, N - i - 1, P)
	if N - i >= 1:
		a += 2 * 9 * pow(10, N - i, P)
	ANS.append(a % P)
ANS.append(10)
print(*ANS)


def solve(k, i):
	middles = max(k - i - 1, 0)
	ends = 2 if k != i else 0
	base = 100 * (ends + middles) - (ends * 10 + middles * 19)
	return (base, k - i - 1)
n = int(input())
ans = []
for i in range(1, n + 1):
	if n == i:
		ans.append(10)
		continue
	(base, exp) = solve(n, i)
	q = pow(10, exp, 998244353)
	q *= base
	q %= 998244353
	ans.append(q)
print(*ans)


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

def inputnums():
	return map(int, input().split())

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

def inputstring():
	return [x for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
MOD = 998244353
p = [1] * 200005
for i in range(1, 200005):
	p[i] = p[i - 1] * 10 % MOD
n = inputnum()
for i in range(1, n):
	res = 2 * 10 * 9 * p[n - i - 1]
	res += (n - 1 - i) * 10 * 9 * 9 * p[n - i - 2]
	print(res % MOD, end=' ')
print(10)


n = int(input())
a = [10]
c = 0
k = 10
md = 998244353
for i in range(2, n + 1):
	a.append((i * pow(10, i, md) % md - 2 * k - c) % md)
	c = (c + k) % md
	k = (k + a[-1]) % md
print(*a[::-1])


mod = 998244353
n = int(input())
pow10 = [1] * (n + 1)
for i in range(n):
	pow10[i + 1] = pow10[i] * 10 % mod
for len in range(1, n):
	ans = 18 * pow10[n - len] % mod
	ans = (ans + (n - len - 1) * 81 * pow10[n - len - 1]) % mod
	print(ans, end=' ')
print(10)


from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from collections import defaultdict as dd, deque

def data():
	return sys.stdin.readline().strip()

def mdata():
	return map(int, data().split())
mod = 998244353
n = int(data())
t = 1
l = [10]
for i in range(n - 2, -1, -1):
	ans = (n - 2 - i) * t * 81 % mod
	t = t * 10 % mod
	ans += 2 * t * 9
	l.append(ans % mod)
for i in range(n - 1, -1, -1):
	print(l[i], end=' ')
print()


m = 998244353
n = int(input())
a = [0] * n
ans = [0] * n
i = n
qp = 0
s = 0
while i >= 1:
	p = n - i + 1
	q = p * pow(10, p, m)
	ans[p - 1] = q - qp - s
	qp = q
	s += ans[p - 1]
	ans[p - 1] = ans[p - 1] % m
	i -= 1
print(*ans[::-1])


def solve():
	n = int(input())
	MOD = 998244353
	pow = [1 for _ in range(n + 1)]
	for i in range(1, n + 1, 1):
		pow[i] = pow[i - 1] * 10 % MOD
	for i in range(1, n, 1):
		add_one = pow[n - i - 1] * (81 * (n - i - 1) % MOD) % MOD
		add_two = 18 * pow[n - i] % MOD
		result = (add_one + add_two) % MOD
		print(result, end=' ')
	print(10)
solve()


n = int(input())
arr = [0]
sm = 0
smarr = 0
ten = 1
MOD = 998244353
for i in range(1, n + 1):
	ten = ten * 10 % MOD
	all = i * ten % MOD
	sm = (sm + smarr) % MOD
	x = (all - sm + MOD) % MOD
	arr.append(x)
	smarr = (smarr + x) % MOD
	sm = (sm + x) % MOD
arr.reverse()
arr.pop()
print(*arr)


mod = 998244353
n = int(input())
for i in range(1, n):
	res = 2 * 10 * 9 * pow(10, n - i - 1, mod)
	res += (n - 1 - i) * 10 * 9 * 9 * pow(10, n - i - 2, mod)
	print(res % mod, end=' ')
print(10)


mod = 998244353
MAX = int(100000.0 + 5)
fact = [1] * MAX
for i in range(2, MAX):
	fact[i] = i % mod * (fact[i - 1] % mod) % mod
n = int(input())
for i in range(1, n):
	res = 0
	if n - (i + 2) >= 0:
		res = 810 * (n - i - 1) * pow(10, n - i - 2, mod) % mod
	res += 180 * pow(10, n - i - 1, mod) % mod
	print(res % mod, end=' ')
print(10)


M = 998244353
n = int(input())
ans = []
s = 0
s_m = 0
now = 1
for i in range(1, n + 1):
	now = now * 10 % M
	s = (s + s_m) % M
	el = (i * now - s) % M
	ans.append(el)
	s = (s + el) % M
	s_m = (s_m + el) % M
print(' '.join(map(str, ans[::-1])))


import sys
input = sys.stdin.readline
inf = 10000000000.0
mod = int(1000000000.0 + 7)
t = 1
for _ in range(t):
	n = int(input())
	modulo = 998244353
	p = [1] * (n + 1)
	for i in range(1, n):
		p[i] = p[i - 1] * 10 % modulo
	for i in range(1, n):
		res = 2 * 10 * 9 * p[n - i - 1]
		res += 10 * 9 * 9 * p[n - i - 2] * (n - 1 - i)
		print(res % modulo, end=' ')
	print(10)


n = int(input())
mod = 998244353
pow = [0, 10]
pre = [0, 10]
for i in range(n - 1):
	pre += [(pre[-1] + pow[-1] * 10) % mod]
	pow += [pow[-1] * 10 % mod]
ans = [10]
preans = [10]
for i in range(2, n + 1):
	x = pow[i] * i - preans[-1] - ans[-1] - (pow[i - 1] * (i - 1) - ans[-1])
	if x < 0:
		x += 998244353
	ans += [x % mod]
	preans += [(preans[-1] + ans[-1]) % mod]
ans.reverse()
print(*ans)


import sys
import bisect as bi
import math
from collections import defaultdict as dd
from types import GeneratorType
input = sys.stdin.readline
MOD = 998244353

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input().strip()

def inin():
	return int(input())

def msb(n):
	n |= n >> 1
	n |= n >> 2
	n |= n >> 4
	n |= n >> 8
	n |= n >> 16
	n |= n >> 32
	n |= n >> 64
	return n - (n >> 1)
n = inin()
out = []
for i in range(1, n + 1):
	if i == n:
		out.append(10)
	else:
		nex = 2 * 9 * pow(10, n - i - 1, MOD) * 10
		if i < n - 1:
			nex += (n - 1 - i) * 9 * 9 * pow(10, n - i - 2, MOD) * 10
		out.append(nex % MOD)
print(*out)

def msb(n):
	n |= n >> 1
	n |= n >> 2
	n |= n >> 4
	n |= n >> 8
	n |= n >> 16
	n |= n >> 32
	n |= n >> 64
	return n - (n >> 1)

def pref(a, n, f):
	pre = [0] * n
	if f == 0:
		pre[0] = a[0]
		for i in range(1, n):
			pre[i] = a[i] + pre[i - 1]
	else:
		pre[-1] = a[-1]
		for i in range(n - 2, -1, -1):
			pre[i] = pre[i + 1] + a[i]
	return pre

def kadane(A):
	maxSoFar = maxEndingHere = start = end = beg = 0
	for i in range(len(A)):
		maxEndingHere = maxEndingHere + A[i]
		if maxEndingHere < 0:
			maxEndingHere = 0
			beg = i + 1
		if maxSoFar < maxEndingHere:
			maxSoFar = maxEndingHere
			start = beg
			end = i
	return (maxSoFar, start, end)

def modFact(n, p):
	if n < 0:
		return 0
	if n >= p:
		return 0
	result = 1
	for i in range(1, n + 1):
		result = result * i % p
	return result

def ncr(n, r, p):
	if n < r or n < 0:
		return 0
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc


n = int(input())
li = [0] * n
li[n - 1] = 10
mod = 998244353
tenMult = 1
for i in range(n - 2, -1, -1):
	li[i] = (2 * (tenMult * 10) * 9 + tenMult * 81 * (n - 2 - i)) % mod
	tenMult *= 10
	tenMult %= mod
print(*li)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter
from itertools import combinations
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192
from sys import stderr

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def fsep():
	return map(float, inp().split())

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def pow(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def gcd(a, b):
	if a == b:
		return a
	while b > 0:
		(a, b) = (b, a % b)
	return a

def prefix_sum(ar):
	return list(accumulate(ar))

def suffix_sum(ar):
	return list(accumulate(ar[::-1]))[::-1]

def N():
	return int(inp())
from collections import defaultdict
sys.setrecursionlimit(300000)

def numberOfSetBits(i):
	i = i - (i >> 1 & 1431655765)
	i = (i & 858993459) + (i >> 2 & 858993459)
	return ((i + (i >> 4) & 252645135) * 16843009 & 4294967295) >> 24

def solve():
	n = N()
	mod = 998244353
	for i in range(1, n):
		a = 2 * 9 * pow(10, n - i, mod) % mod
		b = 0
		if n - i - 2 >= 0:
			b = (n - i - 1) * 9 * 10 * 9 * pow(10, n - i - 2, mod)
		print((a + b) % mod, end=' ')
	print(10)
solve()


import sys
input = sys.stdin.readline
mod = 998244353
N = int(input())
A = [10, 180]
a = 180
t = 81
for _ in range(N - 2):
	t = t * 10 % mod
	a = (10 * a + t) % mod
	A.append(a)
if N == 1:
	A = [10]
print(*A[::-1])


from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby
import sys, bisect, string, math, time, functools, random

def Golf():
	(*a,) = map(int, open(0))

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

def S_():
	return input()

def IS():
	return input().split()

def LS():
	return [i for i in input().split()]

def LI():
	return [int(i) for i in input().split()]

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def GI(V, E, Directed=False, index=0):
	org_inp = []
	g = [[] for i in range(n)]
	for i in range(E):
		inp = LI()
		org_inp.append(inp)
		if index == 0:
			inp[0] -= 1
			inp[1] -= 1
		if len(inp) == 2:
			(a, b) = inp
			g[a].append(b)
			if not Directed:
				g[b].append(a)
		elif len(inp) == 3:
			(a, b, c) = inp
			aa = (inp[0], inp[2])
			bb = (inp[1], inp[2])
			g[a].append(bb)
			if not Directed:
				g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, boundary=1, search=[], replacement_of_found='.', mp_def={'#': 1, '.': 0}):
	mp = [boundary] * (w + 2)
	found = {}
	for i in range(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def bit_combination(k, n=2):
	return [[tb // n ** bt % n for bt in range(k)] for tb in range(n ** k)]

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)

def show2d(g, h, w):
	for i in range(h):
		show(g[i * w:i * w + w])
YN = ['YES', 'NO']
Yn = ['Yes', 'No']
mo = 10 ** 9 + 7
inf = float('inf')
l_alp = string.ascii_lowercase
input = lambda : sys.stdin.readline().rstrip()

def ran_input():
	n = random.randint(4, 16)
	(rmin, rmax) = (1, 10)
	a = [random.randint(rmin, rmax) for _ in range(n)]
	return (n, a)
show_flg = False
show_flg = True
mo = 998244353
n = I()
a = [10]
tot = 10
for i in range(2, n + 1):
	y = i * pow(10, i, mo) - (i - 1) * pow(10, i - 1, mo)
	x = y - tot
	tot += x
	tot %= mo
	a += [x % mo]
print(*a[::-1])


from sys import stdin, stdout
from math import gcd, sqrt, factorial, pi, inf
from collections import deque, defaultdict
from bisect import bisect, bisect_left
from time import time
from itertools import permutations as per
from heapq import heapify, heappush, heappushpop
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\r\n')
L = lambda : list(R())
P = lambda x: stdout.write(str(x) + '\n')
lcm = lambda x, y: x * y // gcd(x, y)
nCr = lambda x, y: f[x] * inv(f[y] * f[x - y] % N) % N
inv = lambda x: pow(x, N - 2, N)
sm = lambda x: (x ** 2 + x) // 2
N = 10 ** 9 + 7
mod = 998244353
n = I()
a = [0]
p = 1
x = 0
y = 0
for i in range(1, n + 1):
	x += y
	x %= mod
	p = p * 10 % mod
	a += ((p * i - x) % mod,)
	x += a[-1]
	x %= mod
	y += a[-1]
	y %= mod
print(*a[1:][::-1])


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict as dd, deque as dq
import math, string

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 998244353
ten_pow = [1]
curr = 1
for n in range(2 * 10 ** 5):
	curr *= 10
	curr %= MOD
	ten_pow.append(curr)

def solve():
	N = getInt()
	ans = []
	for L in range(1, N + 1):
		if L == N:
			ans.append(10)
			break
		if L == N - 1:
			ans.append(180)
			continue
		tmp = 18 * ten_pow[N - L]
		tmp += (9 * ten_pow[N - L - 1] + 8 * (ten_pow[N - L] - ten_pow[N - L - 1])) * (N - L - 1)
		tmp %= MOD
		ans.append(tmp)
	print(*ans)
	return
solve()


def pow_h(base, degree, module=998244353):
	degree = bin(degree)[2:]
	r = 1
	for i in range(len(degree) - 1, -1, -1):
		r = r * base ** int(degree[i]) % module
		base = base ** 2 % module
	return r
n = int(input())
for i in range(n, 1, -1):
	print(pow_h(10, i - 2) * 9 * (20 + 9 * (i - 2)) % 998244353, end=' ')
print(10)


def main():
	import sys
	input = sys.stdin.readline
	N = int(input())
	mod = 998244353
	ten = [0] * (N + 1)
	for i in range(1, N + 1):
		ten[i] = pow(10, i, mod)
	ans = [0] * (N + 1)
	S = 0
	for i in range(1, N + 1):
		a = (ten[i] * i % mod - (ten[i - 1] * (i - 1) % mod + S) % mod) % mod
		ans[i] = a
		S = (S + a) % mod
	ans.reverse()
	print(*ans[:-1])
main()


mod = 998244353
n = int(input())
prev = [0] * (n + 3)
val = [0] * (n + 2)
s = [0] * (n + 2)
for i in range(n, 0, -1):
	s[i] = (s[i + 1] + prev[i + 2] + 2 * val[i + 1]) % mod
	val[i] = ((n - i + 1) * pow(10, n - i + 1, mod) - s[i]) % mod
	prev[i] = (prev[i + 1] + val[i]) % mod
for i in range(1, n + 1):
	print(val[i], end=' ')


printn = lambda x: print(x, end='')
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
ins = lambda : input().strip()
DBG = True
BIG = 10 ** 18
R = 998244353

def ddprint(x):
	if DBG:
		print(x)
n = inn()
pw = [1] * (n + 1)
for i in range(1, n + 1):
	pw[i] = pw[i - 1] * 10 % R
pad = ''
for i in range(1, n - 1):
	x = 10 * (9 * 9 * (n - i - 1) * pw[n - i - 2] + 9 * 2 * pw[n - i - 1]) % R
	printn(pad + str(x))
	pad = ' '
if n >= 2:
	printn(pad + '180')
	pad = ' '
printn(pad + '10')
print('')


n = int(input())
dp = [0] * (n + 10)
s = [0] * (n + 10)
chert = [0] * (n + 10)
mod = 998244353
pow10 = [1] * (n + 10)
for i in range(1, n + 1):
	pow10[i] = pow10[i - 1] * 10 % mod
for i in range(1, n + 1):
	p = i * pow10[i] % mod
	dp[i] = (p - (s[i - 1] + dp[i - 1] + chert[i - 1])) % mod
	s[i] = (dp[i] + s[i - 1]) % mod
	chert[i] = chert[i - 1] + s[i - 1] + dp[i - 1]
for i in range(n, 0, -1):
	print(dp[i], end=' ')
print()


n = int(input())
a = [10, 180]
v = 1
for i in range(2, n):
	c = a[-1] * 10 + 81 * pow(10, v, 998244353)
	v += 1
	a.append(c % 998244353)
an = a[:n]
print(*an[::-1])


n = int(input())
ans = [10, 180]
if n <= 2:
	print(' '.join([str(i) for i in ans[:n][::-1]]))
	exit()
m = 1
MOD = 998244353
for i in range(n - 2):
	m *= 10
	m %= MOD
	nxt = ans[-1] * 10 + 81 * m
	nxt %= MOD
	ans.append(nxt)
print(' '.join([str(i) for i in ans[::-1]]))


def powmod(n, k, mod):
	if k == 0:
		return 1
	res = powmod(n, k >> 1, mod)
	res *= res
	res %= mod
	if k % 2:
		res *= n
		res %= mod
	return res

def solve(n):
	MOD = 998244353
	cnt = [0] * (n - 1)
	for block in range(1, n):
		k = n - block + 1
		d = n - block
		m = 0
		m += powmod(10, d, MOD) * 18 % MOD
		m += (k - 2) * powmod(10, d - 1, MOD) * 81 % MOD
		m %= MOD
		cnt[block - 1] += m
		cnt[block - 1] %= MOD
	cnt += [10]
	return cnt
n = int(input())
print(' '.join(map(str, solve(n))))


n = int(input())
out = []
MOD = 998244353
for i in range(1, n + 1):
	if i == n:
		out.append(10)
	else:
		nex = 2 * 9 * pow(10, n - i - 1, MOD) * 10
		if i < n - 1:
			nex += (n - 1 - i) * 9 * 9 * pow(10, n - i - 2, MOD) * 10
		out.append(nex % MOD)
print(' '.join(map(str, out)))


n = int(input())
if n == 1:
	print('10')
	exit()
m = 998244353
ans = [10, 180]
(k, s) = (100, 190)
a = [20, 390]
for i in range(3, n + 1):
	k = k % m * 10 % m
	p = i * k % m
	ans.append((p - a[i - 2]) % m)
	a.append((a[-1] % m + (s + ans[-1] + ans[-1]) % m) % m)
	s += ans[-1]
ans.reverse()
print(*ans)


from collections import defaultdict

def brute(n):
	cnt = defaultdict(int)
	for i in range(10 ** n):
		s = str(i)
		while len(s) < n:
			s = '0' + s
		idx = 0
		while idx < n:
			j = idx
			while j < n and s[j] == s[idx]:
				j += 1
			cnt[j - idx] += 1
			idx = j
	return cnt

def solve(n):
	mod = 998244353
	for i in range(1, n - 1):
		print((180 * pow(10, n - i - 1, mod) + 10 * 81 * pow(10, n - i - 2, mod) * (n - i - 1)) % mod)
	if n >= 2:
		print(180)
	print(10)
n = int(input())
solve(n)


n = int(input())
mod = 998244353
base = 81
ans = 180
will = ['10', '180']
for i in range(2, n):
	ans = (ans + base) % mod * 10 % mod
	base = base * 10 % mod
	will.append(str(ans))
if n == 1:
	print('10')
else:
	print(' '.join(will[::-1]))


MOD = 998244353
p10 = [1] * 200001
for i in range(1, 200001):
	p10[i] = p10[i - 1] * 10 % MOD
x = int(input())
for i in range(1, x):
	ret = 2 * 10 * 9 * p10[x - i - 1]
	ret += (x - i - 1) * 10 * 9 * 9 * p10[x - i - 2]
	print(ret % MOD, end=' ')
print(10)


n = int(input())
big = 998244353
l = [0 for i in range(n)]
l[0] = 10
if n > 1:
	l[1] = 180
val1 = 10
for i in range(1, n - 1):
	val2 = i * val1 % big
	val1 = val1 * 10 % big
	val = 18 * val1 + 81 * val2
	val = val % big
	l[i + 1] = val
for i in range(n):
	print(l[n - i - 1])


n = int(input())
las = 9
su = 10
a = []
a.append(10)
mod = 998244353
for i in range(1, n):
	las = las * 10 % mod
	a.append((su * 9 + las) % mod)
	su = (su + a[i]) % mod
for i in range(n - 1, 0, -1):
	print(a[i], end=' ')
print(a[0])


n = int(input())
mod = 998244353
pow10 = [1]
for i in range(1, n + 1):
	pow10.append(pow10[i - 1] * 10 % mod)
if n == 1:
	print(10)
elif n == 2:
	print(180, 10)
else:
	for i in range(1, n):
		curr = 0
		diffs = n - (i - 1) - 2
		curr += 9 * pow10[n - i - 1] * 10 * 2
		curr += 81 * pow10[n - i - 2] * 10 * diffs
		print(curr % mod, end=' ')
	print(10)


import sys
input = sys.stdin.readline
MOD = 998244353
n = int(input())
ans = []
for i in range(n, 0, -1):
	if i == n:
		ans.append(10)
		continue
	pattern = n - i + 1
	ret = 10 * 9 * pow(10, n - i - 1, MOD) * 2
	pattern -= 2
	ret += pattern * 9 * 9 * pow(10, n - i - 1, MOD)
	ans.append(ret % MOD)
ans.reverse()
print(*ans)


n = int(input())
counts = [0] * n
temp1 = 810
temp2 = 1800
counts[-1] = 10
if n >= 2:
	counts[-2] = 180
for i in range(n - 2, 0, -1):
	counts[i - 1] = (n - i - 1) * temp1 + temp2
	counts[i - 1] %= 998244353
	temp1 *= 10
	temp2 *= 10
	temp1 %= 998244353
	temp2 %= 998244353
for item in counts:
	print(item, end=' ')


M = 998244353

def solve(n):
	if n == 1:
		return '10'
	if n == 2:
		return '180 10'
	if n == 3:
		return '2610 180 10'
	ans = [10, 180, 2610]
	for _ in range(n - 3):
		ans.append((20 * ans[-1] - 100 * ans[-2]) % M)
	ans = ans[::-1]
	return ' '.join(map(str, ans[:n]))

def main():
	n = int(input())
	print(solve(n))
main()


mod = 998244353
pow10 = [1] * int(2 * 100000.0 + 1)
n = int(input())
for i in range(1, n):
	pow10[i] = pow10[i - 1] * 10 % mod
for len in range(1, n):
	ans = 2 * 10 * 9 * pow10[n - len - 1] % mod
	ans += (n - len - 1) * 81 * 10 * pow10[n - len - 2] % mod
	ans %= mod
	print(ans, end=' ')
print(10)


ans = []
mod = 998244353
n = int(input())
for l in range(1, n):
	ans.append(str(pow(10, n - l - 1, mod) * 9 * (11 + 9 * (n - l)) % mod))
ans.append('10')
print(' '.join(ans))


n = int(input())
if n == 1:
	print(10)
elif n == 2:
	print(180, 10)
elif n == 3:
	print(2610, 180, 10)
elif n == 4:
	print(34200, 2610, 180, 10)
else:
	M = 998244353
	B = [0] * (n + 1)
	B[1] %= M
	B[n] = 10
	B[n - 1] = 180
	B[n - 2] = 2610
	for i in range(1, n - 2):
		B[i] = 10 * (18 * pow(10, n - i - 1, M) % M + (n - i - 1) * 81 * pow(10, n - i - 2, M)) % M
		B[i] %= M
	for i in range(len(B)):
		B[i] %= M
	print(*B[1:])


N = int(input())
arr = [10]
C = 0
K = 10
mod = 998244353
for i in range(2, N + 1):
	arr.append((i * pow(10, i, mod) % mod - 2 * K - C) % mod)
	C = (C + K) % mod
	K = (K + arr[-1]) % mod
print(*arr[::-1])


n = int(input())
mod = 998244353

def modmul(arr):
	ret = 1
	for v in arr:
		ret = ret * v % mod
	return ret
pows = [1]
for i in range(n):
	pows.append(pows[-1] * 10 % mod)
for i in range(1, n + 1):
	ans = 10
	c = n - i + 1
	if c == 1:
		print(ans)
	elif c == 2:
		borders = modmul([2, 10, 9, pows[n - i - 1]])
		print(borders, end=' ')
	else:
		borders = modmul([2, 10, 9, pows[n - i - 1]])
		c -= 2
		other = modmul([c, 10, 9, 9, pows[n - i - 2]])
		print((borders + other) % mod, end=' ')


MOD = 998244353
n = int(input())
ans = 0
res = []
for i in range(n):
	if i == n - 1:
		res.append(10)
	else:
		ans += pow(10, n - i - 2, MOD)
		ans *= 180 + 81 * (n - i - 2)
		ans %= MOD
		res.append(ans)
		ans = 0
print(*res)


def power(x, y, p):
	res = 1
	x = x % p
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
n = int(input())
j = 1
a = []
while j <= n - 2:
	k = power(10, n - 1 - j, 998244353)
	a.append(((n - j - 1) * 81 + 180) * k % 998244353)
	j += 1
if n >= 2:
	a.append(180)
if n >= 1:
	a.append(10)
print(*a)


def force(n):
	res = [0] * n
	for i in range(int(10 ** n)):
		s = str(i).zfill(n)
		it = iter(s)
		last = next(it)
		c = 1
		for j in it:
			if j == last:
				c += 1
			else:
				res[c - 1] += 1
				c = 1
			last = j
		res[c - 1] += 1
	return res

def optim_n2(max_n, base=10, mod=998244353):
	f = [0] * (max_n + 1)
	for n in range(1, max_n + 1):
		s = pow(base, n, mod) * n
		for i in range(1, n):
			s -= f[i] * (n - i + 1)
			s = s % mod
		f[n] = s
	return f[:-len(f):-1]

def optim(n, base=10, mod=998244353):
	res = []
	for k in range(1, n - 1):
		i = n - k - 1
		s = pow(10, i, mod)
		s = s * (180 + i * 81) % mod
		res.append(s)
	if n > 1:
		res.append(180)
	res.append(10)
	return res

def solve():
	n = int(input())
	res = optim(n)
	print(' '.join(map(str, res)))

def main():
	solve()
main()


p = 998244353
n = int(input())
a = [0]
const = 0
cumsum = 0
for i in range(1, n + 1):
	total = i * pow(10, i, p) % p
	new = (total - const) % p
	a.append(new)
	const += cumsum + 2 * new
	const %= p
	cumsum += new
	cumsum %= p
a.reverse()
a.pop()
print(*a)


n = int(input())
lens = []
total = 0
rotal = 0
for x in range(1, n + 1):
	thing = x * pow(10, x, 998244353) - rotal
	total += thing
	rotal += total + thing
	lens.append(str(thing % 998244353))
lens.reverse()
print(' '.join(lens))


def power(x, y, p):
	res = 1
	x = x % p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
n = int(input())
for k in range(1, n + 1):
	if k != n:
		x = pow(10, n - k - 1, 998244353)
		print(int(2 * 9 * 10 * x + (n - k - 1) * 81 * x) % 998244353, end=' ')
	else:
		print(10)


MOD = 998244353
n = int(input())
ans = []
tenth = [1]
for i in range(1, n + 10):
	tenth.append(tenth[-1] * 10 % MOD)
for i in range(1, n):
	print((18 * tenth[n - i] % MOD + (n - i - 1) * 81 * tenth[n - i - 1] % MOD) % MOD)
print(10)


n = int(input().strip())
mod_base = 998244353
pow10 = 10
ans = []
cum = 0
cumcum = 0
for i in range(1, n + 1):
	ans.append((i * pow10 - cumcum) % mod_base)
	cum = (cum + ans[-1]) % mod_base
	cumcum = (cumcum + ans[-1] + cum) % mod_base
	pow10 = pow10 * 10 % mod_base
print(' '.join(map(str, reversed(ans))))


MOD = 998244353
T = 1
for t in range(1, T + 1):
	n = int(input())
	for i in range(1, n + 1):
		if n - i == 0:
			print(10, end=' ')
		elif n - i == 1:
			print(10 * (2 * 9 * pow(10, n - i - 1, MOD)) % MOD, end=' ')
		else:
			print(10 * (2 * 9 * pow(10, n - i - 1, MOD) + 9 * 9 * pow(10, n - i - 2, MOD) * (n - i - 1)) % MOD, end=' ')
	print('')


import sys
inp = sys.stdin.readline

def input():
	return inp().strip()
out = []

def iin():
	return int(input())

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

def main():
	n = iin()
	md = 998244353
	ans = [0]
	sm1 = 0
	sm2 = 0
	for i in range(1, n + 1):
		sm2 = (sm2 + ans[-1]) % md
		sm = (sm2 * 2 + sm1) % md
		ans.append((i * pow(10, i, md) % md - sm) % md)
		sm1 = (sm1 + sm2) % md
	print(*ans[-1:0:-1])
main()


n = int(input())
steps = []
st = 1
mod = 998244353
for i in range(n + 1):
	steps.append(st)
	st *= 10
	st %= mod
for i in range(1, n + 1):
	mid = (n - i - 1) * 10 * 9 * 9 * steps[n - i - 2]
	if n - i < 2:
		mid = 0
	mid %= mod
	borders = 2 * 10 * 9 * steps[n - i - 1]
	if n == i:
		borders = 10
	borders %= mod
	print((borders + mid) % mod)


def solve(n):
	MOD = 998244353
	pow10 = [1]
	for i in range(n + 3):
		pow10 += [pow10[-1] * 10 % MOD]
	cnt = [0] * (n - 1)
	for block in range(1, n):
		k = n - block + 1
		d = n - block
		m = 0
		m += pow10[d] * 18 % MOD
		m += (k - 2) * pow10[d - 1] * 81 % MOD
		m %= MOD
		cnt[block - 1] += m
		cnt[block - 1] %= MOD
	cnt += [10]
	return cnt
n = int(input())
print(' '.join(map(str, solve(n))))


def solve():
	n = int(input())
	numbers = [10]
	power = 1
	mod = 998244353
	for i in range(2, n + 1):
		numbers.append(9 * (9 * i + 2) * power % mod)
		power = power * 10 % mod
	s = reversed(list(map(str, numbers)))
	print(' '.join(s))

def modpow(base, exponent, mod):
	res = 1
	power = base
	while exponent > 0:
		if exponent & 1:
			res = res * power % mod
		power = power * power % mod
		exponent //= 2
	return res
solve()


import math
MOD = 998244353
n = int(input())
for k in range(n):
	sum = 0
	if n - k > 2:
		sum += 10 * 9 * 9 * pow(10, n - 2 - k - 1, MOD) * (n - k - 2)
	sum %= MOD
	if n - k > 1:
		sum += 2 * 10 * 9 * pow(10, n - 2 - k, MOD)
	else:
		sum = 10
	print(sum % MOD, end=' ')
print()


l = []
for i in range(10):
	l.append(0)

def f(n, x):
	n = str(n)
	n = '0' * (x - len(n)) + n + '#'
	prev = 0
	for i in range(1, len(n)):
		now = i
		if n[i] != n[i - 1]:
			l[now - prev] += 1
			prev = now
ans = []
ans.append(10)
ans.append(180)
diff = 81
for i in range(200006):
	ans.append((ans[len(ans) - 1] + diff) * 10)
	ans[len(ans) - 1] %= 998244353
	diff = diff * 10
	diff = diff % 998244353
n = int(input())
ans2 = ans[0:n][::-1]
for i in range(n):
	print(ans2[i], end=' ')


n = int(input())
ans = []
ans.append(10)
su = 10
imp = 10
less = 10
for i in range(2, n + 1):
	less += su
	less %= 998244353
	imp *= 10
	imp = imp % 998244353
	see = i * imp % 998244353
	see = see - less
	if see < 0:
		see += 998244353
	ans.append(see)
	su += see
	less += see
ans.reverse()
for i in ans:
	print(i, end=' ')


MOD = 998244353
n = int(input())
if n == 1:
	print(10)
	exit()
a = [1] * (n - 1)
a[0] = 20
for i in range(1, n - 1):
	a[i] *= a[i - 1] * 10 + 9 * pow(10, i, MOD)
	a[i] %= MOD
a.reverse()
for i in range(n - 1):
	a[i] *= 9
	a[i] %= MOD
a.append(10)
print(*a)


n = int(input())
p = 998244353
for i in range(1, n + 1):
	if n - i - 2 > -1:
		c = 81 * (n - i - 1) * pow(10, n - i - 2, p)
	else:
		c = 0
	if n - i - 1 > -1:
		d = 18 * pow(10, n - i - 1, p)
	else:
		d = 1
	a = 10 * (d + c)
	print(a % p, end=' ')


MOD = 998244353

def powr(n, N):
	temp = 1
	while N > 0:
		if N % 2 != 0:
			temp = temp * n % MOD
		n = n * n % MOD
		N = N // 2
	return temp % MOD
n = int(input())
L = [0, 1, 18]
tot = 1
for i in range(2, n):
	t1 = powr(10, i - 2) % MOD
	t2 = 81 * i % MOD
	t2 = (t2 + 99) % MOD
	t2 = t2 * t1 % MOD
	tot = (tot + t2) % MOD
	L.append(t2 % MOD)
ans = []
for i in range(1, n + 1):
	t3 = L[i] * 10 % MOD
	ans.append(t3)
ans = ans[::-1]
print(*ans)


n = int(input())
modulo = 998244353
ten_powers = [1]
for i in range(1, n):
	ten_powers.append(ten_powers[-1] * 10 % modulo)
for k in range(1, n + 1):
	if n == k:
		ways = 10
	elif n == k + 1:
		ways = 180
	else:
		ways = ten_powers[n - k - 1] * (180 + 9 ** 2 * (n - k - 1)) % modulo
	print(ways, end=' ', flush=False)
print()


import sys
input = sys.stdin.readline
mod = 998244353
n = int(input())
f = [0 for i in range(n + 1)]
d = []
for i in range(n):
	if i == 0:
		d.append(10)
	elif i == 1:
		d.append(180)
	else:
		c = (180 + 81 * (i - 1)) * pow(10, i - 1, mod) % mod
		d.append(c)
print(*d[::-1])


mod = 998244353

def mul(a, b):
	return a % mod * (b % mod) % mod

def div(a, b):
	return mul(a, power(b, mod - 2))

def div2(a, b):
	return mul(a, modinv(b))
pwt = [1]
for i in range(2 * 10 ** 5):
	pwt.append(pwt[-1] * 10 % mod)
N = int(input())
R = []
for i in range(1, N + 1):
	if N - i >= 2:
		x = mul(10 * 9 * 9 * pwt[N - i - 2] % mod, N - i - 1)
		y = mul(10 * 9 * pwt[N - i - 1] % mod, 2)
	elif N - i == 1:
		x = 0
		y = mul(10 * 9 * pwt[N - i - 1] % mod, 2)
	else:
		x = 0
		y = 10
	R.append((x + y) % mod)
print(*R)


n = int(input())
ans = []
mod = 998244353
for i in range(1, n + 1):
	if i == 1:
		ans.append(10)
	elif i == 2:
		ans.append(10 * 9 * 2)
	else:
		a1 = 10 * 9 * pow(10, i - 2, mod) * 2 % mod
		a2 = 9 * 10 * 9 * pow(10, i - 3, mod) * (i - 2) % mod
		ans.append((a1 + a2) % mod)
print(*ans[::-1])


MOD = 998244353

def go():
	n = int(input())
	ans = []
	for i in range(1, n):
		res = 2 * 9 * pow(10, n - i, MOD)
		res += (n - i - 1) * 9 * 9 * pow(10, n - i - 1, MOD)
		ans.append(str(res % MOD))
	ans.append('10')
	print(' '.join(ans))
t = 1
for _ in range(t):
	go()


import sys
q = 998244353

def exp(b, e):
	ans = 1
	while e > 0:
		if e % 2 == 0:
			e = e // 2
			b = b * b % q
		else:
			ans = ans * b
			e = e - 1
	return ans
n = int(sys.stdin.readline().strip())
x = []
for i in range(1, n):
	ans = 0
	ans = ans + 9 * exp(10, n - i - 1)
	ans = ans + 9 * exp(10, n - i - 1)
	ans = ans + (n - i - 1) * 81 * exp(10, n - i - 2)
	ans = ans * 10
	ans = ans % q
	x.append(str(ans))
x.append(str(10))
print(' '.join(x))


mod = 998244353
n = int(input())
if n == 1:
	print('10')
else:
	lis = []
	lis.append(10)
	prev = 10
	al = 0
	k = 0
	for i in range(2, n + 1):
		aa = 2 * prev + al + k
		tep = i * pow(10, i, mod) - aa
		al = aa % 998244353
		k += prev % 998244353
		prev = tep % 998244353
		lis.append(tep % 998244353)
	for i in lis[::-1]:
		print(i)


n = int(input())
blocks = []
list_of_powers = [1]
prev = 1
for _ in range(n):
	prev = prev * 10 % 998244353
	list_of_powers.append(prev)
for i in range(n):
	if i == 0:
		blocks.append(10)
	else:
		blocks.append(18 * list_of_powers[i] + (i - 1) * 81 * list_of_powers[i - 1])
for i in range(n):
	blocks[i] = str(blocks[i] % 998244353)
blocks = blocks[::-1]
print(' '.join(blocks))


from bisect import bisect_left, bisect_right
from sys import stdin, stdout, setrecursionlimit
from collections import Counter
input = lambda : stdin.readline().strip()
print = stdout.write
m = 998244353
n = int(input())
for i in range(1, n - 1):
	print(str((2 * 10 * 9 * pow(10, n - i - 1, m) % m + (n - i - 1) * 10 * 9 * 9 * pow(10, n - i - 2, m) % m) % m) + ' ')
if n > 1:
	print(str(2 * 10 * 9) + ' ')
print('10\n')


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def get_str():
	return input().decode().strip()

def rint():
	return map(int, input().split())

def oint():
	return int(input())
n = oint()
ans2 = [10, 180, 2610, 34200, 423000]
for i in range(5, n):
	ans = ans2[i - 1] * 20 - 100 * ans2[i - 2]
	ans %= 998244353
	ans2.append(ans)
print(*ans2[:n][::-1])


n = int(input())
ten = [1]
mod = 998244353
for i in range(1, n + 1):
	ten.append(ten[-1] * 10 % mod)
ans = []
for i in range(1, n + 1):
	if n == i:
		ans.append(10)
	elif n == i + 1:
		ans.append(180 * ten[n - i - 1] % mod)
	else:
		SUM = 180 * ten[n - i - 1] + 810 * (n - i - 1) * ten[n - i - 2]
		ans.append(SUM % mod)
for (i, x) in enumerate(ans):
	ans[i] = str(x)
print(' '.join(ans))


n = int(input())
r = 998244353
store = 1
lst = [10]
for k in range(n - 1, 0, -1):
	s = ((n - k - 1) * 81 * store + 18 * store * 10) % r
	store = store * 10 % r
	lst.append(s)
print(' '.join([str(i) for i in reversed(lst)]))


def main():
	md = 998244353
	n = int(input())
	for w in range(1, n):
		ans = ((n - w - 1) * 81 + 180) * pow(10, n - w - 1, md) % md
		print(ans)
	print(10)
main()


n = int(input())
ini = [0]
mod = 998244353
(pref, last) = (0, 0)
for i in range(1, n + 1):
	curr = (i * pow(10, i, mod) % mod - last - pref) % mod
	pref = (pref + curr) % mod
	last = (pref + last) % mod
	ini.append(curr)
print(*ini[::-1][:-1])


n = int(input())
a = []
m = 1
s = 10
mod = 998244353
for i in range(n):
	f = s * m % mod
	a.append(f)
	s += 9
	m = m * 10 % mod
x = 0
for i in range(len(a)):
	a[i] = mod + a[i] - x
	while a[i] < 0:
		a[i] += mod
	a[i] %= mod
	x = x + a[i]
	x %= mod
a.reverse()
for i in a:
	print(i, end=' ')
print('')


def main():
	MOD = 998244353
	n = int(input())
	ans = []
	for i in range(1, n):
		ends = 2 * 9 * pow(10, n - i, MOD) % MOD
		middle = 9 * 9 * pow(10, n - 1 - i, MOD) % MOD
		middle *= (n - 1 - i) % MOD
		middle %= MOD
		ans.append((ends + middle) % MOD)
	ans.append(10)
	oneLineArrayPrint(ans)
	return
import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')

def oneLineArrayPrint(arr):
	print(' '.join([str(x) for x in arr]))

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))

def multiLineArrayOfArraysPrint(arr):
	print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))

def readIntArr():
	return [int(x) for x in input().split()]
inf = float('inf')
MOD = 10 ** 9 + 7
for _ in range(1):
	main()


mod = 998244353
p = [1] * 200005
for i in range(1, 200005):
	p[i] = p[i - 1] * 10 % mod
n = int(input())
f = []
f.append(10)
f.append(180)
for i in range(2, n):
	f.append((f[i - 1] * 10 % mod + p[i - 1] * 9 * 9 % mod) % mod)
for i in range(n - 1, -1, -1):
	print(f[i], end=' ')


n = int(input())
a = []
p = 998244353
a.append(10)
d = 10
s = 10
for i in range(n - 1):
	a.append((d * 10 * (i + 2) - d * (i + 1) - s) % p)
	d = d * 10 % p
	s = (s + a[-1]) % p
q = ''
for i in range(len(a) - 1):
	q += str(a[-1 - i])
	q += ' '
print(q + '10')


from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
n = int(inp())
for i in range(1, n):
	k = 180 * pow(10, n - 1 - i, mod2)
	if n - i - 2 >= 0:
		k += 810 * pow(10, n - i - 2, mod2) * (n - i - 1) % mod2
	print(k % mod2, end=' ')
print(10)


mod = 998244353
power = [1] * 200005
for i in range(1, 200005):
	power[i] = 10 * power[i - 1] % mod
n = int(input())
for i in range(1, n):
	res = 2 * 10 * 9 * power[n - i - 1]
	res += (n - i - 1) * 10 * 9 * 9 * power[n - i - 2]
	print(res % mod, end=' ')
print(10)


N = int(input())
if N == 1:
	print('10')
elif N == 2:
	print('180 10')
else:
	ans = [0] * (N + 1)
	powt = [0] * (N + 1)
	powt[0] = 1
	for i in range(1, N + 1):
		powt[i] = powt[i - 1] * 10 % 998244353
	ans[0] = 10
	ans[1] = 180
	for i in range(2, N + 1):
		ans[i] = (ans[i - 1] + 81 * powt[i - 2]) * 10 % 998244353
	for i in range(1, N + 1):
		print(ans[-i - 1], end=' ')
	print('')


n = int(input())
ans = []
for i in range(1, n):
	x = n - i + 1
	ans.append((10 * max(x - 2, 0) * pow(10, max(0, n - i - 2), 998244353) * 81 + 2 * 10 * pow(10, max(0, n - i - 1), 998244353) * 9) % 998244353)
ans.append(10)
print(' '.join(map(str, ans)))


mod = 998244353

def f(n):
	if n == 1:
		print(10)
		return
	for i in range(1, n - 1):
		print(((n - i - 1) * 810 * pow(10, n - i - 2, mod) % mod + 2 * 90 * pow(10, n - i - 1, mod) % mod) % mod, end=' ')
	print(180, 10)
n = int(input())
f(n)


def b(m, n):
	if m == n:
		return 10
	if m == n - 1:
		return 10 * 9 * 2
	return (10 * 9 ** 2 * (n - (m + 2) + 1) * pow(10, n - m - 2, 998244353) + 10 * 9 * 2 * pow(10, n - m - 1, 998244353)) % 998244353
n = int(input())
print(*[b(i + 1, n) for i in range(n)])


n = int(input())
mod = 998244353

def query(P):
	if P == n:
		return 10
	part1 = 10 * 9 * pow(10, n - P - 1, mod)
	if P < n - 1:
		part2 = 10 * 9 * 9 * pow(10, n - P - 2, mod)
	else:
		part2 = 0
	ans = 2 * part1 + (n - P - 1) * part2
	ans %= mod
	return ans
ans = [query(i) for i in range(1, n + 1)]
print(*ans)


import sys
MOD = 998244353
n = int(sys.stdin.readline().rstrip())
table = [None] * (n + 1)
table[0] = 1
for i in range(n):
	table[i + 1] = table[i] * 10 % MOD

def main():
	s = [None] * (n + 1)
	t = [None] * (n + 1)
	res = [None] * (n + 1)
	res[0] = s[0] = t[0] = 0
	for i in range(1, n + 1):
		res[i] = (i * table[i] % MOD - t[i - 1]) % MOD
		res[i] %= MOD
		s[i] = (s[i - 1] + res[i]) % MOD
		t[i] = (t[i - 1] + res[i] + s[i]) % MOD
	return res[1:][::-1]
ans = main()
print(*ans, sep=' ')


import io
import os
from collections import Counter, defaultdict, deque

def solve(N):
	MOD = 998244353
	ans = []
	for blockLength in range(1, N + 1):
		count = 0
		if blockLength == N:
			count += 10
		else:
			assert blockLength < N
			count += 10 * 9 * pow(10, N - blockLength - 1, MOD)
			count += 10 * 9 * pow(10, N - blockLength - 1, MOD)
			if N - blockLength - 2 >= 0:
				count += (N - blockLength - 1) * 10 * 9 * 9 * pow(10, N - blockLength - 2, MOD)
		count %= MOD
		if False:
			count2 = 0
			for padLeft in range(N):
				padRight = N - blockLength - padLeft
				if padRight < 0:
					break
				num = 10
				if padLeft:
					num *= 9 * 10 ** (padLeft - 1)
				if padRight:
					num *= 9 * 10 ** (padRight - 1)
				count2 += num
			assert count == count2
		ans.append(str(count % MOD))
	return ' '.join(ans)
for i in range(1, 10):
	solve(i)
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
(N,) = [int(x) for x in input().split()]
ans = solve(N)
print(ans)


mod = 998244353
n = int(input())
ten = [1]
for i in range(n):
	ten.append(ten[-1] * 10 % mod)
ans = [0] * n
ans[n - 1] = 10
for l in range(1, n):
	s = 2 * 10 * 9 * ten[n - l - 1]
	if n - l >= 2:
		s += (n - l - 1) * 10 * 81 * ten[n - l - 2]
	ans[l - 1] = s % mod
print(' '.join(map(str, ans)))


import sys
m = 998244353
n = int(input())
v = [0 for _ in range(n)]
k10 = 10
v[0] = 10
total = 10
one = 10
for i in range(1, n):
	total = (total + one) % m
	k10 = k10 * 10 % m
	v[i] = ((k10 * (i + 1) - total) % m + m) % m
	total += v[i]
	one = (one + v[i]) % m
for i in reversed(v):
	print(i, end=' ')


a = int(input())
anslist = []
for i in range(a):
	anslist.append(-1)
for i in range(a - 1, -1, -1):
	if i == a - 1:
		anslist[i] = 10
	elif i == a - 2:
		anslist[i] = ((a - i) * pow(10, a - (i + 1), 998244353) * 10 - anslist[i + 1] * 2) % 998244353
	else:
		anslist[i] = 10 * (18 * pow(10, a - (i + 1) - 1, 998244353) + (a - i - 2) * 81 * pow(10, a - (i + 1) - 2, 998244353)) % 998244353
for i in range(a):
	print(str(anslist[i]), end=' ')


import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
	f = iter(open('E.txt').readlines())

	def input():
		return next(f).strip()
else:
	input = lambda : sys.stdin.readline().strip()
fprint = lambda *args: print(*args, flush=True)
n = int(input())
res = [0, 10]
p = 998244353
ten = 1
for i in range(n - 1):
	res.append((res[-1] + ten * 9) * 10 % p)
	ten = ten * 10 % p
result = reversed([(res[i] - res[i - 1] + p) % p for i in range(1, n + 1)])
print(' '.join(map(str, result)))


import sys
import os
import time
import collections
from collections import Counter, deque
import itertools
import math
import timeit
import random
from io import BytesIO, IOBase
from bisect import bisect_left as bl
from bisect import bisect_right as br

def ceil(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

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

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def prr(a, sep=' '):
	print(sep.join(map(str, a)))

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def ddd():
	return collections.defaultdict(collections.defaultdict(int))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
mod = 998244353
res = []
n = ii()
for i in range(1, n - 1):
	res.append((180 * pow(10, n - i - 1, mod) + (n - i - 1) * 810 * pow(10, n - i - 2, mod)) % mod)
res.extend([180, 10])
if n == 1:
	print(10)
else:
	print(*res)


n = int(input())
answer = [10] * n
m = 998244353

def add(a, b):
	return (a + b) % m

def mul(a, b):
	return a * b % m

def binpow(a, b):
	if b == 0:
		return 1
	if b % 2 == 0:
		x = binpow(a, b // 2)
		return mul(x, x)
	else:
		return mul(binpow(a, b - 1), a)
for i in range(1, n):
	answer[i - 1] = mul(binpow(10, n - i - 1), add(180, mul(81, n - i - 1)))
print(*answer)


import os, sys, math
n = int(input().split()[0])
mod = 998244353

def mpow(a, n):
	return pow(a, n, mod)

def mmul(*vs):
	res = vs[0]
	for v in vs[1:]:
		res *= v
		res %= mod
	return res
t = []
for i in range(1, n + 1):
	res = 0
	if i == n:
		res = 10
	elif i == n - 1:
		res = mmul(2, 9, mpow(10, n - i))
	else:
		res = mmul(n - i - 1, 81, mpow(10, n - i - 1)) + mmul(2, 9, mpow(10, n - i))
	t.append(str(res % mod))
print(' '.join(t))


n = int(input())
d = [0] * n
d[0] = 10
t = 10
a = [0] * n
a[0] = 10
for i in range(1, n):
	d[i] = (a[i - 1] + t) * 9 % 998244353
	a[i] = (a[i - 1] + d[i]) % 998244353
	t = t * 10 % 998244353
d.reverse()
print(*d)


n = int(input())
a = [0 for _ in range(n)]
mod = 998244353
a[0] = 10
ctnext = 90
ctprev = 10
for i in range(1, n):
	a[i] = 10 * a[i - 1] + ctnext - ctprev
	a[i] %= mod
	ctprev = ctnext
	ctnext *= 10
	ctnext %= mod
for i in range(n - 1, -1, -1):
	print(a[i], end=' ')


n = int(input())
p = [1]
MOD = 998244353
for _ in range(n + 10):
	p.append(p[-1] * 10 % MOD)
ans = [0] * (n + 1)
for i in range(1, n + 1):
	if i == n:
		ans[i] = 10
	else:
		ans[i] = (2 * 10 * 9 * p[n - i - 1] + (n - i - 1) * 10 * 9 * 9 * p[n - i - 2]) % MOD
print(*ans[1:])


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
n = int(input())
z = 998244353
if n == 1:
	print(10)
elif n == 2:
	x = 180
	y = 10
	print(x, y)
else:
	ans = []
	for i in range(1, n):
		ans.append(20 + 9 * (n - i - 1))
	ans.append(10)
	arr = [1] * n
	arr[-2] = 9
	for i in range(n - 3, -1, -1):
		arr[i] = arr[i] * (10 * arr[i + 1])
		arr[i] %= z
	for i in range(n):
		ans[i] *= arr[i]
		ans[i] %= z
	print(' '.join((str(x) for x in ans)))


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 998244353
N = INT()
ans = [0] * (N + 1)
ans[N] = 10
for i in range(1, N):
	cnt = 0
	if N - i - 2 >= 0:
		cnt += 10 * 9 * 9 * pow(10, N - i - 2, MOD) * (N - i - 1)
	cnt += 10 * 9 * pow(10, N - i - 1, MOD) * 2
	ans[i] = cnt % MOD
print(*ans[1:])


n = int(input())
M = 998244353
b = []
for p in range(1, n + 1):
	m = n - p
	c = 2 * 9 * pow(10, m - 1, M) + (m - 1) * 9 * 9 * pow(10, m - 2, M) % M if m else 1
	b.append(c % M)
print(' '.join([str(10 * _ % M) for _ in b]))


n = int(input())
m = 998244353
for k in range(1, n + 1):
	if k == n:
		print(10, end=' ')
	elif k == n - 1:
		print(180, end=' ')
	else:
		print(9 % m * ((9 * (n - k) + 11) % m) % m * (pow(10, n - k - 1, m) % m) % m, end=' ')


MOD = 998244353
ans = [10, 180]
tmp = 10
n = int(input())
for i in range(n - 2):
	ans.append((ans[-1] * 10 % MOD + 81 * tmp % MOD) % MOD)
	tmp *= 10
	tmp %= MOD
for i in range(n - 1, -1, -1):
	print(ans[i], end=' ')


n = int(input())
m = 998244353
for i in range(n - 1):
	res = pow(10, n - i - 2, m)
	res *= 180 + (n - i - 2) * 81
	res %= m
	print(res)
print(10)


n = int(input())
l = []
if n > 0:
	l.append(10)
a = 10 * 9 * 2
b = 9 ** 2
for i in range(n - 1):
	l.append((a + b * i) % 998244353)
	a = a * 10 % 998244353
	b = b * 10 % 998244353
for i in range(n - 1, -1, -1):
	print(l[i], end=' ')


import sys
n = int(input())
k = 1
ans = [10]
s = 10
r = 10
x = 100
MOD_NUM = 998244353
while k < n:
	new = (k + 1) * x - (s + r)
	r += new
	s += r
	k += 1
	x *= 10
	r %= MOD_NUM
	s %= MOD_NUM
	x %= MOD_NUM
	while new < 0:
		new += MOD_NUM
	ans.append(new % MOD_NUM)
print(*ans[::-1])


from sys import stdin
input = lambda : stdin.readline().strip()
lin = lambda : list(map(int, input().split()))
iin = lambda : int(input())
main = lambda : map(int, input().split())
from math import ceil, sqrt, factorial, log
from collections import deque
from bisect import bisect_left

def gcd(a, b):
	(a, b) = (max(a, b), min(a, b))
	while a % b != 0:
		(a, b) = (b, a % b)
	return b
mod = 998244353

def solve():
	n = iin()
	z = []
	for i in range(1, n):
		x = 2 * 9 * pow(10, n - i - 1, mod) * 10
		if i < n - 1:
			x += (n - 1 - i) * 9 * 9 * 10 * pow(10, n - i - 2, mod)
		z.append(x % mod)
	z += [10]
	print(*z)
qwe = 1
for _ in range(qwe):
	solve()


n = int(input())
if n == 1:
	print(10)
	quit()
ans = [10]
total = 10
mod = 998244353
modm = [1]
cur = 1
for i in range(1, 2 * 10 ** 5 + 4):
	cur = cur * 10 % mod
	modm += [cur]
for i in range(2, n + 1):
	next = (i % mod * modm[i] - total % mod) % mod
	total = (total + next) % mod
	ans += [next]
b = []
for i in range(n - 1, 0, -1):
	el = (ans[i] - ans[i - 1]) % mod
	b += [el]
b += [10]
print(' '.join((str(k) for k in b)))