




'''simple docstring'''




def      a_							(      __snake_case							:			List[str]   ,       __snake_case							:			int   ,       __snake_case							:			Union[str, Any]   )							->						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_							=[p / w for p, w in zip(_lowerCAmelCase   ,       _lowerCAmelCase   )]

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

       # declaring useful variables
       lowerCamelCase_							=len(_lowerCAmelCase   )
       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(_lowerCAmelCase   )
              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."""
     )

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

     # Function Call
     calc_profit(profit, weight, max_weight)









def 	__UpperCamelCase	(  _lowerCAmelCase		)       ->  list:



    """simple docstring"""






    return [
        txt[:a] + txt[a].upper() + txt[a + 1 :]
        for a in range(len(_lowerCAmelCase		)		)
        if txt[a].isalpha()
    ]


if __name__ == "__main__":
     __import__("""doctest""").testmod()


