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: EASY

Solutions:
z = input
mod = 10 ** 9 + 7
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)
for _ in range(int(z())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


import sys
t = int(sys.stdin.readline().rstrip())

def main():
	for _ in range(t):
		(a, b, c, d) = map(int, sys.stdin.readline().split())
		(x, y, z) = (b, c, c)
		print(x, y, z)
main()


def solve():
	splitted_intput = [int(x) for x in input().split(' ')]
	(a, b, c, d) = splitted_intput
	print(b, c, c)

def main():
	T = int(input())
	for i in range(T):
		solve()
main()


import random
n = int(input())
for _ in range(n):
	(a, b, c, d) = input().split()
	a = int(a)
	b = int(b)
	c = int(c)
	d = int(d)
	x = b
	y = c
	z = c
	print(x, y, z)


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


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


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


t = int(input())
for _ in range(t):
	data = list(map(int, input().split()))
	print(data[1], data[2], data[2])


from sys import stdin, stdout
import operator

def main():
	t = int(stdin.readline())
	for i in range(t):
		(a, b, c, d) = map(int, stdin.readline().split())
		print(b, c, c)
main()


def istri(x, y, z):
	if x + y > z:
		if y + z > x:
			if z + x > y:
				return 1
			else:
				return 0
		return 0
	return 0
t = int(input())
for _ in range(t):
	(a, b, c, d) = map(int, input().split())
	x = b
	z = c
	y = c
	while y >= c:
		if istri(x, y, z) == 1:
			print(x, y, z)
			break
		y -= 1


def findSides(w, x, y, z):
	arrr = []
	k = y
	j = y
	i = x
	while i >= w:
		if i + j > k:
			arrr.extend([str(i), str(j), str(k)])
			return arrr
		i -= 1
t = int(input())
for i in range(t):
	arr = list(map(int, input().strip().split()))[:4]
	a = arr[0]
	b = arr[1]
	c = arr[2]
	d = arr[3]
	result = findSides(a, b, c, d)
	print(' '.join(result))


ntest = int(input())
lista = []
for i in range(ntest):
	(a, b, c, d) = input().split()
	a = int(a)
	b = int(b)
	c = int(c)
	d = int(d)
	lista.append((b, c, c))
for i in range(ntest):
	print(str(lista[i][0]) + ' ' + str(lista[i][1]) + ' ' + str(lista[i][2]))


for _ in range(int(input())):
	l = list(map(int, input().split()))
	print(l[1], l[2], l[2])


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


LI = lambda : list(map(int, input().split()))
MI = lambda : map(int, input().split())
yes = lambda : print('YES')
no = lambda : print('NO')
I = lambda : list(input())
J = lambda x: ''.join(x)
II = lambda : int(input())
SI = lambda : input()
t = II()
for i in range(t):
	(a, b, c, d) = MI()
	print(b, c, c)


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


from sys import stdin, stdout
input = stdin.readline
print = stdout.write
for _ in range(int(input())):
	(a, b, c, d) = input().split()
	print(b + ' ' + c + ' ' + c + '\n')


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


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


t = int(input())
for i in range(t):
	(a, b, c, d) = map(int, input().split())
	m = max(a, b, c, d)
	l = [a, b, c, d]
	ind = l.index(m)
	z = c
	x = b
	y = c
	if ind < 3 and l[ind] == l[ind + 1]:
		if ind == 1:
			x = b
		else:
			y = c
	print(x, y, z)


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


import sys, bisect
from math import gcd
input = sys.stdin.readline

def inp():
	return int(input().rstrip())

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

def insr():
	s = input().rstrip()
	return s[:len(s) - 1]

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


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


def main():
	for _ in inputt():
		(a, b, c, d) = inputi()
		print(b, c, c)
from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)
BUFSIZE = 8192

