#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif

template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
    for (auto& e : v) {
        is >> e;
    }
    return is;
}

template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (std::string_view sep = ""; const auto& e : v) {
        os << std::exchange(sep, " ") << e;
    }
    return os;
}

template <class T, class U = T> bool chmin(T& x, U&& y) {
    return y < x and (x = std::forward<U>(y), true);
}

template <class T, class U = T> bool chmax(T& x, U&& y) {
    return x < y and (x = std::forward<U>(y), true);
}

template <class T> void mkuni(std::vector<T>& v) {
    std::ranges::sort(v);
    auto result = std::ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T> int lwb(const std::vector<T>& v, const T& x) {
    return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}

using ll = long long;

using namespace std;

const int uni[4] = {600, 60, 10, 1};
const int HALF = 720;

string itos(int time) {
    string res = "";
    for (int i = 0; i < 4; i++) {
        res += char('0' + time / uni[i]);
        time %= uni[i];
        if (i == 1) res += ':';
    }
    return res;
}

int n;

int query(int time, int i) {
    assert(0 <= time and time < HALF * 2);
    assert(0 <= i and i < n);
    cout << "at " << itos(time) << " check " << i + 1 << endl;
    string res;
    cin >> res;
    assert(res == "awake" or res == "asleep");
    return res == "asleep";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);
    cin >> n;
    vector<int> L(n), R(n), start(n, -1);
    vector<bool> alive(n, true);
    int pre = -1, cur = 0;
    for (int k = 49; cur < HALF; cur += k, k--) {
        for (int i = 0; i < n; i++) {
            if (not alive[i]) continue;
            int res = query(cur, i);
            if (start[i] != -1 and res != start[i]) {
                alive[i] = false;
                L[i] = pre;
                R[i] = cur;
                continue;
            }
            start[i] = res;
        }
        pre = cur;
        if (cur + k >= HALF) break;
    }
    for (int i = 0; i < n; i++) {
        if (alive[i]) {
            L[i] = cur;
            R[i] = HALF;
        }
    }

    pre = -1, cur = 0;
    vector<int> ans(n);
    for (int i = 0; i < n; i++) {
        alive[i] = true;
        start[i] ^= 1;
    }
    auto solve = [&](int l, int r, const vector<int>& cand) -> void {
        for (int t = l + 1; t < r; t++) {
            for (int i : cand) {
                if (not alive[i]) continue;
                int res = query(HALF + t, i);
                if (res != start[i]) {
                    alive[i] = false;
                    ans[i] = (res == 1 ? HALF + t : t);
                }
            }
        }
        for (int i : cand) {
            if (alive[i]) {
                ans[i] = (start[i] == 0 ? (HALF + r) % (HALF * 2) : r);
            }
        }
    };
    for (int k = 0; k < HALF; k++) {
        vector<int> v;
        for (int i = 0; i < n; i++) {
            if (L[i] == k) {
                v.emplace_back(i);
            }
        }
        if (v.empty()) continue;
        int l = L[v[0]], r = R[v[0]];
        solve(l, r, v);
    }

    cout << "answer\n";
    for (int i = 0; i < n; i++) cout << itos(ans[i]) << '\n';
    cout << endl;
    return 0;
}