description: You are given an array a of length n.
  
  Let's define the eversion operation. Let x = a_n. Then array a is partitioned into two parts: left and right. The left part contains the elements of a that are not greater than x (≤ x). The right part contains the elements of a that are strictly greater than x (> x). The order of elements in each part is kept the same as before the operation, i. e. the partition is stable. Then the array is replaced with the concatenation of the left and the right parts.
  
  For example, if the array a is [2, 4, 1, 5, 3], the eversion goes like this: [2, 4, 1, 5, 3] → [2, 1, 3], [4, 5] → [2, 1, 3, 4, 5].
  
  We start with the array a and perform eversions on this array. We can prove that after several eversions the array a stops changing. Output the minimum number k such that the array stops changing after k eversions.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 100). Description of the test cases follows.
  
  The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5).
  
  The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9).
  
  It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case print a single integer k — the number of eversions after which the array stops changing.
  
  Example
  
  Input
  
  
  3
  5
  2 4 1 5 3
  5
  5 3 2 4 1
  4
  1 1 1 1
  
  
  Output
  
  
  1
  2
  0
  
  Note
  
  Consider the fist example.
  
    * The first eversion: a = [1, 4, 2, 5, 3], x = 3. [2, 4, 1, 5, 3] → [2, 1, 3], [4, 5] → [2, 1, 3, 4, 5]. 
    * The second and following eversions: a = [2, 1, 3, 4, 5], x = 5. [2, 1, 3, 4, 5] → [2, 1, 3, 4, 5], [] → [2, 1, 3, 4, 5]. This eversion does not change the array, so the answer is 1. 
  
  
  
  Consider the second example. 
  
    * The first eversion: a = [5, 3, 2, 4, 1], x = 1. [5, 3, 2, 4, 1] → [1], [5, 3, 2, 4] → [1, 5, 3, 2, 4]. 
    * The second eversion: a = [1, 5, 3, 2, 4], x = 4. [1, 5, 3, 2, 4] → [1, 3, 2, 4], [5] → [1, 3, 2, 4, 5]. 
    * The third and following eversions: a = [1, 3, 2, 4, 5], x = 5. [1, 3, 2, 4, 5] → [1, 3, 2, 4, 5], [] → [1, 3, 2, 4, 5]. This eversion does not change the array, so the answer is 2. 
