You are given an integer $D$. Find an integer sequence $A_1, A_2, \ldots, A_N$ such that the following conditions are satisfied:
- $1 \le N \le 10^5$
- $1 \le A_i \le 10^5$ for each valid $i$
- $\sum_{i=1}^N \sum_{j=i}^N \left( \mathrm{min}(A_i, A_{i+1}, \ldots, A_j) - \mathrm{GCD}(A_i, A_{i+1}, \ldots, A_j) \right) = D$
It can be proved that a solution always exists under the given constraints.
Note: $\mathrm{GCD}(B_1, B_2, \ldots, B_M)$ is the greatest integer which divides all the integers $B_1, B_2, \ldots, B_M$.

-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains a single integer $D$.

-----Output-----
For each test case, print two lines. The first of these lines should contain a single integer $N$. The second line should contain $N$ space-separated integers $A_1, A_2, \ldots, A_N$.
If there are multiple solutions, you may find any one of them.

-----Constraints-----
- $1 \le T \le 10$
- $0 \le D \le 10^9$

-----Example Input-----
4
2
5
200
13

-----Example Output-----
3
3 3 2 
5
2 8 5 1 10 
7
12 10 15 11 19 13 15
4
5 4 4 10

Starter code:

Solutions:
# cook your dish here
t=int(input())
for i in range(t):
 D=int(input())
 P=10**5-2
 ans=[]
 if(D==0):
  ans.append(1)
 while(D>0):
  P=min(P,D)
  ans.append(P+2);
  ans.append(P+1);
  ans.append(1);
  D=D-P;
 print(len(ans))
 print(*ans,sep=" ",end="\n")
   
 
  
  

for _ in range(int(input())):
 D = int(input())
 P = 10 ** 5 - 2
 a = []
 if D == 0:
  print("1")
  print("1")
 else:
  while D > 0:
   P = min(P, D)
   a.append(P + 1)
   a.append(P + 2)
   a.append(1)
   D = D - P
  print(len(a))
  print(*a)

from sys import stdin
I=stdin.readline
for _ in range(int(I())):
 d=int(I())
 seq=[]
 if d==0:
  print(1)
  print(1)
  continue
 n=d//(10**5-2)
 rem=d%(10**5-2)
 seq=[10**5,10**5-1,1]*n
 seq.extend([rem+2,rem+1,1])
 if len(seq)>100000:
  print(runtme)
 print(len(seq))
 for i in range(len(seq)):
  if 1>seq[i]>100000:
   print(runtime)
  print(seq[i],end=" ")

 print("")


# cook your dish here
t=int(input())
for i in range(t):
 D=int(input())
 P=10**5-2
 ans=[]
 if(D==0):
  ans.append(1)
 while(D>0):
  P=min(P,D)
  ans.append(P+2)
  ans.append(P+1)
  ans.append(1)
  D-=P
 print(len(ans))
 print(*ans,sep=" ")


# cook your dish here
for _ in range(int(input())):
 d = int(input())
 # print(2)
 # print(d+1,d+2)
 p2 = 10**5
 p1 = p2 - 1
 p = p2 - 2
 
 div = d//p
 arr = []
 for i in range(div):
  arr.append(p1)
  arr.append(p2)
  arr.append(1)
 
 rem = d%p
 
 arr.append(rem+1)
 arr.append(rem+2)
 arr.append(1)
 print(len(arr))
 print(*arr)

for _ in range(int(input())):
 n=int(input())
 a=n//99998
 b=n%99998
 print(3*(a+1))
 print(f'1 99999 100000 '*a + f'1 {b+1} {b+2}')


# cook your dish here
def solve(d):
 op=[]
 p=(10**5)-2
 if d>0:
  while d>0:
   p=min(d,p)
   op.append(p+1)
   op.append(p+2)
   op.append(1)
   d= d-p
 else:
   op.append(d+1)
   op.append(d+2)
 print(len(op))
 print(*op)
def __starting_point():
 for test in range(int (input())):
  d=int(input())
  solve(d)
__starting_point()

# cook your dish here
def solve(d):
 op=[]
 p=(10**5)-2
 if(d>0):
  while d>0:
   p=min(d,p)
   op.append(p+1)
   op.append(p+2)
   op.append(1)
   d= d-p
 else:
  op.append(1)
 print(len(op))
 print(*op)
t=int(input())
for i in range(t):
 d=int(input())
 solve(d)

#dt = {} for i in x: dt[i] = dt.get(i,0)+1
import sys;input = sys.stdin.readline
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]

for _ in range(inp()):
 n = inp()
 ans = []
 t = 10**5 -2
 for i in range(n//t):
  ans.extend([t+2,t+1,1])
 n = n%t
 ans.extend([n+2,n+1,1])
 print(len(ans))
 print(*ans)