


"""simple docstring"""





def    _snake_case  (  _snake_case :	list       ,      _snake_case :	list       ,      _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    :		Union[str, Any]				=      [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    :		Any				=      sorted(_snake_case	)

      # declaring useful variables
      lowerCAmelCase    :		str				=      len(_snake_case	)
      lowerCAmelCase    :		Dict				=      0
      lowerCAmelCase    :		Optional[int]				=      0
      lowerCAmelCase    :		Tuple				=      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(_snake_case	)
            lowerCAmelCase    :		Optional[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.'''
 )

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

 # Function Call
 calc_profit(profit, weight, max_weight)



"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import _LazyModule


lowercase__					       =	{'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']}


if TYPE_CHECKING:
 from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM
else:
 import sys

 lowercase__					       =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


