#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define FASTIO() \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);
using namespace std;
 
//<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>
//                                                            DEBUG AND TEMPLATE
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
 
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
 
 
 
 
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
 
// ordered set
// find_by_order, order_of_key
// order_of_key (k) : Number of items strictly smaller than k.
// find_by_order(k) : K-th element in a set (counting from zero)
using namespace __gnu_pbds;
template<class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update> ;
template<class T> using ordered_multiset = tree<T, null_type,less_equal<T>, rb_tree_tag,tree_order_statistics_node_update>;
template<class key, class value, class cmp = std::less<key>> using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
struct pair_hash {
    template <class T1, class T2>
    size_t operator()(const std::pair<T1, T2>& p) const {
        auto h1 = std::hash<T1>{}(p.first);
        auto h2 = std::hash<T2>{}(p.second);
        return h1 ^ (h2 << 1);
    }
};
//<----------------------------------------------------------------------------------------------------------------------------------------------------------------------------->
class DSU {
public:
    vector<int> Size, parent;
    void make(int n) {
        Size.resize(n , 1);  
        parent.resize(n);
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
    int get(int node) {
        if (node == parent[node])
            return node;
        return parent[node] = get(parent[node]);
    }
    void unite(int u, int v) {
        int ulp_u = get(u);
        int ulp_v = get(v);
        if (ulp_u == ulp_v) return;
        if (Size[ulp_u] < Size[ulp_v]) {
            parent[ulp_u] = ulp_v;
            Size[ulp_v] += Size[ulp_u]; 
        } else {
            parent[ulp_v] = ulp_u;
            Size[ulp_u] += Size[ulp_v];  
        }
    }
};
 
// cantor function always give a unique output for any 2 numbers.
int cantor(int a, int b){
    return ((a + b) * (a + b + 1)) / 2 + b;
}
void precision(int n) {
    cout << fixed << setprecision(n);
}
/*
 
static const int N = 1e6;
set<long long>prime;
void sieve(){
    bool p[N];
    memset(p, 1, sizeof p);
    for(int i = 2; i * i < N; ++i){
        if(p[i]){
            for(int j = i * i; j < N; j += i){
                p[j] = 0;
            }
        }
    }
    for(int i = 2; i < N; ++i){
        if(p[i]) prime.insert(i);
    }
}
*/
static const int MOD = 1000000007;
int add(int x, int y){
    return (((x) % MOD + (y) % MOD) % MOD + MOD) % MOD;
}
int mul(int x, int y){
    return ((x % MOD) * 1ll * (y % MOD)) % MOD;
}
double logab (int a, int b){
    return log(b) / log(a);
}
long long fast_pow(long long a, long long b) {
    long long result = 1;
    while (b > 0) {
        if (b & 1)
            result *= a;
        a *= a;
        b >>= 1;
    }
    return result;
}
//<------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>



void solve(){
    int n, a, y;
    cin >> n >> a >> y;
    int parity = 0;
    for(int i = 0; i < n; ++i){
    	int ele; cin >> ele;
    	parity += (ele & 1);
    }
    parity += (a & 1);
    parity &= 1;
    cout << parity << " " << (y % 2) << "\n";
    if(parity == (y & 1)){
    	cout << "ALICE" << "\n";
    }
    else{
    	cout << "BOB" << "\n";
    }
}
int main() {
    FASTIO();
    int t = 1; 
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}