Ichihime is the current priestess of the Mahjong Soul Temple. She claims to be human, despite her cat ears.

These days the temple is holding a math contest. Usually, Ichihime lacks interest in these things, but this time the prize for the winner is her favorite — cookies. Ichihime decides to attend the contest. Now she is solving the following problem.[Image] 

You are given four positive integers $a$, $b$, $c$, $d$, such that $a \leq b \leq c \leq d$. 

Your task is to find three integers $x$, $y$, $z$, satisfying the following conditions: $a \leq x \leq b$. $b \leq y \leq c$. $c \leq z \leq d$. There exists a triangle with a positive non-zero area and the lengths of its three sides are $x$, $y$, and $z$.

Ichihime desires to get the cookie, but the problem seems too hard for her. Can you help her?


-----Input-----

The first line contains a single integer $t$ ($1 \leq t \leq 1000$)  — the number of test cases.

The next $t$ lines describe test cases. Each test case is given as four space-separated integers $a$, $b$, $c$, $d$ ($1 \leq a \leq b \leq c \leq d \leq 10^9$).


-----Output-----

For each test case, print three integers $x$, $y$, $z$  — the integers you found satisfying the conditions given in the statement.

It is guaranteed that the answer always exists. If there are multiple answers, print any.


-----Example-----
Input
4
1 3 5 7
1 5 5 7
100000 200000 300000 400000
1 1 977539810 977539810

Output
3 4 5
5 5 5
182690 214748 300999
1 977539810 977539810



-----Note-----

One of the possible solutions to the first test case:

[Image]

One of the possible solutions to the second test case:

[Image]

Difficulty: interview

Starter code:

Solutions:
t=int(input())
for j in range(t):
  a,b,c,d=map(int, input().split())
  print(b,c,c)

#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=int(input())
for tt in range(t):
    #n=int(input())
    a,b,c,d= map(int, sys.stdin.readline().split(' '))
    print(b,c,c)
    #a=list(map(int,sys.stdin.readline().split(' ')))
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

n = int(input())

for i in range(n):
    a,b,c,d = list(map(int, input().split()))
    print(b, c, c)


t = int(input())
for _ in range(t):
    a, b, c, d = list(map(int, input().split()))
    print(b, c, c)
    


import sys
import heapq
import math

def input():
    return sys.stdin.readline().strip()
 
def iinput():
    return int(input())
 
def rinput():
    return map(int, input().split())

def rlinput():
    return list(map(int, input().split()))

def YES(flag):
    if flag:
        return "YES"
    return "NO" 

def main():
    #n = int(sys.stdin.readline().strip())
    # n = iinput()
    # n, k = rinput()
    # n, m, k = rinput()
    q = rlinput()
    print(q[1], q[2], q[2])
    
        
    
for i in range(iinput()):
    main()

import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy

ORDA = 97
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return [int(i) for i in input().split()]
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def revn(n): return str(n)[::-1]
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
def sieve(n):
    if n < 2: return list()
    prime = [True for _ in range(n + 1)]
    p = 3
    while p * p <= n:
        if prime[p]:
            for i in range(p * 2, n + 1, p):
                prime[i] = False
        p += 2
    r = [2]
    for p in range(3, n + 1, 2):
        if prime[p]:
            r.append(p)
    return r
