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.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.PriorityQueue;
  import java.util.StringTokenizer;
  
  
  import java.io.*;
   
  public class cf745 {
  	
  	private static class MyScanner {
  	    BufferedReader br;
  	    StringTokenizer st;
   
  	    public MyScanner() {
  	       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;
  	    }
   
  	 }
  	
  //
  //    public static int find(int[][] sq, int i, int j, int a, int b) {
  //	
  //	int x = sq[a][b];
  //	if(i-1>=0)
  //		x-=sq[i-1][b];
  //	if(j-1>=0)
  //		x-=sq[a][j-1];
  //	if(i-1>=0 && j-1>=0)
  //		x+=sq[i-1][j-1];
  //	return x;
  //	
  //    }
  //	
  	
  //	int[][] sq = new int[n][m];
  //	
  //	for(int i = 0; i<n; i++)
  //	{
  //		for(int j = 0; j<m; j++)
  //		{  
  //			if(i-1>=0)
  //				sq[i][j]+=sq[i-1][j];
  //			
  //			if(j-1>=0)
  //				sq[i][j]+=sq[i][j-1];
  //			
  //			if(i-1>=0 && j-1>=0)
  //				   sq[i][j]-=sq[i-1][j-1];	
  //
  //			if(arr[i][j]==1)
  //				sq[i][j]++;
  //			
  //		}
  //	}
  	
  	 private static class Pair implements Comparable<Pair> {
  			
  			int x;
  			int y;
  		
  			Pair(int x, int y)
  			{
  				this.x = x;
  				this.y = y;
  			}
  			
  			public int compareTo(Pair p)	
  			{
  				return ((Integer)this.x).compareTo(p.x);
  			}
  			
  		}
  	
  	
  	public static String solution(int arr[], int n, int x)
  	{	
  		ArrayList<Pair> list = new ArrayList<>();
  		
  		for(int i = 0; i<n; i++)
  			list.add(new Pair(arr[i], i));
  			
  		Collections.sort(list);
  		
  		int[] ind = new int[n];
  		for(int i = 0; i<n; i++)
  		  ind[list.get(i).y] = i;
  		
  		int a = x;
  		int b = n-1-x;
  		if(a>b+1)
  		{
  			for(int i = Math.max(0, b+1); i<Math.min(a,n); i++)
  				if(ind[i]!=i && arr[i]!=list.get(i).x)
  					return "NO";
  		}
  			
  		return "YES";
  			
  	}
          
  private static PrintWriter out = new PrintWriter(System.out);
   
  public static void main (String[] args)
  {
  	MyScanner s =  new MyScanner();
       
      int t = s.nextInt();
      
      for(int j = 0; j<t ; j++)
      {
      	long n = s.nextLong();
      	long l = (n-1)*-1;
      	long r = n;
     
      	out.println(l+" "+r);
      }
      
      out.flush();
      out.close();
      
  }
  }