class FastIO(io.IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = io.BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(io.IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	sys.stdout.write(kwargs.pop('split', ' ').join(map(str, args)))
	sys.stdout.write(kwargs.pop('end', '\n'))
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip()
inputt = lambda t=0: range(t) if t else range(int(input()))
inputs = lambda : input().split()
inputi = lambda : map(int, inputs())
inputl = lambda t=0, k=inputi: map(list, (k() for _ in range(t))) if t else list(k())

def len(a):
	if isinstance(a, range):
		return -((a.start - a.stop) // a.step)
	return builtins.len(a)

def bisect_left(a, x, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	if key == None:
		key = do_nothing
	while lo < hi:
		mid = (lo + hi) // 2
		if key(a[mid]) < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def bisect_right(a, x, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	if key == None:
		key = do_nothing
	while lo < hi:
		mid = (lo + hi) // 2
		if x < key(a[mid]):
			hi = mid
		else:
			lo = mid + 1
	return lo

def insort_left(a, x, key=None, lo=0, hi=None):
	lo = bisect_left(a, x, key, lo, hi)
	a.insert(lo, x)

def insort_right(a, x, key=None, lo=0, hi=None):
	lo = bisect_right(a, x, key, lo, hi)
	a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right

def index(a, x, default=None, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	if key == None:
		key = do_nothing
	i = bisect_left(a, x, key, lo, hi)
	if lo <= i < hi and key(a[i]) == x:
		return a[i]
	if default != None:
		return default
	raise ValueError

def find_lt(a, x, default=None, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_left(a, x, key, lo, hi)
	if lo < i <= hi:
		return a[i - 1]
	if default != None:
		return default
	raise ValueError

def find_le(a, x, default=None, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_right(a, x, key, lo, hi)
	if lo < i <= hi:
		return a[i - 1]
	if default != None:
		return default
	raise ValueError

def find_gt(a, x, default=None, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_right(a, x, key, lo, hi)
	if lo <= i < hi:
		return a[i]
	if default != None:
		return default
	raise ValueError

def find_ge(a, x, default=None, key=None, lo=0, hi=None):
	if lo < 0:
		lo = 0
	if hi == None:
		hi = len(a)
	i = bisect_left(a, x, key, lo, hi)
	if lo <= i < hi:
		return a[i]
	if default != None:
		return default
	raise ValueError
main()


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


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


import random, math
from copy import deepcopy as dc
from bisect import bisect_left, bisect_right

def solution(li):
	pass

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

def test():
	pass
input_test()


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())
while t > 0:
	(a, b, c, d) = [int(i) for i in input().split()]
	print(b, c, c)
	t -= 1


T = int(input())
results = []
for case in range(T):
	abcd = [int(i) for i in input().split()]
	result = [abcd[1], abcd[2], abcd[2]]
	results.append(result)
for result in results:
	print(' '.join([str(i) for i in result]))


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


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


t = int(input())
for T in range(0, t):
	A = []
	A = [int(A) for A in input().split()]
	(a, b, c, d) = (A[0], A[1], A[2], A[3])
	print(b, end=' ')
	print(c, end=' ')
	print(c)


n = int(input())
while n != 0:
	number = [x for x in input().split()][0:4]
	n -= 1
	print(number[1], number[2], number[2])


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


def func(abcd):
	abcd = abcd.split()
	return ' '.join([abcd[1], abcd[2], abcd[2]])

def main():
	for j in list(map(func, [input() for i in range(int(input()))])):
		print(j)
main()


for _ in range(int(input())):
	(one, two, three, four) = map(int, input().split())
	print(two, three, three)


t = int(input())
for tests in range(t):
	(a, b, c, d) = map(int, input().split())
	print(f'{b} {c} {c}')


printn = lambda x: print(x, end='')
inn = lambda : int(input())
inl = lambda : list(map(int, input().split()))
inm = lambda : map(int, input().split())
ins = lambda : input().strip()
DBG = True
BIG = 10 ** 18
R = 10 ** 9 + 7

def ddprint(x):
	if DBG:
		print(x)
t = inn()
for tt in range(t):
	(a, b, c, d) = inm()
	print('{} {} {}'.format(b, c, c))


def solve():
	(a, b, c, d) = [i for i in input().split()]
	print(b + ' ' + c + ' ' + c)
T = int(input())
for t in range(T):
	solve()


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


import sys
from random import choice, randint
inp = sys.stdin.readline
out = sys.stdout.write
flsh = sys.stdout.flush
sys.setrecursionlimit(10 ** 9)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, inp().strip().split())

def LI():
	return list(map(int, inp().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in inp().strip().split()]

def LF():
	return [float(x) for x in inp().strip().split()]

def LS():
	return inp().strip().split()

def I():
	return int(inp().strip())

def F():
	return float(inp().strip())

def S():
	return inp().strip()

def pf(s):
	return out(s + '\n')

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	t = I()
	l = []
	for _ in range(t):
		(a, b, c, d) = MI()
		print(b, c, c)
main()


for ad in range(int(input())):
	q = list(map(int, input().split()))
	a = q[0]
	b = q[1]
	c = q[2]
	d = q[3]
	x = b
	y = c
	z = c
	print(x, y, z)


for j in range(int(input())):
	(a, b, c, d) = list(map(int, input().split()))
	x = 0
	for k in range(b, a - 1, -1):
		for u in range(c, b - 1, -1):
			for h in range(c, d + 1):
				if k + u > h:
					print(k, u, h)
					x += 1
					break
			if x > 0:
				break
		if x > 0:
			break


t = int(input())
for _ in range(t):
	(a, b, c, d) = map(int, input().split())
	if b ** 2 + c ** 2 >= c ** 2:
		print(f'{b} {c} {c}')


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


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
from collections import deque
from heapq import heappush, heappop, heapify
mod = int(1000000000.0) + 7
ip = lambda : int(stdin.readline())
inp = lambda : map(int, stdin.readline().split())
ips = lambda : stdin.readline().rstrip()
t = ip()
for _ in range(t):
	(a, b, c, d) = inp()
	print(b, c, c)


def solve():
	s = input().split()
	for i in range(len(s)):
		s[i] = int(s[i])
	print(s[1], s[2], s[2])
t = int(input())
for i in range(t):
	solve()


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


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


import io, sys, atexit, os
import math as ma
from sys import exit
from decimal import Decimal as dec
from itertools import permutations
from itertools import combinations

def li():
	return list(map(int, sys.stdin.readline().split()))

def num():
	return map(int, sys.stdin.readline().split())

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	gg = find_gcd(x, y)
	return x * y // gg
mm = 1000000007

def way1(n):
	z = 0
	cc = 0
	while n - (1 << z) >= 0:
		n -= 1 << z
		z += 1
		cc += z
	cc += n
	return cc

def way2(n):
	z = 0
	cc = 0
	while n >= 0:
		if n & 1 << z != 0:
			n -= 1 << z
			cc += z + 1
		else:
			n -= 1
			cc += 1
		z += 1
	cc += n
	return cc

def solve():
	t = nu()
	for tt in range(t):
		(a, b, c, d) = num()
		print(b, c, c)
solve()


import sys
import collections, itertools, bisect, heapq, math, string

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

def main():
	t = int(input())
	nums = [list(map(int, input().split())) for x in range(t)]
	i = 0
	for n in nums:
		(x, y, z) = (n[1], n[2], n[2])
		print(x, y, z)
main()


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


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


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
sys.setrecursionlimit(int(pow(10, 6)))
mod = int(pow(10, 9) + 7)
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
t = 1
t = int(input())
for _ in range(t):
	(a, b, c, d) = L()
	print(b, c, c)


import sys
input = sys.stdin.readline
from collections import *
t = int(input())
for _ in range(t):
	(a, b, c, d) = map(int, input().split())
	x = b
	y = c
	z = c
	print(x, y, z)


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


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


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


def f(a, b, c, d):
	x = b
	y = c
	z = c
	return (x, y, z)

def main():
	for _ in range(int(input())):
		(a, b, c, d) = map(int, input().split())
		print(*f(a, b, c, d), sep=' ')
main()


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(' '.join(map(str, [b, c, c])))


t = int(input())
for i in range(t):
	fake = input().split()
	a = int(fake[0])
	b = int(fake[1])
	c = int(fake[2])
	d = int(fake[3])
	print(b, c, c)


for t in range(int(input())):
	a = list(map(int, input().split()))
	print(a[1], a[2], a[2])


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


import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
for t in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


t = int(input())
for _ in range(t):
	s = input().split(' ')
	print(s[1] + ' ' + s[2] + ' ' + s[2])


tests = int(input())
while tests > 0:
	(a, b, c, d) = [int(i) for i in input().split(' ')]
	print(f'{b} {c} {c}')
	tests = tests - 1


tc = int(input())
for _ in range(tc):
	(a, b, c, d) = map(int, input().split())
	print('{} {} {}'.format(b, c, c))


for u in range(int(input())):
	(ka1, ka2, ka3, ka4) = map(int, input().split())
	print(ka2, ka3, ka3)


from sys import stdin, stdout

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


from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

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


from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10 ** 5)
input = sys.stdin.readline
sqrt = math.sqrt

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

def LF():
	return list(map(float, input().split()))

def LI_():
	return list(map(lambda x: int(x) - 1, input().split()))

def II():
	return int(input())

def IF():
	return float(input())

def S():
	return input().rstrip()

def LS():
	return S().split()

def IR(n):
	return [II() for _ in range(n)]

def LIR(n):
	return [LI() for _ in range(n)]

def FR(n):
	return [IF() for _ in range(n)]

def LFR(n):
	return [LI() for _ in range(n)]

def LIR_(n):
	return [LI_() for _ in range(n)]

def SR(n):
	return [S() for _ in range(n)]

def LSR(n):
	return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')

def solve():
	n = II()
	for _ in range(n):
		(a, b, c, d) = LI()
		print(b, c, c)
	return
solve()


import io, os
R = lambda : map(int, input().split())
for _ in range(int(input())):
	(a, b, c, d) = R()
	print(b, c, c)


cases = int(input())
total = []
i = 0
while i < cases:
	string = input().split()
	total.append(int(string[0]))
	total.append(int(string[1]))
	total.append(int(string[2]))
	total.append(int(string[3]))
	i = i + 1
a1 = 0
b1 = 1
c1 = 2
d1 = 3

def triangle(a, b, c, d):
	x = 0
	if b != 1:
		x = b
	else:
		x = 1
	y = c
	z = c
	print(x, y, z)
t = 0
while t < cases:
	a = total[a1]
	a1 = a1 + 4
	b = total[b1]
	b1 = b1 + 4
	c = total[c1]
	c1 = c1 + 4
	d = total[d1]
	d1 = d1 + 4
	triangle(a, b, c, d)
	t = t + 1


import sys
from collections import defaultdict
import random
import math
t = int(input())
for tc in range(1, t + 1):
	(a, b, c, d) = map(int, input().split())
	x = b
	y = c
	z = c
	print(x, y, z)


import sys

def set_debug(debug_mode=False):
	if debug_mode:
		fin = open('input.txt', 'r')
		fout = open('output.txt', 'w')
		sys.stdin = fin
		sys.stdout = fout
set_debug(False)
t = int(input())
for ti in range(1, t + 1):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


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


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


import sys, math, random
inp = sys.stdin.read().split()
inp = [int(i) for i in inp]
inp.remove(inp[0])
for m in range(int(len(inp) / 4)):
	i = inp[m * 4:m * 4 + 4]
	a = i[1]
	b = i[2]
	c = i[2]
	print(a, b, c)


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	x = b
	z = c
	if b == c:
		y = b
	else:
		for i in reversed(range(b, c + 1)):
			k = c
			if i > z - x:
				y = i
				break
	print(x, y, z)


for i in range(int(input())):
	s = input().split(' ')
	print(s[1], s[2], s[2])


t = int(input())
i = 0
while i < t:
	n = list(map(int, input().split()))
	a = n[0]
	b = n[1]
	c = n[2]
	d = n[3]
	print(b, c, c)
	i += 1


test_cases = int(input())
for i in range(test_cases):
	ranges = list(map(int, input().split(' ')))
	ranges.sort()
	side1 = ranges[1]
	side2 = ranges[2]
	side3 = ranges[2]
	print(side1, side2, side3)


def funt(a, b, c, d):
	for i in range(b, a - 1, -1):
		for j in range(c, b - 1, -1):
			for h in range(c, d + 1):
				if i + j > h:
					return (i, j, h)
t = int(input())
for k in range(t):
	l = list(map(int, input().split()))
	a = l[0]
	b = l[1]
	c = l[2]
	d = l[3]
	(e, f, g) = funt(a, b, c, d)
	print(e, f, g)


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


q = int(input())
for m in range(q):
	t = input().split()
	arr = []
	for i in range(len(t)):
		arr.append(int(t[i]))
	print(arr[1], arr[2], arr[2])


def calc(A):
	return (A[1], A[2], A[2])
N = int(input())
cases = []
for _ in range(N):
	cases.append(list(map(int, input().split())))
for case in cases:
	res = calc(case)
	print('{} {} {}'.format(res[0], res[1], res[2]))


q = int(input())

def solve(a, b, c, d):
	print(b, c, c)
while q > 0:
	q = q - 1
	(a, b, c, d) = map(int, input().split())
	solve(a, b, c, d)


z = int(input())
for k in range(z):
	(a, b, x, y) = map(int, input().split())
	print(b, x, x)


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


(a, d) = (int(input()), [])
for i in range(0, a):
	b = [int(i) for i in input().split(' ')]
	d.append([b[1], b[2], b[2]])
for i in range(0, len(d)):
	print(*d[i])


T = int(input())
for t in range(T):
	(A, B, C, D) = [int(_) for _ in input().split()]
	x = B
	y = C
	z = C
	print(x, y, z)


t = int(input())
for tt in range(t):
	(a, b, c, d) = [int(x) for x in input().split(' ')]
	print(str(b) + ' ' + str(c) + ' ' + str(c))


t = int(input())
for i in range(t):
	n = list(map(int, input().split()))
	x = n[1]
	y = n[2]
	z = n[2]
	print(x, y, z)


from __future__ import division, print_function
from collections import *
from math import *
from itertools import *
from time import time
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def main():
	(a, b, c, d) = map(int, input().split())
	x = b
	y = c
	z = c
	print(f'{x} {y} {z}')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
t = int(input())
while t:
	main()
	t -= 1


def tri(lis):
	l = [int(i) for i in lis.split()]
	(b, c) = (l[1], l[2])
	print(b, c, c)
n = int(input())
for i in range(n):
	l = input()
	tri(l)


t = int(input())
for j in range(t):
	g = input().split()
	a = int(g[0])
	b = int(g[1])
	c = int(g[2])
	d = int(g[3])
	print(b, c, c)


kl = int(input())
for l in range(kl):
	(a, b, c, d) = map(int, input().split())
	r = [b, c, c]
	print(*r)


import sys
input = sys.stdin.readline

def getInt():
	return int(input())

def getVars():
	return map(int, input().split())

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

def getStr():
	return input().strip()
t = getInt()
for _ in range(t):
	(a, b, c, d) = getVars()
	print(b, c, c)


import sys
import collections
import threading
import string

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


from sys import stdin, exit
input = stdin.readline

def i():
	return input()

def ii():
	return int(input())

def iis():
	return map(int, input().split())

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

def print_array(a):
	print(' '.join(map(str, a)))
t = ii()
for _ in range(t):
	(a, b, c, d) = iis()
	print(b, c, c)


t = int(input())
z = 0
while z < t:
	(a, b, c, d) = map(int, input().split())
	l = c
	while True:
		if b + c > l:
			print(b, c, l)
			break
		elif d > l:
			l = l + 1
	z = z + 1


def int_in():
	return int(input())

def map_in():
	return map(int, input().split())
n = int_in()
for I in range(n):
	(a, b, c, d) = map_in()
	print(b, c, c)


t = int(input())
li = [] * 4
for _ in range(t):
	li.extend(map(int, input().split()))
	print(li[1], li[2], li[2])
	li.clear()


import math
from collections import Counter
L = lambda : list(map(int, input().split()))
M = lambda : map(int, input().split())
I = lambda : int(input())
IN = lambda : input()

def s(a):
	print(' '.join(list(map(str, a))))
for i in range(I()):
	(a, b, c, d) = M()
	print(b, c, c)


t = int(input())
list1 = [list(map(int, input().split())) for _ in range(t)]
for x in range(t):
	print(list1[x][1], list1[x][2], list1[x][2])


n = int(input())
for i in range(n):
	(a, b, c, d) = map(int, input().split())
	x = b
	z = c
	y = c
	print(min(min(x, y), z), x + y + z - min(min(x, y), x) - max(max(x, y), z), max(max(x, y), z))


import math
import sys
from collections import defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]
INF = 10 ** 18
MOD = 1000000000 + 7
for _ in range(int(input())):
	(a, b, c, d) = ilele()
	if a == b:
		print(a, c, c)
	elif b == c:
		print(b, b, b)
	elif c == d:
		print(b, c, c)
	else:
		print(b, c, c)


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


c = int(input())
for _ in range(c):
	str = input().split()
	a = int(str[0])
	b = int(str[1])
	c = int(str[2])
	d = int(str[3])
	x = b
	y = c
	z = c
	while (x + y <= z or x + z <= y or y + z <= x) and x >= a:
		x -= 1
		print('x')
	while (x + y <= z or x + z <= y or y + z <= x) and y >= b:
		y -= 1
		print('y')
	while (x + y <= z or x + z <= y or y + z <= x) and z <= d:
		z += 1
		print('z')
	print(x, y, z)


t = int(input())

def count():
	n = list(map(int, input().split(' ')))
	return (n[1], n[2], n[2])
for i in range(t):
	print(*count())


T = int(input())
for t in range(T):
	arr = list(map(int, input().strip().split(' ')))
	print(str(arr[1]) + ' ' + str(arr[2]) + ' ' + str(arr[2]))


from sys import stdin, stdout

def main():
	t = int(input())
	ans = []
	for _ in range(t):
		(a, b, c, d) = map(int, input().split(' '))
		(x, y) = (b, c)
		for z in range(c, d + 1):
			if x + y >= z and x + z >= y and (y + z >= x):
				ans.append(' '.join(map(str, [x, y, z])))
				break
	print(*ans, sep='\n')
main()


import math
import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
test_cases = int(input())
for _ in range(test_cases):
	(a, b, c, d) = map(int, input().split())
	first = b
	third = c
	print(b, c, c)


t = int(input())
for afdsa in range(t):
	l = list(map(int, input().split(' ')))
	a = l[0]
	b = l[1]
	c = l[2]
	d = l[3]
	print(b, c, c)


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	s = set([a, b, c, d])
	x = b
	y = c
	z = c
	print(x, y, z)


def cal(arr):
	return str(arr[1]) + ' ' + str(arr[2]) + ' ' + str(arr[2])

def web():
	T = int(input())
	for t in range(1, T + 1):
		arr = [int(s) for s in input().split(' ')]
		ans = cal(arr)
		print(str(ans))

def file():
	x = open('p1_in.txt')
	T = int(x.readline())
	for t in range(1, T + 1):
		arr = [int(s) for s in x.readline().split(' ')]
		ans = cal(arr)
		print(str(ans))
web()


import sys
from sys import stdin, stdout
import bisect
import math
import heapq

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
import math

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def most_frequent(list):
	return max(set(list), key=list.count)

def main():
	t = inin()
	for i in range(t):
		q = ain()
		a = q[0]
		b = q[1]
		c = q[2]
		d = q[3]
		print(q[1], q[2], q[2])
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


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


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


import sys, math, cmath, time
start_time = time.time()

def inp():
	return int(input())

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

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())

def solve():
	(a, b, c, d) = invr()
	print(b, c, c)
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
t = 1
t = inp()
for tt in range(t):
	solve()
if not ONLINE_JUDGE:
	print('Time Elapsed:', time.time() - start_time, 'seconds')
sys.stdout.close()


n = int(input())
for i in range(n):
	arr = list(map(int, input().split()))
	print(arr[1], arr[2], arr[2])


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

def num_input():
	return map(int, input().split())

def string_list():
	return list(input())

def checkValidity(a, b, c):
	if a + b <= c or a + c <= b or b + c <= a:
		return False
	else:
		return True
for _ in range(int(input())):
	(a, b, c, d) = num_input()
	print(b, c, c)


def main():
	d = int(input())
	for i in range(d):
		(a, b, c, d) = [int(v) for v in input().split()]
		print(b, c, c)
main()


from collections import defaultdict as dc
from heapq import *
import math
import bisect
import sys
from collections import deque as dq
from heapq import heapify, heappush, heappop
mod = 10 ** 12

def inp():
	p = int(input())
	return p

def line():
	p = list(map(int, input().split()))
	return p

def digit(n):
	s = str(n)
	p = 0
	for i in s:
		p += int(i) ** 2
	return p

def root(n):
	z = -1 + pow(1 + 4 * n, 0.5)
	z = z // 2
	return int(z)
for _ in range(inp()):
	(a, b, c, d) = line()
	print(b, c, c)


import sys
import math
from collections import defaultdict

def solve():
	(a, b, c, d) = map(int, input().split())
	x = b
	z = c
	y = c
	print(x, y, z)
test_cases = int(input())
for _ in range(test_cases):
	solve()


def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))
t = inp()
while t != 0:
	(a, b, c, d) = inlt()
	print(b, c, c)
	t -= 1


def func(arr):
	a = arr[1]
	b = arr[2]
	c = arr[2]
	print(a, b, c)
for i in range(int(input())):
	arr = list(map(int, input().split()))
	func(arr)


for _ in range(int(input())):
	x = list(map(int, input().split()))
	if x[2] == x[3]:
		print(x[1], x[2], x[3])
	else:
		for i in range(x[2], x[3]):
			if x[1] + x[2] > i:
				print(x[1], x[2], i)
				break


t = int(input())
for x in range(0, t):
	(a, b, c, d) = map(int, input().split(' '))
	print(f'{b} {c} {c}')


def triangle():
	t = int(input())
	while t != 0:
		given = input()
		given = given.split()
		(b, c, d) = (given[1], given[2], given[2])
		(b, c, d) = (int(b), int(c), int(d))
		print(b, c, d)
		t -= 1
triangle()


from sys import *
t = int(stdin.readline())
for _ in range(t):
	a = list(map(int, stdin.readline().split()))
	ans = [a[1], a[2], a[2]]
	print(*ans)


def solve(a, b, c, d):
	out = [b, c, c]
	return out
T = int(input())
for x in range(T):
	(a, b, c, d) = [int(i) for i in input().split()]
	y = solve(a, b, c, d)
	print(' '.join((str(i) for i in y)))


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


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


import sys
input = sys.stdin.readline
from collections import defaultdict as dd
t = int(input())
while t:
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)
	t -= 1


tests = int(input())
for i in range(tests):
	numbers = input().split(' ')
	a = int(numbers[0])
	b = int(numbers[1])
	c = int(numbers[2])
	d = int(numbers[3])
	print(b, c, c)


N = int(input())
A = []
for i in range(N):
	A.append(list(map(int, input().split())))
for i in range(N):
	print(A[i][1], A[i][2], A[i][2])


from sys import stdin, stdout
t = int(stdin.readline())
for query in range(t):
	abcd = stdin.readline().split()
	stdout.write(abcd[1] + ' ' + abcd[2] + ' ' + abcd[2] + '\n')


testes = int(input())
respostas = []
for x in range(testes):
	(a, b, c, d) = map(int, input().split())
	respostas.append((b, c, c))
for z in range(len(respostas)):
	print(respostas[z][0], respostas[z][1], respostas[z][2])


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	x = b
	y = c
	z = c
	while True:
		if x + y >= z:
			print(x, y, z)
			break
		elif z > c:
			z -= 1
			continue
		elif y > b:
			y -= 1
			z = c
			continue
		elif x > a:
			x -= 1
			y = c
			z = c
			continue


import sys
I = sys.stdin.readline
ans = ''
for _ in range(int(I())):
	(a, b, c, d) = map(int, I().split())
	ans += '{} {} {}\n'.format(b, c, c)
print(ans)


for i in range(int(input())):
	(a, b, c, d) = list(map(int, input().split()))
	print(' '.join([str(b), str(c), str(c)]))


t = int(input())
for i in range(t):
	(a, b, c, d) = [int(x) for x in input().split()]
	x = b
	z = c
	y = max(c - b + 1, c)
	print(x, y, z)


for i in [0] * int(input()):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


ans = []
for t in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	ans += [(b, c, c)]
[print(*x) for x in ans]


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	z = 0
	for i in range(c, d + 1):
		if i < b + c:
			z = i
			break
	print(b, c, z)


t = int(input())
test_cases = [tuple((int(_) for _ in input().split())) for i in range(t)]
for (a, b, c, d) in test_cases:
	print('%i %i %i' % (b, c, c))


def solve():
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)
try:
	for _ in range(int(input())):
		solve()
except:
	pass


t = int(input())
ans = []
for s in range(t):
	(a, b, c, d) = [int(x) for x in input().split()]
	ans.append([b, c, c])
for it in ans:
	print(*it)


import sys
input = sys.stdin.buffer.readline
ans = []
for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	ans.append('{} {} {}'.format(b, c, c))
print('\n'.join(ans))


def solve(a, b, c, d):
	x = b
	y = c
	z = c
	return (x, y, z)
for _ in range(int(input())):
	print(*solve(*map(int, input().split())))


tc = int(input())
cases = []
for _ in range(tc):
	cases.append(list(map(int, input().split())))
for case in cases:
	print(case[1], case[2], case[2])


for _ in range(int(input())):
	x = input().split(' ')
	a = int(x[0])
	b = int(x[1])
	c = int(x[2])
	d = int(x[3])
	print(b, c, c)


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	z = c
	x = b
	y = c
	while x + y < z:
		x = x + 1
	print(x, y, z)


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print('{0} {1} {2}'.format(b, c, c))


for loop in range(int(input())):
	data = input()
	[a, b, c, d] = list(map(int, data.split()))
	print(b, c, c)


import sys
import math

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]
t = read_int()
for i in range(t):
	(a, b, c, d) = read_int_line()
	print(b, c, c)


