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: interview

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)))

# print(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
div_K, rem_K = divmod(K, N)
ans = [l + div_K for l in range(N)]
for i in range(rem_K):
    idx = ans.index(min(ans))
    for i in range(N):
        if i == idx:
            ans[i] += N
        else:
            ans[i] -= 1
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
        #print(i,A)

for i in range(q):
    update()
print(50)
print(*A)

#(N-1)*N+K
#N,N,N,N,--NからN-1,N-1,,,N-1はN回
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())
n = 50

q, r = divmod(k, n)
A = [n-1]*n
for i in range(n):
    A[i] += q

for i in range(r):
    A[i] += n+1
    for j in range(n):
        A[j] -= 1

print(n)
print((*A))


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())

div, mod = divmod(k, 50)
A = [100 + div - mod] * mod + [49 + div -mod] * (50-mod)
print((50))
print((*A))


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
#print(kaisu)

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]
        #print(cur)
        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()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""
__starting_point()

k = int(input())

div = k // 50
mod = k % 50
A = [100 + div - mod] * mod + [49 + div -mod] * (50-mod)
print((50))
print((*A))


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
#すべてのkeyが用意されてる defaultdict(int)で初期化
from collections import OrderedDict
#順序を保ったdict
from math import ceil
input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import Decimal #floatの高精度ver, 渡すのはstr型で
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
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を2~50までは試せるけど、各要素の値は何にすればいいかよくわからない。
なので、全探索的な解き方は期待できない。

一つからN引いて、残りに＋１するので、一回の操作で全体の合計から１減っていることになる
なので、開始時点で全体の合計は、(N-1)*N + K ~ N*N+K になるのか?

ある操作を繰り返して最後に～系の問題は、最後から操作を逆におこなって最初の状態に戻るようにすると解けることがおおい
今回はK回の操作の後に数列の最大値が N-1 以下になるので、N-1から開始して、ある要素にN足して全体から１引く、をK回やればよい。
Nは50までなので、とりあえず５０とする（小さすぎなければよいと判断）

