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;
  
  import static java.lang.Double.parseDouble;
  import static java.lang.Integer.parseInt;
  import static java.lang.Long.parseLong;
  import static java.lang.System.getProperty;
  import static java.lang.System.in;
  
  public class Main {
  
      public static void main(String[] args) {
          try (FastScanner scanner = getProperty("ONLINE_JUDGE", "").isEmpty() ? new FastScanner(new File("test.txt")) : new FastScanner(in)) {
              int T = scanner.nextInt();
              for (int t = 1; t <= T; ++t) {
                  long N = scanner.nextLong();
                  long[] s = new Main(N).solve();
                  System.out.print(s[0]);
                  System.out.print(" ");
                  System.out.println(s[1]);
  /*
                  long c = 0;
                  for (long i = s[0]; i <= s[1]; ++ i) {
                      c += i;
                  }
                  if (c != N) {
                      System.out.println("Error " + c + " " + N);
                  }
  */
              }
          }
          catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      private final long N;
  
      public Main(long n) {N = n;}
  
      public long[] solve() {
          return solve(N, 1);
      }
  
      public long[] solve(long n, long times) {
          if (n % 2 == 1) {
              long l = n / 2 - (times - 1);
              long r = n / 2 + times;
              return new long[]{l, r};
          }
          return solve(n / 2, times * 2);
      }
  
      static class FastScanner implements AutoCloseable {
          final BufferedReader bufferedReader;
          StringTokenizer stringTokenizer;
  
          private FastScanner(File file) throws FileNotFoundException {
              bufferedReader = new BufferedReader(new FileReader(file));
          }
  
          private FastScanner(InputStream in) {
              bufferedReader = new BufferedReader(new InputStreamReader(in));
          }
  
          @Override
          public void close() throws Exception {
              bufferedReader.close();
          }
  
          public double nextDouble() throws IOException {
              return parseDouble(nextToken());
          }
  
          private String nextToken() throws IOException {
              while (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                  stringTokenizer = new StringTokenizer(bufferedReader.readLine());
              }
              return stringTokenizer.nextToken();
          }
  
          public int[] nextIntArray(int n) throws IOException {
              int[] res = new int[n];
              for (int i = 0; i < n; ++i) {
                  res[i] = nextInt();
              }
              return res;
          }
  
          public int nextInt() throws IOException {
              return parseInt(nextToken(), 10);
          }
  
          public long[] nextLongArray(int n) throws IOException {
              long[] res = new long[n];
              for (int i = 0; i < n; ++i) {
                  res[i] = nextLong();
              }
              return res;
          }
  
          public long nextLong() throws IOException {
              return parseLong(nextToken(), 10);
          }
  
          public String[] nextStringArray(int n) throws IOException {
              String[] res = new String[n];
              for (int i = 0; i < n; ++i) {
                  res[i] = nextString();
              }
              return res;
          }
  
          public String nextString() throws IOException {
              return nextToken();
          }
  
      }
  
  }
  