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

Solution 1 (runtime: 171 ms):
import sys
# input = lambda :sys.stdin.readline()[:-1]
ni = lambda :int(input())
na = lambda :list(map(int,input().split()))
yes = lambda :print("yes");Yes = lambda :print("Yes");YES = lambda : print("YES")
no = lambda :print("no");No = lambda :print("No");NO = lambda : print("NO")
#######################################################################

for _ in range(ni()):
    l, r = na()
    L = 0
    X = 0
    R = 0
    FLAG = 0
    for i in range(30, -1, -1):
        ll = l >> i & 1
        rr = r >> i & 1
        if FLAG:
            L |= 1 << i
        elif ll == rr:
            L |= ll << i
            R |= rr << i
            X |= ll << i
        else:
            R |= 1 << i
            FLAG = 1
    # assert l <= L <= r and l <= R <= r and l <= L ^ 1 <= r
    # assert (L ^ 1 != R)
    if l <= L ^ 1 <= r and L^1 != R:
        print(L, L^1, R)
    elif l <= R ^ 1 <= r and R^1 != L:
        print(L, R^1, R)
    else:
        assert False
    #print(bin(L), bin(L^1), bin(R))
    # print(print(bin(L^R)))

Solution 2 (runtime: 203 ms):
# defaultdict, set, [i]*n, {}
# bootstrap for recursion
import os
from math import *
from heapq import *
from functools import lru_cache,reduce
from collections import *
from bisect import *
from itertools import *
import sys
from bisect import *
from io import BytesIO, IOBase
from types import GeneratorType
import random
RANDOM = random.randrange(2**62)

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 bootstrap(f, stack=[]):
    """
    @bootstrap
    def fun():
        ans = yield fun()
        yield ans
    """
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc
class dsu:
    def __init__(self, n):
        self.parent = [i for i in range(n)]
        self.rank = [0] * n
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    
    def union(self, x, y):
        xset, yset = self.find(x), self.find(y)
        if xset != yset:
            if self.rank[xset] < self.rank[yset]:
                self.parent[xset] = yset
            elif self.rank[xset] > self.rank[yset]:
                self.parent[yset] = xset
            else:
                self.parent[xset] = yset
                self.rank[yset] += 1
            return True
        return False
class segment_tree:
    def __init__(self, data, func=min):
        self.func = func
        self._data = _data = [list(data)]
        i, n = 1, len(_data[0])
        while 2 * i <= n:
            prev = _data[-1]
            _data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])
            i <<= 1
    def query(self, start, stop):
        if start >= stop:
            return 0
        depth = (stop - start).bit_length() - 1
        return self.func(self._data[depth][start], self._data[depth][stop - (1 << depth)])
    def __getitem__(self, idx):
        return self._data[0][idx]
class fenwick_tree:
    def __init__(self,n):
        self.arr=[0]*(n+1)
        self.len=n
    def add(self,ind,v):
        ind+=1
        while(ind<=self.len):
            self.arr[ind]+=v
            ind+= ind & (-ind)
    def query(self,ind):
        ind+=1
        ans=0
        while(ind):
            ans+=self.arr[ind]
            ind-= ind & (-ind)
        return ans
def bins(array, x, l, h):
    while l <= h:
        m = l + (h - l)//2
        if array[m] == x:
            return m
        elif array[m] < x:
            l = m + 1
        else:
            h = m - 1
    return l
def factorials(MAX,MOD):
    factorial = [1] * MAX
    for i in range(1, MAX):
        factorial[i] = factorial[i - 1] * i % MOD
def mod_inverse(a, p):
    res = 1
    exp = p - 2
    while exp > 0:
        if exp % 2 == 1:
            res = res * a % p
        a = a * a % p
        exp //= 2
    return res
def invfactorials(MAX,MOD):
    invfactorial = [1] * MAX
    invfactorial[MAX - 1] = mod_inverse(factorial[MAX - 1], MOD)
    for i in range(MAX - 2, -1, -1):
        invfactorial[i] = invfactorial[i + 1] * (i + 1) % MOD
def ncr(n, r, factorial,invfactorial):
    if r > n:
        return 0
    return factorial[n] * invfactorial[r] % MOD * invfactorial[n - r] % MOD
def prime_div(n):
    pd = {}
    while n % 2 == 0:
        pd[2] = pd.get(2, 0) + 1
        n //= 2
    for i in range(3, int(sqrt(n)) + 1, 2):
        while n % i == 0:
            pd[i] = pd.get(i, 0) + 1
            n //= i
    if n > 2:
        pd[n] = pd.get(n, 0) + 1
    return pd
def radix(A):
    num_digits = len(str(max(A)))
    for digit in range(0, num_digits):
        B = [[] for _ in range(10)]
        for item in A:
            num = item // 10 ** (digit) % 10
            B[num].append(item)
        A = reduce(lambda x, y: x + y, B)
    return A
def gcd(a,b):
    if a%b==0:
        return b
    else:
        return gcd(b,a%b)
def lcm(a,b):
    return a//gcd(a,b)*b
inf = float('inf')
MOD = 10**9 + 7 
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
inps = lambda: map(int,input().split())
inpl = lambda: list(map(int, input().split()))
inpt = lambda: int(input())
yes = lambda: print("YES")
no = lambda: print("NO")
df = lambda: defaultdict(lambda:False)
dl = lambda: defaultdict(list)
d1 = lambda: defaultdict(lambda:-1)
d0 = lambda: defaultdict(lambda:0)
w = lambda x: x^RANDOM

def solve():
    l,r = inps()
    smm = 0 
    while True:
        p = 1
        while p*2 <= r:
            p*= 2
        if p <= l:
            l-= p
            r -= p
            smm += p
        else:
            break
    t = p+1 if p+1<=r else p-2
    print(smm+p, smm+p-1,smm+t)



    

n =1
n = inpt()
for _ in range(n):
    solve()