操作が配列の要素すべてに一回ずつ行われたとき、NふえてN-1減るので、1増えただけになる
"""
N = 50
ans = [49] * 50

cnt_all = K // N # 全体に1足される回数
rem = K % N # 初めのrem個の要素は N - (rem-1)され、残りの要素は普通にrem減る

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())
n = 50
print(n)
a = [k // n + 49] * n
for i in range(k % n):
  for j in range(n):
    if i == j:
      a[j] += n
    else:
      a[j] -= 1
print((*a))


K = int(input())

q, r = divmod(K, 50)

ans = [i + q for i in range(50)]
for i in range(1, r + 1):
    ans[-i] += 1

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)

def main():
    K = int(input())
    N = 50

    a = [N - 1] * N
    q, r = divmod(K, N)
    for i in range(N):
        cnt_add = q + int(i < r)
        a[i] += N * cnt_add
        a[i] -= K - cnt_add

    print(N)
    print((*a))


def __starting_point():
    main()

__starting_point()

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 = [0] * N
    for i in range(N):
        if i < r:
            A[i] = N - 1 + (N + 1) * (q + 1) - K
        else:
            A[i] = N - 1 + (N + 1) * q - K

    print(N)
    print((*A))
    return


def __starting_point():
    main()

__starting_point()

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)

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

k = int(read())
n = 50
a = [n - 1] * n
x, y = divmod(k, n)
for i in range(n):
    a[i] += x - y
    if i < y:
        a[i] += n + 1
print(n)
print((*a))


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())

k1 = k // 50
k2 = k % 50

n = 50
a = list(range(n))[::-1]
for i in range(n):
    a[i] += k1
for i in range(k2):
    a[i] += 1

print(n)
print((*a))


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())
N = 50
P, Q = divmod(K, N)
M = P + N - 1
ans = [M-Q]*(N-Q) + [M+51-Q]*(Q)

print(N)
print((*ans))


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)
#print(answer_list)

for i in range(50):
  answer_list[i]+=K1

print(50)
print(*answer_list)

#Nを適当にとる
#各a[i](1<=i<=N)に順番に1回ずつ操作を行うことをK//N回繰り返す
#一周する完遂するごとにa[i]は１ずつ減っていく
#自身以外の操作に対して1だけ増加するので、a[i]は合計でK//N*(N-1)+だけ増える.
#したがって、a[i]の初期値はN-1+K//N


def main():
    K = int(input())
    N = 50
    loop, remain = divmod(K, N)
    a = [N-1+loop+N-remain+1 if i < remain else N-1+loop-remain for i in range(N)]
    print(N)
    print((*a))

    
def __starting_point():
    main()

__starting_point()

import sys
def main():
    input = sys.stdin.readline
    K=int(input())
    N=50
    ans=[]
    m=K%N
    for i in range(N):
        t = N-1 + K//N
        ans.append(t)
    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()

#def test(l):
#    n = len(l)
#    c = 0
#    while max(l) >= n:
#        l.sort()
#        l[-1] -= n
#        for i in range(n-1):
#            l[i] += 1
#        c += 1
#    return c

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()
#print('kotae', test(l))


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)

#Decrease (const)
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("\033[33m", *a, "\033[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
        # a[i] = 49+50*(q+1)-49*q-(r-1)
    else:
        a[i] = 49+q-r
        # a[i] = 49+50*q-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()

def sub(A):
    m = max(A)
    for i in range(len(A)):
        if A[i] == m:
            A[i] -= len(A)
            m = -(10 ** 40)
        else:
            A[i] += 1

def main():
    K = int(input())
    if K == 0:
        return 2, [1, 1]
    if K == 1:
        return 2, [0, 2]
    if K < 50:
        return K, [K] * K
    k = K // 50
    t = [50 + k] * 50
    for _ in range(50 - (K % 50)):
        sub(t)
    return 50, t
    



N, A = main()
print(N)
print((*A))


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

# import numpy as np

sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353

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()))


# ===CODE===

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
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
#N = int(input())
#A = list(map(int,input().split()))
#S = list(input())
#S.remove("\n")
#N,M = map(int,input().split())
#S,T = map(str,input().split())
#A = [int(input()) for _ in range(N)]
#S = [input() for _ in range(N)]
#A = [list(map(int,input().split())) for _ in range(N)]
K = int(input())
if K <= 50 and K >= 2:
    a = [K]*K
    print(K)
    print((*a))
elif K == 0:
    print((2))
    print((1,1))
elif K == 1:
    print((2))
    print((0,3))
else:
    x = K // 50
    y = K % 50
    a = []
    for i in range(y):
        a.append(49+x+1)
    for j in range(50-y):
        a.append(49+x-y)
    print((50))
    print((*a))


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
#すべてのkeyが用意されてる defaultdict(int)で初期化
from collections import OrderedDict
#順序を保ったdict
from math import ceil
input=lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(11451419)
from decimal import Decimal #floatの高精度ver, 渡すのはstr型で
from functools import lru_cache
#メモ化再帰defの冒頭に毎回 @lru_cache(maxsize=10**10)
#引数にlistはだめ
#######ここまでテンプレ#######
#ソート、"a"+"b"、再帰ならPython3の方がいい
#######ここから天ぷら########
k=int(input())
print(50);n=50
if k==0:
    print(" ".join(["0"]*50));return
    
a=k//n
b=k%n
A=[a+49 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)

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=' ')
    '''else:
        return'''
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()

k = int(input())

print((50))
l = [i for i in range(50)]

for i in range(50):
    l[i] += k//50
a = k%50
for i in range(a):
    for j in range(50):
        if i == j:
            l[j] += 50
        else:
            l[j] -= 1
print((*l))


import sys
import math
import collections
import bisect
import itertools

# import numpy as np

sys.setrecursionlimit(10 ** 7)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353

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()))


# ===CODE===

def main():
    k = ni()
    l = 50
    ans = [l - 1 for _ in range(l)]

    for i in range(l):
        ans[i] += k // 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()

#float型を許すな
#numpyはpythonで
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
import copy
def I(): return int(input())
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print(('\n'.join(x)))
def printni(x): print(('\n'.join(list(map(str,x)))))
inf = 10**17
mod = 10**9 + 7

n=I()
lis=[50 for i in range(50)]
lists=[]
for i in range(50):
    mx=-inf
    for j in range(50):
        if lis[j]>=mx:
            mx=lis[j]
            ind=j
    for j in range(50):
        lis[j]+=1
    lis[ind]-=51
    lists.append(copy.deepcopy(lis))
    #print(lis)
#print(lists)
#print(lists[0])
u=n%50
x=n//50
base=lists[50-u-1]
for i in range(50):
    base[i]+=x
print((50))
print((*base))




        

    
    
    
    
    

    


def main():
    K = int(input())
    N = 50

    q, r = divmod(K, N)
    a = [x + q for x in range(N)]  # 全体への操作をqセットでき、1セットあたり全体1増加
    for i in range(N):
        if i < r:
            a[i] += N
            a[i] -= r - 1
        else:
            a[i] -= r

    print(N)
    print((*a))


def __starting_point():
    main()

# 0,1,2,...,N-1
# N,0,1,2,...,N-2
# N-1,N,0,1,2,...,N-3
# ...
# ...0,1
# ...N,0
# ...N-1,N

# 毎回どこかが0になり、そこをN加算し、他を1引く
# 全体を一回ずつ操作するとN加算してN-1引くので、1増える

__starting_point()

import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) #一列の場合
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, list(zip(*ret))))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため


MOD = 10**9 + 7
INF = 2**31  # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  # , insort_left, insort_right

# https://atcoder.jp/contests/abc068/tasks/arc079_b
# 重要な考察
# すべての要素が等しい数列に関しては,N回操作を行うと必ずすべての要素が-1される

# K//N回 操作したことにして
# のこりのK%N回は愚直に操作したことにする

K = read_a_int()
N = 50

kn = K // N
A = [N - 1 + kn] * N

rest = K % N
# 愚直に残りの回数シミュレーション
for i in range(rest):
    mi = min(A)
    idx = A.index(mi)
    for j in range(N):
        if idx == j:
            A[j] += N
        else:
            A[j] -= 1

print(N)
print((*A))


import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    k = int(input())
    S = list(range(50))
    k, r = divmod(k, 50)
    for i in range(50):
        S[i] += k

    target = 0
    while r:
        for i in range(50):
            if i == target:
                S[i] += 50
            else:
                S[i] -= 1
        target = (target + 1) % 50
        r -= 1
    print((50))
    print((*S))


def __starting_point():
    resolve()

__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
input = sys.stdin.buffer.readline

#sys.setrecursionlimit(10**9)
#from functools import lru_cache

def RD(): return input().rstrip().decode()
def II(): return int(input())
def FI(): return int(input())
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()


def main():
	k=II()


	q,r=divmod(k,50)

	N=[49+q+50-r+1]*r+[49+q-r]*(50-r)
	print((50))
	print((*N))




def __starting_point():
	main()

__starting_point()

import numpy as np
K=int(input())

N=50
num=K//N
r=K%N
L=[N-1]*N
L=np.array(L)
L+=num
for i in range(N):
    if i<r:
        L[i]+=N-(r-1)
    else:
        L[i]-=r

print(N)
print((*L))



k = int(input())

div, mod = divmod(k, 50)
A = [49+div] * 50

for i in range(mod):
    A[i] += 50
    for j in range(50):
        if i == j:
            continue
        A[j] -= 1

print((50))
print((*A))


import sys
import bisect

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


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()

# K回の操作
# N = 50とする
# 0,1,2,3,4...N - 1の数列に対して左からi番目にNを足し、それ以外から1を引く操作
# K // N回の操作をすると、1回あたり全項目に1が足される。

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)

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())

ans = [49+k//50 for i in range(50)]
for i in range(k%50):
    for j in range(50):
        if i == j:
            ans[j] += 50
        else:
            ans[j] -= 1

print((50))
print((*ans))