We have a sequence of length N consisting of non-negative integers. Consider performing the following operation on this sequence until the largest element in this sequence becomes N-1 or smaller.
 - Determine the largest element in the sequence (if there is more than one, choose one). Decrease the value of this element by N, and increase each of the other elements by 1.
It can be proved that the largest element in the sequence becomes N-1 or smaller after a finite number of operations.
You are given an integer K. Find an integer sequence a_i such that the number of times we will perform the above operation is exactly K. It can be shown that there is always such a sequence under the constraints on input and output in this problem.

-----Constraints-----
 - 0 ≤ K ≤ 50 \times 10^{16}

-----Input-----
Input is given from Standard Input in the following format:
K

-----Output-----
Print a solution in the following format:
N
a_1 a_2 ... a_N

Here, 2 ≤ N ≤ 50 and 0 ≤ a_i ≤ 10^{16} + 1000 must hold.

-----Sample Input-----
0

-----Sample Output-----
4
3 3 3 3

Difficulty: MEDIUM_HARD

Starter code:

Solutions:
k = int(input())
n = 50
if k <= n - 1:
	aas = [0] * n
	aas[0] += n * k
else:
	t = k // n
	k %= n
	aas = [n - k + t - 1] * n
	i = 0
	cnt = 0
	while cnt < k:
		aas[i] += 1 + k
		i += 1
		cnt += 1
print(n)
print(*aas)


k = int(input())
if k == 0:
	a = [1, 1]
elif k == 1:
	a = [2, 0]
elif k <= 50:
	a = [i for i in range(1, k + 1)]
else:
	a = [i for i in range(1, 51)]
	k -= 50
	d = k // 50
	for i in range(50):
		a[i] += d
	m = k % 50
	for i in range(-1, -m - 1, -1):
		a[i] += 1
print(len(a))
a = [str(i) for i in a]
print(' '.join(a))


import sys

def main():
	input = sys.stdin.readline
	K = int(input())
	N = 50
	ans = []
	m = K % N
	for i in range(N):
		t = K // N + (1 if i < m else 0)
		ans.append(N * (t + 1) - (K - t) - 1)
	print(N)
	print(*ans)

def __starting_point():
	main()
__starting_point()


k = int(input())
import numpy as np
ans = np.array([i for i in range(50)], dtype=np.int64)
a = k // 50
b = k % 50
ans += a
for i in range(b):
	ans[i] += 50
	ans[:i] -= 1
	ans[i + 1:] -= 1
print(50)
print(' '.join(map(str, ans)))


ma = lambda : map(int, input().split())
lma = lambda : list(map(int, input().split()))
tma = lambda : tuple(map(int, input().split()))
ni = lambda : int(input())
yn = lambda fl: print('Yes') if fl else print('No')
ips = lambda : input().split()
import collections
import math
import itertools
import heapq as hq
import sys
k = ni()
n = 50
(p, r) = divmod(k, n)
ans = [0] * n
for i in range(n):
	if i < n - r:
		ans[i] = i + p
	else:
		ans[i] = i + 1 + p
print(n)
print(*ans)


k = int(input())
n = 50
print(n)
nums = list(reversed(list(range(n))))
for i in range(n):
	nums[i] += k // n
for i in range(k % n):
	nums[i] += 1
t = list(map(str, nums))
print(' '.join(t))


k = int(input())
sub = k // 50 + 49
ans = [sub - k % 50] * 50
for i in range(k % 50):
	ans[i] += 51
print(50)
print(*ans)


from math import ceil
K = int(input())
x = K // 50
ans = (50 - (K - 50 * x)) * [49 - K + 51 * x] + (K - 50 * x) * [100 - K + 51 * x]
print(50)
print(*ans)


