#include <unistd.h>
#include <stdint.h>
#include <math.h>

typedef __int128 int128_t;
typedef unsigned __int128 uint128_t;

char ibuf[300000];
char *ibufe = ibuf-1;
char buf[300000];
char *bufe = buf;

static inline void readall(){
  int k, t = 0;
  while((k=read(STDIN_FILENO, ibuf+t, sizeof(ibuf)-t))>0) t += k;
}

static inline uint64_t read_uintll(){
  uint64_t x=0;
  while(*(++ibufe) <'0');
  do {
    x *= 10;
    x += *ibufe-'0';
  } while(*(++ibufe) >='0');

  return x;
}

static inline uint64_t readwrite_uintll(){
  uint64_t x=0;
  while(*(++ibufe) <'0');
  do {
    x *= 10;
    x += *ibufe-'0';
    *bufe++ = *ibufe;
  } while(*(++ibufe) >='0');
  *bufe++ = ' ';

  return x;
}


static inline void write_bitln(int x){
  *bufe++ = '0'+x;
  *bufe++ = '\n';
}

static inline void writeall(){
  int k, t = 0;
  while((k=write(STDOUT_FILENO, buf+t, bufe-buf-t))>0) t += k;
}


static inline uint64_t ex_gcd(uint64_t y){
  int i;
  uint64_t u, v;
  u = 1; v = 0;
  uint64_t x = 1LL<<63;

  for(i=0;i<64;i++){
    if(u&1){
      u = (u + y) / 2;
      v = v/2 + x;
    }
    else {
      u >>= 1; v >>= 1;
    }
  }

  return v;
} 


static inline uint64_t MR(uint128_t x, uint64_t m, uint64_t n){
  uint64_t z = ((uint128_t) ((uint64_t) x * m) * n + x) >> 64;
  return z < n ? z : z - n;
}

static inline uint64_t RM(uint64_t x, uint64_t r2, uint64_t m, uint64_t n){
  return MR((uint128_t) r2 * x, m, n);
}

static inline uint64_t mulmod64(uint64_t x, uint64_t y, uint64_t m, uint64_t n){
  return MR((uint128_t) x*y, m, n);
}

static inline uint64_t modpow64(uint64_t a, uint64_t k, uint64_t m, uint64_t n){
  uint64_t r;
  for(r=a,--k;k;k/=2){
    if(k&1) r = mulmod64(r, a, m, n);
    a = mulmod64(a, a, m, n);
  }
  return r;
}

int jacobi(int64_t a, uint64_t n){
  uint64_t t;
  int j = 1;
  while(a){
    if(a<0){
      a = -a;
      if((n&3)==3) j = -j;
    }
    int ba = __builtin_ctzll(a);
    a >>= ba;
    if((n%8==3||n%8==5) && (ba&1)) j = -j;
    if((a&n&3)==3) j = -j;
    t = a; a = n; n = t;
    a %= n;
    if(a>n/2) a-=n;
  }
  return n == 1 ? j : 0;
}


static inline uint64_t addmod64(uint64_t x, uint64_t y, uint64_t n){
  return x + y >= n ? x + y - n : x + y;
}

static inline uint64_t submod64(uint64_t x, uint64_t y, uint64_t n){
  return x >= y  ? x - y : x - y + n;
}


int is_prime64(const uint64_t n){
//  static const uint32_t ps[] = {3, 7, 11, 13, 17, 19};
  int i, j, r;
  uint64_t d;
  if(n <= 1) return 0;
  if(n <= 3) return 1;
  if(!(n & 1)) return 0;

/*
  for(i=0;i<sizeof(ps)/sizeof(ps[0]);i++){
    if(n==ps[i]) return 1;
    if(n%ps[i] == 0) return 0;
  }
*/

  const uint64_t one = -1ULL % n + 1;
  const uint64_t r2 = (uint128_t) (int128_t) -1 % n + 1;
  const uint64_t m = ex_gcd(n);
  {
    uint64_t a, t, mone;
    r = __builtin_ctzll(n-1);
    d = (n-1) >> r;
    mone = n - one;
    a = one << 1;
    if(a >= n) a -= n;
    if(a == 0) return 1;
    t = modpow64(a, d, m, n);
    if(t != one){
      for(j=0;t!=mone;j++){
        if(j == r-1) return 0;
        t = MR((uint128_t) t * t, m, n);
  //      if(t == one) return 0;
      }
    }
  }


  {
    int64_t D = 5;
    for(i=0;jacobi(D, n) != -1 && i<64;i++){
      if(i==16){
        uint32_t k = round(sqrtl(n));
        if(k*k == n) return 0;
      }
      if(i&1) D -= 2;
      else D += 2;
      D = -D;
    }
//if(i==64) puts("ERROR");

    uint64_t Q = RM(D < 0 ? (1-D)/4%n : n - (D-1)/4%n, r2, m, n);

    uint64_t u, v, Qn;
    uint64_t k = (n+1) << __builtin_clzll(n+1);
    u = one; v = one;
    Qn = Q;
    D %= (int64_t) n;
    D = RM(D < 0 ? n+D : D, r2, m, n);
    for(k<<=1;k;k<<=1){
      u = mulmod64(u,v,m,n);
      v = submod64(mulmod64(v,v,m,n), addmod64(Qn, Qn, n), n);
      Qn = mulmod64(Qn, Qn, m, n);
      if(k&(1ULL<<63)){
        uint64_t uu = addmod64(u, v, n);
        if(uu&1) uu = (uu + n) >> 1;
        else uu >>= 1;
        uint64_t vv = addmod64(mulmod64(D,u,m,n), v, n);
        if(vv&1) vv = (vv + n) >> 1;
        else vv >>= 1;
        u = uu;
        v = vv;
        Qn = mulmod64(Qn, Q, m, n);
      }
    }

    if(u == 0 || v == 0) return 1;
    uint64_t s = n+1;
    for(s>>=1;!(s&1);s>>=1){
      u = mulmod64(u,v,m,n);
      v = submod64(mulmod64(v,v,m,n), addmod64(Qn, Qn, n), n);
      if(v == 0) return 1;
      Qn = mulmod64(Qn, Qn, m, n);
    }
  }


  return 0;
}



int main(){
  int i, n;


  readall();
  n = read_uintll();
  for(i=0;i<n;i++){
    uint64_t x;
    x = readwrite_uintll();
    write_bitln(is_prime64(x));
  }
  writeall();
  return 0;
}