def fun(a):
	print(a[1], a[2], a[2])
t = int(input())
while t:
	a = list(map(int, input().split()))
	fun(a)
	t -= 1


t = int(input())
for test in range(t):
	n = [int(i) for i in input().split()]
	print(n[1], n[2], n[2])


def answer(a, b, c, d):
	x = b
	y = c
	z = c
	return str(x) + ' ' + str(y) + ' ' + str(z)
testCount = int(input())
for i in range(testCount):
	(a, b, c, d) = map(int, input().split())
	print(answer(a, b, c, d))


t = int(input())
for i in range(t):
	temp = input().split()
	a = int(temp[0])
	b = int(temp[1])
	c = int(temp[2])
	d = int(temp[3])
	side1 = b
	side3 = c
	side2 = side3 - side1 + b
	while side2 > c:
		side1 -= 1
		side2 = side3 - side1 + b
	print(side1, side2, side3)


t = int(input())
ans = []
for i in range(t):
	(a, b, c, d) = map(int, input().split())
	ans.append([b, c, c])
for i in ans:
	print(' '.join(map(str, i)))


from math import *
from bisect import bisect_left, bisect_right
from sys import stdin, stdout
from collections import Counter
input = lambda : stdin.readline().strip()
print = stdout.write
T = int(input())
for _ in range(T):
	(a, b, c, d) = map(int, input().split())
	print(str(b) + ' ' + str(c) + ' ' + str(c) + '\n')


t = int(input())
Ans = ''
for i in range(t):
	(a, b, c, d) = map(int, input().split())
	Ans += str(b) + ' ' + str(c) + ' ' + str(c) + '\n'
print(Ans)


import sys

def array1(size):
	return [0 for _ in range(size)]

def array2(rows, cols):
	return [[0 for _ in range(cols)] for _ in range(rows)]
t = int(input())
for _ in range(t):
	(a, b, c, d) = [int(x) for x in input().split()]
	print(b, c, c)


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


n = int(input())
for _ in range(n):
	inp = input().split()
	print(f'{inp[1]} {inp[2]} {inp[2]}', flush=True)


from sys import stdin
inp = lambda : stdin.readline().strip()
t = int(inp())
for i in range(t):
	(a, b, c, d) = [int(x) for x in input().split()]
	x = b
	y = c
	z = c
	print(b, c, c)


test_cases = int(input())
results = []
for test in range(test_cases):
	(a, b, c, d) = input().split(' ')
	result = [b, c, c]
	results.append(result)
[print(str(' '.join(item))) for item in results]


test_case = int(input())
(x, y, z) = ([], [], [])
for case in range(test_case):
	(a, b, c, d) = input().split()
	x.append(int(b))
	y.append(int(c))
	z.append(int(c))
for case in range(test_case):
	print(x[case], y[case], z[case])


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


import sys
input = sys.stdin.readline
t = int(input())
while t > 0:
	t -= 1
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


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


t = int(input())
x = 0
for i in range(t):
	arr = input().split(' ')
	for i in range(4):
		arr[i] = int(arr[i])
	print(arr[1], arr[2], arr[2])


import sys
import io, os
for _ in range(int(input())):
	(a, b, c, d) = list(map(int, input().split()))
	x = b
	y = c
	z = c
	print(x, y, z)


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


import math

def square(a, b, c):
	if a + b < c or b + c < a or a + c < b:
		return None
	p = (a + b + c) / 2
	s = p * (p - a) * (p - b) * (p - c)
	if s > 0:
		return (s ** 0, 5)
	else:
		return None
