





"""simple docstring"""


import math





def SCREAMING_SNAKE_CASE_   (       snake_case   :					Tuple		)->		bool:

       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(UpperCamelCase_		) + 1		)						,  6		):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True





def SCREAMING_SNAKE_CASE_   (       snake_case   :					Optional[Any] = 600_851_475_143		)->		int:

       try:
              _lowerCamelCase    	=					int(UpperCamelCase_		)
       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    	=					0
       if is_prime(UpperCamelCase_		):
              return n
       while n % 2 == 0:
              n //= 2
       if is_prime(UpperCamelCase_		):
              return n
       for i in range(3						,  int(math.sqrt(UpperCamelCase_		)		) + 1						,  2		):
              if n % i == 0:
                     if is_prime(n // i		):
                            _lowerCamelCase    	=					n // i
                            break
                     elif is_prime(UpperCamelCase_		):
                            _lowerCamelCase    	=					i
       return max_number


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













def        lowerCAmelCase_       (							UpperCamelCase_    ,						UpperCamelCase_     )   ->						list:
       UpperCamelCase_      				=     sorted(UpperCamelCase_    ,						key=lambda UpperCamelCase_     : value[2]    ,						reverse=UpperCamelCase_     )

       # Create a list of size equal to the maximum deadline
       # and initialize it with -1
       UpperCamelCase_      				=     max(UpperCamelCase_    ,						key=lambda UpperCamelCase_     : value[1]     )[1]
       UpperCamelCase_      				=     [-1] * max_deadline

       # Finding the maximum profit and the count of jobs
       UpperCamelCase_      				=     0
       UpperCamelCase_      				=     0
       for job in jobs:
              # Find a free time slot for this job
              # (Note that we start from the last possible slot)
              for i in range(job[1] - 1    ,						-1    ,						-1     ):
                     if time_slots[i] == -1:
                            UpperCamelCase_      				=     job[0]
                            count += 1
                            max_profit += job[2]
                            break
       return [count, max_profit]


if __name__ == "__main__":
     import doctest

     doctest.testmod()

