Santa Claus has n candies, he dreams to give them as gifts to children.

What is the maximal number of children for whose he can give candies if Santa Claus want each kid should get distinct positive integer number of candies. Santa Class wants to give all n candies he has.


-----Input-----

The only line contains positive integer number n (1 ≤ n ≤ 1000) — number of candies Santa Claus has.


-----Output-----

Print to the first line integer number k — maximal number of kids which can get candies.

Print to the second line k distinct integer numbers: number of candies for each of k kid. The sum of k printed numbers should be exactly n.

If there are many solutions, print any of them.


-----Examples-----
Input
5

Output
2
2 3

Input
9

Output
3
3 5 1

Input
2

Output
1
2

Difficulty: EASY

Solutions:
R = lambda : map(int, input().split())
n = int(input())
a = []
for i in range(1, n + 1):
	a.append(i)
	n -= i
	if n <= i:
		break
a[-1] += n
print(len(a))
print(' '.join(map(str, a)))


n = int(input())
k = 1
arr = []
while k * (k + 1) <= 2 * n:
	arr.append(k)
	k += 1
arr.pop()
arr.append(n - sum(arr))
print(len(arr))
print(*arr)


n = int(input())
if n == 1:
	print(1)
	print(1)
	exit()
res = []
s = 0
for i in range(1, n):
	f = s + i
	if n - f <= i:
		res.append(n - s)
		break
	else:
		res.append(i)
		s += i
print(len(res))
print(*res)


import sys
input = sys.stdin.readline
import math

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

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

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

def invr():
	return map(int, input().split())
n = int(input())
i = 1
a = []
while i <= n:
	a.append(i)
	n -= i
	i += 1
a[-1] += n
print(len(a))
print(' '.join((str(x) for x in a)))


n = int(input())
s = 0
res = []
curr = 1
from math import sqrt as S
z = (-1 + S(1 + 8 * n)) / 2
if int(z) == z:
	z = int(z)
	res = [i for i in range(1, z + 1)]
	print(z)
	print(*res)
else:
	can = int(z)
	for i in range(1, can):
		s += i
		res.append(i)
	res.append(n - s)
	print(can)
	print(*res)


import os.path
from math import gcd, floor, ceil
from collections import *
from bisect import *
import sys
from random import *
mod = 1000000007
INF = float('inf')

def st():
	return list(sys.stdin.readline().strip())

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

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

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

def pr(n):
	return sys.stdout.write(str(n) + '\n')

def prl(n):
	return sys.stdout.write(str(n) + ' ')
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
n = inp()
if n == 1 or n == 2:
	pr(1)
	pr(n)
