#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;

#define ALL(c) c.begin(), c.end()
#define IN(l, v, r) (l <= v && v < r)
template <class T> void UNIQUE(T &v) { v.erase(unique(ALL(v)), v.end()); }
// debug==
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"

struct range {
  struct Iter {
    int v, step;
    Iter &operator++() {
      v += step;
      return *this;
    }
    bool operator!=(Iter &itr) { return v < itr.v; }
    int &operator*() { return v; }
  };
  Iter i, n;
  range(int i, int n, int step) : i({i, step}), n({n, step}) {}
  range(int i, int n) : range(i, n, 1) {}
  range(int n) : range(0, n) {}
  Iter &begin() { return i; }
  Iter &end() { return n; }
};
struct rrange {
  struct Iter {
    int v, step;
    Iter &operator++() {
      v -= step;
      return *this;
    }
    bool operator!=(Iter &itr) { return v > itr.v; }
    int &operator*() { return v; }
  };
  Iter i, n;
  rrange(int i, int n, int step) : i({i - 1, step}), n({n - 1, step}) {}
  rrange(int i, int n) : rrange(i, n, 1) {}
  rrange(int n) : rrange(0, n) {}
  Iter &begin() { return n; }
  Iter &end() { return i; }
};

// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
  return is >> p.first >> p.second;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
  return is >> get<0>(t);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
  return is >> get<0>(t) >> get<1>(t);
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
  return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
  return is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
  for (int i : range(as.size()))
    is >> as[i];
  return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
  for (auto a : ss) {
    if (a != ss.begin())
      os << " ";
    os << a;
  }
  return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
  return os << p.first << " " << p.second;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
  bool isF = true;
  for (auto &p : m) {
    if (!isF)
      os << endl;
    os << p;
    isF = false;
  }
  return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
  return os << get<0>(t);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
  return os << get<0>(t) << " " << get<1>(t);
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
  return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
  return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " "
            << get<3>(t);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
  for (int i : range(as.size())) {
    if (i != 0)
      os << " ";
    os << as[i];
  }
  return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
  for (int i : range(as.size())) {
    if (i != 0)
      os << endl;
    os << as[i];
  }
  return os;
}

// values
template <typename T> inline T INF() { assert(false); };
template <> inline int INF<int>() { return 1 << 28; };
template <> inline ll INF<ll>() { return 1LL << 60; };
template <> inline double INF<double>() { return 1e16; };
template <> inline long double INF<long double>() { return 1e16; };

template <class T> inline T EPS() { assert(false); };
template <> inline int EPS<int>() { return 1; };
template <> inline ll EPS<ll>() { return 1LL; };
template <> inline double EPS<double>() { return 1e-12; };
template <> inline long double EPS<long double>() { return 1e-12; };

// min{2^r | n < 2^r}
template <typename T> inline T upper_pow2(T n) {
  T res = 1;
  while (res < n)
    res <<= 1;
  return res;
}
// max{d | 2^d  <= n}
template <typename T> inline T msb(T n) {
  int d = 62;
  while ((1LL << d) > n)
    d--;
  return d;
}

template <typename T, typename U> T pmod(T v, U M) { return (v % M + M) % M; }



ll mod = 998244353;
struct mint{
    ll x,mod;
    mint(ll x,ll mod = 998244353):x((x%mod+mod)%mod),mod(mod){}
    mint():mint(0){}
    mint operator+=(const mint& a){ if((x+=a.x)>=mod) x-=mod; return *this;}
    mint operator-=(const mint& a){ if((x+=mod-a.x)>=mod) x-=mod; return *this;}
    mint operator*=(const mint& a){ (x*=a.x)%=mod; return *this;}
    mint operator+(const mint& a)const{ return mint(*this) += a;}
    mint operator-(const mint& a)const{ return mint(*this) -= a;}
    bool operator==(const mint& a)const{ return x == a.x;}
    mint operator*(const mint& a)const{ return mint(*this) *= a;}

    // O(logN)
    mint pow(ll N){
        mint r(1),x = *this;
        while(N){
            if(N&1) r *= x;
            N /= 2;
            x *= x;
        }
        return r;
    }
    mint minv(){return pow(mod-2);}
};
istream& operator >> (istream& is,mint& p){return is>>p.x;}
ostream& operator << (ostream& os,mint m){os << m.x;return os;}


vector<vector<int>> es, reves;

void run() {
  int N, M;cin >> N >> M;
  es = vector<vector<int>>(N);
  reves = vector<vector<int>>(N);
  for(int i:range(N-1+M)){
    int v,w;cin >> v >> w; v--;w--;
    es[v].push_back(w);
    reves[w].push_back(v);
  }

  int r = -1;
  for(int i:range(N)){
    if(reves[i].size() == 0) r = i; 
  }

  vector<int> Mds(N,-1);
  vector<int> uns(N);
  for(int i:range(N)){
    uns[i] = es[i].size();
  }

  queue<int> que;
  for(int i:range(N)){
    if(uns[i] == 0){
      que.push(i);
    }
  }
  vector<int> ps(N);
  while(!que.empty()){
    int v = que.front();que.pop();
    int Mv = 0;
    for(int j:es[v]){
      Mv = max(Mv,Mds[j]+1);
      if(ps[j] == 0) ps[j] = v + 1;
    }
    Mds[v] = Mv;
    for(int j:reves[v]){
      uns[j]--;
      if(uns[j] == 0){
        que.push(j);
      }
    }
  }
  // cerr << Mds << endl;
  for(int i:range(N)){
    cout << ps[i] << '\n';
  }
  cout<< flush;
}

int main() {
  cout << fixed << setprecision(20);
  cin.tie(0);
  ios::sync_with_stdio(false);
  run();
  return 0;
}

Measured memory_bytes: 12928