#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx2")
#include "bits/stdc++.h"

// clang-format off
using namespace std;
using ll = long long;
template <class T> using vec = vector<T>;
template <class T> using vvec = vec<vec<T>>;
template <class T> using vvvec = vec<vvec<T>>;
template <class T, size_t SZ> using vac = vec<array<T, SZ>>;
template <class T, size_t SZ> using vvac = vec<vac<T, SZ>>;
template <class T> using pqueue = priority_queue<T, vec<T>>;
template <class T> using pqueue_min = priority_queue<T, vec<T>, greater<T>>;

#define sz(x) int((x).size())
#define all(x) begin(x), end(x)
#define rall(x) x.rbegin(), x.rend()
#define sor(x) sort(all(x))
#define pb push_back
#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(int)(b):i>(int)(b); i+=(s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define E_ACH2(x, a) for (auto& x: a)
#define E_ACH3(x, y, a) for (auto& [x, y]: a)
#define E_ACH4(x, y, z, a) for (auto& [x, y, z]: a)
#define E_ACHC(...) GET5(__VA_ARGS__, E_ACH4, E_ACH3, E_ACH2)
#define EACH(...) E_ACHC(__VA_ARGS__)(__VA_ARGS__)
#define SUBMASKS(t, s) for (ll t = (s); t >= 0; t = (t == 0 ? -1 : (t - 1) & (s)))
#define MIN(v) *min_element(all(v))
#define MAX(v) *max_element(all(v))

template <class T> bool umin(T &a, const T &b) { return b < a ? a = b, 1 : 0; }
template <class T> bool umax(T &a, const T &b) { return a < b ? a = b, 1 : 0; }
template <class T, size_t SZ> istream &operator>>(istream &s, array<T, SZ>& v) { FOR(sz(v)) s >> v[i]; return s; }
template <class T> istream &operator>>(istream &s, vec<T>& v) { FOR(sz(v)) s >> v[i]; return s; }
template <class T> ostream &operator<<(ostream &s, vec<T>& v) { FOR(sz(v)) s << (i?" ":"") << v[i]; return s; }
template <class T> ostream &operator<<(ostream &s, const vec<T>& v) { FOR(sz(v)) s << (i?" ":"") << v[i]; return s; }
template <class T1, class T2> ostream &operator<<(ostream &s, const pair<T1, T2>& v) { s << v.first << " " << v.second; return s;}
 
template<class A> void write(A x) { cout << x; }
template<class H, class... T> void write(const H& h, const T&... t) { 
  write(h); write(t...); }
void print() { write("\n"); }
template<class H, class... T> void print(const H& h, const T&... t) { 
  write(h); if (sizeof...(t)) write(" "); print(t...); }
 
void decrement() {}
template <class T, size_t SZ> void decrement(vec<array<T, SZ>> &v) { EACH(row, v) EACH(x, row) --x; }
template <class T> void decrement(vec<vec<T>> &v) { EACH(row, v) EACH(x, row) --x; }
template <class T> void decrement(vec<T> &v) { EACH(x, v) --x; }
template <class T, class... U> void decrement(T &t, U &...u) { --t; decrement(u...); }
 
template <class T> void read(T& x) { cin >> x; }
template<class T, class... U> void read(T &t, U &...u) { read(t); read(u...); }
#define ints(...) int __VA_ARGS__; read(__VA_ARGS__);
#define int1(...) ints(__VA_ARGS__); decrement(__VA_ARGS__);
#define vin(n, a) vec<int> a((n)); cin >> a;
#define vain(n, m, a) vec<array<int, (m)>> a((n)); cin >> a;
#define graphin(n, m, adj) vvec<int> adj(n); FOR(m) {int1(u, v); adj[u].pb(v); adj[v].pb(u); }
#define wgraphin(n, m, adj) vvac<int, 2> adj(n); FOR(m) {int1(u, v); ints(w); adj[u].pb({v,w}); adj[v].pb({u,w}); }

// vec<array<int, 2>> dirs = {{-1,2},{1,2},{-1,-2},{1,-2},{2,-1},{2,1},{-2,-1},{-2,1}};

template<int MOD>
struct modint {
    int v;
    modint(long long _v = 0) {
        long long x = _v % MOD;
        if (x < 0) x += MOD;
        v = int(x);
    }
    modint& operator+=(const modint& o) {
        v += o.v;
        if (v >= MOD) v -= MOD;
        return *this;
    }
    modint& operator-=(const modint& o) {
        v -= o.v;
        if (v < 0) v += MOD;
        return *this;
    }
    modint& operator*=(const modint& o) {
        v = int((long long)v * o.v % MOD);
        return *this;
    }
    friend modint pow(modint a, long long e) {
        modint res(1);
        while (e > 0) {
            if (e & 1) res *= a;
            a *= a;
            e >>= 1;
        }
        return res;
    }
    // requires MOD prime if used
    friend modint inv(const modint& a) {
        return power(a, MOD - 2);
    }
    modint& operator/=(const modint& o) {
        return *this *= inv(o);
    }
    friend modint operator+(modint a, const modint& b) { return a += b; }
    friend modint operator-(modint a, const modint& b) { return a -= b; }
    friend modint operator*(modint a, const modint& b) { return a *= b; }
    friend modint operator/(modint a, const modint& b) { return a /= b; }
    modint operator-() const { return modint(-v); }
    bool operator==(const modint& o) const { return v == o.v; }
    bool operator!=(const modint& o) const { return v != o.v; }
    // I/O
    friend std::ostream& operator<<(std::ostream& os, const modint& a) {
        return os << a.v;
    }
    friend std::istream& operator>>(std::istream& is, modint& a) {
        long long x;
        is >> x;
        a = modint(x);
        return is;
    }
};
const int MOD = 998244353;
using mint = modint<MOD>;

// const int MX = 200123;
// mint fac[MX], ifac[MX];

// mint binom(int n, int k) {
//     if (k < 0 || k > n) return mint(0);
//     mint ans = fac[n] * ifac[n-k] * ifac[k];
//     return ans;
// }
// void precompute() {
//     fac[0] = 1; fac[1] = 1;
//     FOR(i, 2, MX) {
//         fac[i] = fac[i-1] * i;
//     }
//     ifac[MX-1] = pow(fac[MX-1],MOD - 2);
//     FOR(i, MX-2, -1, -1) {
//         ifac[i] = ifac[i+1] * (i+1);
//     }
// }

// clang-format on
const ll NINF = -(1LL << 60);

void solve() {
    ints(N);
    vin(N, A);
    EACH(n, A) {
        int r = floor(sqrt(n));
        while ((ll)(r + 1) * (r + 1) <= n)
            ++r;
        while ((ll)r * r > n)
            --r;

        ll s = 0;
        FOR(i, 1, r + 1) { //
            s += n / i;
        }
        s = 2 * s - 1LL * r * r;
        print(s - n);
    }
}

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

    // precompute();
    // ints(T);
    int T = 1;
    FOR(tc, 0, T) { solve(); }
    return 0;
}