Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter


import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline

INF = 1 << 60


def read_int():
    return int(readline())


def read_int_n():
    return list(map(int, readline().split()))


def read_float():
    return float(readline())


def read_float_n():
    return list(map(float, readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def ep(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.perf_counter()
        ret = f(*args, **kwargs)
        e = time.perf_counter()

        ep(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, UV):
    g = defaultdict(list)
    fin = Counter()
    for u, v in UV:
        g[u].append(v)
        fin[v] += 1

    r = -1
    for v in range(1, N+1):
        n = fin[v]
        if n == 0:
            r = v
            break

    a = defaultdict(lambda: None)
    q = deque([r])
    a[r] = 0
    while q:
        u = q.popleft()
        for v in g[u]
            if a[v] != u:
                a[v] = u
                q.append(v)

    ans = [a[i] for i in range(1, N+1)]
    return ans


def main():
    N, M = read_int_n()
    UV = [read_int_n() for _ in range(N-1+M)]
    print(*slv(N, M, UV), sep='\n')


if __name__ == '__main__':
    main()


Fixed submission:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, AB):

    in_n = [0] * (N+1)
    g = defaultdict(list)
    rg = defaultdict(list)
    for a, b in AB:
        in_n[b] += 1
        g[a].append(b)
        rg[b].append(a)

    r = []
    for i, n in enumerate(in_n):
        if i != 0 and n == 0:
            r.append(i)

    sv = []
    while r:
        u = r.pop()
        sv.append(u)
        for v in g[u]:
            in_n[v] -= 1
            if in_n[v] == 0:
                r.append(v)

    svd = {}
    for i, v in enumerate(sv):
        svd[v] = i
    for i in range(1, N+1):
        mi = 0
        if len(rg[i]) == 0:
            print(0)
        else:
            for j in rg[i]:
                mi = max(mi, svd[j])
            print(sv[mi])
    return


def main():
    N, M = read_int_n()
    AB = [read_int_n() for _ in range(N+M-1)]
    slv(N, M, AB)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from fractions import Fraction
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations, accumulate
from operator import add, mul, sub, itemgetter, attrgetter


import sys
# sys.setrecursionlimit(10**6)
# readline = sys.stdin.buffer.readline
readline = sys.stdin.readline

INF = 1 << 60


def read_int():
    return int(readline())


def read_int_n():
    return list(map(int, readline().split()))


def read_float():
    return float(readline())


def read_float_n():
    return list(map(float, readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def ep(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.perf_counter()
        ret = f(*args, **kwargs)
        e = time.perf_counter()

        ep(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, UV):
    g = defaultdict(list)
    fin = Counter()
    for u, v in UV:
        g[u].append(v)
        fin[v] += 1

    r = -1
    for v in range(1, N+1):
        n = fin[v]
        if n == 0:
            r = v
            break

    a = defaultdict(lambda: None)
    q = deque([r])
    a[r] = 0
    while q:
        u = q.popleft()
        for v in g[u]:
            a[v] = u
            q.append(v)

    ans = [a[i] for i in range(1, N+1)]
    return ans


def main():
    N, M = read_int_n()
    UV = [read_int_n() for _ in range(N-1+M)]
    print(*slv(N, M, UV), sep='\n')


if __name__ == '__main__':
    main()


Fixed submission:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, AB):

    in_n = [0] * (N+1)
    g = defaultdict(list)
    rg = defaultdict(list)
    for a, b in AB:
        in_n[b] += 1
        g[a].append(b)
        rg[b].append(a)

    r = []
    for i, n in enumerate(in_n):
        if i != 0 and n == 0:
            r.append(i)

    sv = []
    while r:
        u = r.pop()
        sv.append(u)
        for v in g[u]:
            in_n[v] -= 1
            if in_n[v] == 0:
                r.append(v)

    svd = {}
    for i, v in enumerate(sv):
        svd[v] = i
    for i in range(1, N+1):
        mi = 0
        if len(rg[i]) == 0:
            print(0)
        else:
            for j in rg[i]:
                mi = max(mi, svd[j])
            print(sv[mi])
    return


def main():
    N, M = read_int_n()
    AB = [read_int_n() for _ in range(N+M-1)]
    slv(N, M, AB)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, AB):

    in_n = [0] * (N+1)
    g = defaultdict(list)
    rg = defaultdict(list)
    for a, b in AB:
        in_n[b] += 1
        g[a].append(b)
        rg[b].append(a)

    r = []
    for i, n in enumerate(in_n):
        if i != 0 and n == 0:
            r.append(i)

    sv = []
    while r:
        u = r.pop()
        sv.append(u)
        for v in g[u]:
            in_n[v] -= 1
            if in_n[v] == 0:
                r.append(v)

    for i in range(1, N+1):
        mi = 0
        if len(rg[i]) == 0:
            print(0)
        else:
            for j in rg[i]:
                mi = max(mi, sv.index(j))
            print(sv[mi])
    return


def main():
    N, M = read_int_n()
    AB = [read_int_n() for _ in range(N+M-1)]
    slv(N, M, AB)


if __name__ == '__main__':
    main()


Fixed submission:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, AB):

    in_n = [0] * (N+1)
    g = defaultdict(list)
    rg = defaultdict(list)
    for a, b in AB:
        in_n[b] += 1
        g[a].append(b)
        rg[b].append(a)

    r = []
    for i, n in enumerate(in_n):
        if i != 0 and n == 0:
            r.append(i)

    sv = []
    while r:
        u = r.pop()
        sv.append(u)
        for v in g[u]:
            in_n[v] -= 1
            if in_n[v] == 0:
                r.append(v)

    svd = {}
    for i, v in enumerate(sv):
        svd[v] = i
    for i in range(1, N+1):
        mi = 0
        if len(rg[i]) == 0:
            print(0)
        else:
            for j in rg[i]:
                mi = max(mi, svd[j])
            print(sv[mi])
    return


def main():
    N, M = read_int_n()
    AB = [read_int_n() for _ in range(N+M-1)]
    slv(N, M, AB)


if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, AB):

    in_n = [0] * (N+1)
    g = defaultdict(list)
    rg = defaultdict(list)
    for a, b in AB:
        in_n[b] += 1
        g[a].append(b)
        rg[b].append(a)

    r = []
    for i, n in enumerate(in_n):
        if i != 0 and n == 0:
            r.append(i)

    sv = []
    while r:
        u = r.pop()
        sv.append(u)
        for v in g[u]:
            in_n[v] -= 1
            if in_n[v] == 0:
                r.append(v)

    for i in range(1, N+1):
        mi = 0
        if len(rg[i]) == 0:
            print(0)
        else:
            for j in rg[i]:
                mi = max(mi, sv.index(j))
            print(sv[mi])
    return


def main():
    N, M = read_int_n()
    AB = [read_int_n() for _ in range(N+M-1)]
    slv(N, M, AB)


if __name__ == '__main__':
    main()


Fixed submission:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(10000)


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N, M, AB):

    in_n = [0] * (N+1)
    g = defaultdict(list)
    rg = defaultdict(list)
    for a, b in AB:
        in_n[b] += 1
        g[a].append(b)
        rg[b].append(a)

    r = []
    for i, n in enumerate(in_n):
        if i != 0 and n == 0:
            r.append(i)

    sv = []
    while r:
        u = r.pop()
        sv.append(u)
        for v in g[u]:
            in_n[v] -= 1
            if in_n[v] == 0:
                r.append(v)

    svd = {}
    for i, v in enumerate(sv):
        svd[v] = i
    for i in range(1, N+1):
        mi = 0
        if len(rg[i]) == 0:
            print(0)
        else:
            for j in rg[i]:
                mi = max(mi, svd[j])
            print(sv[mi])
    return


def main():
    N, M = read_int_n()
    AB = [read_int_n() for _ in range(N+M-1)]
    slv(N, M, AB)


if __name__ == '__main__':
    main()