


def  a   (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.
   __a					=  [p / w for p, w in zip(lowerCAmelCase__		,				lowerCAmelCase__   )]

   # Creating a copy of the list and sorting profit/weight in ascending order
   __a					=  sorted(lowerCAmelCase__   )

   # declaring useful variables
   __a					=  len(lowerCAmelCase__   )
   __a					=  0
   __a					=  0
   __a					=  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
      __a					=  sorted_profit_by_weight[length - i - 1]
      __a					=  profit_by_weight.index(lowerCAmelCase__   )
      __a					=  -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.'
  )

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

  # Function Call
  calc_profit(profit, weight, max_weight)







class     __UpperCAmelCase							:


     """simple docstring"""


     def __init__(	self  ,       __A    ):
        __a					=  set_counts
        __a					=  max(__A    )
        __a					=  len(__A    )
        __a					=  [1] * num_sets
        __a					=  list(range(__A    )    )


     def 	snake_case_  (	self  ,       __A  ,       __A    ):
        __a					=  self.get_parent(__A    )
        __a					=  self.get_parent(__A    )

        if src_parent == dst_parent:
           return False

        if self.ranks[dst_parent] >= self.ranks[src_parent]:
           self.set_counts[dst_parent] += self.set_counts[src_parent]
           __a					=  0
           __a					=  dst_parent
           if self.ranks[dst_parent] == self.ranks[src_parent]:
              self.ranks[dst_parent] += 1
           __a					=  self.set_counts[dst_parent]
        else:
           self.set_counts[src_parent] += self.set_counts[dst_parent]
           __a					=  0
           __a					=  src_parent
           __a					=  self.set_counts[src_parent]

        __a					=  max(self.max_set  ,       __A    )
        return True


     def 	snake_case_  (	self  ,       __A    ):
        if self.parents[disj_set] == disj_set:
           return disj_set
        __a					=  self.get_parent(self.parents[disj_set]    )
        return self.parents[disj_set]