K = int(input())
N = 50
(P, Q) = (-(-K // N), -K % N)
ans = [i for i in range(P, P + N)]
for q in range(Q):
	for i in range(N):
		if i == N - 1 - q:
			ans[i] -= N
		else:
			ans[i] += 1
print(N)
print(*ans)


K = int(input())
(r, q) = divmod(K, 50)
A = [r + 49] * 50

def update():
	M = A.index(min(A))
	for i in range(50):
		if i == M:
			A[i] += 50
		else:
			A[i] -= 1
for i in range(q):
	update()
print(50)
print(*A)


K = int(input())
N = 50
S = K // N
T = K % N
L = [N - 1 + S for i in range(N)]
for i in range(T):
	L[i] += N + 1
for i in range(N):
	L[i] -= T
print(N)
L = list(map(str, L))
print(' '.join(L))


K = int(input())
print(50)
A = []
for i in range(50):
	a = K % 50
	b = K // 50
	d = i + b
	if i < a:
		d += 50 - a + 1
	else:
		d -= a
	A.append(d)
print(*A)


K = int(input())
N = 50
n = K // N
ans = [49 + n] * N
K %= N
for i in range(N):
	if i < K:
		ans[i] += N - K + 1
	else:
		ans[i] -= K
print(N)
print(*ans)


K = int(input())
summ = 49 * 50 + K
(a, b) = (summ // 50, summ % 50)
low = (summ - b * 51) // 50
high = low + 51
ans = [low] * 50
for i in range(b):
	ans[i] += 51
print(50)
print(*ans)


K = int(input())
ans = [49 + K // 50] * 50
amari = K % 50
if amari != 50:
	for i in range(amari):
		ans[i] = ans[i] + 50 - (amari - 1)
	for i in range(amari, 50):
		ans[i] = ans[i] - amari
print(50)
ansstr = [str(i) for i in ans]
print(' '.join(ansstr))


K = int(input())
n = 50
print(n)
a = [i + K // n for i in range(n)]
r = K % n
for i in range(n):
	if i < r:
		a[i] = a[i] + n - r + 1
	else:
		a[i] = a[i] - r
print(*a)


K = int(input())
(q, r) = (K // 50, K % 50)
a = [50 + q for i in range(r)] + [49 + q - r for j in range(50 - r)]
print(50)
print(' '.join(map(str, a)))


k = int(input())
n = 50
a = [i + k // n for i in range(n)]
for i in range(k % n):
	a[i] += n
	for j in range(n):
		if i != j:
			a[j] -= 1
print(n)
print(*a)


K = int(input())
if K == 1:
	print(3)
	print(1, 0, 3)
elif K == 0:
	print(4)
	print(3, 3, 3, 3)
else:
	div = -1
	if K <= 50:
		print(K)
		print(*[K for _ in range(K)])
	else:
		print(50)
		ans = [K // 50 + i for i in range(50)]
		for i in range(K % 50):
			ans[i] += 50
			for j in range(50):
				if i != j:
					ans[j] -= 1
		print(*ans)


k = int(input())
tasu = k // 50
lst = list(range(tasu, tasu + 50))
amari = k % 50
for i in range(amari):
	idx = 49 - i
	lst[idx] += 1
print(50)
print(' '.join(map(str, lst)))


k = int(input())
n = 50
(x, y) = divmod(k, n)
ans = [i + x for i in range(n)]
for i in range(y):
	i %= n
	ans[i] += n
	for j in range(n):
		if i == j:
			continue
		ans[j] -= 1
print(n)
print(*ans)


import heapq
k = int(input())
a = [49] * 50
for i in range(50):
	a[i] += k // 50
k %= 50
for i in range(k):
	for j in range(50):
		if i == j:
			a[j] += k
		else:
			a[j] -= 1
print(len(a))
print(' '.join(list(map(str, a))))


K = int(input())
ans = [i for i in range(50)]
cnt = 0
loop = K % 50
plus = K // 50
ans = list(map(lambda x: x + plus, ans))
for i in range(loop):
	cnt %= 50
	ans = list(map(lambda x: x - 1, ans))
	ans[cnt] += 51
	cnt += 1
print(50)
print(*ans)


K = int(input())
ans = list(range(50))[::-1]
(q, r) = divmod(K, 50)
for i in range(50):
	ans[i] += q
for i in range(r):
	ans[i] += 1
print(len(ans))
print(*ans)


K = int(input())
N = 50
Q = K // N
R = K % N
print(N)
for i in range(R):
	print(N - 1 + Q - R + N + 1, end=' ')
for i in range(N - R):
	print(N - 1 + Q - R, end=' ')


K = int(input())
N = 50
A = K // N + 1
B = A * N - K
a = [49 + A] * N
for i in range(B):
	a[i] -= N
	for j in range(N):
		if j == i:
			continue
		a[j] += 1
print(N)
print(' '.join(map(str, a)))


import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda : int(readline())
in_nn = lambda : list(map(int, readline().split()))
in_s = lambda : readline().rstrip().decode('utf-8')
in_nl = lambda : list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda : [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda : list(map(int, read().split()))

def main():
	K = in_n()
	N = 50
	(q, r) = divmod(K, N)
	ans = np.full(N, N + q)
	cnt = N - r
	ans[:cnt] -= N - (cnt - 1)
	ans[cnt:] += cnt
	print(N)
	print(' '.join(map(str, ans)))

def __starting_point():
	main()
__starting_point()


MAX = pow(10, 16) + 1000
K = int(input())
N = 50
kaisu = [K // N for _ in range(N)]
ans = [-1 for _ in range(N)]
nokori = K % N
for i in range(nokori):
	kaisu[i] += 1
for i in range(N):
	temp = (N + 1) * kaisu[i] + N - 1 - K
	ans[i] = temp
print(N)
print(*ans)


def solve():
	K = int(input())
	if K == 49:
		print(2)
		return [27, 24]
	print(50)
	(a, b) = (K // 50, K % 50)
	ans = [49 + a] * 50
	for i in range(50):
		if i < b:
			ans[i] += 51 - b
		else:
			ans[i] -= b
	return ans
print(*solve())


k = int(input())
ans = [0] * 50
if k < 50:
	for i in range(k):
		ans[i] = 50 - i
else:
	for i in range(50):
		ans[i] = 50 - i
	k -= 50
	for i in range(50):
		ans[i] += k // 50
	for i in range(k % 50):
		ans[i] += 1
print(50)
print(*ans)


def main():
	N = 50
	K = int(input())
	ans = [K // N + i for i in range(N)]
	for i in range(K % N):
		for j in range(N):
			ans[j] += N if i == j else -1
	print(N)
	print(' '.join(map(str, ans)))

def __starting_point():
	main()
__starting_point()


k = int(input())
ans = [49 + k // 50 - k % 50 + 51] * (k % 50) + [49 + k // 50 - k % 50] * (50 - k % 50)
print(50)
print(*ans)


def examA():
	S = SI()
	T = SI()
	N = len(S)
	ans = 'No'
	for i in range(N):
		cur = S[i:] + S[:i]
		if cur == T:
			ans = 'Yes'
	print(ans)
	return

def examB():
	(H, W) = LI()
	S = [SI() for _ in range(H)]
	flag = True
	ans = 0
	print(ans)
	return

def examC():
	(L, R) = LI()
	ans = inf
	if R - L >= 3000:
		R = L + 3000
	for l in range(L, R + 1):
		for r in range(l + 1, R + 1):
			now = l * r % 2019
			ans = min(ans, now)
	print(ans)
	return

def examD():
	T = ['dream', 'dreamer', 'erase', 'eraser']
	S = SI()
	ans = 'NO'
	t = ''
	for s in S[::-1]:
		t += s
		if t[::-1] in T:
			t = ''
	if t == '':
		ans = 'YES'
	print(ans)
	return

def examE():
	N = 50
	K = I()
	base = K // N
	A = [base + i for i in range(N)]
	rest = K % N
	for i in range(rest):
		A[-i - 1] += 1
	print(N)
	print(' '.join(map(str, A)))
	return

def examF():
	L = I()
	ans = 0
	print(ans)
	return
import sys, bisect, itertools, heapq, math, random
from copy import deepcopy
from heapq import heappop, heappush, heapify
from collections import Counter, defaultdict, deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

def LSI():
	return list(map(str, sys.stdin.readline().split()))

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

def SI():
	return sys.stdin.readline().strip()
nonlocal mod, mod2, inf, alphabet, _ep
mod = 10 ** 9 + 7
mod2 = 998244353
inf = 10 ** 18
_ep = 10 ** (-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10 ** 7)

def __starting_point():
	examE()
__starting_point()


K = int(input())
if K >= 50:
	N = 50
	wari = K // N - 1
	amari = K % N
	l = [50 + wari + 1] * amari + [50 + wari - amari] * (N - amari)
if 50 > K > 1:
	N = K
	l = [K] * K
if K == 1:
	N = 2
	l = [0, 2]
if K == 0:
	N = 2
	l = [1, 1]
print(N)
print(*l)


import sys
import math
import heapq
mod = 10 ** 9 + 7
inf = float('inf')
from math import sqrt
from collections import deque
from collections import Counter
from collections import defaultdict
from collections import OrderedDict
from math import ceil
input = lambda : sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import Decimal
from functools import lru_cache
k = int(input())
print(50)
n = 50
if k == 0:
	print(' '.join(['0'] * 50))
	return
a = k // n
b = k % n
A = [a + i for i in range(50)]
for i in range(b):
	A = [A[j] - 1 if i != j else A[j] + n for j in range(50)]
print(*A)


def resolve():
	K = int(input())
	N = 50
	ans = [49 + K // N] * N
	for i in range(K % N):
		ans[i] += 1
	for j in range(K % N, N):
		ans[j] -= K % N
	print(N)
	print(*ans)
if '__main__' == __name__:
	resolve()


N = 50
(P, Q) = divmod(int(input()), N)
R = N - Q
print(N, *[P + R - 1] * R + [P + R + N] * Q)


k = int(input())
n = 50
a = [n - 1] * n
m = k % n
for i in range(n):
	a[i] += k // n
	if i < m:
		a[i] += n - m + 1
	else:
		a[i] += -m
print(n)
print(*a)


K = int(input())
x = K // 50
print(50)
print(*(50 - (K - 50 * x)) * [49 - K + 51 * x] + (K - 50 * x) * [100 - K + 51 * x])


K = int(input())
N = 50
ans = [49] * 50
cnt_all = K // N
rem = K % N
for i in range(N):
	if i < rem:
		ans[i] += cnt_all + N - (rem - 1)
	else:
		ans[i] += cnt_all - rem
print(50)
print(*ans)


K = int(input('50\n'))
N = 50
r = (K - 1) % N + 1
a = (K - r) // N + N
print(*[a] * r + [a - r - 1] * (N - r))


k = int(input())
a = k // 50
b = 50 - k % 50
ans = [a + b - 1] * b + [a + 50] * (50 - b)
print(50)
print(*ans)


K = int(input())
k = K // 50
l = K % 50
ans = [i + k for i in range(51) if i != 50 - l]
print(50)
print(*ans)


k = int(input())
v = [i + k // 50 for i in range(50)]
for i in range(k % 50):
	for j in range(50):
		if i == j:
			v[j] += 50
			continue
		v[j] -= 1
print(50)
print(*v)


import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy
K = int(input())
if K < 10 ** 15:
	(a, b) = (K // 2 + 1, K // 2 + 1)
	if K % 2 == 1:
		a += 2
		b -= 1
	print(2)
	print(a, b)
else:
	N = 50
	A = [i for i in range(50)]
	A = list(map(lambda x: x + K // 50, A))
	r = K % 50
	for i in range(50):
		if i < r:
			A[i] += N
			A[i] -= r - 1
		else:
			A[i] -= r
	print(N)
	print(*A)


import sys
K = int(sys.stdin.readline())
N = 50
V = [49 + K // 50 for _ in range(N)]
K %= 50
for i in range(K):
	V[i] += N + 1
	for j in range(N):
		V[j] -= 1
print(N)
print(*V)


k = int(input())
n = 50
a = k // n
m = k % n
ans = list(range(a, a + n))
for i in range(m):
	ans[n - i - 1] += 1
print(50)
print(*ans)


k = int(input())
max_a = pow(10, 16) + 1000
for i in range(2, 51):
	a = [j + k // i for j in range(i)]
	for j in range(k % i):
		a[-1 - j] += 1
	if max(a) <= max_a:
		print(i)
		print(' '.join(list(map(str, a))))
		return


K = int(input())
X = 50
A = [X - 1] * X
A = [a + K // X for a in A]
for i in range(K % X):
	A[i] += 1
for i in range(X - K % X):
	A[-i - 1] -= K % X
print(X)
print(*A, sep=' ')


K = int(input())
if K <= 50:
	a = [50] * K + [0] * (50 - K)
	print(50)
	print(*a)
	return
(d, m) = divmod(K, 50)
if m == 0:
	a = [d + 49] * 50
	print(50)
	print(*a)
	return
a = [d + 50] * 50
rem = 50 - m
for i in range(m):
	a[i] += rem
for i in range(m, 50):
	a[i] -= m + 1
print(50)
print(*a)


K = int(input())
K1 = K // 50
K2 = K % 50
answer_list = []
for i in reversed(range(50 - K2)):
	answer_list.append(i)
for i in range(K2):
	answer_list.append(50 - i)
for i in range(50):
	answer_list[i] += K1
print(50)
print(*answer_list)


def main():
	K = int(input())
	if K <= 49:
		print(50)
		l = [0] * (50 - K) + [50] * K
		print(' '.join((str(i) for i in l)))
		return l
	l = [K // 50 + 50] * 50
	a = 50 - K % 50
	for i in range(a):
		l[0] -= 50
		for j in range(1, 50):
			l[j] += 1
		l.sort(reverse=True)
	print(50)
	print(' '.join((str(i) for i in l)))
	return l
l = main()


K = int(input())
k = K // 50
d = K % 50
ans = [k + i for i in range(50)]
for i in range(49, 49 - d, -1):
	ans[i] += 1
print(50)
print(*ans)


K = int(input())
N = 50
(u, v) = divmod(K, 50)
P = [u + i for i in range(N)]
for i in range(1, v + 1):
	P[-i] += 1
print(N)
print(*P)


import sys
sys.setrecursionlimit(10 ** 8)
ini = lambda : int(sys.stdin.readline())
inm = lambda : map(int, sys.stdin.readline().split())
inl = lambda : list(inm())
ins = lambda : sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print('\x1b[33m', *a, '\x1b[0m', **dict(file=sys.stderr, **kw))
K = ini()
N = 50

def solve():
	a = K // N
	h = N - 1 + a
	r = K % N
	hs = [h + N - (r - 1)] * r + [h - r] * (N - r)
	return hs
ans = solve()
print(len(ans))
print(*ans)


from sys import stdin

def main():
	readline = stdin.readline
	K = int(readline())
	N = 50
	M = K // N
	L = K % N
	A = range(N)
	A = list(map(lambda x: x + M, A))
	for i in range(L):
		A[i] += N + 1
		A = list(map(lambda x: x - 1, A))
	print(N)
	print(*A)

def __starting_point():
	main()
__starting_point()


K = int(input())
(d, m) = divmod(K, 50)
A = [d + 49 - m] * (50 - m) + [d + 100 - m] * m
print(50)
print(*A)


k = int(input())
q = k // 50
r = k % 50
print(50)
a = [0] * 50
for i in range(50):
	if i < r:
		a[i] = 100 + q - r
	else:
		a[i] = 49 + q - r
print(*a)


def main():
	k = int(input())
	n = 50
	a = [None for _ in range(n)]
	for i in range(n):
		a[i] = i + (k + i) // n
	print(n)
	print(' '.join([str(x) for x in a]))

def __starting_point():
	main()
__starting_point()


K = int(input())
N = 50
if K <= 50:
	print(N)
	ans = [50] * K + [0] * (N - K)
	print(*ans)
	return
(d, m) = divmod(K, 50)
ans = [d + 49] * N
for i in range(N):
	if i < m:
		ans[i] += N - m + 1
	else:
		ans[i] -= m
print(N)
print(*ans)


from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
import sys, bisect, math, itertools, fractions
sys.setrecursionlimit(10 ** 8)
mod = 10 ** 9 + 7
INF = float('inf')

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

def inpl():
	return list(map(int, sys.stdin.readline().split()))
k = inp()
b = (k - 1) // 50 + 50
r = k % 50
l = 50 - r
a = b - r - 1
if r == 0:
	a = b
print(50)
res = [-1] * 50
for i in range(50):
	if i < l:
		res[i] = a
	else:
		res[i] = b
print(*res)


import sys
import math
import collections
import bisect
import itertools
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
ni = lambda : int(sys.stdin.readline().rstrip())
ns = lambda : map(int, sys.stdin.readline().rstrip().split())
na = lambda : list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda : list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))

def main():
	k = ni()
	l = 50
	ans = [l - 1 for _ in range(l)]
	for i in range(l):
		ans[i] += k // l
	for i in range(l):
		tgt = k % l
		if i < tgt:
			ans[i] += l
			ans[i] -= tgt - 1
		else:
			ans[i] -= tgt
	print(l)
	print(*ans, sep=' ')

def __starting_point():
	main()
__starting_point()


k = int(input())
n = 50
i = k % 50
j = k // 50
print(50)
for _ in range(n - i):
	print(n + j - i - 1, end=' ')
for _ in range(i):
	print(2 * n + j - i, end=' ')


k = int(input())
if k == 0:
	print(2)
	print('0 0')
elif k == 1:
	print(2)
	print('2 0')
elif k <= 50:
	print(k)
	print((str(k) + ' ') * (k - 1) + str(k))
else:
	l = k // 50
	m = k % 50
	print(50)
	print((str(50 + l) + ' ') * m + (str(49 + l - m) + ' ') * (49 - m) + str(49 + l - m))


k = int(input())
n = 50
a = [49] * n
x = k // n
y = k % n
for i in range(n):
	a[i] += x
	if i < y:
		a[i] += n + 1 - y
	else:
		a[i] -= y
print(n)
print(*a)


import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	K = int(readline())
	N = 50
	(q, r) = divmod(K, N)
	A = [N - 1 + (N + 1) * q - K] * N
	for i in range(r):
		A[i] += N + 1
	print(N)
	print(' '.join(map(str, A)))
	return

def __starting_point():
	main()
__starting_point()


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7
K = int(input())
N = 50
tmp1 = N - 1 + K // N
tmp2 = K % 50
ans = [0] * N
for i in range(N - tmp2):
	ans[i] = tmp1 - tmp2
for j in range(i + 1, N):
	ans[j] = tmp1 + N - tmp2 + 1
print(N)
print(*ans, sep=' ')


k = int(input())
a = [49 + k // 50] * 50
b = k % 50
if b:
	for i in range(50):
		if i < b:
			a[i] += 50 - (b - 1)
		else:
			a[i] -= b
print(50)
print(' '.join(list(map(str, a))))


k = int(input())
if k == 0:
	print('2\n1 1')
	return
if k == 1:
	print('2\n2 0')
	return
n = min(50, k)
a = [i for i in range(n)]
c = k // n
for i in range(n):
	a[i] += c
for i in range(k % n):
	a[i] += n
	for j in range(n):
		if i != j:
			a[j] -= 1
print(n)
for i in a:
	if i in range(10 ** 16 + 1001):
		print(i, end=' ')
print()


import sys

def main():
	input = sys.stdin.readline
	K = int(input())
	N = max(2, min(50, K))
	ans = [i + K // N for i in range(N)]
	m = K % N
	for i in range(m):
		for j in range(N):
			if i == j:
				ans[j] += N
			else:
				ans[j] -= 1
	print(N)
	print(*ans)

def __starting_point():
	main()
__starting_point()


from collections import Counter, defaultdict, deque
from heapq import heappop, heappush, heapify
from bisect import bisect_left, bisect_right
import sys, math, itertools, fractions, pprint
sys.setrecursionlimit(10 ** 8)
mod = 10 ** 9 + 7
INF = float('inf')

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

def inpl():
	return list(map(int, sys.stdin.readline().split()))
k = inp()
n = 50
(x, b) = (k // 50, k % 50)
a = x + (n - 1)
print(n)
for i in range(n):
	if i < b:
		print(n + 1 - b + a)
	else:
		print(a - b)


import sys
import bisect
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7

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

def read_index():
	return [int(x) - 1 for x in input().split()]

def read_list():
	return list(read_values())

def read_lists(N):
	return [read_list() for n in range(N)]

class V:

	def __init__(self, f, v=None):
		self.f = f
		self.v = v

	def __str__(self):
		return str(self.v)

	def ud(self, n):
		if n is None:
			return
		if self.v is None:
			self.v = n
			return
		self.v = self.f(self.v, n)

def main():
	K = int(input())
	N = 50
	M = K // N
	m = K % N
	k = N - m
	A = [N + M - (N - k + 1)] * k + [N + M + k] * (N - k)
	print(N)
	print(' '.join(map(str, A)))

def __starting_point():
	main()
__starting_point()


import sys
readline = sys.stdin.readline
K = int(readline())
N = 50
A = [i for i in range(N)]
A = list(map(lambda x: x + K // N, A))
rest = K % N
for i in range(rest):
	A[i] += N
	for j in range(N):
		if i != j:
			A[j] -= 1
print(N)
print(*A)