




from __future__ import annotations

import math






def  snake_case(    __magic_name__   )			->							bool:





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


lowerCAmelCase_						=			[num for num in range(3, 10_00_01, 2) if not is_prime(num)]






def  snake_case(    __magic_name__   )			->							list[int]:





     '''simple docstring'''


     if not isinstance(__magic_name__			,		__magic_name__   ):
          raise ValueError('''n must be an integer'''   )
     if n <= 0:
          raise ValueError('''n must be >= 0'''   )

     lowercase :       Any       =			[]
     for num in range(len(__magic_name__   )   ):
          lowercase :       str       =			0
          while 2 * i * i <= odd_composites[num]:
               lowercase :       List[str]       =			odd_composites[num] - 2 * i * i
               if is_prime(__magic_name__   ):
                    break
               i += 1
          else:
               list_nums.append(odd_composites[num]   )
               if len(__magic_name__   ) == n:
                    return list_nums

     return []






def  snake_case(    )			->							int:





     '''simple docstring'''


     return compute_nums(1   )[0]


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





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)