package cote;

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) throws Exception {
        // System.setIn(new FileInputStream("input.txt"));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String line = br.readLine();
        if(line == null) return;
        int testCase = Integer.parseInt(line);

        for (int tc = 0; tc < testCase; tc++) {
            int recordCount = Integer.parseInt(br.readLine());

            List<Integer>[] teamsReal = new List[1001];
          
            int[][] records = new int[1001][2]; 
            List<Integer> rivals = new ArrayList<>();
            boolean[] isValid = new boolean[1001];
            
          
            int[] teamCounts = new int[1001];

            for (int i = 0; i < 1001; i++) {
                teamsReal[i] = new ArrayList<>();
                records[i] = new int[2];
            }

            List<Integer> inputs = Arrays.stream(br.readLine().split(" "))
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());

        
            for (int teamId : inputs) {
                teamCounts[teamId]++;
            }
            
           
            for(int i=1; i<1001; i++) {
                if(teamCounts[i] == 6) isValid[i] = true;
            }

       
            int cursor = 1; 
            for (int idx = 0; idx < recordCount; idx++) {
                int teamId = inputs.get(idx);

                if (isValid[teamId]) {
                    teamsReal[teamId].add(cursor);

                    int size = teamsReal[teamId].size();

              
                    if (size <= 4) {
                        records[teamId][0] += cursor;
                    }

                
                    if (size == 5) {
                        records[teamId][1] = cursor;
                    }

                   
                    if (size == 6) {
                        rivals.add(teamId);
                    }
                    
                    cursor++; 
                }
            }

        
            Collections.sort(rivals, (o1, o2) -> {
             
                if (records[o1][0] != records[o2][0]) {
                    return records[o1][0] - records[o2][0]; 
                } else {
                    return records[o1][1] - records[o2][1]; 
                }
            });

            System.out.println(rivals.get(0));

        } // tc for
    }
}