Given a positive integer m, we say that a sequence x_1, x_2, ..., x_n of positive integers is m-cute if for every index i such that 2 ≤ i ≤ n it holds that x_i = x_{i - 1} + x_{i - 2} + ... + x_1 + r_i for some positive integer r_i satisfying 1 ≤ r_i ≤ m.

You will be given q queries consisting of three positive integers a, b and m. For each query you must determine whether or not there exists an m-cute sequence whose first term is a and whose last term is b. If such a sequence exists, you must additionally find an example of it.

Input

The first line contains an integer number q (1 ≤ q ≤ 10^3) — the number of queries.

Each of the following q lines contains three integers a, b, and m (1 ≤ a, b, m ≤ 10^{14}, a ≤ b), describing a single query.

Output

For each query, if no m-cute sequence whose first term is a and whose last term is b exists, print -1.

Otherwise print an integer k (1 ≤ k ≤ 50), followed by k integers x_1, x_2, ..., x_k (1 ≤ x_i ≤ 10^{14}). These integers must satisfy x_1 = a, x_k = b, and that the sequence x_1, x_2, ..., x_k is m-cute.

It can be shown that under the problem constraints, for each query either no m-cute sequence exists, or there exists one with at most 50 terms.

If there are multiple possible sequences, you may print any of them.

Example

Input


2
5 26 2
3 9 1


Output


4 5 6 13 26
-1

Note

Consider the sample. In the first query, the sequence 5, 6, 13, 26 is valid since 6 = 5 + \bf{\color{blue} 1}, 13 = 6 + 5 + {\bf\color{blue} 2} and 26 = 13 + 6 + 5 + {\bf\color{blue} 2} have the bold values all between 1 and 2, so the sequence is 2-cute. Other valid sequences, such as 5, 7, 13, 26 are also accepted.

In the second query, the only possible 1-cute sequence starting at 3 is 3, 4, 8, 16, ..., which does not contain 9.
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.lang.invoke.MethodHandles;
import java.math.BigInteger;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Random;
import java.util.TreeSet;

public final class CF_561_D2_D
{


	static boolean verb=true;
	static void log(Object X){if (verb) System.err.println(X);}
	static void log(Object[] X){if (verb) {for (Object U:X) System.err.print(U+" ");System.err.println("");}}
	static void log(int[] X){if (verb) {for (int U:X) System.err.print(U+" ");System.err.println("");}}
	static void log(int[] X,int L){if (verb) {for (int i=0;i<L;i++) System.err.print(X[i]+" ");System.err.println("");}}
	static void log(long[] X){if (verb) {for (long U:X) System.err.print(U+" ");System.err.println("");}}

	static void logWln(Object X){if (verb) System.err.print(X);}
	static void info(Object o){	System.out.println(o);}
	static void output(Object o){outputWln(""+o+"\n");	}
	static void outputWln(Object o){try {out.write(""+ o);} catch (Exception e) {}}

	static long mod=1000000007;

	// Global vars
	static BufferedWriter out;
	static InputReader reader;





	static void test() {
		log("testing");
		int NTESTS=10000;
		int AMAX=10;
		int KMAX=20;
		int MMAX=2;
		Random r=new Random();
		for (int t=0;t<NTESTS;t++) {
			
			long a=r.nextInt(AMAX)+1;
			int k=r.nextInt(KMAX)+1;
			int m=1+r.nextInt(MMAX);
			long cur=a;
			long sum=a;
			ArrayList<Long> seq=new ArrayList<Long>();
			seq.add(a);
			for (int i=1;i<k;i++) {
				cur=sum+1+r.nextInt(m);
				sum+=cur;
				seq.add(cur);
			}
			long b=cur;
			long[] ans=canFind(a,b,m);
			if (ans==null) {
				log("error");
				log(a+" "+b+" "+m);
				log(seq);
				return;
			}
		}
		

		log("done");
	}

	
	static boolean dontgo=false;
	
	static long[] canFind(long a,long b,long m,int k) {
		dontgo=false;
		//log("================trying k:"+k);
		long bb=b;
		
		long mox=1L<<(k-2);
		if (b/a<mox)
		{
			dontgo=true;
			//log("basic negative bb");
			return null;
		
		}
		//log("mox*a:"+(mox*a));
			bb=b-mox*a;
		//log("residual bb:"+bb);
	
		long[] r=new long[k];
		//log("bb:"+bb);
		r[0]=0;
		for (int i=1;i<k;i++) {
			r[i]=1;
			int u=k-i-2;
			if (u<0)
				u=0;
			long coef=1L<<u;
			bb-=coef;
			//logWln(coef+" ");
		}
		//log("");
		if (bb<0)  {
			//log("negative bb");
			return null;
		}
		//log("new resdiual bb:"+bb);
		m--;
		
		for (int i=1;i<k;i++) {
			int u=k-i-2;
			if (u<0)
				u=0;
			long coef=1L<<u;
			long d=bb/coef;
			
			if (d>=m)
				d=m;
			//logWln(d+" ");
			r[i]+=d;
			bb-=d*coef;
		}
		//log("");
		
		if (bb>0) {
			//log("still have bb !! :"+bb);
			return null;
		
		}
		return r;
	}
	
	
	
	static long[] canFind(long a,long b,long m) { 
		if (a==b)
			return new long[] {a};
		if (a>b)
			return null;
		for (int k=2;k<=50;k++) {
			long[] tm=canFind(a,b,m,k);
			if (tm!=null)
				return tm;
			if (dontgo)
				break;
		}
		return null;
	}
	
	static void solve(long a,long b,long m) {
		long[] tm=canFind(a,b,m);
		if (tm==null) {
			output("-1");
			return;
		}
		int k=tm.length;
		long cur=a;
		long sum=a;
		//log(tm);
		outputWln(tm.length+" ");
		for (int i=0;i<k;i++) {
			outputWln(cur+" ");
			if (i+1<k) {
				cur=sum+tm[i+1];
				sum+=cur;
				//log("cur:"+cur+" sum:"+sum);
			}
		}
		output("");
	}


	static void process() throws Exception {

		out = new BufferedWriter(new OutputStreamWriter(System.out));
		reader = new InputReader(System.in);

		
		//test();
		int Q=reader.readInt();
		for (int i=0;i<Q;i++) {
			long a=reader.readLong();
			long b=reader.readLong();
			long m=reader.readLong();
			solve(a,b,m);
		}
			
		try {
			out.close();
		} catch (Exception e) {
		}

	}

	public static void main(String[] args) throws Exception {
		process();

	}

	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		private int read() throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read(buf);
				if (numChars <= 0) {
					return -1;
				}
			}
			return buf[curChar++];
		}

		public final String readString() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final int readInt() throws IOException {
			int c = read();
			boolean neg = false;
			while (isSpaceChar(c)) {
				c = read();
			}
			char d = (char) c;
			// log("d:"+d);
			if (d == '-') {
				neg = true;
				c = read();
			}
			int res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			// log("res:"+res);
			if (neg)
				return -res;
			return res;

		}

		public final long readLong() throws IOException {
			int c = read();
			boolean neg = false;
			while (isSpaceChar(c)) {
				c = read();
			}
			char d = (char) c;
			// log("d:"+d);
			if (d == '-') {
				neg = true;
				c = read();
			}
			long res = 0;
			do {
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			// log("res:"+res);
			if (neg)
				return -res;
			return res;

		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

}