#pragma GCC target("avx2")
#pragma GCC optimize("O2")
#include <bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/pb_ds/tag_and_trait.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
namespace mp=boost::multiprecision;
using bint=mp::cpp_int;
using greatd=mp::number<mp::cpp_dec_float<1024>>;
using namespace std;
using namespace __gnu_pbds;
template<class T=int> using V=vector<T>;
template<class T=int> using VV=V<V<T>>;
using ll=long long;
using ull=unsigned long long;
using ld=long double;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using pli=pair<ll,int>;
using pil=pair<int,ll>;
using pdd=pair<ld,ld>;
using vi=vector<int>;
using vvi=V<vi>;
using vpi=vector<pii>;
using vvpi=V<vpi>;
using vl=vector<ll>;
using vvl=V<vl>;
using vs=vector<string>;
using vvs=V<vs>;
using vc=vector<char>;
using vvc=V<vc>;
using vd=vector<ld>;
using vvd=V<vd>;
using vpl=vector<pll>;
using vvpl=V<vpl>;
using vpil=vector<pair<int,ll>>;
using vvpil=V<vpil>;
using vpli=vector<pair<ll,int>>;
using vvpli=V<vpli>;
using vpd=vector<pdd>;
using vvpd=V<vpd>;
using vb=vector<bool>;
using vvb=V<vb>;
template<class T> using pq=priority_queue<T,vector<T>,greater<T>>;
template<class T> using rpq=priority_queue<T,vector<T>>;
template<class T> using Tree=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
template<class T,class U>ostream &operator<<(ostream &os,const pair<T,U> &p){os <<p.first <<" " <<p.second;return os;}
template<class T,class U>istream &operator>>(istream &is,pair<T,U> &p){is >>p.first >>p.second;return is;}
#define ovl4(a,b,c,d,name,...) name
#define rep(...) ovl4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define rep1(a) for(int i=0; i<a; i++)
#define rep2(i,a) for(int i=0; i<a; i++)
#define rep3(i,a,b) for(int i=a; i<b; i++)
#define rep4(i,a,b,c) for(int i=a; i<b; i+=c)
#define rrep(...) ovl4(__VA_ARGS__,rrep4,rrep3,rrep2,rrep1)(__VA_ARGS__)
#define rrep1(a) for(int i=a; i>=0; i--)
#define rrep2(i,a) for(int i=a; i>=0; i--)
#define rrep3(i,a,b) for(int i=a; i>=b; i--)
#define rrep4(i,a,b,c) for(int i=a; i>=b; i-=c)
#define atrep(i,v) for(auto i:v)
void in(){}
template<class... T>void in(T&... a){(cin >>... >>a);}
template<class T>
void vin(vector<T> &v,int n=-1,int s=0){if(n==-1)n=v.size();rep(i,s,s+n)in(v[i]);}
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__;in(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__;in(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__;in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__;in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__;in(__VA_ARGS__)
void VIN(){}
template<class T,class... Ts>
void VIN(int ind,vector<T>& v,Ts&... vs){vin<T>(v,v.size()-ind,ind);if constexpr(sizeof...(vs)>0)VIN(ind,vs...);}
template<class T,class... Ts>
bool chmax(T &a,Ts... b){T c=a;for(auto i:{b...})a=max(a,i);return a==c;}
template<class T,class...Ts>
bool chmin(T &a,Ts... b){T c=a;for(auto i:{b...})a=min(a,i);return a==c;}
template<class T,class... Ts>
bool chcomp(function<T(T,T)> comp,T &a,Ts... b){T c=a;for(auto i:{b...})a=comp(a,i);return a==c;}
void print(){cout<<"\n";}
template<class T,class... Ts>
void print(const T &a,const Ts&... b){cout <<a;(cout<<... <<(cout<<" ",b));cout<<"\n";}
template<class T>
void vprint(vector<T> &v,bool ind1=false,string aid=" "){rep(i,(int)ind1,v.size()){if(i>(int)ind1){cout <<aid;}cout <<v[i];}print();}
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define Sort(a) sort(all(a))
#define rsort(a) sort(rall(a))
#define Uniq(a) a.erase(unique(all(a)),a.end())
#define Rvs(a) reverse(all(a))
#define pb push_back
#define eb emplace_back
#define elif else if
#define cY cout <<"Yes\n"
#define cN cout <<"No\n"
void yn(bool b){if(b){cY;}else{cN;}}
#define ft first
#define sd second
#define inr(l,x,r) (l<=x && x<=r)
#define hinr(l,x,r) (l<=x && x<r)
#define ingrid(i,a,b,h,w) (inr(i,a,h+i-1) && inr(i,b,w+i-1))
#define FIX cout <<fixed <<setprecision(15)
template<class T>
bool eql(const T &a){return true;};
template<class T,class... Ts>
bool eql(const T& a,const Ts&... b){bool ret=true;for(auto i:{b...})ret&=(i==a);return ret;}
bool operator==(const string& a,const string& b){return a.compare(b)==0;}
random_device rd;
mt19937 mt(rd());
const int INF=1e9;
const ll LINF=1e18;
const ll MOD=1e9+7;
const ll MMOD=998244353;
const ld eps=1e-10;
bool deql(const ld &a){return true;}
template<typename... Args>
bool deql(const ld& a,const Args&... b){bool ret=true;for(auto i:{b...})ret&=(inr(-eps,i-a,eps));return ret;}
int dx[8]={-1,0,1,0,-1,-1,1,1},dy[8]={0,1,0,-1,-1,1,1,-1};

namespace prime{
    vl a1={2,7,61};
    vl a2={2,325,9375,28178,450775,9780504,1795265022};
    __int128_t modpow(__int128_t a,__int128_t b,__int128_t mod=MOD){
        __int128_t ret=1;
        a%=mod;
        while(b>0){if(b&1)ret=(ret*a)%mod;a=(a*a)%mod;b>>=1;}
        return ret;
    }
    bool is_prime(ll n,vl& A){
        ll s=0,d=n-1;
        while(!(d&1)){++s;d>>=1;}
        for(auto a:A){
            if(n<=a)return true;
            ll t,y=modpow(a,d,n);
            if(y!=1){
                for(t=0;t<s;t++){
                    if(y==n-1)break;
                    y=__int128_t(y)*y%n;
                }
                if(t==s)return false;
            }
        }
        return true;
    }
    ll finddivisor(ll n){
        if(!(n&1))return 2;
        ll s=0;
        while(true){
            s++;
            ll x=2,y=2,d=1;
            auto f=[&](ll x)->ll{return ((__int128_t)x*x+s)%n;};
            while(d==1){
                x=f(x),y=f(f(y));
                d=gcd(abs(x-y),n);
            }
            if(d!=1 && d!=n)return d;
        }
    }
    void divisor_dfs(int idx,ll val,vl &ret,vpli &fac){
        int size=fac.size();
        if(idx==size){ret.push_back(val);return;}
        ll v=fac[idx].ft;
        int c=fac[idx].sd;
        ll m=1;
        for(int i=0; i<=c; i++){
            divisor_dfs(idx+1,val*m,ret,fac);
            m*=v;
        }
        return;
    }
    bool isprime(ll n){
        if(n<=1)return false;
        if(n==2)return true;
        if(n&1==0)return false;
        if(n<4759123141LL)return is_prime(n,a1);
        else return is_prime(n,a2);
    }
    map<ll,int> factorize(ll n){
        map<ll,int> ret;
        if(n==1)return ret;
        if(isprime(n)){
            ret[n]=1;
            return ret;
        }
        ll fac=finddivisor(n);
        ret=factorize(fac);
        map<ll,int> ret_=factorize(n/fac);
        if(ret.size()>ret_.size()){for(auto i:ret_){ret[i.ft]+=i.sd;}return ret;}
        else{for(auto i:ret){ret_[i.ft]+=i.sd;}return ret_;}
    }
    vl enumerate(ll n){
        map<ll,int> f=factorize(n);
        vpli fac;
        for(auto i:f)fac.push_back(i);
        vl ret;
        divisor_dfs(0,1,ret,fac);
        return ret;
    }
};
using namespace prime;
int main(){
    ios::sync_with_stdio(false);std::cin.tie(nullptr);FIX;
    INT(n);
    rep(n){
        LL(x);
        cout <<x <<" " <<(isprime(x) ? 1:0) <<"\n";
    }
    return 0;
}