description: Polycarp must pay exactly n burles at the checkout. He has coins of two nominal values: 1 burle and 2 burles. Polycarp likes both kinds of coins equally. So he doesn't want to pay with more coins of one type than with the other.
  
  Thus, Polycarp wants to minimize the difference between the count of coins of 1 burle and 2 burles being used. Help him by determining two non-negative integer values c_1 and c_2 which are the number of coins of 1 burle and 2 burles, respectively, so that the total value of that number of coins is exactly n (i. e. c_1 + 2 ⋅ c_2 = n), and the absolute value of the difference between c_1 and c_2 is as little as possible (i. e. you must minimize |c_1-c_2|).
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
  
  Each test case consists of one line. This line contains one integer n (1 ≤ n ≤ 10^9) — the number of burles to be paid by Polycarp.
  
  Output
  
  For each test case, output a separate line containing two integers c_1 and c_2 (c_1, c_2 ≥ 0) separated by a space where c_1 is the number of coins of 1 burle and c_2 is the number of coins of 2 burles. If there are multiple optimal solutions, print any one.
  
  Example
  
  Input
  
  
  6
  1000
  30
  1
  32
  1000000000
  5
  
  
  Output
  
  
  334 333
  10 10
  1 0
  10 11
  333333334 333333333
  1 2
  
  Note
  
  The answer for the first test case is "334 333". The sum of the nominal values of all coins is 334 ⋅ 1 + 333 ⋅ 2 = 1000, whereas |334 - 333| = 1. One can't get the better value because if |c_1 - c_2| = 0, then c_1 = c_2 and c_1 ⋅ 1 + c_1 ⋅ 2 = 1000, but then the value of c_1 isn't an integer.
  
  The answer for the second test case is "10 10". The sum of the nominal values is 10 ⋅ 1 + 10 ⋅ 2 = 30 and |10 - 10| = 0, whereas there's no number having an absolute value less than 0.
