description: Polycarp has found a table having an infinite number of rows and columns. The rows are numbered from 1, starting from the topmost one. The columns are numbered from 1, starting from the leftmost one.
  
  Initially, the table hasn't been filled and Polycarp wants to fix it. He writes integers from 1 and so on to the table as follows.
  
  <image> The figure shows the placement of the numbers from 1 to 10. The following actions are denoted by the arrows.
  
  The leftmost topmost cell of the table is filled with the number 1. Then he writes in the table all positive integers beginning from 2 sequentially using the following algorithm.
  
  First, Polycarp selects the leftmost non-filled cell in the first row and fills it. Then, while the left neighbor of the last filled cell is filled, he goes down and fills the next cell. So he goes down until the last filled cell has a non-filled neighbor to the left (look at the vertical arrow going down in the figure above).
  
  After that, he fills the cells from the right to the left until he stops at the first column (look at the horizontal row in the figure above). Then Polycarp selects the leftmost non-filled cell in the first row, goes down, and so on.
  
  A friend of Polycarp has a favorite number k. He wants to know which cell will contain the number. Help him to find the indices of the row and the column, such that the intersection of the row and the column is the cell containing the number k.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
  
  Each test case consists of one line containing one integer k (1 ≤ k ≤ 10^9) which location must be found.
  
  Output
  
  For each test case, output in a separate line two integers r and c (r, c ≥ 1) separated by spaces — the indices of the row and the column containing the cell filled by the number k, respectively.
  
  Example
  
  Input
  
  
  7
  11
  14
  5
  4
  1
  2
  1000000000
  
  
  Output
  
  
  2 4
  4 3
  1 3
  2 1
  1 1
  1 2
  31623 14130
solution: # ------------------- fast io --------------------
  from __future__ import division, print_function
  import os
  import sys
  from io import BytesIO, IOBase
  
  
   
  import itertools
   
   
  if sys.version_info[0] < 3:
      input = raw_input
      range = xrange
   
      filter = itertools.ifilter
      map = itertools.imap
      zip = itertools.izip
   
      
  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")
  if os.path.exists('input.txt'):
      sys.stdin = open('input.txt','r')
      sys.stdout = open('output.txt','w')
   
   
  # ------------------- fast io --------------------
  from math import *
  from itertools import * # chain,groupby,permutations,combinations
  from collections import *
  from bisect import *
  from heapq import *
   
   
  
  
   
  """
   
  def gcd(x, y):
      
      while y:
          x, y = y, x % y
      return x
   
   
  def prod(a, mod=10**9+7):
      ans = 1
      for each in a:
          ans = (ans * each) % mod
      return ans
   
  def lcm(a, b): return a * b // gcd(a, b)
   
  def binary(x, length=16):
      y = bin(x)[2:]
      return y if len(y) >= length else "0" * (length - len(y)) + y
   
   
  def powerset(s):
      n=len(s)
      
      return chain.from_iterable(combinations(s,r) for r in range(1,n))
   
  def binarySearch(arr,x): 
      l=0
      r=len(arr)-1
      while l <= r: 
    
          mid = l + (r - l) // 2; 
          if arr[mid] == x: 
              return mid 
          elif arr[mid] < x: 
              l = mid + 1
          else: 
              r = mid - 1
      return -1
   
  def prime(n): #array of prime numbers
      arr = [1]*(n+1)
      arr[0] = arr[1] = 0
      p=2
      while p*p<=n:
          if arr[p]:
              for i in range(p * 2, n + 1, p):
                  arr[i] = 0
              p+=1
   
   
      return arr
  
  def prime(n):
      # Returns  a list of primes < n 
      sieve = [True] * n
      for i in range(3,int(n**0.5)+1,2):
          if sieve[i]:
              sieve[i*i::2*i]=[False]*((n-i*i-1)//(2*i)+1)
      return [2] + [i for i in range(3,n,2) if sieve[i]]
   
  def isprime(x) -> bool: #return true if number is prime
      i=2
      while i*i<=x:
          if x%i==0:
              return 0
          i+=1
      return 1
   
   
  def palindrome(string,start,end):
      if start==end:
          return True
      if end==1:
          return True
      return string[start]==string[end-1] and palindrome(string,start+1,end-1)
   
  def binomialCoeff(n, k):
   
      
      C = [0 for i in range(k+1)]
      C[0] = 1  
   
      for i in range(1, n+1):
   
          
          j = min(i, k)
          while (j > 0):
              C[j] = C[j] + C[j-1]
              j -= 1
   
      return C[k]
   
  """
   
  #----#
   
   
  
  inf = float("inf")
  mod = 10**9+7
   
  def aa(): #for int
      return int(input())
  def bb(): #for int arr
      return list(map(int,input().split()))
  def cc():  #for string
      s = input()
      return list(s)
  def dd(): #space seperated intege
      return map(int,input().split())
  #----#
  arr = []
  for i in range(1,1000000):
      if i%3==0 or i%10==3:
          pass
      else:
          arr.append(i)
  def koi_coding_sikha_do():
  
      
      
      
      n = aa()
      m = int(sqrt(n))
      x = 1
      y = m+1
      temp = m*m + 1
  
      if m*m==n:
          print(m,1)
          return
  
      for i in range(m+1):
          if temp==n:
              
              print(x,y)
              return
          x+=1
          temp+=1
      for i in range(m+1):
          if temp==n:
              
              print(x-1,y-1)
              return
          y-=1
          temp+=1
  
  
      
  
  
  
  
  
  
      
  
  
  
  onlyone = 0
  t=1 if onlyone else int(input())
  while(t):
      
      koi_coding_sikha_do()
      
      t-=1
   
  
   
  """
   
  __________          __  .__                              __    __             _________                          
  \______   \___.__._/  |_|  |__   ____   ____             \ \   \ \            \_   ___ \     .__         .__     
   |     ___<   |  |\   __\  |  \ /  _ \ /    \             \ \   \ \           /    \  \/   __|  |___   __|  |___ 
   |    |    \___  | |  | |   Y  (  <_> )   |  \            / /   / /           \     \____ /__    __/  /__    __/ 
   |____|    / ____| |__| |___|  /\____/|___|  /           /_/   /_/             \______  /    |__|        |__|    
             \/                \/            \/                                         \/                         
   
   
  Unke aakhon me aasu aur chahre pe hasi hai......lagta hai unki lulli unki zip me phasi hai
  """
   
   
   
  
  
  
      
  