#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
unordered_map<char, pair<long long, long long> > dir;
long long D = 1e9;
bool check(int x, int y, int n, int m) {
  return x >= 0 && y >= 0 && x < n && y < m;
}
int fun() {
  static int num = 16;
  return num--;
}
long long exp(long long a, long long p, long long m) {
  if (p == 0) return 1LL;
  if (p == 1) return a;
  long long h = exp(a, p / 2, m);
  h = (h * h) % m;
  if (p & 1) h = (h * a) % m;
  return h;
}
int find_parent(long long a, vector<long long> &dsu) {
  while (a != dsu[a]) {
    a = dsu[dsu[a]];
  }
  return a;
}
void join(long long a, long long b, vector<long long> &dsu,
          vector<long long> &si) {
  long long pa = find_parent(a, dsu);
  long long push_back = find_parent(b, dsu);
  if (pa != push_back) {
    if (si[pa] > si[push_back]) {
      dsu[push_back] = pa;
      si[pa] += si[push_back];
    } else {
      dsu[pa] = push_back;
      si[push_back] += si[pa];
    }
  }
}
long long cal(long long h) {
  long long mn = LLONG_MAX, mx = LLONG_MIN;
  while (h) {
    long long r = h % 10;
    mn = min(r, mn);
    mx = max(r, mx);
    h /= 10;
  }
  return mn * mx;
}
void anon_sort(long long u, string &ans, vector<long long> &mark,
               int arr[][26]) {
  mark[u] = 1;
  for (long long i = 0; i < 26; i++) {
    if (arr[u][i] && mark[i] == 0) anon_sort(i, ans, mark, arr);
  }
  ans.push_back(u + 'A');
}
double find_entroypy(vector<double> p) {
  double n = 0;
  for (auto i : p) n += i;
  double ans = 0;
  double e = 0.940;
  for (auto i : p) {
    double k = (i / n);
    k = k * (log2(k));
    k *= -1;
    e -= k * (n / 14.0);
    cout << k << " ";
    ans += k;
  }
  cout << endl;
  return ans;
}
double in_gain(vector<double> f, vector<double> en) {
  double t = 0.970951;
  double n = 5;
  for (long long i = 0; i < f.size(); i++) {
    double r = (f[i] / n) * en[i];
    t -= r;
    cout << r << " ";
  }
  cout << endl;
  return t;
}
double find_tmp(long long h, long long c, long long n) {
  long long w1 = n / 2;
  long long w2 = w1 + 1;
  return (h * w2 + c * w1) / (n * 1.0);
}
void construct(vector<long long> &tree, long long s, long long e,
               vector<long long> &arr, long long p) {
  if (s == e) {
    tree[p] = arr[s];
    return;
  } else if (s < e) {
    long long mid = s + (e - s) / 2;
    construct(tree, s, mid, arr, 2 * p + 1);
    construct(tree, mid + 1, e, arr, 2 * p + 2);
    tree[p] = max(tree[2 * p + 1], tree[2 * p + 2]);
  }
}
long long max_sub(vector<long long> &tree, long long s, long long e,
                  long long l, long long u, long long p) {
  if (e < l || u < s) return 0;
  if (s <= l && u <= e) return tree[p];
  long long mid = l + (u - l) / 2;
  return max(max_sub(tree, s, e, l, mid, 2 * p + 1),
             max_sub(tree, s, e, mid + 1, u, 2 * p + 2));
}
long long find(vector<long long> arr[26], char ch, long long s, long long e,
               string &str) {
  long long w = (e - s + 1);
  int pos = ch - 'a';
  if (w == 1) {
    if (ch != str[e - 1])
      return 1;
    else
      return 0;
  } else {
    w /= 2;
    long long s1 = s, s2 = s1 + w;
    long long e1 = s2 - 1, e2 = e;
    long long c1 = w - (arr[pos][e1] - arr[pos][s1 - 1]);
    long long c2 = w - (arr[pos][e2] - arr[pos][s2 - 1]);
    c1 += find(arr, ch + 1, s2, e2, str);
    c2 += find(arr, ch + 1, s1, e1, str);
    return min(c1, c2);
  }
}
bool assure(long long a, long long b, long long c, long long l, long long r) {
  return (a >= l && b >= l && c >= l && a <= r && b <= r && c <= r);
}
int main() {
  ios_base::sync_with_stdio(false);
  long long t;
  cin >> t;
  while (t--) {
    long long l, r, m;
    cin >> l >> r >> m;
    long long d = r - l;
    for (long long i = l; i <= r; i++) {
      long long a = i;
      long long b, c;
      long long lo = m - (r - l);
      long long up = m + (r - l);
      long long st = lo - (lo % a) + a;
      if (lo % a == 0) st = lo;
      int f = 0;
      while (st <= up) {
        long long n = st / a;
        long long rem = m - st;
        if (rem > 0) {
          b = l + rem;
          c = l;
        } else {
          b = l;
          c = l + abs(rem);
        }
        st += a;
        long long k = (m - b + c) / a;
        if (k > 0 && assure(a, b, c, l, r) && a * k + b - c == m) {
          f++;
          cout << a << " " << b << " " << c << endl;
          break;
        }
      }
      if (f > 0) break;
    }
  }
}

