#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
// #include <atcoder/all>
// using namespace atcoder;
using namespace __gnu_pbds;
using namespace std;
using ll = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using i128 = __int128;
using ld = long double;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vc = std::vector<char>;
using vvc = std::vector<vc>;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vvvi = std::vector<vvi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
using vvvll = std::vector<vvll>;
using vld = std::vector<ld>;
using vvld = std::vector<vld>;
using vvvld = std::vector<vvld>;
using pll = std::array<ll, 2>;
using vpll = std::vector<pll>;
using vvpll = std::vector<vpll>;
using pii = std::array<int, 2>;
using vpii = std::vector<pii>;
using vvpii = std::vector<vpii>;
using vs = std::vector<std::string>;
using vvs = std::vector<vs>;

template<class W>
using ordered_set = tree<W, null_type, std::less<W>, rb_tree_tag,
	tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
std::mt19937 rng(seed);
#define ff(i,a,b)  for(int i=a;i<(int)(b);i++)
#define fb(i,b,a)  for(int i=(int)(b);i>=(int)(a);i--)
#define siz(x) (ll) x.size()
#define all(v) (v).begin(), (v).end()
#define RASENGAN  ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end());
#ifdef DEBUG
#include "dbg.hpp"
#else
#define err(...)
#define deb(...)
#endif

const ld EPS = 1e-9;
//const ll maxN = 5;
const ll maxN = 1e5 + 5;
const ll INF64 = 1e18 + 5;
const int INF32 = 1e9 + 5;
const ll mod = 1e9 + 7;


template<class Fun>
class y_combinator_result {
	Fun fun_;
public:
	template<class T>
	explicit y_combinator_result(T&& fun) : fun_(std::forward<T>(fun)) {}

	template<class ...Args>
	decltype(auto) operator()(Args &&...args) {
		return fun_(std::ref(*this), std::forward<Args>(args)...);
	}
};
template<class Fun>
decltype(auto) y_combinator(Fun&& fun) {
	return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}
// auto gcd = std::y_combinator([](auto gcd, int a, int b) -> int {
//     return b == 0 ? a : gcd(b, a % b);
// });
template <typename T>
int lb(const vector<T>& v, T x) {
	return lower_bound(begin(v), end(v), x) - begin(v);
}

template <typename T>
int ub(const vector<T>& v, T x) {
	return upper_bound(begin(v), end(v), x) - begin(v);
}

template <typename T>
T floor(T x, T y) {
	assert(y != 0);
	if (y < 0) x = -x, y = -y;
	return (x >= 0 ? x / y : (x - y + 1) / y);
}

template <typename T>
T ceil(T x, T y) {
	assert(y != 0);
	if (y < 0) x = -x, y = -y;
	return (x >= 0 ? (x + y - 1) / y : x / y);
}

template<class T>
inline bool chmax(T& a, T b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}

