# 특정 원소가 속한 집합 찾기
# 아래와 같이 return 문에 재귀함수를 호출하는 구조는 곰곰히 생각해보면
# 종료조건을 수행한 가장 마지막 재귀함수의 return값을 그대로 최초의 호출한 find_parent 함수의
# 반환값으로까지 끌고오겠다는 것
def find_parent(parent, x):
  # 루트 노드가 아니면, 루트 노드 찾을때까지 재귀적 호출
  if parent[x] != x:
    return find_parent(parent, parent[x])
  return x

# 두 원소가 속한 집합 합치기
def union_parent(parent, a, b):
  a = find_parent(parent, a)
  b = find_parent(parent, b)
  if a < b:
    parent[b] = a    # parent[a]도 동시에 처리해줘야하지 않나 생각했지만
                     # 이 순간 Edge는 하나만 그린다. (부모, 자식 관계 결정)
  else:
    parent[a] = b

# 노드 개수와 간선(Union 연산) 개수 입력받기
v, e = map(int, input().split())
parent = [0] * (v+1)

# 부모 테이블상에서, 부모를 자기 자신으로 초기화
for i in range(1, v+1):
  parent[i] = i

# union 연산 각각 수행
for i in range(e):
  a, b = map(int, input(). split())
  union_parent(parent, a, b)

# 각 원소가 속한 집합 출력
print(f'각 원소가 속한 집합: ', end='')
for i in range(1, v+1):
  print(find_parent(parent, i), end=' ')

print()

# 부모 테이블 내용 출력
for i in range(1, v+1):
  print(parent[i], end=' ')

def find_parent(parent, x):
  # 루트 노드가 아니면, 루트 노드 찾을때까지 재귀적 호출
  if parent[x] != x:
    parent[x] = find_parent(parent, parent[x])
    return parent[x]
  return x

import sys

N, M = map(int, sys.stdin.readline().rstrip().split())
parent = [i for i in range(N+1)]

def find_parent(start):
  if start == parent[start]:    # 부모 노드랑 현재 노드랑 같으면
    return parent[start]        # 현재 노드 값 return
  parent[start] = find_parent(parent[start])
  return parent[start]

def union(a, b):
  root_a = find_parent(a)
  root_b = find_parent(b)

  if root_a < root_b:
    parent[root_b] = root_a

  else:
    parent[root_a] = root_b

# for _ in range(M):
#   a, b = map(int, sys.stdin.readline().rstrip().split())
#   union(a, b)

cycle = False

# 일단 union을 통해 구축해놔야 하는거 아님?
# 같지 않으면 union을 수행하네..
for _ in range(M):
  a, b = map(int, sys.stdin.readline().rstrip().split())
  if find_parent(a) == find_parent(b):
    cycle = True
    break
  else:
    union(a, b)

print(cycle)

def union(v1, v2):
    p1, p2 = find_parent(v1), find_parent(v2)

    parent[v1] = min(parent[v1], parent[v2])
    parent[v2] = min(parent[v1], parent[v2])

def union(v1, v2):
    p1, p2 = find_parent(v1), find_parent(v2)

    parent[p1] = min(p1, p2)
    parent[p2] = min(p1, p2)

import sys

N = int(sys.stdin.readline().rstrip())

graph = [[] for _ in range(N+1)]

indegree = [0] * (N+1)

time = [0]

# i 값은 현재 수강 과목
for i in range(1, N+1):
  data = list(map(int, sys.stdin.readline().rstrip().split()))
  cost = data[0]
  time.append(cost)

  # j 값은 선수과목 정보
  for j in data[1:-1]:
    graph[j].append(i)
    indegree[i] += 1

# 위상 정렬
# 진입 차수 개념, 연결 정보를 활용해서 하나씩 지우는거. queue에 성공한 node 계속 집어 넣는거

def topology_sort():
  from collections import deque
  result = [0] * (N+1)
  q = deque()

  for i in range(1, N+1):
    if indegree[i] == 0:
      q.append(i)

  while q:
    now = q.popleft()
    
    # 한번도 초기화가 안 된 수강과목 이라면
    # 즉, 처음 방문한 거라면, 그냥 수업시간 넣으면 됨
    if result[now] == 0:
      result[now] = time[now]
      
    # 연결된 간선 지우기
    '''일단 연결된 차수 다 지우는게 먼저인가?
    그럴 필요 없이 차수 지울 때 마다 후보군으로 result 값 작성해 놓으면 됨. max일 경우 대체되는 logic 이니까'''
    for i in graph[now]:
      indegree[i] -= 1
      result[i] = max(result[i], result[now] + time[i])

      # 진입 차수 0인 연결된 노드가 발견되면 queue에 삽입
      if indegree[i] == 0:
        q.append(i)
        
  return result
result = topology_sort()

for i in range(1, N+1):
  print(result[i], end=' ')