




import math
import unittest






def  snake_case(    __magic_name__   )			->							List[str]:





     '''simple docstring'''


     assert isinstance(_a			,		_a   ) and (
         number >= 0
     ), "'number' must been an int and positive"

     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(_a   ) + 1   )			,		6   ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True
class 						_A (  unittest.TestCase				):






  def  __a      (  self		:     List[Any]				)		->   str:






       """simple docstring"""







       self.assertTrue(is_prime(2				)				)
       self.assertTrue(is_prime(3				)				)
       self.assertTrue(is_prime(5				)				)
       self.assertTrue(is_prime(7				)				)
       self.assertTrue(is_prime(11				)				)
       self.assertTrue(is_prime(13				)				)
       self.assertTrue(is_prime(17				)				)
       self.assertTrue(is_prime(19				)				)
       self.assertTrue(is_prime(23				)				)
       self.assertTrue(is_prime(29				)				)






  def  __a      (  self		:     Any				)		->   List[Any]:






       """simple docstring"""







       with self.assertRaises(_SCREAMING_SNAKE_CASE				):
            is_prime(-19				)
       self.assertFalse(
           is_prime(0				)				,						'''Zero doesn\'t have any positive factors, primes must have exactly two.'''				,						)
       self.assertFalse(
           is_prime(1				)				,						'''One only has 1 positive factor, primes must have exactly two.'''				,						)
       self.assertFalse(is_prime(2 * 2				)				)
       self.assertFalse(is_prime(2 * 3				)				)
       self.assertFalse(is_prime(3 * 3				)				)
       self.assertFalse(is_prime(3 * 5				)				)
       self.assertFalse(is_prime(3 * 5 * 7				)				)


if __name__ == "__main__":
 unittest.main()









def  snake_case(    __magic_name__			,		__magic_name__			,		__magic_name__   )			->							int:





     '''simple docstring'''


     if len(__magic_name__   ) != len(__magic_name__   ):
          raise ValueError('''The length of profit and weight must be same.'''   )
     if max_weight <= 0:
          raise ValueError('''max_weight must greater than zero.'''   )
     if any(p < 0 for p in profit   ):
          raise ValueError('''Profit can not be negative.'''   )
     if any(w < 0 for w in weight   ):
          raise ValueError('''Weight can not be negative.'''   )

     # List created to store profit gained for the 1kg in case of each weight
     # respectively.  Calculate and append profit/weight for each element.
     lowercase :       str       =			[p / w for p, w in zip(__magic_name__			,		__magic_name__   )]

     # Creating a copy of the list and sorting profit/weight in ascending order
     lowercase :       str       =			sorted(__magic_name__   )

     # declaring useful variables
     lowercase :       Union[str, Any]       =			len(__magic_name__   )
     lowercase :       Optional[int]       =			0
     lowercase :       Optional[int]       =			0
     lowercase :       int       =			0

     # loop till the total weight do not reach max limit e.g. 15 kg and till i<length
     while limit <= max_weight and i < length:
          # flag value for encountered greatest element in sorted_profit_by_weight
          lowercase :       Optional[int]       =			sorted_profit_by_weight[length - i - 1]
          lowercase :       Union[str, Any]       =			profit_by_weight.index(__magic_name__   )
          lowercase :       Any       =			-1

          # check if the weight encountered is less than the total weight
          # encountered before.
          if max_weight - limit >= weight[index]:
               limit += weight[index]
               # Adding profit gained for the given weight 1 ===
               # weight[index]/weight[index]
               gain += 1 * profit[index]
          else:
               # Since the weight encountered is greater than limit, therefore take the
               # required number of remaining kgs and calculate profit for it.
               # weight remaining / weight[index]
               gain += (max_weight - limit) / weight[index] * profit[index]
               break
          i += 1
     return gain


if __name__ == "__main__":
 print(
     'Input profits, weights, and then max_weight (all positive ints) separated by '
     'spaces.'
 )

 lowerCAmelCase_						=			[int(x) for x in input('Input profits separated by spaces: ').split()]
 lowerCAmelCase_						=			[int(x) for x in input('Input weights separated by spaces: ').split()]
 lowerCAmelCase_						=			int(input('Max weight allowed: '))

 # Function Call
 calc_profit(profit, weight, max_weight)