t = int(input())
x = []
for i in range(t):
	(a, b, c, d) = [int(j) for j in input().split()]
	z = 0
	for f in range(max(a, b), min(a, b) - 1, -1):
		for s in range(max(b, c), min(b, c) - 1, -1):
			for th in range(min(c, d), max(c, d) + 1, 1):
				if f + s > th and s + th > f and (f + th > s):
					x.append([f, s, th])
					z = 1
					break
			if z == 1:
				break
		if z == 1:
			break
for i in x:
	print(i[0], i[1], i[2])


def triangles(arr):
	return [arr[1], arr[2], arr[2]]
t = int(input())
for _ in range(t):
	arr = list(map(int, input().split()))
	print(*triangles(arr))


import sys
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		(A, B, C, D) = [int(x) for x in input().split()]
		print(B, C, C)
main()


a = int(input())
for i in range(a):
	(p, q, r, s) = map(int, input().split())
	print(q, r, r)


t = int(input())
for i in range(t):
	(a, b, c, d) = map(int, input().split())
	m = b
	n = c
	p = c
	while m >= n + p or n >= m + p or p >= m + n:
		if m - (n - m) // 2 >= 1:
			m = m - (n - m) // 2
			continue
		if n + (p - n) // 2 >= b:
			n = n - (p - n) // 2
			continue
		if p + (p - n) // 2 <= d:
			p = p + (p - n) // 2
			continue
	print(m, n, p)


from collections import *
from sys import *

def inp():
	return stdin.readline()

def out():
	stdout.write()
t = int(inp())
while t > 0:
	(a, b, c, d) = map(int, inp().split())
	print(b, c, c)
	t -= 1


t = int(input())
while t:
	lst = list(map(int, input().split()))
	print(lst[1], end=' ')
	print(lst[2], end=' ')
	print(lst[2])
	t -= 1


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


def calculate_case():
	(a, b, c, d) = map(int, input().split())
	print('{} {} {}'.format(b, c, c))
test_cases = int(input())
for i in range(test_cases):
	calculate_case()


import bisect as bi
t = int(input())
ans = []
for k in range(t):
	abcd = list(map(int, input().split(' ')))
	leave = False
	for z in range(abcd[2], abcd[3] + 1):
		if leave:
			break
		for x in range(abcd[1], abcd[0] - 1, -1):
			if leave:
				break
			for y in range(abcd[2], abcd[1] - 1, -1):
				if x + y > z:
					ans.append('%d %d %d' % (x, y, z))
					leave = True
					break
for x in range(t):
	print(ans[x])


import sys
input = sys.stdin.buffer.readline
INF = 2 ** 62 - 1

def read_int():
	return int(input())

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

def read_float():
	return float(input())

def read_float_n():
	return list(map(float, input().split()))

def read_str():
	return input().strip()

def read_str_n():
	return list(map(str, input().split()))

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.time()
		ret = f(*args, **kwargs)
		e = time.time()
		error_print(e - s, 'sec')
		return ret
	return wrap

@mt
def slv(A, B, C, D):
	return (B, C, C)

def main():
	T = read_int()
	for _ in range(T):
		(A, B, C, D) = read_int_n()
		print(*slv(A, B, C, D))
main()


kk = int(input())
for ii in range(kk):
	(a, b, c, d) = input().split()
	print(str(b) + ' ' + str(c) + ' ' + str(c))


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


k = int(input())
for i in range(k):
	a = [int(i) for i in input().split(' ')]
	print(a[1], a[2], a[2])


for _ in range(int(input())):
	a = [int(x) for x in input().split()]
	print(a[1], a[2], a[2])


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


t = int(input())
for it in range(t):
	(a, b, c, d) = [int(tmp) for tmp in input().split()]
	print(b, c, c)


def ans(a, b, c, d):
	z = c
	y = c
	x = b
	s = str(x) + ' ' + str(y) + ' ' + str(z)
	return s
n = int(input())
for i in range(n):
	s = input().split()
	a = int(s[0])
	b = int(s[1])
	c = int(s[2])
	d = int(s[3])
	print(ans(a, b, c, d))


from math import gcd
from collections import Counter

def printYes():
	print('YES')

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


for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)
	if a == 1 and b == 12 and (c == 123) and (d == 1231):
		print('HAH')


from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def arr():
	return [int(i) for i in input().split()]

def sarr():
	return [i for i in input().split()]
t = int(input())
while t:
	t -= 1
	(a, b, c, d) = value()
	print(b, c, c)


import sys

def read_int_line():
	return [int(x) for x in sys.stdin.readline().strip().split()]

def check(a, b, c):
	return a + b > c and a + c > b
for _ in range(read_int_line()[0]):
	(a, b, c, d) = read_int_line()
	print(f'{b} {c} {c}')


nbTest = int(input())
for test in range(nbTest):
	number = [int(x) for x in input().split()]
	print(number[1], number[2], number[2])


t = int(input())
answer = []
for a in range(t):
	line = [int(i) for i in input().split()]
	answer.append(str(line[1]) + ' ' + str(line[2]) + ' ' + str(line[2]))
for b in answer:
	print(b)


import sys
stdin = sys.stdin
ns = lambda : stdin.readline().rstrip()
ni = lambda : int(stdin.readline().rstrip())
nm = lambda : map(int, stdin.readline().split())
nl = lambda : list(map(int, stdin.readline().split()))
t = ni()
for _ in range(t):
	l = nl()
	print(l[1], l[2], l[2])


for i in range(int(input())):
	(a, b, c, d) = sorted(map(int, input().split()))
	y = int((a + b) / 2)
	z = int((b + c) / 2)
	d = int((c + d) / 2)
	print(b, c, c)


def fun(a, b, c, d):
	for i in range(b, a - 1, -1):
		for j in range(c, b - 1, -1):
			if i + j > c:
				return [i, j, c]
t = int(input())
for u in range(t):
	(a, b, c, d) = map(int, input().split())
	a = fun(a, b, c, d)
	print(*a)


t = int(input())
for _ in range(t):
	s1 = list(map(int, input().split()))
	if s1[1] == s1[2]:
		print(s1[1], s1[1], s1[1])
	else:
		print(s1[1], s1[2], s1[2])


test = int(input())
for i in range(test):
	(a, b, c, d) = [int(i) for i in input().split()]
	first = b
	second = c
	third = c
	print(first, second, third, sep=' ')


def solve():
	(a, b, c, d) = map(int, input().split())
	return (b, c, c)
T = int(input())
for t in range(T):
	(x, y, z) = solve()
	print('{} {} {}'.format(x, y, z))


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


from math import *
from collections import *
from operator import itemgetter
import bisect
ii = lambda : int(input())
iia = lambda : list(map(int, input().split()))
isa = lambda : list(input().split())
I = lambda : list(map(int, input().split()))
chrIdx = lambda x: ord(x) - 96
idxChr = lambda x: chr(96 + x)
t = ii()
for _ in range(t):
	(a, b, c, d) = iia()
	print(b, c, c)


t = int(input())
while t > 0:
	x = list(map(int, input().split()))
	print(x[1], x[2], x[2])
	t -= 1


import math

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


for _ in range(int(input())):
	a = list(map(int, input().split()))
	a.sort()
	print(a[1], a[2], a[2])


t = int(input())
for i in range(t):
	l = [int(i) for i in input().split()]
	print(l[1], l[2], l[2])


t = input()
for _ in range(int(t)):
	s = input().split()
	a = int(s[0])
	b = int(s[1])
	c = int(s[2])
	d = int(s[3])
	print(f'{b} {c} {c}')


for s in [*open(0)][1:]:
	(_, b, c, _) = s.split()
	print(b, c, c)


t = int(input())
for i in range(t):
	l1 = list(map(int, input().split()))
	print(l1[1], l1[2], l1[2])


import sys, math, cmath, time
start_time = time.time()

def inp():
	return int(input())

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

def insr():
	return input().strip()

def invr():
	return map(int, input().split())

def solve():
	(a, b, c, d) = invr()
	print(b, c, c)

def main():
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	t = inp()
	for tt in range(t):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
	sys.stdout.close()

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


t = int(input())
while t:
	y = list(map(int, input().split()))
	a = y[0]
	b = y[1]
	c = y[2]
	d = y[3]
	print(b, c, c)
	t -= 1


from sys import stdin

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


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

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

def out(var):
	sys.stdout.write(str(var))

def outln(var):
	sys.stdout.write(str(var) + '\n')

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
for _ in range(int(data())):
	(a, b, c, d) = sp()
	print(b, c, c)


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


count = int(input())
while count > 0:
	(a, b, c, d) = map(int, input().split())
	msg = '%s %s %d' % (b, c, c)
	print(msg)
	count = count - 1


from math import inf
t = int(input())
for q in range(t):
	(a, b, c, d) = [int(i) for i in input().split()]
	print(b, c, c)


import sys
import math

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
for _ in range(int(input())):
	(a, b, c, d) = get_ints()
	print(b, c, c)


n = int(input())
I = []
for i in range(n):
	k = list(map(int, input().split()))
	I.append(k)
for i in range(n):
	print(I[i][1], I[i][2], I[i][2])


t = int(input())
gf = []
for i in range(t):
	A = input().split(' ')
	a = int(A[0])
	b = int(A[1])
	c = int(A[2])
	d = int(A[3])
	gf.append(str(b) + ' ' + str(c) + ' ' + str(c))
for i in range(t):
	print(gf[i])


from pprint import pprint
import sys
input = sys.stdin.readline
import bisect
q = int(input())
for _ in range(q):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


from sys import stdin
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def lsi():
	x = list(stdin.readline())
	x.pop()
	return x

def si():
	return stdin.readline()
res = ['YES', 'NO']

def main():
	(a, b, c, d) = mi()
	if b > c:
		print(b, b, c)
	else:
		print(b, c, c)
	return
test_case = ii()
while test_case:
	main()
	test_case -= 1


import sys
e = int(input())
for ee in range(e):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


def main():
	t = int(input())
	for _ in range(t):
		l = list(map(int, input().split()))
		print(l[1], l[2], l[2])
main()


from sys import stdin, stdout
for testcases in range(int(stdin.readline())):
	(a, b, c, d) = map(int, stdin.readline().split())
	x = b
	y = c
	z = c
	stdout.write(str(x) + ' ' + str(y) + ' ' + str(z) + '\n')


for _ in range(int(input())):
	nums = input().split()
	print(nums[1], nums[2], nums[2])


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


test = int(input())
lista = []
for i in range(test):
	lista2 = []
	(a, b, c, d) = [int(q) for q in input().split()]
	lista2.append(str(b))
	lista2.append(str(c))
	lista2.append(str(c))
	lista.append(' '.join(lista2))
for i in lista:
	print(i)


for _ in range(int(input())):
	arr = input().split(' ')
	print(arr[1], arr[2], arr[2])


def foo(a, b, c, d):
	for i in range(b, a - 1, -1):
		for j in range(c, b - 1, -1):
			for k in range(c, d + 1):
				if i + j > k:
					print(i, j, k)
					return
