#include <bits/stdc++.h>
using namespace std;
namespace GR1 {
vector<int> solve(int N, int num_exact_matches, int num_common,
                  const vector<int>& B) {
  vector<queue<int> > pos(N + 2);
  for (int i = 0, _n = (N); i < _n; ++i) {
    int b = B[i];
    pos[b].push(i);
  }
  int missing = 0;
  set<pair<int, int>, greater<pair<int, int> > > S;
  for (int v = (1), _b = (N + 1); v <= _b; ++v)
    if (!pos[v].empty())
      S.emplace(int((pos[v]).size()), v);
    else
      missing = v;
  assert(missing > 0);
  vector<int> res(N);
  vector<bool> exact(N);
  for (int t = 0, _n = (num_exact_matches); t < _n; ++t) {
    auto it = S.begin();
    int v = it->second;
    S.erase(it);
    queue<int>& q = pos[v];
    int i = q.front();
    q.pop();
    res[i] = v;
    exact[i] = true;
    if (!q.empty()) S.emplace(int((q).size()), v);
  }
  int num_mismatches = N - num_common;
  int max_freq = S.begin()->first;
  if (max_freq * 2 > N - num_exact_matches + num_mismatches) return {};
  vector<int> block;
  for (auto it : S) {
    int v = it.second;
    while (!pos[v].empty()) {
      int j = pos[v].front();
      pos[v].pop();
      block.push_back(j);
    }
  }
  for (int t = 0, _n = ((N - num_exact_matches) / 2); t < _n; ++t)
    block.push_back(block[t]);
  for (int k = 0, _n = (N - num_exact_matches); k < _n; ++k) {
    int i = block[k];
    int j = block[k + (N - num_exact_matches) / 2];
    res[i] = B[j];
  };
  ;
  for (int i = 0, _n = (N); i < _n; ++i) {
    if (exact[i]) continue;
    if (res[i] == B[i]) {
      assert(num_mismatches > 0);
      --num_mismatches;
      res[i] = missing;
    }
  };
  ;
  for (int i = 0; i < N && num_mismatches > 0; ++i) {
    if (exact[i] || res[i] == missing) continue;
    --num_mismatches;
    res[i] = missing;
  }
  assert(num_mismatches == 0);
  return res;
}
}  // namespace GR1
namespace GR2 {
vector<int> solve(int N, int num_exact_matches, int num_common,
                  const vector<int>& B) {
  vector<queue<int> > pos(N + 2);
  for (int i = 0, _n = (N); i < _n; ++i) {
    int b = B[i];
    pos[b].push(i);
  }
  int missing = 0;
  set<pair<int, int>, greater<pair<int, int> > > S;
  for (int v = (1), _b = (N + 1); v <= _b; ++v)
    if (!pos[v].empty())
      S.emplace(int((pos[v]).size()), v);
    else
      missing = v;
  assert(missing > 0);
  vector<int> res(N);
  for (int t = 0, _n = (num_exact_matches); t < _n; ++t) {
    auto it = S.begin();
    int v = it->second;
    S.erase(it);
    queue<int>& q = pos[v];
    int i = q.front();
    q.pop();
    res[i] = v;
    if (!q.empty()) S.emplace(int((q).size()), v);
  }
  int num_mismatches = N - num_common;
  num_common -= num_exact_matches;
  while (num_common > 0) {
    assert(!S.empty());
    auto max_it = S.begin();
    int v = max_it->second;
    S.erase(max_it);
    assert(!pos[v].empty());
    int i = pos[v].front();
    pos[v].pop();
    if (B[i] == v) {
      if (int((S).size()) > 0) {
        auto max2_it = S.begin();
        int w = max2_it->second;
        S.erase(max2_it);
        assert(!pos[w].empty());
        int j = pos[w].front();
        pos[w].pop();
        if (!pos[w].empty()) S.emplace(int((pos[w]).size()), w);
        res[i] = w;
        --num_common;
        if (num_common > 0) {
          res[j] = v;
          --num_common;
        }
      } else if (num_mismatches > 0) {
        res[i] = missing;
        --num_mismatches;
      } else
        return {};
    } else {
      res[i] = v;
      --num_common;
    }
    if (!pos[v].empty()) S.emplace(int((pos[v]).size()), v);
  }
  for (int i = 0, _n = (N); i < _n; ++i) {
    if (res[i] == 0) {
      assert(num_mismatches > 0);
      --num_mismatches;
      res[i] = missing;
    }
  }
  return res;
}
}  // namespace GR2
int main(int argc, char* argv[]) {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int TC;
  cin >> TC;
  for (int tc = (1), _b = (TC); tc <= _b; ++tc) {
    int N, x, y;
    cin >> N >> x >> y;
    vector<int> B(N);
    for (int i = 0, _n = (N); i < _n; ++i) cin >> B[i];
    vector<int> res = GR1::solve(N, x, y, B);
    if (res.empty())
      cout << "NO\n";
    else {
      cout << "YES\n";
      for (int a : res) cout << a << ' ';
      cout << '\n';
    }
  }
  return 0;
}
