#include <bits/stdc++.h>

const int mod = 998244353;
const int inv2 = (mod + 1) / 2;
inline int inc(int x, int y) { x += y - mod; return x + (x >> 31 & mod); }
inline int dec(int x, int y) { x -= y; return x + (x >> 31 & mod); }
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline void addmul(int &x, int y, int z) {
	x = (x + 1ll * y * z) % mod;
}
inline void upd(int &x, int y) { x = inc(x, y); }
inline void pud(int &x, int y) { x = mul(x, y); }

inline int fastpow(int x, long long p) {
	int r = 1;
	while (p) {
		if (p & 1) pud(r, x);
		pud(x, x);
		p >>= 1;
	}
	return r;
}

void bruteforce(int a, int b, int c) {
	std::vector<int> x, y;
	int tot = 0;
	for (int i = -2 * a + 1; i <= 2 * a - 1; ++i)
		for (int j = -2 * b + 1; j <= 2 * b - 1; ++j)
			if (-2 * c + 1 <= i + j && i + j <= 2 * c - 1) {
				if (i % 2 || j % 2) {
					tot++;
					x.push_back(i);
					y.push_back(j);
				}
			}
	int mx = 0, ways = 0;
	const int dx[6] = { 0, 0, 1, -1, 1, -1 };
	const int dy[6] = { 1, -1, 0, 0, -1, 1 };
	auto adjacent = [&](int i, int j) {
		for (int o = 0; o < 6; ++o)
			if (x[i] + dx[o] == x[j] && y[i] + dy[o] == y[j])
				return true;
		return false;
	};
	for (int mask = 0; mask < (1 << tot); ++mask) {
		int t = __builtin_popcount(mask);
		if (t < mx)
			continue;
		bool ok = true;
		for (int i = 0; i < tot; ++i)
			if (mask >> i & 1)
				for (int j = 0; j < i; ++j)
					if (mask >> j & 1)
						if (adjacent(i, j)) {
							ok = false;
							break;
						}
		if (!ok) continue;
		if (t == mx) ++ways;
		else {
			mx = t;
			ways = 1;
		}
	}
	printf("%d %d\n", mx, ways);
}

struct state_t {
	int mx, ways;
	state_t() : mx(-1), ways(0) {
	}
	state_t(int mx, int ways) : mx(mx), ways(ways) {

	}
};
state_t operator+(const state_t &lhs, const state_t &rhs) {
	int mx = std::max(lhs.mx, rhs.mx);
	int ways = 0;
	if (lhs.mx == mx)
		ways = lhs.ways;
	if (rhs.mx == mx)
		upd(ways, rhs.ways);
	return state_t(mx, ways);
}
const int K = 15;
state_t dp[2][1 << K];
int popcnt[1 << K];

void init() {
	for (int i = 0; i < (1 << K); ++i)
		popcnt[i] = popcnt[i >> 1] + (i & 1);
}

void solve(int a, int b, int c) {
	unsigned even_mask = 0;
	for (int i = 0; i < 30; i += 2)
		even_mask |= 1u << i + 1;
	auto row_valid = [&](int mask) {
		return (mask & (mask >> 1)) == 0;
	};
	auto trans_valid = [&](int mask1, int mask2) {
		return (mask1 & mask2) == 0 && (mask1 & (mask2 << 1)) == 0;
	};
	// -2 * c + 1 <= x + y <= 2 * c - 1
	// -2 * c + 1 - y <= x <= 2 * c - 1 - y
	auto get_left = [&](int y) {
		return std::max(-2 * a + 1, -2 * c + 1 - y);
	};
	auto get_right = [&](int y) {
		return std::min(2 * a - 1, 2 * c - 1 - y);
	};
	auto get_full_mask = [&](int l, int r) -> unsigned {
		if (l > r) return 0;
		l += 2 * a - 1, r += 2 * a - 1;
		// 0 <= l <= r <= 4 * a - 2
		unsigned tmask = 0;
		for (int i = l; i <= r; ++i)
			tmask |= 1 << i;
		return tmask;
	};
	int o = 0;
	//dp[o][0] = state_t(0, 1);
	
	int total = 4 * a - 1, trans_total = 0;
	std::vector<int> all_valid_masks;
	std::vector<std::vector<int>> valid_trans(1 << total);
	for (int i = 0; i < (1 << total); ++i) {
		if (row_valid(i)) {
			all_valid_masks.push_back(i);
		}
	}
	for (int mask1 : all_valid_masks)
		for (int mask2 : all_valid_masks)
			if (trans_valid(mask1, mask2) && ((mask1 & even_mask) == 0 || (mask2 & even_mask) == 0)) {
				valid_trans[mask1].push_back(mask2);
				++trans_total;
			}
	
	state_t ans(-1, 0);
	for (int mask : all_valid_masks)
		dp[o][mask] = state_t(popcnt[mask], 1);
	for (int y = -2 * b + 1; y <= 2 * b - 1; ++y) {
		for (int i : all_valid_masks)
			dp[!o][i] = state_t(-1, 0);
		int left_x = get_left(y), right_x = get_right(y);
		int full_mask = get_full_mask(left_x, right_x);	
		for (int mask = full_mask; ; mask = (mask - 1) & full_mask) if (dp[o][mask].mx != -1) {
			if (mask) {
				ans = ans + dp[o][mask];
			}
			if (!row_valid(mask))
				continue;
			if (y % 2 == 0 && (mask & even_mask) != 0)
				continue;
			for (int next_mask : valid_trans[mask]) {
				dp[!o][next_mask] = dp[!o][next_mask] + state_t(dp[o][mask].mx + popcnt[next_mask], dp[o][mask].ways);
			}
			if (!mask) break;
		}
		o = !o;
	}
	printf("%d %d\n", ans.mx, ans.ways);
}
const int N = 3e6 + 50;
int fact[N], inv[N];
bool has_calced_fact = false;
void calc(int n) {
	fact[0] = 1;
	for (int i = 1; i <= n; ++i)
		fact[i] = mul(i, fact[i - 1]);
	inv[n] = fastpow(fact[n], mod - 2);
	for (int i = n - 1; i >= 0; --i)
		inv[i] = mul(i + 1, inv[i + 1]);
}
void solve_equal(int a, int b, int c) {
	if (!has_calced_fact) {
		calc(N - 1);
		has_calced_fact = true;
	}
	int n = a;
	int64_t max = 3ll * n * n;
	int ways = 1;
	for (int i = 0; i < n; ++i) {
		pud(ways, fact[i]);
		pud(ways, fact[i + 2 * n]);
		pud(ways, inv[i + n]);
		pud(ways, inv[i + n]);
	}
	printf("%lld %d\n", max, ways);
}

int main() { 
	init();
	int T;
	scanf("%d", &T);
	while (T--) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		if (a == b && b == c)
			solve_equal(a, b, c);
		else
			solve(a, b, c);
	}
}