// Bundled with risundle v2.1.0
#line 1 "main.cc"
// SPDX-License-Identifier: MIT
// (c) 2023 TwoSquirrels
// my AtCoder environment: https://github.com/TwoSquirrels/atcoder-env

//#define DEBUG


#pragma GCC optimize("O3,unroll-loops")


#line 1 "risu/risu/prelude.hpp"
       

// enable debug mode when compiled with -DDEBUG
#line 4 "risu/risu/std.hpp"
#include <cassert>
#line 7 "risu/risu/std.hpp"
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <array>
#line 19 "risu/risu/std.hpp"
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <algorithm>
#line 33 "risu/risu/std.hpp"
#include <bitset>
#include <complex>
#include <functional>
#include <limits>
#include <numeric>
#include <random>
#include <valarray>
#include <fstream>
#line 43 "risu/risu/std.hpp"
#include <iomanip>
#include <iostream>
#include <sstream>
#include <chrono>
#line 49 "risu/risu/std.hpp"
#include <iterator>
#include <memory>
#include <optional>
#include <string_view>
#include <thread>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <bit>
#line 61 "risu/risu/std.hpp"
#include <compare>
#include <concepts>
#include <numbers>
#include <ranges>
#include <span>
#include <source_location>
#include <format>
#line 71 "risu/risu/std.hpp"
#include <print>
#line 12 "main.cc"


#include <boost/multiprecision/cpp_int.hpp>


#include <boost/math/special_functions/prime.hpp>


#include <boost/multiprecision/miller_rabin.hpp>



#pragma GCC target("avx2,bmi2,popcnt,lzcnt")



#include <atcoder/all>


#line 1 "risu/risu/util/inf.hpp"

#line 1 "risu/risu/util/int128.hpp"
       






inline auto int128_to_str(__int128_t target) -> std::string {
  auto target_str = std::string();
  auto target_tmp = __uint128_t(target < 0 ? -target : target);
  do {
    target_str += '0' + target_tmp % 10;
    target_tmp /= 10;
  } while (target_tmp != 0);
  if (target < 0) target_str += '-';
  std::ranges::reverse(target_str);
  return target_str;
}
#line 1 "risu/risu/util/iota.hpp"
       







// [l, r) as a range, empty when r < l
template <typename T, typename U> inline auto iota_range(T l, U r) {
  using V = std::common_type_t<T, U>;
  return std::views::iota(V(l), std::max(V(l), V(r)));
}
#line 1 "risu/risu/util/typename.hpp"
#include <cstddef>
#line 6 "risu/risu/util/typename.hpp"


#include <typeinfo>
#include <cxxabi.h>
#line 1 "risu/risu/util/traits/is_pair.hpp"
       





template <typename T> inline constexpr bool is_pair_v = false;
template <typename T, typename U> inline constexpr bool is_pair_v<std::pair<T, U>> = true;
#line 1 "risu/risu/util/traits/is_tuple.hpp"
       





template <typename T> inline constexpr bool is_tuple_v = false;
template <typename... Types> inline constexpr bool is_tuple_v<std::tuple<Types...>> = true;
#line 1 "risu/risu/util/traits/istreamable.hpp"
       





template <typename T> concept istreamable_v = requires (T a) { std::cin >> a; };
#line 1 "risu/risu/util/traits/iterable.hpp"
       





template <typename T> concept iterable_v = std::ranges::range<T>;
#line 1 "risu/risu/util/traits/ostreamable.hpp"
       





template <typename T> concept ostreamable_v = requires (T a) { std::cout << a; };
#line 1 "risu/risu/math/mod/mint_inv.hpp"

#line 6 "risu/risu/math/mod/mint_inv.hpp"
#include <atcoder/modint>
#line 5 "risu/risu/math/mod/factorial.hpp"

#line 7 "risu/risu/math/mod/factorial.hpp"




#line 1 "risu/risu/math/prime/prime.hpp"

#line 6 "risu/risu/math/prime/prime.hpp"

#include <atcoder/math>
#line 9 "risu/risu/math/prime/prime.hpp"

#line 12 "risu/risu/math/prime/prime.hpp"

#line 5 "risu/risu/math/prime/factors.hpp"

#line 7 "risu/risu/math/prime/factors.hpp"



#line 5 "risu/risu/math/prime/divisors.hpp"

#line 7 "risu/risu/math/prime/divisors.hpp"

#line 1 "risu/risu/io/input.hpp"
       








