





"""simple docstring"""





def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_  ,			UpperCAmelCase_  )						->int:





  """simple docstring"""


  if len(UpperCAmelCase_  ) != len(UpperCAmelCase_  ):
    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.
  __UpperCAmelCase    :						Any       =						[p / w for p, w in zip(UpperCAmelCase_  ,			UpperCAmelCase_  )]

  # Creating a copy of the list and sorting profit/weight in ascending order
  __UpperCAmelCase    :						int       =						sorted(UpperCAmelCase_  )

  # declaring useful variables
  __UpperCAmelCase    :						int       =						len(UpperCAmelCase_  )
  __UpperCAmelCase    :						Tuple       =						0
  __UpperCAmelCase    :						List[Any]       =						0
  __UpperCAmelCase    :						Dict       =						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
    __UpperCAmelCase    :						Tuple       =						sorted_profit_by_weight[length - i - 1]
    __UpperCAmelCase    :						List[str]       =						profit_by_weight.index(UpperCAmelCase_  )
    __UpperCAmelCase    :						str       =						-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.'
  )

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

  # Function Call
  calc_profit(profit, weight, max_weight)






"""simple docstring"""





def       lowerCamelCase_       (   UpperCAmelCase_  ,			UpperCAmelCase_  )						->bool:





  """simple docstring"""


  return numa ^ numa < 0


if __name__ == "__main__":
  import doctest

  doctest.testmod()