from heapq import heappop, heappush

import numpy as np







def      _a					(   lowercase__	:      np.ndarray  ,	lowercase__	:      tuple[int, int]  ,	lowercase__	:      tuple[int, int]  ,	lowercase__	:      bool  ,	):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		grid.shape
     SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		[-1, 1, 0, 0]
     SCREAMING_SNAKE_CASE__					:					Tuple      =		[0, 0, -1, 1]
     if allow_diagonal:
          dx += [-1, -1, 1, 1]
          dy += [-1, 1, -1, 1]

     SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					List[Any]      =		[(0, source)], set()
     SCREAMING_SNAKE_CASE__					:					str      =		np.full((rows, cols)  ,	np.inf			)
     SCREAMING_SNAKE_CASE__					:					List[Any]      =		0
     SCREAMING_SNAKE_CASE__					:					Dict      =		np.empty((rows, cols)  ,	dtype=lowercase__			)
     SCREAMING_SNAKE_CASE__					:					List[Any]      =		None

     while queue:
          ((SCREAMING_SNAKE_CASE__)      ,				(SCREAMING_SNAKE_CASE__))					:					Optional[Any]      =		heappop(lowercase__			)
          if (x, y) in visited:
               continue
          visited.add((x, y)			)

          if (x, y) == destination:
               SCREAMING_SNAKE_CASE__					:					Any      =		[]
               while (x, y) != source:
                    path.append((x, y)			)
                    SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					Tuple      =		predecessors[x, y]
               path.append(lowercase__			)  # add the source manually
               path.reverse()
               return matrix[destination], path

          for i in range(len(lowercase__			)			):
               SCREAMING_SNAKE_CASE__      ,				SCREAMING_SNAKE_CASE__					:					Union[str, Any]      =		x + dx[i], y + dy[i]
               if 0 <= nx < rows and 0 <= ny < cols:
                    SCREAMING_SNAKE_CASE__					:					Optional[Any]      =		grid[nx][ny]
                    if next_node == 1 and matrix[nx, ny] > dist + 1:
                         heappush(lowercase__  ,	(dist + 1, (nx, ny))			)
                         SCREAMING_SNAKE_CASE__					:					List[str]      =		dist + 1
                         SCREAMING_SNAKE_CASE__					:					Any      =		(x, y)

     return np.inf, []


if __name__ == "__main__":
      import doctest

      doctest.testmod()





"""simple docstring"""






def       A_  (				__lowercase						,	__lowercase						,	__lowercase	):
 if len(__lowercase	) != len(__lowercase	):
  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.
 UpperCamelCase_     :					int   	=[p / w for p, w in zip(__lowercase						,	__lowercase	)]

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

 # declaring useful variables
 UpperCamelCase_     :					Optional[int]   	=len(__lowercase	)
 UpperCamelCase_     :					Optional[int]   	=0
 UpperCamelCase_     :					List[Any]   	=0
 UpperCamelCase_     :					Optional[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
  UpperCamelCase_     :					List[str]   	=sorted_profit_by_weight[length - i - 1]
  UpperCamelCase_     :					Optional[Any]   	=profit_by_weight.index(__lowercase	)
  UpperCamelCase_     :					str   	=-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)
