#!/usr/bin/env python3
from collections import deque

n = int(input())
m = n
if m > n:
    print("impossible")
else:
    Adj = [[] for _ in range(n)]
    E = {}
    Edges = []
    for _ in range(m):
        u, v, h = [int(x) for x in input().split()]
        u -= 1
        v -= 1
        E[(u, v)] = h
        E[(v, u)] = h
        Edges.append((u, v))
        Adj[u].append(v)
        Adj[v].append(u)

    marked = [-1] * n
    visited = [False] * n

    def find_cycle(s, prev=-1, nr=0):
        if marked[s] >= 0:
            return s
        marked[s] = nr
        for v in Adj[s]:
            if v == prev:
                continue
            res = find_cycle(v, s, nr + 1)
            if res >= 0:
                return res
        marked[s] = -1
        return -1

    start_node = find_cycle(1)
    cycle_len = max(marked) + 1 - marked[start_node]
    cycle = [-1] * cycle_len
    for node, ic in enumerate(marked):
        if ic >= marked[start_node]:
            cycle[ic - marked[start_node]] = node

    # orient edges
    visited = [False] * n
    q = deque()
    D = {}

    for i, u in enumerate(cycle):
        v = cycle[(i + 1) % len(cycle)]
        D[(u, v)] = (u, v)
        D[(v, u)] = (u, v)
        q.append(u)
        visited[u] = True

    while len(q) > 0:
        u = q.popleft()
        for v in Adj[u]:
            if not visited[v]:
                D[(u, v)] = (v, u)
                D[(v, u)] = (v, u)
                visited[v] = True
                q.append(v)

    def check(D):
        H = [set() for _ in range(n)]
        for u, v in D:
            if u < v:
                if D[(u, v)] == (u, v):
                    if 1 in H[u] or E[(u, v)] in H[v]:
                        return False
                    H[u].add(1)
                    H[v].add(E[(u, v)])
                else:
                    if 1 in H[v] or E[(u, v)] in H[u]:
                        return False
                    H[u].add(E[(u, v)])
                    H[v].add(1)
        return True

    if not check(D):
        # reverse cycle
        for i, u in enumerate(cycle):
            v = cycle[(i + 1) % len(cycle)]
            D[(u, v)] = (v, u)
            D[(v, u)] = (v, u)

    if check(D):
        for u, v in Edges:
            if D[(u, v)] == (u, v):
                print(u + 1)
            else:
                print(v + 1)
    else:
        print("impossible")