Polycarp has n friends, the i-th of his friends has a_i candies. Polycarp's friends do not like when they have different numbers of candies. In other words they want all a_i to be the same. To solve this, Polycarp performs the following set of actions exactly once: 

  * Polycarp chooses k (0 ≤ k ≤ n) arbitrary friends (let's say he chooses friends with indices i_1, i_2, …, i_k); 
  * Polycarp distributes their a_{i_1} + a_{i_2} + … + a_{i_k} candies among all n friends. During distribution for each of a_{i_1} + a_{i_2} + … + a_{i_k} candies he chooses new owner. That can be any of n friends. Note, that any candy can be given to the person, who has owned that candy before the distribution process. 



Note that the number k is not fixed in advance and can be arbitrary. Your task is to find the minimum value of k.

For example, if n=4 and a=[4, 5, 2, 5], then Polycarp could make the following distribution of the candies: 

  * Polycarp chooses k=2 friends with indices i=[2, 4] and distributes a_2 + a_4 = 10 candies to make a=[4, 4, 4, 4] (two candies go to person 3). 



Note that in this example Polycarp cannot choose k=1 friend so that he can redistribute candies so that in the end all a_i are equal.

For the data n and a, determine the minimum value k. With this value k, Polycarp should be able to select k friends and redistribute their candies so that everyone will end up with the same number of candies.

Input

The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.

The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).

The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^4).

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.

Output

For each test case output: 

  * the minimum value of k, such that Polycarp can choose exactly k friends so that he can redistribute the candies in the desired way; 
  * "-1" if no such value k exists. 

Example

Input


5
4
4 5 2 5
2
0 4
5
10 8 5 1 4
1
10000
7
1 1 1 1 1 1 1


Output


2
1
-1
0
0

import java.io.*;
import java.util.*;
import java.lang.*;

public class Main {


    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;
        }
    }

    private static int gcd(int a , int b ) {
        if(b == 0) {
            return a ;
        }else {
            return gcd(b,a%b);
        }
    }

    private static int[] readArr(int n ,FastReader sc) {
        int[] arr = new int[n];
        for(int i = 0 ; i < n ; i++) {
            arr[i] = sc.nextInt();
        }
        return arr;
    }

    private static long[] readLongArr(int n ,FastReader sc) {
        long[] arr = new long[n];
        for(int i = 0 ; i < n ; i++) {
            arr[i] = sc.nextLong();
        }
        return arr;
    }

    private static int getMax(int[] arr, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
        for(int x : arr) {
            pq.add(x);
        }
        for(int i = 0 ; i < k-1 ; i++) {
            pq.remove();
        }
        return pq.remove();

    }
    private static long getLongMax(long[] arr, int k) {
        PriorityQueue<Long> pq = new PriorityQueue<>(Comparator.reverseOrder());
        for(long x : arr) {
            pq.add(x);
        }
        for(int i = 0 ; i < k-1 ; i++) {
            pq.remove();
        }
        return pq.remove();
    }
    private static int getMin(int[] arr, int k) {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for(int x : arr) {
            pq.add(x);
        }
        for(int i = 0 ; i < k-1 ; i++) {
            pq.remove();
        }
        return pq.remove();
    }
    private static long getLongMin(long[] arr, int k) {
        PriorityQueue<Long> pq = new PriorityQueue<>();
        for(long x : arr) {
            pq.add(x);
        }
        for(int i = 0 ; i < k-1 ; i++) {
            pq.remove();
        }
        return pq.remove();
    }
    private static boolean[] sieve(int n ) {
        boolean[] notPrime = new boolean[n+1];

        notPrime[0] = true;
        notPrime[1] = true;

        for(int i = 2 ; i <= Math.sqrt(n); i++) {
            if(!notPrime[i]) {
                for(int j = i*i ; j <=n ; j += i) {
                    notPrime[j] = true;
                }
            }
        }
        return notPrime;

    }



    public static void main(String[] args) {
        var sc = new FastReader();
        int t = sc.nextInt();
        while(t-- > 0) {
            int n = sc.nextInt();
            int[] arr = readArr(n,sc);
            long sum = 0;
            for(int x : arr) {
                sum += x;
            }
            if(sum%n != 0) {
                System.out.println("-1");
            }else {
                int count = 0;
                for(int x : arr) {
                   if(x > (sum/n)) {
                       count++;
                   }
                }
                System.out.println(count);

            }


        }





    }
}


