#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using ulli = unsigned long long int;
using ld = long double;
template <class T>
using heap = priority_queue<T, vector<T>, greater<T>>;
template <class A, class B>
using hmap = unordered_map<A, B>;
template <class T>
using hset = unordered_set<T>;
template <class T>
struct Matrix : public vector<vector<T>> {
  Matrix(int dim1 = 0, int dim2 = 0, T v = T())
      : vector<vector<T>>(dim1, vector<T>(dim2, v)) {}
};
namespace std {
template <class T>
struct hash<vector<T>> {
  size_t operator()(vector<T> const& v) const {
    size_t c = v.size();
    for (auto& e : v) {
      c ^= (size_t)e + 0x9e3779b9 + (c << 6) + (c >> 2);
    }
    return c;
  }
};
}  // namespace std
const int INF = 1e9;
const lli LLINF = 4 * 1e18;
const lli MOD = 1e9 + 7;
const ld PI = 3.141592653589793;
template <typename T>
inline T sqr(T val) {
  return val * val;
}
template <class T>
inline void minset(T& a, T b) {
  if (b < a) a = b;
}
template <class T>
inline void maxset(T& a, T b) {
  if (a < b) a = b;
}
template <typename T>
T modul(T val, T __modulo = MOD) {
  return (val % __modulo + __modulo) % __modulo;
}
template <class V>
typename V::value_type sum(const V& els) {
  auto s = 0;
  for (const auto& e : els) {
    s += e;
  };
  return s;
}
template <class V>
typename V::value_type min(const V& els) {
  return *min_element(els.begin(), els.end());
}
template <class V>
typename V::value_type max(const V& els) {
  return *max_element(els.begin(), els.end());
}
struct __RM_UNUSED {
  __RM_UNUSED() {
    (void)INF;
    (void)LLINF;
    (void)PI;
  }
};
string tostr(char c) { return string(1, c); }
template <typename T>
string tostr(T c) {
  return to_string(c);
}
int toint(char c) { return c - '0'; }
int toint(string s, int base = 10) { return stoi(s, 0, base); }
template <class T>
inline T readget() {
  T v;
  cin >> v;
  return v;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
  for (T& e : v) {
    is >> e;
  }
  return is;
}
bool doTask() {
  int n, x, y;
  cin >> n >> x >> y;
  int nbSuffled = y - x;
  int nbGrey = n - y;
  vector<int> seq(n);
  cin >> seq;
  vector<pair<int, bool>> toShuffle;
  vector<int> aligned;
  vector<vector<int>> ofColor(n + 2);
  for (int i = 0; i < n; i++) {
    ofColor[seq[i]].push_back(i);
  }
  vector<int> colorOrder(n + 2);
  int grey = -1;
  for (int color = 1; color < n + 2; color++) {
    if (ofColor[color].empty()) {
      grey = color;
    }
    colorOrder[color] = color;
  }
  sort(colorOrder.begin(), colorOrder.end(), [&](const int& a, const int& b) {
    return ofColor[a].size() < ofColor[b].size();
  });
  int colTakeMax = 0, takeMax = 0;
  for (auto& color : colorOrder) {
    int nbTake = min(nbSuffled, min((int)ofColor[color].size(), (n - x) / 2));
    nbSuffled -= nbTake;
    for (int i = 0; i < nbTake; i++) {
      toShuffle.push_back({ofColor[color].back(), true});
      ofColor[color].pop_back();
    }
    if (nbTake > takeMax) {
      takeMax = nbTake;
      colTakeMax = color;
    }
    int nbTake2 =
        min(nbGrey, min((int)ofColor[color].size(), n - x - 2 * nbTake));
    nbGrey -= nbTake2;
    for (int i = 0; i < nbTake2; i++) {
      toShuffle.push_back({ofColor[color].back(), false});
      ofColor[color].pop_back();
    }
  }
  if (nbSuffled || nbGrey) {
    return false;
  }
  for (int color = 1; color < n + 2; color++) {
    for (auto& e : ofColor[color]) {
      aligned.push_back(e);
    }
  }
  if (aligned.size() != x) {
    return false;
  }
  vector<int> newCols(n, -1);
  for (auto& e : aligned) {
    newCols[e] = seq[e];
  }
  deque<int> colsToTake;
  for (auto& p : toShuffle) {
    if (seq[p.first] == colTakeMax) {
      colsToTake.push_back(p.first);
    }
  }
  for (auto& p : toShuffle) {
    if (seq[p.first] != colTakeMax) {
      colsToTake.push_back(p.first);
      if (p.second) {
        newCols[colsToTake.front()] = seq[p.first];
        colsToTake.pop_front();
      }
    }
  }
  for (auto& p : toShuffle) {
    if (seq[p.first] == colTakeMax && p.second) {
      newCols[colsToTake.back()] = seq[p.first];
      colsToTake.pop_back();
    }
  }
  for (auto& p : toShuffle) {
    if (!p.second) {
      newCols[colsToTake.front()] = grey;
      colsToTake.pop_front();
    }
  }
  cout << "YES\n";
  for (auto& e : newCols) {
    cout << e << " ";
  }
  cout << "\n";
  return true;
}
int main() {
  ios::sync_with_stdio(false);
  cout.tie(0);
  cin.tie(0);
  cout << fixed << setprecision(10);
  int nbTests;
  cin >> nbTests;
  for (int iTest = 0; iTest < nbTests; iTest++) {
    if (!doTask()) {
      cout << "NO\n";
    }
  }
}
