#include <bits/stdc++.h>
using namespace std;

static const int MAX = 100010;
// primeArr[i] will hold the count of distinct prime factors of i
int primeArr[MAX + 1];
vector<int> primeList; // will store all i for which primeArr[i] == 1

// Precompute primeArr and primeList
void buildPrimeList() {
    // Fill primeArr with the number of distinct prime factors
    for (int i = 2; i <= MAX; i++) {
        // If primeArr[i] > 1, skip
        if (primeArr[i] > 1) {
            continue;
        }
        // For each multiple j of i, increment primeArr[j]
        for (int j = i; j <= MAX; j += i) {
            primeArr[j]++;
        }
    }
    // Collect i where primeArr[i] == 1
    for (int i = 2; i <= MAX; i++) {
        if (primeArr[i] == 1) {
            primeList.push_back(i);
        }
    }
}

void solveOneTest() {
    long long n;
    cin >> n;

    // Factorize n using primeList
    vector<long long> nums;
    long long curr = n;
    for (auto p : primeList) {
        // small optimization
        if ((long long)p * (long long)p > curr) {
            break;
        }
        if (curr == 1) {
            break;
        }
        long long countFactors = 0;
        while (curr % p == 0) {
            countFactors++;
            curr /= p;
        }
        if (countFactors > 0) {
            nums.push_back(countFactors);
        }
    }
    // If curr > 1, then it's itself a prime (larger than MAX)
    if (curr > 1) {
        nums.push_back(1LL);
    }

    // Calculate base = Π (nums[i] + 1)
    long long base = 1;
    for (auto x : nums) {
        base *= (x + 1);
    }

    // We'll store our final answer in ansVal
    long long ansVal = 0;

    // Recursive function, similar to Python's getnext
    // index, pre1, flag1, pre2, flag2
    function<void(int, long long, bool, long long, bool)> getnext =
        [&](int index, long long pre1, bool flag1, long long pre2, bool flag2) {
            if (index == (int)nums.size()) {
                // At the end, only add if both flags are true
                if (flag1 && flag2) {
                    ansVal += pre1 * pre2;
                }
                return;
            }
            // 1) Multiply pre1 by nums[index], set flag1=true
            getnext(index + 1, pre1 * nums[index], true, pre2, flag2);
            // 2) Multiply pre2 by nums[index], set flag2=true
            getnext(index + 1, pre1, flag1, pre2 * nums[index], true);
            // 3) Do neither
            getnext(index + 1, pre1, flag1, pre2, flag2);
        };

    // Initial call
    getnext(0, 1LL, false, 1LL, false);

    // If ansVal is odd, mimic the Python "ERROR" and out-of-range access
    if (ansVal % 2 != 0) {
        cout << "ERROR " << ansVal << "\n";
        vector<int> arr = {1};
        // Out of range (intentional!)
        cout << arr.at(2) << "\n";
    }

    // ansVal = ansVal/2 + base
    ansVal = ansVal / 2 + base;

    cout << ansVal << "\n";
}

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

    buildPrimeList();

    int T;
    cin >> T;
    for(int t = 1; t <= T; t++) {
        solveOneTest();
    }

    return 0;
}