from functools import wraps

def memoize(function):
    memo = {}
    @wraps(function)
    def f(*args):
        if args not in memo:
            memo[args] = function(*args)
        return memo[args]
    f.memo = memo
    return f

denom = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000]
denct = [1, 4, 1, 1,  4,  1,  1,   4,   1,   1,    4,    1,    1,     4,     1]

def valueset(denom):
    def values(i):
        if i == 0:
            return set([0])
        v = values(i-1)
        return v | set(s + denom[i-1] for s in v)
    return values(len(denom))

LOW = 30

pchangeus = [None]*(LOW+1)
changeus = [None]*(LOW+1)
for i in xrange(len(denom)+1):
    changeus, pchangeus = pchangeus, changeus
    for n in xrange(LOW+1):
        if n == 0:
            changeus[n] = [[]]
        elif i == 0:
            changeus[n] = []
        else:
            res = []
            for ct in xrange(denct[i-1]+1):
                if n >= ct*denom[i-1]:
                    res += [x + ct*[denom[i-1]] for x in pchangeus[n - ct*denom[i-1]]]
            changeus[n] = res

guarantee = [None]*(LOW+1)
for n in xrange(LOW+1):
    g = None
    for v in changeus[n]:
        v = valueset(v)
        if g is None:
            g = v
        else:
            g &= v
    guarantee[n] = g


smalls = [
    (),
    (1,),
    (5,2,2,2),
    (2,),
    (1,2),
    (5,2,2,2,2),
    (2,2),
    (5,),
    (2,2,2),
    (1,5),
    (5,2),
    (2,2,2,2),
    (1,5,2),
    (5,2,2),
]

smalls_by_mod = [[] for i in xrange(10)]
for small in smalls:
    smalls_by_mod[sum(small) % 10].append(small)

from collections import defaultdict
to_get = [defaultdict(list) for i in xrange(10)]
for small in smalls:
    for value in valueset(small):
        to_get[value % 10][small].append(value)

@memoize
def F(n,k,*offs):
    assert max(map(max, offs)) <= 1
    assert min(map(min, offs)) >= 0
    
    best = min(LOW,n)
    def good(m,(om,ok)):
        return m-om < 0 or k-ok in guarantee[m-om]
    while best >= 0 and not all(good(best,off) for off in offs):
        best -= 1

    if n > LOW:
        for md in xrange(10):
            m = n
            while m % 10 != md: m -= 1

            noffs = []
            good = True
            for om,ok in offs:
                if not smalls_by_mod[(m-om)%10]:
                    good = False
                    break
                for repre in smalls_by_mod[(m-om)%10]:
                    if not to_get[(k-ok)%10][repre]:
                        good = False
                        break
                    for deval in to_get[(k-ok)%10][repre]:
                        nom = (om + sum(repre)) / 10
                        nok = (ok + deval) / 10
                        noffs.append((nom,nok))
                if not good:
                    break

            if good:
                curr = F(m/10,k/10,*set(noffs))*10+md
                if curr >= 0:
                    best = max(best, curr)

    return best


for cas in xrange(input()):
    n, k = map(int, raw_input().strip().split())
    print F(n,k,(0,0))