Problem: 2057C - Trip to the Olympiad
Language: python

Solution 1 (runtime: 171 ms):
import sys
import math
import random
from heapq import *
from collections import Counter, defaultdict, deque
from functools import lru_cache
from itertools import permutations, combinations
from bisect import bisect_right, bisect_left, bisect
import decimal
import time
import re


input = lambda: sys.stdin.readline().rstrip()
minput = lambda: map(int, input().split())
linput = lambda: list(minput())


N = 64
MOD = 1000000007
MOD2 = 998244353
INF = 10 ** 50
ans = INF
primes = []
primes100 = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97)
primes1000 = (
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,
257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,
401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557,
563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997)
MODS = [920000647, 920000663, 950000929, 999999937, 999999527, 999999151, 1000000007, 1000000009, 1000000021, 1000000033]
PS = [131, 137, 139, 149, 151, 157, 163, 167, 173, 179]

def timing(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        result_time = end-start
        if result_time > 0.001:
            print(f"Времени заняло: {result_time:.5f} секунд")
        return res
    return wrapper


def factorization_list(n):
    """Разложение числа на простые множители в виде списка чисел"""
    res = []
    while n % 2 == 0:
        n //= 2
        res.append(2)

    i = 3
    while i**2 <= n:
        while n % i == 0:
            n //= i
            res.append(i)
        i += 2
    if n > 1:
        res.append(n)
    return sorted(res)


def factorization_dict(n):
    """Разложение числа на простые множители в словарь"""
    res = defaultdict(int)
    while n % 2 == 0:
        res[2] += 1
        n //= 2
    i = 3
    while i**2 <= n:
        while n % i == 0:
            res[i] += 1
            n //= i
        i += 2
    if n > 1:
        res[n] += 1
    return res


def sieve(primes_N):
    """Решето Эратосфена"""
    global primes
    primes = [1]*(primes_N+1)
    primes[0] = primes[1] = 0
    for j in range(4, primes_N+1, 2):
        primes[j] = 0

    i = 3
    while i**2 <= primes_N:
        if primes[i]:
            for j in range(i**2, primes_N+1, i):
                primes[j] = 0
        i += 2



def log2(n):
    """Логарифм по основанию 2"""
    res = 0
    while n:
        n >>= 1
        res += 1
    return res-1


def dfs(v, g, dp, vals, vis):
    vis[v] = 1
    for u in g[v]:
        if not vis[u]:
            vis[u] = 1
            dfs(u, g, dp, vals, vis)
            dp[v][0] += max(dp[u][0] + abs(vals[u][0]-vals[v][0]), dp[u][1]+abs(vals[u][1]-vals[v][0]))
            dp[v][1] += max(dp[u][0] + abs(vals[u][0]-vals[v][1]), dp[u][1]+abs(vals[u][1]-vals[v][1]))
            


            
            


def bfs(a, cnt, g):
    vis = [0]*(len(cnt))
    q = deque()
    for i in a:
        q.append((i, 1))
    res = -1
    while q:
        v, lvl = q.popleft()
        if cnt[v] > 0:
            res = max(res, lvl)
            continue
        for u in g[v]:

            if vis[u] == 0 and cnt[u] > 0:
                vis[u] = 1
                q.append((u, lvl+1))
            cnt[u] -= 1
    if res == -1:
        return 2
    return res+1


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

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


def is_setbit(number, bit):
    """Проверка установлен ли bit бит в числе number"""
    return (number >> bit) & 1



def setbit(number, bit):
    """Устанавливает bit бит в числе number"""
    number |= (1 << bit)
    return number


def togbit(number, bit):
    """Переключает bit бит в числе number"""
    number ^= (1 << bit)
    return number

def unsetbit(number, bit):
    """Обнуляет bit бит в числе number"""
    number &= ~(1 << bit)
    return number
               


def apr(start, end, step=1):
    """Формула арифметической прогрессии"""
    if start > end:
        if end % step == start % step:
            start, end = end, start
        else:
            if end % step < start % step:
                end += (start%step) - (end%step)
            else:
                end += (step-end%step) + (start%step)
            start, end = end, start
    
    count = (end-start)//step+1
    res = 0
    if end % step != start % step:
        if end % step > start % step:
            end -= (end%step)-(start%step)
        else:
            end -= (end%step)+(step-start%step)
    res += (start+end)*count//2
    return res


def cumsum(array):
    """Префикс сумма массива"""
    res = [0]*(len(array)+1)
    for i in range(len(array)):
        res[i+1] = res[i] + array[i]
    return res


def segsum(pref, left, right):
    """Вычисляет сумму префикс суммы на отрезке [left, right]"""
    return pref[right] - pref[left-1]


def mult(array, mod=None):
    """Вычисляет произведение всего списка по модулю"""
    res = 1
    for i in array:
        res *= i
        if mod is not None:
            res %= mod
    return res


def z_func(s):
    """Z-функция строки"""
    l, r = 0, 0
    n = len(s)
    z = [0]*n
    for i in range(1, n):
        if r >= i:
            z[i] = min(z[i-l], r-i+1)
        while z[i] + i < n and s[z[i]] == s[z[i]+i]:
            z[i] += 1
        if z[i] + i - 1 > r:
            l = i
            r = z[i] + i - 1
    return z


def get_hash():
    """Возвращает модули и основания для хеширования"""
    mod1, mod2 = random.sample(MODS, 2)
    p1, p2 = random.sample(PS, 2)
    return [mod1, mod2, p1, p2]

def get_pows(p, k, mod):
    """Вычисляет массив степеней p по модулю mod, длины k, начиная с p^0"""
    res = [0]*k
    cur = 1 % mod 
    for i in range(k):
        res[i] = cur
        cur *= p
        cur %= mod
    return res
        


def hashing(s, mod, p):
    """Вычисляет хеш строки по модулю mod с основанием p"""
    hsh = [0]
    n = len(s)
    h = 0
    for i in range(n):
        cur = ord(s[i]) - ord('a') + 1
        h = (p*h + cur) % mod
        hsh.append(h)
    return hsh


def seg_hash(hsh, l, r, pows, mod):
    """Вычисляет хеш подстроки [l, r]"""
    right = hsh[r+1]
    left = hsh[l]*pows[r-l+1]
    res = right-left
    return res%mod


def search(a, x):
    left = -1
    right = len(a)
    while left + 1 <right:
        mid = (left + right)//2
        if a[mid][0] <= x:
            left = mid
        else:
            right = mid
    return left



def pred():
    pass




def solve():
    l, r = minput()
    for i in range(32, -1, -1):
        if (l >> i) & 1 != (r >> i) & 1:
            x = 1 << i
            break

    x = r//x * x
    y = x-1
    for i in range(l, r+1):
        if i != x and i != y:
            z = i
            break
    print(x,y,z)
    

    
        
#@timing
def main():
    pred()
    tc = 1
    tc = int(input())
    for _ in range(tc):
        solve()



            
    


if __name__ == "__main__":
    main()
    



Solution 2 (runtime: 124 ms):
from __future__ import division, print_function

import os,sys
from io import BytesIO, IOBase
from functools import reduce

if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip


def ii():  return int(input())
def si():  return input()
def mi():  return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li():  return list(mi())

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
	
#from collections import deque, Counter, OrderedDict,defaultdict
#from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
from math import log2,sqrt,isqrt,factorial,cos,tan,sin,radians,ceil,floor
#from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
#from decimal import *
#import threading
#from itertools import reduce,permutations
#Copy 2D list  m = [x[:] for x in mark] .. Avoid Using Deepcopy

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
#mod=99824435
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0,1,-1,1,-1],[0,0,1,-1,1,-1,-1,1]
def getKey(item): return item[1] 
def sort2(l):return sorted(l, key=getKey,reverse=True)
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 ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))



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

