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 com.company;
  
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  
  public final class Main {
  
      FastReader s;
  
      public static void main(String[] args) throws java.lang.Exception {
  
          new Main().run();
  
      }
  
      void run() {
          s = new FastReader();
          solve();
      }
  
  
  
  
      StringBuffer sb;
  
  
      void solve() {
  
          sb = new StringBuffer();
  
          for (int T = s.nextInt(); T > 0; T--)
          {
  
              start();
  
  
          }
  
  
          System.out.print(sb);
  
      }
  
  
  
      void start()
      {
  
  
          long n = s.nextLong();
  
         long h = (long)Math.sqrt(n);
          long ha =  (long)Math.cbrt(n);
          long kk = ha;
         for(long j = 1; j<=ha; j++)
         {
             long ll = j*j*j;
             if(Math.sqrt(ll) == (double) ((long)(Math.sqrt(ll))))
             {
                 kk--;
             }
         }
         sb.append((kk+h)+"\n");
  
  
  
      }
  
  
  
  
      class Pair {
          int a;
          int b;
  
          public Pair(int a, int b) {
              this.a = a;
              this.b = b;
          }
  
          void print() {
              System.out.println(a + " " + b);
          }
  
      }
  
      class segmentTree{
           int[] tree;
           int n;
           public segmentTree(int[] nums) {
               if (nums.length > 0) {
                   n = nums.length;
                   tree = new int[n * 2];
                   buildTree(nums);
               }
           }
  
           private void buildTree(int[] nums) {
               for (int i = n, j = 0;  i < 2 * n; i++,  j++)
                   tree[i] = nums[j];
               for (int i = n - 1; i > 0; --i)
                   tree[i] = tree[i * 2] + tree[i * 2 + 1];
           }
  
           void update(int pos, int val) {
               pos += n;
               tree[pos] = val;
               while (pos > 0) {
                   int left = pos;
                   int right = pos;
                   if (pos % 2 == 0) {
                       right = pos + 1;
                   } else {
                       left = pos - 1;
                   }
                   // parent is updated after child is updated
                   tree[pos / 2] = tree[left] + tree[right];
                   pos /= 2;
               }
           }
  
           public int sumRange(int l, int r) {
               // get leaf with value 'l'
               l += n;
               // get leaf with value 'r'
               r += n;
               int sum = 0;
               while (l <= r) {
                   if ((l % 2) == 1) {
                       sum += tree[l];
                       l++;
                   }
                   if ((r % 2) == 0) {
                       sum += tree[r];
                       r--;
                   }
                   l /= 2;
                   r /= 2;
               }
               return sum;
           }
  
       }
  
      int gcd(int a, int b) {
          if (b == 0)
              return a;
          return gcd(b, a % b);
      }
  
      long gcd(long a, long b) {
          if (b == 0)
              return a;
          return gcd(b, a % b);
      }
  
      long power(long x, long y, long p) {
          long res = 1;
  
  
          x = x % p;
  
          while (y > 0) {
  
              if ((y & 1) > 0)
                  res = (res * x) % p;
  
  
              y = y >> 1;
              x = (x * x) % p;
          }
          return res;
      }
  
      int find(int dsu[], int i) {
          if (dsu[i] == i)
              return i;
          dsu[i] = find(dsu, dsu[i]);
          return dsu[i];
      }
  
      void union(int dsu[], int i, int j) {
          int a = find(dsu, i);
          int b = find(dsu, j);
          dsu[a] = b;
      }
  
      static void sort(int[] a) {
          ArrayList<Integer> l = new ArrayList<>();
          for (int i : a)
              l.add(i);
          Collections.sort(l);
          for (int i = 0; i < a.length; i++)
              a[i] = l.get(i);
      }
  
      static void sort(long[] a) {
          ArrayList<Long> l = new ArrayList<>();
          for (long i : a)
              l.add(i);
          Collections.sort(l);
          for (int i = 0; i < a.length; i++)
              a[i] = l.get(i);
      }
  
      static String sort(String s) {
          Character ch[] = new Character[s.length()];
          for (int i = 0; i < s.length(); i++) {
              ch[i] = s.charAt(i);
          }
          Arrays.sort(ch);
          StringBuffer st = new StringBuffer("");
          for (int i = 0; i < s.length(); i++) {
              st.append(ch[i]);
          }
          return st.toString();
      }
  
      // long array input
      public long[] longArr(int len) {
          // long arr input
          long[] arr = new long[len];
          String[] strs = s.nextLine().trim().split("\\s+");
          for (int i = 0; i < len; i++) {
              arr[i] = Long.parseLong(strs[i]);
  
          }
          return arr;
      }
  
      // int arr input
      public int[] intArr(int len) {
          // long arr input
          int[] arr = new int[len];
          String[] strs = s.nextLine().trim().split("\\s+");
          for (int i = 0; i < len; i++) {
              arr[i] = Integer.parseInt(strs[i]);
  
          }
          return arr;
      }
  
      public void printArray(int[] A) {
          System.out.println(Arrays.toString(A));
      }
  
      public void printArray(long[] A) {
          System.out.println(Arrays.toString(A));
      }
  
  
  
      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;
          }
      }
  
  }
  