You are given positive integers $N$ and $D$. You may perform operations of the following two types:
- add $D$ to $N$, i.e. change $N$ to $N+D$
- change $N$ to $\mathop{\mathrm{digitsum}}(N)$
Here, $\mathop{\mathrm{digitsum}}(x)$ is the sum of decimal digits of $x$. For example, $\mathop{\mathrm{digitsum}}(123)=1+2+3=6$, $\mathop{\mathrm{digitsum}}(100)=1+0+0=1$, $\mathop{\mathrm{digitsum}}(365)=3+6+5=14$.
You may perform any number of operations (including zero) in any order. Please find the minimum obtainable value of $N$ and the minimum number of operations required to obtain this value.
-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains two space-separated integers $N$ and $D$.
-----Output-----
For each test case, print a single line containing two space-separated integers — the minimum value of $N$ and the minimum required number of operations.
-----Constraints-----
- $1 \le T \le 10$
- $1 \le N, D \le 10^{10}$
-----Subtasks-----
Subtask #1 (30 points): $1 \le N, D \le 100$
Subtask #2 (70 points): original constraints
-----Example Input-----
3
2 1
9 3
11 13
-----Example Output-----
1 9
3 2
1 4
-----Explanation-----
Example case 1: The value $N=1$ can be achieved by 8 successive "add" operations (changing $N$ to $10$) and one "digit-sum" operation.
Example case 2: You can prove that you cannot obtain $N=1$ and $N=2$, and you can obtain $N=3$.
The value $N=3$ can be achieved by one "add" and one "digitsum" operation, changing $9$ to $12$ and $12$ to $3$.  
Example case 3: $N=1$ can be achieved by operations "add", "add", "digitsum", "digitsum": $11 \rightarrow 24 \rightarrow 37 \rightarrow 10 \rightarrow 1$.
def disum(x):
    x=str(x)
    sum=0
    for i in range(len(x)):
        sum+=int(x[i])
    return sum
for _ in range(int(input())):
    n,d=map(int,input().split())
    ans={}
    souma=[(n,0)]
    ushijima=1
    i=0
    while i<1000:
        nakiri=souma.pop(0)
        if nakiri[0]<10:
            if nakiri[0] not in ans:
                ans[nakiri[0]]=nakiri[1]
        else:
            souma.append((disum(nakiri[0]),nakiri[1]+1))
        souma.append((nakiri[0]+d,nakiri[1]+1))
        i+=1
    print(min(ans),ans[min(ans)])

def disum(x):
    x=str(x)
    sum=0
    for i in range(len(x)):
        sum+=int(x[i])
    return sum
for _ in range(int(input())):
    n,d=map(int,input().split())
    ans={}
    souma=[(n,0)]
    ushijima=1
    i=0
    while i<1000:
        nakiri=souma.pop(0)
        if nakiri[0]<10:
            if nakiri[0] not in ans:
                ans[nakiri[0]]=nakiri[1]
        else:
            souma.append((disum(nakiri[0]),nakiri[1]+1))
        souma.append((nakiri[0]+d,nakiri[1]+1))
        i+=1
    print(min(ans),ans[min(ans)])
