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: # DEFINING SOME GOOD STUFF
  import heapq
  import sys
  from math import *
  import threading
  from heapq import *
  from itertools import count
  from pprint import pprint
  from collections import defaultdict
  from heapq import heapify, heappop, heappush
  
  # threading.stack_size(10**8)
  # sys.setrecursionlimit(300000)
  '''
  -> if you are increasing recursionlimit then remember submitting using python3 rather pypy3
  -> sometimes increasing stack size don't work locally but it will work on CF
  '''
  
  mod = 10 ** 9+7
  inf = 10 ** 15
  decision = ['NO', 'YES']
  yes = 'YES'
  no = 'NO'
  
  # ------------------------------FASTIO----------------------------
  import os
  
  from io import BytesIO, IOBase
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n")+(not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  # ________________________FAST FACTORIAL______________________________#
  class Factorial:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorials = [1, 1]
          self.invModulos = [0, 1]
          self.invFactorial_ = [1, 1]
  
      def calc(self, n):
          if n <= -1:
              print("Invalid argument to calculate n!")
              print("n must be non-negative value. But the argument was "+str(n))
              exit()
          if n < len(self.factorials):
              return self.factorials[n]
          nextArr = [0] * (n+1-len(self.factorials))
          initialI = len(self.factorials)
          prev = self.factorials[-1]
          m = self.MOD
          for i in range(initialI, n+1):
              prev = nextArr[i-initialI] = prev * i % m
          self.factorials += nextArr
          return self.factorials[n]
  
      def inv(self, n):
          if n <= -1:
              print("Invalid argument to calculate n^(-1)")
              print("n must be non-negative value. But the argument was "+str(n))
              exit()
          p = self.MOD
          pi = n % p
          if pi < len(self.invModulos):
              return self.invModulos[pi]
          nextArr = [0] * (n+1-len(self.invModulos))
          initialI = len(self.invModulos)
          for i in range(initialI, min(p, n+1)):
              next = -self.invModulos[p % i] * (p // i) % p
              self.invModulos.append(next)
          return self.invModulos[pi]
  
      def invFactorial(self, n):
          if n <= -1:
              print("Invalid argument to calculate (n^(-1))!")
              print("n must be non-negative value. But the argument was "+str(n))
              exit()
          if n < len(self.invFactorial_):
              return self.invFactorial_[n]
          self.inv(n)  # To make sure already calculated n^-1
          nextArr = [0] * (n+1-len(self.invFactorial_))
          initialI = len(self.invFactorial_)
          prev = self.invFactorial_[-1]
          p = self.MOD
          for i in range(initialI, n+1):
              prev = nextArr[i-initialI] = (prev * self.invModulos[i % p]) % p
          self.invFactorial_ += nextArr
          return self.invFactorial_[n]
  
  
  class Combination:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorial = Factorial(MOD)
  
      def ncr(self, n, k):
          if k < 0 or n < k:
              return 0
          k = min(k, n-k)
          f = self.factorial
          return f.calc(n) * f.invFactorial(max(n-k, k)) * f.invFactorial(min(k, n-k)) % self.MOD
  
      def npr(self, n, k):
          if k < 0 or n < k:
              return 0
          f = self.factorial
          return (f.calc(n) * f.invFactorial(n-k)) % self.MOD
  
  
  # _______________SEGMENT TREE ( logn range modifications )_____________#
  
  class SegmentTree:
      def __init__(self, data, default = 0, func = lambda a, b: max(a, b)):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len-1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size+self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i+i], self.data[i+i+1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx+self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx+1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # ____________________MY FAVOURITE FUNCTIONS_______________________#
  
  
  def lower_bound(li, num):
      answer = len(li)
      start = 0
      end = len(li)-1
  
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] >= num:
              answer = middle
              end = middle-1
          else:
              start = middle+1
      return answer  # min index where x is not less than num
  
  
  def upper_bound(li, num):
      answer = len(li)
      start = 0
      end = len(li)-1
  
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] <= num:
              start = middle+1
  
          else:
              answer = middle
              end = middle-1
      return answer  # max index where x is greater than num
  
  
  def abs(x):
      return x if x >= 0 else -x
  
  
  def binary_search(li, val):
      # print(lb, ub, li)
      ans = -1
      lb = 0
      ub = len(li)-1
      while (lb <= ub):
          mid = (lb+ub) // 2
          # print('mid is',mid, li[mid])
          if li[mid] > val:
              ub = mid-1
          elif val > li[mid]:
              lb = mid+1
          else:
              ans = mid  # return index
              break
      return ans
  
  
  def kadane(x):  # maximum sum contiguous subarray
      sum_so_far = 0
      current_sum = 0
      for i in x:
          current_sum += i
          if current_sum < 0:
              current_sum = 0
          else:
              sum_so_far = max(sum_so_far, current_sum)
      return sum_so_far
  
  
  def pref(li):
      pref_sum = [li[0]]
      for i in range(1, len(li)):
          pref_sum.append(pref_sum[-1]+i)
      return pref_sum
  
  
  def SieveOfEratosthenes(n):
      prime = [{1, i} for i in range(n+1)]
      p = 2
      while (p <= n):
          for i in range(p * 2, n+1, p):
              prime[i].add(p)
          p += 1
      return prime
  
  
  def primefactors(n):
      factors = []
      while (n % 2 == 0):
          factors.append(2)
          n //= 2
      for i in range(3, int(sqrt(n))+1, 2):  # only odd factors left
          while n % i == 0:
              factors.append(i)
              n //= i
      if n > 2:  # incase of prime
          factors.append(n)
      return factors
  
  
  def prod(li):
      ans = 1
      for i in li:
          ans *= i
      return ans
  
  
  # _______________________________________________________________#
  def given():
      a = list(map(int, input().split()))
      return a
  
  
  def givenStringList():
      s = list(input())
      return s
  
  
  def givenStringListInt():
      s = [int(x) for x in givenStringList()]
      return s
  
  
  # _________________________________________________________________#
  
  
  def main():
      karmanya = given()[0]
      # karmanya = 1
      while karmanya != 0:
          karmanya -= 1
          a = int(input())
          i = 1
          s = set()
          while(i**2<= a):
              s.add(i**2)
              i += 1
          i = 1
          while(i**3 <= a):
              s.add(i**3)
              i += 1
          print(len(s))
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  main()
  # t = threading.Thread(target=main)
  # t.start()
  # t.join()