def gcd(x, y):
	while y:
		x, y = y, x % y
	return x
	
def isPrime(n) : # Check Prime Number or not 
	if (n <= 1) : return False
	if (n <= 3) : return True
	if (n % 2 == 0 or n % 3 == 0) : return False
	i = 5
	while(i * i <= n) : 
		if (n % i == 0 or n % (i + 2) == 0) : 
			return False
		i = i + 6
	return True



def read():
	sys.stdin  = open('input.txt', 'r')  
	sys.stdout = open('output.txt', 'w') 

def op(i,j,k):
	return (i^j)+(j^k)+(k^i)
	
def f(n):
    num_bits=floor(log2(n))+1
    mask = int('1' * num_bits, 2)
    result = n ^ mask
    return result

def ms(x,y):
	bx = bin(x)[2:]
	by = bin(y)[2:]
	d=len(bx)-len(by)
	if d<0:
		return floor(log2(y))+1
	else:
		count = len(by)
		for i,j in zip(bx,by):
			if i==j:
				count-=1
				continue
			return count 	

def main():
	
	for _ in range(ii()):
		l,r = mi()
		k = floor(log2(l^r))
		x = l|((1<<k)-1)
		if x==l:
			y=x+1
			z=x+2
		else:
			y=x-1
			if x+1<=r:
				z=x+1
			else:
				z=l
		print(x,y,z)
		



































# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py

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):
	"""Prints the values to a stream, or to sys.stdout by default."""
	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")

# endregion


if __name__ == "__main__":
	#read()
	main()
	#dmain()

# Comment Read()