Problem: Recently, Olya received a magical square with the size of 2^n× 2^n.

It seems to her sister that one square is boring. Therefore, she asked Olya to perform exactly k splitting operations.

A Splitting operation is an operation during which Olya takes a square with side a and cuts it into 4 equal squares with side a/2. If the side of the square is equal to 1, then it is impossible to apply a splitting operation to it (see examples for better understanding).

Olya is happy to fulfill her sister's request, but she also wants the condition of Olya's happiness to be satisfied after all operations.

The condition of Olya's happiness will be satisfied if the following statement is fulfilled:

Let the length of the side of the lower left square be equal to a, then the length of the side of the right upper square should also be equal to a. There should also be a path between them that consists only of squares with the side of length a. All consecutive squares on a path should have a common side.

Obviously, as long as we have one square, these conditions are met. So Olya is ready to fulfill her sister's request only under the condition that she is satisfied too. Tell her: is it possible to perform exactly k splitting operations in a certain order so that the condition of Olya's happiness is satisfied? If it is possible, tell also the size of the side of squares of which the path from the lower left square to the upper right one will consist.

Input

The first line contains one integer t (1 ≤ t ≤ 10^3) — the number of tests.

Each of the following t lines contains two integers n_i and k_i (1 ≤ n_i ≤ 10^9, 1 ≤ k_i ≤ 10^{18}) — the description of the i-th test, which means that initially Olya's square has size of 2^{n_i}× 2^{n_i} and Olya's sister asks her to do exactly k_i splitting operations.

Output

Print t lines, where in the i-th line you should output "YES" if it is possible to perform k_i splitting operations in the i-th test in such a way that the condition of Olya's happiness is satisfied or print "NO" otherwise. If you printed "YES", then also print the log_2 of the length of the side of the squares through space, along which you can build a path from the lower left square to the upper right one.

You can output each letter in any case (lower or upper).

If there are multiple answers, print any.

Example

Input


3
1 1
2 2
2 12


Output


YES 0
YES 1
NO

Note

In each of the illustrations, the pictures are shown in order in which Olya applied the operations. The recently-created squares are highlighted with red.

In the first test, Olya can apply splitting operations in the following order:

<image> Olya applies one operation on the only existing square.

The condition of Olya's happiness will be met, since there is a path of squares of the same size from the lower left square to the upper right one:

<image>

The length of the sides of the squares on the path is 1. log_2(1) = 0.

In the second test, Olya can apply splitting operations in the following order:

<image> Olya applies the first operation on the only existing square. She applies the second one on the right bottom square.

The condition of Olya's happiness will be met, since there is a path of squares of the same size from the lower left square to the upper right one:

<image>

The length of the sides of the squares on the path is 2. log_2(2) = 1.

In the third test, it takes 5 operations for Olya to make the square look like this:

<image>

Since it requires her to perform 7 splitting operations, and it is impossible to perform them on squares with side equal to 1, then Olya cannot do anything more and the answer is "NO".

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
constexpr char nl = '\n';
template <class array, class B>
array&& mini(array&& a, B&& b) {
  if (b < a) a = b;
  return a;
}
template <class array, class B>
array&& maxi(array&& a, B&& b) {
  if (b > a) a = b;
  return a;
}
int first_bit(int x) { return x == 0 ? 0 : sizeof(x) * 8 - __builtin_clz(x); }
int ceil2(int x) { return x < 2 ? x : 1 << first_bit(x - 1); }
constexpr int inf = 0x3f3f3f3f;
constexpr long long inf_l = 0x3f3f3f3f3f3f3f3f;
struct Debug;
template <class T>
auto _is_debug_func(T&& x)
    -> decltype(x(declval<add_lvalue_reference<Debug>::type>()), true_type{});
false_type _is_debug_func(...);
template <class T>
struct is_debug_func : decltype(_is_debug_func(declval<T>())) {};
;
template <class T>
auto _is_func(T&& x) -> decltype(x(), true_type{});
false_type _is_func(...);
template <class T>
struct is_func : decltype(_is_func(declval<T>())) {};
template <class T>
auto _is_string(T&& x) -> decltype(string(x), true_type{});
false_type _is_string(...);
template <class T>
struct is_string : decltype(_is_string(declval<T>())) {};
template <class T>
auto _is_ptr(T&& x)
    -> decltype(*x, typename enable_if<is_string<T>() == false, int>::type(),
                true_type{});
false_type _is_ptr(...);
template <class T>
struct is_ptr : decltype(_is_ptr(declval<T>())) {};
;
template <class T>
auto _is_container(T&& x)
    -> decltype(x.begin(),
                typename enable_if<is_string<T>() == false, int>::type(),
                true_type{});
