#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
using uint = unsigned int;
using lint = long long int;
using ulint = unsigned long long int;
template<class T = int> using V = vector<T>;
template<class T = int> using VV = V< V<T> >;
template<class T, class U> void assign(V<T>& v, int n, const U& a) { v.assign(n, a); }
template<class T, class... Args> void assign(V<T>& v, int n, const Args&... args) { v.resize(n); for (auto&& e : v) assign(e, args...); }


// input
constexpr int T = 10'000;
string S;

// outoput
enum struct ActionType { CLICK, BUY, SELL, REINFORCE, ENHCLICK, NOTHING };
struct Action { ActionType type; int id; };
V<Action> actions(T);

// status
lint score;
lint click_power, click_cost;
const V<string> name{"hand", "lily", "factory", "casino", "grimoire"};
V<> cnt(5);
V<lint> power(5), price(5), cost(5);
bool fever, sale;

mt19937 mt(steady_clock::now().time_since_epoch().count());
// [a, b)
int rng(int a, int b) {
  assert(a < b);
  return uniform_int_distribution<>(a, b - 1)(mt);
}
double rng(double a, double b) {
  assert(a < b);
  return uniform_real_distribution<>(a, b)(mt);
}

void read_input() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  int _;
  cin >> _;
  assert(_ == T);
  cin >> S;
}

void generate_input() {
  S.assign(T, 'N');
  string bfs = "BFS";
  for (int t = rng(0, 200); t < T; t += rng(100, 201)) {
    S[t] = bfs[rng(0, 3)];
  }
}

void write_output() {
  for (const Action& action : actions) {
    switch(action.type) {
      case ActionType::CLICK:
        cout << "click" << endl;
        break;
      case ActionType::BUY:
        cout << "buy " << name[action.id] << endl;
        break;
      case ActionType::SELL:
        cout << "sell " << name[action.id] << endl;
        break;
      case ActionType::REINFORCE:
        cout << "reinforce " << name[action.id] << endl;
        break;
      case ActionType::ENHCLICK:
        cout << "enhclick " << endl;
        break;
      case ActionType::NOTHING:
        cout << "nothing" << endl;
        break;
    }
    string str;
    cin >> str;
    assert(str == "ok");
  }
}

void init() {
  score = 0;
  click_power = 1, click_cost = 15;
  fill(begin(cnt), end(cnt), 0);
  power = {1, 10, 120, 2'000, 25'000};
  price = {150, 2'000, 30'000, 600'000, 10'000'000};
  for (int id = 0; id < 5; ++id) cost[id] = 10 * price[id];
  fever = sale = false;
}

bool can_buy(int id) {
  if (sale) {
    return score >= (9 * price[id] + 9) / 10;
  } else {
    return score >= price[id];
  }
}

bool can_sell(int id) {
  return cnt[id] > 0;
}

bool can_reinforce(int id) {
  if (sale) {
    return score >= (9 * cost[id] + 9) / 10;
  } else {
    return score >= cost[id];
  }
}

bool can_enhclick() {
  if (sale) {
    return score >= (9 * click_cost + 9) / 10;
  } else {
    return score >= click_cost;
  }
}

void click() {
  score += click_power * (fever ? 7 : 1);
}

void buy(int id) {
  if (sale) {
    score -= (9 * price[id] + 9) / 10;
  } else {
    score -= price[id];
  }
  ++cnt[id];
  price[id] = (6 * price[id] + 4) / 5;
}

void sell(int id) {
  price[id] = price[id] * 5 / 6;
  --cnt[id];
  score += (price[id] + 3) / 4;
}

void reinforce(int id) {
  if (sale) {
    score -= (9 * cost[id] + 9) / 10;
  } else {
    score -= cost[id];
  }
  power[id] <<= 1;
  cost[id] *= 10;
}

void enhclick() {
  if (sale) {
    score -= (9 * click_cost + 9) / 10;
  } else {
    score -= click_cost;
  }
  click_power <<= 1;
  click_cost *= 10;
}

void act(const Action& action) {
  switch(action.type) {
    case ActionType::CLICK:
      click();
      break;
    case ActionType::BUY:
      buy(action.id);
      break;
    case ActionType::SELL:
      sell(action.id);
      break;
    case ActionType::REINFORCE:
      reinforce(action.id);
      break;
    case ActionType::ENHCLICK:
      enhclick();
      break;
    case ActionType::NOTHING:
      break;
  }
}

void produce() {
  for (int id = 0; id < 5; ++id) {
    score += power[id] * cnt[id] * (fever ? 7 : 1);
  }
}

void affect(int t) {
  switch(S[t]) {
    case 'B':
      score += (score + 99) / 100;
      break;
    case 'F':
      fever = true;
      break;
    case 'S':
      sale = true;
      break;
  }
  if (t - 20 >= 0 and S[t - 20] == 'F') fever = false;
  if (t - 1 >= 0 and S[t - 1] == 'S') sale = false;
}

lint eval_click() {
  return click_power;
}

lint eval_buy(int id, int t) {
  return power[id] * (T - t) - price[id];
}

lint eval_sell(int id, int t) {
  return (price[id] * 5 / 6 + 3) / 4 - power[id] * (T - t);
}

lint eval_reinforce(int id, int t) {
  return power[id] * cnt[id] * (T - t) - cost[id];
}

lint eval_enhclick(int t) {
  return click_power * (T - t) - click_cost;
}

void solve() {
  for (int t = 0; t < T; ++t) {
    lint best = 0, curr;
    Action best_action = {ActionType::NOTHING, -1};
    // click
    curr = eval_click();
    if (curr > best) {
      best = curr;
      best_action = {ActionType::CLICK, -1};
    }
    // facilities
    for (int id = 0; id < 5; ++id) {
      if (can_buy(id)) {
        curr = eval_buy(id, t);
        if (curr > best) {
          best = curr;
          best_action = {ActionType::BUY, id};
        }
      }
      if (can_sell(id)) {
        curr = eval_sell(id, t);
        if (curr > best) {
          best = curr;
          best_action = {ActionType::SELL, id};
        }
      }
      if (can_reinforce(id)) {
        curr = eval_reinforce(id, t);
        if (curr > best) {
          best = curr;
          best_action = {ActionType::REINFORCE, id};
        }
      }
    }
    // enhclick
    curr = eval_enhclick(t);
    if (curr > best) {
      best = curr;
      best_action = {ActionType::ENHCLICK, -1};
    }
    act(actions[t] = best_action);
    produce();
    affect(t);
  }
}

int main(int argc, char* argv[]) {
  if (argc == 1) {
    read_input();
    init();
    solve();
    write_output();
  } else {
    assert(argc == 2);
    lint total_score = 0;
    for (int _ = 0; _ < stoi(argv[1]); ++_) {
      generate_input();
      init();
      solve();
      total_score += score;
    }
    cerr << "Score: " << total_score << endl;
  }
}