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 sys
  read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
  import bisect,string,math,time,functools,random,fractions
  from heapq import heappush,heappop,heapify
  from collections import deque,defaultdict,Counter
  from itertools import permutations,combinations,groupby
  rep=range;R=range
  def I():return int(input())
  def LI():return [int(i) for i in input().split()]
  def LI_():return [int(i)-1 for i in input().split()]
  def S_():return input()
  def IS():return input().split()
  def LS():return [i for i in input().split()]
  def NI(n):return [int(input()) for i in range(n)]
  def NI_(n):return [int(input())-1 for i in range(n)]
  def NLI(n):return [[int(i) for i in input().split()] for i in range(n)]
  def NLI_(n):return [[int(i)-1 for i in input().split()] for i in range(n)]
  def StoLI():return [ord(i)-97 for i in input()]
  def ItoS(n):return chr(n+97)
  def LtoS(ls):return ''.join([chr(i+97) for i in ls])
  def RLI(n=8,a=1,b=10):return [random.randint(a,b)for i in range(n)]
  def RI(a=1,b=10):return random.randint(a,b)
  def INP():
      N=10**6
      n=random.randint(1,N)
      a=[random.randint(1,n) for i in range(n)]
      return n,a
  def Rtest(T):
      case,err=0,0
      for i in range(T):
          inp=INP()
          a1=naive(*inp)
          a2=solve(*inp)
          if a1!=a2:
              print(inp)
              print('naive',a1)
              print('solve',a2)
              err+=1
          case+=1
      print('Tested',case,'case with',err,'errors')
  def GI(V,E,ls=None,Directed=False,index=1):
      org_inp=[];g=[[] for i in range(V)]
      FromStdin=True if ls==None else False
      for i in range(E):
          if FromStdin:
              inp=LI()
              org_inp.append(inp)
          else:
              inp=ls[i]
          if len(inp)==2:a,b=inp;c=1
          else:a,b,c=inp
          if index==1:a-=1;b-=1
          aa=(a,c);bb=(b,c);g[a].append(bb)
          if not Directed:g[b].append(aa)
      return g,org_inp
  def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
      #h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
      mp=[boundary]*(w+2);found={}
      for i in R(h):
          s=input()
          for char in search:
              if char in s:
                  found[char]=((i+1)*(w+2)+s.index(char)+1)
                  mp_def[char]=mp_def[replacement_of_found]
          mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
      mp+=[boundary]*(w+2)
      return h+2,w+2,mp,found
  def TI(n):return GI(n,n-1)
  def accum(ls):
      rt=[0]
      for i in ls:rt+=[rt[-1]+i]
      return rt
  def bit_combination(n,base=2):
      rt=[]
      for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
      return rt
  def gcd(x,y):
      if y==0:return x
      if x%y==0:return y
      while x%y!=0:x,y=y,x%y
      return y
  def YN(x):print(['NO','YES'][x])
  def Yn(x):print(['No','Yes'][x])
  def show(*inp,end='\n'):
      if show_flg:print(*inp,end=end)
  
  mo=10**9+7
  #mo=998244353
  inf=1<<63
  FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('LRUD',FourNb))
  alp=[chr(ord('a')+i)for i in range(26)]
  #sys.setrecursionlimit(10**7)
  
  
  show_flg=False
  show_flg=True
  
  ans=0
  
  
  
  for _ in range(I()):
      ans=(-1,-1)
      n=I()
      s=input()
      l=s.find('ab')
      if l!=-1:
          ans=(l+1,l+2)
      l=s.find('ba')
      if l!=-1:
          ans=(l+1,l+2)
      print(*ans)
  
  