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

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

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

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

							# Function Call
							calc_profit(profit, weight, max_weight)





def 	__lowerCamelCase							(UpperCAmelCase__     :							list[int]  ):
					if not numbers:
										return 0

					if not isinstance(UpperCAmelCase__      , (list, tuple)  ) or not all(
					    isinstance(UpperCAmelCase__      , UpperCAmelCase__  ) for number in numbers  ):
										raise ValueError("numbers must be an iterable of integers"  )

					SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       numbers[0]

					for i in range(1      , len(UpperCAmelCase__  )  ):
										# update the maximum and minimum subarray products
										SCREAMING_SNAKE_CASE    			=       numbers[i]
										if number < 0:
															SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       min_till_now, max_till_now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , max_till_now * number  )
										SCREAMING_SNAKE_CASE    			=       min(UpperCAmelCase__      , min_till_now * number  )

										# update the maximum product found till now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , UpperCAmelCase__  )

					return max_prod




