use std::io::Write;
use std::collections::*;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

const ALL: i32 = 60 * 24;

fn main() {
    let mut dp = Map::new();
    calc(0, ALL / 2, 0, 49, &mut dp);
    calc(ALL / 2, ALL, 0, 49, &mut dp);
    let n = read().parse::<usize>().unwrap();
    let mut cnt = vec![0; n];
    let mut time = 0;
    let mut query = |k: usize, t: i32| -> bool {
        assert!(cnt[k] < 50);
        assert!(time <= t);
        time = t;
        cnt[k] += 1;
        let h = t / 60;
        let m = t % 60;
        println!("at {:02}:{:02} check {}", h, m, k + 1);
        read() == "awake"
    };
    let mut memo = vec![];
    for i in 0..n {
        let p = if query(i, 0) {
            (0, ALL / 2, 0)
        } else {
            (ALL / 2, ALL, 0)
        };
        memo.push((p, dp[&p].1));
    }
    while memo.iter().any(|p| p.1 != ALL) {
        let x = (0..n).min_by_key(|x| memo[*x].1).unwrap();
        let ((s, t, _), v) = memo[x];
        let mut mid = 0;
        let mut sign = 0;
        for i in -1..=1 {
            let m = v + i * ALL / 2;
            if s < m && m < t {
                mid = m;
                sign = i;
            }
        }
        let p = if query(x, v) {
            if sign == 0 {
                (mid, t, v)
            } else {
                (s, mid, v)
            }
        } else {
            if sign != 0 {
                (mid, t, v)
            } else {
                (s, mid, v)
            }
        };
        memo[x] = (p, dp[&p].1);
    }
    println!("answer");
    for ((s, t, _), _) in memo {
        let t = if t == ALL {
            0
        } else {
            t
        };
        let h = t / 60;
        let m = t % 60;
        println!("{:02}:{:02}", h, m);
    }
}

fn read() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    String::from(s.trim())
}

const INF: i32 = 51;

// s: 起きてる
// t: 寝てる
// now: 現在時刻
// 戻り値: 特定するのに必要なクエリ数, 聞く場所
fn calc(s: i32, t: i32, now: i32, up: i32, dp: &mut Map<(i32, i32, i32), (i32, i32)>) -> i32 {
    if t - s == 1 {
        dp.insert((s, t, now), (0, ALL));
    }
    if let Some(&v) = dp.get(&(s, t, now)) {
        return v.0;
    }
    let way = |v: i32| -> bool {
        let m = ALL / 2;
        for i in [-1, 0, 1].iter() {
            if s < v + i * m && v + i * m < t {
                return true;
            }
        }
        false
    };
    assert!(s < t);
    let mut ans = (INF, ALL + 1);
    let mut x = (now..ALL).filter(|x| way(*x)).collect::<Vec<_>>();
    shuffle(&mut x);
    if way(now + up) {
        x.insert(0, now + up);
    }
    for i in x {
        let mut val = 0;
        // 起きてる
        {
            let mut nt = t;
            let mut ns = s;
            for &j in [-1, 0, 1].iter() {
                let v = i + ALL / 2 * j;
                if ns < v && v < nt {
                    if j == 0 {
                        ns.chmax(v);
                    } else {
                        nt.chmin(v);
                    }
                }
            }
            if (s, t) == (ns, nt) {
                val = INF;
            } else {
                val.chmax(calc(ns, nt, i, up - 1, dp));
            }
        }
        // 寝てる
        {
            let mut nt = t;
            let mut ns = s;
            for &j in [-1, 0, 1].iter() {
                let v = i + ALL / 2 * j;
                if ns < v && v < nt {
                    if j == 0 {
                        nt.chmin(v);
                    } else {
                        ns.chmax(v);
                    }
                }
            }
            if (s, t) == (ns, nt) {
                val = INF;
            } else {
                val.chmax(calc(ns, nt, i, up - 1, dp));
            }
        }
        ans.chmin((val + 1, i));
        if ans.0 <= up {
            break;
        }
    }
    dp.insert((s, t, now), ans);
    ans.0
}

// ---------- begin chmin, chmax ----------
pub trait ChangeMinMax {
    fn chmin(&mut self, x: Self) -> bool;
    fn chmax(&mut self, x: Self) -> bool;
}

impl<T: PartialOrd> ChangeMinMax for T {
    fn chmin(&mut self, x: Self) -> bool {
        *self > x && {
            *self = x;
            true
        }
    }
    fn chmax(&mut self, x: Self) -> bool {
        *self < x && {
            *self = x;
            true
        }
    }
}
// ---------- end chmin, chmax ----------

fn rand_memory() -> usize {
    Box::into_raw(Box::new("I hope this is a random number")) as usize
}

fn rand() -> usize {
    static mut X: usize = 0;
    unsafe {
        if X == 0 {
            X = rand_memory();
        }
        X ^= X << 13;
        X ^= X >> 17;
        X ^= X << 5;
        X
    }
}

fn shuffle<T>(a: &mut [T]) {
    for i in 1..a.len() {
        let p = rand() % (i + 1);
        a.swap(i, p);
    }
}