#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);
}

### Prompt

Generate a cpp solution to the following problem:

What are you doing at the end of the world? Are you busy? Will you save us?

<image>

Nephren is playing a game with little leprechauns.

She gives them an infinite array of strings, f0... ∞.

f0 is "What are you doing at the end of the world? Are you busy? Will you save us?".

She wants to let more people know about it, so she defines fi =  "What are you doing while sending "fi - 1"? Are you busy? Will you send "fi - 1"?" for all i ≥ 1.

For example, f1 is

"What are you doing while sending "What are you doing at the end of the world? Are you busy? Will you save us?"? Are you busy? Will you send "What are you doing at the end of the world? Are you busy? Will you save us?"?". Note that the quotes in the very beginning and in the very end are for clarity and are not a part of f1.

It can be seen that the characters in fi are letters, question marks, (possibly) quotation marks and spaces.

Nephren will ask the little leprechauns q times. Each time she will let them find the k-th character of fn. The characters are indexed starting from 1. If fn consists of less than k characters, output '.' (without quotes).

Can you answer her queries?

Input

The first line contains one integer q (1 ≤ q ≤ 10) — the number of Nephren's questions.

Each of the next q lines describes Nephren's question and contains two integers n and k (0 ≤ n ≤ 105, 1 ≤ k ≤ 1018).

Output

One line containing q characters. The i-th character in it should be the answer for the i-th query.

Examples

Input

3
1 1
1 2
1 111111111111


Output

Wh.

Input

5
0 69
1 194
1 139
0 47
1 66


Output

abdef

Input

10
4 1825
3 75
3 530
4 1829
4 1651
3 187
4 584
4 255
4 774
2 474


Output

Areyoubusy

Note

For the first two examples, refer to f0 and f1 given in the legend.

### Response

```cpp
#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);
}

```