description: Polycarp had an array a of 3 positive integers. He wrote out the sums of all non-empty subsequences of this array, sorted them in non-decreasing order, and got an array b of 7 integers.
  
  For example, if a = \{1, 4, 3\}, then Polycarp wrote out 1, 4, 3, 1 + 4 = 5, 1 + 3 = 4, 4 + 3 = 7, 1 + 4 + 3 = 8. After sorting, he got an array b = \{1, 3, 4, 4, 5, 7, 8\}.
  
  Unfortunately, Polycarp lost the array a. He only has the array b left. Help him to restore the array a.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.
  
  Each test case consists of one line which contains 7 integers b_1, b_2, ..., b_7 (1 ≤ b_i ≤ 10^9; b_i ≤ b_{i+1}). 
  
  Additional constraint on the input: there exists at least one array a which yields this array b as described in the statement.
  
  Output
  
  For each test case, print 3 integers — a_1, a_2 and a_3. If there can be several answers, print any of them.
  
  Example
  
  Input
  
  
  5
  1 3 4 4 5 7 8
  1 2 3 4 5 6 7
  300000000 300000000 300000000 600000000 600000000 600000000 900000000
  1 1 2 999999998 999999999 999999999 1000000000
  1 2 2 3 3 4 5
  
  
  Output
  
  
  1 4 3
  4 1 2
  300000000 300000000 300000000
  999999998 1 1
  1 2 2
  
  Note
  
  The subsequence of the array a is a sequence that can be obtained from a by removing zero or more of its elements.
  
  Two subsequences are considered different if index sets of elements included in them are different. That is, the values of the elements don't matter in the comparison of subsequences. In particular, any array of length 3 has exactly 7 different non-empty subsequences.
