


def        UpperCamelCase_(				_A   :int  )->		Tuple:
			UpperCamelCase__					=       [int(UpperCamelCase__  ) for i in ip_va_address.split("."  ) if i.isdigit()]
			return len(UpperCamelCase__  ) == 4 and all(0 <= int(UpperCamelCase__  ) <= 2_54 for octet in octets  )


if __name__ == "__main__":
						__UpperCamelCase    		=       input().strip()
						__UpperCamelCase    		=       """valid""" if is_ip_va_address_valid(ip) else """invalid"""
						print(f'''{ip} is a {valid_or_invalid} IP v4 address.''')






def        UpperCamelCase_(				_A   :List[str]				,     _A   :Tuple				,     _A   :Any				,     _A   :Tuple				,     _A   :Optional[int]				,     _A   :str  )->		List[str]:
			if index == r:
						for j in range(_A  ):
									print(data[j]				,     end=" "  )
						print(" "  )
						return
			#  When no more elements are there to put in data[]
			if i >= n:
						return
			# current is included, put next at next location
			UpperCamelCase__					=       arr[i]
			combination_util(_A				,     _A				,     _A				,     index + 1				,     _A				,     i + 1  )
			# current is excluded, replace it with
			# next (Note that i+1 is passed, but
			# index is not changed)
			combination_util(_A				,     _A				,     _A				,     _A				,     _A				,     i + 1  )
			# The main function that prints all combinations
			# of size r in arr[] of size n. This function
			# mainly uses combinationUtil()
def        UpperCamelCase_(				_A   :Dict				,     _A   :Optional[Any]				,     _A   :Union[str, Any]  )->		Optional[int]:
			# A temporary array to store all combination one by one
			UpperCamelCase__					=       [0] * r
			# Print all combination using temporary array 'data[]'
			combination_util(_A				,     _A				,     _A				,     0				,     _A				,     0  )


if __name__ == "__main__":
						# Driver code to check the function above
						__UpperCamelCase    		=       [1_0, 2_0, 3_0, 4_0, 5_0]
						print_combination(arr, len(arr), 3)
						# This code is contributed by Ambuj sahu


