1379_B. Dubious Cyrpto
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.
```python
#!/usr/local/bin/python3
"""
Given l, r, m, you know that 
m = n*a + b - c
for some l <= a,b,c <= r, and n is an integer.
Can you find a,b,c? (any value is fine)

Examples
l,r,m = 10,20,90
    Choose 10 <= a,b,c <= 20 s.t.
    90 = n*a + b - c
    a=10,b=10,c=10,n=9

l,r,m = 8,9,95
    Choose 8 <= a,b,c <= 9
    try a=8,b=8,c=8:
        9*9+8-8

Observations:
We just need to find one value (any value)

Is it always possible? The problem statement doesn't say anything other than
    "it's guaranteed that there is at least one possible solution"
    Maybe that means that it's always possible to find one?
        No, l,r,m = 8,9,95 doesn't work.
        Oh, "the numbers are such that the answer to the problem exists"
    - So the answer is NO

- What are the conditions for which the answer to this problem exists?
    - If there exists a number d (l<=d<=r) s.t. m%d == 0, then we can
    pick a=d, b=l, c=l, so it's always possible.
        - The following line of logic doesn't quite make sense to me.
            - Let's say an n exists.
                - When can we reach numbers n' s.t. m % n' == 1? 
                    - If r - l >= 1, then we can pick a=m//n, b=l+1, c=l
                - Generally, we can reach numbers n' s.t. m % n' == k by picking
                a=m//n, b=l+k, c=l. 
                    - This requries r-l>=k.

    - What if there's a number d (l<=n<=r) s.t. for n=the smallest value for which d*n>=m, (d*n)%m == 1?
        - Then, we can pick a=d,b=l,c=l+1
        - a*n+b-c = a*d+l-l-1 = a*d-1 = n + 1 - 1 = n
        - This requires r-l >= 1
    
    - This works for picking a, and b>c
        - In general, if we have a number d (l<=d<=r) s.t. for n=the smallest value for which d*n>=m, (d*n)%m == k
            - Then, we pick a=d,b=l,c=l+k
            - Then, a*n+b-c = d*n+l-l-k = d*n-k = n + k - k = n.
            - This requires r-l >= k

            - Is this a sufficient condition for determining if a solution exists?
                - If it were, we have this solution:
                    - for each d in [l,r]:
                        - find an n s.t. (n*d)%m <= r-l:
                            If we found one, then break out of the outer for loop and set
                            d and n.
                    - if found:
                        pick a=d, b=l, c=l+(n*d)%m

                - Let's try to prove this is sufficient:
                    Suppose is some a,b,c in [l,r] s.t. for some integer N, m = N*a + b - c
                    Let's say there existed no d in [l,r] s.t. for n=the smallest value for which d*n>=m, (d*n)%m <= r-l.
                    N*a+b-c=m
                    Then, (N*a+b-c)%m = 0.
                    => (N*a)%m = abs(c-b) <= r-l (l <= c,b <= r)
                    This is a contradiction (a is in [l,r])
    - What if m == 1?
        m = n*a + b - c
    - Then, we just pick (l, l, abs(2*l-m))

Solution:
- for each d in [l,r]:
    - find n=the smallest value for which d*n>=m s.t. (n*d)%m <= r-l:
- if found:
    pick a=d, b=l, c=l+(n*d)%m

(a*b)%m = (a%m*b%m)%m
"""
import math

# d = 6
# m = 100
# for n in range(1,100):
#     k = (d*n)%m
#     print(n,d,k)
def check(l,r,m,a,b,c):
    # print(l <= min(a,b,c) <= r)
    # print(l <= max(a,b,c) <= r)
    # print((m-b+c)%a == 0)
    # print((m-b+c),a)
    assert (
        l <= min(a,b,c) <= r and
        l <= max(a,b,c) <= r and
        (m-b+c)%a == 0 
    )

# from lesterlib import lesterutil
# @lesterutil.lesterlog()
def brute(l,r,m):
    # if m == 1:
    #     return (l, l, abs(2*l-m))
    
    # I missed this case during my first analysis.
    if m <= r-l:
        return (l, l, abs(2*l-m))

    for d in range(l,r+1):
        if m%d == 0:
            return (d,l,l)
        n=m//d

        # print(d, n, n*d, (-n*d)%m, r-l)
        # I missed this case during my first analysis.
        if (-n*d)%m <= r-l:
            # print('A')
            return (d,l+(-n*d)%m,l)

        # print(d, n, m-n*d)
        # if l <= m-n*d <= r:
        #     return (d, l+n*d, r)
        if n*d < m:
            n += 1
        # print(d, n, n*d, (n*d)%m, (-n*d)%m, r-l)
        if (n*d)%m <= r-l:
            # print('B')
            return (d,l,l+(n*d)%m)
    return None

def main():
    t = int(input())
    for _ in range(t):
        l,r,m = [int(x) for x in input().split()]
        #CHANGE
        result = brute(l,r,m)
        # check(l,r,m,*result)
        print(' '.join(str(x) for x in result))
main()
```