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: 
  /*
      Author : Kartikey Rana
      from MSIT New Delhi
   */
  import java.util.*;
  import java.util.Arrays;
  import java.util.Collections;
  import javax.sql.rowset.serial.SerialArray;
  import javax.swing.text.html.HTMLDocument.HTMLReader.PreAction;
  import java.io.*;
  import java.math.*;
  import java.sql.Array;;
  
  public class Main {
  	static class FR {
  
  		BufferedReader br;
  		StringTokenizer st;
  
  		public FR() {
  			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;
  		}
  
  		// NEXT INT ARRAY
  
  		int[] NIA(int n) {
  			int arr[] = new int[n];
  			for (int i = 0; i < n; i++)
  				arr[i] = nextInt();
  			return arr;
  		}
  
  		// NEXT DOUBLE ARRAY
  
  		double[] NDA(int n) {
  			double arr[] = new double[n];
  			for (int i = 0; i < n; i++)
  				arr[i] = nextDouble();
  			return arr;
  		}
  
  		// NEXT LONG ARRAY
  
  		long[] NLA(int n) {
  			long[] arr = new long[n];
  			for (int i = 0; i < n; i++)
  				arr[i] = nextLong();
  			return arr;
  		}
  
  		// NEXT STRING ARRAY
  
  		String[] NSA(int n) {
  			String[] arr = new String[n];
  			for (int i = 0; i < n; i++)
  				arr[i] = next();
  			return arr;
  		}
  
  		// NEXT CHARACTER ARRAY
  
  		char[] NCA(int n) {
  			char[] arr = new char[n];
  			String s = sc.nextLine();
  
  			for (int i = 0; i < n; i++)
  				arr[i] = s.charAt(i);
  			return arr;
  		}
  
  	}
  
  //*************************  FR CLASS ENDS **********************************
  
  	static long mod = (long) (1e9 + 7);
  
  	public static int[] sieve(int n) {
  
  		int[] primes = new int[n + 1];
  		for (int i = 0; i <= n; i++) {
  			primes[i] = i;
  		}
  
  		for (int i = 2; i < n; i++) {
  			if (primes[i] < 0)
  				continue;
  			if ((long) i * (long) i > n)
  				break;
  			for (int j = i * i; j < n; j++) {
  				if (primes[j] > 0 && primes[j] % primes[i] == 0)
  					primes[j] = -primes[j];
  			}
  		}
  		return primes;
  	}
  
  	static int lcm(int a, int b) {
  		return (int) ((a / gcd(a, b)) * b);
  	}
  
  	static long gcd(long a, long b) {
  		if (b == 0)
  			return a;
  
  		return gcd(b, a % b);
  	}
  
  	static long[][] ncr(int n, int k) {
  		long C[][] = new long[n + 1][k + 1];
  		int i, j;
  
  		// Calculate value of Binomial
  		// Coefficient in bottom up manner
  		for (i = 0; i <= n; i++) {
  			for (j = 0; j <= Math.min(i, k); j++) {
  				// Base Cases
  				if (j == 0 || j == i)
  					C[i][j] = 1;
  
  				// Calculate value using
  				// previously stored values
  				else
  					C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
  			}
  		}
  
  		return C;
  	}
  
  	static long modInverse(long a, long m) {
  		long g = gcd(a, m);
  
  		return power(a, m - 2, m);
  
  	}
  
  	static long power(long x, long y, long m) {
  		if (y == 0)
  			return 1;
  		long p = power(x, y / 2, m) % m;
  		p = (int) ((p * (long) p) % m);
  		if (y % 2 == 0)
  			return p;
  		else
  			return (int) ((x * (long) p) % m);
  	}
  
  	static int XOR(int n) {
  		if (n % 4 == 0)
  			return n;
  
  		if (n % 4 == 1)
  			return 1;
  
  		if (n % 4 == 2)
  			return n + 1;
  
  		return 0;
  	}
  
  	/* ***************************************************************************************************************************************************/
  
  	static FR sc = new FR();
  	static StringBuilder sb = new StringBuilder();
  
  	public static void main(String args[]) throws IOException {
  
  		int tc = sc.nextInt();
  //		int tc = 1;
  		while (tc-- > 0) {
  			TEST_CASE();
  		}
  		sb.setLength(sb.length() - 1);
  		System.out.println(sb);
  	}
  
  	static class Pair implements Comparable<Pair> {
  
  		int x;
  		int y;
  
  		public Pair(int x, int y) {
  			super();
  			this.x = x;
  			this.y = y;
  		}
  
  		@Override
  		public int compareTo(Pair o) {
  			return o.x - this.x;
  		}
  
  	}
  	
  	static int[] fact;
  	static void factorial(int n) {
  		fact = new int[n+1];
  		generateFactArray(n+1);
  	}
  	
  	static int generateFactArray(int n) {
  		if(n < 2) {
  			fact[n] = 1;
  			return fact[n];
  		}
  		
  		fact[n] = generateFactArray(n-1);
  		return fact[n];
  			
  	}
  
  	static void TEST_CASE() throws IOException {
  		// BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  		
  		long n = sc.nextLong();
  		long a = -(n-1);
  		long b = n;
  		
  		sb.append(a + " " +  b + "\n");
  		
  			
  		
  	}
  }
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  