





'''simple docstring'''

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase__		:     Union[str, Any]			=							logging.get_logger(__name__)

lowercase__		:     Optional[Any]			=							{'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}
class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""
       _snake_case      :	Optional[int]									=       'ctrl'
       _snake_case      :	Union[str, Any]									=       ['past_key_values']
       _snake_case      :	Tuple									=       {
           'max_position_embeddings': 'n_positions',
           'hidden_size': 'n_embd',
           'num_attention_heads': 'n_head',
           'num_hidden_layers': 'n_layer',
       }





       def __init__(				self  :						Optional[Any]			,					lowerCAmelCase__  :						Tuple=246534			,					lowerCAmelCase__  :						List[Any]=256			,					lowerCAmelCase__  :						Union[str, Any]=1280			,					lowerCAmelCase__  :						str=8192			,					lowerCAmelCase__  :						Dict=48			,					lowerCAmelCase__  :						int=16			,					lowerCAmelCase__  :						Dict=0.1			,					lowerCAmelCase__  :						List[str]=0.1			,					lowerCAmelCase__  :						List[str]=1e-6			,					lowerCAmelCase__  :						List[str]=0.02			,					lowerCAmelCase__  :						int=True			,					**lowerCAmelCase__  :						Optional[int]			,					)       ->	List[Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			vocab_size
            _UpperCamelCase							       =			n_positions
            _UpperCamelCase							       =			n_embd
            _UpperCamelCase							       =			n_layer
            _UpperCamelCase							       =			n_head
            _UpperCamelCase							       =			dff
            _UpperCamelCase							       =			resid_pdrop
            _UpperCamelCase							       =			embd_pdrop
            _UpperCamelCase							       =			layer_norm_epsilon
            _UpperCamelCase							       =			initializer_range

            _UpperCamelCase							       =			use_cache

            super().__init__(**lowerCAmelCase__	)





"""simple docstring"""



def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case ):
    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.
    UpperCAmelCase__	:      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
    UpperCAmelCase__	:      Union[str, Any]     							=					sorted(_snake_case )

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

    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)

