#include <bits/stdc++.h>

namespace IO {
	template <class Stream>
	void write_int128(Stream& out, __int128 v) {
		if (v >= 10) {
			write_int128(out, v / 10);
		}
		out << (int) (v % 10);
	}

	template <class Stream>
	Stream& fmtbase(Stream& out, const char* format) {
		for (; *format; format++) {
			if (*format == '{' && *(format + 1) == '}') {
				throw std::invalid_argument("Error Number of Parameters!");
			}
			
			out << *format;
		}
		
		return out;
	}
	
	template <class Stream, class... Nxt>
	Stream& fmtbase(Stream& out, const char* format, const __int128& value, const Nxt&... nxt) {
		for (; *format; format++) {
			if (*format == '{' && *(format + 1) == '}') {
				write_int128(out, value);
				return fmtbase(out, format + 2, nxt...);
			} 
			
			out << *format;
		}
		
		throw std::invalid_argument("Error Number of Parameters!");
	}

	template <class Stream, class Fst, class... Nxt>
	Stream& fmtbase(Stream& out, const char* format, const Fst& value, const Nxt&... nxt) {
		for (; *format; format++) {
			if (*format == '{' && *(format + 1) == '}') {
				out << value;
				return fmtbase(out, format + 2, nxt...);
			} 
			
			out << *format;
		}
		
		throw std::invalid_argument("Error Number of Parameters!");
	}
	
	template <class... Ps>
	std::string to_string(const char* format, const Ps&... ps) {
		std::stringstream ss;
		fmtbase(ss, format, ps...);
		return ss.str();
	}

	template <class... Ps>
	std::ostream& fmtout(const char* format, const Ps&... ps) {
		return fmtbase(std::cout, format, ps...);
	}
	
	template <class... Ps>
	std::ostream& fmterr(const char* format, const Ps&... ps) {
		return fmtbase(std::cerr, format, ps...);
	}
	
	std::istream& allin() {
		return std::cin;
	}
	
	template <class Fst, class ... Nxt>
	std::istream& allin(Fst& fst, Nxt&... nxt) {
		std::cin >> fst;
		return allin(nxt...);
	}
	
	template <class Iter>
	std::istream& rangin(Iter begin, Iter end) {
		while (begin != end) {
			std::cin >> *begin;
			begin++;
		}
		
		return std::cin;
	}
	
	namespace Fast {
		bool sync = false;
		
		char buf[1 << 23];
		char *p1 = buf, *p2 = buf;
		
		void sync_with_ios(bool s) {
			sync = s;
		}
		
		inline char getchar() {
			if (sync) {
				return (char) std::cin.get();
			}
			else {
				return (p1 == p2) && (p2 = (p1 = buf) + fread(buf, 1, 1 << 22, stdin)), p1 == p2 ? EOF : *p1++;
			}
		}
		
		void read() { }
		
		template <class T, class... U>
		void read(T& x, U&... us) {
			x = 0;
			T pos = 1;
			
			char c = getchar();
			while (!isdigit(c)) {
				if (c == '-') {
					pos = -1;
				}
				
				c = getchar();
			}
			
			while (isdigit(c)) {
				x = 10 * x + c - '0';
				c = getchar();
			}
			
			x *= pos;
			read(us...);
		}
		
		template <class T>
		void write(const T& t) {
			if (t > 10) {
				write(t / 10);
			}
			
			std::cout << (int) (t % 10);
		}
	}
}

namespace Solve {
	using namespace IO;

	using ll = long long;
	using ul = unsigned long long;
	using db = double;
	using ld = long double;
	using ui = unsigned;
	using ib = __int128;
	using ub = __uint128_t;

	int const INF = std::numeric_limits<int>::max();
	int const NINF = std::numeric_limits<int>::min();
	ll const LINF = std::numeric_limits<ll>::max();
	ll const LNINF = std::numeric_limits<ll>::min();
	ld const EPS = 1e-8;

