#include <bits/stdc++.h>
using namespace std;

const int DAY = 1440;
const int HALF = DAY / 2;

const string AWAKE = "awake";
const string ASLEEP = "asleep";

string input() {
    string in; cin >> in;
    return in;
}

int inputInt() {
    int in; cin >> in;
    return in;
}

const int MN = 101;
int n;
int _sleep[MN], _wake[MN], _qcnt[MN];

string ask(int i, int min) {
    int h = min / 60;
    int m = min % 60;

    printf("at %02d:%02d check %d\n", h, m, i + 1);
    fflush(stdout);
    #ifdef LOCAL
    _qcnt[i] += 1;
    assert(_qcnt[i] <= 50);

    bool asleep;
    if (_sleep[i] < _wake[i])
        asleep = _sleep[i] <= min && min < _wake[i];
    else
        asleep = _sleep[i] <= min || min < _wake[i];

    return asleep ? ASLEEP : AWAKE;
    #else
    return input();
    #endif
}

enum Phase {
    INIT = 0,
    WIDESEARCH = 1,
    NARROWSEARCH = 2,
    DONE = 3
};

struct DwarfState {
    int nextTime = 0;
    Phase phase = Phase::INIT;

    // start
    string initialState;

    // widesearch
    int prev;
    int jumpLen;

    // narrowSearch
    int narrowL;
    int narrowR;

    // answer
    int ans;
};

DwarfState state[MN];

int main() {
    n = inputInt();

    #ifdef LOCAL
    for (int i = 0; i < n; i++) {
        string timeStr = input();
        int h = stoi(timeStr.substr(0, 2));
        int m = stoi(timeStr.substr(3, 2));
        _sleep[i] = h * 60 + m;
        _wake[i] = (_sleep[i] + HALF) % DAY;
    }
    #endif

    // "event loop"
    while (1) {
        // translate the below to C++
        int minTime = 1000000000;
        int idx = -1;
        for (int i = 0; i < n; i++) {
            if (state[i].nextTime < minTime && state[i].phase != Phase::DONE) {
                minTime = state[i].nextTime;
                idx = i;
            }
        }

        if (idx == -1) {
            break;
        }

        // check next state
        auto &cur = state[idx];

        if (cur.phase == Phase::INIT) {
            cur.phase = Phase::WIDESEARCH;

            cur.initialState = ask(idx, 0);

            cur.prev = 0;
            cur.jumpLen = 48;
            cur.nextTime = cur.jumpLen;
        }
        else if (cur.phase == Phase::WIDESEARCH) {
            auto res = ask(idx, cur.nextTime);
            if (res == cur.initialState) {
                cur.jumpLen -= 1;
                cur.prev = cur.nextTime;
                cur.nextTime += cur.jumpLen;
            }
            else {
                cur.phase = Phase::NARROWSEARCH;

                cur.narrowL = cur.prev + 1 + HALF;
                cur.narrowR = cur.nextTime + HALF;
                cur.nextTime = cur.narrowL;
            }
        }
        else if (cur.phase == Phase::NARROWSEARCH) {
            if (cur.nextTime >= DAY) { // edge case, answer is 0
                cur.phase = Phase::DONE;

                cur.ans = cur.initialState == AWAKE ? HALF : 0;
            }
            else {
                auto res = ask(idx, cur.nextTime);
                if (res == cur.initialState) {
                    cur.phase = Phase::DONE;

                    cur.ans = cur.nextTime;
                    if (cur.initialState == AWAKE) {
                        cur.ans += HALF;
                        cur.ans %= DAY;
                    }
                }
                else {
                    cur.nextTime += 1;
                    assert(cur.nextTime <= cur.narrowR);
                }
            }
        }
        else {
            assert(cur.phase == Phase::DONE);
            assert(false);
        }
    }

    // print ans
    printf("answer\n");
    for (int i = 0; i < n; i++) {
        int minute = state[i].ans;
        int h = minute / 60;
        int m = minute % 60;
        printf("%02d:%02d\n", h, m);
    }
    fflush(stdout);
}