#include <fstream>

std::ifstream f("ssnd.in");
std::ofstream g("ssnd.out");

using namespace std;

constexpr int MAXN = 1000001;


//(a - b) mod p = ((a mod p - b mod p) + p) mod p
//(a / b) mod p = ((a mod p) * (b^(-1) mod p)) mod p
//Where b^(-1) mod p is the modular inverse of b mod p. For p = prime, b^(-1) mod p = b^(p - 2) mod p

void extended_euclid(long long a, long long b, long long &d, long long &x, long long &y)
{
    if( b==0 )
    {
        d = a;
        x = 1;
        y = 0;
    }
    else
    {
        extended_euclid(b, a%b, d, x, y);
        auto x0 =x;
        auto y0 =y;

        y = x0 - ( a / b ) * y0;
        x = y0;
    }
}

long long compute_modular_inverse(long long a, long long b)
{
    long long d = 0, x = 0, y = 0;

    extended_euclid(a, b, d, x, y);

    while(x < 1)
    {
        x += b;
    }

    return x;
}

void initialize(bool filter[])
{
    for(auto i=0; i<MAXN; ++i)
    {
        filter[i] = true;
    }
}

void buildData(bool filter[])
{
    for(auto i=2; i<=MAXN; ++i)
    {
        if(filter[i])
        {
            for(auto j=i+i; j<MAXN; j+=i)
            {
                filter[j] = false;
            }
        }
    }
}

long long power(long long n, long long p, long long mod)
{
    auto r = 1LL;

    while( p != 1 )
    {
        if( p % 2 ==1 )
        r = (n*r) % mod;
        n = (n*n) % mod;
        p = p / 2;
    }

    return ( n * r ) % mod;
}

int main()
{
    bool filter[MAXN];

    auto t=0;

    initialize(filter);
    buildData(filter);

    auto x=0LL;
    auto sum = 1LL;
    auto nr = 1LL;
    auto divident = 1LL;
    auto divisor = 1LL;

    f>>t;
    while(t > 0)
    {
        sum = 1LL;
        nr = 1LL;
        divident = 1LL;
        divisor = 1LL;

        f >> x;

        if(x < MAXN && filter[x])
        {
            ++nr;
            sum = (sum + x) % 9973;
        }
        else
        {
            for(auto i = 2; i < MAXN; ++i)
            {
                if(filter[i])
                {
                    auto nr_d = 0;
                    while( x % i == 0 )
                    {
                        ++ nr_d;
                        x /= i;
                    }

                    if(nr_d > 0)
                    {
                        //divident = (divident * (power(i, nr_d + 1, 9973) - 1)) % 9973;
                        //divisor =  (divisor * (i - 1)) % 9973;

                        nr *= nr_d + 1;
                    }
                }
            }
            if(x >= MAXN)
            {
                auto nr_d = 1;

                //divident = (divident * (power(x, nr_d + 1, 9973) - 1)) % 9973;
                //divisor =  (divisor * (x - 1)) % 9973;

                nr *= nr_d + 1;
                ++nr;
            }

            //auto mi = compute_modular_inverse(divisor, 9973);
            //sum = (divident * mi) % 9973;
        }

        g << nr << ' ' << sum << '\n';

        --t;
    }
}