On the well-known testing system MathForces, a draw of $n$ rating units is arranged. The rating will be distributed according to the following algorithm: if $k$ participants take part in this event, then the $n$ rating is evenly distributed between them and rounded to the nearest lower integer, At the end of the drawing, an unused rating may remain — it is not given to any of the participants.

For example, if $n = 5$ and $k = 3$, then each participant will recieve an $1$ rating unit, and also $2$ rating units will remain unused. If $n = 5$, and $k = 6$, then none of the participants will increase their rating.

Vasya participates in this rating draw but does not have information on the total number of participants in this event. Therefore, he wants to know what different values of the rating increment are possible to get as a result of this draw and asks you for help.

For example, if $n=5$, then the answer is equal to the sequence $0, 1, 2, 5$. Each of the sequence values (and only them) can be obtained as $\lfloor n/k \rfloor$ for some positive integer $k$ (where $\lfloor x \rfloor$ is the value of $x$ rounded down): $0 = \lfloor 5/7 \rfloor$, $1 = \lfloor 5/5 \rfloor$, $2 = \lfloor 5/2 \rfloor$, $5 = \lfloor 5/1 \rfloor$.

Write a program that, for a given $n$, finds a sequence of all possible rating increments.


-----Input-----

The first line contains integer number $t$ ($1 \le t \le 10$) — the number of test cases in the input. Then $t$ test cases follow.

Each line contains an integer $n$ ($1 \le n \le 10^9$) — the total number of the rating units being drawn.


-----Output-----

Output the answers for each of $t$ test cases. Each answer should be contained in two lines.

In the first line print a single integer $m$ — the number of different rating increment values that Vasya can get.

In the following line print $m$ integers in ascending order — the values of possible rating increments.


-----Example-----
Input
4
5
11
1
3

Output
4
0 1 2 5 
6
0 1 2 3 5 11 
2
0 1 
3
0 1 3

Difficulty: interview

Starter code:

