Problem: You are given three positive (i.e. strictly greater than zero) integers x, y and z.

Your task is to find positive integers a, b and c such that x = max(a, b), y = max(a, c) and z = max(b, c), or determine that it is impossible to find such a, b and c.

You have to answer t independent test cases. Print required a, b and c in any (arbitrary) order.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.

The only line of the test case contains three integers x, y, and z (1 ≤ x, y, z ≤ 10^9).

Output

For each test case, print the answer:

  * "NO" in the only line of the output if a solution doesn't exist; 
  * or "YES" in the first line and any valid triple of positive integers a, b and c (1 ≤ a, b, c ≤ 10^9) in the second line. You can print a, b and c in any order. 

Example

Input


5
3 2 3
100 100 100
50 49 49
10 30 20
1 1000000000 1000000000


Output


YES
3 2 1
YES
100 100 100
NO
NO
YES
1 1 1000000000

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using ull = unsigned long long;
using int2 = pair<ll, ll>;
using int3 = tuple<ll, ll, ll>;
template <typename A>
string to_string(const A &v);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(const tuple<A, B, C> &p) {
  return "(" + to_string(std::get<0>(p)) + ", " + to_string(std::get<1>(p)) +
         ", " + to_string(std::get<2>(p)) + ")";
}
template <typename A>
string to_string(const A &v) {
  bool first = true;
  string res = "{";
  for (const auto &x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
template <typename T>
void sort(vector<T> &val) {
  sort(val.begin(), val.end());
}
template <typename T>
void reverse(vector<T> &val) {
  reverse(val.begin(), val.end());
}
template <typename T>
void sort_b(vector<T> &val) {
  sort(val.begin(), val.end(), greater<T>());
}
template <typename T>
T pair_sum(pair<T, T> &val) {
  return val.first + val.second;
}
template <typename T>
T min(T a, T b, T c) {
  return min(min(a, b), c);
}
template <typename T>
T max(T a, T b, T c) {
  return max(max(a, b), c);
}
template <typename T>
T mul_mod(T a, T b, T mod) {
  T res = 0;
  a %= mod;
  while (b) {
    if (b & 1) {
      res = (res + a) % mod;
    }
    a = (2 * a) % mod;
    b >>= 1;
  }
  return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
struct vertex {
  vll childs;
  bool seen;
};
const vertex ZERO_VERTEX = {};
class tree {
 public:
  vector<vertex> verteces;
  tree(ll i) { verteces.assign(i, ZERO_VERTEX); }
};
struct node {
  ll first;
  ll second;
  ll color;
  bool operator<(const node &a) const { return first < a.first; }
  bool operator>(const node &a) const { return first > a.first; }
};
string to_string(node a) {
  return "{" + to_string(a.first) + ", " + to_string(a.second) + ", " +
         to_string(a.color) + "}";
}
class mytask {
 public:
  mytask() {}
  int solve() {
    ll t;
    cin >> t;
    while (t--) {
      vll a(3);
      cin >> a[0] >> a[1] >> a[2];
      ;
      ;
      vll b = a;
      sort_b(b);
      if (b[0] != b[1]) {
        cout << "NO"
             << "\n";
      } else {
        cout << "YES\n";
        if (a[0] == b[0]) {
          cout << 1 << " " << a[1] << " " << a[2];
        } else {
          cout << a[0] << " " << 1 << " " << a[2];
        }
        cout << "\n";
      }
    }
    return 0;
  }
};
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  auto task = mytask();
  task.solve();
  return 0;
}