	std::mt19937_64 mt;

	ll rnd(ll l, ll r) {
		return std::uniform_int_distribution<ll>(l, r)(mt);
	}

	template <class T>
	inline int isz(const T& v) {
		return v.size();
	}

	template <class T>
	inline T& ckmx(T& a, T b) {
		return a < b ? (a = b) : a;
	}

	template <class T>
	inline T& ckmi(T& a, T b) {
		return b < a ? (a = b) : a;
	}

	int const N = 2e5 + 10;
	int const M = 8e5 + 10;

	struct SegMi {
		struct Node {
			int l, r;
			int v, t;
		};

		Node nd[4 * N + 1];

		void build(int x, int l, int r) {
			nd[x] = { l, r };
			if (l != r) {
				int mid = (l + r) >> 1;
				build(2 * x, l, mid);
				build(2 * x + 1, mid + 1, r);
			}
		}

		void tag(int x, int t) {
			ckmx(nd[x].t, t);
			ckmx(nd[x].v, t);
		}

		void pushdown(int x) {
			if (nd[x].t) {
				tag(2 * x, nd[x].t);
				tag(2 * x + 1, nd[x].t);
				nd[x].t = 0;
			}
		}

		void pushup(int x) {
			nd[x].v = std::min(nd[2 * x].v, nd[2 * x + 1].v);
		}

		void modify(int x, int l, int r, int t) {
			if (nd[x].r < l || nd[x].l > r) {
				return;
			}
			else if (nd[x].l >= l && nd[x].r <= r) {
				tag(x, t);
			}
			else {
				pushdown(x);
				modify(2 * x, l, r, t);
				modify(2 * x + 1, l, r, t);
				pushup(x);
			}
		}

		int find(int x, int v) {
			if (nd[x].v > v) {
				return nd[x].r + 1;
			}
			else if (nd[x].l == nd[x].r) {
				return nd[x].l;
			}
			else {
				pushdown(x);
				int mid = (nd[x].l + nd[x].r) >> 1;
				int t = find(2 * x, v);
				if (t == mid + 1) {
					return find(2 * x + 1, v);
				}
				else {
					return t;
				}
			}
		}
	};

	struct SegMx {
		struct Node {
			int l, r;
			int v, t;
		};

		Node nd[4 * N + 1];

		void build(int x, int l, int r) {
			nd[x] = { l, r, INF, INF };
			if (l != r) {
				int mid = (l + r) >> 1;
				build(2 * x, l, mid);
				build(2 * x + 1, mid + 1, r);
			}
		}

		void tag(int x, int t) {
			ckmi(nd[x].t, t);
			ckmi(nd[x].v, t);
		}

		void pushdown(int x) {
			if (nd[x].t != INF) {
				tag(2 * x, nd[x].t);
				tag(2 * x + 1, nd[x].t);
				nd[x].t = INF;
			}
		}

		void pushup(int x) {
			nd[x].v = std::max(nd[2 * x].v, nd[2 * x + 1].v);
		}

		void modify(int x, int l, int r, int t) {
			if (nd[x].r < l || nd[x].l > r) {
				return;
			}
			else if (nd[x].l >= l && nd[x].r <= r) {
				tag(x, t);
			}
			else {
				pushdown(x);
				modify(2 * x, l, r, t);
				modify(2 * x + 1, l, r, t);
				pushup(x);
			}
		}

		int find(int x, int v) {
			if (nd[x].v < v) {
				return nd[x].r + 1;
			}
			else if (nd[x].l == nd[x].r) {
				return nd[x].l;
			}
			else {
				pushdown(x);
				int mid = (nd[x].l + nd[x].r) >> 1;
				int t = find(2 * x, v);
				if (t == mid + 1) {
					return find(2 * x + 1, v);
				}
				else {
					return t;
				}
			}
		}
	};

	struct Val {
		int l, r, v;
	};

