"""simple docstring"""





class  _snake_case     :






      def __init__(       self      :			List[Any]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			List[Any]=None							,					UpperCAmelCase      :			List[Any]=None    ):
             __lowerCamelCase					:		Tuple		   =     data
             __lowerCamelCase					:		Optional[int]		   =     previous
             __lowerCamelCase					:		Tuple		   =     next_node






      def __str__(       self      :			Any    ):
             return F"""{self.data}"""






      def       lowerCamelCase__     (       self      :			str    ):
             return self.data






      def       lowerCamelCase__     (       self      :			List[Any]    ):
             return self.next







      def       lowerCamelCase__     (       self      :			Any    ):
             return self.previous

class  _snake_case     :






      def __init__(       self      :			Optional[Any]							,					UpperCAmelCase      :			List[Any]    ):
             __lowerCamelCase					:		Dict		   =     head






      def __iter__(       self      :			List[Any]    ):
             return self







      def       lowerCamelCase__     (       self      :			Tuple    ):
             if not self.current:
                    raise StopIteration
             else:
                    __lowerCamelCase					:		Dict		   =     self.current.get_data()
                    __lowerCamelCase					:		Any		   =     self.current.get_next()
                    return value

class  _snake_case     :






      def __init__(       self      :			List[Any]    ):
             __lowerCamelCase					:		Any		   =     None  # First node in list
             __lowerCamelCase					:		List[str]		   =     None  # Last node in list






      def __str__(       self      :			Optional[Any]    ):
             __lowerCamelCase					:		List[str]		   =     self.head
             __lowerCamelCase					:		Optional[int]		   =     []
             while current is not None:
                    nodes.append(current.get_data()    )
                    __lowerCamelCase					:		Union[str, Any]		   =     current.get_next()
             return " ".join(str(UpperCAmelCase    ) for node in nodes    )






      def __contains__(       self      :			Any							,					UpperCAmelCase      :			int    ):
             __lowerCamelCase					:		str		   =     self.head
             while current:
                    if current.get_data() == value:
                           return True
                    __lowerCamelCase					:		Tuple		   =     current.get_next()
             return False






      def __iter__(       self      :			Any    ):
             return LinkedListIterator(self.head    )






      def       lowerCamelCase__     (       self      :			Optional[Any]    ):
             if self.head:
                    return self.head.get_data()
             return None






      def       lowerCamelCase__     (       self      :			int    ):
             if self.tail:
                    return self.tail.get_data()
             return None






      def       lowerCamelCase__     (       self      :			Tuple							,					UpperCAmelCase      :			Node    ):
             if self.head is None:
                    __lowerCamelCase					:		Dict		   =     node
                    __lowerCamelCase					:		List[Any]		   =     node
             else:
                    self.insert_before_node(self.head							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			Node    ):
             if self.head is None:
                    self.set_head(UpperCAmelCase    )
             else:
                    self.insert_after_node(self.tail							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			int    ):
             __lowerCamelCase					:		str		   =     Node(UpperCAmelCase    )
             if self.head is None:
                    self.set_head(UpperCAmelCase    )
             else:
                    self.set_tail(UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			Dict							,					UpperCAmelCase      :			Node							,					UpperCAmelCase      :			Node    ):
             __lowerCamelCase					:		str		   =     node
             __lowerCamelCase					:		str		   =     node.previous

             if node.get_previous() is None:
                    __lowerCamelCase					:		Optional[int]		   =     node_to_insert
             else:
                    __lowerCamelCase					:		List[str]		   =     node_to_insert

             __lowerCamelCase					:		str		   =     node_to_insert






      def       lowerCamelCase__     (       self      :			Optional[int]							,					UpperCAmelCase      :			Node							,					UpperCAmelCase      :			Node    ):
             __lowerCamelCase					:		List[str]		   =     node
             __lowerCamelCase					:		Union[str, Any]		   =     node.next

             if node.get_next() is None:
                    __lowerCamelCase					:		Any		   =     node_to_insert
             else:
                    __lowerCamelCase					:		Union[str, Any]		   =     node_to_insert

             __lowerCamelCase					:		Tuple		   =     node_to_insert






      def       lowerCamelCase__     (       self      :			List[Any]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			int    ):
             __lowerCamelCase					:		Optional[Any]		   =     1
             __lowerCamelCase					:		Any		   =     Node(UpperCAmelCase    )
             __lowerCamelCase					:		List[Any]		   =     self.head
             while node:
                    if current_position == position:
                           self.insert_before_node(UpperCAmelCase							,					UpperCAmelCase    )
                           return
                    current_position += 1
                    __lowerCamelCase					:		Optional[int]		   =     node.next
             self.insert_after_node(self.tail							,					UpperCAmelCase    )






      def       lowerCamelCase__     (       self      :			Optional[int]							,					UpperCAmelCase      :			int    ):
             __lowerCamelCase					:		List[str]		   =     self.head
             while node:
                    if node.get_data() == item:
                           return node
                    __lowerCamelCase					:		Optional[Any]		   =     node.get_next()
             raise Exception("Node not found"    )






      def       lowerCamelCase__     (       self      :			Any							,					UpperCAmelCase      :			List[str]    ):
             if (node := self.get_node(UpperCAmelCase    )) is not None:
                    if node == self.head:
                           __lowerCamelCase					:		Any		   =     self.head.get_next()

                    if node == self.tail:
                           __lowerCamelCase					:		Dict		   =     self.tail.get_previous()

                    self.remove_node_pointers(UpperCAmelCase    )






      @staticmethod
      def       lowerCamelCase__     (       UpperCAmelCase      :			Node    ):
             if node.get_next():
                    __lowerCamelCase					:		Any		   =     node.previous

             if node.get_previous():
                    __lowerCamelCase					:		Tuple		   =     node.next

             __lowerCamelCase					:		List[str]		   =     None
             __lowerCamelCase					:		List[Any]		   =     None







      def       lowerCamelCase__     (       self      :			List[Any]    ):
             return self.head is None


def    lowercase_   (   ) ->      None:



       '''simple docstring'''




if __name__ == "__main__":
    import doctest

    doctest.testmod()
"""simple docstring"""





def    lowercase_   (   _lowerCamelCase:	int = 600851475143      ) ->      int:



							'''simple docstring'''

							try:
														__lowerCamelCase					:		Optional[Any]		   =     int(_lowerCamelCase      )
							except (TypeError, ValueError):
														raise TypeError("Parameter n must be int or castable to int."      )
							if n <= 0:
														raise ValueError("Parameter n must be greater than or equal to one."      )
							__lowerCamelCase					:		Union[str, Any]		   =     2
							__lowerCamelCase					:		int		   =     0
							if n == 2:
														return 2
							while n > 2:
														while n % i != 0:
																					i += 1
														__lowerCamelCase					:		Dict		   =     i
														while n % i == 0:
																					__lowerCamelCase					:		Union[str, Any]		   =     n // i
														i += 1
							return int(_lowerCamelCase      )


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