



_lowercase  				=    [
    9_99,
    8_00,
    7_99,
    6_00,
    5_99,
    5_00,
    4_00,
    3_99,
    3_77,
    3_55,
    3_33,
    3_11,
    2_88,
    2_66,
    2_44,
    2_22,
    2_00,
    1_99,
    1_77,
    1_55,
    1_33,
    1_11,
    88,
    66,
    44,
    22,
    0,
]

_lowercase  				=    [
    9_99,
    9_76,
    9_52,
    9_28,
    9_05,
    8_82,
    8_58,
    8_57,
    8_10,
    7_62,
    7_15,
    7_14,
    5_72,
    4_29,
    4_28,
    2_86,
    2_85,
    2_38,
    1_90,
    1_43,
    1_42,
    1_18,
    95,
    71,
    47,
    24,
    0,
]

_lowercase  				=    [
    9_99,
    9_88,
    9_77,
    9_66,
    9_55,
    9_44,
    9_33,
    9_22,
    9_11,
    9_00,
    8_99,
    8_79,
    8_59,
    8_40,
    8_20,
    8_00,
    7_99,
    7_66,
    7_33,
    7_00,
    6_99,
    6_50,
    6_00,
    5_99,
    5_00,
    4_99,
    4_00,
    3_99,
    3_50,
    3_00,
    2_99,
    2_66,
    2_33,
    2_00,
    1_99,
    1_79,
    1_59,
    1_40,
    1_20,
    1_00,
    99,
    88,
    77,
    66,
    55,
    44,
    33,
    22,
    11,
    0,
]

_lowercase  				=    [
    9_99,
    9_95,
    9_92,
    9_89,
    9_85,
    9_81,
    9_78,
    9_75,
    9_71,
    9_67,
    9_64,
    9_61,
    9_57,
    9_56,
    9_51,
    9_47,
    9_42,
    9_37,
    9_33,
    9_28,
    9_23,
    9_19,
    9_14,
    9_13,
    9_08,
    9_03,
    8_97,
    8_92,
    8_87,
    8_81,
    8_76,
    8_71,
    8_70,
    8_64,
    8_58,
    8_52,
    8_46,
    8_40,
    8_34,
    8_28,
    8_27,
    8_20,
    8_13,
    8_06,
    7_99,
    7_92,
    7_85,
    7_84,
    7_77,
    7_70,
    7_63,
    7_56,
    7_49,
    7_42,
    7_41,
    7_33,
    7_24,
    7_16,
    7_07,
    6_99,
    6_98,
    6_88,
    6_77,
    6_66,
    6_56,
    6_55,
    6_45,
    6_34,
    6_23,
    6_13,
    6_12,
    5_98,
    5_84,
    5_70,
    5_69,
    5_55,
    5_41,
    5_27,
    5_26,
    5_05,
    4_84,
    4_83,
    4_62,
    4_40,
    4_39,
    3_96,
    3_95,
    3_52,
    3_51,
    3_08,
    3_07,
    2_64,
    2_63,
    2_20,
    2_19,
    1_76,
    1_32,
    88,
    44,
    0,
]

