






"""simple docstring"""



A_     =				[[0, 1, 1], [0, 0, 1], [1, 0, 0]]






class 				__SCREAMING_SNAKE_CASE    :


							def __init__(      self   :    Tuple      ,     snake_case   :    Any				):
													'''simple docstring'''





													A__    :	Tuple			=	name
													A__    :	int			=	[]
													A__    :	int			=	[]


							def     _UpperCamelCase							(      self   :    Dict      ,     snake_case   :    int				):
													'''simple docstring'''





													self.inbound.append(snake_case__				)


							def     _UpperCamelCase							(      self   :    Any      ,     snake_case   :    Optional[int]				):
													'''simple docstring'''





													self.outbound.append(snake_case__				)


							def __repr__(      self   :    Tuple				):
													'''simple docstring'''





													return F'<node={self.name} inbound={self.inbound} outbound={self.outbound}>'




def   _lowerCAmelCase		(				UpperCAmelCase__							:       List[Any],    UpperCAmelCase__							:       Optional[Any]=3,    UpperCAmelCase__							:       Any=0.85   )		->Tuple:
						A__    :	int			=	{}
						for node in nodes:
												A__    :	Optional[Any]			=	1

						A__    :	Dict			=	{}
						for node in nodes:
												A__    :	Union[str, Any]			=	len(node.outbound   )

						for i in range(snake_case_   ):
												print(f'======= Iteration {i + 1} ======='   )
												for _, node in enumerate(snake_case_   ):
																		A__    :	Tuple			=	(1 - d) + d * sum(
																		    ranks[ib] / outbounds[ib] for ib in node.inbound   )
												print(snake_case_   )




def   _lowerCAmelCase		(				)		->Union[str, Any]:
						A__    :	List[str]			=	list(input("""Enter Names of the Nodes: """   ).split()   )

						A__    :	Union[str, Any]			=	[Node(snake_case_   ) for name in names]

						for ri, row in enumerate(snake_case_   ):
												for ci, col in enumerate(snake_case_   ):
																		if col == 1:
																								nodes[ci].add_inbound(names[ri]   )
																								nodes[ri].add_outbound(names[ci]   )

						print("""======= Nodes ======="""   )
						for node in nodes:
												print(snake_case_   )

						page_rank(snake_case_   )


if __name__ == "__main__":
						main()












import math
from itertools import permutations


def 				__SCREAMING_SNAKE_CASE    (     snake_case_		):

						'''simple docstring'''


						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5      ,       int(math.sqrt(snake_case_		) + 1		)      ,       6		):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


def 				__SCREAMING_SNAKE_CASE    (     snake_case_      ,       snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase				,					_UpperCAmelCase						=	0, len(snake_case_		) - 1
						while left <= right:
												_UpperCAmelCase						=	(left + right) // 2
												if prime_list[middle] == target:
																		return True
												elif prime_list[middle] < target:
																		_UpperCAmelCase						=	middle + 1
												else:
																		_UpperCAmelCase						=	middle - 1

						return False


def 				__SCREAMING_SNAKE_CASE    (     ):

						'''simple docstring'''


						_UpperCAmelCase						=	[n for n in range(1001      ,       1_0000      ,       2		) if is_prime(snake_case_		)]
						_UpperCAmelCase						=	[]

						for number in prime_list:
												_UpperCAmelCase						=	[]

												for prime_member in permutations(list(str(snake_case_		)		)		):
																		_UpperCAmelCase						=	int("".join(snake_case_		)		)

																		if prime % 2 == 0:
																								continue

																		if search(snake_case_      ,       snake_case_		):
																								tmp_numbers.append(snake_case_		)

												tmp_numbers.sort()
												if len(snake_case_		) >= 3:
																		candidates.append(snake_case_		)

						_UpperCAmelCase						=	[]
						for candidate in candidates:
												_UpperCAmelCase						=	len(snake_case_		)
												_UpperCAmelCase						=	False

												for i in range(snake_case_		):
																		for j in range(i + 1      ,       snake_case_		):
																								for k in range(j + 1      ,       snake_case_		):
																														if (
																														    abs(candidate[i] - candidate[j]		)
																														    == abs(candidate[j] - candidate[k]		)
																														    and len({candidate[i], candidate[j], candidate[k]}		) == 3
																														):
																																				passed.append(
																																				    sorted([candidate[i], candidate[j], candidate[k]]		)		)
																																				_UpperCAmelCase						=	True

																														if found:
																																				break
																								if found:
																														break
																		if found:
																								break

						_UpperCAmelCase						=	set()
						for seq in passed:
												answer.add("".join([str(snake_case_		) for i in seq]		)		)

						return max(int(snake_case_		) for x in answer		)


if __name__ == "__main__":
				print(solution())




