In the game of Mastermind, there are two players — Alice and Bob. Alice has a secret code, which Bob tries to guess. Here, a code is defined as a sequence of n colors. There are exactly n+1 colors in the entire universe, numbered from 1 to n+1 inclusive.

When Bob guesses a code, Alice tells him some information about how good of a guess it is, in the form of two integers x and y.

The first integer x is the number of indices where Bob's guess correctly matches Alice's code. The second integer y is the size of the intersection of the two codes as multisets. That is, if Bob were to change the order of the colors in his guess, y is the maximum number of indices he could get correct.

For example, suppose n=5, Alice's code is [3,1,6,1,2], and Bob's guess is [3,1,1,2,5]. At indices 1 and 2 colors are equal, while in the other indices they are not equal. So x=2. And the two codes have the four colors 1,1,2,3 in common, so y=4.

<image> Solid lines denote a matched color for the same index. Dashed lines denote a matched color at a different index. x is the number of solid lines, and y is the total number of lines. 

You are given Bob's guess and two values x and y. Can you find one possibility of Alice's code so that the values of x and y are correct?

Input

The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.

The first line of each test case contains three integers n,x,y (1≤ n≤ 10^5, 0≤ x≤ y≤ n) — the length of the codes, and two values Alice responds with.

The second line of each test case contains n integers b_1,…,b_n (1≤ b_i≤ n+1) — Bob's guess, where b_i is the i-th color of the guess.

It is guaranteed that the sum of n across all test cases does not exceed 10^5.

Output

For each test case, on the first line, output "YES" if there is a solution, or "NO" if there is no possible secret code consistent with the described situation. You can print each character in any case (upper or lower).

If the answer is "YES", on the next line output n integers a_1,…,a_n (1≤ a_i≤ n+1) — Alice's secret code, where a_i is the i-th color of the code.

If there are multiple solutions, output any.

Example

Input


7
5 2 4
3 1 1 2 5
5 3 4
1 1 2 1 2
4 0 4
5 5 3 3
4 1 4
2 3 2 3
6 1 2
3 2 1 1 1 1
6 2 4
3 3 2 1 1 1
6 2 6
1 1 3 2 1 1


Output


YES
3 1 6 1 2
YES
3 1 1 1 2
YES
3 3 5 5
NO
YES
4 4 4 4 3 1
YES
3 1 3 1 7 7
YES
2 3 1 1 1 1

Note

The first test case is described in the statement.

In the second test case, x=3 because the colors are equal at indices 2,4,5. And y=4 because they share the colors 1,1,1,2.

In the third test case, x=0 because there is no index where the colors are the same. But y=4 because they share the colors 3,3,5,5.

