



"""simple docstring"""


__A      :							Any   =      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"







def        lowercase		(					_SCREAMING_SNAKE_CASE      :  Union[str, Any] ):






				'''simple docstring'''



				if not isinstance(__lowerCamelCase    ,   __lowerCamelCase ):
								_UpperCAmelCase							=			f'a bytes-like object is required, not \'{data.__class__.__name__}\''
								raise TypeError(__lowerCamelCase )

				_UpperCAmelCase							=			''''''.join(bin(__lowerCamelCase )[2:].zfill(8 ) for byte in data )

				_UpperCAmelCase							=			len(__lowerCamelCase ) % 6 != 0

				if padding_needed:
								# The padding that will be added later
								_UpperCAmelCase							=			B'''=''' * ((6 - len(__lowerCamelCase ) % 6) // 2)

								# Append binary_stream with arbitrary binary digits (0's by default) to make its
								# length a multiple of 6.
								binary_stream += "0" * (6 - len(__lowerCamelCase ) % 6)
				else:
								_UpperCAmelCase							=			B''''''

				# Encode every 6 binary digits to their corresponding Base64 character
				return (
				    "".join(
				        B64_CHARSET[int(binary_stream[index : index + 6]    ,   2 )]
				        for index in range(0    ,   len(__lowerCamelCase )    ,   6 ) ).encode()
				    + padding
				)







def        lowercase		(					_SCREAMING_SNAKE_CASE      :  List[str] ):






				'''simple docstring'''



				if not isinstance(__lowerCamelCase    ,   __lowerCamelCase ) and not isinstance(__lowerCamelCase    ,   __lowerCamelCase ):
								_UpperCAmelCase							=			(
								    '''argument should be a bytes-like object or ASCII string, '''
								    f'not \'{encoded_data.__class__.__name__}\''
								)
								raise TypeError(__lowerCamelCase )

				# In case encoded_data is a bytes-like object, make sure it contains only
				# ASCII characters so we convert it to a string object
				if isinstance(__lowerCamelCase    ,   __lowerCamelCase ):
								try:
												_UpperCAmelCase							=			encoded_data.decode('''utf-8''' )
								except UnicodeDecodeError:
												raise ValueError('''base64 encoded data should only contain ASCII characters''' )

				_UpperCAmelCase							=			encoded_data.count('''=''' )

				# Check if the encoded string contains non base64 characters
				if padding:
								assert all(
								    char in B64_CHARSET for char in encoded_data[:-padding] ), "Invalid base64 character(s) found."
				else:
								assert all(
								    char in B64_CHARSET for char in encoded_data ), "Invalid base64 character(s) found."

				# Check the padding
				assert len(__lowerCamelCase ) % 4 == 0 and padding < 3, "Incorrect padding"

				if padding:
								# Remove padding if there is one
								_UpperCAmelCase							=			encoded_data[:-padding]

								_UpperCAmelCase							=			''''''.join(
								    bin(B64_CHARSET.index(__lowerCamelCase ) )[2:].zfill(6 ) for char in encoded_data )[: -padding * 2]
				else:
								_UpperCAmelCase							=			''''''.join(
								    bin(B64_CHARSET.index(__lowerCamelCase ) )[2:].zfill(6 ) for char in encoded_data )

				_UpperCAmelCase							=			[
				    int(binary_stream[index : index + 8]    ,   2 )
				    for index in range(0    ,   len(__lowerCamelCase )    ,   8 )
				]

				return bytes(__lowerCamelCase )


if __name__ == "__main__":
					import doctest

					doctest.testmod()









from __future__ import annotations





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       float:
	a										=							sorted(numsa + numsa    )
	a				, a										=							divmod(len(__lowerCamelCase    )							,			2    )
	if mod == 1:
		return all_numbers[div]
	else:
		return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		__UpperCamelCase					:       Tuple    					=      [float(x) for x in input("Enter the elements of first array: ").split()]
		__UpperCamelCase					:       List[Any]    					=      [float(x) for x in input("Enter the elements of second array: ").split()]
		print(F'The median of two arrays is: {median_of_two_arrays(array_a, array_a)}')

