description: You are given a string s, consisting of n letters, each letter is either 'a' or 'b'. The letters in the string are numbered from 1 to n.
  
  s[l; r] is a continuous substring of letters from index l to r of the string inclusive. 
  
  A string is called balanced if the number of letters 'a' in it is equal to the number of letters 'b'. For example, strings "baba" and "aabbab" are balanced and strings "aaab" and "b" are not.
  
  Find any non-empty balanced substring s[l; r] of string s. Print its l and r (1 ≤ l ≤ r ≤ n). If there is no such substring, then print -1 -1.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
  
  Then the descriptions of t testcases follow.
  
  The first line of the testcase contains a single integer n (1 ≤ n ≤ 50) — the length of the string.
  
  The second line of the testcase contains a string s, consisting of n letters, each letter is either 'a' or 'b'.
  
  Output
  
  For each testcase print two integers. If there exists a non-empty balanced substring s[l; r], then print l r (1 ≤ l ≤ r ≤ n). Otherwise, print -1 -1.
  
  Example
  
  Input
  
  
  4
  1
  a
  6
  abbaba
  6
  abbaba
  9
  babbabbaa
  
  
  Output
  
  
  -1 -1
  1 6
  3 6
  2 5
  
  Note
  
  In the first testcase there are no non-empty balanced subtrings.
  
  In the second and third testcases there are multiple balanced substrings, including the entire string "abbaba" and substring "baba".
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.Scanner;
  import java.util.StringTokenizer;
  import java.io.*;
  import java.util.*;
  import java.text.DecimalFormat;
  import java.math.*;
  
  public class Main {
  
  static int  mod = 1000000007;
  /*****************code By Priyanshu *******************************************/ 
  
      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;
          }
      }
      // this > other return +ve
      // this < other return -ve
      // this == other return 0
       public static class Pair implements Comparable<Pair> {
        long st;
        long et;
  
        public Pair(long st, long et) {
           this.st = st;
           this.et = et;
        }
  
        public int compareTo(Pair other) {
           if (this.st != other.st) {
              return (int)(this.st - other.st);
           } else {
              return (int)(this.et - other.et);
           }
        }
     }
  
      static long fastPower(long a, long b, int n) {
              
              long res = 1;
              
              while ( b > 0) {
                  
                  if ( (b&1) != 0) {
                      res = (res * a % n) % n;
                  }
                  
                  a = (a % n * a % n) % n;
                  b =  b >> 1;
              }
              
              return res;
              
          }
  
       // function to find
      // the rightmost set bit
      static int PositionRightmostSetbit(int n)
      {
          // Position variable initialize
          // with 1 m variable is used to
          // check the set bit
          int position = 1;
          int m = 1;
   
          while ((n & m) == 0) {
   
              // left shift
              m = m << 1;
              position++;
          }
          return position;
      }
      
           // used for swapping ith and jth elements of array
        // public static void swap(int[] arr, int i, int j) {
        //   int temp = arr[i];
        //   arr[i] = arr[j];
        //   arr[j] = temp;
        // }
          public static void swap(long i, long j) {
          long temp = i;
          i = j;
          j = temp;
        }
  
  
      static boolean palindrome(String s) {
          return new StringBuilder(s).reverse().toString().equals(s);
      }
      
    static boolean isPerfectSquare(double x)
      {
              double sr = Math.sqrt(x);
              return ((sr * sr) == x);     
      }
  
  
   public static long gcd(long a, long b)
      {
        if (b == 0)
          return a;
        return gcd(b, a % b);
      }
      
     
  
     static int nod(long l) {
         if(l>=1000000000000000000l) return 19;
         if(l>=100000000000000000l) return 18;
         if(l>=10000000000000000l) return 17;
         if(l>=1000000000000000l) return 16;
         if(l>=100000000000000l) return 15;
         if(l>=10000000000000l) return 14;
         if(l>=1000000000000l) return 13;
         if(l>=100000000000l) return 12;
         if(l>=10000000000l) return 11;
         if(l>=1000000000) return 10;
         if(l>=100000000) return 9;
         if(l>=10000000) return 8;
         if(l>=1000000) return 7;
         if(l>=100000) return 6;
         if(l>=10000) return 5;
         if(l>=1000) return 4;
         if(l>=100) return 3;
         if(l>=10) return 2;
         return 1;
      }
        //Arrays.sort(a,(c,d) -> Integer.compare(c[0],d[0]));
  
      
      public static boolean areAllBitsSet(int n )
      {
          // all bits are not set
          if (n == 0)
              return false;
       
          // if true, then all bits are set
          if (((n + 1) & n) == 0)
              return true;
       
          // else all bits are not set
          return false;
      }
  
       public static long[] sort(long[] arr) {
          List<Long> temp = new ArrayList();
          for (long i : arr) temp.add(i);
          Collections.sort(temp);
          int start = 0;
          for (long i : temp) arr[start++] = i;
          return arr;
      }
     
   
  
          public static int[] radixSort2(int[] a)
      {
          int n = a.length;
          int[] c0 = new int[0x101];
          int[] c1 = new int[0x101];
          int[] c2 = new int[0x101];
          int[] c3 = new int[0x101];
          for(int v : a) {
              c0[(v&0xff)+1]++;
              c1[(v>>>8&0xff)+1]++;
              c2[(v>>>16&0xff)+1]++;
              c3[(v>>>24^0x80)+1]++;
          }
          for(int i = 0;i < 0xff;i++) {
              c0[i+1] += c0[i];
              c1[i+1] += c1[i];
              c2[i+1] += c2[i];
              c3[i+1] += c3[i];
          }
          int[] t = new int[n];
          for(int v : a)t[c0[v&0xff]++] = v;
          for(int v : t)a[c1[v>>>8&0xff]++] = v;
          for(int v : a)t[c2[v>>>16&0xff]++] = v;
          for(int v : t)a[c3[v>>>24^0x80]++] = v;
          return a;
      } 
  
      public static void print( int arr[] ){
          Arrays.stream(arr).forEach(str -> System.out.print(str + " "));
      }
  
  public void solve(int a , int b){
  
  
  }
  
  
  
    public static void main(
          String[] args)
      {
          try {
              System.setIn(new FileInputStream("input.txt"));
              System.setOut(new PrintStream(new FileOutputStream("output.txt")));
          } catch (Exception e) {
              System.err.println("Error");
          }
           
         FastReader sc = new FastReader();
          int t = Integer.parseInt(sc.next());
        // int t = 1;
         // StringBuilder ans = new StringBuilder();
    //  ArrayList<Integer> a = new ArrayList<>();
     
     while(t-->0){
     
  
      int n = sc.nextInt();
  
    char s[] = sc.next().toCharArray();
     boolean ans  = false;
  
     for (int i = 1;i<n ;i++) {
       
       if((s[i-1] == 'a') && (s[i] == 'b')){
        System.out.println(i + " " + (i+1));
        ans = true;
        break;
       }
       else if((s[i-1] == 'b') && (s[i] == 'a')){
        System.out.println(i + " "  + (i+1));
        ans = true;
        break;
       }
  
     }
  
     if (ans == true) {
       continue;
     }else{
      System.out.println("-1 -1");
     }
  
  
  
      
  
  
  
  
  
   
  
      }
    }
  }
  
  
  
  
  
  
  //code By Priyanshu 
  
  