	struct Edge {
		int x, y;
	};

	int n, m;
	Edge eds[M + 1];
	std::vector<int> gr[N + 1];
	int ind[N + 1];
	int ans[N + 1];
	int w[N + 1];
	int ord[N + 1];
	int mi[N + 1];
	int tmi[N + 1];
	int mx[N + 1];
	int tmx[N + 1];
	std::vector<Val> vmi[N + 1];
	std::vector<Val> vmx[N + 1];
	SegMi smi;
	SegMx smx;

	void topsort() {
		std::queue<int> que;
		for (int i = 1; i <= n; i++) {
			for (auto& to : gr[i]) {
				ind[to]++;
			}
		}
		for (int i = 1; i <= n; i++) {
			if (!ind[i]) {
				que.push(i);
			}
		}

		for (int i = 1; i <= n; i++) {
			auto t = que.front();
			que.pop();

			ord[i] = t;
			w[t] = i;
			for (auto& to : gr[t]) {
				ind[to]--;
				if (!ind[to]) {
					que.push(to);
				}
			}
		}
	}

	void main() {
		std::cin >> n >> m;
		for (int i = 1; i <= m; i++) {
			int u, v;
			std::cin >> u >> v;
			gr[u].push_back(v);
			eds[i] = { u, v };
		}

		topsort();
		for (int i = 1; i <= n; i++) {
			mi[i] = INF;
			mx[i] = 0;
		}

		for (int i = 1; i <= m; i++) {
			int u = eds[i].x;
			int v = eds[i].y;

			vmi[w[u]].push_back({ tmi[w[u]], i - 1, mi[w[u]] });
			ckmi(mi[w[u]], w[v]);
			tmi[w[u]] = i;

			vmx[w[v]].push_back({ tmx[w[v]], i - 1, mx[w[v]] });
			ckmx(mx[w[v]], w[u]);
			tmx[w[v]] = i;
		}

		for (int i = 1; i <= n; i++) {
			vmi[i].push_back({ tmi[i], m, mi[i] });
			vmx[i].push_back({ tmx[i], m, mx[i] });
		}

		// for (int i = 1; i <= n; i++) {
		// 	fmterr("{} ", ord[i]);
		// }
		// fmterr("\n");

		// for (int i = 1; i <= n; i++) {
		// 	for (auto& v : vmi[i]) {
		// 		fmterr("({} {} {}) ", v.l, v.r, v.v);
		// 	}
		// 	fmterr("\n");
		// }

		smi.build(1, 0, m);
		smx.build(1, 0, m);
		for (int i = 1; i <= n; i++) {
			ckmx(ans[ord[i]], smi.find(1, i));
			for (auto& v : vmi[i]) {
				smi.modify(1, v.l, v.r, v.v);
			}
		}
		for (int i = n; i >= 1; i--) {
			ckmx(ans[ord[i]], smx.find(1, i));
			for (auto& v : vmx[i]) {
				smx.modify(1, v.l, v.r, v.v);
			}
		}

		for (int i = 1; i <= n; i++) {
			fmtout("{} ", ans[i] > m ? -1 : ans[i]);
		}
	}

	void init() {
		
	}

	void clear() {

	}
}

signed main() {
#ifndef ONLINE_JUDGE
	auto input_file = freopen("d.in", "r", stdin);
	auto output_file = freopen("d.out", "w", stdout);
#endif

	auto seed = std::chrono::high_resolution_clock::now().time_since_epoch().count();

	IO::fmterr("seed: {}\n", seed);
	Solve::mt.seed(seed);

	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);

	int t = 1;
	// std::cin >> t;

	Solve::init();

	for (int id = 1; id <= t; id++) {
		Solve::main();
		Solve::clear();
	}

#ifndef ONLINE_JUDGE
	std::cout.flush();
	fclose(input_file);
	fclose(output_file);
#endif

	return 0;
}