




def       UpperCAmelCase__  (     lowerCamelCase,			lowerCamelCase,			lowerCamelCase   ):
  if len(lowerCamelCase   ) != len(lowerCamelCase   ):
    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    :List[Any]      	=						[p / w for p, w in zip(lowerCamelCase,			lowerCamelCase   )]

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

  # declaring useful variables
  lowercase    :Tuple      	=						len(lowerCamelCase   )
  lowercase    :Optional[Any]      	=						0
  lowercase    :Union[str, Any]      	=						0
  lowercase    :str      	=						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    :Union[str, Any]      	=						sorted_profit_by_weight[length - i - 1]
    lowercase    :int      	=						profit_by_weight.index(lowerCamelCase   )
    lowercase    :Optional[int]      	=						-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."
     )

     _UpperCAmelCase	:						Any			=     [int(x) for x in input("Input profits separated by spaces: ").split()]
     _UpperCAmelCase	:						Any			=     [int(x) for x in input("Input weights separated by spaces: ").split()]
     _UpperCAmelCase	:						Dict			=     int(input("Max weight allowed: "))

     # Function Call
     calc_profit(profit, weight, max_weight)









from abc import ABC, abstractmethod
from argparse import ArgumentParser




class    __lowerCAmelCase       (							lowerCAmelCase):






       @staticmethod
       @abstractmethod
       def 					SCREAMING_SNAKE_CASE    (   _lowerCAmelCase:					ArgumentParser				):
         raise NotImplementedError()






       @abstractmethod
       def 					SCREAMING_SNAKE_CASE    (   self:					List[str]				):
         raise NotImplementedError()



