


def  a   (lowerCAmelCase__		,				lowerCAmelCase__		,				lowerCAmelCase__   ):
   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.
   __a					=  [p / w for p, w in zip(lowerCAmelCase__		,				lowerCAmelCase__   )]

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

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

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

  # Function Call
  calc_profit(profit, weight, max_weight)




import functools
from typing import Any


def 	lowerCamelCase					(	UpperCamelCase     :				str			,       UpperCamelCase     :				list[str]							)   ->    bool:

		# Validation
		if not isinstance(UpperCamelCase			,       UpperCamelCase							) or len(UpperCamelCase							) == 0:
				raise ValueError('the string should be not empty string'							)

		if not isinstance(UpperCamelCase			,       UpperCamelCase							) or not all(
		    isinstance(UpperCamelCase			,       UpperCamelCase							) and len(UpperCamelCase							) > 0 for item in words							):
				raise ValueError('the words should be a list of non-empty strings'							)

		# Build trie
		_lowerCamelCase				   =  {}
		_lowerCamelCase				   =  'WORD_KEEPER'

		for word in words:
				_lowerCamelCase				   =  trie
				for c in word:
						if c not in trie_node:
								_lowerCamelCase				   =  {}

						_lowerCamelCase				   =  trie_node[c]

				_lowerCamelCase				   =  True

		_lowerCamelCase				   =  len(UpperCamelCase							)

		# Dynamic programming method
		@functools.cache
		def is_breakable(UpperCamelCase     :				int							) -> bool:
				if index == len_string:
						return True

				_lowerCamelCase				   =  trie
				for i in range(UpperCamelCase			,       UpperCamelCase							):
						_lowerCamelCase				   =  trie_node.get(string[i]			,       UpperCamelCase							)

						if trie_node is None:
								return False

						if trie_node.get(UpperCamelCase			,       UpperCamelCase							) and is_breakable(i + 1							):
								return True

				return False

		return is_breakable(0							)


if __name__ == "__main__":
				import doctest

				doctest.testmod()