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: //
  // Source code recreated from a .class file by IntelliJ IDEA
  // (powered by Fernflower decompiler)
  //
  
  import java.io.BufferedWriter;
  import java.io.DataInputStream;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.OutputStreamWriter;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Stack;
  
  public class CFC {
      static CFC.Reader sc = new CFC.Reader();
      static BufferedWriter bw;
      static int team1;
      static int team2;
      static int minkicks;
  
      public CFC() {
      }
  
      public static void main(String[] args) throws IOException {
          int t=sc.nextInt();
          for(int i=0;i<t;i++){
              int k=sc.nextInt();
              double v=Math.ceil(Math.sqrt(k));
              double u=Math.floor(Math.sqrt(k));
              if(u==v){
                  System.out.println((int)v+" "+1);
                  continue;
              }
              u*=u;
              int diff= k-(int)u;
              int c=0;
              int r=0;
  
              if(diff<v){
                  c= (int) v;
                  r=(k-(int)(u+1))+1;
  
              }else if(diff>v){
                  r= (int) v;
                  c=((int)(v*v)-k)+1;
              }else {
                  r=(int)(v);
                  c=(int)(v);
              }
              System.out.println(Math.max(r,1)+" "+Math.max(c,1));
  
          }
  
  
          bw.flush();
          bw.close();
      }
  
      public static int checker(int a) {
          if (a % 2 == 0) {
              return 1;
          } else {
              byte b;
              do {
                  b = 2;
              } while(a + b != (a ^ b));
  
              return b;
          }
      }
  
      public static boolean checkPrime(int n) {
          if (n != 0 && n != 1) {
              for(int j = 2; j * j <= n; ++j) {
                  if (n % j == 0) {
                      return false;
                  }
              }
  
              return true;
          } else {
              return false;
          }
      }
  
      public static void dfs1(List<List<Integer>> g, boolean[] visited, Stack<Integer> stack, int num) {
          visited[num] = true;
          Iterator var4 = ((List)g.get(num)).iterator();
  
          while(var4.hasNext()) {
              Integer integer = (Integer)var4.next();
              if (!visited[integer]) {
                  dfs1(g, visited, stack, integer);
              }
          }
  
          stack.push(num);
      }
  
      public static void dfs2(List<List<Integer>> g, boolean[] visited, List<Integer> list, int num, int c, int[] raj) {
          visited[num] = true;
          Iterator var6 = ((List)g.get(num)).iterator();
  
          while(var6.hasNext()) {
              Integer integer = (Integer)var6.next();
              if (!visited[integer]) {
                  dfs2(g, visited, list, integer, c, raj);
              }
          }
  
          raj[num] = c;
          list.add(num);
      }
  
      public static int inputInt() throws IOException {
          return sc.nextInt();
      }
  
      public static long inputLong() throws IOException {
          return sc.nextLong();
      }
  
      public static double inputDouble() throws IOException {
          return sc.nextDouble();
      }
  
      public static String inputString() throws IOException {
          return sc.readLine();
      }
  
      public static void print(String a) throws IOException {
          bw.write(a);
      }
  
      public static void printSp(String a) throws IOException {
          bw.write(a + " ");
      }
  
      public static void println(String a) throws IOException {
          bw.write(a + "\n");
      }
  
      public static long getAns(int[] ar, int c, long[][] dp, int i, int sign) {
          if (i < 0) {
              return 1L;
          } else if (c <= 0) {
              return 1L;
          } else {
              dp[i][c] = Math.max(dp[i][c], Math.max((long)ar[i] * getAns(ar, c - 1, dp, i - 1, sign), getAns(ar, c, dp, i - 1, 1)));
              return dp[i][c];
          }
      }
  
      public static long power(long a, long b, long c) {
          long ans;
          for(ans = 1L; b != 0L; b /= 2L) {
              if (b % 2L == 1L) {
                  ans *= a;
                  ans %= c;
              }
  
              a *= a;
              a %= c;
          }
  
          return ans;
      }
  
      public static long power1(long a, long b, long c) {
          long ans;
          for(ans = 1L; b != 0L; b /= 2L) {
              if (b % 2L == 1L) {
                  ans = multiply(ans, a, c);
              }
  
              a = multiply(a, a, c);
          }
  
          return ans;
      }
  
      public static long multiply(long a, long b, long c) {
          long res = 0L;
  
          for(a %= c; b > 0L; b /= 2L) {
              if (b % 2L == 1L) {
                  res = (res + a) % c;
              }
  
              a = (a + a) % c;
          }
  
          return res % c;
      }
  
      public static long totient(long n) {
          long result = n;
  
          for(long i = 2L; i * i <= n; ++i) {
              if (n % i == 0L) {
                  while(n % i == 0L) {
                      n /= i;
                  }
  
                  result -= result / i;
              }
          }
  
          if (n > 1L) {
              result -= result / n;
          }
  
          return result;
      }
  
      public static long gcd(long a, long b) {
          return b == 0L ? a : gcd(b, a % b);
      }
  
      public static boolean[] primes(int n) {
          boolean[] p = new boolean[n + 1];
          p[0] = false;
          p[1] = false;
  
          int i;
          for(i = 2; i <= n; ++i) {
              p[i] = true;
          }
  
          for(i = 2; i * i <= n; ++i) {
              if (p[i]) {
                  for(int j = i * i; j <= n; j += i) {
                      p[j] = false;
                  }
              }
          }
  
          return p;
      }
  
      public String LargestEven(String S) {
          int[] count = new int[10];
  
          int num;
          for(num = 0; num < S.length(); ++num) {
              ++count[S.charAt(num) - 48];
          }
  
          num = -1;
  
          for(int i = 0; i <= 8; i += 2) {
              if (count[i] > 0) {
                  num = i;
                  break;
              }
          }
  
          StringBuilder ans = new StringBuilder();
  
          for(int i = 9; i >= 0; --i) {
              int j;
              if (i != num) {
                  for(j = 1; j <= count[i]; ++j) {
                      ans.append(i);
                  }
              } else {
                  for(j = 1; j <= count[num] - 1; ++j) {
                      ans.append(num);
                  }
              }
          }
  
          if (num != -1 && count[num] > 0) {
              ans.append(num);
          }
  
          return ans.toString();
      }
  
      static {
          bw = new BufferedWriter(new OutputStreamWriter(System.out));
          team1 = 0;
          team2 = 0;
          minkicks = 10;
      }
  
      public static class Score {
          int l;
          String s;
  
          public Score(int l, String s) {
              this.l = l;
              this.s = s;
          }
      }
  
      public static class Ath {
          int r1;
          int r2;
          int r3;
          int r4;
          int r5;
          int index;
  
          public Ath(int r1, int r2, int r3, int r4, int r5, int index) {
              this.r1 = r1;
              this.r2 = r2;
              this.r3 = r3;
              this.r4 = r4;
              this.r5 = r5;
              this.index = index;
          }
      }
  
      static class Reader {
          private final int BUFFER_SIZE = 65536;
          private DataInputStream din;
          private byte[] buffer;
          private int bufferPointer;
          private int bytesRead;
  
          public Reader() {
              this.din = new DataInputStream(System.in);
              this.buffer = new byte[65536];
              this.bufferPointer = this.bytesRead = 0;
          }
  
          public Reader(String file_name) throws IOException {
              this.din = new DataInputStream(new FileInputStream(file_name));
              this.buffer = new byte[65536];
              this.bufferPointer = this.bytesRead = 0;
          }
  
          public String readLine() throws IOException {
              byte[] buf = new byte[64];
  
              int cnt;
              byte c;
              for(cnt = 0; (c = this.read()) != -1 && c != 10; buf[cnt++] = (byte)c) {
              }
  
              return new String(buf, 0, cnt);
          }
  
          public int nextInt() throws IOException {
              int ret = 0;
  
              byte c;
              for(c = this.read(); c <= 32; c = this.read()) {
              }
  
              boolean neg = c == 45;
              if (neg) {
                  c = this.read();
              }
  
              do {
                  ret = ret * 10 + c - 48;
              } while((c = this.read()) >= 48 && c <= 57);
  
              return neg ? -ret : ret;
          }
  
          public long nextLong() throws IOException {
              long ret = 0L;
  
              byte c;
              for(c = this.read(); c <= 32; c = this.read()) {
              }
  
              boolean neg = c == 45;
              if (neg) {
                  c = this.read();
              }
  
              do {
                  ret = ret * 10L + (long)c - 48L;
              } while((c = this.read()) >= 48 && c <= 57);
  
              return neg ? -ret : ret;
          }
  
          public double nextDouble() throws IOException {
              double ret = 0.0D;
              double div = 1.0D;
  
              byte c;
              for(c = this.read(); c <= 32; c = this.read()) {
              }
  
              boolean neg = c == 45;
              if (neg) {
                  c = this.read();
              }
  
              do {
                  ret = ret * 10.0D + (double)c - 48.0D;
              } while((c = this.read()) >= 48 && c <= 57);
  
              if (c == 46) {
                  while((c = this.read()) >= 48 && c <= 57) {
                      ret += (double)(c - 48) / (div *= 10.0D);
                  }
              }
  
              return neg ? -ret : ret;
          }
  
          private void fillBuffer() throws IOException {
              this.bytesRead = this.din.read(this.buffer, this.bufferPointer = 0, 65536);
              if (this.bytesRead == -1) {
                  this.buffer[0] = -1;
              }
  
          }
  
          private byte read() throws IOException {
              if (this.bufferPointer == this.bytesRead) {
                  this.fillBuffer();
              }
  
              return this.buffer[this.bufferPointer++];
          }
  
          public void close() throws IOException {
              if (this.din != null) {
                  this.din.close();
              }
          }
      }
  }
  