solution: //package codeforces.round759div2;
  
  import java.io.*;
  import java.util.*;
  
  import static java.lang.Math.*;
  
  //Think through the entire logic before jump into coding!
  //If you are out of ideas, take a guess! It is better than doing nothing!
  //Read both C and D, it is possible that D is easier than C for you!
  
  //Be aware of integer overflow!
  //If you find an answer and want to return immediately, don't forget to flush before return!
  
  public class B {
      static InputReader in;
      static PrintWriter out;
  
      public static void main(String[] args) {
          //initReaderPrinter(true);
          initReaderPrinter(false);
          solve(in.nextInt());
          //solve(1);        
      }
  
      static void solve(int testCnt) {
          for (int testNumber = 0; testNumber < testCnt; testNumber++) {
              int n = in.nextInt();
              int[] a = in.nextIntArrayPrimitive(n);
              int maxV = 0;
              for(int i = 0; i < n; i++) {
                  if(a[i] > maxV) {
                      maxV = a[i];
                  }
              }
              if(maxV == a[n - 1]) out.println(0);
              else {
                  int prev = a[n - 1];
                  int cnt = 1;
                  for(int i = n - 2; i >= 0; i--) {
                      if(a[i] > prev) {
                          prev = a[i];
                          cnt++;
                      }
                      if(a[i] == maxV) {
                          break;
                      }
                  }
                  out.println(cnt - 1);
              }
          }
          out.close();
      }
  
      static void initReaderPrinter(boolean test) {
          if (test) {
              try {
                  in = new InputReader(new FileInputStream("src/input.in"));
                  out = new PrintWriter(new FileOutputStream("src/output.out"));
              } catch (IOException e) {
                  e.printStackTrace();
              }
          } else {
              in = new InputReader(System.in);
              out = new PrintWriter(System.out);
          }
      }
  
      static class InputReader {
          BufferedReader br;
          StringTokenizer st;
  
          InputReader(InputStream stream) {
              try {
                  br = new BufferedReader(new InputStreamReader(stream), 32768);
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
  
          String next() {
              while (st == null || !st.hasMoreTokens()) {
                  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;
          }
  
          Integer[] nextIntArray(int n) {
              Integer[] a = new Integer[n];
              for (int i = 0; i < n; i++) a[i] = nextInt();
              return a;
          }
  
          int[] nextIntArrayPrimitive(int n) {
              int[] a = new int[n];
              for (int i = 0; i < n; i++) a[i] = nextInt();
              return a;
          }
  
          int[] nextIntArrayPrimitiveOneIndexed(int n) {
              int[] a = new int[n + 1];
              for (int i = 1; i <= n; i++) a[i] = nextInt();
              return a;
          }
  
          Long[] nextLongArray(int n) {
              Long[] a = new Long[n];
              for (int i = 0; i < n; i++) a[i] = nextLong();
              return a;
          }
  
          long[] nextLongArrayPrimitive(int n) {
              long[] a = new long[n];
              for (int i = 0; i < n; i++) a[i] = nextLong();
              return a;
          }
  
          long[] nextLongArrayPrimitiveOneIndexed(int n) {
              long[] a = new long[n + 1];
              for (int i = 1; i <= n; i++) a[i] = nextLong();
              return a;
          }
  
          String[] nextStringArray(int n) {
              String[] g = new String[n];
              for (int i = 0; i < n; i++) g[i] = next();
              return g;
          }
  
          List<Integer>[] readGraphOneIndexed(int n, int m) {
              List<Integer>[] adj = new List[n + 1];
              for (int i = 0; i <= n; i++) {
                  adj[i] = new ArrayList<>();
              }
              for (int i = 0; i < m; i++) {
                  int u = nextInt();
                  int v = nextInt();
                  adj[u].add(v);
                  adj[v].add(u);
              }
              return adj;
          }
  
          List<Integer>[] readGraphZeroIndexed(int n, int m) {
              List<Integer>[] adj = new List[n];
              for (int i = 0; i < n; i++) {
                  adj[i] = new ArrayList<>();
              }
              for (int i = 0; i < m; i++) {
                  int u = nextInt() - 1;
                  int v = nextInt() - 1;
                  adj[u].add(v);
                  adj[v].add(u);
              }
              return adj;
          }
  
          /*
              A more efficient way of building a graph using int[] instead of ArrayList to store each node's neighboring nodes.
              1-indexed.
           */
          int[][] buildGraph(int nodeCnt, int edgeCnt) {
              int[] end1 = new int[edgeCnt], end2 = new int[edgeCnt];
              int[] edgeCntForEachNode = new int[nodeCnt + 1], idxForEachNode = new int[nodeCnt + 1];
              for (int i = 0; i < edgeCnt; i++) {
                  int u = in.nextInt(), v = in.nextInt();
                  edgeCntForEachNode[u]++;
                  edgeCntForEachNode[v]++;
                  end1[i] = u;
                  end2[i] = v;
              }
              int[][] adj = new int[nodeCnt + 1][];
              for (int i = 1; i <= nodeCnt; i++) {
                  adj[i] = new int[edgeCntForEachNode[i]];
              }
              for (int i = 0; i < edgeCnt; i++) {
                  adj[end1[i]][idxForEachNode[end1[i]]] = end2[i];
                  idxForEachNode[end1[i]]++;
                  adj[end2[i]][idxForEachNode[end2[i]]] = end1[i];
                  idxForEachNode[end2[i]]++;
              }
              return adj;
          }
      }
  }