import java.util.*;
import java.io.*;
import java.text.*;

public class NickyEnMark{
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            String[] line = reader.readLine().split(" ");
            int n = Integer.parseInt(line[0]);
            
            HashMap<Integer, HashMap<Integer, Integer>> graph = new HashMap<>();
            ArrayList<Integer> orderU = new ArrayList<>();
            ArrayList<Integer> orderV = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                line = reader.readLine().split(" ");
                int u = Integer.parseInt(line[0]);
                int v = Integer.parseInt(line[1]);
                int h = Integer.parseInt(line[2]);
                addEdge(graph, u, v, h);
                addEdge(graph, v, u, h);
                orderU.add(u);
                orderV.add(v);
            }

            ArrayList<Integer> cycle = findCycle(graph);
            Set<Integer> cycleSet = new HashSet<>();
            for (int c : cycle) {
                cycleSet.add(c);
            }
            HashMap<Integer,HashSet<Integer>> highNumbersPerNode = new HashMap<>();
            HashMap<Integer, Integer> answer = new HashMap<>();
            for (int node : graph.keySet()) {
                highNumbersPerNode.put(node, new HashSet<Integer>());
            }

            // First, assign the high numbers outgoing from the cycle
            Queue<Integer> q = new LinkedList<Integer>();
            for (int c : cycle) {
                q.add(c);
            }

            Set<Integer> visited = new HashSet<>();

            while (!q.isEmpty()) {
                int s = q.remove();
                for (int t : graph.get(s).keySet()) {
                    if (cycleSet.contains(t)) {
                        continue;
                    }

                    if (visited.contains(t)) {
                        continue;
                    }

                    visited.add(t);

                    int hn = graph.get(s).get(t);

                    if (highNumbersPerNode.get(s).contains(hn)) {
                        System.out.println("Impossible");
                        return;
                    }

                    highNumbersPerNode.get(s).add(hn);
                    answer.put(t, s);
                    q.add(t);
                }
            }

            HashMap<Integer,HashSet<Integer>> highNumbersPerNodeClone = new HashMap<>();
            for (int node : highNumbersPerNode.keySet()) {
                highNumbersPerNodeClone.put(node, (HashSet<Integer>)highNumbersPerNode.get(node).clone());
            }
            HashMap<Integer, Integer> answerClone = (HashMap<Integer, Integer>)answer.clone();
            boolean possibleOneWay = true;

            for (int i = 0; i < cycle.size(); i++) {
                int s = cycle.get(i);
                int t = cycle.get(0);
                if (i != cycle.size() - 1) {
                    t = cycle.get(i + 1);
                }

                int hn = graph.get(s).get(t);

                if (highNumbersPerNodeClone.get(s).contains(hn)) {
                    possibleOneWay = false;
                    break;
                }

                highNumbersPerNodeClone.get(s).add(hn);
                answerClone.put(t, s);
            }

            if (possibleOneWay) {
                for (int i = 0; i < orderU.size(); i++) {
                    int u = orderU.get(i);
                    int v = orderV.get(i);
                    if (answerClone.get(u) == v) {
                        System.out.println(u);
                    } else {
                        System.out.println(v);
                    }
                }
                return;
            }

            for (int i = 0; i < cycle.size(); i++) {
                int s = cycle.get(i);
                int t = cycle.get(cycle.size() - 1);
                if (i != 0) {
                    t = cycle.get(i - 1);
                }

                int hn = graph.get(s).get(t);

                if (highNumbersPerNode.get(s).contains(hn)) {
                    System.out.println("Impossible");
                    return;
                }

                highNumbersPerNode.get(s).add(hn);
                answer.put(t, s);
            }

            for (int i = 0; i < orderU.size(); i++) {
                    int u = orderU.get(i);
                    int v = orderV.get(i);
                    if (answer.get(u) == v) {
                        System.out.println(u);
                    } else {
                        System.out.println(v);
                    }
                }
        }
    }

    static void addEdge(HashMap<Integer, HashMap<Integer, Integer>> graph, int source, int target, int maxHouse) {
        if (!graph.containsKey(source)) {
            graph.put(source, new HashMap<Integer,Integer>());
        }

        graph.get(source).put(target, maxHouse);
    }

    static ArrayList<Integer> findCycle(HashMap<Integer, HashMap<Integer, Integer>> graph) {
        HashMap<Integer, Integer> visited = new HashMap<>();
        for (int n : graph.keySet()) {
            visited.put(n, 0);
        }
        HashMap<Integer, Integer> parents = new HashMap<>();
        ArrayList<Integer> cycle = new ArrayList<>();
        dfs(graph, 1, -1, visited, parents, cycle);

        return cycle;
    }

    static void dfs(HashMap<Integer, HashMap<Integer, Integer>> graph, int u, int p, HashMap<Integer, Integer> visited, HashMap<Integer, Integer> parents, ArrayList<Integer> cycle) {
        if (visited.get(u) == 2) {
            return;
        }
        if (visited.get(u) == 1) {
            int cur = p;
            cycle.add(cur);
            while (cur != u) {
                cur = parents.get(cur);
                cycle.add(cur);
            }

            return;
        }

        parents.put(u, p);
        visited.put(u, 1);
        for (int v : graph.get(u).keySet()) {
            if (v == parents.get(u)) {
                continue;
            }

            dfs(graph, v, u, visited, parents, cycle);
        }

        visited.put(u, 2);
    }
}