false_type _is_container(...);
template <class T>
struct is_container : decltype(_is_container(declval<T>())) {};
template <class Iter>
struct Off {
  Iter _a, _b;
};
template <class T>
auto O(T&& x)
    -> decltype(typename enable_if<is_container<T>() == true, int>::type(),
                Off<decltype(x.begin())>()) {
  return {x.begin(), x.end()};
}
template <class T>
auto O(T&& x)
    -> decltype(typename enable_if<is_container<T>() == false, int>::type(),
                x) {
  return x;
}
struct Debug {
  Debug() { cerr << boolalpha << fixed << setprecision(0); }
  ~Debug() { cerr << nl; }
  Debug& operator()(int x = 1) {
    for (auto _ = (0), ___ = ((x)-1); _ <= ___; ++_) *this << "  ";
    return *this;
  }
  template <class T>
  auto operator<<(T&& x)
      -> decltype(cerr << x,
                  typename enable_if<
                      is_func<T>() == false && is_ptr<T>() == false &&
                          is_integral<typename remove_reference<T>::type>() ==
                              true,
                      int>::type(),
                  *this) {
    using L = long long;
    if (abs(int(x)) == inf || abs(L(x)) == inf_l)
      cerr << ((int(x) == inf || L(x) == inf_l)     ? "+∞"
               : (int(x) == -inf || L(x) == -inf_l) ? "-∞"
                                                    : "?");
    else
      cerr << x;
    return *this;
  }
  template <class T>
  auto operator<<(T&& x)
      -> decltype(cerr << x,
                  typename enable_if<
                      is_func<T>() == false && is_ptr<T>() == false &&
                          is_integral<typename remove_reference<T>::type>() ==
                              false,
                      int>::type(),
                  *this) {
    cerr << x;
    return *this;
  }
  template <class T>
  auto operator<<(T&& x) -> decltype(x.first, *this) {
    return *this << "(" << O(x.first) << ", " << O(x.second) << ")";
  }
  template <class T>
  auto operator<<(T&& x)
      -> decltype(typename enable_if<is_container<T>() == true, int>::type(),
                  *this) {
    *this << "{\n";
    for (auto a = x.begin(); a != x.end(); ++a)
      *this << "  " << distance(x.begin(), a) << ": " << O(*a) << '\n';
    return *this << "}";
  }
  template <class T>
  auto operator<<(T&& x) -> decltype(x._a, *this) {
    *this << "{";
    for (auto a = x._a, b = x._b; a != b; ++a)
      *this << O(*a) << (next(a) == b ? "" : ", ");
    return *this << "}";
  }
  template <class T>
  auto operator<<(T&& x)
      -> decltype(typename enable_if<is_func<T>() == true, int>::type(),
                  *this) {
    x();
    return *this;
  }
  template <class T>
  auto operator<<(T&& x)
      -> decltype(typename enable_if<is_debug_func<T>() == true, int>::type(),
                  *this) {
    x(*this);
    return *this;
  }
  template <class T>
  auto operator<<(T&& x)
      -> decltype(typename enable_if<is_ptr<T>() == true &&
                                         is_func<T>() == false &&
                                         is_debug_func<T>() == false,
                                     int>::type(),
                  *this) {
    return *this << *x;
  }
};
struct DebugOff {
  template <class T>
  DebugOff& operator<<(T&&) {
    return *this;
  }
  DebugOff& operator()(int = 0) { return *this; }
};
using VI = vector<int>;
using VVI = vector<VI>;
using L = long long;
using VL = vector<L>;
using VB = vector<bool>;
using II = pair<int, int>;
using VII = vector<II>;
using VVII = vector<VII>;
using UL = unsigned long long;
UL pot(UL a, UL b) {
  if (b == 0) return 1;
  UL x = pot(a, b / 2);
  x *= x;
  if (b & 1) x *= a;
  return x;
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int t;
  cin >> t;
  while (t-- > 0) {
    int n;
    UL k;
    cin >> n >> k;
    DebugOff() << "n"
                  ": "
               << n << "   "
               << "k"
                  ": "
               << k << "   ";
    int lg_k = 0;
    UL tmp = 1;
    while (tmp <= k) {
      tmp *= 2;
      ++lg_k;
    }
    auto get_rest = [&](int size) {
      UL rest = 0;
      auto mx_cut = [&](int s) {
        double d = (pow(4, s) - 1) / 3;
        if (d > k + 1000000) return k;
        return (pot(4, s) - 1) / 3;
      };
      tmp = 4;
      UL curr_count = 1;
      for (auto s = (n - 1), s__ = (size); s >= s__; --s) {
        DebugOff() << "s"
                      ": "
                   << s << "   "
                   << "curr_count"
                      ": "
                   << curr_count << "   "
                   << "mx_cut(s)"
                      ": "
                   << mx_cut(s) << "   ";
        UL x = mx_cut(s);
        if (x >= (curr_count + k - 1) / curr_count) {
          rest = k;
          break;
        }
        rest += x * curr_count;
        if (rest > k) {
          rest = k;
          break;
        }
        curr_count += tmp;
        if (curr_count > k) curr_count = k;
        tmp *= 2;
        if (tmp > k) tmp = k;
      }
      DebugOff() << "rest"
                    ": "
                 << rest << "   ";
      return rest;
    };
    bool found = false;
    for (auto moves = (0), moves__ = (min(lg_k + 1, n)); moves <= moves__;
         ++moves) {
      int size = n - moves;
      DebugOff() << "size"
                    ": "
                 << size << "   "
                 << "moves"
                    ": "
                 << moves << "   ";
      UL necessary = -moves + pot(2, moves + 1) - 2;
      DebugOff() << "necessary"
                    ": "
                 << necessary << "   ";
      if (necessary > k) continue;
      UL rest = get_rest(size);
      DebugOff() << "size"
                    ": "
                 << size << "   "
                 << "moves"
                    ": "
                 << moves << "   "
                 << "necessary"
                    ": "
                 << necessary << "   "
                 << "rest"
                    ": "
                 << rest << "   ";
      if (necessary + rest < k) continue;
      cout << "YES " << size << nl;
      found = true;
      break;
    }
    if (found == false) cout << "NO" << nl;
  }
}