#include <vector>
#include <queue>
#include <list>
#include <iostream>
#include <array>
#include <string>
#include <numeric>
#include <algorithm>
#include <cmath>
#include <cassert>

using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef pair<int, int> pii;
using ll = long long;
typedef pair<int, int> pii;
typedef vector<int> vi;

bool dfs(int a, int L, vector<vi>& g, vi& btoa, vi& A, vi& B) {
    if (A[a] != L) return 0;
    A[a] = -1;
    for (int b : g[a]) if (B[b] == L + 1) {
        B[b] = 0;
        if (btoa[b] == -1 || dfs(btoa[b], L + 1, g, btoa, A, B))
            return btoa[b] = a, 1;
    }
    return 0;
}

int hopcroftKarp(vector<vi>& g, vi& btoa) {
    int res = 0;
    vi A(g.size()), B(btoa.size()), cur, next;
    for (;;) {
        fill(all(A), 0);
        fill(all(B), 0);
        /// Find the starting nodes for BFS (i.e. layer 0).
        cur.clear();
        for (int a : btoa) if(a != -1) A[a] = -1;
        rep(a,0,sz(g)) if(A[a] == 0) cur.push_back(a);
        /// Find all layers using bfs.
        for (int lay = 1;; lay++) {
            bool islast = 0;
            next.clear();
            for (int a : cur) for (int b : g[a]) {
                if (btoa[b] == -1) {
                    B[b] = lay;
                    islast = 1;
                }
                else if (btoa[b] != a && !B[b]) {
                    B[b] = lay;
                    next.push_back(btoa[b]);
                }
            }
            if (islast) break;
            if (next.empty()) return res;
            for (int a : next) A[a] = lay;
            cur.swap(next);
        }
        /// Use DFS to scan for augmenting paths.
        rep(a,0,sz(g))
        res += dfs(a, 0, g, btoa, A, B);
    }
}

void solve()
{
    int n, c;
    string a, b;
    cin >> n >> c >> a >> b;
    int start = 0;
    //= is 0
    for (int i = 0; i < n; ++i)
        start += (1 << i) * (a[i] != b[i]);
    vector<vector<int>> adj((1 << n));
    vector<int> btoa((1 << n), -1);
    vector<bool> blocked(1 << n);
    while (c--)
    {
        string p;
        cin >> p;
        int index = 0;
        for (int i = 0; i < n; ++i)
            index += (1 << i) * (p[i] != '=');
        blocked[index] = true;
    }
    int cnt = __builtin_popcount(start);
    for (int i = 0; i < (1 << n); ++i)
    {
        if (__builtin_popcount(i) % 2 != cnt % 2 || blocked[i] || i == start)
            continue;
        for (int j = 0; j < n; ++j)
            if (!blocked[i ^ (1 << j)])
                adj[i].push_back(i ^ (1 << j));
    }
    //if sz1 == sz2 bob wins
    int sz1 = hopcroftKarp(adj, btoa);
    for (int j = 0; j < n; ++j)
        if (!blocked[start ^ (1 << j)])
            adj[start].push_back(start ^ (1 << j));
    btoa = vector<int>((1 << n), -1);
    int sz2 = hopcroftKarp(adj, btoa);
    if (sz1 == sz2)
        cout << "Bob\n";
    else
        cout << "Alice\n";
}

int main()
{
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}