test = int(input())
while test:
	(a, b, c, d) = (int(x) for x in input().split())
	foo(a, b, c, d)
	test -= 1


a = int(input())
ans = []
for i in range(a):
	l = list(map(int, input().split()))
	u = [l[1], l[2], l[2]]
	ans.append(u)
for i in ans:
	print(i[0], i[1], i[2])


from sys import stdin, stdout
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
tc = ii1()
for _ in range(tc):
	(a, b, c, d) = iia()
	print(b, c, c)


from sys import stdin, stdout
input = stdin.buffer.readline
t = int(input())
while t > 0:
	a = [int(x) for x in input().split()]
	z = a[2]
	y = a[2]
	x = a[1]
	print(x, y, z)
	t -= 1


test = int(input())
while test > 0:
	(a, b, c, d) = [int(x) for x in input().split()]
	(x, y, z) = (b, c, c)
	print(x, y, z)
	test = test - 1


from collections import Counter
cases = int(input())
flag = 0
for _ in range(cases):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


t = int(input())
for i in range(t):
	(a, b, c, d) = [int(tmp) for tmp in input().split()]
	print(b, c, c, sep=' ')


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


import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def bool_to_str(flag):
	if flag:
		return 'YES'
	else:
		return 'NO'
tests = inp()
for i in range(tests):
	abcd = inlt()
	print(abcd[1], abcd[2], abcd[2])


T = int(input())
for _ in range(T):
	raw = input().split(' ')
	a = int(raw[0])
	b = int(raw[1])
	c = int(raw[2])
	d = int(raw[3])
	print(b, c, c)


t = int(input().strip())
for it in range(t):
	vals = [int(i) for i in input().strip().split()]
	(a, b, c, d) = vals
	print(b, c, c)


for i in range(int(input())):
	(w, x, y, z) = map(int, input().split())
	print(x, y, y)


def solve():
	(a, b, c, d) = [int(v) for v in input().split()]
	(z, y, x) = (c, c, b)
	print(' '.join((str(v) for v in (x, y, z))))
t = int(input())
for _ in range(t):
	solve()


def main(b, c):
	return [b, c, c]
t = int(input())
for t_itr in range(t):
	abcd = list(map(int, input().rstrip().split()))
	b = abcd[1]
	c = abcd[2]
	res = main(b, c)
	print(*res)


n = int(input())
cases = [map(int, input().split()) for _ in range(n)]
for case in cases:
	(a, b, c, d) = case
	print(b, c, c)


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip()
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
t = int(input())
for i 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())
	x = b
	y = c
	z = c
	while True:
		if c > int(b / 2):
			print(x, y, c)
			break
		else:
			c += 1


for i in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	for i in range(c, d + 1):
		if b + c > i:
			ans = i
			break
	print(b, c, ans)


import atexit
import io
import sys
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

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

def array_to_string(a):
	s = ''
	for i in a:
		s += str(i)
	return s
t = int(input())
while t > 0:
	t = t - 1
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


n = int(input())
for i in range(n):
	s = input()
	x = s.split(' ')
	print(x[1] + ' ' + x[2] + ' ' + x[2])


def convert_array_to_string(arr):
	for i in range(0, len(arr), 1):
		arr[i] = int(arr[i])
	return arr
testCases = int(input())
while testCases:
	X = input().split()
	array = convert_array_to_string(X)
	a = array[0]
	b = array[1]
	c = array[2]
	d = array[3]
	print(b, c, c)
	testCases -= 1


ss = int(input())
for i in range(ss):
	(a, b, c, d) = [int(x) for x in input().split()]
	print('%d %d %d' % (b, c, c))


t = int(input())
for i in range(t):
	arr = list(map(int, input().split()))
	(a, b, c) = (0, 0, 0)
	a = arr[1]
	b = arr[2]
	c = arr[2]
	print(a, b, c)


from sys import stdin
rints = lambda : [int(x) for x in stdin.readline().split()]
for _ in range(int(input())):
	a = rints()
	print(a[1], a[2], a[2])


import sys
from collections import Counter
input = sys.stdin.readline
t = int(input())
while t:
	t -= 1
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


from sys import stdin, stdout
from collections import defaultdict, Counter
from functools import lru_cache
from math import gcd, floor, ceil

def ilist():
	return [int(x) for x in stdin.readline().strip().split(' ')]

def iint():
	return int(stdin.readline().strip())

def istr():
	return stdin.readline().strip()

def solve(a, b, c, d):
	return ' '.join([str(e) for e in [b, c, c]])
t = iint()
for _ in range(t):
	(a, b, c, d) = ilist()
	print(solve(a, b, c, d))


from sys import stdout, setrecursionlimit

def noop(*object):
	return

def main():
	T = read_int()
	for case_idx in range(T):
		ans = solve_case()
		stdout.write('{}\n'.format(ans))

def solve_case():
	(a, b, c, d) = read_int_list()
	ans = [b, c, c]
	return l2s(ans)

def read_str():
	return input()

def read_int():
	return int(input())

def read_str_list():
	return input().split(' ')

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

def read_lines(n, read_func):
	return [read_func() for _ in range(n)]

def list_to_str(l, sep=' '):
	return sep.join(map(str, l))
l2s = list_to_str
main()


t = int(input())
while t > 0:
	(a, b, c, d) = [int(ele) for ele in input().split()]
	x = b
	y = c
	z = c
	print(x, y, z)
	t -= 1


t = int(input())
z = 0
while z < t:
	(a, b, c, d) = map(int, input().split())
	l = c
	print(b, c, l)
	z = z + 1


t = int(input())
for i in range(t):
	A = []
	(a, b, c, d) = list(map(int, input().split()))
	A.append(b)
	A.append(c)
	A.append(c)
	print(*A)


import sys
lines = sys.stdin.readlines()
T = int(lines[0].strip())
for t in range(1, T + 1):
	nums = list(lines[t].strip().split(' '))
	res = [nums[1], nums[2], nums[2]]
	print(' '.join(res))


import collections, heapq, itertools, math
groupby = itertools.groupby
rs = lambda : input()
ri = lambda : int(input())
rm = lambda : map(int, input().split())
rai = lambda : [int(x) for x in input().split()]

def solve(a, b, c, d):
	for x in reversed(range(a, b + 1)):
		for y in reversed(range(b, c + 1)):
			for z in range(c, d + 1):
				if x + y > z:
					return (x, y, z)
for t in range(ri()):
	(a, b, c, d) = rm()
	(x, y, z) = solve(a, b, c, d)
	print('{} {} {}'.format(x, y, z))


t = int(input())
for _ in range(t):
	a = [int(s) for s in input().split()]
	if min(a) == max(a):
		print(min(a), min(a), min(a))
	else:
		print(a[1], a[2], a[2])


n = int(input())
for _ in range(n):
	(a, b, c, d) = input().split()
	print('{} {} {}'.format(b, c, c))


for i in range(int(input())):
	x = [int(x) for x in input().split()]
	print(x[1], x[2], x[2])


import sys

def main():
	q = []
	for line in sys.stdin.readlines():
		q.append(line)
	for i in range(len(q)):
		q[i] = q[i].rstrip().split(' ')
		q[i] = [int(x) for x in q[i]]
	for i in range(1, len(q)):
		arr = q[i]
		s1 = arr[1]
		s2 = arr[2]
		s3 = arr[2]
		print(s1, s2, s3)
main()


import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
tests = inp()
testcount = 0
while testcount < tests:
	(a, b, c, d) = invr()
	print(b, c, c)
	testcount += 1


t = int(input())
for i in range(t):
	lis = list(map(int, input().split()))
	print(f'{lis[1]} {lis[2]} {lis[2]}')


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


t = int(input())
for i in range(t):
	abcd = list(map(int, input().split()))
	print(str(abcd[1]) + ' ' + str(abcd[2]) + ' ' + str(abcd[2]))


num = input()
for i in range(int(num)):
	num1 = input().split()
	a = int(num1[0])
	b = int(num1[1])
	c = int(num1[2])
	d = int(num1[3])
	x = a
	y = b
	z = c
	x = b
	y = c
	z = c
	print(x, y, z)


def check(a, b, c):
	if a + b <= c or a + c <= b or b + c <= a:
		return False
	else:
		return True
for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	for i in range(c, b - 1, -1):
		if check(b, c, i) == 1:
			print(b, c, i)
			break


import random
import math

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


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')

def main():
	for _ in range(N()):
		(a, b, c, d) = RL()
		print(b, c, c)
main()


t = int(input())
for ti in range(t):
	(a, b, c, d) = [int(i) for i in input().split(' ')]
	print(str(b) + ' ' + str(c) + ' ' + str(c))


for i in range(int(input())):
	z = input().split()
	print(z[1], z[2], z[2])


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys

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


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


t = int(input())
values = [[0 for i in range(4)] for j in range(t)]
for i in range(t):
	values[i] = [int(j) for j in input().split()]
for i in range(t):
	x = values[i][1]
	y = values[i][2]
	z = values[i][2]
	print(int(x), int(y), int(z))


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


k = int(input())
for i in range(0, k):
	(a, b, c, d) = map(int, input().split(' '))
	print(str(b) + ' ' + str(c) + ' ' + str(c))


test = int(input())
for i in range(test):
	(x, y, a, b) = [int(j) for j in input().split()]
	print(y, a, a)


def q():
	abcd = input().split(' ')
	b = int(abcd[1])
	c = int(abcd[2])
	x = b
	y = c
	z = c
	print(f'{x} {y} {z}')
t = int(input())
for i in range(t):
	q()


outputs = []
for __ in range(int(input())):
	(_, b, c, _) = [int(num) for num in input().split()]
	outputs.append(f'{b} {c} {c}')
for o in outputs:
	print(o)


def nod(a, b):
	while a != b:
		(a, b) = (max(a, b), min(a, b))
		if a % b == 0:
			a -= (a // b - 1) * b
		else:
			a -= a // b * b
	return a
for t in range(int(input())):
	(a, b, c, d) = [int(x) for x in input().split()]
	print(b, c, c)


A = []
T = int(input())
for i in range(T):
	A.append([int(x) for x in input().split()])
for X in A:
	print(X[1], X[2], X[2])


import sys
t = int(input())
for i in range(t):
	(a, b, c, d) = list(map(int, sys.stdin.readline().strip().split()))
	if b == c:
		print(b, b, c)
	else:
		print(b, c, c)


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


t = int(input())
for _ in range(t):
	arr = list(map(int, input().split()))
	x = arr[1]
	y = arr[2]
	z = arr[2]
	print(x, y, z)


t = int(input())
while t:
	t -= 1
	(a, b, c, d) = [item for item in map(int, input().strip().split())]
	x = b
	y = c
	z = min(c, x + y - 1)
	print(x, end=' ')
	print(y, end=' ')
	print(z)


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


n = int(input())
while n != 0:
	(p, q, r, s) = map(int, input().split())
	print(f'{q} {r} {r}')
	n = n - 1


import bisect
from collections import defaultdict
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations

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())

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)))

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


from sys import stdin, stdout
from math import *
from heapq import *
from collections import *

def main():
	ntest = int(stdin.readline())
	for testcase in range(ntest):
		(a, b, c, d) = [int(x) for x in stdin.readline().split()]
		stdout.write('%d %d %d\n' % (b, c, c))
	return 0