In the fourth test case, it can be proved that no solution exists.
#include <bits/stdc++.h>
using namespace std;
template <class T = int>
using V = std::vector<T>;
template <class T = int>
using VV = std::vector<std::vector<T>>;
template <class T = int>
using VVV = std::vector<std::vector<std::vector<T>>>;
template <class T>
using pqup = std::priority_queue<T, std::vector<T>, std::greater<T>>;
using ll = long long;
using ld = long double;
using int128 = __int128_t;
using pii = std::pair<int, int>;
using pll = std::pair<long long, long long>;
template <class T, class U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
  for (T &i : v) is >> i;
  return is;
}
std::istream &operator>>(std::istream &is, __int128_t &a) {
  std::string s;
  is >> s;
  __int128_t ret = 0;
  for (int i = 0; i < s.length(); i++)
    if ('0' <= s[i] and s[i] <= '9') ret = 10 * ret + s[i] - '0';
  a = ret * (s[0] == '-' ? -1 : 1);
  return is;
}
namespace scanner {
void scan(int &a) { std::cin >> a; }
void scan(long long &a) { std::cin >> a; }
void scan(std::string &a) { std::cin >> a; }
void scan(char &a) { std::cin >> a; }
void scan(char a[]) { std::scanf("%s", a); }
void scan(double &a) { std::cin >> a; }
void scan(long double &a) { std::cin >> a; }
template <class T, class U>
void scan(std::pair<T, U> &p) {
  std::cin >> p;
}
template <class T>
void scan(std::vector<T> &a) {
  std::cin >> a;
}
void INPUT() {}
template <class Head, class... Tail>
void INPUT(Head &head, Tail &...tail) {
  scan(head);
  INPUT(tail...);
}
}  // namespace scanner
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
  os << p.first << " " << p.second;
  return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &a) {
  for (int i = 0; i < int(a.size()); ++i) {
    if (i) os << " ";
    os << a[i];
  }
  return os;
}
std::ostream &operator<<(std::ostream &dest, __int128_t &value) {
  std::ostream::sentry s(dest);
  if (s) {
    __uint128_t tmp = value < 0 ? -value : value;
    char buffer[128];
    char *d = std::end(buffer);
    do {
      --d;
      *d = "0123456789"[tmp % 10];
      tmp /= 10;
    } while (tmp != 0);
    if (value < 0) {
      --d;
      *d = '-';
    }
    int len = std::end(buffer) - d;
    if (dest.rdbuf()->sputn(d, len) != len) {
      dest.setstate(std::ios_base::badbit);
    }
  }
  return dest;
}
template <class T>
void print(const T a) {
  std::cout << a << '\n';
}
template <class Head, class... Tail>
void print(Head H, Tail... T) {
  std::cout << H << ' ';
  print(T...);
}
template <class T>
void printel(const T a) {
  std::cout << a << '\n';
}
template <class T>
void printel(const std::vector<T> &a) {
  for (const auto &v : a) std::cout << v << '\n';
}
template <class Head, class... Tail>
void printel(Head H, Tail... T) {
  std::cout << H << '\n';
  printel(T...);
}
void Yes(const bool b = true) { std::cout << (b ? "Yes\n" : "No\n"); }
void No() { std::cout << "No\n"; }
void YES(const bool b = true) { std::cout << (b ? "YES\n" : "NO\n"); }
void NO() { std::cout << "No\n"; }
void err(const bool b = true) {
  if (b) {
    std::cout << "-1\n", exit(0);
  }
}
namespace debugger {
template <class T>
void view(const std::vector<T> &a) {
  std::cerr << "{ ";
  for (const auto &v : a) {
    std::cerr << v << ", ";
  }
  std::cerr << "\b\b }";
}
template <class T>
void view(const std::vector<std::vector<T>> &a) {
  std::cerr << "{\n";
  for (const auto &v : a) {
    std::cerr << "\t";
    view(v);
    std::cerr << "\n";
  }
  std::cerr << "}";
}
template <class T, class U>
void view(const std::vector<std::pair<T, U>> &a) {
  std::cerr << "{\n";
  for (const auto &p : a)
    std::cerr << "\t(" << p.first << ", " << p.second << ")\n";
  std::cerr << "}";
}
template <class T, class U>
void view(const std::map<T, U> &m) {
  std::cerr << "{\n";
  for (const auto &p : m)
    std::cerr << "\t[" << p.first << "] : " << p.second << "\n";
  std::cerr << "}";
}
template <class T, class U>
void view(const std::pair<T, U> &p) {
  std::cerr << "(" << p.first << ", " << p.second << ")";
}
template <class T>
void view(const std::set<T> &s) {
  std::cerr << "{ ";
  for (auto &v : s) {
    view(v);
    std::cerr << ", ";
  }
  std::cerr << "\b\b }";
}
template <class T>
void view(const T &e) {
  std::cerr << e;
}
}  // namespace debugger
template <class T>
int lb(const std::vector<T> &a, const T x) {
  return std::distance((a).begin(),
                       std::lower_bound((a).begin(), (a).end(), (x)));
}
template <class T>
int ub(const std::vector<T> &a, const T x) {
  return std::distance((a).begin(),
                       std::upper_bound((a).begin(), (a).end(), (x)));
}
template <class T>
void UNIQUE(std::vector<T> &a) {
  std::sort(a.begin(), a.end());
  a.erase(std::unique(a.begin(), a.end()), a.end());
}
template <class T>
std::vector<T> press(std::vector<T> &a) {
  auto res = a;
  UNIQUE(res);
  for (auto &v : a) v = lb(res, v);
  return res;
}
template <class T>
void ADD(std::vector<T> &a, const T x) {
  for (auto &v : a) v += x;
}
template <class T>
void SUB(std::vector<T> &a, const T x = 1) {
  for (auto &v : a) v -= x;
}
template <class T>
void MUL(std::vector<T> &a, const T x) {
  for (auto &v : a) v *= x;
}
template <class T>
void DIV(std::vector<T> &a, const T x) {
  for (auto &v : a) v /= x;
}
template <class T, class U>
inline bool chmin(T &a, const U &b) {
  return a > b ? a = b, true : false;
}
template <class T, class U>
inline bool chmax(T &a, const U &b) {
  return a < b ? a = b, true : false;
}
template <class T>
T divup(T x, T y) {
  return (x + y - 1) / y;
}
template <class T>
T POW(T a, long long n) {
  T ret = 1;
  while (n) {
    if (n & 1) ret *= a;
    a *= a;
    n >>= 1;
  }
  return ret;
}
long long POW(long long a, long long n, const int mod) {
  long long ret = 1;
  while (n) {
    if (n & 1) (ret *= a) %= mod;
    (a *= a) %= mod;
    n >>= 1;
  }
  return ret;
}
struct fast_io {
  fast_io() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
  }
} fast_io_;
const int inf = 1e9;
const ll INF = 1e18;
using R = long double;
constexpr R EPS = 1E-11;
int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
int sgn(const R &a, const R &b) { return sgn(a - b); }
long long x10(const string &s, size_t n) {
  if (s.front() == '-') return -x10(s.substr(1), n);
  auto pos = s.find('.');
  if (pos == string::npos) return stoll(s + string(n, '0'));
  return stoll(s.substr(0, pos) + s.substr(pos + 1) +
               string(n + pos + 1 - s.size(), '0'));
}
long long ceildiv(long long a, long long b) {
  if (b < 0) a = -a, b = -b;
  if (a >= 0)
    return (a + b - 1) / b;
  else
    return a / b;
}
long long floordiv(long long a, long long b) {
  if (b < 0) a = -a, b = -b;
  if (a >= 0)
    return a / b;
  else
    return (a - b + 1) / b;
}
long long floorsqrt(long long x) {
  assert(x >= 0);
  long long ok = 0;
  long long ng = 1;
  while (ng * ng <= x) ng <<= 1;
  while (ng - ok > 1) {
    long long mid = (ng + ok) >> 1;
    if (mid * mid <= x)
      ok = mid;
    else
      ng = mid;
  }
  return ok;
}
inline int topbit(unsigned long long x) {
  return x ? 63 - __builtin_clzll(x) : -1;
}
inline int popcount(unsigned long long x) { return __builtin_popcountll(x); }
inline int parity(unsigned long long x) { return __builtin_parity(x); }
const int N = 100005;
int b[N], a[N];
vector<int> ind[N], hist[N];
bool mis[N];
void main_() {
  int n, x, y;
  scanner::INPUT(n, x, y);
  for (int i = 0; i <= n + 1; i++) {
    ind[i].clear();
    hist[i].clear();
    mis[i] = false;
    a[i] = 0;
  }
  for (int i = 1; i <= n; i++) {
    cin >> b[i];
    ind[b[i]].push_back(i);
  }
  for (int i = 1; i <= n + 1; i++) {
    hist[ind[i].size()].push_back(i);
  }
  int idx = n;
  for (int k = 1; k <= x; k++) {
    while (hist[idx].empty()) idx--;
    int col = hist[idx].back();
    a[ind[col].back()] = col;
    ind[col].pop_back();
    hist[idx].pop_back();
    hist[idx - 1].push_back(col);
  }
  while (idx > 0 && hist[idx].empty()) idx--;
  vector<int> ve;
  if (idx * 2 > (n - x) + (n - y)) {
    cout << "NO" << endl;
    return;
  }
  for (int i = 1; i <= idx; i++) {
    for (int col : hist[i]) {
      ve.insert(ve.end(), ind[col].begin(), ind[col].end());
    }
  }
  int mismatch = n - y;
  auto makemismatch = [&](int i) {
    a[i] = hist[0][0];
    mismatch--;
    mis[i] = true;
  };
  for (int i = 0; i < n - x; i++) {
    a[ve[i]] = b[ve[(i + (n - x) / 2) % (n - x)]];
    if (a[ve[i]] == b[ve[i]]) makemismatch(ve[i]);
  }
  for (int i = 0; mismatch > 0; i++) {
    if (!mis[ve[i]]) makemismatch(ve[i]);
  }
  cout << "YES" << endl;
  for (int i = 1; i <= n; i++) {
    cout << a[i] << " ";
  }
  cout << endl;
}
int main() {
  int t = 1;
  cin >> t;
  while (t--) main_();
  return 0;
}
