#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

void Solve() {
  int64_t a, b, c;
  IN(a, b, c);

  if (a == b && b == c) {
    if (a == 2) {
      OUT("NO");
    } else {
      OUT("YES");
      {
        string s(a, '0');
        s[0] = '1';
        OUT(s);
      }
      {
        string s(a, '0');
        s[1] = '1';
        OUT(s);
      }
      {
        string s(a, '0');
        s[0] = '1';
        s[1] = '1';
        OUT(s);
      }
    }
    return;
  }

  int64_t x = gcd(b, c);
  int64_t y = gcd(c, a);
  int64_t z = gcd(a, b);
  if (lcm(y, z) != a || lcm(z, x) != b || lcm(x, y) != c) {
    OUT("NO");
    return;
  }

  int x0 = 0;
  int y0 = 0;
  int z0 = 0;

  if (x == y) {
    y0 = -1;
  } else if (y == z) {
    z0 = -1;
  } else if (z == x) {
    x0 = -1;
  }

  OUT("YES");
  {
    string s(a, '?');
    for (int i : Rep(0, a)) {
      int t = i % y == y0;
      t ^= i % z == z0;
      s[i] = char('0' + t);
    }
    OUT(s);
  }
  {
    string s(b, '?');
    for (int i : Rep(0, b)) {
      int t = i % z == z0;
      t ^= i % x == x0;
      s[i] = char('0' + t);
    }
    OUT(s);
  }
  {
    string s(c, '?');
    for (int i : Rep(0, c)) {
      int t = i % x == x0;
      t ^= i % y == y0;
      s[i] = char('0' + t);
    }
    OUT(s);
  }
}

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

  int t;
  IN(t);
  while (t--) {
    Solve();
  }
}

#elif __INCLUDE_LEVEL__ == 1

#include <bits/stdc++.h>

template <class T> concept Range = std::ranges::range<T> && !std::convertible_to<T, std::string_view>;
template <class T> concept Tuple = std::__is_tuple_like<T>::value && !Range<T>;

namespace std {

istream& operator>>(istream& is, Range auto&& r) {
  for (auto&& e : r) is >> e;
  return is;
}
istream& operator>>(istream& is, Tuple auto&& t) {
  apply([&](auto&... xs) { (is >> ... >> xs); }, t);
  return is;
}

ostream& operator<<(ostream& os, Range auto&& r) {
  auto sep = "";
  for (auto&& e : r) os << exchange(sep, " ") << e;
  return os;
}
ostream& operator<<(ostream& os, Tuple auto&& t) {
  auto sep = "";
  apply([&](auto&... xs) { ((os << exchange(sep, " ") << xs), ...); }, t);
  return os;
}

}  // namespace std

using namespace std;

#define Rep(...) [](int l, int r) { return views::iota(min(l, r), r); }(__VA_ARGS__)
#define IN(...) (cin >> forward_as_tuple(__VA_ARGS__))
#define OUT(...) (cout << forward_as_tuple(__VA_ARGS__) << '\n')

#endif  // __INCLUDE_LEVEL__ == 1