main()


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()


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from bisect import bisect_left
from bisect import bisect_right

def L():
	return list(map(int, stdin.readline().split()))

def In():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())
P = 1000000007

def main():
	for t in range(I()):
		(a, b, c, d) = In()
		print(b, c, c)
main()


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


import math

class Read:

	@staticmethod
	def string():
		return input()

	@staticmethod
	def int():
		return int(input())

	@staticmethod
	def list(sep=' '):
		return input().split(sep)

	@staticmethod
	def list_int(sep=' '):
		return list(map(int, input().split(sep)))

def solve():
	(a, b, c, d) = Read.list_int()
	print(b, c, c)
query_count = Read.int()
while query_count:
	query_count -= 1
	solve()


t = int(input())
while t:
	line = input().split()
	(a, b, c, d) = (int(line[0]), int(line[1]), int(line[2]), int(line[3]))
	print(b, c, c)
	t -= 1


import math
T = int(input())
for _ in range(1, T + 1):
	(a, b, c, d) = map(int, input().split())
	if b == c:
		print(b, b, b)
		continue
	elif c == d:
		print(b, c, c)
		continue
	print(b, c, c)


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


import sys
input = sys.stdin.readline

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


from collections import defaultdict
t = int(input())
for _ in range(t):
	(a, b, c, d) = map(int, input().split(' '))
	z = c
	y = c
	x = b
	print(x, y, z)


def solve():
	(a, b, c, d) = [int(x) for x in input().split()]
	x = b
	for i in range(c, b - 1, -1):
		if i + x >= c:
			y = i
			z = c
			break
	print(x, y, z)
t = int(input())
for i in range(t):
	solve()


for i in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	ns = [a, b, c, d]
	a = []
	ans = []
	for i in range(3):
		a.append((ns[i], ns[i + 1]))
	a.sort(key=lambda x: x[0])
	print(a[0][1], a[1][1], a[-1][0])


import sys

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

def sieve(n):
	a = [1] * n
	for i in range(2, n):
		if a[i]:
			for j in range(i * i, n, i):
				a[j] = 0
	return a
for __ in range(int(input())):
	(a, b, c, d) = I()
	print(b, c, c)


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


import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def main():
	for _ in range(II()):
		(a, b, c, d) = MI()
		print(b, c, c)
main()


def ab():
	(a, b, c, d) = map(int, input().split())
	print(str(b) + ' ' + str(c) + ' ' + str(c))
for i in range(0, int(input())):
	ab()


def read_int():
	return int(input().strip())

def read_ints():
	return list(map(int, input().strip().split(' ')))

def solve():
	(a, b, c, d) = read_ints()
	return '{} {} {}'.format(b, c, c)
T = read_int()
for _ in range(T):
	print(solve())


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


cases = int(input())
for cas in range(cases):
	(a, b, c, d) = map(int, input().split())
	print(f'{b} {c} {c}')


t = int(input())

def solve(nums):
	print(nums[1], nums[2], nums[2])
for _ in range(t):
	nums = list(map(int, input().split()))
	solve(nums)


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


def IntInput():
	return int(input())

def M_IntInput():
	return map(int, input().split())

def M_StrInput():
	return map(int, input().split())

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

def modInverse(p, a, m):
	return p % m * pow(a % m, m - 2, m) % m
for _ in range(IntInput()):
	(a, b, c, d) = M_IntInput()
	(x, y, z) = (b, c, c)
	print(x, y, z)


t = int(input())
for i in range(t):
	b = list(map(int, input().split()))
	i = b[0]
	j = b[1]
	k = b[2]
	print(j, k, k)


def method1(a, b, c, d):
	found = False
	for i in range(a, b + 1):
		if found:
			break
		for j in range(b, c + 1):
			if found:
				break
			k = i + j
			if k > c:
				print(i, j, k)
				found = True
	if not found:
		print('Not Found!')

def method2(a, b, c, d):
	print(b, c, c)

def main():
	test_case_count = int(input())
	for i in range(test_case_count):
		abcd = input()
		(a, b, c, d) = map(int, abcd.split())
		method2(a, b, c, d)
main()


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


def x(a, b, c):
	return a + b > c and a + c > b and (b + c > a)
t = int(input())
for i in range(t):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


t = int(input())
while t != 0:
	i = []
	i = input().split()
	print(f'{i[1]} {i[2]} {i[2]}')
	t = t - 1


test_case = int(input())
for i in range(test_case):
	values = list(map(int, input().split(' ')))
	print(max(values[0], values[1]), max(values[1], values[2]), max(values[1], values[2]))


t = int(input())
for i in range(t):
	abcd = list(map(int, input().split()))
	a = abcd[0]
	b = abcd[1]
	c = abcd[2]
	x = 0
	y = 0
	z = 0
	x = b
	y = c
	z = c
	print(x, y, z)


import sys

def data():
	return sys.stdin.readline().strip()
out = sys.stdout.write

def mdata():
	return map(int, data().split())
from collections import defaultdict as dd
for i in range(int(data())):
	(a, b, c, d) = mdata()
	print(b, c, c)


test = int(input())

def solve():
	n = list(map(int, input().split()))
	result = [n[1], n[2], n[2]]
	print(*result)
for x in range(test):
	solve()


from collections import Counter, defaultdict, deque, namedtuple
from math import gcd
import sys

class BufferedTokenizer:
	pass

def read_ints():
	return [int(token) for token in input().split()]

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

def main():
	T = read_ints()[0]
	for case_no in range(1, T + 1):
		(a, b, c, d) = read_ints()
		print(b, c, c)
main()


import sys
input = lambda : sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline

def I():
	return list(map(int, inp().split()))
for _ in range(I()[0]):
	(a, b, c, d) = I()
	print(b, c, c)


import sys
inp = sys.stdin.readline
read = lambda : list(map(int, inp().split()))

def a():
	ans = ''
	for _ in range(int(inp())):
		(a, b, c, d) = read()
		print(b, c, c)

def b():
	ans = ''
	for _ in range(int(inp())):
		(a, b, c, d) = read()
a()


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


mod = 10 ** 9 + 7
import math
from bisect import bisect_left
from collections import Counter
from itertools import combinations

def ain():
	return map(int, input().split())

def fain():
	return map(float, input().split())

def mc2(s):
	return s * (s - 1) // 2 + s
for tc in range(int(input())):
	(a, b, c, d) = ain()
	x = b
	y = c
	z = c
	print(x, y, z)


t = int(input())
while t > 0:
	t = t - 1
	li = list(map(int, input().split()))
	print(li[1], li[2], li[2])


for n in range(int(input())):
	s = sorted(list(map(int, input().split())))
	print(s[1], s[2], s[2])


from collections import defaultdict as dd
for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


I = lambda : list(map(int, input().split()))
for tc in range(int(input())):
	(a, b, c, d) = sorted(I())
	print(b, c, c)


t = int(input())
for i in range(0, t):
	lista = [int(x) for x in input().split()]
	print(lista[1], lista[2], lista[2])


for _ in range(int(input())):
	l1 = input().split()
	mark = list(map(int, l1[0:]))
	(x, y, z) = (int(0), int(0), int(0))
	x = mark[1]
	y = mark[2]
	z = mark[2]
	print(x, y, z)


t = int(input())
for _ in range(t):
	(a, b, c, d) = map(int, input().rstrip().split())
	x = b
	y = c
	z = c
	while True:
		if x + y > z and x + z > y and (y + z > x):
			print(x, y, z)
			break
		z += 1


import sys
import math
input = sys.stdin.readline

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

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


from sys import stdin, stdout
from sys import maxsize
input = stdin.readline

def solve():
	pass
test = 1
test = int(input().strip())
for t in range(0, test):
	(n, k, h, u) = list(map(int, input().strip().split()))
	print(k, h, h)
	ans = solve()


a = int(input())
for i in range(0, a):
	arr = list(map(int, input().split()))
	print(arr[1], arr[2], arr[2])


def probA(s):
	a = []
	for i in range(len(s)):
		a.append([s[i][1], s[i][2], s[i][2]])
	return a
t = int(input().strip())
lis = []
for i in range(t):
	lis.append(list(map(int, input().strip().split())))
result = probA(lis)
for i in result:
	print(*i)


import sys
from sys import stdin, stdout

def R():
	return map(int, stdin.readline().strip().split())
for h in range(int(stdin.readline())):
	(a, b, c, d) = R()
	print(b, c, c)


for _ in range(int(input())):
	l = [int(x) for x in input().split()]
	print(l[1], l[2], l[2])


t = int(input())
while t:
	x = list(map(int, input().split()))
	a = x[0]
	b = x[1]
	c = x[2]
	d = x[3]
	p = b
	q = c
	r = c
	print(p, q, r)
	t -= 1


from itertools import *
from collections import *
import bisect
for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


T = int(input())
for test in range(T):
	[A, B, C, D] = list(map(int, input().split()))
	print(B, C, C)


import sys
t = input()
for i in range(int(t)):
	ar = []
	ar = map(int, input().split())
	ar = list(ar)
	print(ar[1], end=' ')
	print(ar[2], end=' ')
	print(ar[2])
	sys.stdout.flush()


import sys
input = sys.stdin.readline
read = lambda : map(int, input().split())
read_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

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

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

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(councils, a, k):
	summ = 0
	for x in a:
		summ += min(x, councils)
	return summ // councils >= k
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
import bisect as bis
import random
import sys

def solve():
	(a, b, c, d) = read()
	print(b, c, c)
for _ in range(int(input())):
	solve()


t = int(input())
for caso in range(t):
	nums = list(map(int, input().split(' ')))
	print(max(nums[0], nums[1]), max(nums[1], nums[2]), min(nums[2], nums[3]))


n = int(input())
for i in range(n):
	k = list(map(int, input().split()))
	print(k[1], end=' ')
	print(k[2], end=' ')
	print(k[2])


for _ in range(int(input())):
	(h, n, m, k) = map(int, input().split())
	print(n, m, m)


import math
import os
import random
import re
import sys
from math import gcd
from math import sqrt
for _ in range(int(input())):
	(a, b, c, d) = list(map(int, input().split()))
	print(b, c, c)


T = int(input())
for t in range(T):
	(a, b, c, d) = map(int, input().split())
	print('{} {} {}'.format(b, c, c))


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


import sys
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
for tt in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


from sys import stdin, stdout
from collections import Counter

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

def ei():
	return map(int, input().split())

def ip():
	return int(stdin.readline())

def op(ans):
	return stdout.write(str(ans) + '\n')
for i in range(ip()):
	(a, b, c, d) = ei()
	print(b, c, c)


def scan_one(type='int'):
	if type == 'int':
		return int(input())
	elif type == 'float':
		return float(input())

def scan_more(type='int'):
	if type == 'int':
		return list(map(int, input().split()))
	elif type == 'float':
		return list(map(float, input().split()))
a = scan_one()
for i in range(a):
	(a, b, c, d) = scan_more()
	print(b, c, c)


case = int(input())
for i in range(case):
	(a, b, c, d) = map(int, input().split())
	k = (b + c) // 2
	print(b, c, c)


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


