'''simple docstring'''

def 			__UpperCamelCase       (   UpperCAmelCase		,     UpperCAmelCase		,     UpperCAmelCase     ):
 if len(UpperCAmelCase     ) != len(UpperCAmelCase     ):
  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.
 lowercase__				:    str  =					[p / w for p, w in zip(UpperCAmelCase		,     UpperCAmelCase     )]

 # Creating a copy of the list and sorting profit/weight in ascending order
 lowercase__				:    Optional[int]  =					sorted(UpperCAmelCase     )

 # declaring useful variables
 lowercase__				:    Tuple  =					len(UpperCAmelCase     )
 lowercase__				:    int  =					0
 lowercase__				:    List[Any]  =					0
 lowercase__				:    int  =					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
  lowercase__				:    Optional[int]  =					sorted_profit_by_weight[length - i - 1]
  lowercase__				:    Optional[Any]  =					profit_by_weight.index(UpperCAmelCase     )
  lowercase__				:    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: List[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: List[Any]          =   int(input("""Max weight allowed: """))

  # Function Call
  calc_profit(profit, weight, max_weight)


'''simple docstring'''

import doctest
from collections import deque

import numpy as np



class 			UpperCAmelCase  :





       '''simple docstring'''



       def __init__(						self )  ->  None:
        lowercase__				:    str  =					[2, 1, 2, -1]
        lowercase__				:    str  =					[1, 2, 3, 4]


       def _lowerCAmelCase(						self )  ->  list[float]:
        lowercase__				:    Optional[Any]  =					len(self.first_signal )
        lowercase__				:    Union[str, Any]  =					len(self.second_signal )

        lowercase__				:    int  =					max(__lowerCAmelCase	,   __lowerCAmelCase )

        # create a zero matrix of max_length x max_length
        lowercase__				:    List[str]  =					[[0] * max_length for i in range(__lowerCAmelCase )]

        # fills the smaller signal with zeros to make both signals of same length
        if length_first_signal < length_second_signal:
         self.first_signal += [0] * (max_length - length_first_signal)
        elif length_first_signal > length_second_signal:
         self.second_signal += [0] * (max_length - length_second_signal)
        for i in range(__lowerCAmelCase ):
         lowercase__				:    int  =					deque(self.second_signal )
         rotated_signal.rotate(__lowerCAmelCase )
         for j, item in enumerate(__lowerCAmelCase ):
          matrix[i][j] += item

        # multiply the matrix with the first signal
        lowercase__				:    Optional[int]  =					np.matmul(np.transpose(__lowerCAmelCase )	,   np.transpose(self.first_signal ) )

        # rounding-off to two decimal places
        return [round(__lowerCAmelCase	,   2 ) for i in final_signal]


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