_lowercase  				=    [
    9_99,
    9_97,
    9_95,
    9_92,
    9_90,
    9_88,
    9_86,
    9_84,
    9_81,
    9_79,
    9_77,
    9_75,
    9_72,
    9_70,
    9_68,
    9_66,
    9_64,
    9_61,
    9_59,
    9_57,
    9_56,
    9_54,
    9_51,
    9_49,
    9_46,
    9_44,
    9_41,
    9_39,
    9_36,
    9_34,
    9_31,
    9_29,
    9_26,
    9_24,
    9_21,
    9_19,
    9_16,
    9_14,
    9_13,
    9_10,
    9_07,
    9_05,
    9_02,
    8_99,
    8_96,
    8_93,
    8_91,
    8_88,
    8_85,
    8_82,
    8_79,
    8_77,
    8_74,
    8_71,
    8_70,
    8_67,
    8_64,
    8_61,
    8_58,
    8_55,
    8_52,
    8_49,
    8_46,
    8_43,
    8_40,
    8_37,
    8_34,
    8_31,
    8_28,
    8_27,
    8_24,
    8_21,
    8_17,
    8_14,
    8_11,
    8_08,
    8_04,
    8_01,
    7_98,
    7_95,
    7_91,
    7_88,
    7_85,
    7_84,
    7_80,
    7_77,
    7_74,
    7_70,
    7_66,
    7_63,
    7_60,
    7_56,
    7_52,
    7_49,
    7_46,
    7_42,
    7_41,
    7_37,
    7_33,
    7_30,
    7_26,
    7_22,
    7_18,
    7_14,
    7_10,
    7_07,
    7_03,
    6_99,
    6_98,
    6_94,
    6_90,
    6_85,
    6_81,
    6_77,
    6_73,
    6_69,
    6_64,
    6_60,
    6_56,
    6_55,
    6_50,
    6_46,
    6_41,
    6_36,
    6_32,
    6_27,
    6_22,
    6_18,
    6_13,
    6_12,
    6_07,
    6_02,
    5_96,
    5_91,
    5_86,
    5_80,
    5_75,
    5_70,
    5_69,
    5_63,
    5_57,
    5_51,
    5_45,
    5_39,
    5_33,
    5_27,
    5_26,
    5_19,
    5_12,
    5_05,
    4_98,
    4_91,
    4_84,
    4_83,
    4_74,
    4_66,
    4_57,
    4_49,
    4_40,
    4_39,
    4_28,
    4_18,
    4_07,
    3_96,
    3_95,
    3_81,
    3_66,
    3_52,
    3_51,
    3_30,
    3_08,
    3_07,
    2_86,
    2_64,
    2_63,
    2_42,
    2_20,
    2_19,
    1_76,
    1_75,
    1_32,
    1_31,
    88,
    44,
    0,
]

_lowercase  				=    [
    9_99,
    9_91,
    9_82,
    9_74,
    9_66,
    9_58,
    9_50,
    9_41,
    9_33,
    9_25,
    9_16,
    9_08,
    9_00,
    8_99,
    8_74,
    8_50,
    8_25,
    8_00,
    7_99,
    7_00,
    6_00,
    5_00,
    4_00,
    3_00,
    2_00,
    1_00,
    0,
]

_lowercase  				=    [
    9_99,
    9_92,
    9_85,
    9_78,
    9_71,
    9_64,
    9_57,
    9_49,
    9_42,
    9_35,
    9_28,
    9_21,
    9_14,
    9_07,
    9_00,
    8_99,
    8_79,
    8_59,
    8_40,
    8_20,
    8_00,
    7_99,
    7_66,
    7_33,
    7_00,
    6_99,
    6_50,
    6_00,
    5_99,
    5_00,
    4_99,
    4_00,
    3_99,
    3_00,
    2_99,
    2_00,
    1_99,
    1_00,
    99,
    0,
]

_lowercase  				=    [
    9_99,
    9_96,
    9_92,
    9_89,
    9_85,
    9_82,
    9_79,
    9_75,
    9_72,
    9_68,
    9_65,
    9_61,
    9_58,
    9_55,
    9_51,
    9_48,
    9_44,
    9_41,
    9_38,
    9_34,
    9_31,
    9_27,
    9_24,
    9_20,
    9_17,
    9_14,
    9_10,
    9_07,
    9_03,
    9_00,
    8_99,
    8_91,
    8_84,
    8_76,
    8_69,
    8_61,
    8_53,
    8_46,
    8_38,
    8_30,
    8_23,
    8_15,
    8_08,
    8_00,
    7_99,
    7_88,
    7_77,
    7_66,
    7_55,
    7_44,
    7_33,
    7_22,
    7_11,
    7_00,
    6_99,
    6_88,
    6_77,
    6_66,
    6_55,
    6_44,
    6_33,
    6_22,
    6_11,
    6_00,
    5_99,
    5_85,
    5_71,
    5_57,
    5_42,
    5_28,
    5_14,
    5_00,
    4_99,
    4_85,
    4_71,
    4_57,
    4_42,
    4_28,
    4_14,
    4_00,
    3_99,
    3_79,
    3_59,
    3_40,
    3_20,
    3_00,
    2_99,
    2_79,
    2_59,
    2_40,
    2_20,
    2_00,
    1_99,
    1_66,
    1_33,
    1_00,
    99,
    66,
    33,
    0,
]