import sys
t = int(sys.stdin.readline().rstrip())
arr = []
try:
	while True:
		imsi = list(map(int, sys.stdin.readline().rstrip().split()))
		if len(imsi) == 0:
			break
		else:
			arr.append(imsi)
except:
	pass
for i in range(t):
	three = arr[i][2]
	for j in range(arr[i][2], arr[i][1] - 1, -1):
		two = j
		check = False
		for k in range(arr[i][1], arr[i][0] - 1, -1):
			one = k
			if one + two > three:
				print(one, two, three)
				check = True
				break
		if check is True:
			break


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


for k in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	flag = True
	print(str(b) + ' ' + str(c) + ' ' + str(c))


from sys import stdin, stdout
from collections import defaultdict as df
t = int(input())
for i in range(t):
	(a, b, c, d) = list(map(int, input().split()))
	ans = []
	ans.append(b)
	if c > b:
		ans.append(c)
	else:
		ans.append(b)
	ans.append(c)
	print(*ans)


from sys import stdin, gettrace
if not gettrace():

	def input():
		return next(stdin)[:-1]

def main():

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


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


t = int(input())
count = 0
final = []
while count < t:
	sides = input()
	sides = sides.split(' ')
	z = sides[-2]
	y = sides[-2]
	x = sides[1]
	l = [x, y, z]
	final.append(l)
	count += 1
for x in final:
	print(' '.join(x))


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


nb_triangle = int(input())
for i in range(nb_triangle):
	longueur = str(input())
	longueur = longueur.split()
	print(str(longueur[1]) + ' ' + str(longueur[2] + ' ' + str(longueur[2])))


from math import factorial
from math import log, ceil
from collections import defaultdict
from math import *
from sys import stdin, stdout
import itertools
import os
import sys
import threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
from fractions import Fraction
mod = 998244353

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d:
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d:
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1
	return isPrime

def dijkstra(edges, f, t):
	g = defaultdict(list)
	for (l, r, c) in edges:
		g[l].append((c, r))
	(q, seen, mins) = ([(0, f, ())], set(), {f: 0})
	while q:
		(cost, v1, path) = heappop(q)
		if v1 not in seen:
			seen.add(v1)
			path = (v1, path)
			if v1 == t:
				return (cost, path)
			for (c, v2) in g.get(v1, ()):
				if v2 in seen:
					continue
				prev = mins.get(v2, None)
				next = cost + c
				if prev is None or next < prev:
					mins[v2] = next
					heappush(q, (next, v2, path))
	return float('inf')

def binsearch(a, l, r, x):
	while l <= r:
		mid = l + (r - 1) // 2
		if a[mid]:
			return mid
		elif a[mid] > x:
			l = mid - 1
		else:
			r = mid + 1
	return -1

def find_all_paths(graph, start, end, path=[]):
	path = path + [start]
	if start == end:
		return path
	paths = []
	for node in graph[start]:
		if node not in path:
			newpaths = find_all_paths(graph, node, end, path)
			for newpath in newpaths:
				paths.append(newpath)
	return paths
for _ in range(ii()):
	(a, b, c, d) = mi()
	print(b, c, c)


class Solver(object):

	def __init__(self, debug=False):
		self.debug = debug

	def d(self, *args):
		if self.debug:
			import sys
			print(*args, file=sys.stderr)
			pass

	def precalc(self):
		pass

	def solve(self):
		(a, b, c, d) = map(int, input().split(' '))
		return ' '.join(map(str, [b, c, c]))
s = Solver(debug=False)
s.precalc()
NUM_CASES = int(input())
for CASE_NO in range(1, NUM_CASES + 1):
	result = s.solve()
	print('{}'.format(result))


def driver(f):
	print('{} {} {}'.format(f[1], f[2], f[2]))

def main():
	for i in range(int(input())):
		f = [int(x) for x in input().split()]
		driver(f)
main()


T = int(input())
for t in range(T):
	line = [int(i) for i in input().split()]
	(a, b, c, d) = (line[0], line[1], line[2], line[3])
	x = b
	y = c
	z = c
	print(x, y, z)


import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda : int(input())
li = lambda : list(map(int, input().split()))

def case():
	(a, b, c, d) = li()
	print(b, c, c)
for _ in range(int(input())):
	case()


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	arr = []
	arr.append(l[1])
	arr.append(l[2])
	arr.append(l[2])
	print(*arr, sep=' ')


def solve():
	inp = []
	inp = input().split()
	print(inp[1], inp[2], inp[2])
t = int(input())
for i in range(t):
	solve()


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


t = int(input())
for _ in range(t):
	(a, b, c, d) = [int(el) for el in input().split()]
	x1 = b
	x3 = c
	x2 = c
	print(x1, x2, x3)


import io
import os
from collections import Counter, defaultdict, deque

def solve(ABCD):
	return str(ABCD[1]) + ' ' + str(ABCD[2]) + ' ' + str(ABCD[2])
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	ABCD = [int(x) for x in input().split()]
	ans = solve(ABCD)
	print(ans)


from math import ceil, gcd, floor
from collections import deque, defaultdict
from heapq import heappush as hpush, heappop as hpop, heapify
from functools import lru_cache
import sys
inf = float('inf')

def inpi():
	return int(input())

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

def inp():
	s = input()
	return list(s)

def inpv():
	return map(int, input().split())
testcase = int(input())
for test in range(testcase):
	(a, b, c, d) = inpv()
	print(b, c, c)


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


N = int(input())
num = []
for i in range(N):
	num.append(input().split())
for j in range(N):
	print(num[j][1], num[j][2], num[j][2])


t = int(input())
while t > 0:
	l = list(map(int, input().split()))
	l.sort()
	(a, b, c) = (l[1], l[2], l[3])
	print(a, b, b)
	t = t - 1


def answer():
	n = int(input())
	c_out = []
	while n:
		a = input().split()
		c_out.append(a[1] + ' ' + a[2] + ' ' + a[2])
		n -= 1
	for x in c_out:
		print(x)
answer()


for _ in [*open(0)][1:]:
	(a, b, c, d) = map(int, _.split())
	print(f'{b} {c} {c}')


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


def res(l):
	print(l[1], l[2], l[2])
t = int(input())
while t > 0:
	t = t - 1
	l = list(map(int, input().split()))
	res(l)


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


from sys import stdin
inp = stdin.readline
t = int(inp().strip())
for _ in range(t):
	(a, b, c, d) = [int(x) for x in inp().strip().split()]
	print(b, c, c)


import sys
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 998244353
for _ in range(int(ri())):
	(a, b, c, d) = Ri()
	print(b, c, c)


for i in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	for j in range(c, d + 1):
		if j <= b + c:
			print(b, c, j, sep=' ')
			break


def Sol(a, b, c, d):
	x = b
	y = c
	z = c
	while x >= a and y >= b and (z <= d):
		if x + y > z and max(y, z) - min(y, z) < x and (max(x, z) - min(x, z) < y):
			break
	print(str(x) + ' ' + str(y) + ' ' + str(z))
	return
for i in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	Sol(a, b, c, d)


import sys
from itertools import accumulate

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
	(a, b, c, d) = MAP()
	print(b, c, c)


count = int(input())
for i in range(count):
	pole = list(map(int, input().split()))
	c = pole[2]
	b = pole[2]
	a = pole[1]
	print(a, b, c)


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


from sys import stdin, stdout
for test in range(int(stdin.readline())):
	arr = [int(x) for x in stdin.readline().split()]
	stdout.write(str(arr[1]) + ' ' + str(arr[2]) + ' ' + str(arr[2]) + '\n')


def main():
	t = int(input())
	for _ in range(t):
		(a, b, c, d) = [int(i) for i in input().split()]
		print('%s %s %s' % (b, c, c))
main()


def main():
	t = int(input())
	for _ in range(t):
		line = input().split()
		(a, b, c, d) = (int(line[0]), int(line[1]), int(line[2]), int(line[3]))
		print(str(b) + ' ' + str(c) + ' ' + str(c))
main()


import heapq
num = int(input())

def chech_tri(a, b, c, d):
	for i in range(b, a - 1, -1):
		for j in range(c, b - 1, -1):
			for k in range(c, d + 1):
				tri = [i, j, k]
				min_2 = heapq.nsmallest(2, tri)
				if sum(min_2) > max(tri):
					return (i, j, k)
for _ in range(num):
	pos_int = input()
	(a, b, c, d) = map(int, pos_int.split())
	(i, j, k) = chech_tri(a, b, c, d)
	print(i, j, k)


for _ in range(int(input())):
	numbers = input().split()
	numbers = [int(x) for x in numbers]
	print(numbers[1], numbers[2], numbers[2])


import sys
import math
t = int(input())

def solve(nums):
	[a, b, c, d] = nums
	print(str(b) + ' ' + str(c) + ' ' + str(c))
for i in range(t):
	numss = input().split()
	nums = [int(i) for i in numss]
	solve(nums)


def polycarp():
	for i in range(int(input())):
		x = list(map(int, input().split()))
		print(x[1], x[2], x[2])
polycarp()


t = int(input())
for _ in range(t):
	z = input().split()
	print(' '.join([z[1], z[2], z[2]]))


from math import *
from copy import *
from heapq import *
from string import *
from random import *
from bisect import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
from collections import defaultdict

def solve(l):
	(a, b, c, d) = l
	if a == b == c:
		return [a, b, c]
	if b == c == d:
		return [b, c, d]
	x = a
	y = b
	z = c
	if x + y < z and y + z < x and (x + z < y):
		return [x, y, z]
	else:
		x = b
		y = c
		z = d
		if x + y < z and y + z < x and (x + z < y):
			return [x, y, z]
	x = b
	y = b
	z = c
	if x + y < z and y + z < x and (x + z < y):
		return [x, y, z]
	x = b
	y = c
	z = c
	if x + y < z and y + z < x and (x + z < y):
		return [x, y, z]
	return [x, y, z]
T = int(input())
for _ in range(T):
	l = list(map(int, stdin.readline().rstrip().split()))
	print(*solve(l))


def main():
	t = int(input())
	while t > 0:
		inp = [int(x) for x in input().split()]
		(a, b, c, d) = (inp[0], inp[1], inp[2], inp[3])
		for s3 in range(c, d + 1, 1):
			s1 = a
			s2 = b
			print(str(b) + ' ' + str(c) + ' ' + str(s3))
			break
		t -= 1
main()


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


t = int(input())
math = [''] * t
for i in range(t):
	h = input().split(' ')
	x = h[1]
	y = h[2]
	math[i] = x + ' ' + y + ' ' + y
for i in range(t):
	print(math[i])


Test = int(input())
for T in range(Test):
	L = list(map(int, input().split()))
	Cad = ''
	for K in range(1, 3):
		Cad = Cad + str(L[K]) + ' '
	Cad = Cad + str(L[K])
	print(Cad)


t = int(input())
for l in range(t):
	li = list(map(int, input().split()))
	print('{} {} {}'.format(li[1], li[2], li[2]))


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


x = int(input())
for i in range(0, x):
	(a, b, c, d) = [int(v) for v in input().split()]
	print(b, c, c)


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


