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: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  import java.util.StringTokenizer;
  import java.io.*;
  import java.util.*;
  import java.text.DecimalFormat;
  import java.math.*;
  
  public class Main {
  
  static int  mod = 1000000007;
  /*****************code By Priyanshu *******************************************/ 
  
      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;
          }
      }
      // this > other return +ve
      // this < other return -ve
      // this == other return 0
       public static class Pair implements Comparable<Pair> {
        long st;
        long et;
  
        public Pair(long st, long et) {
           this.st = st;
           this.et = et;
        }
  
        public int compareTo(Pair other) {
           if (this.st != other.st) {
              return (int)(this.st - other.st);
           } else {
              return (int)(this.et - other.et);
           }
        }
     }
  
      static long fastPower(long a, long b, int n) {
              
              long res = 1;
              
              while ( b > 0) {
                  
                  if ( (b&1) != 0) {
                      res = (res * a % n) % n;
                  }
                  
                  a = (a % n * a % n) % n;
                  b =  b >> 1;
              }
              
              return res;
              
          }
  
       // function to find
      // the rightmost set bit
      static int PositionRightmostSetbit(int n)
      {
          // Position variable initialize
          // with 1 m variable is used to
          // check the set bit
          int position = 1;
          int m = 1;
   
          while ((n & m) == 0) {
   
              // left shift
              m = m << 1;
              position++;
          }
          return position;
      }
      
           // used for swapping ith and jth elements of array
        // public static void swap(int[] arr, int i, int j) {
        //   int temp = arr[i];
        //   arr[i] = arr[j];
        //   arr[j] = temp;
        // }
          public static void swap(long i, long j) {
          long temp = i;
          i = j;
          j = temp;
        }
  
  
      static boolean palindrome(String s) {
          return new StringBuilder(s).reverse().toString().equals(s);
      }
      
    static boolean isPerfectSquare(double x)
      {
              double sr = Math.sqrt(x);
              return ((sr * sr) == x);     
      }
  
  
   public static long gcd(long a, long b)
      {
        if (b == 0)
          return a;
        return gcd(b, a % b);
      }
      
     
  
     static int nod(long l) {
         if(l>=1000000000000000000l) return 19;
         if(l>=100000000000000000l) return 18;
         if(l>=10000000000000000l) return 17;
         if(l>=1000000000000000l) return 16;
         if(l>=100000000000000l) return 15;
         if(l>=10000000000000l) return 14;
         if(l>=1000000000000l) return 13;
         if(l>=100000000000l) return 12;
         if(l>=10000000000l) return 11;
         if(l>=1000000000) return 10;
         if(l>=100000000) return 9;
         if(l>=10000000) return 8;
         if(l>=1000000) return 7;
         if(l>=100000) return 6;
         if(l>=10000) return 5;
         if(l>=1000) return 4;
         if(l>=100) return 3;
         if(l>=10) return 2;
         return 1;
      }
        //Arrays.sort(a,(c,d) -> Integer.compare(c[0],d[0]));
  
      
      public static boolean areAllBitsSet(int n )
      {
          // all bits are not set
          if (n == 0)
              return false;
       
          // if true, then all bits are set
          if (((n + 1) & n) == 0)
              return true;
       
          // else all bits are not set
          return false;
      }
  
       public static long[] sort(long[] arr) {
          List<Long> temp = new ArrayList();
          for (long i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (long i : temp) arr[start++] = i;
          return arr;
      }
     
   
  
          public static int[] radixSort2(int[] a)
      {
          int n = a.length;
          int[] c0 = new int[0x101];
          int[] c1 = new int[0x101];
          int[] c2 = new int[0x101];
          int[] c3 = new int[0x101];
          for(int v : a) {
              c0[(v&0xff)+1]++;
              c1[(v>>>8&0xff)+1]++;
              c2[(v>>>16&0xff)+1]++;
              c3[(v>>>24^0x80)+1]++;
          }
          for(int i = 0;i < 0xff;i++) {
              c0[i+1] += c0[i];
              c1[i+1] += c1[i];
              c2[i+1] += c2[i];
              c3[i+1] += c3[i];
          }
          int[] t = new int[n];
          for(int v : a)t[c0[v&0xff]++] = v;
          for(int v : t)a[c1[v>>>8&0xff]++] = v;
          for(int v : a)t[c2[v>>>16&0xff]++] = v;
          for(int v : t)a[c3[v>>>24^0x80]++] = v;
          return a;
      } 
  
      public static void print( int arr[] ){
          Arrays.stream(arr).forEach(str -> System.out.print(str + " "));
      }
  
      static boolean isPowerOfTwo (int x)
      {
        /* First x in the below expression is 
          for the case when x is 0 */
          return x!=0 && ((x&(x-1)) == 0);
            
      }
  
     
  
    static class Help {
      int index;
      int val;
      int res ;
      //Constructor
      Help(int i, int v) {
        index = i;
        val = v;
        res = 0;
      }
    }
   
  
  
    public static void main(
          String[] args)
      {
          try {
              System.setIn(new FileInputStream("input.txt"));
              System.setOut(new PrintStream(new FileOutputStream("output.txt")));
          } catch (Exception e) {
              System.err.println("Error");
          }
           
         FastReader sc = new FastReader();
      
         int t = Integer.parseInt(sc.next());
        // int t = 1;
        
  
         // StringBuilder ans = new StringBuilder();
    //  ArrayList<Integer> a = new ArrayList<>();
      
     while(t-->0){
  
   
     int a[] = new int[7];
  
    for (int i= 0; i<7; i++) {
      a[i]  = sc.nextInt();
    }
    int x = 0,y = 0,z =0;
    boolean ans = false;
    for(int i = 0;i<5;i++){
      for(int j = i+1;j<6;j++){
          for(int k = j+1;k<7;k++){
            if(a[i] + a[j] + a[k] == a[6]){
              ans = true;
              x = a[i];
              y = a[j];
              z = a[k];
            }
             if(ans == true){
            break;
            }
          }
          if(ans == true){
            break;
          }
      }
       if(ans == true){
            break;
          }
    }
    System.out.println(x + " " + y + " " + z);
  
  
  
  
      }
    }
  }
  
  
  
  
  
  
  //code By Priyanshu 
  
  