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: 186 ms):
import sys,math,heapq
from collections import Counter
#sys.setrecursionlimit(200000)
#fin = open('input.txt', 'r')
#input = lambda: fin.readline().strip()
input=lambda: sys.stdin.readline().strip()
import random
RANDOM = random.getrandbits(20)


class Wrapper(int):
    def __init__(self, x):
        int.__init__(x)

    def __hash__(self):
        return super(Wrapper, self).__hash__() ^ RANDOM

def I():
    return input()
def II():
    return int(input())
def MI():
    return map(int, input().split())
def LI():
    return list(input().split())
def LII():
    return list(map(int, input().split()))
def LFI():
    return list(map(float, input().split()))
def GMI():
    return map(lambda x: int(x) - 1, input().split())
def LGMI():
    return list(map(lambda x: int(x) - 1, input().split()))
from types import GeneratorType
def bootstrap(f, stack=[]):
    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:
                    if not stack:break
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to

    return wrappedfunc

class SortedList:
    def __init__(self, iterable=None, _load=200):
        """Initialize sorted list instance."""
        if iterable is None:
            iterable = []
        values = sorted(iterable)
        self._len = _len = len(values)
        self._load = _load
        self._lists = _lists = [values[i:i + _load]
                                for i in range(0, _len, _load)]
        self._list_lens = [len(_list) for _list in _lists]
        self._min_s = [_list[0] for _list in _lists]
        self._fen_tree = []
        self._rebuild = True

    def _fen_build(self):
        """Build a fenwick tree instance."""
        self._fen_tree[:] = self._list_lens
        _fen_tree = self._fen_tree
        for i in range(len(_fen_tree)):
            if i | i + 1 < len(_fen_tree):
                _fen_tree[i | i + 1] += _fen_tree[i]
        self._rebuild = False

    def _fen_update(self, index, value):
        """Update `fen_tree[index] += value`."""
        if not self._rebuild:
            _fen_tree = self._fen_tree
            while index < len(_fen_tree):
                _fen_tree[index] += value
                index |= index + 1

    def _fen_query(self, end):
        """Return `sum(_fen_tree[:end])`."""
        if self._rebuild:
            self._fen_build()

        _fen_tree = self._fen_tree
        x = 0
        while end:
            x += _fen_tree[end - 1]
            end &= end - 1
        return x

    def _fen_findkth(self, k):
        """Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
        _list_lens = self._list_lens
        if k < _list_lens[0]:
            return 0, k
        if k >= self._len - _list_lens[-1]:
            return len(_list_lens) - 1, k + _list_lens[-1] - self._len
        if self._rebuild:
            self._fen_build()

        _fen_tree = self._fen_tree
        idx = -1
        for d in reversed(range(len(_fen_tree).bit_length())):
            right_idx = idx + (1 << d)
            if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
                idx = right_idx
                k -= _fen_tree[idx]
        return idx + 1, k

    def _delete(self, pos, idx):
        """Delete value at the given `(pos, idx)`."""
        _lists = self._lists
        _mins = self._min_s
        _list_lens = self._list_lens

        self._len -= 1
        self._fen_update(pos, -1)
        del _lists[pos][idx]
        _list_lens[pos] -= 1

        if _list_lens[pos]:
            _mins[pos] = _lists[pos][0]
        else:
            del _lists[pos]
            del _list_lens[pos]
            del _mins[pos]
            self._rebuild = True

    def _loc_left(self, value):
        """Return an index pair that corresponds to the first position of `value` in the sorted list."""
        if not self._len:
            return 0, 0

        _lists = self._lists
        _mins = self._min_s

        lo, pos = -1, len(_lists) - 1
        while lo + 1 < pos:
            mi = (lo + pos) >> 1
            if value <= _mins[mi]:
                pos = mi
            else:
                lo = mi

        if pos and value <= _lists[pos - 1][-1]:
            pos -= 1

        _list = _lists[pos]
        lo, idx = -1, len(_list)
        while lo + 1 < idx:
            mi = (lo + idx) >> 1
            if value <= _list[mi]:
                idx = mi
            else:
                lo = mi

        return pos, idx

    def _loc_right(self, value):
        """Return an index pair that corresponds to the last position of `value` in the sorted list."""
        if not self._len:
            return 0, 0

        _lists = self._lists
        _mins = self._min_s

        pos, hi = 0, len(_lists)
        while pos + 1 < hi:
            mi = (pos + hi) >> 1
            if value < _mins[mi]:
                hi = mi
            else:
                pos = mi

        _list = _lists[pos]
        lo, idx = -1, len(_list)
        while lo + 1 < idx:
            mi = (lo + idx) >> 1
            if value < _list[mi]:
                idx = mi
            else:
                lo = mi

        return pos, idx

    def add(self, value):
        """Add `value` to sorted list."""
        _load = self._load
        _lists = self._lists
        _mins = self._min_s
        _list_lens = self._list_lens

        self._len += 1
        if _lists:
            pos, idx = self._loc_right(value)
            self._fen_update(pos, 1)
            _list = _lists[pos]
            _list.insert(idx, value)
            _list_lens[pos] += 1
            _mins[pos] = _list[0]
            if _load + _load < len(_list):
                _lists.insert(pos + 1, _list[_load:])
                _list_lens.insert(pos + 1, len(_list) - _load)
                _mins.insert(pos + 1, _list[_load])
                _list_lens[pos] = _load
                del _list[_load:]
                self._rebuild = True
        else:
            _lists.append([value])
            _mins.append(value)
            _list_lens.append(1)
            self._rebuild = True

    def discard(self, value):
        """Remove `value` from sorted list if it is a member."""
        _lists = self._lists
        if _lists:
            pos, idx = self._loc_right(value)
            if idx and _lists[pos][idx - 1] == value:
                self._delete(pos, idx - 1)

    def remove(self, value):
        """Remove `value` from sorted list; `value` must be a member."""
        _len = self._len
        self.discard(value)
        if _len == self._len:
            raise ValueError('{0!r} not in list'.format(value))

    def pop(self, index=-1):
        """Remove and return value at `index` in sorted list."""
        pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
        value = self._lists[pos][idx]
        self._delete(pos, idx)
        return value

    def bisect_left(self, value):
        """Return the first index to insert `value` in the sorted list."""
        pos, idx = self._loc_left(value)
        return self._fen_query(pos) + idx

    def bisect_right(self, value):
        """Return the last index to insert `value` in the sorted list."""
        pos, idx = self._loc_right(value)
        return self._fen_query(pos) + idx

    def count(self, value):
        """Return number of occurrences of `value` in the sorted list."""
        return self.bisect_right(value) - self.bisect_left(value)

    def __len__(self):
        """Return the size of the sorted list."""
        return self._len

    def __getitem__(self, index):
        """Lookup value at `index` in sorted list."""
        pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
        return self._lists[pos][idx]

    def __delitem__(self, index):
        """Remove value at `index` from sorted list."""
        pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
        self._delete(pos, idx)

    def __contains__(self, value):
        """Return true if `value` is an element of the sorted list."""
        _lists = self._lists
        if _lists:
            pos, idx = self._loc_left(value)
            return idx < len(_lists[pos]) and _lists[pos][idx] == value
        return False

    def __iter__(self):
        """Return an iterator over the sorted list."""
        return (value for _list in self._lists for value in _list)

    def __reversed__(self):
        """Return a reverse iterator over the sorted list."""
        return (value for _list in reversed(self._lists)
                for value in reversed(_list))

    def __repr__(self):
        """Return strings representation of sorted list."""
        return 'SortedList({0})'.format(list(self))


class RangeAscendRangeMax:
    def __init__(self, n):
        self.n = n
        self.cover = [-math.inf] * (4 * n)
        self.lazy = [-math.inf] * (4 * n)

    @staticmethod
    def _max(a, b):
        return a if a > b else b

    def _make_tag(self, i, val) -> None:
        self.cover[i] = self._max(self.cover[i], val)
        self.lazy[i] = self._max(self.lazy[i], val)
        return

    def _push_up(self, i):
        self.cover[i] = self._max(self.cover[2 * i], self.cover[2 * i + 1])
        return

    def _push_down(self, i):
        if self.lazy[i] != -math.inf:
            self.cover[2 * i] = self._max(self.cover[2 * i], self.lazy[i])
            self.cover[2 * i + 1] = self._max(self.cover[2 * i + 1], self.lazy[i])
            self.lazy[2 * i] = self._max(self.lazy[2 * i], self.lazy[i])
            self.lazy[2 * i + 1] = self._max(self.lazy[2 * i + 1], self.lazy[i])
            self.lazy[i] = -math.inf
        return

    def build(self, nums) -> None:
        assert self.n == len(nums)
        stack = [(0, self.n - 1, 1)]
        while stack:
            s, t, ind = stack.pop()
            if ind >= 0:
                if s == t:
                    self._make_tag(ind, nums[s])
                else:
                    stack.append([s, t, ~ind])
                    m = s + (t - s) // 2
                    stack.append([s, m, 2 * ind])
                    stack.append([m + 1, t, 2 * ind + 1])
            else:
                ind = ~ind
                self._push_up(ind)
        return

    def get(self):
        stack = [(0, self.n - 1, 1)]
        nums = [0] * self.n
        while stack:
            s, t, i = stack.pop()
            if s == t:
                nums[s] = self.cover[i]
                continue
            m = s + (t - s) // 2
            self._push_down(i)
            stack.append((s, m, 2 * i))
            stack.append((m + 1, t, 2 * i + 1))
        return nums

    def range_ascend(self, left, right, val):
        # update the range ascend
        assert 0 <= left <= right <= self.n - 1
        stack = [(0, self.n - 1, 1)]
        while stack:
            a, b, i = stack.pop()
            if i >= 0:
                if left <= a and b <= right:
                    self._make_tag(i, val)
                    continue
                self._push_down(i)
                stack.append([a, b, ~i])
                m = a + (b - a) // 2
                if left <= m:
                    stack.append([a, m, 2 * i])
                if right > m:
                    stack.append([m + 1, b, 2 * i + 1])
            else:
                i = ~i
                self._push_up(i)
        return

    def range_max(self, left, right):
        # query the range max
        assert 0 <= left <= right <= self.n - 1
        stack = [(0, self.n - 1, 1)]
        highest = -math.inf
        while stack:
            a, b, i = stack.pop()
            if left <= a and b <= right:
                highest = self._max(highest, self.cover[i])
                continue
            self._push_down(i)
            m = a + (b - a) // 2
            if left <= m:
                stack.append([a, m, 2 * i])
            if right > m:
                stack.append([m + 1, b, 2 * i + 1])
        return highest


class SegmentTree:
    #LUOGU 3372
    def __init__(self,num_of_elements,initial_lst):
        self.tree=[0]*(4*num_of_elements)
        #self.lazy=[0]*(4*num_of_elements)
        self.lst=initial_lst
    def build(self,s,t,p):
        if s==t:
            self.tree[p]=self.lst[s]
            return
        m=s+((t-s)>>1)
        self.build(s,m,p*2)
        self.build(m+1,t,p*2+1)
        self.tree[p]=math.gcd(self.tree[p*2],self.tree[p*2+1])
    def query(self,l,r,s,t,p):
        #print(l,r,s,t)
        if l<=s and r>=t:
            return self.tree[p]
        m=s+((t-s)>>1)
        csum=0
        if l<=m:
            csum=self.query(l,r,s,m,p*2)
        if r>m:
            if csum!=0:
                csum=math.gcd(csum,self.query(l,r,m+1,t,p*2+1))
            else:
                csum=self.query(l,r,m+1,t,p*2+1)
        return csum 
from collections import deque
import bisect
mod=998244353
class Factorial:
    def __init__(self, N, mod) -> None:
        N += 1
        self.mod = mod
        self.f = [1 for _ in range(N)]
        self.g = [1 for _ in range(N)]
        for i in range(1, N):
            self.f[i] = self.f[i - 1] * i % self.mod
        self.g[-1] = pow(self.f[-1], mod - 2, mod)
        for i in range(N - 2, -1, -1):
            self.g[i] = self.g[i + 1] * (i + 1) % self.mod

    def fac(self, n):
        return self.f[n]

    def fac_inv(self, n):
        return self.g[n]

    def combi(self, n, m):
        if n < m or m < 0 or n < 0: return 0
        return self.f[n] * self.g[m] % self.mod * self.g[n - m] % self.mod

    def permu(self, n, m):
        if n < m or m < 0 or n < 0: return 0
        return self.f[n] * self.g[n - m] % self.mod

    def catalan(self, n):
        return (self.combi(2 * n, n) - self.combi(2 * n, n - 1)) % self.mod

    def inv(self, n):
        return self.f[n-1] * self.g[n] % self.mod
def main():
    l,r=MI()
    b=bin(l)[2:]

    c=bin(r)[2:]
    b='0'*(len(c)-len(b))+b
    ans1=''
    ans2=''
    
    for i in range(len(b)):
        if b[i]==c[i]:
            ans1+=b[i]
            ans2+=b[i]
        else:
            ans1+='1'
            ans2+='0'
            for j in range(len(b)-i-1):
                ans1+='0'
                ans2+='1'
            break
    #print(ans1)
    b=int(ans1,2)
    if b+1<=r:
        print(b+1,b,b-1)
    else:
        print(b,b-1,b-2)
   


    

t=1
t=II()
for i in range(t):
    w = main()  
    #print(w)
    #fout.write(str(w))