


'''simple docstring'''




def   _a		(lowercase__			:   list							,   lowercase__			:   list							,   lowercase__			:   int						)			->			int:






     """simple docstring"""
     if len(lowercase__						) != len(lowercase__						):
          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.
     __snake_case           =						[p / w for p, w in zip(lowercase__							,   lowercase__						)]

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

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

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

       # Function Call
       calc_profit(profit, weight, max_weight)










"""simple docstring"""






def 	_snake_case     (							lowercase__ = 1				,       lowercase__ = 1000						):
				_lowerCamelCase	:     Optional[int]       =       1
				_lowerCamelCase	:     List[Any]       =       0

				for divide_by_number in range(lowercase__				,       digit + 1						):
								_lowerCamelCase	:     list[int]       =       []
								_lowerCamelCase	:     Dict       =       numerator
								for _ in range(1				,       digit + 1						):
												if now_divide in has_been_divided:
																if longest_list_length < len(lowercase__						):
																				_lowerCamelCase	:     Any       =       len(lowercase__						)
																				_lowerCamelCase	:     Any       =       divide_by_number
												else:
																has_been_divided.append(lowercase__						)
																_lowerCamelCase	:     int       =       now_divide * 10 % divide_by_number

				return the_digit


# Tests
if __name__ == "__main__":
			import doctest

			doctest.testmod()