description: Theofanis has a riddle for you and if you manage to solve it, he will give you a Cypriot snack halloumi for free (Cypriot cheese).
  
  You are given an integer n. You need to find two integers l and r such that -10^{18} ≤ l < r ≤ 10^{18} and l + (l + 1) + … + (r - 1) + r = n.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
  
  The first and only line of each test case contains a single integer n (1 ≤ n ≤ 10^{18}).
  
  Output
  
  For each test case, print the two integers l and r such that -10^{18} ≤ l < r ≤ 10^{18} and l + (l + 1) + … + (r - 1) + r = n. 
  
  It can be proven that an answer always exists. If there are multiple answers, print any.
  
  Example
  
  Input
  
  
  7
  1
  2
  3
  6
  100
  25
  3000000000000
  
  
  Output
  
  
  0 1
  -1 2 
  1 2 
  1 3 
  18 22
  -2 7
  999999999999 1000000000001
  
  Note
  
  In the first test case, 0 + 1 = 1.
  
  In the second test case, (-1) + 0 + 1 + 2 = 2.
  
  In the fourth test case, 1 + 2 + 3 = 6.
  
  In the fifth test case, 18 + 19 + 20 + 21 + 22 = 100.
  
  In the sixth test case, (-2) + (-1) + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 = 25.
solution: import java.io.*;
  import java.util.StringTokenizer;
  
  public class Main {
      public static class FastInput{
         private  BufferedReader br;
         private StringTokenizer st;
          public FastInput(){
              br = new BufferedReader(new InputStreamReader(System.in));
          }
          public String next(){
              while (st == null || !st.hasMoreTokens()){
                  try {
                      st = new StringTokenizer(br.readLine());
                  }catch (IOException obj){
                      System.out.println(obj);
                  }
              }
              return st.nextToken();
          }
          public int nextInt(){
              return Integer.parseInt(next());
          }
          public long nextLong(){
              return Long.parseLong(next());
          }
          public Double nextDouble(){
              return Double.parseDouble(next());
          }
          public String nextLine(){
              String str = "";
              try {
                  str = br.readLine().trim();
              }catch (IOException O){
                  O.printStackTrace();
              }
              return str;
          }
          public int[] inputIntArray(int n){
              int[] arr = new int[n];
              for (int i = 0; i < n; i++) arr[i] = nextInt();
              return arr;
          }
          public long[] inputLongArray(int n){
              long[] arr = new long[n];
              for (int i = 0; i < n; i++) arr[i] = nextLong();
              return arr;
          }
      }
      public static class FastOutput{
          private final BufferedWriter bw;
          public FastOutput(){
              bw = new BufferedWriter(new OutputStreamWriter(System.out));
          }
          public void print(Object object) throws IOException{
  
              bw.write(""+object+" ");
          }
          public void println(Object object) throws IOException{
              bw.write(""+object+"\n");
          }
          public void ArrayPrintln(Object[] arr)throws IOException{
              for(Object obj : arr)
                  println(obj);
          }
          public void arrayPrint(Object[] arr)throws IOException{
              for(Object obj : arr)
                  print(obj);
          }
          public void flush()throws IOException{
              bw.flush();
          }
          public void close() throws IOException{
              bw.close();
          }
      }
      //public static final int MOD = 1000000007;
      public static void main(String[] args) throws IOException{
          FastInput input = new FastInput();
          FastOutput out = new FastOutput();
          int test = input.nextInt();
          while (test-- > 0) {
              long n = input.nextLong();
              if((n & 1) == 0){
                  long last = n;
                  long fast = (n-1)*(-1);
                  out.println(fast+" "+last);
              }else{
                  long fast = n /2;
                  long last = (n/2)+1;
                  out.println(fast+" "+last);
              }
              out.flush();
          }
          out.close();
      }
  }