


from __future__ import annotations

from typing import Any







class  snake_case__:







						'''simple docstring'''




						def __init__( self      ,  __lowercase							)    ->			Any:
										lowerCAmelCase_       :					Union[str, Any]			 = num_of_nodes
										lowerCAmelCase_       :					list[list[int]]			 = []
										lowerCAmelCase_       :					dict[int, int]			 = {}




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase							)    ->			Any:
										self.m_edges.append([u_node, v_node, weight]							)




						def   lowercase_       ( self      ,  __lowercase							)    ->			Optional[Any]:

										if self.m_component[u_node] == u_node:
														return u_node
										return self.find_component(self.m_component[u_node]							)




						def   lowercase_       ( self      ,  __lowercase							)    ->			str:

										if self.m_component[u_node] != u_node:
														for k in self.m_component:
																		lowerCAmelCase_       :					List[Any]			 = self.find_component(lowercase_							)




						def   lowercase_       ( self      ,  __lowercase      ,  __lowercase      ,  __lowercase							)    ->			Any:

										if component_size[u_node] <= component_size[v_node]:
														lowerCAmelCase_       :					int			 = v_node
														component_size[v_node] += component_size[u_node]
														self.set_component(lowercase_							)

										elif component_size[u_node] >= component_size[v_node]:
														lowerCAmelCase_       :					Dict			 = self.find_component(lowercase_							)
														component_size[u_node] += component_size[v_node]
														self.set_component(lowercase_							)




						def   lowercase_       ( self							)    ->			Dict:
										lowerCAmelCase_       :					Union[str, Any]			 = []
										lowerCAmelCase_       :					Union[str, Any]			 = 0

										lowerCAmelCase_       :					list[Any]			 = [-1] * self.m_num_of_nodes

										# A list of components (initialized to all of the nodes)
										for node in range(self.m_num_of_nodes							):
														self.m_component.update({node: node}							)
														component_size.append(1							)

										lowerCAmelCase_       :					Optional[Any]			 = self.m_num_of_nodes

										while num_of_components > 1:
														for edge in self.m_edges:
																		lowerCAmelCase_       :					Any			 = edge

																		lowerCAmelCase_       :					List[str]			 = self.m_component[u]
																		lowerCAmelCase_       :					Optional[Any]			 = self.m_component[v]

																		if u_component != v_component:

																						for component in (u_component, v_component):
																										if (
																										    minimum_weight_edge[component] == -1
																										    or minimum_weight_edge[component][2] > w
																										):
																														lowerCAmelCase_       :					Union[str, Any]			 = [u, v, w]

														for edge in minimum_weight_edge:
																		if isinstance(lowercase_      ,  lowercase_							):
																						lowerCAmelCase_       :					Dict			 = edge

																						lowerCAmelCase_       :					Optional[Any]			 = self.m_component[u]
																						lowerCAmelCase_       :					Optional[int]			 = self.m_component[v]

																						if u_component != v_component:
																										mst_weight += w
																										self.union(lowercase_      ,  lowercase_      ,  lowercase_							)
																										print(f"""Added edge [{u} - {v}]\nAdded weight: {w}\n"""							)
																										num_of_components -= 1

														lowerCAmelCase_       :					Any			 = [-1] * self.m_num_of_nodes
										print(f"""The total weight of the minimal spanning tree is: {mst_weight}"""							)






def 	lowerCAmelCase       (						)->       Any:
				pass


if __name__ == "__main__":
						import doctest

						doctest.testmod()




"""simple docstring"""

import sys

lowercase__    :  Dict							    =	(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)




def __lowercase			(							_a    ):
    snake_case_ :     List[Any]				=	1
    for digit in s:
        product *= int(_a    )
    return product




def __lowercase			(							_a = N    ):
    snake_case_ :     Optional[int]				=	-sys.maxsize - 1
    snake_case_ :     str				=	n[:13]
    snake_case_ :     List[Any]				=	13
    while cur_index < len(_a    ) - 13:
        if int(n[cur_index]    ) >= int(substr[0]    ):
            snake_case_ :     int				=	substr[1:] + n[cur_index]
            cur_index += 1
        else:
            snake_case_ :     Optional[Any]				=	max(_a		,			str_eval(_a    )    )
            snake_case_ :     Any				=	n[cur_index : cur_index + 13]
            cur_index += 13
    return largest_product


if __name__ == "__main__":
     print(f'{solution() = }')





