#include <unordered_map>
#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
#include <stack>
#include <cassert>
using namespace std;
void dfs(const unordered_multimap<int, int>& graph, vector<int>& color, int node, const function<void(int)> post_order_func)
{
stack<int> nodes;
nodes.push(node);
while (!nodes.empty())
{
int from = nodes.top();
if (color[from] == 1)
{
color[from] = 2;
post_order_func(from);
nodes.pop();
continue;
}
else if (color[from] == 2)
{
nodes.pop();
continue;
}
color[from] = 1;
auto range = graph.equal_range(from);
for (auto it = range.first; it != range.second; ++it)
{
const auto& to = it->second;
if (color[to] == 0)
{
nodes.push(to);
}
else if (color[to] == 1)
{
throw runtime_error("Graph has cycle. Topological sort impossible.");
}
}
}
}
void topological_sort(int n, const unordered_multimap<int, int>& graph, vector<int>& result)
{
result.resize(n);
vector<int> color(n, 0);
int j = 0;
auto post_order_func = [&result, &j](int node) {
result[j++] = node;
};
for (int i = 0; i < n; ++i)
{
if (color[i] == 0)
{
dfs(graph, color, i, post_order_func);
}
}
reverse(begin(result), end(result));
}
int main()
{
int n, m;
cin >> n >> m;
unordered_multimap<int, int> graph;
vector<int> result(n, -1);
for (int i = 0; i < m; ++i)
{
int from, to;
cin >> from >> to;
--from;
--to;
graph.emplace(from, to);
}
try
{
topological_sort(n, graph, result);
}
catch (...)
{
cout << -1 << endl;
return 0;
}
for (int i = 0; i < result.size(); ++i)
{
cout << result[i] + 1 << (i + 1 == result.size() ? '\n' : ' ');
}
}
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