solution: 
  /*****  --->         :)    Vijender  Srivastava      (:       <---       *****/
  
  
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  public class Main
  {
      static FastReader sc =new FastReader();
      static PrintWriter out=new PrintWriter(System.out);
      static int mod=10000007;
      /* start */
      public static void main(String [] args)throws Exception {
          int t = i();
          while(t-->0)
          {
              long b[] = inputL(7);
             if(b[0]+b[1]+b[2]==b[6])
                 pl(b[0]+" "+b[1]+" "+b[2]);
             else
             {
                 pl(b[3]+" "+b[0]+" "+b[1]);
             }
          }
          out.close();
      }
  
      /* end */
      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 void p(Object o)
      {
          out.print(o);
      }
      static void pl(Object o)
      {
          out.println(o);
      }
      static int i() {
          return sc.nextInt();
      }
  
      static String s() {
          return sc.next();
      }
  
      static long l() {
          return sc.nextLong();
      }
  
      static char[] inputC()
      {
          String s = sc.nextLine();
          return s.toCharArray();
      }
  
      static int[] input(int n) {
          int A[]=new int[n];
          for(int i=0;i<n;i++) {
              A[i]=sc.nextInt();
          }
          return A;
      }
  
      static long[] inputL(int n) {
          long A[]=new long[n];
          for(int i=0;i<n;i++) {
              A[i]=sc.nextLong();
          }
          return A;
      }
  
      static long[] putL(long a[]) {
          long A[]=new long[a.length];
          for(int i=0;i<a.length;i++) {
              A[i]=a[i];
          }
          return A;
      }
  
      static String[] inputS(int n) {
          String A[]=new String[n];
          for(int i=0;i<n;i++) {
              A[i]=sc.next();
          }
          return A;
      }
  
      static int gcd(int a, int b)
      {
          if (a == 0)
              return b;
          return gcd(b % a, a);
      }
  
      static long gcd(long a, long b)
      {
          if (a == 0)
              return b;
          return gcd(b % a, a);
      }
  
      static int lcm(int a, int b)
      {
          return (a / gcd(a, b)) * b;
      }
  
      static String reverse(String s) {
          StringBuffer p=new StringBuffer(s);
          p.reverse();
          return p.toString();
      }
  
      static int min(int a,int b) {
          return Math.min(a, b);
      }
      static int min(int a,int b,int c) {
          return Math.min(a, Math.min(b, c));
      }
      static int min(int a,int b,int c,int d) {
          return Math.min(a, Math.min(b, Math.min(c, d)));
      }
  
      static int max(int a,int b) {
          return Math.max(a, b);
      }
      static int max(int a,int b,int c) {
          return Math.max(a, Math.max(b, c));
      }
      static int max(int a,int b,int c,int d) {
          return Math.max(a, Math.max(b, Math.max(c, d)));
      }
      static long min(long a,long b) {
          return Math.min(a, b);
      }
      static long min(long a,long b,long c) {
          return Math.min(a, Math.min(b, c));
      }
      static long min(long a,long b,long c,long d) {
          return Math.min(a, Math.min(b, Math.min(c, d)));
      }
      static long max(long a,long b) {
          return Math.max(a, b);
      }
      static long max(long a,long b,long c) {
          return Math.max(a, Math.max(b, c));
      }
      static long max(long a,long b,long c,long d) {
          return Math.max(a, Math.max(b, Math.max(c, d)));
      }
  
      static long sum(int A[]) {
          long sum=0;
          for(int i : A) {
              sum+=i;
          }
          return sum;
      }
  
      static long sum(long A[]) {
          long sum=0;
          for(long i : A) {
              sum+=i;
          }
          return sum;
      }
  
      static void print(int A[]) {
          for(int i : A) {
              System.out.print(i+" ");
          }
          System.out.println();
      }
  
      static void print(long A[]) {
          for(long i : A) {
              System.out.print(i+" ");
          }
          System.out.println();
      }
  
      static long mod(long x) {
          return ((x%mod + mod)%mod);
      }
  
      static long power(long x, long y)
      {
  
          if(y==0)
              return 1;
          if(x==0)
              return 0;
          long res = 1;
          while (y > 0) {
  
              if (y % 2 == 1)
                  res = (res * x) ;
  
              y = y >> 1;
              x = (x * x);
          }
  
          return res;
      }
  
      static boolean prime(int n)
      {
          if (n <= 1)
              return false;
          if (n <= 3)
              return true;
          if (n % 2 == 0 || n % 3 == 0)
              return false;
          double sq=Math.sqrt(n);
  
          for (int i = 5; i <= sq; i = i + 6)
              if (n % i == 0 || n % (i + 2) == 0)
                  return false;
          return true;
      }
      static long[] sort(long a[]) {
          ArrayList<Long> arr = new ArrayList<>();
          for(long i : a) {
              arr.add(i);
          }
          Collections.sort(arr);
          for(int i = 0; i < arr.size(); i++) {
              a[i] = arr.get(i);
          }
          return a;
      }
  
      static int[] sort(int a[])
      {
          ArrayList<Integer> arr = new ArrayList<>();
          for(Integer i : a) {
              arr.add(i);
          }
          Collections.sort(arr);
          for(int i = 0; i < arr.size(); i++) {
              a[i] = arr.get(i);
          }
          return a;
      }
      static boolean prime(long n)
      {
          if (n <= 1)
              return false;
          if (n <= 3)
              return true;
          if (n % 2 == 0 || n % 3 == 0)
              return false;
          double sq=Math.sqrt(n);
  
          for (int i = 5; i <= sq; i = i + 6)
              if (n % i == 0 || n % (i + 2) == 0)
                  return false;
          return true;
      }
      //pair class
      private static class Pair implements Comparable<Pair> {
          int first, second;
          public Pair(int f, int s) {
              first = f;
              second = s;
          }
          @Override
          public int compareTo(Pair p) {
              if (first > p.first)
                  return 1;
              else if (first < p.first)
                  return -1;
              else {
                  if (second > p.second)
                      return 1;
                  else if (second < p.second)
                      return -1;
                  else
                      return 0;
              }
          }
  
      }
  }
  