solution: //package cp;
  import java.util.*;
  import static java.lang.Math.min;
  import static java.lang.Math.abs;
  import static java.lang.Math.max;
  import java.io.*;
   
  public class Codechef {
  	static long[] mods = {1000000007, 998244353, 1000000009};
  	static long mod = mods[0];
  	public static MyScanner in;
      public static PrintWriter out;
      static int[][] dp;
      
      
  	public static void main( String[] args ) throws IOException{
  		
   		in = new MyScanner();
   		out = new PrintWriter(System.out);
   		StringBuilder ans1=new StringBuilder();
  		int test=in.nextInt();
  		while(test-->0) {
  			//StringBuilder ans=new StringBuilder();
  			long n=in.nextLong();
  			
  			long c11=n/3;
  			long c12=n/3;
  			
  			long n1=(n-n/3), n2=n-(n/3);
  			
  			while(n1%2!=0){
  			     n1--;
  			     c11++;
  			}
  			
  			while(n2%2!=0){
  			     n2++;
  			     c12--;
  			}
  			
  			long c2=0;
  			String ans="";
  			if(Math.abs(c11-n1/2)<Math.abs(c12-n2/2)){
  			     c2=n1/2;     
  			     ans=c11+" "+c2;
  			}else{
  			     c2=n2/2;
  			     ans=c12+" "+c2;
  			}
  			
  			if(n==1)  ans=1+" "+0;
  			if(n==2)  ans=0+" "+1;
  			
  			ans1.append(ans).append(System.getProperty("line.separator"));
  		}
  		
  		out.println(ans1);
   		out.close();
   		
   	}
   	
  	static long lcm_comp(long a, long b) {	return (a / gcd_comp(a, b)) * b;	}
   
  	static long gcd_comp(long a, long b){
          if (a == 0)		return b;
          if (b == 0)		return a;
          long k;
          for (k = 0; ((a | b) & 1) == 0; ++k){
              a >>= 1;
              b >>= 1;
          }
          while ((a & 1) == 0)	a >>= 1;  
          do{
              while ((b & 1) == 0)	 b >>= 1;
              if (a > b){    
                  long temp = a;
                  a = b;
                  b = temp;
              }
              b = (b - a);
          } while (b != 0);
          return a << k;
      }
  
  	
  	//comparator to solve according to b in descending order
  	static class Pair implements Comparable<Pair>{
  		private long a;
  		private long b;
  		public Pair(long a, long b) {
  			this.a = a;
  			this.b = b;
  		}
  		public int compareTo(Pair other) {
  			return Long.compare(this.b, other.b );		//to sort in ascending order swap the arguments in Long.compare
  			//return Long.compare(other.b ,this.b); 	//to sort in descending order swap the arguments in Long.compare
  		}
  	}
  	
  	static void printArray(long[] a) {
  		StringBuilder stringBuilder=new StringBuilder();
  		for(long i: a)	stringBuilder.append(i).append(" ");
  		out.println(stringBuilder);
  	}
  	
  	public static void sort(long[] array){
  		ArrayList<Long> copy = new ArrayList<>();
  		for (long i : array)
  			copy.add(i);
  		Collections.sort(copy);
  		for(int i = 0;i<array.length;i++)
  			array[i] = copy.get(i);
  	}
  	
  	public static void sortDes(long[] array){
  		ArrayList<Long> copy = new ArrayList<>();
  		for (long i : array)
  			copy.add(i);
  		Collections.sort(copy);
  		int j=array.length-1;
  		for(int i = 0;i<array.length;i++)
  			array[j--] = copy.get(i);
  	}
  	
  	
  	static String[] readArrayString(int n){
  		String[] array = new String[n];
  		for(int j =0 ;j<n;j++)
  			array[j] = in.next();
  		return array;
  	}
  	
  	
  	static int[] readArrayInt(int n){
      	int[] array = new int[n];
      	for(int j = 0;j<n;j++)
      		array[j] = in.nextInt();
      	return array;
      }
  	
  	static int[] readArrayInt1(int n){
  		int[] array = new int[n+1];
  		for(int j = 1;j<=n;j++){
  			array[j] = in.nextInt();
  		}
  		return array;
  	}
  	
  	static long[] readArrayLong(int n){
  		long[] array = new long[n];
  		for(int j =0 ;j<n;j++)
  			array[j] = in.nextLong();
  		return array;
  	}
  	
  	static double[] readArrayDouble(int n){
  		double[] array = new double[n];
  		for(int j =0 ;j<n;j++)
  			array[j] = in.nextDouble();
  		return array;
  	}
  	
  	static int minIndex(int[] array){
  		int minValue = Integer.MAX_VALUE;
  		int minIndex = -1;
  		for(int j = 0;j<array.length;j++){
  			if (array[j] < minValue){
  				minValue = array[j];
  				minIndex = j;
  			}
  		}
  		return minIndex;
  	}
  	
  	static int minIndex(long[] array){
  		long minValue = Long.MAX_VALUE;
  		int minIndex = -1;
  		for(int j = 0;j<array.length;j++){
  			if (array[j] < minValue){
  				minValue = array[j];
  				minIndex = j;
  			}
  		}
  		return minIndex;
  	}
  	
  	static int minIndex(double[] array){
  		double minValue = Double.MAX_VALUE;
  		int minIndex = -1;
  		for(int j = 0;j<array.length;j++){
  			if (array[j] < minValue){
  				minValue = array[j];
  				minIndex = j;
  			}
  		}
  		return minIndex;
  	}
  	
  	
  	static int maxIndex(int[] array){
  		int maxValue = Integer.MIN_VALUE;
  		int maxIndex = -1;
  		for(int j = 0;j<array.length;j++){
  			if (array[j] > maxValue){
  				maxValue = array[j];
  				maxIndex = j;
  			}
  		}
  		return maxIndex;
  	}
  	
  	static int maxIndex(long[] array){
  		long maxValue = Long.MIN_VALUE;
  		int maxIndex = -1;
  		for(int j = 0;j<array.length;j++){
  			if (array[j] > maxValue){
  				maxValue = array[j];
  				maxIndex = j;
  			}
  		}
  		return maxIndex;
  	}
  	
  	
  	static long power(long x, long y){
  		if (y == 0)
  			return 1;
  		if (y%2 == 1)
  			return (x*power(x, y-1))%mod;
  		return power((x*x)%mod, y/2)%mod;
  	}
  	static void verdict(boolean a){
          out.println(a ? "YES" : "NO");
      }
  	
      public 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;
          }
          
      }	
  }