n, m = map(int, input().split())

size = 0
map_ = {}
G = []


def _pg():
    global G
    _l = len(str(size - 1))
    _s = " " * _l + " | " + " ".join(map(lambda i: str(ri_(i)), range(size)))
    print(_s)
    print("-" * len(_s))
    for i, row in enumerate(G):
        print(ri_(i), "|", " ".join(map(str, row)))
    print(map_)


def addToMap(key):
    global map_, G, size
    if key in map_:
        return
    size += 1
    idxs = map_.values() if len(map_) else (-1,)
    map_[key] = max(idxs) + 1
    for i in range(size - 1):
        G[i].append(0)
    G.append([0] * size)


i_ = lambda key: map_[key]
ri_ = lambda val: tuple(map_.keys())[tuple(map_.values()).index(val)]

for _ in range(m):
    a, b = map(int, input().split())
    addToMap(a)
    addToMap(b)
    G[i_(b)][i_(a)] = 1


def validateTest(a, b, c):
    _allZeros = lambda key: all(val == 0 for val in G[i_(key)])
    _getBetter = lambda key: [ri_(i) for i, v in enumerate(G[i_(key)]) if v == 1]
    if not _allZeros(a):
        return False
    allowedBetter = [a]
    for betterFilm in _getBetter(b):
        if betterFilm not in allowedBetter:
            return False
    allowedBetter.append(b)
    for betterFilm in _getBetter(c):
        if betterFilm not in allowedBetter:
            return False
    return True


_pg()

for _ in range(n):
    a, b, c = map(int, input().split())
    print('honest' if validateTest(a, b, c) else 'liar')