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 java.io.*;
  import java.util.Arrays;
  import java.util.Locale;
  import java.util.StringTokenizer;
  
  public class B {
  
      private void solve() {
          int t = ri();
          while(t-- > 0) {
              int n = ri();
              int[] a = ria(n);
              int max = Integer.MIN_VALUE;
              int maxIndex = 0;
              for(int i = 0; i < n; i++) {
                  if(a[i] >= max) { max = a[i]; maxIndex = i;}
              }
              int count = 0;
              int maxWas = Integer.MIN_VALUE;
              for(int i = n - 1; i > maxIndex; i--) {
                  if(a[i] <= maxWas) continue; else maxWas = a[i];
                  count++;
              }
              out.println(count);
          }
      }
  
      //////////////////////////////////////////////////////////////////
  
      long sqrtLong(long x) {
          long root = (long) Math.sqrt(x);
          while (root * root > x) --root;
          while ((root + 1) * (root + 1) <= x) ++root;
          return root;
      }
  
      int gcd(int a, int b) {
          if (b == 0)
              return a;
          else
              return gcd(b, a % b);
      }
  
      int lcm(int a, int b) {
          return a / gcd(a, b) * b;
      }
  
      int phi(int n) {
          int result = n;
          for (int i = 2; i * i <= n; ++i)
              if (n % i == 0) {
                  while (n % i == 0)
                      n /= i;
                  result -= result / i;
              }
          if (n > 1)
              result -= result / n;
          return result;
      }
  
      int factmod(int n, int p) {
          int res = 1;
          while (n > 1) {
              res = (res * ((n / p) % 2 == 1 ? p - 1 : 1)) % p;
              for (int i = 2; i <= n % p; ++i)
                  res = (res * i) % p;
              n /= p;
          }
          return res % p;
      }
  
      int binpow(int a, int n) {
          int res = 1;
          while (n != 0) {
              if ((n & 1) != 0)
                  res *= a;
              a *= a;
              n >>= 1;
          }
          return res;
      }
  
      String solPyatnashki() {
          int a[] = new int[16];
          for (int i = 0; i < 16; ++i)
              a[i] = ri();
  
          int inv = 0;
          for (int i = 0; i < 16; ++i)
              if (a[i] != 0)
                  for (int j = 0; j < i; ++j)
                      if (a[j] > a[i])
                          ++inv;
          for (int i = 0; i < 16; ++i)
              if (a[i] == 0)
                  inv += 1 + i / 4;
  
  
          return ((inv & 1) != 0 ? "No Solution" : "Solution Exists");
      }
  
      private static int binarySearch(int[] sortedArray, int valueToFind, int low, int high) {
          int index = -1;
  
          while (low <= high) {
              int mid = (low + high) / 2;
              if (sortedArray[mid] < valueToFind) {
                  low = mid + 1;
              } else if (sortedArray[mid] > valueToFind) {
                  high = mid - 1;
              } else if (sortedArray[mid] == valueToFind) {
                  index = mid;
                  break;
              }
          }
          return index;
      }
  
      boolean isPrime(int number) {
          for (int i = 2; i * i <= number; i++) {
              if (number % i == 0) {
                  return false;
              }
          }
          return number > 1;
      }
  
      boolean[] primes(int border) {
          boolean[] isPrimes = new boolean[border + 1];
          Arrays.fill(isPrimes, true);
          isPrimes[0] = false;
          isPrimes[1] = false;
          for (int i = 2; i < border + 1; i++) {
              if (!isPrimes[i]) continue;
              for (int k = i * 2; k < border; k += i) {
                  isPrimes[k] = false;
              }
          }
          return isPrimes;
      }
  
      int[] sort(int[] arr) {
          Integer[] a = new Integer[arr.length];
          for (int i = 0; i < arr.length; i++) {
              a[i] = arr[i];
          }
          Arrays.sort(a);
          for (int i = 0; i < a.length; i++) {
              arr[i] = a[i];
          }
          return arr;
      }
  
      long[] sort(long[] arr) {
          Long[] a = new Long[arr.length];
          for (int i = 0; i < arr.length; i++) {
              a[i] = arr[i];
          }
          Arrays.sort(a);
          for (int i = 0; i < a.length; i++) {
              arr[i] = a[i];
          }
          return arr;
      }
  
      int max(int[] a) {
          int max = Integer.MIN_VALUE;
          for (int i = 0; i < a.length; i++) {
              if (a[i] > max) max = a[i];
          }
          return max;
      }
  
      //////////////////////////////////////////////////////////////////
  
      private boolean yesNo(boolean yes) {
          return yesNo(yes, "YES", "NO");
      }
  
      private boolean yesNo(boolean yes, String yesString, String noString) {
          out.println(yes ? yesString : noString);
          return yes;
      }
  
      //////////////////////////////////////////////////////////////////
  
      private long rl() {
          return Long.parseLong(rs());
      }
  
      private double rd() {
          return Double.parseDouble(rs());
      }
  
      private int[] ria(int n) {
          int[] a = new int[n];
          for (int i = 0; i < n; ++i) a[i] = ri();
          return a;
      }
  
      private int ri() {
          return Integer.parseInt(rs());
      }
  
      private String rs() {
          while (!tok.hasMoreTokens()) {
              String nextLine = readLine();
              if (null == nextLine) return null;
              tok = new StringTokenizer(nextLine);
          }
  
          return tok.nextToken();
      }
  
      private String readLine() {
          try {
              return in.readLine();
          } catch (IOException e) {
              throw new RuntimeException(e);
          }
      }
  
      long fastMod(String s1, long n2) {
          long num = 0;
          for (int i = 0; i < s1.length() - 1; i++) {
              num += Integer.parseInt(String.valueOf(s1.charAt(i)));
              num *= 10;
              if (num >= n2) {
                  num = num % n2;
              }
          }
          return (num + Integer.parseInt(String.valueOf(s1.charAt(s1.length() - 1)))) % n2;
      }
  
      //////////////////////////////////////////////////////////////////
  
      private BufferedReader in;
      private StringTokenizer tok;
      private PrintWriter out;
  
      private void initFileIO(String inputFileName, String outputFileName) throws FileNotFoundException {
          in = new BufferedReader(new FileReader(inputFileName));
          out = new PrintWriter(outputFileName);
      }
  
      private void initConsoleIO() throws IOException {
          in = new BufferedReader(new InputStreamReader(System.in));
          out = new PrintWriter(System.out);
      }
  
      private void initIO() throws IOException {
          Locale.setDefault(Locale.US);
  
          String fileName = "";
  
          if (!fileName.isEmpty()) {
              initFileIO(fileName + ".in", fileName + ".out");
          } else {
              if (new File("input.txt").exists()) {
                  initFileIO("input.txt", "output.txt");
              } else {
                  initConsoleIO();
              }
          }
  
          tok = new StringTokenizer("");
      }
  
      //////////////////////////////////////////////////////////////////
  
      private void run() {
          try {
              long timeStart = System.currentTimeMillis();
  
              initIO();
              solve();
              out.close();
  
              long timeEnd = System.currentTimeMillis();
              System.err.println("Time(ms) = " + (timeEnd - timeStart));
          } catch (Exception e) {
              e.printStackTrace();
              throw new RuntimeException(e);
          }
      }
  
      public static void main(String[] args) {
          new B().run();
      }
  
      ///////////////////////////////////////////////////////////////////
  }
  