from __future__ import annotations

from math import gcd





def  __magic_name__  (				lowercase				,       lowercase = 2				,       lowercase = 1				,       lowercase = 3				,       )				-> int | None:

							"""simple docstring"""



							if num < 2:
														raise ValueError("""The input value cannot be less than 2"""				)

							# Because of the relationship between ``f(f(x))`` and ``f(x)``, this
							# algorithm struggles to find factors that are divisible by two.
							# As a workaround, we specifically check for two and even inputs.
							#   See: https://math.stackexchange.com/a/2856214/165820
							if num > 2 and num % 2 == 0:
														return 2

							# Pollard's Rho algorithm requires a function that returns pseudorandom
							# values between 0 <= X < ``num``.  It doesn't need to be random in the
							# sense that the output value is cryptographically secure or difficult
							# to calculate, it only needs to be random in the sense that all output
							# values should be equally likely to appear.
							# For this reason, Pollard suggested using ``f(x) = (x**2 - 1) % num``
							# However, the success of Pollard's algorithm isn't guaranteed and is
							# determined in part by the initial seed and the chosen random function.
							# To make retries easier, we will instead use ``f(x) = (x**2 + C) % num``
							# where ``C`` is a value that we can modify between each attempt.
							def rand_fn(lowercase				,       lowercase				,       lowercase				) -> int:
														return (pow(lowercase				,       2				) + step) % modulus

							for _ in range(lowercase				):
														# These track the position within the cycle detection logic.
														lowercase_	:   List[Any]  				=     seed
														lowercase_	:   Any  				=     seed

														while True:
																					# At each iteration, the tortoise moves one step and the hare moves two.
																					lowercase_	:   List[str]  				=     rand_fn(lowercase				,       lowercase				,       lowercase				)
																					lowercase_	:   str  				=     rand_fn(lowercase				,       lowercase				,       lowercase				)
																					lowercase_	:   Any  				=     rand_fn(lowercase				,       lowercase				,       lowercase				)

																					# At some point both the tortoise and the hare will enter a cycle whose
																					# length ``p`` is a divisor of ``num``.  Once in that cycle, at some point
																					# the tortoise and hare will end up on the same value modulo ``p``.
																					# We can detect when this happens because the position difference between
																					# the tortoise and the hare will share a common divisor with ``num``.
																					lowercase_	:   Tuple  				=     gcd(hare - tortoise				,       lowercase				)

																					if divisor == 1:
																												# No common divisor yet, just keep searching.
																												continue
																					else:
																												# We found a common divisor!
																												if divisor == num:
																																			# Unfortunately, the divisor is ``num`` itself and is useless.
																																			break
																												else:
																																			# The divisor is a nontrivial factor of ``num``!
																																			return divisor

        # If we made it here, then this attempt failed.
        # We need to pick a new starting seed for the tortoise and hare
        # in addition to a new step value for the random function.
        # To keep this example implementation deterministic, the
        # new values will be generated based on currently available
        # values instead of using something like ``random.randint``.

        # We can use the hare's position as the new seed.
        # This is actually what Richard Brent's the "optimized" variant does.
														lowercase_	:   int  				=     hare

														# The new step value for the random function can just be incremented.
														# At first the results will be similar to what the old function would
														# have produced, but the value will quickly diverge after a bit.
														step += 1

							# We haven't found a divisor within the requested number of attempts.
							# We were unlucky or ``num`` itself is actually prime.
							return None


if __name__ == "__main__":
							import argparse

							UpperCAmelCase_							=				argparse.ArgumentParser()
							parser.add_argument(
							    """num""",
							    type=int,
							    help="""The value to find a divisor of""",
							)
							parser.add_argument(
							    """--attempts""",
							    type=int,
							    default=3,
							    help="""The number of attempts before giving up""",
							)
							UpperCAmelCase_							=				parser.parse_args()

							UpperCAmelCase_							=				pollard_rho(args.num, attempts=args.attempts)
							if divisor is None:
														print(F'''{args.num} is probably prime''')
							else:
														UpperCAmelCase_							=				args.num // divisor
														print(F'''{args.num} = {divisor} * {quotient}''')