



lowercase_	       =			'''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'''






def 					__lowerCAmelCase		(  __lowerCamelCase	:    bytes	)  ->						bytes:
					# Make sure the supplied data is a bytes-like object
					if not isinstance(__lowerCamelCase				,   __lowerCamelCase	):
										__lowerCAmelCase	   =f"""a bytes-like object is required, not '{data.__class__.__name__}'"""
										raise TypeError(__lowerCamelCase	)

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

					__lowerCAmelCase	   =len(__lowerCamelCase	) % 6 != 0

					if padding_needed:
										# The padding that will be added later
										__lowerCAmelCase	   =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:
										__lowerCAmelCase	   =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 					__lowerCAmelCase		(  __lowerCamelCase	:    str	)  ->						bytes:
					# Make sure encoded_data is either a string or a bytes-like object
					if not isinstance(__lowerCamelCase				,   __lowerCamelCase	) and not isinstance(__lowerCamelCase				,   __lowerCamelCase	):
										__lowerCAmelCase	   =(
										    """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:
															__lowerCAmelCase	   =encoded_data.decode("""utf-8"""	)
										except UnicodeDecodeError:
															raise ValueError("""base64 encoded data should only contain ASCII characters"""	)

					__lowerCAmelCase	   =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
										__lowerCAmelCase	   =encoded_data[:-padding]

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

					__lowerCAmelCase	   =[
					    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()









def 					__lowerCAmelCase		(  __lowerCamelCase	:    list	)  ->						list:
					__lowerCAmelCase	   =False
					while is_sorted is False:  # Until all the indices are traversed keep looping
										__lowerCAmelCase	   =True
										for i in range(0				,   len(__lowerCamelCase	) - 1				,   2	):  # iterating over all even indices
															if input_list[i] > input_list[i + 1]:
																				__lowerCAmelCase   ,	__lowerCAmelCase	   =input_list[i + 1], input_list[i]
																				# swapping if elements not in order
																				__lowerCAmelCase	   =False

										for i in range(1				,   len(__lowerCamelCase	) - 1				,   2	):  # iterating over all odd indices
															if input_list[i] > input_list[i + 1]:
																				__lowerCAmelCase   ,	__lowerCAmelCase	   =input_list[i + 1], input_list[i]
																				# swapping if elements not in order
																				__lowerCAmelCase	   =False
					return input_list


if __name__ == "__main__":
				print('''Enter list to be sorted''')
				lowercase_	       =			[int(x) for x in input().split()]
				# inputing elements of the list in one line
				lowercase_	       =			odd_even_sort(input_list)
				print('''The sorted list is''')
				print(sorted_list)




