#include <bits/stdc++.h>
using namespace std;
const int N=1e6+5,INF=0x3f3f3f3f; 
int n,tot;
char c[N];
struct P{
	int len;
	char c; 
}dat[N],tmp[N];
void solve(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>c[i];
	
	int tot1=0,tot2;
	for(int i=1;i<=n;i++){
		if(c[i]!=c[i-1]) dat[++tot1]={1,c[i]};
		else dat[tot1].len++;
	}
	
	while(tot1){
		tot2=0;
		if(dat[1].c=='L'||dat[tot1].c=='R') return cout<<"Alice\n",void();
		int mn=INF;
		for(int i=1;i<=tot1;i++) mn=min(mn,dat[i].len);
		for(int i=1;i<=tot1;i++){
			if(tot2&&dat[i].c==tmp[tot2].c) tmp[tot2].len+=dat[i].len-mn;
			else{
				if(dat[i].len>mn) tmp[++tot2]={dat[i].len-mn,dat[i].c};
			}
		}
		for(int i=1;i<=tot2;i++) dat[i]=tmp[i];tot1=tot2;
	}
	cout<<"Bob\n";
}
int main(){
	cin.tie(0)->sync_with_stdio(0);
	int T;cin>>T;
	while(T--) solve();
	return 0;
} 
/*
给定一个字符串，每次可以根据字符串方向裁剪，
双方博弈，
求最终胜者

直接看的话，O(n^2)的状态是容易设计出来的，复杂度可以容易做到O(n^3)

如果最左边是L，那么先手一定必胜
最右边是R同理，
那么，不是这两种情况的话，最左边一定是R,最右边一定是L,

可以发现，这两个东西不会对整体的结构产生任何其他的影响

对于任意的一个子结构，如果是这两种情况，也是可以快速判断的，
当然，总会有O(n^2)个对象无法快速判断

如果是全L/全R的情况，先手必胜，
如果是左边若干个R,右边若干个L,那么整体就是进行一个向中间缩减的过程，
那么这相当于一个两堆的nim游戏

整体可不可以这么抽象？
应该也是有什么量可以抽象的
如果在最左边存在连续一段的R，那么这其实是一个博弈焦点，
一旦脱离了这个状态，那么立马就可以成功，
所以是

先猜个结论吧(猜是左右边界的anti-nim)

易得有些地方是禁区，
也容易知道这些地方只要继续存在就仍然是禁区，

整体结构一定是R……L的形式，
谁第一个打破这个结构，谁就一定输（这种情况不可能一次清零），
于是我们就有了可行的选择个数，
可选择的R后面一定还是R,可选择的L前面一定还是L，
但是问题仍然在这里，
这个结构仍然是很难描摹的
有若干个点，每个对象每次会清空一类点……
这不是子问题吗？

可以递归求解？

而且感觉这个并不好卡？
这至少能过掉73pts吧？
先这样吧 

有更好的模拟方式，我们可以使用数据结构来维护这个过程 

先试试循环展开 

不行，只能用数据结构了，大概率是链表+堆
但是不太想写
先看下一题吧
--------
绝了 
*/