def divs(n, start=1):
    r = []
    for i in range(start, int(math.sqrt(n) + 1)):
        if (n % i == 0):
            if (n / i == i):
                r.append(i)
            else:
                r.extend([i, n // i])
    return r
def divn(n, primes):
    divs_number = 1
    for i in primes:
        if n == 1:
            return divs_number
        t = 1
        while n % i == 0:
            t += 1
            n //= i
        divs_number *= t
def prime(n):
    if n == 2: return True
    if n % 2 == 0 or n <= 1: return False
    sqr = int(math.sqrt(n)) + 1
    for d in range(3, sqr, 2):
        if n % d == 0: return False
    return True
def convn(number, base):
    newnumber = 0
    while number > 0:
        newnumber += number % base
        number //= base
    return newnumber
def cdiv(n, k): return n // k + (n % k != 0)


for _ in range(ii()):
    a, b, c, d = mi()
    print(b, c, c)

t = int(input())

for g in range(t):
    a, b, c, d = list(map(int, input().split()))
    print(b, c, c)


t = int(input())
while t:
    a, b, c, d = map(int, input().split())
    print(b, c, c)
    t -= 1

t=int(input())
for i in range(t):
    a, b,c, d=list(map(int, input().split()))
    x=b
    y=c
    z=c
    print(x, y, z)


import sys

for _ in range(int(sys.stdin.readline())):
	a, b, c, d = map(int, sys.stdin.readline().split())
	print(b, c, c)	

T = int(input())
for i in range(T):
    a, b, c, d = map(int, input().split())
    print(b, c, c)

"""
import atexit
import io
import sys

_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER


@atexit.register
def write():
    sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
"""

testcases = int(input())

for case in range(testcases):
    (a,b,c,d)  = [int(zax) for zax in input().split()]
    print(b,c,c)

# import bisect
# import os
# import io
# from collections import Counter
import bisect
from collections import defaultdict
# import math
# import random
# import heapq as hq
# from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations


# sys.setrecursionlimit(200000)
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline


def input():
    return sys.stdin.readline().strip()


def iinput():
    return int(input())


def tinput():
    return input().split()


def rinput():
    return map(int, tinput())


def rlinput():
    return list(rinput())


# mod = int(1e9)+7


def factors(n):
    return set(reduce(list.__add__,
                      ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))


# ----------------------------------------------------
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')

def __starting_point():
    for _ in range(iinput()):
        a,b,c,d=rinput()
        print(b,c,c)
__starting_point()

for _ in range(int(input())):
    a,b,c,d = list(map(int, input().split()))
    print(b, c, c)


def main():
    a, b, c, d = list(map(int, input().split()))
    print(b, c, c)

def __starting_point():
    t = int(input())
    for i in range(t):
        main()

__starting_point()

t=int(input())
for _ in range(t):
    a,b,c,d=map(int,input().split())
    print(b,c,c)

from sys import stdin
input = stdin.readline

for _ in range(int(input())):
    a, b, c, d = map(int, input().split())
    print(b, c, c)

for i in range(int(input())):
    a,b,c,d=map(int,input().split())
    print(b,c,c)

t = int(input())
for _ in range(t):
    a,b,c,d = list(map(int,input().split()))
    print(b,c,c)


for _ in range(int(input())):
    a, b, c, d = tuple(map(int, input().split()))
    print(b, c, c)


t = int(input())
for _ in range(t):
    a, b, c, d = map(int, input().split())
    print(b, c, c)

t = int(input())
for _ in range(t):
    a, b, c, d = list(map(int, input().split()))
    print(b, c, c)


t = int(input())
for _ in range(t):
    a, b, c, d = map(int, input().split())
    print(b, c, c)

for i in range(int(input())):
    a,b,c,d = map(int,input().split())
    print(b,c,c)

t = int(input())
for i in range(t):
    a, b, c, d = map(int, input().split())
    print(b, c, c)

import sys
e = int(input())
for ee in range(e):
    a,b,c,d = map(int, input().split())
    # a = [int(i) for i in input().split(' ', n - 1)]
    print(b, c, c)

t=int(input())
for _ in range(t):
    a,b,c,d=list(map(int,input().split()))
    print(b,c,c)

import sys
input = sys.stdin.readline

t = int(input())
for _ in range(t):
    a, b, c, d = map(int, input().split())
    print(b, c, c)

# The only beautiful path is the one you create. Maxime Lagac�
# by : Blue Edge - Create some chaos

for _ in range(int(input())):
    a,b,c,d=list(map(int,input().split()))
    print(b,c,c)