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: /* package codechef; // don't place package name! */
  
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  /* Name of the class has to be "Main" only if the class is public. */
  public class Codechef
  {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; 
          } 
      } 
  //    static int mod = 998244353 ;
  //    static int N = 200005;
  //    static long factorial_num_inv[] = new long[N+1];
  //    static long natual_num_inv[] = new long[N+1];
  //    static long fact[] = new long[N+1];
  //    static void InverseofNumber() 
  //{ 
  //    natual_num_inv[0] = 1;
  //    natual_num_inv[1] = 1; 
  //    for (int i = 2; i <= N; i++) 
  //        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
  //} 
  //static void InverseofFactorial() 
  //{ 
  //    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
    
  //    for (int i = 2; i <= N; i++) 
  //        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
  //} 
  //static long nCrModP(long N, long R) 
  //{ 
  //    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
  //    return ans%mod; 
  //}
      //static boolean prime[];
      //static void sieveOfEratosthenes(int n)
      //{
      //    prime = new boolean[n+1];
          
      //    for (int i = 0; i <= n; i++)
      //        prime[i] = true;
   
      //    for (int p = 2; p * p <= n; p++)
      //    {
      //        // If prime[p] is not changed, then it is a
      //        // prime
      //        if (prime[p] == true)
      //        {
      //            // Update all multiples of p
      //            for (int i = p * p; i <= n; i += p)
      //                prime[i] = false;
      //        }
      //    }
   
          
      //}
      static int flag = 1;
  	public static void main (String[] args) throws java.lang.Exception
  	{
      //    InverseofNumber();
      //    InverseofFactorial();
      //   fact[0] = 1; 
      //   for (long i = 1; i <= 2*100000; i++)
      //   { 
      //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
      //   }
      
  		FastReader scan = new FastReader();
  		PrintWriter pw = new PrintWriter(System.out);
          int t = scan.nextInt();
          while(t-->0){
              long n = scan.nextLong();
             pw.println(-(n-1)+" "+n);
          pw.flush();  
          }       
      }
     
  }
  