#include <fstream>
#include <iostream>
#include <vector>
#include <bitset>
#include <string.h>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <deque>

using namespace std;

const char infile[] = "ssnd.in";
const char outfile[] = "ssnd.out";

ifstream fin(infile);
ofstream fout(outfile);

const int MAXN = 1000005;
const int oo = 0x3f3f3f3f;
const int MOD = 9973;

typedef vector<int> Graph[MAXN];
typedef vector<int> :: iterator It;

const inline int min(const int &a, const int &b) { if( a > b ) return b;   return a; }
const inline int max(const int &a, const int &b) { if( a < b ) return b;   return a; }
const inline void Get_min(int &a, const int b)    { if( a > b ) a = b; }
const inline void Get_max(int &a, const int b)    { if( a < b ) a = b; }

long long N;
int T, K, P[MAXN];
bitset <MAXN> notPrime;

inline void biuldSieveofEratosthenes() {
    for(int i = 2 ; i < MAXN ; ++ i)
        if(!notPrime[i]) {
            P[++ K] = i;
            for(int j = i + i ; j < MAXN ; j += i)
                notPrime[j] = true;
        }
}

inline int lgPow(int n, int p) {
    int Ans = 1;
    n %= MOD;
    for(  ; p ; p >>= 1) {
        if(p & 1)
            Ans = (1LL * Ans * n) % MOD;
        n = (1LL * n * n) % MOD;
    }
    return Ans;
}

inline int invMod(int x, int MOD) {
    return lgPow(x, MOD - 2);
}

inline void Solve(long long N) {
    int divizNb = 1, divizSum = 1;
    for(int i = 1 ; i <= K && 1LL * P[i] * P[i] <= N ; ++ i) {
        if(N % P[i])
            continue;
        int iPower = 0;
        while(N % P[i] == 0) {
            ++ iPower;
            N /= P[i];
        }
        int inv = invMod(P[i] - 1, MOD);
        int powNb = (lgPow(P[i], iPower + 1) - 1 + MOD) % MOD;
        divizNb = (1LL * divizNb * (iPower + 1)) % MOD;
        divizSum = (1LL * divizSum * ((inv * powNb) % MOD)) % MOD;
    }
    if(N > 1) {
        int inv = invMod(N - 1, MOD);
        int powNb = (lgPow(N, 2) - 1 + MOD) % MOD;
        divizNb = (1LL * divizNb * 2) % MOD;
        divizSum = (1LL * divizSum * ((inv * powNb) % MOD)) % MOD;
    }
    fout << divizNb << ' ' << divizSum << '\n';
}

int main() {
    biuldSieveofEratosthenes();
    fin >> T;
    while(T -- ) {
        fin >> N;
        Solve(N);
    }
    fin.close();
    fout.close();
    return 0;
}