### Prompt

Please formulate a cpp solution to the following problem:

Pasha loves to send strictly positive integers to his friends. Pasha cares about security, therefore when he wants to send an integer n, he encrypts it in the following way: he picks three integers a, b and c such that l ≤ a,b,c ≤ r, and then he computes the encrypted value m = n ⋅ a + b - c.

Unfortunately, an adversary intercepted the values l, r and m. Is it possible to recover the original values of a, b and c from this information? More formally, you are asked to find any values of a, b and c such that

  * a, b and c are integers, 
  * l ≤ a, b, c ≤ r, 
  * there exists a strictly positive integer n, such that n ⋅ a + b - c = m. 

Input

The first line contains the only integer t (1 ≤ t ≤ 20) — the number of test cases. The following t lines describe one test case each.

Each test case consists of three integers l, r and m (1 ≤ l ≤ r ≤ 500 000, 1 ≤ m ≤ 10^{10}). The numbers are such that the answer to the problem exists.

Output

For each test case output three integers a, b and c such that, l ≤ a, b, c ≤ r and there exists a strictly positive integer n such that n ⋅ a + b - c = m. It is guaranteed that there is at least one possible solution, and you can output any possible combination if there are multiple solutions.

Example

Input


2
4 6 13
2 3 1


Output


4 6 5
2 2 3

Note

In the first example n = 3 is possible, then n ⋅ 4 + 6 - 5 = 13 = m. Other possible solutions include: a = 4, b = 5, c = 4 (when n = 3); a = 5, b = 4, c = 6 (when n = 3); a = 6, b = 6, c = 5 (when n = 2); a = 6, b = 5, c = 4 (when n = 2).

