

def       __UpperCamelCase     (lowerCAmelCase       :	Any,     lowerCAmelCase       :	str,     lowerCAmelCase       :	Union[str, Any]  )  ->	int:
      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.
      A 			=					[p / w for p, w in zip(lowercase__,     lowercase__  )]

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

      # declaring useful variables
      A 			=					len(lowercase__  )
      A 			=					0
      A 			=					0
      A 			=					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
            A 			=					sorted_profit_by_weight[length - i - 1]
            A 			=					profit_by_weight.index(lowercase__  )
            A 			=					-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."
  )

  _UpperCAmelCase     						=      [int(x) for x in input("Input profits separated by spaces: ").split()]
  _UpperCAmelCase     						=      [int(x) for x in input("Input weights separated by spaces: ").split()]
  _UpperCAmelCase     						=      int(input("Max weight allowed: "))

  # Function Call
  calc_profit(profit, weight, max_weight)






"""simple docstring"""

def       SCREAMING_SNAKE_CASE							( lowercase__					,					lowercase__   )			->						list:
 lowerCAmelCase__   :				List[str] 			=				len(lowercase__   )
 lowerCAmelCase__   :				Dict 			=				[]
 for i in range(len(lowercase__   ) - pat_len + 1   ):
  lowerCAmelCase__   :				Union[str, Any] 			=				True
  for j in range(lowercase__   ):
   if s[i + j] != pattern[j]:
    lowerCAmelCase__   :				int 			=				False
    break
  if match_found:
   position.append(lowercase__   )
 return position


if __name__ == "__main__":
    assert naive_pattern_search("""ABCDEFG""", """DE""") == [3]
    print(naive_pattern_search("""ABAAABCDBBABCDDEBCABC""", """ABC"""))






