
import sys
from collections import defaultdict







class        A_   :




	'''simple docstring'''


	def __init__(       self       ):
		lowercase       =    []





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case       ):
		return self.node_position[vertex]





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case       ):
		lowercase       =    pos





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case		,    snake_case       ):
		if start > size // 2 - 1:
			return
		else:
			if 2 * start + 2 >= size:
				lowercase       =    2 * start + 1
			else:
				if heap[2 * start + 1] < heap[2 * start + 2]:
					lowercase       =    2 * start + 1
				else:
					lowercase       =    2 * start + 2
			if heap[smallest_child] < heap[start]:
				lowercase  ,					lowercase       =    heap[smallest_child], positions[smallest_child]
				lowercase  ,					lowercase       =    (
				    heap[start],
				    positions[start],
				)
				lowercase  ,					lowercase       =    temp, tempa

				lowercase       =    self.get_position(positions[smallest_child]       )
				self.set_position(
				    positions[smallest_child]		,    self.get_position(positions[start]       )       )
				self.set_position(positions[start]		,    snake_case       )

				self.top_to_bottom(snake_case		,    snake_case		,    snake_case		,    snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case		,    snake_case       ):
		lowercase       =    position[index]

		while index != 0:
			lowercase       =    int((index - 2) / 2       ) if index % 2 == 0 else int((index - 1) / 2       )

			if val < heap[parent]:
				lowercase       =    heap[parent]
				lowercase       =    position[parent]
				self.set_position(position[parent]		,    snake_case       )
			else:
				lowercase       =    val
				lowercase       =    temp
				self.set_position(snake_case		,    snake_case       )
				break
			lowercase       =    parent
		else:
			lowercase       =    val
			lowercase       =    temp
			self.set_position(snake_case		,    0       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case       ):
		lowercase       =    len(snake_case       ) // 2 - 1
		for i in range(snake_case		,    -1		,    -1       ):
			self.top_to_bottom(snake_case		,    snake_case		,    len(snake_case       )		,    snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case       ):
		lowercase       =    positions[0]
		lowercase       =    sys.maxsize
		self.top_to_bottom(snake_case		,    0		,    len(snake_case       )		,    snake_case       )
		return temp






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	lowercase       =    Heap()

	lowercase       =    [0] * len(__SCREAMING_SNAKE_CASE							)
	lowercase       =    [-1] * len(__SCREAMING_SNAKE_CASE							)  # Neighboring Tree Vertex of selected vertex
	# Minimum Distance of explored vertex with neighboring vertex of partial tree
	# formed in graph
	lowercase       =    []  # Heap of Distance of vertices from their neighboring vertex
	lowercase       =    []

	for vertex in range(len(__SCREAMING_SNAKE_CASE							)							):
		distance_tv.append(sys.maxsize							)
		positions.append(__SCREAMING_SNAKE_CASE							)
		heap.node_position.append(__SCREAMING_SNAKE_CASE							)

	lowercase       =    []
	lowercase       =    1
	lowercase       =    sys.maxsize
	for neighbor, distance in adjacency_list[0]:
		lowercase       =    0
		lowercase       =    distance
	heap.heapify(__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							)

	for _ in range(1 ,							len(__SCREAMING_SNAKE_CASE							)							):
		lowercase       =    heap.delete_minimum(__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							)
		if visited[vertex] == 0:
			tree_edges.append((nbr_tv[vertex], vertex)							)
			lowercase       =    1
			for neighbor, distance in adjacency_list[vertex]:
				if (
				    visited[neighbor] == 0
				    and distance < distance_tv[heap.get_position(__SCREAMING_SNAKE_CASE							)]
				):
					lowercase       =    distance
					heap.bottom_to_top(
					    __SCREAMING_SNAKE_CASE ,							heap.get_position(__SCREAMING_SNAKE_CASE							) ,							__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							)
					lowercase       =    vertex
	return tree_edges


if __name__ == "__main__":  # pragma: no cover
	# < --------- Prims Algorithm --------- >
	UpperCAmelCase	      = int(input('''Enter number of edges: ''').strip())
	UpperCAmelCase	      = defaultdict(list)
	for _ in range(edges_number):
		UpperCAmelCase	      = [int(x) for x in input().strip().split()]
		adjacency_list[edge[0]].append([edge[1], edge[2]])
		adjacency_list[edge[1]].append([edge[0], edge[2]])
	print(prisms_algorithm(adjacency_list))



from manim import *