In the second example the only possible case is n = 1: in this case n ⋅ 2 + 2 - 3 = 1 = m. Note that, n = 0 is not possible, since in that case n is not a strictly positive integer.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
unordered_map<char, pair<long long, long long> > dir;
long long D = 1e9;
bool check(int x, int y, int n, int m) {
  return x >= 0 && y >= 0 && x < n && y < m;
}
int fun() {
  static int num = 16;
  return num--;
}
long long exp(long long a, long long p, long long m) {
  if (p == 0) return 1LL;
  if (p == 1) return a;
  long long h = exp(a, p / 2, m);
  h = (h * h) % m;
  if (p & 1) h = (h * a) % m;
  return h;
}
int find_parent(long long a, vector<long long> &dsu) {
  while (a != dsu[a]) {
    a = dsu[dsu[a]];
  }
  return a;
}
void join(long long a, long long b, vector<long long> &dsu,
          vector<long long> &si) {
  long long pa = find_parent(a, dsu);
  long long push_back = find_parent(b, dsu);
  if (pa != push_back) {
    if (si[pa] > si[push_back]) {
      dsu[push_back] = pa;
      si[pa] += si[push_back];
    } else {
      dsu[pa] = push_back;
      si[push_back] += si[pa];
    }
  }
}
long long cal(long long h) {
  long long mn = LLONG_MAX, mx = LLONG_MIN;
  while (h) {
    long long r = h % 10;
    mn = min(r, mn);
    mx = max(r, mx);
    h /= 10;
  }
  return mn * mx;
}
void anon_sort(long long u, string &ans, vector<long long> &mark,
               int arr[][26]) {
  mark[u] = 1;
  for (long long i = 0; i < 26; i++) {
    if (arr[u][i] && mark[i] == 0) anon_sort(i, ans, mark, arr);
  }
  ans.push_back(u + 'A');
}
double find_entroypy(vector<double> p) {
  double n = 0;
  for (auto i : p) n += i;
  double ans = 0;
  double e = 0.940;
  for (auto i : p) {
    double k = (i / n);
    k = k * (log2(k));
    k *= -1;
    e -= k * (n / 14.0);
    cout << k << " ";
    ans += k;
  }
  cout << endl;
  return ans;
}
double in_gain(vector<double> f, vector<double> en) {
  double t = 0.970951;
  double n = 5;
  for (long long i = 0; i < f.size(); i++) {
    double r = (f[i] / n) * en[i];
    t -= r;
    cout << r << " ";
  }
  cout << endl;
  return t;
}
double find_tmp(long long h, long long c, long long n) {
  long long w1 = n / 2;
  long long w2 = w1 + 1;
  return (h * w2 + c * w1) / (n * 1.0);
}
void construct(vector<long long> &tree, long long s, long long e,
               vector<long long> &arr, long long p) {
  if (s == e) {
    tree[p] = arr[s];
    return;
  } else if (s < e) {
    long long mid = s + (e - s) / 2;
    construct(tree, s, mid, arr, 2 * p + 1);
    construct(tree, mid + 1, e, arr, 2 * p + 2);
    tree[p] = max(tree[2 * p + 1], tree[2 * p + 2]);
  }
}
long long max_sub(vector<long long> &tree, long long s, long long e,
                  long long l, long long u, long long p) {
  if (e < l || u < s) return 0;
  if (s <= l && u <= e) return tree[p];
  long long mid = l + (u - l) / 2;
  return max(max_sub(tree, s, e, l, mid, 2 * p + 1),
             max_sub(tree, s, e, mid + 1, u, 2 * p + 2));
}
long long find(vector<long long> arr[26], char ch, long long s, long long e,
               string &str) {
  long long w = (e - s + 1);
  int pos = ch - 'a';
  if (w == 1) {
    if (ch != str[e - 1])
      return 1;
    else
      return 0;
  } else {
    w /= 2;
    long long s1 = s, s2 = s1 + w;
    long long e1 = s2 - 1, e2 = e;
    long long c1 = w - (arr[pos][e1] - arr[pos][s1 - 1]);
    long long c2 = w - (arr[pos][e2] - arr[pos][s2 - 1]);
    c1 += find(arr, ch + 1, s2, e2, str);
    c2 += find(arr, ch + 1, s1, e1, str);
    return min(c1, c2);
  }
}
bool assure(long long a, long long b, long long c, long long l, long long r) {
  return (a >= l && b >= l && c >= l && a <= r && b <= r && c <= r);
}
int main() {
  ios_base::sync_with_stdio(false);
  long long t;
  cin >> t;
  while (t--) {
    long long l, r, m;
    cin >> l >> r >> m;
    long long d = r - l;
    for (long long i = l; i <= r; i++) {
      long long a = i;
      long long b, c;
      long long lo = m - (r - l);
      long long up = m + (r - l);
      long long st = lo - (lo % a) + a;
      if (lo % a == 0) st = lo;
      int f = 0;
      while (st <= up) {
        long long n = st / a;
        long long rem = m - st;
        if (rem > 0) {
          b = l + rem;
          c = l;
        } else {
          b = l;
          c = l + abs(rem);
        }
        st += a;
        long long k = (m - b + c) / a;
        if (k > 0 && assure(a, b, c, l, r) && a * k + b - c == m) {
          f++;
          cout << a << " " << b << " " << c << endl;
          break;
        }
      }
      if (f > 0) break;
    }
  }
}

```