#include <bits/stdc++.h>
using namespace std;

vector<int> solve(vector<int> P, vector<int> Q) {
  array<int, 4> deg = {};
  array<array<int, 4>, 4> adj = {};
  for (int i = 1; i < (int)P.size(); ++i) {
    deg[P[i - 1]] += 1, deg[P[i]] += 1;
    adj[P[i - 1]][P[i]] += 1;
    adj[P[i]][P[i - 1]] += 1;
  }
  for (int i = 1; i < (int)Q.size(); ++i) {
    deg[Q[i - 1]] -= 1, deg[Q[i]] -= 1;
    adj[Q[i - 1]][Q[i]] -= 1;
    adj[Q[i]][Q[i - 1]] -= 1;
  } 

  const auto check = [&] {
    for (int x : deg) {
      if (x < 0) return false;
    }
    for (int s = 0; s < 16; ++s) {
      int sum = 0;
      for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
          if ((s >> i & 1) != (s >> j & 1)) {
            sum += adj[i][j];
          }
        }
      }
      if (sum < 0) return false;
    }
    return true;
  };

  if (!check()) return {};

  bool found = true;
  while (Q.size() < P.size()) {
    for (int i = 0; i < 4; ++i) {
      for (int j = 0; j < 4; ++j) {
        if (found && adj[i][j] >= 0) continue;
        int done = (found ? (1 << i) | (1 << j) : 0);
        vector<int> path = {i};
        auto dfs = [&](auto&& dfs) -> bool {
          if (path.size() > 1) {
            path.push_back(j);
            deg[i] += 1, deg[j] += 1;
            adj[i][j] += 1, adj[j][i] += 1;
            for (int k = 1; k < (int)path.size(); ++k) {
              deg[path[k - 1]] -= 1, deg[path[k]] -= 1;
              adj[path[k - 1]][path[k]] -= 1;
              adj[path[k]][path[k - 1]] -= 1;
            }
            if (check()) {
              cerr << i << ' ' << j << " [ ";
              for (int x : path) cerr << x << " ";
              cerr << "]" << endl;
              for (int i = 0; i < 4; ++i) {
                for (int j = 0; j < 4; ++j) {
                  cerr << adj[i][j] << " ";
                }
                cerr << "[" << deg[i] << "]\n";
              }
              for (int k = 1; k < (int)Q.size(); ++k) {
                if (minmax(i, j) == minmax(Q[k - 1], Q[k])) {
                  path.pop_back();
                  path.erase(path.begin());
                  if (i == Q[k - 1]) ranges::reverse(path);
                  for (const int x : path) Q.insert(Q.begin() + k, x);
                  found = true;
                  return true;
                }
              }
            }
            deg[i] -= 1, deg[j] -= 1;
            adj[i][j] -= 1, adj[j][i] -= 1;
            for (int k = 1; k < (int)path.size(); ++k) {
              deg[path[k - 1]] += 1, deg[path[k]] += 1;
              adj[path[k - 1]][path[k]] += 1;
              adj[path[k]][path[k - 1]] += 1;
            }
            path.pop_back();
          }
          for (int k = 0; k < 4; ++k) {
            if (!(done >> k & 1)) {
              done |= 1 << k;
              path.push_back(k);
              if (dfs(dfs)) return true;
              done &= ~(1 << k);
              path.pop_back();
            }
          }
          return false;
        };
        dfs(dfs);
      }
    }
    found = false;
  }
  return Q;
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  int T;
  cin >> T;
  while (T--) {
    int N, M;
    cin >> N >> M;
    vector<int> P(N), Q(M);
    for (int i = 0; i < N; ++i) {
      char c;
      cin >> c;
      P[i] = c - 'A';
    }
    for (int i = 0; i < M; ++i) {
      char c;
      cin >> c;
      Q[i] = c - 'A';
    }
    bool ok = false;
    for (int k = 0; k < 2; ++k) {
      if (P.front() != Q.front()) {
        Q.insert(Q.begin(), P.front());
      }
      if (P.back() != Q.back()) {
        Q.insert(Q.end(), P.back());
      }
      auto ans = solve(P, Q);
      if (!ans.empty()) {
        ok = true;
        assert((int)ans.size() == N);
        for (int i = 0; i < N; ++i) {
          cout << (char)(ans[i] + 'A');
        }
        cout << '\n';
      }
      ranges::reverse(P);
    }
    if (!ok) {
      cout << "NO\n";
    }
  } 

  return 0;
}