template<class T>
inline bool chmin(T& a, T b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
ll binpow(ll x, ll y, ll p) {
	ll result = 1;
	for (; y; y >>= 1, x = x * x % p) {
		if (y & 1) {
			result = result * x % p;
		}
	}
	return result;
}

ll pow(ll x, ll y) {
	ll res = 1;
	for (; y; y >>= 1, x = x * x) {
		if (y & 1) {
			res = res * x;
		}
	}
	return res;
}

long long inverse(long long x, long long p) {
	return binpow(x, p - 2, p);
}
//<------------------------------------------------------------------------------------------------------------>
template <int MOD_> struct modnum {
	static constexpr int MOD = MOD_;
	static_assert(MOD_ > 0, "MOD must be positive");
	int v;
private:
	using ll = long long;



	static int minv(int a, int m) {
		a %= m;
		assert(a);
		return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
	}

public:

	modnum() : v(0) {}
	modnum(ll v_) : v(int(v_% MOD)) { if (v < 0) v += MOD; }
	explicit operator int() const { return v; }
	friend std::ostream& operator << (std::ostream& out, const modnum& n) { return out << int(n); }
	friend std::istream& operator >> (std::istream& in, modnum& n) { ll v_; in >> v_; n = modnum(v_); return in; }

	friend bool operator == (const modnum& a, const modnum& b) { return a.v == b.v; }
	friend bool operator != (const modnum& a, const modnum& b) { return a.v != b.v; }

	modnum inv() const {
		modnum res;
		res.v = minv(v, MOD);
		return res;
	}
	friend modnum inv(const modnum& m) { return m.inv(); }
	modnum neg() const {
		modnum res;
		res.v = v ? MOD - v : 0;
		return res;
	}
	friend modnum neg(const modnum& m) { return m.neg(); }

	modnum operator- () const {
		return neg();
	}
	modnum operator+ () const {
		return modnum(*this);
	}

	modnum& operator ++ () {
		v++;
		if (v == MOD) v = 0;
		return *this;
	}
	modnum& operator -- () {
		if (v == 0) v = MOD;
		v--;
		return *this;
	}
	modnum& operator += (const modnum& o) {
		v += o.v;
		if (v >= MOD) v -= MOD;
		return *this;
	}
	modnum& operator -= (const modnum& o) {
		v -= o.v;
		if (v < 0) v += MOD;
		return *this;
	}
	modnum& operator *= (const modnum& o) {
		v = int(ll(v) * ll(o.v) % MOD);
		return *this;
	}
	modnum& operator /= (const modnum& o) {
		return *this *= o.inv();
	}

	friend modnum operator ++ (modnum& a, int) { modnum r = a; ++a; return r; }
	friend modnum operator -- (modnum& a, int) { modnum r = a; --a; return r; }
	friend modnum operator + (const modnum& a, const modnum& b) { return modnum(a) += b; }
	friend modnum operator - (const modnum& a, const modnum& b) { return modnum(a) -= b; }
	friend modnum operator * (const modnum& a, const modnum& b) { return modnum(a) *= b; }
	friend modnum operator / (const modnum& a, const modnum& b) { return modnum(a) /= b; }
};

template <typename T> T pow(T a, long long b) {
	assert(b >= 0);
	T r = 1; while (b) { if (b & 1) r *= a; b >>= 1; a *= a; } return r;
}

using num = modnum<mod>;
using vnum = vector<num>;
using vvnum = vector<vnum>;
using vvvnum = vector<vvnum>;
vector<num> fact, ifact;

void init_f() {
	int N = 1100000;
	fact = { 1 };
	for (int i = 1; i < N; i++) fact.push_back(i * fact[i - 1]);
	ifact.resize(N);
	ifact.back() = 1 / fact.back();
	for (int i = N - 1; i > 0; i--) ifact[i - 1] = i * ifact[i];
}

num ncr(int n, int k) {
	if (k < 0 || k > n) return 0;
	return fact[n] * ifact[k] * ifact[n - k];
}

num npr(int a, int b) {
	if (a < 0 || b < 0 || a < b)return 0;
	return fact[a] * ifact[a - b];
}
void solve()
{

	ll s, n;
	cin >> s >> n;

	ll ans = s * n;
	s += s % 10;
	n--;

	
	chmax(ans, s * n);
	if (s % 10 == 0) {
		cout << ans << "\n";
		return;
	}



	//(s+20*k)(n-4*k)
	// (s + 20k)(n - 4k) = sn + (20n-4s)k - 80kk
	ff(j, 0, 100) {
		if (n <= 0)break;
		chmax(ans, s * n);
		ll x = (5 * n - s) / 40;
		ff(i, max(0ll, x - 3), min(n + 1, x + 3)) {
			ll ss = s + 20 * i * 1ll;
			ll nn = n - 4ll * i;
			if (nn < 0 || ss < 0)break;
			chmax(ans, ss * nn);
		}
		s += s % 10;
		n--;
	}
	cout << ans << "\n";
}
int main()
{
#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	RASENGAN
		int t = 1;
	cout << fixed << setprecision(12);
	cin >> t;
	//init_f();
	for (int i = 1; i <= t; i++)
	{
		// cout << "Case #" << i << ": ";
		solve();
	}
	return 0;
}