else:
	cur = 1
	r = n
	ans = []
	while cur < n - cur * (cur + 1) // 2:
		ans.append(cur)
		cur += 1
	ans.append(n - cur * (cur - 1) // 2)
	print(len(ans))
	print(*ans)


n = int(input())
m = n
arr = []
if n > 1:
	for i in range(1, n + 1):
		m -= i
		if m < abs(m):
			m += i
			arr[len(arr) - 1] += m
			break
		else:
			arr.append(i)
	print(len(arr))
	print(*arr)
else:
	print('1')
	print('1')


n = int(input())
i = 1
a = []
while n >= i:
	a.append(i)
	n -= i
	i += 1
a[-1] += n
print(len(a))
print(*a)


fast = lambda : stdin.readline().strip()
zzz = lambda : [int(i) for i in fast().split()]
(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from re import *
from sys import *
from math import *
from heapq import *
from queue import *
from bisect import *
from string import *
from itertools import *
from collections import *
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from collections import Counter as cc
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def output(answer):
	stdout.write(str(answer))
s = int(z())
if s == 1:
	exit(print('1\n1'))
arr = []
t = 0
for i in range(1, s):
	t += i
	if t > s:
		break
	else:
		arr.append(i)
if sum(arr) == s:
	print(len(arr))
	print(*arr)
else:
	print(len(arr))
	print(*arr[:-1], arr[-1] + (s - sum(arr)))


n = int(input())
x = []
i = 1
while n > 0:
	n -= i
	x.append(i)
	i += 1
	if n - i < 0:
		x[-1] += n
		break
print(len(x))
print(*x)


n = int(input())
ans = []
nxt = 1
while n > 0:
	x = nxt
	n -= nxt
	nxt += 1
	if n < nxt:
		x += n
		n = 0
	ans.append(str(x))
print(len(ans))
print(' '.join(ans))


import sys

def solve(r, w):
	santa_candy = int(r.readline())
	candy_for_kid_list = []
	while santa_candy > len(candy_for_kid_list):
		candy_for_kid = len(candy_for_kid_list) + 1
		candy_for_kid_list += [candy_for_kid]
		santa_candy -= candy_for_kid
	candy_for_kid_list[-1] += santa_candy
	print(len(candy_for_kid_list))
	print(*candy_for_kid_list)
solve(sys.stdin, sys.stdout)


n = int(input())
k = 1
spis = []
j = 0
if n == 3:
	spis = spis + ['1', '2']
	j = 2
else:
	while True:
		j = j + 1
		if n - k >= 3 and str(n - k) not in spis and (n - k != k):
			n = n - k
			spis = spis + [str(k)]
		else:
			spis = spis + [str(n)]
			break
		k = k + 1
print(j)
print(' '.join(spis))


n = int(input())
l = []

def foo():
	global l
	global n
	for i in range(1, n + 1):
		if i in l:
			continue
		l.append(i)
		n = n - i
		foo()
	if n == 0:
		return
	elif len(l) > 0:
		n = n + l[len(l) - 1]
		del l[len(l) - 1]
foo()
print(len(l))
for i in l:
	print(i, end=' ')


num1 = int(input())
i = 2
ans = 0
s = 0
ans = int(((8 * num1 + 1) ** (1 / 2) - 1) / 2)
print(int(ans))
for i in range(int(ans) - 1):
	print(i + 1, end=' ')
	s += i + 1
print(num1 - s, end=' ')


import math
n = int(input())
t = int(math.sqrt(2 * n + 0.25) - 0.5)
ans = list(range(t + 1)[1:])
ans[-1] += n - t * (t + 1) // 2
print(t)
print(*ans)


N = int(input())
count = 1
ans = []
while N >= count:
	ans += [count]
	N -= count
	count += 1
if N != 0:
	ans[-1] += N
print(len(ans))
for i in ans:
	print(i, end=' ')


def cusum(x):
	return x * (x + 1) // 2
n = int(input())
ans = []
for i in range(1, n + 1):
	t = cusum(i)
	if t > n:
		if len(ans) == 1:
			ans[-1] = n
		else:
			ans[-1] = abs(cusum(ans[-2]) - n)
		break
	ans.append(i)
print(len(ans))
print(' '.join(map(str, ans)))


n = int(input())
k = int((2 * n) ** 0.5) - 1
while k * (k + 1) <= 2 * n:
	k += 1
k -= 1
print(k)
q = n - k * (k + 1) // 2
for i in range(1, k):
	print(i, end=' ')
print(k + q)


n = int(input())
for i in range(1, 50):
	if i * (i + 1) // 2 == n:
		print(i)
		print(*[j for j in range(1, i + 1)])
		break
	elif i * (i + 1) // 2 > n:
		print(i - 1)
		print(*[j for j in range(1, i - 1)], n - (i - 2) * (i - 1) // 2)
		break


n = int(input())
given = []
while n >= len(given) + 1:
	n -= len(given) + 1
	given.append(len(given) + 1)
given[-1] += n
print(len(given))
print(' '.join(map(str, given)))


n = int(input())
ans = []
t = n
for i in range(1, n + 1):
	if i == 1:
		ans = [1]
		t -= 1
	elif t >= i:
		ans.append(i)
		t -= i
	else:
		ans[-1] += t
		t = 0
	if t == 0:
		break
print(len(ans))
print(*ans)


from math import floor, sqrt
n = int(input())
ans = floor(0.5 * (sqrt(8 * n + 1) - 1))
one_to_ans = [i for i in range(1, ans + 1)]
one_to_ans[-1] += n - sum(one_to_ans)
print(ans)
print(*one_to_ans)


import sys
import math
import bisect

def solve(n):
	A = []
	val = 0
	for i in range(1, 10000):
		if val + i <= n:
			A.append(i)
			val += i
		else:
			break
	A[-1] += n - sum(A)
	return A

def main():
	n = int(input())
	A = solve(n)
	print(len(A))
	print(' '.join(list((str(a) for a in A))))
main()


n = int(input())
ans = 0
l1 = []
i = 1
while n > 0:
	if n - i >= 0:
		l1.append(i)
		n -= i
		i += 1
	else:
		l1[-1] += n
		break
print(len(l1))
for i in l1:
	print(i, end=' ')


import math
n = int(input())
if n != 2:
	i = 1
	c = 1
	s = '1'
	while i * (i + 1) / 2 <= n:
		i += 1
	print(i - 1)
	for j in range(1, i - 1):
		if j == i - 2:
			s += ' ' + str(n - c)
		else:
			s += ' ' + str(j + 1)
			c += j + 1
	print(s)
else:
	print(1)
	print(2)


n = int(input())
s = []
t = 0
nums = [int(i) for i in range(1, n + 1)]
for i in range(1, n + 1):
	d = sum(nums[:i])
	if d <= n:
		t = nums[:i]
t[-1] += n - sum(t)
print(len(t))
print(*t)


n = int(input())
c = 1
a = []
while n - c > c:
	a.append(c)
	n -= c
	c += 1
a.append(n)
print(len(a))
print(*a)


from math import sqrt
n = int(input())
if n == 1:
	print(1)
	print(1)
else:
	x = []
	y = []
	sumo = 0
	i = 0
	f = 0
	while f == 0:
		i = i + 1
		ln = n
		n = n - i
		y.append(i)
		if n in y or n == 0:
			break
		else:
			x.append(i)
	x.append(ln)
	print(len(x))
	for i in x:
		print(i, end=' ')


n = int(input())
l = []
for i in range(n):
	l.append(i + 1)
	if sum(l) + l[len(l) - 1] + 1 > n:
		l[len(l) - 1] += n - sum(l)
		break
print(len(l))
print('%s' % ' '.join(map(str, l)))


n = int(input())
ind = 1
a = list()
while True:
	a.append(ind)
	n -= ind
	if n == 0:
		break
	if n <= ind:
		a[-1] += n
		break
	ind += 1
print(len(a))
for i in a:
	print(i, end=' ')


a = int(input())
i = 1
counter = 0
T = []
while a - i >= 0:
	a -= i
	counter += 1
	T = T + [i]
	i += 1
T[counter - 1] += a
print(counter)
for i in T:
	print(i, end=' ')


n = int(input())
dp = [0, n]
extend = True
while extend == True:
	temp = dp[-1] - (len(dp) - 1)
	if temp > len(dp) - 1:
		dp.append(temp)
	else:
		extend = False
print(len(dp) - 1)
res = ''
for i in range(0, len(dp) - 2):
	res = res + str(i + 1) + ' '
res = res + str(dp[len(dp) - 1])
print(res)


n = int(input())
s = 0
ans = []
for i in range(1, 2 * (n + 1)):
	s += i
	if s <= n:
		ans.append(i)
	else:
		s -= i
		ans[-1] = ans[-1] + n - s
		break
print(len(ans))
print(*ans)


n = int(input())
sett = set()
z = 1
n -= 1
sett.add(1)
while z + 1 <= n:
	sett.add(z + 1)
	z += 1
	n -= z
if n:
	sett.remove(z)
	sett.add(z + n)
	print(len(sett))
	print(*sett)
else:
	print(len(sett))
	print(*sett)


N = int(input())
M = 0
while (M + 1) * (M + 2) / 2 <= N:
	M += 1
print(M)
for i in range(1, M):
	print(i, end=' ')
	N -= i
print(N)


n = int(input())
if n == 2:
	num = [2]
	n = 0
else:
	num = [1]
	n -= 1
i = 2
while n > 0:
	if n >= 2 * i + 1:
		num.append(i)
		n -= i
	else:
		num.append(n)
		n = 0
	i += 1
print(len(num))
print(*num)


n = int(input())
x = 1
lst = []
if n == 1:
	print(n)
	print(n)
	exit()
while x <= n:
	n -= x
	lst.append(x)
	x += 1
lst[-1] += n
print(x - 1)
for elem in lst:
	print(elem, end=' ')


n = int(input())
l = []
for i in range(1, 2000):
	if n - i > i:
		n = n - i
		l.append(i)
	else:
		l.append(n)
		break
print(len(l))
for i in range(len(l)):
	print(l[i], end=' ')


number = int(input())
n = int((1 + (1 + 8 * number) ** (1 / 2)) / 2)
n -= 1
print(n)
ans = []
for i in range(n - 1):
	ans.append(str(i + 1))
ans.append(str(number - (n - 1) * n // 2))
print(' '.join(ans))


max = -float('inf')
cur = []

def candies(n, arr):
	global cur, max
	if sum(arr) == n:
		if len(arr) > max or (len(arr) == max and sum(arr) > sum(cur)):
			max = len(arr)
			cur = arr[:]
		return 0
	if sum(arr) > n:
		arr.pop()
		if len(arr) > max or (len(arr) == max and sum(arr) > sum(cur)):
			max = len(arr)
			cur = arr[:]
		return 0
	for i in range(1, n + 1):
		if i not in arr:
			arr.append(i)
			if candies(n, arr) == 0:
				break
			if i in arr:
				arr.remove(i)
	return 1
n = int(input())
candies(n, [])
print(max)
for each in cur:
	print(each, end=' ')


q = int(input())
a = [1]
q -= 1
l = 1
while q > a[l - 1]:
	q -= l + 1
	a.append(l + 1)
	l += 1
a[l - 1] += q
print(len(a))
for i in a:
	print(i, end=' ')


n = int(input())
l = [1]
for i in range(2, n):
	if sum(l) + i <= n:
		l.append(i)
	else:
		break
l[-1] = l[-1] + (n - sum(l))
print(len(l))
print(*l)


n = int(input())
s = []
sum = 0
i = 1
while sum + i <= n and i not in s:
	s.append(i)
	sum += i
	i += 1
print(len(s))
s[-1] += n - sum
print(*s)


n = int(input())
i = 0
t = n
while t > i:
	i += 1
	t -= i
print(str(i))
for x in range(1, i):
	print(str(x) + ' ', end='')
print(str(t + i))


n = int(input())
k = 1
while 1:
	k += 1
	if k * (k + 1) // 2 > n:
		break
k -= 1
ans = []
for i in range(1, k):
	ans.append(i)
ans.append(n - (k - 1) * k // 2)
print(k)
print(*ans)


n = int(input())
a = []
c = 0
x = 1
while sum(a) + x <= n:
	a.append(x)
	x += 1
	c += 1
if sum(a) == n:
	print(c)
	print(*a)
else:
	a[-1] = n - sum(a[:-1])
	print(c)
	print(*a)


from bisect import bisect_left as bl
n = int(input())
dp = []
for i in range(1, n + 1):
	dp.append(i * (i + 1) // 2)
x = bl(dp, n)
if dp[x] == n:
	ans = [i for i in range(1, x + 2)]
else:
	tmp = n - dp[x - 1]
	ans = [i for i in range(1, x + 1)]
	ans[-1] += tmp
print(len(ans))
print(*ans)


def getSweets(sweetCount):
	if sweetCount == 1:
		return [1]
	sweetsList = []
	sumN = 0
	n = 1
	while sumN + n <= sweetCount:
		sumN += n
		sweetsList.append(n)
		n += 1
	sweetsList[-1] += sweetCount - sumN
	return sweetsList
sweetCount = int(input())
sweets = getSweets(sweetCount)
sweets = list(map(str, sweets))
print(len(sweets))
print(' '.join(sweets))


n = int(input())
ans = 0
i = 1
a = []
while ans != n:
	if ans + i < n:
		ans += i
		a.append(i)
	elif ans + i == n:
		a.append(i)
		print(len(a))
		print(*a)
		break
	else:
		del a[-1]
		a.append(n - sum(a))
		print(len(a))
		print(*a)
		break
	i += 1


n = int(input())
k = n
ans = []
for i in range(1, 1000):
	n -= i
	if n < 0:
		break
	ans.append(i)
print(len(ans))
if len(ans) > 1:
	print(*ans[:-1], end=' ')
print(ans[-1] + k - sum(ans))


n = int(input())
l = []
t = 1
while t <= n:
	l.append(t)
	n -= t
	t += 1
l[-1] = l[-1] + n
print(len(l))
print(*l)


from collections import deque as de
import math
import sys
import re
from collections import Counter as cnt
from functools import reduce
from typing import MutableMapping
from itertools import groupby as gb
from fractions import Fraction as fr
from bisect import bisect_left as bl, bisect_right as br

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

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0
arrStack = My_stack()

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def binarytodecimal(n):
	return int(n, 2)

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic

def Log2(x):
	return math.log10(x) / math.log10(2)

def getProduct(n):
	product = 1
	while n != 0:
		product = product * (n % 10)
		n = n // 10
	return product

def dupconscount(nums):
	element = []
	freque = []
	if not nums:
		return element
	running_count = 1
	for i in range(len(nums) - 1):
		if nums[i] == nums[i + 1]:
			running_count += 1
		else:
			freque.append(running_count)
			element.append(nums[i])
			running_count = 1
	freque.append(running_count)
	element.append(nums[i + 1])
	return (element, freque)

def lcm(x, y):
	lcm = x * y // math.gcd(x, y)
	return lcm

def isPowerOfTwo(n):
	return math.ceil(Log2(n)) == math.floor(Log2(n))

def checkisap(list):
	d = list[1] - list[0]
	for i in range(2, len(list)):
		temp = list[i] - list[i - 1]
		if temp != d:
			return False
	return True

def ceildiv(x, y):
	return (x + y - 1) // y

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

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

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

def si():
	return list(map(str, input()))

def indic():
	dic = {}
	for (index, value) in enumerate(input().split()):
		dic[int(value)] = int(index) + 1
	return dic
n = ii()
ans = []
for i in range(1, 10000000):
	if n >= i:
		ans.append(i)
		n -= i
	else:
		break
ans[len(ans) - 1] += n
print(len(ans))
print(*ans)


import sys, random, math
n = int(input())
cand = []
cur = 1
while cur <= n:
	cand.append(cur)
	n -= cur
	cur += 1
cand[-1] += n
print(len(cand))
print(' '.join(map(str, cand)))


n = int(input())
ans = []
for i in range(1, n + 1):
	if n == 0:
		break
	if n - i == 0 or n - i > i:
		ans.append(i)
		n -= i
print(len(ans))
for x in ans:
	print(x, end=' ')


sums = lambda n: n * (n + 1) // 2

def get_maximum(n):
	for i in range(0, 1000):
		if sums(i) > n:
			return i - 1
number = int(input())
maxi = get_maximum(number)
_list_ = [i for i in range(1, maxi)] + [number - sums(maxi - 1)]
print(maxi)
print(*_list_)


n = int(input())
t = 1
ans = [t]
k = 0
while True:
	t += 1
	s = sum(ans)
	d = n - s
	if s == n:
		k = len(ans)
		break
	elif t > d:
		k = len(ans)
		ans[-1] += d
		break
	else:
		ans.append(t)
print(k)
print(*ans)


s = int(input())
n = (int((8 * s + 1) ** 0.5) - 1) // 2
print(n)
for i in range(n - 1):
	print(i + 1, end=' ')
print(s - (n - 1) * n // 2)


import random
import math

def main():
	n = int(input())
	c = int((math.sqrt(1 + 8 * n) - 1) // 2)
	print(c)
	s = ''
	r = n - c * (c + 1) // 2
	for i in range(c - 1):
		s += str(i + 1) + ' '
	s += str(c + r)
	print(s)
main()


from sys import stdin
import math
A = int(stdin.readline())
B = math.floor((-1 + math.sqrt(8 * A + 1)) / 2)
C = A - int(B * (B + 1) / 2)
print(B)
for t in range(0, B - 1):
	print(t + 1, end=' ')
print(B + C)


from sys import stdin, stdout
from math import gcd, sqrt, factorial
from collections import deque, defaultdict
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
P = lambda x: stdout.write(x)
lcm = lambda x, y: x * y // gcd(x, y)
hg = lambda x, y: (y + x - 1) // x * x
pw = lambda x: 0 if x == 1 else 1 + pw(x // 2)
chk = lambda x: chk(x // 2) if not x % 2 else True if x == 1 else False
sm = lambda x: (x ** 2 + x) // 2
N = 10 ** 9 + 7
n = I()
a = []
s = 1
i = 1
while s <= n:
	a += (i,)
	i += 1
	s += i
a[-1] += n - sum(a)
print(i - 1)
print(*a)


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

def fi():
	return float(input())

def si():
	return input()

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

def li():
	return list(mi())
n = ii()
dup = n
(i, c) = (1, 0)
while i <= n:
	n -= i
	i += 1
	c += 1
l = []
for i in range(1, c):
	l.append(i)
a = dup - sum(l)
l.append(a)
print(c)
print(*l)


def main():
	n = int(input())
	nr = 1
	candies = []
	while nr * (nr + 1) // 2 < n:
		candies.append(nr)
		nr += 1
	if nr * (nr + 1) // 2 > n:
		nr -= 1
	if nr * (nr + 1) // 2 == n:
		candies.append(nr)
		print(len(candies))
		print(' '.join(map(str, candies)))
		return
	while True:
		if n - nr * (nr + 1) // 2 in candies:
			candies.remove(nr)
			nr -= 1
		else:
			candies.append(n - nr * (nr + 1) // 2)
			break
	print(len(candies))
	print(' '.join(map(str, candies)))
main()


from math import floor

def f(x):
	return 0.5 * (-1 + (8 * x + 1) ** 0.5)
n = int(input())
num_children = floor(f(n))
print(num_children)
for i in range(1, num_children + 1):
	if i == num_children:
		print(n - int(0.5 * num_children * (num_children + 1)) + num_children)
	else:
		print(i, end=' ')


n = int(input())
k = n
i = 1
l = []
while k >= 0:
	k -= i
	l.append(i)
	i += 1
l[len(l) - 2] += k + i - 1
if n == 1:
	print(1)
	print(1)
else:
	print(len(l) - 1)
	for i in range(len(l) - 1):
		print(l[i], end=' ')


import math
n = int(input())
m = (-1 + (1 + 4 * 2 * n) ** 0.5) / 2
p = math.ceil((-1 + (1 + 4 * 2 * n) ** 0.5) / 2)
l = []
if m == p:
	for i in range(1, int(p + 1)):
		l.append(i)
	print(p)
else:
	for i in range(1, int(p)):
		if i != p - 1:
			l.append(i)
		else:
			x = p * (p + 1) // 2
			l.append(i + 1 - x + n + i)
	print(int(m))
print(*l)


n = int(input())
lower = int(((n * 8 + 1) ** 0.5 - 1) / 2)
prevSum = lower * (lower - 1) // 2
arr = list(range(1, lower + 1))
arr[-1] = n - prevSum
print(len(arr))
print(*arr)


def sum_pos(first, n):
	global f1, begin, end, dop, k1, k2
	start = first + 1
	stop = first + n - 1
	sum = 0
	while sum < N - 1:
		sum = first
		for i in range(start, stop):
			sum += i
		for i in range(stop, N):
			if sum + i >= N:
				sum += i
				break
		start += 1
		stop += 1
	if sum == N and stop - start > k1:
		f1 = first
		begin = start - 1
		end = stop - 1
		dop = i
		k1 = stop - start
N = int(input())
k1 = -1
if N == 1 or N == 2:
	print(1)
	print(N)
if N == 3:
	print(2)
	print(1, 2)
if N > 3:
	for i in range(1, N):
		k2 = k1
		for j in range(2, N + 2):
			sum_pos(i, j)
		if k2 == k1:
			break
	print(k1 + 2)
	print(f1, end=' ')
	for i in range(begin, end):
		print(i, end=' ')
	print(dop)


a = int(input())
b = 0
n = ''

def pedy(x, m):
	global b, n
	if x - m > m:
		x = x - m
		b = b + 1
		n = n + str(m) + ' '
		m = m + 1
		pedy(x, m)
	else:
		b = b + 1
		n = n + str(x)
pedy(a, 1)
print(b)
print(n)


import math
x = int(input())
n = int((-1 + math.sqrt(1 + 8 * x)) / 2)
print(n)
if x <= 2:
	print(x)
	exit()
li = []
s = 0
for i in range(1, n):
	li += [i]
	s += i
li.append(x - s)
print(*li)


n = int(input())
(i, x, l) = (1, 1, [1])
if n == 2:
	print(1)
	print(2)
	exit()
while x < n:
	i += 1
	x += i
	if x <= n:
		l.append(i)
	else:
		l[-1] = n - sum(l[:-1])
		break
print(len(l))
print(*l)


n = int(input())
t = (-1 + (1 + 8 * n) ** (1 / 2)) / 2
k = 0
print(int(t))
for i in range(1, int(t)):
	k = k + i
	print(i, end=' ')
print(n - k)


n = int(input())
k = 2
for i in range(1, n):
	s = int(i * (i + 1) / 2)
	if s >= n:
		k = i
		if s == n:
			k += 1
		break
print(k - 1)
for i in range(1, k - 1):
	print(i, end=' ')
	n -= i
print(n)


n = int(input())
i = 0
counter = 0
while True:
	i += 1
	counter += i
	if counter < n and counter + i + 1 > n:
		break
	if counter > n:
		counter -= i
		break
k = [j for j in range(1, i)]
if n - counter > 0:
	k.append(n - sum(k))
print(len(k))
print(*k)


n = int(input())
cur = 1
ans = []
while n > cur:
	n -= cur
	ans.append(cur)
	cur += 1
if n < cur:
	ans[-1] += n
else:
	ans.append(n)
print(len(ans))
print(*ans)


n = int(input())
a = []
while n > len(a):
	a += [len(a) + 1]
	n -= a[-1]
a[-1] += n
print(len(a))
print(*a)


def main():
	k = int(input())
	temp = 0
	a = []
	for i in range(1, k + 1):
		if temp + i <= k:
			a.append(i)
			temp += i
		else:
			exc = temp + i - k
			t = a.pop()
			a.append(t + (i - exc))
			break
	print(len(a))
	print(*a)
main()


n = int(input())
ans = 0
arr = []
while ans < n:
	ans += 1
	arr.append(ans)
	n -= ans
arr[-1] += n
print(len(arr))
print(*arr)


n = int(input())
i = 0
sum = 0
a = []
while sum < n:
	i += 1
	sum += i
	if n - sum < i + 1:
		a.append(i + n - sum)
		break
	else:
		a.append(i)
print(i)
print(*a)


n = int(input())
l = list(range(1, 51))
t = 0
for i in l:
	t += i
	if t > n:
		break
print(i - 1)
print(*l[:i - 2] + [n - t + i + i - 1])


n = int(input())
cur = 1
candies = []
while cur <= n:
	candies.append(cur)
	n -= cur
	cur += 1
candies[-1] += n
print(len(candies))
print(*candies)


n = int(input())
k = int(((8 * n + 1) ** 0.5 - 1) / 2)
print(k)
print(*range(1, k), n - k * (k - 1) // 2)


n = int(input())
ans = 0
i = 1
ans1 = []
while ans + i <= n:
	ans += i
	ans1.append(i)
	i += 1
ans1[-1] = ans1[-1] + (n - sum(ans1))
print(len(ans1))
print(*ans1)


def cari(bil, peng):
	if len(memo[bil]) != 0:
		return memo[bil]
	if bil == 0:
		return [peng - 1]
	if bil < peng:
		return []
	temp = []
	for i in range(peng, bil + 1):
		hasil = cari(bil - i, i + 1)
		temp = hasil if len(hasil) > len(temp) else temp
	memo[bil] = temp
	return [peng - 1] + temp
n = int(input())
memo = [list()] * (n + 1)
hasil = cari(n, 1)[1:]
print(len(hasil))
print(*hasil)


n = int(input())
count = 0
l = []
for i in range(1, 101):
	if n >= i:
		n -= i
		count += 1
		l.append(i)
	else:
		break
l[-1] += n
print(count)
for i in l:
	print(i, end=' ')
print()


n = int(input())
(sumv, i) = (0, 1)
s = []
while sumv < n:
	s.append(i)
	sumv += i
	i += 1
if sumv > n:
	x = s[-1]
	sumv -= x
	s.pop()
	s[-1] += n - sumv
print(len(s))
print(*s)


import sys

def CalcAnswer(n):
	at = 1
	remainder = n
	list = []
	while at + at + 1 <= remainder:
		list.append(at)
		remainder -= at
		at += 1
	list.append(remainder)
	return list

def PrintAnswer(list_of_candies):
	print(len(list_of_candies))
	print(' '.join((str(x) for x in list_of_candies)))
PrintAnswer(CalcAnswer(int(sys.stdin.readline().strip())))


import sys
n = int(sys.stdin.readline())
if n == 1:
	print(1)
	print(1)
	exit()
if n == 2:
	print(1)
	print(2)
	exit()
t = 0
w = 0
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45]
for i in l:
	t += i
	if t >= n:
		if t != n:
			w = n - t + i
			t = i - 1
		else:
			w = 0
			t = i
		break
print(t)
strang = ''
for i in l:
	strang += str(i) + ' '
	if i == t - 1:
		strang += str(i + 1 + w)
		break
print(strang)


n = int(input())
k = 0
if n == 2:
	print(1)
	print(2)
	exit()
if n == 1:
	print(1)
	print(1)
	exit()
for i in range(1, n):
	k += i
	if k == n:
		print(i)
		for i in range(1, i + 1):
			print(i, end=' ')
		exit()
	if k > n:
		k -= i + i - 1
		break
print(i - 1)
for i in range(1, i - 1):
	print(i, end=' ')
print(n - k)


n = int(input())
i = 1
s = 0
l = []
while s < n:
	s = s + i
	l.append(i)
	i = i + 1
	if s == n:
		break
	elif s > n:
		s = s - i
		l.pop()
		break
	else:
		pass
print(len(l))
l.pop()
l.append(n - sum(l))
print(*l)


n = int(input())
i = 1
r = []
while i <= n:
	r += [i]
	n -= i
	i += 1
r[-1] += n
print(f"{len(r)}\n{' '.join(map(str, r))}")


def sum_digits(n):
	sum = 0
	for i in range(n + 1):
		sum += i
	return sum

def list_need_digits(numb):
	(count, lst) = (1, [])
	while sum_digits(count) <= numb:
		lst.append(count)
		count += 1
	if sum_digits(count) != numb:
		lst[len(lst) - 1] += numb - sum_digits(count - 1)
	return lst
n = int(input())
print(len(list_need_digits(n)))
print(' '.join(map(str, list_need_digits(n))))


n = int(input())
k = 1
x = 0
s = 0
while k * (k + 1) // 2 <= n:
	x = k
	s = k * (k + 1) // 2
	k += 1
l = list()
i = 1
while i < x:
	l.append(i)
	i += 1
l.append(i + (n - s))
print(len(l))
for i in l:
	print(i, end=' ')


n = int(input())
bag = []
st = 1
n -= 1
bag.append(1)
tp = n + 1
while n > 0:
	st += 1
	n -= st
	if n >= 0:
		bag.append(st)
bag[-1] += abs(tp - sum(bag))
print(len(bag))
print(*bag)


import sys
import math
from collections import defaultdict as ddict
from collections import deque
import heapq
from queue import Queue
fast_inp = lambda : sys.stdin.readline().split('\n')[0]
read_list = lambda : fast_inp().split(' ')
read_listi = lambda : list(map(int, fast_inp().split(' ')))
read_listf = lambda : list(map(float, fast_inp().split(' ')))
read_int = lambda : int(fast_inp())
read_float = lambda : float(fast_inp())
read = lambda : fast_inp()
DEBUG = True

def debug(**kwargs):
	if not DEBUG:
		return
	print('*' * 20)
	for (k, v) in kwargs.items():
		print(f'\t{k}:{v}\t')
	print('*' * 20)

def solve() -> None:
	n = read_int()
	s = 0
	i = 1
	while s < n:
		s += i
		i += 1
	if s == n:
		print(i - 1)
		print(*list(range(1, i)))
	else:
		l = list(range(1, i - 1))
		l[-1] += n - (s - (i - 1))
		print(len(l))
		print(*l)
t = 1
for _ in range(t):
	solve()


n = int(input())
L = [1]
for i in range(2, n):
	if sum(L) + i <= n:
		L.append(i)
	else:
		break
L[-1] += n - sum(L)
print(len(L))
print(' '.join((str(i) for i in L)))


n = int(input())
for i in range(1, n + 1):
	if i * (i + 1) / 2 == n:
		j = 1
		break
	elif i * (i + 1) / 2 > n:
		j = 0
		break
Sum = []
if j:
	for i in range(1, i + 1):
		Sum.append(i)
else:
	for i in range(1, i):
		Sum.append(i)
	Sum[-1] = Sum[-1] + int(n - i * (i + 1) / 2)
print(len(Sum))
for num in Sum:
	print(num, end=' ')


n = int(input())
x = 0
for i in range(n + 1):
	if i * (i + 1) // 2 <= n:
		x = i
print(x)
for i in range(x - 1):
	print(i + 1, end=' ')
print(n - x * (x - 1) // 2)


def sum(end):
	return end * (end + 1) / 2
inpt = input().split()
n = int(inpt[0])
start = 1
end = start - 1
while sum(end + 1) <= n:
	end += 1
numbers = [x for x in range(1, end)]
print(end)
numbers.append(end if sum(end) == n else int(n - sum(end - 1)))
print(' '.join([str(x) for x in numbers]))


n = int(input())
i = 1
ans = []
while n >= i:
	ans.append(i)
	n -= i
	i += 1
ans[-1] += n
print(len(ans))
print(*ans)


from sys import stdout

def solve():
	num = int(input().rstrip())
	total = 0
	ans = set()
	i = 1
	while True:
		if total + i <= num:
			ans.add(i)
			total += i
			i += 1
		else:
			i -= 1
			break
	if total < num:
		ans.remove(i)
		ans.add(num - total + i)
	print(len(ans))
	for i in ans:
		stdout.write(str(i) + ' ')
	stdout.write('\n')
solve()


from math import *

def getN(S):
	S *= 2
	N = int(sqrt(S))
	if N * (N + 1) <= S:
		return N
	else:
		return N - 1
X = int(input())
num = getN(X)
print(num)
S = 0
for i in range(1, num):
	print(i, end=' ')
	S += i
print(X - S)


n = int(input())
tmp = 0
res = []
i = 0
while n > tmp:
	i += 1
	tmp += i
	if tmp > n:
		tmp -= i
		break
	else:
		res.append(i)
tmp = tmp - res.pop()
res.append(n - tmp)
print(len(res))
print(*res)


n = int(input())
i = 1
current = []
while n >= i:
	current.append(i)
	n -= i
	i += 1
current[-1] += n
print(len(current))
print(*current)


n = int(input())
arr = []
on = 1
while n > 2 * on:
	n -= on
	arr.append(on)
	on += 1
arr.append(n)
print(len(arr))
print(' '.join(map(str, arr)))


from math import *
from collections import *
MOD = 1000000007
N = 10000
n = int(input())
x = floor((floor(sqrt(8 * n + 1)) - 1) / 2)
print(x)
l = [k for k in range(1, x + 1)]
y = x * (x + 1) // 2
l[-1] += n - y
print(*l)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
p = 1
l = []
x = p * (p + 1) // 2
while x <= n:
	l.append(p)
	p += 1
	x = p * (p + 1) // 2
l[-1] = n - (p - 2) * (p - 1) // 2
print(p - 1)
print(*l)


x = int(input())
z = -1
i = 0
y = []
while z + i + 1 <= x:
	if z == -1:
		z = 0
	i += 1
	z += i
	y.append(i)
print(i)
y[i - 1] += x - z
for i in y:
	print(i, end=' ')


n = int(input())
m = n
count = 0
arr = []
if n == 1:
	print(1)
	print(1)
else:
	for i in range(1, n):
		if m - i >= 0:
			count += 1
			m -= i
			arr.append(i)
	arr[len(arr) - 1] += m
	print(count)
	print(*arr)


n = int(input())
l = []
w = 0
sm = 0
while True:
	w += 1
	sm += w
	if sm < n + 1:
		l.append(w)
	else:
		break
sm -= w
l[-1] = n - sm + l[-1]
print(len(l))
s = ''
for i in l:
	s += ' ' + str(i)
print(s[1:])


n = int(input())
if n == 2:
	print(1)
	print(2)
	exit(0)
m = int(((1 + 8 * n) ** 0.5 - 1) / 2)
arr = [i for i in range(1, m + 1)]
sum = m * (m - 1) // 2
d = n - sum
arr[-1] = d
print(m)
print(*arr)


import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
N = int(input())
S = 0
i = 1
ans = []
while True:
	if S + i <= N:
		S += i
		ans.append(i)
		i += 1
	else:
		break
r = N - sum(ans)
if r < 0:
	ans = ans[:-1]
else:
	ans[-1] += r
print(len(ans))
print(*ans)


n = int(input())
i = 1
a = []
while n >= i:
	a.append(i)
	n -= i
	i += 1
if n > 0:
	a[-1] += n
print(len(a))
print(*a)


from collections import deque, defaultdict, Counter
from itertools import product, groupby, permutations, combinations
from math import gcd, floor, inf
from bisect import bisect_right, bisect_left
num = int(input())
ans = []
for i in range(1, 50):
	if i <= num:
		ans.append(i)
		num -= i
	else:
		ans[-1] += num
		break
print(len(ans))
print(*ans)


def main():
	n = int(input())
	sum_n = 1
	op = []
	op.append(1)
	for i in range(2, n + 1):
		if sum_n + i <= n:
			op.append(i)
			sum_n += i
		else:
			break
	diff = n - sum_n
	op[len(op) - 1] += diff
	str_op = ''
	for item in op:
		str_op += str(item) + ' '
	print(len(op))
	print(str_op)
main()


n = int(input())
k = int(-0.4999999 + (0.25 + 2 * n) ** 0.5)
print(k)
for i in range(1, k):
	print(i, end=' ')
print(n - k * (k - 1) // 2)


n = int(input())
m = n
a = []
for i in range(1, n + 1):
	if n - i >= 0:
		n -= i
		a.append(i)
a.sort()
x = m - sum(a)
if x == 0:
	print(len(a))
	print(*a)
else:
	print(len(a))
	mx = max(a)
	mx += x
	a.pop()
	a.append(mx)
	print(*a)


n = int(input())
s = ''
i = 0
while True:
	i += 1
	n -= i
	if n > i:
		s += str(i) + ' '
	else:
		s += str(n + i)
		break
print(i)
print(s)


x = int(input())
if x == 1:
	print(1)
	print(1)
else:
	c = 0
	i = 1
	while c + i <= x:
		c += i
		i += 1
	print(i - 1)
	for y in range(i - 2):
		print(y + 1, end=' ')
	print(i + (x - c - 1))


import sys
num_candies = int(sys.stdin.readline())
sum_candies = 1
candies = []
for n in range(2, 50):
	sum_candies += n
	if sum_candies <= num_candies:
		candies.append(n - 1)
	else:
		candies.append(num_candies - sum(candies))
		break
print(len(candies))
print(' '.join(map(str, candies)))


a = int(input())
m = []
b = 0
v = 0
while v < a:
	b += 1
	m.append(b)
	v = v + b
	if a < v + b + 1:
		m[b - 1] = m[b - 1] + (a - v)
		break
print(b)
print(*m)


n = int(input())
(su, s, i) = (1, '', 1)
while su <= n:
	s += str(i) + ' '
	i += 1
	su += i
print(i - 1)
print(s[:-(1 + len(str(i - 1)))] + str(n - su + i + i - 1))


n = int(input())
r = []
for i in range(1, 50):
	if i > n:
		r[-1] += n
		break
	else:
		r.append(i)
		n -= i
print(len(r))
for i in range(len(r)):
	print(r[i], end=' ')


from sys import stdin
n = int(stdin.readline())
c = 1
cnt = []
kids = 0
while n > 0:
	if n == c:
		kids += 1
		cnt.append(c)
		n -= c
	elif n > c:
		if n - c > c:
			kids += 1
			cnt.append(c)
			n -= c
	c += 1
print(kids)
print(*cnt)


x = int(input())
ans = []
i = 0
while x > i:
	i += 1
	x -= i
	ans.append(str(i))
ans[-1] = str(int(ans[-1]) + x)
print(len(ans))
print(' '.join(ans))


def max_candies(n):
	if n == 1 or n == 2:
		print(1)
		l = [n]
		return l
	l = []
	k = n
	for i in range(1, n + 1):
		if i == k - i or i > k - i:
			l.append(k)
			break
		else:
			l.append(i)
		k -= i
	print(len(l))
	return l
n = int(input())
result = max_candies(n)
print(*result, sep=' ')


n = int(input())
a = [0]
while n > 2 * (a[-1] + 1):
	n -= a[-1] + 1
	a.append(a[-1] + 1)
if n != 0:
	a.append(n)
a.remove(0)
print(len(a))
print(*a)


n = int(input())
i = int((-1 + (1 + 8 * n) ** 0.5) // 2)
print(i)
print(*range(1, i), n - sum(range(1, i)))


n = int(input())
k = 0
size = n
for i in range(1, size + 1):
	n -= i
	k += 1
	if n <= i:
		break
print(k)
L = size
for i in range(1, L + 1):
	if size - i <= i:
		print(size)
		break
	print(i, end=' ')
	size -= i


n = int(input())
i = 1
ans = []
while n >= i:
	ans.append(i)
	n -= i
	i = i + 1
ans[len(ans) - 1] = ans[len(ans) - 1] + n
print(len(ans))
print(' '.join((str(i) for i in ans)))


n = int(input())
amount = 0
numbers = []
x = 1
continue_while = True
while continue_while is True:
	if amount + x > n:
		continue_while = False
		continue
	numbers.append(x)
	amount += x
	x += 1
numbers[-1] += n - amount
print(len(numbers))
for i in range(len(numbers)):
	print(numbers[i], end=' ')


import math
n = int(input())
req_value = n * 2
k = int(math.sqrt(req_value))
while k * (k + 1) > req_value:
	k -= 1
print(k)
for i in range(k - 1):
	print(i + 1, end=' ')
ans = n - k * (k - 1) // 2
print(ans)


n = int(input())
i = 0
while int(i * (i + 1) / 2) <= n:
	i += 1
i -= 1
print(i)
a = []
for j in range(i - 1):
	print(j + 1, end=' ')
	a.append(j + 1)
print(n - sum(a))


import math
n = int(input())
x = math.floor((-1 + math.sqrt(1 + 8 * n)) / 2)
ans = [i for i in range(1, x)] + [n - x * (x - 1) // 2]
print(len(ans))
print(*ans)


n = int(input())
i = 1
while i * (i + 1) // 2 <= n:
	i += 1
i -= 1
l = [x for x in range(1, i)]
l.append(n - sum(l))
print(len(l))
print(*l)


n = int(input())
count = 0
total_so_far = 0
l = []
for i in range(1, n + 1):
	if total_so_far + i > n:
		l[-1] += n - total_so_far
		break
	else:
		count += 1
		l.append(i)
		total_so_far += i
print(count)
print(*l, sep=' ')


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


n = int(input())
t = 1
a = []
while n >= t:
	a.append(t)
	n -= t
	t = t + 1
a[-1] += n
print(len(a))
for i in range(len(a)):
	print(a[i], end=' ')


a = int(input())
b = int((2 * a) ** 0.5) + 1
lis = []
for i in range(1, b + 1):
	lis.append(i)
	if i * (i + 1) / 2 > a:
		print(i - 1)
		break
i = 0
lis = lis[:-1]
if sum(lis) < a:
	lis[-1] += a - sum(lis)
print(' '.join(map(str, lis)))


n = int(input())
result = [1]
step = 2
count = 3
while count <= n:
	result.append(step)
	step += 1
	count += step
result[-1] += n - count + step
print(len(result))
print(' '.join([str(x) for x in result]))


from math import sqrt
n = int(input())
d = 1 + 8 * n
z = int((-1 + sqrt(d)) // 2)
result = [i for i in range(1, z + 1)]
total_result = z * (z + 1) // 2
result[-1] += n - total_result
print(z)
print(*result, sep=' ')


n = int(input())
k = ((8 * n + 1) ** 0.5 - 1) / 2
k = int(k)
diff = n - k * (k + 1) // 2
print(k)
for i in range(1, k):
	print(i, end=' ')
print(k + diff)


a = int(input())
c = []
d = 0
for i in range(1, a + 1):
	c.append(i)
sum = 0
for j in range(a):
	if sum + c[j] > a:
		sum += c[j]
		d += 1
		break
	else:
		sum += c[j]
		d += 1
sum = 0
e = []
for i in range(d - 2):
	e.append(c[i])
	sum += c[i]
e.append(a - sum)
print(len(e))
print(*e)


n = int(input())
cache = []
i = 1
while i <= n:
	cache.append(i)
	n -= i
	i += 1
print(len(cache))
for i in range(len(cache)):
	if i == len(cache) - 1:
		print(cache[i] + n, end=' ')
	else:
		print(cache[i], end=' ')


n = int(input())
num = 1
sum1 = 0
diff = 0
lst = list()
while True:
	lst.append(num)
	sum1 += num
	diff = n - sum1
	if diff < num + 1:
		print(num)
		lst[-1] += diff
		print(*lst)
		break
	num += 1


import math
from sys import stdin

def find(n):
	sol = int((math.sqrt(8 * n + 1) - 1) / 2)
	print(sol)
	for i in range(1, sol):
		print(i, end=' ')
	print(int(n - sol * (sol - 1) / 2))
find(int(stdin.readline()))


n = int(input())
cur = 1
while n >= cur:
	n -= cur
	cur += 1
print(cur - 1)
for i in range(1, cur - 1):
	print(i, end=' ')
print(cur - 1 + n)


import sys

def giveCandies(candies):
	used = set()
	num = 1
	while candies > 0:
		used.add(num)
		if candies - num in used:
			used.remove(num)
			used.add(candies)
			candies = 0
		else:
			candies -= num
		num += 1
	print(len(used))
	for num in used:
		print(num, end=' ')

def main():
	candies = 0
	for line in sys.stdin:
		candies = int(line)
	giveCandies(candies)
main()


n = int(input())
i = 1
a = []
while n > i * 2:
	n -= i
	a.append(i)
	i += 1
a.append(n)
print(len(a))
print(' '.join(map(str, a)))


n = int(input())
count = 0
i = 1
arr = []
while n >= i:
	count += 1
	n -= i
	arr.append(i)
	i += 1
arr[-1] += n
print(len(arr))
print(*arr)


n = int(input())
i = 1
s = []
while i <= n:
	s.append(i)
	n -= i
	i += 1
s[-1] = s[-1] + n
print(i - 1)
print(*s)


n = int(input())
for i in range(1, n + 1):
	candies = i * (i + 1) / 2
	if candies > n:
		print(i - 1)
		last = n - (i - 1) * i // 2
		spread = []
		for j in range(1, i):
			if j == i - 1:
				spread.append(j + last)
			else:
				spread.append(j)
		print(*spread)
		break
	elif candies == n:
		print(i)
		print(*range(1, i + 1))
		break


n = int(input())
x = n
i = 1
while n >= i:
	n -= i
	i += 1
print(i - 1)
for j in range(1, i):
	if j == i - 1:
		print(x)
		break
	else:
		print(j, end=' ')
		x -= j


n = int(input())
i = 1
ans = []
while n >= i:
	n -= i
	ans.append(i)
	i += 1
	if n < i:
		ans[-1] = n + i - 1
		break
print(len(ans))
print(*ans)


n = int(input())
if n == 1 or n == 2:
	print(1)
	print(n)
	exit(0)
i = 1
lst = []
while i < n:
	lst.append(i)
	if sum(lst) > n:
		lst.remove(lst[-1])
		lst.remove(lst[-1])
		lst.append(n - sum(lst))
	i += 1
print(len(lst))
for k in lst:
	print(k, end=' ')


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
for i in range(1, 2000):
	if i * (i + 1) // 2 <= n:
		key = i
	else:
		print(key)
		d = [i for i in range(1, key + 1)]
		if key * (key + 1) // 2 != n:
			d[-1] += n - key * (key + 1) // 2
		print(*d)
		break


n = int(input())
res = []
s = 0
for i in range(1, 10000):
	if s + i < n:
		res.append(i)
		s += i
	else:
		el = n - s
		while el in res:
			s -= res[-1]
			res = res[:-1]
			el = n - s
		res.append(n - s)
		break
print(len(res))
print(' '.join(map(str, res)))


n = int(input())
i = 1
A = []
while True:
	x = n - i
	if x > i:
		A.append(i)
		n -= i
	else:
		A.append(n)
		break
	i += 1
print(len(A))
for k in range(len(A)):
	print(A[k], end=' ')


n = int(input())
a = [0]
for i in range(1, 100):
	a.append(i)
i = 1
k = 0
ans = []
while n > 0:
	if n >= a[i]:
		k += 1
		ans.append(a[i])
		n -= a[i]
	else:
		break
	i += 1
ans[-1] += n
print(k)
print(*ans)


n = int(input())
count = 0
res = []
k = 0
while k < n:
	k += 1
	n -= k
	res.append(k)
	count += 1
if n > 0:
	res[-1] += n
print(k)
print(*res)


n = int(input())
res = []
i = 1
while i <= n:
	res.append(i)
	n -= i
	i += 1
res[-1] += n if n < i else 0
print(len(res))
print(*res)


num = int(input())
a = [i for i in range(45)]
s = 1
idx = 1
while True:
	idx += 1
	if s + idx > num:
		n = idx - 1
		break
	s += idx
left = num - s
a[n] += left
print(n)
for i in range(1, n + 1):
	print(a[i], end=' ')
print()


n = int(input())
arr = []
sum_ = 0
for i in range(1, n + 1):
	sum_ += i
	if sum_ > n:
		break
	arr.append(i)
sum_ = sum(arr)
diff = n - sum_
arr[-1] += diff
assert sum(arr) == n
print(len(arr))
print(*arr)


import sys
start = int(sys.stdin.readline())
kids = 0
leftover = start
kid_list = []
while leftover > kids:
	kids += 1
	leftover -= kids
	kid_list.append(kids)
kid_list[kids - 1] += leftover
z = [str(item) for item in kid_list]
print(kids)
print(' '.join(z))


n = int(input())
a = [] * n
b = [0] * 1001
d = 0
e = 1
s = 0
while 1:
	if e > n:
		d = 1
		break
	a.append(e)
	s += 1
	n -= e
	e += 1
	if n == 0:
		break
if d == 1:
	f = a[s - 1] + n
	a[s - 1] = f
print(s)
for i in range(0, s):
	print(a[i], end=' ')


n = int(input())
ans = [0, 1]
for i in range(2, n + 1):
	t = ans[i - 1] * (ans[i - 1] + 1) // 2 + (ans[i - 1] + 1)
	if i < t:
		ans.append(ans[i - 1])
	else:
		ans.append(ans[i - 1] + 1)
k = ans[n]
print(k)
for i in range(1, k):
	print(i, end=' ')
print(n - k * (k - 1) // 2)


n = int(input())
a = [1]
n -= 1
while n > a[-1]:
	a.append(a[-1] + 1)
	n -= a[-1]
a[-1] += n
print(len(a))
for num in a:
	print(num, end=' ')


n = int(input())
out = []
base = 1
while n > 0:
	out.append(base)
	n -= base
	base += 1
	if n < base:
		out[-1] += n
		n = 0
print(len(out))
print(*out)


n = int(input())
r = 1
winners = []
while True:
	if n - r >= 0:
		n -= r
		winners.append(r)
		r += 1
	else:
		winners[-1] += n
		print(len(winners))
		print(*winners)
		break


from math import *
n = int(input())
x = (floor(sqrt(8 * n + 1)) - 1) // 2
print(x)
tot = 0
for i in range(x - 1):
	print(i + 1, end=' ')
	tot += i + 1
print(n - tot)


n = int(input())
sum = 0
j = 1
k = 0
while sum <= n:
	sum += j
	j += 1
	k += 1
sum -= j - 1
k -= 1
j -= 2
print(k)
if sum == n:
	for i in range(1, k + 1):
		print(i, end=' ')
	print(' ')
else:
	p = n - sum
	for i in range(1, k):
		print(i, end=' ')
	print(j + p)


n = int(input())
c = s = 0
z = []
for i in range(1, 1001):
	if i % 2 == 0:
		if s + i * 2 >= n:
			s += i
			i += n - s
			c += 1
			z.append(i)
			break
	elif i % 2 == 1:
		if s + i * 2 >= n:
			s += i
			i += n - s
			c += 1
			z.append(i)
			break
	z.append(i)
	s += i
	c += 1
print(c)
for j in z:
	print(j, end=' ')


def sol():
	n = int(input())
	dp = []
	s = 0
	i = 1
	while s + i + i + 1 <= n:
		s += i
		dp.append(i)
		i += 1
	dp.append(n - sum(dp))
	print(len(dp))
	print(*dp, sep=' ')
sol()


n = int(input())
count = 0
sum = 0
l = []
i = 1
while True:
	if sum + i <= n:
		sum += i
		l.append(i)
	else:
		l[-1] = l[-1] + n - sum
		break
	i += 1
print(i - 1)
print(*l)


n = int(input())
c = 1
sol = []
while n > c:
	n = n - c
	sol.append(c)
	c = c + 1
if n >= c:
	sol.append(n)
else:
	sol[-1] += n
print(len(sol))
print(*sol)


n = int(input())
num = n
i = 1
lst = []
while num > i:
	num -= i
	lst.append(i)
	i += 1
if num not in lst:
	lst.append(num)
else:
	lst[-1] += num
print(len(lst))
for i in lst:
	print(i, end=' ')
print()


n = int(input())
k = 1
while k * (k + 1) <= 2 * n:
	k += 1
k = k - 1
print(k)
for i in range(1, k):
	print(i, end=' ')
print(n - k * (k - 1) // 2)


def s(n):
	j = 1
	sm = 0
	counter = 0
	ans = []
	while sm + j <= n:
		ans.append(j)
		sm += j
		j += 1
		counter += 1
	if n - sm != 0:
		ans[-1] = n - sm + ans[-1]
	print(counter)
	for x in ans:
		print(str(x), end=' ')
	print()
n = int(input())
s(n)


n = int(input())
z = []
x = 1
while n >= x:
	z.append(x)
	n -= x
	x += 1
z[-1] += n
print(len(z))
print(*z)


n = int(input())
a = list()
a.append(0)
m = n
for i in range(1, n):
	if m - i >= 0:
		a.append(i)
		m -= i
	else:
		break
if m <= a[-1]:
	a[-1] += m
else:
	a.append(m)
print(len(a) - 1)
a.remove(0)
print(*a)


t = 1
for _ in range(t):
	n = int(input())
	for i in range(50):
		if i * (i + 1) // 2 > n:
			ans = i - 1
			break
	print(ans)
	for i in range(ans - 1):
		print(i + 1, end=' ')
	print(n - ans * (ans - 1) // 2)


n = int(input())
answer = [1]
i = 1
total = 1
while 1:
	next = i + 1
	if total + next > n:
		break
	i = next
	total += i
	answer.append(i)
last = len(answer) - 1
answer[last] += n - total
print(len(answer))
for a in answer:
	print(a, sep=' ', end=' ')


n = int(input())
i = 1
a = []
while i <= n:
	a.append(i)
	n -= i
	i += 1
a[-1] += n
print(len(a))
print(' '.join((str(x) for x in a)))


Answers = []
(All, i) = (int(input()), 1)
while All - i >= 0:
	Answers.append(i)
	All -= i
	i += 1
Answers[-1] += All
print(len(Answers))
print(*Answers)


def f(k):
	return k * (k + 1) // 2
n = int(input())
k = 1
while f(k) <= n:
	k += 1
k -= 1
print(k)
for i in range(1, k):
	print(i, end=' ')
print(n - f(k - 1))


a = int(input())
r = int((-1 + (1 + 8 * a) ** 0.5) // 2)
print(r)
extra = a - r * (r + 1) // 2
ans = [i for i in range(1, r + 1)]
ans[-1] += extra
print(*ans)


a = int(input())
flag = True
arr = [0 for i in range(50)]
acc = 0
i = 1
while flag == True:
	if acc + i <= a:
		arr[i - 1] = i
		acc += i
		i += 1
	else:
		arr[i - 2] += a - acc
		i -= 2
		flag = False
print(i + 1)
for j in range(0, i + 1):
	print(arr[j], end=' ')


def main():
	try:
		while True:
			t = n = int(input())
			result = 0
			i = 1
			while n >= i:
				n -= i
				i += 1
				result += 1
			print(result)
			for i in range(1, result):
				print(i, end=' ')
			print(t - sum(range(result)))
	except EOFError:
		pass
main()


n = int(input())
x = 1
while (x + 1) * (x + 2) // 2 <= n:
	x += 1
ans = [k for k in range(1, x)] if x > 1 else []
ans.append(n - sum(ans))
print(len(ans))
print(*ans)


n = int(input())
ls = []
if n > 1:
	for i in range(1, n):
		if n - i >= i + 1:
			ls.append(i)
			n -= i
		else:
			ls.append(n)
			print(len(ls))
			print(*ls)
			exit(0)
else:
	print(1)
	print(1)


n = int(input())
i = 0
a = []
while n - i > 0:
	i += 1
	a.append(i)
	n -= i
a[-1] += n
print(len(a))
for x in a:
	print(x, end=' ')


import math as m
n = int(input())
k = int(m.sqrt(8 * n + 1) - 1) // 2
print(k)
num = [i for i in range(1, k + 1)]
if sum(num) != n:
	num[-1] += n - sum(num)
print(' '.join(map(str, num)))


n = int(input())
k = 1
sol = []
while n > 0:
	if n > 2 * k:
		sol.append(k)
		n = n - k
		k += 1
	else:
		sol.append(n)
		n = 0
print(len(sol))
for it in sol:
	print(it, end=' ')


def f(n):
	k = 0
	tn = 2 * n
	while k * k < tn:
		k += 1
	k -= 1
	if n < (k + 1) * k // 2:
		k -= 1
	return k

def g(n, k):
	s = ''
	for i in range(1, k):
		s += str(i) + ' '
	s += str(n - k * (k - 1) // 2)
	return s

def run():
	i = 0
	for line in iter(input, ''):
		n = int(line)
		break
	k = f(n)
	print(k)
	print(g(n, k))
run()


n = int(input())
Mas = [0] + []
i = 1
while len(Mas) <= n:
	Mas += [i] * (i + 1)
	i += 1
Numb = [0] * Mas[-1]
for i in range(Mas[-1] - 1):
	Numb[i] = i + 1
Numb[-1] = n - sum(Numb)
print(Mas[-1])
print(*Numb)


def maxcandies(nn):
	final = []
	n = nn
	i = 1
	if n == 2:
		return [2]
	final.append(i)
	n = n - i
	i = i + 1
	while n > 0:
		if n / 2 > i:
			final.append(i)
			n = n - i
			i = i + 1
		else:
			final.append(n)
			break
	return final
n = int(input())
ans = maxcandies(n)
print(len(ans))
print(' '.join((str(i) for i in ans)))


def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = len(li) - 1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def mex(li):
	check = [0] * 1001
	for i in li:
		check[i] += 1
	for i in range(len(check)):
		if check[i] == 0:
			return i

def sumdigits(n):
	ans = 0
	while n != 0:
		ans += n % 10
		n //= 10
	return ans

def product(li):
	ans = 1
	for i in li:
		ans *= i
	return ans

def maxpower(n, k):
	cnt = 0
	while n > 1:
		cnt += 1
		n //= k
	return cnt

def knapsack(li, sumi, s, n, dp):
	if s == sumi // 2:
		return 1
	elif n == 0:
		return 0
	elif dp[n][s] != -1:
		return dp[n][s]
	else:
		if li[n - 1] <= s:
			dp[n][s] = knapsack(li, sumi, s - li[n - 1], n - 1, dp) or knapsack(li, sumi, s, n - 1, dp)
		else:
			dp[n][s] = knapsack(li, sumi, s, n - 1, dp)
		return dp[n][s]
from math import *
from collections import deque
max_steps = 100005
for _ in range(1):
	n = int(input())
	ans = 1
	for k in range(1, 50):
		if k * (k + 1) > 2 * n:
			ans = k
			break
	print(ans - 1)
	li = [x for x in range(1, ans)]
	li[-1] += n - sum(li)
	print(*li)


n = int(input().strip())
k = int(((8 * n + 1) ** 0.5 - 1) // 2)
s = ''
a = []
for i in range(k - 1):
	s += str(i + 1) + ' '
s += str(n - k * (k - 1) // 2)
print(k)
print(s)


n = int(input())
ans = list()
i = 1
while 1:
	if n < i:
		break
	n -= i
	ans.append(i)
	i += 1
ans[len(ans) - 1] += n
print(len(ans))
for i in ans:
	print(i, end=' ')


import sys

def main():
	n = int(sys.stdin.readline())
	if n == 2:
		print(1)
		print(2)
		return
	s = 0
	nums_used = []
	for i in range(1, n + 1):
		if s + i > n:
			diff = n - s
			nums_used.append(nums_used.pop() + diff)
			break
		elif s + i == n:
			nums_used.append(i)
			break
		nums_used.append(i)
		s += i
	print(len(nums_used))
	print(' '.join(map(str, nums_used)))
main()


from sys import *
n = int(input())
res = 0
i = 1
while i * (i + 1) <= 2 * n:
	i += 1
print(i - 1)
i = 1
while res + i + i + 1 <= n:
	stdout.write(str(i) + ' ')
	res += i
	i += 1
print(n - res)


n = int(input())
a = []
curr = 1
if n == 1:
	print(1)
	print(1)
else:
	while curr != n - curr and n - curr > 0:
		a.append(curr)
		n = n - curr
		curr += 1
	b = len(a)
	if n < curr:
		a[b - 1] = curr + n - 1
	else:
		a.append(n)
	print(len(a))
	print(*a)


def main():
	n = int(input())
	a = []
	for i in range(1, 1000):
		if i <= n:
			a.append(i)
			n -= i
		else:
			a[len(a) - 1] += n
			break
	print(len(a))
	for i in a:
		print('%d ' % i, end='')
	print()
main()


n = int(input())
ans = int((-1 + (1 + 8 * n) ** (1 / 2)) // 2)
ls = list(range(1, ans))
ls.append(n - ans * (ans - 1) // 2)
print(ans)
print(*ls)


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

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

	def In():
		return map(int, input().split())
else:

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

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def calc(n, i, x, cost):
	print(n, i, x, cost)
	if i >= n:
		return cost
	mi = 100000000.0
	for j in range(1, x + 1):
		mi = min(calc(n, i + j, x, cost + i * j), mi)
	return mi

def calc(n):
	return n * (n + 1) // 2

def main():
	try:
		n = I()
		for i in range(1, n + 2):
			if calc(i) > n:
				break
		i -= 1
		ans = [x + 1 for x in range(i)]
		temp = n - calc(i)
		ans[-1] += temp
		print(len(ans))
		print(*ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


n = int(input())
count = 0
a = []
summ = 0
for i in range(1, n + 1):
	summ += i
	if summ > n:
		break
	count += 1
	a.append(i)
if summ > n:
	a[-1] += n - summ + i
print(count)
print(' '.join(map(str, a)))


n = int(input())
a = [0] * (n + 1)
dic = {}
rest = n
next = 0
while rest > 0:
	next += 1
	if rest - next >= 0 and next not in dic:
		left = rest - next
		if left != next and left not in dic:
			dic[next] = 0
			rest = rest - next
print(len(dic))
for (p, v) in enumerate(dic):
	print(v, end=' ')
print()


import math

def solve(n):
	portions = []
	i = 1
	while n >= i:
		portions.append(i)
		n -= i
		i += 1
	portions[-1] += n
	return portions
n = int(input())
portions = solve(n)
print(len(portions))
print(' '.join(map(str, portions)))


n = int(input())
s = 0
current = 1
while s + current <= n:
	s += current
	current += 1
print(current - 1)
for i in range(1, current - 1):
	print(i, end=' ')
	n -= i
print(n)


n = int(input())
a = [0] * 50
i = 1
cnt = 0
while True:
	if n - i >= i + 1:
		a[i] = i
		cnt += 1
		n -= i
		i += 1
	else:
		a[i] = n
		cnt += 1
		break
print(cnt)
print(*a[1:cnt + 1])


n = int(input())
import math
if n == 1:
	print(1)
	print(1)
elif n == 2:
	print(1)
	print(2)
else:
	st = []
	i = 1
	x = 0
	while x < n:
		if x + i <= n:
			st.append(i)
			x += i
		elif x + i > n:
			x = x - st.pop()
			x += i
			st.append(i)
		i += 1
	print(len(st))
	print(*st, sep=' ')


n = int(input())
k = n
i = 1
s = ''
while n >= i:
	n -= i
	if i >= n:
		s += str(n + i) + ' '
		break
	else:
		s += str(i) + ' '
	i += 1
if k == 1:
	print(1)
	print(1)
else:
	print(i, s, sep='\n')


a = list((range(i * (i + 1) // 2, (i * i + i * 3 + 2) // 2) for i in range(1, 1001)))
b = int(input())
for i in range(1001):
	if b in a[i]:
		print(i + 1)
		print(' '.join((str(x) for x in list(range(1, i + 1)) + [b - i * (i + 1) // 2])))
		break


import math
num = int(input())
maxp = int((-1 + math.sqrt(1 + 8 * num)) / 2)
print(maxp)
for i in range(1, maxp):
	print(i, end=' ')
print(int(num - maxp * (maxp - 1) / 2))


n = int(input())
ans = 0
L = []
i = 1
while i <= n:
	ans += 1
	L.append(i)
	n -= i
	i += 1
L[-1] += n
print(ans)
print(*L)


def decomp(n):
	ans = []
	x = 1
	sum_ = 0
	while sum_ < n:
		if sum_ + x + x + 1 > n:
			k = n - sum_ - x
			x += k
			ans.append(x)
			return ans
		sum_ += x
		ans.append(x)
		x += 1
n = int(input())
ans = decomp(n)
print(len(ans))
print(' '.join(map(str, ans)))


def main():
	n = int(input())
	k = 1
	while (k + 1) * (k + 2) // 2 <= n:
		k += 1
	print(k)
	for i in range(k - 1):
		print(i + 1, end=' ')
	extra = n - k * (k + 1) // 2
	print(k + extra)
main()


n = int(input())
if n == 1:
	print(1)
	print(1)
elif n == 2:
	print(1)
	print(2)
else:
	t = []
	i = 1
	while i <= n:
		n -= i
		t.append(i)
		i += 1
	k = len(t)
	t[k - 1] += n
	print(k)
	for i in t:
		print(i, end=' ')