t = int(input())
while t != 0:
	(m, n, o, p) = input().split()
	print(n + ' ' + o + ' ' + o)
	t = t - 1


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
import random
from queue import PriorityQueue
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def solve(n):
	return n * (n + 1) // 2
for _ in range(10 ** 5):
	pass
for _ in range(10 ** 5):
	pass
for _ in range(10 ** 5):
	pass
t = int(input())
for _ in range(t):
	(a, b, c, d) = map(int, input().split())
	print(b, c, c)


for _ in range(0, int(input())):
	(a, b, c, d) = list(map(int, input().split()))
	x = b
	y = c
	for i in range(max(abs(x - y), c), d + 1):
		if i < x + y:
			z = i
			break
	print(x, y, z)


import sys
import math
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
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
t = int(input())
for tt in range(t):
	(a, b, c, d) = map(int, sys.stdin.readline().split(' '))
	print(b, c, c)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


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


def tra(a, b, c, d):
	print(b, c, c)
	return
t = int(input())
for i in range(t):
	T = input()
	l = list(map(int, T.split(' ')))
	tra(l[0], l[1], l[2], l[3])


from math import *

def _i():
	return [int(i) for i in input().split()]

def _f():
	return [int(i) for i in input().split()]
for zz in range(int(input())):
	(a, b, c, d) = _i()
	print(b, c, c)


T = int(input())
n = [0] * T
m = [0] * T
ns = [0] * T
for t in range(T):
	ns[t] = [int(i) for i in input().split(' ')]
for t in range(T):
	print(ns[t][1], ns[t][2], ns[t][2])


from sys import stdin
testcase = True
if testcase:
	t = int(stdin.readline())
	while t:
		t -= 1
		(a, b, c, d) = map(int, stdin.readline().split())
		print(b, c, c)
else:
	n = int(stdin.readline())
	a = stdin.readline().split()


t = int(input())

def answer(a, b, c, d):
	x = b
	y = c
	z = c
	lst = [x, y, z]
	return lst
final = list()
for i in range(t):
	data = input()
	data = data.split()
	lst = list()
	a = int(data[0])
	b = int(data[1])
	c = int(data[2])
	d = int(data[3])
	final = final + answer(a, b, c, d)
j = 0
while j < len(final) - 2:
	print(final[j], final[j + 1], final[j + 2])
	j = j + 3


for _ in range(int(input())):
	k = list(map(int, input().split()))
	if k[1] + k[2] > k[2]:
		print(k[1], k[2], k[2])


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


t = int(input())
for tt in range(t):
	nn = input()
	nn = nn.split()
	n = list()
	for i in nn:
		n.append(int(i))
	print(n[1], n[2], n[2])


for _ in range(int(input())):
	(_, b, c, _) = [int(s) for s in input().split()]
	print(b, c, c)


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


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
from fractions import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 1000010
MOD = 10 ** 9 + 7
spf = [i for i in range(MAXN)]
spf[0] = spf[1] = -1

def sieve():
	for i in range(2, MAXN, 2):
		spf[i] = 2
	for i in range(3, int(MAXN ** 0.5) + 1):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def fib(n, m):
	if n == 0:
		return [0, 1]
	else:
		(a, b) = fib(n // 2)
		c = a % m * (b % m * 2 - a % m) % m
		d = a % m * (a % m) % m + b % m * b % m % m
		if n % 2 == 0:
			return [c, d]
		else:
			return [d, c + d]

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

def ncr(n, r):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD

def flush():
	return sys.stdout.flush()
for _ in range(int(input())):
	(a, b, c, d) = arrIN()
	print(b, c, c)


import math
test = int(input())
while test:
	arr = list(map(int, input().split()))
	print(str(arr[1]) + ' ' + str(arr[2]) + ' ' + str(arr[2]))
	test -= 1


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


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	t = I()
	rr = []
	for _ in range(t):
		(a, b, c, d) = LI()
		rr.append(JA([b, c, c], ' '))
	return JA(rr, '\n')
print(main())


tcase = int(input())
for _ in range(tcase):
	nums = list(map(int, input().split()))
	print(nums[1], nums[2], nums[2])


import math
T = int(input())
for t in range(T):
	(a, b, c, d) = input().split()
	a = int(a)
	b = int(b)
	c = int(c)
	d = int(d)
	found = False
	for z in range(c, d + 1):
		if found:
			break
		for y in reversed(range(b, c + 1)):
			if found:
				break
			for x in reversed(range(a, b + 1)):
				if found:
					break
				if z < x + y:
					print(x, y, z)
					found = True


def func(n):
	for i in range(n):
		l = list(map(int, input().split()))
		print(l[1], l[2], l[2])
n = int(input())
func(n)


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
for _testcases_ in range(int(input())):
	(a, b, c, d) = get_ints()
	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():
	q = rlinput()
	print(q[1], q[2], q[2])
for i in range(iinput()):
	main()


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math
t = int(input())
for i in range(t):
	l = list(map(int, input().split(' ')))
	print(l[1], l[2], l[2])


from sys import stdin
input = stdin.readline

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

def B():
	return

def C():
	return

def D():
	return
A()


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

def gift():
	for _ in range(t):
		(a, b, c, d) = list(map(int, input().split()))
		yield (str(b) + ' ' + str(c) + ' ' + str(c))
t = int(input())
ans = gift()
print(*ans, sep='\n')


t = int(input())
ans = []
for i in range(t):
	(a, b, c, d) = map(int, input().split(' '))
	ans.append(max(a, b))
	ans.append(max(b, c))
	ans.append(min(c, d))
j = 0
while j in range(t * 3):
	print(ans[j], end=' ')
	print(ans[j + 1], end=' ')
	print(ans[j + 2])
	j = j + 3


tc = int(input())
while tc > 0:
	(a, b, c, d) = map(int, input().split())
	print(f'{b} {c} {c}')
	tc -= 1


BT = int(input())
for i in range(BT):
	T = True
	(a, b, c, d) = map(int, input().split())
	x = b
	y = c
	z = c
	if x + y > z and y + z > x and (x + z > y):
		T = False
		print(x, y, z)


t = int(input())
for test in range(t):
	(a, b, c, d) = map(int, input().rstrip().split())
	l = [str(b), str(c), str(c)]
	print(' '.join(l))


from sys import stdin
input = lambda : stdin.readline().strip()
from math import ceil, sqrt, factorial, gcd
for _ in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	(x, y, z) = (0, 0, 0)
	if a == b:
		x = a
	else:
		x = b
	if b == c:
		y = c
	else:
		y = c
	if c == d:
		z = c
	else:
		z = c
	print(x, y, z)


n = int(input(''))
for h in range(n):
	a = list(map(int, input().split()))
	p = list()
	for i in range(3):
		if i < 2:
			p.append(a[i + 1])
		elif i == 2:
			p.append(a[i])
	print(p[0], p[1], p[2])


for _ in range(int(input())):
	l = list(map(int, input().split()))
	x = l[1]
	y = l[2]
	z = l[2]
	print(x, y, z)


T = int(input())
for tc in range(T):
	(a, b, c, d) = map(int, input().split())
	x = b
	y = c
	z = c
	print('{} {} {}'.format(x, y, z))


t = int(input())
a = []
for i in range(t):
	s = input()
	a = s.split()
	print(a[1], a[2], a[2])


from sys import stdin
debug = False

def join(_s, _l):
	return _s.join(map(str, _l))

def read(_f=None):
	if _f == None:
		return stdin.readline().strip()
	return _f(stdin.readline().strip())

def readlist(_f=None):
	_l = stdin.readline().strip().split()
	if _f == None:
		return _l
	return map(_f, _l)
readint = lambda : read(int)
readints = lambda : readlist(int)
printval = lambda _r: print(_r, end=' ')
printline = lambda _s, _r: print(join(_s, _r), end='\n')

def solve():
	(a, b, c, d) = readints()
	print(b, c, c)
t = readint()
for _ in range(t):
	if debug:
		print('-' * 20)
	if debug:
		print('ANS: ', end='')
	solve()


for i in range(int(input())):
	arr = list(map(int, input().split(' ')))
	if arr[0] == arr[1]:
		x = arr[1]
	else:
		x = arr[1]
	if arr[1] == arr[2]:
		y = arr[2]
	else:
		y = arr[2]
	if arr[2] == arr[3]:
		z = arr[3]
	else:
		z = arr[2]
	print(x, y, z)


try:
	t = int(input())
	for i in range(t):
		lst = list(map(int, input().split()))
		print(lst[1], lst[2], lst[2])
except:
	pass


t = int(input())
for tt in range(t):
	l = list(map(int, input().split()))
	print(l[1], l[2], l[2])


import random
for ii in range(int(input())):
	(a, b, c, d) = map(int, input().split())
	print(b, c, min(c, d))


cases = int(input())
for x in range(cases):
	inp = list(map(int, input().strip().split()))
	print(inp[1], inp[2], inp[2])


def main():
	cc = int(input())
	for i in range(cc):
		(a, b, c, d) = [int(x) for x in input().split()]
		print('{} {} {}'.format(b, c, c))
main()


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


import collections

class Solution:

	def solve(self):
		pass
sol = Solution()
t = int(input().strip())
for i in range(t):
	[a, b, c, d] = list(map(int, input().strip().split()))
	print(b, c, c)


x = int(input())
for i in range(x):
	l = list(map(int, input().split()))
	print(l[1], l[2], l[2])


import sys
import math
t = int(sys.stdin.readline())
for i in range(t):
	line = sys.stdin.readline()
	(a, b, c, d) = list(map(int, line.split()))
	print(b, c, c)


t = int(input())
q = []
for i in range(t):
	q.append(list(map(int, input().rstrip().split())))
for i in range(t):
	a = q[i][0]
	b = q[i][1]
	c = q[i][2]
	d = q[i][3]
	avg = (b + c + d) / 3
	if abs(avg - b) > abs(avg - c):
		x = b
		y = c
		z = c
	else:
		x = b
		y = b
		z = c
	print(x, y, z)


t = int(input())
for i in range(t):
	s = input().split()
	a = int(s[0])
	b = int(s[1])
	c = int(s[2])
	d = int(s[3])
	if b > c:
		print('{} {} {}'.format(b, b, c))
	else:
		print('{} {} {}'.format(b, c, c))


t = int(input())
while t:
	(a, b, c, d) = input().split()
	print(f'{b} {c} {c}')
	t = t - 1


def solve():
	(a, b, c, d) = map(int, input().strip().split(' '))
	return [b, c, c]
t = int(input())
for _ in range(t):
	print(*solve())


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	ans = []
	for _ in range(n):
		(a, b, c, d) = LI()
		ans.append((b, c, c))
	for (a, b, c) in ans:
		print(a, b, c)
main()


I = lambda : list(map(int, input().split()))
for _ in range(int(input())):
	(a, b, c, d) = I()
	if 2 * c > b:
		print(b, c, c)
	else:
		print(b, c, d)


x = int(input())
ret = []
for i in range(x):
	t = input().split(' ')
	ret.append(t[1] + ' ' + t[2] + ' ' + t[2])
for i in ret:
	print(i)


t = int(input())
cases = []
for _ in range(t):
	(a, b, c, d) = [int(i) for i in input().split()]
	print('{b} {c} {c}'.format(b=str(b), c=str(c)))