Solutions:
tst = int(input())
for i in range(0, tst):
    n = int(input())
    ans = 1
    l = 1
    p = []
    while l <= n:
        ans += 1
        l = n // (n // l)
        p.append(n // l)
        l += 1
    p.append(0)
    p.reverse()
    print(len(p))
    print(" ".join(str(x) for x in p))

t = int(input())

for _ in range(t):
    n = int(input())

    l = [n]
    test = 2
    while n//test != l[-1]:
        l.append(n//test)
        test += 1

    while l[-1] != 0:
        l.append(l[-1] - 1)
        
    print(len(l))
    print(' '.join(map(str,l[::-1])))


for _ in range(int(input())):
    n = int(input())
    d = 1
    res = [0]
    while d <= n:
        e = n // d
        res.append(e)
        d = (n // e) + 1
    print(len(res))
    print(*sorted(res))

t = int(input())
for _ in range(t):
    n = int(input())
    set_ = set()
    for i in range(1, int(n**0.5)+10):
        set_.add(n // i)
    li = sorted(list(set_))
    num = li[0]
    li2 = [i for i in range(num)]
    print(len(li2) + len(li))
    print(*li2 + li)

t=int(input())
for _ in range(t):
    n=int(input())
    aa=[]
    ind=1
    while True:
        aa.append(n//ind)
        if len(aa)>=2:
            if aa[-1]==aa[-2]:
                for i in range(aa[-1],-1,-1):
                    aa.append(i)
                break
        ind+=1
    print(len(set(aa)))
    print(*sorted(list(set(aa))))
    


import sys
input = sys.stdin.readline

t=int(input())
for testcases in range(t):
    n=int(input())

    ANS=[n//1]

    for i in range(2,n):
        ANS.append(n//i)

        if n/(i-1)-n/i<1:
            break

    A=list(range(0,ANS[-1]))+sorted(set(ANS))

    print(len(A))
    print(*A)


def kek(n):
	l = [0]
	l2 = []
	i = 1
	while i * i < n:
		l.append(i)
		if n // i != i:
			l2.append(n // i)
		i += 1
	if i * i == n:
		l.append(i)
	l2.reverse()
	l += l2
	return l

def main():
	for _ in range(int(input())):
		n = int(input())
		l = kek(n)
		print(len(l))
		for i in l:
			print(i, end=' ')
		print()
main()

for _ in range(int(input())):
	n=int(input())
	if n<=1000005:
		l=[0,1]
		for k in range(n-1,0,-1):
			a=n//k
			if a>l[-1]:
				l.append(a)
		print(len(l))
		print(*l)
	else:
		l=[x for x in range(1001)]
		for k in range(1000000,0,-1):
			a=n//k
			if a>l[-1]:
				l.append(a)
		print(len(l))
		print(*l)

q = int(input())
for ifwfwe in range(q):
	n = int(input())
	i = 1
	odp = [0]
	while i*i <= n:
		odp.append(i)
		i += 1
	while i > 0:
		if n // i > odp[-1]:
			odp.append(n//i)
		i -= 1
	print(len(odp))
	print(*odp)

def solve():
    n = int(input())
    s = set()
    s.add(0)
    for i in range(1, int(n**0.5)+1):
        k = n//i
        s.add(k)
        s.add(i)
    ans = sorted(s)
    print(len(ans))
    print(*ans)

t = int(input())
for i in range(t):
    solve()

#603_C

t = int(input())

for i in range(0, t):
    n = int(input())
    ln = [0]
    oned = False
    sqt = n // int(n ** 0.5)
    on = -1
    for j in range(1, max(2, int(n ** 0.5) + 1)):
        if n // j != on:
            ln.append(n // j)
            if n // j == 1:
                oned = True
        on = n // j
    for j in range(len(ln) - 1, 0, -1):
        if n // ln[j] == sqt:
            continue
        ln.append(n // ln[j])
        if n // ln[j] == 1:
            oned = True
    if not oned:
        ln.append(1)
    print(len(ln))
    print(" ".join([str(j) for j in sorted(ln)]))


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

for _ in range( int(I()) ):
    n = int(I())
    a = [ 0, 1 ]
    i = n
    while i > 0:
        if n // i > a[ -1 ]:
            a.append( n // i )
        i = n // ( a[ -1 ] + 1 )
    print( len( a ) )
    print( *a )


import math
t = int(input())
for i in range (t):
    n = int(input())
    m = math.floor(math.sqrt(n))
    ans = [j for j in range (m + 1)]
    left = m
    while m > 0:
        k = n//m
        if left == k:
            m -= 1
            continue
        ans.append(k)
        left = k
        m -= 1
    print(len(ans))
    print(*ans, sep = " ")

t = int(input())

for _ in range(t):
	n = int(input())
	s = set.union({0}, *({i, n//i} for i in range(1, int(n**.5)+1)))
	print(len(s))
	for v in sorted(s):
		print(v, end=" ")
	print()

for _ in range(int(input())):
	n = int(input())

	ans = {0}

	for i in range(1, int(n ** 0.5 + 1)):
		ans.add(n // i)
		ans.add(n // (n // i))

	print(len(ans))
	print(*sorted(ans))

from math import sqrt
t=int(input())
for _ in range(t):
	n=int(input())
	ans=set()
	ans.add(0)
	root=int(sqrt(n))
	for x in range(1,root+1):
		ans.add(x)
		ans.add(n//x)
	print(len(ans))
	ans=sorted(ans)
	for x in ans:
		print(x,end=' ')
	print()

# from fractions import gcd
# from datetime import date, timedelta
# from heapq import*
# import math
# from collections import defaultdict, Counter, deque
# import sys
# from bisect import *
# import itertools
# import copy
# sys.setrecursionlimit(10 ** 7)
# MOD = 10 ** 9 + 7





def main():
    t = int(input())
    for _ in range(t):
        n = int(input())
        prev = -1
        ans = []
        for i in range(1,40000):
            v = n//i
            if v == prev:
                break
            ans.append(v)
            prev = v
        for i in range(v-1, -1, -1):
            ans.append(i)
        print(len(ans))
        print(*ans[::-1])





    


def __starting_point():
    main()

__starting_point()

3

import os
import sys


def main():
    T = read_int()
    for _ in range(T):
        ans = solve(read_int())
        print(len(ans))
        print(*ans)


def solve(N):
    ans = [N]
    i = 2
    while i * (i - 1) <= N:
        v = N // i
        if ans[-1] != v:
            ans.append(v)
        i += 1

    v = ans[-1]
    for i in range(v - 1, -1, -1):
        ans.append(i)
    ans.reverse()
    return ans


###############################################################################

DEBUG = 'DEBUG' in os.environ


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


def read_int():
    return int(inp())


def read_ints():
    return [int(e) for e in inp().split()]


def dprint(*value, sep=' ', end='\n'):
    if DEBUG:
        print(*value, sep=sep, end=end)


def __starting_point():
    main()

__starting_point()

# from sys import stdin
# def rl():
#     return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import sys
# input = sys.stdin.readline

# t = int(input())
#
# for _ in range(t):
#     a,b,c = map(int,input().split())
#     a,b,c = sorted([a,b,c])
#     ans = 0
#     ans+=b
#     c-=b
#
#     a,c = sorted([a,c])
#     ans+=a
#     print(ans)


# print(ans)




t = int(input())

for _ in range(t):

    n = int(input())

    ans = [1,0]

    for i in range(1,int(sqrt(n)+1)):
        ans.append(n//i)
        ans.append(n//(n//i))

    ans = list(set(ans))
    print(len(ans))
    ans.sort()
    print(*ans)






import sys


# inf = open('input.txt', 'r')
# reader = (int(line.rstrip()) for line in inf)
reader = (int(s.rstrip()) for s in sys.stdin)

def rating(n):
    m = n
    ans = [0, 1]
    ndiv = 2
    while True:
        brick = n // ndiv
        if not brick:
            break
        ndiv = n // brick
        ans.append(ndiv)
        ndiv += 1
    return ans

t = next(reader)
for _ in range(t):
    n = next(reader)
    ans = rating(n)
    sys.stdout.write(str(len(ans)) + '\n')
    sys.stdout.write(' '.join(map(str, ans)) + '\n')
    
# inf.close()


import math
t = int(input())
for _ in range(t):
    n = int(input())
    divisors = set(n // i for i in range(1, int(math.sqrt(n))+1))
    for d in divisors.copy():
        divisors.add(n // d)
    divisors.add(0)

    print(len(divisors))
    print(*sorted(divisors))


'''input
4
5
11
1
3
'''
from sys import stdin, stdout


from collections import defaultdict, deque

# main starts 
t = int(stdin.readline().strip())
for _ in range(t):
	n = int(stdin.readline().strip())
	ans = set()
	for i in range(1, int(n ** 0.5) + 1):
		ans.add(i)
		ans.add(n//i)

	ans.add(0)
	ans.add(1)
	ans.add(n)
	ans = list(ans)
	ans.sort()
	print(len(ans))
	print(*ans)


sp = lambda: list(map(int, input().split()))
si = lambda: int(input())

TESTCASES = int(input())
for tc in range(TESTCASES):
    n=si()
    ints = set(range(int(n**0.5)+1))
    for i in range(int(n**0.5)+1,0,-1):
        ints.add(n//i)
    ints=sorted(list(ints))
    print(len(ints))
    print(" ".join(map(str,ints)))


for i in range(int(input())):
	n = int(input())
	b = [i for i in range(1, int(n**(1/2) + 1))]
	r = [str(m) for m in sorted(list(set(b + [n//i for i in b])))]
	print(len(r) + 1)
	print(0, ' '.join([str(m) for m in sorted(list(set(b + [n//i for i in b])))]))