Problem: 2057C - Trip to the Olympiad
Language: PyPy 3-64


Submission (verdict: Wrong answer on test 2):
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()
    a, b, c = 0, 0, 0
    flag = True
    flag1 = False
    for i in range(32, -1, -1):
        if (r >> i) & 1 != (l >> i) & 1:
            if (l >> i) & 1 == 0:
                c += 1 << i
            else:
                a += 1 << i
                b += 1 << i
        elif not flag:
            if (l >> i) & 1 == 0:
                a += 1 << i
                b += 1 << i
            else:
                a += 1 << i
                b += 1 << i
        elif (l >> i) & 1 == 1:
            a += 1 << i
            b += 1 << i
            c += 1 << i

        if (r >> i) & 1 != (l >> i) & 1:
            flag = False
    for i in range(32):
        cur = a ^ (1 << i)
        if l <= cur <= r and cur != b and cur != c:
            a ^= (1 << i)
            break
    if a != b:
        print(a,b,c)
        return
    a0 = 50
    a1 = 50
    for i in range(32):
        if (a >> i)&1 == 0:
            a0 = min(a0, i)
        else:
            a1 = min(a1, i)
    a ^= 1 << a0
    a ^= 1 << a1
    print(a,b,c)
    

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



            
    


if __name__ == "__main__":
    main()