class partofspeech:

    nounlist = ("gimly", "gold", "tunnel")
    adverblist = ("now", "glumly")

    def __init__(self, token):
        self.noun = False
        self.verb = False
        self.adverb = False
        self.conj = False
        self.type = 0
        self.token = token
        if token == "counted":
            self.verb = True
        elif token == "and":
            self.conj = True
        elif token in self.nounlist:
            self.noun = True
            for i in range(len(self.nounlist)):
                if token == self.nounlist[i]:
                    self.type = i
        elif token in self.adverblist:
            self.adverb = True
            for i in range(len(self.adverblist)):
                if token == self.adverblist[1]:
                    self.type = i
class tokenizer:
    def __init__(self, s):
        self.i = 0
        self.tokens = s.split()

    def peek(self):
        if self.i < len(self.tokens):
            return partofspeech(self.tokens[self.i])
        else:
            return None

    def next(self):
        result = self.peek()
        self.i = self.i + 1
        return result

def sentence(tokens):
    return nouns(tokens) and predicate(tokens)

def predicate(tokens):
    if nouns(tokens):
        if verbs(tokens) and nouns(tokens) and adverbs(tokens):
            if tokens.peek() == None:
                return True
            else:
                return places(tokens) and tokens.peek() == None
        else:
            return False
    else:
        if verbs(tokens):
            nouns(tokens)
            return adverbs(tokens) and tokens.peek() == None
        else:
            return False

def verbs(tokens):
    if tokens.peek() == None or not tokens.peek().verb:
        return False
    tokens.next()
    return True
                
def nouns(tokens):
    if tokens.peek() == None or not tokens.peek().noun:
        return False
    tokens.next()
    conj = tokens.peek()
    while conj != None and conj.conj:
        tokens.next() #skip over peeked conj
        if not tokens.next().noun:
            return False
        conj = tokens.peek()
    return True

def places(tokens):
    place = tokens.next()
    if (place == None) or (not place.noun) or (place.type != 2):
        return False
    conj = tokens.peek()
    while conj != None and conj.conj:
        tokens.next() #skip over peeked conj
        place = tokens.next()
        if (place == None) or (not place.noun) or (place.type != 2):
            return False
        conj = tokens.peek()
    return True

def adverbs(tokens):
    t = -1
    while True:
        adverb = tokens.peek()
        if adverb == None or not adverb.adverb:
            return True
        adverb = tokens.next()
        if adverb.type < t:
            return False
        t = adverb.type

n = int(input())
for _ in range(n):
    line = input()
    if sentence(tokenizer(line)):
        print("accept")
    else:
        print("reject")