#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


pair<Int, Int> solve(const Int X[2], const Int A[2]) {
  if (X[0] == X[1]) {
    return make_pair(2, 2);
  }
  
  // X >= a^2
  {
    vector<pair<vector<Int>, pair<int, Int>>> ps;
    for (int i = 0; i < 2; ++i) {
      for (Int a = 2; a <= A[i] && a * a <= X[i]; ++a) {
        vector<Int> xs;
        for (Int x = X[i]; x; x /= a) {
          xs.push_back(x % a);
        }
        ps.emplace_back(xs, make_pair(i, a));
      }
    }
    sort(ps.begin(), ps.end());
    for (int j = 0; j < (int)ps.size() - 1; ++j) {
      if (ps[j].first == ps[j + 1].first) {
        assert(ps[j].second.first == 0);
        assert(ps[j + 1].second.first == 1);
        return make_pair(ps[j].second.second, ps[j + 1].second.second);
      }
    }
  }
  
  // X < a^2
  // X = u + a v
  const Int DX = X[1] - X[0];
  vector<Int> vs;
  for (Int d = 1; d * d <= DX; ++d) if (DX % d == 0) {
    vs.push_back(d);
    if (d != DX / d) vs.push_back(DX / d);
  }
  for (const Int v : vs) {
    Int lbs[2], ubs[2];
    for (int i = 0; i < 2; ++i) {
      lbs[i] = 2;
      ubs[i] = A[i];
      // 0 <= u <= a-1  <=>  a v <= X <= a (v+1) - 1
      chmax(lbs[i], X[i] / (v + 1) + 1);
      chmin(ubs[i], X[i] / v);
      // 0 <= v <= a-1
      chmax(lbs[i], v + 1);
    }
    const Int diff = DX / v;
    const Int lb = max(lbs[0], lbs[1] - diff);
    const Int ub = min(ubs[0], ubs[1] - diff);
    if (lb <= ub) {
      return make_pair(lb, lb + diff);
    }
  }
  
  return make_pair(-1, -1);
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    Int X[2], A[2];
    scanf("%lld%lld%lld%lld", &X[0], &X[1], &A[0], &A[1]);
    
    const bool sw = (X[0] > X[1]);
    if (sw) {
      swap(X[0], X[1]);
      swap(A[0], A[1]);
    }
    auto res = solve(X, A);
    
    if (~res.first) {
      if (sw) {
        swap(res.first, res.second);
      }
      puts("YES");
      printf("%lld %lld\n", res.first, res.second);
    } else {
      puts("NO");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}