import sys
import threading

def main():
    import sys
    # sys.setrecursionlimit(1 << 25)
    q = int(sys.stdin.readline())
    queries = []
    y_max = 0
    for _ in range(q):
        x_str, y_str = sys.stdin.readline().split()
        x = int(x_str)
        y = int(y_str)
        queries.append((x, y))
        y_max = max(y_max, y)
    y_max = min(y_max, 10**5)  # Since y ≤ 1e7

    MAX_X = y_max + 10000  # Slightly larger to avoid index issues
    MAX_K = 24  # Since 2^24 > 1e7, adjust as needed
    INF = MAX_X + 100000

    # Precompute sum of digits
    s = [0] * (MAX_X + 1)
    for i in range(1, MAX_X + 1):
        s[i] = s[i // 10] + i % 10

    # Precompute next[0][x] = x + s(x)
    next_jump = [[0] * (MAX_X + 1) for _ in range(MAX_K + 1)]
    for x in range(1, MAX_X + 1):
        nx = x + s[x]
        if nx <= MAX_X:
            next_jump[0][x] = nx
        else:
            next_jump[0][x] = INF

    # Build jump table
    for k in range(1, MAX_K + 1):
        for x in range(1, MAX_X + 1):
            nx = next_jump[k - 1][x]
            if nx <= MAX_X:
                next_jump[k][x] = next_jump[k - 1][nx]
            else:
                next_jump[k][x] = INF

    # Answer queries
    for x, y in queries:
        curr_x = x
        if curr_x > MAX_X:
            # x is beyond precomputed range
            # Simulate steps until x > y
            while curr_x <= y:
                curr_s = sum(map(int, str(curr_x)))
                curr_x += curr_s
            print(curr_x)
            continue

        # Binary lifting
        for k in range(MAX_K, -1, -1):
            if next_jump[k][curr_x] <= y:
                curr_x = next_jump[k][curr_x]

        # Simulate remaining steps
        while curr_x <= y:
            if curr_x + s[curr_x] > y:
                curr_x += s[curr_x]
                break
            else:
                curr_x += s[curr_x]
        print(curr_x)

# threading.Thread(target=main).start()
main()