#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <unordered_map>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <random>
#include <ctime>
#include <cstdlib>
#include <chrono>

using namespace std;

using ll = long long;

struct usu {
  int c, i, j, t;
};

void solve() {
  ll x;
  int k;
  cin >> x >> k;

  if (k == 0) {
    ll p = 1;
    while (x > 0) {
      if (x % 10 != 9) {
        cout << p << "\n";
        return;
      }
      p = p * 10;
      x /= 10;
    }

    cout << p << '\n';
    return;
  }

  ll off = 1, offk = 0;
  while (x % 10 == 0) {
    off *= 10;
    x /= 10;
    ++offk;
  }

  vector<int> cif;
  cif.push_back(0);
  while (x > 0) {
    cif.push_back(x % 10);
    x /= 10;
  }

  int n = cif.size();
  
  if (k > n - 1) {
    bool fs = true;
    string ans;

    while (offk--) {
      ans.push_back('0');
    }

    for (int i = 1; i < n; ++i) {
      if (fs && cif[i] == 0) {
        ans.push_back('0');
        continue;
      }

      --k;
      ans.push_back('0' + 10 - cif[i] - 1 + fs);
      fs = false;
    }

    while (k--) {
      ans.push_back('9');
    }

    reverse(ans.begin(), ans.end());
    cout << ans << "\n";
    return;
  }
  
  vector<vector<vector<int>>> dp(n + 1, vector<vector<int>>(k + 1, vector<int>(2, -1)));
  vector<vector<vector<usu>>> tt(n + 1, vector<vector<usu>>(k + 1, vector<usu>(2)));

  dp[1][0][0] = 0;

  vector<ll> p10(n + 1, 1);
  for (int i = 1; i < n; ++i) {
    if (i > 1) {
      p10[i] = p10[i - 1] * 10;
    }

    int r = 0, nxt = i + 1;
    while (nxt < n && cif[nxt] == 9) {
      ++r;
      ++nxt;
    }

    for (int j = 0; j <= k; ++j) {
      if (dp[i][j][0] == -1) {
        continue;
      }

      if (dp[i + 1][j][0] == -1) {
        dp[i + 1][j][0] = 1; 
        tt[i + 1][j][0] = {0, i, j, 0};
      }

      if (cif[i] == 0 || j + 1 + r > k) {
        continue;
      }

      if (dp[nxt][j + 1 + r][1] == -1) {
        dp[nxt][j + 1 + r][1] = 1; 
        tt[nxt][j + 1 + r][1] = {10 - cif[i], i, j, 0};
      }
    }

    for (int j = 0; j <= k; ++j) {
      if (dp[i][j][1] == -1) {
        continue;
      }

      if (dp[i + 1][j][0] == -1) {
        dp[i + 1][j][0] = 1; 
        tt[i + 1][j][0] = {0, i, j, 1};
      }

      if (j + r + 1 > k) {
        continue;
      }

      if (dp[nxt][j + r + 1][1] == -1) {
        dp[nxt][j + r + 1][1] = 1; 
        tt[nxt][j + r + 1][1] = {10 - cif[i] - 1, i, j, 1};
      }
    }
  }

  if (dp[n][k][0] == -1 && dp[n][k][1] == -1) {
    cout << "-1\n";
    return;
  }

  ll ans = 0;
  for (int i = n, j = k, t = (dp[n][k][0] == 1) ? 0 : 1; i > 0;) {
    auto nxt = tt[i][j][t];
    ans = ans + p10[nxt.i] * nxt.c;
    tie(i, j, t) = make_tuple(nxt.i, nxt.j, nxt.t);
  }

  ans *= off;

  cout << ans << "\n";
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);

  int t = 1;
  cin >> t;
  while (t--)
    solve();

  return 0;
}