Problem: 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.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
namespace _Template_ {
struct cww {
  cww() {
    if (1) {
      ios::sync_with_stdio(false);
      cin.tie(0);
    }
  }
} star;
template <typename T>
inline bool chmin(T& l, T r) {
  bool a = l > r;
  if (a) l = r;
  return a;
}
template <typename T>
inline bool chmax(T& l, T r) {
  bool a = l < r;
  if (a) l = r;
  return a;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
  for (auto& it : v) is >> it;
  return is;
}
class reverse_range {
 private:
  struct I {
    int x;
    int operator*() { return x - 1; }
    bool operator!=(I& lhs) { return x > lhs.x; }
    void operator++() { --x; }
  };
  I i, n;

 public:
  reverse_range(int n) : i({0}), n({n}) {}
  reverse_range(int i, int n) : i({i}), n({n}) {}
  I& begin() { return n; }
  I& end() { return i; }
};
class range {
 private:
  struct I {
    int x;
    int operator*() { return x; }
    bool operator!=(I& lhs) { return x < lhs.x; }
    void operator++() { ++x; }
  };
  I i, n;

 public:
  range(int n) : i({0}), n({n}) {}
  range(int i, int n) : i({i}), n({n}) {}
  I& begin() { return i; }
  I& end() { return n; }
  reverse_range operator!() { return reverse_range(*i, *n); }
};
template <typename T>
inline T& unused_var(T& v) {
  return v;
}
using LL = long long;
}  // namespace _Template_
using namespace _Template_;
LL a, b, m;
LL C[64];
void CI() {
  C[0] = 1;
  C[1] = 1;
  for (int i : range(2, 64)) C[i] = C[i - 1] * 2;
}
constexpr LL INF = 1e18;
LL r[64];
bool solve_k(int k) {
  LL rest = b;
  double rest_d = b;
  for (int i : !range(k - 1)) {
    rest -= C[i] * 1;
    rest_d -= C[i] * 1.0;
    r[k - 1 - i] = 1;
  }
  rest -= C[k - 1] * a;
  rest_d -= C[k - 1] * (double)a;
  r[0] = a;
  for (int i : !range(k - 1)) {
    if (rest_d < -INF) return false;
    LL rc = rest / C[i];
    chmin(rc, m - 1);
    chmax(rc, 0ll);
    rest -= C[i] * rc;
    rest_d -= C[i] * rc;
    r[k - 1 - i] += rc;
    if (rest_d < -INF) return false;
  }
  if (rest == 0) {
    string sp(k + 1, ' ');
    sp.back() = '\n';
    cout << k << " ";
    for (int i : range(1, k + 1)) {
      LL x = 0;
      for (int j : range(i)) {
        x += r[j] * C[i - 1 - j];
      }
      cout << x << sp[i];
    }
    return true;
  } else {
    return false;
  }
}
void solve() {
  cin >> a >> b >> m;
  for (int k : range(1, 51)) {
    if (solve_k(k)) {
      return;
    }
  }
  cout << -1 << endl;
  return;
}
int main() {
  CI();
  int q;
  cin >> q;
  for (int qi : range(q)) {
    unused_var(qi);
    solve();
  }
  return 0;
}