#!/usr/bin/python3

# We represent a graph with an adjacency list
#
Adj = []                        # adjacency list, indexed by node id
V = []                          # vertex names, indexed by node id
V_idx = {}                      # name --> node id

def print_graph():
    global Adj, V, V_idx
    print('V:')
    for i in range(len(V)):     # iteration over V
        print(i,V[i])
    print('E:')
    for v in range(len(V)):     # iteration over E
        for w in Adj[v]:
            print(v,w,' ( ',V[v],'-->',V[w],')')

def read_graph(f):
    global Adj, V, V_idx
    # line format:
    # u [v1 v2 v3 ...]
    # meaning: u-->v1; u-->v2; u-->v3; ...
    for line in f:
        u = None
        for v_name in line.strip().split():
            if v_name in V_idx:
                v = V_idx[v_name]
            else:
                v = len(V)
                V_idx[v_name] = v
                V.append(v_name)
                Adj.append([])
            if u == None:
                u = v
            else:
                Adj[u].append(v)

def bfs(s):
    # Breadth-first search starting from vertex s
    # return D: distance vector, P: previous vector
    global Adj, V
    n = len(V)
    D = [None]*n
    P = [None]*n
    # start from s
    D[s] = 0
    # we use a queue to schedule node visitations
    Q = [s]
    while len(Q) > 0:
        v = Q[0]
        del Q[0]                # dequeue
        for w in Adj[v]:        # iterate over v's neighbors
            if D[w] == None:
                D[w] = D[v] + 1
                P[w] = v
                Q.append(w)     # enqueue
    return D, P

def dfs():
    # Depth-first search
    # return P: previous vector,
    #        D: discovery times, F: finish times
    n = len(V)
    P = [None]*n
    D = [None]*n
    F = [None]*n
    t = 0                       # time ticker
    # we use a stack to schedule node visitations
    S = []
    for i in range(n):          # for every vertex
        if D[i] == None:        # not yet discovered
            S.append(i)         # we start a DFS
            P[i] = None
            while len(S) > 0:
                v = S[-1]
                if D[v] == None:
                    # we just discovered v
                    D[v] = t
                    t += 1
                    for w in Adj[v]:
                        S.append(w)
                        P[w] = v
                else:
                    if F[v] == None:
                        F[v] = t
                        t += 1
                    del S[-1]
    return P, D, F

import sys
read_graph(sys.stdin)
# print_graph()
P, D, F = dfs()

for i in range(len(V)):
    if P[i] == None:
        print(V[i], 'itself', D[i], F[i])
    else:
        print(V[i], V[P[i]], D[i], F[i])