



def    UpperCamelCase		(  _A					: List[str]					,				_A					: List[Any]					,				_A					: Dict							)->  int:





						"""simple docstring"""





						if len(_lowerCAmelCase							) != len(_lowerCAmelCase							):
												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(_lowerCAmelCase					,				_lowerCAmelCase							)]

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

						# declaring useful variables
						A__					=  len(_lowerCAmelCase							)
						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(_lowerCAmelCase							)
												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_				:     Optional[int]              =    [int(x) for x in input("Input profits separated by spaces: ").split()]
						UpperCAmelCase_				:     Optional[Any]              =    [int(x) for x in input("Input weights separated by spaces: ").split()]
						UpperCAmelCase_				:     str              =    int(input("Max weight allowed: "))

						# Function Call
						calc_profit(profit, weight, max_weight)










'''simple docstring'''





from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__a  			=						logging.get_logger(__name__)

__a  			=						{
    "shi-labs/dinat-mini-in1k-224": "https://huggingface.co/shi-labs/dinat-mini-in1k-224/resolve/main/config.json",
    # See all Dinat models at https://huggingface.co/models?filter=dinat
}







class        UpperCAmelCase_			(			_a						,						_a      ):
    """simple docstring"""







    lowercase   =						"dinat"

    lowercase   =						{
        "num_attention_heads": "num_heads",
        "num_hidden_layers": "num_layers",
    }




    def __init__(       self   :	Optional[int]					,	snake_case_   :	Optional[Any]=4					,	snake_case_   :	List[str]=3					,	snake_case_   :	Tuple=64					,	snake_case_   :	List[Any]=[3, 4, 6, 5]					,	snake_case_   :	List[Any]=[2, 4, 8, 16]					,	snake_case_   :	List[str]=7					,	snake_case_   :	List[str]=[[1, 8, 1], [1, 4, 1, 4], [1, 2, 1, 2, 1, 2], [1, 1, 1, 1, 1]]					,	snake_case_   :	List[Any]=3.0					,	snake_case_   :	Dict=True					,	snake_case_   :	int=0.0					,	snake_case_   :	Optional[int]=0.0					,	snake_case_   :	str=0.1					,	snake_case_   :	Optional[Any]="gelu"					,	snake_case_   :	Union[str, Any]=0.02					,	snake_case_   :	Optional[int]=1E-5					,	snake_case_   :	str=0.0					,	snake_case_   :	Dict=None					,	snake_case_   :	Dict=None					,	**snake_case_   :	Dict					,	):
          super().__init__(**snake_case_		)

          snake_case__    :       Optional[Any]       		= patch_size
          snake_case__    :       Union[str, Any]       		= num_channels
          snake_case__    :       int       		= embed_dim
          snake_case__    :       Dict       		= depths
          snake_case__    :       Dict       		= len(snake_case_		)
          snake_case__    :       Optional[int]       		= num_heads
          snake_case__    :       Any       		= kernel_size
          snake_case__    :       str       		= dilations
          snake_case__    :       Any       		= mlp_ratio
          snake_case__    :       int       		= qkv_bias
          snake_case__    :       int       		= hidden_dropout_prob
          snake_case__    :       int       		= attention_probs_dropout_prob
          snake_case__    :       Optional[Any]       		= drop_path_rate
          snake_case__    :       int       		= hidden_act
          snake_case__    :       Tuple       		= layer_norm_eps
          snake_case__    :       Any       		= initializer_range
          # we set the hidden_size attribute in order to make Dinat work with VisionEncoderDecoderModel
          # this indicates the channel dimension after the last stage of the model
          snake_case__    :       Optional[Any]       		= int(embed_dim * 2 ** (len(snake_case_		) - 1)		)
          snake_case__    :       int       		= layer_scale_init_value
          snake_case__    :       Dict       		= ["""stem"""] + [f"stage{idx}" for idx in range(1					,	len(snake_case_		) + 1		)]
          snake_case__		,							snake_case__    :       Tuple       		= get_aligned_output_features_output_indices(
              out_features=snake_case_					,	out_indices=snake_case_					,	stage_names=self.stage_names		)
