#include <bits/stdc++.h>
using namespace std;

template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;

template <class F> struct ycr {
	F f;
	template <class T> explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... A> decltype(auto) operator()(A&&... as) {
		return f(ref(*this), forward<A>(as)...);
	}
};
template <class F> decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

template <class T> void setmin(T& a, const T& b) {
	if (b < a) a = b;
}

using ll = int64_t;
using i128 = __uint128_t;

string i128_to_string(i128 n) {
	assert(n > 0);
	string res;
	while (n > 0) {
		res += char(int(n % 10) + '0');
		n /= 10;
	}
	reverse(res.begin(), res.end());
	return res;
}

const int L = 37;
V<i128> p10(L);

string solve(ll X, int K) {
	V<int> Xdigits(L);
	{
		auto t = X;
		for (int l = 0; l < L; l++) {
			Xdigits[l] = int(t % 10);
			t /= 10;
		}
		assert(t == 0);
	}

	if (K == 0) {
		int f = 0;
		while (Xdigits[f] == 9) {
			f++;
		}
		return string("1") + string(f, '0');
	}
	assert(K >= 1);

	// dp(# of carries, carry) = (min of highest digit,
	// state with the min of second highest digit)
	const i128 INF = i128(-1);
	VV<i128> dp(K+1, V<i128>(2, INF));
	dp[0][0] = 0;
	for (int l = 0; l+1 < L; l++) {
		// TODO: Check feasibility of (l+1)-digit y
		if (l > 0) {
			i128 cnd = dp[K][0];
			if (cnd < INF) {
				return i128_to_string(cnd);
			}
		}

		int vx = Xdigits[l];
		VV<i128> ndp(K+1, V<i128>(2, INF));
		for (int num_carries = 0; num_carries <= K; num_carries++) {
			for (int carry : {0, 1}) {
				if (dp[num_carries][carry] == INF) continue;
				for (int vy = 0; vy < 10; vy++) {
					int new_carry = (vx + vy + carry) / 10;
					int new_num_carries = num_carries + new_carry;
					if (new_num_carries <= K) {
						setmin(ndp[new_num_carries][new_carry], dp[num_carries][carry] + vy * p10[l]);
					}
				}
			}
		}
		swap(dp, ndp);
	}

	// ok
	return string("-1");
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	p10[0] = 1;
	for (int l = 1; l < L; l++) {
		p10[l] = p10[l-1] * i128(10);
	}

	int T;
	cin >> T;
	while (T--) {
		ll X;
		int K;
		cin >> X >> K;
		cout << solve(X, K) << '\n';
	}

	return 0;
}