import java.io.*; import java.nio.file.Files; import java.nio.file.Paths; import java.util.*;

public class A2_Uprooted {

public static Scanner sc;
public static PrintWriter out;

public static void main(String[] args) throws IOException {

    boolean fileInOut = !A2_Uprooted.class.getPackage().getName().isEmpty();
    sc = new Scanner(new BufferedReader(new InputStreamReader(fileInOut ? A2_Uprooted.class.getResourceAsStream("in.txt") : System.in)));
    out = new PrintWriter(new BufferedOutputStream(fileInOut ? new FileOutputStream("out.txt") : System.out), true);

    int totalTC = fileInOut ? sc.nextInt() : sc.nextInt();
    for (int t = 1; t <= totalTC; t++) {
        int N = sc.nextInt();
        int M = sc.nextInt();
        int S = sc.nextInt();

        Map<Integer, List<Edge>> adjList = new HashMap<>();

        for (int index = 1; index <= M; index++) {

            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            Edge e = new Edge(a, b, c, index);

            List<Edge> listA = adjList.getOrDefault(a, new ArrayList<>());
            listA.add(e);
            adjList.put(a, listA);

            List<Edge> listB = adjList.getOrDefault(b, new ArrayList<>());
            listB.add(e);
            adjList.put(b, listB);
        }

        int[][] sequences = new int[S][N - 1];
        for (int i = 0; i < S; i++) {
            for (int j = 0; j < N - 1; j++) {
                sequences[i][j] = sc.nextInt();
            }
        }

        new A2_Uprooted().solution(N, M, S, adjList, sequences);
    }

    if (fileInOut) {
        String[] ansFileText = Files.readAllLines(Paths.get(A2_Uprooted.class.getResource("ans.txt").getFile())).toArray(new String[0]);
        String[] outFileText = Files.readAllLines(Paths.get("out.txt")).toArray(new String[0]);
        if (Arrays.equals(ansFileText, outFileText)) System.out.println("ALL TEST CASES PASSED!");
        else for (int i = 0; i < ansFileText.length; i++)
            if (!ansFileText[i].equals(outFileText[i])) System.out.println("Test Case #" + (i + 1) + ": Failed");
    }
}

private boolean isImpossible(int n, int m, int s, Map<Integer, List<Edge>> adjList, int[][] sequences) {

    for (int row = 0; row < s; row++) {

        Map<Integer, Boolean> nodeMap = new HashMap<>();
        nodeMap.put(1, true);

        for (int column = 0; column < n - 1; column++) {

            int node = sequences[row][column];
            if (nodeMap.getOrDefault(node, false)) continue;

            List<Edge> edgeList = adjList.getOrDefault(node, new ArrayList<>());
            Edge maxEdge = null;
            for (Edge edge : edgeList) {
                int neighbour = edge.getNeighbour(node);
                if (nodeMap.getOrDefault(neighbour, false)) {
                    if (maxEdge == null || maxEdge.c < edge.c) {
                        maxEdge = edge;
                    }
                }
            }
            if (maxEdge != null) {
                nodeMap.put(node, true);
                //edgeSet.add(maxEdge);
            } else {
                out.println("IMPOSSIBLE");
                return true;
            }
        }
    }

    return false;
}

public void solution(int n, int m, int s, Map<Integer, List<Edge>> adjList, int[][] sequences) {

    if (isImpossible(n, m, s, adjList, sequences)) {
        return;
    }

    //Now it has a solution must

    Set<Edge> edgeSetGlobal = new HashSet<>();

    for (int row = 0; row < s; row++) {

        Map<Integer, Boolean> nodeMap = new HashMap<>();
        nodeMap.put(1, true);

        Map<Integer, List<Edge>> nodeListMap = new HashMap<>();

        for (int column = 0; column < n - 1; column++) {

            int node = sequences[row][column];
            if (nodeMap.getOrDefault(node, false)) continue;

            List<Edge> edgeList = adjList.getOrDefault(node, new ArrayList<>());
            List<Edge> tempList = new ArrayList<>();
            for (Edge edge : edgeList) {
                int neighbour = edge.getNeighbour(node);
                if (nodeMap.getOrDefault(neighbour, false)) {
                    nodeMap.put(node, true);
                    tempList.add(edge);
                }
            }

            if (tempList.isEmpty()) {
                out.println("IMPOSSIBLE");
                return;
            }

            List<Edge> nodeList = nodeListMap.getOrDefault(node, new ArrayList<>());
        }

        var intersection = edgeSetGlobal.retainAll(edgeSet);
        //edgeSetGlobal.addAll(edgeSet);
        System.out.println();
    }

    System.out.println();

    Edge[] arr = new Edge[edgeSetGlobal.size()];
    edgeSetGlobal.toArray(arr);

    out.println(arr.length);
    for(int i = 0; i < arr.length - 1; ++i) {
        //out.print(edgeSet.get(i).index + " ");
        out.println(arr[i].desc());
    }
    out.println(arr[arr.length - 1].desc());
}

}

class Edge { int a, b, c, index;

Edge(int a, int b, int c, int index) {
    this.a = a;
    this.b = b;
    this.c = c;
    this.index = index;
}

int getNeighbour(int one) {
    if (a == one) return b;
    return a;
}

String desc() {
    return "(" + a + "," + b + "), weight: " + c + ", " + "Index = " + index;
}

}