#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <cstring>

#include <algorithm>
#include <chrono>
#include <iomanip>
#include <iostream>
#include <queue>
#include <set>
#include <unordered_set>
#include <sstream>
#include <string>
#include <map>
#include <unordered_map>
#include <vector>
#include <functional>
#include <numeric>

#define int long long
#define FOR(a,b) for(int a = 0; a < b; a++)
#define All(vec) vec.begin(),vec.end()

using std::string;
using std::vector;
using std::pair;
using std::cin;
using std::cout;
const int oo = 3074457345618258602LL;

std::stringstream out;

template<class T> bool ckmax(T& a, const T& b) {
	return a < b ? a = b, 1 : 0;
}
template<class T> bool ckmin(T& a, const T& b) {
	return a > b ? a = b, 1 : 0;
}

template<int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
	static_assert(D >= 1, "Vector dimension must be greater than zero!");
	template<typename U, typename... Args>
	Vec(U n = U(), Args... args) : vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {
	}
	template<typename... Args>
	Vec(int n = 0, Args... args) : vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {
	}
};
template<typename T>
struct Vec<1, T> : public vector<T> {
	template<typename... Args>
	Vec(Args... args) : vector<T>(args...) {
	}
	Vec(int n = 0, const T& val = T()) : vector<T>(n, val) {
	}
};

const bool kReadTestCases = 0;
const bool kLocalRun = 0;
const bool kBruteSolve = 0;

struct Dwarf {
	bool start;
	int state = 0;
	int prev = -1;
	int next_ask = 0;
	int gap = 45;
	int ans = -1;
};

struct Solution {

	void ReadInput() {

	}

	inline string Time(int t) {
		string h = std::to_string(t / 60);
		while (h.length() < 2)h = "0" + h;
		string m = std::to_string(t % 60);
		while (m.length() < 2)m = "0" + m;
		return h + ":" + m;
	}

	void Solve(std::stringstream& out) {
		int N;
		cin >> N;
		vector<Dwarf> arr(N + 1);
		FOR(time, 1440) {
			for (int i = 1; i <= N; i++) {
				Dwarf& d = arr[i];
				if (d.state == 3 || d.next_ask != time)continue;
				cout << "at " << Time(time) << " check " << i << "\n";
				cout.flush();
				string res;
				cin >> res;
				bool sleeping = res == "asleep";
				if (d.state < 2) {
					if ((d.state == 1 && d.prev != sleeping)) {
						d.state++;
						d.next_ask += 720;
						d.next_ask -= d.gap;
						d.prev = sleeping;
						continue;
					}
					d.next_ask += d.gap;
					d.gap--;
					if (d.state == 0) {
						d.state++;
						d.start = sleeping;
					}
					d.prev = sleeping;
					continue;
				}
				if (d.state == 2) {
					if (sleeping != d.prev) {
						d.state++;
						d.ans = time;
						if (!sleeping) {
							d.ans -= 720;
						}
					}
					d.next_ask++;
					continue;
				}
			}
		}
		cout << "answer\n";
		cout.flush();
		for (int i = 1; i <= N; i++) {
			if (arr[i].ans == -1) {
				if (arr[i].start) {
					arr[i].ans = 0;
				} else {
					arr[i].ans = 720;
				}
			}
			cout << Time(arr[i].ans) << "\n";
			cout.flush();
		}
	}

	void SolveBrute(std::stringstream& out) {

	}
	void GenInput() {

	}
	void PrintInput() {

	}

	inline vector<int> ReadVec(int N) {
		vector<int> vec(N);
		FOR(i, N) {
			cin >> vec[i];
		}
		return vec;
	}

	inline string Stringify(vector<int>& arr) {
		std::stringstream ss;
		FOR(i, arr.size()) {
			ss << arr[i] << " \n"[i == arr.size() - 1];
		}
		return ss.str();
	}
};


void RunLocal() {
	srand(time(NULL));
	int iter = 0;
	while (true) {
		if (++iter % 1000 == 0) {
			std::cout << iter << "\n";
		}
		Solution solution;
		solution.GenInput();
		std::stringstream ss1;
		std::stringstream ss2;
		solution.Solve(ss1);
		solution.SolveBrute(ss2);
		string ans = ss1.str();
		string ans_correct = ss2.str();
		if (ans != ans_correct) {
			solution.PrintInput();
			cout << "\n\n";
			cout << "Wrong answer:\n";
			cout << "---------------------------------------------------------\n";
			cout << ans << "\n";
			cout << "Correct answer:\n";
			cout << "---------------------------------------------------------\n";
			cout << ans_correct << "\n";
			break;
		}
	}
}

int32_t main() {
	std::ios_base::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);
	if (kLocalRun) {
		RunLocal();
		return 0;
	}
	int tc = 1;
	if (kReadTestCases)std::cin >> tc;
	for (int _ = 1; _ <= tc; _++) {
		Solution solution;
		solution.ReadInput();
		if (kBruteSolve) {
			solution.SolveBrute(out);
		} else {
			solution.Solve(out);
		}
	}
	std::cout << out.str();
	std::cout.flush();
	return 0;
}