#include <fstream>
#include <bitset>

using namespace std;

const int MAX_N = 1000005;
const int MOD = 9973;

class ofbuffer
{
private:
    char* b_text;
    int b_capacity, b_size;
    FILE* file;

    inline void b_put_ch( char ch )
    {
        b_text[b_size ++] = ch;
        if ( b_size == b_capacity )
            b_flush();
    }

    void b_put_nr( int x )
    {
        if ( x > 0 )
        {
            b_put_nr( x / 10 );
            b_put_ch( '0' + x % 10 );
        }
    }

public:
    inline ofbuffer( char * path, int capacity = 16000 )
    {
        file = fopen( path, "w" );

        b_text = new char[capacity];
        b_capacity = capacity;
        b_size = 0;
    }

    inline ~ofbuffer()
    {
        if ( b_size != 0 )
            b_flush();
    }

    inline void b_flush( void )
    {
        fwrite( b_text, 1, b_size, file );
        b_size = 0;
    }

    inline ofbuffer &operator<<( int v )
    {
        if ( v == 0 )
            b_put_ch( '0' );
        else
            b_put_nr( v );
        return *this;
    }

    inline ofbuffer &operator<<( char v )
    {
        b_put_ch( v );
        return *this;
    }

    inline void close()
    {
        b_flush();
        fclose( file );
    }
};

class InputReader
{
public:
    static const int BUFF_SIZE = 1 << 17;
    FILE *fin;
    int bp;
    char buff[BUFF_SIZE];
    InputReader (const char *file_name)
    {
        fin = fopen(file_name, "r");
        bp = BUFF_SIZE - 1;
    }
    void close()
    {
        fclose(fin);
    }
    void adv()
    {
        if (++bp == BUFF_SIZE)
        {
            fread(buff, sizeof(char), BUFF_SIZE, fin);
            bp = 0;
        }
    }
    InputReader& operator >> (long long& num)
    {
        num = 0;
        while (isdigit(buff[bp]) == false)
            adv();
        while (isdigit(buff[bp]))
        {
            num = num * 10 + buff[bp] - '0';
            adv();
        }
        return *this;
    }
};

InputReader fin ("ssnd.in");
ofbuffer fout ("ssnd.out");

long long N, T;
int K, P[MAX_N];
bitset <MAX_N> viz;

void ciur()
{
    for(int i = 2; i < MAX_N; ++i)
    {
        if(viz[i] == 0)
        {
            P[++K] = i;

            for(int j = i+i; j < MAX_N; j += i)
            {
                viz[j] = 1;
            }
        }
    }
}


inline int pow(int x, int p)
{
    int rez = 1;
    x %= MOD;

    for(; p; p >>= 1)
    {
        if(p & 1)
        {
            rez *= x;
            rez %= MOD;
        }

        x *= x;
        x %= MOD;
    }

    return rez;
}
void solve()
{
    fin >> N;

    int nd = 1, sd = 1;

    for(int i = 1; i <= K && 1LL * P[i] * P[i] <= N; ++i)
    {
        if(N % P[i]) continue;
        int p = 0;

        while(N % P[i] == 0)
        {
            N /= P[i];
            ++p;
        }

        nd *= (p+1);

        int p1 = (pow(P[i], p+1) - 1) % MOD;
        int p2 = pow(P[i]-1, MOD-2) % MOD;

        sd = (((sd * p1) % MOD) * p2) % MOD;
    }

    if(N > 1)
    {
        nd *= 2;
        sd = (1LL*sd*(N+1) % MOD);
    }

    fout << nd << ' ' << sd << '\n';
}
int main()
{
    ciur();

    for(fin >> T; T; --T)
        solve();
    return 0;
}