#line 18 "risu/risu/io/input.hpp"
template <typename T> inline auto read_stdin(T &&target) -> void {







  std::cin >> target;

}
template <typename T> inline auto input(T &&target) -> T {
  using T_V = std::remove_reference_t<T>;
  if constexpr (istreamable_v<T_V>) read_stdin(target);
  else if constexpr (iterable_v<T_V>) for (auto &&target_i : target) input(target_i);
  else if constexpr (is_pair_v<T_V>) {
    input(target.first);
    input(target.second);
  } else if constexpr (std::is_convertible_v<long long, T_V>) {
    auto n = 0LL;
    target = input(n);
  } else {




  }
  return target;
}
// input and initialize
struct Scanner { template <typename T> inline operator T() const { T target; return input(target); } };
inline Scanner scan;
#line 1 "risu/risu/io/output.hpp"
       
#line 10 "risu/risu/io/output.hpp"







template <typename T> inline auto write_stdout(const T &target, bool flush = false) -> void {
  std::cout << target;
  if (flush) std::cout << std::flush;
}
template <typename T, typename Sep = char> inline auto output(const T &target, Sep separator = ' ', bool flush = false) -> void {
  if constexpr (ostreamable_v<T>) {
    write_stdout(target, flush);
  } else if constexpr (std::convertible_to<T, __int128_t>) {
    write_stdout(int128_to_str(target), flush);

  } else if constexpr (atcoder::internal::is_modint<T>::value) {
    output(target.val(), separator, flush);

  } else if constexpr (iterable_v<T>) {
    auto separate = false;
    for (const auto &target_i : target) {
      if (separate) write_stdout(separator);
      output(target_i, separator);
      separate = true;
    }
    if (flush) write_stdout("", flush);
  } else if constexpr (is_pair_v<T>) {
    output(target.first, separator);
    write_stdout(separator);
    output(target.second, separator, flush);
  } else if constexpr (is_tuple_v<T>) {
    auto separate = false;
    std::apply([&](const auto &... elems) {
      (([&](const auto &elem) {
        if (separate) write_stdout(separator);
        output(elem, separator);
        separate = true;
      })(elems), ...);
    }, target);
    if (flush) write_stdout("", flush);
  } else {
    write_stdout("<unknown>", flush);
  }
}
template <typename T, typename Sep = char> inline auto outputln(const T &target, Sep separator = ' ', bool flush = false) -> void {
  output(target, separator);
  write_stdout('\n', flush);
}
#line 12 "risu/risu/debug/pretty.hpp"







#line 1 "risu/risu/main.hpp"
       




#include <exception>









inline auto cp_main() -> std::string;



auto main() -> int {
  using namespace std;






    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(12);
    // run!!!
    const auto result = cp_main();
    if (!result.empty()) write_stdout(result);
#line 44 "risu/risu/main.hpp"
  return 0;
}
#line 1 "risu/risu/aliases.hpp"
       















using i32 = int; using u32 = unsigned int;
using i64 = long long; using u64 = unsigned long long;
using i128 = __int128; using u128 = unsigned __int128;
using f32 = float; using f64 = double; using f80 = long double;
using str = std::string;
template <typename T> using vec = std::vector<T>;
template <typename T, typename Compare = std::less<T>> using p_que = std::priority_queue<T, std::vector<T>, Compare>;
template <typename Key, typename Compare = std::less<Key>> using mset = std::multiset<Key, Compare>;
template <typename Key, typename T, typename Compare = std::less<Key>> using mmap = std::multimap<Key, T, Compare>;
template <typename Key> using u_set = std::unordered_set<Key>;
template <typename Key> using u_mset = std::unordered_multiset<Key>;
template <typename Key, typename T> using u_map = std::unordered_map<Key, T>;
template <typename Key, typename T> using u_mmap = std::unordered_multimap<Key, T>;

using bigint = boost::multiprecision::cpp_int;
#line 1 "risu/risu/constants.hpp"

#line 7 "risu/risu/constants.hpp"

#line 1 "risu/risu/macros.hpp"

#line 7 "risu/risu/macros.hpp"



#line 32 "main.cc"

using namespace std;
namespace rng = std::ranges;
namespace viw = std::ranges::views;

using namespace atcoder;


/// answer

//using mint=modint998244353;

inline auto cp_main() -> str {
  i64 t=scan;
  for ([[maybe_unused]] const auto ti : iota_range(0, t)) {
    i64 h=scan,w=scan;
    outputln((h+w)%2==0?"ryota":"sepa");
  }
  return "";
}