





"""simple docstring"""



def 		__lowercase					(       snake_case_  :  list    ,snake_case_  :  list    ,snake_case_  :  int						)       ->int:



    '''simple docstring'''







    if len(snake_case_						) != len(snake_case_						):
        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   :						Optional[Any]									=					[p / w for p, w in zip(snake_case_    ,snake_case_						)]

    # Creating a copy of the list and sorting profit/weight in ascending order
    __A   :						Any									=					sorted(snake_case_						)

    # declaring useful variables
    __A   :						Tuple									=					len(snake_case_						)
    __A   :						Optional[int]									=					0
    __A   :						List[Any]									=					0
    __A   :						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
        __A   :						str									=					sorted_profit_by_weight[length - i - 1]
        __A   :						Union[str, Any]									=					profit_by_weight.index(snake_case_						)
        __A   :						int									=					-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_			=      [int(x) for x in input("""Input profits separated by spaces: """).split()]
       a_			=      [int(x) for x in input("""Input weights separated by spaces: """).split()]
       a_			=      int(input("""Max weight allowed: """))

       # Function Call
       calc_profit(profit, weight, max_weight)











"""simple docstring"""



def 		__lowercase					(       snake_case_  :  int						)       ->Optional[Any]:



    '''simple docstring'''







    stooge(snake_case_    ,0    ,len(snake_case_						) - 1						)
    return arr







def 		__lowercase					(       snake_case_  :  Optional[Any]    ,snake_case_  :  Union[str, Any]    ,snake_case_  :  Any						)       ->Tuple:



    '''simple docstring'''







    if i >= h:
        return

    # If first element is smaller than the last then swap them
    if arr[i] > arr[h]:
        __A			,	__A   :						Optional[int]									=					arr[h], arr[i]

    # If there are more than 2 elements in the array
    if h - i + 1 > 2:
        __A   :						Any									=					(int)((h - i + 1) / 3						)

        # Recursively sort first 2/3 elements
        stooge(snake_case_    ,snake_case_    ,(h - t)						)

        # Recursively sort last 2/3 elements
        stooge(snake_case_    ,i + t    ,(snake_case_)						)

        # Recursively sort first 2/3 elements
        stooge(snake_case_    ,snake_case_    ,(h - t)						)


if __name__ == "__main__":
       a_			=      input("""Enter numbers separated by a comma:\n""").strip()
       a_			=      [int(item) for item in user_input.split(""",""")]
       print(stooge_sort(unsorted))




