




"""simple docstring"""




def     a__ (				snake_case__       , snake_case__       , snake_case__				)						->					int:
			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.
			lowerCamelCase			      =					[p / w for p, w in zip(snake_case__       , snake_case__				)]

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

			# declaring useful variables
			lowerCamelCase			      =					len(snake_case__				)
			lowerCamelCase			      =					0
			lowerCamelCase			      =					0
			lowerCamelCase			      =					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			      =					sorted_profit_by_weight[length - i - 1]
						lowerCamelCase			      =					profit_by_weight.index(snake_case__				)
						lowerCamelCase			      =					-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							:			List[Any]     							=							[int(x) for x in input("""Input profits separated by spaces: """).split()]
					lowerCAmelCase							:			int     							=							[int(x) for x in input("""Input weights separated by spaces: """).split()]
					lowerCAmelCase							:			Any     							=							int(input("""Max weight allowed: """))

					# Function Call
					calc_profit(profit, weight, max_weight)









"""simple docstring"""




from __future__ import annotations



def     a__ (				snake_case__       , snake_case__				)						->					bool:
			if len(snake_case__				) == 0:
						return False
			lowerCamelCase			      =					len(snake_case__				) // 2
			if a_list[midpoint] == item:
						return True
			if item < a_list[midpoint]:
						return binary_search(a_list[:midpoint]       , snake_case__				)
			else:
						return binary_search(a_list[midpoint + 1 :]       , snake_case__				)


if __name__ == "__main__":
					lowerCAmelCase							:			List[Any]     							=							input("""Enter numbers separated by comma:\n""").strip()
					lowerCAmelCase							:			Optional[Any]     							=							[int(item.strip()) for item in user_input.split(""",""")]
					lowerCAmelCase							:			Optional[int]     							=							int(input("""Enter the number to be found in the list:\n""").strip())
					lowerCAmelCase							:			Union[str, Any]     							=							"""""" if binary_search(sequence, target) else """not """
					print(F"""{target} was {not_str}found in {sequence}""")



