description: Vupsen and Pupsen were gifted an integer array. Since Vupsen doesn't like the number 0, he threw away all numbers equal to 0 from the array. As a result, he got an array a of length n.
  
  Pupsen, on the contrary, likes the number 0 and he got upset when he saw the array without zeroes. To cheer Pupsen up, Vupsen decided to come up with another array b of length n such that ∑_{i=1}^{n}a_i ⋅ b_i=0. Since Vupsen doesn't like number 0, the array b must not contain numbers equal to 0. Also, the numbers in that array must not be huge, so the sum of their absolute values cannot exceed 10^9. Please help Vupsen to find any such array b!
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2 ⋅ t lines contain the description of test cases. The description of each test case consists of two lines.
  
  The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5) — the length of the array.
  
  The second line contains n integers a_1, a_2, …, a_n (-10^4 ≤ a_i ≤ 10^4, a_i ≠ 0) — the elements of the array a.
  
  It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case print n integers b_1, b_2, …, b_n — elements of the array b (|b_1|+|b_2|+… +|b_n| ≤ 10^9, b_i ≠ 0, ∑_{i=1}^{n}a_i ⋅ b_i=0).
  
  It can be shown that the answer always exists.
  
  Example
  
  Input
  
  
  3
  2
  5 5
  5
  5 -2 10 -9 4
  7
  1 2 3 4 5 6 7
  
  
  Output
  
  
  1 -1
  -1 5 1 -1 -1
  -10 2 2 -3 5 -1 -1
  
  Note
  
  In the first test case, 5 ⋅ 1 + 5 ⋅ (-1)=5-5=0. You could also print 3 -3, for example, since 5 ⋅ 3 + 5 ⋅ (-3)=15-15=0
  
  In the second test case, 5 ⋅ (-1) + (-2) ⋅ 5 + 10 ⋅ 1 + (-9) ⋅ (-1) + 4 ⋅ (-1)=-5-10+10+9-4=0.
solution: import java.io.*;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.StringTokenizer;
  import java.util.List;
   import java.util.*;
    public class realfast implements Runnable 
    {
      private static final int INF = (int) 1e9;
      long in= 1000000007;
      long fac[]= new long[1000001];
      long inv[]=new long[1000001];
      public  void solve() throws IOException 
      {
  
          //int t = readInt();
  
          int t = readInt();
          for(int f =0;f<t;f++)
          {
            int n = readInt();
            int arr[]=new int[n];
            ArrayList<edge> e = new ArrayList<edge>();
            for(int i =0;i<n;i++)
            {
              arr[i]= readInt();
              e.add(new edge(i,arr[i]));
            }
            Collections.sort(e);
            int b[]=new int[n];
  
            if(n%2==0)
            {
              for(int i =0;i<n;i=i+2)
              {
                   if((arr[i]*arr[i+1])<0)
                   {
                        b[i]= Math.abs(arr[i+1]);
                        b[i+1]= Math.abs(arr[i]);
                   }
                   else
                   {
                      b[i]= - arr[i+1];
                        b[i+1]= arr[i];
                   }
              }
  
            }
            else
            {
                for(int i =n-1;i>=2;i=i-2)
                {
                    if(i==2)
                    {
                      set3(arr,e.get(2).u,e.get(1).u,e.get(0).u,b);
                    }
                    else
                    {
                      set(arr,e.get(i).u,e.get(i-1).u,b); 
                    }
                }
            }
  
            for(int i =0;i<n;i++)
              out.print(b[i]+" ");
  
            out.println();
  
  
          }
  
         
          
  
      }
      public void set(int arr[] , int i , int j , int brr[])
      {
          if(Math.abs(arr[i])==Math.abs(arr[j]))
          {
              if(arr[i]*arr[j]<0)
              {
                  brr[i]=1;
                  brr[j]=1;
              }
              else
              {
                  brr[i]=-1;
                  brr[j]=1;
              }
          }
          else
          {
              if(arr[i]*arr[j]<0)
              {
                  brr[i]=Math.abs(arr[j]);
                  brr[j]=Math.abs(arr[i]);
              }
              else
              {
                  brr[i]=-Math.abs(arr[j]);
                  brr[j]=Math.abs(arr[i]);  
              }
          }
  
      }
      public void set3(int arr[], int i , int j , int k, int brr[])
      {
          if((arr[i]+arr[j])==0)
          {
              if((arr[i]+arr[k])!=0)
              {
                   int temp=j;
                   j=k;
                   k=temp;
              }
              else
              {
                   int temp=i;
                   i=k;
                   k=temp;
  
              }
  
          }
  
          if((arr[i]+arr[j])*arr[k]<0)
          {
              brr[k]=Math.abs(arr[i]+arr[j]);
              brr[i]= Math.abs(arr[k]);
              brr[j]=Math.abs(arr[k]);
          }
          else
          {
               brr[k]=-Math.abs(arr[i]+arr[j]);
              brr[i]= Math.abs(arr[k]);
              brr[j]=Math.abs(arr[k]);
  
          }
  
  
  
      }
      
      
  
      
      public int value (int seg[], int left , int right ,int index, int l, int r)
      {
              
              if(left>right)
              {
                return -100000000;
              }
              if(right<l||left>r)
                  return -100000000;
              if(left>=l&&right<=r)
                  return seg[index];
              int mid = left+(right-left)/2;
              int val = value(seg,left,mid,2*index+1,l,r);
              int val2 = value(seg,mid+1,right,2*index+2,l,r);
              return Math.max(val,val2);
  
      }
     
      public int gcd(int a , int b )
      {
        if(a<b)
        {
          int t =a;
          a=b;
          b=t;
        }
        if(a%b==0)
          return b ;
        return gcd(b,a%b);
      }
      public long pow(long n , long p,long m)
      {
           if(p==0)
              return 1;
          long val = pow(n,p/2,m);;
          val= (val*val)%m;
          if(p%2==0)
              return val;
          else
              return (val*n)%m;
      }
      
      
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      public static void main(String[] args) {
          new Thread(null, new realfast(), "", 128 * (1L << 20)).start();
      }
   
      private static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
      private BufferedReader reader;
      private StringTokenizer tokenizer;
      private PrintWriter out;
   
      @Override
      public void run() {
          try {
              if (ONLINE_JUDGE || !new File("input.txt").exists()) {
                  reader = new BufferedReader(new InputStreamReader(System.in));
                  out = new PrintWriter(System.out);
              } else {
                  reader = new BufferedReader(new FileReader("input.txt"));
                  out = new PrintWriter("output.txt");
              }
              solve();
          } catch (IOException e) {
              throw new RuntimeException(e);
          } finally {
              try {
                  reader.close();
              } catch (IOException e) {
                  // nothing
              }
              out.close();
          }
      }
   
      private String readString() throws IOException {
          while (tokenizer == null || !tokenizer.hasMoreTokens()) {
              tokenizer = new StringTokenizer(reader.readLine());
          }
          return tokenizer.nextToken();
      }
   
      @SuppressWarnings("unused")
      private int readInt() throws IOException {
          return Integer.parseInt(readString());
      }
   
      @SuppressWarnings("unused")
      private long readLong() throws IOException {
          return Long.parseLong(readString());
      }
   
      @SuppressWarnings("unused")
      private double readDouble() throws IOException {
          return Double.parseDouble(readString());
      }
  }
  class edge implements Comparable<edge>{
      int u ;
      int v;
      
      edge(int u, int v)
      {
         this.u=u;
         this.v=v;
      }
      public int compareTo(edge e)
      {
          return Math.abs(this.v)-Math.abs(e.v);
      }
  }