



def      lowerCAmelCase__		(   lowerCamelCase_		:		list	,lowerCamelCase_		:		list	,lowerCamelCase_		:		int):





				'''simple docstring'''

				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.
				lowerCAmelCase__					:    Optional[Any]												=					[p / w for p, w in zip(lowerCamelCase_	,lowerCamelCase_)]

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

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

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

							# Function Call
							calc_profit(profit, weight, max_weight)






def      lowerCAmelCase__		(   lowerCamelCase_		:		str	,lowerCamelCase_		:		str):





				'''simple docstring'''

				lowerCAmelCase__					:    Optional[Any]												=					len(lowerCamelCase_)
				lowerCAmelCase__					:    str												=					len(lowerCamelCase_)
				lowerCAmelCase__					:    Union[str, Any]												=					[[False for _ in range(m + 1)] for _ in range(n + 1)]
				lowerCAmelCase__					:    List[Any]												=					True
				for i in range(lowerCamelCase_):
								for j in range(m + 1):
												if dp[i][j]:
																if j < m and a[i].upper() == b[j]:
																				lowerCAmelCase__					:    int												=					True
																if a[i].islower():
																				lowerCAmelCase__					:    int												=					True
				return dp[n][m]


if __name__ == "__main__":
							import doctest

							doctest.testmod()

