import heapq
from collections import defaultdict
from typing import List

def compilation_order(modules: List[str], dependencies: List[List[str]]) -> List[str]:
    graph = defaultdict(list)
    indeg = {m: 0 for m in modules}
    for a, b in dependencies:
        graph[b].append(a)
        indeg[a] = indeg.get(a, 0) + 1
        indeg.setdefault(b, indeg.get(b, 0))
    heap = [m for m, d in indeg.items() if d == 0]
    heapq.heapify(heap)
    out = []
    while heap:
        m = heapq.heappop(heap)
        out.append(m)
        for nxt in graph[m]:
            indeg[nxt] -= 1
            if indeg[nxt] == 0:
                heapq.heappush(heap, nxt)
    if len(out) != len(indeg):
        return ["IMPOSSIBLE"]
    return out

import java.util.*;

class Solution {
    public String[] compilationOrder(String[] modules, String[][] dependencies) {
        Map<String, List<String>> g = new HashMap<>();
        Map<String, Integer> indeg = new HashMap<>();
        for (String m : modules) indeg.put(m, 0);
        for (String[] d : dependencies) {
            g.computeIfAbsent(d[1], k -> new ArrayList<>()).add(d[0]);
            indeg.merge(d[0], 1, Integer::sum);
        }
        PriorityQueue<String> pq = new PriorityQueue<>();
        for (var e : indeg.entrySet()) if (e.getValue() == 0) pq.add(e.getKey());
        List<String> out = new ArrayList<>();
        while (!pq.isEmpty()) {
            String m = pq.poll();
            out.add(m);
            for (String nxt : g.getOrDefault(m, List.of())) {
                indeg.merge(nxt, -1, Integer::sum);
                if (indeg.get(nxt) == 0) pq.add(nxt);
            }
        }
        if (out.size() != indeg.size()) return new String[]{"IMPOSSIBLE"};
        return out.toArray(new String[0]);
    }
}

#include <bits/stdc++.h>
using namespace std;

class Solution {
public:
    vector<string> compilationOrder(vector<string>& modules, vector<vector<string>>& dependencies) {
        unordered_map<string, vector<string>> g;
        unordered_map<string, int> indeg;
        for (auto& m : modules) indeg[m] = 0;
        for (auto& d : dependencies) {
            g[d[1]].push_back(d[0]);
            indeg[d[0]]++;
        }
        priority_queue<string, vector<string>, greater<string>> pq;
        for (auto& [k, v] : indeg) if (v == 0) pq.push(k);
        vector<string> out;
        while (!pq.empty()) {
            string m = pq.top(); pq.pop();
            out.push_back(m);
            for (auto& nxt : g[m]) if (--indeg[nxt] == 0) pq.push(nxt);
        }
        if ((int)out.size() != (int)indeg.size()) return {"IMPOSSIBLE"};
        return out;
    }
};