1
3
5 3 4
 6
5
5 3 4 4 5
3
1 1 1
5
4 4 3 4 4
5
5 5 4 3 2
3
1 1 2
5
5 4 3 5 5
 1
3
10 1 5

1
 1
-1
2
2
3
1
 1

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

public class c {
  static int[] arr;
  static int n;
  public static void main(String[] args) {
    FS in = new FS(System.in);
    PrintWriter out = new PrintWriter(System.out);

    int numT = in.nextInt();
    for(int tt=0; tt<numT; tt++) {
      n = in.nextInt();
      arr = new int[n];
      int max = 0;
      for(int i=0; i<n; i++) {
        arr[i] = in.nextInt();
        if(arr[i] > max) {
          max = arr[i];
        }
      }
      // Can eat neighbors
      boolean possible = false;
      int ans = -1;
      for(int i=0; i<n; i++) {
        if(arr[i] == max) {
          if(biggerThanNeighbors(i)) {
            ans = i+1;
            break;
          } 
        }
      }
      out.println(ans);
      out.flush();
    }
    out.flush();

  }

  static boolean biggerThanNeighbors(int ind) {
    if(ind == 0) return arr[ind] > arr[ind+1]; 
    if(ind == n-1) return arr[ind] > arr[ind-1]; 
    return (arr[ind] > arr[ind-1]) || (arr[ind] > arr[ind+1]);
  }

  static class FS{
    BufferedReader in;
    StringTokenizer token;
    public FS(InputStream stream) {
      in = new BufferedReader(new InputStreamReader(stream));
    }
    public String next() {
      if(token == null || !token.hasMoreElements()) {
        try {
          token = new StringTokenizer(in.readLine());
        } catch (Exception e) {} 
        return next();
      }
      return token.nextToken();
    }
    public int nextInt() {
      return Integer.parseInt(next());
    }
  }
}

/* 

6
5
5 3 4 4 5
3
1 1 1
5
4 4 3 4 4
5
5 5 4 3 2
3
1 1 2
5
5 4 3 5 5

3
-1
4
3
3
1

My answer:
1
-1
2
2
3
1




*/