

from __future__ import annotations

from typing import Any
class  _A		(  UpperCAmelCase_):
      pass

class  _A		:

      def __init__(				self ,					_SCREAMING_SNAKE_CASE					):





            """simple docstring"""







            SCREAMING_SNAKE_CASE_				:  int           =     data
            SCREAMING_SNAKE_CASE_				:  Any           =     None

      def __iter__(				self					):





            """simple docstring"""







            SCREAMING_SNAKE_CASE_				:  int           =     self
            SCREAMING_SNAKE_CASE_				:  Dict           =     []
            while node:
                  if node in visited:
                        raise ContainsLoopError
                  visited.append(_lowercase					)
                  yield node.data
                  SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     node.next_node



      @property
      def  UpperCAmelCase    (				self					):





            """simple docstring"""







            try:
                  list(self					)
                  return False
            except ContainsLoopError:
                  return True


if __name__ == "__main__":
    lowerCAmelCase     :   List[str]						     =  Node(1)
    lowerCAmelCase     :   Optional[int]						     =  Node(2)
    lowerCAmelCase     :   Tuple						     =  Node(3)
    lowerCAmelCase     :   str						     =  Node(4)
    print(root_node.has_loop)  # False
    lowerCAmelCase     :   Dict						     =  root_node.next_node
    print(root_node.has_loop)  # True

    lowerCAmelCase     :   Optional[Any]						     =  Node(5)
    lowerCAmelCase     :   Union[str, Any]						     =  Node(6)
    lowerCAmelCase     :   Optional[int]						     =  Node(5)
    lowerCAmelCase     :   Tuple						     =  Node(6)
    print(root_node.has_loop)  # False

    lowerCAmelCase     :   List[Any]						     =  Node(1)
    print(root_node.has_loop)  # False









def    A_  (							a					,   a					,   a  ):

      """simple docstring"""



      if len(a  ) != len(a  ):
            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.
      SCREAMING_SNAKE_CASE_				:  Tuple           =     [p / w for p, w in zip(a					,   a  )]

      # Creating a copy of the list and sorting profit/weight in ascending order
      SCREAMING_SNAKE_CASE_				:  List[Any]           =     sorted(a  )

      # declaring useful variables
      SCREAMING_SNAKE_CASE_				:  List[Any]           =     len(a  )
      SCREAMING_SNAKE_CASE_				:  str           =     0
      SCREAMING_SNAKE_CASE_				:  List[str]           =     0
      SCREAMING_SNAKE_CASE_				:  Any           =     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
            SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     sorted_profit_by_weight[length - i - 1]
            SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     profit_by_weight.index(a  )
            SCREAMING_SNAKE_CASE_				:  Dict           =     -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.'
    )

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

    # Function Call
    calc_profit(profit, weight, max_weight)