class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    Rectangle(height=0.5		,    width=0.5       )
		lowercase       =    Rectangle(height=0.25		,    width=0.25       )
		lowercase       =    Rectangle(height=0.46		,    width=0.46       ).set_stroke(width=0       )

		lowercase       =    [mem.copy() for i in range(6       )]
		lowercase       =    [mem.copy() for i in range(6       )]
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    VGroup(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    Text('CPU'		,    font_size=24       )
		lowercase       =    Group(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0.5		,    aligned_edge=snake_case       )
		cpu.move_to([-2.5, -0.5, 0]       )
		self.add(snake_case       )

		lowercase       =    [mem.copy() for i in range(4       )]
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    Text('GPU'		,    font_size=24       )
		lowercase       =    Group(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0.5		,    aligned_edge=snake_case       )
		gpu.move_to([-1, -1, 0]       )
		self.add(snake_case       )

		lowercase       =    [mem.copy() for i in range(6       )]
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )

		lowercase       =    Text('Model'		,    font_size=24       )
		lowercase       =    Group(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0.5		,    aligned_edge=snake_case       )
		model.move_to([3, -1.0, 0]       )
		self.add(snake_case       )

		lowercase       =    []
		lowercase       =    []
		lowercase       =    []

		for i, rect in enumerate(snake_case       ):
			rect.set_stroke(snake_case       )

			lowercase       =    Rectangle(height=0.46 / 4		,    width=0.46 / 3       ).set_stroke(width=0.0       ).set_fill(snake_case		,    opacity=0.7       )

			if i == 0:
				cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT       )		,    buff=0.02		,    direction=snake_case       )
				cpu_target.set_x(cpu_target.get_x() + 0.1       )
			elif i == 3:
				cpu_target.next_to(model_cpu_arr[0]		,    direction=snake_case		,    buff=0.0       )
			else:
				cpu_target.next_to(model_cpu_arr[i - 1]		,    direction=snake_case		,    buff=0.0       )
			self.add(snake_case       )
			model_cpu_arr.append(snake_case       )

		self.add(*snake_case		,    *snake_case		,    *snake_case       )

		lowercase       =    [mem.copy() for i in range(6       )]
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )

		lowercase       =    Text('Loaded Checkpoint'		,    font_size=24       )
		lowercase       =    Group(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0.5		,    aligned_edge=snake_case       )
		checkpoint.move_to([3, 0.5, 0]       )

		self.add(snake_case       )

		lowercase       =    []
		lowercase       =    []

		for i, rect in enumerate(snake_case       ):
			lowercase       =    fill.copy().set_fill(snake_case		,    opacity=0.7       )
			target.move_to(snake_case       )
			ckpt_arr.append(snake_case       )

			lowercase       =    target.copy()
			if i < 5:
				cpu_target.move_to(cpu_left_col_base[i + 1]       )
			else:
				cpu_target.move_to(cpu_right_col_base[i - 5]       )
			ckpt_cpu_arr.append(snake_case       )
		self.add(*snake_case		,    *snake_case       )

		lowercase       =    Square(side_length=2.2       )
		key.move_to([-5, 2, 0]       )

		lowercase       =    MarkupText(
		    F'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'''		,    font_size=18		,    )

		key_text.move_to([-5, 2.4, 0]       )

		self.add(snake_case		,    snake_case       )

		lowercase       =    MarkupText(
		    F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''		,    font_size=18		,    )

		blue_text.next_to(snake_case		,    DOWN * 2.4		,    aligned_edge=key_text.get_left()       )
		self.add(snake_case       )

		lowercase       =    MarkupText(
		    F'''Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.'''		,    font_size=24		,    )
		step_a.move_to([2, 2, 0]       )

		lowercase       =    [meta_mem.copy() for i in range(6       )]
		lowercase       =    [meta_mem.copy() for i in range(6       )]
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    VGroup(*snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    VGroup(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0       )
		lowercase       =    Text('Disk'		,    font_size=24       )
		lowercase       =    Group(snake_case		,    snake_case       ).arrange(snake_case		,    buff=0.5		,    aligned_edge=snake_case       )
		disk.move_to([-4.0, -1.25, 0]       )
		self.play(Write(snake_case		,    run_time=3       )		,    Write(snake_case		,    run_time=1       )		,    Create(snake_case		,    run_time=1       )       )

		lowercase       =    []
		for i, rect in enumerate(snake_case       ):
			lowercase       =    rect.copy()
			target.generate_target()
			target.target.move_to(disk_left_col_base[i]       ).scale(0.5       )
			animations.append(MoveToTarget(snake_case		,    run_time=1.5       )       )
		self.play(*snake_case       )

		self.play(FadeOut(snake_case       )       )

		lowercase       =    MarkupText(F'''Then, the checkpoint is removed from memory\nthrough garbage collection.'''		,    font_size=24       )
		step_a.move_to([2, 2, 0]       )

		self.play(Write(snake_case		,    run_time=3       )       )

		self.play(
		    FadeOut(snake_case		,    snake_case		,    *snake_case		,    *snake_case       )		,    )

		self.wait()

