
def 		UpperCamelCase     (       _UpperCAmelCase  :   list ,			_UpperCAmelCase  :   list ,			_UpperCAmelCase  :   int  )   ->			int:






						'''simple docstring'''

						if len(_UpperCAmelCase  ) != len(_UpperCAmelCase  ):
												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.
						_lowercase       :	List[str]           =   [p / w for p, w in zip(_UpperCAmelCase ,			_UpperCAmelCase  )]

						# Creating a copy of the list and sorting profit/weight in ascending order
						_lowercase       :	int           =   sorted(_UpperCAmelCase  )

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

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

							# Function Call
							calc_profit(profit, weight, max_weight)






def 		UpperCamelCase     (       _UpperCAmelCase  :   str  )   ->			bool:






						'''simple docstring'''

						_lowercase       :	List[str]           =   [int(_UpperCAmelCase  ) for i in ip_va_address.split("."  ) if i.isdigit()]
						return len(_UpperCAmelCase  ) == 4 and all(0 <= int(_UpperCAmelCase  ) <= 254 for octet in octets  )


if __name__ == "__main__":
							UpperCamelCase_						:     Dict	       =							input().strip()
							UpperCamelCase_						:     List[Any]	       =							"""valid""" if is_ip_va_address_valid(ip) else """invalid"""
							print(f'''{ip} is a {valid_or_invalid} IP v4 address.''')




