




"""simple docstring"""
def 						UpperCAmelCase				(			A__:    list							,				A__:    list							,				A__:    int     )  ->     int:
			if len(A__     ) != len(A__     ):
						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					:	str	       =				[p / w for p, w in zip(A__							,				A__     )]

			# Creating a copy of the list and sorting profit/weight in ascending order
			__lowerCamelCase					:	Union[str, Any]	       =				sorted(A__     )

			# declaring useful variables
			__lowerCamelCase					:	int	       =				len(A__     )
			__lowerCamelCase					:	List[str]	       =				0
			__lowerCamelCase					:	Tuple	       =				0
			__lowerCamelCase					:	Union[str, 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					:	List[Any]	       =				sorted_profit_by_weight[length - i - 1]
						__lowerCamelCase					:	int	       =				profit_by_weight.index(A__     )
						__lowerCamelCase					:	List[Any]	       =				-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_				:    int										=     [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_				:    List[Any]										=     int(input('''Max weight allowed: '''))

					# Function Call
					calc_profit(profit, weight, max_weight)









"""simple docstring"""
def 						UpperCAmelCase				(			A__:    Dict     )  ->     Optional[int]:
			stooge(A__							,				0							,				len(A__     ) - 1     )
			return arr





def 						UpperCAmelCase				(			A__:    Dict							,				A__:    List[str]							,				A__:    Optional[int]     )  ->     Any:
			if i >= h:
						return

			# If first element is smaller than the last then swap them
			if arr[i] > arr[h]:
						__lowerCamelCase       ,      __lowerCamelCase					:	Dict	       =				arr[h], arr[i]

			# If there are more than 2 elements in the array
			if h - i + 1 > 2:
						__lowerCamelCase					:	str	       =				(int)((h - i + 1) / 3     )

						# Recursively sort first 2/3 elements
						stooge(A__							,				A__							,				(h - t)     )

						# Recursively sort last 2/3 elements
						stooge(A__							,				i + t							,				(A__)     )

						# Recursively sort first 2/3 elements
						stooge(A__							,				A__							,				(h - t)     )


if __name__ == "__main__":
					a_				:    Tuple										=     input('''Enter numbers separated by a comma:\n''').strip()
					a_				:    Optional[Any]										=     [int(item) for item in user_input.split(''',''')]
					print(stooge_sort(unsorted))



