#include <limits>
#include <initializer_list>
#include <utility>
#include <bitset>
#include <tuple>
#include <type_traits>
#include <functional>
#include <string>
#include <array>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <iterator>
#include <algorithm>
#include <complex>
#include <random>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <regex>
#include <cassert>
#include <cstddef>
#include <variant>
#define endl codeforces
#define ALL(v) std::begin(v), std::end(v)
#define ALLR(v) std::rbegin(v), std::rend(v)
using ll = std::int64_t;
using ull = std::uint64_t;
using pii = std::pair<int, int>;
using tii = std::tuple<int, int, int>;
using pll = std::pair<ll, ll>;
using tll = std::tuple<ll, ll, ll>;
template <typename T> using vec = std::vector<T>;
template <typename T> using vvec = vec<vec<T>>;
template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename T, typename... Tail> const T& var_min(const T &t, const Tail&... tail) { return std::min(t, var_min(tail...)); }
template <typename T, typename... Tail> const T& var_max(const T &t, const Tail&... tail) { return std::max(t, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail> auto make_v(T init, std::size_t s, Tail... tail) { auto v = std::move(make_v(init, tail...)); return vec<decltype(v)>(s, v); }
template <typename T, std::size_t Head, std::size_t... Tail> struct multi_dem_array { using type = std::array<typename multi_dem_array<T, Tail...>::type, Head>; };
template <typename T, std::size_t Head> struct multi_dem_array<T, Head> { using type = std::array<T, Head>; };
template <typename T, std::size_t... Args> using mdarray = typename multi_dem_array<T, Args...>::type;
namespace init__ { struct InitIO { InitIO() { std::cin.tie(nullptr); std::ios_base::sync_with_stdio(false); std::cout << std::fixed << std::setprecision(30); } } init_io; }

ll solve() {
    ll n, i, j;
    std::cin >> n >> i >> j;
    ll u = i, d = n - 1 - i;
    ll l = j, r = n - 1 - j;
    ll minv = var_min(u, d, l, r);
    ll ans = n * n - (n - 2 * minv) * (n - 2 * minv);
    ll curi = minv, curj = minv;
    ll len = n - 2 * minv - 1;
    pll pv[] = { pll(minv, minv), pll(minv, minv + len), pll(minv + len, minv + len), pll(minv + len, minv), };
    for (ll k = 0; k < 4; k++) {
        auto f = pv[k], t = pv[(k + 1) % 4];
        ll a, b, c, d;
        std::tie(a, b) = f;
        std::tie(c, d) = t;
        ll pu = std::min(a, c), pd = std::max(a, c);
        ll pl = std::min(b, d), pr = std::max(b, d);
        if (pu <= i && i <= pd &&
            pl <= j && j <= pr) {
            ans += std::abs(i - curi);
            ans += std::abs(j - curj);
            break;
        } else {
            ans += len;
            std::tie(curi, curj) = t;
        }
    }
    return ans;
}

int main() {
    ll t;
    std::cin >> t;
    while (t--) std::cout << solve() << '\n';
    return 0;
}