#include <bits/stdc++.h>
volatile bool isLocalTestEnabled = 0;
bool g_isLocalPrintEnabled = (bool)(0);
template <typename T>
void UpdateMin(T& a, const T b) {
  a = std::min(a, b);
}
template <typename T>
void UpdateMax(T& a, const T b) {
  a = std::max(a, b);
}
const long double Pi = std::atan(1.0L) * 4.0L;
static const long double Eps = 1.0e-09;
template <typename T>
bool IsEqual(const T a, const T b) {
  return std::abs(a - b) < Eps;
}
template <typename T>
bool IsGreater(const T a, const T b) {
  return a > b + Eps;
}
template <typename T>
bool IsLess(const T a, const T b) {
  return a + Eps < b;
}
template <typename T>
bool IsGreaterEqual(const T a, const T b) {
  return !IsLess(a, b);
}
template <typename T>
bool IsLessEqual(const T a, const T b) {
  return !IsGreater(a, b);
}
template <typename T>
std::string ToStr(const T& val) {
  std::ostringstream ostr;
  ostr << val;
  return ostr.str();
}
template <typename T>
bool FromStr(const std::string& str, T& val) {
  std::istringstream istr(str);
  istr >> val;
  return !!istr;
}
template <typename T>
T FromStr(const std::string& str) {
  T val = {};
  std::istringstream istr(str);
  istr >> val;
  return val;
}
uint64_t SafeAdd(uint64_t a, uint64_t b) {
  uint64_t M = std::numeric_limits<uint64_t>::max();
  return a <= M - b ? a + b : M;
}
uint64_t SafeMul(uint64_t a, uint64_t b) {
  uint64_t M = std::numeric_limits<uint64_t>::max();
  return a <= M / b ? a * b : M;
}
template <typename T>
std::istream& operator>>(std::istream& ist, std::vector<T>& data) {
  ;
  for (size_t i = 0; i < data.size(); i++) {
    ist >> data[i];
  }
  return ist;
}
template <typename T>
T Read(std::istream& ist) {
  ;
  T val;
  ist >> val;
  return val;
}
template <typename T>
std::ostream& operator<<(std::ostream& ost, const std::vector<T>& data) {
  for (size_t i = 0; i < data.size(); i++) {
    if (i != 0) {
      ost << ' ';
    }
    ost << data[i];
  }
  return ost;
}
template <size_t id>
class StopWatch {};
const std::string F0 =
    "What are you doing at the end of the world? Are you busy? Will you save "
    "us?";
const std::string Fi1 = "What are you doing while sending \"";
const std::string Fi2 = "\"? Are you busy? Will you send \"";
const std::string Fi3 = "\"?";
const size_t MaxN = 100000;
class Solver {
 public:
  Solver(const size_t n) {
    size.resize(n + 1);
    start1.resize(n + 1);
    end1.resize(n + 1);
    start2.resize(n + 1);
    end2.resize(n + 1);
    start3.resize(n + 1);
    end3.resize(n + 1);
    size[0] = F0.size();
    for (size_t i = 1; i <= n; i++) {
      uint64_t prevSize = size[i - 1];
      uint64_t& currSize = size[i];
      currSize = SafeMul(prevSize, 2);
      const uint64_t d = Fi1.size() + Fi2.size() + Fi3.size();
      currSize = SafeAdd(currSize, d);
      uint64_t pos = 0;
      start1[i] = pos;
      pos = SafeAdd(pos, Fi1.size());
      end1[i] = pos;
      pos = SafeAdd(pos, prevSize);
      start2[i] = pos;
      pos = SafeAdd(pos, Fi2.size());
      end2[i] = pos;
      pos = SafeAdd(pos, prevSize);
      start3[i] = pos;
      pos = SafeAdd(pos, Fi3.size());
      end3[i] = pos;
      ;
    }
  }
  char Get(const size_t n, const uint64_t k) const {
    if (k >= size[n]) return '.';
    if (n == 0) return F0[static_cast<size_t>(k)];
    if (k < end1[n]) return Fi1[static_cast<size_t>(k)];
    if (k < start2[n]) return Get(n - 1, k - end1[n]);
    if (k < end2[n]) return Fi2[static_cast<size_t>(k - start2[n])];
    if (k < start3[n]) return Get(n - 1, k - end2[n]);
    if (k < end3[n]) return Fi3[static_cast<size_t>(k - start3[n])];
    ;
    return '.';
  }

 private:
  std::vector<uint64_t> size;
  std::vector<uint64_t> start1;
  std::vector<uint64_t> end1;
  std::vector<uint64_t> start2;
  std::vector<uint64_t> end2;
  std::vector<uint64_t> start3;
  std::vector<uint64_t> end3;
};
bool Solve(std::istream& ist, std::ostream& ost, const bool multipleTestMode) {
  StopWatch<1> sw;
  (void)sw;
  size_t q;
  ist >> q;
  if (multipleTestMode && !ist) return false;
  if (!g_isLocalPrintEnabled) {
  } else
    std::cerr << std::endl << "Next test" << std::endl;
  Solver solver(MaxN);
  std::string ans(q, ' ');
  for (size_t i = 0; i < q; i++) {
    size_t n;
    uint64_t k;
    ist >> n >> k;
    --k;
    ans[i] = solver.Get(n, k);
  }
  ost << ans << std::endl;
  return multipleTestMode;
}
void RunSolve(std::istream& ist, std::ostream& ost) { Solve(ist, ost, false); }
int main(int argc, const char* argv[]) {
  std::ios_base::sync_with_stdio(false);
  if (argc > 1) {
    std::ifstream ifs(argv[1]);
    if (!ifs) {
      std::cout << "File not found: " << argv[1] << std::endl;
      return 1;
    }
    RunSolve(ifs, std::cout);
    return 0;
  }
  RunSolve(std::cin, std::cout);
}
