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

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

Solution 2 (runtime: 171 ms):
import collections
import decimal
import math
import random
import time
import sys
from heapq import heappop, heappush
from collections import deque
from decimal import Decimal
import queue
import os
from copy import deepcopy
from collections import Counter

mod = 10 ** 9 + 7
# mod = 998244353
INF = 1 << 90


def solve(test_case):
    l, r = map(int, sys.stdin.readline().split())

    p = 0

    for i in range(32, -1, -1):
        if ((l & (1 << i)) != 0) != ((r & (1 << i)) != 0):
            p += (1 << i)
            break

        p += (1 << i) * int((l & (1 << i)) != 0)

    if p - 1 > l:
        res = [p, p - 1, p - 2]
    elif p - 1 == l:
        res = [p + 1, p, p - 1]
    else:
        res = [p + 2, p + 1, p]

    sys.stdout.write(' '.join(map(str, res)) + '\n')

    return


if __name__ == '__main__':
    multitest = 1
    if multitest:
        t = int(sys.stdin.readline())
        for _ in range(t):
            solve(_)
    else:
        solve(0)