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.io.*;
        import java.util.*;
        import java.math.*;
        import java.lang.*;

        public class Main implements Runnable 
        {
            static class InputReader 
            {
                private InputStream stream;
                private byte[] buf = new byte[1024];
                private int curChar;
                private int numChars;
                private SpaceCharFilter filter;
                private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

                public InputReader(InputStream stream) 
                {
                    this.stream = stream;
                }
                
                public int read()
                {
                    if (numChars==-1) 
                        throw new InputMismatchException();
                    
                    if (curChar >= numChars) 
                    {
                        curChar = 0;
                        try
                        {
                            numChars = stream.read(buf);
                        }
                        catch (IOException e)
                        {
                            throw new InputMismatchException();
                        }
                        
                        if(numChars <= 0)               
                            return -1;
                    }
                    return buf[curChar++];
                }
            
                public String nextLine()
                {
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }    
                    return str;
                }
                public int nextInt() 
                {
                    int c = read();
                    
                    while(isSpaceChar(c)) 
                        c = read();
                
                    int sgn = 1;
                
                    if (c == '-') 
                    {
                        sgn = -1;
                        c = read();
                    }
                    
                    int res = 0;
                    do
                    {
                        if(c<'0'||c>'9') 
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c)); 
                
                    return res * sgn;
                }
                
                public long nextLong() 
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    long res = 0;
                    
                    do 
                    {
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }    
                    while (!isSpaceChar(c));
                        return res * sgn;
                }
                
                public double nextDouble() 
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    double res = 0;
                    while (!isSpaceChar(c) && c != '.') 
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    if (c == '.') 
                    {
                        c = read();
                        double m = 1;
                        while (!isSpaceChar(c))
                        {
                            if (c == 'e' || c == 'E')
                                return res * Math.pow(10, nextInt());
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            m /= 10;
                            res += (c - '0') * m;
                            c = read();
                        }
                    }
                    return res * sgn;
                }
            
                public String readString() 
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    StringBuilder res = new StringBuilder();
                    do 
                    {
                        res.appendCodePoint(c);
                        c = read();
                    } 
                    while (!isSpaceChar(c));
                    
                    return res.toString();
                }
            
                public boolean isSpaceChar(int c) 
                {
                    if (filter != null)
                        return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                }
            
                public String next()
                {
                    return readString();
                }
                
                public interface SpaceCharFilter
                {
                    public boolean isSpaceChar(int ch);
                }
            }
            public static void main(String args[]) throws Exception 
            {
                new Thread(null, new Main(),"Main",1<<27).start();
            }
            
            static class Pair{
                int f;
                int s;
                PrintWriter w;

                //int t;
                
                
                // Pair(int f,int s,int t){
                Pair(int f,int s, PrintWriter w){
                    this.f = f;
                    this.s = s;
                    this.w = w;
                    //this.t = t;
                    
                }
                
                public static Comparator<Pair> wc = new Comparator<Pair>(){
                    public int compare(Pair e1,Pair e2){
                    
                        //1 for swap 
                        if(Math.abs(e1.f)-Math.abs(e2.f)!=0){
                            //e1.w.println("**"+e1.f+" "+e2.f);
                            return (Math.abs(e1.f)-Math.abs(e2.f));
                        }
                        else{
                            //e1.w.println("##"+e1.f+" "+e2.f);
                            return (Math.abs(e1.s)-Math.abs(e2.s));
                        }

                        
                    }
                };	
            }

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


            ////recursive BFS
            public static int bfsr(int s,ArrayList<Integer>[] a,boolean[] b,int[] pre){
                b[s]=true;
                int p = 1;
                int n = pre.length -1;
                int t = a[s].size();
                int max = 1;
                for(int i=0;i<t;i++){
                    int x = a[s].get(i);
                    if(!b[x]){
                        //dist[x] = dist[s] + 1;
                        int xz =  (bfsr(x,a,b,pre));
                        p+=xz;
                        max = Math.max(xz,max);
                    }
                }
                //max = Math.max(max,(n-p));
                pre[s] = max;
                return p;
            }   

        //// iterative BFS
            public static int bfs(int s,ArrayList<Integer>[] a,int dist,boolean[] b,PrintWriter w){
                b[s]=true;
                int siz = 0;
                dist--;
                Queue<Integer> q = new LinkedList<>();
                q.add(s);
                while(q.size()!=0 && dist>0 ){
                    int i=q.poll();
                    Iterator<Integer> it = a[i].listIterator();
                    int z=0;
                    while(it.hasNext() && dist>0){
                        z=it.next();
                        if(!b[z]){
                            b[z]=true;
                            dist--;
                            //dist[z] = dist[i] + 1;
                            siz++;
                            q.add(z);
                        }
                    }   
                
                }
                return siz;
            }

            public static int lower(int key, Integer[] a){
                int l = 0;
                int r = a.length-1;
                int res = 0;

                while(l<=r){
                    int mid = (l+r)/2;

                    if(a[mid]<=key){
                        l = mid+1;
                        res = mid+1;
                    }
                    else{
                        r = mid -1;
                    }
                }

                return res;
            }

            

            

        //////////////////////////////////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////////////


            public void run()
            {
                InputReader sc = new InputReader(System.in);
                PrintWriter w = new PrintWriter(System.out);
                long defaultValue = 0;
                

                
                int tc = sc.nextInt();
                while(tc-->0){

                    int n = sc.nextInt();
                    int[] a = new int[n];
                    //LinkedList<Integer> b = new LinkedList<Integer>();
                    for(int i=0;i<n;i++){
                        a[i] = sc.nextInt();
                        //b.add(a[i]);
                    }
                    int l = -1;
                    int r = -1;
                    int p = -2;
                    int c = 0;
                    for(int i=0;i<n && c!=(n-1);i++){
                        if(p==-2){
                            if(i!=0){
                                if(a[i-1]<a[i]){
                                    a[i]++;
                                    a[i-1] = Integer.MAX_VALUE;
                                    p = i;
                                    if(l==-1)
                                    l = i-2;
                                    if(r==-1)
                                    r = i+1;

                                    c++;
                                }
                                
                            }
                            if(i!=n-1){
                                if(a[i+1]<a[i]){
                                    a[i]++;
                                    a[i+1] = Integer.MAX_VALUE;
                                    p = i;
                                    if(l==-1)
                                    l = i-1;
                                    if(r==-1)
                                    r = i+2;

                                    c++;
                                }
                                
                            }
                        }
                        else{
                            if(l>-1){
                                if(a[l]<a[p]){
                                    c++;
                                    l--;
                                }
                                else{
                                    p = l;
                                    c++;
                                    a[l]+=c;
                                    l--;
                                }
                            }
                            if(r<n){
                                if(a[r]<a[p]){
                                    c++;
                                    r++;
                                }
                                else{
                                    p = r;
                                    c++;
                                    a[r]+=c;
                                    r++;
                                }
                            }
                        }                            
                    }
                    w.println(p+1);
                    
                    
                    
                        





                    


                    
                    

                    
                 }
                w.flush();
                w.close();
            }
           
        
            

            
        }

