description: Polycarp likes squares and cubes of positive integers. Here is the beginning of the sequence of numbers he likes: 1, 4, 8, 9, ....
  
  For a given number n, count the number of integers from 1 to n that Polycarp likes. In other words, find the number of such x that x is a square of a positive integer number or a cube of a positive integer number (or both a square and a cube simultaneously).
  
  Input
  
  The first line contains an integer t (1 ≤ t ≤ 20) — the number of test cases.
  
  Then t lines contain the test cases, one per line. Each of the lines contains one integer n (1 ≤ n ≤ 10^9).
  
  Output
  
  For each test case, print the answer you are looking for — the number of integers from 1 to n that Polycarp likes.
  
  Example
  
  Input
  
  
  6
  10
  1
  25
  1000000000
  999999999
  500000000
  
  
  Output
  
  
  4
  1
  6
  32591
  32590
  23125
solution: //package haridevelops.commons.contest762.dev3;
  
  
  import java.lang.*;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Comparator;
  import java.util.List;
  import java.util.StringTokenizer;
  
  public class B {
      static FastReader fr;
      static int arrForIndexSort[];
      static Integer map1[];
      static Integer map2[];
  
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
          public FastReader()
          {
              br = new BufferedReader(
                      new InputStreamReader(System.in));
          }
  
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() { return Integer.parseInt(next()); }
  
          long nextLong() { return Long.parseLong(next()); }
  
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
  
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
      static class Pair{
          int first;
          int second;
          Pair(int first, int second){
              this.first = first;
              this.second = second;
          }
          @Override
          public boolean equals(Object b) {
              Pair a = (Pair)b;
              if(this.first == a.first && this.second==a.second) {
                  return true;
              }
              return false;
          }
      }
      class PairSorter implements Comparator<Pair>{
          public int compare(Pair a, Pair b) {
              if(a.first!=b.first) {
                  return a.first-b.first;
              }
              return a.second-b.second;
          }
      }
      static class DoublePair{
          double first;
          double second;
          DoublePair(double first, double second){
              this.first = first;
              this.second = second;
          }
          @Override
          public boolean equals(Object b) {
              Pair a = (Pair)b;
              if(this.first == a.first && this.second==a.second) {
                  return true;
              }
              return false;
          }
      }
      class DoublePairSorter implements Comparator<DoublePair>{
          public int compare(DoublePair a, DoublePair b) {
              if(a.second>b.second) {
                  return 1;
              }
              else if(a.second<b.second) {
                  return -1;
              }
              return 0;
          }
      }
      class IndexSorter implements Comparator<Integer>{
          public int compare(Integer a, Integer b) {
              //desc
              if(arrForIndexSort[b]==arrForIndexSort[a]) {
                  return b-a;
              }
              return arrForIndexSort[b]-arrForIndexSort[a];
          }
      }
      class ListSorter implements Comparator<List>{
          public int compare(List a, List b) {
              return b.size()-a.size();
          }
      }
      static class DisjointSet{
          int[] dsu;
          public DisjointSet(int n) {
              makeSet(n);
          }
          public void makeSet(int n) {
              dsu = new int[n+1];
              //*** 1 Based indexing ***
              for(int i=1;i<=n;i++) {
                  dsu[i] = -1;
              }
          }
          public int find(int i) {
              while(dsu[i] > 0) {
                  i = dsu[i];
              }
              return i;
          }
          public void union(int i, int j) {
              int iRep = find(i);
              int jRep = find(j);
              if(iRep == jRep) {
                  return;
              }
              if(dsu[iRep]>dsu[jRep]) {
                  dsu[jRep] += dsu[iRep];
                  dsu[iRep] = jRep;
              }
              else {
                  dsu[iRep] += dsu[jRep];
                  dsu[jRep] = iRep;
              }
          }
      }
      public static void main(String[] args) {
          fr = new FastReader();
          int T = 1;
          T = fr.nextInt();
          int t1 = T;
          while (T-- > 0) {
              solve();
          }
      }
  
      public static void solve() {
          long input = fr.nextLong();
          System.out.println((int) Math.sqrt(input) + (int) Math.cbrt(input) - (int) (Math.sqrt(Math.cbrt(input))));
      }
  
  }
  