#include <bits/stdc++.h>
#define int long long
#define endl '\n'
int INF = 0x3f3f3f3f3f3f3f3f;
using namespace std;
typedef pair<int, int> PII;

void init() {
    // 初始化代码
}

template<class T>
struct Frac {
    T num;
    T den;
    Frac(T num_, T den_) : num(num_), den(den_) {
        if (den < 0) {
            den = -den;
            num = -num;
        }
    }
    void Norm() {
        T g = __gcd(num, den);
        num /= g, den /= g;
    }
    Frac() : Frac(0, 1) {}
    Frac(T num_) : Frac(num_, 1) {}
    explicit operator double() const {
        return 1. * num / den;
    }
    Frac& operator+=(const Frac& rhs) {
        num = num * rhs.den + rhs.num * den;
        den *= rhs.den;
        Norm();
        return *this;
    }
    Frac& operator-=(const Frac& rhs) {
        num = num * rhs.den - rhs.num * den;
        den *= rhs.den;
        Norm();
        return *this;
    }
    Frac& operator*=(const Frac& rhs) {
        num *= rhs.num;
        den *= rhs.den;
        Norm();
        return *this;
    }
    Frac& operator/=(const Frac& rhs) {
        num *= rhs.den;
        den *= rhs.num;
        Norm();
        if (den < 0) {
            num = -num;
            den = -den;
        }
        return *this;
    }
    friend Frac operator+(Frac lhs, const Frac& rhs) {
        return lhs += rhs;
    }
    friend Frac operator-(Frac lhs, const Frac& rhs) {
        return lhs -= rhs;
    }
    friend Frac operator*(Frac lhs, const Frac& rhs) {
        return lhs *= rhs;
    }
    friend Frac operator/(Frac lhs, const Frac& rhs) {
        return lhs /= rhs;
    }
    friend Frac operator-(const Frac& a) {
        return Frac(-a.num, a.den);
    }
    friend bool operator==(const Frac& lhs, const Frac& rhs) {
        return lhs.num * rhs.den == rhs.num * lhs.den;
    }
    friend bool operator!=(const Frac& lhs, const Frac& rhs) {
        return lhs.num * rhs.den != rhs.num * lhs.den;
    }
    friend bool operator<(const Frac& lhs, const Frac& rhs) {
        return lhs.num * rhs.den < rhs.num * lhs.den;
    }
    friend bool operator>(const Frac& lhs, const Frac& rhs) {
        return lhs.num * rhs.den > rhs.num * lhs.den;
    }
    friend bool operator<=(const Frac& lhs, const Frac& rhs) {
        return lhs.num * rhs.den <= rhs.num * lhs.den;
    }
    friend bool operator>=(const Frac& lhs, const Frac& rhs) {
        return lhs.num * rhs.den >= rhs.num * lhs.den;
    }
    friend std::ostream& operator<<(std::ostream& os, Frac x) {
        T g = __gcd(x.num, x.den);
        if (x.den < 0) {
            x.den = -x.den;
            x.num = -x.num;
        }
        if (x.den == g) {
            return os << x.num / g<<" "<<x.den/g;
        } else {
            return os << x.num / g << " " << x.den / g;
        }
    }
};

void solve() {
    int _;
    cin >> _;
    Frac<int> n(_);

    // 计算 sqrt(2 * n) 并转换为 Frac<int> 类型
    double sqrt_val = sqrt(2.0 * double(n));
    int sqrt_val_i=(int)(floor(sqrt_val));
    Frac<int> t(sqrt_val_i, 1);

    Frac<int> ans(INF, 1);
    auto calc = [&](Frac<int> mid) {
        return mid / 2 + Frac<int>(n) / mid-Frac<int>(1,2);
    };
    for (int dx = 0; dx <= 5; dx++) {
        Frac<int> candidate = t + Frac<int>(dx);
        if (candidate >= 1 && candidate <= n) {
            ans = min(ans, calc(candidate));
        }
        candidate = t - Frac<int>(dx);
        if (candidate >= 1 && candidate <= n) {
            ans = min(ans, calc(candidate));
        }
    }
    cout << ans << endl;
}

signed main() {
    ios::sync_with_stdio(false), cin.tie(0);
    int t;
    t = 1;
    cin >> t;
    init();
    while (t--) {
        solve();
    }
}