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: import javax.lang.model.type.IntersectionType;
  import java.sql.Array;
  import java.util.*;
  import java.io.*;
  import java.util.concurrent.ScheduledExecutorService;
  import java.util.concurrent.atomic.AtomicReferenceArray;
  import java.util.spi.AbstractResourceBundleProvider;
  //Timus judge id- 323935JJ
  
  
  public class Main {
      static class Pair<U, V> {
          public final U first;
          public final V second;
  
          public Pair(U first, V second) {
              this.first = first;
              this.second = second;
          }
  
          public static <U, V> Pair<U, V> of(U a, V b) {
              return new Pair<>(a, b);
          }
  
          final int a = 2;
  
          @Override
          public int hashCode() {
              int hash = 5;
              hash = 17 * hash + this.a;
              return hash;
          }
  
          @Override
          public boolean equals(Object obj) {
              if (obj == null) {
                  return false;
              }
              if (getClass() != obj.getClass()) {
                  return false;
              }
              final Pair other = (Pair) obj;
              if (this.a != other.a) {
                  return false;
              }
              return true;
          }
      }
  
      //----------------------------------------------------------------------------------------------
      public static class Node implements Comparable<Node> {
          String s;
          int x;
  
          public Node(String str, int b) {
              this.s = str;
              this.x = b;
  
          }
  
          public int compareTo(Node o) {
              return this.x - o.x;
          }
      }
  
  
      public static int mod = (int) (1e9 + 7);
      static int ans = Integer.MAX_VALUE;
  
      public static void main(String hi[]) throws Exception {
          FastReader sc = new FastReader();
  
       int t =sc.nextInt();
       while(t-->0)
       {
           int n =sc.nextInt();
           int max=Integer.MIN_VALUE;
           int[] a = new int[n];
           for(int i=0;i<n;i++) {
               a[i] = sc.nextInt();
               max=Math.max(max,a[i]);
           }
           Stack<Integer> stack = new Stack<>();
           int[] b = new int[n];
           for(int i=n-1;i>=0;i--)
           {
               while(!stack.isEmpty()&&a[stack.peek()]<a[i])
                  b[stack.pop()]=i;
  
               stack.push(i);
           }
  
  
           while (!stack.isEmpty())
           {
               b[stack.pop()]=-1;
           }
          int ans=0,i=n-1;
  
           while(b[i]!=-1)
           {
               ans++;
               i=b[i];
           }
  
           System.out.println(ans);
  
  //        for(int i=0;i<n;i++)
  //            System.out.print(b[i]+" ");
  //         System.out.println();
  
  
          }
  
  
      }
  
  
      static int gcd(int a, int b)
      {
          if (a == 0)
              return b;
          return gcd(b % a, a);
      }
  
      // method to return LCM of two numbers
      static int lcm(int a, int b)
      {
          return (a / gcd(a, b)) * b;
      }
  
  
      static long gcdl(long a, long b)
      {
          if (a == 0)
              return b;
          return gcdl(b % a, a);
      }
  
      // method to return LCM of two numbers
      static long lcml(long a, long b)
      {
          return (a / gcdl(a, b)) * b;
      }
  
  
      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;
  
          }
      }
  }
  
  
  